rays 0.2 → 0.3

data/src/win32/camera.cpp

@@ -0,0 +1,119 @@
+#include "rays/camera.h"
+
+
+#include "rays/exception.h"
+
+
+namespace Rays
+{
+
+
+	struct Camera::Data
+	{
+	};// Camera::Data
+
+
+	std::vector<String>
+	get_camera_device_names ()
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+
+	Camera::Camera (
+		const char* device_name,
+		int min_width, int min_height, bool resize, bool crop)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	Camera::~Camera ()
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	bool
+	Camera::start ()
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Camera::stop ()
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	bool
+	Camera::is_active () const
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Camera::set_min_width (int width)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	int
+	Camera::min_width () const
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Camera::set_min_height (int height)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	int
+	Camera::min_height () const
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Camera::set_resize (bool resize)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	bool
+	Camera::is_resize () const
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	void
+	Camera::set_crop (bool crop)
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	bool
+	Camera::is_crop () const
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	const Image*
+	Camera::image () const
+	{
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+	Camera::operator bool () const
+	{
+		return false;
+	}
+
+	bool
+	Camera::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Rays

data/src/win32/font.cpp

@@ -1,97 +1,236 @@
-#include "font.h"
+#include "../font.h"
+
+
+#include <assert.h>
+#include <set>
+#include "rays/exception.h"
+#include "gdi.h"
 
 
 namespace Rays
 {
 
 
-	struct Font::Data
+	struct RawFont::Data
 	{
 
 		Win32::Font font;
 
-	};// Window::Data
+		String path;
+
+	};// RawFont::Data
 
 
-	Font::Font ()
+	typedef std::set<String> StringSet;
+
+	struct EnumFontFamiliesCallbackParams
 	{
-	}
 
-	Font::Font (const char* name, coord size)
+		StringSet* names;
+
+		bool fullname;
+
+		EnumFontFamiliesCallbackParams (StringSet* names, bool fullname)
+		:	names(names), fullname(fullname)
+		{
+		}
+
+	};// EnumFontFamiliesCallbackParams
+
+
+	static int CALLBACK
+	enum_callback (
+		const ENUMLOGFONT* elf, const NEWTEXTMETRIC* ntm, DWORD font_type, LPARAM lp)
 	{
-		self->font = Win32::Font(name, size);
+		const auto* params = (EnumFontFamiliesCallbackParams*) lp;
+		const char* name   = params->fullname
+			?	(const char*) elf->elfFullName
+			:	(const char*) elf->elfLogFont.lfFaceName;
+
+		if (name && *name != '\0'  && *name != '@')
+			params->names->insert(name);
+
+		return TRUE;
 	}
 
-	Font::~Font ()
+	static void
+	get_font_names (
+		StringSet* names, HDC hdc, const char* query = NULL, bool fullname = false)
 	{
+		assert(!query || strlen(query) < LF_FACESIZE);
+
+		LOGFONT lf   = {0};
+		lf.lfCharSet = DEFAULT_CHARSET;
+
+		if (query) strcpy(lf.lfFaceName, query);
+
+		EnumFontFamiliesCallbackParams params(names, fullname);
+		EnumFontFamiliesEx(
+			hdc, &lf, (FONTENUMPROC) &enum_callback, (LPARAM) &params, 0);
 	}
 
-	String
-	Font::name () const
+	const FontFamilyMap&
+	get_font_families ()
 	{
-		return self->font.name();
+		static const FontFamilyMap MAP = []() {
+			Win32::DC dc(GetDC(NULL), true, Win32::DC::RELEASE_DC);
+
+			StringSet families;
+			get_font_names(&families, dc.handle());
+
+			StringSet faces;
+			FontFamilyMap map;
+			for (const auto& family : families)
+			{
+				faces.clear();
+				get_font_names(&faces, dc.handle(), family, true);
+
+				auto& list = map[family];
+				list.insert(list.end(), faces.begin(), faces.end());
+			}
+
+			return map;
+		}();
+		return MAP;
 	}
 
-	coord
-	Font::size () const
+	RawFont
+	RawFont_load (const char* path, coord size)
 	{
-		return self->font.size();
+		not_implemented_error(__FILE__, __LINE__);
 	}
 
-	bool
-	Font::get_extent (coord* width, coord* height, const char* str) const
+
+	RawFont::RawFont ()
 	{
-		return self->font.get_extent(width, height, str);
 	}
 
-	Font::operator bool () const
+	RawFont::RawFont (const char* name, coord size)
 	{
-		return self && self->font;
+		self->font = Win32::Font(name, size);
 	}
 
-	bool
-	Font::operator ! () const
+	RawFont::RawFont (const This& obj, coord size)
 	{
-		return !operator bool();
+		const char* path = obj.self->path.empty() ? NULL : obj.self->path.c_str();
+		if (path)
+			*this = RawFont_load(path, size);
+		else
+			self->font = Win32::Font(obj.name().c_str(), size);
 	}
 
-
-	const Font&
-	get_default_font ()
+	RawFont::~RawFont ()
 	{
-		static const Font FONT(NULL);
-		return FONT;
 	}
 
-
 	void
-	Font_draw_string (
-		const Font& font, HDC hdc, coord context_height,
-		const char* str, coord x, coord y)
+	RawFont::draw_string (
+		void* context, coord context_height,
+		const char* str, coord x, coord y) const
 	{
 		using namespace Win32;
 
-		if (!font || !hdc || !str)
+		HDC hdc = (HDC) context;
+
+		if (!hdc || !str)
 			argument_error(__FILE__, __LINE__);
 
 		if (*str == '\0') return;
 
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
 		coord width = 0, height = 0;
-		if (!font.get_extent(&width, &height, str))
-			rays_error(__FILE__, __LINE__, "getting font extent failed.");
+		if (!self->font.get_extent(&width, &height, str))
+			rays_error(__FILE__, __LINE__, "failed to get font extent.");
+
+		DC dc               = hdc;
+		Win32::Font font    = dc.font();
+		COLORREF text_color = dc.text_color();
+		COLORREF back_color = dc.back_color();
 
-		DC dc = hdc;
-		RECT rect = {x, y, x + (int) width, y + (int) height};
-		FillRect(dc.handle(), &rect, Brush(0, 0, 0).handle());
+		dc.set_font(self->font.handle());
+		dc.set_text_color(RGB(255, 255, 255));
+		dc.set_back_color(RGB(0, 0, 0));
 
-		Win32::Font old = dc.font();
-		dc.set_font(font.self->font.handle());
 		BOOL ret = TextOutA(dc.handle(), x, y, str, strlen(str));
-		dc.set_font(old);
+
+		dc.set_font(font);
+		dc.set_text_color(text_color);
+		dc.set_back_color(back_color);
 
 		if (ret == FALSE)
 			rays_error(__FILE__, __LINE__, "drawing text failed.");
 	}
 
+	String
+	RawFont::name () const
+	{
+		if (!*this) return "";
+		return self->font.name();
+	}
+
+	coord
+	RawFont::size () const
+	{
+		if (!*this) return 0;
+		return self->font.size();
+	}
+
+	coord
+	RawFont::get_width (const char* str) const
+	{
+		if (!str)
+			argument_error(__FILE__, __LINE__);
+
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		if (*str == '\0') return 0;
+
+		coord width;
+		if (!self->font.get_extent(&width, NULL, str))
+			rays_error(__FILE__, __LINE__, "failed to get font width");
+
+		return width;
+	}
+
+	coord
+	RawFont::get_height (coord* ascent, coord* descent, coord* leading) const
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		if (ascent || descent || leading)
+		{
+			Win32::DC dc(GetDC(NULL), true, Win32::DC::RELEASE_DC);
+			dc.set_font(self->font);
+
+			TEXTMETRIC tm;
+			GetTextMetrics(dc.handle(), &tm);
+
+			if (ascent)  *ascent  = tm.tmAscent;
+			if (descent) *descent = tm.tmDescent;
+			if (leading) *leading = tm.tmExternalLeading;
+		}
+
+		coord height;
+		if (!self->font.get_extent(NULL, &height, "X"))
+			rays_error(__FILE__, __LINE__, "failed to get font height");
+
+		return height;
+	}
+
+	RawFont::operator bool () const
+	{
+		return self->font;
+	}
+
+	bool
+	RawFont::operator ! () const
+	{
+		return !operator bool();
+	}
+
 
 }// Rays

data/src/win32/gdi.cpp

@@ -43,10 +43,8 @@ namespace Rays
 
 				typedef HANDLE Handle;
 
-				HandleObject (
-					Handle handle = NULL, bool owner = true,
-					DeleteHandleFunc delfun = delete_object)
-				:	handle_(handle), delfun_(delfun)
+				HandleObject ()
+				:	handle_(NULL), delfun_(NULL)
 				{
 				}
 

data/src/win32/gdi.h

@@ -4,8 +4,8 @@
 #define __RAYS_SRC_WIN32_GDI_H__
 
 
-#include <windows.h>
 #include <xot/pimpl.h>
+#include <xot/windows.h>
 #include "rays/defs.h"
 
 

data/src/win32/opengl.cpp

@@ -0,0 +1,127 @@
+#include "../opengl.h"
+
+
+#include <xot/windows.h>
+#include "rays/rays.h"
+#include "rays/exception.h"
+
+
+namespace Rays
+{
+
+
+	static const char* WINDOW_CLASS = "Rays:OffscreenWindow";
+
+
+	struct OffscreenContext
+	{
+
+		HWND hwnd = NULL;
+
+		HDC hdc   = NULL;
+
+		HGLRC hrc = NULL;
+
+		OffscreenContext ()
+		{
+			static const PIXELFORMATDESCRIPTOR PFD =
+			{
+				sizeof(PIXELFORMATDESCRIPTOR), 1,
+				PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL,
+				PFD_TYPE_RGBA, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0,
+				PFD_MAIN_PLANE, 0, 0, 0, 0
+			};
+
+			WNDCLASS wc      = {0};
+			wc.lpfnWndProc   = DefWindowProc;
+			wc.hInstance     = GetModuleHandle(NULL);
+			wc.lpszClassName = WINDOW_CLASS;
+			wc.style         = CS_OWNDC;
+			if (!RegisterClass(&wc))
+			{
+				// It's OK to be registered by the duplicated Rays module
+				if (GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
+					system_error(__FILE__, __LINE__);
+			}
+
+			hwnd = CreateWindowEx(
+				WS_EX_LAYERED, WINDOW_CLASS, "", WS_POPUP, 0, 0, 1, 1,
+				NULL, NULL, GetModuleHandle(NULL), NULL);
+			if (!hwnd)
+				system_error(__FILE__, __LINE__);
+
+			hdc    = GetDC(hwnd);
+			int pf = ChoosePixelFormat(hdc, &PFD);
+			if (!SetPixelFormat(hdc, pf, &PFD))
+				system_error(__FILE__, __LINE__);
+
+			hrc = wglCreateContext(hdc);
+			if (!hrc)
+				system_error(__FILE__, __LINE__);
+		}
+
+		~OffscreenContext ()
+		{
+
+			if (hrc && hrc == wglGetCurrentContext())
+			{
+				if (!wglMakeCurrent(NULL, NULL))
+					system_error(__FILE__, __LINE__);
+			}
+
+			if (!wglDeleteContext(hrc))
+				system_error(__FILE__, __LINE__);
+
+			if (!ReleaseDC(hwnd, hdc))
+				system_error(__FILE__, __LINE__);
+
+			if (!DestroyWindow(hwnd))
+				system_error(__FILE__, __LINE__);
+		}
+
+	};// OffscreenContext
+
+
+	static OffscreenContext*
+	get_opengl_offscreen_context ()
+	{
+		static OffscreenContext* context = NULL;
+		if (!context) context = new OffscreenContext();
+		return context;
+	}
+
+	void
+	OpenGL_init ()
+	{
+		activate_offscreen_context();
+
+		static bool glew_initialized = false;
+		if (!glew_initialized)
+		{
+			glew_initialized = true;
+			if (glewInit() != GLEW_OK)
+				opengl_error(__FILE__, __LINE__, "failed to initialize GLEW.");
+		}
+	}
+
+	void
+	OpenGL_fin ()
+	{
+	}
+
+
+	Context
+	get_offscreen_context ()
+	{
+		return get_opengl_offscreen_context();
+	}
+
+	void
+	activate_offscreen_context ()
+	{
+		const auto* c = get_opengl_offscreen_context();
+		wglMakeCurrent(c->hdc, c->hrc);
+	}
+
+
+}// Rays

data/src/win32/rays.cpp

@@ -1,7 +1,10 @@
-// -*- objc -*-
 #include "rays/rays.h"
 
 
+#include "rays/exception.h"
+#include "../opengl.h"
+
+
 namespace Rays
 {
 
@@ -9,27 +12,31 @@ namespace Rays
 	namespace global
 	{
 
-
 		static bool initialized = false;
 
-
 	}// global
 
 
-	bool
+	void
 	init ()
 	{
-		if (global::initialized) return false;
+		if (global::initialized)
+			rays_error(__FILE__, __LINE__, "already initialized.");
+
 		global::initialized = true;
-		return true;
+
+		OpenGL_init();
 	}
 
-	bool
+	void
 	fin ()
 	{
-		if (!global::initialized) return false;
+		if (!global::initialized)
+			rays_error(__FILE__, __LINE__, "not initialized.");
+
+		OpenGL_fin();
+
 		global::initialized = false;
-		return true;
 	}
 
 

data/test/helper.rb

@@ -3,16 +3,13 @@
   .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
 require 'xot/test'
+require 'xot/util'
 require 'rays'
 
 require 'test/unit'
 
 include Xot::Test
-
-
-unless defined?($RAYS_NOAUTOINIT) && $RAYS_NOAUTOINIT
-  def Rays.fin!() end
-end
+include Xot::Util
 
 
 def assert_equal_color(c1, c2, delta = 0.000001)

data/test/test_bitmap.rb

@@ -37,13 +37,15 @@ class TestBitmap < Test::Unit::TestCase
 
     bmp.pixels = [0xffff0000, 0xff00ff00, 0xff0000ff, 0xffffff00]
     assert_equal [0xffff0000, 0xff00ff00, 0xff0000ff, 0xffffff00], bmp.pixels
+  end
 
+  def test_pixels_float()
     bmp = bitmap 2, 2, Rays::RGBA_float
     assert_equal [0,0,0,0] * 4, bmp.pixels
 
     bmp.pixels = [1,0,0,1, 0,1,0,1, 0,0,1,1, 1,1,0,1]
     assert_equal [1,0,0,1, 0,1,0,1, 0,0,1,1, 1,1,0,1], bmp.pixels
-  end
+  end unless win32?
 
   def test_at()
     o       = bitmap

data/test/test_image.rb

@@ -99,33 +99,27 @@ class TestImage < Test::Unit::TestCase
   end
 
   def test_save_load()
-    def get_image_type(filename)
+    get_image_type = -> filename {
       `file #{filename}`.match(/#{filename}: ([^,]+),/)[1]
-    end
+    }
 
     img    = image(10, 10).paint {fill 1, 0, 0; ellipse 0, 0, 10}
     pixels = img.bitmap.to_a
-    paths  = %w[png jpg jpeg gif bmp tif tiff].map {|ext| "#{__dir__}/testimage.#{ext}"}
+    paths  = %w[png jpg jpeg bmp].map {|ext| "#{__dir__}/testimage.#{ext}"}
 
-    png, jpg, jpeg, gif, bmp, tif, tiff = paths
+    png, jpg, jpeg, bmp = paths
 
     paths.each {|path| img.save path}
 
-    assert_equal 'PNG image data',  get_image_type(png)
-    assert_equal 'JPEG image data', get_image_type(jpg)
-    assert_equal 'JPEG image data', get_image_type(jpeg)
-    assert_equal 'GIF image data',  get_image_type(gif)
-    assert_equal 'PC bitmap',       get_image_type(bmp)
-    assert_equal 'TIFF image data', get_image_type(tif)
-    assert_equal 'TIFF image data', get_image_type(tiff)
+    assert_equal 'PNG image data',  get_image_type[png]
+    assert_equal 'JPEG image data', get_image_type[jpg]
+    assert_equal 'JPEG image data', get_image_type[jpeg]
+    assert_equal 'PC bitmap',       get_image_type[bmp]
 
     assert_equal pixels,   load(png) .then {|o| o.bitmap.to_a}
     assert_equal [10, 10], load(jpg) .then {|o| [o.width, o.height]}
     assert_equal [10, 10], load(jpeg).then {|o| [o.width, o.height]}
-    assert_equal pixels,   load(gif) .then {|o| o.bitmap.to_a}
     assert_equal [10, 10], load(bmp) .then {|o| [o.width, o.height]}
-    assert_equal pixels,   load(tif) .then {|o| o.bitmap.to_a}
-    assert_equal pixels,   load(tiff).then {|o| o.bitmap.to_a}
 
     paths.each {|path| File.delete path}
 

data/test/test_painter.rb

@@ -175,7 +175,7 @@ class TestPainter < Test::Unit::TestCase
     pa.line_height =     nil
     assert_equal        [h, -1], [pa.line_height, pa.line_height!]
 
-    pa.font "Menlo", 100
+    pa.font "Arial", 100
     assert_equal pa.font.height, pa.line_height
   end
 
@@ -223,11 +223,11 @@ class TestPainter < Test::Unit::TestCase
 
   def test_font_name_size()
     pa = painter
-    pa.font "Menlo", 10
-    assert_equal "Menlo Regular", pa.font.name
+    pa.font "Arial", 10
+    assert_equal "Arial", pa.font.name
     assert_equal 10, pa.font.size
     pa.font nil
-    assert_not_equal "Menlo Regular", pa.font.name
+    assert_not_equal "Arial", pa.font.name
     pa.font nil, 20
     assert_equal 20, pa.font.size
   end