rays 0.1.1

data/ext/rays/rays.cpp

@@ -0,0 +1,61 @@
+#include <rucy.h>
+#include <rays/rays.h>
+#include "rays.h"
+
+
+using namespace Rucy;
+
+
+namespace Rays
+{
+
+
+	Module
+	rays_module ()
+	{
+		static Module m = define_module("Rays");
+		return m;
+	}
+
+	Class
+	rays_error_class ()
+	{
+		static Class c =
+			rays_module().define_class("RaysError", native_error_class());
+		return c;
+	}
+
+
+}// Rays
+
+
+static
+RUBY_DEF0(init)
+{
+	if (!Rays::init())
+		error("Rays::init() failed.");
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(fin)
+{
+	if (!Rays::fin())
+		error("Rays::fin() failed.");
+
+	return self;
+}
+RUBY_END
+
+
+void
+Init_rays ()
+{
+	Rays::rays_error_class();
+
+	Rays::rays_module()
+		.define_singleton_method("init!", init)
+		.define_singleton_method("fin!", fin);
+}

data/ext/rays/rays.h

@@ -0,0 +1,39 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_EXT_RAYS_H__
+#define __RAYS_EXT_RAYS_H__
+
+
+#include <rucy/class.h>
+#include "rays/ruby/rays.h"
+
+
+namespace Rays
+{
+
+
+	Rucy::Class rays_error_class ();
+	// class Rays::RaysError < Rucy::NativeError
+
+
+}// Rays
+
+
+#define CHECK_OBJ(obj, type, klass) \
+	do \
+	{ \
+		type* p = Rucy::get_type<type>(obj, klass); \
+		if (!p) Rucy::invalid_object_error(); \
+	} \
+	while(0)
+
+#define CHECK_OBJECT(obj, type, klass) \
+	do \
+	{ \
+		type* p = Rucy::get_type<type>(obj, klass); \
+		if (!p || !*p) Rucy::invalid_object_error(); \
+	} \
+	while(0)
+
+
+#endif//EOH

data/ext/rays/texture.cpp

@@ -0,0 +1,130 @@
+#include "rays/ruby/texture.h"
+
+
+#include <rucy.h>
+#include "rays.h"
+#include "rays/ruby/bitmap.h"
+
+
+using namespace Rucy;
+
+using Rays::coord;
+
+
+namespace Rays
+{
+
+
+	Class
+	texture_class ()
+	{
+		static Class c = rays_module().define_class("Texture");
+		return c;
+	}
+
+
+}// Rays
+
+
+namespace Rucy
+{
+
+
+	Value
+	value (const Rays::Texture& texture)
+	{
+		return new_type<Rays::Texture>(
+			Rays::texture_class(), new Rays::Texture(texture));
+	}
+
+
+}// Rucy
+
+
+#define this to<Rays::Texture*>(self)
+
+#define CHECK CHECK_OBJECT(self, Rays::Texture, Rays::texture_class())
+
+
+static
+RUBY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Rays::Texture>(klass, new Rays::Texture);
+}
+RUBY_END
+
+static
+RUBY_DEFN(initialize)
+{
+	CHECK_OBJ(self, Rays::Texture, Rays::texture_class());
+	if (argc != 1 && argc != 2) arg_count_error("Texture#initialize", argc, 1, 2);
+
+	Rays::Bitmap* bitmap = to<Rays::Bitmap*>(argv[0]);
+	bool alphaonly = (argc == 2) ? to<bool>(argv[1]) : false;
+
+	if (!bitmap)
+		argument_error("%s is not a Bitmap object.", argv[0].inspect().c_str());
+
+	*this = Rays::Texture(*bitmap, alphaonly);
+	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(s_max)
+{
+	CHECK;
+
+	return value(this->s_max());
+}
+RUBY_END
+
+static
+RUBY_DEF0(t_max)
+{
+	CHECK;
+
+	return value(this->t_max());
+}
+RUBY_END
+
+static
+RUBY_DEF0(bitmap)
+{
+	CHECK;
+
+	return value(this->bitmap());
+}
+RUBY_END
+
+
+void
+Init_texture ()
+{
+	Rays::texture_class()
+		.define_alloc_func(alloc)
+		.define_method("initialize", initialize)
+		.define_method("width", width)
+		.define_method("height", height)
+		.define_method("s_max", s_max)
+		.define_method("t_max", t_max)
+		.define_method("bitmap", bitmap);
+}

data/include/rays.h

@@ -0,0 +1,20 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_H__
+#define __RAYS_H__
+
+
+#include <rays/defs.h>
+#include <rays/rays.h>
+#include <rays/colorspace.h>
+#include <rays/bitmap.h>
+#include <rays/texture.h>
+#include <rays/image.h>
+#include <rays/font.h>
+#include <rays/transform.h>
+#include <rays/painter.h>
+#include <rays/helpers.h>
+#include <rays/opengl.h>
+
+
+#endif//EOH

data/include/rays/bitmap.h

@@ -0,0 +1,80 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_BITMAP_H__
+#define __RAYS_BITMAP_H__
+
+
+#include <rays/defs.h>
+#include <rays/colorspace.h>
+#include <rays/font.h>
+#include <rays/helpers.h>
+
+
+namespace Rays
+{
+
+
+	class Bitmap
+	{
+
+		public:
+
+			Bitmap ();
+
+			Bitmap (int width, int height, const ColorSpace& cs = RGBA);
+
+			~Bitmap ();
+
+			int width () const;
+
+			int height () const;
+
+			const ColorSpace& color_space () const;
+
+			int pitch () const;
+
+			size_t size () const;
+
+			bool dirty () const;
+
+			void set_dirty (bool b = true);
+
+			      void* data ();
+
+			const void* data () const;
+
+			template <typename T>       T* at (int x, int y)
+			{
+				return (T*) (((char*) data()) + pitch() * y + x * color_space().Bpp());
+			}
+
+			template <typename T> const T* at (int x, int y) const
+			{
+				return const_cast<Bitmap*>(this)->at<T>(x, y);
+			}
+
+			operator bool () const;
+
+			bool operator ! () const;
+
+			struct Data;
+
+			Impl<Data> self;
+
+	};// Bitmap
+
+
+	bool load_bitmap (Bitmap* bitmap, const char* path);
+
+	bool save_bitmap (const Bitmap& bitmap, const char* path);
+
+
+	bool draw_string (
+		Bitmap* bitmap, const char* str,
+		coord x = 0, coord y = 0, const Font& font = default_font());
+
+
+}// Rays
+
+
+#endif//EOH

data/include/rays/colorspace.h

@@ -0,0 +1,101 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_COLOR_H__
+#define __RAYS_COLOR_H__
+
+
+#include <rays/defs.h>
+
+
+namespace Rays
+{
+
+
+	enum ColorSpaceType
+	{
+
+		COLORSPACE_UNKNOWN = UNKNOWN,
+
+		GRAY_8, GRAY_16, GRAY_24, GRAY_32, GRAY_float,
+
+		RGB_888, RGBA_8888, RGBX_8888, ARGB_8888, XRGB_8888,
+
+		BGR_888, BGRA_8888, BGRX_8888, ABGR_8888, XBGR_8888,
+
+		RGB_float, RGBA_float, ARGB_float,
+
+		BGR_float, BGRA_float, ABGR_float,
+
+		COLORSPACE_LAST,
+
+		GRAY = GRAY_8,
+
+		RGB  = RGB_888,   BGR  = BGR_888,
+
+		RGBA = RGBA_8888, RGBX = RGBX_8888, ARGB = ARGB_8888, XRGB = XRGB_8888,
+
+		BGRA = BGRA_8888, BGRX = BGRX_8888, ABGR = ABGR_8888, XBGR = XBGR_8888,
+
+	};// ColorSpaceType
+
+
+	class ColorSpace
+	{
+
+		public:
+
+			ColorSpace ();
+
+			ColorSpace (ColorSpaceType type, bool premultiplied = false);
+
+			ColorSpaceType type () const;
+
+			int bpc () const;
+
+			int Bpc () const;
+
+			int bpp () const;
+
+			int Bpp () const;
+
+			int alpha_pos () const;
+
+			bool is_gray () const;
+
+			bool is_rgb () const;
+
+			bool is_bgr () const;
+
+			bool is_float () const;
+
+			bool has_alpha () const;
+
+			bool has_skip () const;
+
+			bool is_alpha_first () const;
+
+			bool is_alpha_last () const;
+
+			bool is_skip_first () const;
+
+			bool is_skip_last () const;
+
+			bool is_premult () const;
+
+			operator bool () const;
+
+			bool operator ! () const;
+
+		private:
+
+			ColorSpaceType type_;
+
+			bool premult;
+
+	};// ColorSpace
+
+
+}// Rays
+
+
+#endif//EOH

data/include/rays/defs.h

@@ -0,0 +1,33 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_DEFS_H__
+#define __RAYS_DEFS_H__
+
+
+#include <string>
+
+
+namespace Rays
+{
+
+
+	typedef unsigned char  uchar;
+
+	typedef unsigned short ushort;
+
+	typedef unsigned int   uint;
+
+	typedef unsigned long  ulong;
+
+	typedef float coord;
+
+	typedef std::string String;
+
+
+	enum {UNKNOWN = 0};
+
+
+}// Rays
+
+
+#endif//EOH