add stuff

src/shader.c

+#include "../inc/shader.h"
+
+unsigned int create_shader(const char *file, GLenum type) {
+  unsigned int ID;
+  FILE *fp = fopen(file, "rb");
+  if (!fp) {
+    fprintf(stderr, "failed to open shader source file\n");
+    exit(1);
+  }
+
+  fseek(fp, 0, SEEK_END);
+  size_t fsize = ftell(fp);
+  fseek(fp, 0, SEEK_SET);
+
+  char *source;
+  source = (char*)malloc(sizeof(char) * fsize);
+  if (!source) {
+    fclose(fp);
+    fprintf(stderr, "shader source buffer alloc failed\n");
+    exit(1);
+  }
+
+  fread(source, fsize, sizeof(char), fp);
+
+  source = (char*)realloc(source, (fsize + 1) * sizeof(char));
+  source[fsize] = '\0';
+
+  fclose(fp);
+
+  ID = glCreateShader(type);
+  glShaderSource(ID, 1, (const GLchar * const *)&source, NULL);
+  glCompileShader(ID);
+  print_errors(ID, GL_COMPILE_STATUS);
+
+  free(source);
+
+  return ID;
+}
+
+unsigned int create_program(unsigned int *shaders, unsigned int n) {
+  unsigned int ID = glCreateProgram();
+  for (int i = 0; i<n; i++) {
+    glAttachShader(ID, shaders[i]);
+  }
+  glLinkProgram(ID);
+  print_errors(ID, GL_LINK_STATUS);
+
+  for (int i = 0; i<n; i++) {
+    glDeleteShader(shaders[i]);
+  }
+
+  return ID;
+}
+
+void print_errors(unsigned int ID, GLenum info) {
+  int success;
+  char infolog[1024];
+  if (info == GL_COMPILE_STATUS) {
+    glGetShaderiv(ID, GL_COMPILE_STATUS, &success);
+    if (!success) {
+      glGetShaderInfoLog(ID, 1024, NULL, infolog);
+      printf("%s\n", infolog);
+      exit(1);
+    }
+  } else if (info == GL_LINK_STATUS) {
+    glGetProgramiv(ID, GL_LINK_STATUS, &success);
+    if (!success) {
+      glGetProgramInfoLog(ID, 1024, NULL, infolog);
+      printf("%s\n", infolog);
+      exit(1);
+    }
+  }
+}

src/spiro.c

+#include "../inc/spiro.h"
+
+float greatest_common_divisor(uint64_t a, uint64_t b) {
+  while (a != b) {
+    if (a > b) {
+      a = a - b;
+    } else {
+      b = b - a;
+    }
+  }
+  return a;
+}
+
+float lowest_common_multiple(float a, float b) {
+  int64_t ab = (int)(a*1000000)*(int)(b*1000000);
+  if (ab < 0) ab *= -1;
+  uint64_t result = ab/greatest_common_divisor((uint64_t)(a*1000000), (uint64_t)(b*1000000));
+  return result/1000000.0f;
+}
+
+float get_max_t(float internal_r, float external_r) {
+  return TAU * (lowest_common_multiple(internal_r, external_r)/external_r);
+}
+
+void init_point_vertex_data(graph *g) {
+  unsigned int point_vao;
+  glGenVertexArrays(1, &point_vao);
+  glBindVertexArray(point_vao);
+  glBindVertexArray(0);
+  
+  for (uint32_t i = 0; i < g->n_points; i++) {
+    g->points[i].vao = point_vao;
+    g->points[i].position = (vec2){0.0f, 0.0f};
+    g->points[i].t = g->max_t*((float)i/(float)g->n_points);
+  }
+    
+}
+
+void calculate_points(graph *g, unsigned int ssbo_program, unsigned int points_ssbo) {
+
+  glUseProgram(ssbo_program);
+  glUniform1f(glGetUniformLocation(ssbo_program, "big_r"), g->e_r);
+  glUniform1f(glGetUniformLocation(ssbo_program, "small_r"), g->i_r);
+  glUniform1f(glGetUniformLocation(ssbo_program, "d"), g->d);
+  glUniform1i(glGetUniformLocation(ssbo_program, "type"), g->type);
+  glUniform1f(glGetUniformLocation(ssbo_program, "time"), (float)glfwGetTime());
+  glUniform1f(glGetUniformLocation(ssbo_program, "rotation_multiplier"), g->rotation_multiplier);
+  glUniform1f(glGetUniformLocation(ssbo_program, "angle_offset"), g->angle_offset);
+  glDispatchCompute(g->n_points/360, 1, 1);
+  glMemoryBarrier(GL_ALL_BARRIER_BITS);
+  
+  glBindBuffer(GL_SHADER_STORAGE_BUFFER, points_ssbo);
+  point *new_points = (point*)glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_READ_ONLY);
+  for (uint32_t i = 0; i < g->n_points; i++) {
+    g->points[i].position.x = new_points[i].position.x;
+    g->points[i].position.y = new_points[i].position.y;
+  }
+  glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
+  glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
+  glUseProgram(0);
+
+}
+
+void draw_spirograph_points(graph *g, unsigned int shader_program) {
+  glUseProgram(shader_program);
+  glUniform1f(glGetUniformLocation(shader_program, "time"), (float)glfwGetTime());
+  for (uint32_t i = 0; i < g->n_points; i++) {
+    glUniform2fv(glGetUniformLocation(shader_program, "position"), 1, &g->points[i].position.raw[0]);
+    glBindVertexArray(g->points[i].vao);
+    glDrawArrays(GL_POINTS, 0, 1);
+    glBindVertexArray(0);
+  }
+  glUseProgram(0);
+}
+

src/window_init.c

+#include "../inc/window_init.h"
+
+void framebuffer_size_callback(GLFWwindow *window, int w, int h) {
+  glViewport(0, 0, w, h);
+}
+
+GLFWwindow *init_window() {
+  glfwInit();
+
+  GLFWwindow *window = glfwCreateWindow(600, 600, "spiro", NULL, NULL);
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+
+  glfwMakeContextCurrent(window);
+
+  gladLoadGL((GLADloadfunc)glfwGetProcAddress);
+
+  glViewport(0, 0, 800, 600);
+  glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+
+  return window;
+
+}