rays 0.1.6 → 0.1.7

data/src/ios/bitmap.mm

@@ -0,0 +1,340 @@
+// -*- objc -*-
+#import "rays/bitmap.h"
+
+
+#include <assert.h>
+#include <boost/scoped_array.hpp>
+#import <ImageIO/ImageIO.h>
+#import <MobileCoreServices/UTCoreTypes.h>
+#include "rays/exception.h"
+#include "rays/texture.h"
+#include "../frame_buffer.h"
+#include "helper.h"
+
+
+namespace Rays
+{
+
+
+	static CGBitmapInfo
+	make_bitmapinfo (const ColorSpace& cs)
+	{
+		// Q: What color spaces does CGBitmapContextCreate support?
+		// http://developer.apple.com/library/mac/#qa/qa1037/_index.html
+
+		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 color_space;
+
+		void* pixels;
+
+		CGContextRef context;
+
+		bool dirty;
+
+		Data ()
+		:	pixels(NULL), context(NULL)
+		{
+			clear();
+		}
+
+		~Data ()
+		{
+			clear();
+		}
+
+		CGContextRef get_context ()
+		{
+			if (context) return context;
+
+			int bpc   = color_space.bpc();
+			int pitch = width * color_space.Bpp();
+			if (bpc <= 0 || pitch <= 0) return NULL;
+
+			CGColorSpaceRef cgcs = NULL;
+			if (color_space.is_gray())
+				cgcs = CGColorSpaceCreateDeviceGray();
+			else if (color_space.is_rgb() || color_space.is_bgr())
+				cgcs = CGColorSpaceCreateDeviceRGB();
+			else
+				return NULL;
+
+			context = CGBitmapContextCreate(
+				pixels, width, height, bpc, pitch, cgcs, make_bitmapinfo(color_space));
+			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;
+			color_space = COLORSPACE_UNKNOWN;
+			pixels      = NULL;
+			context     = NULL;
+			dirty       = false;
+		}
+
+	};// Bitmap::Data
+
+
+	static void
+	setup_bitmap (
+		Bitmap* this_,
+		int w, int h, const ColorSpace& cs,
+		const void* pixels_ = NULL, bool clear_pixels = true)
+	{
+		if (!this_ || w <= 0 || h <= 0 || !cs)
+			argument_error(__FILE__, __LINE__);
+
+		this_->self->clear();
+
+		this_->self->width       = w;
+		this_->self->height      = h;
+		this_->self->color_space = cs;
+		this_->self->dirty       = true;
+
+		size_t size = w * h * cs.Bpp();
+		this_->self->pixels = new uchar[size];
+
+		if (pixels_)
+			memcpy(this_->self->pixels, pixels_, size);
+		else if (clear_pixels)
+			memset(this_->self->pixels, 0, size);
+	}
+
+	static void
+	setup_bitmap (Bitmap* this_, const Texture& tex)
+	{
+		if (!this_ || !tex)
+			argument_error(__FILE__, __LINE__);
+
+		setup_bitmap(this_, tex.width(), tex.height(), tex.color_space(), NULL, false);
+
+		GLenum format, type;
+		tex.color_space().get_gl_enums(&format, &type, tex.alpha_only());
+
+		FrameBuffer fb(tex);
+		FrameBufferBinder binder(fb.id());
+
+		for (int y = 0; y < this_->height(); ++y)
+			glReadPixels(0, y, this_->width(), 1, format, type, (GLvoid*) this_->at<uchar>(0, y));
+	}
+
+
+	Bitmap::Bitmap ()
+	{
+	}
+
+	Bitmap::Bitmap (
+		int width, int height, const ColorSpace& color_space, const void* pixels)
+	{
+		setup_bitmap(this, width, height, color_space, pixels);
+	}
+
+	Bitmap::Bitmap (const Texture& texture)
+	{
+		setup_bitmap(this, texture);
+	}
+
+	Bitmap::~Bitmap ()
+	{
+	}
+
+	Bitmap
+	Bitmap::copy () const
+	{
+		return Bitmap(width(), height(), color_space(), pixels());
+	}
+
+	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->color_space;
+	}
+
+	int
+	Bitmap::pitch () const
+	{
+		return width() * self->color_space.Bpp();
+	}
+
+	size_t
+	Bitmap::size () const
+	{
+		return pitch() * height();
+	}
+
+	void*
+	Bitmap::pixels ()
+	{
+		if (!*this) return NULL;
+		return self->pixels;
+	}
+
+	const void*
+	Bitmap::pixels () const
+	{
+		return const_cast<This*>(this)->pixels();
+	}
+
+	bool
+	Bitmap::dirty () const
+	{
+		return self->dirty;
+	}
+
+	void
+	Bitmap::set_dirty (bool b)
+	{
+		self->dirty = b;
+	}
+
+	Bitmap::operator bool () const
+	{
+		return
+			self->width > 0 && self->height > 0 && self->color_space && self->pixels;
+	}
+
+	bool
+	Bitmap::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+	Bitmap
+	load_bitmap (const char* path_)
+	{
+		if (!path_ || path_[0] == '\0')
+			argument_error(__FILE__, __LINE__);
+
+		NSString* path = [NSString stringWithUTF8String: path_];
+		UIImage* uiimage = [UIImage imageWithContentsOfFile: path];
+		if (!uiimage)
+			rays_error(__FILE__, __LINE__, "[UIImage imageWithContentsOfFile:] failed.");
+
+		CGImageRef image = [uiimage CGImage];
+		if (!image)
+			rays_error(__FILE__, __LINE__, "[imagerep CGImage] failed.");
+
+		size_t width  = CGImageGetWidth(image);
+		size_t height = CGImageGetHeight(image);
+
+		Bitmap bmp((int) width, (int) height, RGBA);
+		if (!bmp)
+			rays_error(__FILE__, __LINE__, "invalid bitmap.");
+
+		CGContextRef context = bmp.self->get_context();
+		if (!context)
+			rays_error(__FILE__, __LINE__, "creating CGContext failed.");
+
+		CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);
+		return bmp;
+	}
+
+	void
+	save_bitmap (const Bitmap& bmp, const char* path_)
+	{
+		boost::shared_ptr<CGImage> img(
+			bmp.self->get_image(), CGImageRelease);
+		if (!img)
+			rays_error(__FILE__, __LINE__, "getting CGImage failed.");
+
+		NSString* path = [NSString stringWithUTF8String: path_];
+		NSURL* url = [NSURL fileURLWithPath: path];
+		if (!url)
+			rays_error(__FILE__, __LINE__, "creating NSURL failed.");
+
+		boost::shared_ptr<CGImageDestination> dest(
+			CGImageDestinationCreateWithURL((CFURLRef) url, kUTTypePNG, 1, NULL),
+			safe_cfrelease);
+		if (!dest)
+			rays_error(__FILE__, __LINE__, "CGImageDestinationCreateWithURL() failed.");
+
+		CGImageDestinationAddImage(dest.get(), img.get(), NULL);
+		if (!CGImageDestinationFinalize(dest.get()))
+			rays_error(__FILE__, __LINE__, "CGImageDestinationFinalize() failed.");
+	}
+
+
+	void draw_string (
+		CGContextRef, coord, const char*, coord, coord, const Font&);
+
+	void
+	draw_string (
+		Bitmap* bmp, const char* str, coord x, coord y, const Font& font)
+	{
+		if (!bmp || !*bmp || !str || !font)
+			argument_error(__FILE__, __LINE__);
+
+		if (*str == '\0') return;
+
+		draw_string(bmp->self->get_context(), bmp->height(), str, x, y, font);
+		bmp->set_dirty();
+	}
+
+
+}// Rays

data/src/ios/font.mm

@@ -0,0 +1,206 @@
+// -*- objc -*-
+#include "rays/font.h"
+
+
+#import <CoreText/CoreText.h>
+#include "rays/exception.h"
+#include "helper.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 ()
+	{
+	}
+
+	Font
+	Font::copy () const
+	{
+		return Font(name(), size());
+	}
+
+	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);
+	}
+
+	coord
+	Font::get_width (const char* str) const
+	{
+		if (!str)
+			argument_error(__FILE__, __LINE__);
+
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		if (*str == '\0') return 0;
+
+		CTLineRef line = make_line(self->font, str);
+		if (!line)
+			rays_error(__FILE__, __LINE__, "creating CTLineRef failed.");
+
+		coord w = CTLineGetTypographicBounds(line, NULL, NULL, NULL);
+		CFRelease(line);
+
+		return w;
+	}
+
+	coord
+	Font::get_height (coord* ascent, coord* descent, coord* leading) const
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		CGFloat asc  = CTFontGetAscent(self->font);
+		CGFloat desc = CTFontGetDescent(self->font);
+		CGFloat lead = CTFontGetLeading(self->font);
+
+		if (ascent)  *ascent  = asc;
+		if (descent) *descent = desc;
+		if (leading) *leading = lead;
+
+		return asc + desc + lead;
+	}
+
+	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;
+	}
+
+
+	void
+	draw_string (
+		CGContextRef context, coord context_height,
+		const char* str, coord x, coord y, const Font& font)
+	{
+		if (!context || !str || !font)
+			argument_error(__FILE__, __LINE__);
+
+		if (*str == '\0') return;
+
+		CTLineRef line = make_line(font.self->font, str);
+		if (!line)
+			rays_error(__FILE__, __LINE__, "creating CTLineRef failed.");
+
+		coord width = 0, height = 0, ascent = 0;
+		width  = font.get_width(str);
+		height = font.get_height(&ascent);
+
+		height = ceil(height);
+		ascent = floor(ascent);
+
+		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 - ascent - y);
+		CTLineDraw(line, context);
+		CGContextRestoreGState(context);
+
+		CFRelease(line);
+	}
+
+
+}// Rays

data/src/{cocoa → ios}/helper.h

@@ -1,7 +1,7 @@
 // -*- c++ -*-
 #pragma once
-#ifndef __RAYS_COCOA_HELPER_H__
-#define __RAYS_COCOA_HELPER_H__
+#ifndef __RAYS_OSX_HELPER_H__
+#define __RAYS_OSX_HELPER_H__
 
 
 #include <boost/shared_ptr.hpp>

data/src/ios/opengl.mm

@@ -0,0 +1,21 @@
+// -*- objc -*-
+#include "rays/opengl.h"
+
+
+#include <vector>
+#import <OpenGLES/EAGL.h>
+
+
+namespace Rays
+{
+
+
+	void
+	init_offscreen_context ()
+	{
+		EAGLContext* c = [[EAGLContext alloc] initWithAPI: kEAGLRenderingAPIOpenGLES1];
+		[EAGLContext setCurrentContext: c];
+	}
+
+
+}// Rays

data/src/ios/program.cpp

@@ -0,0 +1,122 @@
+#include "program.h"
+
+
+#include "rays/exception.h"
+
+
+namespace Rays
+{
+
+
+	struct Program::Data {};
+
+
+	Program::Program ()
+	{
+	}
+
+	Program::~Program ()
+	{
+	}
+
+	void
+	Program::attach (const Shader& shader)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Program::detach (const Shader& shader)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Program::set_uniform (const char* name, int arg1)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Program::set_uniform (const char* name, int arg1, int arg2)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Program::set_uniform (const char* name, int arg1, int arg2, int arg3)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Program::set_uniform (const char* name, int arg1, int arg2, int arg3, int arg4)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Program::set_uniform (const char* name, const int* args, size_t size)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Program::set_uniform (const char* name, float arg1)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Program::set_uniform (const char* name, float arg1, float arg2)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Program::set_uniform (const char* name, float arg1, float arg2, float arg3)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Program::set_uniform (const char* name, float arg1, float arg2, float arg3, float arg4)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Program::set_uniform (const char* name, const float* args, size_t size)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Program::push ()
+	{
+	}
+
+	void
+	Program::pop ()
+	{
+	}
+
+	GLuint
+	Program::id () const
+	{
+		return 0;
+	}
+
+	Program::operator bool () const
+	{
+		return false;
+	}
+
+	bool
+	Program::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Rays