shaders

shaders/frag.glsl

@@ -1,13 +1,13 @@
 #version 330 core
 
-uniform vec3 color1;
-uniform vec3 color2;
+//uniform vec3 color1;
+//uniform vec3 color2;
 
 void main() {
 
-    vec2 st = gl_PointCoord;
-    float mixval = distance(st, vec2(0, 1));
+    //vec2 st = gl_PointCoord;
+    //float mixval = distance(st, vec2(0, 1));
  
-    vec3 color = mix(color1, color2, mixval);
-    gl_FragColor = vec4(color, 0.5);
+    //vec3 color = mix(color1, color2, mixval);
+    gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
 }

shaders/tringle.glsl

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

src/controller.c

@@ -16,6 +16,7 @@ void ctrl_start(ctrl_binder *cb) {
         if (cb->rec_sl != NULL) {
             cb->live_sl->list[cb->current_segment]->realtime = ghtimer_time(cb->timer_rta);
             cb->current_segment++;
+            cb->sr->current = cb->current_segment;
         } else {
             ghtimer_stop(cb->timer_rta); //stop or reset, save splits
         }
@@ -26,8 +27,18 @@ void ctrl_start(ctrl_binder *cb) {
             return;
         }
     } else {
-        ghtimer_start(cb->timer_rta);    
+        ghtimer_start(cb->timer_rta);
+        cb->sr->running = true;
     }
+
+    //cb->sr->current = cb->current_segment;
+}
+
+void ctrl_bind_timer_renderer(ctrl_binder *cb, timer_renderer *timer) {
+    cb->tr = timer;
+}
+void ctrl_bind_segment_renderer(ctrl_binder *cb, segment_renderer *segmer) {
+    cb->sr = segmer;
 }
 
 ctrl_binder *create_ctrl_binder(GHTimer *rta, segment_list *sl) {

src/controller.h

@@ -3,6 +3,8 @@
 
 #include "timer.h"
 #include "splits.h"
+#include "segment_renderer.h"
+#include "timer_renderer.h"
 #include <stdlib.h>
 //controller binds the timer to the splits
 //and to the input handler
@@ -11,10 +13,14 @@
 typedef struct ctrl_binder {
     GHTimer *timer_rta, *timer_igt;
     segment_list *rec_sl, *live_sl;
+    timer_renderer *tr;
+    segment_renderer *sr;
     int current_segment;
 } ctrl_binder;
 
 ctrl_binder *create_ctrl_binder(GHTimer *rta, segment_list *sl);
+void ctrl_bind_timer_renderer(ctrl_binder *cb, timer_renderer *timer);
+void ctrl_bind_segment_renderer(ctrl_binder *cb, segment_renderer *segmer);
 void ctrl_start(ctrl_binder *cb);
 void ctrl_pause(GHTimer *timer);
 #endif

src/main.c

@@ -13,13 +13,10 @@
     #define GLSL_VERSION 100
 #endif
 
+//global variables
 int windowWidth = 420;
 int windowHeight = 640;
 
-GHTimer timer = {0};
-
-char timer_string[50];
-
 int remote_state = 0;
 
 Font font;
@@ -28,7 +25,7 @@ Font font;
 void control(void) {
     static int last_state;
     if (last_state != remote_state)
-        ctrl_pause(&timer);
+        //ctrl_pause(&timer);
 
     //printf("%d, %d\n", last_state, remote_state);
     last_state = remote_state;
@@ -40,13 +37,22 @@ int main(int argc, char *argv[]) {
     SetTargetFPS(60);
 
     segment_list segments = open_splits_file("test/splits.ghs");
+    GHTimer *timer = ghtimer_new();
     
-    timer_renderer *tr = create_timer_renderer(&timer, 500.0f, 40.0f);
-    segment_renderer *sr = create_segment_renderer(&segments, 0.0f, 0.0f);    
+    timer_renderer *tr = create_timer_renderer(timer, (Vector2){0.0f, 90.0f}, (Vector2){(float)windowWidth, (float)windowHeight/8});
+    segment_renderer *sr = create_segment_renderer(&segments, 0.0f, 0.0f);  
 
-    ctrl_binder *cb = create_ctrl_binder(&timer, &segments);
+    Image blank = GenImageColor(windowWidth, windowHeight, BLANK);
+    Texture2D texture = LoadTextureFromImage(blank);
+    Shader shader = LoadShader(0, "shaders/frag.glsl");
+    UnloadImage(blank);
 
-    //ghtimer_start(&timer);
+    set_segment_renderer_shader(sr, &shader);
+    set_timer_shader(tr, &shader);
+
+    ctrl_binder *cb = create_ctrl_binder(timer, &segments);
+    ctrl_bind_timer_renderer(cb, tr);
+    ctrl_bind_segment_renderer(cb, sr);
     
     font = LoadFontEx("/usr/share/fonts/CozetteVector.ttf", 400, 0, 0);
     GenTextureMipmaps(&font.texture);
@@ -54,20 +60,23 @@ int main(int argc, char *argv[]) {
     float fontSize = (float)font.baseSize;
 
     while (!WindowShouldClose()) {
-        ghtimer_tick(&timer);
+        ghtimer_tick(timer);
 
         if (IsKeyPressed(KEY_P)) {
-            printf("p\n");
             ctrl_start(cb);
         }
-
-        ClearBackground(RAYWHITE);        
-        
+                
         BeginDrawing();
+            //BeginShaderMode(shader);
+            ClearBackground(RAYWHITE);
+            //DrawTexture(texture, 0, 0, WHITE);
+            //EndShaderMode();
             render_timer(tr);
             render_segments(sr);
+            EndShaderMode();
         EndDrawing();    
     }
 
+    ghtimer_delete(timer);
     CloseWindow();
 }

src/segment_renderer.c

@@ -0,0 +1,51 @@
+#include "segment_renderer.h"
+
+extern int windowHeight;
+extern int windowWidth;
+extern char *time_unparse(char *buffer, size_t len, struct timespec *ts);
+
+segment_renderer *create_segment_renderer(segment_list *sl, float y, float h) {
+    segment_renderer *sr = calloc(1, sizeof(segment_renderer));
+    sr->pos = y;
+    sr->height = h;
+    sr->seglist = sl;
+    sr->count = sl->cnt;
+    sr->current = 0;
+    sr->running = false;
+    sr->shader = NULL;
+    return sr;
+}
+
+void set_segment_renderer_shader(segment_renderer *sr, Shader *s) {
+    sr->shader = s;
+}
+
+void set_segment_count(segment_renderer *sr, int c) {
+    sr->count = c;
+}
+
+void destroy_segment_renderer(segment_renderer *sr) {
+    free(sr);
+}
+
+void render_segments(segment_renderer *sr) {
+    if (sr->shader != NULL) {
+        BeginShaderMode(*sr->shader);
+    }
+
+    if (sr->running) {
+        DrawRectangle(0, (sr->current) * 30, windowWidth, (float)font.baseSize/16, BLUE);
+    }
+
+    //draw a big rectangle the size of the segment thing
+    DrawRectangle(0, 0, windowWidth, 90, WHITE);
+
+    if (sr->shader != NULL) {
+        EndShaderMode();
+    }
+
+    for (int i = 0; i < sr->count; i++) {
+        DrawTextEx(font, sr->seglist->list[i]->name, (Vector2){10, 30 * i}, (float)font.baseSize/16, 2, BLACK);
+        DrawTextEx(font, time_unparse(sr->strfmt, FMT_SIZE, &sr->seglist->list[i]->realtime), (Vector2){200, 30 * i}, (float)font.baseSize/16, 2, BLACK);
+    }
+}

src/segment_renderer.h

@@ -3,6 +3,7 @@
 
 #include <raylib.h>
 #include <stdlib.h>
+#include <stdbool.h>
 #include "timer.h"
 #include "splits.h"
 
@@ -18,34 +19,15 @@ typedef struct segment_renderer {
     segment_list *seglist;
     int count;
     int current;
+    bool running;
+    Shader *shader;
     char strfmt[FMT_SIZE];
 } segment_renderer;
 
-segment_renderer *create_segment_renderer(segment_list *sl, float y, float h) {
-    segment_renderer *sr = calloc(1, sizeof(segment_renderer));
-    sr->pos = y;
-    sr->height = h;
-    sr->seglist = sl;
-    sr->count = sl->cnt;
-    return sr;
-}
-
-void set_segment_count(segment_renderer *sr, int c) {
-    sr->count = c;
-}
-
-inline void destroy_segment_renderer(segment_renderer *sr) {
-    free(sr);
-}
-
-void render_segments(segment_renderer *sr) {
-    for (int i = 0; i < sr->count; i++) {
-        DrawTextEx(font, sr->seglist->list[i]->name, (Vector2){10, 30 * i}, (float)font.baseSize/16, 2, BLACK);
-        //if (sr->current < i) {
-            //DrawTextEx(font, time_unparse(sr->strfmt, FMT_SIZE, &sr->seglist->list[i]->realtime), (Vector2){200, 30 * i}, (float)font.baseSize/16, 2, BLACK);
-        //}
-        DrawTextEx(font, time_unparse(sr->strfmt, FMT_SIZE, &sr->seglist->list[i]->realtime), (Vector2){200, 30 * i}, (float)font.baseSize/16, 2, BLACK);
-    }
-}
+segment_renderer *create_segment_renderer(segment_list *sl, float y, float h);
+void set_segment_renderer_shader(segment_renderer *sr, Shader *s);
+void set_segment_count(segment_renderer *sr, int c);
+void destroy_segment_renderer(segment_renderer *sr);
+void render_segments(segment_renderer *sr);
 
 #endif

src/timer.c

@@ -20,7 +20,7 @@ double timespec_to_double(struct timespec ts) {
 }
 
 
-GHTimer *ghtimer_init(void) {
+GHTimer *ghtimer_new(void) {
     GHTimer *timer = calloc(1, sizeof(GHTimer));
     timer->running = false;
     timer->paused = false;
@@ -31,6 +31,10 @@ GHTimer *ghtimer_init(void) {
     return timer;
 }
 
+inline void ghtimer_delete(GHTimer *timer) {
+    free(timer);
+}
+
 void ghtimer_start(GHTimer *timer) {
     clock_gettime(CLOCK_REALTIME, &timer->start);
     timer->running = true;

src/timer.h

@@ -25,6 +25,8 @@ typedef struct GHTimer {
     int paused;
 } GHTimer;
 
+GHTimer *ghtimer_new(void);
+void ghtimer_delete(GHTimer *timer);
 void ghtimer_start(GHTimer *timer);
 void ghtimer_pause(GHTimer *timer);
 void ghtimer_resume(GHTimer *timer);

src/timer_renderer.c

@@ -0,0 +1,42 @@
+#include "timer_renderer.h"
+
+timer_renderer *create_timer_renderer(GHTimer *t, Vector2 p, Vector2 sz) {
+    timer_renderer *tr = calloc(1, sizeof(timer_renderer));
+    tr->timer = t;
+    tr->pos = p;
+    tr->size = sz;
+    return tr;
+}
+
+void set_timer_shader(timer_renderer *tr, Shader *s) {
+    tr->shader = s;
+}
+
+void set_timer_pos(timer_renderer *tr, Vector2 p) {
+    tr->pos = p;
+}
+
+//maybe just destroy_renderer() or just free()
+void destroy_timer_renderer(timer_renderer *tr) {
+    free(tr);
+}
+
+void render_timer(timer_renderer *tr) {
+    struct timespec ts = ghtimer_time(tr->timer);
+    time_unparse(tr->strfmt, FMT_SIZE, &ts);
+    Vector2 text_size = MeasureTextEx(font, tr->strfmt, (float)font.baseSize/4, 2);
+    
+    //set_timer_pos(tr, (Vector2)tr->pos.y - text_size.y);
+    if (tr->shader != NULL) {
+        BeginShaderMode(*tr->shader);
+    }
+
+    //draw the timer background
+    DrawRectangle(tr->pos.x, tr->pos.y, tr->size.x, tr->size.y, WHITE);
+
+    if (tr->shader != NULL) {
+        EndShaderMode();
+    }
+
+    DrawTextEx(font, tr->strfmt , (Vector2){(float)windowWidth - text_size.x - 2.0f, tr->pos.y}, (float)font.baseSize / 4, 2, BLACK);
+}

src/timer_renderer.h

@@ -3,6 +3,7 @@
 
 #include <raylib.h>
 #include <stdlib.h>
+#include <stdbool.h>
 #include "timer.h"
 
 //this is just a thing to bind some extra data to the timer
@@ -17,32 +18,18 @@ extern char *time_unparse(char *buffer, size_t len, struct timespec *ts);
 typedef struct timer_renderer {
     GHTimer *timer;
     //Font font;
-    float pos; //pos
-    float height; //height
+    Vector2 pos;
+    Vector2 size;
+    bool running;
+    Shader *shader;
     char strfmt[FMT_SIZE];
 } timer_renderer;
 
-timer_renderer *create_timer_renderer(GHTimer *t, float y, float h) {
-    timer_renderer *tr = calloc(1, sizeof(timer_renderer));
-    tr->timer = t;
-    tr->pos = y;
-    tr->height = h;
-    return tr;
-}
-
-void set_timer_pos(timer_renderer *tr, float y) {
-    tr->pos = y;
-}
-
+timer_renderer *create_timer_renderer(GHTimer *t, Vector2 p, Vector2 sz);
+void set_timer_shader(timer_renderer *tr, Shader *s);
+void set_timer_pos(timer_renderer *tr, Vector2 p);
 //maybe just destroy_renderer() or just free()
-inline void destroy_timer_renderer(timer_renderer *tr) {
-    free(tr);
-}
-
-void render_timer(timer_renderer *tr) {
-    struct timespec ts = ghtimer_time(tr->timer);
-    time_unparse(tr->strfmt, FMT_SIZE, &ts);
-    DrawTextEx(font, tr->strfmt , (Vector2){20.0f, tr->pos}, (float)font.baseSize / 4, 2, BLACK);
-}
+void destroy_timer_renderer(timer_renderer *tr);
+void render_timer(timer_renderer *tr);
 
 #endif