Initial commit

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());
+}