Nigel/Pacman-Clone
1
0
Fork 0
Code Issues Pull Requests Actions Packages repo.project_board Releases Wiki Activity

Fix shader errs

Browse Source
This commit is contained in:
Nigel Barink
2026-01-14 14:00:09 +01:00
parent 85df7154a7
commit 81096a9b5f
5 changed files with 84 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored
View File

@@ -1,3 +1,3 @@
!build/shader.v !build/vertex.glsl
!build/shader.f !build/fragment.glsl
build/ build/

9
build/fragment.glsl Normal file
View File

@@ -0,0 +1,9 @@
#version 460 core
out vec4 fragcolor;
void main(){
fragcolor = vec4(1.0, 0.5, 0.2, 1.0);
}

6
build/shader.f
View File

@@ -1,6 +0,0 @@
#version 460 core
out vec4 FragColor;
void main(){
FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);
}

8
build/shader.v → build/vertex.glsl
View File

@@ -1,7 +1,7 @@
#version 460 core #version 460 core
layout (location = 0) in vec3 aPos; layout (location = 0) in vec3 aPos;
void main(){ void main(){
gl_Position = vec4(aPos, 1.0);
gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0); };
}

143
src/main.c
View File

@@ -5,96 +5,93 @@
#include <glad/glad.h> #include <glad/glad.h>
#include <stdio.h> #include <stdio.h>
void keyfunc (RGFW_window* win, RGFW_key key, u8 keychar, RGFW_keymod keymod, RGFW_bool repeat, RGFW_bool pressed){ void keyfunc(RGFW_window *win, RGFW_key key, u8 keychar, RGFW_keymod keymod,
RGFW_bool repeat, RGFW_bool pressed) {
RGFW_UNUSED(repeat); RGFW_UNUSED(repeat);
if (key == RGFW_escape && pressed){ if (key == RGFW_escape && pressed) {
RGFW_window_setShouldClose(win, 1); RGFW_window_setShouldClose(win, 1);
} }
} }
RGFW_window* SetupWindow(){ RGFW_window *SetupWindow() {
RGFW_glHints* hints = RGFW_getGlobalHints_OpenGL(); RGFW_glHints *hints = RGFW_getGlobalHints_OpenGL();
hints->major = 4; hints->major = 4;
hints->minor = 6; hints->minor = 6;
RGFW_setGlobalHints_OpenGL(hints); RGFW_setGlobalHints_OpenGL(hints);
RGFW_window* win = RGFW_createWindow("PACMAN CLONE", 0,0, 800, 600, RGFW_windowCenter | RGFW_windowNoResize | RGFW_windowOpenGL | RGFW_windowHide); RGFW_window *win = RGFW_createWindow("PACMAN CLONE", 0, 0, 800, 600,
RGFW_window_createContext_OpenGL(win, hints); RGFW_windowCenter | RGFW_windowNoResize |
RGFW_window_show(win); RGFW_windowOpenGL | RGFW_windowHide);
RGFW_window_createContext_OpenGL(win, hints);
RGFW_setKeyCallback(keyfunc); RGFW_window_show(win);
RGFW_window_makeCurrentContext_OpenGL(win);
// Initialize GLAD RGFW_setKeyCallback(keyfunc);
if(!gladLoadGLLoader((GLADloadproc)RGFW_getProcAddress_OpenGL)){ RGFW_window_makeCurrentContext_OpenGL(win);
printf("Failed to load GLAD!" );
return NULL; // Initialize GLAD
} if (!gladLoadGLLoader((GLADloadproc)RGFW_getProcAddress_OpenGL)) {
return win; printf("Failed to load GLAD!");
return NULL;
}
return win;
} }
long stat_GetSize(FILE* file ) { long stat_GetSize(FILE *file) {
fseek(file, 0, SEEK_END); fseek(file, 0, SEEK_END);
long size = ftell(file); long size = ftell(file);
fseek(file, 0, SEEK_SET); // Reset to the beginning fseek(file, 0, SEEK_SET); // Reset to the beginning
return size; return size;
} }
char* LoadFile(const char* Path) char *LoadFile(const char *Path) {
{ FILE *fptr;
FILE* fptr;
fptr = fopen(Path, "r"); fptr = fopen(Path, "r");
if( !fptr ){ if (!fptr) {
printf("Failed to open file" ) ; printf("Failed to open file");
return NULL; return NULL;
} }
long size = stat_GetSize(fptr); long size = stat_GetSize(fptr);
char* text = malloc(sizeof(char) * size); char *text = malloc(sizeof(char) * (size + 1));
fread(text , size , 1, fptr); memset(text, 0x00, sizeof(char)*(size + 1));
fread(text, size + 1, 1, fptr);
fclose(fptr); fclose(fptr);
return text; return text;
} }
uint CompileShader(const char *FilePath, GLenum ShaderType) {
uint CompileShader (const char* FilePath , GLenum ShaderType ) { char *shdr_text = LoadFile(FilePath);
char* shdr_text = LoadFile(FilePath); printf("%s\n" , shdr_text);
uint shader = glCreateShader(ShaderType); uint shader = glCreateShader(ShaderType);
glShaderSource(shader, 1, (const char**)&shdr_text, NULL); glShaderSource(shader, 1, (const char **)&shdr_text, NULL);
glCompileShader(shader); glCompileShader(shader);
int status; int status;
char info[512]; char info[512];
glGetShaderiv(shader, GL_COMPILE_STATUS, &status); glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
if(!status){ if (!status) {
glGetShaderInfoLog(shader,512, NULL, info); glGetShaderInfoLog(shader, 512, NULL, info);
const char* typename = ShaderType == GL_VERTEX_SHADER ? "VERTEX" : "FRAGMENT"; const char *typename =
ShaderType == GL_VERTEX_SHADER ? "VERTEX" : "FRAGMENT";
printf("ERROR::SHADER::%s::COMPILATION %s\n", typename, info); printf("ERROR::SHADER::%s::COMPILATION %s\n", typename, info);
} }
free(shdr_text); free(shdr_text);
return shader; return shader;
} }
float vertices[] = { float vertices[] = {
0.5f, 0.5f, 0.0f, 0.5f, 0.5f, 0.0f, 0.5f, -0.5f, 0.0f, -0.5f, -0.5f, 0.0f, -0.5f, 0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
-0.5f, -0.5f, 0.0f,
-0.5f, 0.5f, 0.0f,
}; };
uint indices[] = { uint indices[] = {0, 1, 3, 1, 2, 3};
0,1,3,
1,2,3
};
struct { struct {
unsigned int shaderProgram; unsigned int shaderProgram;
unsigned int VAO; unsigned int VAO;
unsigned int EBO; unsigned int EBO;
unsigned int VBO; unsigned int VBO;
} RenderVariables; } RenderVariables;
void Setup(){ void Setup() {
// Load Vertex Shader // Load Vertex Shader
uint vert_shader = CompileShader("shader.v", GL_VERTEX_SHADER); uint vert_shader = CompileShader("vertex.glsl", GL_VERTEX_SHADER);
// Load Fragment Shader // Load Fragment Shader
uint frag_shader = CompileShader("shader.f", GL_FRAGMENT_SHADER); uint frag_shader = CompileShader("fragment.glsl", GL_FRAGMENT_SHADER);
RenderVariables.shaderProgram = glCreateProgram(); RenderVariables.shaderProgram = glCreateProgram();
glAttachShader(RenderVariables.shaderProgram, vert_shader); glAttachShader(RenderVariables.shaderProgram, vert_shader);
@@ -103,52 +100,50 @@ void Setup(){
glLinkProgram(RenderVariables.shaderProgram); glLinkProgram(RenderVariables.shaderProgram);
int success; int success;
glGetProgramiv(RenderVariables.shaderProgram, GL_LINK_STATUS, &success); glGetProgramiv(RenderVariables.shaderProgram, GL_LINK_STATUS, &success);
if(!success){ if (!success) {
char log[512]; char log[512];
glGetProgramInfoLog(RenderVariables.shaderProgram, 512, NULL, log); glGetProgramInfoLog(RenderVariables.shaderProgram, 512, NULL, log);
printf("LINK ERROR SHADERPROGRAM", log); printf("LINK ERROR SHADERPROGRAM", log);
} }
glDeleteShader(vert_shader); glDeleteShader(vert_shader);
glDeleteShader(frag_shader); glDeleteShader(frag_shader);
glGenVertexArrays(1,&RenderVariables.VAO); glGenVertexArrays(1, &RenderVariables.VAO);
glGenBuffers(1,&RenderVariables.VBO); glGenBuffers(1, &RenderVariables.VBO);
glGenBuffers(1,&RenderVariables.EBO); glGenBuffers(1, &RenderVariables.EBO);
glBindVertexArray(RenderVariables.VAO); glBindVertexArray(RenderVariables.VAO);
glBindBuffer(GL_ARRAY_BUFFER, RenderVariables.EBO); glBindBuffer(GL_ARRAY_BUFFER, RenderVariables.VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, RenderVariables.EBO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, RenderVariables.EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices,
GL_STATIC_DRAW);
glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE, 3* sizeof(float), (void*)0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
glEnableVertexAttribArray(0); glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0 ); glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0); glBindVertexArray(0);
} }
int main (int argc, char **argv){ int main(int argc, char **argv) {
RGFW_window* win = SetupWindow(); RGFW_window *win = SetupWindow();
Setup(); Setup();
while ( RGFW_window_shouldClose(win) == RGFW_FALSE){ while (RGFW_window_shouldClose(win) == RGFW_FALSE) {
RGFW_event event; RGFW_event event;
RGFW_pollEvents(); RGFW_pollEvents();
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glUseProgram(RenderVariables.shaderProgram); glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glBindVertexArray(RenderVariables.VAO); glClear(GL_COLOR_BUFFER_BIT);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
RGFW_window_swapBuffers_OpenGL(win);
glUseProgram(RenderVariables.shaderProgram);
glBindVertexArray(RenderVariables.VAO);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
RGFW_window_swapBuffers_OpenGL(win);
}
RGFW_window_close(win);
} return 0;
RGFW_window_close(win);
return 0;
} }