ray 0.1.0.pre1 → 0.1.0

data/ext/say_polygon.c

@@ -0,0 +1,358 @@
+#include "say.h"
+
+static say_vector2 say_vector2_normal(say_vector2 a, say_vector2 b) {
+  say_vector2 res = say_make_vector2(a.y - b.y, a.x - b.x);
+
+  float len = sqrtf(res.x * res.x + res.y * res.y);
+  res.x /= len;
+  res.y /= len;
+
+  return res;
+}
+
+static float say_vector2_dot(say_vector2 a, say_vector2 b) {
+  return (a.x * b.x + a.y * b.y);
+}
+
+static void say_polygon_fill_vertices(void *data, void *vertices_ptr) {
+  say_polygon *polygon  = (say_polygon*)data;
+  say_vertex  *vertices = (say_vertex*)vertices_ptr;
+
+  if (polygon->point_count < 3)
+    return;
+
+  size_t i = 0;
+
+  say_vector2 center = say_make_vector2(0, 0);
+  size_t r = 0, g = 0, b = 0, a = 0;
+  for (size_t j = 0; j < polygon->point_count; j++) {
+    center.x += polygon->points[j].pos.x;
+    center.y += polygon->points[j].pos.y;
+
+    r += polygon->points[j].col.r;
+    g += polygon->points[j].col.g;
+    b += polygon->points[j].col.b;
+    a += polygon->points[j].col.a;
+  }
+
+  center.x /= polygon->point_count;
+  center.y /= polygon->point_count;
+
+  say_color center_col = say_make_color(r / polygon->point_count,
+                                        g / polygon->point_count,
+                                        b / polygon->point_count,
+                                        a / polygon->point_count);
+
+  if (polygon->filled) {
+    if (polygon->point_count <= 4) {
+      for (i = 0; i < polygon->point_count; i++) {
+        vertices[i].pos = polygon->points[i].pos;
+        vertices[i].col = polygon->points[i].col;
+      }
+    }
+    else {
+      vertices[i].pos = center;
+      vertices[i].col = center_col;
+
+      for (i = 1; i < polygon->point_count + 1; i++) {
+        vertices[i].pos = polygon->points[i - 1].pos;
+        vertices[i].col = polygon->points[i - 1].col;
+      }
+
+      vertices[i++] = vertices[1];
+    }
+  }
+
+  if (polygon->outlined) {
+    size_t first_id = i;
+
+    for (size_t j = 0; j < polygon->point_count; j++, i += 2) {
+      say_polygon_point current = polygon->points[j];
+
+      say_polygon_point next, prev;
+      if (j == polygon->point_count - 1) {
+        next = polygon->points[0];
+        prev = polygon->points[j - 1];
+      }
+      else if (j == 0) {
+        next = polygon->points[j + 1];
+        prev = polygon->points[polygon->point_count - 1];
+      }
+      else {
+        next = polygon->points[j + 1];
+        prev = polygon->points[j - 1];
+      }
+
+      say_vector2 first_normal = say_vector2_normal(prev.pos, current.pos);
+      say_vector2 sec_normal = say_vector2_normal(current.pos, next.pos);
+
+      say_vector2 normal = say_make_vector2(first_normal.x + sec_normal.x,
+                                            first_normal.y + sec_normal.y);
+      float len = 1.0 + say_vector2_dot(first_normal, sec_normal);
+      normal.x /= len;
+      normal.y /= len;
+
+      say_vector2 vector = say_make_vector2(current.pos.x - center.x,
+                                            current.pos.y - center.y);
+
+      if (normal.x * vector.x <= 0)
+        normal.x *= -1;
+
+      normal.x *= polygon->outline_width;
+      normal.y *= polygon->outline_width;
+
+      vertices[i].pos = current.pos;
+      vertices[i].col = current.outline_color;
+
+      vertices[i + 1].pos = say_make_vector2(current.pos.x + normal.x,
+                                             current.pos.y + normal.y);
+      vertices[i + 1].col = current.outline_color;
+    }
+
+    memcpy(&(vertices[i]), &(vertices[first_id]), sizeof(say_vertex) * 2);
+  }
+}
+
+static void say_polygon_draw(void *data, size_t first, size_t index,
+                             say_shader *shader) {
+  say_polygon *polygon = (say_polygon*)data;
+
+  if (polygon->point_count < 3)
+    return;
+
+  size_t current = first;
+
+  if (polygon->filled) {
+    if (polygon->point_count <= 4) {
+      glDrawArrays(GL_TRIANGLE_FAN, current, polygon->point_count);
+      current += polygon->point_count;
+    }
+    else {
+      glDrawArrays(GL_TRIANGLE_FAN, current, polygon->point_count + 2);
+      current += polygon->point_count + 2;
+    }
+  }
+
+  if (polygon->outlined) {
+    glDrawArrays(GL_TRIANGLE_STRIP, current, polygon->point_count * 2 + 2);
+  }
+}
+
+static void say_polygon_compute_size(say_polygon *polygon) {
+  size_t count = 0;
+
+  if (polygon->filled) {
+    if (polygon->point_count <= 4)
+      count += polygon->point_count;
+    else
+      count += polygon->point_count + 2;
+  }
+
+  if (polygon->outlined)
+    count += 2 + polygon->point_count * 2;
+
+  say_drawable_set_vertex_count(polygon->drawable, count);
+}
+
+say_polygon *say_polygon_create(size_t size) {
+  say_polygon *polygon = (say_polygon*)malloc(sizeof(say_polygon));
+
+  polygon->points      = malloc(sizeof(say_polygon_point) * size);
+  polygon->point_count = size;
+
+  polygon->outline_width = 1;
+  polygon->outlined = 0;
+  polygon->filled   = 1;
+
+  polygon->drawable = say_drawable_create(0);
+  say_drawable_set_custom_data(polygon->drawable, polygon);
+  say_drawable_set_fill_proc(polygon->drawable, say_polygon_fill_vertices);
+  say_drawable_set_render_proc(polygon->drawable, say_polygon_draw);
+
+  say_polygon_compute_size(polygon);
+
+  return polygon;
+}
+
+void say_polygon_free(say_polygon *polygon) {
+  say_drawable_free(polygon->drawable);
+
+  free(polygon->points);
+  free(polygon);
+}
+
+void say_polygon_copy(say_polygon *polygon, say_polygon *other) {
+  say_drawable_copy(polygon->drawable, other->drawable);
+  say_drawable_set_custom_data(polygon->drawable, polygon);
+
+  polygon->outline_width = other->outline_width;
+  polygon->outlined      = other->outlined;
+  polygon->filled        = other->filled;
+
+  say_polygon_resize(polygon, say_polygon_get_size(other));
+  memcpy(polygon->points, other->points, sizeof(say_polygon_point) *
+         say_polygon_get_size(other));
+}
+
+say_polygon *say_polygon_triangle(say_vector2 a, say_vector2 b, say_vector2 c,
+                                  say_color color) {
+  say_polygon *triangle = say_polygon_create(3);
+
+  triangle->points[0].pos = a;
+  triangle->points[1].pos = b;
+  triangle->points[2].pos = c;
+
+  say_polygon_set_color(triangle, color);
+
+  return triangle;
+}
+
+say_polygon *say_polygon_rectangle(say_vector2 pos, say_vector2 size,
+                                   say_color color) {
+  say_polygon *rect = say_polygon_create(4);
+
+  rect->points[0].pos = pos;
+  rect->points[1].pos = say_make_vector2(pos.x + size.x, pos.y);
+  rect->points[2].pos = say_make_vector2(pos.x + size.x, pos.y + size.y);
+  rect->points[3].pos = say_make_vector2(pos.x, pos.y + size.y);
+
+  say_polygon_set_color(rect, color);
+
+  return rect;
+}
+
+say_polygon *say_polygon_circle(say_vector2 center, float radius, say_color color) {
+  static const size_t point_count = 40;
+
+  say_polygon *circle = say_polygon_create(point_count);
+
+  float angle_step = 2 * SAY_PI / point_count;
+  float current_angle = 0;
+
+  for (size_t i = 0; i < point_count; i++) {
+    circle->points[i].pos = say_make_vector2(center.x + radius *
+                                             cosf(current_angle),
+                                             center.y + radius *
+                                             sinf(current_angle));
+
+    current_angle += angle_step;
+  }
+
+  say_polygon_set_color(circle, color);
+
+  return circle;
+}
+
+say_polygon *say_polygon_ellipse(say_vector2 center, float rx, float ry,
+                                 say_color color) {
+  say_polygon *ellipse = say_polygon_circle(center, rx, color);
+
+  say_drawable_set_scale(ellipse->drawable, say_make_vector2(1, ry / rx));
+  say_drawable_set_origin(ellipse->drawable, center);
+
+  return ellipse;
+}
+
+say_polygon *say_polygon_line(say_vector2 first, say_vector2 last, float width,
+                              say_color color) {
+  say_polygon *line = say_polygon_create(4);
+
+  line->points[0].pos = first;
+  line->points[1].pos = last;
+  line->points[2].pos = say_make_vector2(last.x + width, last.y);
+  line->points[3].pos = say_make_vector2(first.x + width, first.y);
+
+  say_polygon_set_color(line, color);
+
+  return line;
+}
+
+void say_polygon_resize(say_polygon *polygon, size_t size) {
+  polygon->point_count = size;
+  polygon->points = realloc(polygon->points, sizeof(say_polygon_point) * size);
+  say_polygon_compute_size(polygon);
+}
+
+void say_polygon_set_color(say_polygon *polygon, say_color color) {
+  for (size_t i = 0; i < say_polygon_get_size(polygon); i++)
+    polygon->points[i].col = color;
+  say_drawable_set_changed(polygon->drawable);
+}
+
+void say_polygon_set_outline_color(say_polygon *polygon, say_color color) {
+  for (size_t i = 0; i < say_polygon_get_size(polygon); i++)
+    polygon->points[i].outline_color = color;
+  say_drawable_set_changed(polygon->drawable);
+}
+
+size_t say_polygon_get_size(say_polygon *polygon) {
+  return polygon->point_count;
+}
+
+void say_polygon_set_pos_for(say_polygon *polygon, size_t id, say_vector2 pos) {
+  if (say_vector2_eq(pos, polygon->points[id].pos))
+    return;
+
+  polygon->points[id].pos = pos;
+  say_drawable_set_changed(polygon->drawable);
+}
+
+void say_polygon_set_color_for(say_polygon *polygon, size_t id, say_color col) {
+  if (say_color_eq(col, polygon->points[id].col))
+    return;
+
+  polygon->points[id].col = col;
+  say_drawable_set_changed(polygon->drawable);
+}
+
+void say_polygon_set_outline_for(say_polygon *polygon, size_t id, say_color col) {
+  if (say_color_eq(col, polygon->points[id].outline_color))
+    return;
+
+  polygon->points[id].outline_color = col;
+  say_drawable_set_changed(polygon->drawable);
+}
+
+say_vector2 say_polygon_get_pos_for(say_polygon *polygon, size_t id) {
+  return polygon->points[id].pos;
+}
+
+say_color say_polygon_get_color_for(say_polygon *polygon, size_t id) {
+  return polygon->points[id].col;
+}
+
+say_color say_polygon_get_outline_for(say_polygon *polygon, size_t id) {
+  return polygon->points[id].outline_color;
+}
+
+void say_polygon_set_outline(say_polygon *polygon, float size) {
+  if (polygon->outline_width == size)
+    return;
+
+  polygon->outline_width = size;
+
+  if (polygon->outlined)
+    say_drawable_set_changed(polygon->drawable);
+}
+
+float say_polygon_get_outline(say_polygon *polygon) {
+  return polygon->outline_width;
+}
+
+uint8_t say_polygon_outlined(say_polygon *polygon) {
+  return polygon->outlined;
+}
+
+uint8_t say_polygon_filled(say_polygon *polygon) {
+  return polygon->filled;
+}
+
+void say_polygon_set_outlined(say_polygon *polygon, uint8_t val) {
+  polygon->outlined = val;
+  say_polygon_compute_size(polygon);
+}
+
+void say_polygon_set_filled(say_polygon *polygon, uint8_t val) {
+  polygon->filled = val;
+  say_polygon_compute_size(polygon);
+}

data/ext/say_polygon.h

@@ -0,0 +1,62 @@
+#ifndef SAY_POLYGON_H_
+#define SAY_POLYGON_H_
+
+#include "say_drawable.h"
+
+typedef struct {
+  say_vector2 pos;
+  say_color col;
+  say_color outline_color;
+} say_polygon_point;
+
+typedef struct {
+  say_drawable *drawable;
+
+  say_polygon_point *points;
+  size_t point_count;
+
+  float outline_width;
+  uint8_t outlined;
+  uint8_t filled;
+} say_polygon;
+
+say_polygon *say_polygon_create(size_t size);
+void say_polygon_free(say_polygon *polygon);
+
+void say_polygon_copy(say_polygon *polygon, say_polygon *other);
+
+say_polygon *say_polygon_triangle(say_vector2 a, say_vector2 b, say_vector2 c,
+                                  say_color color);
+say_polygon *say_polygon_rectangle(say_vector2 pos, say_vector2 size,
+                                     say_color color);
+say_polygon *say_polygon_circle(say_vector2 center, float radius, say_color color);
+say_polygon *say_polygon_ellipse(say_vector2 center, float rx, float ry,
+                                 say_color color);
+say_polygon *say_polygon_line(say_vector2 first, say_vector2 last, float width,
+                              say_color color);
+
+void say_polygon_resize(say_polygon *polygon, size_t resize);
+
+void say_polygon_set_color(say_polygon *polygon, say_color color);
+void say_polygon_set_outline_color(say_polygon *polygon, say_color color);
+
+size_t say_polygon_get_size(say_polygon *polygon);
+
+void say_polygon_set_pos_for(say_polygon *polygon, size_t id, say_vector2 pos);
+void say_polygon_set_color_for(say_polygon *polygon, size_t id, say_color col);
+void say_polygon_set_outline_for(say_polygon *polygon, size_t id, say_color col);
+
+say_vector2 say_polygon_get_pos_for(say_polygon *polygon, size_t id);
+say_color say_polygon_get_color_for(say_polygon *polygon, size_t id);
+say_color say_polygon_get_outline_for(say_polygon *polygon, size_t id);
+
+void say_polygon_set_outline(say_polygon *polygon, float size);
+float say_polygon_get_outline(say_polygon *polygon);
+
+uint8_t say_polygon_outlined(say_polygon *polygon);
+uint8_t say_polygon_filled(say_polygon *polygon);
+
+void say_polygon_set_outlined(say_polygon *polygon, uint8_t val);
+void say_polygon_set_filled(say_polygon *polygon, uint8_t val);
+
+#endif

data/ext/say_renderer.c

@@ -0,0 +1,42 @@
+#include "say.h"
+
+say_renderer *say_renderer_create() {
+  say_renderer *renderer = (say_renderer*)malloc(sizeof(say_renderer));
+  renderer->shader = say_shader_create();
+  say_renderer_reset_states(renderer);
+
+  return renderer;
+}
+
+void say_renderer_free(say_renderer *renderer) {
+  say_shader_free(renderer->shader);
+  free(renderer);
+}
+
+say_shader *say_renderer_get_shader(say_renderer *renderer) {
+  return renderer->shader;
+}
+
+void say_renderer_reset_states(say_renderer *renderer) {
+  renderer->using_texture = 0;
+  say_shader_set_int_id(renderer->shader, SAY_TEXTURE_ENABLED_LOC_ID, 0);
+
+}
+void say_renderer_push(say_renderer *renderer, say_drawable *drawable) {
+  if (!drawable->shader &&
+      renderer->using_texture != say_drawable_is_textured(drawable)) {
+    renderer->using_texture = !(renderer->using_texture);
+    say_shader_set_int_id(renderer->shader, SAY_TEXTURE_ENABLED_LOC_ID,
+                          renderer->using_texture);
+  }
+
+  say_drawable_draw(drawable, renderer->shader);
+}
+
+void say_renderer_push_buffer(say_renderer *renderer,
+                              say_buffer_renderer *buf) {
+  say_buffer_renderer_render(buf, renderer->shader);
+
+  renderer->using_texture = 0;
+  say_shader_set_int_id(renderer->shader, SAY_TEXTURE_ENABLED_LOC_ID, 0);
+}