larb 0.1.0 → 1.0.0

data/ext/larb/vec4.c

@@ -0,0 +1,340 @@
+#include "vec4.h"
+
+#include <math.h>
+
+static void vec4_free(void *ptr) {
+  xfree(ptr);
+}
+
+static size_t vec4_memsize(const void *ptr) {
+  return sizeof(Vec4Data);
+}
+
+static const rb_data_type_t vec4_type = {
+    "Vec4",
+    {0, vec4_free, vec4_memsize},
+    0,
+    0,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE cVec4 = Qnil;
+
+static double value_to_double(VALUE value) {
+  VALUE coerced = rb_funcall(value, rb_intern("to_f"), 0);
+  return NUM2DBL(coerced);
+}
+
+static Vec4Data *vec4_get(VALUE obj) {
+  Vec4Data *data = NULL;
+  TypedData_Get_Struct(obj, Vec4Data, &vec4_type, data);
+  return data;
+}
+
+static VALUE vec4_build(VALUE klass, double x, double y, double z, double w) {
+  VALUE obj = vec4_alloc(klass);
+  Vec4Data *data = vec4_get(obj);
+  data->x = x;
+  data->y = y;
+  data->z = z;
+  data->w = w;
+  return obj;
+}
+
+VALUE vec4_alloc(VALUE klass) {
+  Vec4Data *data = ALLOC(Vec4Data);
+  data->x = 0.0;
+  data->y = 0.0;
+  data->z = 0.0;
+  data->w = 1.0;
+  return TypedData_Wrap_Struct(klass, &vec4_type, data);
+}
+
+VALUE vec4_initialize(int argc, VALUE *argv, VALUE self) {
+  VALUE vx = Qnil;
+  VALUE vy = Qnil;
+  VALUE vz = Qnil;
+  VALUE vw = Qnil;
+  Vec4Data *data = vec4_get(self);
+
+  rb_scan_args(argc, argv, "04", &vx, &vy, &vz, &vw);
+  data->x = NIL_P(vx) ? 0.0 : value_to_double(vx);
+  data->y = NIL_P(vy) ? 0.0 : value_to_double(vy);
+  data->z = NIL_P(vz) ? 0.0 : value_to_double(vz);
+  data->w = NIL_P(vw) ? 1.0 : value_to_double(vw);
+
+  return self;
+}
+
+static VALUE vec4_class_bracket(int argc, VALUE *argv, VALUE klass) {
+  VALUE vx = Qnil;
+  VALUE vy = Qnil;
+  VALUE vz = Qnil;
+  VALUE vw = Qnil;
+
+  rb_scan_args(argc, argv, "31", &vx, &vy, &vz, &vw);
+  return vec4_build(klass, value_to_double(vx), value_to_double(vy),
+                    value_to_double(vz), NIL_P(vw) ? 1.0 : value_to_double(vw));
+}
+
+static VALUE vec4_class_zero(VALUE klass) {
+  return vec4_build(klass, 0.0, 0.0, 0.0, 0.0);
+}
+
+static VALUE vec4_class_one(VALUE klass) {
+  return vec4_build(klass, 1.0, 1.0, 1.0, 1.0);
+}
+
+static VALUE vec4_get_x(VALUE self) {
+  Vec4Data *data = vec4_get(self);
+  return DBL2NUM(data->x);
+}
+
+static VALUE vec4_set_x(VALUE self, VALUE value) {
+  Vec4Data *data = vec4_get(self);
+  data->x = value_to_double(value);
+  return value;
+}
+
+static VALUE vec4_get_y(VALUE self) {
+  Vec4Data *data = vec4_get(self);
+  return DBL2NUM(data->y);
+}
+
+static VALUE vec4_set_y(VALUE self, VALUE value) {
+  Vec4Data *data = vec4_get(self);
+  data->y = value_to_double(value);
+  return value;
+}
+
+static VALUE vec4_get_z(VALUE self) {
+  Vec4Data *data = vec4_get(self);
+  return DBL2NUM(data->z);
+}
+
+static VALUE vec4_set_z(VALUE self, VALUE value) {
+  Vec4Data *data = vec4_get(self);
+  data->z = value_to_double(value);
+  return value;
+}
+
+static VALUE vec4_get_w(VALUE self) {
+  Vec4Data *data = vec4_get(self);
+  return DBL2NUM(data->w);
+}
+
+static VALUE vec4_set_w(VALUE self, VALUE value) {
+  Vec4Data *data = vec4_get(self);
+  data->w = value_to_double(value);
+  return value;
+}
+
+VALUE vec4_add(VALUE self, VALUE other) {
+  Vec4Data *a = vec4_get(self);
+  Vec4Data *b = vec4_get(other);
+  return vec4_build(rb_obj_class(self), a->x + b->x, a->y + b->y,
+                    a->z + b->z, a->w + b->w);
+}
+
+VALUE vec4_sub(VALUE self, VALUE other) {
+  Vec4Data *a = vec4_get(self);
+  Vec4Data *b = vec4_get(other);
+  return vec4_build(rb_obj_class(self), a->x - b->x, a->y - b->y,
+                    a->z - b->z, a->w - b->w);
+}
+
+VALUE vec4_mul(VALUE self, VALUE scalar) {
+  Vec4Data *a = vec4_get(self);
+  double s = value_to_double(scalar);
+  return vec4_build(rb_obj_class(self), a->x * s, a->y * s, a->z * s,
+                    a->w * s);
+}
+
+VALUE vec4_div(VALUE self, VALUE scalar) {
+  Vec4Data *a = vec4_get(self);
+  double s = value_to_double(scalar);
+  return vec4_build(rb_obj_class(self), a->x / s, a->y / s, a->z / s,
+                    a->w / s);
+}
+
+VALUE vec4_negate(VALUE self) {
+  Vec4Data *a = vec4_get(self);
+  return vec4_build(rb_obj_class(self), -a->x, -a->y, -a->z, -a->w);
+}
+
+VALUE vec4_dot(VALUE self, VALUE other) {
+  Vec4Data *a = vec4_get(self);
+  Vec4Data *b = vec4_get(other);
+  return DBL2NUM(a->x * b->x + a->y * b->y + a->z * b->z + a->w * b->w);
+}
+
+VALUE vec4_length(VALUE self) {
+  Vec4Data *a = vec4_get(self);
+  return DBL2NUM(sqrt(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w));
+}
+
+VALUE vec4_length_squared(VALUE self) {
+  Vec4Data *a = vec4_get(self);
+  return DBL2NUM(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
+}
+
+VALUE vec4_normalize(VALUE self) {
+  Vec4Data *a = vec4_get(self);
+  double len = sqrt(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
+  return vec4_build(rb_obj_class(self), a->x / len, a->y / len, a->z / len,
+                    a->w / len);
+}
+
+VALUE vec4_normalize_bang(VALUE self) {
+  Vec4Data *a = vec4_get(self);
+  double len = sqrt(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
+  a->x /= len;
+  a->y /= len;
+  a->z /= len;
+  a->w /= len;
+  return self;
+}
+
+VALUE vec4_perspective_divide(VALUE self) {
+  Vec4Data *a = vec4_get(self);
+  VALUE vec3_class = rb_const_get(mLarb, rb_intern("Vec3"));
+
+  if (a->w == 0.0 || a->w == 1.0) {
+    return rb_funcall(vec3_class, rb_intern("new"), 3, DBL2NUM(a->x),
+                      DBL2NUM(a->y), DBL2NUM(a->z));
+  }
+
+  return rb_funcall(vec3_class, rb_intern("new"), 3, DBL2NUM(a->x / a->w),
+                    DBL2NUM(a->y / a->w), DBL2NUM(a->z / a->w));
+}
+
+VALUE vec4_xyz(VALUE self) {
+  Vec4Data *a = vec4_get(self);
+  VALUE vec3_class = rb_const_get(mLarb, rb_intern("Vec3"));
+  return rb_funcall(vec3_class, rb_intern("new"), 3, DBL2NUM(a->x),
+                    DBL2NUM(a->y), DBL2NUM(a->z));
+}
+
+VALUE vec4_xy(VALUE self) {
+  Vec4Data *a = vec4_get(self);
+  VALUE vec2_class = rb_const_get(mLarb, rb_intern("Vec2"));
+  return rb_funcall(vec2_class, rb_intern("new"), 2, DBL2NUM(a->x),
+                    DBL2NUM(a->y));
+}
+
+VALUE vec4_rgb(VALUE self) {
+  return vec4_xyz(self);
+}
+
+VALUE vec4_to_a(VALUE self) {
+  Vec4Data *a = vec4_get(self);
+  VALUE ary = rb_ary_new_capa(4);
+  rb_ary_push(ary, DBL2NUM(a->x));
+  rb_ary_push(ary, DBL2NUM(a->y));
+  rb_ary_push(ary, DBL2NUM(a->z));
+  rb_ary_push(ary, DBL2NUM(a->w));
+  return ary;
+}
+
+VALUE vec4_aref(VALUE self, VALUE index) {
+  VALUE ary = vec4_to_a(self);
+  return rb_ary_entry(ary, NUM2LONG(index));
+}
+
+VALUE vec4_equal(VALUE self, VALUE other) {
+  if (!rb_obj_is_kind_of(other, cVec4)) {
+    return Qfalse;
+  }
+  Vec4Data *a = vec4_get(self);
+  Vec4Data *b = vec4_get(other);
+  return (a->x == b->x && a->y == b->y && a->z == b->z && a->w == b->w)
+             ? Qtrue
+             : Qfalse;
+}
+
+VALUE vec4_near(int argc, VALUE *argv, VALUE self) {
+  VALUE other = Qnil;
+  VALUE epsilon = Qnil;
+
+  rb_scan_args(argc, argv, "11", &other, &epsilon);
+  Vec4Data *a = vec4_get(self);
+  Vec4Data *b = vec4_get(other);
+  double eps = NIL_P(epsilon) ? 1e-6 : value_to_double(epsilon);
+
+  if (fabs(a->x - b->x) < eps && fabs(a->y - b->y) < eps &&
+      fabs(a->z - b->z) < eps && fabs(a->w - b->w) < eps) {
+    return Qtrue;
+  }
+  return Qfalse;
+}
+
+VALUE vec4_lerp(VALUE self, VALUE other, VALUE t) {
+  Vec4Data *a = vec4_get(self);
+  Vec4Data *b = vec4_get(other);
+  double s = value_to_double(t);
+  return vec4_build(rb_obj_class(self), a->x + (b->x - a->x) * s,
+                    a->y + (b->y - a->y) * s,
+                    a->z + (b->z - a->z) * s,
+                    a->w + (b->w - a->w) * s);
+}
+
+VALUE vec4_inspect(VALUE self) {
+  Vec4Data *a = vec4_get(self);
+  VALUE sx = rb_funcall(DBL2NUM(a->x), rb_intern("to_s"), 0);
+  VALUE sy = rb_funcall(DBL2NUM(a->y), rb_intern("to_s"), 0);
+  VALUE sz = rb_funcall(DBL2NUM(a->z), rb_intern("to_s"), 0);
+  VALUE sw = rb_funcall(DBL2NUM(a->w), rb_intern("to_s"), 0);
+  VALUE str = rb_str_new_cstr("Vec4[");
+  rb_str_concat(str, sx);
+  rb_str_cat_cstr(str, ", ");
+  rb_str_concat(str, sy);
+  rb_str_cat_cstr(str, ", ");
+  rb_str_concat(str, sz);
+  rb_str_cat_cstr(str, ", ");
+  rb_str_concat(str, sw);
+  rb_str_cat_cstr(str, "]");
+  return str;
+}
+
+void Init_vec4(VALUE module) {
+  cVec4 = rb_define_class_under(module, "Vec4", rb_cObject);
+
+  rb_define_alloc_func(cVec4, vec4_alloc);
+  rb_define_method(cVec4, "initialize", vec4_initialize, -1);
+
+  rb_define_singleton_method(cVec4, "[]", vec4_class_bracket, -1);
+  rb_define_singleton_method(cVec4, "zero", vec4_class_zero, 0);
+  rb_define_singleton_method(cVec4, "one", vec4_class_one, 0);
+
+  rb_define_method(cVec4, "x", vec4_get_x, 0);
+  rb_define_method(cVec4, "x=", vec4_set_x, 1);
+  rb_define_method(cVec4, "y", vec4_get_y, 0);
+  rb_define_method(cVec4, "y=", vec4_set_y, 1);
+  rb_define_method(cVec4, "z", vec4_get_z, 0);
+  rb_define_method(cVec4, "z=", vec4_set_z, 1);
+  rb_define_method(cVec4, "w", vec4_get_w, 0);
+  rb_define_method(cVec4, "w=", vec4_set_w, 1);
+
+  rb_define_method(cVec4, "+", vec4_add, 1);
+  rb_define_method(cVec4, "-", vec4_sub, 1);
+  rb_define_method(cVec4, "*", vec4_mul, 1);
+  rb_define_method(cVec4, "/", vec4_div, 1);
+  rb_define_method(cVec4, "-@", vec4_negate, 0);
+
+  rb_define_method(cVec4, "dot", vec4_dot, 1);
+  rb_define_method(cVec4, "length", vec4_length, 0);
+  rb_define_method(cVec4, "length_squared", vec4_length_squared, 0);
+  rb_define_method(cVec4, "normalize", vec4_normalize, 0);
+  rb_define_method(cVec4, "normalize!", vec4_normalize_bang, 0);
+  rb_define_method(cVec4, "perspective_divide", vec4_perspective_divide, 0);
+  rb_define_method(cVec4, "xyz", vec4_xyz, 0);
+  rb_define_method(cVec4, "xy", vec4_xy, 0);
+  rb_define_method(cVec4, "rgb", vec4_rgb, 0);
+  rb_define_method(cVec4, "to_a", vec4_to_a, 0);
+  rb_define_method(cVec4, "[]", vec4_aref, 1);
+  rb_define_method(cVec4, "==", vec4_equal, 1);
+  rb_define_method(cVec4, "near?", vec4_near, -1);
+  rb_define_method(cVec4, "lerp", vec4_lerp, 2);
+  rb_define_method(cVec4, "inspect", vec4_inspect, 0);
+  rb_define_alias(cVec4, "to_s", "inspect");
+}

data/ext/larb/vec4.h

@@ -0,0 +1,38 @@
+#ifndef VEC4_H
+#define VEC4_H
+
+#include "larb.h"
+
+typedef struct {
+  double x;
+  double y;
+  double z;
+  double w;
+} Vec4Data;
+
+void Init_vec4(VALUE module);
+VALUE vec4_alloc(VALUE klass);
+VALUE vec4_initialize(int argc, VALUE *argv, VALUE self);
+
+VALUE vec4_add(VALUE self, VALUE other);
+VALUE vec4_sub(VALUE self, VALUE other);
+VALUE vec4_mul(VALUE self, VALUE scalar);
+VALUE vec4_div(VALUE self, VALUE scalar);
+VALUE vec4_negate(VALUE self);
+VALUE vec4_dot(VALUE self, VALUE other);
+VALUE vec4_length(VALUE self);
+VALUE vec4_length_squared(VALUE self);
+VALUE vec4_normalize(VALUE self);
+VALUE vec4_normalize_bang(VALUE self);
+VALUE vec4_perspective_divide(VALUE self);
+VALUE vec4_xyz(VALUE self);
+VALUE vec4_xy(VALUE self);
+VALUE vec4_rgb(VALUE self);
+VALUE vec4_to_a(VALUE self);
+VALUE vec4_aref(VALUE self, VALUE index);
+VALUE vec4_equal(VALUE self, VALUE other);
+VALUE vec4_near(int argc, VALUE *argv, VALUE self);
+VALUE vec4_lerp(VALUE self, VALUE other, VALUE t);
+VALUE vec4_inspect(VALUE self);
+
+#endif

data/lib/larb/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Larb
+  VERSION = "1.0.0"
+end

data/lib/larb.rb

@@ -1,16 +1,4 @@
 # frozen_string_literal: true
 
-require_relative "larb/vec2"
-require_relative "larb/vec3"
-require_relative "larb/vec4"
-require_relative "larb/quat"
-require_relative "larb/quat2"
-require_relative "larb/mat2"
-require_relative "larb/mat2d"
-require_relative "larb/mat3"
-require_relative "larb/mat4"
-require_relative "larb/color"
-
-module Larb
-  VERSION = "0.1.0"
-end
+require "larb/larb"
+require "larb/version"

data/test/larb/color_test.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class ColorTest < Test::Unit::TestCase
+  def test_new_with_default_values
+    c = Larb::Color.new
+    assert_equal 0.0, c.r
+    assert_equal 0.0, c.g
+    assert_equal 0.0, c.b
+    assert_equal 1.0, c.a
+  end
+
+  def test_new_with_given_values
+    c = Larb::Color.new(0.1, 0.2, 0.3, 0.4)
+    assert_equal 0.1, c.r
+    assert_equal 0.2, c.g
+    assert_equal 0.3, c.b
+    assert_equal 0.4, c.a
+  end
+
+  def test_bracket_syntax
+    c = Larb::Color[0.1, 0.2, 0.3, 0.4]
+    assert_equal 0.1, c.r
+    assert_equal 0.2, c.g
+    assert_equal 0.3, c.b
+    assert_equal 0.4, c.a
+  end
+
+  def test_bracket_syntax_default_alpha
+    c = Larb::Color[0.1, 0.2, 0.3]
+    assert_equal 1.0, c.a
+  end
+
+  def test_rgb
+    c = Larb::Color.rgb(0.5, 0.6, 0.7)
+    assert_equal 0.5, c.r
+    assert_equal 0.6, c.g
+    assert_equal 0.7, c.b
+    assert_equal 1.0, c.a
+  end
+
+  def test_rgba
+    c = Larb::Color.rgba(0.1, 0.2, 0.3, 0.4)
+    assert_equal 0.1, c.r
+    assert_equal 0.2, c.g
+    assert_equal 0.3, c.b
+    assert_equal 0.4, c.a
+  end
+
+  def test_from_bytes
+    c = Larb::Color.from_bytes(255, 128, 0, 255)
+    assert_equal 1.0, c.r
+    assert_in_delta 0.5, c.g, 0.01
+    assert_equal 0.0, c.b
+    assert_equal 1.0, c.a
+  end
+
+  def test_from_bytes_default_alpha
+    c = Larb::Color.from_bytes(255, 0, 0)
+    assert_equal 1.0, c.a
+  end
+
+  def test_from_hex
+    c = Larb::Color.from_hex("#ff8000")
+    assert_equal 1.0, c.r
+    assert_in_delta 0.5, c.g, 0.01
+    assert_equal 0.0, c.b
+    assert_equal 1.0, c.a
+  end
+
+  def test_from_hex_without_hash
+    c = Larb::Color.from_hex("ff0000")
+    assert_equal 1.0, c.r
+    assert_equal 0.0, c.g
+    assert_equal 0.0, c.b
+  end
+
+  def test_from_hex_with_alpha
+    c = Larb::Color.from_hex("#ff000080")
+    assert_equal 1.0, c.r
+    assert_in_delta 0.5, c.a, 0.01
+  end
+
+  def test_black
+    c = Larb::Color.black
+    assert_equal 0.0, c.r
+    assert_equal 0.0, c.g
+    assert_equal 0.0, c.b
+    assert_equal 1.0, c.a
+  end
+
+  def test_white
+    c = Larb::Color.white
+    assert_equal 1.0, c.r
+    assert_equal 1.0, c.g
+    assert_equal 1.0, c.b
+  end
+
+  def test_red
+    c = Larb::Color.red
+    assert_equal 1.0, c.r
+    assert_equal 0.0, c.g
+    assert_equal 0.0, c.b
+  end
+
+  def test_green
+    c = Larb::Color.green
+    assert_equal 0.0, c.r
+    assert_equal 1.0, c.g
+    assert_equal 0.0, c.b
+  end
+
+  def test_blue
+    c = Larb::Color.blue
+    assert_equal 0.0, c.r
+    assert_equal 0.0, c.g
+    assert_equal 1.0, c.b
+  end
+
+  def test_yellow
+    c = Larb::Color.yellow
+    assert_equal 1.0, c.r
+    assert_equal 1.0, c.g
+    assert_equal 0.0, c.b
+  end
+
+  def test_cyan
+    c = Larb::Color.cyan
+    assert_equal 0.0, c.r
+    assert_equal 1.0, c.g
+    assert_equal 1.0, c.b
+  end
+
+  def test_magenta
+    c = Larb::Color.magenta
+    assert_equal 1.0, c.r
+    assert_equal 0.0, c.g
+    assert_equal 1.0, c.b
+  end
+
+  def test_transparent
+    c = Larb::Color.transparent
+    assert_equal 0.0, c.r
+    assert_equal 0.0, c.g
+    assert_equal 0.0, c.b
+    assert_equal 0.0, c.a
+  end
+
+  def test_add
+    c1 = Larb::Color.new(0.1, 0.2, 0.3, 0.4)
+    c2 = Larb::Color.new(0.2, 0.3, 0.4, 0.5)
+    result = c1 + c2
+    assert_in_delta 0.3, result.r, 1e-10
+    assert_in_delta 0.5, result.g, 1e-10
+    assert_in_delta 0.7, result.b, 1e-10
+    assert_in_delta 0.9, result.a, 1e-10
+  end
+
+  def test_subtract
+    c1 = Larb::Color.new(0.5, 0.6, 0.7, 0.8)
+    c2 = Larb::Color.new(0.1, 0.2, 0.3, 0.4)
+    result = c1 - c2
+    assert_in_delta 0.4, result.r, 1e-10
+    assert_in_delta 0.4, result.g, 1e-10
+    assert_in_delta 0.4, result.b, 1e-10
+    assert_in_delta 0.4, result.a, 1e-10
+  end
+
+  def test_multiply_by_scalar
+    c = Larb::Color.new(0.2, 0.3, 0.4, 0.5)
+    result = c * 2
+    assert_in_delta 0.4, result.r, 1e-10
+    assert_in_delta 0.6, result.g, 1e-10
+    assert_in_delta 0.8, result.b, 1e-10
+    assert_in_delta 1.0, result.a, 1e-10
+  end
+
+  def test_multiply_by_color
+    c1 = Larb::Color.new(0.5, 0.5, 0.5, 1.0)
+    c2 = Larb::Color.new(1.0, 0.5, 0.0, 1.0)
+    result = c1 * c2
+    assert_in_delta 0.5, result.r, 1e-10
+    assert_in_delta 0.25, result.g, 1e-10
+    assert_equal 0.0, result.b
+  end
+
+  def test_lerp
+    c1 = Larb::Color.new(0, 0, 0, 0)
+    c2 = Larb::Color.new(1, 1, 1, 1)
+    result = c1.lerp(c2, 0.5)
+    assert_equal 0.5, result.r
+    assert_equal 0.5, result.g
+    assert_equal 0.5, result.b
+    assert_equal 0.5, result.a
+  end
+
+  def test_clamp
+    c = Larb::Color.new(-0.5, 1.5, 0.5, 2.0)
+    result = c.clamp
+    assert_equal 0.0, result.r
+    assert_equal 1.0, result.g
+    assert_equal 0.5, result.b
+    assert_equal 1.0, result.a
+  end
+
+  def test_to_bytes
+    c = Larb::Color.new(1.0, 0.5, 0.0, 1.0)
+    bytes = c.to_bytes
+    assert_equal 255, bytes[0]
+    assert_equal 128, bytes[1]
+    assert_equal 0, bytes[2]
+    assert_equal 255, bytes[3]
+  end
+
+  def test_to_hex
+    c = Larb::Color.new(1.0, 0.0, 0.0, 1.0)
+    assert_equal "#ff0000ff", c.to_hex
+  end
+
+  def test_to_vec3
+    c = Larb::Color.new(0.1, 0.2, 0.3, 1.0)
+    v = c.to_vec3
+    assert_instance_of Larb::Vec3, v
+    assert_equal 0.1, v.x
+    assert_equal 0.2, v.y
+    assert_equal 0.3, v.z
+  end
+
+  def test_to_vec4
+    c = Larb::Color.new(0.1, 0.2, 0.3, 0.4)
+    v = c.to_vec4
+    assert_instance_of Larb::Vec4, v
+    assert_equal 0.1, v.x
+    assert_equal 0.2, v.y
+    assert_equal 0.3, v.z
+    assert_equal 0.4, v.w
+  end
+
+  def test_to_a
+    c = Larb::Color.new(0.1, 0.2, 0.3, 0.4)
+    assert_equal [0.1, 0.2, 0.3, 0.4], c.to_a
+  end
+
+  def test_from_vec4
+    v = Larb::Vec4.new(0.1, 0.2, 0.3, 0.4)
+    c = Larb::Color.from_vec4(v)
+    assert_equal 0.1, c.r
+    assert_equal 0.2, c.g
+    assert_equal 0.3, c.b
+    assert_equal 0.4, c.a
+  end
+
+  def test_from_vec3
+    v = Larb::Vec3.new(0.1, 0.2, 0.3)
+    c = Larb::Color.from_vec3(v)
+    assert_equal 0.1, c.r
+    assert_equal 0.2, c.g
+    assert_equal 0.3, c.b
+    assert_equal 1.0, c.a
+  end
+
+  def test_from_vec3_with_alpha
+    v = Larb::Vec3.new(0.1, 0.2, 0.3)
+    c = Larb::Color.from_vec3(v, 0.5)
+    assert_equal 0.5, c.a
+  end
+
+  def test_inspect
+    c = Larb::Color.new(0.1, 0.2, 0.3, 0.4)
+    assert_equal "Color[0.1, 0.2, 0.3, 0.4]", c.inspect
+  end
+
+  def test_to_s
+    c = Larb::Color.new(0.1, 0.2, 0.3, 0.4)
+    assert_equal c.inspect, c.to_s
+  end
+end