JosephFerano/opengl-playground
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Finish Shaders with exercises

Browse Source
This commit is contained in:
Joseph Ferano 2023-10-16 22:55:02 +07:00
parent 8345b696d9
commit 4f871d12bc
5 changed files with 159 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@ -1,7 +1,7 @@
P=opengl
OBJECTS=
OBJECTS=libs/glad/glad.o
CFLAGS=-g -Wall -Wextra -O0
LDLIBS=-lglfw -lOpenGL
LDLIBS=-lglfw -lOpenGL -lm
INCLUDES=-I./libs/glad/include/
CC=gcc
RM=rm -vf

114
lib.h Normal file
View File

@ -0,0 +1,114 @@
#pragma once
#include <string.h>
void checkCode(int code, char* errorMsg) {
if (code < 0) {
fprintf(stderr, "Application Error %i: %s\n", code, errorMsg);
exit(1);
}
}
void* checkPtr(void *ptr, char* errorMsg) {
if (ptr == NULL) {
fprintf(stderr, "Application Error: %s\n", errorMsg);
exit(1);
}
return ptr;
}
void checkShader(unsigned int shader, int statusFlag, char* actionName) {
int success;
glGetShaderiv(shader, statusFlag, &success);
if (success < 0) {
fprintf(stderr, "%s Error %i\n", actionName, success);
exit(1);
}
}
char* loadText(char* path) {
char* buffer = NULL;
long length;
FILE* f = fopen(path, "rb");
if (f) {
fseek(f, 0, SEEK_END);
length = ftell(f);
fseek(f, 0, SEEK_SET);
buffer = calloc(length, sizeof(char));
if (buffer) {
fread(buffer, 1, length, f);
}
fclose(f);
}
return buffer;
}
void checkCompileErrors(unsigned int object, char* type)
{
int success;
char infoLog[1024];
if (strcmp("PROGRAM", type))
{
glGetShaderiv(object, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(object, 1024, NULL, infoLog);
fprintf(stderr, "| ERROR::SHADER: Compile-time error: Type: %s \n %s\n", type, infoLog);
}
}
else
{
glGetProgramiv(object, GL_LINK_STATUS, &success);
if (!success)
{
glGetProgramInfoLog(object, 1024, NULL, infoLog);
fprintf(stderr, "| ERROR::Shader: Link-time error: Type: %s \n %s\n", type, infoLog);
}
}
}
unsigned int compileShaderProgram(char* vertSrcPath, char* fragSrcPath, char* geoSrcPath) {
unsigned int vertShader, fragShader, geoShader;
char* vertSrc = checkPtr(loadText(vertSrcPath), "Error loading source file");
vertShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertShader, 1, (const GLchar* const*)&vertSrc, NULL);
glCompileShader(vertShader);
checkCompileErrors(vertShader, "VERTEX");
char* fragSrc = checkPtr(loadText(fragSrcPath), "Error loading source file");
fragShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragShader, 1, (const GLchar* const*)&fragSrc, NULL);
glCompileShader(fragShader);
checkCompileErrors(fragShader, "FRAGMENT");
char* geoSrc = NULL;
if (geoSrcPath != NULL) {
geoSrc = checkPtr(loadText(geoSrcPath), "Error loading source file");
geoShader = glCreateShader(GL_GEOMETRY_SHADER);
glShaderSource(geoShader, 1, (const GLchar* const*)&geoSrc, NULL);
glCompileShader(geoShader);
checkCompileErrors(geoShader, "GEOMETRY");
}
unsigned int program = glCreateProgram();
glAttachShader(program, vertShader);
glAttachShader(program, fragShader);
if (geoSrcPath != NULL) {
glAttachShader(program, geoShader);
}
glLinkProgram(program);
checkCompileErrors(program, "PROGRAM");
glDeleteShader(vertShader);
glDeleteShader(fragShader);
free(vertSrc);
free(fragSrc);
if (geoSrc != NULL) {
free(geoSrc);
}
return program;
}

92
main.c
View File

@ -1,27 +1,14 @@
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>
#include "glad/glad.h"
#include <GLFW/glfw3.h>
#include "lib.h"
int SCREEN_WIDTH = 1024;
int SCREEN_HEIGHT = 768;
void checkCode(int code, char* errorMsg) {
if (code < 0) {
fprintf(stderr, "Application Error %i: %s\n", code, errorMsg);
exit(1);
}
}
void* checkPtr(void *ptr, char* errorMsg) {
if (ptr == NULL) {
fprintf(stderr, "Application Error: %s\n", errorMsg);
exit(1);
}
return ptr;
}
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
(void)window;
@ -36,46 +23,6 @@ void processInput(GLFWwindow *window)
glfwSetWindowShouldClose(window, true);
}
const char* vertSrc =
"#version 330 core\n"
"layout (location = 0) in vec3 aPos;\n"
"\n"
"void main()\n"
"{\n"
" gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
"}\n";
unsigned int compileVertShader() {
unsigned int vertexShader;
vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertSrc, NULL);
glCompileShader(vertexShader);
int success;
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
checkCode(success, "Failed to compile vertex shader");
return vertexShader;
}
const char* fragSrc =
"#version 330 core\n"
"out vec4 FragColor;\n"
"\n"
"void main()\n"
"{\n"
" FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
"}\n";
unsigned int compileFragShader() {
unsigned int fragmentShader;
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragSrc, NULL);
glCompileShader(fragmentShader);
int success;
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
checkCode(success, "Failed to compile fragment shader");
return fragmentShader;
}
int main(void) {
glfwInit();
@ -96,18 +43,8 @@ int main(void) {
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
unsigned int vertexShader = compileVertShader();
unsigned int fragmentShader = compileFragShader();
unsigned int shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);
int success = 0;
glGetShaderiv(shaderProgram, GL_LINK_STATUS, &success);
checkCode(success, "Failed to link shader program");
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
GLuint shaderProgram =
compileShaderProgram("shaders/main.vert", "shaders/main.frag", NULL);
// float vertices[] = {
// 0.5f, 0.5f, 0.0f, // top right
@ -127,9 +64,9 @@ int main(void) {
// };
float v1[] = {
-1.0f, -0.5f, 0.0f, // -0.5, -0.5
0.0f, -0.5f, 0.0f,// 0.5, -0.5
-0.5f, 0.5f, 0.0f// 0.0, 0.5
-1.0f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f,
};
float v2[] = {
@ -140,7 +77,8 @@ int main(void) {
GLuint vaos[2];
GLuint vbos[2];
unsigned int VBO1, VBO2, EBO;
unsigned int VBO1, VBO2;
// unsigned int EBO;
glGenVertexArrays(2, vaos);
// glGenBuffers(1, &EBO);
glGenBuffers(2, vbos);
@ -148,8 +86,10 @@ int main(void) {
glBindVertexArray(vaos[0]);
glBindBuffer(GL_ARRAY_BUFFER, vbos[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(v1), v1, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3*sizeof(float)));
glEnableVertexAttribArray(1);
glBindVertexArray(vaos[1]);
glBindBuffer(GL_ARRAY_BUFFER, vbos[1]);
@ -168,9 +108,17 @@ int main(void) {
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
float timeValue = glfwGetTime();
float green = (sin(timeValue) / 2.0f) + 0.5f;
glUseProgram(shaderProgram);
int ourColorLoc = glGetUniformLocation(shaderProgram, "ourColor");
glUniform4f(ourColorLoc, 0.0f, green, 0.0f, 1.0f);
int offsetLoc = glGetUniformLocation(shaderProgram, "offset");
glUniform1f(offsetLoc, 0.5f);
glBindVertexArray(vaos[0]);
glDrawArrays(GL_TRIANGLES, 0, 3);
glBindVertexArray(vaos[1]);
glDrawArrays(GL_TRIANGLES, 0, 3);
// glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);

11
shaders/main.frag Normal file
View File

@ -0,0 +1,11 @@
#version 330 core
in vec3 vertexPos;
in vec3 vertexColor;
out vec4 FragColor;
// uniform vec4 ourColor;
void main() {
FragColor = vec4(vertexPos, 1);
}

12
shaders/main.vert Normal file
View File

@ -0,0 +1,12 @@
#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aColor;
out vec3 vertexPos;
out vec3 vertexColor;
uniform float offset;
void main() {
gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);
vertexPos = vec3(abs(aPos.x), abs(aPos.y), abs(aPos.z));
}