ashton 0.0.1alpha → 0.0.2alpha

data/ext/ashton/particle_emitter.h

@@ -0,0 +1,171 @@
+/*
+ * class Ashton::ParticleEmitter
+ *
+ */
+
+
+#ifndef ASHTON_PARTICLE_EMITTER_H
+#define ASHTON_PARTICLE_EMITTER_H
+
+#include "fast_math.h"
+#include "common.h"
+
+#define VERTICES_IN_PARTICLE 4
+
+// A single particle.
+typedef struct _particle
+{
+    // State.
+    float x, y;
+    float center_x, center_y;
+    float velocity_x, velocity_y;
+    float angular_velocity;
+
+    Color_f color;
+
+    // Rate of change
+    float fade;
+    float scale;
+    float zoom;
+    float friction;
+    float angle;
+
+    // Time to die.
+    float time_to_live;
+} Particle;
+
+typedef struct _range
+{
+    float min, max;
+} Range;
+
+typedef struct _vertex2d
+{
+    float x, y;
+} Vertex2d;
+
+typedef struct _tex_info
+{
+   uint id;
+   float left;
+   float right;
+   float top;
+   float bottom;
+} TextureInfo;
+
+// The Ashton::ParticleEmitter's own data, including particles.
+typedef struct _particle_emitter
+{
+    VALUE rb_image;
+    uint width; // Width of image.
+    uint height; // Height of image.
+    TextureInfo texture_info; // Texture coords and id.
+
+    VALUE rb_shader;
+
+    // Position of the emitter.
+    float x, y, z;
+    float gravity;
+
+    // Generating particles.
+    Range angular_velocity;
+    Range center_x, center_y;
+    Color_f color;
+    Range fade;
+    Range friction;
+    Range offset; // Distance from origin to spawn.
+    Range scale;
+    Range speed;
+    Range time_to_live;
+    Range zoom;
+
+    // When to emit.
+    Range interval;
+    float time_until_emit;
+
+    // Managing the particles themselves.
+    uint count; // Current number of active particles.
+    uint max_particles; // No more will be created if max hit.
+    uint next_particle_index; // Next place to create a new particle (either dead or oldest living).
+    Particle* particles;
+
+    // VBO and client-side data arrays.
+    uint vbo_id;
+
+    Color_i* color_array; // Color array.
+    ulong color_array_offset; // Offset to colours within VBO.
+
+    Vertex2d* texture_coords_array; // Tex coord array.
+    ulong texture_coords_array_offset; // Offset to texture coords within VBO.
+
+    Vertex2d* vertex_array; // Vertex array.
+    ulong vertex_array_offset; // Offset to vertices within VBO.
+} ParticleEmitter;
+
+
+void Init_Ashton_ParticleEmitter(VALUE module);
+
+// Initialization
+VALUE Ashton_ParticleEmitter_init(VALUE self, VALUE x, VALUE y, VALUE z, VALUE max_particles);
+
+// Create an 'emitter' variable which points to our data.
+#define EMITTER() \
+    ParticleEmitter* emitter; \
+    Data_Get_Struct(self, ParticleEmitter, emitter);
+
+
+// Implementation of get/set functions .
+#define GET_EMITTER_DATA(ATTRIBUTE_NAME, ATTRIBUTE, CAST) \
+    VALUE Ashton_ParticleEmitter_get_##ATTRIBUTE_NAME(VALUE self) \
+    { \
+       EMITTER(); \
+       return CAST(emitter->ATTRIBUTE); \
+    }
+
+#include "limits.h"
+// BUG: Passing in Infinity seems to convert it to NaN!
+#define SET_EMITTER_DATA(ATTRIBUTE_NAME, ATTRIBUTE, CAST) \
+    VALUE Ashton_ParticleEmitter_set_##ATTRIBUTE_NAME(VALUE self, VALUE value) \
+    { \
+       EMITTER(); \
+       emitter->ATTRIBUTE = CAST(value); \
+       return value; \
+    }
+
+#define GET_SET_EMITTER_DATA(ATTRIBUTE, CAST_TO_RUBY, CAST_TO_C) \
+    GET_EMITTER_DATA(ATTRIBUTE, ATTRIBUTE, CAST_TO_RUBY) \
+    SET_EMITTER_DATA(ATTRIBUTE, ATTRIBUTE, CAST_TO_C)
+
+#define GET_SET_EMITTER_DATA_RANGE(ATTRIBUTE, CAST_TO_RUBY, CAST_TO_C) \
+    GET_EMITTER_DATA(ATTRIBUTE##_min, ATTRIBUTE.min, CAST_TO_RUBY) \
+    SET_EMITTER_DATA(ATTRIBUTE##_min, ATTRIBUTE.min, CAST_TO_C)  \
+    GET_EMITTER_DATA(ATTRIBUTE##_max, ATTRIBUTE.max, CAST_TO_RUBY) \
+    SET_EMITTER_DATA(ATTRIBUTE##_max, ATTRIBUTE.max, CAST_TO_C)
+
+
+// Define minimum and maximum get/set functions as methods.
+
+// Define get/set functions as methods.
+#define DEFINE_METHOD_GET_SET(ATTRIBUTE) \
+    rb_define_method(rb_cParticleEmitter, #ATTRIBUTE, Ashton_ParticleEmitter_get_##ATTRIBUTE, 0); \
+    rb_define_method(rb_cParticleEmitter, #ATTRIBUTE "=", Ashton_ParticleEmitter_set_##ATTRIBUTE, 1);
+
+#define DEFINE_METHOD_GET_SET_RANGE(ATTRIBUTE) \
+    DEFINE_METHOD_GET_SET(ATTRIBUTE##_min); \
+    DEFINE_METHOD_GET_SET(ATTRIBUTE##_max);
+
+
+VALUE Ashton_ParticleEmitter_get_color_argb(VALUE self);
+VALUE Ashton_ParticleEmitter_set_color_argb(VALUE self, VALUE color);
+
+// Methods
+VALUE Ashton_ParticleEmitter_get_shader(VALUE self);
+VALUE Ashton_ParticleEmitter_set_shader(VALUE self, VALUE shader);
+VALUE Ashton_ParticleEmitter_get_image(VALUE self);
+VALUE Ashton_ParticleEmitter_set_image(VALUE self, VALUE image);
+VALUE Ashton_ParticleEmitter_draw(VALUE self);
+VALUE Ashton_ParticleEmitter_emit(VALUE self);
+VALUE Ashton_ParticleEmitter_update(VALUE self, VALUE delta);
+
+#endif // ASHTON_PARTICLE_EMITTER_H
+

data/ext/ashton/pixel_cache.c

@@ -0,0 +1,237 @@
+#include "pixel_cache.h"
+
+VALUE rb_cPixelCache;
+
+// Helpers
+static void cache_texture(PixelCache* pixel_cache);
+static Color_i get_pixel_color(PixelCache* pixel_cache, VALUE x, VALUE y);
+static VALUE pixel_cache_allocate(VALUE klass);
+static void pixel_cache_mark(PixelCache* pixel_cache);
+static void pixel_cache_free(PixelCache* pixel_cache);
+
+void Init_Ashton_PixelCache(VALUE module)
+{
+    rb_cPixelCache = rb_define_class_under(module, "PixelCache", rb_cObject);
+
+    rb_define_alloc_func(rb_cPixelCache, pixel_cache_allocate);
+
+    rb_define_method(rb_cPixelCache, "initialize", Ashton_PixelCache_init, 1);
+
+    // Getters
+    rb_define_method(rb_cPixelCache, "owner", Ashton_PixelCache_get_owner, 0);
+    rb_define_method(rb_cPixelCache, "width", Ashton_PixelCache_get_width, 0);
+    rb_define_method(rb_cPixelCache, "height", Ashton_PixelCache_get_height, 0);
+
+    // Methods
+    rb_define_method(rb_cPixelCache, "[]", Ashton_PixelCache_get_pixel, 2);
+    rb_define_method(rb_cPixelCache, "rgba", Ashton_PixelCache_get_rgba_array, 2);
+    rb_define_method(rb_cPixelCache, "red", Ashton_PixelCache_get_red, 2);
+    rb_define_method(rb_cPixelCache, "green", Ashton_PixelCache_get_green, 2);
+    rb_define_method(rb_cPixelCache, "blue", Ashton_PixelCache_get_blue, 2);
+    rb_define_method(rb_cPixelCache, "alpha", Ashton_PixelCache_get_alpha, 2);
+    rb_define_method(rb_cPixelCache, "transparent?", Ashton_PixelCache_is_transparent, 2);
+
+    rb_define_method(rb_cPixelCache, "refresh", Ashton_PixelCache_refresh, 0);
+    rb_define_method(rb_cPixelCache, "to_blob", Ashton_PixelCache_to_blob, 0);
+}
+
+//
+VALUE Ashton_PixelCache_get_width(VALUE self)
+{
+    PIXEL_CACHE();
+    return UINT2NUM(pixel_cache->width);
+}
+
+//
+VALUE Ashton_PixelCache_get_height(VALUE self)
+{
+    PIXEL_CACHE();
+    return UINT2NUM(pixel_cache->height);
+}
+
+
+//
+static VALUE pixel_cache_allocate(VALUE klass)
+{
+    PixelCache* pixel_cache = ALLOC(PixelCache);
+    memset(pixel_cache, 0, sizeof(PixelCache));
+
+    return Data_Wrap_Struct(klass, pixel_cache_mark, pixel_cache_free, pixel_cache);
+}
+
+//
+static void pixel_cache_mark(PixelCache* pixel_cache)
+{
+    rb_gc_mark(pixel_cache->rb_owner);
+}
+
+//
+static void pixel_cache_free(PixelCache* pixel_cache)
+{
+    xfree(pixel_cache->data);
+    xfree(pixel_cache);
+}
+
+//
+VALUE Ashton_PixelCache_init(VALUE self, VALUE owner)
+{
+    PIXEL_CACHE();
+
+    pixel_cache->rb_owner = owner;
+
+    // Different behaviour depending on what the owning class is.
+    if(RTEST(rb_obj_is_kind_of(owner, rb_cTexture)))
+    {
+        // Ashton::Texture
+        pixel_cache->texture_id = NUM2UINT(rb_funcall(owner, rb_intern("id"), 0));
+    }
+    else if(RTEST(rb_obj_is_kind_of(owner, rb_cImage)))
+    {
+        // Gosu::Image
+        // TODO: this needs to be done completely differently, since the image is a sprite on a texture, 1024x1024.
+        VALUE tex_info = rb_funcall(owner, rb_intern("gl_tex_info"), 0);
+        pixel_cache->texture_id = NUM2UINT(rb_funcall(tex_info, rb_intern("tex_name"), 0));
+    }
+    else
+    {
+        rb_raise(rb_eTypeError, "Can only cache Gosu::Image or Ashton::Texture objects.");
+    }
+
+    pixel_cache->width = NUM2UINT(rb_funcall(owner, rb_intern("width"), 0));
+    pixel_cache->height = NUM2UINT(rb_funcall(owner, rb_intern("height"), 0));
+    pixel_cache->data = ALLOC_N(Color_i, pixel_cache->width * pixel_cache->height);
+    cache_texture(pixel_cache);
+
+    return Qnil;
+}
+
+// Make a copy of the pixel_cache texture in main memory.
+static void cache_texture(PixelCache* pixel_cache)
+{
+    glEnable(GL_TEXTURE_2D);
+    glBindTexture(GL_TEXTURE_2D, pixel_cache->texture_id);
+    glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixel_cache->data);
+
+    pixel_cache->is_cached = true;
+}
+
+// Get color of a single pixel.
+static Color_i get_pixel_color(PixelCache* pixel_cache, VALUE x, VALUE y)
+{
+    int _x = NUM2INT(x);
+    int _y = NUM2INT(y);
+
+    if(_x < 0 || _x >= (int)pixel_cache->width ||
+       _y < 0 || _y >= (int)pixel_cache->height)
+    {
+        Color_i color;
+        memset(&color, 0, sizeof(Color_i));
+        return color;
+    }
+    else
+    {
+        if(!pixel_cache->is_cached) cache_texture(pixel_cache);
+
+        return pixel_cache->data[_x + _y * pixel_cache->width];
+    }
+}
+
+VALUE Ashton_PixelCache_get_owner(VALUE self)
+{
+    PIXEL_CACHE();
+    return pixel_cache->rb_owner;
+}
+
+//
+VALUE Ashton_PixelCache_refresh(VALUE self)
+{
+    PIXEL_CACHE();
+    // Lazy refresh - we take a new copy only when we access it next.
+    pixel_cache->is_cached = false;
+    return Qnil;
+}
+
+// Gosu:Color object.
+VALUE Ashton_PixelCache_get_pixel(VALUE self, VALUE x, VALUE y)
+{
+    PIXEL_CACHE();
+
+    Color_i rgba = get_pixel_color(pixel_cache, x, y);
+
+    VALUE color = rb_funcall(rb_cColor, rb_intern("new"), 1,
+                             UINT2NUM((rgba.alpha << 24) +
+                                      (rgba.red   << 16) +
+                                      (rgba.green <<  8) +
+                                       rgba.blue));
+
+    return color;
+}
+
+// RGBA array [255, 255, 255, 255]
+VALUE Ashton_PixelCache_get_rgba_array(VALUE self, VALUE x, VALUE y)
+{
+    PIXEL_CACHE();
+
+    Color_i rgba = get_pixel_color(pixel_cache, x, y);
+
+    VALUE array = rb_ary_new();
+    rb_ary_push(array, UINT2NUM(rgba.red));
+    rb_ary_push(array, UINT2NUM(rgba.green));
+    rb_ary_push(array, UINT2NUM(rgba.blue));
+    rb_ary_push(array, UINT2NUM(rgba.alpha));
+
+    return array;
+}
+
+//
+VALUE Ashton_PixelCache_get_red(VALUE self, VALUE x, VALUE y)
+{
+    PIXEL_CACHE();
+    Color_i rgba = get_pixel_color(pixel_cache, x, y);
+    return UINT2NUM(rgba.red);
+}
+
+//
+VALUE Ashton_PixelCache_get_green(VALUE self, VALUE x, VALUE y)
+{
+    PIXEL_CACHE();
+    Color_i rgba = get_pixel_color(pixel_cache, x, y);
+    return UINT2NUM(rgba.green);
+}
+
+//
+VALUE Ashton_PixelCache_get_blue(VALUE self, VALUE x, VALUE y)
+{
+    PIXEL_CACHE();
+    Color_i rgba = get_pixel_color(pixel_cache, x, y);
+    return UINT2NUM(rgba.blue);
+}
+
+//
+VALUE Ashton_PixelCache_get_alpha(VALUE self, VALUE x, VALUE y)
+{
+    PIXEL_CACHE();
+    Color_i rgba = get_pixel_color(pixel_cache, x, y);
+    return UINT2NUM(rgba.alpha);
+}
+
+//
+VALUE Ashton_PixelCache_is_transparent(VALUE self, VALUE x, VALUE y)
+{
+    PIXEL_CACHE();
+    Color_i rgba = get_pixel_color(pixel_cache, x, y);
+    return (rgba.alpha == 0) ? Qtrue : Qfalse;
+}
+
+//
+VALUE Ashton_PixelCache_to_blob(VALUE self)
+{
+   PIXEL_CACHE();
+
+   uint size = sizeof(Color_i) * pixel_cache->width * pixel_cache->height;
+   VALUE blob = rb_str_new(NULL, size);
+
+   memcpy(RSTRING_PTR(blob), pixel_cache->data, size);
+
+   return blob;
+}

data/ext/ashton/pixel_cache.h

@@ -0,0 +1,58 @@
+/*
+ * class Ashton::PixelCache
+ *
+ *
+ */
+
+
+#ifndef ASHTON_PIXEL_CACHE_H
+#define ASHTON_PIXEL_CACHE_H
+
+#include <math.h>
+
+#include "common.h"
+
+typedef struct _pixel_cache
+{
+    float x;
+    float y;
+
+    uint width;
+    uint height;
+
+    VALUE rb_owner; // Texture or Image object (held for marking purposes).
+    uint texture_id; // Direct access to the owner's texture.
+    
+    Color_i* data; // The actual "blob" data.
+
+    bool is_cached; // If false, then the cache data needs updating.
+    bool is_created; // Has space for the cache ever been allocated?
+} PixelCache;
+
+#define PIXEL_CACHE() \
+    PixelCache* pixel_cache; \
+    Data_Get_Struct(self, PixelCache, pixel_cache);
+
+void Init_Ashton_PixelCache(VALUE module);
+
+// Creation and destruction.
+VALUE Ashton_PixelCache_init(VALUE self, VALUE owner);
+
+// Accessors
+VALUE Ashton_PixelCache_get_owner(VALUE self);
+VALUE Ashton_PixelCache_get_width(VALUE self);
+VALUE Ashton_PixelCache_get_height(VALUE self);
+
+// Methods.
+VALUE Ashton_PixelCache_get_pixel(VALUE self, VALUE x, VALUE y);
+VALUE Ashton_PixelCache_get_rgba_array(VALUE self, VALUE x, VALUE y);
+VALUE Ashton_PixelCache_get_red(VALUE self, VALUE x, VALUE y);
+VALUE Ashton_PixelCache_get_green(VALUE self, VALUE x, VALUE y);
+VALUE Ashton_PixelCache_get_blue(VALUE self, VALUE x, VALUE y);
+VALUE Ashton_PixelCache_get_alpha(VALUE self, VALUE x, VALUE y);
+VALUE Ashton_PixelCache_is_transparent(VALUE self, VALUE x, VALUE y);
+
+VALUE Ashton_PixelCache_refresh(VALUE self);
+VALUE Ashton_PixelCache_to_blob(VALUE self);
+   
+#endif // ASHTON_PIXEL_CACHE_H