Rakarake/glonkers
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

gles triangle

Browse source
This commit is contained in:
Rakarake 2025-12-13 01:56:09 +01:00
parent bd699f2183
commit 9cbcd7acca
3 changed files with 294 additions and 263 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Makefile
View file

@ -6,4 +6,4 @@ all:
$(CC) $(CFLAGS) $(LDFLAGS) -o glonkers main.c $(CC) $(CFLAGS) $(LDFLAGS) -o glonkers main.c
run: all run: all
./glonkers SDL_VIDEODRIVER="wayland,x11" ./glonkers

139
fragment.glsl
View file

@ -1,69 +1,76 @@
#version 330 core precision mediump float;
out vec4 FragColor;
uniform vec2 WindowSize;
uniform float time;
float rand(ivec2 co) {
return fract(sin(dot(co, vec2(12.9898, 78.233))) * 43758.5453);
}
float cell_size = 0.01;
#define PI 3.1415926538
// whatever that corner contributes
float c_dot(vec2 point, vec2 corner) {
ivec2 c = ivec2(round(corner * 100));
float angle = rand(c) * 2*PI;
vec2 random_corner_vec = vec2(cos(angle), sin(angle));
vec2 offset = (point - corner) / cell_size;
float dot_product = dot(random_corner_vec, offset);
// for now just return something
return dot_product;
}
float lerp(float a, float b, float x) {
return a + x*(b-a);
}
// better than built in smoothstep.
float fade(float t) {
return ((6*t - 15)*t + 10)*t*t*t;
}
void main() { void main() {
// We'll make origin in the top-left. gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
vec2 uv = gl_FragCoord.xy / WindowSize;
uv.y = 1.0 - uv.y;
vec2 grid_edge_offset = mod(uv, cell_size);
// c: corner
vec2 c_tl = uv - grid_edge_offset;
vec2 c_tr = uv - grid_edge_offset + vec2(cell_size, 0);
vec2 c_bl = uv - grid_edge_offset + vec2(0, cell_size);
vec2 c_br = uv - grid_edge_offset + vec2(cell_size, cell_size);
float c_tl_dot = c_dot(uv, c_tl);
float c_tr_dot = c_dot(uv, c_tr);
float c_bl_dot = c_dot(uv, c_bl);
float c_br_dot = c_dot(uv, c_br);
// the uv within the tile (0 to 1)
vec2 tile_uv = (uv - c_tl) / cell_size;
// lerp index
float u = fade(tile_uv.x);
float v = fade(tile_uv.y);
//float u = tile_uv.x;
//float v = tile_uv.y;
//float u = smoothstep(0, 1, tile_uv.x);
//float v = smoothstep(0, 1, tile_uv.y);
//float val = smoothstep(tile_uv.x, smoothstep(tile_uv.y, c_bl_dot, c_tl_dot), smoothstep(tile_uv.y, c_br_dot, c_tr_dot));
float val = lerp(lerp(c_tl_dot, c_bl_dot, v), lerp(c_tr_dot, c_br_dot, v), u);
//float val = tile_uv.y;
//float val = c_bl_dot*2 + 0.5;
//val = val * 20;
float out_val = val /2 + 0.5;
FragColor = vec4(out_val, out_val, out_val, 1);
//float yes = 0.5 + (c_dot(uv, c_tl) + c_dot(uv, c_tr) + c_dot(uv, c_bl) + c_dot(uv, c_br)) / 2;
//FragColor = vec4(yes, yes, yes, 1);
} }
//#version 330 core
//out vec4 FragColor;
//uniform vec2 WindowSize;
//uniform float time;
//
//float rand(ivec2 co) {
// return fract(sin(dot(co, vec2(12.9898, 78.233))) * 43758.5453);
//}
//
//float cell_size = 0.01;
//
//#define PI 3.1415926538
//
//// whatever that corner contributes
//float c_dot(vec2 point, vec2 corner) {
// ivec2 c = ivec2(round(corner * 100));
// float angle = rand(c) * 2*PI;
// vec2 random_corner_vec = vec2(cos(angle), sin(angle));
// vec2 offset = (point - corner) / cell_size;
// float dot_product = dot(random_corner_vec, offset);
// // for now just return something
// return dot_product;
//}
//
//float lerp(float a, float b, float x) {
// return a + x*(b-a);
//}
//
//// better than built in smoothstep.
//float fade(float t) {
// return ((6*t - 15)*t + 10)*t*t*t;
//}
//
//void main() {
// // We'll make origin in the top-left.
// vec2 uv = gl_FragCoord.xy / WindowSize;
// uv.y = 1.0 - uv.y;
// vec2 grid_edge_offset = mod(uv, cell_size);
// // c: corner
// vec2 c_tl = uv - grid_edge_offset;
// vec2 c_tr = uv - grid_edge_offset + vec2(cell_size, 0);
// vec2 c_bl = uv - grid_edge_offset + vec2(0, cell_size);
// vec2 c_br = uv - grid_edge_offset + vec2(cell_size, cell_size);
// float c_tl_dot = c_dot(uv, c_tl);
// float c_tr_dot = c_dot(uv, c_tr);
// float c_bl_dot = c_dot(uv, c_bl);
// float c_br_dot = c_dot(uv, c_br);
//
// // the uv within the tile (0 to 1)
// vec2 tile_uv = (uv - c_tl) / cell_size;
//
// // lerp index
// float u = fade(tile_uv.x);
// float v = fade(tile_uv.y);
// //float u = tile_uv.x;
// //float v = tile_uv.y;
// //float u = smoothstep(0, 1, tile_uv.x);
// //float v = smoothstep(0, 1, tile_uv.y);
// //float val = smoothstep(tile_uv.x, smoothstep(tile_uv.y, c_bl_dot, c_tl_dot), smoothstep(tile_uv.y, c_br_dot, c_tr_dot));
// float val = lerp(lerp(c_tl_dot, c_bl_dot, v), lerp(c_tr_dot, c_br_dot, v), u);
// //float val = tile_uv.y;
// //float val = c_bl_dot*2 + 0.5;
// //val = val * 20;
// float out_val = val /2 + 0.5;
// FragColor = vec4(out_val, out_val, out_val, 1);
//
// //float yes = 0.5 + (c_dot(uv, c_tl) + c_dot(uv, c_tr) + c_dot(uv, c_bl) + c_dot(uv, c_br)) / 2;
// //FragColor = vec4(yes, yes, yes, 1);
//}

410
main.c
View file

@ -5,10 +5,11 @@
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
#include <EGL/egl.h>
#include <GL/gl.h> #include <GL/gl.h>
#include <wayland-client.h> #include <wayland-client.h>
#include <wayland-util.h> #include <wayland-util.h>
//#include <SDL3/SDL.h> #include <SDL3/SDL.h>
//int main() { //int main() {
// struct wl_display *display = wl_display_connect(NULL); // struct wl_display *display = wl_display_connect(NULL);
@ -23,208 +24,231 @@
// //
// wl_display_disconnect(display); // wl_display_disconnect(display);
//} //}
struct our_state { //struct our_state {
// ... // // ...
struct wl_compositor *compositor; // struct wl_compositor *compositor;
// ... // // ...
}; //};
//
//static void
//registry_handle_global(void *data, struct wl_registry *registry,
// uint32_t name, const char *interface, uint32_t version)
//{
// printf("interface: '%s', version: %d, name: %d\n",
// interface, version, name);
//
// struct our_state *state = data;
//
// if (strcmp(interface, wl_compositor_interface.name) == 0) {
// state->compositor = wl_registry_bind(
// registry, name, &wl_compositor_interface, 4);
// }
//}
//
//static void
//registry_handle_global_remove(void *data, struct wl_registry *registry,
// uint32_t name)
//{
// // This space deliberately left blank
//}
//
//static const struct wl_registry_listener
//registry_listener = {
// .global = registry_handle_global,
// .global_remove = registry_handle_global_remove,
//};
//
//int
//main(int argc, char *argv[])
//{
// struct our_state state = { 0 };
// struct wl_display *display = wl_display_connect(NULL);
// struct wl_registry *registry = wl_display_get_registry(display);
// wl_registry_add_listener(registry, &registry_listener, &state);
// wl_display_roundtrip(display);
// return 0;
//}
static void void checkGlError() {
registry_handle_global(void *data, struct wl_registry *registry, const char *err = SDL_GetError();
uint32_t name, const char *interface, uint32_t version) if (*err != 0) {
{ printf("OpenGL error: %s", err);
printf("interface: '%s', version: %d, name: %d\n",
interface, version, name);
struct our_state *state = data;
if (strcmp(interface, wl_compositor_interface.name) == 0) {
state->compositor = wl_registry_bind(
registry, name, &wl_compositor_interface, 4);
} }
} }
static void /// returns 0 if failed.
registry_handle_global_remove(void *data, struct wl_registry *registry, GLuint compile_shader(GLuint type, const char *src) {
uint32_t name) GLuint id = glCreateShader(type);
{ glShaderSource(id, 1, &src, 0);
// This space deliberately left blank glCompileShader(id);
}
static const struct wl_registry_listener int result;
registry_listener = { glGetShaderiv(id, GL_COMPILE_STATUS, &result);
.global = registry_handle_global, if (result == GL_FALSE) {
.global_remove = registry_handle_global_remove, int length;
}; glGetShaderiv(id, GL_INFO_LOG_LENGTH, &result);
char *message = alloca(length * sizeof(char));
int glGetShaderInfoLog(id, length, &length, message);
main(int argc, char *argv[]) printf("failed to compile %s shader\n", type == GL_VERTEX_SHADER ? "vertex" : "fragment");
{ printf("%s\n", message);
struct our_state state = { 0 }; glDeleteShader(id);
struct wl_display *display = wl_display_connect(NULL);
struct wl_registry *registry = wl_display_get_registry(display);
wl_registry_add_listener(registry, &registry_listener, &state);
wl_display_roundtrip(display);
return 0; return 0;
} }
//void checkGlError() { return id;
// const char *err = SDL_GetError(); }
// if (*err != 0) {
// printf("OpenGL error: %s", err); const char *vertex_shader_src =
// } "attribute vec4 vPosition; \n"
//} "void main() \n"
// "{ \n"
///// returns 0 if failed. " gl_Position = vPosition; \n"
//GLuint compile_shader(GLuint type, const char *src) { "} \n";
// GLuint id = glCreateShader(type);
// glShaderSource(id, 1, &src, 0); /// returns 0 if failed.
// glCompileShader(id); GLuint create_shader(const char *fragment_src) {
// GLuint program = glCreateProgram();
// int result; GLuint vertex_shader = compile_shader(GL_VERTEX_SHADER, vertex_shader_src);
// glGetShaderiv(id, GL_COMPILE_STATUS, &result); GLuint fragment_shader = compile_shader(GL_FRAGMENT_SHADER, fragment_src);
// if (result == GL_FALSE) { if (!((fragment_shader == 0) || (vertex_shader == 0))) {
// int length; glAttachShader(program, vertex_shader);
// glGetShaderiv(id, GL_INFO_LOG_LENGTH, &result); glAttachShader(program, fragment_shader);
// char *message = alloca(length * sizeof(char)); glLinkProgram(program);
// glGetShaderInfoLog(id, length, &length, message); glValidateProgram(program);
// printf("failed to compile %s shader\n", type == GL_VERTEX_SHADER ? "vertex" : "fragment"); glDeleteShader(vertex_shader);
// printf("%s\n", message); glDeleteShader(fragment_shader);
// glDeleteShader(id); return program;
// return 0; } else {
// } return 0;
// }
// return id; }
//}
// GLuint load_shader(const char *path) {
///// returns 0 if failed. FILE *handle = fopen(path, "r");
//GLuint create_shader(const char *fragment_src) { fseek(handle, 0L, SEEK_END);
// GLuint program = glCreateProgram(); long length = ftell(handle);
// GLuint fragment_shader = compile_shader(GL_FRAGMENT_SHADER, fragment_src); fseek(handle, 0L, SEEK_SET);
// if (!(fragment_shader == 0)) { char *string = malloc(length * sizeof(char));
// glAttachShader(program, fragment_shader); if (!fread(string, sizeof(char), length, handle)) {
// glLinkProgram(program); printf("failed to read shader file");
// glValidateProgram(program); exit(1);
// glDeleteShader(fragment_shader); }
// return program; fclose(handle);
// } else {
// return 0; GLuint shader = create_shader(string);
// }
//} if (shader == 0) {
// // print file
//GLuint load_shader(const char *path) { int line_count = 1;
// FILE *handle = fopen(path, "r"); printf("%i\t", line_count);
// fseek(handle, 0L, SEEK_END); line_count++;
// long length = ftell(handle); for (int i = 0; i < length; i++) {
// fseek(handle, 0L, SEEK_SET); printf("%c", string[i]);
// char *string = malloc(length * sizeof(char)); if (string[i] == '\n') {
// if (!fread(string, sizeof(char), length, handle)) { printf("%i\t", line_count);
// printf("failed to read shader file"); line_count++;
// exit(1); }
// } }
// fclose(handle); printf("\n");
// }
// GLuint shader = create_shader(string);
// free(string);
// if (shader == 0) { return shader;
// // print file }
// int line_count = 1;
// printf("%i\t", line_count); struct timespec program_start;
// line_count++;
// for (int i = 0; i < length; i++) { void init_timer() {
// printf("%c", string[i]); clock_gettime(CLOCK_MONOTONIC, &program_start);
// if (string[i] == '\n') { }
// printf("%i\t", line_count);
// line_count++; double time_since_start() {
// } struct timespec now;
// } clock_gettime(CLOCK_MONOTONIC, &now);
// printf("\n");
// } return (now.tv_sec - program_start.tv_sec) +
// (now.tv_nsec - program_start.tv_nsec) / 1e9;
// free(string); }
// return shader;
//} int main() {
// init_timer();
//struct timespec program_start;
// printf("Good Morning 🍵\n");
//void init_timer() { SDL_Init(SDL_INIT_VIDEO);
// clock_gettime(CLOCK_MONOTONIC, &program_start); SDL_SetHint(SDL_HINT_OPENGL_ES_DRIVER, "1");
//} SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,
// SDL_GL_CONTEXT_PROFILE_ES);
//double time_since_start() { SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
// struct timespec now; SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
// clock_gettime(CLOCK_MONOTONIC, &now); SDL_Window* window = SDL_CreateWindow("SDL3 OpenGL Cube",
// 800, 600, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
// return (now.tv_sec - program_start.tv_sec) + if (!window) {
// (now.tv_nsec - program_start.tv_nsec) / 1e9; printf("CreateWindow Error: %s\n", SDL_GetError());
//} SDL_Quit();
// return 1;
//int main() { }
// init_timer();
// SDL_GLContext glContext = SDL_GL_CreateContext(window);
// printf("Good Morning 🍵\n"); const char *version = (const char *)glGetString(GL_VERSION);
// SDL_Init(SDL_INIT_VIDEO); const char *renderer = (const char *)glGetString(GL_RENDERER);
// SDL_Window* window = SDL_CreateWindow("SDL3 OpenGL Cube",
// 800, 600, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE); SDL_Log("GL_VERSION: %s", version);
// if (!window) { SDL_Log("GL_RENDERER: %s", renderer);
// printf("CreateWindow Error: %s\n", SDL_GetError());
// SDL_Quit(); if (!glContext) {
// return 1; printf("GL Context Error: %s\n", SDL_GetError());
// } SDL_DestroyWindow(window);
// SDL_Quit();
// SDL_GLContext glContext = SDL_GL_CreateContext(window); return 1;
// if (!glContext) { }
// printf("GL Context Error: %s\n", SDL_GetError()); glEnable(GL_DEPTH_TEST);
// SDL_DestroyWindow(window);
// SDL_Quit(); SDL_Event e;
// return 1; int running = 1;
// }
// glEnable(GL_DEPTH_TEST); GLuint shader = load_shader("fragment.glsl"); //create_shader(fragment_shader_source);
//
// SDL_Event e; int w, h;
// int running = 1; double time;
// while (running) {
// GLuint shader = load_shader("fragment.glsl"); //create_shader(fragment_shader_source); while (SDL_PollEvent(&e)) {
// if (e.type == SDL_EVENT_QUIT) running = false;
// int w, h; if (e.type == SDL_EVENT_WINDOW_RESIZED) {
// double time; SDL_GetWindowSize(window, &w, &h);
// while (running) { }
// while (SDL_PollEvent(&e)) { }
// if (e.type == SDL_EVENT_QUIT) running = false; checkGlError();
// if (e.type == SDL_EVENT_WINDOW_RESIZED) {
// SDL_GetWindowSize(window, &w, &h); // Rendorrrr
// } glViewport(0, 0, w, h);
// }
// checkGlError(); glClearColor(0.1f, 0.1f, 0.1f, 1.0f); // Dark gray background
// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// // Rendorrrr
// glViewport(0, 0, w, h); // Shader parameters.
// glUseProgram(shader);
// glClearColor(0.1f, 0.1f, 0.1f, 1.0f); // Dark gray background
// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//
// // Shader parameters.
// glUseProgram(shader);
//
//int uniform_WindowSize = glGetUniformLocation(shader, "WindowSize"); //int uniform_WindowSize = glGetUniformLocation(shader, "WindowSize");
//glUniform2f(uniform_WindowSize, w, h); //glUniform2f(uniform_WindowSize, w, h);
//
//time = time_since_start(); //time = time_since_start();
//int uniform_time = glGetUniformLocation(shader, "time"); //int uniform_time = glGetUniformLocation(shader, "time");
//glUniform1f(uniform_time, (float)time); //glUniform1f(uniform_time, (float)time);
//
// // Draw quad. // Load the vertex data
// glBegin(GL_QUADS); GLfloat vVertices[] = {
// glVertex2f(-1, 1); 0.0f, 0.5f, 0.0f,
// glVertex2f(-1,-1); -0.5f, -0.5f, 0.0f,
// glVertex2f( 1,-1); 0.5f, -0.5f, 0.0f
// glVertex2f( 1, 1); };
// glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices);
// glEnd(); glEnableVertexAttribArray(0);
// glDrawArrays(GL_TRIANGLES, 0, 3);
// SDL_GL_SwapWindow(window);
// } SDL_GL_SwapWindow(window);
// checkGlError();
// checkGlError(); }
//}
// checkGlError();
}