rays 0.1.1

data/rays.gemspec

@@ -0,0 +1,54 @@
+# -*- mode: ruby; coding: utf-8 -*-
+
+
+$: << File.join(File.dirname(__FILE__), 'lib')
+
+require 'rake'
+require 'rays/module'
+
+
+FILES = FileList[*%w[
+  ChangeLog
+  README
+  Rakefile
+  support.rb
+  rays.gemspec
+  VERSION
+  task/**/*.rake
+  ext/**/*.rb
+  ext/**/*.h
+  ext/**/*.cpp
+  include/**/*.h
+  lib/**/*.rb
+  src/**/*.h
+  src/**/*.cpp
+  src/**/*.mm
+  test/**/*.rb
+]]
+
+Gem::Specification.new do |s|
+  s.name        = 'rays'
+  s.summary     = 'A Drawing Engine using OpenGL.'
+  s.description = 'This library helps you to develop graphics application with OpenGL.'
+  s.version     = Rays.version
+
+  s.authors  = %w[snori]
+  s.email    = 'snori@xord.org'
+  s.homepage = 'http://blog.xord.org/'
+
+  s.platform              = Gem::Platform::RUBY
+  s.required_ruby_version = '>=1.9.0'
+  s.require_paths         << 'ext'
+
+  s.add_runtime_dependency 'rucy'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'gemcutter'
+
+  s.files      = FILES.to_a
+  s.test_files = FileList['test/**/test_*.rb'].to_a
+
+  s.has_rdoc         = true
+  s.extra_rdoc_files = ['README']
+
+  s.extensions << 'Rakefile'
+end

data/src/cocoa/bitmap.mm

@@ -0,0 +1,286 @@
+// -*- objc -*-
+#import <rays/bitmap.h>
+
+
+#include <assert.h>
+#import <Cocoa/Cocoa.h>
+#include "helpers.h"
+
+
+namespace Rays
+{
+
+
+	static CGBitmapInfo
+	make_bitmapinfo (const ColorSpace& cs)
+	{
+		CGBitmapInfo info = 0;
+
+		if (cs.is_alpha_first())
+		{
+			info |= cs.is_premult()
+				? kCGImageAlphaPremultipliedFirst
+				: kCGImageAlphaFirst;
+		}
+		else if (cs.is_alpha_last())
+		{
+			info |= cs.is_premult()
+				? kCGImageAlphaPremultipliedLast
+				: kCGImageAlphaLast;
+		}
+		else if (cs.is_skip_first())
+			info |= kCGImageAlphaNoneSkipFirst;
+		else if (cs.is_skip_last())
+			info |= kCGImageAlphaNoneSkipLast;
+		else
+			info |= kCGImageAlphaNone;
+
+		     if (cs.is_rgb()) info |= kCGBitmapByteOrder32Big;
+		else if (cs.is_bgr()) info |= kCGBitmapByteOrder32Little;
+		else return false;
+
+		if (cs.is_float()) info |= kCGBitmapFloatComponents;
+
+		return info;
+	}
+
+
+	struct Bitmap::Data
+	{
+
+		int width, height;
+
+		ColorSpace colorspace;
+
+		void* pixels;
+
+		CGContextRef context;
+
+		bool dirty;
+
+		Data ()
+		:	width(0), height(0), pixels(NULL), context(NULL), dirty(true)
+		{
+		}
+
+		~Data ()
+		{
+			clear();
+		}
+
+		bool setup (int w, int h, const ColorSpace& cs)
+		{
+			if (w <= 0 || h <= 0 || !cs) return false;
+
+			clear();
+
+			width      = w;
+			height     = h;
+			colorspace = cs;
+
+			size_t size = w * h * cs.Bpp();
+			pixels = new uchar[size];
+			memset(pixels, 0, size);
+
+			return true;
+		}
+
+		CGContextRef get_context ()
+		{
+			if (context) return context;
+
+			int bpc   = colorspace.bpc();
+			int pitch = width * colorspace.Bpp();
+			if (bpc <= 0 || pitch <= 0) return NULL;
+
+			CGColorSpaceRef cgcs = NULL;
+			if (colorspace.is_gray())
+				cgcs = CGColorSpaceCreateDeviceGray();
+			else if (colorspace.is_rgb() || colorspace.is_bgr())
+				cgcs = CGColorSpaceCreateDeviceRGB();
+			else
+				return NULL;
+
+			context = CGBitmapContextCreate(
+				pixels, width, height, bpc, pitch, cgcs, make_bitmapinfo(colorspace));
+			CGColorSpaceRelease(cgcs);
+			return context;
+		}
+
+		CGImageRef get_image ()
+		{
+			CGContextRef c = get_context();
+			if (!c) return NULL;
+			return CGBitmapContextCreateImage(c);
+		}
+
+		void clear ()
+		{
+			if (context) CGContextRelease(context);
+			if (pixels) delete [] (uchar*) pixels;
+
+			width = height = 0;
+			colorspace = COLORSPACE_UNKNOWN;
+			pixels     = NULL;
+			context    = NULL;
+			dirty      = true;
+		}
+
+	};// Bitmap::Data
+
+
+	Bitmap::Bitmap ()
+	{
+	}
+
+	Bitmap::Bitmap (int width, int height, const ColorSpace& colorspace)
+	{
+		self->setup(width, height, colorspace);
+	}
+
+	Bitmap::~Bitmap ()
+	{
+	}
+
+	int
+	Bitmap::width () const
+	{
+		if (!*this) return 0;
+		return self->width;
+	}
+
+	int
+	Bitmap::height () const
+	{
+		if (!*this) return 0;
+		return self->height;
+	}
+
+	const ColorSpace&
+	Bitmap::color_space () const
+	{
+		if (!*this)
+		{
+			static const ColorSpace UNKNOWN = COLORSPACE_UNKNOWN;
+			return UNKNOWN;
+		}
+		return self->colorspace;
+	}
+
+	int
+	Bitmap::pitch () const
+	{
+		return width() * self->colorspace.Bpp();
+	}
+
+	size_t
+	Bitmap::size () const
+	{
+		return pitch() * height();
+	}
+
+	bool
+	Bitmap::dirty () const
+	{
+		return self->dirty;
+	}
+
+	void
+	Bitmap::set_dirty (bool b)
+	{
+		self->dirty = b;
+	}
+
+	void*
+	Bitmap::data ()
+	{
+		if (!*this) return NULL;
+		return self->pixels;
+	}
+
+	const void*
+	Bitmap::data () const
+	{
+		return const_cast<Bitmap*>(this)->data();
+	}
+
+	Bitmap::operator bool () const
+	{
+		return
+			self->width > 0 && self->height > 0 && self->colorspace && self->pixels;
+	}
+
+	bool
+	Bitmap::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+	bool
+	load_bitmap (Bitmap* bmp, const char* path_)
+	{
+		if (!bmp || !path_) return false;
+
+		NSString* path = [NSString stringWithUTF8String: path_];
+		NSBitmapImageRep* imagerep =
+			[NSBitmapImageRep imageRepWithContentsOfFile: path];
+		if (!imagerep) return false;
+
+		CGImageRef image = [imagerep CGImage];
+		if (!image) return false;
+
+		int width  = CGImageGetWidth(image);
+		int height = CGImageGetHeight(image);
+
+		*bmp = Bitmap(width, height, ColorSpace(RGBA, true));
+		if (!*bmp) return false;
+
+		CGContextRef context = bmp->self->get_context();
+		if (!context) return false;
+
+		CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);
+		return true;
+	}
+
+	bool
+	save_bitmap (const Bitmap& bmp, const char* path_)
+	{
+		boost::shared_ptr<CGImage> img(
+			bmp.self->get_image(), CGImageRelease);
+		if (!img) return false;
+
+		NSString* path = [NSString stringWithUTF8String: path_];
+		NSURL* url = [NSURL fileURLWithPath: path];
+		if (!url) return false;
+
+		boost::shared_ptr<CGImageDestination> dest(
+			CGImageDestinationCreateWithURL((CFURLRef) url, kUTTypePNG, 1, NULL),
+			safe_cfrelease);
+		if (!dest) return false;
+
+		CGImageDestinationAddImage(dest.get(), img.get(), NULL);
+		return CGImageDestinationFinalize(dest.get());
+	}
+
+
+	bool draw_string (
+		CGContextRef, coord, const char*, coord, coord, const Font&);
+
+	bool
+	draw_string (
+		Bitmap* bmp, const char* str, coord x, coord y, const Font& font)
+	{
+		if (!bmp || !*bmp || !str || !font) return false;
+
+		if (*str == '\0') return true;
+
+		if (!draw_string(bmp->self->get_context(), bmp->height(), str, x, y, font))
+			return false;
+
+		bmp->set_dirty();
+		return true;
+	}
+
+
+}// Rays

data/src/cocoa/font.mm

@@ -0,0 +1,193 @@
+// -*- objc -*-
+#include "rays/font.h"
+
+
+#include <ApplicationServices/ApplicationServices.h>
+#include "helpers.h"
+
+
+namespace Rays
+{
+
+
+	struct Font::Data
+	{
+
+		CTFontRef font;
+
+		Data ()
+		:	font(NULL)
+		{
+		}
+
+		~Data ()
+		{
+			if (font)
+			{
+				CFRelease(font);
+				font = NULL;
+			}
+		}
+
+	};// Font::Data
+
+
+	static CTLineRef
+	make_line (CTFontRef font, const char* str)
+	{
+		if (!font || !str || *str == '\0')
+			return NULL;
+
+		CFStringRef keys[] = {
+			kCTFontAttributeName,
+			kCTForegroundColorFromContextAttributeName
+		};
+		CFTypeRef values[] = {
+			font,
+			kCFBooleanTrue
+		};
+		size_t nkeys = sizeof(keys) / sizeof(keys[0]);
+
+		CFDictionaryRef attr = CFDictionaryCreate(
+			NULL, (const void**) &keys, (const void**) &values, nkeys,
+			&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+
+		CFAttributedStringRef attrstr = CFAttributedStringCreate(
+			NULL, cfstring(str).get(), attr);
+		CFRelease(attr);
+
+		CTLineRef line = CTLineCreateWithAttributedString(attrstr);
+		CFRelease(attrstr);
+
+		return line;
+	}
+
+
+	Font::Font ()
+	{
+	}
+
+	Font::Font (const char* name, coord size)
+	{
+		self->font = name
+			? CTFontCreateWithName(cfstring(name).get(), size, NULL)
+			: CTFontCreateUIFontForLanguage(kCTFontSystemFontType, size, NULL);
+	}
+
+	Font::~Font ()
+	{
+	}
+
+	String
+	Font::name () const
+	{
+		if (!*this) return "";
+
+		CFStringRef str = CTFontCopyFullName(self->font);
+
+		enum {BUFSIZE = 2048};
+		char buf[BUFSIZE + 1];
+		if (!CFStringGetCString(str, buf, BUFSIZE, kCFStringEncodingUTF8))
+			buf[0] = '\0';
+
+		CFRelease(str);
+		return buf;
+	}
+
+	coord
+	Font::size () const
+	{
+		if (!*this) return 0;
+		return CTFontGetSize(self->font);
+	}
+
+	bool
+	Font::get_extent (coord* width, coord* height, const char* str) const
+	{
+		if (!*this) return false;
+
+		if (width)  *width  = 0;
+		if (height) *height = 0;
+
+		CGFloat ascent = 0, descent = 0, leading = 0;
+		if (width)
+		{
+			CTLineRef line = make_line(self->font, str);
+			if (!line) return false;
+
+			*width = CTLineGetTypographicBounds(line, &ascent, &descent, &leading);
+			CFRelease(line);
+		}
+
+		if (height)
+		{
+			if (width)
+				*height = ascent + descent + leading;
+			else
+			{
+				*height =
+					CTFontGetAscent(self->font) +
+					CTFontGetDescent(self->font) +
+					CTFontGetLeading(self->font);
+			}
+		}
+
+		return true;
+	}
+
+	Font::operator bool () const
+	{
+		return !!self->font;
+	}
+
+	bool
+	Font::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+	const Font&
+	default_font ()
+	{
+		static const Font FONT(NULL);
+		return FONT;
+	}
+
+
+	bool
+	draw_string (
+		CGContextRef context, coord context_height,
+		const char* str, coord x, coord y, const Font& font)
+	{
+		if (!context || !str || !font) return false;
+
+		if (*str == '\0') return true;
+
+		CTLineRef line = make_line(font.self->font, str);
+		if (!line) return false;
+
+		coord width = 0, height = 0;
+		if (!font.get_extent(&width, &height, str))
+			return false;
+
+		CGRect rect = CGRectMake(
+			x, context_height - height - y, width, height);
+		CGContextClearRect(context, rect);
+		//CGContextSetRGBFillColor(context, 0, 0, 0, 1);
+		//CGContextFillRect(context, rect);
+		CGContextSetRGBFillColor(context, 1, 1, 1, 1);
+
+		CGContextSaveGState(context);
+		CGContextSetTextMatrix(context, CGAffineTransformIdentity);
+		CGContextSetTextPosition(
+			context, x, context_height - CTFontGetAscent(font.self->font) - y);
+		CTLineDraw(line, context);
+		CGContextRestoreGState(context);
+
+		CFRelease(line);
+		return true;
+	}
+
+
+}// Rays