rays 0.1.11 → 0.1.16

data/src/matrix.h

@@ -0,0 +1,30 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_SRC_MATRIX_H__
+#define __RAYS_SRC_MATRIX_H__
+
+
+#include <glm/mat4x4.hpp>
+#include <rays/matrix.h>
+
+
+namespace Rays
+{
+
+
+	typedef glm::tmat4x4<coord> Mat4;
+
+
+	inline       Mat4&   to_glm (      Matrix& val) {return *(      Mat4*)   &val;}
+
+	inline const Mat4&   to_glm (const Matrix& val) {return *(const Mat4*)   &val;}
+
+	inline       Matrix& to_rays (      Mat4&  val) {return *(      Matrix*) &val;}
+
+	inline const Matrix& to_rays (const Mat4&  val) {return *(const Matrix*) &val;}
+
+
+}// Rays
+
+
+#endif//EOH

data/src/noise.cpp

@@ -0,0 +1,74 @@
+#include "rays/noise.h"
+
+
+#include <glm/gtc/noise.hpp>
+#include "coord.h"
+
+
+namespace Rays
+{
+
+
+	coord
+	perlin (coord x)
+	{
+		return (coord) glm::perlin(glm::vec2(x, 0));
+	}
+
+	coord
+	perlin (coord x, coord y)
+	{
+		return (coord) glm::perlin(glm::vec2(x, y));
+	}
+
+	coord
+	perlin (coord x, coord y, coord z)
+	{
+		return (coord) glm::perlin(glm::vec3(x, y, z));
+	}
+
+	coord
+	perlin (coord x, coord y, coord z, coord w)
+	{
+		return (coord) glm::perlin(glm::vec4(x, y, z, w));
+	}
+
+	coord
+	perlin (const Coord3& position)
+	{
+		return (coord) glm::perlin(to_glm(position));
+	}
+
+
+	coord
+	simplex (coord x)
+	{
+		return (coord) glm::simplex(glm::vec2(x, 0));
+	}
+
+	coord
+	simplex (coord x, coord y)
+	{
+		return (coord) glm::simplex(glm::vec2(x, y));
+	}
+
+	coord
+	simplex (coord x, coord y, coord z)
+	{
+		return (coord) glm::simplex(glm::vec3(x, y, z));
+	}
+
+	coord
+	simplex (coord x, coord y, coord z, coord w)
+	{
+		return (coord) glm::simplex(glm::vec4(x, y, z, w));
+	}
+
+	coord
+	simplex (const Coord3& position)
+	{
+		return (coord) glm::simplex(to_glm(position));
+	}
+
+
+}// Rays

data/src/opengl.cpp

@@ -1,4 +1,4 @@
-#include "rays/opengl.h"
+#include "opengl.h"
 
 
 #include "rays/exception.h"
@@ -9,23 +9,11 @@ namespace Rays
 
 
 	GLenum
-	get_error ()
+	OpenGL_get_error ()
 	{
 		return glGetError();
 	}
 
-	bool
-	no_error ()
-	{
-		return get_error() == GL_NO_ERROR;
-	}
-
-	bool
-	is_error (GLenum err)
-	{
-		return get_error() == err;
-	}
-
 	static String
 	get_error_name (GLenum error)
 	{
@@ -35,30 +23,24 @@ namespace Rays
 			case GL_INVALID_ENUM:      return "GL_INVALID_ENUM";
 			case GL_INVALID_VALUE:     return "GL_INVALID_VALUE";
 			case GL_INVALID_OPERATION: return "GL_INVALID_OPERATION";
-		#ifndef IOS
-			case GL_STACK_OVERFLOW:    return "GL_STACK_OVERFLOW";
-			case GL_STACK_UNDERFLOW:   return "GL_STACK_UNDERFLOW";
-		#endif
 			case GL_OUT_OF_MEMORY:     return "GL_OUT_OF_MEMORY";
+			#ifndef IOS
+				case GL_STACK_OVERFLOW:  return "GL_STACK_OVERFLOW";
+				case GL_STACK_UNDERFLOW: return "GL_STACK_UNDERFLOW";
+			#endif
 			case 0x506:                return "GL_INVALID_FRAMEBUFFER_OPERATION";
 			case 0x8031:               return "GL_TABLE_TOO_LARGE";
+			default:                   return "UNKNOWN ERROR";
 		}
-		return "UNKNOWN ERROR";
 	}
 
 	void
-	check_error (const char* file, int line)
+	OpenGL_check_error (const char* file, int line)
 	{
-		GLenum e = get_error();
+		GLenum e = OpenGL_get_error();
 		if (e != GL_NO_ERROR)
 			opengl_error(file, line, "OpenGL error %s", get_error_name(e).c_str());
 	}
 
-	void
-	clear_error ()
-	{
-		get_error();
-	}
-
 
 }// Rays

data/src/opengl.h

@@ -0,0 +1,37 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_SRC_OPENGL_H__
+#define __RAYS_SRC_OPENGL_H__
+
+
+#if defined(OSX)
+	#include <OpenGL/gl.h>
+	#include <OpenGL/glext.h>
+#elif defined(IOS)
+	#include <OpenGLES/ES3/gl.h>
+	#include <OpenGLES/ES3/glext.h>
+#elif defined(WIN32)
+	#include <GL/gl.h>
+	#include <GL/glext.h>
+#endif
+
+#include <rays/opengl.h>
+
+
+namespace Rays
+{
+
+
+	void OpenGL_set_context (Context context);
+
+	Context OpenGL_get_context ();
+
+	GLenum OpenGL_get_error ();
+
+	void OpenGL_check_error (const char* file, int line);
+
+
+}// Rays
+
+
+#endif//EOH

data/src/osx/bitmap.h

@@ -0,0 +1,21 @@
+// -*- mode: c++ -*-
+#pragma once
+#ifndef __RAYS_SRC_OSX_BITMAP_H__
+#define __RAYS_SRC_OSX_BITMAP_H__
+
+
+#import <CoreGraphics/CGImage.h>
+#include "../bitmap.h"
+
+
+namespace Rays
+{
+
+
+	void Bitmap_copy_pixels (Bitmap* bitmap, CGImageRef image);
+
+
+}// Rays
+
+
+#endif//EOH

data/src/osx/bitmap.mm

@@ -1,12 +1,12 @@
 // -*- objc -*-
-#import "rays/bitmap.h"
+#import "bitmap.h"
 
 
-#include <assert.h>
-#include <boost/scoped_array.hpp>
 #import <Cocoa/Cocoa.h>
 #include "rays/exception.h"
-#include "rays/texture.h"
+#include "../color_space.h"
+#include "../font.h"
+#include "../texture.h"
 #include "../frame_buffer.h"
 #include "helper.h"
 
@@ -26,14 +26,14 @@ namespace Rays
 		if (cs.is_alpha_first())
 		{
 			info |= cs.is_premult()
-				? kCGImageAlphaPremultipliedFirst
-				: kCGImageAlphaFirst;
+				?	kCGImageAlphaPremultipliedFirst
+				:	kCGImageAlphaFirst;
 		}
 		else if (cs.is_alpha_last())
 		{
 			info |= cs.is_premult()
-				? kCGImageAlphaPremultipliedLast
-				: kCGImageAlphaLast;
+				?	kCGImageAlphaPremultipliedLast
+				:	kCGImageAlphaLast;
 		}
 		else if (cs.is_skip_first())
 			info |= kCGImageAlphaNoneSkipFirst;
@@ -59,14 +59,13 @@ namespace Rays
 
 		ColorSpace color_space;
 
-		void* pixels;
+		void* pixels = NULL;
 
-		CGContextRef context;
+		CGContextRef context = NULL;
 
-		bool dirty;
+		bool modified;
 
 		Data ()
-		:	pixels(NULL), context(NULL)
 		{
 			clear();
 		}
@@ -85,7 +84,7 @@ namespace Rays
 			if (bpc <= 0 || pitch <= 0) return NULL;
 
 			CGColorSpaceRef cgcs = NULL;
-			if (color_space.is_gray())
+			if (color_space.is_gray() || color_space.is_alpha())
 				cgcs = CGColorSpaceCreateDeviceGray();
 			else if (color_space.is_rgb() || color_space.is_bgr())
 				cgcs = CGColorSpaceCreateDeviceRGB();
@@ -114,7 +113,7 @@ namespace Rays
 			color_space = COLORSPACE_UNKNOWN;
 			pixels      = NULL;
 			context     = NULL;
-			dirty       = false;
+			modified    = false;
 		}
 
 	};// Bitmap::Data
@@ -134,7 +133,7 @@ namespace Rays
 		this_->self->width       = w;
 		this_->self->height      = h;
 		this_->self->color_space = cs;
-		this_->self->dirty       = true;
+		this_->self->modified    = true;
 
 		size_t size = w * h * cs.Bpp();
 		this_->self->pixels = new uchar[size];
@@ -151,16 +150,123 @@ namespace Rays
 		if (!this_ || !tex)
 			argument_error(__FILE__, __LINE__);
 
-		setup_bitmap(this_, tex.width(), tex.height(), tex.color_space(), NULL, false);
+		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());
+		ColorSpace_get_gl_format_and_type(&format, &type, tex.color_space());
 
 		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));
+		{
+			GLvoid* ptr = (GLvoid*) this_->at<uchar>(0, y);
+			glReadPixels(0, y, this_->width(), 1, format, type, ptr);
+		}
+	}
+
+	Bitmap
+	Bitmap_from (const Texture& texture)
+	{
+		Bitmap bmp;
+		setup_bitmap(&bmp, texture);
+		return bmp;
+	}
+
+	void
+	Bitmap_copy_pixels (Bitmap* bitmap, CGImageRef image)
+	{
+		if (!bitmap || !image)
+			argument_error(__FILE__, __LINE__);
+
+		CGContextRef context = bitmap->self->get_context();
+		if (!context)
+			rays_error(__FILE__, __LINE__, "getting CGContext failed.");
+
+		size_t width  = CGImageGetWidth(image);
+		size_t height = CGImageGetHeight(image);
+		CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);
+
+		Bitmap_set_modified(bitmap);
+	}
+
+	void
+	Bitmap_draw_string (
+		Bitmap* bitmap, const RawFont& font, const char* str, coord x, coord y)
+	{
+		if (!bitmap || !*bitmap || !font || !str)
+			argument_error(__FILE__, __LINE__);
+
+		if (*str == '\0') return;
+
+		font.draw_string(bitmap->self->get_context(), bitmap->height(), str, x, y);
+
+		Bitmap_set_modified(bitmap);
+	}
+
+	void
+	Bitmap_set_modified (Bitmap* bitmap, bool modified)
+	{
+		assert(bitmap);
+
+		bitmap->self->modified = modified;
+	}
+
+	bool
+	Bitmap_get_modified (const Bitmap& bitmap)
+	{
+		return bitmap.self->modified;
+	}
+
+	void
+	Bitmap_save (const Bitmap& bmp, const char* path_)
+	{
+		std::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.");
+
+		std::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.");
+	}
+
+	Bitmap
+	Bitmap_load (const char* path_)
+	{
+		if (!path_ || path_[0] == '\0')
+			argument_error(__FILE__, __LINE__);
+
+		NSString* path = [NSString stringWithUTF8String: path_];
+		NSBitmapImageRep* imagerep =
+			[NSBitmapImageRep imageRepWithContentsOfFile: path];
+		if (!imagerep)
+			rays_error(__FILE__, __LINE__, "[NSBitmapImageRep imageRepWithContentsOfFile] failed.");
+
+		CGImageRef image = [imagerep 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.");
+
+		Bitmap_copy_pixels(&bmp, image);
+		return bmp;
 	}
 
 
@@ -174,17 +280,12 @@ namespace Rays
 		setup_bitmap(this, width, height, color_space, pixels);
 	}
 
-	Bitmap::Bitmap (const Texture& texture)
-	{
-		setup_bitmap(this, texture);
-	}
-
 	Bitmap::~Bitmap ()
 	{
 	}
 
 	Bitmap
-	Bitmap::copy () const
+	Bitmap::dup () const
 	{
 		return Bitmap(width(), height(), color_space(), pixels());
 	}
@@ -239,22 +340,13 @@ namespace Rays
 		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;
+			self->width  > 0  &&
+			self->height > 0  &&
+			self->color_space &&
+			self->pixels;
 	}
 
 	bool
@@ -264,77 +356,4 @@ namespace Rays
 	}
 
 
-	Bitmap
-	load_bitmap (const char* path_)
-	{
-		if (!path_ || path_[0] == '\0')
-			argument_error(__FILE__, __LINE__);
-
-		NSString* path = [NSString stringWithUTF8String: path_];
-		NSBitmapImageRep* imagerep =
-			[NSBitmapImageRep imageRepWithContentsOfFile: path];
-		if (!imagerep)
-			rays_error(__FILE__, __LINE__, "[NSBitmapImageRep imageRepWithContentsOfFile] failed.");
-
-		CGImageRef image = [imagerep 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