rays 0.1.1

data/ChangeLog

@@ -0,0 +1,8 @@
+2011-08-28 snori <snori@xord.org>
+
+	* v0.1.1
+
+
+2011-06-03 snori <snori@xord.org>
+
+	* delete Gemfile.

data/README

@@ -0,0 +1,4 @@
+
+= Rays - A Drawing Engine using OpenGL
+
+== by snori@xord.org

data/Rakefile

@@ -0,0 +1,72 @@
+# -*- mode: ruby; coding: utf-8 -*-
+
+
+$: << File.expand_path(File.dirname __FILE__)
+%w[../rucy/lib ../rays/lib].each do |path|
+  $: << File.expand_path(File.join File.dirname(__FILE__), *path.split('/'))
+end
+
+require 'rubygems'
+require 'rbconfig'
+require 'support'
+require 'rays/module'
+
+
+NAME = 'rays'
+
+SRCDIR  = 'src'
+INCDIR  = 'include'
+LIBDIR  = 'lib'
+EXTDIR  = 'ext'
+TASKDIR = 'task'
+
+EXTEXT = RbConfig::CONFIG['DLEXT'] || 'so'
+
+DEFS  = %w[]
+DEFS << 'WIN32' if win32?
+DEFS << 'COCOA' if cocoa?
+
+incroot = RbConfig::CONFIG['rubyhdrdir']
+INCDIRS = Rays.include_dirs + [
+  incroot,
+  "#{incroot}/#{RUBY_PLATFORM}",
+  '/opt/local/include',
+  '/opt/include'
+]
+
+RUBY    = ENV['RUBY'] || 'ruby'
+GEM     = ENV['GEM']  || 'gem'
+GIT     = ENV['GIT']  || 'git'
+MAKE    = ENV['MAKE'] || 'make'
+CC      = RbConfig::CONFIG['CC'] || ENV['CC'] || 'g++'
+CFLAGS  = '-Wall -O' + DEFS.map{|s| " -D#{s}"}.join
+AR      = ENV['AR'] || 'ar'
+ARFLAGS = 'crs'
+
+
+task :default => :build
+
+task :build => :ext
+
+task :rebuild => [:clean, :build]
+
+task :lib => 'lib:build'
+
+task :ext => 'ext:build'
+
+task :gem => 'gem:build'
+
+task :install => 'gem:install'
+
+task :uninstall => 'gem:uninstall'
+
+task :clean => ['lib:clean', 'ext:clean', 'gem:clean']
+
+task :test => :ext do
+  Dir['test/**/test_*.rb'].each do |rb|
+    sh %( ruby #{rb} )
+  end
+end
+
+
+Dir["#{TASKDIR}/**/*.rake"].each {|path| load path}

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/ext/rays/bitmap.cpp

@@ -0,0 +1,322 @@
+#include "rays/ruby/bitmap.h"
+
+
+#include <rucy.h>
+#include "rays.h"
+
+
+using namespace Rucy;
+
+using Rays::uchar;
+using Rays::ushort;
+using Rays::ulong;
+using Rays::coord;
+
+
+namespace Rays
+{
+
+
+	Class
+	bitmap_class ()
+	{
+		static Class c = rays_module().define_class("Bitmap");
+		return c;
+	}
+
+
+}// Rays
+
+
+namespace Rucy
+{
+
+
+	Value
+	value (const Rays::Bitmap& bitmap)
+	{
+		return new_type<Rays::Bitmap>(
+			Rays::bitmap_class(), new Rays::Bitmap(bitmap));
+	}
+
+
+}// Rucy
+
+
+#define this to<Rays::Bitmap*>(self)
+
+#define CHECK CHECK_OBJECT(self, Rays::Bitmap, Rays::bitmap_class())
+
+
+static
+RUBY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Rays::Bitmap>(klass, new Rays::Bitmap);
+}
+RUBY_END
+
+static
+RUBY_DEFN(initialize)
+{
+	CHECK_OBJ(self, Rays::Bitmap, Rays::bitmap_class());
+	if (argc != 0 && argc != 2 && argc != 3)
+		arg_count_error("Bitmap#initialize", argc, 0, 2, 3);
+
+	if (argc == 0) return self;
+
+	int width  = to<int>(argv[0]);
+	int height = to<int>(argv[1]);
+	uint colorspace = (argc == 3) ? to<uint>(argv[2]) : (uint) Rays::RGBA;
+
+	*this = Rays::Bitmap(width, height, (Rays::ColorSpaceType) colorspace);
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(width)
+{
+	CHECK;
+
+	return value(this->width());
+}
+RUBY_END
+
+static
+RUBY_DEF0(height)
+{
+	CHECK;
+
+	return value(this->height());
+}
+RUBY_END
+
+static
+RUBY_DEF0(color_space)
+{
+	CHECK;
+
+	return value(this->color_space().type());
+}
+RUBY_END
+
+static
+RUBY_DEF2(at, x, y)
+{
+	CHECK;
+
+	int xx = x.as_i(), yy = y.as_i();
+	void* pixel = this->at<void*>(xx, yy);
+	if (!pixel) error("Bitmap#at(%d, %d) failed.", xx, yy);
+
+	Value array(this->color_space().Bpp() / this->color_space().Bpc(), NULL);
+	if (this->color_space().is_float())
+	{
+		float* p = (float*) pixel;
+		switch (this->color_space().type())
+		{
+			case Rays::GRAY_float:
+				array.push(p[0]);
+				break;
+			case Rays::RGB_float:
+				array.push(p[0]).push(p[1]).push(p[2]);
+				break;
+			case Rays::RGBA_float:
+				array.push(p[0]).push(p[1]).push(p[2]).push(p[3]);
+				break;
+			case Rays::ARGB_float:
+				array.push(p[1]).push(p[2]).push(p[3]).push(p[0]);
+				break;
+			case Rays::BGR_float:
+				array.push(p[2]).push(p[1]).push(p[0]);
+				break;
+			case Rays::BGRA_float:
+				array.push(p[2]).push(p[1]).push(p[0]).push(p[3]);
+				break;
+			case Rays::ABGR_float:
+				array.push(p[3]).push(p[2]).push(p[1]).push(p[0]);
+				break;
+			default:
+				error("Bitmap#at: unknown color space");
+		}
+	}
+	else
+	{
+		uchar* p = (uchar*) pixel;
+		switch (this->color_space().type())
+		{
+			case Rays::GRAY_8:
+				array.push(*(uchar*) pixel);
+				break;
+			case Rays::GRAY_16:
+				array.push(*(ushort*) pixel);
+				break;
+			case Rays::GRAY_32:
+				array.push(*(ulong*) pixel);
+				break;
+			case Rays::RGB_888:
+				array.push(p[0]).push(p[1]).push(p[2]);
+				break;
+			case Rays::RGBA_8888:
+				array.push(p[0]).push(p[1]).push(p[2]).push(p[3]);
+				break;
+			case Rays::ARGB_8888:
+				array.push(p[1]).push(p[2]).push(p[3]).push(p[0]);
+				break;
+			case Rays::RGBX_8888:
+				array.push(p[0]).push(p[1]).push(p[2]);
+				break;
+			case Rays::XRGB_8888:
+				array.push(p[1]).push(p[2]).push(p[3]);
+				break;
+			case Rays::BGR_888:
+				array.push(p[2]).push(p[1]).push(p[0]);
+				break;
+			case Rays::BGRA_8888:
+				array.push(p[2]).push(p[1]).push(p[0]).push(p[3]);
+				break;
+			case Rays::ABGR_8888:
+				array.push(p[3]).push(p[2]).push(p[1]).push(p[0]);
+				break;
+			case Rays::BGRX_8888:
+				array.push(p[2]).push(p[1]).push(p[0]);
+				break;
+			case Rays::XBGR_8888:
+				array.push(p[3]).push(p[2]).push(p[1]);
+				break;
+			default:
+				error("Bitmap#at: unknown color space");
+		}
+	}
+
+	return array;
+}
+RUBY_END
+
+static
+RUBY_DEF3(assign_at, x, y, color)
+{
+	CHECK;
+
+	int xx = x.as_i(), yy = y.as_i();
+	void* pixel = this->at<void*>(xx, yy);
+	if (!pixel) error("Bitmap#assign_at(%d, %d) failed.", xx, yy);
+
+	Value array(this->color_space().Bpp() / this->color_space().Bpc(), NULL);
+	if (this->color_space().is_float())
+	{
+		float* p = (float*) pixel;
+		switch (this->color_space().type())
+		{
+			#define C(n) ((float) color[n].as_f())
+			case Rays::GRAY_float:
+				p[0] = C(0);
+				break;
+			case Rays::RGB_float:
+				p[0] = C(0); p[1] = C(1); p[2] = C(2);
+				break;
+			case Rays::RGBA_float:
+				p[0] = C(0); p[1] = C(1); p[2] = C(2); p[3] = C(3);
+				break;
+			case Rays::ARGB_float:
+				p[0] = C(1); p[1] = C(2); p[2] = C(3); p[3] = C(0);
+				break;
+			case Rays::BGR_float:
+				p[0] = C(2); p[1] = C(1); p[2] = C(0);
+				break;
+			case Rays::BGRA_float:
+				p[0] = C(2); p[1] = C(1); p[2] = C(0); p[3] = C(3);
+				break;
+			case Rays::ABGR_float:
+				p[0] = C(3); p[1] = C(2); p[2] = C(1); p[3] = C(0);
+				break;
+			#undef C
+			default:
+				error("Bitmap#at: unknown color space");
+		}
+	}
+	else
+	{
+		uchar* p = (uchar*) pixel;
+		switch (this->color_space().type())
+		{
+			#define C(n) ((uchar) color[n].as_i())
+			case Rays::GRAY_8:
+				*(uchar*) pixel = C(0);
+				break;
+			case Rays::GRAY_16:
+				*(ushort*) pixel = C(0);
+				break;
+			case Rays::GRAY_32:
+				*(ulong*) pixel = C(0);
+				break;
+			case Rays::RGB_888:
+				p[0] = C(0); p[1] = C(1); p[2] = C(2);
+				break;
+			case Rays::RGBA_8888:
+				p[0] = C(0); p[1] = C(1); p[2] = C(2); p[3] = C(3);
+				break;
+			case Rays::ARGB_8888:
+				p[0] = C(1); p[1] = C(2); p[2] = C(3); p[3] = C(0);
+				break;
+			case Rays::RGBX_8888:
+				p[0] = C(0); p[1] = C(1); p[2] = C(2);
+				break;
+			case Rays::XRGB_8888:
+				p[0] = C(1); p[1] = C(2); p[2] = C(3);
+				break;
+			case Rays::BGR_888:
+				p[0] = C(2); p[1] = C(1); p[2] = C(0);
+				break;
+			case Rays::BGRA_8888:
+				p[0] = C(2); p[1] = C(1); p[2] = C(0); p[3] = C(3);
+				break;
+			case Rays::ABGR_8888:
+				p[0] = C(3); p[1] = C(2); p[2] = C(1); p[3] = C(0);
+				break;
+			case Rays::BGRX_8888:
+				p[0] = C(2); p[1] = C(1); p[2] = C(0);
+				break;
+			case Rays::XBGR_8888:
+				p[0] = C(3); p[1] = C(2); p[2] = C(1);
+				break;
+			#undef C
+			default:
+				error("Bitmap#at: unknown color space");
+		}
+	}
+
+	return color;
+}
+RUBY_END
+
+
+static
+RUBY_DEF1(load, path)
+{
+	Rays::Bitmap bmp;
+	if (!Rays::load_bitmap(&bmp, path.c_str()))
+		error("Bitmap.load('%s') failed.", path.c_str());
+
+	return value(bmp);
+}
+RUBY_END
+
+
+void
+Init_bitmap ()
+{
+	Rays::rays_module()
+		.define_const("RGB", Rays::RGB)
+		.define_const("RGBA", Rays::RGBA);
+
+	Rays::bitmap_class()
+		.define_alloc_func(alloc)
+		.define_method("initialize", initialize)
+		.define_method("width", width)
+		.define_method("height", height)
+		.define_method("color_space", color_space)
+		.define_method("[]", at)
+		.define_method("[]=", assign_at)
+		.define_function("load", load);
+}

data/ext/rays/extconf.rb

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+
+
+%w[../../../rucy/lib ../../lib].each do |path|
+  $: << File.expand_path(File.join File.dirname(__FILE__), *path.split('/'))
+end
+
+require 'rubygems'
+require 'mkmf'
+require 'rucy/module'
+require 'rays/module'
+
+
+DEBUG = ENV['DEBUG'] || false
+
+DEFS    = []
+INCDIRS = %w[/opt/local/include /opt/include] +
+  Rucy.include_dirs + Rays.include_dirs
+LIBDIRS = %w[] +
+  Rucy.library_dirs + Rays.library_dirs
+
+HEADERS    = %w[
+  boost/scoped_array.hpp
+  boost/shared_ptr.hpp
+  ruby.h
+  rucy.h
+  rays.h
+]
+LIBS       = %w[stdc++ rucy rays]
+FRAMEWORKS = %w[]
+
+
+DEFS << '_DEBUG' if DEBUG
+
+case RUBY_PLATFORM
+when /mswin|ming|cygwin/
+  DEFS << 'WINDOWS' << 'WIN32' << $~[0].upcase
+  LIBS.unshift 'gdi32', 'opengl32'
+when /darwin/
+  DEFS << 'COCOA'
+  FRAMEWORKS << 'AppKit' << 'OpenGL'
+end
+
+$CPPFLAGS   << DEFS.map       {|s| " -D#{s}"}.join
+$CPPFLAGS   << INCDIRS.map    {|s| " -I#{s}"}.join
+$LDFLAGS    << LIBDIRS.map    {|s| " -L#{s}"}.join
+$LDFLAGS    << FRAMEWORKS.map {|s| " -framework #{s}"}.join
+$LOCAL_LIBS << ' -lrucy'
+
+dir_config 'boost'
+dir_config 'rucy', Rucy.root_dir
+dir_config 'rays', Rays.root_dir
+
+
+Config::CONFIG.each {|key, val| val.gsub!(/gcc/, 'g++')}
+
+exit 1 unless HEADERS.all? {|s| have_header(s)}
+exit 1 unless LIBS.all?    {|s| have_library(s)}
+
+
+create_makefile 'rays/native'