ray 0.1.0.pre1 → 0.1.0

data/ext/image.c

@@ -0,0 +1,263 @@
+#include "ray.h"
+
+VALUE ray_cImage = Qnil;
+
+say_image *ray_rb2image(VALUE obj) {
+  if (!RAY_IS_A(obj, rb_path2class("Ray::Image"))) {
+    rb_raise(rb_eTypeError, "can't convert %s into Ray::Image",
+             RAY_OBJ_CLASSNAME(obj));
+  }
+
+  say_image *img = NULL;
+  Data_Get_Struct(obj, say_image, img);
+
+  return img;
+}
+
+static
+VALUE ray_image_alloc(VALUE self) {
+  say_image *img = say_image_create();
+  return Data_Wrap_Struct(ray_cImage, NULL, say_image_free, img);
+}
+
+/*
+  @overload initialize(io)
+    @param [IO, #read] io An object containing the image.
+    @example
+      open("test.png") { |io| Ray::Image.new(io) }
+  @overload initialize(filename)
+    @param [String] filename Name of a file to load the image from.
+    @example
+      Ray::Image.new "test.png"
+  @overload initialize(size)
+    @param [Vector2, #to_vector2] size Size of the image to create
+    @example
+      Ray::Image.new [64, 128]
+*/
+static
+VALUE ray_image_init(VALUE self, VALUE arg) {
+  say_image *img = ray_rb2image(self);
+
+  if (rb_respond_to(arg, RAY_METH("read"))) {
+    arg = rb_funcall(arg, RAY_METH("read"), 0);
+    if (!say_image_load_from_memory(img, RSTRING_LEN(arg),
+                                    StringValuePtr(arg))) {
+      rb_raise(rb_eRuntimeError, "%s", say_error_get_last());
+    }
+  }
+  else if (rb_respond_to(arg, RAY_METH("to_str"))) {
+    if (!say_image_load_file(img, StringValuePtr(arg))) {
+      rb_raise(rb_eRuntimeError, "%s", say_error_get_last());
+    }
+  }
+  else {
+    say_vector2 size = ray_convert_to_vector2(arg);
+    if (!say_image_create_with_size(img, size.x, size.y))
+      rb_raise(rb_eRuntimeError, "%s", say_error_get_last());
+  }
+
+  return self;
+}
+
+static
+VALUE ray_image_init_copy(VALUE self, VALUE other) {
+  say_image *orig = ray_rb2image(other);
+
+  say_image_load_raw(ray_rb2image(self),
+                     say_image_get_width(orig), say_image_get_height(orig),
+                     say_image_get_buffer(orig));
+
+  return self;
+}
+
+/*
+ * @overload write_bmp(filename)
+ *   Saves the image as a BMP.
+ */
+static
+VALUE ray_image_write_bmp(VALUE self, VALUE filename) {
+  if (!say_image_write_bmp(ray_rb2image(self), StringValuePtr(filename))) {
+    rb_raise(rb_eRuntimeError, "%s", say_error_get_last());
+  }
+
+  return self;
+}
+
+/*
+ * @overload write_png(filename)
+ *   Saves the image as a PNG.
+ */
+static
+VALUE ray_image_write_png(VALUE self, VALUE filename) {
+  if (!say_image_write_png(ray_rb2image(self), StringValuePtr(filename))) {
+    rb_raise(rb_eRuntimeError, "%s", say_error_get_last());
+  }
+
+  return self;
+}
+
+/*
+ * @overload write_tga(filename)
+ *   Saves the image as a TGA.
+ */
+static
+VALUE ray_image_write_tga(VALUE self, VALUE filename) {
+  if (!say_image_write_tga(ray_rb2image(self), StringValuePtr(filename))) {
+    rb_raise(rb_eRuntimeError, "%s", say_error_get_last());
+  }
+
+  return self;
+}
+
+/*
+ * @overload write(filename)
+ *   Saves the image, tyring to guess the format. If it cannot be guessed, BMP
+ *   will be used.
+ */
+static
+VALUE ray_image_write(VALUE self, VALUE filename) {
+  if (!say_image_write(ray_rb2image(self), StringValuePtr(filename))) {
+    rb_raise(rb_eRuntimeError, "%s", say_error_get_last());
+  }
+
+  return self;
+}
+
+/* @return [Integer] Width of the image in pixels */
+static
+VALUE ray_image_width(VALUE self) {
+  return INT2FIX(say_image_get_width(ray_rb2image(self)));
+}
+
+/* @return [Integer] Height of the image in pixels */
+static
+VALUE ray_image_height(VALUE self) {
+  return INT2FIX(say_image_get_height(ray_rb2image(self)));
+}
+
+/* @return [Ray::Vector2] Size of the image in pixels */
+static
+VALUE ray_image_size(VALUE self) {
+  return ray_vector2_to_rb(say_image_get_size(ray_rb2image(self)));
+}
+
+static
+void ray_image_assert_pos(say_image *img, size_t x, size_t y) {
+  if (x >= say_image_get_width(img)) {
+    rb_raise(rb_eRangeError, "%ld is not in the 0...%ld range",
+             x, say_image_get_width(img));
+  }
+  else if (y >= say_image_get_height(img)) {
+    rb_raise(rb_eRangeError, "%ld is not in the 0...%ld range",
+             y, say_image_get_height(img));
+  }
+}
+
+/*
+  @overload [](x, y)
+    @param [Integer] x X position of the pixel
+    @param [Integer] y Y position of the pixel
+
+    @return [Color] Color of the pixel
+*/
+static
+VALUE ray_image_get(VALUE self, VALUE rb_x, VALUE rb_y) {
+  say_image *img = ray_rb2image(self);
+  size_t x = NUM2ULONG(rb_x), y = NUM2ULONG(rb_y);
+
+  if (x >= say_image_get_width(img) ||
+      y >= say_image_get_height(img))
+    return Qnil;
+
+  return ray_col2rb(say_image_get(img, x, y));
+}
+
+/*
+  @overload []=(x, y, color)
+    @param [Integer] x X position of the pixel
+    @param [Integer] y Y position of the pixel
+
+    @param [Color] color New color of the pixel
+*/
+static
+VALUE ray_image_set(VALUE self, VALUE rb_x, VALUE rb_y, VALUE color) {
+  rb_check_frozen(self);
+
+  say_image *img = ray_rb2image(self);
+  size_t x = NUM2ULONG(rb_x), y = NUM2ULONG(rb_y);
+
+  ray_image_assert_pos(img, x, y);
+
+  say_image_set(img, x, y, ray_rb2col(color));
+  return color;
+}
+
+/*
+  @overload tex_rect(rect)
+    Converts a rect of pixel coordinates to a rect of texture coordinates,
+    which may be needed to generate vertices using this image.
+
+    @param [Rect] rect Rect in pixel coordinates
+    @return [Rect] Rect in texture coordinates
+*/
+VALUE ray_image_tex_rect(VALUE self, VALUE rect) {
+  return ray_rect2rb(say_image_get_tex_rect(ray_rb2image(self),
+                                            ray_convert_to_rect(rect)));
+}
+
+/*
+  Binds the texture, which will be used as GL_TEXTURE_2D when drawing with
+  OpenGL
+*/
+VALUE ray_image_bind(VALUE self) {
+  say_image_bind(ray_rb2image(self));
+  return self;
+}
+
+/*
+  @return [true, false] True if the image uses linear interplation when it's
+    drawn with a different size than the normal one. Uses the color of the
+    nearest pixel otherwise.
+ */
+VALUE ray_image_is_smooth(VALUE self) {
+  return say_image_is_smooth(ray_rb2image(self)) ? Qtrue : Qfalse;
+}
+
+VALUE ray_image_set_smooth(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+  say_image_set_smooth(ray_rb2image(self), RTEST(val));
+  return val;
+}
+
+/*
+  Document-class: Ray::Image
+
+  An image is only the resource used when drawing. It is not the object you can
+  directly draw on the screen.
+*/
+void Init_ray_image() {
+  ray_cImage = rb_define_class_under(ray_mRay, "Image", rb_cObject);
+
+  rb_define_alloc_func(ray_cImage, ray_image_alloc);
+  rb_define_method(ray_cImage, "initialize", ray_image_init, 1);
+  rb_define_method(ray_cImage, "initialize_copy", ray_image_init_copy, 1);
+
+  rb_define_method(ray_cImage, "write_bmp", ray_image_write_bmp, 1);
+  rb_define_method(ray_cImage, "write_png", ray_image_write_png, 1);
+  rb_define_method(ray_cImage, "write_tga", ray_image_write_tga, 1);
+  rb_define_method(ray_cImage, "write", ray_image_write, 1);
+
+  rb_define_method(ray_cImage, "width", ray_image_width, 0);
+  rb_define_method(ray_cImage, "height", ray_image_height, 0);
+  rb_define_method(ray_cImage, "size", ray_image_size, 0);
+
+  rb_define_method(ray_cImage, "[]", ray_image_get, 2);
+  rb_define_method(ray_cImage, "[]=", ray_image_set, 3);
+
+  rb_define_method(ray_cImage, "smooth?", ray_image_is_smooth, 0);
+  rb_define_method(ray_cImage, "smooth=", ray_image_set_smooth, 1);
+
+  rb_define_method(ray_cImage, "tex_rect", ray_image_tex_rect, 1);
+
+  rb_define_method(ray_cImage, "bind", ray_image_bind, 0);
+}

data/ext/image_target.c

@@ -0,0 +1,84 @@
+#include "ray.h"
+
+VALUE ray_cImageTarget = Qnil;
+
+say_image_target *ray_rb2image_target(VALUE obj) {
+  if (!RAY_IS_A(obj, rb_path2class("Ray::ImageTarget"))) {
+    rb_raise(rb_eTypeError, "Can't convert %s into Ray::ImageTarget",
+             RAY_OBJ_CLASSNAME(obj));
+  }
+
+  say_image_target *ret = NULL;
+  Data_Get_Struct(obj, say_image_target, ret);
+
+  return ret;
+}
+
+VALUE ray_image_target_alloc(VALUE self) {
+  if (!say_image_target_is_available())
+    rb_raise(rb_eRuntimeError, "Ray::RenderImage is not supported here");
+  
+  say_image_target *target = say_image_target_create();
+  return Data_Wrap_Struct(ray_cImageTarget, NULL, say_image_target_free,
+                          target);
+}
+
+/* @overload image=(img) */
+VALUE ray_image_target_set_image(VALUE self, VALUE img) {
+  rb_check_frozen(self);
+  say_image_target_set_image(ray_rb2image_target(self), ray_rb2image(img));
+  rb_iv_set(self, "@image", img);
+  return img;
+}
+
+/* @return [Ray::Image] image the target draws on */
+VALUE ray_image_target_image(VALUE self) {
+  return rb_iv_get(self, "@image");
+}
+
+/* Updates the content of the image target */
+VALUE ray_image_target_update(VALUE self) {
+  say_image_target_update(ray_rb2image_target(self));
+  return self;
+}
+
+/* Binds an image target to draw directly on it */
+VALUE ray_image_target_bind(VALUE self) {
+  say_image_target_bind(ray_rb2image_target(self));
+  return self;
+}
+
+/*
+ * Unbinds any image target. This is mostly not needed, as making a window the
+ * current target will call this automatically.
+ */
+VALUE ray_image_target_unbind(VALUE self) {
+  /*
+   * No need for an error when this is not supported, because it just means
+   * we don't need to unbind anything.
+   */
+  if (say_image_target_is_available())
+    say_image_target_unbind();
+  return Qnil;
+}
+
+/*
+ * @return [true, false] True when ImageTargets are available
+ */
+VALUE ray_image_target_available(VALUE self) {
+  return say_image_target_is_available() ? Qtrue : Qfalse;
+}
+
+void Init_ray_image_target() {
+  ray_cImageTarget = rb_define_class_under(ray_mRay, "ImageTarget", ray_cTarget);
+  rb_define_alloc_func(ray_cImageTarget, ray_image_target_alloc);
+
+  rb_define_singleton_method(ray_cImageTarget, "unbind", ray_image_target_unbind, 0);
+  rb_define_singleton_method(ray_cImageTarget, "available?", ray_image_target_available, 0);
+
+  rb_define_method(ray_cImageTarget, "image=", ray_image_target_set_image, 1);
+  rb_define_method(ray_cImageTarget, "image", ray_image_target_image, 0);
+
+  rb_define_method(ray_cImageTarget, "bind", ray_image_target_bind, 0);
+  rb_define_method(ray_cImageTarget, "update", ray_image_target_update, 0);
+}

data/ext/input.c

@@ -0,0 +1,53 @@
+#include "ray.h"
+
+VALUE ray_cInput = Qnil;
+
+say_input *ray_rb2input(VALUE obj) {
+  if (!RAY_IS_A(obj, rb_path2class("Ray::Input"))) {
+    rb_raise(rb_eTypeError, "Can't convert %s into Ray::Input",
+             RAY_OBJ_CLASSNAME(obj));
+  }
+
+  say_input *input = NULL;
+  Data_Get_Struct(obj, say_input, input);
+
+  return input;
+}
+
+VALUE ray_input2rb(say_input *input, VALUE owner) {
+  VALUE obj = Data_Wrap_Struct(rb_path2class("Ray::Input"), NULL, NULL, input);
+  rb_iv_set(obj, "@owner", owner);
+
+  return obj;
+}
+
+static
+VALUE ray_input_alloc(VALUE self) {
+  rb_raise(rb_eRuntimeError, "can't allocate Ray::Input");
+  return Qnil;
+}
+
+/*
+  @overload holding?(key)
+    @param [Integer] key A key
+    @return [true, false] True if the given key is being held
+*/
+static
+VALUE ray_input_holding(VALUE self, VALUE key) {
+  return say_input_is_holding(ray_rb2input(self), NUM2INT(key)) ?
+    Qtrue : Qfalse;
+}
+
+/* @return [Ray::Vector2] The position of the mouse */
+static
+VALUE ray_input_mouse_pos(VALUE self) {
+  return ray_vector2_to_rb(say_input_get_mouse_pos(ray_rb2input(self)));
+}
+
+void Init_ray_input() {
+  ray_cInput = rb_define_class_under(ray_mRay, "Input", rb_cObject);
+  rb_define_alloc_func(ray_cInput, ray_input_alloc);
+
+  rb_define_method(ray_cInput, "holding?", ray_input_holding, 1);
+  rb_define_method(ray_cInput, "mouse_pos", ray_input_mouse_pos, 0);
+}

data/ext/matrix.c

@@ -0,0 +1,374 @@
+#include "ray.h"
+
+VALUE ray_cMatrix = Qnil;
+
+VALUE ray_matrix2rb(say_matrix *matrix) {
+  say_matrix *copy = say_matrix_identity();
+  say_matrix_set_content(copy, matrix->content);
+  return Data_Wrap_Struct(rb_path2class("Ray::Matrix"), NULL, say_matrix_free,
+                          copy);
+}
+
+say_matrix *ray_rb2matrix(VALUE matrix) {
+  if (!RAY_IS_A(matrix, rb_path2class("Ray::Matrix"))) {
+    rb_raise(rb_eTypeError, "can't convert %s into Ray::Matrix",
+             RAY_OBJ_CLASSNAME(matrix));
+  }
+
+  say_matrix *obj = NULL;
+  Data_Get_Struct(matrix, say_matrix, obj);
+
+  return obj;
+}
+
+static
+void ray_matrix_assert_valid_pos(int x, int y) {
+  if (x < 0 || x >= 4)
+    rb_raise(rb_eRangeError, "%d is not in the 0...4 range", x);
+  else if (y < 0 || y >= 4)
+    rb_raise(rb_eRangeError, "%d is not in the 0...4 range", y);
+}
+
+static
+VALUE ray_matrix_alloc(VALUE self) {
+  say_matrix *obj = say_matrix_identity();
+  return Data_Wrap_Struct(self, NULL, say_matrix_free, obj);
+}
+
+/*
+  @overload [](x, y)
+    @param [Integer] x X position of the cell
+    @param [Integer] y Y position of the cell
+
+    @return [Float] Content of the cell at the given position
+
+    @raise [ArgumentError] If at least one of x and y is not included in the
+      0...4 range
+*/
+static
+VALUE ray_matrix_get(VALUE self, VALUE rb_x, VALUE rb_y) {
+  int x = NUM2INT(rb_x), y = NUM2INT(rb_y);
+  ray_matrix_assert_valid_pos(x, y);
+
+  say_matrix *matrix = ray_rb2matrix(self);
+  return rb_float_new(say_matrix_get(matrix, x, y));
+}
+
+/*
+  @overload []=(x, y, val)
+
+  Sets a new value to one of the cell of the matrix
+
+  @param [Integer] x X position of the cell
+  @param [Integer] y Y position of the cell
+
+  @param [Float] val New content for the cell
+
+  @return [void]
+
+  @raise [ArgumentError] If at least one of x and y is not included in the
+    0...4 range
+*/
+static
+VALUE ray_matrix_set(VALUE self, VALUE rb_x, VALUE rb_y, VALUE val) {
+  rb_check_frozen(self);
+
+  int x = NUM2INT(rb_x), y = NUM2INT(rb_y);
+  ray_matrix_assert_valid_pos(x, y);
+
+  say_matrix *matrix = ray_rb2matrix(self);
+  say_matrix_set(matrix, x, y, NUM2DBL(val));
+
+  return val;
+}
+
+/*
+  @return [Array<Float>] The 16 cells of the matrix.
+
+  @example
+    p Matrix.new.content
+    # result:
+    #   [1, 0, 0, 0,
+    #    0, 1, 0, 0,
+    #    0, 0, 1, 0,
+    #    0, 0, 0, 1]
+*/
+static
+VALUE ray_matrix_content(VALUE self) {
+  float *content = say_matrix_get_content(ray_rb2matrix(self));
+
+  VALUE result = rb_ary_new();
+  for (int i = 0; i < 16; i++)
+    rb_ary_push(result, rb_float_new(content[i]));
+
+  return result;
+}
+
+/*
+  @overload content=(val)
+
+  Changes the whole content of the matrix.
+  @param [Array<Float>] val The 16 cells of the matrix
+
+  @return [void]
+*/
+static
+VALUE ray_matrix_set_content(VALUE self, VALUE rb_content) {
+  rb_check_frozen(self);
+
+  if (RARRAY_LEN(rb_content) != 16) {
+    rb_raise(rb_eArgError, "size of array is %ld, 16 expected",
+             RARRAY_LEN(rb_content));
+  }
+
+  say_matrix *matrix = ray_rb2matrix(self);
+
+  float content[16];
+  for (int i = 0; i < 16; i++)
+    content[i] = NUM2DBL(RAY_ARRAY_AT(rb_content, i));
+
+  say_matrix_set_content(matrix, content);
+
+  return rb_content;
+}
+
+/*
+  Resets a matrix to identity.
+  @return [self]
+*/
+static
+VALUE ray_matrix_reset(VALUE self) {
+  rb_check_frozen(self);
+  say_matrix_reset(ray_rb2matrix(self));
+  return self;
+}
+
+/*
+  @overload multiply_by!(other)
+    Multiplies this matrix by another one and stores the result in self.
+
+    @param [Matrix] other A matrix to multiply self by.
+    @return [self]
+
+    @see Matrix#*
+*/
+static
+VALUE ray_matrix_multiply_by(VALUE self, VALUE other) {
+  rb_check_frozen(self);
+  say_matrix_multiply_by(ray_rb2matrix(self), ray_rb2matrix(other));
+  return self;
+}
+
+/*
+  @overload transform(vector)
+    Applies this transformation matrix to a vector.
+
+    @param [#to_vector3] Vector to apply the transformations to
+    @return [Ray::Vector3] A new vector to which the transformations have been
+      applied.
+*/
+static
+VALUE ray_matrix_transform(VALUE self, VALUE vector) {
+  say_vector3 ret = say_matrix_transform(ray_rb2matrix(self),
+                                         ray_convert_to_vector3(vector));
+
+  return ray_vector3_to_rb(ret);
+}
+
+/*
+  @param [Integer] x X position of the element
+  @param [Integer] y Y position of the element
+
+  @return [Float] The cofactor for that element
+*/
+static
+VALUE ray_matrix_cofactor(VALUE self, VALUE x, VALUE y) {
+  return rb_float_new(say_matrix_cofactor(ray_rb2matrix(self),
+                                          NUM2INT(x),
+                                          NUM2INT(y)));
+}
+
+/*
+  @return [Ray::Matrix] the comatrix of the current one.
+*/
+static
+VALUE ray_matrix_comatrix(VALUE self) {
+  say_matrix *comatrix = say_matrix_comatrix(ray_rb2matrix(self));
+  return Data_Wrap_Struct(rb_class_of(self), NULL, say_matrix_free, comatrix);
+}
+
+
+/*
+  @return [Ray::Matrix] The inverse matrix of the current one.
+*/
+static
+VALUE ray_matrix_inverse(VALUE self) {
+  say_matrix *inverse = say_matrix_inverse(ray_rb2matrix(self));
+  return Data_Wrap_Struct(rb_class_of(self), NULL, say_matrix_free, inverse);
+}
+
+/*
+  @overload translate(vector)
+    Applies a translation to the matrix.
+
+    @param [Ray::Vector3] vector Translation to apply
+    @return [void]
+*/
+static
+VALUE ray_matrix_translate(VALUE self, VALUE rb_vector) {
+  rb_check_frozen(self);
+
+  say_vector3 vector = ray_convert_to_vector3(rb_vector);
+  say_matrix_translate_by(ray_rb2matrix(self), vector.x, vector.y, vector.z);
+
+  return self;
+}
+
+/*
+  @overload scale(vector)
+    Scales the matrix. Sizes are multiplied by the vector.
+
+    @param [Ray::Vector3] vector Vector multiplying the sizes
+    @return [void]
+*/
+static
+VALUE ray_matrix_scale(VALUE self, VALUE rb_vector) {
+  rb_check_frozen(self);
+
+  say_vector3 vector = ray_convert_to_vector3(rb_vector);
+  say_matrix_scale_by(ray_rb2matrix(self), vector.x, vector.y, vector.z);
+
+  return self;
+}
+
+/*
+  @overload rotate(angle, vector)
+    Rotates the matrix.
+
+    @param [Float] angle Angle of the rotation in degrees
+    @param [Ray::Vector3] vector Vector followed by the rotation
+
+    @return [void]
+*/
+static
+VALUE ray_matrix_rotate(VALUE self, VALUE angle, VALUE rb_vector) {
+  rb_check_frozen(self);
+
+  say_vector3 vector = ray_convert_to_vector3(rb_vector);
+  say_matrix_rotate(ray_rb2matrix(self), NUM2DBL(angle),
+                    vector.x, vector.y, vector.z);
+
+  return self;
+}
+
+/*
+  @overload look_at(eye, center, up)
+    Creates a view matrix, usually for 3D.
+
+    @param [Ray::Vector3] eye Position of the eye
+    @param [Ray::Vector3] center Reference point
+    @param [Ray::Vector3] up
+ */
+static
+VALUE ray_matrix_look_at(VALUE self, VALUE eye, VALUE center, VALUE up) {
+  say_matrix *mat = ray_rb2matrix(self);
+
+  say_vector3 c_eye    = ray_convert_to_vector3(eye);
+  say_vector3 c_center = ray_convert_to_vector3(center);
+  say_vector3 c_up     = ray_convert_to_vector3(up);
+
+  say_matrix_look_at(mat,
+                     c_eye.x, c_eye.y, c_eye.z,
+                     c_center.x, c_center.y, c_center.z,
+                     c_up.x, c_up.y, c_up.z);
+
+  return self;
+}
+
+/*
+  @overload orthogonal(left, right, bottom, top, near, far)
+    Setup an orthogonal projection.
+
+    @param [Float] left X position of the left corners
+    @param [Float] right X position of the right corners
+
+    @param [Float] bottom Y position of the bottom corners
+    @param [Float] top Y position of the top corners
+
+    @param [Float] near Nearest z value that can be seen
+    @param [Float] far Farthest z valaue that can be seen
+*/
+static
+VALUE ray_matrix_orthogonal(VALUE self,
+                            VALUE left, VALUE right,
+                            VALUE bottom, VALUE top,
+                            VALUE z_near, VALUE z_far) {
+  rb_check_frozen(self);
+
+  say_matrix_set_ortho(ray_rb2matrix(self),
+                       NUM2DBL(left), NUM2DBL(right),
+                       NUM2DBL(bottom), NUM2DBL(top),
+                       NUM2DBL(z_near), NUM2DBL(z_far));
+
+  return self;
+}
+
+/*
+
+  @overload perspective(fovy, aspect, near, far)
+    Setup a perspective projection.
+
+    @param [Float] fovy Field of view in degrees, in the y direction.
+    @param [Float] aspect Width divided by height
+    @param [Float] near Distance from the viewer to the nearest point
+    @param [Float] far Distance from the viewer to the farthest point
+*/
+static
+VALUE ray_matrix_perspective(VALUE self,
+                             VALUE fovy, VALUE aspect,
+                             VALUE z_near, VALUE z_far) {
+  rb_check_frozen(self);
+
+  say_matrix_set_perspective(ray_rb2matrix(self),
+                             NUM2DBL(fovy), NUM2DBL(aspect),
+                             NUM2DBL(z_near), NUM2DBL(z_far));
+
+  return self;
+}
+
+
+/*
+  Document-class: Ray::Matrix
+
+  Ray::Matrix represents a 4x4 matrices. Such matrices can be used to aplly
+  transformations to a point. It contains methods creating such transformation
+  matrices directly, or adding new transformations to the current matrix.
+*/
+
+void Init_ray_matrix() {
+  ray_cMatrix = rb_define_class_under(ray_mRay, "Matrix", rb_cObject);
+
+  rb_define_alloc_func(ray_cMatrix, ray_matrix_alloc);
+
+  rb_define_method(ray_cMatrix, "[]", ray_matrix_get, 2);
+  rb_define_method(ray_cMatrix, "[]=", ray_matrix_set, 3);
+
+  rb_define_method(ray_cMatrix, "content", ray_matrix_content, 0);
+  rb_define_method(ray_cMatrix, "content=", ray_matrix_set_content, 1);
+
+  rb_define_method(ray_cMatrix, "reset", ray_matrix_reset, 0);
+
+  rb_define_method(ray_cMatrix, "multiply_by!", ray_matrix_multiply_by, 1);
+  rb_define_method(ray_cMatrix, "transform", ray_matrix_transform, 1);
+
+  rb_define_method(ray_cMatrix, "cofactor", ray_matrix_cofactor, 2);
+  rb_define_method(ray_cMatrix, "comatrix", ray_matrix_comatrix, 0);
+  rb_define_method(ray_cMatrix, "inverse", ray_matrix_inverse, 0);
+
+  rb_define_method(ray_cMatrix, "translate", ray_matrix_translate, 1);
+  rb_define_method(ray_cMatrix, "scale", ray_matrix_scale, 1);
+  rb_define_method(ray_cMatrix, "rotate", ray_matrix_rotate, 2);
+  rb_define_method(ray_cMatrix, "look_at", ray_matrix_look_at, 3);
+  rb_define_method(ray_cMatrix, "orthogonal", ray_matrix_orthogonal, 6);
+  rb_define_method(ray_cMatrix, "perspective", ray_matrix_perspective, 4);
+}