Initial commit

.gitignore

@@ -0,0 +1,7 @@
+*.o
+*.pro.*
+*.bak
+*.frag.xxd
+*.ttf.xxd
+
+mkxp

README.md

@@ -0,0 +1,85 @@
+# mkxp
+
+mkxp is a project that seeks to provide a fully open source implementation of the RGSS (Ruby Game Scripting System) interface used in the popular game creation software "RPG Maker XP" (trademark by Enterbrain, Inc.), with focus on Linux. The goal is to be able to run games created with the above software natively without changing a single file.
+
+## Bindings
+Bindings provide the interpreted language environment to run game scripts in. As of right now, they are compiled directly into the executable. Currently there are three bindings:
+
+### MRI
+Website: https://www.ruby-lang.org/en/
+
+Matz's Ruby Interpreter, also called CRuby, is the most widely deployed version of ruby. If you're interested in running games created with RPG Maker XP, this is the one you should go for. MRI 1.8 is what was used in RPG Maker XP, however, this binding is written against 2.0 (the latest version). For games utilizing only the default scripts provided by Enterbrain, this binding works quite well so far. Note that there are language and syntax differences between 1.8 and 2.0, so some user created scripts may not work correctly.
+
+For a list of differences, see:
+http://stackoverflow.com/questions/21574/what-is-the-difference-between-ruby-1-8-and-ruby-1-9
+
+To select this backend, run `qmake BINDING=BINDING_MRI`
+
+### mruby (Lightweight Ruby)
+Website: https://github.com/mruby/mruby
+
+mruby is a new endeavor by Matz and others to create a more lightweight, spec-adhering, embeddable Ruby implementation. You can think of it as a Ruby version of Lua.
+
+Due to heavy differences between mruby and MRI as well as lacking modules, running RPG Maker games with this backend will most likely not work correctly. It is provided as experimental code. You can eg. write your own ruby scripts and run them with this backend.
+
+Some extensions to the standard classes/modules are provided taking the RPG Maker XP helpfile as a quasi "standard". These include Marshal, File, FileTest and Time.
+
+To select this backend, run `qmake BINDING=BINDING_MRUBY`
+
+### null
+This backend only exists for testing purposes and does nothing (the engine quits immediately).
+
+To select this backend, run `qmake BINDING=BINDING_NULL`
+
+## Dependencies
+
+* QtCore 4.8
+* libsigc++
+* PhysFS
+* glew
+* SDL2
+* SDL2_image
+* SDL2_ttf
+* sfml-system 2.0
+* sfml-audio 2.0
+
+(If no version specified, assume latest)
+ 
+### MRI binding:
+Place a recent version of ruby in the project folder and build it.
+
+### mruby binding:
+Place a recent version of mruby in the project folder and build it.
+
+To run mkxp, you should have a graphics card capable of at least **OpenGL 3.0**
+
+## Building
+
+mkxp employs Qt's qmake build system, so you'll need to install that beforehand. After cloning mkxp, run one of the above qmake calls, or simply `qmake` to select the default backend (currently MRI), then `make`.
+
+## Configuration
+
+mkxp reads configuration data from the file "mkxp.conf" contained in the current directory. The format is ini-style.
+
+* "gameFolder": Specifies where mkxp will look for the game scripts. Default is the current directory.
+* "customScript": Specifies a raw ruby script file to be run instead of an RPG Maker game, residing in "gameFolder".
+* "RTPs": Specifies a list of space separated paths to RTPs to be used. (See next section)
+
+Most other entries are self explanatory.
+
+## RTPs
+
+As of right now, mkxp doesn't support midi files, so to use the default RTPs provided by Enterbrain you will have to convert all midi tracks (those in BGM and ME) to ogg or wav. Make sure that the file names match up, ie. "foobar.mid" should be converted to "foobar.ogg".
+
+## Fonts
+
+In the RMXP version of RGSS, fonts are loaded directly from system specific search paths (meaning they must be installed to be available to games). Because this whole thing is a giant platform-dependent headache, I decided to implement the behavior Enterbrain thankfully added in VX Ace: loading fonts will automatically search a folder called "Fonts", which obeys the default searchpath behavior (ie. it can be located directly in the game folder, or an RTP).
+
+If a requested font is not found, no error is generated. Instead, a built-in font is used (currently "Liberation Sans").
+
+## What doesn't work
+
+* Audio formats other than ogg/wav (this might change in the future)
+* Audio "pitch" parameter
+* The Win32API ruby class (for obvious reasons)
+* Loading Bitmaps with sizes greater than the OpenGL texture size limit (around 8192 on modern cards)

binding-mri/audio-binding.cpp

@@ -0,0 +1,88 @@
+/*
+** audio-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "audio.h"
+#include "globalstate.h"
+#include "binding-util.h"
+#include "exception.h"
+
+#define DEF_PLAY_STOP(entity) \
+	RB_METHOD(audio_##entity##Play) \
+	{ \
+		RB_UNUSED_PARAM; \
+		const char *filename; \
+		int volume = 100; \
+		int pitch = 100; \
+		rb_get_args(argc, argv, "z|ii", &filename, &volume, &pitch); \
+		GUARD_EXC( gState->audio().entity##Play(filename, volume, pitch); ) \
+		return Qnil; \
+	} \
+	RB_METHOD(audio_##entity##Stop) \
+	{ \
+		RB_UNUSED_PARAM; \
+		gState->audio().entity##Stop(); \
+		return Qnil; \
+	}
+
+#define DEF_FADE(entity) \
+RB_METHOD(audio_##entity##Fade) \
+{ \
+	RB_UNUSED_PARAM; \
+	int time; \
+	rb_get_args(argc, argv, "i", &time); \
+	gState->audio().bgmFade(time); \
+	return Qnil; \
+}
+
+#define DEF_PLAY_STOP_FADE(entity) \
+	DEF_PLAY_STOP(entity) \
+	DEF_FADE(entity)
+
+DEF_PLAY_STOP_FADE( bgm )
+DEF_PLAY_STOP_FADE( bgs )
+DEF_PLAY_STOP_FADE( me  )
+
+DEF_PLAY_STOP( se  )
+
+
+#define BIND_PLAY_STOP(entity) \
+	_rb_define_module_function(module, #entity "_play", audio_##entity##Play); \
+	_rb_define_module_function(module, #entity "_stop", audio_##entity##Stop);
+
+#define BIND_FADE(entity) \
+	_rb_define_module_function(module, #entity "_fade", audio_##entity##Fade);
+
+#define BIND_PLAY_STOP_FADE(entity) \
+	BIND_PLAY_STOP(entity) \
+	BIND_FADE(entity)
+
+
+void
+audioBindingInit()
+{
+	VALUE module = rb_define_module("Audio");
+
+	BIND_PLAY_STOP_FADE( bgm )
+	BIND_PLAY_STOP_FADE( bgs )
+	BIND_PLAY_STOP_FADE( me  )
+
+	BIND_PLAY_STOP( se )
+}

binding-mri/binding-mri.cpp

@@ -0,0 +1,313 @@
+/*
+** binding-mri.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "binding.h"
+#include "binding-util.h"
+#include "globalstate.h"
+#include "eventthread.h"
+#include "filesystem.h"
+
+#include "./ruby/include/ruby.h"
+
+#include "zlib.h"
+
+#include <QFile>
+#include <QByteArray>
+
+#include <QDebug>
+
+extern const char module_rpg[];
+
+static void mriBindingExecute();
+static void mriBindingTerminate();
+
+ScriptBinding scriptBindingImpl =
+{
+    mriBindingExecute,
+    mriBindingTerminate
+};
+
+ScriptBinding *scriptBinding = &scriptBindingImpl;
+
+void tableBindingInit();
+void etcBindingInit();
+void fontBindingInit();
+void bitmapBindingInit();
+void spriteBindingInit();
+void viewportBindingInit();
+void planeBindingInit();
+void windowBindingInit();
+void tilemapBindingInit();
+
+void inputBindingInit();
+void audioBindingInit();
+void graphicsBindingInit();
+
+void fileIntBindingInit();
+
+static VALUE mriPrint(int, VALUE*, VALUE);
+static VALUE mriP(int, VALUE*, VALUE);
+
+static void mriBindingInit()
+{
+	tableBindingInit();
+	etcBindingInit();
+	fontBindingInit();
+	bitmapBindingInit();
+	spriteBindingInit();
+	viewportBindingInit();
+	planeBindingInit();
+	windowBindingInit();
+	tilemapBindingInit();
+
+	inputBindingInit();
+	audioBindingInit();
+	graphicsBindingInit();
+
+	fileIntBindingInit();
+
+	_rb_define_module_function(rb_mKernel, "print", mriPrint);
+	_rb_define_module_function(rb_mKernel, "p",     mriP);
+
+	rb_eval_string(module_rpg);
+
+	rb_define_global_const("MKXP", Qtrue);
+}
+
+static void
+showMsg(const QByteArray &msg)
+{
+	gState->eThread().showMessageBox(msg.constData());
+}
+
+static void printP(int argc, VALUE *argv,
+                   const char *convMethod, const char *sep)
+{
+	VALUE dispString = rb_str_buf_new(128);
+	ID conv = rb_intern(convMethod);
+
+	for (int i = 0; i < argc; ++i)
+	{
+		VALUE str = rb_funcall(argv[i], conv, 0);
+		rb_str_buf_append(dispString, str);
+
+		if (i < argc)
+			rb_str_buf_cat2(dispString, sep);
+	}
+
+	showMsg(RSTRING_PTR(dispString));
+
+	rb_str_free(dispString);
+}
+
+RB_METHOD(mriPrint)
+{
+	RB_UNUSED_PARAM;
+
+	printP(argc, argv, "to_s", "");
+
+	return Qnil;
+}
+
+RB_METHOD(mriP)
+{
+	RB_UNUSED_PARAM;
+
+	printP(argc, argv, "inspect", "\n");
+
+	return Qnil;
+}
+
+static void runCustomScript(const char *filename)
+{
+	QFile scriptFile(filename);
+	if (!scriptFile.open(QFile::ReadOnly))
+	{
+		showMsg(QByteArray("Unable to open '") + filename + "'");
+		return;
+	}
+
+	QByteArray scriptData = scriptFile.readAll();
+	scriptFile.close();
+
+	rb_eval_string_protect(scriptData.constData(), 0);
+}
+
+VALUE kernelLoadDataInt(const char *filename);
+
+struct Script
+{
+	QByteArray name;
+	QByteArray encData;
+	uint32_t unknown;
+
+	QByteArray decData;
+};
+
+static void runRMXPScripts()
+{
+	const QByteArray &scriptPack = gState->rtData().config.game.scripts;
+
+	if (!gState->fileSystem().exists(scriptPack.constData()))
+	{
+		showMsg("Unable to open '" + scriptPack + "'");
+		return;
+	}
+
+	VALUE scriptArray = kernelLoadDataInt(scriptPack.constData());
+
+	if (rb_type(scriptArray) != RUBY_T_ARRAY)
+	{
+		showMsg("Failed to read script data");
+		return;
+	}
+
+	int scriptCount = RARRAY_LEN(scriptArray);
+
+	QByteArray decodeBuffer;
+	decodeBuffer.resize(0x1000);
+
+	QVector<Script> encScripts(scriptCount);
+
+	for (int i = 0; i < scriptCount; ++i)
+	{
+		VALUE script = rb_ary_entry(scriptArray, i);
+
+		if (rb_type(script) != RUBY_T_ARRAY)
+		{
+			continue;
+		}
+
+		VALUE scriptUnknown = rb_ary_entry(script, 0);
+		VALUE scriptName    = rb_ary_entry(script, 1);
+		VALUE scriptString  = rb_ary_entry(script, 2);
+
+		Script &sc = encScripts[i];
+		sc.name = RSTRING_PTR(scriptName);
+		sc.encData = QByteArray(RSTRING_PTR(scriptString), RSTRING_LEN(scriptString));
+		sc.unknown = FIX2UINT(scriptUnknown);
+	}
+
+	for (int i = 0; i < scriptCount; ++i)
+	{
+		Script &sc = encScripts[i];
+
+		int result = Z_OK;
+		ulong bufferLen;
+
+		while (true)
+		{
+			unsigned char *bufferPtr =
+			        reinterpret_cast<unsigned char*>(const_cast<char*>(decodeBuffer.constData()));
+			const unsigned char *sourcePtr =
+			        reinterpret_cast<const unsigned char*>(sc.encData.constData());
+
+			bufferLen = decodeBuffer.length();
+
+			result = uncompress(bufferPtr, &bufferLen,
+			                    sourcePtr, sc.encData.length());
+
+			bufferPtr[bufferLen] = '\0';
+
+			if (result != Z_BUF_ERROR)
+				break;
+
+			decodeBuffer.resize(decodeBuffer.size()*2);
+		}
+
+		if (result != Z_OK)
+		{
+			static char buffer[256];
+			snprintf(buffer, sizeof(buffer), "Error decoding script %d: '%s'",
+			         i, sc.name.constData());
+
+			showMsg(buffer);
+			break;
+		}
+
+//		QFile file(QString("/home/Ancurio/programming/C++/mkxp/dump/%1.rb").arg(i, 3, 10, QChar('0')));
+//		if (file.open(QFile::WriteOnly))
+//			file.write(decodeBuffer.constData(), bufferLen);
+
+		sc.decData = QByteArray(decodeBuffer.constData(), bufferLen);
+
+		ruby_script(sc.name.constData());
+
+		rb_gc_start();
+
+		qDebug() << "Executing script:" << QString("%1").arg(i, 3, 10, QChar('0'));
+
+		/* Execute code */
+		rb_eval_string_protect(decodeBuffer.constData(), 0);
+
+		VALUE exc = rb_gv_get("$!");
+		if (rb_type(exc) != RUBY_T_NIL)
+			break;
+	}
+
+//	QFile file("/home/Ancurio/programming/C++/mkxp/dump/index");
+//	if (file.open(QFile::WriteOnly))
+//	{
+//		for (int i = 0; i < encScripts.size(); ++i)
+//		{
+//			const Script &sc = encScripts[i];
+//			file.write(sc.name);
+//		}
+//	}
+}
+
+static void mriBindingExecute()
+{
+	ruby_setup();
+
+	RbData rbData;
+	gState->setBindingData(&rbData);
+
+	mriBindingInit();
+
+	QByteArray &customScript = gState->rtData().config.customScript;
+	if (!customScript.isEmpty())
+		runCustomScript(customScript.constData());
+	else
+		runRMXPScripts();
+
+	VALUE exc = rb_gv_get("$!");
+	if (rb_type(exc) != RUBY_T_NIL && !rb_eql(rb_obj_class(exc), rb_eSystemExit))
+	{
+		qDebug() << "Had exception:" << rb_class2name(rb_obj_class(exc));
+		VALUE bt = rb_funcall(exc, rb_intern("backtrace"), 0);
+		rb_p(bt);
+		VALUE msg = rb_funcall(exc, rb_intern("message"), 0);
+		if (RSTRING_LEN(msg) < 256)
+			showMsg(RSTRING_PTR(msg));
+		else
+			qDebug() << (RSTRING_PTR(msg));
+	}
+
+	ruby_cleanup(0);
+
+	gState->rtData().rqTermAck = true;
+}
+
+static void mriBindingTerminate()
+{
+	rb_raise(rb_eSystemExit, " ");
+}

binding-mri/binding-types.h

@@ -0,0 +1,40 @@
+/*
+** binding-types.h
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef BINDINGTYPES_H
+#define BINDINGTYPES_H
+
+#include "binding-util.h"
+
+DECL_TYPE(Table);
+DECL_TYPE(Rect);
+DECL_TYPE(Color);
+DECL_TYPE(Tone);
+DECL_TYPE(Font);
+
+DECL_TYPE(Bitmap);
+DECL_TYPE(Sprite);
+DECL_TYPE(Plane);
+DECL_TYPE(Viewport);
+DECL_TYPE(Tilemap);
+DECL_TYPE(Window);
+
+#endif // BINDINGTYPES_H

binding-mri/binding-util.cpp

@@ -0,0 +1,306 @@
+/*
+** binding-util.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "binding-util.h"
+
+#include "globalstate.h"
+#include "exception.h"
+#include "util.h"
+
+#include <stdarg.h>
+
+#include <QDebug>
+
+void initType(rb_data_type_struct &type,
+              const char *name,
+              void (*freeInst)(void *))
+{
+	type.wrap_struct_name = name;
+	type.function.dmark = 0;
+	type.function.dsize = 0;
+	type.function.dfree = freeInst;
+	type.function.reserved[0] =
+	type.function.reserved[1] = 0;
+	type.parent = 0;
+}
+
+RbData *getRbData()
+{
+	return static_cast<RbData*>(gState->bindingData());
+}
+
+//enum RbException
+//{
+//	RGSS = 0,
+//	PHYSFS,
+//	SDL,
+
+//	ErrnoENOENT,
+
+//	IOError,
+
+//	TypeError,
+//	ArgumentError,
+
+//	RbExceptionsMax
+//};
+
+struct
+{
+	RbException id;
+	const char *name;
+} static customExc[] =
+{
+	{ RGSS,   "RGSSError"   },
+	{ PHYSFS, "PHYSFSError" },
+	{ SDL,    "SDLError"    }
+};
+
+RbData::RbData()
+{
+	for (size_t i = 0; i < ARRAY_SIZE(customExc); ++i)
+		exc[customExc[i].id] = rb_define_class(customExc[i].name, rb_eException);
+
+	exc[ErrnoENOENT] = rb_const_get(rb_const_get(rb_cObject, rb_intern("Errno")), rb_intern("ENOENT"));
+	exc[IOError] = rb_eIOError;
+	exc[TypeError] = rb_eTypeError;
+	exc[ArgumentError] = rb_eArgError;
+}
+
+RbData::~RbData()
+{
+
+}
+
+/* Indexed with Exception::Type */
+static const RbException excToRbExc[] =
+{
+    RGSS,        /* RGSSError   */
+    ErrnoENOENT, /* NoFileError */
+    IOError,
+
+    TypeError,
+    ArgumentError,
+
+    PHYSFS,      /* PHYSFSError */
+    SDL          /* SDLError    */
+};
+
+void raiseRbExc(const Exception &exc)
+{
+	RbData *data = getRbData();
+	VALUE excClass = data->exc[excToRbExc[exc.type]];
+
+	static char buffer[512];
+	exc.snprintf(buffer, sizeof(buffer));
+	rb_raise(excClass, buffer);
+}
+
+int
+rb_get_args(int argc, VALUE *argv, const char *format, ...)
+{
+	char c;
+	VALUE *arg = argv;
+	va_list ap;
+	bool opt = false;
+	int argI = 0;
+
+	va_start(ap, format);
+
+	while ((c = *format++))
+	{
+		switch (c)
+		{
+	    case '|' :
+			break;
+	    default:
+		// FIXME print num of needed args vs provided
+			if (argc <= argI && !opt)
+				rb_raise(rb_eArgError, "wrong number of arguments");
+			break;
+	    }
+
+		if (argI >= argc)
+			break;
+
+		switch (c)
+		{
+		case 'o' :
+		{
+			if (argI >= argc)
+				break;
+
+			VALUE *obj = va_arg(ap, VALUE*);
+
+			*obj = *arg++;
+			++argI;
+			break;
+		}
+
+		case 'S' :
+		{
+			if (argI >= argc)
+				break;
+
+			VALUE *str = va_arg(ap, VALUE*);
+			VALUE tmp = *arg;
+
+			if (!rb_type(tmp) == RUBY_T_STRING)
+				rb_raise(rb_eTypeError, "Argument %d: Expected string", argI);
+
+			*str = tmp;
+			++argI;
+			break;
+		}
+
+		case 's' :
+		{
+			if (argI >= argc)
+				break;
+
+			const char **s = va_arg(ap, const char**);
+			int *len = va_arg(ap, int*);
+
+			VALUE tmp = *arg;
+
+			if (!rb_type(tmp) == RUBY_T_STRING)
+				rb_raise(rb_eTypeError, "Argument %d: Expected string", argI);
+
+			*s = RSTRING_PTR(tmp);
+			*len = RSTRING_LEN(tmp);
+			++argI;
+			break;
+		}
+
+		case 'z' :
+		{
+			if (argI >= argc)
+				break;
+
+			const char **s = va_arg(ap, const char**);
+
+			VALUE tmp = *arg++;
+
+			if (!rb_type(tmp) == RUBY_T_STRING)
+				rb_raise(rb_eTypeError, "Argument %d: Expected string", argI);
+
+			*s = RSTRING_PTR(tmp);
+			++argI;
+			break;
+		}
+
+		case 'f' :
+		{
+			if (argI >= argc)
+				break;
+
+			double *f = va_arg(ap, double*);
+			VALUE fVal = *arg++;
+
+			switch (rb_type(fVal))
+			{
+			case RUBY_T_FLOAT :
+				*f = rb_float_value(fVal);
+				break;
+
+			case RUBY_T_FIXNUM :
+				*f = rb_fix2int(fVal);
+				break;
+
+			default:
+				rb_raise(rb_eTypeError, "Argument %d: Expected float", argI);
+			}
+
+			++argI;
+			break;
+		}
+
+		case 'i' :
+		{
+			if (argI >= argc)
+				break;
+
+			int *i = va_arg(ap, int*);
+			VALUE iVal = *arg++;
+
+			switch (rb_type(iVal))
+			{
+			case RUBY_T_FLOAT :
+				// FIXME check int range?
+				*i = rb_num2long(iVal);
+				break;
+
+			case RUBY_T_FIXNUM :
+				*i = rb_fix2int(iVal);
+				break;
+
+			default:
+				rb_raise(rb_eTypeError, "Argument %d: Expected fixnum", argI);
+			}
+
+			++argI;
+			break;
+		}
+
+		case 'b' :
+		{
+			if (argI >= argc)
+				break;
+
+			bool *b = va_arg(ap, bool*);
+			VALUE bVal = *arg++;
+
+			switch (rb_type(bVal))
+			{
+			case RUBY_T_TRUE :
+				*b = true;
+				break;
+
+			case RUBY_T_FALSE :
+			case RUBY_T_NIL :
+				*b = false;
+				break;
+
+			default:
+				rb_raise(rb_eTypeError, "Argument %d: Expected bool", argI);
+			}
+
+			++argI;
+			break;
+		}
+
+		case '|' :
+			opt = true;
+			break;
+
+		default:
+			rb_raise(rb_eFatal, "invalid argument specifier %c", c);
+		}
+	}
+
+	// FIXME print num of needed args vs provided
+	if (!c && argc > argI)
+		rb_raise(rb_eArgError, "wrong number of arguments");
+
+	va_end(ap);
+
+	return argI;
+}

binding-mri/binding-util.h

@@ -0,0 +1,297 @@
+/*
+** binding-util.h
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef BINDING_UTIL_H
+#define BINDING_UTIL_H
+
+#include "./ruby/ruby.h"
+
+#define PRIV_IV "priv"
+
+enum RbException
+{
+	RGSS = 0,
+	PHYSFS,
+	SDL,
+
+	ErrnoENOENT,
+
+	IOError,
+
+	TypeError,
+	ArgumentError,
+
+	RbExceptionsMax
+};
+
+struct RbData
+{
+	VALUE exc[RbExceptionsMax];
+
+	RbData();
+	~RbData();
+};
+
+RbData *getRbData();
+
+struct Exception;
+
+void
+raiseRbExc(const Exception &exc);
+
+#define DECL_TYPE(Klass) \
+	extern rb_data_type_struct Klass##Type
+
+#define DEF_TYPE(Klass) \
+	rb_data_type_struct Klass##Type
+
+void initType(rb_data_type_struct &type,
+              const char *name,
+              void (*freeInst)(void*));
+
+template<class C>
+static inline void freeInstance(void *inst)
+{
+	delete static_cast<C*>(inst);
+}
+
+#define INIT_TYPE(Klass) initType(Klass##Type, #Klass, freeInstance<Klass>)
+
+template<class C>
+static inline C *
+getPrivateData(VALUE self)
+{
+	VALUE priv = rb_iv_get(self, PRIV_IV);
+	return static_cast<C*>(RTYPEDDATA_DATA(priv));
+}
+
+template<class C>
+static inline C *
+getPrivateDataCheck(VALUE self, const rb_data_type_struct &type)
+{
+	VALUE priv = rb_iv_get(self, PRIV_IV);
+	void *obj = rb_check_typeddata(priv, &type);
+	return static_cast<C*>(obj);
+}
+
+static inline void
+setPrivateData(VALUE self, void *p, const rb_data_type_struct &type)
+{
+	VALUE priv = rb_data_typed_object_alloc(rb_cData, p, &type);
+	rb_iv_set(self, PRIV_IV, priv);
+}
+
+inline VALUE
+wrapObject(void *p, const rb_data_type_struct &type)
+{
+	VALUE klass = rb_const_get(rb_cObject, rb_intern(type.wrap_struct_name));
+	VALUE obj = rb_obj_alloc(klass);
+
+	setPrivateData(obj, p, type);
+
+	return obj;
+}
+
+inline VALUE
+wrapProperty(VALUE self, void *prop, const char *iv,
+             const rb_data_type_struct &type)
+{
+	VALUE propObj = wrapObject(prop, type);
+
+	rb_iv_set(self, iv, propObj);
+
+	return propObj;
+}
+
+inline void
+wrapNilProperty(VALUE self, const char *iv)
+{
+	rb_iv_set(self, iv, Qnil);
+}
+
+/* Implemented: oSszfib| */
+int
+rb_get_args(int argc, VALUE *argv, const char *format, ...);
+
+typedef VALUE (*RubyMethod)(int argc, VALUE *argv, VALUE self);
+
+static inline void
+_rb_define_method(VALUE klass, const char *name, RubyMethod func)
+{
+	rb_define_method(klass, name, RUBY_METHOD_FUNC(func), -1);
+}
+
+static inline void
+rb_define_class_method(VALUE klass, const char *name, RubyMethod func)
+{
+	rb_define_singleton_method(klass, name, RUBY_METHOD_FUNC(func), -1);
+}
+
+static inline void
+_rb_define_module_function(VALUE module, const char *name, RubyMethod func)
+{
+	rb_define_module_function(module, name, RUBY_METHOD_FUNC(func), -1);
+}
+
+template<class C>
+static inline VALUE
+objectLoad(int argc, VALUE *argv, VALUE self, rb_data_type_struct &type)
+{
+	const char *data;
+	int dataLen;
+	rb_get_args(argc, argv, "s", &data, &dataLen);
+
+	VALUE obj = rb_obj_alloc(self);
+
+	C *c = C::deserialize(data, dataLen);
+
+	setPrivateData(obj, c, type);
+
+	return obj;
+}
+
+static inline VALUE
+rb_bool_new(bool value)
+{
+	return value ? Qtrue : Qfalse;
+}
+
+#define RB_METHOD(name) \
+	static VALUE name(int argc, VALUE *argv, VALUE self)
+
+#define RB_UNUSED_PARAM \
+	{ (void) argc; (void) argv; (void) self; }
+
+#define MARSH_LOAD_FUN(Typ) \
+	RB_METHOD(Typ##Load) \
+	{ \
+		return objectLoad<Typ>(argc, argv, self, Typ##Type); \
+	}
+
+#define CLONE_FUNC(Klass) \
+	static mrb_value \
+	Klass##Clone(mrb_state *mrb, mrb_value self) \
+	{ \
+		Klass *k = getPrivateData<Klass>(mrb, self); \
+		mrb_value dupObj = mrb_obj_clone(mrb, self); \
+		Klass *dupK = new Klass(*k); \
+		setPrivateData(mrb, dupObj, dupK, Klass##Type); \
+		return dupObj; \
+	}
+
+#define CLONE_FUN(Klass) \
+	RB_METHOD(Klass##Clone) \
+	{ \
+		RB_UNUSED_PARAM \
+		Klass *k = getPrivateData<Klass>(self); \
+		VALUE dupObj = rb_obj_clone(self); \
+		Klass *dupK = new Klass(*k); \
+		setPrivateData(dupObj, dupK, Klass##Type); \
+		return dupObj; \
+	}
+
+/* If we're not binding a disposable class,
+ * we want to #undef DEF_PROP_CHK_DISP */
+#define DEF_PROP_CHK_DISP \
+	checkDisposed(k, DISP_CLASS_NAME);
+
+#define DEF_PROP_OBJ(Klass, PropKlass, PropName, prop_iv) \
+	RB_METHOD(Klass##Get##PropName) \
+	{ \
+		RB_UNUSED_PARAM; \
+		Klass *k = getPrivateData<Klass>(self); (void) k; \
+		DEF_PROP_CHK_DISP \
+		return rb_iv_get(self, prop_iv); \
+	} \
+	RB_METHOD(Klass##Set##PropName) \
+	{ \
+		Klass *k = getPrivateData<Klass>(self); \
+		VALUE propObj; \
+		PropKlass *prop; \
+		rb_get_args(argc, argv, "o", &propObj); \
+		prop = getPrivateDataCheck<PropKlass>(propObj, PropKlass##Type); \
+		GUARD_EXC( k->set##PropName(prop); ) \
+		rb_iv_set(self, prop_iv, propObj); \
+		return propObj; \
+	}
+
+/* Object property with allowed NIL */
+#define DEF_PROP_OBJ_NIL(Klass, PropKlass, PropName, prop_iv) \
+	RB_METHOD(Klass##Get##PropName) \
+	{ \
+		RB_UNUSED_PARAM; \
+		Klass *k = getPrivateData<Klass>(self); (void) k; \
+		DEF_PROP_CHK_DISP \
+		return rb_iv_get(self, prop_iv); \
+	} \
+	RB_METHOD(Klass##Set##PropName) \
+	{ \
+		RB_UNUSED_PARAM; \
+		Klass *k = getPrivateData<Klass>(self); \
+		VALUE propObj; \
+		PropKlass *prop; \
+		rb_get_args(argc, argv, "o", &propObj); \
+		if (rb_type(propObj) == RUBY_T_NIL) \
+			prop = 0; \
+		else \
+			prop = getPrivateDataCheck<PropKlass>(propObj, PropKlass##Type); \
+		GUARD_EXC( k->set##PropName(prop); ) \
+		rb_iv_set(self, prop_iv, propObj); \
+		return propObj; \
+	}
+
+#define DEF_PROP(Klass, type, PropName, param_t_s, value_fun) \
+	RB_METHOD(Klass##Get##PropName) \
+	{ \
+		RB_UNUSED_PARAM; \
+		Klass *k = getPrivateData<Klass>(self); \
+		DEF_PROP_CHK_DISP \
+		return value_fun(k->get##PropName()); \
+	} \
+	RB_METHOD(Klass##Set##PropName) \
+	{ \
+		Klass *k = getPrivateData<Klass>(self); \
+		type value; \
+		rb_get_args(argc, argv, param_t_s, &value); \
+		GUARD_EXC( k->set##PropName(value); ) \
+		return value_fun(value); \
+	}
+
+#define DEF_PROP_I(Klass, PropName) \
+	DEF_PROP(Klass, int, PropName, "i", rb_fix_new)
+
+#define DEF_PROP_F(Klass, PropName) \
+	DEF_PROP(Klass, double, PropName, "f", rb_float_new)
+
+#define DEF_PROP_B(Klass, PropName) \
+	DEF_PROP(Klass, bool, PropName, "b", rb_bool_new)
+
+#define INIT_PROP_BIND(Klass, PropName, prop_name_s) \
+{ \
+	_rb_define_method(klass, prop_name_s, Klass##Get##PropName); \
+	_rb_define_method(klass, prop_name_s "=", Klass##Set##PropName); \
+}
+
+#define GUARD_EXC(exp) \
+{ try { exp } catch (const Exception &exc) { raiseRbExc(exc); } }
+
+
+#endif // BINDING_UTIL_H

binding-mri/bitmap-binding.cpp

@@ -0,0 +1,324 @@
+/*
+** bitmap-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "bitmap.h"
+#include "font.h"
+#include "exception.h"
+#include "disposable-binding.h"
+#include "binding-util.h"
+#include "binding-types.h"
+
+#include <QDebug>
+
+#define DISP_CLASS_NAME "bitmap"
+
+DEF_TYPE(Bitmap);
+
+RB_METHOD(bitmapInitialize)
+{
+	Bitmap *b = 0;
+
+	if (argc == 1)
+	{
+		char *filename;
+		rb_get_args(argc, argv, "z", &filename);
+
+		GUARD_EXC( b = new Bitmap(filename); )
+	}
+	else
+	{
+		int width, height;
+		rb_get_args(argc, argv, "ii", &width, &height);
+
+		b = new Bitmap(width, height);
+	}
+
+	setPrivateData(self, b, BitmapType);
+
+	/* Wrap properties */
+	Font *font = new Font();
+	b->setFont(font);
+	font->setColor(new Color(*font->getColor()));
+
+	VALUE fontProp = wrapProperty(self, font, "font", FontType);
+	wrapProperty(fontProp, font->getColor(), "color", ColorType);
+
+	return self;
+}
+
+RB_METHOD(bitmapWidth)
+{
+	RB_UNUSED_PARAM;
+
+	Bitmap *b = getPrivateData<Bitmap>(self);
+
+	int value = 0;
+	GUARD_EXC( value = b->width(); );
+
+	return INT2FIX(value);
+}
+
+RB_METHOD(bitmapHeight)
+{
+	RB_UNUSED_PARAM;
+
+	Bitmap *b = getPrivateData<Bitmap>(self);
+
+	int value = 0;
+	GUARD_EXC( value = b->height(); );
+
+	return INT2FIX(value);
+}
+
+RB_METHOD(bitmapRect)
+{
+	RB_UNUSED_PARAM;
+
+	Bitmap *b = getPrivateData<Bitmap>(self);
+
+	IntRect rect;
+	GUARD_EXC( rect = b->rect(); );
+
+	Rect *r = new Rect(rect);
+
+	return wrapObject(r, RectType);
+}
+
+RB_METHOD(bitmapBlt)
+{
+	Bitmap *b = getPrivateData<Bitmap>(self);
+
+	int x, y;
+	VALUE srcObj;
+	VALUE srcRectObj;
+	int opacity = 255;
+
+	Bitmap *src;
+	Rect *srcRect;
+
+	rb_get_args(argc, argv, "iioo|i", &x, &y, &srcObj, &srcRectObj, &opacity);
+
+	src = getPrivateDataCheck<Bitmap>(srcObj, BitmapType);
+	srcRect = getPrivateDataCheck<Rect>(srcRectObj, RectType);
+
+	GUARD_EXC( b->blt(x, y, *src, srcRect->toIntRect(), opacity); );
+
+	return self;
+}
+
+RB_METHOD(bitmapStretchBlt)
+{
+	Bitmap *b = getPrivateData<Bitmap>(self);
+
+	VALUE destRectObj;
+	VALUE srcObj;
+	VALUE srcRectObj;
+	int opacity = 255;
+
+	Bitmap *src;
+	Rect *destRect, *srcRect;
+
+	rb_get_args(argc, argv, "ooo|i", &destRectObj, &srcObj, &srcRectObj);
+
+	src = getPrivateDataCheck<Bitmap>(srcObj, BitmapType);
+	destRect = getPrivateDataCheck<Rect>(destRectObj, RectType);
+	srcRect = getPrivateDataCheck<Rect>(srcRectObj, RectType);
+
+	GUARD_EXC( b->stretchBlt(destRect->toIntRect(), *src, srcRect->toIntRect(), opacity); );
+
+	return self;
+}
+
+RB_METHOD(bitmapFillRect)
+{
+	Bitmap *b = getPrivateData<Bitmap>(self);
+
+	VALUE colorObj;
+	Color *color;
+
+	if (argc == 2)
+	{
+		VALUE rectObj;
+		Rect *rect;
+
+		rb_get_args(argc, argv, "oo", &rectObj, &colorObj);
+
+		rect = getPrivateDataCheck<Rect>(rectObj, RectType);
+		color = getPrivateDataCheck<Color>(colorObj, ColorType);
+
+		GUARD_EXC( b->fillRect(rect->toIntRect(), color->norm); );
+	}
+	else
+	{
+		int x, y, width, height;
+
+		rb_get_args(argc, argv, "iiiio", &x, &y, &width, &height, &colorObj);
+
+		color = getPrivateDataCheck<Color>(colorObj, ColorType);
+
+		GUARD_EXC( b->fillRect(x, y, width, height, color->norm); );
+	}
+
+	return self;
+}
+
+RB_METHOD(bitmapClear)
+{
+	RB_UNUSED_PARAM;
+
+	Bitmap *b = getPrivateData<Bitmap>(self);
+
+	GUARD_EXC( b->clear(); )
+
+	return self;
+}
+
+RB_METHOD(bitmapGetPixel)
+{
+	Bitmap *b = getPrivateData<Bitmap>(self);
+
+	int x, y;
+
+	rb_get_args(argc, argv, "ii", &x, &y);
+
+	GUARD_EXC(
+		if (x < 0 || y < 0 || x >= b->width() || y >= b->height())
+	            return Qnil;
+	         )
+
+	Vec4 value;
+	GUARD_EXC( value = b->getPixel(x, y); );
+
+	Color *color = new Color(value);
+
+	return wrapObject(color, ColorType);
+}
+
+RB_METHOD(bitmapSetPixel)
+{
+	Bitmap *b = getPrivateData<Bitmap>(self);
+
+	int x, y;
+	VALUE colorObj;
+
+	Color *color;
+
+	rb_get_args(argc, argv, "iio", &x, &y, &colorObj);
+
+	color = getPrivateDataCheck<Color>(colorObj, ColorType);
+
+	GUARD_EXC( b->setPixel(x, y, color->norm); );
+
+	return self;
+}
+
+RB_METHOD(bitmapHueChange)
+{
+	Bitmap *b = getPrivateData<Bitmap>(self);
+
+	int hue;
+
+	rb_get_args(argc, argv, "i", &hue);
+
+	GUARD_EXC( b->hueChange(hue); );
+
+	return self;
+}
+
+RB_METHOD(bitmapDrawText)
+{
+	Bitmap *b = getPrivateData<Bitmap>(self);
+
+	const char *str;
+	int align = Bitmap::Left;
+
+	if (argc == 2 || argc == 3)
+	{
+		VALUE rectObj;
+		Rect *rect;
+
+		rb_get_args(argc, argv, "oz|i", &rectObj, &str, &align);
+
+		rect = getPrivateDataCheck<Rect>(rectObj, RectType);
+
+		GUARD_EXC( b->drawText(rect->toIntRect(), str, align); );
+	}
+	else
+	{
+		int x, y, width, height;
+
+		rb_get_args(argc, argv, "iiiiz|i", &x, &y, &width, &height, &str, &align);
+
+		GUARD_EXC( b->drawText(x, y, width, height, str, align); );
+	}
+
+	return self;
+}
+
+RB_METHOD(bitmapTextSize)
+{
+	Bitmap *b = getPrivateData<Bitmap>(self);
+
+	const char *str;
+
+	rb_get_args(argc, argv, "z", &str);
+
+	IntRect value;
+	GUARD_EXC( value = b->textSize(str); );
+
+	Rect *rect = new Rect(value);
+
+	return wrapObject(rect, RectType);
+}
+
+DEF_PROP_OBJ(Bitmap, Font, Font, "font")
+
+CLONE_FUN(Bitmap)
+
+
+void
+bitmapBindingInit()
+{
+	INIT_TYPE(Bitmap);
+
+	VALUE klass = rb_define_class("Bitmap", rb_cObject);
+
+	disposableBindingInit<Bitmap>(klass);
+
+	_rb_define_method(klass, "initialize",  bitmapInitialize);
+
+	_rb_define_method(klass, "width",       bitmapWidth);
+	_rb_define_method(klass, "height",      bitmapHeight);
+	_rb_define_method(klass, "rect",        bitmapRect);
+	_rb_define_method(klass, "blt",         bitmapBlt);
+	_rb_define_method(klass, "stretch_blt", bitmapStretchBlt);
+	_rb_define_method(klass, "fill_rect",   bitmapFillRect);
+	_rb_define_method(klass, "clear",       bitmapClear);
+	_rb_define_method(klass, "get_pixel",   bitmapGetPixel);
+	_rb_define_method(klass, "set_pixel",   bitmapSetPixel);
+	_rb_define_method(klass, "hue_change",  bitmapHueChange);
+	_rb_define_method(klass, "draw_text",   bitmapDrawText);
+	_rb_define_method(klass, "text_size",   bitmapTextSize);
+
+	INIT_PROP_BIND(Bitmap, Font, "font");
+
+	_rb_define_method(klass, "clone",       BitmapClone);
+}

binding-mri/disposable-binding.h

@@ -0,0 +1,65 @@
+/*
+** disposable-binding.h
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef DISPOSABLEBINDING_H
+#define DISPOSABLEBINDING_H
+
+#include "disposable.h"
+#include "binding-util.h"
+
+template<class C>
+RB_METHOD(disposableDispose)
+{
+	RB_UNUSED_PARAM;
+
+	Disposable *d = getPrivateData<C>(self);
+
+	d->dispose();
+
+	return Qnil;
+}
+
+template<class C>
+RB_METHOD(disposableIsDisposed)
+{
+	RB_UNUSED_PARAM;
+
+	Disposable *d = getPrivateData<C>(self);
+
+	return rb_bool_new(d->isDisposed());
+}
+
+template<class C>
+static void disposableBindingInit(VALUE klass)
+{
+	_rb_define_method(klass, "dispose", disposableDispose<C>);
+	_rb_define_method(klass, "disposed?", disposableIsDisposed<C>);
+}
+
+inline void checkDisposed(Disposable *d, const char *klassName)
+{
+	RbData *data = getRbData(); (void) data;
+
+	if (d->isDisposed())
+		rb_raise(getRbData()->exc[RGSS], "disposed %s", klassName);
+}
+
+#endif // DISPOSABLEBINDING_H

binding-mri/etc-binding.cpp

@@ -0,0 +1,204 @@
+/*
+** etc-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "etc.h"
+#include "binding-util.h"
+#include "serializable-binding.h"
+
+#include <QDebug>
+
+DEF_TYPE(Color);
+DEF_TYPE(Tone);
+DEF_TYPE(Rect);
+
+#define ATTR_RW(Klass, Attr, arg_type, arg_t_s, value_fun) \
+	RB_METHOD(Klass##Get##Attr) \
+	{ \
+		RB_UNUSED_PARAM \
+		Klass *p = getPrivateData<Klass>(self); \
+		return value_fun(p->get##Attr()); \
+	} \
+	RB_METHOD(Klass##Set##Attr) \
+	{ \
+		Klass *p = getPrivateData<Klass>(self); \
+		arg_type arg; \
+		rb_get_args(argc, argv, arg_t_s, &arg); \
+		p->set##Attr(arg); \
+		return *argv; \
+	}
+
+#define ATTR_DOUBLE_RW(Klass, Attr) ATTR_RW(Klass, Attr, double, "f", rb_float_new)
+#define ATTR_INT_RW(Klass, Attr)   ATTR_RW(Klass, Attr, int, "i", rb_fix_new)
+
+ATTR_DOUBLE_RW(Color, Red)
+ATTR_DOUBLE_RW(Color, Green)
+ATTR_DOUBLE_RW(Color, Blue)
+ATTR_DOUBLE_RW(Color, Alpha)
+
+ATTR_DOUBLE_RW(Tone, Red)
+ATTR_DOUBLE_RW(Tone, Green)
+ATTR_DOUBLE_RW(Tone, Blue)
+ATTR_DOUBLE_RW(Tone, Gray)
+
+ATTR_INT_RW(Rect, X)
+ATTR_INT_RW(Rect, Y)
+ATTR_INT_RW(Rect, Width)
+ATTR_INT_RW(Rect, Height)
+
+#define EQUAL_FUN(Klass) \
+	RB_METHOD(Klass##Equal) \
+	{ \
+		Klass *p = getPrivateData<Klass>(self); \
+		VALUE otherObj; \
+		Klass *other; \
+		rb_get_args(argc, argv, "o", &otherObj); \
+		other = getPrivateDataCheck<Klass>(otherObj, Klass##Type); \
+		return rb_bool_new(*p == *other); \
+	}
+
+EQUAL_FUN(Color)
+EQUAL_FUN(Tone)
+EQUAL_FUN(Rect)
+
+#define INIT_FUN(Klass, param_type, param_t_s, last_param_def) \
+	RB_METHOD(Klass##Initialize) \
+	{ \
+		param_type p1, p2, p3, p4 = last_param_def; \
+		rb_get_args(argc, argv, param_t_s, &p1, &p2, &p3, &p4); \
+		Klass *k = new Klass(p1, p2, p3, p4); \
+		setPrivateData(self, k, Klass##Type); \
+		return self; \
+	}
+
+INIT_FUN(Color, double, "fff|f", 255)
+INIT_FUN(Tone, double, "fff|f", 0)
+INIT_FUN(Rect, int, "iiii", 0)
+
+#define SET_FUN(Klass, param_type, param_t_s, last_param_def) \
+	RB_METHOD(Klass##Set) \
+	{ \
+		param_type p1, p2, p3, p4 = last_param_def; \
+		rb_get_args(argc, argv, param_t_s, &p1, &p2, &p3, &p4); \
+		Klass *k = getPrivateData<Klass>(self); \
+		k->set(p1, p2, p3, p4); \
+		return self; \
+	}
+
+SET_FUN(Color, double, "fff|f", 255)
+SET_FUN(Tone, double, "fff|f", 0)
+SET_FUN(Rect, int, "iiii", 0)
+
+RB_METHOD(rectEmpty)
+{
+	RB_UNUSED_PARAM;
+	Rect *r = getPrivateData<Rect>(self);
+	r->empty();
+	return self;
+}
+
+RB_METHOD(ColorStringify)
+{
+	RB_UNUSED_PARAM;
+
+	Color *c = getPrivateData<Color>(self);
+
+	return rb_sprintf("(%f, %f, %f, %f)",
+	                  c->red, c->green, c->blue, c->alpha);
+}
+
+RB_METHOD(ToneStringify)
+{
+	RB_UNUSED_PARAM;
+
+	Tone *t = getPrivateData<Tone>(self);
+
+	return rb_sprintf("(%f, %f, %f, %f)",
+	                  t->red, t->green, t->blue, t->gray);
+}
+
+RB_METHOD(RectStringify)
+{
+	RB_UNUSED_PARAM;
+
+	Rect *r = getPrivateData<Rect>(self);
+
+	return rb_sprintf("(%d, %d, %d, %d)",
+	                  r->x, r->y, r->width, r->height);
+}
+
+MARSH_LOAD_FUN(Color)
+MARSH_LOAD_FUN(Tone)
+MARSH_LOAD_FUN(Rect)
+
+CLONE_FUN(Tone)
+CLONE_FUN(Color)
+CLONE_FUN(Rect)
+
+#define INIT_BIND(Klass) \
+{ \
+	INIT_TYPE(Klass); \
+	klass = rb_define_class(#Klass, rb_cObject); \
+	rb_define_class_method(klass, "_load", Klass##Load); \
+	serializableBindingInit<Klass>(klass); \
+	_rb_define_method(klass, "initialize", Klass##Initialize); \
+	_rb_define_method(klass, "set", Klass##Set); \
+	_rb_define_method(klass, "clone", Klass##Clone); \
+	_rb_define_method(klass, "==", Klass##Equal); \
+	_rb_define_method(klass, "to_s", Klass##Stringify); \
+	_rb_define_method(klass, "inspect", Klass##Stringify); \
+}
+
+#define MRB_ATTR_R(Class, attr) mrb_define_method(mrb, klass, #attr, Class##Get_##attr, MRB_ARGS_NONE())
+#define MRB_ATTR_W(Class, attr) mrb_define_method(mrb, klass, #attr "=", Class##Set_##attr, MRB_ARGS_REQ(1))
+#define MRB_ATTR_RW(Class, attr) { MRB_ATTR_R(Class, attr); MRB_ATTR_W(Class, attr); }
+
+#define RB_ATTR_R(Klass, Attr, attr) _rb_define_method(klass, #attr, Klass##Get##Attr)
+#define RB_ATTR_W(Klass, Attr, attr) _rb_define_method(klass, #attr "=", Klass##Set##Attr)
+#define RB_ATTR_RW(Klass, Attr, attr) \
+	{ RB_ATTR_R(Klass, Attr, attr); RB_ATTR_W(Klass, Attr, attr); }
+
+void
+etcBindingInit()
+{
+	VALUE klass;
+
+	INIT_BIND(Color);
+
+	RB_ATTR_RW(Color, Red, red);
+	RB_ATTR_RW(Color, Green, green);
+	RB_ATTR_RW(Color, Blue, blue);
+	RB_ATTR_RW(Color, Alpha, alpha);
+
+	INIT_BIND(Tone);
+
+	RB_ATTR_RW(Tone, Red, red);
+	RB_ATTR_RW(Tone, Green, green);
+	RB_ATTR_RW(Tone, Blue, blue);
+	RB_ATTR_RW(Tone, Gray, gray);
+
+	INIT_BIND(Rect);
+
+	RB_ATTR_RW(Rect, X, x);
+	RB_ATTR_RW(Rect, Y, y);
+	RB_ATTR_RW(Rect, Width, width);
+	RB_ATTR_RW(Rect, Height, height);
+	_rb_define_method(klass, "empty", rectEmpty);
+}

binding-mri/filesystem-binding.cpp

@@ -0,0 +1,173 @@
+/*
+** filesystem-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "binding-util.h"
+
+#include "globalstate.h"
+#include "filesystem.h"
+
+#include <QDebug>
+
+DEF_TYPE(FileInt);
+
+static VALUE
+fileIntForPath(const char *path)
+{
+	SDL_RWops *ops = SDL_AllocRW();
+	gState->fileSystem().openRead(*ops, path);
+
+	VALUE klass = rb_const_get(rb_cObject, rb_intern("FileInt"));
+
+	VALUE obj = rb_obj_alloc(klass);
+
+	setPrivateData(obj, ops, FileIntType);
+
+	return obj;
+}
+
+RB_METHOD(fileIntRead)
+{
+
+	int length = -1;
+	rb_get_args(argc, argv, "i", &length);
+
+	SDL_RWops *ops = getPrivateData<SDL_RWops>(self);
+
+	if (length == -1)
+	{
+		Sint64 cur = SDL_RWtell(ops);
+		Sint64 end = SDL_RWseek(ops, 0, SEEK_END);
+		length = end - cur;
+		SDL_RWseek(ops, cur, SEEK_SET);
+	}
+
+	if (length == 0)
+		return Qnil;
+
+	VALUE data = rb_str_new(0, length);
+
+	SDL_RWread(ops, RSTRING_PTR(data), 1, length);
+
+	return data;
+}
+
+RB_METHOD(fileIntClose)
+{
+	RB_UNUSED_PARAM;
+
+	SDL_RWops *ops = getPrivateData<SDL_RWops>(self);
+	SDL_RWclose(ops);
+
+	return Qnil;
+}
+
+RB_METHOD(fileIntGetByte)
+{
+	RB_UNUSED_PARAM;
+
+	SDL_RWops *ops = getPrivateData<SDL_RWops>(self);
+
+	unsigned char byte;
+	size_t result = SDL_RWread(ops, &byte, 1, 1);
+
+	return (result == 1) ? rb_fix_new(byte) : Qnil;
+}
+
+RB_METHOD(fileIntBinmode)
+{
+	RB_UNUSED_PARAM;
+
+	return Qnil;
+}
+
+static void
+fileIntFreeInstance(void *inst)
+{
+	SDL_RWops *ops = static_cast<SDL_RWops*>(inst);
+
+	SDL_RWclose(ops);
+	SDL_FreeRW(ops);
+}
+
+VALUE
+kernelLoadDataInt(const char *filename)
+{
+	rb_gc_start();
+
+	VALUE port = fileIntForPath(filename);
+
+	VALUE marsh = rb_const_get(rb_cObject, rb_intern("Marshal"));
+
+	VALUE result = rb_funcall(marsh, rb_intern("load"), 1, port);
+
+	rb_funcall(port, rb_intern("close"), 0);
+
+	return result;
+}
+
+RB_METHOD(kernelLoadData)
+{
+	RB_UNUSED_PARAM;
+
+	const char *filename;
+	rb_get_args(argc, argv, "z", &filename);
+
+	return kernelLoadDataInt(filename);
+}
+
+RB_METHOD(kernelSaveData)
+{
+	RB_UNUSED_PARAM;
+
+	VALUE obj;
+	VALUE filename;
+
+	rb_get_args(argc, argv, "oS", &obj, &filename);
+
+	VALUE file = rb_funcall(rb_cFile, rb_intern("open"), 2, filename, rb_str_new_cstr("w"));
+
+	VALUE marsh = rb_const_get(rb_cObject, rb_intern("Marshal"));
+
+	rb_funcall(marsh, rb_intern("dump"), 2, obj, file);
+
+	rb_funcall(file, rb_intern("close"), 0);
+
+	return Qnil;
+}
+
+void
+fileIntBindingInit()
+{
+	initType(FileIntType, "FileInt", fileIntFreeInstance);
+
+	VALUE klass = rb_define_class("FileInt", rb_cIO);
+
+	_rb_define_method(klass, "read", fileIntRead);
+//	_rb_define_method(klass, "eof?", fileIntIsEof);
+//	_rb_define_method(klass, "pos", fileIntGetPos);
+//	_rb_define_method(klass, "pos=", fileIntSetPos);
+	_rb_define_method(klass, "getbyte", fileIntGetByte);
+	_rb_define_method(klass, "binmode", fileIntBinmode);
+	_rb_define_method(klass, "close", fileIntClose);
+
+	_rb_define_module_function(rb_mKernel, "load_data", kernelLoadData);
+	_rb_define_module_function(rb_mKernel, "save_data", kernelSaveData);
+}

binding-mri/flashable-binding.h

@@ -0,0 +1,73 @@
+/*
+** flashable-binding.h
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef FLASHABLEBINDING_H
+#define FLASHABLEBINDING_H
+
+#include "flashable.h"
+#include "binding-util.h"
+#include "binding-types.h"
+
+template<class C>
+RB_METHOD(flashableFlash)
+{
+	Flashable *f = getPrivateData<C>(self);
+
+	VALUE colorObj;
+	int duration;
+
+	Color *color;
+
+	rb_get_args(argc, argv, "oi", &colorObj, &duration);
+
+	if (rb_type(colorObj) == RUBY_T_NIL)
+	{
+		f->flash(0, duration);
+		return Qnil;
+	}
+
+	color = getPrivateDataCheck<Color>(colorObj, ColorType);
+
+	f->flash(&color->norm, duration);
+
+	return Qnil;
+}
+
+template<class C>
+RB_METHOD(flashableUpdate)
+{
+	RB_UNUSED_PARAM;
+
+	Flashable *f = getPrivateData<C>(self);
+
+	f->update();
+
+	return Qnil;
+}
+
+template<class C>
+static void flashableBindingInit(VALUE klass)
+{
+	_rb_define_method(klass, "flash", flashableFlash<C>);
+	_rb_define_method(klass, "update", flashableUpdate<C>);
+}
+
+#endif // FLASHABLEBINDING_H

binding-mri/font-binding.cpp

@@ -0,0 +1,173 @@
+/*
+** font-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "font.h"
+#include "binding-util.h"
+#include "binding-types.h"
+#include "exception.h"
+
+DEF_TYPE(Font);
+
+RB_METHOD(fontDoesExist)
+{
+	RB_UNUSED_PARAM;
+
+	const char *name;
+	rb_get_args(argc, argv, "z", &name);
+
+	return rb_bool_new(Font::doesExist(name));
+}
+
+RB_METHOD(fontInitialize)
+{
+	const char *name = 0;
+	int size = 0;
+
+	rb_get_args(argc, argv, "|zi", &name, &size);
+
+	Font *f = new Font(name, size);
+
+	setPrivateData(self, f, FontType);
+
+	/* Wrap property objects */
+	f->setColor(new Color(*f->getColor()));
+	wrapProperty(self, f->getColor(), "color", ColorType);
+
+	return self;
+}
+
+RB_METHOD(FontGetName)
+{
+	RB_UNUSED_PARAM;
+
+	Font *f = getPrivateData<Font>(self);
+
+	return rb_str_new_cstr(f->getName());
+}
+
+RB_METHOD(FontSetName)
+{
+	Font *f = getPrivateData<Font>(self);
+
+	VALUE name;
+	rb_get_args(argc, argv, "S", &name);
+
+	f->setName(RSTRING_PTR(name));
+
+	return name;
+}
+
+#undef DEF_PROP_CHK_DISP
+#define DEF_PROP_CHK_DISP
+
+DEF_PROP_I(Font, Size)
+DEF_PROP_B(Font, Bold)
+DEF_PROP_B(Font, Italic)
+DEF_PROP_OBJ(Font, Color, Color, "color")
+
+#define DEF_KLASS_PROP(Klass, type, PropName, param_t_s, value_fun) \
+	RB_METHOD(Klass##Get##PropName) \
+	{ \
+		RB_UNUSED_PARAM; \
+		return value_fun(Klass::get##PropName()); \
+	} \
+	RB_METHOD(Klass##Set##PropName) \
+	{ \
+		RB_UNUSED_PARAM; \
+		type value; \
+		rb_get_args(argc, argv, param_t_s, &value); \
+		Klass::set##PropName(value); \
+		return value_fun(value); \
+	}
+
+DEF_KLASS_PROP(Font, int, DefaultSize, "i", rb_fix_new)
+DEF_KLASS_PROP(Font, bool, DefaultBold, "b", rb_bool_new)
+DEF_KLASS_PROP(Font, bool, DefaultItalic, "b", rb_bool_new)
+
+RB_METHOD(FontGetDefaultName)
+{
+	RB_UNUSED_PARAM;
+	return rb_str_new_cstr(Font::getDefaultName());
+}
+
+RB_METHOD(FontSetDefaultName)
+{
+	RB_UNUSED_PARAM;
+	VALUE nameObj;
+	rb_get_args(argc, argv, "S", &nameObj);
+
+	Font::setDefaultName(RSTRING_PTR(nameObj));
+
+	return nameObj;
+}
+
+RB_METHOD(FontGetDefaultColor)
+{
+	RB_UNUSED_PARAM;
+	return rb_iv_get(self, "default_color");
+}
+
+
+RB_METHOD(FontSetDefaultColor)
+{
+	VALUE colorObj;
+	rb_get_args(argc, argv, "o", &colorObj);
+
+	Color *c = getPrivateDataCheck<Color>(colorObj, ColorType);
+
+	Font::setDefaultColor(c);
+	rb_iv_set(self, "default_color", colorObj);
+
+	return colorObj;
+}
+
+#define INIT_KLASS_PROP_BIND(Klass, PropName, prop_name_s) \
+{ \
+	rb_define_class_method(klass, prop_name_s, Klass##Get##PropName); \
+	rb_define_class_method(klass, prop_name_s "=", Klass##Set##PropName); \
+}
+
+void
+fontBindingInit()
+{
+	INIT_TYPE(Font);
+
+	VALUE klass = rb_define_class("Font", rb_cObject);
+
+	Font::setDefaultColor(new Color(*Font::getDefaultColor()));
+	wrapProperty(klass, Font::getDefaultColor(), "default_color", ColorType);
+
+	INIT_KLASS_PROP_BIND(Font, DefaultName, "default_name");
+	INIT_KLASS_PROP_BIND(Font, DefaultSize, "default_size");
+	INIT_KLASS_PROP_BIND(Font, DefaultBold, "default_bold");
+	INIT_KLASS_PROP_BIND(Font, DefaultItalic, "default_italic");
+	INIT_KLASS_PROP_BIND(Font, DefaultColor, "default_color");
+
+	rb_define_class_method(klass, "exist?", fontDoesExist);
+
+	_rb_define_method(klass, "initialize", fontInitialize);
+
+	INIT_PROP_BIND(Font, Name, "name");
+	INIT_PROP_BIND(Font, Size, "size");
+	INIT_PROP_BIND(Font, Bold, "bold");
+	INIT_PROP_BIND(Font, Italic, "italic");
+	INIT_PROP_BIND(Font, Color, "color");
+}

binding-mri/graphics-binding.cpp

@@ -0,0 +1,124 @@
+/*
+** graphics-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "graphics.h"
+#include "globalstate.h"
+#include "binding-util.h"
+#include "exception.h"
+
+RB_METHOD(graphicsUpdate)
+{
+	RB_UNUSED_PARAM;
+
+	gState->graphics().update();
+
+	return Qnil;
+}
+
+RB_METHOD(graphicsFreeze)
+{
+	RB_UNUSED_PARAM;
+
+	gState->graphics().freeze();
+
+	return Qnil;
+}
+
+RB_METHOD(graphicsTransition)
+{
+	RB_UNUSED_PARAM;
+
+	int duration = 8;
+	const char *filename = 0;
+	int vague = 40;
+
+	rb_get_args(argc, argv, "|izi", &duration, &filename, &vague);
+
+	GUARD_EXC( gState->graphics().transition(duration, filename, vague); )
+
+	return Qnil;
+}
+
+RB_METHOD(graphicsFrameReset)
+{
+	RB_UNUSED_PARAM;
+
+	gState->graphics().frameReset();
+
+	return Qnil;
+}
+
+#define DEF_GRA_PROP_I(PropName) \
+	RB_METHOD(graphics##Get##PropName) \
+	{ \
+		RB_UNUSED_PARAM; \
+		return rb_fix_new(gState->graphics().get##PropName()); \
+	} \
+	RB_METHOD(graphics##Set##PropName) \
+	{ \
+		RB_UNUSED_PARAM; \
+		int value; \
+		rb_get_args(argc, argv, "i", &value); \
+		gState->graphics().set##PropName(value); \
+		return rb_fix_new(value); \
+	}
+
+DEF_GRA_PROP_I(FrameRate)
+DEF_GRA_PROP_I(FrameCount)
+
+RB_METHOD(graphicsGetFullscreen)
+{
+	RB_UNUSED_PARAM;
+	return rb_bool_new(gState->graphics().getFullscreen());
+}
+
+RB_METHOD(graphicsSetFullscreen)
+{
+	RB_UNUSED_PARAM;
+
+	bool mode;
+	rb_get_args(argc, argv, "b", &mode);
+
+	gState->graphics().setFullscreen(mode);
+
+	return rb_bool_new(mode);
+}
+
+#define INIT_GRA_PROP_BIND(PropName, prop_name_s) \
+{ \
+	_rb_define_module_function(module, prop_name_s, graphics##Get##PropName); \
+	_rb_define_module_function(module, prop_name_s "=", graphics##Set##PropName); \
+}
+
+void graphicsBindingInit()
+{
+	VALUE module = rb_define_module("Graphics");
+
+	_rb_define_module_function(module, "update", graphicsUpdate);
+	_rb_define_module_function(module, "freeze", graphicsFreeze);
+	_rb_define_module_function(module, "transition", graphicsTransition);
+	_rb_define_module_function(module, "frame_reset", graphicsFrameReset);
+
+	INIT_GRA_PROP_BIND( FrameRate,  "frame_rate"  );
+	INIT_GRA_PROP_BIND( FrameCount, "frame_count" );
+
+	INIT_GRA_PROP_BIND( Fullscreen, "fullscreen" );
+}

binding-mri/input-binding.cpp

@@ -0,0 +1,146 @@
+/*
+** input-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "input.h"
+#include "globalstate.h"
+#include "exception.h"
+#include "binding-util.h"
+
+RB_METHOD(inputUpdate)
+{
+	RB_UNUSED_PARAM;
+
+	gState->input().update();
+
+	return Qnil;
+}
+
+RB_METHOD(inputPress)
+{
+	RB_UNUSED_PARAM;
+
+	int num;
+	rb_get_args(argc, argv, "i", &num);
+
+	Input::ButtonCode bc = (Input::ButtonCode) num;
+
+	return rb_bool_new(gState->input().isPressed(bc));
+}
+
+RB_METHOD(inputTrigger)
+{
+	RB_UNUSED_PARAM;
+
+	int num;
+	rb_get_args(argc, argv, "i", &num);
+
+	Input::ButtonCode bc = (Input::ButtonCode) num;
+
+	return rb_bool_new(gState->input().isTriggered(bc));
+}
+
+RB_METHOD(inputRepeat)
+{
+	RB_UNUSED_PARAM;
+
+	int num;
+	rb_get_args(argc, argv, "i", &num);
+
+	Input::ButtonCode bc = (Input::ButtonCode) num;
+
+	return rb_bool_new(gState->input().isRepeated(bc));
+}
+
+RB_METHOD(inputDir4)
+{
+	RB_UNUSED_PARAM;
+
+	return rb_fix_new(gState->input().dir4Value());
+}
+
+RB_METHOD(inputDir8)
+{
+	RB_UNUSED_PARAM;
+
+	return rb_fix_new(gState->input().dir8Value());
+}
+
+/* Non-standard extensions */
+RB_METHOD(inputMouseX)
+{
+	RB_UNUSED_PARAM;
+
+	return rb_fix_new(gState->input().mouseX());
+}
+
+RB_METHOD(inputMouseY)
+{
+	RB_UNUSED_PARAM;
+
+	return rb_fix_new(gState->input().mouseY());
+}
+
+#define DEF_CONST_I(name, value) \
+	rb_const_set(module, rb_intern(name), rb_fix_new(value))
+
+void
+inputBindingInit()
+{
+	VALUE module = rb_define_module("Input");
+
+	_rb_define_module_function(module, "update", inputUpdate);
+	_rb_define_module_function(module, "press?", inputPress);
+	_rb_define_module_function(module, "trigger?", inputTrigger);
+	_rb_define_module_function(module, "repeat?", inputRepeat);
+	_rb_define_module_function(module, "dir4", inputDir4);
+	_rb_define_module_function(module, "dir8", inputDir8);
+
+	DEF_CONST_I("DOWN",  Input::Down );
+	DEF_CONST_I("LEFT",  Input::Left );
+	DEF_CONST_I("RIGHT", Input::Right);
+	DEF_CONST_I("UP",    Input::Up   );
+
+	DEF_CONST_I("A",     Input::A    );
+	DEF_CONST_I("B",     Input::B    );
+	DEF_CONST_I("C",     Input::C    );
+	DEF_CONST_I("X",     Input::X    );
+	DEF_CONST_I("Y",     Input::Y    );
+	DEF_CONST_I("Z",     Input::Z    );
+	DEF_CONST_I("L",     Input::L    );
+	DEF_CONST_I("R",     Input::R    );
+
+	DEF_CONST_I("SHIFT", Input::Shift);
+	DEF_CONST_I("CTRL",  Input::Ctrl );
+	DEF_CONST_I("ALT",   Input::Alt  );
+
+	DEF_CONST_I("F5",    Input::F5   );
+	DEF_CONST_I("F6",    Input::F6   );
+	DEF_CONST_I("F7",    Input::F7   );
+	DEF_CONST_I("F8",    Input::F8   );
+	DEF_CONST_I("F9",    Input::F9   );
+
+	_rb_define_module_function(module, "mouse_x", inputMouseX);
+	_rb_define_module_function(module, "mouse_y", inputMouseY);
+
+	DEF_CONST_I("MOUSELEFT",   Input::MouseLeft  );
+	DEF_CONST_I("MOUSEMIDDLE", Input::MouseMiddle);
+	DEF_CONST_I("MOUSERIGHT",  Input::MouseRight );
+}

binding-mri/module_rpg.cpp

@@ -0,0 +1 @@
+#include "module_rpg.rb.xxd"

binding-mri/plane-binding.cpp

@@ -0,0 +1,82 @@
+/*
+** plane-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "plane.h"
+#include "disposable-binding.h"
+#include "viewportelement-binding.h"
+#include "binding-util.h"
+#include "binding-types.h"
+
+DEF_TYPE(Plane);
+
+RB_METHOD(planeInitialize)
+{
+	Plane *p = viewportElementInitialize<Plane>(argc, argv, self);
+
+	setPrivateData(self, p, PlaneType);
+
+	p->setColor(new Color);
+	p->setTone(new Tone);
+
+	wrapNilProperty(self, "bitmap");
+	wrapProperty(self, p->getColor(), "color", ColorType);
+	wrapProperty(self, p->getTone(), "tone", ToneType);
+
+	return self;
+}
+
+#define DISP_CLASS_NAME "plane"
+
+DEF_PROP_OBJ(Plane, Bitmap, Bitmap, "bitmap")
+DEF_PROP_OBJ(Plane, Color, Color, "color")
+DEF_PROP_OBJ(Plane, Tone, Tone, "tone")
+
+DEF_PROP_I(Plane, OX)
+DEF_PROP_I(Plane, OY)
+DEF_PROP_I(Plane, Opacity)
+DEF_PROP_I(Plane, BlendType)
+
+DEF_PROP_F(Plane, ZoomX)
+DEF_PROP_F(Plane, ZoomY)
+
+
+void
+planeBindingInit()
+{
+	INIT_TYPE(Plane);
+
+	VALUE klass = rb_define_class("Plane", rb_cObject);
+
+	disposableBindingInit<Plane>     (klass);
+	viewportElementBindingInit<Plane>(klass);
+
+	_rb_define_method(klass, "initialize", planeInitialize);
+
+	INIT_PROP_BIND( Plane, Bitmap,    "bitmap"     );
+	INIT_PROP_BIND( Plane, OX,        "ox"         );
+	INIT_PROP_BIND( Plane, OY,        "oy"         );
+	INIT_PROP_BIND( Plane, ZoomX,     "zoom_x"     );
+	INIT_PROP_BIND( Plane, ZoomY,     "zoom_y"     );
+	INIT_PROP_BIND( Plane, Opacity,   "opacity"    );
+	INIT_PROP_BIND( Plane, BlendType, "blend_type" );
+	INIT_PROP_BIND( Plane, Color,     "color"      );
+	INIT_PROP_BIND( Plane, Tone,      "tone"       );
+}

binding-mri/sceneelement-binding.h

@@ -0,0 +1,90 @@
+/*
+** sceneelement-binding.h
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef SCENEELEMENTBINDING_H
+#define SCENEELEMENTBINDING_H
+
+#include "scene.h"
+#include "binding-util.h"
+
+template<class C>
+RB_METHOD(sceneElementGetZ)
+{
+	RB_UNUSED_PARAM;
+
+	SceneElement *se = getPrivateData<C>(self);
+
+	int value = 0;
+	GUARD_EXC( value = se->getZ(); );
+
+	return rb_fix_new(value);
+}
+
+template<class C>
+RB_METHOD(sceneElementSetZ)
+{
+	SceneElement *se = getPrivateData<C>(self);
+
+	int z;
+	rb_get_args(argc, argv, "i", &z);
+
+	GUARD_EXC( se->setZ(z); );
+
+	return rb_fix_new(z);
+}
+
+template<class C>
+RB_METHOD(sceneElementGetVisible)
+{
+	RB_UNUSED_PARAM;
+
+	SceneElement *se = getPrivateData<C>(self);
+
+	bool value = false;
+	GUARD_EXC( value = se->getVisible(); );
+
+	return rb_bool_new(value);
+}
+
+template<class C>
+RB_METHOD(sceneElementSetVisible)
+{
+	SceneElement *se = getPrivateData<C>(self);
+
+	bool visible;
+	rb_get_args(argc, argv, "b", &visible);
+
+	GUARD_EXC( se->setVisible(visible); );
+
+    return rb_bool_new(visible);
+}
+
+template<class C>
+void
+sceneElementBindingInit(VALUE klass)
+{
+	_rb_define_method(klass, "z",        sceneElementGetZ<C>);
+	_rb_define_method(klass, "z=",       sceneElementSetZ<C>);
+	_rb_define_method(klass, "visible",  sceneElementGetVisible<C>);
+	_rb_define_method(klass, "visible=", sceneElementSetVisible<C>);
+}
+
+#endif // SCENEELEMENTBINDING_H

binding-mri/serializable-binding.h

@@ -0,0 +1,51 @@
+/*
+** serializable-binding.h
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef SERIALIZABLEBINDING_H
+#define SERIALIZABLEBINDING_H
+
+#include "serializable.h"
+#include "binding-util.h"
+#include "exception.h"
+
+template<class C>
+static VALUE
+serializableDump(int, VALUE *, VALUE self)
+{
+	Serializable *s = getPrivateData<C>(self);
+
+	int dataSize = s->serialSize();
+
+	VALUE data = rb_str_new(0, dataSize);
+
+	GUARD_EXC( s->serialize(RSTRING_PTR(data)); );
+
+	return data;
+}
+
+template<class C>
+void
+serializableBindingInit(VALUE klass)
+{
+	_rb_define_method(klass, "_dump", serializableDump<C>);
+}
+
+#endif // SERIALIZABLEBINDING_H

binding-mri/sprite-binding.cpp

@@ -0,0 +1,100 @@
+/*
+** sprite-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "sprite.h"
+#include "disposable-binding.h"
+#include "flashable-binding.h"
+#include "sceneelement-binding.h"
+#include "viewportelement-binding.h"
+#include "binding-util.h"
+#include "binding-types.h"
+
+DEF_TYPE(Sprite);
+
+RB_METHOD(spriteInitialize)
+{
+	Sprite *s = viewportElementInitialize<Sprite>(argc, argv, self);
+
+	setPrivateData(self, s, SpriteType);
+
+	/* Wrap property objects */
+	s->setSrcRect(new Rect);
+	s->setColor(new Color);
+	s->setTone(new Tone);
+
+	wrapNilProperty(self, "bitmap");
+	wrapProperty(self, s->getSrcRect(), "src_rect", RectType);
+	wrapProperty(self, s->getColor(), "color", ColorType);
+	wrapProperty(self, s->getTone(), "tone", ToneType);
+
+	return self;
+}
+
+#define DISP_CLASS_NAME "sprite"
+
+DEF_PROP_OBJ_NIL(Sprite, Bitmap, Bitmap,  "bitmap")
+DEF_PROP_OBJ(Sprite, Rect,   SrcRect, "src_rect")
+DEF_PROP_OBJ(Sprite, Color,  Color,   "color")
+DEF_PROP_OBJ(Sprite, Tone,   Tone,    "tone")
+
+DEF_PROP_I(Sprite, X)
+DEF_PROP_I(Sprite, Y)
+DEF_PROP_I(Sprite, OX)
+DEF_PROP_I(Sprite, OY)
+DEF_PROP_I(Sprite, BushDepth)
+DEF_PROP_I(Sprite, Opacity)
+DEF_PROP_I(Sprite, BlendType)
+
+DEF_PROP_F(Sprite, ZoomX)
+DEF_PROP_F(Sprite, ZoomY)
+DEF_PROP_F(Sprite, Angle)
+
+DEF_PROP_B(Sprite, Mirror)
+
+void
+spriteBindingInit()
+{
+	INIT_TYPE(Sprite);
+
+	VALUE klass = rb_define_class("Sprite", rb_cObject);
+
+	disposableBindingInit     <Sprite>(klass);
+	flashableBindingInit      <Sprite>(klass);
+	viewportElementBindingInit<Sprite>(klass);
+
+	_rb_define_method(klass, "initialize", spriteInitialize);
+
+	INIT_PROP_BIND( Sprite, Bitmap,    "bitmap"     );
+	INIT_PROP_BIND( Sprite, SrcRect,   "src_rect"   );
+	INIT_PROP_BIND( Sprite, X,         "x"          );
+	INIT_PROP_BIND( Sprite, Y,         "y"          );
+	INIT_PROP_BIND( Sprite, OX,        "ox"         );
+	INIT_PROP_BIND( Sprite, OY,        "oy"         );
+	INIT_PROP_BIND( Sprite, ZoomX,     "zoom_x"     );
+	INIT_PROP_BIND( Sprite, ZoomY,     "zoom_y"     );
+	INIT_PROP_BIND( Sprite, Angle,     "angle"      );
+	INIT_PROP_BIND( Sprite, Mirror,    "mirror"     );
+	INIT_PROP_BIND( Sprite, BushDepth, "bush_depth" );
+	INIT_PROP_BIND( Sprite, Opacity,   "opacity"    );
+	INIT_PROP_BIND( Sprite, BlendType, "blend_type" );
+	INIT_PROP_BIND( Sprite, Color,     "color"      );
+	INIT_PROP_BIND( Sprite, Tone,      "tone"       );
+}

binding-mri/table-binding.cpp

@@ -0,0 +1,162 @@
+/*
+** table-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "table.h"
+#include "binding-util.h"
+#include "serializable-binding.h"
+
+DEF_TYPE(Table);
+
+RB_METHOD(tableInitialize)
+{
+	int x, y, z;
+	x = y = z = 1;
+
+	rb_get_args(argc, argv, "i|ii", &x, &y, &z);
+
+	Table *t = new Table(x, y, z);
+
+	setPrivateData(self, t, TableType);
+
+	return self;
+}
+
+RB_METHOD(tableResize)
+{
+	Table *t = getPrivateData<Table>(self);
+
+	switch (argc)
+	{
+	default:
+	case 1:
+		t->resize(rb_fix2int(argv[0]));
+		return Qnil;
+
+	case 2:
+		t->resize(rb_fix2int(argv[0]),
+		          rb_fix2int(argv[1]));
+		return Qnil;
+
+	case 3:
+		t->resize(rb_fix2int(argv[0]),
+		          rb_fix2int(argv[1]),
+		          rb_fix2int(argv[2]));
+		return Qnil;
+	}
+}
+
+#define TABLE_SIZE(d, D) \
+	RB_METHOD(table##D##Size) \
+	{ \
+		RB_UNUSED_PARAM \
+		Table *t = getPrivateData<Table>(self); \
+		return rb_int2inum(t->d##Size()); \
+	}
+
+TABLE_SIZE(x, X)
+TABLE_SIZE(y, Y)
+TABLE_SIZE(z, Z)
+
+RB_METHOD(tableGetAt)
+{
+	Table *t = getPrivateData<Table>(self);
+
+	int x, y, z;
+	x = y = z = 0;
+
+	x = rb_num2int(argv[0]);
+	if (argc > 1)
+		y = rb_num2int(argv[1]);
+	if (argc > 2)
+		z = rb_num2int(argv[2]);
+
+	if (argc > 3)
+		rb_raise(rb_eArgError, "wrong number of arguments");
+
+	if (x < 0 || x >= t->xSize()
+	||  y < 0 || y >= t->ySize()
+	||  z < 0 || z >= t->zSize())
+	{
+		return Qnil;
+	}
+
+	int result = t->get(x, y, z);
+
+	return rb_int2inum(result);
+}
+
+RB_METHOD(tableSetAt)
+{
+	Table *t = getPrivateData<Table>(self);
+
+	int x, y, z, value;
+	x = y = z = 0;
+
+	if (argc < 2)
+		rb_raise(rb_eArgError, "wrong number of arguments");
+
+	switch (argc)
+	{
+	default:
+	case 2 :
+		x = rb_fix2int(argv[0]);
+		value = rb_fix2int(argv[1]);
+		break;
+	case 3 :
+		x = rb_fix2int(argv[0]);
+		y = rb_fix2int(argv[1]);
+		value = rb_fix2int(argv[2]);
+		break;
+	case 4 :
+		x = rb_fix2int(argv[0]);
+		y = rb_fix2int(argv[1]);
+		z = rb_fix2int(argv[2]);
+		value = rb_fix2int(argv[3]);
+		break;
+	}
+
+	t->set(value, x, y, z);
+
+	return rb_int2inum(value);
+}
+
+MARSH_LOAD_FUN(Table)
+
+void
+tableBindingInit()
+{
+	INIT_TYPE(Table);
+
+	VALUE klass = rb_define_class("Table", rb_cObject);
+
+	serializableBindingInit<Table>(klass);
+
+	rb_define_class_method(klass, "_load", TableLoad);
+
+	_rb_define_method(klass, "initialize", tableInitialize);
+	_rb_define_method(klass, "resize", tableResize);
+	_rb_define_method(klass, "xsize", tableXSize);
+	_rb_define_method(klass, "ysize", tableYSize);
+	_rb_define_method(klass, "zsize", tableZSize);
+	_rb_define_method(klass, "[]", tableGetAt);
+	_rb_define_method(klass, "[]=", tableSetAt);
+
+}

binding-mri/tilemap-binding.cpp

@@ -0,0 +1,160 @@
+/*
+** tilemap-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "tilemap.h"
+#include "viewport.h"
+#include "bitmap.h"
+#include "table.h"
+
+#include "disposable-binding.h"
+#include "binding-util.h"
+#include "binding-types.h"
+
+static rb_data_type_struct TilemapAutotilesType;
+
+RB_METHOD(tilemapAutotilesSet)
+{
+	Tilemap::Autotiles *a = getPrivateData<Tilemap::Autotiles>(self);
+
+	int i;
+	VALUE bitmapObj;
+
+	rb_get_args(argc, argv, "io", &i, &bitmapObj);
+
+	Bitmap *bitmap = getPrivateDataCheck<Bitmap>(bitmapObj, BitmapType);
+
+	a->set(i, bitmap);
+
+	VALUE ary = rb_iv_get(self, "array");
+	rb_ary_store(ary, i, bitmapObj);
+
+	return self;
+}
+
+RB_METHOD(tilemapAutotilesGet)
+{
+	int i;
+	rb_get_args (argc, argv, "i", &i);
+
+	if (i < 0 || i > 6)
+		return Qnil;
+
+	VALUE ary = rb_iv_get(self, "array");
+
+	return rb_ary_entry(ary, i);
+}
+
+DEF_TYPE(Tilemap);
+
+RB_METHOD(tilemapInitialize)
+{
+	Tilemap *t;
+
+	/* Get parameters */
+	VALUE viewportObj = Qnil;
+	Viewport *viewport = 0;
+
+	rb_get_args(argc, argv, "|o", &viewportObj);
+
+	if (rb_type(viewportObj) != RUBY_T_NIL)
+		viewport = getPrivateDataCheck<Viewport>(viewportObj, ViewportType);
+
+	/* Construct object */
+	t = new Tilemap(viewport);
+
+	setPrivateData(self, t, TilemapType);
+
+	rb_iv_set(self, "viewport", viewportObj);
+
+	wrapProperty(self, &t->getAutotiles(), "autotiles", TilemapAutotilesType);
+
+	VALUE autotilesObj = rb_iv_get(self, "autotiles");
+
+	VALUE ary = rb_ary_new2(7);
+	for (int i = 0; i < 7; ++i)
+		rb_ary_push(ary, Qnil);
+
+	rb_iv_set(autotilesObj, "array", ary);
+
+	return self;
+}
+
+RB_METHOD(tilemapGetAutotiles)
+{
+	RB_UNUSED_PARAM;
+
+	return rb_iv_get(self, "autotiles");
+}
+
+RB_METHOD(tilemapUpdate)
+{
+	RB_UNUSED_PARAM;
+
+	Tilemap *t = getPrivateData<Tilemap>(self);
+
+	t->update();
+
+	return Qnil;
+}
+
+#define DISP_CLASS_NAME "tilemap"
+
+DEF_PROP_OBJ(Tilemap, Viewport, Viewport,   "viewport")
+DEF_PROP_OBJ(Tilemap, Bitmap,   Tileset,    "tileset")
+DEF_PROP_OBJ(Tilemap, Table,    MapData,    "map_data")
+DEF_PROP_OBJ(Tilemap, Table,    FlashData,  "flash_data")
+DEF_PROP_OBJ(Tilemap, Table,    Priorities, "priorities")
+
+DEF_PROP_B(Tilemap, Visible)
+
+DEF_PROP_I(Tilemap, OX)
+DEF_PROP_I(Tilemap, OY)
+
+void
+tilemapBindingInit()
+{
+	initType(TilemapAutotilesType, "TilemapAutotiles", 0);
+
+	VALUE klass = rb_define_class("TilemapAutotiles", rb_cObject);
+
+	_rb_define_method(klass, "[]=", tilemapAutotilesSet);
+	_rb_define_method(klass, "[]", tilemapAutotilesGet);
+
+	INIT_TYPE(Tilemap);
+
+	klass = rb_define_class("Tilemap", rb_cObject);
+
+	disposableBindingInit<Tilemap>(klass);
+
+	_rb_define_method(klass, "initialize", tilemapInitialize);
+	_rb_define_method(klass, "autotiles", tilemapGetAutotiles);
+	_rb_define_method(klass, "update", tilemapUpdate);
+
+	INIT_PROP_BIND( Tilemap, Viewport,   "viewport"   );
+	INIT_PROP_BIND( Tilemap, Tileset,    "tileset"    );
+	INIT_PROP_BIND( Tilemap, MapData,    "map_data"   );
+	INIT_PROP_BIND( Tilemap, FlashData,  "flash_data" );
+	INIT_PROP_BIND( Tilemap, Priorities, "priorities" );
+	INIT_PROP_BIND( Tilemap, Visible,    "visible"    );
+	INIT_PROP_BIND( Tilemap, OX,         "ox"         );
+	INIT_PROP_BIND( Tilemap, OY,         "oy"         );
+}
+

binding-mri/viewport-binding.cpp

@@ -0,0 +1,100 @@
+/*
+** viewport-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "viewport.h"
+#include "disposable-binding.h"
+#include "flashable-binding.h"
+#include "sceneelement-binding.h"
+#include "binding-util.h"
+#include "binding-types.h"
+
+DEF_TYPE(Viewport);
+
+RB_METHOD(viewportInitialize)
+{
+	Viewport *v;
+
+	if (argc == 1)
+	{
+		/* The rect arg is only used to init the viewport,
+		 * and does NOT replace its 'rect' property */
+		VALUE rectObj;
+		Rect *rect;
+
+		rb_get_args(argc, argv, "o", &rectObj);
+
+		rect = getPrivateDataCheck<Rect>(rectObj, RectType);
+
+		v = new Viewport(rect);
+	}
+	else
+	{
+		int x, y, width, height;
+
+		rb_get_args(argc, argv, "iiii", &x, &y, &width, &height);
+
+		v = new Viewport(x, y, width, height);
+	}
+
+	setPrivateData(self, v, ViewportType);
+
+	/* Wrap property objects */
+	v->setRect(new Rect(*v->getRect()));
+	v->setColor(new Color);
+	v->setTone(new Tone);
+
+	wrapProperty(self, v->getRect(),  "rect",  RectType);
+	wrapProperty(self, v->getColor(), "color", ColorType);
+	wrapProperty(self, v->getTone(),  "tone",  ToneType);
+
+	return self;
+}
+
+#define DISP_CLASS_NAME "viewport"
+
+DEF_PROP_OBJ(Viewport, Rect, Rect, "rect")
+DEF_PROP_OBJ(Viewport, Color, Color, "color")
+DEF_PROP_OBJ(Viewport, Tone, Tone, "tone")
+
+DEF_PROP_I(Viewport, OX)
+DEF_PROP_I(Viewport, OY)
+
+
+void
+viewportBindingInit()
+{
+	INIT_TYPE(Viewport);
+
+	VALUE klass = rb_define_class("Viewport", rb_cObject);
+
+	disposableBindingInit  <Viewport>(klass);
+	flashableBindingInit   <Viewport>(klass);
+	sceneElementBindingInit<Viewport>(klass);
+
+	_rb_define_method(klass, "initialize", viewportInitialize);
+
+	INIT_PROP_BIND( Viewport, Rect,  "rect"  );
+	INIT_PROP_BIND( Viewport, OX,    "ox"    );
+	INIT_PROP_BIND( Viewport, OY,    "oy"    );
+	INIT_PROP_BIND( Viewport, Color, "color" );
+	INIT_PROP_BIND( Viewport, Tone,  "tone"  );
+}
+

binding-mri/viewportelement-binding.h

@@ -0,0 +1,74 @@
+/*
+** viewportelement-binding.h
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef VIEWPORTELEMENTBINDING_H
+#define VIEWPORTELEMENTBINDING_H
+
+#include "viewport.h"
+#include "binding-util.h"
+#include "binding-types.h"
+
+#include "sceneelement-binding.h"
+
+template<class C>
+RB_METHOD(viewportElementGetViewport)
+{
+	RB_UNUSED_PARAM;
+
+	ViewportElement *ve = getPrivateData<C>(self);
+
+	GUARD_EXC( ve->aboutToAccess(); );
+
+	return rb_iv_get(self, "viewport");
+}
+
+template<class C>
+static C *
+viewportElementInitialize(int argc, VALUE *argv, VALUE self)
+{
+	/* Get parameters */
+	VALUE viewportObj = Qnil;
+	Viewport *viewport = 0;
+
+	rb_get_args(argc, argv, "|o", &viewportObj);
+
+	if (rb_type(viewportObj) != RUBY_T_NIL)
+		viewport = getPrivateDataCheck<Viewport>(viewportObj, ViewportType);
+
+	/* Construct object */
+	C *ve = new C(viewport);
+
+	/* Set property objects */
+	rb_iv_set(self, "viewport", viewportObj);
+
+	return ve;
+}
+
+template<class C>
+void
+viewportElementBindingInit(VALUE klass)
+{
+	sceneElementBindingInit<C>(klass);
+
+	_rb_define_method(klass, "viewport", viewportElementGetViewport<C>);
+}
+
+#endif // VIEWPORTELEMENTBINDING_H

binding-mri/window-binding.cpp

@@ -0,0 +1,103 @@
+/*
+** window-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "window.h"
+#include "disposable-binding.h"
+#include "viewportelement-binding.h"
+#include "binding-util.h"
+
+DEF_TYPE(Window);
+
+RB_METHOD(windowInitialize)
+{
+	Window *w = viewportElementInitialize<Window>(argc, argv, self);
+
+	setPrivateData(self, w, WindowType);
+
+	w->setCursorRect(new Rect);
+	wrapNilProperty(self, "windowskin");
+	wrapNilProperty(self, "contents");
+	wrapProperty(self, w->getCursorRect(), "cursor_rect", RectType);
+
+	return self;
+}
+
+RB_METHOD(windowUpdate)
+{
+	RB_UNUSED_PARAM;
+
+	Window *w = getPrivateData<Window>(self);
+
+	w->update();
+
+	return Qnil;
+}
+
+#define DISP_CLASS_NAME "window"
+
+DEF_PROP_OBJ_NIL(Window, Bitmap, Windowskin, "windowskin")
+DEF_PROP_OBJ_NIL(Window, Bitmap, Contents,   "contents")
+DEF_PROP_OBJ(Window, Rect, CursorRect, "cursor_rect")
+
+DEF_PROP_B(Window, Stretch)
+DEF_PROP_B(Window, Active)
+DEF_PROP_B(Window, Pause)
+
+DEF_PROP_I(Window, X)
+DEF_PROP_I(Window, Y)
+DEF_PROP_I(Window, Width)
+DEF_PROP_I(Window, Height)
+DEF_PROP_I(Window, OX)
+DEF_PROP_I(Window, OY)
+DEF_PROP_I(Window, Opacity)
+DEF_PROP_I(Window, BackOpacity)
+DEF_PROP_I(Window, ContentsOpacity)
+
+
+void
+windowBindingInit()
+{
+	INIT_TYPE(Window);
+
+	VALUE klass = rb_define_class("Window", rb_cObject);
+
+	disposableBindingInit     <Window>(klass);
+	viewportElementBindingInit<Window>(klass);
+
+	_rb_define_method(klass, "initialize", windowInitialize);
+	_rb_define_method(klass, "update",     windowUpdate);
+
+	INIT_PROP_BIND( Window, Windowskin,      "windowskin"       );
+	INIT_PROP_BIND( Window, Contents,        "contents"         );
+	INIT_PROP_BIND( Window, Stretch,         "stretch"          );
+	INIT_PROP_BIND( Window, CursorRect,      "cursor_rect"      );
+	INIT_PROP_BIND( Window, Active,          "active"           );
+	INIT_PROP_BIND( Window, Pause,           "pause"            );
+	INIT_PROP_BIND( Window, X,               "x"                );
+	INIT_PROP_BIND( Window, Y,               "y"                );
+	INIT_PROP_BIND( Window, Width,           "width"            );
+	INIT_PROP_BIND( Window, Height,          "height"           );
+	INIT_PROP_BIND( Window, OX,              "ox"               );
+	INIT_PROP_BIND( Window, OY,              "oy"               );
+	INIT_PROP_BIND( Window, Opacity,         "opacity"          );
+	INIT_PROP_BIND( Window, BackOpacity,     "back_opacity"     );
+	INIT_PROP_BIND( Window, ContentsOpacity, "contents_opacity" );
+}

binding-mruby/audio-binding.cpp

@@ -0,0 +1,88 @@
+/*
+** audio-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "audio.h"
+#include "globalstate.h"
+#include "binding-util.h"
+#include "exception.h"
+
+#define DEF_PLAY_STOP(entity) \
+	MRB_METHOD(audio_##entity##Play) \
+	{ \
+		MRB_UNUSED_PARAM; \
+		char *filename; \
+		mrb_int volume = 100; \
+		mrb_int pitch = 100; \
+		mrb_get_args(mrb, "z|ii", &filename, &volume, &pitch); \
+		GUARD_EXC( gState->audio().entity##Play(filename, volume, pitch); ) \
+		return mrb_nil_value(); \
+	} \
+	MRB_METHOD(audio_##entity##Stop) \
+	{ \
+		MRB_UNUSED_PARAM; \
+		gState->audio().entity##Stop(); \
+		return mrb_nil_value(); \
+	}
+
+#define DEF_FADE(entity) \
+MRB_METHOD(audio_##entity##Fade) \
+{ \
+	MRB_UNUSED_PARAM; \
+	mrb_int time; \
+	mrb_get_args(mrb, "i", &time); \
+	gState->audio().entity##Fade(time); \
+	return mrb_nil_value(); \
+}
+
+#define DEF_PLAY_STOP_FADE(entity) \
+	DEF_PLAY_STOP(entity) \
+	DEF_FADE(entity)
+
+DEF_PLAY_STOP_FADE( bgm )
+DEF_PLAY_STOP_FADE( bgs )
+DEF_PLAY_STOP_FADE( me  )
+
+DEF_PLAY_STOP( se  )
+
+
+#define BIND_PLAY_STOP(entity) \
+	mrb_define_module_function(mrb, module, #entity "_play", audio_##entity##Play, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(2)); \
+	mrb_define_module_function(mrb, module, #entity "_stop", audio_##entity##Stop, MRB_ARGS_NONE());
+
+#define BIND_FADE(entity) \
+	mrb_define_module_function(mrb, module, #entity "_fade", audio_##entity##Fade, MRB_ARGS_REQ(1));
+
+#define BIND_PLAY_STOP_FADE(entity) \
+	BIND_PLAY_STOP(entity) \
+	BIND_FADE(entity)
+
+
+void
+audioBindingInit(mrb_state *mrb)
+{
+	RClass *module = mrb_define_module(mrb, "Audio");
+
+	BIND_PLAY_STOP_FADE( bgm )
+	BIND_PLAY_STOP_FADE( bgs )
+	BIND_PLAY_STOP_FADE( me  )
+
+	BIND_PLAY_STOP( se )
+}

binding-mruby/binding-mruby.cpp

@@ -0,0 +1,356 @@
+/*
+** binding-mruby.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "binding.h"
+
+#include "mruby.h"
+#include "mruby/string.h"
+#include "mruby/array.h"
+#include "mruby/class.h"
+#include "mruby/irep.h"
+#include "mruby/compile.h"
+#include "mruby/proc.h"
+
+#include "binding-util.h"
+
+#include "stdio.h"
+#include "zlib.h"
+
+#include "SDL2/SDL_messagebox.h"
+#include "SDL2/SDL_rwops.h"
+#include "SDL2/SDL_timer.h"
+
+#include "globalstate.h"
+#include "texpool.h"
+#include "eventthread.h"
+#include "filesystem.h"
+
+#include "binding-types.h"
+#include "mrb-ext/marshal.h"
+
+void mrbBindingExecute();
+void mrbBindingTerminate();
+
+ScriptBinding scriptBindingImpl =
+{
+    mrbBindingExecute,
+    mrbBindingTerminate
+};
+
+ScriptBinding *scriptBinding = &scriptBindingImpl;
+
+
+void fileBindingInit(mrb_state *);
+void timeBindingInit(mrb_state *);
+void marshalBindingInit(mrb_state *);
+void kernelBindingInit(mrb_state *);
+
+void tableBindingInit(mrb_state *);
+void etcBindingInit(mrb_state *);
+void fontBindingInit(mrb_state *);
+void bitmapBindingInit(mrb_state *);
+void spriteBindingInit(mrb_state *);
+void planeBindingInit(mrb_state *);
+void viewportBindingInit(mrb_state *);
+void windowBindingInit(mrb_state *);
+void tilemapBindingInit(mrb_state *);
+
+void inputBindingInit(mrb_state *);
+void audioBindingInit(mrb_state *);
+void graphicsBindingInit(mrb_state *);
+
+/* From module_rpg.c */
+extern const uint8_t mrbModuleRPG[];
+
+static void mrbBindingInit(mrb_state *mrb)
+{
+	int arena = mrb_gc_arena_save(mrb);
+
+	/* Init standard classes */
+	fileBindingInit(mrb);
+	timeBindingInit(mrb);
+	marshalBindingInit(mrb);
+	kernelBindingInit(mrb);
+
+	/* Init RGSS classes */
+	tableBindingInit(mrb);
+	etcBindingInit(mrb);
+	fontBindingInit(mrb);
+	bitmapBindingInit(mrb);
+	spriteBindingInit(mrb);
+	planeBindingInit(mrb);
+	viewportBindingInit(mrb);
+	windowBindingInit(mrb);
+	tilemapBindingInit(mrb);
+
+	/* Init RGSS modules */
+	inputBindingInit(mrb);
+	audioBindingInit(mrb);
+	graphicsBindingInit(mrb);
+
+	/* Load RPG module */
+	mrb_load_irep(mrb, mrbModuleRPG);
+
+	mrb_define_global_const(mrb, "MKXP", mrb_true_value());
+
+	mrb_gc_arena_restore(mrb, arena);
+}
+
+static mrb_value
+mkxpTimeOp(mrb_state *mrb, mrb_value)
+{
+	const char *opName;
+	mrb_value block;
+
+	mrb_get_args(mrb, "z&", &opName, &block);
+
+	Uint64 start = SDL_GetPerformanceCounter();
+
+	mrb_yield(mrb, block, mrb_nil_value());
+
+	Uint64 diff = SDL_GetPerformanceCounter() - start;
+	double sec = (double) diff / SDL_GetPerformanceFrequency();
+	float ms = sec * 1000;
+
+	printf("<%s> [%f ms]\n", opName, ms);
+	fflush(stdout);
+
+	return mrb_nil_value();
+}
+
+static mrb_value
+mkxpEvalBlock(mrb_state *mrb, mrb_value)
+{
+	mrb_value block;
+	mrb_get_args(mrb, "&", &block);
+
+//	mrb_yield_argv(mrb, block, 0, 0);
+
+	mrb_run(mrb, mrb_proc_ptr(block), mrb_obj_value(mrb->top_self));
+
+	if (mrb->exc)
+	{
+		qDebug() << "Got exc!" << mrb_class_name(mrb, mrb_class(mrb, mrb_obj_value(mrb->exc)));
+	}
+
+	return mrb_nil_value();
+}
+
+static const char *
+mrbValueString(mrb_value value)
+{
+	return mrb_string_p(value) ? RSTRING_PTR(value) : 0;
+}
+
+static void
+showExcMessageBox(mrb_state *mrb, mrb_value exc)
+{
+	/* Display actual exception in a message box */
+	mrb_value mesg = mrb_funcall(mrb, exc, "message", 0);
+	mrb_value line = mrb_attr_get(mrb, exc, mrb_intern2(mrb, "line", 4));
+	mrb_value file = mrb_attr_get(mrb, exc, mrb_intern2(mrb, "file", 4));
+	const char *excClass = mrb_class_name(mrb, mrb_class(mrb, exc));
+
+	char msgBoxText[512];
+	snprintf(msgBoxText, 512, "Script '%s' line %d: %s occured.\n\n%s",
+	         mrbValueString(file), mrb_fixnum(line), excClass, mrbValueString(mesg));
+
+	gState->eThread().showMessageBox(msgBoxText, SDL_MESSAGEBOX_ERROR);
+}
+
+static void
+checkException(mrb_state *mrb)
+{
+	if (!mrb->exc)
+		return;
+
+	mrb_value exc = mrb_obj_value(mrb->exc);
+	MrbData &mrbData = *getMrbData(mrb);
+
+	/* Check if an actual exception occured, or just a shutdown was called */
+	if (mrb_obj_class(mrb, exc) != mrbData.exc[Shutdown])
+		showExcMessageBox(mrb, exc);
+}
+
+
+static void
+showError(const QByteArray &msg)
+{
+	gState->eThread().showMessageBox(msg.constData());
+}
+
+static void
+runCustomScript(mrb_state *mrb, mrbc_context *ctx, const char *filename)
+{
+	/* Execute custom script */
+	FILE *f = fopen(filename, "r");
+
+	if (!f)
+	{
+		static char buffer[256];
+		snprintf(buffer, sizeof(buffer), "Unable to open script '%s'", filename);
+		showError(buffer);
+
+		return;
+	}
+
+	ctx->filename = strdup(filename);
+	ctx->lineno = 1;
+
+	/* Run code */
+	mrb_load_file_cxt(mrb, f, ctx);
+
+	free(ctx->filename);
+	fclose(f);
+}
+
+static void
+runRMXPScripts(mrb_state *mrb, mrbc_context *ctx)
+{
+	const QByteArray &scriptLoc = gState->rtData().config.game.scripts;
+
+	if (!gState->fileSystem().exists(scriptLoc.constData()))
+	{
+		showError("Unable to open '" + scriptLoc + "'");
+		return;
+	}
+
+	/* We use a secondary util state to unmarshal the scripts */
+	mrb_state *scriptMrb = mrb_open();
+	SDL_RWops ops;
+
+	gState->fileSystem().openRead(ops, scriptLoc.constData());
+
+	mrb_value scriptArray = marshalLoadInt(scriptMrb, &ops);
+	SDL_RWclose(&ops);
+
+	if (!mrb_array_p(scriptArray))
+	{
+		showError("Failed to read script data");
+		mrb_close(scriptMrb);
+		return;
+	}
+
+	int scriptCount = mrb_ary_len(scriptMrb, scriptArray);
+
+	QByteArray decodeBuffer;
+	decodeBuffer.resize(0x1000);
+
+	for (int i = 0; i < scriptCount; ++i)
+	{
+		mrb_value script = mrb_ary_entry(scriptArray, i);
+
+		mrb_value scriptChksum = mrb_ary_entry(script, 0);
+		mrb_value scriptName   = mrb_ary_entry(script, 1);
+		mrb_value scriptString = mrb_ary_entry(script, 2);
+
+		(void) scriptChksum;
+
+		int result = Z_OK;
+		ulong bufferLen;
+
+		while (true)
+		{
+			unsigned char *bufferPtr =
+			        reinterpret_cast<unsigned char*>(const_cast<char*>(decodeBuffer.constData()));
+			unsigned char *sourcePtr =
+			        reinterpret_cast<unsigned char*>(RSTRING_PTR(scriptString));
+
+			bufferLen = decodeBuffer.length();
+
+			result = uncompress(bufferPtr, &bufferLen,
+			                    sourcePtr, RSTRING_LEN(scriptString));
+
+			bufferPtr[bufferLen] = '\0';
+
+			if (result != Z_BUF_ERROR)
+				break;
+
+			decodeBuffer.resize(decodeBuffer.size()*2);
+		}
+
+		if (result != Z_OK)
+		{
+			static char buffer[256];
+			snprintf(buffer, sizeof(buffer), "Error decoding script %d: '%s'",
+			         i, RSTRING_PTR(scriptName));
+
+			showError(buffer);
+			break;
+		}
+
+		ctx->filename = RSTRING_PTR(scriptName);
+		ctx->lineno = 1;
+
+		int ai = mrb_gc_arena_save(mrb);
+
+		/* Execute code */
+		mrb_load_nstring_cxt(mrb, decodeBuffer.constData(), bufferLen, ctx);
+
+		mrb_gc_arena_restore(mrb, ai);
+
+		if (mrb->exc)
+			break;
+	}
+
+	mrb_close(scriptMrb);
+}
+
+void mrbBindingExecute()
+{
+	mrb_state *mrb = mrb_open();
+
+	gState->setBindingData(mrb);
+
+	MrbData mrbData(mrb);
+	mrb->ud = &mrbData;
+
+	RClass *mkxpMod = mrb_define_module(mrb, "MKXP");
+	mrb_define_module_function(mrb, mkxpMod, "time_op", mkxpTimeOp, MRB_ARGS_REQ(1) | MRB_ARGS_BLOCK());
+	mrb_define_module_function(mrb, mkxpMod, "eval_block", mkxpEvalBlock, MRB_ARGS_BLOCK());
+
+	mrbBindingInit(mrb);
+
+	mrbc_context *ctx = mrbc_context_new(mrb);
+	ctx->capture_errors = 1;
+
+	QByteArray &customScript = gState->rtData().config.customScript;
+	if (!customScript.isEmpty())
+		runCustomScript(mrb, ctx, customScript.constData());
+	else
+		runRMXPScripts(mrb, ctx);
+
+	checkException(mrb);
+
+	gState->rtData().rqTermAck = true;
+	gState->texPool().disable();
+
+	mrbc_context_free(mrb, ctx);
+	mrb_close(mrb);
+}
+
+void mrbBindingTerminate()
+{
+	mrb_state *mrb = static_cast<mrb_state*>(gState->bindingData());
+	MrbData *data = static_cast<MrbData*>(mrb->ud);
+
+	mrb_raise(mrb, data->exc[Shutdown], "");
+}

binding-mruby/binding-types.h

@@ -0,0 +1,40 @@
+/*
+** binding-types.h
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef BINDINGTYPES_H
+#define BINDINGTYPES_H
+
+#include "binding-util.h"
+
+DECL_TYPE(Table);
+DECL_TYPE(Rect);
+DECL_TYPE(Color);
+DECL_TYPE(Tone);
+DECL_TYPE(Font);
+
+DECL_TYPE(Bitmap);
+DECL_TYPE(Sprite);
+DECL_TYPE(Plane);
+DECL_TYPE(Viewport);
+DECL_TYPE(Tilemap);
+DECL_TYPE(Window);
+
+#endif // BINDINGTYPES_H

binding-mruby/binding-util.cpp

@@ -0,0 +1,167 @@
+/*
+** binding-util.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "binding-util.h"
+#include "util.h"
+#include "exception.h"
+
+#define SYMD(symbol) { CS##symbol, #symbol }
+
+struct
+{
+	CommonSymbol ind;
+	const char *str;
+} static const symData[] =
+{
+	SYMD(priv_iv),
+	SYMD(font),
+	SYMD(viewport),
+	SYMD(bitmap),
+	SYMD(color),
+	SYMD(tone),
+	SYMD(rect),
+	SYMD(src_rect),
+	SYMD(tileset),
+	SYMD(autotiles),
+	SYMD(map_data),
+	SYMD(flash_data),
+	SYMD(priorities),
+	SYMD(windowskin),
+	SYMD(contents),
+	SYMD(cursor_rect),
+	SYMD(path),
+	SYMD(array),
+	SYMD(default_color)
+};
+
+static elementsN(symData);
+
+struct MrbExcData
+{
+	MrbException ind;
+	const char *str;
+};
+
+static const MrbExcData excData[] =
+{
+	{ Shutdown, "SystemExit"  },
+	{ RGSS,     "RGSSError"   },
+	{ PHYSFS,   "PHYSFSError" },
+	{ SDL,      "SDLError"    },
+    { IO,       "IOError"     }
+};
+
+static elementsN(excData);
+
+#define ENO(id) { Errno##id, #id }
+
+static const MrbExcData enoExcData[] =
+{
+    ENO(E2BIG),
+    ENO(EACCES),
+    ENO(EAGAIN),
+    ENO(EBADF),
+    ENO(ECHILD),
+    ENO(EDEADLOCK),
+    ENO(EDOM),
+    ENO(EEXIST),
+    ENO(EINVAL),
+    ENO(EMFILE),
+    ENO(ENOENT),
+    ENO(ENOEXEC),
+    ENO(ENOMEM),
+    ENO(ENOSPC),
+    ENO(ERANGE),
+    ENO(EXDEV)
+};
+
+static elementsN(enoExcData);
+
+MrbData::MrbData(mrb_state *mrb)
+{
+	int arena = mrb_gc_arena_save(mrb);
+
+	for (int i = 0; i < excDataN; ++i)
+		exc[excData[i].ind] = mrb_define_class(mrb, excData[i].str, mrb->eException_class);
+
+	RClass *errnoMod = mrb_define_module(mrb, "Errno");
+
+	for (int i = 0; i < enoExcDataN; ++i)
+		exc[enoExcData[i].ind] =
+		        mrb_define_class_under(mrb, errnoMod, enoExcData[i].str, mrb->eStandardError_class);
+
+	exc[TypeError] = mrb_class_get(mrb, "TypeError");
+	exc[ArgumentError] = mrb_class_get(mrb, "ArgumentError");
+
+	for (int i = 0; i < symDataN; ++i)
+		symbols[symData[i].ind] = mrb_intern(mrb, symData[i].str);
+
+	mrb_gc_arena_restore(mrb, arena);
+}
+
+//enum Type
+//{
+//	RGSSError,
+//	NoFileError,
+//	IOError,
+
+//	/* Already defined by ruby */
+//	TypeError,
+//	ArgumentError,
+
+//	/* New types introduced in mkxp */
+//	PHYSFSError,
+//	SDLError
+//};
+
+/* Indexed with Exception::Type */
+static const MrbException excToMrbExc[] =
+{
+    RGSS,        /* RGSSError   */
+    ErrnoENOENT, /* NoFileError */
+    IO,
+
+    TypeError,
+    ArgumentError,
+
+    PHYSFS,      /* PHYSFSError */
+    SDL,         /* SDLError    */
+};
+
+void raiseMrbExc(mrb_state *mrb, const Exception &exc)
+{
+	MrbData *data = getMrbData(mrb);
+	RClass *excClass = data->exc[excToMrbExc[exc.type]];
+
+	static char buffer[512];
+	exc.snprintf(buffer, sizeof(buffer));
+	mrb_raise(mrb, excClass, buffer);
+}
+
+MRB_METHOD_PUB(inspectObject)
+{
+	mrb_value priv = mrb_obj_iv_get(mrb, mrb_obj_ptr(self), getSym(mrb, CSpriv_iv));
+
+	static char buffer[64];
+	sprintf(buffer, "#<%s:%p>", DATA_TYPE(priv)->struct_name, DATA_PTR(priv));
+
+	return mrb_str_new_cstr(mrb, buffer);
+}

binding-mruby/binding-util.h

@@ -0,0 +1,387 @@
+/*
+** binding-util.h
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef BINDINGUTIL_H
+#define BINDINGUTIL_H
+
+#include "mruby.h"
+#include "mruby/data.h"
+#include "mruby/variable.h"
+#include "mruby/class.h"
+
+#include <stdio.h>
+
+
+enum CommonSymbol
+{
+	CSpriv_iv = 0, /* private data */
+
+	/* From here on out all symbols
+	 * have implicit '@' prefix */
+	CSfont,
+	CSviewport,
+	CSbitmap,
+	CScolor,
+	CStone,
+	CSrect,
+	CSsrc_rect,
+	CStileset,
+	CSautotiles,
+	CSmap_data,
+	CSflash_data,
+	CSpriorities,
+	CSwindowskin,
+	CScontents,
+	CScursor_rect,
+	CSpath,
+	CSarray,
+	CSdefault_color,
+
+	CommonSymbolsMax
+};
+
+enum MrbException
+{
+	Shutdown = 0,
+	RGSS,
+	PHYSFS,
+	SDL,
+
+	ErrnoE2BIG,
+	ErrnoEACCES,
+	ErrnoEAGAIN,
+	ErrnoEBADF,
+	ErrnoECHILD,
+	ErrnoEDEADLOCK,
+	ErrnoEDOM,
+	ErrnoEEXIST,
+	ErrnoEINVAL,
+	ErrnoEMFILE,
+	ErrnoENOENT,
+	ErrnoENOEXEC,
+	ErrnoENOMEM,
+	ErrnoENOSPC,
+	ErrnoERANGE,
+	ErrnoEXDEV,
+
+	IO,
+
+	TypeError,
+	ArgumentError,
+
+	MrbExceptionsMax
+};
+
+struct MrbData
+{
+	RClass *exc[MrbExceptionsMax];
+	/* I'll leave the usage of these syms to later,
+	 * so I can measure how much of a speed difference they make */
+	mrb_sym symbols[CommonSymbolsMax];
+
+	MrbData(mrb_state *mrb);
+};
+
+struct Exception;
+
+void
+raiseMrbExc(mrb_state *mrb, const Exception &exc);
+
+inline MrbData*
+getMrbData(mrb_state *mrb)
+{
+	return static_cast<MrbData*>(mrb->ud);
+}
+
+#define GUARD_EXC(exp) \
+{ try { exp } catch (Exception &exc) { raiseMrbExc(mrb, exc); } }
+
+#define DECL_TYPE(_Type) \
+	extern const mrb_data_type _Type##Type
+
+#define DEF_TYPE(_Type) \
+	extern const mrb_data_type _Type##Type = \
+	{ \
+		#_Type, \
+		freeInstance<_Type> \
+	}
+
+#define MRB_METHOD_PUB(name) \
+	mrb_value name(mrb_state *mrb, mrb_value self)
+
+#define MRB_METHOD(name) static MRB_METHOD_PUB(name)
+
+#define MRB_UNUSED_PARAM \
+	{ (void) mrb; (void) self; }
+
+/* If we're not binding a disposable class,
+ * we want to #undef DEF_PROP_CHK_DISP */
+#define DEF_PROP_CHK_DISP \
+	checkDisposed(mrb, k, DISP_CLASS_NAME);
+
+#define DEF_PROP_OBJ(Klass, PropKlass, PropName, prop_iv) \
+	MRB_METHOD(Klass##Get##PropName) \
+	{ \
+		Klass *k = getPrivateData<Klass>(mrb, self); (void) k; \
+		DEF_PROP_CHK_DISP \
+		return getProperty(mrb, self, prop_iv); \
+	} \
+	MRB_METHOD(Klass##Set##PropName) \
+	{ \
+		Klass *k = getPrivateData<Klass>(mrb, self); \
+		mrb_value propObj; \
+		PropKlass *prop; \
+		mrb_get_args(mrb, "o", &propObj); \
+		prop = getPrivateDataCheck<PropKlass>(mrb, propObj, PropKlass##Type); \
+		GUARD_EXC( k->set##PropName(prop); ) \
+		setProperty(mrb, self, prop_iv, propObj); \
+		return propObj; \
+	}
+
+/* Object property with allowed NIL */
+#define DEF_PROP_OBJ_NIL(Klass, PropKlass, PropName, prop_iv) \
+	MRB_METHOD(Klass##Get##PropName) \
+	{ \
+		Klass *k = getPrivateData<Klass>(mrb, self); (void) k; \
+		DEF_PROP_CHK_DISP \
+		return getProperty(mrb, self, prop_iv); \
+	} \
+	MRB_METHOD(Klass##Set##PropName) \
+	{ \
+		Klass *k = getPrivateData<Klass>(mrb, self); \
+		mrb_value propObj; \
+		PropKlass *prop; \
+		mrb_get_args(mrb, "o", &propObj); \
+		if (mrb_nil_p(propObj)) \
+			prop = 0; \
+		else \
+			prop = getPrivateDataCheck<PropKlass>(mrb, propObj, PropKlass##Type); \
+		GUARD_EXC( k->set##PropName(prop); ) \
+		setProperty(mrb, self, prop_iv, propObj); \
+		return mrb_nil_value(); \
+	}
+
+#define DEF_PROP(Klass, mrb_type, PropName, arg_type, conv_t) \
+	MRB_METHOD(Klass##Get##PropName) \
+	{ \
+		Klass *k = getPrivateData<Klass>(mrb, self); \
+		DEF_PROP_CHK_DISP \
+		return mrb_##conv_t##_value(k->get##PropName()); \
+	} \
+	MRB_METHOD(Klass##Set##PropName) \
+	{ \
+		Klass *k = getPrivateData<Klass>(mrb, self); \
+		mrb_type value; \
+		mrb_get_args(mrb, arg_type, &value); \
+		GUARD_EXC( k->set##PropName(value); ) \
+		return mrb_##conv_t##_value(value); \
+	}
+
+#define DEF_PROP_I(Klass, PropName) \
+	DEF_PROP(Klass, mrb_int, PropName, "i", fixnum)
+
+#define DEF_PROP_F(Klass, PropName) \
+	DEF_PROP(Klass, mrb_float, PropName, "f", _float)
+
+#define DEF_PROP_B(Klass, PropName) \
+	DEF_PROP(Klass, mrb_bool, PropName, "b", bool)
+
+#define CLONE_FUN(Klass) \
+	MRB_METHOD(Klass##Clone) \
+	{ \
+		Klass *k = getPrivateData<Klass>(mrb, self); \
+		mrb_value dupObj = mrb_obj_clone(mrb, self); \
+		Klass *dupK = new Klass(*k); \
+		setPrivateData(mrb, dupObj, dupK, Klass##Type); \
+		return dupObj; \
+	}
+
+#define MARSH_LOAD_FUN(Klass) \
+	MRB_METHOD(Klass##Load) \
+	{ \
+		return objectLoad<Klass>(mrb, self, Klass##Type); \
+	}
+
+#define INIT_PROP_BIND(Klass, PropName, prop_name_s) \
+{ \
+	mrb_define_method(mrb, klass, prop_name_s, Klass##Get##PropName, MRB_ARGS_NONE()); \
+	mrb_define_method(mrb, klass, prop_name_s "=", Klass##Set##PropName, MRB_ARGS_REQ(1)); \
+}
+
+static inline mrb_value
+mrb__float_value(mrb_float f)
+{
+  mrb_value v;
+
+  MRB_SET_VALUE(v, MRB_TT_FLOAT, value.f, f);
+  return v;
+}
+
+inline mrb_sym
+getSym(mrb_state *mrb, CommonSymbol sym)
+{
+	return getMrbData(mrb)->symbols[sym];
+}
+
+template<typename T>
+inline T *
+getPrivateData(mrb_state *mrb, mrb_value self)
+{
+	mrb_value priv = mrb_obj_iv_get(mrb,
+									mrb_obj_ptr(self),
+	                                getSym(mrb, CSpriv_iv));
+
+	return static_cast<T*>(DATA_PTR(priv));
+}
+
+template<typename T>
+inline T *
+getPrivateDataCheck(mrb_state *mrb, mrb_value obj, const mrb_data_type &type)
+{
+	static const char mesg[] = "wrong argument type %S (expected %S)";
+
+	if (mrb_type(obj) != MRB_TT_OBJECT)
+		mrb_raisef(mrb, E_TYPE_ERROR, mesg,
+		           mrb_str_new_cstr(mrb, (mrb_class_name(mrb, mrb_class(mrb, obj)))),
+		           mrb_str_new_cstr(mrb, type.struct_name));
+
+	RObject *objP = mrb_obj_ptr(obj);
+
+	if (!mrb_obj_iv_defined(mrb, objP, getSym(mrb, CSpriv_iv)))
+		mrb_raisef(mrb, E_TYPE_ERROR, mesg,
+		           mrb_str_new_cstr(mrb, (mrb_class_name(mrb, mrb_class(mrb, obj)))),
+		           mrb_str_new_cstr(mrb, type.struct_name));
+
+	mrb_value priv = mrb_obj_iv_get(mrb, objP, getSym(mrb, CSpriv_iv));
+
+	void *p = mrb_check_datatype(mrb, priv, &type);
+
+	return static_cast<T*>(p);
+}
+
+inline void
+setPrivateData(mrb_state *mrb, mrb_value self, void *p, const mrb_data_type &type)
+{
+	RData *data =
+			mrb_data_object_alloc(mrb,
+								  mrb_obj_class(mrb, self),
+								  p,
+								  &type);
+
+	mrb_obj_iv_set(mrb,
+				   mrb_obj_ptr(self),
+	               getSym(mrb, CSpriv_iv),
+				   mrb_obj_value(data));
+}
+
+
+inline mrb_value
+wrapObject(mrb_state *mrb, void *p, const mrb_data_type &type)
+{
+	RClass *c = mrb_class_get(mrb, type.struct_name);
+	RObject *o = (RObject*) mrb_obj_alloc(mrb, MRB_TT_OBJECT, c);
+	mrb_value obj = mrb_obj_value(o);
+
+	setPrivateData(mrb, obj, p, type);
+
+	return obj;
+}
+
+inline void
+wrapProperty(mrb_state *mrb, mrb_value self,
+             void *prop, CommonSymbol iv, const mrb_data_type &type)
+{
+	mrb_value propObj = wrapObject(mrb, prop, type);
+
+	mrb_obj_iv_set(mrb,
+	               mrb_obj_ptr(self),
+	               getSym(mrb, iv),
+		           propObj);
+}
+
+inline void
+wrapNilProperty(mrb_state *mrb, mrb_value self, CommonSymbol iv)
+{
+	mrb_obj_iv_set(mrb,
+	               mrb_obj_ptr(self),
+	               getSym(mrb, iv),
+	               mrb_nil_value());
+}
+
+inline mrb_value
+getProperty(mrb_state *mrb, mrb_value self, CommonSymbol iv)
+{
+	return mrb_obj_iv_get(mrb,
+	                      mrb_obj_ptr(self),
+	                      getSym(mrb, iv));
+}
+
+inline void
+setProperty(mrb_state *mrb, mrb_value self,
+            CommonSymbol iv, mrb_value propObject)
+{
+	mrb_obj_iv_set(mrb,
+	               mrb_obj_ptr(self),
+	               getSym(mrb, iv),
+	               propObject);
+}
+
+template<typename T>
+void
+freeInstance(mrb_state *, void *instance)
+{
+	delete static_cast<T*>(instance);
+}
+
+inline mrb_value
+mrb_bool_value(bool value)
+{
+	return value ? mrb_true_value() : mrb_false_value();
+}
+
+inline bool
+_mrb_bool(mrb_value o)
+{
+	return mrb_test(o);
+}
+
+template<class C>
+inline mrb_value
+objectLoad(mrb_state *mrb, mrb_value self, const mrb_data_type &type)
+{
+	RClass *klass = mrb_class_ptr(self);
+	char *data;
+	int data_len;
+	mrb_get_args(mrb, "s", &data, &data_len);
+
+	RObject *obj = (RObject*) mrb_obj_alloc(mrb, MRB_TT_OBJECT, klass);
+	mrb_value obj_value = mrb_obj_value(obj);
+
+	C *c = C::deserialize(data, data_len);
+
+	setPrivateData(mrb, obj_value, c, type);
+
+	return obj_value;
+}
+
+MRB_METHOD_PUB(inspectObject);
+
+#endif // BINDINGUTIL_H

binding-mruby/bitmap-binding.cpp

@@ -0,0 +1,340 @@
+/*
+** bitmap-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "bitmap.h"
+#include "font.h"
+#include "exception.h"
+#include "disposable-binding.h"
+#include "binding-util.h"
+#include "binding-types.h"
+
+#include <QDebug>
+
+#define DISP_CLASS_NAME "bitmap"
+
+DEF_TYPE(Bitmap);
+
+MRB_METHOD(bitmapInitialize)
+{
+	Bitmap *b = 0;
+
+	if (mrb->c->ci->argc == 1)
+	{
+		char *filename;
+		mrb_get_args(mrb, "z", &filename);
+
+		GUARD_EXC( b = new Bitmap(filename); )
+	}
+	else
+	{
+		mrb_int width, height;
+		mrb_get_args(mrb, "ii", &width, &height);
+
+		b = new Bitmap(width, height);
+	}
+
+	setPrivateData(mrb, self, b, BitmapType);
+
+	/* Wrap properties */
+	Font *font = new Font();
+	b->setFont(font);
+	font->setColor(new Color(*font->getColor()));
+
+	wrapProperty(mrb, self, font, CSfont, FontType);
+	wrapProperty(mrb, getProperty(mrb, self, CSfont), font->getColor(), CScolor, ColorType);
+
+	return self;
+}
+
+MRB_METHOD(bitmapWidth)
+{
+	Bitmap *b = getPrivateData<Bitmap>(mrb, self);
+
+	mrb_int value = 0;
+	GUARD_EXC( value = b->width(); )
+
+	return mrb_fixnum_value(value);
+}
+
+MRB_METHOD(bitmapHeight)
+{
+	Bitmap *b = getPrivateData<Bitmap>(mrb, self);
+
+	mrb_int value = 0;
+	GUARD_EXC( value = b->height(); )
+
+	return mrb_fixnum_value(value);
+}
+
+MRB_METHOD(bitmapRect)
+{
+	Bitmap *b = getPrivateData<Bitmap>(mrb, self);
+
+	IntRect rect;
+	GUARD_EXC( rect = b->rect(); )
+
+	Rect *r = new Rect(rect);
+
+	return wrapObject(mrb, r, RectType);
+}
+
+MRB_METHOD(bitmapBlt)
+{
+	Bitmap *b = getPrivateData<Bitmap>(mrb, self);
+
+	mrb_int x, y;
+	mrb_value srcObj;
+	mrb_value srcRectObj;
+	mrb_int opacity = 255;
+
+	Bitmap *src;
+	Rect *srcRect;
+
+	mrb_get_args(mrb, "iioo|i", &x, &y, &srcObj, &srcRectObj, &opacity);
+
+	src = getPrivateDataCheck<Bitmap>(mrb, srcObj, BitmapType);
+	srcRect = getPrivateDataCheck<Rect>(mrb, srcRectObj, RectType);
+
+	GUARD_EXC( b->blt(x, y, *src, srcRect->toIntRect(), opacity); )
+
+	return mrb_nil_value();
+}
+
+MRB_METHOD(bitmapStretchBlt)
+{
+	Bitmap *b = getPrivateData<Bitmap>(mrb, self);
+
+	mrb_value destRectObj;
+	mrb_value srcObj;
+	mrb_value srcRectObj;
+	mrb_int opacity = 255;
+
+	Bitmap *src;
+	Rect *destRect, *srcRect;
+
+	mrb_get_args(mrb, "ooo|i", &destRectObj, &srcObj, &srcRectObj);
+
+	src = getPrivateDataCheck<Bitmap>(mrb, srcObj, BitmapType);
+	destRect = getPrivateDataCheck<Rect>(mrb, destRectObj, RectType);
+	srcRect = getPrivateDataCheck<Rect>(mrb, srcRectObj, RectType);
+
+	GUARD_EXC( b->stretchBlt(destRect->toIntRect(), *src, srcRect->toIntRect(), opacity); )
+
+	return mrb_nil_value();
+}
+
+MRB_METHOD(bitmapFillRect)
+{
+	Bitmap *b = getPrivateData<Bitmap>(mrb, self);
+
+	mrb_value colorObj;
+	Color *color;
+
+	if (mrb->c->ci->argc == 2)
+	{
+		mrb_value rectObj;
+		Rect *rect;
+
+		mrb_get_args(mrb, "oo", &rectObj, &colorObj);
+
+		rect = getPrivateDataCheck<Rect>(mrb, rectObj, RectType);
+		color = getPrivateDataCheck<Color>(mrb, colorObj, ColorType);
+
+		GUARD_EXC( b->fillRect(rect->toIntRect(), color->norm); )
+	}
+	else
+	{
+		mrb_int x, y, width, height;
+
+		mrb_get_args(mrb, "iiiio", &x, &y, &width, &height, &colorObj);
+
+		color = getPrivateDataCheck<Color>(mrb, colorObj, ColorType);
+
+		GUARD_EXC( b->fillRect(x, y, width, height, color->norm); )
+	}
+
+	return mrb_nil_value();
+}
+
+MRB_METHOD(bitmapClear)
+{
+	Bitmap *b = getPrivateData<Bitmap>(mrb, self);
+
+	GUARD_EXC( b->clear(); )
+
+	return mrb_nil_value();
+}
+
+MRB_METHOD(bitmapGetPixel)
+{
+	Bitmap *b = getPrivateData<Bitmap>(mrb, self);
+
+	mrb_int x, y;
+
+	mrb_get_args(mrb, "ii", &x, &y);
+
+	GUARD_EXC(
+		if (x < 0 || y < 0 || x >= b->width() || y >= b->height())
+	            return mrb_nil_value();
+	         )
+
+	Vec4 value;
+	GUARD_EXC( value = b->getPixel(x, y); )
+
+	Color *color = new Color(value);
+
+	return wrapObject(mrb, color, ColorType);
+}
+
+MRB_METHOD(bitmapSetPixel)
+{
+	Bitmap *b = getPrivateData<Bitmap>(mrb, self);
+
+	mrb_int x, y;
+	mrb_value colorObj;
+
+	Color *color;
+
+	mrb_get_args(mrb, "iio", &x, &y, &colorObj);
+
+	color = getPrivateDataCheck<Color>(mrb, colorObj, ColorType);
+
+	GUARD_EXC( b->setPixel(x, y, color->norm); )
+
+	return mrb_nil_value();
+}
+
+MRB_METHOD(bitmapHueChange)
+{
+	Bitmap *b = getPrivateData<Bitmap>(mrb, self);
+
+	mrb_int hue;
+
+	mrb_get_args(mrb, "i", &hue);
+
+	GUARD_EXC( b->hueChange(hue); )
+
+	return mrb_nil_value();
+}
+
+MRB_METHOD(bitmapDrawText)
+{
+	Bitmap *b = getPrivateData<Bitmap>(mrb, self);
+
+	char *str;
+	mrb_int align = Bitmap::Left;
+
+	int argc = mrb->c->ci->argc;
+	if (argc == 2 || argc == 3)
+	{
+		mrb_value rectObj;
+		Rect *rect;
+
+		mrb_get_args(mrb, "oz|i", &rectObj, &str, &align);
+
+		rect = getPrivateDataCheck<Rect>(mrb, rectObj, RectType);
+
+		GUARD_EXC( b->drawText(rect->toIntRect(), str, align); )
+	}
+	else
+	{
+		mrb_int x, y, width, height;
+
+		mrb_get_args(mrb, "iiiiz|i", &x, &y, &width, &height, &str, &align);
+
+		GUARD_EXC( b->drawText(x, y, width, height, str, align); )
+	}
+
+	return mrb_nil_value();
+}
+
+MRB_METHOD(bitmapTextSize)
+{
+	Bitmap *b = getPrivateData<Bitmap>(mrb, self);
+
+	char *str;
+
+	mrb_get_args(mrb, "z", &str);
+
+	IntRect value;
+	GUARD_EXC( value = b->textSize(str); )
+
+	Rect *rect = new Rect(value);
+
+	return wrapObject(mrb, rect, RectType);
+}
+
+MRB_METHOD(bitmapGetFont)
+{
+	Bitmap *b = getPrivateData<Bitmap>(mrb, self);
+	checkDisposed(mrb, b, "bitmap");
+
+	return getProperty(mrb, self, CSfont);
+}
+
+MRB_METHOD(bitmapSetFont)
+{
+	Bitmap *b = getPrivateData<Bitmap>(mrb, self);
+
+	mrb_value fontObj;
+	Font *font;
+
+	mrb_get_args(mrb, "o", &fontObj);
+
+	font = getPrivateDataCheck<Font>(mrb, fontObj, FontType);
+
+	GUARD_EXC( b->setFont(font); )
+	setProperty(mrb, self, CSfont, fontObj);
+
+	return mrb_nil_value();
+}
+
+CLONE_FUN(Bitmap)
+
+
+void
+bitmapBindingInit(mrb_state *mrb)
+{
+	RClass *klass = mrb_define_class(mrb, "Bitmap", 0);
+
+	disposableBindingInit<Bitmap>(mrb, klass);
+
+	mrb_define_method(mrb, klass, "initialize",  bitmapInitialize, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(1));
+
+	mrb_define_method(mrb, klass, "width",       bitmapWidth,      MRB_ARGS_NONE());
+	mrb_define_method(mrb, klass, "height",      bitmapHeight,     MRB_ARGS_NONE());
+	mrb_define_method(mrb, klass, "rect",        bitmapRect,       MRB_ARGS_NONE());
+	mrb_define_method(mrb, klass, "blt",         bitmapBlt,        MRB_ARGS_REQ(4) | MRB_ARGS_OPT(1));
+	mrb_define_method(mrb, klass, "stretch_blt", bitmapStretchBlt, MRB_ARGS_REQ(3) | MRB_ARGS_OPT(1));
+	mrb_define_method(mrb, klass, "fill_rect",   bitmapFillRect,   MRB_ARGS_REQ(2) | MRB_ARGS_OPT(2));
+	mrb_define_method(mrb, klass, "clear",       bitmapClear,      MRB_ARGS_NONE());
+	mrb_define_method(mrb, klass, "get_pixel",   bitmapGetPixel,   MRB_ARGS_REQ(2));
+	mrb_define_method(mrb, klass, "set_pixel",   bitmapSetPixel,   MRB_ARGS_REQ(3));
+	mrb_define_method(mrb, klass, "hue_change",  bitmapHueChange,  MRB_ARGS_REQ(1));
+	mrb_define_method(mrb, klass, "draw_text",   bitmapDrawText,   MRB_ARGS_REQ(2) | MRB_ARGS_OPT(4));
+	mrb_define_method(mrb, klass, "text_size",   bitmapTextSize,   MRB_ARGS_REQ(1));
+
+	mrb_define_method(mrb, klass, "font",        bitmapGetFont,    MRB_ARGS_NONE());
+	mrb_define_method(mrb, klass, "font=",       bitmapSetFont,    MRB_ARGS_REQ(1));
+
+	mrb_define_method(mrb, klass, "inspect",     inspectObject,    MRB_ARGS_NONE());
+	mrb_define_method(mrb, klass, "clone",       BitmapClone,      MRB_ARGS_NONE());
+}

binding-mruby/disposable-binding.h

@@ -0,0 +1,62 @@
+/*
+** disposable-binding.h
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef DISPOSABLEBINDING_H
+#define DISPOSABLEBINDING_H
+
+#include "disposable.h"
+#include "binding-util.h"
+
+template<class C>
+MRB_METHOD(disposableDispose)
+{
+	Disposable *d = getPrivateData<C>(mrb, self);
+
+	d->dispose();
+
+	return mrb_nil_value();
+}
+
+template<class C>
+MRB_METHOD(disposableDisposed)
+{
+	Disposable *d = getPrivateData<C>(mrb, self);
+
+	return mrb_bool_value(d->isDisposed());
+}
+
+template<class C>
+static void disposableBindingInit(mrb_state *mrb, RClass *klass)
+{
+	mrb_define_method(mrb, klass, "dispose", disposableDispose<C>, MRB_ARGS_NONE());
+	mrb_define_method(mrb, klass, "disposed?", disposableDisposed<C>, MRB_ARGS_NONE());
+}
+
+inline void checkDisposed(mrb_state *mrb, Disposable *d, const char *klassName)
+{
+	MrbData *data = getMrbData(mrb);
+
+	if (d->isDisposed())
+		mrb_raisef(mrb, data->exc[RGSS], "disposed %S",
+		           mrb_str_new_static(mrb, klassName, strlen(klassName)));
+}
+
+#endif // DISPOSABLEBINDING_H

binding-mruby/etc-binding.cpp

@@ -0,0 +1,214 @@
+/*
+** etc-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "etc.h"
+#include "binding-util.h"
+#include "binding-types.h"
+#include "serializable-binding.h"
+#include "mruby/class.h"
+
+#include <QDebug>
+
+#define ATTR_RW(Type, attr, arg_type, mrb_val, arg_t_s) \
+	MRB_METHOD(Type##Get_##attr) \
+	{ \
+		Type *p = getPrivateData<Type>(mrb, self); \
+	 \
+		return mrb_##mrb_val##_value(p->attr); \
+	} \
+\
+	MRB_METHOD(Type##Set_##attr) \
+	{ \
+		Type *p = getPrivateData<Type>(mrb, self); \
+	 \
+		arg_type arg; \
+		mrb_get_args(mrb, arg_t_s, &arg); \
+	 \
+		p->attr = arg; \
+		UPDATE_F \
+	 \
+		return mrb_##mrb_val##_value(arg); \
+	}
+
+#define EQUAL_FUN(Typ) \
+	MRB_METHOD(Typ##Equal) \
+	{ \
+		Typ *p = getPrivateData<Typ>(mrb, self); \
+		mrb_value otherObj; \
+		Typ *other; \
+		mrb_get_args(mrb, "o", &otherObj); \
+		RClass *klass = mrb_obj_class(mrb, self); \
+		RClass *otherKlass = mrb_obj_class(mrb, otherObj); \
+		if (klass != otherKlass) \
+			return mrb_false_value(); \
+		other = getPrivateDataCheck<Typ>(mrb, otherObj, Typ##Type); \
+		return mrb_bool_value(*p == *other); \
+	}
+
+#define ATTR_FLOAT_RW(Type, attr) ATTR_RW(Type, attr, mrb_float, _float, "f")
+#define ATTR_INT_RW(Type, attr)   ATTR_RW(Type, attr, mrb_int, fixnum, "i")
+
+#define UPDATE_F p->updateInternal();
+ATTR_FLOAT_RW(Color, red)
+ATTR_FLOAT_RW(Color, green)
+ATTR_FLOAT_RW(Color, blue)
+ATTR_FLOAT_RW(Color, alpha)
+
+ATTR_FLOAT_RW(Tone, red)
+ATTR_FLOAT_RW(Tone, green)
+ATTR_FLOAT_RW(Tone, blue)
+ATTR_FLOAT_RW(Tone, gray)
+
+#undef UPDATE_F
+#define UPDATE_F
+ATTR_INT_RW(Rect, x)
+ATTR_INT_RW(Rect, y)
+ATTR_INT_RW(Rect, width)
+ATTR_INT_RW(Rect, height)
+
+EQUAL_FUN(Color)
+EQUAL_FUN(Tone)
+EQUAL_FUN(Rect)
+
+DEF_TYPE(Color);
+DEF_TYPE(Tone);
+DEF_TYPE(Rect);
+
+#define INIT_FUN(Klass, param_type, param_t_s, last_param_def) \
+	MRB_METHOD(Klass##Initialize) \
+	{ \
+		param_type p1, p2, p3, p4 = last_param_def; \
+		mrb_get_args(mrb, param_t_s, &p1, &p2, &p3, &p4); \
+		Klass *k = new Klass(p1, p2, p3, p4); \
+		setPrivateData(mrb, self, k, Klass##Type); \
+		return self; \
+	}
+
+INIT_FUN(Color, mrb_float, "fff|f", 255)
+INIT_FUN(Tone, mrb_float, "fff|f", 0)
+INIT_FUN(Rect, mrb_int, "iiii", 0)
+
+#define SET_FUN(Klass, param_type, param_t_s, last_param_def) \
+	MRB_METHOD(Klass##Set) \
+	{ \
+		param_type p1, p2, p3, p4 = last_param_def; \
+		mrb_get_args(mrb, param_t_s, &p1, &p2, &p3, &p4); \
+		Klass *k = getPrivateData<Klass>(mrb, self); \
+		k->set(p1, p2, p3, p4); \
+		return self; \
+	}
+
+SET_FUN(Color, mrb_float, "fff|f", 255)
+SET_FUN(Tone, mrb_float, "fff|f", 0)
+SET_FUN(Rect, mrb_int, "iiii", 0)
+
+MRB_METHOD(RectEmpty)
+{
+	Rect *r = getPrivateData<Rect>(mrb, self);
+
+	r->empty();
+
+	return mrb_nil_value();
+}
+
+static char buffer[64];
+
+MRB_METHOD(ColorStringify)
+{
+	Color *c = getPrivateData<Color>(mrb, self);
+
+	sprintf(buffer, "(%f, %f, %f, %f)", c->red, c->green, c->blue, c->alpha);
+
+	return mrb_str_new_cstr(mrb, buffer);
+}
+
+MRB_METHOD(ToneStringify)
+{
+	Tone *t = getPrivateData<Tone>(mrb, self);
+
+	sprintf(buffer, "(%f, %f, %f, %f)", t->red, t->green, t->blue, t->gray);
+
+	return mrb_str_new_cstr(mrb, buffer);
+}
+
+MRB_METHOD(RectStringify)
+{
+	Rect *r = getPrivateData<Rect>(mrb, self);
+
+	sprintf(buffer, "(%d, %d, %d, %d)", r->x, r->y, r->width, r->height);
+
+	return mrb_str_new_cstr(mrb, buffer);
+}
+
+MARSH_LOAD_FUN(Color)
+MARSH_LOAD_FUN(Tone)
+MARSH_LOAD_FUN(Rect)
+
+CLONE_FUN(Tone)
+CLONE_FUN(Color)
+CLONE_FUN(Rect)
+
+#define MRB_ATTR_R(Class, attr) mrb_define_method(mrb, klass, #attr, Class##Get_##attr, MRB_ARGS_NONE())
+#define MRB_ATTR_W(Class, attr) mrb_define_method(mrb, klass, #attr "=", Class##Set_##attr, MRB_ARGS_REQ(1))
+#define MRB_ATTR_RW(Class, attr) { MRB_ATTR_R(Class, attr); MRB_ATTR_W(Class, attr); }
+
+#define MRB_ATTR_RW_A(Class, attr, alias) \
+{ \
+	mrb_define_method(mrb, klass, #alias, Class##Get_##attr, MRB_ARGS_NONE()); \
+	mrb_define_method(mrb, klass, #alias "=", Class##Set_##attr, MRB_ARGS_REQ(1)); \
+}
+
+#define INIT_BIND(Klass) \
+{ \
+	klass = mrb_define_class(mrb, #Klass, 0); \
+	mrb_define_class_method(mrb, klass, "_load", Klass##Load, MRB_ARGS_REQ(1)); \
+	serializableBindingInit<Klass>(mrb, klass); \
+	mrb_define_method(mrb, klass, "initialize", Klass##Initialize, MRB_ARGS_REQ(3) | MRB_ARGS_OPT(1)); \
+	mrb_define_method(mrb, klass, "set", Klass##Set, MRB_ARGS_REQ(3) | MRB_ARGS_OPT(1)); \
+	mrb_define_method(mrb, klass, "clone", Klass##Clone, MRB_ARGS_NONE()); \
+	mrb_define_method(mrb, klass, "==", Klass##Equal, MRB_ARGS_REQ(1)); \
+	mrb_define_method(mrb, klass, "to_s", Klass##Stringify, MRB_ARGS_NONE()); \
+	mrb_define_method(mrb, klass, "inspect", Klass##Stringify, MRB_ARGS_NONE()); \
+}
+
+void etcBindingInit(mrb_state *mrb)
+{
+	RClass *klass;
+
+	INIT_BIND(Color);
+	MRB_ATTR_RW(Color, red);
+	MRB_ATTR_RW(Color, green);
+	MRB_ATTR_RW(Color, blue);
+	MRB_ATTR_RW(Color, alpha);
+
+	INIT_BIND(Tone);
+	MRB_ATTR_RW(Tone, red);
+	MRB_ATTR_RW(Tone, green);
+	MRB_ATTR_RW(Tone, blue);
+	MRB_ATTR_RW(Tone, gray);
+
+	INIT_BIND(Rect);
+	MRB_ATTR_RW(Rect, x);
+	MRB_ATTR_RW(Rect, y);
+	MRB_ATTR_RW(Rect, width);
+	MRB_ATTR_RW(Rect, height);
+	mrb_define_method(mrb, klass, "empty", RectEmpty, MRB_ARGS_NONE());
+}

binding-mruby/flashable-binding.h

@@ -0,0 +1,71 @@
+/*
+** flashable-binding.h
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef FLASHABLEBINDING_H
+#define FLASHABLEBINDING_H
+
+#include "flashable.h"
+#include "binding-util.h"
+#include "binding-types.h"
+
+template<class C>
+MRB_METHOD(flashableFlash)
+{
+	Flashable *f = getPrivateData<C>(mrb, self);
+
+	mrb_value colorObj;
+	mrb_int duration;
+
+	Color *color;
+
+	mrb_get_args(mrb, "oi", &colorObj, &duration);
+
+	if (mrb_nil_p(colorObj))
+	{
+		f->flash(0, duration);
+		return mrb_nil_value();
+	}
+
+	color = getPrivateDataCheck<Color>(mrb, colorObj, ColorType);
+
+	f->flash(&color->norm, duration);
+
+	return mrb_nil_value();
+}
+
+template<class C>
+MRB_METHOD(flashableUpdate)
+{
+	Flashable *f = getPrivateData<C>(mrb, self);
+
+	f->update();
+
+	return mrb_nil_value();
+}
+
+template<class C>
+static void flashableBindingInit(mrb_state *mrb, RClass *klass)
+{
+	mrb_define_method(mrb, klass, "flash", flashableFlash<C>, MRB_ARGS_REQ(2));
+	mrb_define_method(mrb, klass, "update", flashableUpdate<C>, MRB_ARGS_NONE());
+}
+
+#endif // FLASHABLEBINDING_H

binding-mruby/font-binding.cpp

@@ -0,0 +1,173 @@
+/*
+** font-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "font.h"
+#include "binding-util.h"
+#include "binding-types.h"
+#include "exception.h"
+
+#include "mruby/string.h"
+
+DEF_TYPE(Font);
+
+MRB_METHOD(fontDoesExist)
+{
+	MRB_UNUSED_PARAM;
+
+	const char *name;
+	mrb_get_args(mrb, "z", &name);
+
+	return mrb_bool_value(Font::doesExist(name));
+}
+
+MRB_METHOD(fontInitialize)
+{
+	char *name = 0;
+	mrb_int size = 0;
+
+	mrb_get_args(mrb, "|zi", &name, &size);
+
+	Font *f = new Font(name, size);
+
+	setPrivateData(mrb, self, f, FontType);
+
+	/* Wrap property objects */
+	f->setColor(new Color(*f->getColor()));
+	wrapProperty(mrb, self, f->getColor(), CScolor, ColorType);
+
+	return self;
+}
+
+MRB_METHOD(FontGetName)
+{
+	Font *f = getPrivateData<Font>(mrb, self);
+
+	return mrb_str_new_cstr(mrb, f->getName());
+}
+
+MRB_METHOD(FontSetName)
+{
+	Font *f = getPrivateData<Font>(mrb, self);
+
+	mrb_value name;
+	mrb_get_args(mrb, "S", &name);
+
+	f->setName(RSTRING_PTR(name));
+
+	return name;
+}
+
+#undef DEF_PROP_CHK_DISP
+#define DEF_PROP_CHK_DISP
+
+DEF_PROP_I(Font, Size)
+DEF_PROP_B(Font, Bold)
+DEF_PROP_B(Font, Italic)
+DEF_PROP_OBJ(Font, Color, Color, CScolor)
+
+#define DEF_KLASS_PROP(Klass, mrb_type, PropName, arg_type, conv_t) \
+	static mrb_value \
+	Klass##Get##PropName(mrb_state *, mrb_value) \
+	{ \
+		return mrb_##conv_t##_value(Klass::get##PropName()); \
+	} \
+	static mrb_value \
+	Klass##Set##PropName(mrb_state *mrb, mrb_value) \
+	{ \
+		mrb_type value; \
+		mrb_get_args(mrb, arg_type, &value); \
+		Klass::set##PropName(value); \
+		return mrb_##conv_t##_value(value); \
+	}
+
+DEF_KLASS_PROP(Font, mrb_int, DefaultSize, "i", fixnum)
+DEF_KLASS_PROP(Font, mrb_bool, DefaultBold, "b", bool)
+DEF_KLASS_PROP(Font, mrb_bool, DefaultItalic, "b", bool)
+
+MRB_METHOD(FontGetDefaultName)
+{
+	MRB_UNUSED_PARAM;
+
+	return mrb_str_new_cstr(mrb, Font::getDefaultName());
+}
+
+MRB_METHOD(FontSetDefaultName)
+{
+	MRB_UNUSED_PARAM;
+
+	mrb_value nameObj;
+	mrb_get_args(mrb, "S", &nameObj);
+
+	Font::setDefaultName(RSTRING_PTR(nameObj));
+
+	return nameObj;
+}
+
+MRB_METHOD(FontGetDefaultColor)
+{
+	return getProperty(mrb, self, CSdefault_color);
+}
+
+MRB_METHOD(FontSetDefaultColor)
+{
+	mrb_value colorObj;
+	mrb_get_args(mrb, "o", &colorObj);
+
+	Color *c = getPrivateDataCheck<Color>(mrb, colorObj, ColorType);
+
+	Font::setDefaultColor(c);
+	setProperty(mrb, self, CSdefault_color, colorObj);
+
+	return colorObj;
+}
+
+#define INIT_KLASS_PROP_BIND(Klass, PropName, prop_name_s) \
+{ \
+	mrb_define_class_method(mrb, klass, prop_name_s, Klass##Get##PropName, MRB_ARGS_NONE()); \
+	mrb_define_class_method(mrb, klass, prop_name_s "=", Klass##Set##PropName, MRB_ARGS_REQ(1)); \
+}
+
+void
+fontBindingInit(mrb_state *mrb)
+{
+	RClass *klass = mrb_define_class(mrb, "Font", 0);
+
+	Font::setDefaultColor(new Color(*Font::getDefaultColor()));
+	wrapProperty(mrb, mrb_obj_value(klass), Font::getDefaultColor(), CSdefault_color, ColorType);
+
+	mrb_define_class_method(mrb, klass, "exist?", fontDoesExist, MRB_ARGS_REQ(1));
+
+	INIT_KLASS_PROP_BIND(Font, DefaultName, "default_name");
+	INIT_KLASS_PROP_BIND(Font, DefaultSize, "default_size");
+	INIT_KLASS_PROP_BIND(Font, DefaultBold, "default_bold");
+	INIT_KLASS_PROP_BIND(Font, DefaultItalic, "default_italic");
+	INIT_KLASS_PROP_BIND(Font, DefaultColor, "default_color");
+
+	mrb_define_method(mrb, klass, "initialize", fontInitialize, MRB_ARGS_OPT(2));
+
+	INIT_PROP_BIND(Font, Name, "name");
+	INIT_PROP_BIND(Font, Size, "size");
+	INIT_PROP_BIND(Font, Bold, "bold");
+	INIT_PROP_BIND(Font, Italic, "italic");
+	INIT_PROP_BIND(Font, Color, "color");
+
+	mrb_define_method(mrb, klass, "inspect", inspectObject, MRB_ARGS_NONE());
+}

binding-mruby/graphics-binding.cpp

@@ -0,0 +1,126 @@
+/*
+** graphics-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "graphics.h"
+#include "globalstate.h"
+#include "mruby.h"
+#include "binding-util.h"
+#include "exception.h"
+
+MRB_METHOD(graphicsUpdate)
+{
+	MRB_UNUSED_PARAM;
+
+	gState->graphics().update();
+
+	return mrb_nil_value();
+}
+
+MRB_METHOD(graphicsFreeze)
+{
+	MRB_UNUSED_PARAM;
+
+	gState->graphics().freeze();
+
+	return mrb_nil_value();
+}
+
+MRB_METHOD(graphicsTransition)
+{
+	MRB_UNUSED_PARAM;
+
+	mrb_int duration = 8;
+	const char *filename = 0;
+	mrb_int vague = 40;
+
+	mrb_get_args(mrb, "|izi", &duration, &filename, &vague);
+
+	GUARD_EXC( gState->graphics().transition(duration, filename, vague); )
+
+	return mrb_nil_value();
+}
+
+MRB_METHOD(graphicsFrameReset)
+{
+	MRB_UNUSED_PARAM;
+
+	gState->graphics().frameReset();
+
+	return mrb_nil_value();
+}
+
+#define DEF_GRA_PROP_I(PropName) \
+	MRB_METHOD(graphics##Get##PropName) \
+	{ \
+		MRB_UNUSED_PARAM; \
+		return mrb_fixnum_value(gState->graphics().get##PropName()); \
+	} \
+	MRB_METHOD(graphics##Set##PropName) \
+	{ \
+		MRB_UNUSED_PARAM; \
+		mrb_int value; \
+		mrb_get_args(mrb, "i", &value); \
+		gState->graphics().set##PropName(value); \
+		return mrb_nil_value(); \
+	}
+
+DEF_GRA_PROP_I(FrameRate)
+DEF_GRA_PROP_I(FrameCount)
+
+MRB_METHOD(graphicsGetFullscreen)
+{
+	MRB_UNUSED_PARAM;
+
+	return mrb_bool_value(gState->graphics().getFullscreen());
+}
+
+MRB_METHOD(graphicsSetFullscreen)
+{
+	MRB_UNUSED_PARAM;
+
+	mrb_bool mode;
+	mrb_get_args(mrb, "b", &mode);
+
+	gState->graphics().setFullscreen(mode);
+
+	return mrb_bool_value(mode);
+}
+
+#define INIT_GRA_PROP_BIND(PropName, prop_name_s) \
+{ \
+	mrb_define_module_function(mrb, module, prop_name_s, graphics##Get##PropName, MRB_ARGS_NONE()); \
+	mrb_define_module_function(mrb, module, prop_name_s "=", graphics##Set##PropName, MRB_ARGS_REQ(1)); \
+}
+
+void graphicsBindingInit(mrb_state *mrb)
+{
+	RClass *module = mrb_define_module(mrb, "Graphics");
+
+	mrb_define_module_function(mrb, module, "update", graphicsUpdate, MRB_ARGS_NONE());
+	mrb_define_module_function(mrb, module, "freeze", graphicsFreeze, MRB_ARGS_NONE());
+	mrb_define_module_function(mrb, module, "transition", graphicsTransition, MRB_ARGS_OPT(3));
+	mrb_define_module_function(mrb, module, "frame_reset", graphicsFrameReset, MRB_ARGS_NONE());
+
+	INIT_GRA_PROP_BIND( FrameRate,  "frame_rate"  );
+	INIT_GRA_PROP_BIND( FrameCount, "frame_count" );
+
+	INIT_GRA_PROP_BIND( Fullscreen, "fullscreen" );
+}

binding-mruby/input-binding.cpp

@@ -0,0 +1,146 @@
+/*
+** input-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "input.h"
+#include "globalstate.h"
+#include "exception.h"
+#include "binding-util.h"
+
+MRB_METHOD(inputUpdate)
+{
+	MRB_UNUSED_PARAM;
+
+	gState->input().update();
+
+	return mrb_nil_value();
+}
+
+MRB_METHOD(inputPress)
+{
+	MRB_UNUSED_PARAM;
+
+	mrb_int num;
+	mrb_get_args(mrb, "i", &num);
+
+	Input::ButtonCode bc = (Input::ButtonCode) num;
+
+	return mrb_bool_value(gState->input().isPressed(bc));
+}
+
+MRB_METHOD(inputTrigger)
+{
+	MRB_UNUSED_PARAM;
+
+	mrb_int num;
+	mrb_get_args(mrb, "i", &num);
+
+	Input::ButtonCode bc = (Input::ButtonCode) num;
+
+	return mrb_bool_value(gState->input().isTriggered(bc));
+}
+
+MRB_METHOD(inputRepeat)
+{
+	MRB_UNUSED_PARAM;
+
+	mrb_int num;
+	mrb_get_args(mrb, "i", &num);
+
+	Input::ButtonCode bc = (Input::ButtonCode) num;
+
+	return mrb_bool_value(gState->input().isRepeated(bc));
+}
+
+MRB_METHOD(inputDir4)
+{
+	MRB_UNUSED_PARAM;
+
+	return mrb_fixnum_value(gState->input().dir4Value());
+}
+
+MRB_METHOD(inputDir8)
+{
+	MRB_UNUSED_PARAM;
+
+	return mrb_fixnum_value(gState->input().dir8Value());
+}
+
+/* Non-standard extensions */
+MRB_METHOD(inputMouseX)
+{
+	MRB_UNUSED_PARAM;
+
+	return mrb_fixnum_value(gState->input().mouseX());
+}
+
+MRB_METHOD(inputMouseY)
+{
+	MRB_UNUSED_PARAM;
+
+	return mrb_fixnum_value(gState->input().mouseY());
+}
+
+#define DEF_CONST_I(name, value) \
+	mrb_const_set(mrb, mrb_obj_value(module), mrb_intern(mrb, name), mrb_fixnum_value(value))
+
+void
+inputBindingInit(mrb_state *mrb)
+{
+	RClass *module = mrb_define_module(mrb, "Input");
+
+	mrb_define_module_function(mrb, module, "update", inputUpdate, MRB_ARGS_NONE());
+	mrb_define_module_function(mrb, module, "press?", inputPress, MRB_ARGS_REQ(1));
+	mrb_define_module_function(mrb, module, "trigger?", inputTrigger, MRB_ARGS_REQ(1));
+	mrb_define_module_function(mrb, module, "repeat?", inputRepeat, MRB_ARGS_REQ(1));
+	mrb_define_module_function(mrb, module, "dir4", inputDir4, MRB_ARGS_NONE());
+	mrb_define_module_function(mrb, module, "dir8", inputDir8, MRB_ARGS_NONE());
+
+	DEF_CONST_I("DOWN",  Input::Down );
+	DEF_CONST_I("LEFT",  Input::Left );
+	DEF_CONST_I("RIGHT", Input::Right);
+	DEF_CONST_I("UP",    Input::Up   );
+
+	DEF_CONST_I("A",     Input::A    );
+	DEF_CONST_I("B",     Input::B    );
+	DEF_CONST_I("C",     Input::C    );
+	DEF_CONST_I("X",     Input::X    );
+	DEF_CONST_I("Y",     Input::Y    );
+	DEF_CONST_I("Z",     Input::Z    );
+	DEF_CONST_I("L",     Input::L    );
+	DEF_CONST_I("R",     Input::R    );
+
+	DEF_CONST_I("SHIFT", Input::Shift);
+	DEF_CONST_I("CTRL",  Input::Ctrl );
+	DEF_CONST_I("ALT",   Input::Alt  );
+
+	DEF_CONST_I("F5",    Input::F5   );
+	DEF_CONST_I("F6",    Input::F6   );
+	DEF_CONST_I("F7",    Input::F7   );
+	DEF_CONST_I("F8",    Input::F8   );
+	DEF_CONST_I("F9",    Input::F9   );
+
+	mrb_define_module_function(mrb, module, "mouse_x", inputMouseX, MRB_ARGS_NONE());
+	mrb_define_module_function(mrb, module, "mouse_y", inputMouseY, MRB_ARGS_NONE());
+
+	DEF_CONST_I("MOUSELEFT",   Input::MouseLeft  );
+	DEF_CONST_I("MOUSEMIDDLE", Input::MouseMiddle);
+	DEF_CONST_I("MOUSERIGHT",  Input::MouseRight );
+}

binding-mruby/plane-binding.cpp

@@ -0,0 +1,82 @@
+/*
+** plane-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "plane.h"
+#include "disposable-binding.h"
+#include "viewportelement-binding.h"
+#include "binding-util.h"
+#include "binding-types.h"
+
+DEF_TYPE(Plane);
+
+MRB_METHOD(planeInitialize)
+{
+	Plane *p = viewportElementInitialize<Plane>(mrb, self);
+
+	setPrivateData(mrb, self, p, PlaneType);
+
+	p->setColor(new Color);
+	p->setTone(new Tone);
+
+	wrapNilProperty(mrb, self, CSbitmap);
+	wrapProperty(mrb, self, p->getColor(), CScolor, ColorType);
+	wrapProperty(mrb, self, p->getTone(), CStone, ToneType);
+
+	return self;
+}
+
+#define DISP_CLASS_NAME "plane"
+
+DEF_PROP_OBJ(Plane, Bitmap, Bitmap, CSbitmap)
+DEF_PROP_OBJ(Plane, Color, Color, CScolor)
+DEF_PROP_OBJ(Plane, Tone, Tone, CStone)
+
+DEF_PROP_I(Plane, OX)
+DEF_PROP_I(Plane, OY)
+DEF_PROP_I(Plane, Opacity)
+DEF_PROP_I(Plane, BlendType)
+
+DEF_PROP_F(Plane, ZoomX)
+DEF_PROP_F(Plane, ZoomY)
+
+
+void
+planeBindingInit(mrb_state *mrb)
+{
+	RClass *klass = mrb_define_class(mrb, "Plane", 0);
+
+	disposableBindingInit<Plane>     (mrb, klass);
+	viewportElementBindingInit<Plane>(mrb, klass);
+
+	mrb_define_method(mrb, klass, "initialize", planeInitialize, MRB_ARGS_OPT(1));
+
+	INIT_PROP_BIND( Plane, Bitmap,    "bitmap"     );
+	INIT_PROP_BIND( Plane, OX,        "ox"         );
+	INIT_PROP_BIND( Plane, OY,        "oy"         );
+	INIT_PROP_BIND( Plane, ZoomX,     "zoom_x"     );
+	INIT_PROP_BIND( Plane, ZoomY,     "zoom_y"     );
+	INIT_PROP_BIND( Plane, Opacity,   "opacity"    );
+	INIT_PROP_BIND( Plane, BlendType, "blend_type" );
+	INIT_PROP_BIND( Plane, Color,     "color"      );
+	INIT_PROP_BIND( Plane, Tone,      "tone"       );
+
+	mrb_define_method(mrb, klass, "inspect", inspectObject, MRB_ARGS_NONE());
+}

binding-mruby/sceneelement-binding.h

@@ -0,0 +1,90 @@
+/*
+** sceneelement-binding.h
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef SCENEELEMENTBINDING_H
+#define SCENEELEMENTBINDING_H
+
+#include "scene.h"
+#include "binding-util.h"
+
+template<class C>
+MRB_METHOD(sceneElementGetZ)
+{
+	SceneElement *se = getPrivateData<C>(mrb, self);
+
+	mrb_int value = 0;
+	GUARD_EXC( value = se->getZ(); )
+
+	return mrb_fixnum_value(value);
+}
+
+template<class C>
+MRB_METHOD(sceneElementSetZ)
+{
+	SceneElement *se = getPrivateData<C>(mrb, self);
+
+	mrb_int z;
+	mrb_get_args(mrb, "i", &z);
+
+	GUARD_EXC( se->setZ(z); )
+
+	return mrb_nil_value();
+}
+
+template<class C>
+MRB_METHOD(sceneElementGetVisible)
+{
+	SceneElement *se = getPrivateData<C>(mrb, self);
+
+	bool value = false;
+	GUARD_EXC( value = se->getVisible(); )
+
+	return mrb_bool_value(value);
+}
+
+template<class C>
+MRB_METHOD(sceneElementSetVisible)
+{
+	SceneElement *se = getPrivateData<C>(mrb, self);
+
+	mrb_value visibleObj;
+	bool visible;
+
+	mrb_get_args(mrb, "o", &visibleObj);
+
+	visible = mrb_test(visibleObj);
+
+	GUARD_EXC( se->setVisible(visible); )
+
+	return mrb_nil_value();
+}
+
+template<class C>
+void
+sceneElementBindingInit(mrb_state *mrb, RClass *klass)
+{
+	mrb_define_method(mrb, klass, "z",        sceneElementGetZ<C>,       MRB_ARGS_NONE());
+	mrb_define_method(mrb, klass, "z=",       sceneElementSetZ<C>,       MRB_ARGS_REQ(1));
+	mrb_define_method(mrb, klass, "visible",  sceneElementGetVisible<C>, MRB_ARGS_NONE());
+	mrb_define_method(mrb, klass, "visible=", sceneElementSetVisible<C>, MRB_ARGS_REQ(1));
+}
+
+#endif // SCENEELEMENTBINDING_H

binding-mruby/serializable-binding.h

@@ -0,0 +1,51 @@
+/*
+** serializable-binding.h
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef SERIALIZABLEBINDING_H
+#define SERIALIZABLEBINDING_H
+
+#include "serializable.h"
+#include "binding-util.h"
+
+#include "mruby/string.h"
+
+template<class C>
+MRB_METHOD(serializableDump)
+{
+	Serializable *s = getPrivateData<C>(mrb, self);
+
+	int dataSize = s->serialSize();
+
+	mrb_value data = mrb_str_new(mrb, 0, dataSize);
+
+	s->serialize(RSTRING_PTR(data));
+
+	return data;
+}
+
+template<class C>
+void
+serializableBindingInit(mrb_state *mrb, RClass *klass)
+{
+	mrb_define_method(mrb, klass, "_dump", serializableDump<C>, MRB_ARGS_NONE());
+}
+
+#endif // SERIALIZABLEBINDING_H

binding-mruby/sprite-binding.cpp

@@ -0,0 +1,99 @@
+/*
+** sprite-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "sprite.h"
+#include "disposable-binding.h"
+#include "flashable-binding.h"
+#include "sceneelement-binding.h"
+#include "viewportelement-binding.h"
+#include "binding-util.h"
+
+DEF_TYPE(Sprite);
+
+MRB_METHOD(spriteInitialize)
+{
+	Sprite *s = viewportElementInitialize<Sprite>(mrb, self);
+
+	setPrivateData(mrb, self, s, SpriteType);
+
+	/* Wrap property objects */
+	s->setSrcRect(new Rect);
+	s->setColor(new Color);
+	s->setTone(new Tone);
+
+	wrapNilProperty(mrb, self, CSbitmap);
+	wrapProperty(mrb, self, s->getSrcRect(), CSsrc_rect, RectType);
+	wrapProperty(mrb, self, s->getColor(), CScolor, ColorType);
+	wrapProperty(mrb, self, s->getTone(), CStone, ToneType);
+
+	return self;
+}
+
+#define DISP_CLASS_NAME "sprite"
+
+DEF_PROP_OBJ_NIL(Sprite, Bitmap, Bitmap,  CSbitmap)
+DEF_PROP_OBJ(Sprite, Rect,   SrcRect, CSsrc_rect)
+DEF_PROP_OBJ(Sprite, Color,  Color,   CScolor)
+DEF_PROP_OBJ(Sprite, Tone,   Tone,    CStone)
+
+DEF_PROP_I(Sprite, X)
+DEF_PROP_I(Sprite, Y)
+DEF_PROP_I(Sprite, OX)
+DEF_PROP_I(Sprite, OY)
+DEF_PROP_I(Sprite, BushDepth)
+DEF_PROP_I(Sprite, Opacity)
+DEF_PROP_I(Sprite, BlendType)
+
+DEF_PROP_F(Sprite, ZoomX)
+DEF_PROP_F(Sprite, ZoomY)
+DEF_PROP_F(Sprite, Angle)
+
+DEF_PROP_B(Sprite, Mirror)
+
+void
+spriteBindingInit(mrb_state *mrb)
+{
+	RClass *klass = mrb_define_class(mrb, "Sprite", 0);
+
+	disposableBindingInit     <Sprite>(mrb, klass);
+	flashableBindingInit      <Sprite>(mrb, klass);
+	viewportElementBindingInit<Sprite>(mrb, klass);
+
+	mrb_define_method(mrb, klass, "initialize", spriteInitialize, MRB_ARGS_OPT(1));
+
+	INIT_PROP_BIND( Sprite, Bitmap,    "bitmap"     );
+	INIT_PROP_BIND( Sprite, SrcRect,   "src_rect"   );
+	INIT_PROP_BIND( Sprite, X,         "x"          );
+	INIT_PROP_BIND( Sprite, Y,         "y"          );
+	INIT_PROP_BIND( Sprite, OX,        "ox"         );
+	INIT_PROP_BIND( Sprite, OY,        "oy"         );
+	INIT_PROP_BIND( Sprite, ZoomX,     "zoom_x"     );
+	INIT_PROP_BIND( Sprite, ZoomY,     "zoom_y"     );
+	INIT_PROP_BIND( Sprite, Angle,     "angle"      );
+	INIT_PROP_BIND( Sprite, Mirror,    "mirror"     );
+	INIT_PROP_BIND( Sprite, BushDepth, "bush_depth" );
+	INIT_PROP_BIND( Sprite, Opacity,   "opacity"    );
+	INIT_PROP_BIND( Sprite, BlendType, "blend_type" );
+	INIT_PROP_BIND( Sprite, Color,     "color"      );
+	INIT_PROP_BIND( Sprite, Tone,      "tone"       );
+
+	mrb_define_method(mrb, klass, "inspect", inspectObject, MRB_ARGS_NONE());
+}

binding-mruby/table-binding.cpp

@@ -0,0 +1,163 @@
+/*
+** table-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "table.h"
+#include "binding-util.h"
+#include "binding-types.h"
+#include "serializable-binding.h"
+
+#include "mruby.h"
+
+#include <QDebug>
+
+DEF_TYPE(Table);
+
+MRB_METHOD(tableInitialize)
+{
+	mrb_int x, y, z;
+	x = y = z = 1;
+
+	mrb_get_args(mrb, "i|ii", &x, &y, &z);
+
+	Table *t = new Table(x, y, z);
+
+	setPrivateData(mrb, self, t, TableType);
+
+	return self;
+}
+
+#define TABLE_SIZE(d, D) \
+	MRB_METHOD(table##D##Size) \
+	{ \
+		Table *t = getPrivateData<Table>(mrb, self); \
+		return mrb_fixnum_value((mrb_int)t->d##Size()); \
+	}
+
+TABLE_SIZE(x, X)
+TABLE_SIZE(y, Y)
+TABLE_SIZE(z, Z)
+
+MRB_METHOD(tableResize)
+{
+	Table *t = getPrivateData<Table>(mrb, self);
+
+	mrb_int x, y, z;
+	mrb_get_args(mrb, "i|ii", &x, &y, &z);
+
+	switch (mrb->c->ci->argc)
+	{
+	default:
+	case 1:
+		t->resize(x);
+		return mrb_nil_value();
+
+	case 2:
+		t->resize(x, y);
+		return mrb_nil_value();
+
+	case 3:
+		t->resize(x, y, z);
+		return mrb_nil_value();
+	}
+}
+
+MRB_METHOD(tableGetAt)
+{
+	Table *t = getPrivateData<Table>(mrb, self);
+
+	mrb_int x, y, z;
+	x = y = z = 0;
+
+	mrb_get_args(mrb, "i|ii", &x, &y, &z);
+
+	if (x < 0 || x >= t->xSize()
+	||  y < 0 || y >= t->ySize()
+	||  z < 0 || z >= t->zSize())
+	{
+		return mrb_nil_value();
+	}
+
+	mrb_int result = t->get(x, y, z);
+
+	return mrb_fixnum_value(result);
+}
+
+#define fix(x) mrb_fixnum(x)
+
+MRB_METHOD(tableSetAt)
+{
+	Table *t = getPrivateData<Table>(mrb, self);
+
+	int argc;
+	mrb_value* argv;
+	mrb_int x, y, z, value;
+	x = y = z = 0;
+
+	mrb_get_args(mrb, "*", &argv, &argc);
+
+	if (argc < 2)
+		mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments");
+
+	switch (argc)
+	{
+	default:
+	case 2 :
+		x = fix(argv[0]);
+		value = fix(argv[1]);
+		break;
+	case 3 :
+		x = fix(argv[0]);
+		y = fix(argv[1]);
+		value = fix(argv[2]);
+		break;
+	case 4 :
+		x = fix(argv[0]);
+		y = fix(argv[1]);
+		z = fix(argv[2]);
+		value = fix(argv[3]);
+		break;
+	}
+
+	t->set(value, x, y, z);
+
+	return mrb_fixnum_value(value);
+}
+
+MARSH_LOAD_FUN(Table)
+
+void
+tableBindingInit(mrb_state *mrb)
+{
+	RClass *klass = mrb_define_class(mrb, "Table", 0);
+
+	mrb_define_class_method(mrb, klass, "_load", TableLoad, MRB_ARGS_REQ(1));
+	serializableBindingInit<Table>(mrb, klass);
+
+	mrb_define_method(mrb, klass, "initialize", tableInitialize, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(2));
+	mrb_define_method(mrb, klass, "resize",     tableResize,     MRB_ARGS_REQ(1) | MRB_ARGS_OPT(2));
+	mrb_define_method(mrb, klass, "xsize",      tableXSize,      MRB_ARGS_NONE()                  );
+	mrb_define_method(mrb, klass, "ysize",      tableYSize,      MRB_ARGS_NONE()                  );
+	mrb_define_method(mrb, klass, "zsize",      tableZSize,      MRB_ARGS_NONE()                  );
+	mrb_define_method(mrb, klass, "[]",         tableGetAt,      MRB_ARGS_REQ(1) | MRB_ARGS_OPT(2));
+	mrb_define_method(mrb, klass, "[]=",        tableSetAt,      MRB_ARGS_REQ(2) | MRB_ARGS_OPT(2));
+
+	mrb_define_method(mrb, klass, "inspect", inspectObject, MRB_ARGS_NONE());
+}

binding-mruby/tilemap-binding.cpp

@@ -0,0 +1,161 @@
+/*
+** tilemap-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "tilemap.h"
+#include "viewport.h"
+#include "bitmap.h"
+#include "table.h"
+
+#include "disposable-binding.h"
+#include "binding-util.h"
+#include "binding-types.h"
+
+#include "mruby/array.h"
+
+static const mrb_data_type TilemapAutotilesType =
+{
+    "TilemapAutotiles",
+	0
+};
+
+MRB_METHOD(tilemapAutotilesSet)
+{
+	Tilemap::Autotiles *a = getPrivateData<Tilemap::Autotiles>(mrb, self);
+
+	mrb_int i;
+	mrb_value bitmapObj;
+
+	mrb_get_args(mrb, "io", &i, &bitmapObj);
+
+	Bitmap *bitmap = getPrivateDataCheck<Bitmap>(mrb, bitmapObj, BitmapType);
+
+	a->set(i, bitmap);
+
+	mrb_value ary = mrb_iv_get(mrb, self, getMrbData(mrb)->symbols[CSarray]);
+	mrb_ary_set(mrb, ary, i, bitmapObj);
+
+	return self;
+}
+
+MRB_METHOD(tilemapAutotilesGet)
+{
+	mrb_int i;
+
+	mrb_get_args (mrb, "i", &i);
+
+	if (i < 0 || i > 6)
+		return mrb_nil_value();
+
+	mrb_value ary = mrb_iv_get(mrb, self, getMrbData(mrb)->symbols[CSarray]);
+
+	return mrb_ary_entry(ary, i);
+}
+
+DEF_TYPE(Tilemap);
+
+MRB_METHOD(tilemapInitialize)
+{
+	Tilemap *t;
+
+	/* Get parameters */
+	mrb_value viewportObj = mrb_nil_value();
+	Viewport *viewport = 0;
+
+	mrb_get_args(mrb, "|o", &viewportObj);
+
+	if (!mrb_nil_p(viewportObj))
+		viewport = getPrivateDataCheck<Viewport>(mrb, viewportObj, ViewportType);
+
+	/* Construct object */
+	t = new Tilemap(viewport);
+
+	setPrivateData(mrb, self, t, TilemapType);
+
+	setProperty(mrb, self, CSviewport, viewportObj);
+
+	wrapProperty(mrb, self, &t->getAutotiles(), CSautotiles, TilemapAutotilesType);
+
+	mrb_value autotilesObj = mrb_iv_get(mrb, self, getMrbData(mrb)->symbols[CSautotiles]);
+
+	mrb_value ary = mrb_ary_new_capa(mrb, 7);
+	for (int i = 0; i < 7; ++i)
+		mrb_ary_push(mrb, ary, mrb_nil_value());
+
+	mrb_iv_set(mrb, autotilesObj, getMrbData(mrb)->symbols[CSarray], ary);
+
+	return self;
+}
+
+MRB_METHOD(tilemapGetAutotiles)
+{
+	return getProperty(mrb, self, CSautotiles);
+}
+
+MRB_METHOD(tilemapUpdate)
+{
+	Tilemap *t = getPrivateData<Tilemap>(mrb, self);
+
+	t->update();
+
+	return mrb_nil_value();
+}
+
+#define DISP_CLASS_NAME "tilemap"
+
+DEF_PROP_OBJ(Tilemap, Viewport, Viewport,   CSviewport)
+DEF_PROP_OBJ(Tilemap, Bitmap,   Tileset,    CStileset)
+DEF_PROP_OBJ(Tilemap, Table,    MapData,    CSmap_data)
+DEF_PROP_OBJ(Tilemap, Table,    FlashData,  CSflash_data)
+DEF_PROP_OBJ(Tilemap, Table,    Priorities, CSpriorities)
+
+DEF_PROP_B(Tilemap, Visible)
+
+DEF_PROP_I(Tilemap, OX)
+DEF_PROP_I(Tilemap, OY)
+
+void
+tilemapBindingInit(mrb_state *mrb)
+{
+	RClass *klass = mrb_define_class(mrb, "TilemapAutotiles", 0);
+
+	mrb_define_method(mrb, klass, "[]=", tilemapAutotilesSet, MRB_ARGS_REQ(2));
+	mrb_define_method(mrb, klass, "[]", tilemapAutotilesGet, MRB_ARGS_REQ(1));
+	mrb_define_method(mrb, klass, "inspect", inspectObject, MRB_ARGS_NONE());
+
+	klass = mrb_define_class(mrb, "Tilemap", 0);
+
+	disposableBindingInit<Tilemap>(mrb, klass);
+
+	mrb_define_method(mrb, klass, "initialize", tilemapInitialize, MRB_ARGS_OPT(1));
+	mrb_define_method(mrb, klass, "autotiles", tilemapGetAutotiles, MRB_ARGS_NONE());
+	mrb_define_method(mrb, klass, "update", tilemapUpdate, MRB_ARGS_NONE());
+
+	INIT_PROP_BIND( Tilemap, Viewport,   "viewport"   );
+	INIT_PROP_BIND( Tilemap, Tileset,    "tileset"    );
+	INIT_PROP_BIND( Tilemap, MapData,    "map_data"   );
+	INIT_PROP_BIND( Tilemap, FlashData,  "flash_data" );
+	INIT_PROP_BIND( Tilemap, Priorities, "priorities" );
+	INIT_PROP_BIND( Tilemap, Visible,    "visible"    );
+	INIT_PROP_BIND( Tilemap, OX,         "ox"         );
+	INIT_PROP_BIND( Tilemap, OY,         "oy"         );
+
+	mrb_define_method(mrb, klass, "inspect", inspectObject, MRB_ARGS_NONE());
+}

binding-mruby/viewport-binding.cpp

@@ -0,0 +1,99 @@
+/*
+** viewport-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "viewport.h"
+#include "disposable-binding.h"
+#include "flashable-binding.h"
+#include "sceneelement-binding.h"
+#include "binding-util.h"
+#include "binding-types.h"
+
+DEF_TYPE(Viewport);
+
+MRB_METHOD(viewportInitialize)
+{
+	Viewport *v;
+
+	if (mrb->c->ci->argc == 1)
+	{
+		/* The rect arg is only used to init the viewport,
+		 * and does NOT replace its 'rect' property */
+		mrb_value rectObj;
+		Rect *rect;
+
+		mrb_get_args(mrb, "o", &rectObj);
+
+		rect = getPrivateDataCheck<Rect>(mrb, rectObj, RectType);
+
+		v = new Viewport(rect);
+	}
+	else
+	{
+		mrb_int x, y, width, height;
+
+		mrb_get_args(mrb, "iiii", &x, &y, &width, &height);
+
+		v = new Viewport(x, y, width, height);
+	}
+
+	setPrivateData(mrb, self, v, ViewportType);
+
+	/* Wrap property objects */
+	v->setRect(new Rect(*v->getRect()));
+	v->setColor(new Color);
+	v->setTone(new Tone);
+
+	wrapProperty(mrb, self, v->getRect(),  CSrect,  RectType);
+	wrapProperty(mrb, self, v->getColor(), CScolor, ColorType);
+	wrapProperty(mrb, self, v->getTone(),  CStone,  ToneType);
+
+	return self;
+}
+
+#define DISP_CLASS_NAME "viewport"
+
+DEF_PROP_OBJ(Viewport, Rect, Rect, CSrect)
+DEF_PROP_OBJ(Viewport, Color, Color, CScolor)
+DEF_PROP_OBJ(Viewport, Tone, Tone, CStone)
+
+DEF_PROP_I(Viewport, OX)
+DEF_PROP_I(Viewport, OY)
+
+
+void
+viewportBindingInit(mrb_state *mrb)
+{
+	RClass *klass = mrb_define_class(mrb, "Viewport", 0);
+
+	disposableBindingInit  <Viewport>(mrb, klass);
+	flashableBindingInit   <Viewport>(mrb, klass);
+	sceneElementBindingInit<Viewport>(mrb, klass);
+
+	mrb_define_method(mrb, klass, "initialize", viewportInitialize, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(3));
+
+	INIT_PROP_BIND( Viewport, Rect,  "rect"  );
+	INIT_PROP_BIND( Viewport, OX,    "ox"    );
+	INIT_PROP_BIND( Viewport, OY,    "oy"    );
+	INIT_PROP_BIND( Viewport, Color, "color" );
+	INIT_PROP_BIND( Viewport, Tone,  "tone"  );
+
+	mrb_define_method(mrb, klass, "inspect", inspectObject, MRB_ARGS_NONE());
+}

binding-mruby/viewportelement-binding.h

@@ -0,0 +1,72 @@
+/*
+** viewportelement-binding.h
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef VIEWPORTELEMENTBINDING_H
+#define VIEWPORTELEMENTBINDING_H
+
+#include "viewport.h"
+#include "binding-util.h"
+#include "binding-types.h"
+
+#include "sceneelement-binding.h"
+
+template<class C>
+MRB_METHOD(viewportElementGetViewport)
+{
+	ViewportElement *ve = getPrivateData<C>(mrb, self);
+
+	GUARD_EXC( ve->aboutToAccess(); )
+
+	return getProperty(mrb, self, CSviewport);
+}
+
+template<class C>
+static C *
+viewportElementInitialize(mrb_state *mrb, mrb_value self)
+{
+	/* Get parameters */
+	mrb_value viewportObj = mrb_nil_value();
+	Viewport *viewport = 0;
+
+	mrb_get_args(mrb, "|o", &viewportObj);
+
+	if (!mrb_nil_p(viewportObj))
+		viewport = getPrivateDataCheck<Viewport>(mrb, viewportObj, ViewportType);
+
+	/* Construct object */
+	C *ve = new C(viewport);
+
+	/* Set property objects */
+	setProperty(mrb, self, CSviewport, viewportObj);
+
+	return ve;
+}
+
+template<class C>
+void
+viewportElementBindingInit(mrb_state *mrb, RClass *klass)
+{
+	sceneElementBindingInit<C>(mrb, klass);
+
+	mrb_define_method(mrb, klass, "viewport", viewportElementGetViewport<C>, MRB_ARGS_NONE());
+}
+
+#endif // VIEWPORTELEMENTBINDING_H

binding-mruby/window-binding.cpp

@@ -0,0 +1,101 @@
+/*
+** window-binding.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "window.h"
+#include "disposable-binding.h"
+#include "viewportelement-binding.h"
+#include "binding-util.h"
+
+DEF_TYPE(Window);
+
+MRB_METHOD(windowInitialize)
+{
+	Window *w = viewportElementInitialize<Window>(mrb, self);
+
+	setPrivateData(mrb, self, w, WindowType);
+
+	w->setCursorRect(new Rect);
+	wrapNilProperty(mrb, self, CSwindowskin);
+	wrapNilProperty(mrb, self, CScontents);
+	wrapProperty(mrb, self, w->getCursorRect(), CScursor_rect, RectType);
+
+	return self;
+}
+
+MRB_METHOD(windowUpdate)
+{
+	Window *w = getPrivateData<Window>(mrb, self);
+
+	w->update();
+
+	return mrb_nil_value();
+}
+
+#define DISP_CLASS_NAME "window"
+
+DEF_PROP_OBJ_NIL(Window, Bitmap, Windowskin, CSwindowskin)
+DEF_PROP_OBJ_NIL(Window, Bitmap, Contents,   CScontents)
+DEF_PROP_OBJ(Window, Rect, CursorRect, CScursor_rect)
+
+DEF_PROP_B(Window, Stretch)
+DEF_PROP_B(Window, Active)
+DEF_PROP_B(Window, Pause)
+
+DEF_PROP_I(Window, X)
+DEF_PROP_I(Window, Y)
+DEF_PROP_I(Window, Width)
+DEF_PROP_I(Window, Height)
+DEF_PROP_I(Window, OX)
+DEF_PROP_I(Window, OY)
+DEF_PROP_I(Window, Opacity)
+DEF_PROP_I(Window, BackOpacity)
+DEF_PROP_I(Window, ContentsOpacity)
+
+
+void
+windowBindingInit(mrb_state *mrb)
+{
+	RClass *klass = mrb_define_class(mrb, "Window", 0);
+
+	disposableBindingInit     <Window>(mrb, klass);
+	viewportElementBindingInit<Window>(mrb, klass);
+
+	mrb_define_method(mrb, klass, "initialize", windowInitialize, MRB_ARGS_REQ(1));
+	mrb_define_method(mrb, klass, "update",     windowUpdate,     MRB_ARGS_NONE());
+
+	INIT_PROP_BIND( Window, Windowskin,      "windowskin"       );
+	INIT_PROP_BIND( Window, Contents,        "contents"         );
+	INIT_PROP_BIND( Window, Stretch,         "stretch"          );
+	INIT_PROP_BIND( Window, CursorRect,      "cursor_rect"      );
+	INIT_PROP_BIND( Window, Active,          "active"           );
+	INIT_PROP_BIND( Window, Pause,           "pause"            );
+	INIT_PROP_BIND( Window, X,               "x"                );
+	INIT_PROP_BIND( Window, Y,               "y"                );
+	INIT_PROP_BIND( Window, Width,           "width"            );
+	INIT_PROP_BIND( Window, Height,          "height"           );
+	INIT_PROP_BIND( Window, OX,              "ox"               );
+	INIT_PROP_BIND( Window, OY,              "oy"               );
+	INIT_PROP_BIND( Window, Opacity,         "opacity"          );
+	INIT_PROP_BIND( Window, BackOpacity,     "back_opacity"     );
+	INIT_PROP_BIND( Window, ContentsOpacity, "contents_opacity" );
+
+	mrb_define_method(mrb, klass, "inspect", inspectObject, MRB_ARGS_NONE());
+}

binding-null/binding-null.cpp

@@ -0,0 +1,45 @@
+/*
+** binding-null.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "binding.h"
+#include "globalstate.h"
+#include "eventthread.h"
+
+#include <QDebug>
+
+static void nullBindingExecute()
+{
+	qDebug() << "The null binding doesn't do anything, so we're done!";
+	gState->rtData().rqTermAck = true;
+}
+
+static void nullBindingTerminate()
+{
+
+}
+
+ScriptBinding scriptBindingImpl =
+{
+    nullBindingExecute,
+    nullBindingTerminate
+};
+
+ScriptBinding *scriptBinding = &scriptBindingImpl;

mkxp.conf

@@ -0,0 +1,11 @@
+[General]
+debugMode=true
+winResizable=true
+fullscreen=false
+vsync=true
+defScreenW=640
+defScreenH=480
+solidFonts=false
+gameFolder=.
+customScript=
+RTPs=/home/Ancurio/Public/RGSS-RTP

mkxp.pro

@@ -0,0 +1,192 @@
+
+
+TEMPLATE = app
+QT = core
+TARGET = mkxp
+DEPENDPATH += src shader assets
+INCLUDEPATH += . src SFML/include libsigc++
+
+isEmpty(BINDING) {
+	BINDING = BINDING_MRI
+}
+
+CONFIG += $$BINDING
+
+unix {
+    CONFIG += link_pkgconfig
+    PKGCONFIG += sigc++-2.0 sdl2 SDL2_image SDL2_ttf sfml-audio
+	LIBS += -lGLEW -lphysfs -lz
+}
+
+# 'slots' keyword fucks with libsigc++
+DEFINES += QT_NO_KEYWORDS
+
+# Input
+HEADERS += \
+	src/quadarray.h \
+	src/audio.h \
+	src/binding.h \
+	src/bitmap.h \
+	src/disposable.h \
+	src/etc.h \
+	src/etc-internal.h \
+	src/eventthread.h \
+	src/flashable.h \
+	src/font.h \
+	src/globalstate.h \
+	src/input.h \
+	src/plane.h \
+	src/scene.h \
+	src/sprite.h \
+	src/table.h \
+	src/texpool.h \
+	src/tilequad.h \
+	src/transform.h \
+	src/viewport.h \
+	src/window.h \
+    src/serializable.h \
+    src/shader.h \
+    src/glstate.h \
+    src/quad.h \
+    src/tilemap.h \
+    src/graphics.h \
+    src/debuglogger.h \
+    src/global-ibo.h \
+    src/exception.h \
+    src/filesystem.h \
+    src/serial-util.h \
+    src/intrulist.h \
+    src/binding.h \
+	src/gl-util.h \
+	src/util.h \
+    src/config.h
+
+SOURCES += \
+	src/main.cpp \
+	src/audio.cpp \
+	src/bitmap.cpp \
+	src/eventthread.cpp \
+	src/filesystem.cpp \
+	src/font.cpp \
+	src/globalstate.cpp \
+	src/input.cpp \
+	src/plane.cpp \
+	src/scene.cpp \
+	src/sprite.cpp \
+	src/table.cpp \
+	src/tilequad.cpp \
+	src/viewport.cpp \
+	src/window.cpp \
+	src/texpool.cpp \
+    src/shader.cpp \
+    src/glstate.cpp \
+    src/tilemap.cpp \
+	src/autotiles.cpp \
+    src/graphics.cpp \
+    src/debuglogger.cpp \
+	src/etc.cpp \
+    src/config.cpp
+
+EMBED = shader/transSimple.frag \
+        shader/trans.frag \
+        shader/hue.frag \
+        shader/sprite.frag \
+	    shader/bitmapBlit.frag \
+		assets/liberation.ttf
+
+# xxd
+xxd.output = ${QMAKE_FILE_NAME}.xxd
+xxd.commands = xxd -i ${QMAKE_FILE_NAME} > ${QMAKE_FILE_OUT}
+xxd.depends = $$EMBED
+xxd.input = EMBED
+xxd.variable_out = HEADERS
+
+QMAKE_EXTRA_COMPILERS += xxd
+
+
+BINDING_NULL {
+	SOURCES += binding-null/binding-null.cpp
+}
+
+BINDING_MRUBY {
+	LIBS += mruby/build/host/lib/libmruby.a
+	INCLUDEPATH += mruby/include
+	DEPENDPATH += mruby/include
+	DEFINES += BINDING_MRUBY
+
+	HEADERS += \
+	binding-mruby/binding-util.h \
+	binding-mruby/disposable-binding.h \
+    binding-mruby/flashable-binding.h \
+    binding-mruby/binding-types.h \
+    binding-mruby/sceneelement-binding.h \
+    binding-mruby/viewportelement-binding.h \
+    binding-mruby/serializable-binding.h \
+    binding-mruby/mrb-ext/file.h \
+    binding-mruby/mrb-ext/rwmem.h \
+    binding-mruby/mrb-ext/marshal.h
+
+	SOURCES += \
+	binding-mruby/binding-mruby.cpp \
+	binding-mruby/binding-util.cpp \
+	binding-mruby/window-binding.cpp \
+	binding-mruby/bitmap-binding.cpp \
+	binding-mruby/sprite-binding.cpp \
+	binding-mruby/font-binding.cpp \
+	binding-mruby/viewport-binding.cpp \
+	binding-mruby/plane-binding.cpp \
+	binding-mruby/audio-binding.cpp \
+	binding-mruby/tilemap-binding.cpp \
+	binding-mruby/etc-binding.cpp \
+	binding-mruby/graphics-binding.cpp \
+	binding-mruby/input-binding.cpp \
+	binding-mruby/table-binding.cpp \
+	binding-mruby/module_rpg.c \
+	binding-mruby/mrb-ext/file.cpp \
+	binding-mruby/mrb-ext/marshal.cpp \
+	binding-mruby/mrb-ext/rwmem.cpp \
+	binding-mruby/mrb-ext/kernel.cpp \
+	binding-mruby/mrb-ext/time.cpp
+}
+
+BINDING_MRI {
+	LIBS += ./ruby/libruby.so
+	INCLUDEPATH += ruby/include
+	DEPENDPATH += ruby/include
+	DEFINES += BINDING_MRI
+
+	EMBED2 = binding-mri/module_rpg.rb
+	xxdp.output = ${QMAKE_FILE_NAME}.xxd
+	xxdp.commands = xxd+/xxd+ ${QMAKE_FILE_NAME} -o ${QMAKE_FILE_OUT} --string
+	xxdp.depends = $$EMBED2
+	xxdp.input = EMBED2
+	xxdp.variable_out = HEADERS
+	QMAKE_EXTRA_COMPILERS += xxdp
+
+	HEADERS += \
+    binding-mri/binding-util.h \
+	binding-mri/binding-types.h \
+    binding-mri/serializable-binding.h \
+    binding-mri/disposable-binding.h \
+    binding-mri/sceneelement-binding.h \
+    binding-mri/viewportelement-binding.h \
+    binding-mri/flashable-binding.h
+
+	SOURCES += \
+	binding-mri/binding-mri.cpp \
+    binding-mri/binding-util.cpp \
+    binding-mri/table-binding.cpp \
+    binding-mri/etc-binding.cpp \
+    binding-mri/bitmap-binding.cpp \
+    binding-mri/font-binding.cpp \
+    binding-mri/graphics-binding.cpp \
+    binding-mri/input-binding.cpp \
+    binding-mri/sprite-binding.cpp \
+    binding-mri/viewport-binding.cpp \
+    binding-mri/plane-binding.cpp \
+    binding-mri/window-binding.cpp \
+    binding-mri/tilemap-binding.cpp \
+    binding-mri/audio-binding.cpp \
+    binding-mri/module_rpg.cpp \
+    binding-mri/filesystem-binding.cpp
+}

shader/bitmapBlit.frag

@@ -0,0 +1,31 @@
+
+uniform sampler2D source;
+uniform sampler2D destination;
+
+uniform vec4 subRect;
+
+uniform float opacity;
+
+void main()
+{
+	vec2 coor = gl_TexCoord[0].xy;
+	vec2 dstCoor = (coor - subRect.xy) * subRect.zw;
+
+	vec4 srcFrag = texture2D(source, coor);
+	vec4 dstFrag = texture2D(destination, dstCoor);
+
+	vec4 resFrag;
+
+	float ab = opacity;
+	const float as = srcFrag.a;
+	const float ad = dstFrag.a;
+
+	const float at = ab*as;
+	resFrag.a = at + ad - ad*at;
+
+	resFrag.rgb = mix(dstFrag.rgb, srcFrag.rgb, ab*as);
+//	resFrag.rgb /= (resFrag.a);
+	resFrag.rgb = mix(srcFrag.rgb, resFrag.rgb, ad*resFrag.a);
+
+	gl_FragColor = resFrag;
+}

shader/hue.frag

@@ -0,0 +1,40 @@
+uniform sampler2D inputTexture;
+uniform float   hueAdjust;
+void main ()
+{
+	const vec4  kRGBToYPrime = vec4 (0.299, 0.587, 0.114, 0.0);
+	const vec4  kRGBToI     = vec4 (0.596, -0.275, -0.321, 0.0);
+	const vec4  kRGBToQ     = vec4 (0.212, -0.523, 0.311, 0.0);
+
+	const vec4  kYIQToR   = vec4 (1.0, 0.956, 0.621, 0.0);
+	const vec4  kYIQToG   = vec4 (1.0, -0.272, -0.647, 0.0);
+	const vec4  kYIQToB   = vec4 (1.0, -1.107, 1.704, 0.0);
+
+	// Sample the input pixel
+	vec4    color   = texture2D (inputTexture, gl_TexCoord [ 0 ].xy);
+
+	// Convert to YIQ
+	float   YPrime = dot (color, kRGBToYPrime);
+	float   I      = dot (color, kRGBToI);
+	float   Q      = dot (color, kRGBToQ);
+
+	// Calculate the hue and chroma
+	float   hue     = atan (Q, I);
+	float   chroma  = sqrt (I * I + Q * Q);
+
+	// Make the user's adjustments
+	hue += hueAdjust;
+
+	// Convert back to YIQ
+	Q = chroma * sin (hue);
+	I = chroma * cos (hue);
+
+	// Convert back to RGB
+	vec4    yIQ   = vec4 (YPrime, I, Q, 0.0);
+	color.r = dot (yIQ, kYIQToR);
+	color.g = dot (yIQ, kYIQToG);
+	color.b = dot (yIQ, kYIQToB);
+
+	// Save the result
+	gl_FragColor    = color;
+}

shader/sprite.frag

@@ -0,0 +1,43 @@
+
+uniform sampler2D texture;
+
+uniform vec4 tone;
+
+uniform float opacity;
+uniform vec4 color;
+uniform vec4 flash;
+
+uniform float bushDepth;
+uniform float bushOpacity;
+
+const vec3 lumaF = { .299, .587, .114 };
+
+void main()
+{
+	vec2 coor = gl_TexCoord[0].xy;
+
+	/* Sample source color */
+	vec4 frag = texture2D(texture, coor);
+	
+	/* Apply gray */
+	const float luma = dot(frag.rgb, lumaF);
+	frag.rgb = mix(frag.rgb, vec3(luma), tone.w);
+	
+	/* Apply tone */
+	frag.rgb += tone.rgb;
+
+	/* Apply opacity */
+	frag.a *= opacity;
+	
+	/* Apply color */
+	frag.rgb = mix(frag.rgb, color.rgb, color.a);
+
+	/* Apply flash */
+	frag.rgb = mix(frag.rgb, flash.rgb, flash.a);
+
+	/* Apply bush alpha by mathematical if */
+	float underBush = float(coor.y < bushDepth);
+	frag.a *= clamp(bushOpacity + underBush, 0, 1);
+	
+	gl_FragColor = frag;
+}

shader/trans.frag

@@ -0,0 +1,23 @@
+
+/* Fragment shader dealing with transitions */
+
+uniform sampler2D currentScene;
+uniform sampler2D frozenScene;
+uniform sampler2D transMap;
+/* Normalized */
+uniform float prog;
+/* Vague [0, 512] normalized */
+uniform float vague;
+
+void main()
+{
+    vec2 texCoor = gl_TexCoord[0].st;
+    float transV = texture2D(transMap, texCoor).r;
+    float cTransV = clamp(transV, prog, prog+vague);
+    float alpha = (cTransV - prog) / vague;
+    
+    vec4 newFrag = texture2D(currentScene, texCoor);
+    vec4 oldFrag = texture2D(frozenScene, texCoor);
+    
+    gl_FragColor = mix(newFrag, oldFrag, alpha);
+}

shader/transSimple.frag

@@ -0,0 +1,13 @@
+
+uniform sampler2D frozenScene;
+uniform sampler2D currentScene;
+uniform float prog;
+
+void main()
+{
+    vec2 texCoor = gl_TexCoord[0].st;
+    vec4 newPixel = texture2D(currentScene, texCoor);
+    vec4 oldPixel = texture2D(frozenScene, texCoor);
+
+    gl_FragColor = mix(oldPixel, newPixel, prog);
+}

src/audio.cpp

@@ -0,0 +1,668 @@
+/*
+** audio.cpp
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "audio.h"
+
+#include "globalstate.h"
+#include "util.h"
+#include "intrulist.h"
+#include "filesystem.h"
+#include "exception.h"
+
+#include <SFML/Audio/Music.hpp>
+#include <SFML/Audio/Sound.hpp>
+#include <SFML/Audio/SoundBuffer.hpp>
+#include <SFML/System/Thread.hpp>
+#include <SFML/System/Clock.hpp>
+#include <SFML/System/Sleep.hpp>
+#include <QByteArray>
+#include <QHash>
+
+#include "SDL2/SDL_thread.h"
+
+//#include "SDL2/SDL_mixer.h"
+
+#include <QDebug>
+
+#define FADE_SLEEP 10
+#define SOUND_MAG_SIZE 10
+#define SOUND_MAX_MEM (50*1000*1000) // 5 MB
+
+struct MusicEntity
+{
+	sf::Music music;
+	QByteArray filename;
+	FileStream currentData;
+	SDL_mutex *mutex;
+
+	int pitch;
+
+	volatile bool fading;
+	struct
+	{
+		unsigned int duration;
+		float msStep;
+		volatile bool terminate;
+		sf::Thread *thread;
+	} fadeData;
+
+	/* normalized */
+	float intVolume;
+	float extVolume;
+
+	bool extPaused;
+	bool noFadeInFlag;
+
+	MusicEntity()
+	    : currentData(0),
+	      pitch(100),
+	      fading(false),
+	      intVolume(1),
+	      extVolume(1),
+	      extPaused(false),
+	      noFadeInFlag(false)
+	{
+		music.setLoop(true);
+		fadeData.thread = 0;
+		mutex = SDL_CreateMutex();
+	}
+
+	~MusicEntity()
+	{
+		SDL_DestroyMutex(mutex);
+	}
+
+	void play(const QByteArray &filename,
+	          int volume,
+	          int pitch)
+	{
+		terminateFade();
+
+		volume = bound<int>(volume, 0, 100);
+		pitch = bound<int>(pitch, 50, 150);
+
+		if (filename == this->filename
+		&&  volume == (int)music.getVolume()
+//		&&  pitch == music.getPitch()
+		&&  music.getStatus() == sf::Music::Playing)
+			return;
+
+		if (filename == this->filename
+		&&  music.getStatus() == sf::Music::Playing)
+//		&&  pitch == music.getPitch())
+		{
+			intVolume = (float) volume / 100;
+			updateVolumeSync();
+			return;
+		}
+
+		SDL_LockMutex(mutex);
+
+		this->music.stop();
+
+		this->filename = filename;
+
+		currentData.close();
+
+		currentData =
+		        gState->fileSystem().openRead(filename.constData(), FileSystem::Audio);
+
+		if (!this->music.openFromStream(currentData))
+			return;
+
+		intVolume = (float) volume / 100;
+		updateVolume();
+//		this->music.setPitch((float) pitch / 100);
+
+		if (!extPaused)
+			this->music.play();
+		else
+			noFadeInFlag = true;
+
+		SDL_UnlockMutex(mutex);
+	}
+
+	void stop()
+	{
+		terminateFade();
+
+		stopPriv();
+	}
+
+	void fade(unsigned int ms)
+	{
+		if (music.getStatus() != sf::Music::Playing)
+			return;
+
+		if (fading)
+			return;
+
+		delete fadeData.thread;
+		fadeData.thread = new sf::Thread(&MusicEntity::processFade, this);
+		fadeData.duration = ms;
+		fadeData.terminate = false;
+
+		fading = true;
+		fadeData.thread->launch();
+	}
+
+	void updateVolume()
+	{
+		music.setVolume(intVolume * extVolume * 100);
+	}
+
+	void updateVolumeSync()
+	{
+		SDL_LockMutex(mutex);
+		updateVolume();
+		SDL_UnlockMutex(mutex);
+	}
+
+private:
+	void terminateFade()
+	{
+		if (!fading)
+			return;
+
+		/* Tell our thread to wrap up and wait for it */
+		fadeData.terminate = true;
+		fadeData.thread->wait();
+
+		fading = false;
+	}
+
+	void stopPriv()
+	{
+		SDL_LockMutex(mutex);
+		music.stop();
+		SDL_UnlockMutex(mutex);
+
+		filename = QByteArray();
+	}
+
+	void processFade()
+	{
+		float msStep = music.getVolume() / fadeData.duration;
+		sf::Clock timer;
+		sf::Time sleepTime = sf::milliseconds(FADE_SLEEP);
+		unsigned int currentDur = 0;
+
+		while (true)
+		{
+			int elapsed = timer.getElapsedTime().asMilliseconds();
+			timer.restart();
+			currentDur += elapsed;
+
+			if (music.getStatus() != sf::Music::Playing)
+				break;
+
+			if (fadeData.terminate)
+				break;
+
+			if (currentDur >= fadeData.duration)
+				break;
+
+			intVolume = (float) (music.getVolume() - (elapsed * msStep)) / 100;
+			updateVolumeSync();
+
+			sf::sleep(sleepTime);
+		}
+
+		stopPriv();
+		fading = false;
+	}
+};
+
+//struct SoundBuffer
+//{
+//	Mix_Chunk *sdlBuffer;
+//	QByteArray filename;
+//	IntruListLink<SoundBuffer> link;
+
+//	SoundBuffer()
+//	    : link(this)
+//	{}
+//};
+
+//struct SoundEntity
+//{
+//	IntruList<SoundBuffer> buffers;
+//	QHash<QByteArray, SoundBuffer*> bufferHash;
+//	uint cacheSize; // in chunks, for now
+//	int channelIndex;
+
+//	SoundEntity()
+//	    : cacheSize(0),
+//	      channelIndex(0)
+//	{
+//		Mix_AllocateChannels(SOUND_MAG_SIZE);
+//	}
+
+//	~SoundEntity()
+//	{
+//		IntruListLink<SoundBuffer> *iter = buffers.iterStart();
+//		iter = iter->next;
+
+//		for (int i = 0; i < buffers.getSize(); ++i)
+//		{
+//			SoundBuffer *buffer = iter->data;
+//			iter = iter->next;
+//			delete buffer;
+//		}
+//	}
+
+//	void play(const char *filename,
+//	          int volume,
+//	          int pitch)
+//	{
+//		(void) pitch;
+
+//		volume = bound(volume, 0, 100);
+
+//		Mix_Chunk *buffer = requestBuffer(filename);
+
+//		int nextChIdx = channelIndex++;
+//		if (channelIndex > SOUND_MAG_SIZE-1)
+//			channelIndex = 0;
+
+//		Mix_HaltChannel(nextChIdx);
+//		Mix_Volume(nextChIdx, ((float) MIX_MAX_VOLUME / 100) * volume);
+//		Mix_PlayChannelTimed(nextChIdx, buffer, 0, -1);
+//	}
+
+//	void stop()
+//	{
+//		/* Stop all channels */
+//		Mix_HaltChannel(-1);
+//	}
+
+//private:
+//	Mix_Chunk *requestBuffer(const char *filename)
+//	{
+//		SoundBuffer *buffer = bufferHash.value(filename, 0);
+
+//		if (buffer)
+//		{
+//			/* Buffer still in cashe.
+//			 * Move to front of priority list */
+//			buffers.remove(buffer->link);
+//			buffers.append(buffer->link);
+
+//			return buffer->sdlBuffer;
+//		}
+//		else
+//		{
+//			/* Buffer not in cashe, needs to be loaded */
+//			SDL_RWops ops;
+//			gState->fileSystem().openRead(ops, filename, FileSystem::Audio);
+
+//			Mix_Chunk *sdlBuffer = Mix_LoadWAV_RW(&ops, 1);
+
+//			if (!sdlBuffer)
+//			{
+//				SDL_RWclose(&ops);
+//				throw Exception(Exception::RGSSError, "Unable to read sound file");
+//			}
+
+//			buffer = new SoundBuffer;
+//			buffer->sdlBuffer = sdlBuffer;
+//			buffer->filename = filename;
+
+//			++cacheSize;
+
+//			bufferHash.insert(filename, buffer);
+//			buffers.prepend(buffer->link);
+
+//			if (cacheSize > 20)
+//			{
+//				SoundBuffer *last = buffers.tail();
+//				bufferHash.remove(last->filename);
+//				buffers.remove(last->link);
+//				--cacheSize;
+
+//				qDebug() << "Deleted buffer" << last->filename;
+
+//				delete last;
+//			}
+
+//			return buffer->sdlBuffer;
+//		}
+//	}
+//};
+
+struct SoundBuffer
+{
+	sf::SoundBuffer sfBuffer;
+	QByteArray filename;
+	IntruListLink<SoundBuffer> link;
+
+	SoundBuffer()
+	    : link(this)
+	{}
+};
+
+struct SoundEntity
+{
+	IntruList<SoundBuffer> buffers;
+	QHash<QByteArray, SoundBuffer*> bufferHash;
+	unsigned int bufferSamples;
+
+	sf::Sound soundMag[SOUND_MAG_SIZE];
+	int magIndex;
+
+	SoundEntity()
+	    : bufferSamples(0),
+	      magIndex(0)
+	{}
+
+	~SoundEntity()
+	{
+		QHash<QByteArray, SoundBuffer*>::iterator iter;
+		for (iter = bufferHash.begin(); iter != bufferHash.end(); ++iter)
+			delete iter.value();
+	}
+
+	void play(const char *filename,
+	          int volume,
+	          int pitch)
+	{
+		(void) pitch;
+
+		volume = bound<int>(volume, 0, 100);
+
+		sf::SoundBuffer &buffer = allocateBuffer(filename);
+
+		int soundIndex = magIndex++;
+		if (magIndex > SOUND_MAG_SIZE-1)
+			magIndex = 0;
+
+		sf::Sound &sound = soundMag[soundIndex];
+		sound.stop();
+		sound.setBuffer(buffer);
+		sound.setVolume(volume);
+
+		sound.play();
+	}
+
+	void stop()
+	{
+		for (int i = 0; i < SOUND_MAG_SIZE; i++)
+			soundMag[i].stop();
+	}
+
+private:
+	sf::SoundBuffer &allocateBuffer(const char *filename)
+	{
+		SoundBuffer *buffer = bufferHash.value(filename, 0);
+
+		if (buffer)
+		{
+			/* Buffer still in cashe.
+			 * Move to front of priority list */
+
+			buffers.remove(buffer->link);
+			buffers.append(buffer->link);
+
+			return buffer->sfBuffer;
+		}
+		else
+		{
+			/* Buffer not in cashe, needs to be loaded */
+
+			FileStream data =
+				gState->fileSystem().openRead(filename, FileSystem::Audio);
+
+			buffer = new SoundBuffer;
+			buffer->sfBuffer.loadFromStream(data);
+			bufferSamples += buffer->sfBuffer.getSampleCount();
+
+			data.close();
+
+//			qDebug() << "SoundCache: Current memory consumption:" << bufferSamples/2;
+
+			buffer->filename = filename;
+
+			bufferHash.insert(filename, buffer);
+			buffers.prepend(buffer->link);
+
+			// FIXME this part would look better if it actually looped until enough memory is freed
+			/* If memory limit is reached, delete lowest priority buffer.
+			 * Samples are 2 bytes big */
+			if ((bufferSamples/2) > SOUND_MAX_MEM && !buffers.isEmpty())
+			{
+				SoundBuffer *last = buffers.tail();
+				bufferHash.remove(last->filename);
+				buffers.remove(last->link);
+				bufferSamples -= last->sfBuffer.getSampleCount();
+
+				qDebug() << "Deleted buffer" << last->filename;
+
+				delete last;
+			}
+
+			return buffer->sfBuffer;
+		}
+	}
+};
+
+struct AudioPrivate
+{
+	MusicEntity bgm;
+	MusicEntity bgs;
+	MusicEntity me;
+
+	SoundEntity se;
+
+	sf::Thread *meWatchThread;
+	bool meWatchRunning;
+	bool meWatchThreadTerm;
+
+	AudioPrivate()
+	    : meWatchThread(0),
+	      meWatchRunning(false),
+	      meWatchThreadTerm(false)
+	{
+		me.music.setLoop(false);
+	}
+
+	~AudioPrivate()
+	{
+		if (meWatchThread)
+		{
+			meWatchThreadTerm = true;
+			meWatchThread->wait();
+			delete meWatchThread;
+		}
+
+		bgm.stop();
+		bgs.stop();
+		me.stop();
+		se.stop();
+	}
+
+	void scheduleMeWatch()
+	{
+		if (meWatchRunning)
+			return;
+
+		meWatchRunning = true;
+
+		if (meWatchThread)
+			meWatchThread->wait();
+
+		bgm.extPaused = true;
+
+		delete meWatchThread;
+		meWatchThread = new sf::Thread(&AudioPrivate::meWatchFunc, this);
+		meWatchThread->launch();
+	}
+
+	void meWatchFunc()
+	{
+		// FIXME Need to catch the case where an ME is started while
+		// the BGM is still being faded in from this function
+		sf::Time sleepTime = sf::milliseconds(FADE_SLEEP);
+		const int bgmFadeOutSteps = 20;
+		const int bgmFadeInSteps = 100;
+
+		/* Fade out BGM */
+		for (int i = bgmFadeOutSteps; i > 0; --i)
+		{
+			if (meWatchThreadTerm)
+				return;
+
+			if (bgm.music.getStatus() != sf::Music::Playing)
+			{
+				bgm.extVolume = 0;
+				bgm.updateVolumeSync();
+				break;
+			}
+
+			bgm.extVolume = (1.0 / bgmFadeOutSteps) * (i-1);
+			bgm.updateVolumeSync();
+			sf::sleep(sleepTime);
+		}
+
+		SDL_LockMutex(bgm.mutex);
+		if (bgm.music.getStatus() == sf::Music::Playing)
+			bgm.music.pause();
+		SDL_UnlockMutex(bgm.mutex);
+
+		/* Linger while ME plays */
+		while (me.music.getStatus() == sf::Music::Playing)
+		{
+			if (meWatchThreadTerm)
+				return;
+
+			sf::sleep(sleepTime);
+		}
+
+		SDL_LockMutex(bgm.mutex);
+		bgm.extPaused = false;
+
+		if (bgm.music.getStatus() == sf::Music::Paused)
+			bgm.music.play();
+		SDL_UnlockMutex(bgm.mutex);
+
+		/* Fade in BGM again */
+		for (int i = 0; i < bgmFadeInSteps; ++i)
+		{
+			if (meWatchThreadTerm)
+				return;
+
+			SDL_LockMutex(bgm.mutex);
+
+			if (bgm.music.getStatus() != sf::Music::Playing || bgm.noFadeInFlag)
+			{
+				bgm.noFadeInFlag = false;
+				bgm.extVolume = 1;
+				bgm.updateVolume();
+				bgm.music.play();
+				SDL_UnlockMutex(bgm.mutex);
+				break;
+			}
+
+			bgm.extVolume = (1.0 / bgmFadeInSteps) * (i+1);
+			bgm.updateVolume();
+
+			SDL_UnlockMutex(bgm.mutex);
+
+			sf::sleep(sleepTime);
+		}
+
+		meWatchRunning = false;
+	}
+};
+
+Audio::Audio()
+	: p(new AudioPrivate)
+{
+}
+
+
+void Audio::bgmPlay(const char *filename,
+					int volume,
+                    int pitch)
+{
+	p->bgm.play(filename, volume, pitch);
+}
+
+void Audio::bgmStop()
+{
+	p->bgm.stop();
+}
+
+void Audio::bgmFade(int time)
+{
+	p->bgm.fade(time);
+}
+
+
+void Audio::bgsPlay(const char *filename,
+					int volume,
+                    int pitch)
+{
+	p->bgs.play(filename, volume, pitch);
+}
+
+void Audio::bgsStop()
+{
+	p->bgs.stop();
+}
+
+void Audio::bgsFade(int time)
+{
+	p->bgs.fade(time);
+}
+
+
+void Audio::mePlay(const char *filename,
+                   int volume,
+                   int pitch)
+{
+	p->me.play(filename, volume, pitch);
+	p->scheduleMeWatch();
+}
+
+void Audio::meStop()
+{
+	p->me.stop();
+}
+
+void Audio::meFade(int time)
+{
+	p->me.fade(time);
+}
+
+
+void Audio::sePlay(const char *filename,
+                   int volume,
+                   int pitch)
+{
+	p->se.play(filename, volume, pitch);
+}
+
+void Audio::seStop()
+{
+	p->se.stop();
+}
+
+Audio::~Audio() { delete p; }

src/audio.h

@@ -0,0 +1,52 @@
+/*
+** audio.h
+**
+** This file is part of mkxp.
+**
+** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
+**
+** mkxp is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** mkxp is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with mkxp.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef AUDIO_H
+#define AUDIO_H
+
+struct AudioPrivate;
+
+class Audio
+{
+public:
+	Audio();
+	~Audio();
+
+	void bgmPlay(const char *filename, int volume = 100, int pitch = 100);
+	void bgmStop();
+	void bgmFade(int time);
+
+	void bgsPlay(const char *filename, int volume = 100, int pitch = 100);
+	void bgsStop();
+	void bgsFade(int time);
+
+	void mePlay(const char *filename, int volume = 100, int pitch = 100);
+	void meStop();
+	void meFade(int time);
+
+	void sePlay(const char *filename, int volume = 100, int pitch = 100);
+	void seStop();
+
+private:
+	AudioPrivate *p;
+};
+
+#endif // AUDIO_H

src/autotiles.cpp

@@ -0,0 +1,199 @@
+struct StaticRect { float x, y, w, h; };
+
+extern const StaticRect autotileRects[] =
+{
+	{ 32.5, 64.5, 15, 15 },
+	{ 48.5, 64.5, 15, 15 },
+	{ 48.5, 80.5, 15, 15 },
+	{ 32.5, 80.5, 15, 15 },
+	{ 64.5, 0.5, 15, 15 },
+	{ 48.5, 64.5, 15, 15 },
+	{ 48.5, 80.5, 15, 15 },
+	{ 32.5, 80.5, 15, 15 },
+	{ 32.5, 64.5, 15, 15 },
+	{ 80.5, 0.5, 15, 15 },
+	{ 48.5, 80.5, 15, 15 },
+	{ 32.5, 80.5, 15, 15 },
+	{ 64.5, 0.5, 15, 15 },
+	{ 80.5, 0.5, 15, 15 },
+	{ 48.5, 80.5, 15, 15 },
+	{ 32.5, 80.5, 15, 15 },
+	{ 32.5, 64.5, 15, 15 },
+	{ 48.5, 64.5, 15, 15 },
+	{ 80.5, 16.5, 15, 15 },
+	{ 32.5, 80.5, 15, 15 },
+	{ 64.5, 0.5, 15, 15 },
+	{ 48.5, 64.5, 15, 15 },
+	{ 80.5, 16.5, 15, 15 },
+	{ 32.5, 80.5, 15, 15 },
+	{ 32.5, 64.5, 15, 15 },
+	{ 80.5, 0.5, 15, 15 },
+	{ 80.5, 16.5, 15, 15 },
+	{ 32.5,</