rays 0.1.12 → 0.1.17

data/lib/rays/point.rb

@@ -10,6 +10,7 @@ module Rays
   class Point
 
     include Comparable
+    include Enumerable
 
     def move_to (*args)
       dup.move_to! *args
@@ -19,6 +20,14 @@ module Rays
       dup.move_by! *args
     end
 
+    def zero? ()
+      length == 0
+    end
+
+    def each (&block)
+      to_a.each &block
+    end
+
     def to_a (dimension = 2)
       case dimension
       when 1 then [x]
@@ -28,20 +37,8 @@ module Rays
       end
     end
 
-    def + (*args)
-      op_add Point.from(*args)
-    end
-
-    def - (*args)
-      op_sub Point.from(*args)
-    end
-
-    def * (*args)
-      op_mult Point.from(*args)
-    end
-
-    def / (*args)
-      op_div Point.from(*args)
+    def to_s (dimension = 2)
+      to_a(dimension).to_s
     end
 
     def <=> (o)
@@ -50,13 +47,8 @@ module Rays
             z <=> o.z
     end
 
-    def self.from (*args)
-      case arg0 = args[0]
-      when Point   then arg0
-      when Array   then Point.new *arg0
-      when Numeric then Point.new arg0, arg0, arg0
-      else raise ArgumentError
-      end
+    def inspect ()
+      "#<Rays::Point #{to_a(3).join ', '}>"
     end
 
   end# Point

data/lib/rays/polygon.rb

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+
+
+require 'rays/ext'
+require 'rays/polyline'
+
+
+module Rays
+
+
+  class Polygon
+
+    include Enumerable
+
+    def initialize (*args, loop: true)
+      setup args, loop
+    end
+
+    def transform (matrix = nil, &block)
+      lines = to_a
+      lines = lines.map {|line| line.transform matrix} if matrix
+      lines = block.call lines if block
+      self.class.new *lines
+    end
+
+    def intersects (obj)
+      !(self & obj).empty?
+    end
+
+    def self.line (*args, loop: false)
+      new *args, loop: loop
+    end
+
+    def self.rect (
+      *args, round: nil, lt: nil, rt: nil, lb: nil, rb: nil, nsegment: nil)
+
+      create_rect args, round, lt, rt, lb, rb, nsegment
+    end
+
+    def self.ellipse (
+      *args, center: nil, radius: nil, hole: nil, from: nil, to: nil,
+      nsegment: nil)
+
+      create_ellipse args, center, radius, hole, from, to, nsegment
+    end
+
+    def self.curve (*args, loop: false)
+      create_curve args, loop
+    end
+
+    def self.bezier (*args, loop: false)
+      create_bezier args, loop
+    end
+
+  end# Polygon
+
+
+end# Rays

data/lib/rays/polygon_line.rb

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+
+require 'rays/ext'
+
+
+module Rays
+
+
+  class Polygon
+
+
+    class Line < Polyline
+
+      def initialize (*points, loop: true, hole: false)
+        setup points, loop, hole
+      end
+
+      def transform (matrix = nil, loop: loop?, hole: hole?, &block)
+        points = to_a
+        points = points.map {|point| matrix * point} if matrix
+        points = block.call points if block
+        self.class.new *points, loop: loop, hole: hole
+      end
+
+      def inspect ()
+        "#<Rays::Polygon::Line #{to_a.join ', '}, loop: #{loop?}, hole: #{hole?}>"
+      end
+
+    end# Line
+
+
+  end# Polygon
+
+
+end# Rays

data/lib/rays/polyline.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+
+require 'rays/ext'
+
+
+module Rays
+
+
+  class Polyline
+
+    include Enumerable
+
+    def initialize (*points, loop: false)
+      setup points, loop
+    end
+
+    def transform (matrix = nil, loop: loop?, &block)
+      points = to_a
+      points = points.map {|point| matrix * point} if matrix
+      points = block.call points if block
+      self.class.new *points, loop: loop
+    end
+
+    def inspect ()
+      "#<Rays::Polyline #{to_a.join ', '}, loop: #{loop?}>"
+    end
+
+  end# Polyline
+
+
+end# Rays

data/lib/rays/shader.rb

@@ -1,13 +1,32 @@
 # -*- coding: utf-8 -*-
 
 
+require 'xot/block_util'
 require 'rays/ext'
 
 
 module Rays
 
 
-  #class Shader
+  class Shader
+
+    def initialize (source = nil, **uniforms, &block)
+      if source
+        setup source
+        uniform **uniforms unless uniforms.empty?
+      end
+
+      Xot::BlockUtil.instance_eval_or_block_call self, &block if block
+    end
+
+    def uniform (name = nil, *args, **uniforms)
+      set_uniform name, *args if name
+      uniforms.each do |key, value|
+        set_uniform key, value
+      end
+    end
+
+  end# Shader
 
 
 end# Rays

data/rays.gemspec

@@ -21,17 +21,15 @@ Gem::Specification.new do |s|
   s.description = 'This library helps you to develop graphics application with OpenGL.'
   s.version     = mod.version
 
-  s.authors  = %w[snori]
-  s.email    = 'snori@xord.org'
+  s.authors  = %w[xordog]
+  s.email    = 'xordog@gmail.com'
   s.homepage = "https://github.com/xord/rays"
 
   s.platform              = Gem::Platform::RUBY
-  s.required_ruby_version = '>=1.9.0'
+  s.required_ruby_version = '~> 2'
 
-  s.add_runtime_dependency 'rake'
-  s.add_runtime_dependency 'xot'
-  s.add_runtime_dependency 'rucy'
-  s.add_development_dependency 'gemcutter'
+  s.add_runtime_dependency 'xot',  '~> 0.1.16'
+  s.add_runtime_dependency 'rucy', '~> 0.1.16'
 
   s.files            = `git ls-files`.split $/
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}

data/src/bitmap.h

@@ -0,0 +1,36 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_SRC_BITMAP_H__
+#define __RAYS_SRC_BITMAP_H__
+
+
+#include <rays/bitmap.h>
+
+
+namespace Rays
+{
+
+
+	class Texture;
+
+	class RawFont;
+
+
+	Bitmap Bitmap_from (const Texture& texture);
+
+	void Bitmap_draw_string (
+		Bitmap* bitmap, const RawFont& font, const char* str, coord x, coord y);
+
+	void Bitmap_set_modified (Bitmap* bitmap, bool modified = true);
+
+	bool Bitmap_get_modified (const Bitmap& bitmap);
+
+	void Bitmap_save (const Bitmap& bitmap, const char* path);
+
+	Bitmap Bitmap_load (const char* path);
+
+
+}// Rays
+
+
+#endif//EOH

data/src/bounds.cpp

@@ -1,6 +1,7 @@
 #include "rays/bounds.h"
 
 
+#include <float.h>
 #include <algorithm>
 #include "rays/exception.h"
 
@@ -293,6 +294,22 @@ namespace Rays
 		return z + d - 1;
 	}
 
+	void
+	Bounds::set_position (coord x, coord y, coord z)
+	{
+		this->x = x;
+		this->y = y;
+		this->z = z;
+	}
+
+	void
+	Bounds::set_position (const Point& position)
+	{
+		x = position.x;
+		y = position.y;
+		z = position.z;
+	}
+
 	Point&
 	Bounds::position ()
 	{
@@ -305,6 +322,20 @@ namespace Rays
 		return const_cast<This*>(this)->position();
 	}
 
+	void
+	Bounds::set_size (coord width, coord height, coord depth)
+	{
+		w = width;
+		h = height;
+		d = depth;
+	}
+
+	void
+	Bounds::set_size (const Point& size)
+	{
+		set_size(size.x, size.y, size.z);
+	}
+
 	Point&
 	Bounds::size ()
 	{
@@ -326,9 +357,9 @@ namespace Rays
 	}
 
 	void
-	Bounds::set_center (const Point& point)
+	Bounds::set_center (const Point& center)
 	{
-		set_center(point.x, point.y, point.z);
+		set_center(center.x, center.y, center.z);
 	}
 
 	Point
@@ -372,12 +403,15 @@ namespace Rays
 	Bounds&
 	Bounds::operator &= (const Bounds& rhs)
 	{
-		if (!*this || !rhs)
+		if (!rhs)
 			argument_error(__FILE__, __LINE__);
 
-		coord x = std::max(this->x, rhs.x);
-		coord y = std::max(this->y, rhs.y);
-		coord z = std::max(this->z, rhs.z);
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		coord x = std::max(this->x,           rhs.x);
+		coord y = std::max(this->y,           rhs.y);
+		coord z = std::max(this->z,           rhs.z);
 		coord w = std::min(this->x + this->w, rhs.x + rhs.w) - x;
 		coord h = std::min(this->y + this->h, rhs.y + rhs.h) - y;
 		coord d = std::min(this->z + this->d, rhs.z + rhs.d) - z;
@@ -392,12 +426,11 @@ namespace Rays
 	Bounds&
 	Bounds::operator |= (const Bounds& rhs)
 	{
-		if (!*this || !rhs)
-			argument_error(__FILE__, __LINE__);
+		if (!rhs) return *this;
 
-		coord x = std::min(this->x, rhs.x);
-		coord y = std::min(this->y, rhs.y);
-		coord z = std::min(this->z, rhs.z);
+		coord x = std::min(this->x,           rhs.x);
+		coord y = std::min(this->y,           rhs.y);
+		coord z = std::min(this->z,           rhs.z);
 		coord w = std::max(this->x + this->w, rhs.x + rhs.w) - x;
 		coord h = std::max(this->y + this->h, rhs.y + rhs.h) - y;
 		coord d = std::max(this->z + this->d, rhs.z + rhs.d) - z;
@@ -405,6 +438,19 @@ namespace Rays
 		return reset(x, y, z, w, h, d);
 	}
 
+	Bounds&
+	Bounds::operator |= (const Point& rhs)
+	{
+		coord x = std::min(this->x,           rhs.x);
+		coord y = std::min(this->y,           rhs.y);
+		coord z = std::min(this->z,           rhs.z);
+		coord w = std::max(this->x + this->w, rhs.x) - x;
+		coord h = std::max(this->y + this->h, rhs.y) - y;
+		coord d = std::max(this->z + this->d, rhs.z) - z;
+
+		return reset(x, y, z, w, h, d);
+	}
+
 	bool
 	operator == (const Bounds& lhs, const Bounds& rhs)
 	{
@@ -439,5 +485,22 @@ namespace Rays
 		return t;
 	}
 
+	Bounds
+	operator | (const Bounds& lhs, const Point& rhs)
+	{
+		Bounds t = lhs;
+		t |= rhs;
+		return t;
+	}
+
+
+	Bounds
+	invalid_bounds ()
+	{
+		coord max  =  FLT_MAX / 2;
+		coord size = -FLT_MAX;
+		return Bounds(max, max, max, size, size, size);
+	}
+
 
 }// Rays

data/src/color.cpp

@@ -2,44 +2,69 @@
 
 
 #include <limits.h>
+#include <glm/gtx/color_space.hpp>
 #include <xot/util.h>
 #include "rays/exception.h"
 #include "rays/color_space.h"
+#include "coord.h"
 
 
 namespace Rays
 {
 
 
-	Color::Color (float gray, float alpha)
+	Color
+	gray (float gray, float alpha)
 	{
-		reset(gray, alpha);
+		return Color(gray, alpha);
 	}
 
-	Color::Color (float red, float green, float blue, float alpha)
+	Color
+	gray8 (int gray, int alpha)
 	{
-		reset(red, green, blue, alpha);
+		Color c;
+		c.reset8(gray, alpha);
+		return c;
 	}
 
-	Color::Color (void* pixel, const ColorSpace& cs)
+	Color
+	rgb (float red, float green, float blue, float alpha)
 	{
-		reset(pixel, cs);
+		return Color(red, green, blue, alpha);
 	}
 
 	Color
-	Color8 (uchar gray, uchar alpha)
+	rgb8 (int red, int green, int blue, int alpha)
 	{
 		Color c;
-		c.reset8(gray, alpha);
+		c.reset8(red, green, blue, alpha);
 		return c;
 	}
 
 	Color
-	Color8 (uchar red, uchar green, uchar blue, uchar alpha)
+	hsv (float hue, float saturation, float value, float alpha)
 	{
-		Color c;
-		c.reset8(red, green, blue, alpha);
-		return c;
+		hue = fmod(hue, 1.f);
+		if (hue < 0) hue += 1.f;
+
+		auto c = glm::rgbColor(Vec3(hue * 360.f, saturation, value));
+		return Color(c[0], c[1], c[2], alpha);
+	}
+
+
+	Color::Color (float gray, float alpha)
+	{
+		reset(gray, alpha);
+	}
+
+	Color::Color (float red, float green, float blue, float alpha)
+	{
+		reset(red, green, blue, alpha);
+	}
+
+	Color::Color (void* pixel, const ColorSpace& cs)
+	{
+		reset(pixel, cs);
 	}
 
 	Color
@@ -57,15 +82,12 @@ namespace Rays
 	Color&
 	Color::reset (float red, float green, float blue, float alpha)
 	{
-		this->red   = red;
-		this->green = green;
-		this->blue  = blue;
-		this->alpha = alpha;
+		Super::reset(red, green, blue, alpha);
 		return *this;
 	}
 
 	Color&
-	Color::reset8 (uchar gray, uchar alpha)
+	Color::reset8 (int gray, int alpha)
 	{
 		float g = uchar2float(gray);
 		float a = uchar2float(alpha);
@@ -73,12 +95,13 @@ namespace Rays
 	}
 
 	Color&
-	Color::reset8 (uchar red, uchar green, uchar blue, uchar alpha)
+	Color::reset8 (int red, int green, int blue, int alpha)
 	{
-		this->red   = uchar2float(red);
-		this->green = uchar2float(green);
-		this->blue  = uchar2float(blue);
-		this->alpha = uchar2float(alpha);
+		Super::reset(
+			uchar2float(red),
+			uchar2float(green),
+			uchar2float(blue),
+			uchar2float(alpha));
 		return *this;
 	}
 
@@ -211,7 +234,7 @@ namespace Rays
 
 	Color::operator bool () const
 	{
-		return red >= 0 && green >= 0 && blue >= 0 && alpha >= 0;
+		return alpha > 0;
 	}
 
 	bool
@@ -220,5 +243,17 @@ namespace Rays
 		return !operator bool();
 	}
 
+	bool
+	operator == (const Color& lhs, const Color& rhs)
+	{
+		return lhs.r == rhs.r && lhs.g == rhs.g && lhs.b == rhs.b && lhs.a == rhs.a;
+	}
+
+	bool
+	operator != (const Color& lhs, const Color& rhs)
+	{
+		return !operator==(lhs, rhs);
+	}
+
 
 }// Rays