Implemented a bunch of core types. Image needs love

include/godot/core/CoreTypes.h

@@ -0,0 +1,23 @@
+#ifndef CORETYPES_H
+#define CORETYPES_H
+
+#include "Defs.h"
+
+#include "Basis.h"
+#include "Color.h"
+#include "Image.h"
+#include "InputEvent.h"
+#include "NodePath.h"
+#include "Plane.h"
+#include "Quat.h"
+#include "Rect2.h"
+#include "Rect3.h"
+#include "RID.h"
+#include "String.h"
+#include "Transform.h"
+#include "Transform2D.h"
+#include "Vector2.h"
+#include "Vector3.h"
+
+
+#endif // CORETYPES_H

include/godot/core/Defs.h

@@ -0,0 +1,72 @@
+#ifndef DEFS_H
+#define DEFS_H
+
+
+namespace godot {
+
+enum Error {
+	OK,
+	FAILED, ///< Generic fail error
+	ERR_UNAVAILABLE, ///< What is requested is unsupported/unavailable
+	ERR_UNCONFIGURED, ///< The object being used hasnt been properly set up yet
+	ERR_UNAUTHORIZED, ///< Missing credentials for requested resource
+	ERR_PARAMETER_RANGE_ERROR, ///< Parameter given out of range (5)
+	ERR_OUT_OF_MEMORY, ///< Out of memory
+	ERR_FILE_NOT_FOUND,
+	ERR_FILE_BAD_DRIVE,
+	ERR_FILE_BAD_PATH,
+	ERR_FILE_NO_PERMISSION,	// (10)
+	ERR_FILE_ALREADY_IN_USE,
+	ERR_FILE_CANT_OPEN,
+	ERR_FILE_CANT_WRITE,
+	ERR_FILE_CANT_READ,
+	ERR_FILE_UNRECOGNIZED, // (15)
+	ERR_FILE_CORRUPT,
+	ERR_FILE_MISSING_DEPENDENCIES,
+	ERR_FILE_EOF,
+	ERR_CANT_OPEN, ///< Can't open a resource/socket/file
+	ERR_CANT_CREATE,		// (20)
+	ERR_QUERY_FAILED,
+	ERR_ALREADY_IN_USE,
+	ERR_LOCKED, ///< resource is locked
+	ERR_TIMEOUT,
+	ERR_CANT_CONNECT,		// (25)
+	ERR_CANT_RESOLVE,
+	ERR_CONNECTION_ERROR,
+	ERR_CANT_AQUIRE_RESOURCE,
+	ERR_CANT_FORK,
+	ERR_INVALID_DATA, ///< Data passed is invalid	(30)
+	ERR_INVALID_PARAMETER, ///< Parameter passed is invalid
+	ERR_ALREADY_EXISTS, ///< When adding, item already exists
+	ERR_DOES_NOT_EXIST, ///< When retrieving/erasing, it item does not exist
+	ERR_DATABASE_CANT_READ, ///< database is full
+	ERR_DATABASE_CANT_WRITE, ///< database is full	(35)
+	ERR_COMPILATION_FAILED,
+	ERR_METHOD_NOT_FOUND,
+	ERR_LINK_FAILED,
+	ERR_SCRIPT_FAILED,
+	ERR_CYCLIC_LINK,		// (40)
+	ERR_INVALID_DECLARATION,
+	ERR_DUPLICATE_SYMBOL,
+	ERR_PARSE_ERROR,
+	ERR_BUSY,
+	ERR_SKIP,			// (45)
+	ERR_HELP, ///< user requested help!!
+	ERR_BUG, ///< a bug in the software certainly happened, due to a double check failing or unexpected behavior.
+	ERR_PRINTER_ON_FIRE, /// the parallel port printer is engulfed in flames
+	ERR_OMFG_THIS_IS_VERY_VERY_BAD, ///< shit happens, has never been used, though
+	ERR_WTF = ERR_OMFG_THIS_IS_VERY_VERY_BAD ///< short version of the above
+};
+
+}
+
+// @Todo error handling stuff here plz
+// @Todo as well as real_t
+
+
+#ifndef ERR_PRINT
+#define ERR_PRINT(msg)
+#endif
+
+
+#endif // DEFS_H

include/godot/core/Image.h

@@ -0,0 +1,194 @@
+#ifndef IMAGE_H
+#define IMAGE_H
+
+#include "Defs.h"
+
+#include "Vector2.h"
+#include "Rect2.h"
+#include "Color.h"
+#include "String.h"
+
+#include <godot/godot_image.h>
+
+namespace godot {
+
+class Image {
+	godot_image _godot_image;
+public:
+
+	enum Format {
+
+		FORMAT_L8, //luminance
+		FORMAT_LA8, //luminance-alpha
+		FORMAT_R8,
+		FORMAT_RG8,
+		FORMAT_RGB8,
+		FORMAT_RGBA8,
+		FORMAT_RGB565, //16 bit
+		FORMAT_RGBA4444,
+		FORMAT_RGBA5551,
+		FORMAT_RF, //float
+		FORMAT_RGF,
+		FORMAT_RGBF,
+		FORMAT_RGBAF,
+		FORMAT_RH, //half float
+		FORMAT_RGH,
+		FORMAT_RGBH,
+		FORMAT_RGBAH,
+		FORMAT_DXT1, //s3tc bc1
+		FORMAT_DXT3, //bc2
+		FORMAT_DXT5, //bc3
+		FORMAT_ATI1, //bc4
+		FORMAT_ATI2, //bc5
+		FORMAT_BPTC_RGBA, //btpc bc6h
+		FORMAT_BPTC_RGBF, //float /
+		FORMAT_BPTC_RGBFU, //unsigned float
+		FORMAT_PVRTC2, //pvrtc
+		FORMAT_PVRTC2A,
+		FORMAT_PVRTC4,
+		FORMAT_PVRTC4A,
+		FORMAT_ETC, //etc1
+		FORMAT_ETC2_R11, //etc2
+		FORMAT_ETC2_R11S, //signed, NOT srgb.
+		FORMAT_ETC2_RG11,
+		FORMAT_ETC2_RG11S,
+		FORMAT_ETC2_RGB8,
+		FORMAT_ETC2_RGBA8,
+		FORMAT_ETC2_RGB8A1,
+		FORMAT_MAX
+	};
+
+	enum Interpolation {
+
+		INTERPOLATE_NEAREST,
+		INTERPOLATE_BILINEAR,
+		INTERPOLATE_CUBIC,
+		/* INTERPOLATE GAUSS */
+	};
+
+	enum CompressMode {
+		COMPRESS_16BIT,
+		COMPRESS_S3TC,
+		COMPRESS_PVRTC2,
+		COMPRESS_PVRTC4,
+		COMPRESS_ETC,
+		COMPRESS_ETC2
+	};
+
+
+	Image()
+	{
+		godot_image_new(&_godot_image);
+	}
+
+	Image(const int width, const int height, const bool mipmaps, const Format format)
+	{
+		godot_image_new_with_size_format(&_godot_image, width, height, mipmaps, (godot_image_format) format);
+	}
+
+	void blit_rect(const Image& src, const Rect2& src_rect, const Vector2& dest = Vector2(0, 0))
+	{
+		// @DLScript @Todo
+	}
+
+	void brush_transfer(const Image& src, const Image& brush, const Vector2& pos = Vector2(0, 0))
+	{
+		// @DLScript @Todo
+	}
+
+	Image brushed(const Image& src, const Image& brush, const Vector2& pos = Vector2(0, 0))
+	{
+		return *this; // @DLScript @Todo
+	}
+
+	Image compressed(const Format format)
+	{
+		return *this; // @DLScript @Todo
+	}
+
+	Image converted(const Format format)
+	{
+		return *this; // @DLScript @Todo
+	}
+
+	Image decompressed()
+	{
+		return *this; // @DLScript @Todo
+	}
+
+	bool empty() const
+	{
+		return true; // @DLScript @Todo
+	}
+
+	void fix_alpha_edges()
+	{
+		// @DLScript @Todo
+	}
+
+	/*
+	PoolByteArray get_data()
+	{
+		// @Todo
+	}
+	*/
+
+	Format get_format() const
+	{
+		return Format::FORMAT_RGBAH; // @DLScript @Todo
+	}
+
+	int get_height() const
+	{
+		return godot_image_get_height(&_godot_image);
+	}
+
+	Color get_pixel(const int x, const int y, const int mipmap_level = 0)
+	{
+		return Color(); // @DLScript @Todo
+	}
+
+	Image get_rect(const Rect2& area = Rect2())
+	{
+		return *this; // @DLScript @Todo
+	}
+
+	Rect2 get_used_rect() const
+	{
+		return Rect2(); // @DLScript @Todo
+	}
+
+	int get_width() const
+	{
+		return godot_image_get_width(&_godot_image);
+	}
+
+	Error load(const String& path)
+	{
+		return (Error) godot_image_load(&_godot_image, (godot_string *) &path);
+	}
+
+	void put_pixel(const int x, const int y, const Color& color, int mipmap_level = 0)
+	{
+		// @DLScript @Todo
+	}
+
+	Image resized(const int x, const int y, const Interpolation interpolation = INTERPOLATE_NEAREST)
+	{
+		return *this; // @DLScript @Todo
+	}
+
+	Error save_png(const String& path)
+	{
+		return (Error) godot_image_save_png(&_godot_image, (godot_string *) &path); // @Todo Error enum
+	}
+
+	~Image()
+	{
+		godot_image_destroy(&_godot_image);
+	}
+};
+
+}
+
+#endif // IMAGE_H

include/godot/core/InputEvent.h

@@ -0,0 +1,535 @@
+#ifndef INPUTEVENT_H
+#define INPUTEVENT_H
+
+#include <cstdint>
+
+#include "String.h"
+
+namespace godot {
+
+
+enum {
+	BUTTON_LEFT=1,
+	BUTTON_RIGHT=2,
+	BUTTON_MIDDLE=3,
+	BUTTON_WHEEL_UP=4,
+	BUTTON_WHEEL_DOWN=5,
+	BUTTON_WHEEL_LEFT=6,
+	BUTTON_WHEEL_RIGHT=7,
+	BUTTON_MASK_LEFT=(1<<(BUTTON_LEFT-1)),
+	BUTTON_MASK_RIGHT=(1<<(BUTTON_RIGHT-1)),
+	BUTTON_MASK_MIDDLE=(1<<(BUTTON_MIDDLE-1)),
+
+};
+
+enum {
+
+	JOY_BUTTON_0 = 0,
+	JOY_BUTTON_1 = 1,
+	JOY_BUTTON_2 = 2,
+	JOY_BUTTON_3 = 3,
+	JOY_BUTTON_4 = 4,
+	JOY_BUTTON_5 = 5,
+	JOY_BUTTON_6 = 6,
+	JOY_BUTTON_7 = 7,
+	JOY_BUTTON_8 = 8,
+	JOY_BUTTON_9 = 9,
+	JOY_BUTTON_10 = 10,
+	JOY_BUTTON_11 = 11,
+	JOY_BUTTON_12 = 12,
+	JOY_BUTTON_13 = 13,
+	JOY_BUTTON_14 = 14,
+	JOY_BUTTON_15 = 15,
+	JOY_BUTTON_MAX = 16,
+
+	JOY_L = JOY_BUTTON_4,
+	JOY_R = JOY_BUTTON_5,
+	JOY_L2 = JOY_BUTTON_6,
+	JOY_R2 = JOY_BUTTON_7,
+	JOY_L3 = JOY_BUTTON_8,
+	JOY_R3 = JOY_BUTTON_9,
+	JOY_SELECT = JOY_BUTTON_10,
+	JOY_START = JOY_BUTTON_11,
+	JOY_DPAD_UP = JOY_BUTTON_12,
+	JOY_DPAD_DOWN = JOY_BUTTON_13,
+	JOY_DPAD_LEFT = JOY_BUTTON_14,
+	JOY_DPAD_RIGHT = JOY_BUTTON_15,
+
+	// a little history about game controllers (who copied who)
+
+	JOY_SNES_B = JOY_BUTTON_0,
+	JOY_SNES_A = JOY_BUTTON_1,
+	JOY_SNES_Y = JOY_BUTTON_2,
+	JOY_SNES_X = JOY_BUTTON_3,
+
+	JOY_SONY_CIRCLE=JOY_SNES_A,
+	JOY_SONY_X=JOY_SNES_B,
+	JOY_SONY_SQUARE=JOY_SNES_Y,
+	JOY_SONY_TRIANGLE=JOY_SNES_X,
+
+	JOY_SEGA_B=JOY_SNES_A,
+	JOY_SEGA_A=JOY_SNES_B,
+	JOY_SEGA_X=JOY_SNES_Y,
+	JOY_SEGA_Y=JOY_SNES_X,
+
+	JOY_XBOX_B=JOY_SEGA_B,
+	JOY_XBOX_A=JOY_SEGA_A,
+	JOY_XBOX_X=JOY_SEGA_X,
+	JOY_XBOX_Y=JOY_SEGA_Y,
+
+	JOY_DS_A = JOY_SNES_A,
+	JOY_DS_B = JOY_SNES_B,
+	JOY_DS_X = JOY_SNES_X,
+	JOY_DS_Y = JOY_SNES_Y,
+
+	JOY_WII_C = JOY_BUTTON_5,
+	JOY_WII_Z = JOY_BUTTON_6,
+
+	JOY_WII_MINUS = JOY_BUTTON_9,
+	JOY_WII_PLUS = JOY_BUTTON_10,
+
+	// end of history
+
+	JOY_AXIS_0=0,
+	JOY_AXIS_1=1,
+	JOY_AXIS_2=2,
+	JOY_AXIS_3=3,
+	JOY_AXIS_4=4,
+	JOY_AXIS_5=5,
+	JOY_AXIS_6=6,
+	JOY_AXIS_7=7,
+	JOY_AXIS_MAX=8,
+
+	JOY_ANALOG_0_X = JOY_AXIS_0,
+	JOY_ANALOG_0_Y = JOY_AXIS_1,
+
+	JOY_ANALOG_1_X = JOY_AXIS_2,
+	JOY_ANALOG_1_Y = JOY_AXIS_3,
+
+	JOY_ANALOG_2_X = JOY_AXIS_4,
+	JOY_ANALOG_2_Y = JOY_AXIS_5,
+
+	JOY_ANALOG_L2 = JOY_AXIS_6,
+	JOY_ANALOG_R2 = JOY_AXIS_7,
+};
+
+
+/**
+ * Input Modifier Status
+ * for keyboard/mouse events.
+ */
+struct InputModifierState {
+
+	bool shift;
+	bool alt;
+#ifdef APPLE_STYLE_KEYS
+	union {
+	bool command;
+	bool meta; //< windows/mac key
+	};
+
+	bool control;
+#else
+	union {
+	bool command; //< windows/mac key
+	bool control;
+	};
+	bool meta; //< windows/mac key
+
+#endif
+
+	bool operator==(const InputModifierState& rvalue) const {
+
+		return ( (shift==rvalue.shift) && (alt==rvalue.alt) && (control==rvalue.control) && (meta==rvalue.meta));
+	}
+};
+
+
+
+
+
+
+struct InputEventKey  {
+
+	InputModifierState mod;
+
+	bool pressed; /// otherwise release
+
+	uint32_t scancode; ///< check keyboard.h , KeyCode enum, without modifier masks
+	uint32_t unicode; ///unicode
+
+	bool echo; /// true if this is an echo key
+};
+
+
+struct InputEventMouse  {
+
+	InputModifierState mod;
+	int button_mask;
+	float x,y;
+	float global_x,global_y;
+	int pointer_index;
+};
+
+struct InputEventMouseButton : public InputEventMouse {
+
+
+	int button_index;
+	bool pressed; //otherwise released
+	bool doubleclick; //last even less than doubleclick time
+
+};
+
+struct InputEventMouseMotion : public InputEventMouse {
+
+	float relative_x,relative_y;
+	float speed_x,speed_y;
+};
+
+struct InputEventJoypadMotion  {
+
+	int axis; ///< Joypad axis
+	float axis_value; ///< -1 to 1
+};
+
+struct InputEventJoypadButton  {
+
+	int button_index;
+	bool pressed;
+	float pressure; //0 to 1
+};
+
+struct InputEventScreenTouch  {
+
+	int index;
+	float x,y;
+	bool pressed;
+};
+struct InputEventScreenDrag  {
+
+	int index;
+	float x,y;
+	float relative_x,relative_y;
+	float speed_x,speed_y;
+};
+
+struct InputEventAction  {
+
+	int action;
+	bool pressed;
+};
+
+
+
+struct InputEvent {
+
+	enum Type {
+		NONE,
+		KEY,
+		MOUSE_MOTION,
+		MOUSE_BUTTON,
+		JOYPAD_MOTION,
+		JOYPAD_BUTTON,
+		SCREEN_TOUCH,
+		SCREEN_DRAG,
+		ACTION,
+		TYPE_MAX
+	};
+
+	uint32_t ID;
+	int type;
+	int device;
+
+	union {
+		InputEventMouseMotion mouse_motion;
+		InputEventMouseButton mouse_button;
+		InputEventJoypadMotion joy_motion;
+		InputEventJoypadButton joy_button;
+		InputEventKey key;
+		InputEventScreenTouch screen_touch;
+		InputEventScreenDrag screen_drag;
+		InputEventAction action;
+	};
+
+	bool is_pressed() const;
+	bool is_action(const String& p_action) const;
+	bool is_action_pressed(const String& p_action) const;
+	bool is_action_released(const String& p_action) const;
+	bool is_echo() const;
+	void set_as_action(const String& p_action, bool p_pressed);
+
+
+	InputEvent xform_by(const Transform2D& p_xform) const;
+	bool operator==(const InputEvent &p_event) const;
+	operator String() const;
+	InputEvent() { memset(this,0,sizeof(InputEvent)); }
+};
+
+
+
+bool InputEvent::operator==(const InputEvent &p_event) const {
+	if (type != p_event.type){
+		return false;
+	}
+
+	switch(type) {
+		/** Current clang-format style doesn't play well with the aligned return values of that switch. */
+		/* clang-format off */
+		case NONE:
+			return true;
+		case KEY:
+			return key.unicode == p_event.key.unicode
+				&& key.scancode == p_event.key.scancode
+				&& key.echo == p_event.key.echo
+				&& key.pressed == p_event.key.pressed
+				&& key.mod == p_event.key.mod;
+		case MOUSE_MOTION:
+			return mouse_motion.x == p_event.mouse_motion.x
+				&& mouse_motion.y == p_event.mouse_motion.y
+				&& mouse_motion.relative_x == p_event.mouse_motion.relative_x
+				&& mouse_motion.relative_y == p_event.mouse_motion.relative_y
+				&& mouse_motion.button_mask == p_event.mouse_motion.button_mask
+				&& key.mod == p_event.key.mod;
+		case MOUSE_BUTTON:
+			return mouse_button.pressed == p_event.mouse_button.pressed
+				&& mouse_button.x == p_event.mouse_button.x
+				&& mouse_button.y == p_event.mouse_button.y
+				&& mouse_button.button_index == p_event.mouse_button.button_index
+				&& mouse_button.button_mask == p_event.mouse_button.button_mask
+				&& key.mod == p_event.key.mod;
+		case JOYPAD_MOTION:
+			return joy_motion.axis == p_event.joy_motion.axis
+				&& joy_motion.axis_value == p_event.joy_motion.axis_value;
+		case JOYPAD_BUTTON:
+			return joy_button.pressed == p_event.joy_button.pressed
+				&& joy_button.button_index == p_event.joy_button.button_index
+				&& joy_button.pressure == p_event.joy_button.pressure;
+		case SCREEN_TOUCH:
+			return screen_touch.pressed == p_event.screen_touch.pressed
+				&& screen_touch.index == p_event.screen_touch.index
+				&& screen_touch.x == p_event.screen_touch.x
+				&& screen_touch.y == p_event.screen_touch.y;
+		case SCREEN_DRAG:
+			return screen_drag.index == p_event.screen_drag.index
+				&& screen_drag.x == p_event.screen_drag.x
+				&& screen_drag.y == p_event.screen_drag.y;
+		case ACTION:
+			return action.action == p_event.action.action
+				&& action.pressed == p_event.action.pressed;
+		/* clang-format on */
+		default:
+			ERR_PRINT("No logic to compare InputEvents of this type, this shouldn't happen.");
+	}
+
+	return false;
+}
+InputEvent::operator String() const {
+	/*
+	String str ="Device "+itos(device)+" ID "+itos(ID)+" ";
+
+	switch(type) {
+
+		case NONE: {
+
+			return "Event: None";
+		} break;
+		case KEY: {
+
+			str+= "Event: Key ";
+			str=str+"Unicode: "+String::chr(key.unicode)+" Scan: "+itos( key.scancode )+" Echo: "+String(key.echo?"True":"False")+" Pressed"+String(key.pressed?"True":"False")+" Mod: ";
+			if (key.mod.shift)
+				str+="S";
+			if (key.mod.control)
+				str+="C";
+			if (key.mod.alt)
+				str+="A";
+			if (key.mod.meta)
+				str+="M";
+
+			return str;
+		} break;
+		case MOUSE_MOTION: {
+
+			str+= "Event: Motion ";
+			str=str+" Pos: " +itos(mouse_motion.x)+","+itos(mouse_motion.y)+" Rel: "+itos(mouse_motion.relative_x)+","+itos(mouse_motion.relative_y)+" Mask: ";
+			for (int i=0;i<8;i++) {
+
+				if ((1<<i)&mouse_motion.button_mask)
+					str+=itos(i+1);
+			}
+			str+=" Mod: ";
+			if (key.mod.shift)
+				str+="S";
+			if (key.mod.control)
+				str+="C";
+			if (key.mod.alt)
+				str+="A";
+			if (key.mod.meta)
+				str+="M";
+
+			return str;
+		} break;
+		case MOUSE_BUTTON: {
+			str+= "Event: Button ";
+			str=str+"Pressed: "+itos(mouse_button.pressed)+" Pos: " +itos(mouse_button.x)+","+itos(mouse_button.y)+" Button: "+itos(mouse_button.button_index)+" Mask: ";
+			for (int i=0;i<8;i++) {
+
+				if ((1<<i)&mouse_button.button_mask)
+					str+=itos(i+1);
+			}
+			str+=" Mod: ";
+			if (key.mod.shift)
+				str+="S";
+			if (key.mod.control)
+				str+="C";
+			if (key.mod.alt)
+				str+="A";
+			if (key.mod.meta)
+				str+="M";
+
+			str+=String(" DoubleClick: ")+(mouse_button.doubleclick?"Yes":"No");
+
+			return str;
+
+		} break;
+		case JOYPAD_MOTION: {
+			str+= "Event: JoypadMotion ";
+			str=str+"Axis: "+itos(joy_motion.axis)+" Value: " +rtos(joy_motion.axis_value);
+			return str;
+
+		} break;
+		case JOYPAD_BUTTON: {
+			str+= "Event: JoypadButton ";
+			str=str+"Pressed: "+itos(joy_button.pressed)+" Index: " +itos(joy_button.button_index)+" pressure "+rtos(joy_button.pressure);
+			return str;
+
+		} break;
+		case SCREEN_TOUCH: {
+			str+= "Event: ScreenTouch ";
+			str=str+"Pressed: "+itos(screen_touch.pressed)+" Index: " +itos(screen_touch.index)+" pos "+rtos(screen_touch.x)+","+rtos(screen_touch.y);
+			return str;
+
+		} break;
+		case SCREEN_DRAG: {
+			str+= "Event: ScreenDrag ";
+			str=str+" Index: " +itos(screen_drag.index)+" pos "+rtos(screen_drag.x)+","+rtos(screen_drag.y);
+			return str;
+
+		} break;
+		case ACTION: {
+			str+= "Event: Action: "+InputMap::get_singleton()->get_action_from_id(action.action)+" Pressed: "+itos(action.pressed);
+			return str;
+
+		} break;
+
+	}
+	*/
+
+	return "";
+}
+
+void InputEvent::set_as_action(const String& p_action, bool p_pressed) {
+
+	godot_input_event_set_as_action((godot_input_event *) this, (godot_string*) &p_action, p_pressed);
+}
+
+bool InputEvent::is_pressed() const {
+
+	switch(type) {
+
+		case KEY: return key.pressed;
+		case MOUSE_BUTTON: return mouse_button.pressed;
+		case JOYPAD_BUTTON: return joy_button.pressed;
+		case SCREEN_TOUCH: return screen_touch.pressed;
+		case JOYPAD_MOTION: return ::fabs(joy_motion.axis_value) > 0.5;
+		case ACTION: return action.pressed;
+		default: {}
+	}
+
+	return false;
+}
+
+bool InputEvent::is_echo() const {
+
+	return (type==KEY && key.echo);
+}
+
+bool InputEvent::is_action(const String& p_action) const {
+
+	return godot_input_event_is_action((godot_input_event *) this, (godot_string *) &p_action);
+}
+
+bool InputEvent::is_action_pressed(const String& p_action) const {
+
+	return is_action(p_action) && is_pressed() && !is_echo();
+}
+
+bool InputEvent::is_action_released(const String& p_action) const {
+
+	return is_action(p_action) && !is_pressed();
+}
+
+
+InputEvent InputEvent::xform_by(const Transform2D& p_xform) const {
+
+
+	InputEvent ev=*this;
+
+	switch(ev.type) {
+
+		case InputEvent::MOUSE_BUTTON: {
+
+			Vector2 g = p_xform.xform(Vector2(ev.mouse_button.global_x,ev.mouse_button.global_y));
+			Vector2 l = p_xform.xform(Vector2(ev.mouse_button.x,ev.mouse_button.y));
+			ev.mouse_button.x=l.x;
+			ev.mouse_button.y=l.y;
+			ev.mouse_button.global_x=g.x;
+			ev.mouse_button.global_y=g.y;
+
+		} break;
+		case InputEvent::MOUSE_MOTION: {
+
+			Vector2 g = p_xform.xform(Vector2(ev.mouse_motion.global_x,ev.mouse_motion.global_y));
+			Vector2 l = p_xform.xform(Vector2(ev.mouse_motion.x,ev.mouse_motion.y));
+			Vector2 r = p_xform.basis_xform(Vector2(ev.mouse_motion.relative_x,ev.mouse_motion.relative_y));
+			Vector2 s = p_xform.basis_xform(Vector2(ev.mouse_motion.speed_x,ev.mouse_motion.speed_y));
+			ev.mouse_motion.x=l.x;
+			ev.mouse_motion.y=l.y;
+			ev.mouse_motion.global_x=g.x;
+			ev.mouse_motion.global_y=g.y;
+			ev.mouse_motion.relative_x=r.x;
+			ev.mouse_motion.relative_y=r.y;
+			ev.mouse_motion.speed_x=s.x;
+			ev.mouse_motion.speed_y=s.y;
+
+		} break;
+		case InputEvent::SCREEN_TOUCH: {
+
+
+			Vector2 t = p_xform.xform(Vector2(ev.screen_touch.x,ev.screen_touch.y));
+			ev.screen_touch.x=t.x;
+			ev.screen_touch.y=t.y;
+
+		} break;
+		case InputEvent::SCREEN_DRAG: {
+
+
+			Vector2 t = p_xform.xform(Vector2(ev.screen_drag.x,ev.screen_drag.y));
+			Vector2 r = p_xform.basis_xform(Vector2(ev.screen_drag.relative_x,ev.screen_drag.relative_y));
+			Vector2 s = p_xform.basis_xform(Vector2(ev.screen_drag.speed_x,ev.screen_drag.speed_y));
+			ev.screen_drag.x=t.x;
+			ev.screen_drag.y=t.y;
+			ev.screen_drag.relative_x=r.x;
+			ev.screen_drag.relative_y=r.y;
+			ev.screen_drag.speed_x=s.x;
+			ev.screen_drag.speed_y=s.y;
+		} break;
+	}
+
+	return ev;
+}
+
+
+}
+
+#endif // INPUTEVENT_H

include/godot/core/Plane.h

@@ -0,0 +1,273 @@
+#ifndef PLANE_H
+#define PLANE_H
+
+#include "Vector3.h"
+
+#include <cmath>
+
+typedef float real_t; // @Todo move this to a global Godot.h
+
+#define CMP_EPSILON 0.00001
+
+namespace godot {
+
+
+
+#define _PLANE_EQ_DOT_EPSILON 0.999
+#define _PLANE_EQ_D_EPSILON 0.0001
+
+
+
+enum ClockDirection {
+
+	CLOCKWISE,
+	COUNTERCLOCKWISE
+};
+
+class Plane {
+public:
+	Vector3 normal;
+	real_t d;
+
+	void set_normal(const Vector3& p_normal)
+	{
+		this->normal = p_normal;
+	}
+
+	Vector3 get_normal() const { return normal; } ///Point is coplanar, CMP_EPSILON for precision
+
+	void normalize(); // down below
+
+	Plane normalized() const; // down below
+
+	/* Plane-Point operations */
+
+	Vector3 center() const { return normal*d; }
+	Vector3 get_any_point() const;
+	Vector3 get_any_perpendicular_normal() const;
+
+	bool is_point_over(const Vector3 &p_point) const; ///< Point is over plane
+	real_t distance_to(const Vector3 &p_point) const;
+	bool has_point(const Vector3 &p_point,real_t _epsilon=CMP_EPSILON) const;
+
+	/* intersections */
+
+	bool intersect_3(const Plane &p_plane1, const Plane &p_plane2, Vector3 *r_result=0) const;
+	bool intersects_ray(Vector3 p_from, Vector3 p_dir, Vector3* p_intersection)  const;
+	bool intersects_segment(Vector3 p_begin, Vector3 p_end, Vector3* p_intersection)  const;
+
+	Vector3 project(const Vector3& p_point) const {
+
+		return p_point - normal * distance_to(p_point);
+	}
+
+	/* misc */
+
+	Plane operator-() const { return Plane(-normal,-d); }
+	bool is_almost_like(const Plane& p_plane) const;
+
+	bool operator==(const Plane& p_plane) const;
+	bool operator!=(const Plane& p_plane) const;
+	operator String() const;
+
+	Plane() { d=0; }
+	Plane(real_t p_a, real_t p_b, real_t p_c, real_t p_d) : normal(p_a,p_b,p_c), d(p_d) { }
+
+	Plane(const Vector3 &p_normal, real_t p_d);
+	Plane(const Vector3 &p_point, const Vector3& p_normal);
+	Plane(const Vector3 &p_point1, const Vector3 &p_point2,const Vector3 &p_point3,ClockDirection p_dir = CLOCKWISE);
+
+};
+
+void Plane::normalize() {
+
+	real_t l = normal.length();
+	if (l==0) {
+		*this=Plane(0,0,0,0);
+		return;
+	}
+	normal/=l;
+	d/=l;
+}
+
+Plane Plane::normalized() const {
+
+	Plane p = *this;
+	p.normalize();
+	return p;
+}
+
+Vector3 Plane::get_any_point() const {
+
+	return get_normal()*d;
+}
+
+Vector3 Plane::get_any_perpendicular_normal() const {
+
+	static const Vector3 p1 = Vector3(1,0,0);
+	static const Vector3 p2 = Vector3(0,1,0);
+	Vector3 p;
+
+	if (::fabs(normal.dot(p1)) > 0.99) // if too similar to p1
+		p=p2; // use p2
+	else
+		p=p1; // use p1
+
+	p-=normal * normal.dot(p);
+	p.normalize();
+
+	return p;
+}
+
+
+/* intersections */
+
+bool Plane::intersect_3(const Plane &p_plane1, const Plane &p_plane2, Vector3 *r_result) const {
+
+	const Plane &p_plane0=*this;
+	Vector3 normal0=p_plane0.normal;
+	Vector3 normal1=p_plane1.normal;
+	Vector3 normal2=p_plane2.normal;
+
+	real_t denom=vec3_cross(normal0,normal1).dot(normal2);
+
+	if (::fabs(denom)<=CMP_EPSILON)
+		return false;
+
+	if (r_result) {
+		*r_result = 	( (vec3_cross(normal1, normal2) * p_plane0.d) +
+			(vec3_cross(normal2, normal0) * p_plane1.d) +
+			(vec3_cross(normal0, normal1) * p_plane2.d) )/denom;
+	}
+
+	return true;
+}
+
+
+bool Plane::intersects_ray(Vector3 p_from, Vector3 p_dir, Vector3* p_intersection)  const {
+
+	Vector3 segment=p_dir;
+	real_t den=normal.dot( segment );
+
+	//printf("den is %i\n",den);
+	if (::fabs(den)<=CMP_EPSILON) {
+
+		return false;
+	}
+
+	real_t dist=(normal.dot( p_from ) - d) / den;
+	//printf("dist is %i\n",dist);
+
+	if (dist>CMP_EPSILON) { //this is a ray, before the emiting pos (p_from) doesnt exist
+
+		return false;
+	}
+
+	dist=-dist;
+	*p_intersection = p_from + segment * dist;
+
+	return true;
+}
+
+bool Plane::intersects_segment(Vector3 p_begin, Vector3 p_end, Vector3* p_intersection)  const {
+
+	Vector3 segment= p_begin - p_end;
+	real_t den=normal.dot( segment );
+
+	//printf("den is %i\n",den);
+	if (::fabs(den)<=CMP_EPSILON) {
+
+		return false;
+	}
+
+	real_t dist=(normal.dot( p_begin ) - d) / den;
+	//printf("dist is %i\n",dist);
+
+	if (dist<-CMP_EPSILON || dist > (1.0 +CMP_EPSILON)) {
+
+		return false;
+	}
+
+	dist=-dist;
+	*p_intersection = p_begin + segment * dist;
+
+	return true;
+}
+
+/* misc */
+
+bool Plane::is_almost_like(const Plane& p_plane) const {
+
+	return (normal.dot( p_plane.normal ) > _PLANE_EQ_DOT_EPSILON && ::fabs(d-p_plane.d) < _PLANE_EQ_D_EPSILON);
+}
+
+
+Plane::operator String() const {
+
+	// return normal.operator String() + ", " + rtos(d);
+	return String(); // @Todo
+}
+
+
+
+bool Plane::is_point_over(const Vector3 &p_point) const {
+
+	return (normal.dot(p_point) > d);
+}
+
+real_t Plane::distance_to(const Vector3 &p_point) const {
+
+	return (normal.dot(p_point)-d);
+}
+
+bool Plane::has_point(const Vector3 &p_point,real_t _epsilon) const {
+
+	real_t dist=normal.dot(p_point) - d;
+	dist=::fabs(dist);
+	return ( dist <= _epsilon);
+
+}
+
+Plane::Plane(const Vector3 &p_normal, real_t p_d) {
+
+	normal=p_normal;
+	d=p_d;
+}
+
+Plane::Plane(const Vector3 &p_point, const Vector3& p_normal) {
+
+	normal=p_normal;
+	d=p_normal.dot(p_point);
+}
+
+Plane::Plane(const Vector3 &p_point1, const Vector3 &p_point2, const Vector3 &p_point3,ClockDirection p_dir) {
+
+	if (p_dir == CLOCKWISE)
+		normal=(p_point1-p_point3).cross(p_point1-p_point2);
+	else
+		normal=(p_point1-p_point2).cross(p_point1-p_point3);
+
+
+	normal.normalize();
+	d = normal.dot(p_point1);
+
+
+}
+
+bool Plane::operator==(const Plane& p_plane) const {
+
+	return normal==p_plane.normal && d == p_plane.d;
+}
+
+bool Plane::operator!=(const Plane& p_plane) const {
+
+	return normal!=p_plane.normal || d != p_plane.d;
+
+}
+
+
+
+
+}
+
+#endif // PLANE_H

include/godot/core/Rect2.h

@@ -0,0 +1,408 @@
+#ifndef RECT2_H
+#define RECT2_H
+
+#include "Vector2.h"
+
+#include <cmath>
+
+namespace godot {
+
+typedef Vector2 Size2;
+typedef Vector2 Point2;
+
+class Transform2D;
+
+#ifndef MAX
+#define MAX(a, b) (a > b ? a : b)
+#endif
+
+#ifndef MIN
+#define MIN(a, b) (a < b ? a : b)
+#endif
+
+struct Rect2 {
+
+	Point2 pos;
+	Size2 size;
+
+	const Vector2& get_pos() const { return pos; }
+	void set_pos(const Vector2& p_pos) { pos=p_pos; }
+	const Vector2& get_size() const { return size; }
+	void set_size(const Vector2& p_size) { size=p_size; }
+
+	real_t get_area() const { return size.width*size.height; }
+
+	inline bool intersects(const Rect2& p_rect) const {
+		if ( pos.x >= (p_rect.pos.x + p_rect.size.width) )
+			return false;
+		if ( (pos.x+size.width) <= p_rect.pos.x  )
+			return false;
+		if ( pos.y >= (p_rect.pos.y + p_rect.size.height) )
+			return false;
+		if ( (pos.y+size.height) <= p_rect.pos.y  )
+			return false;
+
+		return true;
+	}
+
+	inline real_t distance_to(const Vector2& p_point) const {
+
+		real_t dist = 1e20;
+
+		if (p_point.x < pos.x) {
+			dist=MIN(dist,pos.x-p_point.x);
+		}
+		if (p_point.y < pos.y) {
+			dist=MIN(dist,pos.y-p_point.y);
+		}
+		if (p_point.x >= (pos.x+size.x) ) {
+			dist=MIN(p_point.x-(pos.x+size.x),dist);
+		}
+		if (p_point.y >= (pos.y+size.y) ) {
+			dist=MIN(p_point.y-(pos.y+size.y),dist);
+		}
+
+		if (dist==1e20)
+			return 0;
+		else
+			return dist;
+	}
+
+	bool intersects_transformed(const Transform2D& p_xform, const Rect2& p_rect) const;
+
+	bool intersects_segment(const Point2& p_from, const Point2& p_to, Point2* r_pos=NULL, Point2* r_normal=NULL) const;
+
+	inline bool encloses(const Rect2& p_rect) const {
+
+		return 	(p_rect.pos.x>=pos.x) && (p_rect.pos.y>=pos.y) &&
+			((p_rect.pos.x+p_rect.size.x)<(pos.x+size.x)) &&
+			((p_rect.pos.y+p_rect.size.y)<(pos.y+size.y));
+
+	}
+
+	inline bool has_no_area() const {
+
+		return (size.x<=0 || size.y<=0);
+
+	}
+	inline Rect2 clip(const Rect2& p_rect) const { /// return a clipped rect
+
+		Rect2 new_rect=p_rect;
+
+		if (!intersects( new_rect ))
+			return Rect2();
+
+		new_rect.pos.x = MAX( p_rect.pos.x , pos.x );
+		new_rect.pos.y = MAX( p_rect.pos.y , pos.y );
+
+		Point2 p_rect_end=p_rect.pos+p_rect.size;
+		Point2 end=pos+size;
+
+		new_rect.size.x=MIN(p_rect_end.x,end.x) - new_rect.pos.x;
+		new_rect.size.y=MIN(p_rect_end.y,end.y) - new_rect.pos.y;
+
+		return new_rect;
+	}
+
+	inline Rect2 merge(const Rect2& p_rect) const { ///< return a merged rect
+
+		Rect2 new_rect;
+
+		new_rect.pos.x=MIN( p_rect.pos.x , pos.x );
+		new_rect.pos.y=MIN( p_rect.pos.y , pos.y );
+
+
+		new_rect.size.x = MAX( p_rect.pos.x+p_rect.size.x , pos.x+size.x );
+		new_rect.size.y = MAX( p_rect.pos.y+p_rect.size.y , pos.y+size.y );
+
+		new_rect.size = new_rect.size - new_rect.pos; //make relative again
+
+		return new_rect;
+	}
+	inline bool has_point(const Point2& p_point) const {
+		if (p_point.x < pos.x)
+			return false;
+		if (p_point.y < pos.y)
+			return false;
+
+		if (p_point.x >= (pos.x+size.x) )
+			return false;
+		if (p_point.y >= (pos.y+size.y) )
+			return false;
+
+		return true;
+	}
+
+	inline bool no_area() const { return (size.width<=0 || size.height<=0 ); }
+
+	bool operator==(const Rect2& p_rect) const { return pos==p_rect.pos && size==p_rect.size; }
+	bool operator!=(const Rect2& p_rect) const { return pos!=p_rect.pos || size!=p_rect.size; }
+
+	inline Rect2 grow(real_t p_by) const {
+
+		Rect2 g=*this;
+		g.pos.x-=p_by;
+		g.pos.y-=p_by;
+		g.size.width+=p_by*2;
+		g.size.height+=p_by*2;
+		return g;
+	}
+
+	inline Rect2 expand(const Vector2& p_vector) const {
+
+		Rect2 r = *this;
+		r.expand_to(p_vector);
+		return r;
+	}
+
+	inline void expand_to(const Vector2& p_vector) { //in place function for speed
+
+		Vector2 begin=pos;
+		Vector2 end=pos+size;
+
+		if (p_vector.x<begin.x)
+			begin.x=p_vector.x;
+		if (p_vector.y<begin.y)
+			begin.y=p_vector.y;
+
+		if (p_vector.x>end.x)
+			end.x=p_vector.x;
+		if (p_vector.y>end.y)
+			end.y=p_vector.y;
+
+		pos=begin;
+		size=end-begin;
+	}
+
+
+	operator String() const { return String(pos)+", "+String(size); }
+
+	Rect2() {}
+	Rect2( real_t p_x, real_t p_y, real_t p_width, real_t p_height) { pos=Point2(p_x,p_y); size=Size2( p_width, p_height ); }
+	Rect2( const Point2& p_pos, const Size2& p_size ) { pos=p_pos; size=p_size; }
+};
+
+
+bool Rect2::intersects_segment(const Point2& p_from, const Point2& p_to, Point2* r_pos,Point2* r_normal) const {
+
+	real_t min=0,max=1;
+	int axis=0;
+	real_t sign=0;
+
+	for(int i=0;i<2;i++) {
+		real_t seg_from=p_from[i];
+		real_t seg_to=p_to[i];
+		real_t box_begin=pos[i];
+		real_t box_end=box_begin+size[i];
+		real_t cmin,cmax;
+		real_t csign;
+
+		if (seg_from < seg_to) {
+
+			if (seg_from > box_end || seg_to < box_begin)
+				return false;
+			real_t length=seg_to-seg_from;
+			cmin = (seg_from < box_begin)?((box_begin - seg_from)/length):0;
+			cmax = (seg_to > box_end)?((box_end - seg_from)/length):1;
+			csign=-1.0;
+
+		} else {
+
+			if (seg_to > box_end || seg_from < box_begin)
+				return false;
+			real_t length=seg_to-seg_from;
+			cmin = (seg_from > box_end)?(box_end - seg_from)/length:0;
+			cmax = (seg_to < box_begin)?(box_begin - seg_from)/length:1;
+			csign=1.0;
+		}
+
+		if (cmin > min) {
+			min = cmin;
+			axis=i;
+			sign=csign;
+		}
+		if (cmax < max)
+			max = cmax;
+		if (max < min)
+			return false;
+	}
+
+
+	Vector2 rel=p_to-p_from;
+
+	if (r_normal) {
+		Vector2 normal;
+		normal[axis]=sign;
+		*r_normal=normal;
+	}
+
+	if (r_pos)
+		*r_pos=p_from+rel*min;
+
+	return true;
+}
+
+}
+
+#include "Transform2D.h"
+
+namespace godot {
+
+bool Rect2::intersects_transformed(const Transform2D& p_xform, const Rect2& p_rect) const {
+
+	//SAT intersection between local and transformed rect2
+
+	Vector2 xf_points[4]={
+		p_xform.xform(p_rect.pos),
+		p_xform.xform(Vector2(p_rect.pos.x+p_rect.size.x,p_rect.pos.y)),
+		p_xform.xform(Vector2(p_rect.pos.x,p_rect.pos.y+p_rect.size.y)),
+		p_xform.xform(Vector2(p_rect.pos.x+p_rect.size.x,p_rect.pos.y+p_rect.size.y)),
+	};
+
+	real_t low_limit;
+
+	//base rect2 first (faster)
+
+	if (xf_points[0].y>pos.y)
+		goto next1;
+	if (xf_points[1].y>pos.y)
+		goto next1;
+	if (xf_points[2].y>pos.y)
+		goto next1;
+	if (xf_points[3].y>pos.y)
+		goto next1;
+
+	return false;
+
+	next1:
+
+	low_limit=pos.y+size.y;
+
+	if (xf_points[0].y<low_limit)
+		goto next2;
+	if (xf_points[1].y<low_limit)
+		goto next2;
+	if (xf_points[2].y<low_limit)
+		goto next2;
+	if (xf_points[3].y<low_limit)
+		goto next2;
+
+	return false;
+
+	next2:
+
+	if (xf_points[0].x>pos.x)
+		goto next3;
+	if (xf_points[1].x>pos.x)
+		goto next3;
+	if (xf_points[2].x>pos.x)
+		goto next3;
+	if (xf_points[3].x>pos.x)
+		goto next3;
+
+	return false;
+
+	next3:
+
+	low_limit=pos.x+size.x;
+
+	if (xf_points[0].x<low_limit)
+		goto next4;
+	if (xf_points[1].x<low_limit)
+		goto next4;
+	if (xf_points[2].x<low_limit)
+		goto next4;
+	if (xf_points[3].x<low_limit)
+		goto next4;
+
+	return false;
+
+	next4:
+
+	Vector2 xf_points2[4]={
+		pos,
+		Vector2(pos.x+size.x,pos.y),
+		Vector2(pos.x,pos.y+size.y),
+		Vector2(pos.x+size.x,pos.y+size.y),
+	};
+
+	real_t maxa=p_xform.elements[0].dot(xf_points2[0]);
+	real_t mina=maxa;
+
+	real_t dp = p_xform.elements[0].dot(xf_points2[1]);
+	maxa=MAX(dp,maxa);
+	mina=MIN(dp,mina);
+
+	dp = p_xform.elements[0].dot(xf_points2[2]);
+	maxa=MAX(dp,maxa);
+	mina=MIN(dp,mina);
+
+	dp = p_xform.elements[0].dot(xf_points2[3]);
+	maxa=MAX(dp,maxa);
+	mina=MIN(dp,mina);
+
+	real_t maxb=p_xform.elements[0].dot(xf_points[0]);
+	real_t minb=maxb;
+
+	dp = p_xform.elements[0].dot(xf_points[1]);
+	maxb=MAX(dp,maxb);
+	minb=MIN(dp,minb);
+
+	dp = p_xform.elements[0].dot(xf_points[2]);
+	maxb=MAX(dp,maxb);
+	minb=MIN(dp,minb);
+
+	dp = p_xform.elements[0].dot(xf_points[3]);
+	maxb=MAX(dp,maxb);
+	minb=MIN(dp,minb);
+
+
+	if ( mina > maxb )
+		return false;
+	if ( minb > maxa  )
+		return false;
+
+	maxa=p_xform.elements[1].dot(xf_points2[0]);
+	mina=maxa;
+
+	dp = p_xform.elements[1].dot(xf_points2[1]);
+	maxa=MAX(dp,maxa);
+	mina=MIN(dp,mina);
+
+	dp = p_xform.elements[1].dot(xf_points2[2]);
+	maxa=MAX(dp,maxa);
+	mina=MIN(dp,mina);
+
+	dp = p_xform.elements[1].dot(xf_points2[3]);
+	maxa=MAX(dp,maxa);
+	mina=MIN(dp,mina);
+
+	maxb=p_xform.elements[1].dot(xf_points[0]);
+	minb=maxb;
+
+	dp = p_xform.elements[1].dot(xf_points[1]);
+	maxb=MAX(dp,maxb);
+	minb=MIN(dp,minb);
+
+	dp = p_xform.elements[1].dot(xf_points[2]);
+	maxb=MAX(dp,maxb);
+	minb=MIN(dp,minb);
+
+	dp = p_xform.elements[1].dot(xf_points[3]);
+	maxb=MAX(dp,maxb);
+	minb=MIN(dp,minb);
+
+
+	if ( mina > maxb )
+		return false;
+	if ( minb > maxa  )
+		return false;
+
+
+	return true;
+
+}
+
+}
+
+#endif // RECT2_H

include/godot/core/Rect3.h

@@ -0,0 +1,727 @@
+#ifndef RECT3_H
+#define RECT3_H
+
+#include "Vector3.h"
+
+#include "Plane.h"
+
+namespace godot {
+
+// @Todo
+// error handling...
+
+#ifndef ERR_FAIL_V
+#define ERR_FAIL_V(a) return a
+#endif
+
+#ifndef ERR_FAIL_INDEX
+#define ERR_FAIL_INDEX(a, b)
+#endif
+
+class Rect3 {
+public:
+	Vector3 pos;
+	Vector3 size;
+
+	real_t get_area() const; /// get area
+	bool has_no_area() const {
+
+		return (size.x<=CMP_EPSILON || size.y<=CMP_EPSILON  || size.z<=CMP_EPSILON);
+	}
+
+	bool has_no_surface() const {
+
+		return (size.x<=CMP_EPSILON && size.y<=CMP_EPSILON  && size.z<=CMP_EPSILON);
+	}
+
+	const Vector3& get_pos() const { return pos; }
+	void set_pos(const Vector3& p_pos) { pos=p_pos; }
+	const Vector3& get_size() const { return size; }
+	void set_size(const Vector3& p_size) { size=p_size; }
+
+
+	bool operator==(const Rect3& p_rval) const;
+	bool operator!=(const Rect3& p_rval) const;
+
+	bool intersects(const Rect3& p_aabb) const; /// Both AABBs overlap
+	bool intersects_inclusive(const Rect3& p_aabb) const; /// Both AABBs (or their faces) overlap
+	bool encloses(const Rect3 & p_aabb) const; /// p_aabb is completely inside this
+
+	Rect3 merge(const Rect3& p_with) const;
+	void merge_with(const Rect3& p_aabb); ///merge with another AABB
+	Rect3 intersection(const Rect3& p_aabb) const; ///get box where two intersect, empty if no intersection occurs
+	bool intersects_segment(const Vector3& p_from, const Vector3& p_to,Vector3* r_clip=NULL,Vector3* r_normal=NULL) const;
+	bool intersects_ray(const Vector3& p_from, const Vector3& p_dir,Vector3* r_clip=NULL,Vector3* r_normal=NULL) const;
+	bool smits_intersect_ray(const Vector3 &from,const Vector3& p_dir, real_t t0, real_t t1) const;
+
+	bool intersects_convex_shape(const Plane *p_plane, int p_plane_count) const;
+	bool intersects_plane(const Plane &p_plane) const;
+
+	bool has_point(const Vector3& p_point) const;
+	Vector3 get_support(const Vector3& p_normal) const;
+
+
+	Vector3 get_longest_axis() const;
+	int get_longest_axis_index() const;
+	real_t get_longest_axis_size() const;
+
+	Vector3 get_shortest_axis() const;
+	int get_shortest_axis_index() const;
+	real_t get_shortest_axis_size() const;
+
+	Rect3 grow(real_t p_by) const;
+	void grow_by(real_t p_amount);
+
+	void get_edge(int p_edge,Vector3& r_from,Vector3& r_to) const;
+	Vector3 get_endpoint(int p_point) const;
+
+	Rect3 expand(const Vector3& p_vector) const;
+	void project_range_in_plane(const Plane& p_plane,real_t &r_min,real_t& r_max) const;
+	void expand_to(const Vector3& p_vector); /** expand to contain a point if necesary */
+
+	operator String() const;
+
+	Rect3() {}
+	inline Rect3(const Vector3 &p_pos,const Vector3& p_size) { pos=p_pos; size=p_size; }
+
+
+};
+
+inline bool Rect3::intersects(const Rect3& p_aabb) const {
+
+	if ( pos.x >= (p_aabb.pos.x + p_aabb.size.x) )
+		return false;
+	if ( (pos.x+size.x) <= p_aabb.pos.x  )
+		return false;
+	if ( pos.y >= (p_aabb.pos.y + p_aabb.size.y) )
+		return false;
+	if ( (pos.y+size.y) <= p_aabb.pos.y  )
+		return false;
+	if ( pos.z >= (p_aabb.pos.z + p_aabb.size.z) )
+		return false;
+	if ( (pos.z+size.z) <= p_aabb.pos.z  )
+		return false;
+
+	return true;
+}
+
+inline bool Rect3::intersects_inclusive(const Rect3& p_aabb) const {
+
+	if ( pos.x > (p_aabb.pos.x + p_aabb.size.x) )
+		return false;
+	if ( (pos.x+size.x) < p_aabb.pos.x  )
+		return false;
+	if ( pos.y > (p_aabb.pos.y + p_aabb.size.y) )
+		return false;
+	if ( (pos.y+size.y) < p_aabb.pos.y  )
+		return false;
+	if ( pos.z > (p_aabb.pos.z + p_aabb.size.z) )
+		return false;
+	if ( (pos.z+size.z) < p_aabb.pos.z  )
+		return false;
+
+	return true;
+}
+
+inline bool Rect3::encloses(const Rect3 & p_aabb) const {
+
+	Vector3 src_min=pos;
+	Vector3 src_max=pos+size;
+	Vector3 dst_min=p_aabb.pos;
+	Vector3 dst_max=p_aabb.pos+p_aabb.size;
+
+	return  (
+		 (src_min.x <= dst_min.x) &&
+			(src_max.x > dst_max.x) &&
+			(src_min.y <= dst_min.y) &&
+			(src_max.y > dst_max.y) &&
+			(src_min.z <= dst_min.z) &&
+			(src_max.z > dst_max.z) );
+
+}
+
+Vector3 Rect3::get_support(const Vector3& p_normal) const {
+
+	Vector3 half_extents = size * 0.5;
+	Vector3 ofs = pos + half_extents;
+
+	return Vector3(
+			(p_normal.x>0) ? -half_extents.x : half_extents.x,
+			(p_normal.y>0) ? -half_extents.y : half_extents.y,
+			(p_normal.z>0) ? -half_extents.z : half_extents.z
+		)+ofs;
+}
+
+
+Vector3 Rect3::get_endpoint(int p_point) const {
+
+	switch(p_point) {
+		case 0: return Vector3( pos.x	, pos.y		, pos.z		);
+		case 1: return Vector3( pos.x	, pos.y		, pos.z+size.z	);
+		case 2: return Vector3( pos.x	, pos.y+size.y	, pos.z		);
+		case 3: return Vector3( pos.x	, pos.y+size.y	, pos.z+size.z	);
+		case 4: return Vector3( pos.x+size.x	, pos.y		, pos.z		);
+		case 5: return Vector3( pos.x+size.x	, pos.y		, pos.z+size.z	);
+		case 6: return Vector3( pos.x+size.x	, pos.y+size.y	, pos.z		);
+		case 7: return Vector3( pos.x+size.x	, pos.y+size.y	, pos.z+size.z	);
+	};
+
+	ERR_FAIL_V(Vector3());
+}
+
+bool Rect3::intersects_convex_shape(const Plane *p_planes, int p_plane_count) const {
+
+	Vector3 half_extents = size * 0.5;
+	Vector3 ofs = pos + half_extents;
+
+	for(int i=0;i<p_plane_count;i++) {
+		const Plane &p=p_planes[i];
+		Vector3 point(
+				(p.normal.x>0) ? -half_extents.x : half_extents.x,
+				(p.normal.y>0) ? -half_extents.y : half_extents.y,
+				(p.normal.z>0) ? -half_extents.z : half_extents.z
+			);
+		point+=ofs;
+		if (p.is_point_over(point))
+			return false;
+	}
+
+	return true;
+}
+
+bool Rect3::has_point(const Vector3& p_point) const {
+
+	if (p_point.x<pos.x)
+		return false;
+	if (p_point.y<pos.y)
+		return false;
+	if (p_point.z<pos.z)
+		return false;
+	if (p_point.x>pos.x+size.x)
+		return false;
+	if (p_point.y>pos.y+size.y)
+		return false;
+	if (p_point.z>pos.z+size.z)
+		return false;
+
+	return true;
+}
+
+
+inline void Rect3::expand_to(const Vector3& p_vector) {
+
+	Vector3 begin=pos;
+	Vector3 end=pos+size;
+
+	if (p_vector.x<begin.x)
+		begin.x=p_vector.x;
+	if (p_vector.y<begin.y)
+		begin.y=p_vector.y;
+	if (p_vector.z<begin.z)
+		begin.z=p_vector.z;
+
+	if (p_vector.x>end.x)
+		end.x=p_vector.x;
+	if (p_vector.y>end.y)
+		end.y=p_vector.y;
+	if (p_vector.z>end.z)
+		end.z=p_vector.z;
+
+	pos=begin;
+	size=end-begin;
+}
+
+void Rect3::project_range_in_plane(const Plane& p_plane,real_t &r_min,real_t& r_max) const {
+
+	Vector3 half_extents( size.x * 0.5, size.y * 0.5, size.z * 0.5 );
+	Vector3 center( pos.x + half_extents.x, pos.y + half_extents.y, pos.z + half_extents.z );
+
+	real_t length = p_plane.normal.abs().dot(half_extents);
+	real_t distance = p_plane.distance_to( center );
+	r_min = distance - length;
+	r_max = distance + length;
+}
+
+inline real_t Rect3::get_longest_axis_size() const {
+
+	real_t max_size=size.x;
+
+	if (size.y > max_size ) {
+		max_size=size.y;
+	}
+
+	if (size.z > max_size ) {
+		max_size=size.z;
+	}
+
+	return max_size;
+}
+
+inline real_t Rect3::get_shortest_axis_size() const {
+
+	real_t max_size=size.x;
+
+	if (size.y < max_size ) {
+		max_size=size.y;
+	}
+
+	if (size.z < max_size ) {
+		max_size=size.z;
+	}
+
+	return max_size;
+}
+
+bool Rect3::smits_intersect_ray(const Vector3 &from,const Vector3& dir, real_t t0, real_t t1) const {
+
+	real_t divx=1.0/dir.x;
+	real_t divy=1.0/dir.y;
+	real_t divz=1.0/dir.z;
+
+	Vector3 upbound=pos+size;
+	real_t tmin, tmax, tymin, tymax, tzmin, tzmax;
+	if (dir.x >= 0) {
+		tmin = (pos.x - from.x) * divx;
+		tmax = (upbound.x - from.x) * divx;
+	}
+	else {
+		tmin = (upbound.x - from.x) * divx;
+		tmax = (pos.x - from.x) * divx;
+	}
+	if (dir.y >= 0) {
+		tymin = (pos.y - from.y) * divy;
+		tymax = (upbound.y - from.y) * divy;
+	}
+	else {
+		tymin = (upbound.y - from.y) * divy;
+		tymax = (pos.y - from.y) * divy;
+	}
+	if ( (tmin > tymax) || (tymin > tmax) )
+		return false;
+	if (tymin > tmin)
+			tmin = tymin;
+	if (tymax < tmax)
+		tmax = tymax;
+	if (dir.z >= 0) {
+		tzmin = (pos.z - from.z) * divz;
+		tzmax = (upbound.z - from.z) * divz;
+	}
+	else {
+		tzmin = (upbound.z - from.z) * divz;
+		tzmax = (pos.z - from.z) * divz;
+	}
+	if ( (tmin > tzmax) || (tzmin > tmax) )
+		return false;
+	if (tzmin > tmin)
+		tmin = tzmin;
+	if (tzmax < tmax)
+		tmax = tzmax;
+	return ( (tmin < t1) && (tmax > t0) );
+}
+
+void Rect3::grow_by(real_t p_amount) {
+
+	pos.x-=p_amount;
+	pos.y-=p_amount;
+	pos.z-=p_amount;
+	size.x+=2.0*p_amount;
+	size.y+=2.0*p_amount;
+	size.z+=2.0*p_amount;
+}
+
+}
+
+namespace godot {
+
+
+real_t Rect3::get_area() const {
+
+	return size.x*size.y*size.z;
+
+}
+
+bool Rect3::operator==(const Rect3& p_rval) const {
+
+	return ((pos==p_rval.pos) && (size==p_rval.size));
+
+}
+bool Rect3::operator!=(const Rect3& p_rval) const {
+
+	return ((pos!=p_rval.pos) || (size!=p_rval.size));
+
+}
+
+void Rect3::merge_with(const Rect3& p_aabb) {
+
+	Vector3 beg_1,beg_2;
+	Vector3 end_1,end_2;
+	Vector3 min,max;
+
+	beg_1=pos;
+	beg_2=p_aabb.pos;
+	end_1=Vector3(size.x,size.y,size.z)+beg_1;
+	end_2=Vector3(p_aabb.size.x,p_aabb.size.y,p_aabb.size.z)+beg_2;
+
+	min.x=(beg_1.x<beg_2.x)?beg_1.x:beg_2.x;
+	min.y=(beg_1.y<beg_2.y)?beg_1.y:beg_2.y;
+	min.z=(beg_1.z<beg_2.z)?beg_1.z:beg_2.z;
+
+	max.x=(end_1.x>end_2.x)?end_1.x:end_2.x;
+	max.y=(end_1.y>end_2.y)?end_1.y:end_2.y;
+	max.z=(end_1.z>end_2.z)?end_1.z:end_2.z;
+
+	pos=min;
+	size=max-min;
+}
+
+Rect3 Rect3::intersection(const Rect3& p_aabb) const {
+
+	Vector3 src_min=pos;
+	Vector3 src_max=pos+size;
+	Vector3 dst_min=p_aabb.pos;
+	Vector3 dst_max=p_aabb.pos+p_aabb.size;
+
+	Vector3 min,max;
+
+	if (src_min.x > dst_max.x || src_max.x < dst_min.x )
+		return Rect3();
+	else {
+
+		min.x= ( src_min.x > dst_min.x ) ? src_min.x :dst_min.x;
+		max.x= ( src_max.x < dst_max.x ) ? src_max.x :dst_max.x;
+
+	}
+
+	if (src_min.y > dst_max.y || src_max.y < dst_min.y )
+		return Rect3();
+	else {
+
+		min.y= ( src_min.y > dst_min.y ) ? src_min.y :dst_min.y;
+		max.y= ( src_max.y < dst_max.y ) ? src_max.y :dst_max.y;
+
+	}
+
+	if (src_min.z > dst_max.z || src_max.z < dst_min.z )
+		return Rect3();
+	else {
+
+		min.z= ( src_min.z > dst_min.z ) ? src_min.z :dst_min.z;
+		max.z= ( src_max.z < dst_max.z ) ? src_max.z :dst_max.z;
+
+	}
+
+
+	return Rect3( min, max-min );
+}
+
+bool Rect3::intersects_ray(const Vector3& p_from, const Vector3& p_dir,Vector3* r_clip,Vector3* r_normal) const {
+
+	Vector3 c1, c2;
+	Vector3 end = pos+size;
+	real_t near=-1e20;
+	real_t far=1e20;
+	int axis=0;
+
+	for (int i=0;i<3;i++){
+		if (p_dir[i] == 0){
+			if ((p_from[i] < pos[i]) || (p_from[i] > end[i])) {
+				return false;
+			}
+		} else { // ray not parallel to planes in this direction
+			c1[i] = (pos[i] - p_from[i]) / p_dir[i];
+			c2[i] = (end[i] - p_from[i]) / p_dir[i];
+
+			if(c1[i] > c2[i]){
+				std::swap(c1,c2);
+			}
+			if (c1[i] > near){
+				near = c1[i];
+				axis=i;
+			}
+			if (c2[i] < far){
+				far = c2[i];
+			}
+			if( (near > far) || (far < 0) ){
+				return false;
+			}
+		}
+	}
+
+	if (r_clip)
+		*r_clip=c1;
+	if (r_normal) {
+		*r_normal=Vector3();
+		(*r_normal)[axis]=p_dir[axis]?-1:1;
+	}
+
+	return true;
+
+}
+
+
+bool Rect3::intersects_segment(const Vector3& p_from, const Vector3& p_to,Vector3* r_clip,Vector3* r_normal) const {
+
+	real_t min=0,max=1;
+	int axis=0;
+	real_t sign=0;
+
+	for(int i=0;i<3;i++) {
+		real_t seg_from=p_from[i];
+		real_t seg_to=p_to[i];
+		real_t box_begin=pos[i];
+		real_t box_end=box_begin+size[i];
+		real_t cmin,cmax;
+		real_t csign;
+
+		if (seg_from < seg_to) {
+
+			if (seg_from > box_end || seg_to < box_begin)
+				return false;
+			real_t length=seg_to-seg_from;
+			cmin = (seg_from < box_begin)?((box_begin - seg_from)/length):0;
+			cmax = (seg_to > box_end)?((box_end - seg_from)/length):1;
+			csign=-1.0;
+
+		} else {
+
+			if (seg_to > box_end || seg_from < box_begin)
+				return false;
+			real_t length=seg_to-seg_from;
+			cmin = (seg_from > box_end)?(box_end - seg_from)/length:0;
+			cmax = (seg_to < box_begin)?(box_begin - seg_from)/length:1;
+			csign=1.0;
+		}
+
+		if (cmin > min) {
+			min = cmin;
+			axis=i;
+			sign=csign;
+		}
+		if (cmax < max)
+			max = cmax;
+		if (max < min)
+			return false;
+	}
+
+
+	Vector3 rel=p_to-p_from;
+
+	if (r_normal) {
+		Vector3 normal;
+		normal[axis]=sign;
+		*r_normal=normal;
+	}
+
+	if (r_clip)
+		*r_clip=p_from+rel*min;
+
+	return true;
+
+}
+
+
+bool Rect3::intersects_plane(const Plane &p_plane) const {
+
+	Vector3 points[8] = {
+		Vector3( pos.x	, pos.y		, pos.z		),
+		Vector3( pos.x	, pos.y		, pos.z+size.z	),
+		Vector3( pos.x	, pos.y+size.y	, pos.z		),
+		Vector3( pos.x	, pos.y+size.y	, pos.z+size.z	),
+		Vector3( pos.x+size.x	, pos.y		, pos.z		),
+		Vector3( pos.x+size.x	, pos.y		, pos.z+size.z	),
+		Vector3( pos.x+size.x	, pos.y+size.y	, pos.z		),
+		Vector3( pos.x+size.x	, pos.y+size.y	, pos.z+size.z	),
+	};
+
+	bool over=false;
+	bool under=false;
+
+	for (int i=0;i<8;i++) {
+
+		if (p_plane.distance_to(points[i])>0)
+			over=true;
+		else
+			under=true;
+
+	}
+
+	return under && over;
+}
+
+
+
+Vector3 Rect3::get_longest_axis() const {
+
+	Vector3 axis(1,0,0);
+	real_t max_size=size.x;
+
+	if (size.y > max_size ) {
+		axis=Vector3(0,1,0);
+		max_size=size.y;
+	}
+
+	if (size.z > max_size ) {
+		axis=Vector3(0,0,1);
+		max_size=size.z;
+	}
+
+	return axis;
+}
+int Rect3::get_longest_axis_index() const {
+
+	int axis=0;
+	real_t max_size=size.x;
+
+	if (size.y > max_size ) {
+		axis=1;
+		max_size=size.y;
+	}
+
+	if (size.z > max_size ) {
+		axis=2;
+		max_size=size.z;
+	}
+
+	return axis;
+}
+
+
+Vector3 Rect3::get_shortest_axis() const {
+
+	Vector3 axis(1,0,0);
+	real_t max_size=size.x;
+
+	if (size.y < max_size ) {
+		axis=Vector3(0,1,0);
+		max_size=size.y;
+	}
+
+	if (size.z < max_size ) {
+		axis=Vector3(0,0,1);
+		max_size=size.z;
+	}
+
+	return axis;
+}
+int Rect3::get_shortest_axis_index() const {
+
+	int axis=0;
+	real_t max_size=size.x;
+
+	if (size.y < max_size ) {
+		axis=1;
+		max_size=size.y;
+	}
+
+	if (size.z < max_size ) {
+		axis=2;
+		max_size=size.z;
+	}
+
+	return axis;
+}
+
+Rect3 Rect3::merge(const Rect3& p_with) const {
+
+	Rect3 aabb=*this;
+	aabb.merge_with(p_with);
+	return aabb;
+}
+Rect3 Rect3::expand(const Vector3& p_vector) const {
+	Rect3 aabb=*this;
+	aabb.expand_to(p_vector);
+	return aabb;
+
+}
+Rect3 Rect3::grow(real_t p_by) const {
+
+	Rect3 aabb=*this;
+	aabb.grow_by(p_by);
+	return aabb;
+}
+
+void Rect3::get_edge(int p_edge,Vector3& r_from,Vector3& r_to) const {
+
+	ERR_FAIL_INDEX(p_edge,12);
+	switch(p_edge) {
+
+		case 0:{
+
+			r_from=Vector3( pos.x+size.x	, pos.y		, pos.z		);
+			r_to=Vector3( pos.x	, pos.y		, pos.z		);
+		} break;
+		case 1:{
+
+			r_from=Vector3( pos.x+size.x	, pos.y		, pos.z+size.z	);
+			r_to=Vector3( pos.x+size.x	, pos.y		, pos.z		);
+		} break;
+		case 2:{
+			r_from=Vector3( pos.x	, pos.y		, pos.z+size.z	);
+			r_to=Vector3( pos.x+size.x	, pos.y		, pos.z+size.z	);
+
+		} break;
+		case 3:{
+
+			r_from=Vector3( pos.x	, pos.y		, pos.z		);
+			r_to=Vector3( pos.x	, pos.y		, pos.z+size.z	);
+
+		} break;
+		case 4:{
+
+			r_from=Vector3( pos.x	, pos.y+size.y		, pos.z		);
+			r_to=Vector3( pos.x+size.x	, pos.y+size.y		, pos.z		);
+		} break;
+		case 5:{
+
+			r_from=Vector3( pos.x+size.x	, pos.y+size.y		, pos.z		);
+			r_to=Vector3( pos.x+size.x	, pos.y+size.y		, pos.z+size.z	);
+		} break;
+		case 6:{
+			r_from=Vector3( pos.x+size.x	, pos.y+size.y		, pos.z+size.z	);
+			r_to=Vector3( pos.x	, pos.y+size.y		, pos.z+size.z	);
+
+		} break;
+		case 7:{
+
+			r_from=Vector3( pos.x	, pos.y+size.y		, pos.z+size.z	);
+			r_to=Vector3( pos.x	, pos.y+size.y		, pos.z		);
+
+		} break;
+		case 8:{
+
+			r_from=Vector3( pos.x	, pos.y		, pos.z+size.z	);
+			r_to=Vector3( pos.x	, pos.y+size.y		, pos.z+size.z	);
+
+		} break;
+		case 9:{
+
+			r_from=Vector3( pos.x	, pos.y		, pos.z		);
+			r_to=Vector3( pos.x	, pos.y+size.y	, pos.z		);
+
+		} break;
+		case 10:{
+
+			r_from=Vector3( pos.x+size.x	, pos.y		, pos.z		);
+			r_to=Vector3( pos.x+size.x	, pos.y+size.y	, pos.z		);
+
+		} break;
+		case 11:{
+
+			r_from=Vector3( pos.x+size.x	, pos.y		, pos.z+size.z		);
+			r_to=Vector3( pos.x+size.x	, pos.y+size.y	, pos.z+size.z		);
+
+		} break;
+
+	}
+
+}
+
+Rect3::operator String() const {
+
+	//return String()+pos +" - "+ size;
+	return String(); // @Todo
+}
+
+}
+
+#endif // RECT3_H

include/godot/core/String.h

@@ -91,7 +91,6 @@ public:
 
 	void operator +=(const String &s)
 	{
-		// @Todo
 		godot_string_operator_plus(&_godot_string, &_godot_string, &s._godot_string);
 	}
 

include/godot/core/Transform.h

@@ -0,0 +1,383 @@
+#ifndef TRANSFORM_H
+#define TRANSFORM_H
+
+#include "Basis.h"
+
+#include "Plane.h"
+#include "Rect3.h"
+
+namespace godot {
+
+class Transform {
+public:
+
+	Basis basis;
+	Vector3 origin;
+
+	void invert();
+	Transform inverse() const;
+
+	void affine_invert();
+	Transform affine_inverse() const;
+
+	Transform rotated(const Vector3& p_axis,real_t p_phi) const;
+
+	void rotate(const Vector3& p_axis,real_t p_phi);
+	void rotate_basis(const Vector3& p_axis,real_t p_phi);
+
+	void set_look_at( const Vector3& p_eye, const Vector3& p_target, const Vector3& p_up );
+	Transform looking_at( const Vector3& p_target, const Vector3& p_up ) const;
+
+	void scale(const Vector3& p_scale);
+	Transform scaled(const Vector3& p_scale) const;
+	void scale_basis(const Vector3& p_scale);
+	void translate( real_t p_tx, real_t p_ty, real_t p_tz );
+	void translate( const Vector3& p_translation );
+	Transform translated( const Vector3& p_translation ) const;
+
+	const Basis& get_basis() const { return basis; }
+	void set_basis(const Basis& p_basis) { basis=p_basis; }
+
+	const Vector3& get_origin() const { return origin; }
+	void set_origin(const Vector3& p_origin) { origin=p_origin; }
+
+	void orthonormalize();
+	Transform orthonormalized() const;
+
+	bool operator==(const Transform& p_transform) const;
+	bool operator!=(const Transform& p_transform) const;
+
+	Vector3 xform(const Vector3& p_vector) const;
+	Vector3 xform_inv(const Vector3& p_vector) const;
+
+	Plane xform(const Plane& p_plane) const;
+	Plane xform_inv(const Plane& p_plane) const;
+
+	Rect3 xform(const Rect3& p_aabb) const;
+	Rect3 xform_inv(const Rect3& p_aabb) const;
+
+	void operator*=(const Transform& p_transform);
+	Transform operator*(const Transform& p_transform) const;
+
+	Transform interpolate_with(const Transform& p_transform, real_t p_c) const;
+
+	Transform inverse_xform(const Transform& t) const {
+
+		Vector3 v = t.origin - origin;
+		return Transform(basis.transpose_xform(t.basis),
+			basis.xform(v));
+	}
+
+	void set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz,real_t tx, real_t ty, real_t tz) {
+
+		basis.elements[0][0]=xx;
+		basis.elements[0][1]=xy;
+		basis.elements[0][2]=xz;
+		basis.elements[1][0]=yx;
+		basis.elements[1][1]=yy;
+		basis.elements[1][2]=yz;
+		basis.elements[2][0]=zx;
+		basis.elements[2][1]=zy;
+		basis.elements[2][2]=zz;
+		origin.x=tx;
+		origin.y=ty;
+		origin.z=tz;
+	}
+
+	operator String() const;
+
+	Transform(const Basis& p_basis, const Vector3& p_origin=Vector3());
+	Transform() {}
+
+};
+
+
+Vector3 Transform::xform(const Vector3& p_vector) const {
+
+	return Vector3(
+		basis[0].dot(p_vector)+origin.x,
+		basis[1].dot(p_vector)+origin.y,
+		basis[2].dot(p_vector)+origin.z
+	);
+}
+Vector3 Transform::xform_inv(const Vector3& p_vector) const {
+
+	Vector3 v = p_vector - origin;
+
+	return Vector3(
+		(basis.elements[0][0]*v.x ) + ( basis.elements[1][0]*v.y ) + ( basis.elements[2][0]*v.z ),
+		(basis.elements[0][1]*v.x ) + ( basis.elements[1][1]*v.y ) + ( basis.elements[2][1]*v.z ),
+		(basis.elements[0][2]*v.x ) + ( basis.elements[1][2]*v.y ) + ( basis.elements[2][2]*v.z )
+	);
+}
+
+Plane Transform::xform(const Plane& p_plane) const {
+
+
+	Vector3 point=p_plane.normal*p_plane.d;
+	Vector3 point_dir=point+p_plane.normal;
+	point=xform(point);
+	point_dir=xform(point_dir);
+
+	Vector3 normal=point_dir-point;
+	normal.normalize();
+	real_t d=normal.dot(point);
+
+	return Plane(normal,d);
+
+}
+Plane Transform::xform_inv(const Plane& p_plane) const {
+
+	Vector3 point=p_plane.normal*p_plane.d;
+	Vector3 point_dir=point+p_plane.normal;
+	xform_inv(point);
+	xform_inv(point_dir);
+
+	Vector3 normal=point_dir-point;
+	normal.normalize();
+	real_t d=normal.dot(point);
+
+	return Plane(normal,d);
+
+}
+
+Rect3 Transform::xform(const Rect3& p_aabb) const {
+	/* define vertices */
+	Vector3 x=basis.get_axis(0)*p_aabb.size.x;
+	Vector3 y=basis.get_axis(1)*p_aabb.size.y;
+	Vector3 z=basis.get_axis(2)*p_aabb.size.z;
+	Vector3 pos = xform( p_aabb.pos );
+//could be even further optimized
+	Rect3 new_aabb;
+	new_aabb.pos=pos;
+	new_aabb.expand_to( pos+x );
+	new_aabb.expand_to( pos+y );
+	new_aabb.expand_to( pos+z );
+	new_aabb.expand_to( pos+x+y );
+	new_aabb.expand_to( pos+x+z );
+	new_aabb.expand_to( pos+y+z );
+	new_aabb.expand_to( pos+x+y+z );
+	return new_aabb;
+
+}
+Rect3 Transform::xform_inv(const Rect3& p_aabb) const {
+
+	/* define vertices */
+	Vector3 vertices[8]={
+			Vector3(p_aabb.pos.x+p_aabb.size.x,	p_aabb.pos.y+p_aabb.size.y,	p_aabb.pos.z+p_aabb.size.z),
+			Vector3(p_aabb.pos.x+p_aabb.size.x,	p_aabb.pos.y+p_aabb.size.y,	p_aabb.pos.z),
+			Vector3(p_aabb.pos.x+p_aabb.size.x,	p_aabb.pos.y,		p_aabb.pos.z+p_aabb.size.z),
+			Vector3(p_aabb.pos.x+p_aabb.size.x,	p_aabb.pos.y,		p_aabb.pos.z),
+			Vector3(p_aabb.pos.x,	p_aabb.pos.y+p_aabb.size.y,	p_aabb.pos.z+p_aabb.size.z),
+			Vector3(p_aabb.pos.x,	p_aabb.pos.y+p_aabb.size.y,	p_aabb.pos.z),
+			Vector3(p_aabb.pos.x,	p_aabb.pos.y,		p_aabb.pos.z+p_aabb.size.z),
+			Vector3(p_aabb.pos.x,	p_aabb.pos.y,		p_aabb.pos.z)
+	};
+
+
+	Rect3 ret;
+
+	ret.pos=xform_inv(vertices[0]);
+
+	for (int i=1;i<8;i++) {
+
+		ret.expand_to( xform_inv(vertices[i]) );
+	}
+
+	return ret;
+
+}
+
+}
+
+
+namespace godot {
+
+
+void Transform::affine_invert() {
+
+	basis.invert();
+	origin = basis.xform(-origin);
+}
+
+Transform Transform::affine_inverse() const {
+
+	Transform ret=*this;
+	ret.affine_invert();
+	return ret;
+
+}
+
+
+void Transform::invert() {
+
+	basis.transpose();
+	origin = basis.xform(-origin);
+}
+
+Transform Transform::inverse() const {
+	// FIXME: this function assumes the basis is a rotation matrix, with no scaling.
+	// Transform::affine_inverse can handle matrices with scaling, so GDScript should eventually use that.
+	Transform ret=*this;
+	ret.invert();
+	return ret;
+}
+
+
+void Transform::rotate(const Vector3& p_axis,real_t p_phi) {
+
+	*this = rotated(p_axis, p_phi);
+}
+
+Transform Transform::rotated(const Vector3& p_axis,real_t p_phi) const{
+
+	return Transform(Basis( p_axis, p_phi ), Vector3()) * (*this);
+}
+
+void Transform::rotate_basis(const Vector3& p_axis,real_t p_phi) {
+
+	basis.rotate(p_axis,p_phi);
+}
+
+Transform Transform::looking_at( const Vector3& p_target, const Vector3& p_up ) const {
+
+	Transform t = *this;
+	t.set_look_at(origin,p_target,p_up);
+	return t;
+}
+
+void Transform::set_look_at( const Vector3& p_eye, const Vector3& p_target, const Vector3& p_up ) {
+
+	// Reference: MESA source code
+	Vector3 v_x, v_y, v_z;
+
+	/* Make rotation matrix */
+
+	/* Z vector */
+	v_z = p_eye - p_target;
+
+	v_z.normalize();
+
+	v_y = p_up;
+
+
+	v_x=v_y.cross(v_z);
+
+	/* Recompute Y = Z cross X */
+	v_y=v_z.cross(v_x);
+
+	v_x.normalize();
+	v_y.normalize();
+
+	basis.set_axis(0,v_x);
+	basis.set_axis(1,v_y);
+	basis.set_axis(2,v_z);
+	origin=p_eye;
+
+}
+
+Transform Transform::interpolate_with(const Transform& p_transform, real_t p_c) const {
+
+	/* not sure if very "efficient" but good enough? */
+
+	Vector3 src_scale = basis.get_scale();
+	Quat src_rot = basis;
+	Vector3 src_loc = origin;
+
+	Vector3 dst_scale = p_transform.basis.get_scale();
+	Quat dst_rot = p_transform.basis;
+	Vector3 dst_loc = p_transform.origin;
+
+	Transform dst;
+	dst.basis=src_rot.slerp(dst_rot,p_c);
+	dst.basis.scale(src_scale.linear_interpolate(dst_scale,p_c));
+	dst.origin=src_loc.linear_interpolate(dst_loc,p_c);
+
+	return dst;
+}
+
+void Transform::scale(const Vector3& p_scale) {
+
+	basis.scale(p_scale);
+	origin*=p_scale;
+}
+
+Transform Transform::scaled(const Vector3& p_scale) const {
+
+	Transform t = *this;
+	t.scale(p_scale);
+	return t;
+}
+
+void Transform::scale_basis(const Vector3& p_scale) {
+
+	basis.scale(p_scale);
+}
+
+void Transform::translate( real_t p_tx, real_t p_ty, real_t p_tz)  {
+	translate( Vector3(p_tx,p_ty,p_tz) );
+
+}
+void Transform::translate( const Vector3& p_translation ) {
+
+	for( int i = 0; i < 3; i++ ) {
+		origin[i] += basis[i].dot(p_translation);
+	}
+}
+
+Transform Transform::translated( const Vector3& p_translation ) const {
+
+	Transform t=*this;
+	t.translate(p_translation);
+	return t;
+}
+
+void Transform::orthonormalize() {
+
+	basis.orthonormalize();
+}
+
+Transform Transform::orthonormalized() const {
+
+	Transform _copy = *this;
+	_copy.orthonormalize();
+	return _copy;
+}
+
+bool Transform::operator==(const Transform& p_transform) const {
+
+	return (basis==p_transform.basis && origin==p_transform.origin);
+}
+bool Transform::operator!=(const Transform& p_transform) const {
+
+	return (basis!=p_transform.basis || origin!=p_transform.origin);
+}
+
+void Transform::operator*=(const Transform& p_transform) {
+
+	origin=xform(p_transform.origin);
+	basis*=p_transform.basis;
+}
+
+Transform Transform::operator*(const Transform& p_transform) const {
+
+	Transform t=*this;
+	t*=p_transform;
+	return t;
+}
+
+Transform::operator String() const {
+
+	return basis.operator String() + " - " + origin.operator String();
+}
+
+
+Transform::Transform(const Basis& p_basis, const Vector3& p_origin) {
+
+	basis=p_basis;
+	origin=p_origin;
+}
+
+}
+
+#endif // TRANSFORM_H

include/godot/core/Transform2D.h

@@ -0,0 +1,448 @@
+#ifndef TRANSFORM2D_H
+#define TRANSFORM2D_H
+
+#include "Vector2.h"
+
+// @Todo
+// error handling plllls
+
+#ifndef ERR_FAIL_INDEX_V
+#define ERR_FAIL_INDEX_V(a, b, c)
+#endif
+
+#ifndef ERR_FAIL_INDEX
+#define ERR_FAIL_INDEX(a, b)
+#endif
+
+#ifndef ERR_FAIL_COND
+#define ERR_FAIL_COND(a)
+#endif
+
+namespace godot {
+
+typedef Vector2 Size2;
+
+class Rect2;
+
+struct Transform2D {
+	// Warning #1: basis of Transform2D is stored differently from Basis. In terms of elements array, the basis matrix looks like "on paper":
+	// M = (elements[0][0] elements[1][0])
+	//     (elements[0][1] elements[1][1])
+	// This is such that the columns, which can be interpreted as basis vectors of the coordinate system "painted" on the object, can be accessed as elements[i].
+	// Note that this is the opposite of the indices in mathematical texts, meaning: $M_{12}$ in a math book corresponds to elements[1][0] here.
+	// This requires additional care when working with explicit indices.
+	// See https://en.wikipedia.org/wiki/Row-_and_column-major_order for further reading.
+
+	// Warning #2: 2D be aware that unlike 3D code, 2D code uses a left-handed coordinate system: Y-axis points down,
+	// and angle is measure from +X to +Y in a clockwise-fashion.
+
+	Vector2 elements[3];
+
+	real_t tdotx(const Vector2& v) const { return elements[0][0] * v.x + elements[1][0] * v.y; }
+	real_t tdoty(const Vector2& v) const { return elements[0][1] * v.x + elements[1][1] * v.y; }
+
+	const Vector2& operator[](int p_idx) const { return elements[p_idx]; }
+	Vector2& operator[](int p_idx) { return elements[p_idx]; }
+
+	Vector2 get_axis(int p_axis) const { ERR_FAIL_INDEX_V(p_axis,3,Vector2()); return elements[p_axis]; }
+	void set_axis(int p_axis,const Vector2& p_vec) { ERR_FAIL_INDEX(p_axis,3); elements[p_axis]=p_vec; }
+
+	void invert();
+	Transform2D inverse() const;
+
+	void affine_invert();
+	Transform2D affine_inverse() const;
+
+	void set_rotation(real_t p_phi);
+	real_t get_rotation() const;
+	void set_rotation_and_scale(real_t p_phi,const Size2& p_scale);
+	void rotate(real_t p_phi);
+
+	void scale(const Size2& p_scale);
+	void scale_basis(const Size2& p_scale);
+	void translate( real_t p_tx, real_t p_ty);
+	void translate( const Vector2& p_translation );
+
+	real_t basis_determinant() const;
+
+	Size2 get_scale() const;
+
+	const Vector2& get_origin() const { return elements[2]; }
+	void set_origin(const Vector2& p_origin) { elements[2]=p_origin; }
+
+	Transform2D scaled(const Size2& p_scale) const;
+	Transform2D basis_scaled(const Size2& p_scale) const;
+	Transform2D translated(const Vector2& p_offset) const;
+	Transform2D rotated(real_t p_phi) const;
+
+	Transform2D untranslated() const;
+
+	void orthonormalize();
+	Transform2D orthonormalized() const;
+
+	bool operator==(const Transform2D& p_transform) const;
+	bool operator!=(const Transform2D& p_transform) const;
+
+	void operator*=(const Transform2D& p_transform);
+	Transform2D operator*(const Transform2D& p_transform) const;
+
+	Transform2D interpolate_with(const Transform2D& p_transform, real_t p_c) const;
+
+	Vector2 basis_xform(const Vector2& p_vec) const;
+	Vector2 basis_xform_inv(const Vector2& p_vec) const;
+	Vector2 xform(const Vector2& p_vec) const;
+	Vector2 xform_inv(const Vector2& p_vec) const;
+	Rect2 xform(const Rect2& p_vec) const;
+	Rect2 xform_inv(const Rect2& p_vec) const;
+
+	operator String() const;
+
+	Transform2D(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox, real_t oy) {
+
+		elements[0][0] = xx;
+		elements[0][1] = xy;
+		elements[1][0] = yx;
+		elements[1][1] = yy;
+		elements[2][0] = ox;
+		elements[2][1] = oy;
+	}
+
+	Transform2D(real_t p_rot, const Vector2& p_pos);
+	Transform2D() { elements[0][0]=1.0; elements[1][1]=1.0; }
+};
+
+
+}
+
+#include "Rect2.h"
+
+namespace godot {
+
+Vector2 Transform2D::basis_xform(const Vector2& v) const {
+
+	return Vector2(
+		tdotx(v),
+		tdoty(v)
+	);
+}
+
+Vector2 Transform2D::basis_xform_inv(const Vector2& v) const{
+
+	return Vector2(
+		elements[0].dot(v),
+		elements[1].dot(v)
+	);
+}
+
+Vector2 Transform2D::xform(const Vector2& v) const {
+
+	return Vector2(
+		tdotx(v),
+		tdoty(v)
+	) + elements[2];
+}
+Vector2 Transform2D::xform_inv(const Vector2& p_vec) const {
+
+	Vector2 v = p_vec - elements[2];
+
+	return Vector2(
+		elements[0].dot(v),
+		elements[1].dot(v)
+	);
+
+}
+Rect2 Transform2D::xform(const Rect2& p_rect) const {
+
+	Vector2 x=elements[0]*p_rect.size.x;
+	Vector2 y=elements[1]*p_rect.size.y;
+	Vector2 pos = xform( p_rect.pos );
+
+	Rect2 new_rect;
+	new_rect.pos=pos;
+	new_rect.expand_to( pos+x );
+	new_rect.expand_to( pos+y );
+	new_rect.expand_to( pos+x+y );
+	return new_rect;
+}
+
+void Transform2D::set_rotation_and_scale(real_t p_rot,const Size2& p_scale) {
+
+	elements[0][0]=::cos(p_rot)*p_scale.x;
+	elements[1][1]=::cos(p_rot)*p_scale.y;
+	elements[1][0]=-::sin(p_rot)*p_scale.y;
+	elements[0][1]=::sin(p_rot)*p_scale.x;
+
+}
+
+Rect2 Transform2D::xform_inv(const Rect2& p_rect) const {
+
+	Vector2 ends[4]={
+		xform_inv( p_rect.pos ),
+		xform_inv( Vector2(p_rect.pos.x,p_rect.pos.y+p_rect.size.y ) ),
+		xform_inv( Vector2(p_rect.pos.x+p_rect.size.x,p_rect.pos.y+p_rect.size.y ) ),
+		xform_inv( Vector2(p_rect.pos.x+p_rect.size.x,p_rect.pos.y ) )
+	};
+
+	Rect2 new_rect;
+	new_rect.pos=ends[0];
+	new_rect.expand_to(ends[1]);
+	new_rect.expand_to(ends[2]);
+	new_rect.expand_to(ends[3]);
+
+	return new_rect;
+}
+
+void Transform2D::invert() {
+	// FIXME: this function assumes the basis is a rotation matrix, with no scaling.
+	// Transform2D::affine_inverse can handle matrices with scaling, so GDScript should eventually use that.
+	std::swap(elements[0][1],elements[1][0]);
+	elements[2] = basis_xform(-elements[2]);
+}
+
+Transform2D Transform2D::inverse() const {
+
+	Transform2D inv=*this;
+	inv.invert();
+	return inv;
+
+}
+
+void Transform2D::affine_invert() {
+
+	real_t det = basis_determinant();
+	ERR_FAIL_COND(det==0);
+	real_t idet = 1.0 / det;
+
+	std::swap( elements[0][0],elements[1][1] );
+	elements[0]*=Vector2(idet,-idet);
+	elements[1]*=Vector2(-idet,idet);
+
+	elements[2] = basis_xform(-elements[2]);
+
+}
+
+Transform2D Transform2D::affine_inverse() const {
+
+	Transform2D inv=*this;
+	inv.affine_invert();
+	return inv;
+}
+
+void Transform2D::rotate(real_t p_phi) {
+	*this = Transform2D(p_phi,Vector2()) * (*this);
+}
+
+real_t Transform2D::get_rotation() const {
+	real_t det = basis_determinant();
+	Transform2D m = orthonormalized();
+	if (det < 0) {
+		m.scale_basis(Size2(-1,-1));
+	}
+	return ::atan2(m[0].y,m[0].x);
+}
+
+void Transform2D::set_rotation(real_t p_rot) {
+
+	real_t cr = ::cos(p_rot);
+	real_t sr = ::sin(p_rot);
+	elements[0][0]=cr;
+	elements[0][1]=sr;
+	elements[1][0]=-sr;
+	elements[1][1]=cr;
+}
+
+Transform2D::Transform2D(real_t p_rot, const Vector2& p_pos) {
+
+	real_t cr = ::cos(p_rot);
+	real_t sr = ::sin(p_rot);
+	elements[0][0]=cr;
+	elements[0][1]=sr;
+	elements[1][0]=-sr;
+	elements[1][1]=cr;
+	elements[2]=p_pos;
+}
+
+Size2 Transform2D::get_scale() const {
+	real_t det_sign = basis_determinant() > 0 ? 1 : -1;
+	return det_sign * Size2( elements[0].length(), elements[1].length() );
+}
+
+void Transform2D::scale(const Size2& p_scale) {
+	scale_basis(p_scale);
+	elements[2]*=p_scale;
+}
+void Transform2D::scale_basis(const Size2& p_scale) {
+
+	elements[0][0]*=p_scale.x;
+	elements[0][1]*=p_scale.y;
+	elements[1][0]*=p_scale.x;
+	elements[1][1]*=p_scale.y;
+
+}
+void Transform2D::translate( real_t p_tx, real_t p_ty) {
+
+	translate(Vector2(p_tx,p_ty));
+}
+void Transform2D::translate( const Vector2& p_translation ) {
+
+	elements[2]+=basis_xform(p_translation);
+}
+
+void Transform2D::orthonormalize() {
+
+	// Gram-Schmidt Process
+
+	Vector2 x=elements[0];
+	Vector2 y=elements[1];
+
+	x.normalize();
+	y = (y-x*(x.dot(y)));
+	y.normalize();
+
+	elements[0]=x;
+	elements[1]=y;
+}
+Transform2D Transform2D::orthonormalized() const {
+
+	Transform2D on=*this;
+	on.orthonormalize();
+	return on;
+
+}
+
+bool Transform2D::operator==(const Transform2D& p_transform) const {
+
+	for(int i=0;i<3;i++) {
+		if (elements[i]!=p_transform.elements[i])
+			return false;
+	}
+
+	return true;
+}
+
+bool Transform2D::operator!=(const Transform2D& p_transform) const {
+
+	for(int i=0;i<3;i++) {
+		if (elements[i]!=p_transform.elements[i])
+			return true;
+	}
+
+	return false;
+
+}
+
+void Transform2D::operator*=(const Transform2D& p_transform) {
+
+	elements[2] = xform(p_transform.elements[2]);
+
+	real_t x0,x1,y0,y1;
+
+	x0 = tdotx(p_transform.elements[0]);
+	x1 = tdoty(p_transform.elements[0]);
+	y0 = tdotx(p_transform.elements[1]);
+	y1 = tdoty(p_transform.elements[1]);
+
+	elements[0][0]=x0;
+	elements[0][1]=x1;
+	elements[1][0]=y0;
+	elements[1][1]=y1;
+}
+
+
+Transform2D Transform2D::operator*(const Transform2D& p_transform) const {
+
+	Transform2D t = *this;
+	t*=p_transform;
+	return t;
+
+}
+
+Transform2D Transform2D::scaled(const Size2& p_scale) const {
+
+	Transform2D copy=*this;
+	copy.scale(p_scale);
+	return copy;
+
+}
+
+Transform2D Transform2D::basis_scaled(const Size2& p_scale) const {
+
+	Transform2D copy=*this;
+	copy.scale_basis(p_scale);
+	return copy;
+
+}
+
+Transform2D Transform2D::untranslated() const {
+
+	Transform2D copy=*this;
+	copy.elements[2]=Vector2();
+	return copy;
+}
+
+Transform2D Transform2D::translated(const Vector2& p_offset) const {
+
+	Transform2D copy=*this;
+	copy.translate(p_offset);
+	return copy;
+
+}
+
+Transform2D Transform2D::rotated(real_t p_phi) const {
+
+	Transform2D copy=*this;
+	copy.rotate(p_phi);
+	return copy;
+
+}
+
+real_t Transform2D::basis_determinant() const {
+
+	return elements[0].x * elements[1].y - elements[0].y * elements[1].x;
+}
+
+Transform2D Transform2D::interpolate_with(const Transform2D& p_transform, real_t p_c) const {
+
+	//extract parameters
+	Vector2 p1 = get_origin();
+	Vector2 p2 = p_transform.get_origin();
+
+	real_t r1 = get_rotation();
+	real_t r2 = p_transform.get_rotation();
+
+	Size2 s1 = get_scale();
+	Size2 s2 = p_transform.get_scale();
+
+	//slerp rotation
+	Vector2 v1(::cos(r1), ::sin(r1));
+	Vector2 v2(::cos(r2), ::sin(r2));
+
+	real_t dot = v1.dot(v2);
+
+	dot = (dot < -1.0) ? -1.0 : ((dot > 1.0) ? 1.0 : dot); //clamp dot to [-1,1]
+
+	Vector2 v;
+
+	if (dot > 0.9995) {
+		v = Vector2::linear_interpolate(v1, v2, p_c).normalized(); //linearly interpolate to avoid numerical precision issues
+	} else {
+		real_t angle = p_c*::acos(dot);
+		Vector2 v3 = (v2 - v1*dot).normalized();
+		v = v1*::cos(angle) + v3*::sin(angle);
+	}
+
+	//construct matrix
+	Transform2D res(::atan2(v.y, v.x), Vector2::linear_interpolate(p1, p2, p_c));
+	res.scale_basis(Vector2::linear_interpolate(s1, s2, p_c));
+	return res;
+}
+
+Transform2D::operator String() const {
+
+	//return String(String()+elements[0]+", "+elements[1]+", "+elements[2]);
+	return String(); // @Todo
+}
+
+}
+
+#endif // TRANSFORM2D_H

include/godot/core/Vector3.h

@@ -380,6 +380,11 @@ struct Vector3 {
 		v.snap(by);
 		return v;
 	}
+
+	operator String() const
+	{
+		return String(); // @Todo
+	}
 };
 
 Vector3 operator*(real_t p_scalar, const Vector3& p_vec)
@@ -387,6 +392,11 @@ Vector3 operator*(real_t p_scalar, const Vector3& p_vec)
 	return p_vec * p_scalar;
 }
 
+Vector3 vec3_cross(const Vector3& p_a, const Vector3& p_b) {
+
+	return p_a.cross(p_b);
+}
+
 }
 
 #endif // VECTOR3_H