rays 0.1.12 → 0.1.13

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'
+  s.add_runtime_dependency 'rucy', '~> 0.1'
 
   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

data/src/color_space.cpp

@@ -1,4 +1,4 @@
-#include "rays/color_space.h"
+#include "color_space.h"
 
 
 #include <assert.h>
@@ -13,13 +13,15 @@ namespace Rays
 	enum
 	{
 
-		FIRST        = GRAY_8,    LAST       = ABGR_float,
+		          FIRST = GRAY_8,              LAST = ABGR_float,
 
-		GRAY_FIRST   = GRAY_8,    GRAY_LAST  = GRAY_float,
+		     GRAY_FIRST = GRAY_8,         GRAY_LAST = GRAY_float,
 
-		RGB_FIRST    = RGB_888,   RGB_LAST   = ABGR_float,
+		    ALPHA_FIRST = ALPHA_8,       ALPHA_LAST = ALPHA_float,
 
-		FLOAT_SECOND = RGB_float, FLOAT_LAST = ABGR_float,
+		      RGB_FIRST = RGB_888,         RGB_LAST = ABGR_float,
+
+		RGB_FLOAT_FIRST = RGB_float, RGB_FLOAT_LAST = ABGR_float,
 
 	};
 
@@ -45,10 +47,13 @@ namespace Rays
 	{
 		static const int BPPS[] =
 		{
-			0,                            // UNKNOWN
-			8, 16, 24, 32, 32,            // GRAY
-			8, 8, 8, 8, 8, 8, 8, 8, 8, 8, // RGB(A), BGR(A)
-			32, 32, 32, 32, 32, 32,       // RGB(A), BGR(A) float
+			0,                 // UNKNOWN
+			8, 16, 24, 32, 32, // GRAY
+			8, 16, 24, 32, 32, // ALPHA
+			8, 8, 8, 8, 8,     // RGB(A),
+			8, 8, 8, 8, 8,     // BGR(A)
+			32, 32, 32,        // RGB(A) float
+			32, 32, 32,        // BGR(A) float
 		};
 		if (type_ < 0 || COLORSPACE_LAST <= type_) return BPPS[COLORSPACE_UNKNOWN];
 		return BPPS[type_];
@@ -67,6 +72,7 @@ namespace Rays
 		{
 			0,                     // UNKNOWN
 			8,  16, 24,  32,  32,  // GRAY
+			8,  16, 24,  32,  32,  // ALPHA
 			24, 32,  32,  32,  32, // RGB(A)
 			24, 32,  32,  32,  32, // BGR(A)
 			96, 128, 128,          // RGB(A) float
@@ -91,7 +97,13 @@ namespace Rays
 	bool
 	ColorSpace::is_gray () const
 	{
-		return GRAY_FIRST <= (int) type_ && (int) type_ <= GRAY_LAST;
+		return GRAY_FIRST  <= (int) type_ && (int) type_ <= GRAY_LAST;
+	}
+
+	bool
+	ColorSpace::is_alpha () const
+	{
+		return ALPHA_FIRST <= (int) type_ && (int) type_ <= ALPHA_LAST;
 	}
 
 	bool
@@ -114,14 +126,15 @@ namespace Rays
 	ColorSpace::is_float () const
 	{
 		return
-			type_ == GRAY_float ||
-			(FLOAT_SECOND <= (int) type_ && (int) type_ <= FLOAT_LAST);
+			type_ == GRAY_float || type_ == ALPHA_float ||
+			(RGB_FLOAT_FIRST <= (int) type_ && (int) type_ <= RGB_FLOAT_LAST);
 	}
 
 	bool
 	ColorSpace::has_alpha () const
 	{
 		return
+			(ALPHA_FIRST <= type_ && type_ <= ALPHA_LAST) ||
 			type_ == RGBA_8888  || type_ == ARGB_8888  ||
 			type_ == BGRA_8888  || type_ == ABGR_8888  ||
 			type_ == RGBA_float || type_ == ARGB_float ||
@@ -170,51 +183,56 @@ namespace Rays
 		return premult;
 	}
 
+	ColorSpace::operator bool () const
+	{
+		return FIRST <= (int) type_ && (int) type_ <= LAST;
+	}
+
+	bool
+	ColorSpace::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
 	void
-	ColorSpace::get_gl_enums (GLenum* format, GLenum* type, bool alpha_only) const
+	ColorSpace_get_gl_format_and_type (
+		GLenum* format, GLenum* type, const ColorSpace& cs)
 	{
 		if (!format && !type)
 			argument_error(__FILE__, __LINE__);
 
-		if (!*this)
+		if (!cs)
 			invalid_state_error(__FILE__, __LINE__);
 
 		if (format)
 		{
-			     if (is_rgb())  *format = has_alpha() ? GL_RGBA  : GL_RGB;
+			     if (cs.is_rgb())   *format = cs.has_alpha() ? GL_RGBA  : GL_RGB;
 		#ifndef IOS
-			else if (is_bgr())  *format = has_alpha() ? GL_BGRA  : GL_BGR;
+			else if (cs.is_bgr())   *format = cs.has_alpha() ? GL_BGRA  : GL_BGR;
 		#endif
-			else if (is_gray()) *format = alpha_only  ? GL_ALPHA : GL_LUMINANCE;
-			else rays_error(__FILE__, __LINE__, "invalid color space.");
+			else if (cs.is_gray())  *format = GL_LUMINANCE;
+			else if (cs.is_alpha()) *format = GL_ALPHA;
+			else
+				rays_error(__FILE__, __LINE__, "invalid color space.");
 		}
 
 		if (type)
 		{
-			if (is_float())
+			if (cs.is_float())
 				*type = GL_FLOAT;
-			else switch (bpc())
+			else switch (cs.bpc())
 			{
 				case 8:  *type = GL_UNSIGNED_BYTE; break;
 				case 16: *type = GL_UNSIGNED_SHORT; break;
 			#ifndef IOS
 				case 32: *type = GL_UNSIGNED_INT; break;
 			#endif
-				default: rays_error(__FILE__, __LINE__, "invalid bpc.");
+				default:
+					rays_error(__FILE__, __LINE__, "invalid bpc.");
 			}
 		}
 	}
 
-	ColorSpace::operator bool () const
-	{
-		return FIRST <= (int) type_ && (int) type_ <= LAST;
-	}
-
-	bool
-	ColorSpace::operator ! () const
-	{
-		return !operator bool();
-	}
-
 
 }// Rays