ray 0.1.0.pre1 → 0.1.0

data/ext/say_input.c

@@ -0,0 +1,35 @@
+#include "say.h"
+
+static bool say_input_is_key_in_range(say_key key) {
+  return key > SAY_KEY_UNKNOWN && key < SAY_KEY_COUNT;
+}
+
+uint8_t say_input_is_holding(say_input *input, say_key key) {
+  if (say_input_is_key_in_range(key))
+    return input->keys[key - 1];
+  else
+    return 0;
+}
+
+say_vector2 say_input_get_mouse_pos(say_input *input) {
+  return input->mouse_pos;
+}
+
+void say_input_reset(say_input *input) {
+  memset(&input->keys, 0, sizeof(input->keys));
+  input->mouse_pos = say_make_vector2(0, 0);
+}
+
+void say_input_press(say_input *input, say_key key) {
+  if (say_input_is_key_in_range(key))
+    input->keys[key - 1] = 1;
+}
+
+void say_input_release(say_input *input, say_key key) {
+  if (say_input_is_key_in_range(key))
+    input->keys[key - 1] = 0;
+}
+
+void say_input_set_mouse_pos(say_input *input, say_vector2 pos) {
+  input->mouse_pos = pos;
+}

data/ext/say_matrix.c

@@ -0,0 +1,314 @@
+#include "say.h"
+
+static void say_vector_normalize(float *x, float *y, float *z) {
+  float size = sqrtf((*x) * (*x) + (*y) * (*y) + (*z) * (*z));
+
+  *x = *x / size;
+  *y = *y / size;
+  *z = *z / size;
+}
+
+static say_vector3 say_vector_product(say_vector3 a, say_vector3 b) {
+  say_vector3 res;
+
+  res.x = a.y * b.z - a.z * b.y;
+  res.y = a.z * b.x - a.x * b.z;
+  res.z = a.x * b.y - a.y * b.x;
+
+  return res;
+}
+
+say_matrix *say_matrix_identity() {
+  say_matrix *matrix = (say_matrix*)malloc(sizeof(say_matrix));
+  say_matrix_reset(matrix);
+  return matrix;
+}
+
+void say_matrix_free(say_matrix *matrix) {
+  free(matrix);
+}
+
+say_matrix *say_matrix_translation(float x, float y, float z) {
+  say_matrix *matrix = say_matrix_identity();
+
+  say_matrix_set(matrix, 3, 0, x);
+  say_matrix_set(matrix, 3, 1, y);
+  say_matrix_set(matrix, 3, 2, z);
+
+  return matrix;
+}
+
+say_matrix *say_matrix_scale(float x, float y, float z) {
+  say_matrix *matrix = say_matrix_identity();
+
+  say_matrix_set(matrix, 0, 0, x);
+  say_matrix_set(matrix, 1, 1, y);
+  say_matrix_set(matrix, 2, 2, z);
+
+  return matrix;
+}
+
+say_matrix *say_matrix_rotation(float angle, float x, float y, float z) {
+  say_matrix *matrix = say_matrix_identity();
+
+  say_vector_normalize(&x, &y, &z);
+
+  angle = (angle * SAY_PI) / 180;
+
+  float c = cosf(angle);
+  float s = sinf(angle);
+
+  say_matrix_set(matrix, 0, 0, x * x * (1 - c) + c);
+  say_matrix_set(matrix, 1, 0, x * y * (1 - c) - z * s);
+  say_matrix_set(matrix, 2, 0, x * z * (1 - c) + y * s);
+
+  say_matrix_set(matrix, 0, 1, y * x * (1 - c) + z * s);
+  say_matrix_set(matrix, 1, 1, y * y * (1 - c) + c);
+  say_matrix_set(matrix, 2, 1, y * z * (1 - c) - x * s);
+
+  say_matrix_set(matrix, 0, 2, z * x * (1 - c) - y * s);
+  say_matrix_set(matrix, 1, 2, z * y * (1 - c) + x * s);
+  say_matrix_set(matrix, 2, 2, z * z * (1 - c) + c);
+
+  return matrix;
+}
+
+say_matrix *say_matrix_ortho(float left, float right, float bottom, float top,
+                             float z_near, float z_far) {
+  say_matrix *matrix = say_matrix_identity();
+
+  say_matrix_set(matrix, 0, 0, +2 / (right - left));
+  say_matrix_set(matrix, 1, 1, +2 / (top - bottom));
+  say_matrix_set(matrix, 2, 2, -2 / (z_far - z_near));
+
+  say_matrix_set(matrix, 3, 0, -(right + left) / (right - left));
+  say_matrix_set(matrix, 3, 1, -(top + bottom) / (top - bottom));
+  say_matrix_set(matrix, 3, 2, -(z_far + z_near) / (z_far - z_near));
+
+  return matrix;
+}
+
+say_matrix *say_matrix_perspective(float fovy, float aspect,
+                                   float z_near, float z_far) {
+  say_matrix *matrix = say_matrix_identity();
+
+  float f = 1.0f / tanf(fovy / 2);
+
+  say_matrix_set(matrix, 0, 0, f / aspect);
+  say_matrix_set(matrix, 1, 1, f);
+  say_matrix_set(matrix, 2, 2, (z_far + z_near) / (z_near - z_far));
+
+  say_matrix_set(matrix, 3, 2, (2 * z_far * z_near) / (z_near - z_far));
+  say_matrix_set(matrix, 2, 3, -1);
+
+  return matrix;
+}
+
+say_matrix *say_matrix_looking_at(float eye_x, float eye_y, float eye_z,
+                                  float center_x, float center_y,
+                                  float center_z,
+                                  float up_x, float up_y, float up_z) {
+  say_matrix *matrix = say_matrix_identity();
+
+  say_vector3 f = {
+    center_x - eye_x,
+    center_y - eye_y,
+    center_z - eye_z
+  };
+
+  say_vector3 up = {
+    up_x, up_y, up_z
+  };
+
+  say_vector_normalize(&(f.x), &(f.y), &(f.z));
+  say_vector_normalize(&(up.x), &(up.y), &(up.z));
+
+  say_vector3 s = say_vector_product(f, up);
+  say_vector3 u = say_vector_product(s, f);
+
+  say_matrix_set(matrix, 1, 0, s.x);
+  say_matrix_set(matrix, 2, 0, s.y);
+  say_matrix_set(matrix, 3, 0, s.z);
+
+  say_matrix_set(matrix, 1, 1, u.x);
+  say_matrix_set(matrix, 2, 1, u.y);
+  say_matrix_set(matrix, 3, 1, u.z);
+
+  say_matrix_set(matrix, 1, 2, -f.x);
+  say_matrix_set(matrix, 2, 2, -f.y);
+  say_matrix_set(matrix, 3, 2, -f.z);
+
+  return matrix;
+}
+
+void say_matrix_set(say_matrix *matrix, int x, int y, float value) {
+  matrix->content[y * 4 + x] = value;
+}
+
+float say_matrix_get(say_matrix *matrix, int x, int y) {
+  return matrix->content[y * 4 + x];
+}
+
+say_vector3 say_matrix_transform(say_matrix *matrix, say_vector3 point) {
+  float *ary = matrix->content;
+
+  say_vector3 res;
+
+  res.x = ary[0] * point.x + ary[1] * point.y + ary[2]  * point.z + ary[3];
+  res.y = ary[4] * point.x + ary[5] * point.y + ary[6]  * point.z + ary[7];
+  res.z = ary[8] * point.x + ary[9] * point.y + ary[10] * point.z + ary[11];
+
+  return res;
+}
+
+float say_matrix_cofactor(say_matrix *matrix, int fact_x, int fact_y) {
+  float ary[9];
+  int current_index = 0;
+
+  for (int y = 0; y < 4; y++) {
+    if (fact_y == y)
+      continue;
+
+    for (int x = 0; x < 4; x++) {
+      if (fact_x == x)
+        continue;
+
+      ary[current_index++] = matrix->content[x + 4 * y];
+    }
+  }
+
+  float min =
+    ary[0] * ary[4] * ary[8] +
+    ary[1] * ary[5] * ary[6] +
+    ary[2] * ary[3] * ary[7] -
+
+    ary[6] * ary[4] * ary[2] -
+    ary[7] * ary[5] * ary[0] -
+    ary[8] * ary[3] * ary[1];
+
+  return min * ((fact_x + fact_y) % 2 == 0 ? 1 : -1);
+}
+
+say_matrix *say_matrix_comatrix(say_matrix *matrix) {
+  float res[16];
+  for (int y = 0; y < 4; y++) {
+    for (int x = 0; x < 4; x++) {
+      res[x + y * 4] =  say_matrix_cofactor(matrix, x, y);
+    }
+  }
+
+  say_matrix *comatrix = say_matrix_identity();
+  say_matrix_set_content(comatrix, res);
+
+  return comatrix;
+}
+
+say_matrix *say_matrix_inverse(say_matrix *matrix) {
+  float *ary = matrix->content;
+  say_matrix *comatrix = say_matrix_comatrix(matrix);
+
+  float det =
+    ary[0] * comatrix->content[0] +
+    ary[1] * comatrix->content[1] +
+    ary[2] * comatrix->content[2] +
+    ary[3] * comatrix->content[3];
+
+  float res[16];
+  if (det != 0.f) {
+    for (int y = 0; y < 4; y++) {
+      for (int x = 0; x < 4; x++) {
+        res[y + x * 4] = comatrix->content[x + y * 4] / det;
+      }
+    }
+  }
+
+  /* Reuse comatrix to store the output */
+  say_matrix_set_content(comatrix, res);
+
+  return comatrix;
+}
+
+void say_matrix_set_content(say_matrix *matrix, float *content) {
+  memcpy(matrix->content, content, sizeof(float) * 16);
+}
+
+float *say_matrix_get_content(say_matrix *matrix) {
+  return matrix->content;
+}
+
+void say_matrix_reset(say_matrix *matrix) {
+  for (int y = 0; y < 4; y++) {
+    for (int x = 0; x < 4; x++) {
+      if (x == y)
+        say_matrix_set(matrix, x, y, 1.0f);
+      else
+        say_matrix_set(matrix, x, y, 0.0f);
+    }
+  }
+}
+
+void say_matrix_multiply_by(say_matrix *matrix, say_matrix *other) {
+  float new_content[16];
+
+  for (int y = 0; y < 4; y++) {
+    for (int x = 0; x < 4; x++) {
+      float res = 0;
+
+      for (int i = 0; i < 4; i++)
+        res += say_matrix_get(matrix, i, y) * say_matrix_get(other, x, i);
+
+      new_content[y * 4 + x] = res;
+    }
+  }
+
+  say_matrix_set_content(matrix, new_content);
+}
+
+void say_matrix_translate_by(say_matrix *matrix, float x, float y, float z) {
+  say_matrix *other = say_matrix_translation(x, y, z);
+  say_matrix_multiply_by(matrix, other);
+  say_matrix_free(other);
+}
+
+void say_matrix_scale_by(say_matrix *matrix, float x, float y, float z) {
+  say_matrix *other = say_matrix_scale(x, y, z);
+  say_matrix_multiply_by(matrix, other);
+  say_matrix_free(other);
+}
+
+void say_matrix_rotate(say_matrix *matrix, float angle, float x, float y,
+                       float z) {
+  say_matrix *other = say_matrix_rotation(angle, x, y, z);
+  say_matrix_multiply_by(matrix, other);
+  say_matrix_free(other);
+}
+
+void say_matrix_set_ortho(say_matrix *matrix,
+                          float left, float right, float bottom, float top,
+                          float z_near, float z_far) {
+  say_matrix *other = say_matrix_ortho(left, right, bottom, top, z_near, z_far);
+  say_matrix_multiply_by(matrix, other);
+  say_matrix_free(other);
+}
+
+void say_matrix_set_perspective(say_matrix *matrix,
+                                float fovy, float aspect,
+                                float z_near, float z_far) {
+  say_matrix *other = say_matrix_perspective(fovy, aspect, z_near, z_far);
+  say_matrix_multiply_by(matrix, other);
+  say_matrix_free(other);
+}
+
+void say_matrix_look_at(say_matrix *matrix,
+                        float eye_x, float eye_y, float eye_z,
+                        float center_x, float center_y, float center_z,
+                        float up_x, float up_y, float up_z) {
+  say_matrix *other = say_matrix_looking_at(eye_x, eye_y, eye_z,
+                                            center_x, center_y, center_z,
+                                            up_x, up_y, up_z);
+
+  say_matrix_multiply_by(matrix, other);
+  say_matrix_translate_by(matrix, -eye_x, -eye_y, -eye_z);
+
+  say_matrix_free(other);
+}

data/ext/say_matrix.h

@@ -0,0 +1,55 @@
+#ifndef SAY_MATRIX_H_
+#define SAY_MATRIX_H_
+
+#include "say_basic_type.h"
+
+typedef struct {
+  float content[16];
+} say_matrix;
+
+say_matrix *say_matrix_identity();
+void say_matrix_free(say_matrix *matrix);
+
+say_matrix *say_matrix_translation(float x, float y, float z);
+say_matrix *say_matrix_scale(float x, float y, float z);
+say_matrix *say_matrix_rotation(float angle, float x, float y, float z);
+say_matrix *say_matrix_ortho(float left, float right, float bottom, float top,
+                             float z_near, float z_far);
+say_matrix *say_matrix_perspective(float fovy, float aspect,
+                                   float z_near, float z_far);
+say_matrix *say_matrix_looking_at(float eye_x, float eye_y, float eye_z,
+                                  float center_x, float center_y,
+                                  float center_z,
+                                  float up_x, float up_y, float up_z);
+
+void say_matrix_set(say_matrix *matrix, int x, int y, float value);
+float say_matrix_get(say_matrix *matrix, int x, int y);
+
+say_vector3 say_matrix_transform(say_matrix *matrix, say_vector3 init);
+
+float say_matrix_cofactor(say_matrix *matrix, int x, int y);
+say_matrix *say_matrix_comatrix(say_matrix *matrix);
+say_matrix *say_matrix_inverse(say_matrix *matrix);
+
+void say_matrix_set_content(say_matrix *matrix, float *content);
+float *say_matrix_get_content(say_matrix *matrix);
+
+void say_matrix_reset(say_matrix *matrix);
+
+void say_matrix_multiply_by(say_matrix *matrix, say_matrix *other);
+void say_matrix_translate_by(say_matrix *matrix, float x, float y, float z);
+void say_matrix_scale_by(say_matrix *matrix, float x, float y, float z);
+void say_matrix_rotate(say_matrix *matrix, float angle, float x, float y,
+                       float z);
+void say_matrix_set_ortho(say_matrix *matrix,
+                          float left, float right, float bottom, float top,
+                          float z_near, float z_far);
+void say_matrix_set_perspective(say_matrix *matrix,
+                                float fovy, float aspect,
+                                float z_near, float z_far);
+void say_matrix_look_at(say_matrix *matrix,
+                        float eye_x, float eye_y, float eye_z,
+                        float center_x, float center_y, float center_z,
+                        float up_x, float up_y, float up_z);
+
+#endif

data/ext/say_music.c

@@ -0,0 +1,225 @@
+#include "say.h"
+
+static size_t say_music_get_buf_size(say_music *music) {
+  return music->info.channels * music->info.samplerate;
+}
+
+static sf_count_t say_music_read_chunk(say_music *music, short *buf) {
+  sf_count_t size = (sf_count_t)say_music_get_buf_size(music);
+  return sf_read_short(music->file, buf, size);
+}
+
+static bool say_music_fill_buffer(say_music *music, ALint al_buffer) {
+  sf_count_t sample_count = say_music_get_buf_size(music);
+
+  size_t buf_size = sizeof(short) * sample_count;
+  short *buf = malloc(buf_size);
+
+  sf_count_t read_samples = say_music_read_chunk(music, buf);
+  alBufferData(al_buffer, music->format, buf, read_samples * sizeof(short),
+               music->info.samplerate);
+
+  free(buf);
+
+  return read_samples != 0;
+}
+
+static void say_music_start_stream(say_music *music) {
+  ALint queued = 0;
+  alGetSourcei(music->src->src, AL_BUFFERS_QUEUED, &queued);
+
+  while (queued > 0) {
+    queued--;
+
+    ALuint buf;
+    alSourceUnqueueBuffers(music->src->src, 1, &buf);
+  }
+
+  for (size_t i = 0; i < SAY_MUSIC_BUF_COUNT; i++) {
+    say_music_fill_buffer(music, music->buffers[i]);
+    alSourceQueueBuffers(music->src->src, 1, &music->buffers[i]);
+    music->last_buffer = music->buffers[i];
+  }
+}
+
+static void *say_music_playback_thread(say_music *music) {
+  while (music->continue_running) {
+    if (music->streaming) {
+      ALint processed = 0;
+      alGetSourcei(music->src->src, AL_BUFFERS_PROCESSED, &processed);
+
+      while (processed > 0) {
+        processed--;
+
+        ALuint buffer;
+        alSourceUnqueueBuffers(music->src->src, 1, &buffer);
+
+        /* compute duration of the buffer */
+        ALint size, chan, freq;
+        alGetBufferi(buffer, AL_SIZE, &size);
+        alGetBufferi(buffer, AL_FREQUENCY, &freq);
+        alGetBufferi(buffer, AL_CHANNELS, &chan);
+
+        /* adds 1 for any buffer but the last one */
+        music->played_time += (float)size / (freq * chan * sizeof(short));
+
+        bool still_playing = say_music_fill_buffer(music, buffer);
+        if (!still_playing) {
+          if (music->looping && music->last_buffer == buffer) {
+            say_music_seek(music, 0);
+          }
+          else if (!music->looping) {
+            music->streaming = false;
+          }
+        }
+        else {
+          alSourceQueueBuffers(music->src->src, 1, &buffer);
+          music->last_buffer = buffer;
+        }
+      }
+    }
+    
+    /* sleep for 0.25s */
+#ifdef SAY_WIN
+    Sleep(250);
+#else
+    usleep(250 * 1000); 
+#endif
+  }
+
+  return NULL;
+}
+
+say_music *say_music_create() {
+  say_music *music = malloc(sizeof(say_music));
+
+  music->src = say_audio_source_create();
+  alGenBuffers(SAY_MUSIC_BUF_COUNT, music->buffers);
+
+  music->last_buffer = 0;
+
+  music->file = NULL;
+
+  music->duration = 0;
+
+  music->continue_running = true;
+  music->streaming        = false;
+
+  music->looping = false;
+
+  music->thread = say_thread_create(music,
+                                    (say_thread_func)say_music_playback_thread);
+
+  return music;
+}
+
+void say_music_free(say_music *music) {
+  music->continue_running = false;
+
+  say_thread_join(music->thread);
+  say_thread_free(music->thread);
+
+  alSourceStop(music->src->src);
+  alDeleteBuffers(SAY_MUSIC_BUF_COUNT, music->buffers);
+
+  say_audio_source_free(music->src);
+
+  if (music->file)
+    sf_close(music->file);
+
+  free(music);
+}
+
+bool say_music_open(say_music *music, const char *filename) {
+  music->streaming = false;
+  alSourceStop(music->src->src);
+
+  if (music->file) {
+    sf_close(music->file);
+  }
+
+  music->file = sf_open(filename, SFM_READ, &music->info);
+
+  if (!music->file) {
+    say_error_set(sf_strerror(music->file));
+    return false;
+  }
+
+  music->format = say_audio_get_format(music->info.channels);
+  if (!music->format) {
+    sf_close(music->file);
+    music->file = NULL;
+
+    say_error_set("unsupported amount of channels");
+    return false;
+  }
+
+  music->duration = (float)music->info.frames / music->info.samplerate;
+  music->played_time = 0;
+
+  return true;
+}
+
+void say_music_set_looping(say_music *music, bool val) {
+  music->looping = val;
+}
+
+bool say_music_is_looping(say_music *music) {
+  return music->looping;
+}
+
+void say_music_seek(say_music *music, float time) {
+  if (music->file) {
+    music->played_time = time;
+    sf_seek(music->file, music->info.samplerate * time, SEEK_SET);
+
+    if (music->streaming) {
+      music->streaming = false;
+      alSourceStop(music->src->src);
+
+      say_music_start_stream(music);
+
+      alSourcePlay(music->src->src);
+      music->streaming = true;
+    }
+  }
+}
+
+float say_music_get_time(say_music *music) {
+  ALfloat time = 0.0f;
+  alGetSourcef(music->src->src, AL_SEC_OFFSET, &time);
+
+  return time + music->played_time;
+}
+
+float say_music_get_duration(say_music *music) {
+  return music->duration;
+}
+
+void say_music_play(say_music *music) {
+  if (music->file) {
+    /* queue more data if sound was stopped */
+    if (say_audio_source_get_status(music->src) == SAY_STATUS_STOPPED) {
+      say_music_seek(music, 0);
+      say_music_start_stream(music);
+    }
+
+    alSourcePlay(music->src->src);
+    music->streaming = true;
+  }
+}
+
+void say_music_pause(say_music *music) {
+  if (music->file) {
+    music->streaming = false;
+    alSourcePause(music->src->src);
+  }
+}
+
+void say_music_stop(say_music *music) {
+  if (music->file) {
+    music->streaming = false;
+    say_music_seek(music, 0);
+    alSourceStop(music->src->src);
+  }
+}