rays 0.2 → 0.3

data/src/osx/bitmap.mm

@@ -2,7 +2,6 @@
 #import "bitmap.h"
 
 
-#include <assert.h>
 #import <Cocoa/Cocoa.h>
 #include "rays/exception.h"
 #include "../color_space.h"
@@ -60,7 +59,7 @@ namespace Rays
 
 		ColorSpace color_space;
 
-		void* pixels = NULL;
+		void* pixels         = NULL;
 
 		CGContextRef context = NULL;
 
@@ -122,37 +121,40 @@ namespace Rays
 
 	static void
 	setup_bitmap (
-		Bitmap* this_,
+		Bitmap* bitmap,
 		int w, int h, const ColorSpace& cs,
-		const void* pixels_ = NULL, bool clear_pixels = true)
+		const void* pixels = NULL, bool clear_pixels = true)
 	{
-		if (!this_ || w <= 0 || h <= 0 || !cs)
+		if (w <= 0 || h <= 0 || !cs)
 			argument_error(__FILE__, __LINE__);
 
-		this_->self->clear();
+		Bitmap::Data* self = bitmap->self.get();
 
-		this_->self->width       = w;
-		this_->self->height      = h;
-		this_->self->color_space = cs;
-		this_->self->modified    = true;
+		self->clear();
+
+		self->width       = w;
+		self->height      = h;
+		self->color_space = cs;
+		self->modified    = true;
 
 		size_t size = w * h * cs.Bpp();
-		this_->self->pixels = new uchar[size];
+		self->pixels = new uchar[size];
 
-		if (pixels_)
-			memcpy(this_->self->pixels, pixels_, size);
+		if (pixels)
+			memcpy(self->pixels, pixels, size);
 		else if (clear_pixels)
-			memset(this_->self->pixels, 0, size);
+			memset(self->pixels, 0, size);
 	}
 
-	static void
-	setup_bitmap (Bitmap* this_, const Texture& tex)
+	Bitmap
+	Bitmap_from (const Texture& tex)
 	{
-		if (!this_ || !tex)
+		if (!tex)
 			argument_error(__FILE__, __LINE__);
 
+		Bitmap bmp;
 		setup_bitmap(
-			this_, tex.width(), tex.height(), tex.color_space(), NULL, false);
+			&bmp, tex.width(), tex.height(), tex.color_space(), NULL, false);
 
 		GLenum format, type;
 		ColorSpace_get_gl_format_and_type(&format, &type, tex.color_space());
@@ -160,18 +162,12 @@ namespace Rays
 		FrameBuffer fb(tex);
 		FrameBufferBinder binder(fb.id());
 
-		for (int y = 0; y < this_->height(); ++y)
+		for (int y = 0; y < bmp.height(); ++y)
 		{
-			GLvoid* ptr = (GLvoid*) this_->at<uchar>(0, y);
-			glReadPixels(0, y, this_->width(), 1, format, type, ptr);
+			GLvoid* ptr = (GLvoid*) bmp.at<uchar>(0, y);
+			glReadPixels(0, y, bmp.width(), 1, format, type, ptr);
 		}
-	}
 
-	Bitmap
-	Bitmap_from (const Texture& texture)
-	{
-		Bitmap bmp;
-		setup_bitmap(&bmp, texture);
 		return bmp;
 	}
 
@@ -206,15 +202,12 @@ namespace Rays
 		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;
 	}
 

data/src/osx/font.mm

@@ -154,11 +154,14 @@ namespace Rays
 	{
 		CGContextRef context = (CGContextRef) context_;
 
-		if (!*this || !context || !str)
+		if (!context || !str)
 			argument_error(__FILE__, __LINE__);
 
 		if (*str == '\0') return;
 
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
 		CTLinePtr line = make_line(self->font, str);
 		if (!line)
 			rays_error(__FILE__, __LINE__, "creating CTLineRef failed.");

data/src/osx/opengl.mm

@@ -3,30 +3,18 @@
 
 
 #import <AppKit/AppKit.h>
+#include "rays/rays.h"
+#include "rays/exception.h"
 
 
 namespace Rays
 {
 
 
-	void
-	OpenGL_set_context (Context context)
-	{
-		NSOpenGLContext* c = (NSOpenGLContext*) context;
-		[c makeCurrentContext];
-	}
-
-	Context
-	OpenGL_get_context ()
+	static NSOpenGLContext*
+	get_opengl_offscreen_context ()
 	{
-		return [NSOpenGLContext currentContext];
-	}
-
-
-	Context
-	get_offscreen_context ()
-	{
-		static Context context = NULL;
+		static NSOpenGLContext* context = nil;
 		if (!context)
 		{
 			NSOpenGLPixelFormatAttribute attribs[] =
@@ -44,11 +32,35 @@ namespace Rays
 			};
 			NSOpenGLPixelFormat* pf = [[[NSOpenGLPixelFormat alloc]
 				initWithAttributes: attribs] autorelease];
-			context = [[[NSOpenGLContext alloc]
-				initWithFormat: pf shareContext: nil] autorelease];
+			context = [[NSOpenGLContext alloc] initWithFormat: pf shareContext: nil];
 		}
 		return context;
 	}
 
 
+	void
+	OpenGL_init ()
+	{
+		activate_offscreen_context();
+	}
+
+	void
+	OpenGL_fin ()
+	{
+	}
+
+
+	Context
+	get_offscreen_context ()
+	{
+		return get_opengl_offscreen_context();
+	}
+
+	void
+	activate_offscreen_context ()
+	{
+		[get_opengl_offscreen_context() makeCurrentContext];
+	}
+
+
 }// Rays

data/src/osx/rays.mm

@@ -25,18 +25,20 @@ namespace Rays
 	init ()
 	{
 		if (global::pool)
-			rays_error(__FILE__, __LINE__, "Rays::init(): already initialized.");
+			rays_error(__FILE__, __LINE__, "already initialized.");
 
 		global::pool = [[NSAutoreleasePool alloc] init];
 
-		OpenGL_set_context(get_offscreen_context());
+		OpenGL_init();
 	}
 
 	void
 	fin ()
 	{
 		if (!global::pool)
-			rays_error(__FILE__, __LINE__, "Rays::fin(): not initialized.");
+			rays_error(__FILE__, __LINE__, "not initialized.");
+
+		OpenGL_fin();
 
 		[global::pool release];
 		global::pool = nil;

data/src/painter.cpp

@@ -2,6 +2,7 @@
 
 
 #include <math.h>
+#include <string.h>
 #include <assert.h>
 #include <memory>
 #include <vector>

data/src/shader.cpp

@@ -156,6 +156,9 @@ namespace Rays
 			// restore premultiplied rgb values
 			"  vec3 rgb__   = col__.a != 0.0 ? col__.rgb / col__.a : col__.rgb;\n"
 			"  gl_FragColor = " + V_COLOR + " * vec4(rgb__, col__.a);\n"
+			#elif defined(WIN32)
+			"  float a__    = (col__.r + col__.g + col__.b) / 3.0;\n"
+			"  gl_FragColor = " + V_COLOR + " * vec4(1.0, 1.0, 1.0, a__);\n"
 			#else
 			"  gl_FragColor = " + V_COLOR + " * col__;\n"
 			#endif

data/src/texture.cpp

@@ -17,8 +17,6 @@ namespace Rays
 	struct Texture::Data
 	{
 
-		Context context = NULL;
-
 		GLuint id = 0;
 
 		int width, height, width_pow2, height_pow2;
@@ -53,22 +51,15 @@ namespace Rays
 		{
 			if (!has_id()) return;
 
-			Context current_context = OpenGL_get_context();
-
-			assert(context);
-			OpenGL_set_context(context);
-
 			glDeleteTextures(1, &id);
+			OpenGL_check_error(__FILE__, __LINE__);
 
-			OpenGL_set_context(current_context);
-
-			context = NULL;
-			id      = 0;
+			id = 0;
 		}
 
 		bool has_id () const
 		{
-			return context && id > 0;
+			return id > 0;
 		}
 
 	};// Texture::Data
@@ -185,13 +176,6 @@ namespace Rays
 	{
 		assert(self && !self->has_id());
 
-		if (self->context)
-			invalid_state_error(__FILE__, __LINE__);
-
-		self->context = OpenGL_get_context();
-		if (!self->context)
-			opengl_error(__FILE__, __LINE__);
-
 		glGenTextures(1, &self->id);
 		glBindTexture(GL_TEXTURE_2D, self->id);
 		if (glIsTexture(self->id) == GL_FALSE)
@@ -313,12 +297,6 @@ namespace Rays
 		return self->color_space;
 	}
 
-	Context
-	Texture::context () const
-	{
-		return self->context;
-	}
-
 	GLuint
 	Texture::id () const
 	{

data/src/texture.h

@@ -42,8 +42,6 @@ namespace Rays
 
 			const ColorSpace& color_space () const;
 
-			Context context () const;
-
 			GLuint id () const;
 
 			void set_modified (bool modified = true);

data/src/win32/bitmap.cpp

@@ -1,8 +1,16 @@
 #include "../bitmap.h"
 
 
-#include <assert.h>
-#include "font.h"
+#define STB_IMAGE_IMPLEMENTATION
+#include <stb_image.h>
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include <stb_image_write.h>
+
+#include "rays/exception.h"
+#include "../color_space.h"
+#include "../font.h"
+#include "../texture.h"
+#include "../frame_buffer.h"
 #include "gdi.h"
 
 
@@ -15,60 +23,55 @@ namespace Rays
 
 		int width, height, pitch;
 
-		ColorSpace colorspace;
+		ColorSpace color_space;
 
-		void* pixels;
+		void* pixels = NULL;
 
 		Win32::MemoryDC memdc;
 
 		bool modified;
 
 		Data ()
-		:	pixels(NULL), modified(true)
 		{
+			clear();
 		}
 
-	};// Window::Data
-
-
-	static bool
-	init_bitmap_pixels (Bitmap* bmp)
-	{
-		if (!*bmp) return false;
-
-		memset(bmp->data(), 0, bmp->size());
-
-		if (!bmp->color_space().has_alpha())
-			return true;
+		~Data ()
+		{
+			clear();
+		}
 
-		int Bpp = bmp->color_space().Bpp();
-		for (int y = 0; y < bmp->height(); ++y)
+		void clear ()
 		{
-			unsigned char* p =
-				bmp->at<unsigned char>(0, y) + bmp->color_space().alpha_pos();
-			int w = bmp->width();
-			while (w--)
-			{
-				*p = 255;
-				p += Bpp;
-			}
+			if (memdc) memdc = Win32::MemoryDC();
+
+			width = height = pitch = 0;
+			color_space = COLORSPACE_UNKNOWN;
+			pixels      = NULL;
+			modified    = false;
 		}
 
-		return true;
-	}
+	};// Bitmap::Data
 
-	static bool
-	setup_bitmap (Bitmap* bmp, int w, int h, const ColorSpace& cs, HDC hdc = NULL)
+
+	static void
+	setup_bitmap (
+		Bitmap* bitmap,
+		int w, int h, const ColorSpace& cs,
+		const void* pixels = NULL, bool clear_pixels = true, HDC hdc = NULL)
 	{
-		if (w <= 0 || h <= 0 || !cs || !bmp || *bmp)
-			return false;
+		if (w <= 0 || h <= 0 || !cs)
+			argument_error(__FILE__, __LINE__);
+
+		Bitmap::Data* self = bitmap->self.get();
 
-		Bitmap::Data* self = bmp->self.get();
+		self->clear();
 
-		self->width      = w;
-		self->height     = h;
-		self->colorspace = cs;
-		self->pitch      = self->width * self->colorspace.Bpp();
+		self->width       = w;
+		self->height      = h;
+		self->pitch       = w * cs.Bpp();
+		self->color_space = cs;
+		self->modified    = true;
 
 		int padding = 4 - self->pitch % 4;
 		if (padding < 4) self->pitch += padding;
@@ -81,32 +84,49 @@ namespace Rays
 		header.biWidth       = self->width;
 		header.biHeight      = -self->height;
 		header.biPlanes      = 1;
-		header.biBitCount    = self->colorspace.bpp();
+		header.biBitCount    = self->color_space.bpp();
 		header.biCompression = BI_RGB;
 
 		Win32::DC dc = hdc ? Win32::DC(hdc) : Win32::screen_dc();
 
 		HBITMAP hbmp = CreateDIBSection(
 			dc.handle(), &bmpinfo, DIB_RGB_COLORS, (void**) &self->pixels, NULL, 0);
-		if (!hbmp) return false;
+		if (!hbmp)
+			rays_error(__FILE__, __LINE__);
 
 		self->memdc = Win32::MemoryDC(dc.handle(), Win32::Bitmap(hbmp, true));
-		if (!self->memdc) return false;
-
-		return init_bitmap_pixels(bmp);
-	}
-
-	static void
-	setup_bitmap (Bitmap* this_, const Texture& tex)
-	{
-		not_implemented_error(__FILE__, __LINE__);
+		if (!self->memdc)
+			rays_error(__FILE__, __LINE__);
+
+		size_t size = self->pitch * self->height;
+		if (pixels)
+			memcpy(self->pixels, pixels, size);
+		else if (clear_pixels)
+			memset(self->pixels, 0, size);
 	}
 
 	Bitmap
-	Bitmap_from (const Texture& texture)
+	Bitmap_from (const Texture& tex)
 	{
+		if (!tex)
+			argument_error(__FILE__, __LINE__);
+
 		Bitmap bmp;
-		setup_bitmap(&bmp, texture);
+		setup_bitmap(
+			&bmp, tex.width(), tex.height(), tex.color_space(), NULL, false);
+
+		GLenum format, type;
+		ColorSpace_get_gl_format_and_type(&format, &type, tex.color_space());
+
+		FrameBuffer fb(tex);
+		FrameBufferBinder binder(fb.id());
+
+		for (int y = 0; y < bmp.height(); ++y)
+		{
+			GLvoid* ptr = (GLvoid*) bmp.at<uchar>(0, y);
+			glReadPixels(0, y, bmp.width(), 1, format, type, ptr);
+		}
+
 		return bmp;
 	}
 
@@ -126,8 +146,6 @@ namespace Rays
 	void
 	Bitmap_set_modified (Bitmap* bitmap, bool modified)
 	{
-		assert(bitmap);
-
 		bitmap->self->modified = modified;
 	}
 
@@ -137,16 +155,83 @@ namespace Rays
 		return bitmap.self->modified;
 	}
 
-	bool
-	Bitmap_save (const Bitmap& bitmap, const char* path)
+	static const char*
+	get_ext (const char* path)
 	{
-		return false;
+		if (!path)
+			return NULL;
+
+		return strrchr(path, '.');
 	}
 
-	bool
-	Bitmap_load (Bitmap* bitmap, const char* path)
+	void
+	Bitmap_save (const Bitmap& bmp, const char* path)
 	{
-		return false;
+		const char* ext = get_ext(path);
+		if (!ext)
+		{
+			argument_error(
+				__FILE__, __LINE__, "invalid image file extension: '%s'", path);
+		}
+
+		const auto& cs = bmp.color_space();
+		size_t w       = bmp.width();
+		size_t h       = bmp.height();
+		size_t pitch   = w * cs.Bpp();
+
+		std::unique_ptr<uchar[]> pixels(new uchar[h * pitch]);
+		for (size_t y = 0; y < h; ++y)
+			memcpy(pixels.get() + pitch * y, bmp.at<uchar>(0, y), pitch);
+
+		int ret = 0;
+		if (stricmp(ext, ".bmp") == 0)
+			ret = stbi_write_bmp(path, w, h, cs.Bpp(), pixels.get());
+		else
+		if (stricmp(ext, ".png") == 0)
+			ret = stbi_write_png(path, w, h, cs.Bpp(), pixels.get(), 0);
+		else
+		if (stricmp(ext, ".jpg") == 0 || stricmp(ext, ".jpeg") == 0)
+			ret = stbi_write_jpg(path, w, h, cs.Bpp(), pixels.get(), 90);
+		else
+		if (stricmp(ext, ".tga") == 0)
+			ret = stbi_write_tga(path, w, h, cs.Bpp(), pixels.get());
+		else
+			argument_error(__FILE__, __LINE__, "unknown image file type");
+
+		if (!ret)
+			rays_error(__FILE__, __LINE__, "failed to save: '%s'", path);
+	}
+
+	Bitmap
+	Bitmap_load (const char* path)
+	{
+		if (!path)
+			argument_error(__FILE__, __LINE__);
+
+		int w = 0, h = 0, Bpp = 0;
+		uchar* pixels = stbi_load(path, &w, &h, &Bpp, 0);
+		if (!pixels)
+			rays_error(__FILE__, __LINE__, "failed to load: '%s'", path);
+
+		ColorSpace cs;
+		switch (Bpp)
+		{
+			case 1: cs = GRAY_8;    break;
+			case 3: cs = RGB_888;   break;
+			case 4: cs = RGBA_8888; break;
+			default:
+				rays_error(__FILE__, __LINE__, "unsupported image file: '%s'", path);
+		}
+
+		Bitmap bmp(w, h, cs);
+		if (!bmp)
+			rays_error(__FILE__, __LINE__, "failed to create Bitmap object");
+
+		int pitch = Bpp * w;
+		for (int y = 0; y < h; ++y)
+			memcpy(bmp.at<uchar>(0, y), pixels + pitch * y, pitch);
+
+		return bmp;
 	}
 
 
@@ -154,31 +239,45 @@ namespace Rays
 	{
 	}
 
-	Bitmap::Bitmap (int width, int height, const ColorSpace& cs)
+	Bitmap::Bitmap (
+		int width, int height, const ColorSpace& color_space, const void* pixels)
 	{
-		setup_bitmap(this, width, height, cs);
+		setup_bitmap(this, width, height, color_space, pixels);
 	}
 
 	Bitmap::~Bitmap ()
 	{
 	}
 
+	Bitmap
+	Bitmap::dup () 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
 	{
-		return self->colorspace;
+		if (!*this)
+		{
+			static const ColorSpace UNKNOWN = COLORSPACE_UNKNOWN;
+			return UNKNOWN;
+		}
+		return self->color_space;
 	}
 
 	int
@@ -196,6 +295,7 @@ namespace Rays
 	void*
 	Bitmap::pixels ()
 	{
+		if (!*this) return NULL;
 		return self->pixels;
 	}
 
@@ -208,9 +308,11 @@ namespace Rays
 	Bitmap::operator bool () const
 	{
 		return
-			self &&
-			self->width > 0 && self->height > 0 && self->pitch > 0 &&
-			self->colorspace && self->pixels && self->memdc;
+			self->width  > 0  &&
+			self->height > 0  &&
+			self->pitch  > 0  &&
+			self->color_space &&
+			self->pixels;
 	}
 
 	bool