rays 0.1.27 → 0.1.29

data/src/shader_source.cpp

@@ -42,7 +42,7 @@ namespace Rays
 			GLint status = GL_FALSE;
 			glGetShaderiv(id, GL_COMPILE_STATUS, &status);
 			if (status == GL_FALSE)
-				opengl_error(__FILE__, __LINE__, get_compile_log().c_str());
+				shader_error(__FILE__, __LINE__, get_compile_log().c_str());
 
 			type   = type_;
 			source = source_;
@@ -98,7 +98,7 @@ namespace Rays
 	const char*
 	ShaderSource::source () const
 	{
-		return self->source;
+		return self->is_valid() ? self->source.c_str() : NULL;
 	}
 
 	GLenum

data/src/texture.cpp

@@ -82,38 +82,6 @@ namespace Rays
 		return n;
 	}
 
-	static void
-	setup_texture (Texture::Data* self, const void* pixels = NULL)
-	{
-		assert(self && !self->has_id());
-
-		if (self->context)
-			invalid_state_error(__FILE__, __LINE__);
-
-		self->context = OpenGL_get_context();
-		if (!self->context)
-			opengl_error(__FILE__, __LINE__);
-
-		glGenTextures(1, &self->id);
-		glBindTexture(GL_TEXTURE_2D, self->id);
-		if (glIsTexture(self->id) == GL_FALSE)
-			opengl_error(__FILE__, __LINE__, "failed to create texture.");
-
-		//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-		//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);//GL_LINEAR);
-
-		GLenum format, type;
-		ColorSpace_get_gl_format_and_type(&format, &type, self->color_space);
-
-		glTexImage2D(
-			GL_TEXTURE_2D, 0, format, self->width_pow2, self->height_pow2, 0,
-			format, type, pixels);
-
-		OpenGL_check_error(__FILE__, __LINE__);
-	}
-
 	template <int BytesPerPixel>
 	static inline void
 	copy_pixel (uchar* dest, const uchar* src)
@@ -179,7 +147,9 @@ namespace Rays
 	static void
 	copy_bitmap (Bitmap* dest, const Bitmap& src)
 	{
-		if (!dest || !src)
+		assert(dest);
+
+		if (!src)
 			argument_error(__FILE__, __LINE__);
 
 		int width    = std::min(src.width(),  dest->width());
@@ -196,51 +166,91 @@ namespace Rays
 		}
 	}
 
-
-	Texture::Texture ()
+	static std::shared_ptr<Bitmap>
+	resize_bitmap (const Bitmap& bitmap, int width, int height)
 	{
+		std::shared_ptr<Bitmap> bmp(
+			new Bitmap(width, height, bitmap.color_space()));
+		if (!*bmp)
+			rays_error(__FILE__, __LINE__);
+
+		copy_bitmap(bmp.get(), bitmap);
+		return bmp;
 	}
 
-	Texture::Texture (int width, int height, const ColorSpace& cs)
+	static void
+	setup_texture (
+		Texture::Data* self, int width, int height, const ColorSpace& cs,
+		const Bitmap* bitmap = NULL)
 	{
-		if (width <= 0 || height <= 0 || !cs)
-			argument_error(__FILE__, __LINE__);
+		assert(self && !self->has_id());
+
+		if (self->context)
+			invalid_state_error(__FILE__, __LINE__);
+
+		self->context = OpenGL_get_context();
+		if (!self->context)
+			opengl_error(__FILE__, __LINE__);
+
+		glGenTextures(1, &self->id);
+		glBindTexture(GL_TEXTURE_2D, self->id);
+		if (glIsTexture(self->id) == GL_FALSE)
+			opengl_error(__FILE__, __LINE__, "failed to create texture.");
+
+		//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+		//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);//GL_LINEAR);
+
+		GLenum format, type;
+		ColorSpace_get_gl_format_and_type(&format, &type, cs);
+
+		// create non-power-of-two texture
+		glTexImage2D(
+			GL_TEXTURE_2D, 0, format, width, height, 0, format, type,
+			bitmap ? bitmap->pixels() : NULL);
+		if (OpenGL_has_error())
+		{
+			// create power-of-two texture
+			int width_pow2  = min_pow2(width);
+			int height_pow2 = min_pow2(height);
+
+			glTexImage2D(
+				GL_TEXTURE_2D, 0, format, width_pow2, height_pow2, 0, format, type,
+				bitmap ? resize_bitmap(*bitmap, width_pow2, height_pow2)->pixels() : NULL);
+			OpenGL_check_error(__FILE__, __LINE__);
+
+			self->width_pow2  = width_pow2;
+			self->height_pow2 = height_pow2;
+		}
 
 		self->width       = width;
 		self->height      = height;
-		self->width_pow2  = min_pow2(width);
-		self->height_pow2 = min_pow2(height);
 		self->color_space = cs;
 		self->modified    = true;
+	}
 
-		setup_texture(self.get());
+
+	Texture::Texture ()
+	{
 	}
 
-	Texture::Texture (const Bitmap& bitmap)
+	Texture::Texture (int width, int height, const ColorSpace& cs)
 	{
-		if (!bitmap)
+		if (width <= 0 || height <= 0 || !cs)
 			argument_error(__FILE__, __LINE__);
 
-		self->width       = bitmap.width();
-		self->height      = bitmap.height();
-		self->width_pow2  = min_pow2(self->width);
-		self->height_pow2 = min_pow2(self->height);
-		self->color_space = bitmap.color_space();
-		self->modified    = true;
-
-		Bitmap bmp = bitmap;
-		if (
-			self->width_pow2  != self->width ||
-			self->height_pow2 != self->height)
-		{
-			bmp = Bitmap(self->width_pow2, self->height_pow2, self->color_space);
-			if (!bmp)
-				rays_error(__FILE__, __LINE__);
+		setup_texture(self.get(), width, height, cs);
+	}
 
-			copy_bitmap(&bmp, bitmap);
-		}
+	Texture::Texture (const Bitmap& bitmap)
+	{
+		if (!bitmap)
+			argument_error(__FILE__, __LINE__);
 
-		setup_texture(self.get(), bmp.pixels());
+		setup_texture(
+			self.get(), bitmap.width(), bitmap.height(), bitmap.color_space(),
+			&bitmap);
 	}
 
 	Texture::~Texture ()
@@ -256,7 +266,8 @@ namespace Rays
 	int
 	Texture::reserved_width () const
 	{
-		return self->width_pow2;
+		int w = self->width_pow2;
+		return w > 0 ? w : self->width;
 	}
 
 	int
@@ -268,7 +279,8 @@ namespace Rays
 	int
 	Texture::reserved_height () const
 	{
-		return self->height_pow2;
+		int h = self->height_pow2;
+		return h > 0 ? h : self->height;
 	}
 
 	const ColorSpace&

data/test/test_image.rb

@@ -6,11 +6,12 @@ require_relative 'helper'
 
 class TestImage < Test::Unit::TestCase
 
-  W = 10
-  H = 10
+  def image(*args)
+    Rays::Image.new(*args)
+  end
 
-  def image(w = W, h = H, *args)
-    Rays::Image.new w, h, *args
+  def load(path)
+    Rays::Image.load path
   end
 
   def color(r = 0, g = 0, b = 0, a = 0)
@@ -22,12 +23,12 @@ class TestImage < Test::Unit::TestCase
   end
 
   def test_initialize()
-    assert_equal W, image.width
-    assert_equal H, image.height
+    assert_equal 10, image(10, 20).width
+    assert_equal 10, image(20, 10).height
   end
 
   def test_dup()
-    o          = image
+    o          = image 10, 10
     assert_equal color(0, 0, 0, 0), o[0, 0]
     o[0, 0]    = color(1, 0, 0, 0)
     assert_equal color(1, 0, 0, 0), o[0, 0]
@@ -39,12 +40,12 @@ class TestImage < Test::Unit::TestCase
   end
 
   def test_bitmap()
-    assert_equal W, image.bitmap.width
-    assert_equal H, image.bitmap.height
+    assert_equal 10, image(10, 20).bitmap.width
+    assert_equal 10, image(20, 10).bitmap.height
   end
 
   def test_painter()
-    pa = image.painter
+    pa = image(10, 10).painter
     assert_equal color(0, 0, 0, 0), pa.background
     assert_equal color(1, 1, 1, 1), pa.fill
     assert_equal color(1, 1, 1, 0), pa.stroke
@@ -73,4 +74,38 @@ class TestImage < Test::Unit::TestCase
     assert drawn {|p| p.text "a"}
   end
 
+  def test_save_load()
+    def get_image_type(filename)
+      `file #{filename}`.match(/#{filename}: ([^,]+),/)[1]
+    end
+
+    img    = image(10, 10).paint {fill 1, 0, 0; ellipse 0, 0, 10}
+    pixels = img.bitmap.to_a
+    paths  = %w[png jpg jpeg gif bmp tif tiff].map {|ext| "#{__dir__}/testimage.#{ext}"}
+
+    png, jpg, jpeg, gif, bmp, tif, tiff = paths
+
+    paths.each {|path| img.save path}
+
+    assert_equal 'PNG image data',  get_image_type(png)
+    assert_equal 'JPEG image data', get_image_type(jpg)
+    assert_equal 'JPEG image data', get_image_type(jpeg)
+    assert_equal 'GIF image data',  get_image_type(gif)
+    assert_equal 'PC bitmap',       get_image_type(bmp)
+    assert_equal 'TIFF image data', get_image_type(tif)
+    assert_equal 'TIFF image data', get_image_type(tiff)
+
+    assert_equal pixels,   load(png) .then {|o| o.bitmap.to_a}
+    assert_equal [10, 10], load(jpg) .then {|o| [o.width, o.height]}
+    assert_equal [10, 10], load(jpeg).then {|o| [o.width, o.height]}
+    assert_equal pixels,   load(gif) .then {|o| o.bitmap.to_a}
+    assert_equal [10, 10], load(bmp) .then {|o| [o.width, o.height]}
+    assert_equal pixels,   load(tif) .then {|o| o.bitmap.to_a}
+    assert_equal pixels,   load(tiff).then {|o| o.bitmap.to_a}
+
+    paths.each {|path| File.delete path}
+
+    assert_raise(ArgumentError) {img.save 'testimage.unknown'}
+  end
+
 end# TestImage

data/test/test_painter.rb

@@ -19,18 +19,24 @@ class TestPainter < Test::Unit::TestCase
   end
 
   def image(w = 16, h = 16, bg: 0, &block)
-    Rays::Image.new(w, h).paint {background bg}.paint(&block)
+    Rays::Image.new(w, h)
+      .paint {background bg}
+      .tap {|img| img.paint(&block) if block}
+  end
+
+  def assert_gray(expected, actual)
+    assert_in_epsilon expected, actual, 0.02
   end
 
   def assert_rgb(expected, actual)
     (0..2).each do |i|
-      assert_in_epsilon expected[i], actual[i], 0.02
+      assert_gray expected[i], actual[i]
     end
   end
 
   def assert_rgba(expected, actual)
     (0..3).each do |i|
-      assert_in_epsilon expected[i], actual[i], 0.02
+      assert_gray expected[i], actual[i]
     end
   end
 
@@ -369,7 +375,23 @@ class TestPainter < Test::Unit::TestCase
   end
 
   def test_shader()
-    img = Rays::Image.new(10, 10).paint {
+    image.paint do |pa|
+      assert_nil pa.shader
+
+      pa.shader = Rays::Shader.new "void main() {gl_FragColor = vec4(0.0);}"
+      assert_instance_of Rays::Shader, pa.shader
+
+      pa.shader = nil
+      assert_nil pa.shader
+
+      pa.shader = "void main() {gl_FragColor = vec4(0.0);}"
+      assert_instance_of Rays::Shader, pa.shader
+
+      pa.no_shader
+      assert_nil pa.shader
+    end
+
+    img = image.paint {
       shader "void main() {gl_FragColor = vec4(0.0, 0.0, 1.0, 1.0);}"
       fill   1, 0, 0
       rect   bounds

data/test/test_point.rb

@@ -112,13 +112,14 @@ class TestPoint < Test::Unit::TestCase
 
   def test_to_a()
     o = point 1, 2, 3
-    assert_equal [1, 2],    o.to_a
-    assert_equal [1],       o.to_a(1)
-    assert_equal [1, 2],    o.to_a(2)
-    assert_equal [1, 2, 3], o.to_a(3)
+    assert_equal [1, 2],       o.to_a
+    assert_equal [1],          o.to_a(1)
+    assert_equal [1, 2],       o.to_a(2)
+    assert_equal [1, 2, 3],    o.to_a(3)
+    assert_equal [1, 2, 3, 1], o.to_a(4)
     assert_raise(ArgumentError) {o.to_a(-1)}
     assert_raise(ArgumentError) {o.to_a(0)}
-    assert_raise(ArgumentError) {o.to_a(4)}
+    assert_raise(ArgumentError) {o.to_a(5)}
   end
 
   def test_index()

data/test/test_rays.rb

@@ -9,9 +9,9 @@ require_relative 'helper'
 class TestRays < Test::Unit::TestCase
 
   def test_init!()
-    assert_raise(Rucy::NativeError) {Rays.fin!}
+    assert_raise(Rays::RaysError) {Rays.fin!}
     assert Rays.init!
-    assert_raise(Rucy::NativeError) {Rays.init!}
+    assert_raise(Rays::RaysError) {Rays.init!}
     assert Rays.fin!
   end
 

data/test/test_shader.rb

@@ -6,32 +6,169 @@ require_relative 'helper'
 
 class TestShader < Test::Unit::TestCase
 
-  def shader(src)
-    Rays::Shader.new src
+  def shader(*a, **k)
+    Rays::Shader.new(*a, **k)
   end
 
-  def img(w = 10, h = 10, &block)
-    Rays::Image.new w, h
+  def image(w = 10, h = 10, &block)
+    Rays::Image.new(w, h).tap {|i| i.paint(&block) if block}
   end
 
   def color(*args)
     Rays::Color.new(*args)
   end
 
+  def vshader()
+    "void main() {gl_Position = vec4(0.0, 0.0, 0.0, 1.0);}"
+  end
+
+  def fshader()
+    "void main() {gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);}"
+  end
+
+  def draw_shader(
+    fragment_shader_source, fill: 1, options: {}, uniforms: {}, &block)
+
+    image.tap do |img|
+      img.paint do |p|
+        p.shader shader(fragment_shader_source, **options.merge(uniforms))
+        block.call p.shader if block
+        p.fill(*fill)
+        p.stroke nil
+        p.rect img.bounds.move_to(0, 0)
+      end
+    end
+  end
+
   def test_initialize()
-    assert_raise(Rucy::NativeError) {shader "foo"}
-    assert_raise(ArgumentError) {shader}
-    #assert_raise(TypeError) {shader nil}
-    assert shader("void main() {gl_FragColor = vec4(1, 0, 0, 1);}")
+    assert shader(fshader)
+    assert shader(fshader, vshader)
+
+    assert_raise(Rays::ShaderError) {shader "foo"}
+    assert_raise(Rays::ShaderError) {shader "foo", vshader}
+    assert_raise(Rays::ShaderError) {shader fshader, "foo"}
+    assert_raise(Rays::ShaderError) {shader vshader}
+    assert_raise(Rays::ShaderError) {shader fshader, fshader}
+    assert_raise(ArgumentError) {shader nil}
   end
 
   def test_shader()
-    i = img.paint do
-      shader "void main () {gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);}"
-      fill 0, 1, 0, 1
-      rect(*bounds.move_to(0, 0).to_a)
-    end
-    assert_equal color(1, 0, 0, 1), i[0, 0]
+    assert_equal color(1, 0, 0, 1), draw_shader(<<~END, fill: [0, 1, 0, 1])[0, 0]
+      void main() {gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);}
+    END
+  end
+
+  def test_uniform_int()
+    draw = -> (type, color_string, &b) {
+      draw_shader(<<~END) {|shader| b.call shader}[0, 0].to_a
+        uniform #{type} v;
+        float f(int value, int div) {
+          return float(value) / float(div);
+        }
+        void main() {
+          gl_FragColor = vec4(#{color_string});
+        }
+      END
+    }
+    assert_equal [1, 0, 0, 1], draw['int',   'f(v,   1), 0.0,       0.0,       1.0']       {|sh| sh.uniform :v,  1}
+    assert_equal [1, 0, 0, 1], draw['int',   'f(v,   1), 0.0,       0.0,       1.0']       {|sh| sh.uniform :v, [1]}
+    assert_equal [1, 1, 0, 1], draw['ivec2', 'f(v.x, 1), f(v.y, 2), 0.0,       1.0']       {|sh| sh.uniform :v,  1, 2}
+    assert_equal [1, 1, 0, 1], draw['ivec2', 'f(v.x, 1), f(v.y, 2), 0.0,       1.0']       {|sh| sh.uniform :v, [1, 2]}
+    assert_equal [1, 1, 1, 1], draw['ivec3', 'f(v.x, 1), f(v.y, 2), f(v.z, 3), 1.0']       {|sh| sh.uniform :v,  1, 2, 3}
+    assert_equal [1, 1, 1, 1], draw['ivec3', 'f(v.x, 1), f(v.y, 2), f(v.z, 3), 1.0']       {|sh| sh.uniform :v, [1, 2, 3]}
+    assert_equal [1, 1, 1, 1], draw['ivec4', 'f(v.x, 1), f(v.y, 2), f(v.z, 3), f(v.w, 4)'] {|sh| sh.uniform :v,  1, 2, 3, 4}
+    assert_equal [1, 1, 1, 1], draw['ivec4', 'f(v.x, 1), f(v.y, 2), f(v.z, 3), f(v.w, 4)'] {|sh| sh.uniform :v, [1, 2, 3, 4]}
+  end
+
+  def test_uniform_float()
+    draw = -> (type, color_string, &b) {
+      draw_shader(<<~END) {|shader| b.call shader}[0, 0].to_a
+        uniform #{type} v;
+        float f(float value, int div) {
+          return value / float(div);
+        }
+        void main() {
+          gl_FragColor = vec4(#{color_string});
+        }
+      END
+    }
+    assert_equal [1, 0, 0, 1], draw['float', 'f(v,   1), 0.0,       0.0,       1.0']       {|sh| sh.uniform :v,  1.0}
+    assert_equal [1, 0, 0, 1], draw['float', 'f(v,   1), 0.0,       0.0,       1.0']       {|sh| sh.uniform :v, [1.0]}
+    assert_equal [1, 1, 0, 1], draw['vec2',  'f(v.x, 1), f(v.y, 2), 0.0,       1.0']       {|sh| sh.uniform :v,  1.0, 2.0}
+    assert_equal [1, 1, 0, 1], draw['vec2',  'f(v.x, 1), f(v.y, 2), 0.0,       1.0']       {|sh| sh.uniform :v, [1.0, 2.0]}
+    assert_equal [1, 1, 1, 1], draw['vec3',  'f(v.x, 1), f(v.y, 2), f(v.z, 3), 1.0']       {|sh| sh.uniform :v,  1.0, 2.0, 3.0}
+    assert_equal [1, 1, 1, 1], draw['vec3',  'f(v.x, 1), f(v.y, 2), f(v.z, 3), 1.0']       {|sh| sh.uniform :v, [1.0, 2.0, 3.0]}
+    assert_equal [1, 1, 1, 1], draw['vec4',  'f(v.x, 1), f(v.y, 2), f(v.z, 3), f(v.w, 4)'] {|sh| sh.uniform :v,  1.0, 2.0, 3.0, 4.0}
+    assert_equal [1, 1, 1, 1], draw['vec4',  'f(v.x, 1), f(v.y, 2), f(v.z, 3), f(v.w, 4)'] {|sh| sh.uniform :v, [1.0, 2.0, 3.0, 4.0]}
+  end
+
+  def test_uniform_texture()
+    r, g, b = [[1, 0, 0], [0, 1, 0], [0, 0, 1]].map {|c| image {fill c; rect 10}}
+    assert_equal color(1, 1, 1, 1), draw_shader(<<~END, uniforms: {tex0: r, tex1: g, tex2: b})[0, 0]
+      uniform sampler2D tex0, tex1, tex2;
+      varying vec4 v_TexCoord;
+      void main() {
+        gl_FragColor = vec4(
+          texture2D(tex0, v_TexCoord.xy).r,
+          texture2D(tex1, v_TexCoord.xy).g,
+          texture2D(tex2, v_TexCoord.xy).b,
+          1.0);
+      }
+    END
+  end
+
+  def test_uniform_error()
+    ignore = -> bool {{ignore_no_uniform_location_error: bool}}
+
+    assert_raise(Rays::ShaderError) {draw_shader 'void main() {}',                         uniforms: {val: 1.0}}
+    assert_raise(Rays::ShaderError) {draw_shader 'void main() {}', options: ignore[false], uniforms: {val: 1.0}}
+    assert_nothing_raised           {draw_shader 'void main() {}', options: ignore[true],  uniforms: {val: 1.0}}
+  end
+
+  def test_shader_source()
+    assert_equal vshader, shader(fshader, vshader).vertex_shader_source
+    assert_equal fshader, shader(fshader, vshader).fragment_shader_source
+
+    assert_true shader(fshader).vertex_shader_source.then {|source|
+      %w[
+        a_Position a_TexCoord a_Color
+        v_Position v_TexCoord v_Color
+        u_PositionMatrix u_TexCoordMatrix
+      ].all? {|name| source.include? name}
+    }
+  end
+
+  def test_shader_env()
+    env = {
+      attribute_position:       'aP',
+      attribute_texcoord:       ['aTC', 'aTC2'],
+      attribute_color:          [],
+      varying_position:         'vP',
+      varying_texcoord:         nil,
+      #varying_color:           define nothing
+      uniform_position_matrix:  nil,
+      #uniform_texcoord_matrix: define nothing
+    }
+    assert_true shader(fshader, nil, env).vertex_shader_source.then {|source|
+      %w[
+        aP
+        aTC
+        a_Color
+        vP
+        v_TexCoord
+        v_Color
+        u_PositionMatrix
+        u_TexCoordMatrix
+      ].all? {|name| source.include? name}
+    }
+
+    assert_raise(ArgumentError) {shader(fshader, nil, {attribute_color: ''})}
+    assert_raise(ArgumentError) {shader(fshader, nil, {attribute_color: ['']})}
+    assert_raise(ArgumentError) {shader(fshader, nil, {attribute_color: [nil]})}
+    assert_raise(ArgumentError) {shader(fshader, nil, {attribute_color: ['C', '']})}
+    assert_raise(ArgumentError) {shader(fshader, nil, {attribute_color: ['C', nil]})}
+
+    assert_raise(ArgumentError) {shader(fshader, nil, {varying_color: ''})}
   end
 
 end# TestShader

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rays
 version: !ruby/object:Gem::Version
-  version: 0.1.27
+  version: 0.1.29
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-29 00:00:00.000000000 Z
+date: 2022-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xot
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.27
+        version: 0.1.29
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.27
+        version: 0.1.29
 - !ruby/object:Gem::Dependency
   name: rucy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.27
+        version: 0.1.29
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.27
+        version: 0.1.29
 description: This library helps you to develop graphics application with OpenGL.
 email: xordog@gmail.com
 executables: []
@@ -50,6 +50,7 @@ extra_rdoc_files:
 - ".doc/ext/rays/color.cpp"
 - ".doc/ext/rays/color_space.cpp"
 - ".doc/ext/rays/defs.cpp"
+- ".doc/ext/rays/exception.cpp"
 - ".doc/ext/rays/font.cpp"
 - ".doc/ext/rays/image.cpp"
 - ".doc/ext/rays/matrix.cpp"
@@ -69,6 +70,7 @@ files:
 - ".doc/ext/rays/color.cpp"
 - ".doc/ext/rays/color_space.cpp"
 - ".doc/ext/rays/defs.cpp"
+- ".doc/ext/rays/exception.cpp"
 - ".doc/ext/rays/font.cpp"
 - ".doc/ext/rays/image.cpp"
 - ".doc/ext/rays/matrix.cpp"
@@ -92,6 +94,7 @@ files:
 - ext/rays/color_space.cpp
 - ext/rays/defs.cpp
 - ext/rays/defs.h
+- ext/rays/exception.cpp
 - ext/rays/extconf.rb
 - ext/rays/font.cpp
 - ext/rays/image.cpp
@@ -131,6 +134,8 @@ files:
 - include/rays/ruby/camera.h
 - include/rays/ruby/color.h
 - include/rays/ruby/color_space.h
+- include/rays/ruby/defs.h
+- include/rays/ruby/exception.h
 - include/rays/ruby/font.h
 - include/rays/ruby/image.h
 - include/rays/ruby/matrix.h