rays 0.1.3 → 0.1.4

data/include/rays/point.h

@@ -0,0 +1,39 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_POINT_H__
+#define __RAYS_POINT_H__
+
+
+#include <rays/defs.h>
+
+
+namespace Rays
+{
+
+
+	struct Point
+	{
+
+		coord x, y, z;
+
+		Point (coord value = 0);
+
+		Point (coord x, coord y, coord z = 0);
+
+		Point dup () const;
+
+		Point& set (coord value = 0);
+
+		Point& set (coord x, coord y, coord z = 0);
+
+		      coord* array ();
+
+		const coord* array () const;
+
+	};// Point
+
+
+}// Rays
+
+
+#endif//EOH

data/include/rays/ruby.h

@@ -5,6 +5,9 @@
 
 
 #include <rays/ruby/rays.h>
+#include <rays/ruby/point.h>
+#include <rays/ruby/bounds.h>
+#include <rays/ruby/color.h>
 #include <rays/ruby/bitmap.h>
 #include <rays/ruby/texture.h>
 #include <rays/ruby/image.h>

data/include/rays/ruby/bitmap.h

@@ -24,12 +24,14 @@ namespace Rucy
 {
 
 
-	Value value (const Rays::Bitmap& bitmap);
+	Value value (const Rays::Bitmap& obj);
+
+	Value value (const Rays::Bitmap* obj);
 
 	template <> inline Rays::Bitmap*
-	value_to<Rays::Bitmap*> (Value obj, bool convert)
+	value_to<Rays::Bitmap*> (Value val, bool)
 	{
-		return get_type<Rays::Bitmap>(obj, Rays::bitmap_class());
+		return get_type_ptr<Rays::Bitmap>(val, Rays::bitmap_class());
 	}
 
 

data/include/rays/ruby/bounds.h

@@ -0,0 +1,41 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_RUBY_BOUNDS_H__
+#define __RAYS_RUBY_BOUNDS_H__
+
+
+#include <rucy/rucy.h>
+#include <rucy/class.h>
+#include <rays/bounds.h>
+
+
+namespace Rays
+{
+
+
+	Rucy::Class bounds_class ();
+	// class Rays::Bounds
+
+
+}// Rays
+
+
+namespace Rucy
+{
+
+
+	Value value (const Rays::Bounds& obj);
+
+	Value value (const Rays::Bounds* obj);
+
+	template <> inline Rays::Bounds*
+	value_to<Rays::Bounds*> (Value val, bool)
+	{
+		return get_type_ptr<Rays::Bounds>(val, Rays::bounds_class());
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/rays/ruby/color.h

@@ -0,0 +1,41 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_RUBY_COLOR_H__
+#define __RAYS_RUBY_COLOR_H__
+
+
+#include <rucy/rucy.h>
+#include <rucy/class.h>
+#include <rays/color.h>
+
+
+namespace Rays
+{
+
+
+	Rucy::Class color_class ();
+	// class Rays::Color
+
+
+}// Rays
+
+
+namespace Rucy
+{
+
+
+	Value value (const Rays::Color& obj);
+
+	Value value (const Rays::Color* obj);
+
+	template <> inline Rays::Color*
+	value_to<Rays::Color*> (Value val, bool)
+	{
+		return get_type_ptr<Rays::Color>(val, Rays::color_class());
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/rays/ruby/font.h

@@ -24,12 +24,14 @@ namespace Rucy
 {
 
 
-	Value value (const Rays::Font& font);
+	Value value (const Rays::Font& obj);
+
+	Value value (const Rays::Font* obj);
 
 	template <> inline Rays::Font*
-	value_to<Rays::Font*> (Value obj, bool convert)
+	value_to<Rays::Font*> (Value val, bool)
 	{
-		return get_type<Rays::Font>(obj, Rays::font_class());
+		return get_type_ptr<Rays::Font>(val, Rays::font_class());
 	}
 
 

data/include/rays/ruby/image.h

@@ -24,12 +24,14 @@ namespace Rucy
 {
 
 
-	Value value (const Rays::Image& image);
+	Value value (const Rays::Image& obj);
+
+	Value value (const Rays::Image* obj);
 
 	template <> inline Rays::Image*
-	value_to<Rays::Image*> (Value obj, bool convert)
+	value_to<Rays::Image*> (Value val, bool)
 	{
-		return get_type<Rays::Image>(obj, Rays::image_class());
+		return get_type_ptr<Rays::Image>(val, Rays::image_class());
 	}
 
 

data/include/rays/ruby/matrix.h

@@ -0,0 +1,41 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_RUBY_MATRIX_H__
+#define __RAYS_RUBY_MATRIX_H__
+
+
+#include <rucy/rucy.h>
+#include <rucy/class.h>
+#include <rays/matrix.h>
+
+
+namespace Rays
+{
+
+
+	Rucy::Class matrix_class ();
+	// class Rays::Matrix
+
+
+}// Rays
+
+
+namespace Rucy
+{
+
+
+	Value value (const Rays::Matrix& obj);
+
+	Value value (const Rays::Matrix* obj);
+
+	template <> inline Rays::Matrix*
+	value_to<Rays::Matrix*> (Value val, bool)
+	{
+		return get_type_ptr<Rays::Matrix>(val, Rays::matrix_class());
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/rays/ruby/painter.h

@@ -24,12 +24,14 @@ namespace Rucy
 {
 
 
-	Value value (const Rays::Painter& painter);
+	Value value (const Rays::Painter& obj);
+
+	Value value (const Rays::Painter* obj);
 
 	template <> inline Rays::Painter*
-	value_to<Rays::Painter*> (Value obj, bool convert)
+	value_to<Rays::Painter*> (Value val, bool)
 	{
-		return get_type<Rays::Painter>(obj, Rays::painter_class());
+		return get_type_ptr<Rays::Painter>(val, Rays::painter_class());
 	}
 
 

data/include/rays/ruby/point.h

@@ -0,0 +1,41 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_RUBY_POINT_H__
+#define __RAYS_RUBY_POINT_H__
+
+
+#include <rucy/rucy.h>
+#include <rucy/class.h>
+#include <rays/point.h>
+
+
+namespace Rays
+{
+
+
+	Rucy::Class point_class ();
+	// class Rays::Point
+
+
+}// Rays
+
+
+namespace Rucy
+{
+
+
+	Value value (const Rays::Point& obj);
+
+	Value value (const Rays::Point* obj);
+
+	template <> inline Rays::Point*
+	value_to<Rays::Point*> (Value val, bool)
+	{
+		return get_type_ptr<Rays::Point>(val, Rays::point_class());
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/rays/ruby/texture.h

@@ -24,12 +24,14 @@ namespace Rucy
 {
 
 
-	Value value (const Rays::Texture& texture);
+	Value value (const Rays::Texture& obj);
+
+	Value value (const Rays::Texture* obj);
 
 	template <> inline Rays::Texture*
-	value_to<Rays::Texture*> (Value obj, bool convert)
+	value_to<Rays::Texture*> (Value val, bool)
 	{
-		return get_type<Rays::Texture>(obj, Rays::texture_class());
+		return get_type_ptr<Rays::Texture>(val, Rays::texture_class());
 	}
 
 

data/include/rays/texture.h

@@ -4,9 +4,9 @@
 #define __RAYS_TEXTURE_H__
 
 
+#include <xot/pimpl.h>
 #include <rays/defs.h>
 #include <rays/opengl.h>
-#include <rays/helpers.h>
 
 
 namespace Rays
@@ -33,6 +33,10 @@ namespace Rays
 
 			int height () const;
 
+			float s (float x) const;
+
+			float t (float y) const;
+
 			float s_max () const;
 
 			float t_max () const;
@@ -45,7 +49,7 @@ namespace Rays
 
 			struct Data;
 
-			Impl<Data> self;
+			Xot::PImpl<Data, true> self;
 
 	};// Texture
 

data/lib/rays.rb

@@ -3,6 +3,9 @@
 
 require 'rays/autoinit'
 require 'rays/module'
+require 'rays/point'
+require 'rays/bounds'
+require 'rays/color'
 require 'rays/bitmap'
 require 'rays/texture'
 require 'rays/image'

data/lib/rays/autoinit.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 
-require 'rays/native'
+require 'rays/ext'
 
 
 unless $RAYS_NOAUTOINIT

data/lib/rays/bitmap.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 
-require 'rays/native'
+require 'rays/ext'
 
 
 module Rays
@@ -11,6 +11,16 @@ module Rays
 
     include Enumerable
 
+    def initialize (width, height, colorspace = RGBA)
+      colorspace = case colorspace
+      when :GRAY then GRAY
+      when :RGB  then RGB
+      when :RGBA then RGBA
+      else colorspace
+      end
+      setup width, height, colorspace
+    end
+
     def each ()
       height.times do |y|
         width.times do |x|
@@ -19,6 +29,10 @@ module Rays
       end
     end
 
+    def size ()
+      [width, height]
+    end
+
   end# Bitmap
 
 

data/lib/rays/bounds.rb

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+
+
+require 'rays/ext'
+require 'rays/point'
+
+
+module Rays
+
+
+  class Bounds
+
+    include Comparable
+
+    alias w  width
+    alias w= width=
+
+    alias h  height
+    alias h= height=
+
+    alias d  depth
+    alias d= depth=
+
+    alias pos  position
+    alias pos= position=
+
+    def move_to! (*args)
+      case args.size
+      when 1 then self.x = self.y = args[0]
+      when 2 then self.x, self.y = args
+      when 3 then self.x, self.y, self.z = args
+      else raise ArgumentError
+      end
+      self
+    end
+
+    def move_to (*args)
+      dup.move_to! *args
+    end
+
+    def move_by! (*args)
+      case args.size
+      when 1 then self.x += args[0]; self.y += args[0]
+      when 2 then self.x += args[0]; self.y += args[1]
+      when 3 then self.x += args[0]; self.y += args[1]; self.z += args[2]
+      else raise ArgumentError
+      end
+      self
+    end
+
+    def move_by (*args)
+      dup.move_by! *args
+    end
+
+    def resize_to! (*args)
+      case args.size
+      when 1 then self.w = self.h = args[0]
+      when 2 then self.w, self.h = args
+      when 3 then self.w, self.h, self.d = args
+      else raise ArgumentError
+      end
+      self
+    end
+
+    def resize_to (*args)
+      dup.resize_to! *args
+    end
+
+    def resize_by! (*args)
+      case args.size
+      when 1 then self.w += args[0]; self.h += args[0]
+      when 2 then self.w += args[0]; self.h += args[1]
+      when 3 then self.w += args[0]; self.h += args[1]; self.d += args[2]
+      else raise ArgumentError
+      end
+      self
+    end
+
+    def resize_by (*args)
+      dup.resize_by! *args
+    end
+
+    def inset_by! (*args)
+      move_by! *args
+      resize_by! *args.map {|n| -n * 2}
+      self
+    end
+
+    def inset_by (*args)
+      dup.inset_by! *args
+    end
+
+    def center ()
+      Point.new (x + w / 2).round, (y + h / 2).round
+    end
+
+    def to_a (dimension = 2)
+      case dimension
+      when 1 then [x, w]
+      when 2 then [x, y, w, h]
+      when 3 then [x, y, z, w, h, d]
+      else raise ArgumentError
+      end
+    end
+
+    def [] (index)
+      case index
+      when 0 then Point.new(left,  top,    back)
+      when 1 then Point.new(right, bottom, front)
+      else raise IndexError
+      end
+    end
+
+    def []= (index, point)
+      case index
+      when 0 then self.left,  self.top,    self.back  = point.to_a(3)
+      when 1 then self.right, self.bottom, self.front = point.to_a(3)
+      else raise IndexError
+      end
+    end
+
+    def <=> (o)
+      ret = x <=> o.x; return ret if ret != 0
+      ret = y <=> o.y; return ret if ret != 0
+      ret = z <=> o.z; return ret if ret != 0
+      ret = w <=> o.w; return ret if ret != 0
+      ret = h <=> o.h; return ret if ret != 0
+            d <=> o.d
+    end
+
+    def inspect ()
+      "#<Rays::Bounds x=#{x}, y=#{y}, z=#{z}, width=#{w}, height=#{h}, depth=#{d}>"
+    end
+
+  end# Bounds
+
+
+end# Rays