WIP: Linux port

 - Fixing various warnings/errors when compiling with GCC & Clang

Documentation/Mono-4.4.0-IntegrationGuide.txt

@@ -1,38 +1,37 @@
 ---------------------------------Compiling runtime-------------------------------------
  - Retrieve mono sources using git:
-   - Make sure your git client has this set: "git config --global core.autocrlf input" as otherwise you'll have problems with line endings during later steps
+   - (Windows only) Make sure your git client has this set: "git config --global core.autocrlf input" as otherwise you'll have problems with line endings during later steps
    - Clone mono from https://github.com/mono/mono (make sure to perform a RECURSIVE clone as there are sub-modules in the /external folder)
      - Checkout mono-4.4.0-branch
      - Checkout commit # febc509ab9a7d07734f5b694037bc2becbc97851 (later ones might, but might not work)
- - Go to msvc/ folder to find mono.sln (Visual studio solution)
- - Open in VS2012 as is, or open in later VS and upgrade all projects to latest toolkit (v120 and v140 tested and working)
+ - If on Windows:
+  - Go to msvc/ folder to find mono.sln (Visual studio solution)
+  - Open in VS2012 as is, or open in later VS and upgrade all projects to latest toolkit (v120 and v140 tested and working)
  - Expose "mono_class_bind_generic_parameters" to the public:
-  - In object-internals.h change:
+  - In mono/metadata/object-internals.h change:
    MonoClass* mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, gboolean is_dynamic) MONO_INTERNAL; 
    to:
    MONO_API MonoClass* mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, mono_bool is_dynamic);
    then move it to:
-   object.h
-  - In reflection.c modify:
+   mono/metadata/object.h
+  - In mono/metadata/reflection.c modify:
    MonoClass* mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, gboolean is_dynamic)
    to:
    MonoClass* mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, mono_bool is_dynamic)
-  - Add "mono_class_bind_generic_parameters" entry to mono/msvc/mono.def file
- - Generate missing header files:
+  - (Windows only) Add "mono_class_bind_generic_parameters" entry to mono/msvc/mono.def file
+ - (Windows only) Generate missing header files:
    - First compile "genmdesc" project for desired configuration (debug/release, 32/64 bit)
    - Then run "runmdesc x64\bin\Debug\genmdesc x64" located in /msvc folder
      - Replace folder path to genmdesc you generated in the previous step
 	 - Replace x64 with Win32 for 32-bit builds
  - Compile mono project with desired configuration (debug/release, 32/64 bit, SGen builds were not tested). You will receive mono-2.0.dll and mono-2.0.lib as output.
    - Repeat the "genmdesc" step above for each configuration. Doing it once might be enough but be on the safe side.
- - Add mono-2.0.dll to (BansheeRootDir)/bin/(Platform)/(Configuration)
- - Add mono-2.0.lib to (BansheeRootDir)/Dependencies/lib/(Platform)/(Configuration)
 
------------------------------Compiling libraries & compiler-------------------------------------
+-----------------------------Compiling libraries & compiler -------------------------------------
 
 - Install Mono 4.2.3.4 (This is the latest binary release for Windows, you can use newer if there is one).
 - Add the "(InstallDir)\Mono\bin" to your PATH environment variable.
-- Install Cygwin 32-bit version using these command line parameters:
+- (Windows only)Install Cygwin 32-bit version using these command line parameters:
  setup-x86.exe -qnNdO -R "C:\cygwin" -s "http://cygwin.mirror.constant.com" 
   -l "C:\cygwin\var\cache\setup" -P autoconf -P automake -P bison -P gcc-core -P gcc-g++ -P mingw64-i686-runtime 
   -P mingw64-i686-binutils -P mingw64-i686-gcc-core -P mingw64-i686-gcc-g++ -P mingw64-i686-headers -P mingw64-i686-pthreads
@@ -40,15 +39,15 @@
   -P windows-default-manifest -P libtool -P make -P python -P gettext-devel -P gettext -P intltool -P libiconv 
   -P pkg-config -P git -P wget -P curl
 
-- Go to your mono source directory (the one retrieved when compiling the runtime) in Cygwin and enter these commands in order:
+- Go to your mono source directory (the one retrieved when compiling the runtime) in terminal (Cygwin or native) and enter these commands in order:
  - "./autogen.sh --prefix="(OutputDir)" --with-preview=yes"" (Replace (OutputDir) with a folder where you want to output the binaries, e.g. "C:\MonoInstall")
- - "./configure --host=i686-w64-mingw32"
+ - "./configure --host=i686-w64-mingw32" if Cygwin, "./configure" if native
  - "make"
  - "make install"
-- Your built mono should now be output to (OutputDir) folder. (If it's not in that folder then check your Cygwin install folder under /usr/local)
+- Your built mono should now be output to (OutputDir) folder. (If it's not in that folder, and if using Cygwin then check your Cygwin install folder under /usr/local)
 - Copy contents of (OutputDir)/include/mono/mono-2.0/mono to (BansheeRootDir)/Dependencies/Include/Mono
   - Make sure to modify "object.h" as you did above when building the binaries
 - Copy folder (OutputDir)/etc to (BansheeRootDir)/bin/Mono
 - Copy assembly folders (OutputDir)/lib/mono/4.0 and (OutputDir)/lib/mono/4.5 to (BansheeRootDir)/bin/Mono/lib/mono/4.0 and (BansheeRootDir)/bin/Mono/lib/mono/4.5, respectively
  - If you wish, you can clean up the assemblies within those folders are many might not be used. The minimum needed are "mscorlib.dll", "System.dll" and "System.Core.dll".
-- Copy the compiler (mcs.exe) from (OutputDir)/lib/mono/4.5 to (BansheeRootDir)/bin/Mono/compiler
+- Copy the compiler (mcs executable) from (OutputDir)/lib/mono/4.5 to (BansheeRootDir)/bin/Mono/compiler

Source/BansheeCore/CMakeSources.cmake

@@ -597,9 +597,22 @@ set(BS_BANSHEECORE_SRC_PLATFORM_WIN32
 	"Win32/BsWin32BrowseDialogs.cpp"
 )
 
+set(BS_BANSHEECORE_INC_PLATFORM_UNIX
+	"Unix/BsUnixPlatform.h"
+	"Unix/BsUnixWindow.h"
+)
+
+set(BS_BANSHEECORE_SRC_PLATFORM_UNIX
+	"Unix/BsUnixPlatform.cpp"
+	"Unix/BsUnixWindow.cpp"
+)
+
 if(WIN32)
 	list(APPEND BS_BANSHEECORE_INC_PLATFORM ${BS_BANSHEECORE_INC_PLATFORM_WIN32})
 	list(APPEND BS_BANSHEECORE_SRC_PLATFORM ${BS_BANSHEECORE_SRC_PLATFORM_WIN32})
+elseif(LINUX)
+	list(APPEND BS_BANSHEECORE_INC_PLATFORM ${BS_BANSHEECORE_INC_PLATFORM_UNIX})
+	list(APPEND BS_BANSHEECORE_SRC_PLATFORM ${BS_BANSHEECORE_SRC_PLATFORM_UNIX})
 endif()
 
 source_group("Header Files\\Components" FILES ${BS_BANSHEECORE_INC_COMPONENTS})

Source/BansheeCore/Components/BsCRigidbody.h

@@ -29,15 +29,15 @@ namespace bs
 
 		/** @copydoc Rigidbody::move */
 		BS_SCRIPT_EXPORT(n:Move)
-		inline void move(const Vector3& position);
+		void move(const Vector3& position);
 
 		/** @copydoc Rigidbody::rotate */
 		BS_SCRIPT_EXPORT(n:Rotate)
-		inline void rotate(const Quaternion& rotation);
+		void rotate(const Quaternion& rotation);
 
 		/** @copydoc Rigidbody::setMass */
 		BS_SCRIPT_EXPORT(n:Mass,pr:setter)
-		inline void setMass(float mass);
+		void setMass(float mass);
 
 		/** @copydoc Rigidbody::getMass */
 		BS_SCRIPT_EXPORT(n:Mass,pr:getter)
@@ -45,7 +45,7 @@ namespace bs
 
 		/** @copydoc Rigidbody::setIsKinematic */
 		BS_SCRIPT_EXPORT(n:IsKinematic,pr:setter)
-		inline void setIsKinematic(bool kinematic);
+		void setIsKinematic(bool kinematic);
 
 		/** @copydoc Rigidbody::getIsKinematic */
 		BS_SCRIPT_EXPORT(n:IsKinematic,pr:getter)
@@ -53,19 +53,19 @@ namespace bs
 
 		/** @copydoc Rigidbody::isSleeping */
 		BS_SCRIPT_EXPORT(n:IsSleeping,pr:getter)
-		inline bool isSleeping() const;
+		bool isSleeping() const;
 
 		/** @copydoc Rigidbody::sleep */
 		BS_SCRIPT_EXPORT(n:Sleep)
-		inline void sleep();
+		void sleep();
 
 		/** @copydoc Rigidbody::wakeUp */
 		BS_SCRIPT_EXPORT(n:WakeUp)
-		inline void wakeUp();
+		void wakeUp();
 
 		/** @copydoc Rigidbody::setSleepThreshold */
 		BS_SCRIPT_EXPORT(n:SleepThreshold,pr:setter)
-		inline void setSleepThreshold(float threshold);
+		void setSleepThreshold(float threshold);
 
 		/** @copydoc Rigidbody::getSleepThreshold */
 		BS_SCRIPT_EXPORT(n:SleepThreshold,pr:getter)
@@ -73,7 +73,7 @@ namespace bs
 
 		/** @copydoc Rigidbody::setUseGravity */
 		BS_SCRIPT_EXPORT(n:UseGravity,pr:setter)
-		inline void setUseGravity(bool gravity);
+		void setUseGravity(bool gravity);
 
 		/** @copydoc Rigidbody::getUseGravity */
 		BS_SCRIPT_EXPORT(n:UseGravity,pr:getter)
@@ -81,23 +81,23 @@ namespace bs
 
 		/** @copydoc Rigidbody::setVelocity */
 		BS_SCRIPT_EXPORT(n:Velocity,pr:setter)
-		inline void setVelocity(const Vector3& velocity);
+		void setVelocity(const Vector3& velocity);
 
 		/** @copydoc Rigidbody::getVelocity */
 		BS_SCRIPT_EXPORT(n:Velocity,pr:getter)
-		inline Vector3 getVelocity() const;
+		Vector3 getVelocity() const;
 
 		/** @copydoc Rigidbody::setAngularVelocity */
 		BS_SCRIPT_EXPORT(n:AngularVelocity,pr:setter)
-		inline void setAngularVelocity(const Vector3& velocity);
+		void setAngularVelocity(const Vector3& velocity);
 
 		/** @copydoc Rigidbody::getAngularVelocity */
 		BS_SCRIPT_EXPORT(n:AngularVelocity,pr:getter)
-		inline Vector3 getAngularVelocity() const;
+		Vector3 getAngularVelocity() const;
 
 		/** @copydoc Rigidbody::setDrag */
 		BS_SCRIPT_EXPORT(n:Drag,pr:setter)
-		inline void setDrag(float drag);
+		void setDrag(float drag);
 
 		/** @copydoc Rigidbody::getDrag */
 		BS_SCRIPT_EXPORT(n:Drag,pr:getter)
@@ -105,7 +105,7 @@ namespace bs
 
 		/** @copydoc Rigidbody::setAngularDrag */
 		BS_SCRIPT_EXPORT(n:AngularDrag,pr:setter)
-		inline void setAngularDrag(float drag);
+		void setAngularDrag(float drag);
 
 		/** @copydoc Rigidbody::getAngularDrag */
 		BS_SCRIPT_EXPORT(n:AngularDrag,pr:getter)
@@ -113,15 +113,15 @@ namespace bs
 
 		/** @copydoc Rigidbody::setInertiaTensor */
 		BS_SCRIPT_EXPORT(n:InertiaTensor,pr:setter)
-		inline void setInertiaTensor(const Vector3& tensor);
+		void setInertiaTensor(const Vector3& tensor);
 
 		/** @copydoc Rigidbody::getInertiaTensor */
 		BS_SCRIPT_EXPORT(n:InertiaTensor,pr:getter)
-		inline Vector3 getInertiaTensor() const;
+		Vector3 getInertiaTensor() const;
 
 		/** @copydoc Rigidbody::setMaxAngularVelocity */
 		BS_SCRIPT_EXPORT(n:MaxAngularVelocity,pr:setter)
-		inline void setMaxAngularVelocity(float maxVelocity);
+		void setMaxAngularVelocity(float maxVelocity);
 
 		/** @copydoc Rigidbody::getMaxAngularVelocity */
 		BS_SCRIPT_EXPORT(n:MaxAngularVelocity,pr:getter)
@@ -129,23 +129,23 @@ namespace bs
 
 		/** Determines the rigidbody's center of mass position. Only relevant if RigibodyFlag::AutoTensors is turned off. */
 		BS_SCRIPT_EXPORT(n:CenterOfMassPosition,pr:setter)
-		inline void setCenterOfMassPosition(const Vector3& position);
+		void setCenterOfMassPosition(const Vector3& position);
 
 		/** @copydoc setCenterOfMassPosition() */
 		BS_SCRIPT_EXPORT(n:CenterOfMassPosition,pr:getter)
-		inline Vector3 getCenterOfMassPosition() const;
+		Vector3 getCenterOfMassPosition() const;
 
 		/** Determines the rigidbody's center of mass rotation. Only relevant if RigibodyFlag::AutoTensors is turned off. */
 		BS_SCRIPT_EXPORT(n:CenterOfMassRotation,pr:setter)
-		inline void setCenterOfMassRotation(const Quaternion& rotation);
+		void setCenterOfMassRotation(const Quaternion& rotation);
 
 		/** @copydoc setCenterOfMassRotation() */
 		BS_SCRIPT_EXPORT(n:CenterOfMassRotation,pr:getter)
-		inline Quaternion getCenterOfMassRotation() const;
+		Quaternion getCenterOfMassRotation() const;
 
 		/** @copydoc Rigidbody::setPositionSolverCount */
 		BS_SCRIPT_EXPORT(n:PositionSolverCount,pr:setter)
-		inline void setPositionSolverCount(UINT32 count);
+		void setPositionSolverCount(UINT32 count);
 
 		/** @copydoc Rigidbody::getPositionSolverCount */
 		BS_SCRIPT_EXPORT(n:PositionSolverCount,pr:getter)
@@ -153,7 +153,7 @@ namespace bs
 
 		/** @copydoc Rigidbody::setVelocitySolverCount */
 		BS_SCRIPT_EXPORT(n:VelocitySolverCount,pr:setter)
-		inline void setVelocitySolverCount(UINT32 count);
+		void setVelocitySolverCount(UINT32 count);
 
 		/** @copydoc Rigidbody::getVelocitySolverCount */
 		BS_SCRIPT_EXPORT(n:VelocitySolverCount,pr:getter)
@@ -161,7 +161,7 @@ namespace bs
 
 		/** Sets a value that determines which (if any) collision events are reported. */
 		BS_SCRIPT_EXPORT(n:CollisionReportMode,pr:setter)
-		inline void setCollisionReportMode(CollisionReportMode mode);
+		void setCollisionReportMode(CollisionReportMode mode);
 
 		/** Gets a value that determines which (if any) collision events are reported. */
 		BS_SCRIPT_EXPORT(n:CollisionReportMode,pr:getter)
@@ -169,7 +169,7 @@ namespace bs
 
 		/** @copydoc Rigidbody::setFlags */
 		BS_SCRIPT_EXPORT(n:Flags,pr:setter)
-		inline void setFlags(RigidbodyFlag flags);
+		void setFlags(RigidbodyFlag flags);
 
 		/** @copydoc Rigidbody::getFlags */
 		BS_SCRIPT_EXPORT(n:Flags,pr:getter)
@@ -177,20 +177,20 @@ namespace bs
 
 		/** @copydoc Rigidbody::addForce */
 		BS_SCRIPT_EXPORT(n:AddForce)
-		inline void addForce(const Vector3& force, ForceMode mode = ForceMode::Force);
+		void addForce(const Vector3& force, ForceMode mode = ForceMode::Force);
 
 		/** @copydoc Rigidbody::addTorque */
 		BS_SCRIPT_EXPORT(n:AddTorque)
-		inline void addTorque(const Vector3& torque, ForceMode mode = ForceMode::Force);
+		void addTorque(const Vector3& torque, ForceMode mode = ForceMode::Force);
 
 		/** @copydoc Rigidbody::addForceAtPoint */
 		BS_SCRIPT_EXPORT(n:AddForceAtPoint)
-		inline void addForceAtPoint(const Vector3& force, const Vector3& position,
+		void addForceAtPoint(const Vector3& force, const Vector3& position,
 			PointForceMode mode = PointForceMode::Force);
 
 		/** @copydoc Rigidbody::getVelocityAtPoint */
 		BS_SCRIPT_EXPORT(n:GetVelocityAtPoint)
-		inline Vector3 getVelocityAtPoint(const Vector3& point) const;
+		Vector3 getVelocityAtPoint(const Vector3& point) const;
 
 		/** @copydoc Rigidbody::onCollisionBegin */
 		BS_SCRIPT_EXPORT(n:OnCollisionBegin)

Source/BansheeCore/Components/BsCSliderJoint.h

@@ -24,27 +24,27 @@ namespace bs
 
 		/** @copydoc SliderJoint::getPosition */
 		BS_SCRIPT_EXPORT(n:Position,pr:getter)
-		inline float getPosition() const;
+		float getPosition() const;
 
 		/** @copydoc SliderJoint::getSpeed */
 		BS_SCRIPT_EXPORT(n:Speed,pr:getter)
-		inline float getSpeed() const;
+		float getSpeed() const;
 
 		/** @copydoc SliderJoint::getLimit */
 		BS_SCRIPT_EXPORT(n:Limit,pr:getter)
-		inline LimitLinearRange getLimit() const;
+		LimitLinearRange getLimit() const;
 
 		/** @copydoc SliderJoint::setLimit */
 		BS_SCRIPT_EXPORT(n:Limit,pr:setter)
-		inline void setLimit(const LimitLinearRange& limit);
+		void setLimit(const LimitLinearRange& limit);
 
 		/** @copydoc SliderJoint::setFlag */
 		BS_SCRIPT_EXPORT(n:SetFlag)
-		inline void setFlag(SliderJointFlag flag, bool enabled);
+		void setFlag(SliderJointFlag flag, bool enabled);
 
 		/** @copydoc SliderJoint::hasFlag */
 		BS_SCRIPT_EXPORT(n:HasFlag)
-		inline bool hasFlag(SliderJointFlag flag) const;
+		bool hasFlag(SliderJointFlag flag) const;
 
 		/** @name Internal
 		 *  @{

Source/BansheeCore/Components/BsCSphericalJoint.h

@@ -24,19 +24,19 @@ namespace bs
 
 		/** @copydoc SphericalJoint::getLimit */
 		BS_SCRIPT_EXPORT(n:Limit,pr:getter)
-		inline LimitConeRange getLimit() const;
+		LimitConeRange getLimit() const;
 
 		/** @copydoc SphericalJoint::setLimit */
 		BS_SCRIPT_EXPORT(n:Limit,pr:setter)
-		inline void setLimit(const LimitConeRange& limit);
+		void setLimit(const LimitConeRange& limit);
 
 		/** @copydoc SphericalJoint::setFlag */
 		BS_SCRIPT_EXPORT(n:SetFlag)
-		inline void setFlag(SphericalJointFlag flag, bool enabled);
+		void setFlag(SphericalJointFlag flag, bool enabled);
 
 		/** @copydoc SphericalJoint::hasFlag */
 		BS_SCRIPT_EXPORT(n:HasFlag)
-		inline bool hasFlag(SphericalJointFlag flag) const;
+		bool hasFlag(SphericalJointFlag flag) const;
 
 		/** @name Internal
 		 *  @{

Source/BansheeCore/Platform/BsPlatform.h

@@ -343,6 +343,33 @@ namespace bs
 		static bool openBrowseDialog(FileDialogType type, const Path& defaultPath, const WString& filterList,
 			Vector<Path>& paths);
 
+		/**
+		 * Adds a string to the clipboard.
+		 *
+		 * @note	Thread safe.
+		 */
+		static void copyToClipboard(const WString& string);
+
+		/**
+		 * Reads a string from the clipboard and returns it. If there is no string in the clipboard it returns an empty
+		 * string.
+		 *
+		 * @note
+		 * Both wide and normal strings will be read, but normal strings will be converted to a wide string before returning.
+		 * @note
+		 * Thread safe.
+		 */
+		static WString copyFromClipboard();
+
+		/**
+		 * Converts a keyboard key-code to a Unicode character.
+		 *
+		 * @note
+		 * Normally this will output a single character, but it can happen it outputs multiple in case a accent/diacritic
+		 * character could not be combined with the virtual key into a single character.
+		 */
+		static WString keyCodeToUnicode(UINT32 keyCode);
+
 		/**
 		 * Message pump. Processes OS messages and returns when it's free.
 		 *

Source/BansheeCore/Unix/BsUnixPlatform.cpp

@@ -0,0 +1,766 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include <Image/BsPixelData.h>
+#include <Image/BsPixelUtil.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <String/BsUnicode.h>
+#include "BsUnixPlatform.h"
+#include "BsUnixWindow.h"
+
+namespace bs
+{
+	Event<void(const Vector2I&, const OSPointerButtonStates&)> Platform::onCursorMoved;
+	Event<void(const Vector2I&, OSMouseButton button, const OSPointerButtonStates&)> Platform::onCursorButtonPressed;
+	Event<void(const Vector2I&, OSMouseButton button, const OSPointerButtonStates&)> Platform::onCursorButtonReleased;
+	Event<void(const Vector2I&, const OSPointerButtonStates&)> Platform::onCursorDoubleClick;
+	Event<void(InputCommandType)> Platform::onInputCommand;
+	Event<void(float)> Platform::onMouseWheelScrolled;
+	Event<void(UINT32)> Platform::onCharInput;
+
+	Event<void(ct::RenderWindow*)> Platform::onMouseLeftWindow;
+	Event<void()> Platform::onMouseCaptureChanged
+
+	enum class X11CursorType
+	{
+		Arrow,
+		ArrowDrag,
+		ArrowLeftRight,
+		Wait,
+		IBeam,
+		SizeTopLeft,
+		SizeTopRight,
+		SizeBotLeft,
+		SizeBotRight,
+		SizeLeft,
+		SizeRight,
+		SizeTop,
+		SizeBottom,
+		Deny,
+
+		Count
+	};;
+
+	struct Platform::Pimpl
+	{
+		::Display* xDisplay = nullptr;
+		::Window mainXWindow = 0;
+		::Window fullscreenXWindow = 0;
+		std::unordered_map<::Window, LinuxWindow*> windowMap;
+
+		XIM IM;
+		XIC IC;
+		Time lastButtonPressTime;
+
+		Atom atomDeleteWindow;
+
+		// Clipboard
+		WString clipboardData;
+
+		// Cursor
+		::Cursor currentCursor = None;
+		::Cursor emptyCursor = None;
+		bool isCursorHidden = false;
+
+		Rect2I cursorClipRect;
+		LinuxWindow* cursorClipWindow = nullptr;
+		bool cursorClipEnabled = false;
+	};
+
+	static const UINT32 DOUBLE_CLICK_MS = 500;
+
+	Platform::Pimpl* Platform::mData = bs_new<Platform::Pimpl>();
+
+	Platform::~Platform() { }
+
+	Vector2I Platform::getCursorPosition()
+	{
+		UINT32 screenCount = XScreenCount(mData->xDisplay);
+
+		Vector2I pos;
+		for(UINT32 i = 0; i < screenCount; ++i)
+		{
+			::Window outRoot, outChild;
+			INT32 childX, childY;
+			UINT32 mask;
+			XQueryPointer(mData->xDisplay, XRootWindow(mData->xDisplay, i), &outRoot, &outChild, &pos.x,
+					&pos.y, &childX, &childY, &mask);
+		}
+
+		return pos;
+	}
+
+	void Platform::setCursorPosition(const Vector2I& screenPos)
+	{
+		UINT32 screenCount = XScreenCount(mData->xDisplay);
+
+		// Note assuming screens are laid out horizontally left to right
+		INT32 screenX = 0;
+		for(UINT32 i = 0; i < screenCount; ++i)
+		{
+			::Window root = XRootWindow(mData->xDisplay, i);
+			INT32 screenXEnd = screenX + XDisplayWidth(mData->xDisplay, i);
+
+			if(screenPos.x >= screenX && screenPos.x < screenXEnd)
+			{
+				XWarpPointer(mData->xDisplay, None, root, 0, 0, 0, 0, screenPos.x, screenPos.y);
+				XFlush(mData->xDisplay);
+				return;
+			}
+
+			screenX = screenXEnd;
+		}
+	}
+
+	void Platform::captureMouse(const RenderWindow& window)
+	{
+		// TODOPORT
+	}
+
+	void Platform::releaseMouseCapture()
+	{
+		// TODOPORT
+	}
+
+	bool Platform::isPointOverWindow(const RenderWindow& window, const Vector2I& screenPos)
+	{
+		// TODOPORT
+		return false;
+	}
+
+	void applyCurrentCursor(Platform::Pimpl* data, ::Window window)
+	{
+		if(data->isCursorHidden)
+			XDefineCursor(data->xDisplay, window, data->emptyCursor);
+		else
+		{
+			if (data->currentCursor != None)
+				XDefineCursor(data->xDisplay, window, data->currentCursor);
+			else
+				XUndefineCursor(data->xDisplay, window);
+		}
+	}
+
+	void updateClipBounds(Platform::Pimpl* data, LinuxWindow* window)
+	{
+		if(!data->cursorClipEnabled || data->cursorClipWindow != window)
+			return;
+
+		data->cursorClipRect.x = window->getLeft();
+		data->cursorClipRect.y = window->getTop();
+		data->cursorClipRect.width = window->getWidth();
+		data->cursorClipRect.height = window->getHeight();
+	}
+
+	bool clipCursor(Platform::Pimpl* data, Vector2I& pos)
+	{
+		if(!data->cursorClipEnabled)
+			return false;
+
+		int32_t clippedX = pos.x - data->cursorClipRect.x;
+		int32_t clippedY = pos.y - data->cursorClipRect.y;
+
+		if(clippedX < 0)
+			clippedX = data->cursorClipRect.x + data->cursorClipRect.width + clippedX;
+		else if(clippedX >= data->cursorClipRect.width)
+			clippedX = data->cursorClipRect.x + (clippedX - data->cursorClipRect.width);
+		else
+			clippedX = data->cursorClipRect.x + clippedX;
+
+		if(clippedY < 0)
+			clippedY = data->cursorClipRect.y + data->cursorClipRect.height + clippedY;
+		else if(clippedY >= data->cursorClipRect.height)
+			clippedY = data->cursorClipRect.y + (clippedY - data->cursorClipRect.height);
+		else
+			clippedY = data->cursorClipRect.y + clippedY;
+
+		if(clippedX != pos.x || clippedY != pos.y)
+		{
+			pos.x = clippedX;
+			pos.y = clippedY;
+
+			return true;
+		}
+
+		return false;
+	}
+
+	void Platform::hideCursor()
+	{
+		mData->isCursorHidden = true;
+
+		for(auto& entry : mData->windowMap)
+			applyCurrentCursor(mData, entry.first);
+	}
+
+	void Platform::showCursor()
+	{
+		mData->isCursorHidden = false;
+
+		for(auto& entry : mData->windowMap)
+			applyCurrentCursor(mData, entry.first);
+	}
+
+	bool Platform::isCursorHidden()
+	{
+		return mData->isCursorHidden;
+	}
+
+	void Platform::clipCursorToWindow(const RenderWindow& window)
+	{
+		mData->cursorClipEnabled = true;
+		mData->cursorClipWindow = window->_getInternal();
+
+		updateClipBounds(window);
+
+		Vector2I pos = getCursorPosition();
+
+		if(clipCursor(mData, pos))
+			setCursorPosition(pos);
+	}
+
+	void Platform::clipCursorToRect(const Rect2I& screenRect)
+	{
+		mData->cursorClipEnabled = true;
+		mData->cursorClipRect = screenRect;
+		mData->cursorClipWindow = nullptr;
+
+		Vector2I pos = getCursorPosition();
+
+		if(clipCursor(mData, pos))
+			setCursorPosition(pos);
+	}
+
+	void Platform::clipCursorDisable()
+	{
+		mData->cursorClipEnabled = false;
+		mData->cursorClipWindow = None;
+	}
+
+	void Platform::setCursor(PixelData& pixelData, const Vector2I& hotSpot)
+	{
+		// TODOPORT
+	}
+
+	void Platform::setIcon(const PixelData& pixelData)
+	{
+		SPtr<PixelData> resizedData = PixelData::create(32, 32, 1, PF_RGBA8);
+		PixelUtil::scale(pixelData, *resizedData);
+
+		// TODOPORT
+	}
+
+	void Platform::setCaptionNonClientAreas(const ct::RenderWindow& window, const Vector<Rect2I>& nonClientAreas)
+	{
+		// TODOPORT
+	}
+
+	void Platform::setResizeNonClientAreas(const ct::RenderWindow& window, const Vector<NonClientResizeArea>& nonClientAreas)
+	{
+		// Do nothing, resize areas not supported on Linux (but they are provided even on undecorated windows by the WM)
+	}
+
+	void Platform::resetNonClientAreas(const ct::RenderWindow& window)
+	{
+		// Do nothing, resize areas not supported on Linux (but they are provided even on undecorated windows by the WM)
+	}
+
+	void Platform::sleep(UINT32 duration)
+	{
+		usleep(duration * 1000);
+	}
+
+	OSDropTarget& Platform::createDropTarget(const RenderWindow* window, int x, int y, unsigned int width, unsigned int height)
+	{
+		// TODOPORT
+	}
+
+	void Platform::destroyDropTarget(OSDropTarget& target)
+	{
+		// TODOPORT
+	}
+
+	void Platform::copyToClipboard(const WString& string)
+	{
+		mData->clipboardData = string;
+
+		Atom clipboardAtom = XInternAtom(mData->xDisplay, "CLIPBOARD", 0);
+		XSetSelectionOwner(mData->xDisplay, clipboardAtom, mData->mainXWindow, CurrentTime);
+	}
+
+	WString Platform::copyFromClipboard()
+	{
+		Atom clipboardAtom = XInternAtom(mData->xDisplay, "CLIPBOARD", 0);
+		::Window selOwner = XGetSelectionOwner(mData->xDisplay, clipboardAtom);
+
+		if(selOwner == None)
+			return L"";
+
+		if(selOwner == mData->mainXWindow)
+			return mData->clipboardData;
+
+		XConvertSelection(mData->xDisplay, clipboardAtom, XA_STRING, clipboardAtom, mData->mainXWindow,
+				CurrentTime);
+		XFlush(mData->xDisplay);
+
+		// Note: This might discard events if there are any in between the one we need. Ideally we let the
+		// processEvents() handle them
+		while(true)
+		{
+			XEvent event;
+			XNextEvent(mData->xDisplay, &event);
+
+			if(event.type == SelectionNotify && event.xselection.requestor == mData->mainXWindow)
+				break;
+		}
+
+		Atom actualType;
+		INT32 actualFormat;
+		unsigned long length;
+		unsigned long bytesRemaining;
+		UINT8* data;
+		XGetWindowProperty(mData->xDisplay, mData->mainXWindow, clipboardAtom,
+				0, 0, False, AnyPropertyType, &actualType, &actualFormat, &length, &bytesRemaining, &data);
+
+		if(bytesRemaining > 0)
+		{
+			unsigned long unused;
+			INT32 result = XGetWindowProperty(mData->xDisplay, mData->mainXWindow, clipboardAtom,
+					0, bytesRemaining, False, AnyPropertyType, &actualType, &actualFormat, &length,
+					&unused, &data);
+
+			if(result == Success)
+				return UTF8::toWide(String((const char*)data));
+
+			XFree(data);
+		}
+
+		return L"";
+	}
+
+	WString Platform::keyCodeToUnicode(UINT32 keyCode)
+	{
+		// TODOPORT
+		return L"";
+	}
+
+	void Platform::_messagePump()
+	{
+		while(XPending(mData->xDisplay) > 0)
+		{
+			XEvent event;
+			XNextEvent(mData->xDisplay, &event);
+
+			switch (event.type)
+			{
+			case ClientMessage:
+			{
+				if(event.xclient.data.l[0] == mData->atomDeleteWindow)
+					XDestroyWindow(mData->xDisplay, event.xclient.window);
+			}
+				break;
+			case DestroyNotify:
+			{
+				auto iterFind = mData->windowMap.find(event.xdestroywindow.window);
+				if (iterFind == mData->windowMap.end())
+					break;
+
+				LinuxWindow* window = iterFind->second;
+				window->_cleanUp();
+
+				if(mData->mainXWindow == 0)
+					return;
+			}
+				break;
+			case KeyPress:
+			{
+				// Process text input
+				//// Check if input manager wants this event. If not, we process it.
+				if(!XFilterEvent(&event, None))
+				{
+					Status status;
+					uint8_t buffer[16];
+
+					int32_t length = Xutf8LookupString(mData->IC, &event.xkey, (char*)buffer, sizeof(buffer), nullptr,
+							&status);
+
+					if(length > 0)
+					{
+						buffer[length] = '\0';
+
+						// TODOPORT - Buffer now contains the UTF8 value of length 'length' bytes. I can consider converting
+						// it to single UTF32 before returning
+					}
+				}
+
+				// Process normal key press
+				{
+					static XComposeStatus keyboard;
+					uint8_t buffer[16];
+					KeySym symbol;
+					XLookupString(&event.xkey, (char*)buffer, sizeof(buffer), &symbol, &keyboard);
+
+					bool alt = event.xkey.state & Mod1Mask;
+					bool control = event.xkey.state & ControlMask;
+					bool shift = event.xkey.state & ShiftMask;
+
+					// TODOPORT - Report key press
+				}
+			}
+				break;
+			case KeyRelease:
+			{
+				uint8_t buffer[16];
+				KeySym symbol;
+				XLookupString(&event.xkey, (char *) buffer, sizeof(buffer), &symbol, nullptr);
+
+				bool alt = (event.xkey.state & Mod1Mask) != 0;
+				bool control = (event.xkey.state & ControlMask) != 0;
+				bool shift = (event.xkey.state & ShiftMask) != 0;
+
+				// TODOPORT - Report key release
+			}
+				break;
+			case ButtonPress:
+			{
+				uint32_t button = event.xbutton.button;
+				switch(button)
+				{
+					// Button 4 & 5 is vertical wheel, 6 & 7 horizontal wheel, and we handle them elsewhere
+				case Button1: // Left
+				case Button2: // Middle
+				case Button3: // Right
+				case 8:
+				case 9:
+					int32_t x = event.xbutton.x_root;
+					int32_t y = event.xbutton.y_root;
+
+					bool alt = (event.xbutton.state & Mod1Mask) != 0;
+					bool control = (event.xbutton.state & ControlMask) != 0;
+					bool shift = (event.xbutton.state & ShiftMask) != 0;
+
+					// TODOPORT - Report button press
+					break;
+				}
+
+				// Handle double-click
+				if(event.xbutton.time < (mData->lastButtonPressTime + DOUBLE_CLICK_MS))
+				{
+					// TODOPORT - Trigger double-click
+					mData->lastButtonPressTime = 0;
+				}
+				else
+					mData->lastButtonPressTime = event.xbutton.time;
+
+				// Handle window dragging for windows without a title bar
+				if(button == Button1)
+				{
+					auto iterFind = mData->windowMap.find(event.xbutton.window);
+					if (iterFind != mData->windowMap.end())
+					{
+						LinuxWindow* window = iterFind->second;
+						window->_dragStart(event.xbutton.x, event.xbutton.y);
+					}
+				}
+
+				break;
+			}
+			case ButtonRelease:
+			{
+				uint32_t button = event.xbutton.button;
+				bool alt = (event.xbutton.state & Mod1Mask) != 0;
+				bool control = (event.xbutton.state & ControlMask) != 0;
+				bool shift = (event.xbutton.state & ShiftMask) != 0;
+
+				switch(button)
+				{
+				case Button2: // Middle
+				case Button3: // Right
+				case 8:
+				case 9:
+				{
+					int32_t x = event.xbutton.x_root;
+					int32_t y = event.xbutton.y_root;
+
+					// TODOPORT - Report button release
+					break;
+				}
+				case Button4: // Vertical mouse wheel
+				case Button5:
+				{
+					int32_t delta = button == Button4 ? 1 : -1;
+
+					// TODOPORT - Send mouse wheel scroll
+				}
+					break;
+				case 6: // Horizontal mouse wheel
+				case 7:
+				{
+					int32_t delta = button == 6 ? 1 : -1;
+
+					// TODOPORT - Send mouse wheel scroll
+				}
+					break;
+				}
+
+				// Handle window dragging for windows without a title bar
+				if(button == Button1)
+				{
+					auto iterFind = mData->windowMap.find(event.xbutton.window);
+					if (iterFind != mData->windowMap.end())
+					{
+						LinuxWindow* window = iterFind->second;
+						window->_dragEnd();
+					}
+				}
+
+				break;
+			}
+			case MotionNotify:
+			{
+				Vector2I pos;
+				pos.x = event.xmotion.x_root;
+				pos.y = event.xmotion.y_root;
+
+				// Handle clipping if enabled
+				if(clipCursor(mData, pos))
+					setCursorPosition(pos);
+
+				// TODOPORT - Send mouse move event
+
+				// Handle window dragging for windows without a title bar
+				auto iterFind = mData->windowMap.find(event.xmotion.window);
+				if (iterFind != mData->windowMap.end())
+				{
+					LinuxWindow* window = iterFind->second;
+					window->_dragUpdate(event.xmotion.x, event.xmotion.y);
+				}
+			}
+				break;
+			case EnterNotify:
+				if(event.xcrossing.mode == NotifyNormal)
+				{
+					// TODOPORT - Send mouse enter event
+				}
+				break;
+			case LeaveNotify:
+				if(event.xcrossing.mode == NotifyNormal)
+				{
+					Vector2I pos;
+					pos.x = event.xcrossing.x_root;
+					pos.y = event.xcrossing.y_root;
+
+					if(clipCursor(mData, pos))
+						setCursorPosition(pos);
+
+					// TODOPORT - Send mouse leave event
+				}
+				break;
+			case ConfigureNotify:
+			{
+				const XConfigureEvent &xce = event.xconfigure;
+
+				auto iterFind = mData->windowMap.find(event.xdestroywindow.window);
+				if (iterFind == mData->windowMap.end())
+					break;
+
+				LinuxWindow* window = iterFind->second;
+				updateClipBounds(mData, window);
+
+				// TODOPORT - Send move/resize event
+			}
+				break;
+			case FocusIn:
+				// Update input context focus
+				XSetICFocus(mData->IC);
+				break;
+			case FocusOut:
+				// Update input context focus
+				XUnsetICFocus(mData->IC);
+				break;
+			case SelectionRequest:
+			{
+				// Send the data saved by the last clipboard copy operation
+				Atom compoundTextAtom = XInternAtom(mData->xDisplay, "COMPOUND_TEXT", 0);
+				Atom utf8StringAtom = XInternAtom(mData->xDisplay, "UTF8_STRING", 0);
+				Atom targetsAtom = XInternAtom(mData->xDisplay, "TARGETS", 0);
+
+				XSelectionRequestEvent& selReq = event.xselectionrequest;
+				XEvent response;
+				if(selReq.target == XA_STRING || selReq.target == compoundTextAtom || selReq.target == utf8StringAtom)
+				{
+					String utf8data = UTF8::fromWide(mData->clipboardData);
+
+					const uint8_t* data = (const uint8_t*)utf8data.c_str();
+					int32_t dataLength = utf8data.length();
+
+					XChangeProperty(mData->xDisplay, selReq.requestor, selReq.property,
+							selReq.target, 8, PropModeReplace, data, dataLength);
+
+					response.xselection.property = selReq.property;
+				}
+				else if(selReq.target == targetsAtom)
+				{
+					Atom data[2];
+					data[0] = utf8StringAtom;
+					data[1] = XA_STRING;
+					XChangeProperty (mData->xDisplay, selReq.requestor, selReq.property, selReq.target,
+							8, PropModeReplace, (unsigned char*)&data, sizeof (data));
+
+					response.xselection.property = selReq.property;
+				}
+				else
+				{
+					response.xselection.property = None;
+				}
+
+				response.xselection.type = SelectionNotify;
+				response.xselection.display = selReq.display;
+				response.xselection.requestor = selReq.requestor;
+				response.xselection.selection = selReq.selection;
+				response.xselection.target = selReq.target;
+				response.xselection.time = selReq.time;
+
+				XSendEvent (mData->xDisplay, selReq.requestor, 0, 0, &response);
+				XFlush (mData->xDisplay);
+			}
+				break;
+			default:
+				break;
+			}
+		}
+	}
+
+	void Platform::_startUp()
+	{
+		// XInitThreads(); // TODO: Not sure if this will be necessary
+		mData->xDisplay = XOpenDisplay(nullptr);
+
+		if(XSupportsLocale())
+		{
+			XSetLocaleModifiers("");
+			mData->IM = XOpenIM(mData->xDisplay, nullptr, nullptr, nullptr);
+
+			// Note: Currently our windows don't support pre-edit and status areas, which are used for more complex types
+			// of character input. Later on it might be beneficial to support them.
+			mData->IC = XCreateIC(mData->IM, XNInputStyle, XIMPreeditNothing | XIMStatusNothing, nullptr);
+		}
+
+		mData->atomDeleteWindow = XInternAtom(mData->xDisplay, "WM_DELETE_WINDOW", False);
+
+		// Create empty cursor
+		char data[1];
+		memset(data, 0, sizeof(data));
+
+		Pixmap pixmap = XCreateBitmapFromData(mData->xDisplay, DefaultRootWindow(mData->xDisplay), data, 1, 1);
+
+		XColor color;
+		color.red = color.green = color.blue = 0;
+		mData->emptyCursor = XCreatePixmapCursor(mData->xDisplay, pixmap, pixmap, &color, &color, 0, 0);
+
+		XFreePixmap(mData->xDisplay, pixmap);
+	}
+
+	void Platform::_update()
+	{
+		// Do nothing
+	}
+
+	void Platform::_coreUpdate()
+	{
+		_messagePump();
+	}
+
+	void Platform::_shutDown()
+	{
+		// Free empty cursor
+		XFreeCursor(mData->xDisplay, mData->emptyCursor);
+		mData->emptyCursor = None;
+
+		if(mData->IC)
+		{
+			XDestroyIC(mData->IC);
+			mData->IC = 0;
+		}
+
+		if(mData->IM)
+		{
+			XCloseIM(mData->IM);
+			mData->IM = 0;
+		}
+
+		XCloseDisplay(mData->xDisplay);
+		mData->xDisplay = nullptr;
+
+		bs_delete(mData);
+		mData = nullptr;
+	}
+
+	::Display* LinuxPlatform::getXDisplay()
+	{
+		return mData->xDisplay;
+	}
+
+	::Window LinuxPlatform::getMainXWindow()
+	{
+		return mData->mainXWindow;
+	}
+
+	void LinuxPlatform::_registerWindow(::Window xWindow, LinuxWindow* window)
+	{
+		// First window is assumed to be the main
+		if(mData->mainXWindow == 0)
+		{
+			mData->mainXWindow = xWindow;
+
+			// Input context client window must be set before use
+			XSetICValues(mData->IC,
+					XNClientWindow, xWindow,
+					XNFocusWindow, xWindow,
+					nullptr);
+		}
+
+		mData->windowMap[xWindow] = window;
+
+		applyCurrentCursor(mData, xWindow);
+	}
+
+	void LinuxPlatform::_unregisterWindow(::Window xWindow)
+	{
+		auto iterFind = mData->windowMap.find(xWindow);
+		if(iterFind != mData->windowMap.end())
+		{
+			if(mData->cursorClipEnabled && mData->cursorClipWindow == iterFind->second)
+				clipCursorDisable();
+
+			mData->windowMap.erase(iterFind);
+		}
+
+		if(mData->mainXWindow == xWindow)
+			mData->mainXWindow = 0;
+	}
+
+	Pixmap LinuxPlatform::createPixmap(const SPtr<PixelData>& data)
+	{
+		SPtr<PixelData> bgraData = PixelData::create(data->getWidth(), data->getHeight(), 1, PF_BGRA8);
+		PixelUtil::bulkPixelConversion(*data, *bgraData);
+
+		uint32_t depth = XDefaultDepth(mData->xDisplay, 0);
+		XImage* image = XCreateImage(mData->xDisplay, XDefaultVisual(mData->xDisplay, 0), depth, ZPixmap, 0,
+				(char*)bgraData->getData(), data->getWidth(), data->getHeight(), 32, 0);
+
+		Pixmap pixmap = XCreatePixmap(mData->xDisplay, XDefaultRootWindow(mData->xDisplay),
+				data->getWidth(), data->getHeight(), depth);
+
+		XGCValues gcValues;
+		GC gc = XCreateGC(mData->xDisplay, pixmap, 0, &gcValues);
+		XPutImage(mData->xDisplay, pixmap, gc, image, 0, 0, 0, 0, data->getWidth(), data->getHeight());
+		XFreeGC(mData->xDisplay, gc);
+
+		// Make sure XDestroyImage doesn't free the data pointed to by 'data.bytes'
+		image->data = nullptr;
+		XDestroyImage(image);
+
+		return pixmap;
+	}
+}

Source/BansheeCore/Unix/BsUnixPlatform.h

@@ -0,0 +1,46 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include "Platform/BsPlatform.h"
+
+namespace bs
+{
+	class LinuxWindow;
+
+	/** @addtogroup Platform-Internal
+	 *  @{
+	 */
+
+	/**
+	 * Contains various Linux specific platform functionality;
+	 */
+	class BS_CORE_EXPORT LinuxPlatform : public Platform
+	{
+	public:
+		/** Returns the active X11 display. */
+		static ::Display* getXDisplay();
+
+		/** Returns the main X11 window. Caller must ensure the main window has been created. */
+		static ::Window getMainXWindow();
+
+		/** Notifies the system that a new window was created. */
+		static void _registerWindow(::Window xWindow, LinuxWindow* window);
+
+		/** Notifies the system that a window is about to be destroyed. */
+		static void _unregisterWindow(::Window xWindow);
+
+		/** Generates a X11 Pixmap from the provided pixel data. */
+		static Pixmap createPixmap(const SPtr<PixelData>& data);
+	};
+
+	/** @} */
+}
+
+// Undefine conflicting defines from X.h
+#undef None
+#undef Success
+#undef Convex
+#undef Bool

Source/BansheeCore/Unix/BsUnixWindow.cpp

@@ -0,0 +1,531 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsUnixWindow.h"
+#include "BsUnixPlatform.h"
+#include "Math/BsRect2I.h"
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <X11/extensions/Xrandr.h>
+
+#define _NET_WM_STATE_REMOVE 0
+#define _NET_WM_STATE_ADD 1
+#define _NET_WM_STATE_TOGGLE 2
+
+#define WM_NormalState 1
+#define WM_IconicState 3
+
+namespace bs
+{
+	enum class WindowState
+	{
+		Minimized,
+		Maximized,
+		Normal
+	};
+
+	struct LinuxWindow::Pimpl
+	{
+		::Window xWindow = 0;
+
+		INT32 x, y;
+		UINT32 width, height;
+		bool hasTitleBar = true;
+		bool dragInProgress = false;
+		bool resizeDisabled = false;
+		WindowState state = WindowState::Normal;
+
+		Rect2I dragZone;
+		int32_t dragStartX, dragStartY;
+	};
+
+	LinuxWindow::LinuxWindow(const WINDOW_DESC &desc)
+	{
+		::Display* display = LinuxPlatform::getXDisplay();
+
+		int screen;
+		if(desc.screen == (UINT32)-1)
+			screen = XDefaultScreen(display);
+		else
+			screen = std::min((int)desc.screen, XScreenCount(display));
+
+		XSetWindowAttributes attributes;
+		attributes.background_pixel = XWhitePixel(display, screen);
+		attributes.border_pixel = XBlackPixel(display, screen);
+
+		attributes.colormap = XCreateColormap(display,
+				XRootWindow(display, desc.visualInfo.screen),
+				desc.visualInfo.visual,
+				AllocNone);
+
+		uint32_t borderWidth = 0;
+
+		m->x = desc.x;
+		m->y = desc.y;
+		m->width = desc.width;
+		m->height = desc.height;
+		m->xWindow = XCreateWindow(display,
+				XRootWindow(display, desc.visualInfo.screen),
+				desc.x, desc.y,
+				desc.width, desc.height,
+				borderWidth, desc.visualInfo.depth,
+				InputOutput, desc.visualInfo.visual,
+				CWBackPixel | CWBorderPixel | CWColormap, &attributes);
+
+		XStoreName(display, m->xWindow, desc.title.c_str());
+
+		XSizeHints hints;
+		hints.flags = PPosition | PSize;
+		hints.x = desc.x;
+		hints.y = desc.y;
+		hints.width = desc.width;
+		hints.height = desc.height;
+
+		if(!desc.allowResize)
+		{
+			hints.flags |= PMinSize | PMaxSize;
+
+			hints.min_height = desc.height;
+			hints.max_height = desc.height;
+
+			hints.min_width = desc.width;
+			hints.max_width = desc.width;
+		}
+
+		XSetNormalHints(display, m->xWindow, &hints);
+
+		setShowDecorations(desc.showDecorations);
+		setIsModal(desc.modal);
+
+		// Ensures the child window is always on top of the parent window
+		if(desc.parent)
+			XSetTransientForHint(display, m->xWindow, desc.parent);
+
+		XSelectInput(display, m->xWindow,
+				ExposureMask | FocusChangeMask |
+				KeyPressMask | KeyReleaseMask |
+				ButtonPressMask | ButtonReleaseMask |
+				EnterWindowMask | LeaveWindowMask |
+				PointerMotionMask | ButtonMotionMask |
+				StructureNotifyMask
+		);
+		XMapWindow(display, m->xWindow);
+
+		// Make sure we get the window delete message from WM, so we can clean up ourselves
+		Atom atomDeleteWindow = XInternAtom(display, "WM_DELETE_WINDOW", False);
+		XSetWMProtocols(display, m->xWindow, &atomDeleteWindow, 1);
+
+		// Set background image if assigned
+		if(desc.background)
+		{
+			Pixmap pixmap = LinuxPlatform::createPixmap(desc.background);
+			XSetWindowBackgroundPixmap(display, m->xWindow, pixmap);
+			XFreePixmap(display, pixmap);
+		}
+
+		m->hasTitleBar = desc.showDecorations;
+		m->resizeDisabled = !desc.allowResize;
+
+		LinuxPlatform::_registerWindow(m->xWindow, this);
+	}
+
+	LinuxWindow::~LinuxWindow()
+	{
+		if(m->xWindow != 0)
+			_cleanUp();
+	}
+
+	void LinuxWindow::close()
+	{
+		XDestroyWindow(LinuxPlatform::getXDisplay(), m->xWindow);
+		XFlush(LinuxPlatform::getXDisplay());
+
+		_cleanUp();
+	}
+
+	void LinuxWindow::move(INT32 x, INT32 y)
+	{
+		m->x = x;
+		m->y = y;
+
+		XMoveWindow(LinuxPlatform::getXDisplay(), m->xWindow, x, y);
+	}
+
+	void LinuxWindow::resize(UINT32 width, UINT32 height)
+	{
+		// If resize is disabled on WM level, we need to force it
+		if(m->resizeDisabled)
+		{
+			XSizeHints hints;
+			hints.flags = PMinSize | PMaxSize;
+
+			hints.min_height = height;
+			hints.max_height = height;
+
+			hints.min_width = width;
+			hints.max_width = width;
+
+			XSetNormalHints(LinuxPlatform::getXDisplay(), m->xWindow, &hints);
+		}
+
+		m->width = width;
+		m->height = height;
+
+		XResizeWindow(LinuxPlatform::getXDisplay(), m->xWindow, width, height);
+	}
+
+	void LinuxWindow::hide()
+	{
+		// TODOPORT - Need to track all states so I can restore them on show()
+
+		XUnmapWindow(LinuxPlatform::getXDisplay(), m->xWindow);
+	}
+
+	void LinuxWindow::show()
+	{
+		XMapWindow(LinuxPlatform::getXDisplay(), m->xWindow);
+		XMoveResizeWindow(LinuxPlatform::getXDisplay(), m->xWindow, m->x, m->y, m->width, m->height);
+
+		// TODOPORT - Restore all states (pos, size and style)
+	}
+
+	void LinuxWindow::maximize()
+	{
+		maximize(true);
+	}
+
+	void LinuxWindow::minimize()
+	{
+		minimize(true);
+	}
+
+	void LinuxWindow::restore()
+	{
+		if(isMaximized())
+			maximize(false);
+		else if(isMinimized())
+			minimize(false);
+	}
+
+	INT32 LinuxWindow::getLeft() const
+	{
+		INT32 x, y;
+		::Window child;
+		XTranslateCoordinates(LinuxPlatform::getXDisplay(), m->xWindow, DefaultRootWindow(LinuxPlatform::getXDisplay()),
+				0, 0, &x, &y, &child);
+
+		return x;
+	}
+
+	INT32 LinuxWindow::getTop() const
+	{
+		INT32 x, y;
+		::Window child;
+		XTranslateCoordinates(LinuxPlatform::getXDisplay(), m->xWindow, DefaultRootWindow(LinuxPlatform::getXDisplay()),
+				0, 0, &x, &y, &child);
+
+		return y;
+	}
+
+	UINT32 LinuxWindow::getWidth() const
+	{
+		XWindowAttributes xwa;
+		XGetWindowAttributes(LinuxPlatform::getXDisplay(), m->xWindow, &xwa);
+
+		return xwa.width;
+	}
+
+	UINT32 LinuxWindow::getHeight() const
+	{
+		XWindowAttributes xwa;
+		XGetWindowAttributes(LinuxPlatform::getXDisplay(), m->xWindow, &xwa);
+
+		return xwa.height;
+	}
+
+	Vector2I LinuxWindow::windowToScreenPos(const Vector2I& windowPos) const
+	{
+		Vector2I screenPos;
+
+		::Window child;
+		XTranslateCoordinates(LinuxPlatform::getXDisplay(), m->xWindow, DefaultRootWindow(LinuxPlatform::getXDisplay()),
+				windowPos.x, windowPos.y, &screenPos.x, &screenPos.y, &child);
+
+		return screenPos;
+	}
+
+	Vector2I LinuxWindow::screenToWindowPos(const Vector2I& screenPos) const
+	{
+		Vector2I windowPos;
+
+		::Window child;
+		XTranslateCoordinates(LinuxPlatform::getXDisplay(), DefaultRootWindow(LinuxPlatform::getXDisplay()), m->xWindow,
+				screenPos.x, screenPos.y, &windowPos.x, &windowPos.y, &child);
+
+		return windowPos;
+	}
+
+	void LinuxWindow::setIcon(const SPtr<PixelData>& data)
+	{
+		Pixmap iconPixmap = LinuxPlatform::createPixmap(data);
+
+		XWMHints* hints = XAllocWMHints();
+		hints->flags = IconPixmapHint;
+		hints->icon_pixmap = iconPixmap;
+
+		XSetWMHints(LinuxPlatform::getXDisplay(), m->xWindow, hints);
+		XFlush(LinuxPlatform::getXDisplay());
+
+		XFree(hints);
+		XFreePixmap(LinuxPlatform::getXDisplay(), iconPixmap);
+	}
+
+	void LinuxWindow::_cleanUp()
+	{
+		LinuxPlatform::_unregisterWindow(m->xWindow);
+		m->xWindow = 0;
+	}
+
+	bool LinuxWindow::_dragStart(int32_t x, int32_t y)
+	{
+		if(m->hasTitleBar)
+			return false;
+
+		if(m->dragZone.width == 0 || m->dragZone.height == 0)
+			return false;
+
+		if(x >= m->dragZone.x && x < (m->dragZone.x + m->dragZone.width) &&
+		   y >= m->dragZone.y && y < (m->dragZone.y + m->dragZone.height))
+		{
+			m->dragStartX = x;
+			m->dragStartY = y;
+
+			m->dragInProgress = true;
+			return true;
+		}
+
+		return false;
+	}
+
+	void LinuxWindow::_dragUpdate(int32_t x, int32_t y)
+	{
+		if(!m->dragInProgress)
+			return;
+
+		int32_t offsetX = x - m->dragStartX;
+		int32_t offsetY = y - m->dragStartY;
+
+		move(getLeft() + offsetX, getTop() + offsetY);
+	}
+
+	void LinuxWindow::_dragEnd()
+	{
+		m->dragInProgress = false;
+	}
+
+	::Window LinuxWindow::_getXWindow() const
+	{
+		return m->xWindow;
+	}
+
+	bool LinuxWindow::isMaximized() const
+	{
+		Atom wmState = XInternAtom(LinuxPlatform::getXDisplay(), "_NET_WM_STATE", False);
+		Atom type;
+		int32_t format;
+		uint64_t length;
+		uint64_t remaining;
+		uint8_t* data = nullptr;
+
+		int32_t result = XGetWindowProperty(LinuxPlatform::getXDisplay(), m->xWindow, wmState,
+				0, 1024, False, XA_ATOM, &type, &format,
+				&length, &remaining, &data);
+
+		if (result == Success)
+		{
+			Atom* atoms = (Atom*)data;
+			Atom wmMaxHorz = XInternAtom(LinuxPlatform::getXDisplay(), "_NET_WM_STATE_MAXIMIZED_HORZ", False);
+			Atom wmMaxVert = XInternAtom(LinuxPlatform::getXDisplay(), "_NET_WM_STATE_MAXIMIZED_VERT", False);
+
+			bool foundHorz = false;
+			bool foundVert = false;
+			for (uint64_t i = 0; i < length; i++)
+			{
+				if (atoms[i] == wmMaxHorz)
+					foundHorz = true;
+				if (atoms[i] == wmMaxVert)
+					foundVert = true;
+
+				if (foundVert && foundHorz)
+					return true;
+			}
+
+			XFree(atoms);
+		}
+
+		return false;
+	}
+
+	bool LinuxWindow::isMinimized()
+	{
+		Atom wmState = XInternAtom(LinuxPlatform::getXDisplay(), "WM_STATE", True);
+		Atom type;
+		int32_t format;
+		uint64_t length;
+		uint64_t remaining;
+		uint8_t* data = nullptr;
+
+		int32_t result = XGetWindowProperty(LinuxPlatform::getXDisplay(), m->xWindow, wmState,
+				0, 1024, False, AnyPropertyType, &type, &format,
+				&length, &remaining, &data);
+
+		if(result == Success)
+		{
+			long* state = (long*) data;
+			if(state[0] == WM_IconicState)
+				return true;
+		}
+
+		return false;
+	}
+
+	void LinuxWindow::maximize(bool enable)
+	{
+		Atom wmState = XInternAtom(LinuxPlatform::getXDisplay(), "_NET_WM_STATE", False);
+		Atom wmMaxHorz = XInternAtom(LinuxPlatform::getXDisplay(), "_NET_WM_STATE_MAXIMIZED_HORZ", False);
+		Atom wmMaxVert = XInternAtom(LinuxPlatform::getXDisplay(), "_NET_WM_STATE_MAXIMIZED_VERT", False);
+
+		XEvent xev;
+		memset(&xev, 0, sizeof(xev));
+		xev.type = ClientMessage;
+		xev.xclient.window = m->xWindow;
+		xev.xclient.message_type = wmState;
+		xev.xclient.format = 32;
+		xev.xclient.data.l[0] = enable ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
+		xev.xclient.data.l[1] = wmMaxHorz;
+		xev.xclient.data.l[2] = wmMaxVert;
+
+		XSendEvent(LinuxPlatform::getXDisplay(), DefaultRootWindow(LinuxPlatform::getXDisplay()), False,
+				SubstructureRedirectMask | SubstructureNotifyMask, &xev);
+	}
+
+	void LinuxWindow::minimize(bool enable)
+	{
+		XEvent xev;
+		Atom wmChange = XInternAtom(LinuxPlatform::getXDisplay(), "WM_CHANGE_STATE", False);
+
+		memset(&xev, 0, sizeof(xev));
+		xev.type = ClientMessage;
+		xev.xclient.window = m->xWindow;
+		xev.xclient.message_type = wmChange;
+		xev.xclient.format = 32;
+		xev.xclient.data.l[0] = enable ? WM_IconicState : WM_NormalState;
+
+		XSendEvent(LinuxPlatform::getXDisplay(), DefaultRootWindow(LinuxPlatform::getXDisplay()), False,
+				SubstructureRedirectMask | SubstructureNotifyMask, &xev);
+	}
+
+	void LinuxWindow::_setFullscreen(bool fullscreen)
+	{
+		// Attempt to bypass compositor if switching to fullscreen
+		if(fullscreen)
+		{
+			Atom wmBypassCompositor = XInternAtom(LinuxPlatform::getXDisplay(), "_NET_WM_BYPASS_COMPOSITOR", False);
+			if (wmBypassCompositor)
+			{
+				static constexpr uint32_t enabled = 1;
+
+				XChangeProperty(LinuxPlatform::getXDisplay(), m->xWindow, wmBypassCompositor,
+						XA_CARDINAL, 32, PropModeReplace, (unsigned char*) &enabled, 1);
+			}
+		}
+
+		// Make the switch to fullscreen
+		XEvent xev;
+		Atom wmState = XInternAtom(LinuxPlatform::getXDisplay(), "_NET_WM_STATE", False);
+		Atom wmFullscreen = XInternAtom(LinuxPlatform::getXDisplay(), "_NET_WM_STATE_FULLSCREEN", False);
+
+		memset(&xev, 0, sizeof(xev));
+		xev.type = ClientMessage;
+		xev.xclient.window = m->xWindow;
+		xev.xclient.message_type = wmState;
+		xev.xclient.format = 32;
+		xev.xclient.data.l[0] = fullscreen ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
+		xev.xclient.data.l[1] = wmFullscreen;
+		xev.xclient.data.l[2] = 0;
+
+		XSendEvent(LinuxPlatform::getXDisplay(), DefaultRootWindow(LinuxPlatform::getXDisplay()), False,
+				SubstructureRedirectMask | SubstructureNotifyMask, &xev);
+	}
+
+	void LinuxWindow::setShowDecorations(bool show)
+	{
+		static constexpr uint32_t MWM_HINTS_FUNCTIONS		= (1 << 0);
+		static constexpr uint32_t MWM_HINTS_DECORATIONS		= (1 << 1);
+
+		static constexpr uint32_t MWM_DECOR_BORDER			= (1 << 1);
+		static constexpr uint32_t MWM_DECOR_RESIZEH			= (1 << 2);
+		static constexpr uint32_t MWM_DECOR_TITLE			= (1 << 3);
+		static constexpr uint32_t MWM_DECOR_MENU			= (1 << 4);
+		static constexpr uint32_t MWM_DECOR_MINIMIZE		= (1 << 5);
+		static constexpr uint32_t MWM_DECOR_MAXIMIZE		= (1 << 6);
+
+		static constexpr uint32_t MWM_FUNC_RESIZE			= (1 << 1);
+		static constexpr uint32_t MWM_FUNC_MOVE				= (1 << 2);
+		static constexpr uint32_t MWM_FUNC_MINIMIZE			= (1 << 3);
+		static constexpr uint32_t MWM_FUNC_MAXIMIZE			= (1 << 4);
+		static constexpr uint32_t MWM_FUNC_CLOSE			= (1 << 5);
+
+		struct MotifHints
+		{
+			uint32_t       flags;
+			uint32_t       functions;
+			uint32_t       decorations;
+			int32_t        inputMode;
+			uint32_t       status;
+		};
+
+		if(show)
+			return;
+
+		MotifHints motifHints;
+		motifHints.flags = MWM_HINTS_DECORATIONS;
+		motifHints.decorations = 0;
+		motifHints.functions = 0;
+		motifHints.inputMode = 0;
+		motifHints.status = 0;
+
+		Atom wmHintsAtom = XInternAtom(LinuxPlatform::getXDisplay(), "_MOTIF_WM_HINTS", False);
+		XChangeProperty(LinuxPlatform::getXDisplay(), m->xWindow,
+				wmHintsAtom, wmHintsAtom,
+				32,
+				PropModeReplace,
+				(unsigned char *)&motifHints,
+				5);
+	}
+
+	void LinuxWindow::setIsModal(bool modal)
+	{
+		if(modal)
+		{
+			Atom wmState = XInternAtom(LinuxPlatform::getXDisplay(), "_NET_WM_STATE", False);
+			Atom wmValue = XInternAtom(LinuxPlatform::getXDisplay(), "_NET_WM_STATE_MODAL", False);
+
+			XEvent xev;
+			memset(&xev, 0, sizeof(xev));
+			xev.type = ClientMessage;
+			xev.xclient.window = m->xWindow;
+			xev.xclient.message_type = wmState;
+			xev.xclient.format = 32;
+			xev.xclient.data.l[0] = _NET_WM_STATE_ADD;
+			xev.xclient.data.l[1] = wmValue;
+			xev.xclient.data.l[2] = 0;
+			xev.xclient.data.l[3] = 1;
+
+			XSendEvent(LinuxPlatform::getXDisplay(), DefaultRootWindow(LinuxPlatform::getXDisplay()), False,
+					SubstructureRedirectMask | SubstructureNotifyMask, &xev);
+		}
+	}
+}
+

Source/BansheeCore/Unix/BsUnixWindow.h

@@ -0,0 +1,166 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "Prerequisites/BsPrerequisitesUtil.h"
+#include "Math/BsVector2I.h"
+#include <X11/X.h>
+#include <X11/Xutil.h>
+
+namespace bs
+{
+	/** @addtogroup Internal-Utility
+	 *  @{
+	 */
+
+	/** @addtogroup Platform-Utility-Internal
+	 *  @{
+	 */
+
+	/**	Descriptor used for creating a platform specific native window. */
+	struct WINDOW_DESC
+	{
+		INT32 x, y;
+		UINT32 width, height;
+		UINT32 screen;
+		String title;
+		bool showDecorations;
+		bool allowResize;
+		bool modal;
+		::Window parent;
+		XVisualInfo visualInfo;
+		SPtr<PixelData> background;
+	};
+
+	/**	Represents a X11 window. */
+	class BS_UTILITY_EXPORT LinuxWindow
+	{
+	public:
+		LinuxWindow(const WINDOW_DESC& desc);
+		~LinuxWindow();
+
+		/**	Returns position of the left-most border of the window, relative to the screen. */
+		INT32 getLeft() const;
+
+		/**	Returns position of the top-most border of the window, relative to the screen. */
+		INT32 getTop() const;
+
+		/**	Returns width of the window in pixels. */
+		UINT32 getWidth() const;
+
+		/**	Returns height of the window in pixels. */
+		UINT32 getHeight() const;
+
+		/** Hides the window. */
+		void hide();
+
+		/** Shows (unhides) the window. */
+		void show();
+
+		/**	Minimizes the window. */
+		void minimize();
+
+		/**	Maximizes the window over the entire current screen. */
+		void maximize();
+
+		/**	Restores the window to original position and size if it is minimized or maximized. */
+		void restore();
+
+		/** Closes the window. Window becomes unusable past this call. */
+		void close();
+
+		/**	Change the size of the window. */
+		void resize(UINT32 width, UINT32 height);
+
+		/**	Reposition the window. */
+		void move(INT32 left, INT32 top);
+
+		/** Sets the icon to display for the window. */
+		void setIcon(const SPtr<PixelData>& icon);
+
+		/**	Converts screen position into window local position. */
+		Vector2I screenToWindowPos(const Vector2I& screenPos) const;
+
+		/**	Converts window local position to screen position. */
+		Vector2I windowToScreenPos(const Vector2I& windowPos) const;
+
+		/**
+		 * @name Internal
+		 * @{
+		 */
+
+		/** Unregisters the window from the manager. Should be called before the window is destroyed. */
+		void _cleanUp();
+
+		/**
+		 * Sets a portion of the window in which the user can click and drag in order to move the window. This is needed
+		 * when window has no title bar, yet you still want to allow the user to drag it by clicking on some specific area
+		 * (e.g. a title bar you manually render).
+		 *
+		 * @param[in]	rect	Area of the window (relative to the window origin in top-left corner) in which the drag
+		 * 						operation in allowed.
+		 */
+		void _setDragZone(const Rect2I& rect);
+
+		/**
+		 * Notifies the window that user has started dragging the window using the custom drag zone. Provided coordinates
+		 * specify the location of the drag start. They are relative to the window top left origin.
+		 */
+		bool _dragStart(int32_t x, int32_t y);
+
+		/**
+		 * Notifies the window that the user has moved the cursor while dragging the window. The provided coordinates are
+		 * relative to the window top left origin.
+		 */
+		void _dragUpdate(int32_t x, int32_t y);
+
+		/** Notifies the window the user has stopped the window drag operation. */
+		void _dragEnd();
+
+		/** Returns the internal X11 window handle. */
+		::Window _getXWindow() const;
+
+		/** Toggles between fullscreen and windowed mode. */
+		void _setFullscreen(bool fullscreen);
+
+		/** @} */
+
+	private:
+		/** Checks if the window is currently maximized. */
+		bool isMaximized() const;
+
+		/** Checks if the window is currently minimized (iconified). */
+		bool isMinimized();
+
+		/**
+		 * Maximizes a window if @p enable is true. If false restores the window to size/position before maximization
+		 * occurred.
+		 */
+		void maximize(bool enable);
+
+		/**
+		 * Minimizes a window if @p enable is true. If false restores the window to size/position before minimization
+		 * occurred.
+		 */
+		void minimize(bool enable);
+
+		/**
+		 * Shows or hides window decorations. Decorations include window title bar, border and similar. Essentially anything
+		 * not part of the main rendering area.
+		 */
+		void setShowDecorations(bool show);
+
+		/**
+		 * Switches the window between modal and normal mode. Modal window prevents input to their parent window until
+		 * it is dismissed.
+		 */
+		void setIsModal(bool modal);
+
+		struct Pimpl;
+		Pimpl* m;
+	};
+
+	/** @} */
+	/** @} */
+}
+

Source/BansheeCore/Win32/BsWin32Platform.cpp

@@ -303,6 +303,71 @@ namespace bs
 		BS_PVT_DELETE(OSDropTarget, &target);
 	}
 
+	void Platform::copyToClipboard(const WString& string)
+	{
+		HANDLE hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, (string.size() + 1) * sizeof(WString::value_type));
+		WString::value_type* buffer = (WString::value_type*)GlobalLock(hData);
+
+		string.copy(buffer, string.size());
+		buffer[string.size()] = '\0';
+
+		GlobalUnlock(hData);
+
+		if (OpenClipboard(NULL))
+		{
+			EmptyClipboard();
+			SetClipboardData(CF_UNICODETEXT, hData);
+			CloseClipboard();
+		}
+		else
+		{
+			GlobalFree(hData);
+		}
+	}
+
+	WString Platform::copyFromClipboard()
+	{
+		if (OpenClipboard(NULL))
+		{
+			HANDLE hData = GetClipboardData(CF_UNICODETEXT);
+
+			if (hData != NULL)
+			{
+				WString::value_type* buffer = (WString::value_type*)GlobalLock(hData);
+				WString string(buffer);
+				GlobalUnlock(hData);
+
+				CloseClipboard();
+				return string;
+			}
+			else
+			{
+				CloseClipboard();
+				return L"";
+			}
+		}
+
+		return L"";
+	}
+
+	WString Platform::keyCodeToUnicode(UINT32 keyCode)
+	{
+		static HKL keyboardLayout = GetKeyboardLayout(0);
+		static UINT8 keyboarState[256];
+
+		if (GetKeyboardState(keyboarState) == FALSE)
+			return 0;
+
+		UINT virtualKey = MapVirtualKeyExW(keyCode, 1, keyboardLayout);
+
+		wchar_t output[2];
+		int count = ToUnicodeEx(virtualKey, keyCode, keyboarState, output, 2, 0, keyboardLayout);
+		if (count > 0)
+			return WString(output, count);
+
+		return StringUtil::WBLANK;
+	}
+
 	void Platform::_messagePump()
 	{
 		MSG  msg;

Source/BansheeEditor/Handles/BsHandleSliderPlane.cpp

@@ -11,8 +11,8 @@
 namespace bs
 {
 	HandleSliderPlane::HandleSliderPlane(const Vector3& dir1, const Vector3& dir2, float length, bool fixedScale, UINT64 layer)
-		: HandleSlider(fixedScale, layer), mDirection1(Vector3::normalize(dir1)), mLength(length)
-		, mDirection2(Vector3::normalize(dir2)), mDelta(BsZero), mStartPlanePosition(BsZero), mStartClickPosition(BsZero)
+		: HandleSlider(fixedScale, layer), mDirection1(Vector3::normalize(dir1)), mDirection2(Vector3::normalize(dir2))
+		, mLength(length), mDelta(BsZero), mStartPlanePosition(BsZero), mStartClickPosition(BsZero)
 	{
 		float halfLength = length * 0.5f;
 		std::array<Vector3, 2> axes = {{ mDirection1, mDirection2 }};

Source/BansheeEditor/Library/BsProjectLibrary.cpp

@@ -1045,7 +1045,6 @@ namespace bs
 		}
 
 		// Both source and destination are within Resources folder, need to preserve import options on the copies
-		LibraryEntry* newEntry = nullptr;
 		if (FileSystem::isFile(newFullPath))
 		{
 			assert(oldEntry->type == LibraryEntryType::File);
@@ -1055,7 +1054,7 @@ namespace bs
 			if (oldResEntry->meta != nullptr)
 				importOptions = oldResEntry->meta->getImportOptions();
 
-			newEntry = addResourceInternal(newEntryParent, newFullPath, importOptions, true);
+			addResourceInternal(newEntryParent, newFullPath, importOptions, true);
 		}
 		else
 		{
@@ -1063,7 +1062,6 @@ namespace bs
 			DirectoryEntry* oldDirEntry = static_cast<DirectoryEntry*>(oldEntry);
 
 			DirectoryEntry* newDirEntry = addDirectoryInternal(newEntryParent, newFullPath);
-			newEntry = newDirEntry;
 
 			Stack<std::tuple<DirectoryEntry*, DirectoryEntry*>> todo;
 			todo.push(std::make_tuple(oldDirEntry, newDirEntry));

Source/BansheeEditor/SceneView/BsScenePicking.cpp

@@ -104,7 +104,7 @@ namespace bs
 				continue;
 
 			bool found = false;
-			for (int i = 0; i < ignoreRenderables.size(); i++)
+			for (UINT32 i = 0; i < (UINT32)ignoreRenderables.size(); i++)
 			{
 				if (ignoreRenderables[i] == so)
 				{

Source/BansheeEngine/GUI/BsShortcutKey.cpp

@@ -9,7 +9,7 @@ namespace bs
 {
 	const ShortcutKey ShortcutKey::NONE = ShortcutKey();
 
-	inline size_t ShortcutKey::Hash::operator()(const ShortcutKey& x) const
+	size_t ShortcutKey::Hash::operator()(const ShortcutKey& x) const
 	{
 		size_t seed = 0;
 		hash_combine(seed, (UINT32)x.button);
@@ -18,7 +18,7 @@ namespace bs
 		return seed;
 	}
 
-	inline bool ShortcutKey::Equals::operator()(const ShortcutKey& a, const ShortcutKey& b) const
+	bool ShortcutKey::Equals::operator()(const ShortcutKey& a, const ShortcutKey& b) const
 	{
 		return a.button == b.button && a.modifier == b.modifier;
 	}

Source/BansheeGLRenderAPI/BsGLSupport.cpp

@@ -8,38 +8,36 @@ GLenum GLEWAPIENTRY glewContextInit(bs::ct::GLSupport* glSupport);
 
 namespace bs { namespace ct
 {
-    void GLSupport::initializeExtensions()
-    {
+	void GLSupport::initializeExtensions()
+	{
 		glewContextInit(this);
 		glGetError();
 
-        // Set version string
-        const GLubyte* pcVer = glGetString(GL_VERSION);
-        assert(pcVer && "Problems getting GL version string using glGetString");
-       
-        String tmpStr = (const char*)pcVer;
-        mVersion = tmpStr.substr(0, tmpStr.find(" "));
+		// Set version string
+		const GLubyte* pcVer = glGetString(GL_VERSION);
+		assert(pcVer && "Problems getting GL version string using glGetString");
 
-        // Get vendor
-        const GLubyte* pcVendor = glGetString(GL_VENDOR);
+		String tmpStr = (const char*)pcVer;
+		mVersion = tmpStr.substr(0, tmpStr.find(" "));
+
+		// Get vendor
+		const GLubyte* pcVendor = glGetString(GL_VENDOR);
 		tmpStr = (const char*)pcVendor;
-        mVendor = tmpStr.substr(0, tmpStr.find(" "));
+		mVendor = tmpStr.substr(0, tmpStr.find(" "));
 
-        // Set extension list
-		int numExtensions = 0;
+		// Set extension list
+		INT32 numExtensions = 0;
 		glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions);
 
-		for (int i = 0; i < numExtensions; i++)
-		{
+		for (INT32 i = 0; i < numExtensions; i++)
 			extensionList.insert(String((char*)glGetStringi(GL_EXTENSIONS, i)));
-		}
-    }
-
-    bool GLSupport::checkExtension(const String& ext) const
-    {
-        if(extensionList.find(ext) == extensionList.end())
-            return false; 
-        
-        return true;
-    }
+	}
+
+	bool GLSupport::checkExtension(const String& ext) const
+	{
+		if(extensionList.find(ext) == extensionList.end())
+			return false;
+
+		return true;
+	}
 }}

Source/BansheeGLRenderAPI/BsGLUtil.h

@@ -24,6 +24,8 @@ namespace bs { namespace ct
 
 #elif BS_PLATFORM == BS_PLATFORM_LINUX
 
+#include "Linux/BsLinuxGLSupport.h"
+
 namespace bs { namespace ct
 	{
 		/** @addtogroup GL
@@ -33,10 +35,7 @@ namespace bs { namespace ct
 		/**	Helper method that returns a platform specific GL support object. */
 		GLSupport* getGLSupport()
 		{
-			assert(false);
-
-			// TODOPORT - Not implemented
-			return nullptr;
+			return bs_new<LinuxGLSupport>();
 		}
 
 		/** @} */

Source/BansheeGLRenderAPI/CMakeLists.txt

@@ -27,7 +27,6 @@ if(WIN32)
 	set(BansheeGLRenderAPI_INC ${BansheeGLRenderAPI_INC} "Source/Win32")
 else()
 	set(BansheeGLRenderAPI_INC ${BansheeGLRenderAPI_INC} ${OPENGL_INCLUDE_DIR})
-# TODO_OTHER_PLATFORMS_GO_HERE
 endif()
 	
 include_directories(${BansheeGLRenderAPI_INC})	

Source/BansheeGLRenderAPI/CMakeSources.cmake

@@ -87,6 +87,20 @@ set(BS_BANSHEEGLRENDERAPI_INC_WIN32
 	"Win32/BsWin32VideoModeInfo.h"
 )
 
+set(BS_BANSHEEGLRENDERAPI_INC_LINUX
+	"Linux/BsLinuxContext.h"
+	"Linux/BsLinuxGLSupport.h"
+	"Linux/BsLinuxRenderWindow.h"
+	"Linux/BsLinuxVideoModeInfo.h"
+)
+
+set(BS_BANSHEEGLRENDERAPI_SRC_LINUX
+	"Linux/BsLinuxContext.cpp"
+	"Linux/BsLinuxGLSupport.cpp"
+	"Linux/BsLinuxRenderWindow.cpp"
+	"Linux/BsLinuxVideoModeInfo.cpp"
+)
+
 source_group("Source Files\\GLSL" FILES ${BS_BANSHEEGLRENDERAPI_SRC_GLSL})
 source_group("Header Files" FILES ${BS_BANSHEEGLRENDERAPI_INC_NOFILTER})
 source_group("Source Files\\Win32" FILES ${BS_BANSHEEGLRENDERAPI_SRC_WIN32})
@@ -106,4 +120,9 @@ if(WIN32)
 		${BS_BANSHEEGLRENDERAPI_INC_WIN32}
 		${BS_BANSHEEGLRENDERAPI_SRC_WIN32}
 	)
+elseif(LINUX)
+	list(APPEND BS_BANSHEEGLRENDERAPI_SRC
+		${BS_BANSHEEGLRENDERAPI_INC_LINUX}
+		${BS_BANSHEEGLRENDERAPI_SRC_LINUX}
+	)
 endif()

Source/BansheeGLRenderAPI/Linux/BsLinuxContext.cpp

@@ -0,0 +1,113 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "Linux/BsLinuxContext.h"
+#include "Unix/BsUnixPlatform.h"
+#include "Linux/BsLinuxGLSupport.h"
+
+namespace bs { namespace ct
+{
+		typedef int(*ErrorHandlerProc)(::Display*, XErrorEvent*);
+		int contextErrorHandler(::Display* display, XErrorEvent* error)
+		{
+			// Do nothing
+		}
+
+		LinuxContext::LinuxContext(::Display* display, XVisualInfo& visualInfo)
+		: mDisplay(display), mContext(None)
+	{
+		INT32 dummy;
+		XVisualInfo* windowVisualInfo = XGetVisualInfo(display, VisualIDMask | VisualScreenMask, &visualInfo, &dummy);
+
+		INT32 majorVersion, minorVersion;
+		glXQueryVersion(display, &majorVersion, &minorVersion);
+
+		GLXContext context = 0;
+
+		// createContextAttrib was added in GLX version 1.3
+		bool hasCreateContextAttrib = extGLX_ARB_create_context && (majorVersion > 1 || minorVersion >= 3);
+		if(hasCreateContextAttrib)
+		{
+			// Find the config used to create the window's visual
+			GLXFBConfig* windowConfig = nullptr;
+
+			INT32 numConfigs;
+			GLXFBConfig* configs = glXChooseFBConfig(display, DefaultScreen(display), nullptr, &numConfigs);
+
+			for (INT32 i = 0; i < numConfigs; ++i)
+			{
+				XVisualInfo* configVisualInfo = glXGetVisualFromFBConfig(display, configs[i]);
+
+				if(!configVisualInfo)
+					continue;
+
+				if(windowVisualInfo->visualid == configVisualInfo->visualid)
+				{
+					windowConfig = &configs[i];
+					break;
+				}
+			}
+
+			if(windowConfig)
+			{
+				int32_t attributes[] =
+						{
+								GLX_CONTEXT_MAJOR_VERSION_ARB, 4,
+								GLX_CONTEXT_MINOR_VERSION_ARB, 5,
+								0, 0, // Core profile
+								0, 0, // Debug flags
+								0 // Terminator
+						};
+
+				if(extGLX_ARB_create_context_profile)
+				{
+					attributes[4] = GLX_CONTEXT_PROFILE_MASK_ARB;
+					attributes[5] = GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
+				}
+
+#if BS_DEBUG_MODE
+					attributes[6] = GLX_CONTEXT_FLAGS_ARB;
+					attributes[7] = GLX_CONTEXT_DEBUG_BIT_ARB;
+#endif
+
+				// Add error handler so the application doesn't crash on error
+				ErrorHandlerProc oldErrorHandler = XSetErrorHandler(&contextErrorHandler);
+				context = glXCreateContextAttribsARB(display, *windowConfig, 0, True, attributes);
+				XSetErrorHandler(oldErrorHandler);
+			}
+
+			XFree(configs);
+		}
+
+		// If createContextAttribs failed or isn't supported, fall back to glXCreateContext
+		if(!context)
+			context = glXCreateContext(display, windowVisualInfo, 0, True);
+
+		XFree(windowVisualInfo);
+
+		mContext = context;
+	}
+
+	LinuxContext::~LinuxContext()
+	{
+		releaseContext();
+	}
+
+	void LinuxContext::setCurrent()
+	{
+		glXMakeCurrent(mDisplay, LinuxPlatform::getMainXWindow(), mContext);
+	}
+
+	void LinuxContext::endCurrent()
+	{
+		glXMakeCurrent(mDisplay, None, None);
+	}
+
+	void LinuxContext::releaseContext()
+	{
+		if (mContext)
+		{
+			glXDestroyContext(mDisplay, mContext);
+			mContext = None;
+		}
+	}
+}}

Source/BansheeGLRenderAPI/Linux/BsLinuxContext.h

@@ -0,0 +1,42 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsGLContext.h"
+#include <GL/glxew.h>
+
+namespace bs { namespace ct
+{
+	/** @addtogroup GL
+	 *  @{
+	 */
+
+	/**	Linux specific implementation of an OpenGL context. */
+	class LinuxContext : public GLContext
+	{
+	public:
+		/**
+		 * Constructs a new OpenGL context.
+		 *
+		 * @param[in] 	x11display 		X11 display all windows using this context will be created with.
+		 * @param[in]	visualInfo		X11 visual info describing properties of all windows that will use this context.
+		 **/
+		LinuxContext(::Display* x11display, XVisualInfo& visualInfo);
+		virtual ~LinuxContext();
+
+		/** @copydoc GLContext::setCurrent */
+		void setCurrent() override;
+
+		/** @copydoc GLContext::endCurrent */
+		void endCurrent() override;
+
+		/** @copydoc GLContext::releaseContext  */
+		void releaseContext() override;
+
+	protected:
+		::Display* mDisplay;
+		GLXContext mContext;
+	};
+
+	/** @} */
+}}

Source/BansheeGLRenderAPI/Linux/BsLinuxGLSupport.cpp

@@ -0,0 +1,258 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "Unix/BsUnixPlatform.h"
+#include "Linux/BsLinuxGLSupport.h"
+#include "Linux/BsLinuxContext.h"
+#include "Linux/BsLinuxRenderWindow.h"
+#include "GL/wglew.h"
+#include "BsLinuxVideoModeInfo.h"
+#include "BsGLRenderAPI.h
+
+namespace bs { namespace ct
+{
+	bool extGLX_ARB_multisample = false;
+	bool extGLX_ARB_framebuffer_sRGB = false;
+	bool extGLX_EXT_framebuffer_sRGB = false;
+	bool extGLX_ARB_create_context = false;
+	bool extGLX_ARB_create_context_profile = false;
+	bool extGLX_EXT_swap_control = false;
+	bool extGLX_MESA_swap_control = false;
+	bool extGLX_SGI_swap_control = false;
+
+	typedef GLXContext (*glXCreateContextAttribsARBProc)(Display*, GLXFBConfig, GLXContext, Bool, const int*);
+	glXCreateContextAttribsARBProc glXCreateContextAttribsARB = nullptr;
+
+	bool Load_ARB_create_context()
+	{
+		glXCreateContextAttribsARB =
+				(glXCreateContextAttribsARBProc)glXGetProcAddressARB((const GLubyte*)"glXCreateContextAttribsARB");
+
+		return glXCreateContextAttribsARB != nullptr;
+	}
+
+	typedef void (*glXSwapIntervalEXTProc)(::Display*, GLXDrawable, int);
+	typedef int (*glXSwapIntervalMESAProc)(int);
+	typedef int (*glXSwapIntervalSGIProc)(int);
+
+	glXSwapIntervalEXTProc glXSwapIntervalEXT = nullptr;
+	glXSwapIntervalMESAProc glXSwapIntervalMESA = nullptr;
+	glXSwapIntervalSGIProc glXSwapIntervalSGI = nullptr;
+
+	bool Load_EXT_swap_control()
+	{
+		glXSwapIntervalEXT = (glXSwapIntervalEXTProc)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalEXT");
+
+		return glXSwapIntervalEXT != nullptr;
+	}
+
+	bool Load_MESA_swap_control()
+	{
+		glXSwapIntervalMESA = (glXSwapIntervalMESAProc)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalMESA");
+
+		return glXSwapIntervalMESA != nullptr;
+	}
+
+	bool Load_SGI_swap_control()
+	{
+		glXSwapIntervalSGI = (glXSwapIntervalSGIProc)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalSGI");
+
+		return glXSwapIntervalSGI != nullptr;
+	}
+
+	typedef bool (*ExtensionFunc)(void);
+
+	struct GLExtension
+	{
+		const char* name;
+		bool* status;
+		ExtensionFunc func;
+	};
+
+	static GLExtension gExtensionMap[] = {
+		{ "GLX_ARB_multisample", &extGLX_ARB_multisample, nullptr },
+		{ "GLX_ARB_framebuffer_sRGB", &extGLX_ARB_framebuffer_sRGB, nullptr },
+		{ "GLX_EXT_framebuffer_sRGB", &extGLX_EXT_framebuffer_sRGB, nullptr },
+		{ "GLX_ARB_create_context", &extGLX_ARB_create_context, Load_ARB_create_context },
+		{ "GLX_ARB_create_context_profile", &extGLX_ARB_create_context_profile, nullptr },
+		{ "GLX_EXT_swap_control", &extGLX_EXT_swap_control, Load_EXT_swap_control },
+		{ "GLX_MESA_swap_control", &extGLX_MESA_swap_control, Load_MESA_swap_control },
+		{ "GLX_SGI_swap_control", &extGLX_SGI_swap_control, Load_SGI_swap_control },
+	};
+
+	LinuxGLSupport::LinuxGLSupport()
+	{ }
+
+	SPtr<bs::RenderWindow> LinuxGLSupport::newWindow(RENDER_WINDOW_DESC& desc, UINT32 windowId,
+		SPtr<bs::RenderWindow> parentWindow)
+	{
+		if(parentWindow != nullptr)
+		{
+			::Window x11window;
+			parentWindow->getCustomAttribute("WINDOW", &x11window);
+			desc.platformSpecific["parentWindowHandle"] = toString((UINT64)x11window);
+		}
+
+		bs::LinuxRenderWindow* window = new (bs_alloc<bs::LinuxRenderWindow>()) bs::LinuxRenderWindow(desc, windowId, *this);
+		return SPtr<bs::RenderWindow>(window, &bs::CoreObject::_delete<bs::LinuxRenderWindow, GenAlloc>);
+	}
+
+	SPtr<RenderWindow> LinuxGLSupport::newWindowCore(RENDER_WINDOW_DESC& desc, UINT32 windowId)
+	{
+		LinuxRenderWindow* window = new (bs_alloc<LinuxRenderWindow>()) LinuxRenderWindow(desc, windowId, *this);
+
+		return bs_shared_ptr<LinuxRenderWindow>(window);
+	}
+
+	void LinuxGLSupport::start()
+	{
+		// Retrieve all essential extensions
+		::Display* display = LinuxPlatform::getXDisplay();
+		const char* glExtensions = glXQueryExtensionsString(display, DefaultScreen(display));
+
+		const char* iter = glExtensions;
+		do
+		{
+			const char* start = iter;
+			while(*iter != ' ' && *iter)
+				iter++;
+
+			const char* end = iter;
+			const char* name = std::string(start, end).c_str();
+
+			uint32_t numExtensions = sizeof(gExtensionMap) / sizeof(gExtensionMap[0]);
+			for (int i = 0; i < numExtensions; ++i)
+			{
+				if(strcmp(name, gExtensionMap[i].name) == 0)
+				{
+					if(gExtensionMap[i].func != nullptr)
+						*gExtensionMap[i].status = gExtensionMap[i].func();
+					else
+						*gExtensionMap[i].status = true;
+				}
+
+			}
+
+		} while(*iter++);
+	}
+
+	void LinuxGLSupport::stop()
+	{
+		// Do nothing
+	}
+
+	SPtr<LinuxContext> LinuxGLSupport::createContext(::Display* x11display, XVisualInfo& visualInfo)
+	{
+		GLRenderAPI* rapi = static_cast<GLRenderAPI*>(RenderAPI::instancePtr());
+
+		// If RenderAPI has initialized a context use that, otherwise we create our own
+		if (!rapi->_isContextInitialized())
+			return bs_shared_ptr_new<LinuxContext>(x11display, visualInfo);
+		else
+		{
+			SPtr<LinuxContext> context = rapi->getMainContext();
+			context->setCurrent();
+
+			return context;
+		}
+	}
+
+	void* LinuxGLSupport::getProcAddress(const String& procname)
+	{
+		return (void*)glXGetProcAddressARB((const GLubyte*)procname.c_str());
+	}
+
+	XVisualInfo LinuxGLSupport::findBestVisual(::Display* display, bool depthStencil, UINT32 multisample, bool srgb) const
+	{
+		static constexpr INT32 VISUAL_ATTRIBS[] =
+		{
+			GLX_X_RENDERABLE, 		True,
+			GLX_DRAWABLE_TYPE, 		GLX_WINDOW_BIT,
+			GLX_RENDER_TYPE,		GLX_RGBA_BIT,
+			GLX_X_VISUAL_TYPE,		GLX_TRUE_COLOR,
+			GLX_RED_SIZE,			8,
+			GLX_GREEN_SIZE,			8,
+			GLX_BLUE_SIZE,			8,
+			GLX_ALPHA_SIZE,			8
+		};
+
+		INT32 numConfigs;
+		GLXFBConfig* configs = glXChooseFBConfig(display, DefaultScreen(display), VISUAL_ATTRIBS, &numConfigs);
+
+		// Find a config that best matches the requested properties
+		INT32 bestScore = 0;
+		INT32 bestConfig = -1;
+		for (int i = 0; i < numConfigs; ++i)
+		{
+			uint32_t configScore = 0;
+
+			// Depth buffer contributes the most to score
+			if(depthStencil)
+			{
+				int32_t depth, stencil;
+				glXGetFBConfigAttrib(display, configs[i], GLX_DEPTH_SIZE, &depth);
+				glXGetFBConfigAttrib(display, configs[i], GLX_STENCIL_SIZE, &stencil);
+
+				if(depth == 24 && stencil == 8)
+					configScore += 10000;
+				else if(depth == 32 && stencil == 8)
+					configScore += 9000;
+				else if(depth == 32)
+					configScore += 8000;
+				else if(depth == 16)
+					configScore += 7000;
+			}
+
+			// sRGB contributes second most
+			if(srgb)
+			{
+				int32_t hasSRGB = 0;
+
+				if(extGLX_EXT_framebuffer_sRGB)
+					glXGetFBConfigAttrib(display, configs[i], GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT, &hasSRGB);
+
+				if(!hasSRGB && extGLX_ARB_framebuffer_sRGB)
+					glXGetFBConfigAttrib(display, configs[i], GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT, &hasSRGB);
+
+				if(hasSRGB)
+					configScore += 500;
+
+			}
+
+			if((multisample >= 1) && extGLX_ARB_multisample)
+			{
+				int32_t hasMultisample, numSamples;
+				glXGetFBConfigAttrib(display, configs[i], GLX_SAMPLE_BUFFERS, &hasMultisample);
+				glXGetFBConfigAttrib(display, configs[i], GLX_SAMPLES, &numSamples);
+
+				if(hasMultisample && (numSamples <= multisample))
+					configScore += (32 - (multisample - numSamples)) * 10;
+			}
+
+			if(configScore > bestScore)
+			{
+				bestScore = configScore;
+				bestConfig = i;
+			}
+		}
+
+		if(bestConfig == -1)
+		{
+			// Something went wrong
+			XFree(configs);
+			return XVisualInfo();
+		}
+
+		XVisualInfo* visualInfo = glXGetVisualFromFBConfig(display, configs[bestConfig]);
+		XVisualInfo output = *visualInfo;
+
+		XFree(configs);
+		XFree(visualInfo);
+
+		return output;
+	}
+
+	SPtr<VideoModeInfo> LinuxGLSupport::getVideoModeInfo() const
+	{
+		return bs_shared_ptr_new<LinuxVideoModeInfo>();
+	}
+}}

Source/BansheeGLRenderAPI/Linux/BsLinuxGLSupport.h

@@ -0,0 +1,84 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include <X11/Xutil.h>
+#include <GL/glxew.h>
+#include "BsGLSupport.h"
+#include "BsGLRenderAPI.h"
+
+namespace bs { namespace ct
+{
+	class LinuxContext;
+
+	/** @addtogroup GL
+	 *  @{
+	 */
+
+	// Extensions
+	extern bool extGLX_ARB_multisample;
+	extern bool extGLX_ARB_framebuffer_sRGB;
+	extern bool extGLX_EXT_framebuffer_sRGB;
+	extern bool extGLX_ARB_create_context;
+	extern bool extGLX_ARB_create_context_profile;
+	extern bool extGLX_EXT_swap_control;
+	extern bool extGLX_MESA_swap_control;
+	extern bool extGLX_SGI_swap_control;
+
+	typedef GLXContext (*glXCreateContextAttribsARBProc)(Display*, GLXFBConfig, GLXContext, Bool, const int*);
+	extern glXCreateContextAttribsARBProc glXCreateContextAttribsARB;
+
+	typedef void (*glXSwapIntervalEXTProc)(::Display*, GLXDrawable, int);
+	typedef int (*glXSwapIntervalMESAProc)(int);
+	typedef int (*glXSwapIntervalSGIProc)(int);
+
+	extern glXSwapIntervalEXTProc glXSwapIntervalEXT;
+	extern glXSwapIntervalMESAProc glXSwapIntervalMESA;
+	extern glXSwapIntervalSGIProc glXSwapIntervalSGI;
+
+	/**	Handles OpenGL initialization, window creation and extensions on Linux. */
+	class LinuxGLSupport : public GLSupport
+	{
+	public:
+		LinuxGLSupport();
+
+		/** @copydoc GLSupport::newWindow */
+		SPtr<bs::RenderWindow> newWindow(RENDER_WINDOW_DESC& desc, UINT32 windowId, SPtr<bs::RenderWindow> parentWindow) override;
+
+		/** @copydoc GLSupport::newWindowCore */
+		SPtr<RenderWindow> newWindowCore(RENDER_WINDOW_DESC& desc, UINT32 windowId) override;
+
+		/** @copydoc GLSupport::start */
+		void start() override;
+
+		/** @copydoc GLSupport::stop */
+		void stop() override;
+
+		/** @copydoc GLSupport::getProcAddress */
+		void* getProcAddress(const String& procname) override;
+
+		/** Creates a new OpenGL context. */
+		SPtr<LinuxContext> createContext(::Display* x11display, XVisualInfo& visualInfo);
+
+		/**
+		 * Selects an appropriate X11 visual info depending on the provided parameters. Visual info should then be used
+		 * for creation of an X11 window.
+		 *
+		 * @param[in] display		X11 display the window will be created on.
+		 * @param[in] depthStencil	True if the window requires a depth-stencil buffer.
+		 * @param[in] multisample	Number of samples per pixel, if window back buffer requires support for multiple samples.
+		 * 							Set to 0 or 1 if multisampling is not required.
+		 * @param[in] srgb			If enabled the pixels written to the back-buffer are assumed to be in linear space and
+		 * 							will automatically be encoded into gamma space on write.
+		 * @return					X11 visual info structure you may use to initialize a window.
+		 */
+		XVisualInfo findBestVisual(::Display* display, bool depthStencil, UINT32 multisample, bool srgb) const;
+
+		/** @copydoc GLSupport::getVideoModeInfo */
+		SPtr<VideoModeInfo> getVideoModeInfo() const override;
+
+	private:
+	};
+
+	/** @} */
+}}

Source/BansheeGLRenderAPI/Linux/BsLinuxRenderWindow.cpp

@@ -0,0 +1,427 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "CoreThread/BsCoreThread.h"
+#include "BsGLPixelFormat.h"
+#include "Unix/BsUnixPlatform.h"
+#include "Linux/BsLinuxRenderWindow.h"
+#include "Unix/BsUnixWindow.h"
+#include "Linux/BsLinuxVideoModeInfo.h"
+#include "Linux/BsLinuxGLSupport.h"
+#include "Math/BsMath.h"
+#include "RenderAPI/BsRenderAPI.h"
+#include "BsGLRenderWindowManager.h"
+#include <GL/glxew.h>
+#include "Math/BsVector2I.h"
+
+namespace bs
+{
+	LinuxRenderWindowProperties::LinuxRenderWindowProperties(const RENDER_WINDOW_DESC& desc)
+		:RenderWindowProperties(desc)
+	{ }
+
+	LinuxRenderWindow::LinuxRenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId, ct::LinuxGLSupport& glSupport)
+		:RenderWindow(desc, windowId), mGLSupport(glSupport), mProperties(desc)
+	{ }
+
+	void LinuxRenderWindow::getCustomAttribute(const String& name, void* data) const
+	{
+		if (name == "WINDOW")
+		{
+			::Window *x11Window = (::Window*)data;
+			// TODOPORT
+			//*x11Window = (UINT64)getHWnd();
+			return;
+		}
+	}
+
+	Vector2I LinuxRenderWindow::screenToWindowPos(const Vector2I& screenPos) const
+	{
+		// TODOPORT
+	}
+
+	Vector2I LinuxRenderWindow::windowToScreenPos(const Vector2I& windowPos) const
+	{
+		// TODOPORT
+	}
+
+	SPtr<ct::LinuxRenderWindow> LinuxRenderWindow::getCore() const
+	{
+		return std::static_pointer_cast<ct::LinuxRenderWindow>(mCoreSpecific);
+	}
+
+	void LinuxRenderWindow::syncProperties()
+	{
+		ScopedSpinLock lock(getCore()->mLock);
+		mProperties = getCore()->mSyncedProperties;
+	}
+
+	namespace ct
+	{
+	LinuxRenderWindow::LinuxRenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId, LinuxGLSupport& glsupport)
+			: RenderWindow(desc, windowId), mWindow(nullptr), mGLSupport(glsupport), mContext(nullptr), mProperties(desc)
+			, mSyncedProperties(desc), mIsChild(false), mShowOnSwap(false)
+	{ }
+
+	LinuxRenderWindow::~LinuxRenderWindow()
+	{
+		LinuxRenderWindowProperties& props = mProperties;
+
+		if (mWindow != nullptr)
+		{
+			mWindow->close();
+
+			bs_delete(mWindow);
+			mWindow = nullptr;
+		}
+
+		props.mActive = false;
+	}
+
+	void LinuxRenderWindow::initialize()
+	{
+		LinuxRenderWindowProperties& props = mProperties;
+
+		props.mIsFullScreen = mDesc.fullscreen;
+		mIsChild = false;
+		mDisplayFrequency = Math::roundToInt(mDesc.videoMode.getRefreshRate());
+		props.mColorDepth = 32;
+
+		WINDOW_DESC windowDesc;
+		windowDesc.fullscreen = mDesc.fullscreen;
+		windowDesc.x = mDesc.left;
+		windowDesc.y = mDesc.top;
+		windowDesc.width = mDesc.videoMode.getWidth();
+		windowDesc.height = mDesc.videoMode.getHeight();
+		windowDesc.hidden = mDesc.hidden || mDesc.hideUntilSwap;
+		windowDesc.title = mDesc.title;
+		windowDesc.showDecorations = !mDesc.toolWindow;
+		windowDesc.modal = mDesc.modal;
+		windowDesc.visualInfo = mGLSupport.findBestVisual(LinuxPlatform::getXDisplay(), mDesc.depthBuffer,
+				mDesc.multisampleCount, mDesc.gamma);
+
+		NameValuePairList::const_iterator opt;
+		opt = mDesc.platformSpecific.find("parentWindowHandle");
+		if (opt != mDesc.platformSpecific.end())
+			windowDesc.parent = (::Window)parseUINT64(opt->second);
+
+		const LinuxVideoModeInfo& videoModeInfo = static_cast<const LinuxVideoModeInfo&>(RenderAPI::instance()
+				.getVideoModeInfo());
+		UINT32 numOutputs = videoModeInfo.getNumOutputs();
+		if (numOutputs > 0)
+		{
+			UINT32 actualMonitorIdx = std::min(mDesc.videoMode.getOutputIdx(), numOutputs - 1);
+			const LinuxVideoOutputInfo& outputInfo = static_cast<const LinuxVideoOutputInfo&>(videoModeInfo
+					.getOutputInfo(actualMonitorIdx));
+			windowDesc.monitor = outputInfo.getMonitorHandle();
+		}
+
+		mIsChild = windowDesc.parent != nullptr;
+		props.mIsFullScreen = mDesc.fullscreen && !mIsChild;
+		props.mColorDepth = 32;
+		props.mActive = true;
+
+		if (!windowDesc.external)
+		{
+			mShowOnSwap = mDesc.hideUntilSwap;
+			props.mHidden = mDesc.hideUntilSwap || mDesc.hidden;
+		}
+
+		mWindow = bs_new<LinuxWindow>(windowDesc);
+
+		props.mWidth = mWindow->getWidth();
+		props.mHeight = mWindow->getHeight();
+		props.mTop = mWindow->getTop();
+		props.mLeft = mWindow->getLeft();
+
+		props.mHwGamma = testHwGamma;
+		props.mMultisampleCount = testMultisample;
+
+		XWindowAttributes windowAttributes;
+		XGetWindowAttributes(LinuxPlatform::getXDisplay(), mWindow->_getXWindow(), &windowAttributes);
+
+		XVisualInfo requestVI;
+		requestVI.screen = DefaultScreen(LinuxPlatform::getXDisplay());
+		requestVI.visualid = XVisualIDFromVisual(windowAttributes.visual);
+
+		mContext = mGLSupport.createContext(LinuxPlatform::getXDisplay(), requestVI);
+
+		if(mDesc.fullscreen && !mIsChild)
+			setFullscreen(mDesc.videoMode);
+
+		if(mDesc.hideUntilSwap || mDesc.hidden)
+			setHidden(true);
+
+		{
+			ScopedSpinLock lock(mLock);
+			mSyncedProperties = props;
+		}
+
+		bs::RenderWindowManager::instance().notifySyncDataDirty(this);
+		RenderWindow::initialize();
+	}
+
+	void LinuxRenderWindow::setFullscreen(UINT32 width, UINT32 height, float refreshRate, UINT32 monitorIdx)
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		if (mIsChild)
+			return;
+
+		const LinuxVideoModeInfo& videoModeInfo = static_cast<const LinuxVideoModeInfo&>(RenderAPI::instance() .getVideoModeInfo());
+		UINT32 numOutputs = videoModeInfo.getNumOutputs();
+		if (numOutputs == 0)
+			return;
+
+		LinuxRenderWindowProperties& props = mProperties;
+
+		UINT32 actualMonitorIdx = std::min(monitorIdx, numOutputs - 1);
+		const LinuxVideoOutputInfo& outputInfo = static_cast<const LinuxVideoOutputInfo&>(videoModeInfo.getOutputInfo (actualMonitorIdx));
+
+		// TODO - Change screen mode
+
+
+
+		mWindow->_setFullscreen(true);
+
+		props.mIsFullScreen = true;
+
+		props.mTop = monitorInfo.rcMonitor.top;
+		props.mLeft = monitorInfo.rcMonitor.left;
+		props.mWidth = width;
+		props.mHeight = height;
+
+		_windowMovedOrResized();
+	}
+
+	void LinuxRenderWindow::setFullscreen(const VideoMode& mode)
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		setFullscreen(mode.getWidth(), mode.getHeight(), mode.getRefreshRate(), mode.getOutputIdx());
+	}
+
+	void LinuxRenderWindow::setWindowed(UINT32 width, UINT32 height)
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		LinuxRenderWindowProperties& props = mProperties;
+
+		if (!props.mIsFullScreen)
+			return;
+
+		props.mIsFullScreen = false;
+		props.mWidth = width;
+		props.mHeight = height;
+
+		// TODO - Restore old screen config
+
+		mWindow->_setFullscreen(false);
+
+		{
+			ScopedSpinLock lock(mLock);
+			mSyncedProperties.mWidth = props.mWidth;
+			mSyncedProperties.mHeight = props.mHeight;
+		}
+
+		bs::RenderWindowManager::instance().notifySyncDataDirty(this);
+		_windowMovedOrResized();
+	}
+
+	void LinuxRenderWindow::move(INT32 left, INT32 top)
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		LinuxRenderWindowProperties& props = mProperties;
+		if (!props.mIsFullScreen)
+		{
+			mWindow->move(left, top);
+
+			props.mTop = mWindow->getTop();
+			props.mLeft = mWindow->getLeft();
+
+			{
+				ScopedSpinLock lock(mLock);
+				mSyncedProperties.mTop = props.mTop;
+				mSyncedProperties.mLeft = props.mLeft;
+			}
+
+			bs::RenderWindowManager::instance().notifySyncDataDirty(this);
+		}
+	}
+
+	void LinuxRenderWindow::resize(UINT32 width, UINT32 height)
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		LinuxRenderWindowProperties& props = mProperties;
+		if (!props.mIsFullScreen)
+		{
+			mWindow->resize(width, height);
+
+			props.mWidth = mWindow->getWidth();
+			props.mHeight = mWindow->getHeight();
+
+			{
+				ScopedSpinLock lock(mLock);
+				mSyncedProperties.mWidth = props.mWidth;
+				mSyncedProperties.mHeight = props.mHeight;
+			}
+
+			bs::RenderWindowManager::instance().notifySyncDataDirty(this);
+		}
+	}
+
+	void LinuxRenderWindow::minimize()
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		mWindow->minimize();
+	}
+
+	void LinuxRenderWindow::maximize()
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		mWindow->maximize();
+	}
+
+	void LinuxRenderWindow::restore()
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		mWindow->restore();
+	}
+
+	void LinuxRenderWindow::swapBuffers(UINT32 syncMask)
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		if (mShowOnSwap)
+			setHidden(false);
+
+		glXSwapBuffers(LinuxPlatform::getXDisplay(), mWindow->_getXWindow());
+	}
+
+	void LinuxRenderWindow::copyToMemory(PixelData &dst, FrameBuffer buffer)
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		if ((dst.getRight() > getProperties().getWidth()) ||
+			(dst.getBottom() > getProperties().getHeight()) ||
+			(dst.getFront() != 0) || (dst.getBack() != 1))
+		{
+			BS_EXCEPT(InvalidParametersException, "Invalid box.");
+		}
+
+		if (buffer == FB_AUTO)
+		{
+			buffer = mProperties.isFullScreen() ? FB_FRONT : FB_BACK;
+		}
+
+		GLenum format = GLPixelUtil::getGLOriginFormat(dst.getFormat());
+		GLenum type = GLPixelUtil::getGLOriginDataType(dst.getFormat());
+
+		if ((format == GL_NONE) || (type == 0))
+		{
+			BS_EXCEPT(InvalidParametersException, "Unsupported format.");
+		}
+
+		// Must change the packing to ensure no overruns!
+		glPixelStorei(GL_PACK_ALIGNMENT, 1);
+
+		glReadBuffer((buffer == FB_FRONT)? GL_FRONT : GL_BACK);
+		glReadPixels((GLint)dst.getLeft(), (GLint)dst.getTop(),
+				(GLsizei)dst.getWidth(), (GLsizei)dst.getHeight(),
+				format, type, dst.getData());
+
+		// restore default alignment
+		glPixelStorei(GL_PACK_ALIGNMENT, 4);
+
+		//vertical flip
+		{
+			size_t rowSpan = dst.getWidth() * PixelUtil::getNumElemBytes(dst.getFormat());
+			size_t height = dst.getHeight();
+			UINT8* tmpData = (UINT8*)bs_alloc((UINT32)(rowSpan * height));
+			UINT8* srcRow = (UINT8 *)dst.getData(), *tmpRow = tmpData + (height - 1) * rowSpan;
+
+			while (tmpRow >= tmpData)
+			{
+				memcpy(tmpRow, srcRow, rowSpan);
+				srcRow += rowSpan;
+				tmpRow -= rowSpan;
+			}
+			memcpy(dst.getData(), tmpData, rowSpan * height);
+
+			bs_free(tmpData);
+		}
+	}
+
+	void LinuxRenderWindow::getCustomAttribute(const String& name, void* data) const
+	{
+		if(name == "GLCONTEXT")
+		{
+			SPtr<GLContext>* contextPtr = static_cast<SPtr<GLContext>*>(data);
+			*contextPtr = mContext;
+			return;
+		}
+		else if(name == "WINDOW")
+		{
+			::Window* window = (::Window*)data;
+			*window = mWindow->_getXWindow();
+			return;
+		}
+	}
+
+	void LinuxRenderWindow::setActive(bool state)
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		if(state)
+			mWindow->restore();
+		else
+			mWindow->minimize();
+
+		RenderWindow::setActive(state);
+	}
+
+	void LinuxRenderWindow::setHidden(bool hidden)
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		mShowOnSwap = false;
+
+		if(hidden)
+			mWindow->hide();
+		else
+			mWindow->show();
+
+		RenderWindow::setHidden(hidden);
+	}
+
+	void LinuxRenderWindow::_windowMovedOrResized()
+	{
+		if (!mWindow)
+			return;
+
+		mWindow->_windowMovedOrResized();
+
+		LinuxRenderWindowProperties& props = mProperties;
+		if (!props.mIsFullScreen) // Fullscreen is handled directly by this object
+		{
+			props.mTop = mWindow->getTop();
+			props.mLeft = mWindow->getLeft();
+			props.mWidth = mWindow->getWidth();
+			props.mHeight = mWindow->getHeight();
+		}
+
+		RenderWindow::_windowMovedOrResized();
+	}
+
+	void LinuxRenderWindow::syncProperties()
+	{
+		ScopedSpinLock lock(mLock);
+		mProperties = mSyncedProperties;
+	}
+	}
+}
+

Source/BansheeGLRenderAPI/Linux/BsLinuxRenderWindow.h

@@ -0,0 +1,165 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "RenderAPI/BsRenderWindow.h"
+
+namespace bs
+{
+	class LinuxWindow;
+	class LinuxRenderWindow;
+
+	namespace ct
+	{
+		class LinuxGLSupport;
+		class LinuxContext;
+		class LinuxRenderWindow;
+	}
+
+	/** @addtogroup GL
+	 *  @{
+	 */
+
+	/**	Contains various properties that describe a render window. */
+	class LinuxRenderWindowProperties : public RenderWindowProperties
+	{
+	public:
+		LinuxRenderWindowProperties(const RENDER_WINDOW_DESC& desc);
+		virtual ~LinuxRenderWindowProperties() { }
+
+	private:
+		friend class ct::LinuxRenderWindow;
+		friend class LinuxRenderWindow;
+	};
+
+	/**
+	 * Render window implementation for Linux.
+	 *
+	 * @note	Sim thread only.
+	 */
+	class LinuxRenderWindow : public RenderWindow
+	{
+	public:
+		~LinuxRenderWindow() { }
+
+		/** @copydoc RenderWindow::getCustomAttribute */
+		void getCustomAttribute(const String& name, void* pData) const override;
+
+		/** @copydoc RenderWindow::screenToWindowPos */
+		Vector2I screenToWindowPos(const Vector2I& screenPos) const override;
+
+		/** @copydoc RenderWindow::windowToScreenPos */
+		Vector2I windowToScreenPos(const Vector2I& windowPos) const override;
+
+		/** @copydoc RenderWindow::getCore */
+		SPtr<ct::LinuxRenderWindow> getCore() const;
+
+	protected:
+		friend class GLRenderWindowManager;
+		friend class ct::LinuxGLSupport;
+		friend class ct::LinuxRenderWindow;
+
+		LinuxRenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId, ct::LinuxGLSupport& glSupport);
+
+		/** @copydoc RenderWindow::getProperties */
+		const RenderTargetProperties& getPropertiesInternal() const override { return mProperties; }
+
+		/** @copydoc RenderWindow::syncProperties */
+		void syncProperties() override;
+
+	private:
+		ct::LinuxGLSupport& mGLSupport;
+		LinuxRenderWindowProperties mProperties;
+	};
+
+	namespace ct
+	{
+		/**
+		 * Render window implementation for Linux.
+		 *
+		 * @note	Core thread only.
+		 */
+		class LinuxRenderWindow : public RenderWindow
+		{
+		public:
+			LinuxRenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId, LinuxGLSupport &glSupport);
+			~LinuxRenderWindow();
+
+			/** @copydoc RenderWindow::setFullscreen(UINT32, UINT32, float, UINT32) */
+			void setFullscreen(UINT32 width, UINT32 height, float refreshRate = 60.0f, UINT32 monitorIdx = 0) override;
+
+			/** @copydoc RenderWindow::setFullscreen(const VideoMode&) */
+			void setFullscreen(const VideoMode& videoMode) override;
+
+			/** @copydoc RenderWindow::setWindowed */
+			void setWindowed(UINT32 width, UINT32 height) override;
+
+			/** @copydoc RenderWindow::setHidden */
+			void setHidden(bool hidden) override;
+
+			/** @copydoc RenderWindow::minimize */
+			void minimize() override;
+
+			/** @copydoc RenderWindow::maximize */
+			void maximize() override;
+
+			/** @copydoc RenderWindow::restore */
+			void restore() override;
+
+			/** @copydoc RenderWindow::move */
+			void move(INT32 left, INT32 top) override;
+
+			/** @copydoc RenderWindow::resize */
+			void resize(UINT32 width, UINT32 height) override;
+
+			/**
+			 * Copies the contents of a frame buffer into the pre-allocated buffer.
+			 *
+			 * @param[out]	dst		Previously allocated buffer to read the contents into. Must be of valid size.
+			 * @param[in]	buffer	Frame buffer to read the contents from.
+			 */
+			void copyToMemory(PixelData& dst, FrameBuffer buffer);
+
+			/** @copydoc RenderWindow::swapBuffers */
+			void swapBuffers(UINT32 syncMask) override;
+
+			/** @copydoc RenderWindow::getCustomAttribute */
+			void getCustomAttribute(const String& name, void* pData) const override;
+
+			/** @copydoc RenderWindow::setActive */
+			void setActive(bool state) override;
+
+			/** @copydoc RenderWindow::_windowMovedOrResized */
+			void _windowMovedOrResized() override;
+
+		protected:
+			friend class LinuxGLSupport;
+
+			/** @copydoc CoreObject::initialize */
+			void initialize() override;
+
+			/** @copydoc RenderWindow::getProperties */
+			const RenderTargetProperties& getPropertiesInternal() const override { return mProperties; }
+
+			/** @copydoc RenderWindow::getSyncedProperties */
+			RenderWindowProperties& getSyncedProperties() override { return mSyncedProperties; }
+
+			/** @copydoc RenderWindow::syncProperties */
+			void syncProperties() override;
+
+		protected:
+			friend class bs::LinuxRenderWindow;
+
+			LinuxWindow* mWindow;
+			LinuxGLSupport& mGLSupport;
+			SPtr<LinuxContext> mContext;
+			LinuxRenderWindowProperties mProperties;
+			LinuxRenderWindowProperties mSyncedProperties;
+			bool mIsChild;
+			bool mShowOnSwap;
+		};
+	}
+
+	/** @} */
+}
+

Source/BansheeGLRenderAPI/Linux/BsLinuxVideoModeInfo.cpp

@@ -0,0 +1,165 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "Linux/BsLinuxVideoModeInfo.h"
+#include "Unix/BsUnixPlatform.h"
+#include <X11/extensions/Xrandr.h>
+
+#define XRANDR_ROTATION_LEFT    (1 << 1)
+#define XRANDR_ROTATION_RIGHT   (1 << 3)
+
+namespace bs { namespace ct
+{
+	LinuxVideoModeInfo::LinuxVideoModeInfo()
+	{
+		::Display* display = LinuxPlatform::getXDisplay();
+
+		INT32 minor, major;
+		XRRQueryVersion(display, &minor, &major);
+
+		INT32 defaultScreen = XDefaultScreen(display);
+		RROutput primaryOutput = XRRGetOutputPrimary(display, RootWindow(display, defaultScreen));
+
+		INT32 screenCount = XScreenCount(display);
+		for(INT32 i = 0; i < screenCount; i++)
+		{
+			XRRScreenResources* screenRes = XRRGetScreenResources(display, RootWindow(display, i));
+
+			for(INT32 j = 0; j < screenRes->noutput; j++)
+			{
+				XRROutputInfo* outputInfo = XRRGetOutputInfo(display, screenRes, screenRes->outputs[j]);
+
+				if(outputInfo == nullptr || outputInfo->crtc == 0 || outputInfo->connection == RR_Disconnected)
+				{
+					XRRFreeOutputInfo(outputInfo);
+					continue;
+				}
+
+				XRRCrtcInfo* crtcInfo = XRRGetCrtcInfo(display, screenRes, outputInfo->crtc);
+				if(crtcInfo == nullptr)
+					continue;
+
+				VideoOutputInfo* output = bs_new<LinuxVideoOutputInfo>(display, outputInfo, crtcInfo, screenRes, j,
+						(UINT32)mOutputs.size());
+
+				// Make sure the primary output is the first in the output list
+				if(i == defaultScreen && screenRes->outputs[j] == primaryOutput)
+					mOutputs.insert(mOutputs.begin(), output);
+				else
+					mOutputs.push_back(output);
+
+				XRRFreeCrtcInfo(crtcInfo);
+				XRRFreeOutputInfo(outputInfo);
+			}
+
+			XRRFreeScreenResources(screenRes);
+		}
+	}
+
+	LinuxVideoOutputInfo::LinuxVideoOutputInfo(::Display* x11Display, XRROutputInfo* outputInfo, XRRCrtcInfo* crtcInfo,
+		XRRScreenResources* screenRes, UINT32 resIdx, UINT32 outputIdx)
+	{
+		RRMode currentMode = crtcInfo->mode;
+
+		// Parse output name
+		Atom EDID = XInternAtom(x11Display, "EDID", False);
+
+		INT32 numOutputProps;
+		Atom* outputProps = XRRListOutputProperties(x11Display, screenRes->outputs[resIdx], &numOutputProps);
+
+		for(UINT32 k = 0; k < numOutputProps; k++)
+		{
+			if(outputProps[k] != EDID)
+				continue;
+
+			Atom actualType;
+			unsigned long numItems, bytesAfter;
+			INT32 actualFormat;
+			UINT8* data;
+
+			Status status = XRRGetOutputProperty(x11Display, screenRes->outputs[resIdx], outputProps[k], 0, 100, False,
+					False, AnyPropertyType, &actualType, &actualFormat, &numItems,
+					&bytesAfter, &data);
+			if(status == Success)
+			{
+				// Decode EDID to get the name
+				for(UINT32 l = 0; l < 4; l++)
+				{
+					INT32 idx = 0x36 + l * 18;
+					if(data[idx] == 0 && data[idx + 1] == 0 && data[idx + 3] == 0xFC)
+					{
+						UINT8* nameSrc = &data[idx + 5];
+
+						char name[13];
+						for(UINT32 m = 0; m < 13; m++)
+						{
+							if(nameSrc[m] == 0x0a)
+							{
+								name[m] = '\0';
+								break;
+							}
+							else if(nameSrc[m] == 0x00)
+								name[m] = ' ';
+							else
+								name[m] = nameSrc[m];
+						}
+
+						mName = String(name);
+					}
+				}
+
+				continue;
+			}
+
+			XFree(data);
+			break;
+		}
+
+		XFree(outputProps);
+
+		// Use the output name if display name cannot be found
+		if(mName.empty())
+			mName = outputInfo->name;
+
+		// Enumerate all valid resolutions
+		for(INT32 k = 0; k < screenRes->nmode; k++)
+		{
+			const XRRModeInfo& modeInfo = screenRes->modes[k];
+
+			UINT32 width, height;
+
+			if(crtcInfo->rotation & (XRANDR_ROTATION_LEFT | XRANDR_ROTATION_RIGHT))
+			{
+				width = modeInfo.height;
+				height = modeInfo.width;
+			}
+			else
+			{
+				width = modeInfo.width;
+				height = modeInfo.height;
+			}
+
+			float refreshRate;
+			if(modeInfo.hTotal != 0 && modeInfo.vTotal != 0)
+				refreshRate = (float)(modeInfo.dotClock / (double)(modeInfo.hTotal * modeInfo.vTotal));
+			else
+				refreshRate = 0.0f;
+
+			mVideoModes.push_back(bs_new<LinuxVideoMode>(width, height, refreshRate, outputIdx));
+		}
+
+		// Save current desktop mode
+		for(INT32 k = 0; k < screenRes->nmode; k++)
+		{
+			if(screenRes->modes[k].id == currentMode)
+			{
+				mDesktopVideoMode = bs_new<LinuxVideoMode>(mVideoModes[k]->getWidth(), mVideoModes[k]->getHeight(),
+						mVideoModes[k]->getRefreshRate(), mVideoModes[k]->getOutputIdx());
+				break;
+			}
+		}
+	}
+
+	LinuxVideoMode::LinuxVideoMode(UINT32 width, UINT32 height, float refreshRate, UINT32 outputIdx)
+			:VideoMode(width, height, refreshRate, outputIdx)
+	{ }
+}}

Source/BansheeGLRenderAPI/Linux/BsLinuxVideoModeInfo.h

@@ -0,0 +1,42 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsGLPrerequisites.h"
+#include "RenderAPI/BsVideoModeInfo.h"
+#include <X11/extensions/Xrandr.h>
+
+namespace bs { namespace ct
+{
+	/** @addtogroup GL
+	 *  @{
+	 */
+
+	/** @copydoc VideoMode */
+	class LinuxVideoMode : public VideoMode
+	{
+	public:
+		LinuxVideoMode(UINT32 width, UINT32 height, float refreshRate, UINT32 outputIdx);
+
+	private:
+		friend class LinuxVideoOutputInfo;
+	};
+
+	/** @copydoc VideoOutputInfo */
+	class LinuxVideoOutputInfo : public VideoOutputInfo
+	{
+	public:
+		LinuxVideoOutputInfo(::Display* x11Display, XRROutputInfo* outputInfo, XRRCrtcInfo* crtcInfo,
+			 XRRScreenResources* screenRes, UINT32 resIdx, UINT32 outputIdx);
+	};
+
+	/** @copydoc VideoModeInfo */
+	class LinuxVideoModeInfo : public VideoModeInfo
+	{
+	public:
+		LinuxVideoModeInfo();
+	};
+
+	/** @} */
+}}
+

Source/BansheeMono/BsMonoPrerequisites.h

@@ -86,6 +86,12 @@ namespace bs
 	};
 }
 
+#if BS_PLATFORM == BS_PLATFORM_WIN32
+	#define BS_THUNKCALL BS_STDCALL
+#else
+	#define BS_THUNKCALL
+#endif
+
 typedef struct _MonoClass MonoClass;
 typedef struct _MonoDomain MonoDomain;
 typedef struct _MonoImage MonoImage;

Source/BansheeUtility/Allocators/BsGlobalFrameAlloc.cpp

@@ -8,7 +8,7 @@ namespace bs
 {
 	BS_THREADLOCAL FrameAlloc* _GlobalFrameAlloc = nullptr;
 
-	inline BS_UTILITY_EXPORT FrameAlloc& gFrameAlloc()
+	BS_UTILITY_EXPORT FrameAlloc& gFrameAlloc()
 	{
 		if (_GlobalFrameAlloc == nullptr)
 		{
@@ -20,32 +20,32 @@ namespace bs
 		return *_GlobalFrameAlloc;
 	}
 
-	inline BS_UTILITY_EXPORT UINT8* bs_frame_alloc(UINT32 numBytes)
+	BS_UTILITY_EXPORT UINT8* bs_frame_alloc(UINT32 numBytes)
 	{
 		return gFrameAlloc().alloc(numBytes);
 	}
 
-	inline BS_UTILITY_EXPORT UINT8* bs_frame_alloc_aligned(UINT32 count, UINT32 align)
+	BS_UTILITY_EXPORT UINT8* bs_frame_alloc_aligned(UINT32 count, UINT32 align)
 	{
 		return gFrameAlloc().allocAligned(count, align);
 	}
 
-	inline BS_UTILITY_EXPORT void bs_frame_free(void* data)
+	BS_UTILITY_EXPORT void bs_frame_free(void* data)
 	{
 		gFrameAlloc().dealloc((UINT8*)data);
 	}
 
-	inline BS_UTILITY_EXPORT void bs_frame_free_aligned(void* data)
+	BS_UTILITY_EXPORT void bs_frame_free_aligned(void* data)
 	{
 		gFrameAlloc().dealloc((UINT8*)data);
 	}
 
-	inline BS_UTILITY_EXPORT void bs_frame_mark()
+	BS_UTILITY_EXPORT void bs_frame_mark()
 	{
 		gFrameAlloc().markFrame();
 	}
 
-	inline BS_UTILITY_EXPORT void bs_frame_clear()
+	BS_UTILITY_EXPORT void bs_frame_clear()
 	{
 		gFrameAlloc().clear();
 	}

Source/BansheeUtility/CMakeLists.txt

@@ -11,8 +11,6 @@ set(BansheeUtility_INC
 
 if(WIN32)
 	set(BansheeUtility_INC ${BansheeUtility_INC} "Win32")
-else()
-	# TODO_OTHER_PLATFORMS_GO_HERE
 endif()
 
 include_directories(${BansheeUtility_INC})	

Source/BansheeUtility/CMakeSources.cmake

@@ -328,6 +328,6 @@ set(BS_BANSHEEUTILITY_SRC
 if(WIN32)
 	list(APPEND BS_BANSHEEUTILITY_SRC ${BS_BANSHEEUTILITY_SRC_WIN32})
 	list(APPEND BS_BANSHEEUTILITY_SRC ${BS_BANSHEEUTILITY_INC_WIN32})
-else()
+elseif(LINUX)
 	list(APPEND BS_BANSHEEUTILITY_SRC ${BS_BANSHEEUTILITY_SRC_UNIX})
 endif()

Source/BansheeUtility/Math/BsMath.cpp

@@ -261,23 +261,23 @@ namespace bs
 		return result;
 	}
 
-	inline bool Math::approxEquals(const Vector2& a, const Vector2& b, float tolerance)
+	bool Math::approxEquals(const Vector2& a, const Vector2& b, float tolerance)
 	{
 		return fabs(b.x - a.x) <= tolerance && fabs(b.y - a.y) <= tolerance;
 	}
 
-	inline bool Math::approxEquals(const Vector3& a, const Vector3& b, float tolerance)
+	bool Math::approxEquals(const Vector3& a, const Vector3& b, float tolerance)
 	{
 		return fabs(b.x - a.x) <= tolerance && fabs(b.y - a.y) <= tolerance && fabs(b.z - a.z) <= tolerance;
 	}
 
-	inline bool Math::approxEquals(const Vector4& a, const Vector4& b, float tolerance)
+	bool Math::approxEquals(const Vector4& a, const Vector4& b, float tolerance)
 	{
 		return fabs(b.x - a.x) <= tolerance && fabs(b.y - a.y) <= tolerance && fabs(b.z - a.z) <= tolerance && 
 			fabs(b.w - a.w) <= tolerance;
 	}
 
-	inline bool Math::approxEquals(const Quaternion& a, const Quaternion& b, float tolerance)
+	bool Math::approxEquals(const Quaternion& a, const Quaternion& b, float tolerance)
 	{
 		return fabs(b.x - a.x) <= tolerance && fabs(b.y - a.y) <= tolerance && fabs(b.z - a.z) <= tolerance && 
 			fabs(b.w - a.w) <= tolerance;

Source/BansheeUtility/Math/BsMath.h

@@ -745,13 +745,13 @@ namespace bs
 			coefficients[3] = pointA;
 		}
 
-		static constexpr float Math::POS_INFINITY = std::numeric_limits<float>::infinity();
-		static constexpr float Math::NEG_INFINITY = -std::numeric_limits<float>::infinity();
-		static constexpr float Math::PI = 3.14159265358979323846f;
-		static constexpr float Math::TWO_PI = (float)(2.0f * PI);
-		static constexpr float Math::HALF_PI = (float)(0.5f * PI);
-		static constexpr float Math::DEG2RAD = PI / 180.0f;
-		static constexpr float Math::RAD2DEG = 180.0f / PI;
+		static constexpr float POS_INFINITY = std::numeric_limits<float>::infinity();
+		static constexpr float NEG_INFINITY = -std::numeric_limits<float>::infinity();
+		static constexpr float PI = 3.14159265358979323846f;
+		static constexpr float TWO_PI = (float)(2.0f * PI);
+		static constexpr float HALF_PI = (float)(0.5f * PI);
+		static constexpr float DEG2RAD = PI / 180.0f;
+		static constexpr float RAD2DEG = 180.0f / PI;
 		static const float LOG2;
 	};
 

Source/BansheeUtility/Prerequisites/BsPlatformDefines.h

@@ -27,6 +27,7 @@
 #	define BS_COMP_VER __clang_version__
 #   define BS_THREADLOCAL __thread
 #   define BS_STDCALL __attribute__((stdcall))
+#   define BS_CDECL __attribute__((cdecl))
 #elif defined(__GNUC__) // Check after Clang, as Clang defines this too
 #   define BS_COMPILER BS_COMPILER_GNUC
 #   define BS_COMP_VER (((__GNUC__)*100) + \
@@ -34,16 +35,19 @@
         __GNUC_PATCHLEVEL__)
 #   define BS_THREADLOCAL __thread
 #   define BS_STDCALL __attribute__((stdcall))
+#   define BS_CDECL __attribute__((cdecl))
 #elif defined (__INTEL_COMPILER)
 #   define BS_COMPILER BS_COMPILER_INTEL
 #	define BS_COMP_VER __INTEL_COMPILER
 #   define BS_STDCALL __stdcall
+#   define BS_CDECL __cdecl
 	// BS_THREADLOCAL define is down below because Intel compiler defines it differently based on platform
 #elif defined(_MSC_VER) // Check after Clang and Intel, since we could be building with either within VS
 #   define BS_COMPILER BS_COMPILER_MSVC
 #   define BS_COMP_VER _MSC_VER
 #	define BS_THREADLOCAL __declspec(thread)
 #   define BS_STDCALL __stdcall
+#   define BS_CDECL __cdecl
 #	undef __PRETTY_FUNCTION__
 #	define __PRETTY_FUNCTION__ __FUNCSIG__
 #else

Source/BansheeUtility/String/BsUnicode.h

@@ -6,6 +6,10 @@
 
 namespace bs
 {
+	/** @addtogroup String
+	 *  @{
+	 */
+
 	/** Provides methods to converting between UTF-8 character encoding and other popular encodings. */
 	class BS_UTILITY_EXPORT UTF8
 	{
@@ -81,4 +85,6 @@ namespace bs
 		 */
 		static U32String toUTF32(const String& input);
 	};
+
+	/** @} */
 }

Source/BansheeUtility/Unix/BsUnixFileSystem.cpp

@@ -238,7 +238,7 @@ namespace bs
 	bool FileSystem::iterate(const Path& dirPath, std::function<bool(const Path&)> fileCallback,
 		std::function<bool(const Path&)> dirCallback, bool recursive)
 	{
-		BS_ASSERT(!"TODO: implement FileSystem::iterate()");
+		BS_ASSERT(!"TODOPORT: implement FileSystem::iterate()");
 		return true;
 	}
 

Source/BansheeUtility/Unix/BsUnixPlatformUtility.cpp

@@ -1,13 +1,140 @@
 //********************************** Banshee Engine (www.banshee3d.com) **************************************************//
 //**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
 #include "Utility/BsPlatformUtility.h"
-
 #include <stdlib.h>
+#include <uuid/uuid.h>
+#include <sys/utsname.h>
 
 namespace bs
 {
 	void PlatformUtility::terminate(bool force)
 	{
+		// TODOPORT - Support clean exit by sending the main window a quit message
 		exit(0);
 	}
+
+	SystemInfo PlatformUtility::getSystemInfo()
+	{
+		SystemInfo output;
+
+		// Get CPU vendor, model and number of cores
+		{
+			std::ifstream file("/proc/meminfo");
+			std::string token;
+			while(file >> token)
+			{
+				if(token == "vendor_id")
+				{
+					if(file >> token && token == ":")
+					{
+						std::string vendorId;
+						if(file >> vendorId)
+							output.cpuManufacturer = vendorId.c_str();
+					}
+				}
+				else if(token == "model")
+				{
+					if(file >> token && token == "name")
+					{
+						if (file >> token && token == ":")
+						{
+							std::stringstream modelName;
+							if (file >> token)
+							{
+								modelName << token;
+
+								while (file >> token)
+									modelName << " " << token;
+							}
+
+							output.cpuManufacturer = modelName.str().c_str();
+						}
+					}
+				}
+				else if(token == "cpu")
+				{
+					if(file >> token)
+					{
+						if (token == "cores")
+						{
+							if (file >> token && token == ":")
+							{
+								UINT32 numCores;
+								if (file >> numCores)
+									output.cpuNumCores = numCores;
+							}
+						}
+					}
+				}
+
+				// Ignore the rest of the line
+				file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+			}
+		}
+
+		// Get CPU frequency
+		{
+			std::ifstream file("/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq");
+			UINT32 frequency;
+			if(file >> frequency)
+				output.cpuClockSpeedMhz = frequency / (1000 * 1000);
+		}
+
+		// Get amount of system memory
+		{
+			std::ifstream file("/proc/meminfo");
+			std::string token;
+			while(file >> token)
+			{
+				if(token == "MemTotal:")
+				{
+					UINT32 memTotal;
+					if(file >> memTotal)
+						output.memoryAmountMb = memTotal / (1024 * 1024);
+					else
+						output.memoryAmountMb = 0;
+
+					break;
+				}
+
+				// Ignore the rest of the line
+				file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+			}
+		}
+
+		// Get OS version
+		utsname osInfo;
+		uname(&osInfo);
+
+		// Note: This won't report the exact distro
+		output.osName = String(osInfo.sysname) + String(osInfo.version);
+
+		if (BS_ARCH_TYPE == BS_ARCHITECTURE_x86_64)
+			output.osIs64Bit = true;
+		else
+			output.osIs64Bit = strstr(osInfo.machine, "64") != nullptr;
+
+		// Get GPU info
+		output.gpuInfo = sGPUInfo;
+
+		return output;
+	}
+
+	String PlatformUtility::generateUUID()
+	{
+		uuid_t nativeUUID;
+		uuid_generate(nativeUUID);
+
+		char uuidChars[37];
+		uuid_unparse(nativeUUID, uuidChars);
+
+		return String(uuidChars);
+	}
+
+	void PlatformUtility::open(const Path& path)
+	{
+		// TODOPORT - This call will likely need to be renamed to openURL, and additionals calls
+		// added depending on exact usage, since there is no direct equivalent to ShellExecute on
+		// Linux.
+	}
 }

Source/BansheeUtility/Utility/BsPlatformUtility.h

@@ -56,39 +56,6 @@ namespace bs
 		 */
 		static void terminate(bool force = false);
 
-		/**
-		 * Adds a string to the clipboard.
-		 *
-		 * @note	Thread safe.
-		 */
-		static void copyToClipboard(const WString& string);
-
-		/**
-		 * Reads a string from the clipboard and returns it. If there is no string in the clipboard it returns an empty 
-		 * string.
-		 *
-		 * @note	
-		 * Both wide and normal strings will be read, but normal strings will be converted to a wide string before returning.
-		 * @note
-		 * Thread safe.
-		 */
-		static WString copyFromClipboard();
-
-		/**
-		 * Converts a keyboard key-code to a Unicode character.
-		 *
-		 * @note	
-		 * Normally this will output a single character, but it can happen it outputs multiple in case a accent/diacritic 
-		 * character could not be combined with the virtual key into a single character.
-		 */
-		static WString keyCodeToUnicode(UINT32 keyCode);
-
-		/**
-		 * Populates the provided buffer with a MAC address of the first available adapter, if one exists. If no adapters 
-		 * exist, returns false.
-		 */
-		static bool getMACAddress(MACAddress& address);
-
 		/** Returns information about the underlying hardware. */
 		static SystemInfo getSystemInfo();
 
@@ -118,11 +85,5 @@ namespace bs
 		static GPUInfo sGPUInfo;
 	};
 
-	/** Represents a MAC (ethernet) address. */
-	struct MACAddress
-	{
-		UINT8 value[6];
-	};
-
 	/** @} */
 }

Source/BansheeUtility/Win32/BsWin32PlatformUtility.cpp

@@ -20,112 +20,6 @@ namespace bs
 			TerminateProcess(GetCurrentProcess(), 0);
 	}
 
-	void PlatformUtility::copyToClipboard(const WString& string)
-	{
-		HANDLE hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, (string.size() + 1) * sizeof(WString::value_type));
-		WString::value_type* buffer = (WString::value_type*)GlobalLock(hData);
-
-		string.copy(buffer, string.size());
-		buffer[string.size()] = '\0';
-
-		GlobalUnlock(hData);
-
-		if (OpenClipboard(NULL))
-		{
-			EmptyClipboard();
-			SetClipboardData(CF_UNICODETEXT, hData);
-			CloseClipboard();
-		}
-		else
-		{
-			GlobalFree(hData);
-		}
-	}
-
-	WString PlatformUtility::copyFromClipboard()
-	{
-		if (OpenClipboard(NULL))
-		{
-			HANDLE hData = GetClipboardData(CF_UNICODETEXT);
-
-			if (hData != NULL)
-			{
-				WString::value_type* buffer = (WString::value_type*)GlobalLock(hData);
-				WString string(buffer);
-				GlobalUnlock(hData);
-
-				CloseClipboard();
-				return string;
-			}
-			else
-			{
-				CloseClipboard();
-				return L"";
-			}
-		}
-
-		return L"";
-	}
-
-	WString PlatformUtility::keyCodeToUnicode(UINT32 keyCode)
-	{
-		static HKL keyboardLayout = GetKeyboardLayout(0);
-		static UINT8 keyboarState[256];
-
-		if (GetKeyboardState(keyboarState) == FALSE)
-			return 0;
-
-		UINT virtualKey = MapVirtualKeyExW(keyCode, 1, keyboardLayout);
-
-		wchar_t output[2];
-		int count = ToUnicodeEx(virtualKey, keyCode, keyboarState, output, 2, 0, keyboardLayout);
-		if (count > 0)
-			return WString(output, count);
-
-		return StringUtil::WBLANK;
-	}
-
-	bool PlatformUtility::getMACAddress(MACAddress& address)
-	{
-		std::memset(&address, 0, sizeof(address));
-
-		PIP_ADAPTER_INFO adapterInfo = bs_alloc<IP_ADAPTER_INFO>();
-
-		ULONG len = sizeof(IP_ADAPTER_INFO);
-		DWORD rc = GetAdaptersInfo(adapterInfo, &len);
-
-		if (rc == ERROR_BUFFER_OVERFLOW)
-		{
-			bs_free(adapterInfo);
-			adapterInfo = reinterpret_cast<IP_ADAPTER_INFO*>(bs_alloc(len));
-		}
-		else if (rc != ERROR_SUCCESS)
-		{
-			bs_free(adapterInfo);
-			return false;
-		}
-
-		if (GetAdaptersInfo(adapterInfo, &len) == NO_ERROR)
-		{
-			PIP_ADAPTER_INFO curAdapter = nullptr;
-			curAdapter = adapterInfo;
-
-			while (curAdapter)
-			{
-				if (curAdapter->Type == MIB_IF_TYPE_ETHERNET && curAdapter->AddressLength == sizeof(address))
-				{
-					std::memcpy(&address, curAdapter->Address, curAdapter->AddressLength);
-					return true;
-				}
-
-				curAdapter = curAdapter->Next;
-			}
-		}
-
-		bs_free(adapterInfo);
-		return false;
-	}
-
 	typedef LONG NTSTATUS, *PNTSTATUS;
 	typedef NTSTATUS (WINAPI* RtlGetVersionPtr)(PRTL_OSVERSIONINFOW);
 

Source/CMakeLists.txt

@@ -26,6 +26,10 @@ if(${CMAKE_SIZEOF_VOID_P} EQUAL 8)
 	set(BS_64BIT true)
 endif()
 
+if(UNIX AND NOT APPLE)
+	set(LINUX TRUE)
+endif()
+
 # Options
 set(AUDIO_MODULE "OpenAudio" CACHE STRING "Audio backend to use.")
 set_property(CACHE AUDIO_MODULE PROPERTY STRINGS OpenAudio FMOD)

Source/Examples/ExampleGettingStarted/Main.cpp

@@ -1,7 +1,5 @@
 //********************************** Banshee Engine (www.banshee3d.com) **************************************************//
 //**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
-#include <windows.h>
-
 // Engine includes
 #include "BsApplication.h"
 #include "Resources/BsResources.h"
@@ -29,6 +27,10 @@
 #include "Scene/BsSceneObject.h"
 #include "BsEngineConfig.h"
 
+#if BS_PLATFORM == BS_PLATFORM_WIN32
+#include <windows.h>
+#endif
+
 // Example includes
 #include "CameraFlyer.h"
 
@@ -71,12 +73,16 @@ namespace bs
 using namespace bs;
 
 /** Main entry point into the application. */
+#if BS_PLATFORM == BS_PLATFORM_WIN32
 int CALLBACK WinMain(
 	_In_  HINSTANCE hInstance,
 	_In_  HINSTANCE hPrevInstance,
 	_In_  LPSTR lpCmdLine,
 	_In_  int nCmdShow
 	)
+#else
+int main()
+#endif
 {
 	// Ensure all errors are reported properly
 	CrashHandler::startUp();

Source/RenderBeast/BsLightProbes.cpp

@@ -25,8 +25,7 @@ namespace bs { namespace ct
 		ShaderVariation::Param("MSAA_RESOLVE_0TH", true)
 	});
 
-	ShaderVariation TetrahedraRenderMat::VAR_NoMSAA = ShaderVariation({
-	});
+	ShaderVariation TetrahedraRenderMat::VAR_NoMSAA = ShaderVariation();
 
 	TetrahedraRenderMat::TetrahedraRenderMat()
 	{

Source/RenderBeast/BsLightRendering.cpp

@@ -62,6 +62,8 @@ namespace bs { namespace ct
 		case LightType::Spot:
 			type = 0.8f;
 			break;
+		default:
+			break;
 		}
 
 		gPerLightParamDef.gLightPositionAndSrcRadius.set(buffer, Vector4(lightData.position, lightData.srcRadius));
@@ -167,7 +169,7 @@ namespace bs { namespace ct
 		auto partition = [](Vector<const RendererLight*>& entries)
 		{
 			int first = 0;
-			for (int i = 0; i < entries.size(); ++i)
+			for (UINT32 i = 0; i < (UINT32)entries.size(); ++i)
 			{
 				if(entries[i]->internal->getCastsShadow())
 				{
@@ -176,7 +178,7 @@ namespace bs { namespace ct
 				}
 			}
 
-			for(int i = first + 1; i < entries.size(); ++i)
+			for(UINT32 i = first + 1; i < (UINT32)entries.size(); ++i)
 			{
 				if(!entries[i]->internal->getCastsShadow())
 				{

Source/RenderBeast/BsPostProcessing.cpp

@@ -978,7 +978,6 @@ namespace bs { namespace ct
 		const SPtr<RenderTexture>& output)
 	{
 		RenderAPI& rapi = RenderAPI::instance();
-		const TextureProperties& srcProps = source->getProperties();
 
 		mInputTexture.set(source, TextureSurface(srcMip));
 		rapi.setRenderTarget(output);

Source/RenderBeast/BsRenderCompositor.cpp

@@ -96,7 +96,7 @@ namespace bs { namespace ct
 					curIdx = iterFind2->second;
 
 					// Check if invalid
-					if (curIdx == -1)
+					if (curIdx == (UINT32)-1)
 					{
 						LOGERR("Render compositor nodes recursion detected. Node \"" + String(nodeId.cstr()) + "\" " +
 							"depends on node \"" + String(iterFind->first.cstr()) + "\" which is not available at " +
@@ -111,7 +111,7 @@ namespace bs { namespace ct
 					iterFind2 = processedNodes.find(dep);
 
 					NodeInfo& depNodeInfo = mNodeInfos[iterFind2->second];
-					if (depNodeInfo.lastUseIdx == -1)
+					if (depNodeInfo.lastUseIdx == (UINT32)-1)
 						depNodeInfo.lastUseIdx = curIdx;
 					else
 						depNodeInfo.lastUseIdx = std::max(depNodeInfo.lastUseIdx, curIdx);
@@ -269,7 +269,7 @@ namespace bs { namespace ct
 
 			for (auto& element : inputs.scene.renderables[i]->elements)
 			{
-				if (element.perCameraBindingIdx != -1)
+				if (element.perCameraBindingIdx != (UINT32)-1)
 					element.params->setParamBlockBuffer(element.perCameraBindingIdx, inputs.view.getPerViewBuffer(), true);
 			}
 		}
@@ -963,7 +963,7 @@ namespace bs { namespace ct
 				// Note: It would be nice to be able to set this once and keep it, only updating if the buffers actually
 				// change (e.g. when growing). Although technically the internal systems should be smart enough to
 				// avoid updates unless objects actually changed.
-				if (element.gridParamsBindingIdx != -1)
+				if (element.gridParamsBindingIdx != (UINT32)-1)
 					element.params->setParamBlockBuffer(element.gridParamsBindingIdx, gridParams, true);
 
 				element.gridLightOffsetsAndSizeParam.set(gridLightOffsetsAndSize);
@@ -972,7 +972,7 @@ namespace bs { namespace ct
 
 				// Image based lighting params
 				ImageBasedLightingParams& iblParams = element.imageBasedParams;
-				if (iblParams.reflProbeParamsBindingIdx != -1)
+				if (iblParams.reflProbeParamsBindingIdx != (UINT32)-1)
 					element.params->setParamBlockBuffer(iblParams.reflProbeParamsBindingIdx, reflProbeParamBuffer.buffer);
 
 				element.gridProbeOffsetsAndSizeParam.set(gridProbeOffsetsAndSize);

Source/RenderBeast/BsRendererView.cpp

@@ -376,9 +376,6 @@ namespace bs { namespace ct
 		// Are we reorganize it because it needs to fit the "(1.0f / (depth + y)) * x" format used in the shader:
 		// z = 1.0f / (depth - A/C) * B/C
 
-		RenderAPI& rapi = RenderAPI::instance();
-		const RenderAPIInfo& rapiInfo = rapi.getAPIInfo();
-
 		float a = projMatrix[2][2];
 		float b = projMatrix[2][3];
 		float c = projMatrix[3][2];

Source/RenderBeast/BsShadowRendering.cpp

@@ -487,7 +487,7 @@ namespace bs { namespace ct
 		rtDesc.depthStencilSurface.texture = mShadowMap->texture;
 		rtDesc.depthStencilSurface.numFaces = 1;
 
-		for (int i = 0; i < NUM_CASCADE_SPLITS; ++i)
+		for (UINT32 i = 0; i < NUM_CASCADE_SPLITS; ++i)
 		{
 			rtDesc.depthStencilSurface.face = i;
 			mTargets[i] = RenderTexture::create(rtDesc);
@@ -1051,7 +1051,7 @@ namespace bs { namespace ct
 			}
 		}
 
-		if (shadowInfo.textureIdx == -1)
+		if (shadowInfo.textureIdx == (UINT32)-1)
 		{
 			shadowInfo.textureIdx = (UINT32)mCascadedShadowMaps.size();
 			mCascadedShadowMaps.push_back(ShadowCascadedMap(mapSize));
@@ -1066,7 +1066,7 @@ namespace bs { namespace ct
 		lightRotation.lookRotation(-light->getRotation().zAxis());
 
 		Matrix4 viewMat = Matrix4::view(light->getPosition(), lightRotation);
-		for (int i = 0; i < NUM_CASCADE_SPLITS; ++i)
+		for (UINT32 i = 0; i < NUM_CASCADE_SPLITS; ++i)
 		{
 			Sphere frustumBounds;
 			ConvexVolume cascadeCullVolume = getCSMSplitFrustum(view, -lightDir, i, NUM_CASCADE_SPLITS, frustumBounds);
@@ -1098,7 +1098,7 @@ namespace bs { namespace ct
 			shadowInfo.depthFade = splitFar;
 			shadowInfo.subjectBounds = frustumBounds;
 			
-			if ((i + 1) < NUM_CASCADE_SPLITS)
+			if ((UINT32)(i + 1) < NUM_CASCADE_SPLITS)
 				shadowInfo.fadeRange = CASCADE_FRACTION_FADE * (shadowInfo.depthFade - shadowInfo.depthNear);
 			else
 				shadowInfo.fadeRange = 0.0f;
@@ -1287,7 +1287,7 @@ namespace bs { namespace ct
 			}
 		}
 
-		if (mapInfo.textureIdx == -1)
+		if (mapInfo.textureIdx == (UINT32)-1)
 		{
 			mapInfo.textureIdx = (UINT32)mShadowCubemaps.size();
 			mShadowCubemaps.push_back(ShadowCubemap(options.mapSize));
@@ -1623,7 +1623,7 @@ namespace bs { namespace ct
 		for (auto& entry : frustumVerts)
 			radius = std::max(radius, center.squaredDistance(entry));
 
-		radius = std::max(sqrt(radius), 1.0f);
+		radius = std::max((float)sqrt(radius), 1.0f);
 		outBounds = Sphere(center, radius);
 
 		// Generate light frustum planes
@@ -1766,6 +1766,8 @@ namespace bs { namespace ct
 		case LightType::Spot: 
 			defaultBias = SPOT_DEPTH_BIAS;
 			break;
+		default:
+			break;
 		}
 		
 		return defaultBias * light.getShadowBias() * resolutionScale * rangeScale;

Source/SBansheeEditor/BsManagedEditorCommand.cpp

@@ -30,7 +30,7 @@ namespace bs
 
 	void ScriptCmdManaged::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptCmdManaged::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptCmdManaged::internal_CreateInstance);
 
 		sCommitMethod = metaData.scriptClass->getMethod("Commit");
 		sRevertMethod = metaData.scriptClass->getMethod("Revert");

Source/SBansheeEditor/BsScriptHandleManager.h

@@ -126,7 +126,7 @@ namespace bs
 		MonoClass* mHandleBaseClass = nullptr;
 		MonoClass* mDefaultHandleManagerClass = nullptr;
 
-		typedef void(__stdcall *DestroyThunkDef) (MonoObject*, MonoException**);
+		typedef void(BS_THUNKCALL *DestroyThunkDef) (MonoObject*, MonoException**);
 
 		MonoMethod* mPreInputMethod;
 		MonoMethod* mPostInputMethod;

Source/SBansheeEditor/Wrappers/BsScriptBrowseDialog.cpp

@@ -10,9 +10,9 @@ namespace bs
 {
 	void ScriptBrowseDialog::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_OpenFile", &ScriptBrowseDialog::internal_OpenFile);
-		metaData.scriptClass->addInternalCall("Internal_OpenFolder", &ScriptBrowseDialog::internal_OpenFolder);
-		metaData.scriptClass->addInternalCall("Internal_SaveFile", &ScriptBrowseDialog::internal_SaveFile);
+		metaData.scriptClass->addInternalCall("Internal_OpenFile", (void*)&ScriptBrowseDialog::internal_OpenFile);
+		metaData.scriptClass->addInternalCall("Internal_OpenFolder", (void*)&ScriptBrowseDialog::internal_OpenFolder);
+		metaData.scriptClass->addInternalCall("Internal_SaveFile", (void*)&ScriptBrowseDialog::internal_SaveFile);
 	}
 
 	bool ScriptBrowseDialog::internal_OpenFile(MonoString* defaultFolder, MonoString* filterList, bool allowMultiselect, MonoArray** outPaths)

Source/SBansheeEditor/Wrappers/BsScriptBuildManager.cpp

@@ -30,19 +30,19 @@ namespace bs
 
 	void ScriptBuildManager::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_GetAvailablePlatforms", &ScriptBuildManager::internal_GetAvailablePlatforms);
-		metaData.scriptClass->addInternalCall("Internal_GetActivePlatform", &ScriptBuildManager::internal_GetActivePlatform);
-		metaData.scriptClass->addInternalCall("Internal_SetActivePlatform", &ScriptBuildManager::internal_SetActivePlatform);
-		metaData.scriptClass->addInternalCall("Internal_GetActivePlatformInfo", &ScriptBuildManager::internal_GetActivePlatformInfo);
-		metaData.scriptClass->addInternalCall("Internal_GetPlatformInfo", &ScriptBuildManager::internal_GetPlatformInfo);
-		metaData.scriptClass->addInternalCall("Internal_GetFrameworkAssemblies", &ScriptBuildManager::internal_GetFrameworkAssemblies);
-		metaData.scriptClass->addInternalCall("Internal_GetMainExecutable", &ScriptBuildManager::internal_GetMainExecutable);
-		metaData.scriptClass->addInternalCall("Internal_GetDefines", &ScriptBuildManager::internal_GetDefines);
-		metaData.scriptClass->addInternalCall("Internal_GetNativeBinaries", &ScriptBuildManager::internal_GetNativeBinaries);
-		metaData.scriptClass->addInternalCall("Internal_GetBuildFolder", &ScriptBuildManager::internal_GetBuildFolder);
-		metaData.scriptClass->addInternalCall("Internal_InjectIcons", &ScriptBuildManager::internal_InjectIcons);
-		metaData.scriptClass->addInternalCall("Internal_PackageResources", &ScriptBuildManager::internal_PackageResources);
-		metaData.scriptClass->addInternalCall("Internal_CreateStartupSettings", &ScriptBuildManager::internal_CreateStartupSettings);
+		metaData.scriptClass->addInternalCall("Internal_GetAvailablePlatforms", (void*)&ScriptBuildManager::internal_GetAvailablePlatforms);
+		metaData.scriptClass->addInternalCall("Internal_GetActivePlatform", (void*)&ScriptBuildManager::internal_GetActivePlatform);
+		metaData.scriptClass->addInternalCall("Internal_SetActivePlatform", (void*)&ScriptBuildManager::internal_SetActivePlatform);
+		metaData.scriptClass->addInternalCall("Internal_GetActivePlatformInfo", (void*)&ScriptBuildManager::internal_GetActivePlatformInfo);
+		metaData.scriptClass->addInternalCall("Internal_GetPlatformInfo", (void*)&ScriptBuildManager::internal_GetPlatformInfo);
+		metaData.scriptClass->addInternalCall("Internal_GetFrameworkAssemblies", (void*)&ScriptBuildManager::internal_GetFrameworkAssemblies);
+		metaData.scriptClass->addInternalCall("Internal_GetMainExecutable", (void*)&ScriptBuildManager::internal_GetMainExecutable);
+		metaData.scriptClass->addInternalCall("Internal_GetDefines", (void*)&ScriptBuildManager::internal_GetDefines);
+		metaData.scriptClass->addInternalCall("Internal_GetNativeBinaries", (void*)&ScriptBuildManager::internal_GetNativeBinaries);
+		metaData.scriptClass->addInternalCall("Internal_GetBuildFolder", (void*)&ScriptBuildManager::internal_GetBuildFolder);
+		metaData.scriptClass->addInternalCall("Internal_InjectIcons", (void*)&ScriptBuildManager::internal_InjectIcons);
+		metaData.scriptClass->addInternalCall("Internal_PackageResources", (void*)&ScriptBuildManager::internal_PackageResources);
+		metaData.scriptClass->addInternalCall("Internal_CreateStartupSettings", (void*)&ScriptBuildManager::internal_CreateStartupSettings);
 	}
 
 	MonoArray* ScriptBuildManager::internal_GetAvailablePlatforms()
@@ -304,8 +304,7 @@ namespace bs
 		for (auto& entry : usedResources)
 		{
 			String uuid;
-			bool foundUUID = gResources().getUUIDFromFilePath(entry, uuid);
-			BS_ASSERT(foundUUID);
+			BS_ASSERT(gResources().getUUIDFromFilePath(entry, uuid));
 
 			Path sourcePath = gProjectLibrary().uuidToPath(uuid);
 			if (sourcePath.isEmpty()) // Resource not part of library, meaning its built-in and we don't need to copy those here

Source/SBansheeEditor/Wrappers/BsScriptCodeEditor.cpp

@@ -19,11 +19,11 @@ namespace bs
 
 	void ScriptCodeEditor::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_SetActiveEditor", &ScriptCodeEditor::internal_SetActiveEditor);
-		metaData.scriptClass->addInternalCall("Internal_GetActiveEditor", &ScriptCodeEditor::internal_GetActiveEditor);
-		metaData.scriptClass->addInternalCall("Internal_GetAvailableEditors", &ScriptCodeEditor::internal_GetAvailableEditors);
-		metaData.scriptClass->addInternalCall("Internal_OpenFile", &ScriptCodeEditor::internal_OpenFile);
-		metaData.scriptClass->addInternalCall("Internal_SyncSolution", &ScriptCodeEditor::internal_SyncSolution);
+		metaData.scriptClass->addInternalCall("Internal_SetActiveEditor", (void*)&ScriptCodeEditor::internal_SetActiveEditor);
+		metaData.scriptClass->addInternalCall("Internal_GetActiveEditor", (void*)&ScriptCodeEditor::internal_GetActiveEditor);
+		metaData.scriptClass->addInternalCall("Internal_GetAvailableEditors", (void*)&ScriptCodeEditor::internal_GetAvailableEditors);
+		metaData.scriptClass->addInternalCall("Internal_OpenFile", (void*)&ScriptCodeEditor::internal_OpenFile);
+		metaData.scriptClass->addInternalCall("Internal_SyncSolution", (void*)&ScriptCodeEditor::internal_SyncSolution);
 	}
 
 	CodeEditorType ScriptCodeEditor::internal_GetActiveEditor()

Source/SBansheeEditor/Wrappers/BsScriptDragDropManager.cpp

@@ -21,12 +21,12 @@ namespace bs
 
 	void ScriptDragDrop::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_IsDragInProgress", &ScriptDragDrop::internal_IsDragInProgress);
-		metaData.scriptClass->addInternalCall("Internal_IsDropInProgress", &ScriptDragDrop::internal_IsDropInProgress);
-		metaData.scriptClass->addInternalCall("Internal_GetData", &ScriptDragDrop::internal_GetData);
-		metaData.scriptClass->addInternalCall("Internal_GetDragType", &ScriptDragDrop::internal_GetDragType);
-		metaData.scriptClass->addInternalCall("Internal_StartSceneObjectDrag", &ScriptDragDrop::internal_StartSceneObjectDrag);
-		metaData.scriptClass->addInternalCall("Internal_StartResourceDrag", &ScriptDragDrop::internal_StartResourceDrag);
+		metaData.scriptClass->addInternalCall("Internal_IsDragInProgress", (void*)&ScriptDragDrop::internal_IsDragInProgress);
+		metaData.scriptClass->addInternalCall("Internal_IsDropInProgress", (void*)&ScriptDragDrop::internal_IsDropInProgress);
+		metaData.scriptClass->addInternalCall("Internal_GetData", (void*)&ScriptDragDrop::internal_GetData);
+		metaData.scriptClass->addInternalCall("Internal_GetDragType", (void*)&ScriptDragDrop::internal_GetDragType);
+		metaData.scriptClass->addInternalCall("Internal_StartSceneObjectDrag", (void*)&ScriptDragDrop::internal_StartSceneObjectDrag);
+		metaData.scriptClass->addInternalCall("Internal_StartResourceDrag", (void*)&ScriptDragDrop::internal_StartResourceDrag);
 	}
 
 	bool ScriptDragDrop::internal_IsDragInProgress()
@@ -92,8 +92,8 @@ namespace bs
 
 	void ScriptSceneObjectDragDropData::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptSceneObjectDragDropData::internal_CreateInstance);
-		metaData.scriptClass->addInternalCall("Internal_GetObjects", &ScriptSceneObjectDragDropData::internal_GetObjects);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptSceneObjectDragDropData::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetObjects", (void*)&ScriptSceneObjectDragDropData::internal_GetObjects);
 	}
 
 	MonoObject* ScriptSceneObjectDragDropData::create(const Vector<HSceneObject>& sceneObjects)
@@ -150,8 +150,8 @@ namespace bs
 
 	void ScriptResourceDragDropData::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptResourceDragDropData::internal_CreateInstance);
-		metaData.scriptClass->addInternalCall("Internal_GetPaths", &ScriptResourceDragDropData::internal_GetPaths);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptResourceDragDropData::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetPaths", (void*)&ScriptResourceDragDropData::internal_GetPaths);
 	}
 
 	MonoObject* ScriptResourceDragDropData::create(const Vector<Path>& paths)

Source/SBansheeEditor/Wrappers/BsScriptDropDownWindow.cpp

@@ -39,14 +39,14 @@ namespace bs
 
 	void ScriptDropDownWindow::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptDropDownWindow::internal_CreateInstance);
-		metaData.scriptClass->addInternalCall("Internal_Close", &ScriptDropDownWindow::internal_Close);
-		metaData.scriptClass->addInternalCall("Internal_GetWidth", &ScriptDropDownWindow::internal_GetWidth);
-		metaData.scriptClass->addInternalCall("Internal_SetWidth", &ScriptDropDownWindow::internal_SetWidth);
-		metaData.scriptClass->addInternalCall("Internal_GetHeight", &ScriptDropDownWindow::internal_GetHeight);
-		metaData.scriptClass->addInternalCall("Internal_SetHeight", &ScriptDropDownWindow::internal_SetHeight);
-		metaData.scriptClass->addInternalCall("Internal_ScreenToWindowPos", &ScriptDropDownWindow::internal_ScreenToWindowPos);
-		metaData.scriptClass->addInternalCall("Internal_WindowToScreenPos", &ScriptDropDownWindow::internal_WindowToScreenPos);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptDropDownWindow::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_Close", (void*)&ScriptDropDownWindow::internal_Close);
+		metaData.scriptClass->addInternalCall("Internal_GetWidth", (void*)&ScriptDropDownWindow::internal_GetWidth);
+		metaData.scriptClass->addInternalCall("Internal_SetWidth", (void*)&ScriptDropDownWindow::internal_SetWidth);
+		metaData.scriptClass->addInternalCall("Internal_GetHeight", (void*)&ScriptDropDownWindow::internal_GetHeight);
+		metaData.scriptClass->addInternalCall("Internal_SetHeight", (void*)&ScriptDropDownWindow::internal_SetHeight);
+		metaData.scriptClass->addInternalCall("Internal_ScreenToWindowPos", (void*)&ScriptDropDownWindow::internal_ScreenToWindowPos);
+		metaData.scriptClass->addInternalCall("Internal_WindowToScreenPos", (void*)&ScriptDropDownWindow::internal_WindowToScreenPos);
 
 		guiPanelField = metaData.scriptClass->getField("GUI");
 	}

Source/SBansheeEditor/Wrappers/BsScriptDropDownWindow.h

@@ -88,9 +88,9 @@ namespace bs
 	private:
 		friend class ScriptModalWindow;
 
-		typedef void(__stdcall *OnInitializeThunkDef) (MonoObject*, MonoException**);
-		typedef void(__stdcall *OnDestroyThunkDef) (MonoObject*, MonoException**);
-		typedef void(__stdcall *UpdateThunkDef) (MonoObject*, MonoException**);
+		typedef void(BS_THUNKCALL *OnInitializeThunkDef) (MonoObject*, MonoException**);
+		typedef void(BS_THUNKCALL *OnDestroyThunkDef) (MonoObject*, MonoException**);
+		typedef void(BS_THUNKCALL *UpdateThunkDef) (MonoObject*, MonoException**);
 
 		String mNamespace;
 		String mTypename;

Source/SBansheeEditor/Wrappers/BsScriptEditorApplication.cpp

@@ -39,39 +39,39 @@ namespace bs
 
 	void ScriptEditorApplication::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_SetStatusScene", &ScriptEditorApplication::internal_SetStatusScene);
-		metaData.scriptClass->addInternalCall("Internal_SetStatusProject", &ScriptEditorApplication::internal_SetStatusProject);
-		metaData.scriptClass->addInternalCall("Internal_SetStatusCompiling", &ScriptEditorApplication::internal_SetStatusCompiling);
-		metaData.scriptClass->addInternalCall("Internal_GetProjectPath", &ScriptEditorApplication::internal_GetProjectPath);
-		metaData.scriptClass->addInternalCall("Internal_GetProjectName", &ScriptEditorApplication::internal_GetProjectName);
-		metaData.scriptClass->addInternalCall("Internal_GetProjectLoaded", &ScriptEditorApplication::internal_GetProjectLoaded);
-		metaData.scriptClass->addInternalCall("Internal_GetCompilerPath", &ScriptEditorApplication::internal_GetCompilerPath);
-		metaData.scriptClass->addInternalCall("Internal_GetBuiltinReleaseAssemblyPath", &ScriptEditorApplication::internal_GetBuiltinReleaseAssemblyPath);
-		metaData.scriptClass->addInternalCall("Internal_GetBuiltinDebugAssemblyPath", &ScriptEditorApplication::internal_GetBuiltinDebugAssemblyPath);
-		metaData.scriptClass->addInternalCall("Internal_GetScriptAssemblyPath", &ScriptEditorApplication::internal_GetScriptAssemblyPath);
-		metaData.scriptClass->addInternalCall("Internal_GetFrameworkAssemblyPath", &ScriptEditorApplication::internal_GetFrameworkAssemblyPath);
-		metaData.scriptClass->addInternalCall("Internal_GetEngineAssemblyName", &ScriptEditorApplication::internal_GetEngineAssemblyName);
-		metaData.scriptClass->addInternalCall("Internal_GetEditorAssemblyName", &ScriptEditorApplication::internal_GetEditorAssemblyName);
-		metaData.scriptClass->addInternalCall("Internal_GetScriptGameAssemblyName", &ScriptEditorApplication::internal_GetScriptGameAssemblyName);
-		metaData.scriptClass->addInternalCall("Internal_GetScriptEditorAssemblyName", &ScriptEditorApplication::internal_GetScriptEditorAssemblyName);
-		metaData.scriptClass->addInternalCall("Internal_SaveScene", &ScriptEditorApplication::internal_SaveScene);
-		metaData.scriptClass->addInternalCall("Internal_IsValidProject", &ScriptEditorApplication::internal_IsValidProject);
-		metaData.scriptClass->addInternalCall("Internal_SaveProject", &ScriptEditorApplication::internal_SaveProject);
-		metaData.scriptClass->addInternalCall("Internal_LoadProject", &ScriptEditorApplication::internal_LoadProject);
-		metaData.scriptClass->addInternalCall("Internal_UnloadProject", &ScriptEditorApplication::internal_UnloadProject);
-		metaData.scriptClass->addInternalCall("Internal_CreateProject", &ScriptEditorApplication::internal_CreateProject);
-		metaData.scriptClass->addInternalCall("Internal_ReloadAssemblies", &ScriptEditorApplication::internal_ReloadAssemblies);
-		metaData.scriptClass->addInternalCall("Internal_OpenExternally", &ScriptEditorApplication::internal_OpenExternally);
-		metaData.scriptClass->addInternalCall("Internal_RunUnitTests", &ScriptEditorApplication::internal_RunUnitTests);
-		metaData.scriptClass->addInternalCall("Internal_Quit", &ScriptEditorApplication::internal_Quit);
-		metaData.scriptClass->addInternalCall("Internal_ToggleToolbarItem", &ScriptEditorApplication::internal_ToggleToolbarItem);
-		metaData.scriptClass->addInternalCall("Internal_GetIsPlaying", &ScriptEditorApplication::internal_GetIsPlaying);
-		metaData.scriptClass->addInternalCall("Internal_SetIsPlaying", &ScriptEditorApplication::internal_SetIsPlaying);
-		metaData.scriptClass->addInternalCall("Internal_GetIsPaused", &ScriptEditorApplication::internal_GetIsPaused);
-		metaData.scriptClass->addInternalCall("Internal_SetIsPaused", &ScriptEditorApplication::internal_SetIsPaused);
-		metaData.scriptClass->addInternalCall("Internal_FrameStep", &ScriptEditorApplication::internal_FrameStep);
-		metaData.scriptClass->addInternalCall("Internal_SetMainRenderTarget", &ScriptEditorApplication::internal_SetMainRenderTarget);
-		metaData.scriptClass->addInternalCall("Internal_HasFocus", &ScriptEditorApplication::internal_HasFocus);
+		metaData.scriptClass->addInternalCall("Internal_SetStatusScene", (void*)&ScriptEditorApplication::internal_SetStatusScene);
+		metaData.scriptClass->addInternalCall("Internal_SetStatusProject", (void*)&ScriptEditorApplication::internal_SetStatusProject);
+		metaData.scriptClass->addInternalCall("Internal_SetStatusCompiling", (void*)&ScriptEditorApplication::internal_SetStatusCompiling);
+		metaData.scriptClass->addInternalCall("Internal_GetProjectPath", (void*)&ScriptEditorApplication::internal_GetProjectPath);
+		metaData.scriptClass->addInternalCall("Internal_GetProjectName", (void*)&ScriptEditorApplication::internal_GetProjectName);
+		metaData.scriptClass->addInternalCall("Internal_GetProjectLoaded", (void*)&ScriptEditorApplication::internal_GetProjectLoaded);
+		metaData.scriptClass->addInternalCall("Internal_GetCompilerPath", (void*)&ScriptEditorApplication::internal_GetCompilerPath);
+		metaData.scriptClass->addInternalCall("Internal_GetBuiltinReleaseAssemblyPath", (void*)&ScriptEditorApplication::internal_GetBuiltinReleaseAssemblyPath);
+		metaData.scriptClass->addInternalCall("Internal_GetBuiltinDebugAssemblyPath", (void*)&ScriptEditorApplication::internal_GetBuiltinDebugAssemblyPath);
+		metaData.scriptClass->addInternalCall("Internal_GetScriptAssemblyPath", (void*)&ScriptEditorApplication::internal_GetScriptAssemblyPath);
+		metaData.scriptClass->addInternalCall("Internal_GetFrameworkAssemblyPath", (void*)&ScriptEditorApplication::internal_GetFrameworkAssemblyPath);
+		metaData.scriptClass->addInternalCall("Internal_GetEngineAssemblyName", (void*)&ScriptEditorApplication::internal_GetEngineAssemblyName);
+		metaData.scriptClass->addInternalCall("Internal_GetEditorAssemblyName", (void*)&ScriptEditorApplication::internal_GetEditorAssemblyName);
+		metaData.scriptClass->addInternalCall("Internal_GetScriptGameAssemblyName", (void*)&ScriptEditorApplication::internal_GetScriptGameAssemblyName);
+		metaData.scriptClass->addInternalCall("Internal_GetScriptEditorAssemblyName", (void*)&ScriptEditorApplication::internal_GetScriptEditorAssemblyName);
+		metaData.scriptClass->addInternalCall("Internal_SaveScene", (void*)&ScriptEditorApplication::internal_SaveScene);
+		metaData.scriptClass->addInternalCall("Internal_IsValidProject", (void*)&ScriptEditorApplication::internal_IsValidProject);
+		metaData.scriptClass->addInternalCall("Internal_SaveProject", (void*)&ScriptEditorApplication::internal_SaveProject);
+		metaData.scriptClass->addInternalCall("Internal_LoadProject", (void*)&ScriptEditorApplication::internal_LoadProject);
+		metaData.scriptClass->addInternalCall("Internal_UnloadProject", (void*)&ScriptEditorApplication::internal_UnloadProject);
+		metaData.scriptClass->addInternalCall("Internal_CreateProject", (void*)&ScriptEditorApplication::internal_CreateProject);
+		metaData.scriptClass->addInternalCall("Internal_ReloadAssemblies", (void*)&ScriptEditorApplication::internal_ReloadAssemblies);
+		metaData.scriptClass->addInternalCall("Internal_OpenExternally", (void*)&ScriptEditorApplication::internal_OpenExternally);
+		metaData.scriptClass->addInternalCall("Internal_RunUnitTests", (void*)&ScriptEditorApplication::internal_RunUnitTests);
+		metaData.scriptClass->addInternalCall("Internal_Quit", (void*)&ScriptEditorApplication::internal_Quit);
+		metaData.scriptClass->addInternalCall("Internal_ToggleToolbarItem", (void*)&ScriptEditorApplication::internal_ToggleToolbarItem);
+		metaData.scriptClass->addInternalCall("Internal_GetIsPlaying", (void*)&ScriptEditorApplication::internal_GetIsPlaying);
+		metaData.scriptClass->addInternalCall("Internal_SetIsPlaying", (void*)&ScriptEditorApplication::internal_SetIsPlaying);
+		metaData.scriptClass->addInternalCall("Internal_GetIsPaused", (void*)&ScriptEditorApplication::internal_GetIsPaused);
+		metaData.scriptClass->addInternalCall("Internal_SetIsPaused", (void*)&ScriptEditorApplication::internal_SetIsPaused);
+		metaData.scriptClass->addInternalCall("Internal_FrameStep", (void*)&ScriptEditorApplication::internal_FrameStep);
+		metaData.scriptClass->addInternalCall("Internal_SetMainRenderTarget", (void*)&ScriptEditorApplication::internal_SetMainRenderTarget);
+		metaData.scriptClass->addInternalCall("Internal_HasFocus", (void*)&ScriptEditorApplication::internal_HasFocus);
 
 		onProjectLoadedThunk = (OnProjectLoadedThunkDef)metaData.scriptClass->getMethod("Internal_OnProjectLoaded")->getThunk();
 		onStatusBarClickedThunk = (OnStatusBarClickedThunkDef)metaData.scriptClass->getMethod("Internal_OnStatusBarClicked")->getThunk();

Source/SBansheeEditor/Wrappers/BsScriptEditorApplication.h

@@ -74,8 +74,8 @@ namespace bs
 		static void internal_SetMainRenderTarget(ScriptRenderTarget* renderTarget);
 		static bool internal_HasFocus();
 
-		typedef void(__stdcall *OnProjectLoadedThunkDef)(MonoException**);
-		typedef void(__stdcall *OnStatusBarClickedThunkDef) (MonoException**);
+		typedef void(BS_THUNKCALL *OnProjectLoadedThunkDef)(MonoException**);
+		typedef void(BS_THUNKCALL *OnStatusBarClickedThunkDef) (MonoException**);
 
 		static OnProjectLoadedThunkDef onProjectLoadedThunk;
 		static OnStatusBarClickedThunkDef onStatusBarClickedThunk;

Source/SBansheeEditor/Wrappers/BsScriptEditorBuiltin.cpp

@@ -19,18 +19,18 @@ namespace bs
 
 	void ScriptEditorBuiltin::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_GetLibraryItemIcon", &ScriptEditorBuiltin::internal_getLibraryItemIcon);
-		metaData.scriptClass->addInternalCall("Internal_GetEmptyShaderCode", &ScriptEditorBuiltin::internal_GetEmptyShaderCode);
-		metaData.scriptClass->addInternalCall("Internal_GetEmptyCSScriptCode", &ScriptEditorBuiltin::internal_GetEmptyCSScriptCode);
-		metaData.scriptClass->addInternalCall("Internal_GetToolbarIcon", &ScriptEditorBuiltin::internal_GetToolbarIcon);
-		metaData.scriptClass->addInternalCall("Internal_GetLibraryWindowIcon", &ScriptEditorBuiltin::internal_GetLibraryWindowIcon);
-		metaData.scriptClass->addInternalCall("Internal_GetInspectorWindowIcon", &ScriptEditorBuiltin::internal_GetInspectorWindowIcon);
-		metaData.scriptClass->addInternalCall("Internal_GetSceneWindowIcon", &ScriptEditorBuiltin::internal_GetSceneWindowIcon);
-		metaData.scriptClass->addInternalCall("Internal_GetAnimationWindowIcon", &ScriptEditorBuiltin::internal_GetAnimationWindowIcon);
-		metaData.scriptClass->addInternalCall("Internal_GetLogIcon", &ScriptEditorBuiltin::internal_GetLogIcon);
-		metaData.scriptClass->addInternalCall("Internal_GetEditorIcon", &ScriptEditorBuiltin::internal_GetEditorIcon);
-		metaData.scriptClass->addInternalCall("Internal_GetDefaultFont", &ScriptEditorBuiltin::internal_GetDefaultFont);
-		metaData.scriptClass->addInternalCall("Internal_GetGUISkin", &ScriptEditorBuiltin::internal_GetGUISkin);
+		metaData.scriptClass->addInternalCall("Internal_GetLibraryItemIcon", (void*)&ScriptEditorBuiltin::internal_getLibraryItemIcon);
+		metaData.scriptClass->addInternalCall("Internal_GetEmptyShaderCode", (void*)&ScriptEditorBuiltin::internal_GetEmptyShaderCode);
+		metaData.scriptClass->addInternalCall("Internal_GetEmptyCSScriptCode", (void*)&ScriptEditorBuiltin::internal_GetEmptyCSScriptCode);
+		metaData.scriptClass->addInternalCall("Internal_GetToolbarIcon", (void*)&ScriptEditorBuiltin::internal_GetToolbarIcon);
+		metaData.scriptClass->addInternalCall("Internal_GetLibraryWindowIcon", (void*)&ScriptEditorBuiltin::internal_GetLibraryWindowIcon);
+		metaData.scriptClass->addInternalCall("Internal_GetInspectorWindowIcon", (void*)&ScriptEditorBuiltin::internal_GetInspectorWindowIcon);
+		metaData.scriptClass->addInternalCall("Internal_GetSceneWindowIcon", (void*)&ScriptEditorBuiltin::internal_GetSceneWindowIcon);
+		metaData.scriptClass->addInternalCall("Internal_GetAnimationWindowIcon", (void*)&ScriptEditorBuiltin::internal_GetAnimationWindowIcon);
+		metaData.scriptClass->addInternalCall("Internal_GetLogIcon", (void*)&ScriptEditorBuiltin::internal_GetLogIcon);
+		metaData.scriptClass->addInternalCall("Internal_GetEditorIcon", (void*)&ScriptEditorBuiltin::internal_GetEditorIcon);
+		metaData.scriptClass->addInternalCall("Internal_GetDefaultFont", (void*)&ScriptEditorBuiltin::internal_GetDefaultFont);
+		metaData.scriptClass->addInternalCall("Internal_GetGUISkin", (void*)&ScriptEditorBuiltin::internal_GetGUISkin);
 	}
 
 	MonoObject* ScriptEditorBuiltin::internal_getLibraryItemIcon(ProjectIcon icon, int size)

Source/SBansheeEditor/Wrappers/BsScriptEditorInput.h

@@ -59,9 +59,9 @@ namespace bs
 		/* 								CLR HOOKS						   		*/
 		/************************************************************************/
 
-		typedef void(__stdcall *OnButtonEventThunkDef) (ButtonCode, UINT32, bool, MonoException**);
-		typedef void(__stdcall *OnCharInputEventThunkDef) (UINT32, bool, MonoException**);
-		typedef void(__stdcall *OnPointerEventThunkDef) (MonoObject*, MonoObject*, PointerEventButton,
+		typedef void(BS_THUNKCALL *OnButtonEventThunkDef) (ButtonCode, UINT32, bool, MonoException**);
+		typedef void(BS_THUNKCALL *OnCharInputEventThunkDef) (UINT32, bool, MonoException**);
+		typedef void(BS_THUNKCALL *OnPointerEventThunkDef) (MonoObject*, MonoObject*, PointerEventButton,
 			bool, bool, bool, float, bool, MonoException**);
 
 		static OnButtonEventThunkDef OnButtonPressedThunk;

Source/SBansheeEditor/Wrappers/BsScriptEditorSettings.cpp

@@ -16,45 +16,45 @@ namespace bs
 
 	void ScriptEditorSettings::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_GetMoveHandleSnapActive", &ScriptEditorSettings::internal_GetMoveHandleSnapActive);
-		metaData.scriptClass->addInternalCall("Internal_SetMoveHandleSnapActive", &ScriptEditorSettings::internal_SetMoveHandleSnapActive);
-		metaData.scriptClass->addInternalCall("Internal_GetRotateHandleSnapActive", &ScriptEditorSettings::internal_GetRotateHandleSnapActive);
-		metaData.scriptClass->addInternalCall("Internal_SetRotateHandleSnapActive", &ScriptEditorSettings::internal_SetRotateHandleSnapActive);
-		metaData.scriptClass->addInternalCall("Internal_GetMoveHandleSnapAmount", &ScriptEditorSettings::internal_GetMoveHandleSnapAmount);
-		metaData.scriptClass->addInternalCall("Internal_SetMoveHandleSnapAmount", &ScriptEditorSettings::internal_SetMoveHandleSnapAmount);
-		metaData.scriptClass->addInternalCall("Internal_GetRotateHandleSnapAmount", &ScriptEditorSettings::internal_GetRotateHandleSnapAmount);
-		metaData.scriptClass->addInternalCall("Internal_SetRotateHandleSnapAmount", &ScriptEditorSettings::internal_SetRotateHandleSnapAmount);
-		metaData.scriptClass->addInternalCall("Internal_GetDefaultHandleSize", &ScriptEditorSettings::internal_GetDefaultHandleSize);
-		metaData.scriptClass->addInternalCall("Internal_SetDefaultHandleSize", &ScriptEditorSettings::internal_SetDefaultHandleSize);
-		metaData.scriptClass->addInternalCall("Internal_GetActiveSceneTool", &ScriptEditorSettings::internal_GetActiveSceneTool);
-		metaData.scriptClass->addInternalCall("Internal_SetActiveSceneTool", &ScriptEditorSettings::internal_SetActiveSceneTool);
-		metaData.scriptClass->addInternalCall("Internal_GetActiveCoordinateMode", &ScriptEditorSettings::internal_GetActiveCoordinateMode);
-		metaData.scriptClass->addInternalCall("Internal_SetActiveCoordinateMode", &ScriptEditorSettings::internal_SetActiveCoordinateMode);
-		metaData.scriptClass->addInternalCall("Internal_GetActivePivotMode", &ScriptEditorSettings::internal_GetActivePivotMode);
-		metaData.scriptClass->addInternalCall("Internal_SetActivePivotMode", &ScriptEditorSettings::internal_SetActivePivotMode);
-		metaData.scriptClass->addInternalCall("Internal_GetFPSLimit", &ScriptEditorSettings::internal_GetFPSLimit);
-		metaData.scriptClass->addInternalCall("Internal_SetFPSLimit", &ScriptEditorSettings::internal_SetFPSLimit);
-		metaData.scriptClass->addInternalCall("Internal_GetMouseSensitivity", &ScriptEditorSettings::internal_GetMouseSensitivity);
-		metaData.scriptClass->addInternalCall("Internal_SetMouseSensitivity", &ScriptEditorSettings::internal_SetMouseSensitivity);
-		metaData.scriptClass->addInternalCall("Internal_GetLastOpenProject", &ScriptEditorSettings::internal_GetLastOpenProject);
-		metaData.scriptClass->addInternalCall("Internal_SetLastOpenProject", &ScriptEditorSettings::internal_SetLastOpenProject);
-		metaData.scriptClass->addInternalCall("Internal_GetAutoLoadLastProject", &ScriptEditorSettings::internal_GetAutoLoadLastProject);
-		metaData.scriptClass->addInternalCall("Internal_SetAutoLoadLastProject", &ScriptEditorSettings::internal_SetAutoLoadLastProject);
-		metaData.scriptClass->addInternalCall("Internal_GetRecentProjects", &ScriptEditorSettings::internal_GetRecentProjects);
-		metaData.scriptClass->addInternalCall("Internal_SetRecentProjects", &ScriptEditorSettings::internal_SetRecentProjects);
-		metaData.scriptClass->addInternalCall("Internal_SetFloat", &ScriptEditorSettings::internal_SetFloat);
-		metaData.scriptClass->addInternalCall("Internal_SetInt", &ScriptEditorSettings::internal_SetInt);
-		metaData.scriptClass->addInternalCall("Internal_SetBool", &ScriptEditorSettings::internal_SetBool);
-		metaData.scriptClass->addInternalCall("Internal_SetString", &ScriptEditorSettings::internal_SetString);
-		metaData.scriptClass->addInternalCall("Internal_GetFloat", &ScriptEditorSettings::internal_GetFloat);
-		metaData.scriptClass->addInternalCall("Internal_GetInt", &ScriptEditorSettings::internal_GetInt);
-		metaData.scriptClass->addInternalCall("Internal_GetBool", &ScriptEditorSettings::internal_GetBool);
-		metaData.scriptClass->addInternalCall("Internal_GetString", &ScriptEditorSettings::internal_GetString);
-		metaData.scriptClass->addInternalCall("Internal_HasKey", &ScriptEditorSettings::internal_HasKey);
-		metaData.scriptClass->addInternalCall("Internal_DeleteKey", &ScriptEditorSettings::internal_DeleteKey);
-		metaData.scriptClass->addInternalCall("Internal_DeleteAllKeys", &ScriptEditorSettings::internal_DeleteAllKeys);
-		metaData.scriptClass->addInternalCall("Internal_GetHash", &ScriptEditorSettings::internal_GetHash);
-		metaData.scriptClass->addInternalCall("Internal_Save", &ScriptEditorSettings::internal_Save);
+		metaData.scriptClass->addInternalCall("Internal_GetMoveHandleSnapActive", (void*)&ScriptEditorSettings::internal_GetMoveHandleSnapActive);
+		metaData.scriptClass->addInternalCall("Internal_SetMoveHandleSnapActive", (void*)&ScriptEditorSettings::internal_SetMoveHandleSnapActive);
+		metaData.scriptClass->addInternalCall("Internal_GetRotateHandleSnapActive", (void*)&ScriptEditorSettings::internal_GetRotateHandleSnapActive);
+		metaData.scriptClass->addInternalCall("Internal_SetRotateHandleSnapActive", (void*)&ScriptEditorSettings::internal_SetRotateHandleSnapActive);
+		metaData.scriptClass->addInternalCall("Internal_GetMoveHandleSnapAmount", (void*)&ScriptEditorSettings::internal_GetMoveHandleSnapAmount);
+		metaData.scriptClass->addInternalCall("Internal_SetMoveHandleSnapAmount", (void*)&ScriptEditorSettings::internal_SetMoveHandleSnapAmount);
+		metaData.scriptClass->addInternalCall("Internal_GetRotateHandleSnapAmount", (void*)&ScriptEditorSettings::internal_GetRotateHandleSnapAmount);
+		metaData.scriptClass->addInternalCall("Internal_SetRotateHandleSnapAmount", (void*)&ScriptEditorSettings::internal_SetRotateHandleSnapAmount);
+		metaData.scriptClass->addInternalCall("Internal_GetDefaultHandleSize", (void*)&ScriptEditorSettings::internal_GetDefaultHandleSize);
+		metaData.scriptClass->addInternalCall("Internal_SetDefaultHandleSize", (void*)&ScriptEditorSettings::internal_SetDefaultHandleSize);
+		metaData.scriptClass->addInternalCall("Internal_GetActiveSceneTool", (void*)&ScriptEditorSettings::internal_GetActiveSceneTool);
+		metaData.scriptClass->addInternalCall("Internal_SetActiveSceneTool", (void*)&ScriptEditorSettings::internal_SetActiveSceneTool);
+		metaData.scriptClass->addInternalCall("Internal_GetActiveCoordinateMode", (void*)&ScriptEditorSettings::internal_GetActiveCoordinateMode);
+		metaData.scriptClass->addInternalCall("Internal_SetActiveCoordinateMode", (void*)&ScriptEditorSettings::internal_SetActiveCoordinateMode);
+		metaData.scriptClass->addInternalCall("Internal_GetActivePivotMode", (void*)&ScriptEditorSettings::internal_GetActivePivotMode);
+		metaData.scriptClass->addInternalCall("Internal_SetActivePivotMode", (void*)&ScriptEditorSettings::internal_SetActivePivotMode);
+		metaData.scriptClass->addInternalCall("Internal_GetFPSLimit", (void*)&ScriptEditorSettings::internal_GetFPSLimit);
+		metaData.scriptClass->addInternalCall("Internal_SetFPSLimit", (void*)&ScriptEditorSettings::internal_SetFPSLimit);
+		metaData.scriptClass->addInternalCall("Internal_GetMouseSensitivity", (void*)&ScriptEditorSettings::internal_GetMouseSensitivity);
+		metaData.scriptClass->addInternalCall("Internal_SetMouseSensitivity", (void*)&ScriptEditorSettings::internal_SetMouseSensitivity);
+		metaData.scriptClass->addInternalCall("Internal_GetLastOpenProject", (void*)&ScriptEditorSettings::internal_GetLastOpenProject);
+		metaData.scriptClass->addInternalCall("Internal_SetLastOpenProject", (void*)&ScriptEditorSettings::internal_SetLastOpenProject);
+		metaData.scriptClass->addInternalCall("Internal_GetAutoLoadLastProject", (void*)&ScriptEditorSettings::internal_GetAutoLoadLastProject);
+		metaData.scriptClass->addInternalCall("Internal_SetAutoLoadLastProject", (void*)&ScriptEditorSettings::internal_SetAutoLoadLastProject);
+		metaData.scriptClass->addInternalCall("Internal_GetRecentProjects", (void*)&ScriptEditorSettings::internal_GetRecentProjects);
+		metaData.scriptClass->addInternalCall("Internal_SetRecentProjects", (void*)&ScriptEditorSettings::internal_SetRecentProjects);
+		metaData.scriptClass->addInternalCall("Internal_SetFloat", (void*)&ScriptEditorSettings::internal_SetFloat);
+		metaData.scriptClass->addInternalCall("Internal_SetInt", (void*)&ScriptEditorSettings::internal_SetInt);
+		metaData.scriptClass->addInternalCall("Internal_SetBool", (void*)&ScriptEditorSettings::internal_SetBool);
+		metaData.scriptClass->addInternalCall("Internal_SetString", (void*)&ScriptEditorSettings::internal_SetString);
+		metaData.scriptClass->addInternalCall("Internal_GetFloat", (void*)&ScriptEditorSettings::internal_GetFloat);
+		metaData.scriptClass->addInternalCall("Internal_GetInt", (void*)&ScriptEditorSettings::internal_GetInt);
+		metaData.scriptClass->addInternalCall("Internal_GetBool", (void*)&ScriptEditorSettings::internal_GetBool);
+		metaData.scriptClass->addInternalCall("Internal_GetString", (void*)&ScriptEditorSettings::internal_GetString);
+		metaData.scriptClass->addInternalCall("Internal_HasKey", (void*)&ScriptEditorSettings::internal_HasKey);
+		metaData.scriptClass->addInternalCall("Internal_DeleteKey", (void*)&ScriptEditorSettings::internal_DeleteKey);
+		metaData.scriptClass->addInternalCall("Internal_DeleteAllKeys", (void*)&ScriptEditorSettings::internal_DeleteAllKeys);
+		metaData.scriptClass->addInternalCall("Internal_GetHash", (void*)&ScriptEditorSettings::internal_GetHash);
+		metaData.scriptClass->addInternalCall("Internal_Save", (void*)&ScriptEditorSettings::internal_Save);
 	}
 
 	bool ScriptEditorSettings::internal_GetMoveHandleSnapActive()

Source/SBansheeEditor/Wrappers/BsScriptEditorUtility.cpp

@@ -21,11 +21,11 @@ namespace bs
 
 	void ScriptEditorUtility::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CalculateBounds", &ScriptEditorUtility::internal_CalculateBounds);
-		metaData.scriptClass->addInternalCall("Internal_CalculateBoundsArray", &ScriptEditorUtility::internal_CalculateBoundsArray);
-		metaData.scriptClass->addInternalCall("Internal_CalculateArrayCenter", &ScriptEditorUtility::internal_CalculateArrayCenter);
-		metaData.scriptClass->addInternalCall("Internal_FindDependencies", &ScriptEditorUtility::internal_FindDependencies);
-		metaData.scriptClass->addInternalCall("Internal_IsInternal", &ScriptEditorUtility::internal_IsInternal);
+		metaData.scriptClass->addInternalCall("Internal_CalculateBounds", (void*)&ScriptEditorUtility::internal_CalculateBounds);
+		metaData.scriptClass->addInternalCall("Internal_CalculateBoundsArray", (void*)&ScriptEditorUtility::internal_CalculateBoundsArray);
+		metaData.scriptClass->addInternalCall("Internal_CalculateArrayCenter", (void*)&ScriptEditorUtility::internal_CalculateArrayCenter);
+		metaData.scriptClass->addInternalCall("Internal_FindDependencies", (void*)&ScriptEditorUtility::internal_FindDependencies);
+		metaData.scriptClass->addInternalCall("Internal_IsInternal", (void*)&ScriptEditorUtility::internal_IsInternal);
 	}
 
 	void ScriptEditorUtility::internal_CalculateBounds(MonoObject* so, AABox* bounds)

Source/SBansheeEditor/Wrappers/BsScriptEditorVirtualInput.h

@@ -58,7 +58,7 @@ namespace bs
 		/* 								CLR HOOKS						   		*/
 		/************************************************************************/
 
-		typedef void(__stdcall *OnButtonEventThunkDef) (MonoObject*, UINT32, MonoException**);
+		typedef void(BS_THUNKCALL *OnButtonEventThunkDef) (MonoObject*, UINT32, MonoException**);
 
 		static OnButtonEventThunkDef OnButtonUpThunk;
 		static OnButtonEventThunkDef OnButtonDownThunk;

Source/SBansheeEditor/Wrappers/BsScriptEditorWindow.cpp

@@ -51,20 +51,20 @@ namespace bs
 
 	void ScriptEditorWindow::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateOrGetInstance", &ScriptEditorWindow::internal_createOrGetInstance);
-		metaData.scriptClass->addInternalCall("Internal_GetInstance", &ScriptEditorWindow::internal_getInstance);
-		metaData.scriptClass->addInternalCall("Internal_GetAllWindows", &ScriptEditorWindow::internal_getAllWindows);
-
-		metaData.scriptClass->addInternalCall("Internal_GetWidth", &ScriptEditorWindow::internal_getWidth);
-		metaData.scriptClass->addInternalCall("Internal_GetHeight", &ScriptEditorWindow::internal_getHeight);
-		metaData.scriptClass->addInternalCall("Internal_GetBounds", &ScriptEditorWindow::internal_getBounds);
-		metaData.scriptClass->addInternalCall("Internal_SetFocus", &ScriptEditorWindow::internal_setFocus);
-		metaData.scriptClass->addInternalCall("Internal_HasFocus", &ScriptEditorWindow::internal_hasFocus);
-		metaData.scriptClass->addInternalCall("Internal_SetActive", &ScriptEditorWindow::internal_setActive);
-		metaData.scriptClass->addInternalCall("Internal_IsActive", &ScriptEditorWindow::internal_isActive);
-		metaData.scriptClass->addInternalCall("Internal_IsPointerHovering", &ScriptEditorWindow::internal_isPointerHovering);
-		metaData.scriptClass->addInternalCall("Internal_ScreenToWindowPos", &ScriptEditorWindow::internal_screenToWindowPos);
-		metaData.scriptClass->addInternalCall("Internal_WindowToScreenPos", &ScriptEditorWindow::internal_windowToScreenPos);
+		metaData.scriptClass->addInternalCall("Internal_CreateOrGetInstance", (void*)&ScriptEditorWindow::internal_createOrGetInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetInstance", (void*)&ScriptEditorWindow::internal_getInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetAllWindows", (void*)&ScriptEditorWindow::internal_getAllWindows);
+
+		metaData.scriptClass->addInternalCall("Internal_GetWidth", (void*)&ScriptEditorWindow::internal_getWidth);
+		metaData.scriptClass->addInternalCall("Internal_GetHeight", (void*)&ScriptEditorWindow::internal_getHeight);
+		metaData.scriptClass->addInternalCall("Internal_GetBounds", (void*)&ScriptEditorWindow::internal_getBounds);
+		metaData.scriptClass->addInternalCall("Internal_SetFocus", (void*)&ScriptEditorWindow::internal_setFocus);
+		metaData.scriptClass->addInternalCall("Internal_HasFocus", (void*)&ScriptEditorWindow::internal_hasFocus);
+		metaData.scriptClass->addInternalCall("Internal_SetActive", (void*)&ScriptEditorWindow::internal_setActive);
+		metaData.scriptClass->addInternalCall("Internal_IsActive", (void*)&ScriptEditorWindow::internal_isActive);
+		metaData.scriptClass->addInternalCall("Internal_IsPointerHovering", (void*)&ScriptEditorWindow::internal_isPointerHovering);
+		metaData.scriptClass->addInternalCall("Internal_ScreenToWindowPos", (void*)&ScriptEditorWindow::internal_screenToWindowPos);
+		metaData.scriptClass->addInternalCall("Internal_WindowToScreenPos", (void*)&ScriptEditorWindow::internal_windowToScreenPos);
 
 		onResizedMethod = metaData.scriptClass->getMethod("WindowResized", 2);
 		onFocusChangedMethod = metaData.scriptClass->getMethod("FocusChanged", 1);

Source/SBansheeEditor/Wrappers/BsScriptEditorWindow.h

@@ -188,9 +188,9 @@ namespace bs
 		MonoObject* getManagedInstance() const { return mManagedInstance; }
 
 	private:
-		typedef void(__stdcall *OnInitializeThunkDef) (MonoObject*, MonoException**);
-		typedef void(__stdcall *OnDestroyThunkDef) (MonoObject*, MonoException**);
-		typedef void(__stdcall *UpdateThunkDef) (MonoObject*, MonoException**);
+		typedef void(BS_THUNKCALL *OnInitializeThunkDef) (MonoObject*, MonoException**);
+		typedef void(BS_THUNKCALL *OnDestroyThunkDef) (MonoObject*, MonoException**);
+		typedef void(BS_THUNKCALL *UpdateThunkDef) (MonoObject*, MonoException**);
 
 		String mNamespace;
 		String mTypename;

Source/SBansheeEditor/Wrappers/BsScriptFolderMonitor.cpp

@@ -38,8 +38,8 @@ namespace bs
 
 	void ScriptFolderMonitor::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptFolderMonitor::internal_CreateInstance);
-		metaData.scriptClass->addInternalCall("Internal_Destroy", &ScriptFolderMonitor::internal_Destroy);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptFolderMonitor::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_Destroy", (void*)&ScriptFolderMonitor::internal_Destroy);
 
 		OnModifiedThunk = (OnModifiedThunkDef)metaData.scriptClass->getMethod("Internal_DoOnModified", 1)->getThunk();
 		OnAddedThunk = (OnModifiedThunkDef)metaData.scriptClass->getMethod("Internal_DoOnAdded", 1)->getThunk();

Source/SBansheeEditor/Wrappers/BsScriptFolderMonitor.h

@@ -51,8 +51,8 @@ namespace bs
 		static void internal_CreateInstance(MonoObject* instance, MonoString* folder);
 		static void internal_Destroy(ScriptFolderMonitor* thisPtr);
 
-		typedef void(__stdcall *OnModifiedThunkDef) (MonoObject*, MonoString*, MonoException**);
-		typedef void(__stdcall *OnRenamedThunkDef) (MonoObject*, MonoString*, MonoString*, MonoException**);
+		typedef void(BS_THUNKCALL *OnModifiedThunkDef) (MonoObject*, MonoString*, MonoException**);
+		typedef void(BS_THUNKCALL *OnRenamedThunkDef) (MonoObject*, MonoString*, MonoString*, MonoException**);
 
 		static OnModifiedThunkDef OnModifiedThunk;
 		static OnModifiedThunkDef OnAddedThunk;

Source/SBansheeEditor/Wrappers/BsScriptGizmos.cpp

@@ -14,26 +14,26 @@ namespace bs
 {
 	void ScriptGizmos::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_SetColor", &ScriptGizmos::internal_SetColor);
-		metaData.scriptClass->addInternalCall("Internal_GetColor", &ScriptGizmos::internal_GetColor);
-		metaData.scriptClass->addInternalCall("Internal_SetTransform", &ScriptGizmos::internal_SetTransform);
-		metaData.scriptClass->addInternalCall("Internal_GetTransform", &ScriptGizmos::internal_GetTransform);
-		metaData.scriptClass->addInternalCall("Internal_DrawCube", &ScriptGizmos::internal_DrawCube);
-		metaData.scriptClass->addInternalCall("Internal_DrawSphere", &ScriptGizmos::internal_DrawSphere);
-		metaData.scriptClass->addInternalCall("Internal_DrawCone", &ScriptGizmos::internal_DrawCone);
-		metaData.scriptClass->addInternalCall("Internal_DrawDisc", &ScriptGizmos::internal_DrawDisc);
-		metaData.scriptClass->addInternalCall("Internal_DrawWireCube", &ScriptGizmos::internal_DrawWireCube);
-		metaData.scriptClass->addInternalCall("Internal_DrawWireSphere", &ScriptGizmos::internal_DrawWireSphere);
-		metaData.scriptClass->addInternalCall("Internal_DrawWireCapsule", &ScriptGizmos::internal_DrawWireCapsule);
-		metaData.scriptClass->addInternalCall("Internal_DrawWireCone", &ScriptGizmos::internal_DrawWireCone);
-		metaData.scriptClass->addInternalCall("Internal_DrawWireDisc", &ScriptGizmos::internal_DrawWireDisc);
-		metaData.scriptClass->addInternalCall("Internal_DrawWireArc", &ScriptGizmos::internal_DrawWireArc);
-		metaData.scriptClass->addInternalCall("Internal_DrawWireMesh", &ScriptGizmos::internal_DrawWireMesh);
-		metaData.scriptClass->addInternalCall("Internal_DrawLine", &ScriptGizmos::internal_DrawLine);
-		metaData.scriptClass->addInternalCall("Internal_DrawLineList", &ScriptGizmos::internal_DrawLineList);
-		metaData.scriptClass->addInternalCall("Internal_DrawFrustum", &ScriptGizmos::internal_DrawFrustum);
-		metaData.scriptClass->addInternalCall("Internal_DrawIcon", &ScriptGizmos::internal_DrawIcon);
-		metaData.scriptClass->addInternalCall("Internal_DrawText", &ScriptGizmos::internal_DrawText);
+		metaData.scriptClass->addInternalCall("Internal_SetColor", (void*)&ScriptGizmos::internal_SetColor);
+		metaData.scriptClass->addInternalCall("Internal_GetColor", (void*)&ScriptGizmos::internal_GetColor);
+		metaData.scriptClass->addInternalCall("Internal_SetTransform", (void*)&ScriptGizmos::internal_SetTransform);
+		metaData.scriptClass->addInternalCall("Internal_GetTransform", (void*)&ScriptGizmos::internal_GetTransform);
+		metaData.scriptClass->addInternalCall("Internal_DrawCube", (void*)&ScriptGizmos::internal_DrawCube);
+		metaData.scriptClass->addInternalCall("Internal_DrawSphere", (void*)&ScriptGizmos::internal_DrawSphere);
+		metaData.scriptClass->addInternalCall("Internal_DrawCone", (void*)&ScriptGizmos::internal_DrawCone);
+		metaData.scriptClass->addInternalCall("Internal_DrawDisc", (void*)&ScriptGizmos::internal_DrawDisc);
+		metaData.scriptClass->addInternalCall("Internal_DrawWireCube", (void*)&ScriptGizmos::internal_DrawWireCube);
+		metaData.scriptClass->addInternalCall("Internal_DrawWireSphere", (void*)&ScriptGizmos::internal_DrawWireSphere);
+		metaData.scriptClass->addInternalCall("Internal_DrawWireCapsule", (void*)&ScriptGizmos::internal_DrawWireCapsule);
+		metaData.scriptClass->addInternalCall("Internal_DrawWireCone", (void*)&ScriptGizmos::internal_DrawWireCone);
+		metaData.scriptClass->addInternalCall("Internal_DrawWireDisc", (void*)&ScriptGizmos::internal_DrawWireDisc);
+		metaData.scriptClass->addInternalCall("Internal_DrawWireArc", (void*)&ScriptGizmos::internal_DrawWireArc);
+		metaData.scriptClass->addInternalCall("Internal_DrawWireMesh", (void*)&ScriptGizmos::internal_DrawWireMesh);
+		metaData.scriptClass->addInternalCall("Internal_DrawLine", (void*)&ScriptGizmos::internal_DrawLine);
+		metaData.scriptClass->addInternalCall("Internal_DrawLineList", (void*)&ScriptGizmos::internal_DrawLineList);
+		metaData.scriptClass->addInternalCall("Internal_DrawFrustum", (void*)&ScriptGizmos::internal_DrawFrustum);
+		metaData.scriptClass->addInternalCall("Internal_DrawIcon", (void*)&ScriptGizmos::internal_DrawIcon);
+		metaData.scriptClass->addInternalCall("Internal_DrawText", (void*)&ScriptGizmos::internal_DrawText);
 	}
 
 	void ScriptGizmos::internal_SetColor(Color* color)

Source/SBansheeEditor/Wrappers/BsScriptHandleDrawing.cpp

@@ -12,21 +12,21 @@ namespace bs
 {
 	void ScriptHandleDrawing::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_SetColor", &ScriptHandleDrawing::internal_SetColor);
-		metaData.scriptClass->addInternalCall("Internal_SetTransform", &ScriptHandleDrawing::internal_SetTransform);
-		metaData.scriptClass->addInternalCall("Internal_SetLayer", &ScriptHandleDrawing::internal_SetLayer);
-		metaData.scriptClass->addInternalCall("Internal_DrawCube", &ScriptHandleDrawing::internal_DrawCube);
-		metaData.scriptClass->addInternalCall("Internal_DrawSphere", &ScriptHandleDrawing::internal_DrawSphere);
-		metaData.scriptClass->addInternalCall("Internal_DrawWireCube", &ScriptHandleDrawing::internal_DrawWireCube);
-		metaData.scriptClass->addInternalCall("Internal_DrawWireSphere", &ScriptHandleDrawing::internal_DrawWireSphere);
-		metaData.scriptClass->addInternalCall("Internal_DrawLine", &ScriptHandleDrawing::internal_DrawLine);
-		metaData.scriptClass->addInternalCall("Internal_DrawCone", &ScriptHandleDrawing::internal_DrawCone);
-		metaData.scriptClass->addInternalCall("Internal_DrawDisc", &ScriptHandleDrawing::internal_DrawDisc);
-		metaData.scriptClass->addInternalCall("Internal_DrawWireDisc", &ScriptHandleDrawing::internal_DrawWireDisc);
-		metaData.scriptClass->addInternalCall("Internal_DrawArc", &ScriptHandleDrawing::internal_DrawArc);
-		metaData.scriptClass->addInternalCall("Internal_DrawWireArc", &ScriptHandleDrawing::internal_DrawWireArc);
-		metaData.scriptClass->addInternalCall("Internal_DrawRect", &ScriptHandleDrawing::internal_DrawRect);
-		metaData.scriptClass->addInternalCall("Internal_DrawText", &ScriptHandleDrawing::internal_DrawText);
+		metaData.scriptClass->addInternalCall("Internal_SetColor", (void*)&ScriptHandleDrawing::internal_SetColor);
+		metaData.scriptClass->addInternalCall("Internal_SetTransform", (void*)&ScriptHandleDrawing::internal_SetTransform);
+		metaData.scriptClass->addInternalCall("Internal_SetLayer", (void*)&ScriptHandleDrawing::internal_SetLayer);
+		metaData.scriptClass->addInternalCall("Internal_DrawCube", (void*)&ScriptHandleDrawing::internal_DrawCube);
+		metaData.scriptClass->addInternalCall("Internal_DrawSphere", (void*)&ScriptHandleDrawing::internal_DrawSphere);
+		metaData.scriptClass->addInternalCall("Internal_DrawWireCube", (void*)&ScriptHandleDrawing::internal_DrawWireCube);
+		metaData.scriptClass->addInternalCall("Internal_DrawWireSphere", (void*)&ScriptHandleDrawing::internal_DrawWireSphere);
+		metaData.scriptClass->addInternalCall("Internal_DrawLine", (void*)&ScriptHandleDrawing::internal_DrawLine);
+		metaData.scriptClass->addInternalCall("Internal_DrawCone", (void*)&ScriptHandleDrawing::internal_DrawCone);
+		metaData.scriptClass->addInternalCall("Internal_DrawDisc", (void*)&ScriptHandleDrawing::internal_DrawDisc);
+		metaData.scriptClass->addInternalCall("Internal_DrawWireDisc", (void*)&ScriptHandleDrawing::internal_DrawWireDisc);
+		metaData.scriptClass->addInternalCall("Internal_DrawArc", (void*)&ScriptHandleDrawing::internal_DrawArc);
+		metaData.scriptClass->addInternalCall("Internal_DrawWireArc", (void*)&ScriptHandleDrawing::internal_DrawWireArc);
+		metaData.scriptClass->addInternalCall("Internal_DrawRect", (void*)&ScriptHandleDrawing::internal_DrawRect);
+		metaData.scriptClass->addInternalCall("Internal_DrawText", (void*)&ScriptHandleDrawing::internal_DrawText);
 	}
 
 	void ScriptHandleDrawing::internal_SetColor(Color* color)

Source/SBansheeEditor/Wrappers/BsScriptHandleSlider.cpp

@@ -33,16 +33,16 @@ namespace bs
 
 	void ScriptHandleSlider::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_Destroy", &ScriptHandleSlider::internal_Destroy);
-		metaData.scriptClass->addInternalCall("Internal_GetPosition", &ScriptHandleSlider::internal_GetPosition);
-		metaData.scriptClass->addInternalCall("Internal_SetPosition", &ScriptHandleSlider::internal_SetPosition);
-		metaData.scriptClass->addInternalCall("Internal_GetRotation", &ScriptHandleSlider::internal_GetRotation);
-		metaData.scriptClass->addInternalCall("Internal_SetRotation", &ScriptHandleSlider::internal_SetRotation);
-		metaData.scriptClass->addInternalCall("Internal_SetScale", &ScriptHandleSlider::internal_SetScale);
-		metaData.scriptClass->addInternalCall("Internal_GetScale", &ScriptHandleSlider::internal_GetScale);
-		metaData.scriptClass->addInternalCall("Internal_GetEnabled", &ScriptHandleSlider::internal_GetEnabled);
-		metaData.scriptClass->addInternalCall("Internal_SetEnabled", &ScriptHandleSlider::internal_SetEnabled);
-		metaData.scriptClass->addInternalCall("Internal_GetState", &ScriptHandleSlider::internal_GetState);
+		metaData.scriptClass->addInternalCall("Internal_Destroy", (void*)&ScriptHandleSlider::internal_Destroy);
+		metaData.scriptClass->addInternalCall("Internal_GetPosition", (void*)&ScriptHandleSlider::internal_GetPosition);
+		metaData.scriptClass->addInternalCall("Internal_SetPosition", (void*)&ScriptHandleSlider::internal_SetPosition);
+		metaData.scriptClass->addInternalCall("Internal_GetRotation", (void*)&ScriptHandleSlider::internal_GetRotation);
+		metaData.scriptClass->addInternalCall("Internal_SetRotation", (void*)&ScriptHandleSlider::internal_SetRotation);
+		metaData.scriptClass->addInternalCall("Internal_SetScale", (void*)&ScriptHandleSlider::internal_SetScale);
+		metaData.scriptClass->addInternalCall("Internal_GetScale", (void*)&ScriptHandleSlider::internal_GetScale);
+		metaData.scriptClass->addInternalCall("Internal_GetEnabled", (void*)&ScriptHandleSlider::internal_GetEnabled);
+		metaData.scriptClass->addInternalCall("Internal_SetEnabled", (void*)&ScriptHandleSlider::internal_SetEnabled);
+		metaData.scriptClass->addInternalCall("Internal_GetState", (void*)&ScriptHandleSlider::internal_GetState);
 	}
 
 	void ScriptHandleSlider::internal_Destroy(ScriptHandleSliderBase* nativeInstance)

Source/SBansheeEditor/Wrappers/BsScriptHandleSliderDisc.cpp

@@ -30,10 +30,10 @@ namespace bs
 
 	void ScriptHandleSliderDisc::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptHandleSliderDisc::internal_CreateInstance);
-		metaData.scriptClass->addInternalCall("Internal_GetDelta", &ScriptHandleSliderDisc::internal_GetDelta);
-		metaData.scriptClass->addInternalCall("Internal_GetStartAngle", &ScriptHandleSliderDisc::internal_GetStartAngle);
-		metaData.scriptClass->addInternalCall("Internal_SetCutoffPlane", &ScriptHandleSliderDisc::internal_SetCutoffPlane);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptHandleSliderDisc::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetDelta", (void*)&ScriptHandleSliderDisc::internal_GetDelta);
+		metaData.scriptClass->addInternalCall("Internal_GetStartAngle", (void*)&ScriptHandleSliderDisc::internal_GetStartAngle);
+		metaData.scriptClass->addInternalCall("Internal_SetCutoffPlane", (void*)&ScriptHandleSliderDisc::internal_SetCutoffPlane);
 	}
 
 	void ScriptHandleSliderDisc::internal_CreateInstance(MonoObject* instance, Vector3* normal, float radius, bool fixedScale, UINT64 layer)

Source/SBansheeEditor/Wrappers/BsScriptHandleSliderLine.cpp

@@ -31,8 +31,8 @@ namespace bs
 
 	void ScriptHandleSliderLine::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptHandleSliderLine::internal_CreateInstance);
-		metaData.scriptClass->addInternalCall("Internal_GetDelta", &ScriptHandleSliderLine::internal_GetDelta);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptHandleSliderLine::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetDelta", (void*)&ScriptHandleSliderLine::internal_GetDelta);
 	}
 
 	void ScriptHandleSliderLine::internal_CreateInstance(MonoObject* instance, Vector3* direction, float length, 

Source/SBansheeEditor/Wrappers/BsScriptHandleSliderPlane.cpp

@@ -31,8 +31,8 @@ namespace bs
 
 	void ScriptHandleSliderPlane::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptHandleSliderPlane::internal_CreateInstance);
-		metaData.scriptClass->addInternalCall("Internal_GetDelta", &ScriptHandleSliderPlane::internal_GetDelta);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptHandleSliderPlane::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetDelta", (void*)&ScriptHandleSliderPlane::internal_GetDelta);
 	}
 
 	void ScriptHandleSliderPlane::internal_CreateInstance(MonoObject* instance, Vector3* dir1, Vector3* dir2, 

Source/SBansheeEditor/Wrappers/BsScriptImportOptions.cpp

@@ -71,21 +71,21 @@ namespace bs
 
 	void ScriptTextureImportOptions::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptTextureImportOptions::internal_CreateInstance);
-		metaData.scriptClass->addInternalCall("Internal_GetPixelFormat", &ScriptTextureImportOptions::internal_GetPixelFormat);
-		metaData.scriptClass->addInternalCall("Internal_SetPixelFormat", &ScriptTextureImportOptions::internal_SetPixelFormat);
-		metaData.scriptClass->addInternalCall("Internal_GetGenerateMipmaps", &ScriptTextureImportOptions::internal_GetGenerateMipmaps);
-		metaData.scriptClass->addInternalCall("Internal_SetGenerateMipmaps", &ScriptTextureImportOptions::internal_SetGenerateMipmaps);
-		metaData.scriptClass->addInternalCall("Internal_GetMaxMipmapLevel", &ScriptTextureImportOptions::internal_GetMaxMipmapLevel);
-		metaData.scriptClass->addInternalCall("Internal_SetMaxMipmapLevel", &ScriptTextureImportOptions::internal_SetMaxMipmapLevel);
-		metaData.scriptClass->addInternalCall("Internal_GetCPUCached", &ScriptTextureImportOptions::internal_GetCPUCached);
-		metaData.scriptClass->addInternalCall("Internal_SetCPUCached", &ScriptTextureImportOptions::internal_SetCPUCached);
-		metaData.scriptClass->addInternalCall("Internal_GetIsSRGB", &ScriptTextureImportOptions::internal_GetIsSRGB);
-		metaData.scriptClass->addInternalCall("Internal_SetIsSRGB", &ScriptTextureImportOptions::internal_SetIsSRGB);
-		metaData.scriptClass->addInternalCall("Internal_GetIsCubemap", &ScriptTextureImportOptions::internal_GetIsCubemap);
-		metaData.scriptClass->addInternalCall("Internal_SetIsCubemap", &ScriptTextureImportOptions::internal_SetIsCubemap);
-		metaData.scriptClass->addInternalCall("Internal_GetCubemapSourceType", &ScriptTextureImportOptions::internal_GetCubemapSourceType);
-		metaData.scriptClass->addInternalCall("Internal_SetCubemapSourceType", &ScriptTextureImportOptions::internal_SetCubemapSourceType);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptTextureImportOptions::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetPixelFormat", (void*)&ScriptTextureImportOptions::internal_GetPixelFormat);
+		metaData.scriptClass->addInternalCall("Internal_SetPixelFormat", (void*)&ScriptTextureImportOptions::internal_SetPixelFormat);
+		metaData.scriptClass->addInternalCall("Internal_GetGenerateMipmaps", (void*)&ScriptTextureImportOptions::internal_GetGenerateMipmaps);
+		metaData.scriptClass->addInternalCall("Internal_SetGenerateMipmaps", (void*)&ScriptTextureImportOptions::internal_SetGenerateMipmaps);
+		metaData.scriptClass->addInternalCall("Internal_GetMaxMipmapLevel", (void*)&ScriptTextureImportOptions::internal_GetMaxMipmapLevel);
+		metaData.scriptClass->addInternalCall("Internal_SetMaxMipmapLevel", (void*)&ScriptTextureImportOptions::internal_SetMaxMipmapLevel);
+		metaData.scriptClass->addInternalCall("Internal_GetCPUCached", (void*)&ScriptTextureImportOptions::internal_GetCPUCached);
+		metaData.scriptClass->addInternalCall("Internal_SetCPUCached", (void*)&ScriptTextureImportOptions::internal_SetCPUCached);
+		metaData.scriptClass->addInternalCall("Internal_GetIsSRGB", (void*)&ScriptTextureImportOptions::internal_GetIsSRGB);
+		metaData.scriptClass->addInternalCall("Internal_SetIsSRGB", (void*)&ScriptTextureImportOptions::internal_SetIsSRGB);
+		metaData.scriptClass->addInternalCall("Internal_GetIsCubemap", (void*)&ScriptTextureImportOptions::internal_GetIsCubemap);
+		metaData.scriptClass->addInternalCall("Internal_SetIsCubemap", (void*)&ScriptTextureImportOptions::internal_SetIsCubemap);
+		metaData.scriptClass->addInternalCall("Internal_GetCubemapSourceType", (void*)&ScriptTextureImportOptions::internal_GetCubemapSourceType);
+		metaData.scriptClass->addInternalCall("Internal_SetCubemapSourceType", (void*)&ScriptTextureImportOptions::internal_SetCubemapSourceType);
 	}
 
 	SPtr<TextureImportOptions> ScriptTextureImportOptions::getTexImportOptions()
@@ -191,31 +191,31 @@ namespace bs
 
 	void ScriptMeshImportOptions::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptMeshImportOptions::internal_CreateInstance);
-		metaData.scriptClass->addInternalCall("Internal_GetCPUCached", &ScriptMeshImportOptions::internal_GetCPUCached);
-		metaData.scriptClass->addInternalCall("Internal_SetCPUCached", &ScriptMeshImportOptions::internal_SetCPUCached);
-		metaData.scriptClass->addInternalCall("Internal_GetImportNormals", &ScriptMeshImportOptions::internal_GetImportNormals);
-		metaData.scriptClass->addInternalCall("Internal_SetImportNormals", &ScriptMeshImportOptions::internal_SetImportNormals);
-		metaData.scriptClass->addInternalCall("Internal_GetImportTangents", &ScriptMeshImportOptions::internal_GetImportTangents);
-		metaData.scriptClass->addInternalCall("Internal_SetImportTangents", &ScriptMeshImportOptions::internal_SetImportTangents);
-		metaData.scriptClass->addInternalCall("Internal_GetImportSkin", &ScriptMeshImportOptions::internal_GetImportSkin);
-		metaData.scriptClass->addInternalCall("Internal_SetImportSkin", &ScriptMeshImportOptions::internal_SetImportSkin);
-		metaData.scriptClass->addInternalCall("Internal_GetImportAnimation", &ScriptMeshImportOptions::internal_GetImportAnimation);
-		metaData.scriptClass->addInternalCall("Internal_SetImportAnimation", &ScriptMeshImportOptions::internal_SetImportAnimation);
-		metaData.scriptClass->addInternalCall("Internal_GetImportBlendShapes", &ScriptMeshImportOptions::internal_GetImportBlendShapes);
-		metaData.scriptClass->addInternalCall("Internal_SetImportBlendShapes", &ScriptMeshImportOptions::internal_SetImportBlendShapes);
-		metaData.scriptClass->addInternalCall("Internal_GetKeyFrameReduction", &ScriptMeshImportOptions::internal_GetKeyFrameReduction);
-		metaData.scriptClass->addInternalCall("Internal_SetKeyFrameReduction", &ScriptMeshImportOptions::internal_SetKeyFrameReduction);
-		metaData.scriptClass->addInternalCall("Internal_GetRootMotion", &ScriptMeshImportOptions::internal_GetRootMotion);
-		metaData.scriptClass->addInternalCall("Internal_SetRootMotion", &ScriptMeshImportOptions::internal_SetRootMotion);
-		metaData.scriptClass->addInternalCall("Internal_GetScale", &ScriptMeshImportOptions::internal_GetScale);
-		metaData.scriptClass->addInternalCall("Internal_SetScale", &ScriptMeshImportOptions::internal_SetScale);
-		metaData.scriptClass->addInternalCall("Internal_GetCollisionMeshType", &ScriptMeshImportOptions::internal_GetCollisionMeshType);
-		metaData.scriptClass->addInternalCall("Internal_SetCollisionMeshType", &ScriptMeshImportOptions::internal_SetCollisionMeshType);
-		metaData.scriptClass->addInternalCall("Internal_GetAnimationClipSplits", &ScriptMeshImportOptions::internal_GetAnimationClipSplits);
-		metaData.scriptClass->addInternalCall("Internal_SetAnimationClipSplits", &ScriptMeshImportOptions::internal_SetAnimationClipSplits);
-		metaData.scriptClass->addInternalCall("Internal_GetAnimationEvents", &ScriptMeshImportOptions::internal_GetAnimationEvents);
-		metaData.scriptClass->addInternalCall("Internal_SetAnimationEvents", &ScriptMeshImportOptions::internal_SetAnimationEvents);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptMeshImportOptions::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetCPUCached", (void*)&ScriptMeshImportOptions::internal_GetCPUCached);
+		metaData.scriptClass->addInternalCall("Internal_SetCPUCached", (void*)&ScriptMeshImportOptions::internal_SetCPUCached);
+		metaData.scriptClass->addInternalCall("Internal_GetImportNormals", (void*)&ScriptMeshImportOptions::internal_GetImportNormals);
+		metaData.scriptClass->addInternalCall("Internal_SetImportNormals", (void*)&ScriptMeshImportOptions::internal_SetImportNormals);
+		metaData.scriptClass->addInternalCall("Internal_GetImportTangents", (void*)&ScriptMeshImportOptions::internal_GetImportTangents);
+		metaData.scriptClass->addInternalCall("Internal_SetImportTangents", (void*)&ScriptMeshImportOptions::internal_SetImportTangents);
+		metaData.scriptClass->addInternalCall("Internal_GetImportSkin", (void*)&ScriptMeshImportOptions::internal_GetImportSkin);
+		metaData.scriptClass->addInternalCall("Internal_SetImportSkin", (void*)&ScriptMeshImportOptions::internal_SetImportSkin);
+		metaData.scriptClass->addInternalCall("Internal_GetImportAnimation", (void*)&ScriptMeshImportOptions::internal_GetImportAnimation);
+		metaData.scriptClass->addInternalCall("Internal_SetImportAnimation", (void*)&ScriptMeshImportOptions::internal_SetImportAnimation);
+		metaData.scriptClass->addInternalCall("Internal_GetImportBlendShapes", (void*)&ScriptMeshImportOptions::internal_GetImportBlendShapes);
+		metaData.scriptClass->addInternalCall("Internal_SetImportBlendShapes", (void*)&ScriptMeshImportOptions::internal_SetImportBlendShapes);
+		metaData.scriptClass->addInternalCall("Internal_GetKeyFrameReduction", (void*)&ScriptMeshImportOptions::internal_GetKeyFrameReduction);
+		metaData.scriptClass->addInternalCall("Internal_SetKeyFrameReduction", (void*)&ScriptMeshImportOptions::internal_SetKeyFrameReduction);
+		metaData.scriptClass->addInternalCall("Internal_GetRootMotion", (void*)&ScriptMeshImportOptions::internal_GetRootMotion);
+		metaData.scriptClass->addInternalCall("Internal_SetRootMotion", (void*)&ScriptMeshImportOptions::internal_SetRootMotion);
+		metaData.scriptClass->addInternalCall("Internal_GetScale", (void*)&ScriptMeshImportOptions::internal_GetScale);
+		metaData.scriptClass->addInternalCall("Internal_SetScale", (void*)&ScriptMeshImportOptions::internal_SetScale);
+		metaData.scriptClass->addInternalCall("Internal_GetCollisionMeshType", (void*)&ScriptMeshImportOptions::internal_GetCollisionMeshType);
+		metaData.scriptClass->addInternalCall("Internal_SetCollisionMeshType", (void*)&ScriptMeshImportOptions::internal_SetCollisionMeshType);
+		metaData.scriptClass->addInternalCall("Internal_GetAnimationClipSplits", (void*)&ScriptMeshImportOptions::internal_GetAnimationClipSplits);
+		metaData.scriptClass->addInternalCall("Internal_SetAnimationClipSplits", (void*)&ScriptMeshImportOptions::internal_SetAnimationClipSplits);
+		metaData.scriptClass->addInternalCall("Internal_GetAnimationEvents", (void*)&ScriptMeshImportOptions::internal_GetAnimationEvents);
+		metaData.scriptClass->addInternalCall("Internal_SetAnimationEvents", (void*)&ScriptMeshImportOptions::internal_SetAnimationEvents);
 	}
 
 	SPtr<MeshImportOptions> ScriptMeshImportOptions::getMeshImportOptions()
@@ -415,19 +415,19 @@ namespace bs
 
 	void ScriptFontImportOptions::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptFontImportOptions::internal_CreateInstance);
-		metaData.scriptClass->addInternalCall("Internal_GetFontSizes", &ScriptFontImportOptions::internal_GetFontSizes);
-		metaData.scriptClass->addInternalCall("Internal_SetFontSizes", &ScriptFontImportOptions::internal_SetFontSizes);
-		metaData.scriptClass->addInternalCall("Internal_GetDPI", &ScriptFontImportOptions::internal_GetDPI);
-		metaData.scriptClass->addInternalCall("Internal_SetDPI", &ScriptFontImportOptions::internal_SetDPI);
-		metaData.scriptClass->addInternalCall("Internal_GetRenderMode", &ScriptFontImportOptions::internal_GetRenderMode);
-		metaData.scriptClass->addInternalCall("Internal_SetRenderMode", &ScriptFontImportOptions::internal_SetRenderMode);
-		metaData.scriptClass->addInternalCall("Internal_GetBold", &ScriptFontImportOptions::internal_GetBold);
-		metaData.scriptClass->addInternalCall("Internal_SetBold", &ScriptFontImportOptions::internal_SetBold);
-		metaData.scriptClass->addInternalCall("Internal_GetItalic", &ScriptFontImportOptions::internal_GetItalic);
-		metaData.scriptClass->addInternalCall("Internal_SetItalic", &ScriptFontImportOptions::internal_SetItalic);
-		metaData.scriptClass->addInternalCall("Internal_GetCharRanges", &ScriptFontImportOptions::internal_GetCharRanges);
-		metaData.scriptClass->addInternalCall("Internal_SetCharRanges", &ScriptFontImportOptions::internal_SetCharRanges);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptFontImportOptions::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetFontSizes", (void*)&ScriptFontImportOptions::internal_GetFontSizes);
+		metaData.scriptClass->addInternalCall("Internal_SetFontSizes", (void*)&ScriptFontImportOptions::internal_SetFontSizes);
+		metaData.scriptClass->addInternalCall("Internal_GetDPI", (void*)&ScriptFontImportOptions::internal_GetDPI);
+		metaData.scriptClass->addInternalCall("Internal_SetDPI", (void*)&ScriptFontImportOptions::internal_SetDPI);
+		metaData.scriptClass->addInternalCall("Internal_GetRenderMode", (void*)&ScriptFontImportOptions::internal_GetRenderMode);
+		metaData.scriptClass->addInternalCall("Internal_SetRenderMode", (void*)&ScriptFontImportOptions::internal_SetRenderMode);
+		metaData.scriptClass->addInternalCall("Internal_GetBold", (void*)&ScriptFontImportOptions::internal_GetBold);
+		metaData.scriptClass->addInternalCall("Internal_SetBold", (void*)&ScriptFontImportOptions::internal_SetBold);
+		metaData.scriptClass->addInternalCall("Internal_GetItalic", (void*)&ScriptFontImportOptions::internal_GetItalic);
+		metaData.scriptClass->addInternalCall("Internal_SetItalic", (void*)&ScriptFontImportOptions::internal_SetItalic);
+		metaData.scriptClass->addInternalCall("Internal_GetCharRanges", (void*)&ScriptFontImportOptions::internal_GetCharRanges);
+		metaData.scriptClass->addInternalCall("Internal_SetCharRanges", (void*)&ScriptFontImportOptions::internal_SetCharRanges);
 	}
 
 	SPtr<FontImportOptions> ScriptFontImportOptions::getFontImportOptions()
@@ -552,9 +552,9 @@ namespace bs
 
 	void ScriptScriptCodeImportOptions::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptScriptCodeImportOptions::internal_CreateInstance);
-		metaData.scriptClass->addInternalCall("Internal_IsEditorScript", &ScriptScriptCodeImportOptions::internal_IsEditorScript);
-		metaData.scriptClass->addInternalCall("Internal_SetEditorScript", &ScriptScriptCodeImportOptions::internal_SetEditorScript);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptScriptCodeImportOptions::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_IsEditorScript", (void*)&ScriptScriptCodeImportOptions::internal_IsEditorScript);
+		metaData.scriptClass->addInternalCall("Internal_SetEditorScript", (void*)&ScriptScriptCodeImportOptions::internal_SetEditorScript);
 	}
 
 	SPtr<ScriptCodeImportOptions> ScriptScriptCodeImportOptions::getCodeImportOptions()
@@ -599,15 +599,15 @@ namespace bs
 
 	void ScriptAudioClipImportOptions::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptAudioClipImportOptions::internal_CreateInstance);
-		metaData.scriptClass->addInternalCall("Internal_GetFormat", &ScriptAudioClipImportOptions::internal_GetFormat);
-		metaData.scriptClass->addInternalCall("Internal_SetFormat", &ScriptAudioClipImportOptions::internal_SetFormat);
-		metaData.scriptClass->addInternalCall("Internal_GetReadMode", &ScriptAudioClipImportOptions::internal_GetReadMode);
-		metaData.scriptClass->addInternalCall("Internal_SetReadMode", &ScriptAudioClipImportOptions::internal_SetReadMode);
-		metaData.scriptClass->addInternalCall("Internal_GetIs3D", &ScriptAudioClipImportOptions::internal_GetIs3D);
-		metaData.scriptClass->addInternalCall("Internal_SetIs3D", &ScriptAudioClipImportOptions::internal_SetIs3D);
-		metaData.scriptClass->addInternalCall("Internal_GetBitDepth", &ScriptAudioClipImportOptions::internal_GetBitDepth);
-		metaData.scriptClass->addInternalCall("Internal_SetBitDepth", &ScriptAudioClipImportOptions::internal_SetBitDepth);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptAudioClipImportOptions::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetFormat", (void*)&ScriptAudioClipImportOptions::internal_GetFormat);
+		metaData.scriptClass->addInternalCall("Internal_SetFormat", (void*)&ScriptAudioClipImportOptions::internal_SetFormat);
+		metaData.scriptClass->addInternalCall("Internal_GetReadMode", (void*)&ScriptAudioClipImportOptions::internal_GetReadMode);
+		metaData.scriptClass->addInternalCall("Internal_SetReadMode", (void*)&ScriptAudioClipImportOptions::internal_SetReadMode);
+		metaData.scriptClass->addInternalCall("Internal_GetIs3D", (void*)&ScriptAudioClipImportOptions::internal_GetIs3D);
+		metaData.scriptClass->addInternalCall("Internal_SetIs3D", (void*)&ScriptAudioClipImportOptions::internal_SetIs3D);
+		metaData.scriptClass->addInternalCall("Internal_GetBitDepth", (void*)&ScriptAudioClipImportOptions::internal_GetBitDepth);
+		metaData.scriptClass->addInternalCall("Internal_SetBitDepth", (void*)&ScriptAudioClipImportOptions::internal_SetBitDepth);
 	}
 
 	SPtr<AudioClipImportOptions> ScriptAudioClipImportOptions::getClipImportOptions()

Source/SBansheeEditor/Wrappers/BsScriptInspectorUtility.cpp

@@ -27,8 +27,8 @@ namespace bs
 
 	void ScriptInspectorUtility::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_GetCustomInspector", &ScriptInspectorUtility::internal_GetCustomInspector);
-		metaData.scriptClass->addInternalCall("Internal_GetCustomInspectable", &ScriptInspectorUtility::internal_GetCustomInspectable);
+		metaData.scriptClass->addInternalCall("Internal_GetCustomInspector", (void*)&ScriptInspectorUtility::internal_GetCustomInspector);
+		metaData.scriptClass->addInternalCall("Internal_GetCustomInspectable", (void*)&ScriptInspectorUtility::internal_GetCustomInspectable);
 	}
 
 	void ScriptInspectorUtility::startUp()

Source/SBansheeEditor/Wrappers/BsScriptModalWindow.cpp

@@ -32,15 +32,15 @@ namespace bs
 
 	void ScriptModalWindow::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptModalWindow::internal_createInstance);
-		metaData.scriptClass->addInternalCall("Internal_Close", &ScriptModalWindow::internal_close);
-		metaData.scriptClass->addInternalCall("Internal_GetWidth", &ScriptModalWindow::internal_getWidth);
-		metaData.scriptClass->addInternalCall("Internal_GetHeight", &ScriptModalWindow::internal_getHeight);
-		metaData.scriptClass->addInternalCall("Internal_SetWidth", &ScriptModalWindow::internal_setWidth);
-		metaData.scriptClass->addInternalCall("Internal_SetHeight", &ScriptModalWindow::internal_setHeight);
-		metaData.scriptClass->addInternalCall("Internal_SetTitle", &ScriptModalWindow::internal_setTitle);
-		metaData.scriptClass->addInternalCall("Internal_ScreenToWindowPos", &ScriptModalWindow::internal_screenToWindowPos);
-		metaData.scriptClass->addInternalCall("Internal_WindowToScreenPos", &ScriptModalWindow::internal_windowToScreenPos);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptModalWindow::internal_createInstance);
+		metaData.scriptClass->addInternalCall("Internal_Close", (void*)&ScriptModalWindow::internal_close);
+		metaData.scriptClass->addInternalCall("Internal_GetWidth", (void*)&ScriptModalWindow::internal_getWidth);
+		metaData.scriptClass->addInternalCall("Internal_GetHeight", (void*)&ScriptModalWindow::internal_getHeight);
+		metaData.scriptClass->addInternalCall("Internal_SetWidth", (void*)&ScriptModalWindow::internal_setWidth);
+		metaData.scriptClass->addInternalCall("Internal_SetHeight", (void*)&ScriptModalWindow::internal_setHeight);
+		metaData.scriptClass->addInternalCall("Internal_SetTitle", (void*)&ScriptModalWindow::internal_setTitle);
+		metaData.scriptClass->addInternalCall("Internal_ScreenToWindowPos", (void*)&ScriptModalWindow::internal_screenToWindowPos);
+		metaData.scriptClass->addInternalCall("Internal_WindowToScreenPos", (void*)&ScriptModalWindow::internal_windowToScreenPos);
 
 		guiPanelField = metaData.scriptClass->getField("GUI");
 	}

Source/SBansheeEditor/Wrappers/BsScriptModalWindow.h

@@ -122,9 +122,9 @@ namespace bs
 	private:
 		friend class ScriptModalWindow;
 
-		typedef void(__stdcall *OnInitializeThunkDef) (MonoObject*, MonoException**);
-		typedef void(__stdcall *OnDestroyThunkDef) (MonoObject*, MonoException**);
-		typedef void(__stdcall *UpdateThunkDef) (MonoObject*, MonoException**);
+		typedef void(BS_THUNKCALL *OnInitializeThunkDef) (MonoObject*, MonoException**);
+		typedef void(BS_THUNKCALL *OnDestroyThunkDef) (MonoObject*, MonoException**);
+		typedef void(BS_THUNKCALL *UpdateThunkDef) (MonoObject*, MonoException**);
 
 		String mNamespace;
 		String mTypename;

Source/SBansheeEditor/Wrappers/BsScriptOSDropTarget.cpp

@@ -52,10 +52,10 @@ namespace bs
 
 	void ScriptOSDropTarget::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptOSDropTarget::internal_CreateInstance);
-		metaData.scriptClass->addInternalCall("Internal_Destroy", &ScriptOSDropTarget::internal_Destroy);
-		metaData.scriptClass->addInternalCall("Internal_SetBounds", &ScriptOSDropTarget::internal_SetBounds);
-		metaData.scriptClass->addInternalCall("Internal_GetFilePaths", &ScriptOSDropTarget::internal_GetFilePaths);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptOSDropTarget::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_Destroy", (void*)&ScriptOSDropTarget::internal_Destroy);
+		metaData.scriptClass->addInternalCall("Internal_SetBounds", (void*)&ScriptOSDropTarget::internal_SetBounds);
+		metaData.scriptClass->addInternalCall("Internal_GetFilePaths", (void*)&ScriptOSDropTarget::internal_GetFilePaths);
 
 		onEnterThunk = (OnEnterThunkDef)metaData.scriptClass->getMethod("InternalDoOnEnter", 2)->getThunk();
 		onMoveThunk = (OnMoveDef)metaData.scriptClass->getMethod("InternalDoOnDrag", 2)->getThunk();

Source/SBansheeEditor/Wrappers/BsScriptOSDropTarget.h

@@ -118,10 +118,10 @@ namespace bs
 		/************************************************************************/
 		/* 								CLR HOOKS						   		*/
 		/************************************************************************/
-		typedef void(__stdcall *OnEnterThunkDef) (MonoObject*, INT32, INT32, MonoException**);
-		typedef void(__stdcall *OnMoveDef) (MonoObject*, INT32, INT32, MonoException**);
-		typedef void(__stdcall *OnLeaveDef) (MonoObject*, MonoException**);
-		typedef void(__stdcall *OnDropThunkDef) (MonoObject*, INT32, INT32, MonoException**);
+		typedef void(BS_THUNKCALL *OnEnterThunkDef) (MonoObject*, INT32, INT32, MonoException**);
+		typedef void(BS_THUNKCALL *OnMoveDef) (MonoObject*, INT32, INT32, MonoException**);
+		typedef void(BS_THUNKCALL *OnLeaveDef) (MonoObject*, MonoException**);
+		typedef void(BS_THUNKCALL *OnDropThunkDef) (MonoObject*, INT32, INT32, MonoException**);
 
 		static OnEnterThunkDef onEnterThunk;
 		static OnMoveDef onMoveThunk;

Source/SBansheeEditor/Wrappers/BsScriptPlatformInfo.cpp

@@ -24,17 +24,17 @@ namespace bs
 
 	void ScriptPlatformInfo::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_GetType", &ScriptPlatformInfo::internal_GetType);
-		metaData.scriptClass->addInternalCall("Internal_GetDefines", &ScriptPlatformInfo::internal_GetDefines);
-		metaData.scriptClass->addInternalCall("Internal_SetDefines", &ScriptPlatformInfo::internal_SetDefines);
-		metaData.scriptClass->addInternalCall("Internal_GetMainScene", &ScriptPlatformInfo::internal_GetMainScene);
-		metaData.scriptClass->addInternalCall("Internal_SetMainScene", &ScriptPlatformInfo::internal_SetMainScene);
-		metaData.scriptClass->addInternalCall("Internal_GetFullscreen", &ScriptPlatformInfo::internal_GetFullscreen);
-		metaData.scriptClass->addInternalCall("Internal_SetFullscreen", &ScriptPlatformInfo::internal_SetFullscreen);
-		metaData.scriptClass->addInternalCall("Internal_GetResolution", &ScriptPlatformInfo::internal_GetResolution);
-		metaData.scriptClass->addInternalCall("Internal_SetResolution", &ScriptPlatformInfo::internal_SetResolution);
-		metaData.scriptClass->addInternalCall("Internal_GetDebug", &ScriptPlatformInfo::internal_GetDebug);
-		metaData.scriptClass->addInternalCall("Internal_SetDebug", &ScriptPlatformInfo::internal_SetDebug);
+		metaData.scriptClass->addInternalCall("Internal_GetType", (void*)&ScriptPlatformInfo::internal_GetType);
+		metaData.scriptClass->addInternalCall("Internal_GetDefines", (void*)&ScriptPlatformInfo::internal_GetDefines);
+		metaData.scriptClass->addInternalCall("Internal_SetDefines", (void*)&ScriptPlatformInfo::internal_SetDefines);
+		metaData.scriptClass->addInternalCall("Internal_GetMainScene", (void*)&ScriptPlatformInfo::internal_GetMainScene);
+		metaData.scriptClass->addInternalCall("Internal_SetMainScene", (void*)&ScriptPlatformInfo::internal_SetMainScene);
+		metaData.scriptClass->addInternalCall("Internal_GetFullscreen", (void*)&ScriptPlatformInfo::internal_GetFullscreen);
+		metaData.scriptClass->addInternalCall("Internal_SetFullscreen", (void*)&ScriptPlatformInfo::internal_SetFullscreen);
+		metaData.scriptClass->addInternalCall("Internal_GetResolution", (void*)&ScriptPlatformInfo::internal_GetResolution);
+		metaData.scriptClass->addInternalCall("Internal_SetResolution", (void*)&ScriptPlatformInfo::internal_SetResolution);
+		metaData.scriptClass->addInternalCall("Internal_GetDebug", (void*)&ScriptPlatformInfo::internal_GetDebug);
+		metaData.scriptClass->addInternalCall("Internal_SetDebug", (void*)&ScriptPlatformInfo::internal_SetDebug);
 	}
 
 	MonoObject* ScriptPlatformInfo::create(const SPtr<PlatformInfo>& platformInfo)
@@ -125,10 +125,10 @@ namespace bs
 
 	void ScriptWinPlatformInfo::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_GetIcon", &ScriptWinPlatformInfo::internal_GetIcon);
-		metaData.scriptClass->addInternalCall("Internal_SetIcon", &ScriptWinPlatformInfo::internal_SetIcon);
-		metaData.scriptClass->addInternalCall("Internal_GetTitleText", &ScriptWinPlatformInfo::internal_GetTitleText);
-		metaData.scriptClass->addInternalCall("Internal_SetTitleText", &ScriptWinPlatformInfo::internal_SetTitleText);
+		metaData.scriptClass->addInternalCall("Internal_GetIcon", (void*)&ScriptWinPlatformInfo::internal_GetIcon);
+		metaData.scriptClass->addInternalCall("Internal_SetIcon", (void*)&ScriptWinPlatformInfo::internal_SetIcon);
+		metaData.scriptClass->addInternalCall("Internal_GetTitleText", (void*)&ScriptWinPlatformInfo::internal_GetTitleText);
+		metaData.scriptClass->addInternalCall("Internal_SetTitleText", (void*)&ScriptWinPlatformInfo::internal_SetTitleText);
 	}
 
 	SPtr<WinPlatformInfo> ScriptWinPlatformInfo::getWinPlatformInfo() const

Source/SBansheeEditor/Wrappers/BsScriptPrefabUtility.cpp

@@ -20,14 +20,14 @@ namespace bs
 
 	void ScriptPrefabUtility::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_BreakPrefab", &ScriptPrefabUtility::internal_breakPrefab);
-		metaData.scriptClass->addInternalCall("Internal_ApplyPrefab", &ScriptPrefabUtility::internal_applyPrefab);
-		metaData.scriptClass->addInternalCall("Internal_RevertPrefab", &ScriptPrefabUtility::internal_revertPrefab);
-		metaData.scriptClass->addInternalCall("Internal_HasPrefabLink", &ScriptPrefabUtility::internal_hasPrefabLink);
-		metaData.scriptClass->addInternalCall("Internal_GetPrefabParent", &ScriptPrefabUtility::internal_getPrefabParent);
-		metaData.scriptClass->addInternalCall("Internal_GetPrefabUUID", &ScriptPrefabUtility::internal_GetPrefabUUID);
-		metaData.scriptClass->addInternalCall("Internal_UpdateFromPrefab", &ScriptPrefabUtility::internal_UpdateFromPrefab);
-		metaData.scriptClass->addInternalCall("Internal_RecordPrefabDiff", &ScriptPrefabUtility::internal_RecordPrefabDiff);
+		metaData.scriptClass->addInternalCall("Internal_BreakPrefab", (void*)&ScriptPrefabUtility::internal_breakPrefab);
+		metaData.scriptClass->addInternalCall("Internal_ApplyPrefab", (void*)&ScriptPrefabUtility::internal_applyPrefab);
+		metaData.scriptClass->addInternalCall("Internal_RevertPrefab", (void*)&ScriptPrefabUtility::internal_revertPrefab);
+		metaData.scriptClass->addInternalCall("Internal_HasPrefabLink", (void*)&ScriptPrefabUtility::internal_hasPrefabLink);
+		metaData.scriptClass->addInternalCall("Internal_GetPrefabParent", (void*)&ScriptPrefabUtility::internal_getPrefabParent);
+		metaData.scriptClass->addInternalCall("Internal_GetPrefabUUID", (void*)&ScriptPrefabUtility::internal_GetPrefabUUID);
+		metaData.scriptClass->addInternalCall("Internal_UpdateFromPrefab", (void*)&ScriptPrefabUtility::internal_UpdateFromPrefab);
+		metaData.scriptClass->addInternalCall("Internal_RecordPrefabDiff", (void*)&ScriptPrefabUtility::internal_RecordPrefabDiff);
 	}
 
 	void ScriptPrefabUtility::internal_breakPrefab(ScriptSceneObject* soPtr)

Source/SBansheeEditor/Wrappers/BsScriptProjectLibrary.cpp

@@ -33,26 +33,26 @@ namespace bs
 
 	void ScriptProjectLibrary::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_Refresh", &ScriptProjectLibrary::internal_Refresh);
-		metaData.scriptClass->addInternalCall("Internal_Create", &ScriptProjectLibrary::internal_Create);
-		metaData.scriptClass->addInternalCall("Internal_Load", &ScriptProjectLibrary::internal_Load);
-		metaData.scriptClass->addInternalCall("Internal_Save", &ScriptProjectLibrary::internal_Save);
-		metaData.scriptClass->addInternalCall("Internal_GetRoot", &ScriptProjectLibrary::internal_GetRoot);
-		metaData.scriptClass->addInternalCall("Internal_Reimport", &ScriptProjectLibrary::internal_Reimport);
-		metaData.scriptClass->addInternalCall("Internal_GetEntry", &ScriptProjectLibrary::internal_GetEntry);
-		metaData.scriptClass->addInternalCall("Internal_IsSubresource", &ScriptProjectLibrary::internal_IsSubresource);
-		metaData.scriptClass->addInternalCall("Internal_GetMeta", &ScriptProjectLibrary::internal_GetMeta);
-		metaData.scriptClass->addInternalCall("Internal_GetPath", &ScriptProjectLibrary::internal_GetPath);
-		metaData.scriptClass->addInternalCall("Internal_GetPathFromUUID", &ScriptProjectLibrary::internal_GetPathFromUUID);
-		metaData.scriptClass->addInternalCall("Internal_Search", &ScriptProjectLibrary::internal_Search);
-		metaData.scriptClass->addInternalCall("Internal_Delete", &ScriptProjectLibrary::internal_Delete);
-		metaData.scriptClass->addInternalCall("Internal_CreateFolder", &ScriptProjectLibrary::internal_CreateFolder);
-		metaData.scriptClass->addInternalCall("Internal_Rename", &ScriptProjectLibrary::internal_Rename);
-		metaData.scriptClass->addInternalCall("Internal_Move", &ScriptProjectLibrary::internal_Move);
-		metaData.scriptClass->addInternalCall("Internal_Copy", &ScriptProjectLibrary::internal_Copy);
-		metaData.scriptClass->addInternalCall("Internal_GetResourceFolder", &ScriptProjectLibrary::internal_GetResourceFolder);
-		metaData.scriptClass->addInternalCall("Internal_SetIncludeInBuild", &ScriptProjectLibrary::internal_SetIncludeInBuild);
-		metaData.scriptClass->addInternalCall("Internal_SetEditorData", &ScriptProjectLibrary::internal_SetEditorData);
+		metaData.scriptClass->addInternalCall("Internal_Refresh", (void*)&ScriptProjectLibrary::internal_Refresh);
+		metaData.scriptClass->addInternalCall("Internal_Create", (void*)&ScriptProjectLibrary::internal_Create);
+		metaData.scriptClass->addInternalCall("Internal_Load", (void*)&ScriptProjectLibrary::internal_Load);
+		metaData.scriptClass->addInternalCall("Internal_Save", (void*)&ScriptProjectLibrary::internal_Save);
+		metaData.scriptClass->addInternalCall("Internal_GetRoot", (void*)&ScriptProjectLibrary::internal_GetRoot);
+		metaData.scriptClass->addInternalCall("Internal_Reimport", (void*)&ScriptProjectLibrary::internal_Reimport);
+		metaData.scriptClass->addInternalCall("Internal_GetEntry", (void*)&ScriptProjectLibrary::internal_GetEntry);
+		metaData.scriptClass->addInternalCall("Internal_IsSubresource", (void*)&ScriptProjectLibrary::internal_IsSubresource);
+		metaData.scriptClass->addInternalCall("Internal_GetMeta", (void*)&ScriptProjectLibrary::internal_GetMeta);
+		metaData.scriptClass->addInternalCall("Internal_GetPath", (void*)&ScriptProjectLibrary::internal_GetPath);
+		metaData.scriptClass->addInternalCall("Internal_GetPathFromUUID", (void*)&ScriptProjectLibrary::internal_GetPathFromUUID);
+		metaData.scriptClass->addInternalCall("Internal_Search", (void*)&ScriptProjectLibrary::internal_Search);
+		metaData.scriptClass->addInternalCall("Internal_Delete", (void*)&ScriptProjectLibrary::internal_Delete);
+		metaData.scriptClass->addInternalCall("Internal_CreateFolder", (void*)&ScriptProjectLibrary::internal_CreateFolder);
+		metaData.scriptClass->addInternalCall("Internal_Rename", (void*)&ScriptProjectLibrary::internal_Rename);
+		metaData.scriptClass->addInternalCall("Internal_Move", (void*)&ScriptProjectLibrary::internal_Move);
+		metaData.scriptClass->addInternalCall("Internal_Copy", (void*)&ScriptProjectLibrary::internal_Copy);
+		metaData.scriptClass->addInternalCall("Internal_GetResourceFolder", (void*)&ScriptProjectLibrary::internal_GetResourceFolder);
+		metaData.scriptClass->addInternalCall("Internal_SetIncludeInBuild", (void*)&ScriptProjectLibrary::internal_SetIncludeInBuild);
+		metaData.scriptClass->addInternalCall("Internal_SetEditorData", (void*)&ScriptProjectLibrary::internal_SetEditorData);
 
 		OnEntryAddedThunk = (OnEntryChangedThunkDef)metaData.scriptClass->getMethod("Internal_DoOnEntryAdded", 1)->getThunk();
 		OnEntryRemovedThunk = (OnEntryChangedThunkDef)metaData.scriptClass->getMethod("Internal_DoOnEntryRemoved", 1)->getThunk();
@@ -332,10 +332,10 @@ namespace bs
 
 	void ScriptLibraryEntry::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_GetPath", &ScriptLibraryEntry::internal_GetPath);
-		metaData.scriptClass->addInternalCall("Internal_GetName", &ScriptLibraryEntry::internal_GetName);
-		metaData.scriptClass->addInternalCall("Internal_GetType", &ScriptLibraryEntry::internal_GetType);
-		metaData.scriptClass->addInternalCall("Internal_GetParent", &ScriptLibraryEntry::internal_GetParent);
+		metaData.scriptClass->addInternalCall("Internal_GetPath", (void*)&ScriptLibraryEntry::internal_GetPath);
+		metaData.scriptClass->addInternalCall("Internal_GetName", (void*)&ScriptLibraryEntry::internal_GetName);
+		metaData.scriptClass->addInternalCall("Internal_GetType", (void*)&ScriptLibraryEntry::internal_GetType);
+		metaData.scriptClass->addInternalCall("Internal_GetParent", (void*)&ScriptLibraryEntry::internal_GetParent);
 	}
 
 	MonoString* ScriptLibraryEntry::internal_GetPath(ScriptLibraryEntryBase* thisPtr)
@@ -393,7 +393,7 @@ namespace bs
 
 	void ScriptDirectoryEntry::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_GetChildren", &ScriptDirectoryEntry::internal_GetChildren);
+		metaData.scriptClass->addInternalCall("Internal_GetChildren", (void*)&ScriptDirectoryEntry::internal_GetChildren);
 	}
 
 	MonoArray* ScriptDirectoryEntry::internal_GetChildren(ScriptDirectoryEntry* thisPtr)
@@ -436,9 +436,9 @@ namespace bs
 
 	void ScriptFileEntry::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_GetImportOptions", &ScriptFileEntry::internal_GetImportOptions);
-		metaData.scriptClass->addInternalCall("Internal_GetResourceMetas", &ScriptFileEntry::internal_GetResourceMetas);
-		metaData.scriptClass->addInternalCall("Internal_GetIncludeInBuild", &ScriptFileEntry::internal_GetIncludeInBuild);
+		metaData.scriptClass->addInternalCall("Internal_GetImportOptions", (void*)&ScriptFileEntry::internal_GetImportOptions);
+		metaData.scriptClass->addInternalCall("Internal_GetResourceMetas", (void*)&ScriptFileEntry::internal_GetResourceMetas);
+		metaData.scriptClass->addInternalCall("Internal_GetIncludeInBuild", (void*)&ScriptFileEntry::internal_GetIncludeInBuild);
 	}
 
 	MonoObject* ScriptFileEntry::internal_GetImportOptions(ScriptFileEntry* thisPtr)
@@ -506,11 +506,11 @@ namespace bs
 
 	void ScriptResourceMeta::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_GetUUID", &ScriptResourceMeta::internal_GetUUID);
-		metaData.scriptClass->addInternalCall("Internal_GetSubresourceName", &ScriptResourceMeta::internal_GetSubresourceName);
-		metaData.scriptClass->addInternalCall("Internal_GetIcon", &ScriptResourceMeta::internal_GetIcon);
-		metaData.scriptClass->addInternalCall("Internal_GetResourceType", &ScriptResourceMeta::internal_GetResourceType);
-		metaData.scriptClass->addInternalCall("Internal_GetEditorData", &ScriptResourceMeta::internal_GetEditorData);
+		metaData.scriptClass->addInternalCall("Internal_GetUUID", (void*)&ScriptResourceMeta::internal_GetUUID);
+		metaData.scriptClass->addInternalCall("Internal_GetSubresourceName", (void*)&ScriptResourceMeta::internal_GetSubresourceName);
+		metaData.scriptClass->addInternalCall("Internal_GetIcon", (void*)&ScriptResourceMeta::internal_GetIcon);
+		metaData.scriptClass->addInternalCall("Internal_GetResourceType", (void*)&ScriptResourceMeta::internal_GetResourceType);
+		metaData.scriptClass->addInternalCall("Internal_GetEditorData", (void*)&ScriptResourceMeta::internal_GetEditorData);
 	}
 
 	MonoString* ScriptResourceMeta::internal_GetUUID(ScriptResourceMeta* thisPtr)

Source/SBansheeEditor/Wrappers/BsScriptProjectLibrary.h

@@ -56,7 +56,7 @@ namespace bs
 		/************************************************************************/
 		/* 								CLR HOOKS						   		*/
 		/************************************************************************/
-		typedef void(__stdcall *OnEntryChangedThunkDef) (MonoString*, MonoException**);
+		typedef void(BS_THUNKCALL *OnEntryChangedThunkDef) (MonoString*, MonoException**);
 
 		static OnEntryChangedThunkDef OnEntryAddedThunk;
 		static OnEntryChangedThunkDef OnEntryRemovedThunk;

Source/SBansheeEditor/Wrappers/BsScriptProjectSettings.cpp

@@ -16,21 +16,21 @@ namespace bs
 
 	void ScriptProjectSettings::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_GetLastOpenScene", &ScriptProjectSettings::internal_GetLastOpenScene);
-		metaData.scriptClass->addInternalCall("Internal_SetLastOpenScene", &ScriptProjectSettings::internal_SetLastOpenScene);
-		metaData.scriptClass->addInternalCall("Internal_SetFloat", &ScriptProjectSettings::internal_SetFloat);
-		metaData.scriptClass->addInternalCall("Internal_SetInt", &ScriptProjectSettings::internal_SetInt);
-		metaData.scriptClass->addInternalCall("Internal_SetBool", &ScriptProjectSettings::internal_SetBool);
-		metaData.scriptClass->addInternalCall("Internal_SetString", &ScriptProjectSettings::internal_SetString);
-		metaData.scriptClass->addInternalCall("Internal_GetFloat", &ScriptProjectSettings::internal_GetFloat);
-		metaData.scriptClass->addInternalCall("Internal_GetInt", &ScriptProjectSettings::internal_GetInt);
-		metaData.scriptClass->addInternalCall("Internal_GetBool", &ScriptProjectSettings::internal_GetBool);
-		metaData.scriptClass->addInternalCall("Internal_GetString", &ScriptProjectSettings::internal_GetString);
-		metaData.scriptClass->addInternalCall("Internal_HasKey", &ScriptProjectSettings::internal_HasKey);
-		metaData.scriptClass->addInternalCall("Internal_DeleteKey", &ScriptProjectSettings::internal_DeleteKey);
-		metaData.scriptClass->addInternalCall("Internal_DeleteAllKeys", &ScriptProjectSettings::internal_DeleteAllKeys);
-		metaData.scriptClass->addInternalCall("Internal_GetHash", &ScriptProjectSettings::internal_GetHash);
-		metaData.scriptClass->addInternalCall("Internal_Save", &ScriptProjectSettings::internal_Save);
+		metaData.scriptClass->addInternalCall("Internal_GetLastOpenScene", (void*)&ScriptProjectSettings::internal_GetLastOpenScene);
+		metaData.scriptClass->addInternalCall("Internal_SetLastOpenScene", (void*)&ScriptProjectSettings::internal_SetLastOpenScene);
+		metaData.scriptClass->addInternalCall("Internal_SetFloat", (void*)&ScriptProjectSettings::internal_SetFloat);
+		metaData.scriptClass->addInternalCall("Internal_SetInt", (void*)&ScriptProjectSettings::internal_SetInt);
+		metaData.scriptClass->addInternalCall("Internal_SetBool", (void*)&ScriptProjectSettings::internal_SetBool);
+		metaData.scriptClass->addInternalCall("Internal_SetString", (void*)&ScriptProjectSettings::internal_SetString);
+		metaData.scriptClass->addInternalCall("Internal_GetFloat", (void*)&ScriptProjectSettings::internal_GetFloat);
+		metaData.scriptClass->addInternalCall("Internal_GetInt", (void*)&ScriptProjectSettings::internal_GetInt);
+		metaData.scriptClass->addInternalCall("Internal_GetBool", (void*)&ScriptProjectSettings::internal_GetBool);
+		metaData.scriptClass->addInternalCall("Internal_GetString", (void*)&ScriptProjectSettings::internal_GetString);
+		metaData.scriptClass->addInternalCall("Internal_HasKey", (void*)&ScriptProjectSettings::internal_HasKey);
+		metaData.scriptClass->addInternalCall("Internal_DeleteKey", (void*)&ScriptProjectSettings::internal_DeleteKey);
+		metaData.scriptClass->addInternalCall("Internal_DeleteAllKeys", (void*)&ScriptProjectSettings::internal_DeleteAllKeys);
+		metaData.scriptClass->addInternalCall("Internal_GetHash", (void*)&ScriptProjectSettings::internal_GetHash);
+		metaData.scriptClass->addInternalCall("Internal_Save", (void*)&ScriptProjectSettings::internal_Save);
 	}
 
 	MonoString* ScriptProjectSettings::internal_GetLastOpenScene()

Source/SBansheeEditor/Wrappers/BsScriptSceneGizmos.cpp

@@ -20,8 +20,8 @@ namespace bs
 
 	void ScriptSceneGizmos::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_Create", &ScriptSceneGizmos::internal_Create);
-		metaData.scriptClass->addInternalCall("Internal_Draw", &ScriptSceneGizmos::internal_Draw);
+		metaData.scriptClass->addInternalCall("Internal_Create", (void*)&ScriptSceneGizmos::internal_Create);
+		metaData.scriptClass->addInternalCall("Internal_Draw", (void*)&ScriptSceneGizmos::internal_Draw);
 	}
 
 	void ScriptSceneGizmos::internal_Create(MonoObject* managedInstance, ScriptCamera* camera)

Source/SBansheeEditor/Wrappers/BsScriptSceneGrid.cpp

@@ -21,9 +21,9 @@ namespace bs
 
 	void ScriptSceneGrid::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_Create", &ScriptSceneGrid::internal_Create);
-		metaData.scriptClass->addInternalCall("Internal_Draw", &ScriptSceneGrid::internal_Draw);
-		metaData.scriptClass->addInternalCall("Internal_SetMode", &ScriptSceneGrid::internal_SetMode);
+		metaData.scriptClass->addInternalCall("Internal_Create", (void*)&ScriptSceneGrid::internal_Create);
+		metaData.scriptClass->addInternalCall("Internal_Draw", (void*)&ScriptSceneGrid::internal_Draw);
+		metaData.scriptClass->addInternalCall("Internal_SetMode", (void*)&ScriptSceneGrid::internal_SetMode);
 	}
 
 	void ScriptSceneGrid::internal_Create(MonoObject* managedInstance, ScriptCamera* camera)

Source/SBansheeEditor/Wrappers/BsScriptSceneHandles.cpp

@@ -25,14 +25,14 @@ namespace bs
 
 	void ScriptSceneHandles::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_Create", &ScriptSceneHandles::internal_Create);
-		metaData.scriptClass->addInternalCall("Internal_Draw", &ScriptSceneHandles::internal_Draw);
-		metaData.scriptClass->addInternalCall("Internal_BeginInput", &ScriptSceneHandles::internal_BeginInput);
-		metaData.scriptClass->addInternalCall("Internal_EndInput", &ScriptSceneHandles::internal_EndInput);
-		metaData.scriptClass->addInternalCall("Internal_UpdateInput", &ScriptSceneHandles::internal_UpdateInput);
-		metaData.scriptClass->addInternalCall("Internal_TrySelect", &ScriptSceneHandles::internal_TrySelect);
-		metaData.scriptClass->addInternalCall("Internal_IsActive", &ScriptSceneHandles::internal_IsActive);
-		metaData.scriptClass->addInternalCall("Internal_ClearSelection", &ScriptSceneHandles::internal_ClearSelection);
+		metaData.scriptClass->addInternalCall("Internal_Create", (void*)&ScriptSceneHandles::internal_Create);
+		metaData.scriptClass->addInternalCall("Internal_Draw", (void*)&ScriptSceneHandles::internal_Draw);
+		metaData.scriptClass->addInternalCall("Internal_BeginInput", (void*)&ScriptSceneHandles::internal_BeginInput);
+		metaData.scriptClass->addInternalCall("Internal_EndInput", (void*)&ScriptSceneHandles::internal_EndInput);
+		metaData.scriptClass->addInternalCall("Internal_UpdateInput", (void*)&ScriptSceneHandles::internal_UpdateInput);
+		metaData.scriptClass->addInternalCall("Internal_TrySelect", (void*)&ScriptSceneHandles::internal_TrySelect);
+		metaData.scriptClass->addInternalCall("Internal_IsActive", (void*)&ScriptSceneHandles::internal_IsActive);
+		metaData.scriptClass->addInternalCall("Internal_ClearSelection", (void*)&ScriptSceneHandles::internal_ClearSelection);
 	}
 
 	Vector2I ScriptSceneHandles::wrapCursorToWindow() const

Source/SBansheeEditor/Wrappers/BsScriptSceneSelection.cpp

@@ -25,11 +25,11 @@ namespace bs
 
 	void ScriptSceneSelection::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_Create", &ScriptSceneSelection::internal_Create);
-		metaData.scriptClass->addInternalCall("Internal_Draw", &ScriptSceneSelection::internal_Draw);
-		metaData.scriptClass->addInternalCall("Internal_PickObject", &ScriptSceneSelection::internal_PickObject);
-		metaData.scriptClass->addInternalCall("Internal_PickObjects", &ScriptSceneSelection::internal_PickObjects);
-		metaData.scriptClass->addInternalCall("Internal_Snap", &ScriptSceneSelection::internal_Snap);
+		metaData.scriptClass->addInternalCall("Internal_Create", (void*)&ScriptSceneSelection::internal_Create);
+		metaData.scriptClass->addInternalCall("Internal_Draw", (void*)&ScriptSceneSelection::internal_Draw);
+		metaData.scriptClass->addInternalCall("Internal_PickObject", (void*)&ScriptSceneSelection::internal_PickObject);
+		metaData.scriptClass->addInternalCall("Internal_PickObjects", (void*)&ScriptSceneSelection::internal_PickObjects);
+		metaData.scriptClass->addInternalCall("Internal_Snap", (void*)&ScriptSceneSelection::internal_Snap);
 	}
 
 	void ScriptSceneSelection::internal_Create(MonoObject* managedInstance, ScriptCamera* camera)

Source/SBansheeEditor/Wrappers/BsScriptSelection.cpp

@@ -27,14 +27,14 @@ namespace bs
 
 	void ScriptSelection::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_GetSceneObjectSelection", &ScriptSelection::internal_GetSceneObjectSelection);
-		metaData.scriptClass->addInternalCall("Internal_SetSceneObjectSelection", &ScriptSelection::internal_SetSceneObjectSelection);
-		metaData.scriptClass->addInternalCall("Internal_GetResourceUUIDSelection", &ScriptSelection::internal_GetResourceUUIDSelection);
-		metaData.scriptClass->addInternalCall("Internal_SetResourceUUIDSelection", &ScriptSelection::internal_SetResourceUUIDSelection);
-		metaData.scriptClass->addInternalCall("Internal_GetResourcePathSelection", &ScriptSelection::internal_GetResourcePathSelection);
-		metaData.scriptClass->addInternalCall("Internal_SetResourcePathSelection", &ScriptSelection::internal_SetResourcePathSelection);
-		metaData.scriptClass->addInternalCall("Internal_PingResource", &ScriptSelection::internal_PingResource);
-		metaData.scriptClass->addInternalCall("Internal_PingSceneObject", &ScriptSelection::internal_PingSceneObject);
+		metaData.scriptClass->addInternalCall("Internal_GetSceneObjectSelection", (void*)&ScriptSelection::internal_GetSceneObjectSelection);
+		metaData.scriptClass->addInternalCall("Internal_SetSceneObjectSelection", (void*)&ScriptSelection::internal_SetSceneObjectSelection);
+		metaData.scriptClass->addInternalCall("Internal_GetResourceUUIDSelection", (void*)&ScriptSelection::internal_GetResourceUUIDSelection);
+		metaData.scriptClass->addInternalCall("Internal_SetResourceUUIDSelection", (void*)&ScriptSelection::internal_SetResourceUUIDSelection);
+		metaData.scriptClass->addInternalCall("Internal_GetResourcePathSelection", (void*)&ScriptSelection::internal_GetResourcePathSelection);
+		metaData.scriptClass->addInternalCall("Internal_SetResourcePathSelection", (void*)&ScriptSelection::internal_SetResourcePathSelection);
+		metaData.scriptClass->addInternalCall("Internal_PingResource", (void*)&ScriptSelection::internal_PingResource);
+		metaData.scriptClass->addInternalCall("Internal_PingSceneObject", (void*)&ScriptSelection::internal_PingSceneObject);
 
 		OnSelectionChangedThunk = (OnSelectionChangedThunkDef)metaData.scriptClass->getMethod("Internal_TriggerSelectionChanged", 2)->getThunk();
 		OnPingResourceThunk = (OnPingResourceThunkDef)metaData.scriptClass->getMethod("Internal_TriggerResourcePing", 1)->getThunk();

Source/SBansheeEditor/Wrappers/BsScriptSelection.h

@@ -49,9 +49,9 @@ namespace bs
 		/************************************************************************/
 		/* 								CLR HOOKS						   		*/
 		/************************************************************************/
-		typedef void(__stdcall *OnSelectionChangedThunkDef) (MonoArray*, MonoArray*, MonoException**);
-		typedef void(__stdcall *OnPingResourceThunkDef) (MonoString*, MonoException**);
-		typedef void(__stdcall *OnPingSceneObjectThunkDef) (MonoObject*, MonoException**);
+		typedef void(BS_THUNKCALL *OnSelectionChangedThunkDef) (MonoArray*, MonoArray*, MonoException**);
+		typedef void(BS_THUNKCALL *OnPingResourceThunkDef) (MonoString*, MonoException**);
+		typedef void(BS_THUNKCALL *OnPingSceneObjectThunkDef) (MonoObject*, MonoException**);
 
 		static OnSelectionChangedThunkDef OnSelectionChangedThunk;
 		static OnPingResourceThunkDef OnPingResourceThunk;

Source/SBansheeEditor/Wrappers/BsScriptSerializedDiff.cpp

@@ -17,8 +17,8 @@ namespace bs
 
 	void ScriptSerializedDiff::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateDiff", &ScriptSerializedDiff::internal_CreateDiff);
-		metaData.scriptClass->addInternalCall("Internal_ApplyDiff", &ScriptSerializedDiff::internal_ApplyDiff);
+		metaData.scriptClass->addInternalCall("Internal_CreateDiff", (void*)&ScriptSerializedDiff::internal_CreateDiff);
+		metaData.scriptClass->addInternalCall("Internal_ApplyDiff", (void*)&ScriptSerializedDiff::internal_ApplyDiff);
 	}
 
 	MonoObject* ScriptSerializedDiff::internal_CreateDiff(ScriptSerializedObject* oldObj, MonoObject* newObj)

Source/SBansheeEditor/Wrappers/BsScriptSerializedObject.cpp

@@ -21,10 +21,10 @@ namespace bs
 
 	void ScriptSerializedObject::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateComponent", &ScriptSerializedObject::internal_CreateComponent);
-		metaData.scriptClass->addInternalCall("Internal_CreateResource", &ScriptSerializedObject::internal_CreateResource);
-		metaData.scriptClass->addInternalCall("Internal_CreateGeneric", &ScriptSerializedObject::internal_CreateGeneric);
-		metaData.scriptClass->addInternalCall("Internal_Deserialize", &ScriptSerializedObject::internal_Deserialize);
+		metaData.scriptClass->addInternalCall("Internal_CreateComponent", (void*)&ScriptSerializedObject::internal_CreateComponent);
+		metaData.scriptClass->addInternalCall("Internal_CreateResource", (void*)&ScriptSerializedObject::internal_CreateResource);
+		metaData.scriptClass->addInternalCall("Internal_CreateGeneric", (void*)&ScriptSerializedObject::internal_CreateGeneric);
+		metaData.scriptClass->addInternalCall("Internal_Deserialize", (void*)&ScriptSerializedObject::internal_Deserialize);
 	}
 
 	MonoObject* ScriptSerializedObject::internal_CreateComponent(ScriptManagedComponent* componentPtr)

Source/SBansheeEditor/Wrappers/BsScriptSerializedSceneObject.cpp

@@ -58,8 +58,8 @@ namespace bs
 
 	void ScriptSerializedSceneObject::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptSerializedSceneObject::internal_CreateInstance);
-		metaData.scriptClass->addInternalCall("Internal_Restore", &ScriptSerializedSceneObject::internal_Restore);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptSerializedSceneObject::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_Restore", (void*)&ScriptSerializedSceneObject::internal_Restore);
 	}
 
 	void ScriptSerializedSceneObject::internal_CreateInstance(MonoObject* instance, ScriptSceneObject* so, bool hierarchy)

Source/SBansheeEditor/Wrappers/BsScriptUndoRedo.cpp

@@ -31,24 +31,24 @@ namespace bs
 
 	void ScriptUndoRedo::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptUndoRedo::internal_CreateInstance);
-		metaData.scriptClass->addInternalCall("Internal_Undo", &ScriptUndoRedo::internal_Undo);
-		metaData.scriptClass->addInternalCall("Internal_Redo", &ScriptUndoRedo::internal_Redo);
-		metaData.scriptClass->addInternalCall("Internal_RegisterCommand", &ScriptUndoRedo::internal_RegisterCommand);
-		metaData.scriptClass->addInternalCall("Internal_PushGroup", &ScriptUndoRedo::internal_PushGroup);
-		metaData.scriptClass->addInternalCall("Internal_PopGroup", &ScriptUndoRedo::internal_PopGroup);
-		metaData.scriptClass->addInternalCall("Internal_Clear", &ScriptUndoRedo::internal_Clear);
-		metaData.scriptClass->addInternalCall("Internal_GetTopCommandId", &ScriptUndoRedo::internal_GetTopCommandId);
-		metaData.scriptClass->addInternalCall("Internal_PopCommand", &ScriptUndoRedo::internal_PopCommand);
-		metaData.scriptClass->addInternalCall("Internal_RecordSO", &ScriptUndoRedo::internal_RecordSO);
-		metaData.scriptClass->addInternalCall("Internal_CloneSO", &ScriptUndoRedo::internal_CloneSO);
-		metaData.scriptClass->addInternalCall("Internal_CloneSOMulti", &ScriptUndoRedo::internal_CloneSOMulti);
-		metaData.scriptClass->addInternalCall("Internal_Instantiate", &ScriptUndoRedo::internal_Instantiate);
-		metaData.scriptClass->addInternalCall("Internal_CreateSO", &ScriptUndoRedo::internal_CreateSO);
-		metaData.scriptClass->addInternalCall("Internal_DeleteSO", &ScriptUndoRedo::internal_DeleteSO);
-		metaData.scriptClass->addInternalCall("Internal_ReparentSO", &ScriptUndoRedo::internal_ReparentSO);
-		metaData.scriptClass->addInternalCall("Internal_ReparentSOMulti", &ScriptUndoRedo::internal_ReparentSOMulti);
-		metaData.scriptClass->addInternalCall("Internal_BreakPrefab", &ScriptUndoRedo::internal_BreakPrefab);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptUndoRedo::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_Undo", (void*)&ScriptUndoRedo::internal_Undo);
+		metaData.scriptClass->addInternalCall("Internal_Redo", (void*)&ScriptUndoRedo::internal_Redo);
+		metaData.scriptClass->addInternalCall("Internal_RegisterCommand", (void*)&ScriptUndoRedo::internal_RegisterCommand);
+		metaData.scriptClass->addInternalCall("Internal_PushGroup", (void*)&ScriptUndoRedo::internal_PushGroup);
+		metaData.scriptClass->addInternalCall("Internal_PopGroup", (void*)&ScriptUndoRedo::internal_PopGroup);
+		metaData.scriptClass->addInternalCall("Internal_Clear", (void*)&ScriptUndoRedo::internal_Clear);
+		metaData.scriptClass->addInternalCall("Internal_GetTopCommandId", (void*)&ScriptUndoRedo::internal_GetTopCommandId);
+		metaData.scriptClass->addInternalCall("Internal_PopCommand", (void*)&ScriptUndoRedo::internal_PopCommand);
+		metaData.scriptClass->addInternalCall("Internal_RecordSO", (void*)&ScriptUndoRedo::internal_RecordSO);
+		metaData.scriptClass->addInternalCall("Internal_CloneSO", (void*)&ScriptUndoRedo::internal_CloneSO);
+		metaData.scriptClass->addInternalCall("Internal_CloneSOMulti", (void*)&ScriptUndoRedo::internal_CloneSOMulti);
+		metaData.scriptClass->addInternalCall("Internal_Instantiate", (void*)&ScriptUndoRedo::internal_Instantiate);
+		metaData.scriptClass->addInternalCall("Internal_CreateSO", (void*)&ScriptUndoRedo::internal_CreateSO);
+		metaData.scriptClass->addInternalCall("Internal_DeleteSO", (void*)&ScriptUndoRedo::internal_DeleteSO);
+		metaData.scriptClass->addInternalCall("Internal_ReparentSO", (void*)&ScriptUndoRedo::internal_ReparentSO);
+		metaData.scriptClass->addInternalCall("Internal_ReparentSOMulti", (void*)&ScriptUndoRedo::internal_ReparentSOMulti);
+		metaData.scriptClass->addInternalCall("Internal_BreakPrefab", (void*)&ScriptUndoRedo::internal_BreakPrefab);
 	}
 
 	void ScriptUndoRedo::startUp()

Source/SBansheeEditor/Wrappers/BsScriptUnitTests.cpp

@@ -16,9 +16,9 @@ namespace bs
 
 	void ScriptUnitTests::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_UT1_GameObjectClone", &ScriptUnitTests::internal_UT1_GameObjectClone);
-		metaData.scriptClass->addInternalCall("Internal_UT3_GenerateDiff", &ScriptUnitTests::internal_UT3_GenerateDiff);
-		metaData.scriptClass->addInternalCall("Internal_UT3_ApplyDiff", &ScriptUnitTests::internal_UT3_ApplyDiff);
+		metaData.scriptClass->addInternalCall("Internal_UT1_GameObjectClone", (void*)&ScriptUnitTests::internal_UT1_GameObjectClone);
+		metaData.scriptClass->addInternalCall("Internal_UT3_GenerateDiff", (void*)&ScriptUnitTests::internal_UT3_GenerateDiff);
+		metaData.scriptClass->addInternalCall("Internal_UT3_ApplyDiff", (void*)&ScriptUnitTests::internal_UT3_ApplyDiff);
 
 		RunTestsMethod = metaData.scriptClass->getMethod("RunTests");
 	}

Source/SBansheeEditor/Wrappers/GUI/BsScriptGUIColorField.cpp

@@ -25,10 +25,10 @@ namespace bs
 
 	void ScriptGUIColorField::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptGUIColorField::internal_createInstance);
-		metaData.scriptClass->addInternalCall("Internal_GetValue", &ScriptGUIColorField::internal_getValue);
-		metaData.scriptClass->addInternalCall("Internal_SetValue", &ScriptGUIColorField::internal_setValue);
-		metaData.scriptClass->addInternalCall("Internal_SetTint", &ScriptGUIColorField::internal_setTint);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptGUIColorField::internal_createInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetValue", (void*)&ScriptGUIColorField::internal_getValue);
+		metaData.scriptClass->addInternalCall("Internal_SetValue", (void*)&ScriptGUIColorField::internal_setValue);
+		metaData.scriptClass->addInternalCall("Internal_SetTint", (void*)&ScriptGUIColorField::internal_setTint);
 
 		onClickedThunk = (OnClickedThunkDef)metaData.scriptClass->getMethod("Internal_DoOnClicked")->getThunk();
 	}

Source/SBansheeEditor/Wrappers/GUI/BsScriptGUIColorField.h

@@ -37,7 +37,7 @@ namespace bs
 		static void internal_setValue(ScriptGUIColorField* nativeInstance, Color* value);
 		static void internal_setTint(ScriptGUIColorField* nativeInstance, Color* color);
 
-		typedef void(__stdcall *OnClickedThunkDef) (MonoObject*, MonoException**);
+		typedef void(BS_THUNKCALL *OnClickedThunkDef) (MonoObject*, MonoException**);
 
 		static OnClickedThunkDef onClickedThunk;
 	};

Source/SBansheeEditor/Wrappers/GUI/BsScriptGUIEnumField.cpp

@@ -27,14 +27,14 @@ namespace bs
 
 	void ScriptGUIEnumField::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptGUIEnumField::internal_createInstance);
-		metaData.scriptClass->addInternalCall("Internal_GetValue", &ScriptGUIEnumField::internal_getValue);
-		metaData.scriptClass->addInternalCall("Internal_SetValue", &ScriptGUIEnumField::internal_setValue);
-		metaData.scriptClass->addInternalCall("Internal_SetTint", &ScriptGUIEnumField::internal_setTint);
-		metaData.scriptClass->addInternalCall("Internal_SelectElement", &ScriptGUIEnumField::internal_selectElement);
-		metaData.scriptClass->addInternalCall("Internal_DeselectElement", &ScriptGUIEnumField::internal_deselectElement);
-		metaData.scriptClass->addInternalCall("Internal_GetElementStates", &ScriptGUIEnumField::internal_getElementStates);
-		metaData.scriptClass->addInternalCall("Internal_SetElementStates", &ScriptGUIEnumField::internal_setElementStates);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptGUIEnumField::internal_createInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetValue", (void*)&ScriptGUIEnumField::internal_getValue);
+		metaData.scriptClass->addInternalCall("Internal_SetValue", (void*)&ScriptGUIEnumField::internal_setValue);
+		metaData.scriptClass->addInternalCall("Internal_SetTint", (void*)&ScriptGUIEnumField::internal_setTint);
+		metaData.scriptClass->addInternalCall("Internal_SelectElement", (void*)&ScriptGUIEnumField::internal_selectElement);
+		metaData.scriptClass->addInternalCall("Internal_DeselectElement", (void*)&ScriptGUIEnumField::internal_deselectElement);
+		metaData.scriptClass->addInternalCall("Internal_GetElementStates", (void*)&ScriptGUIEnumField::internal_getElementStates);
+		metaData.scriptClass->addInternalCall("Internal_SetElementStates", (void*)&ScriptGUIEnumField::internal_setElementStates);
 
 		onSelectionChangedThunk = (OnSelectionChangedThunkDef)metaData.scriptClass->getMethod("DoOnSelectionChanged", 1)->getThunk();
 	}

Source/SBansheeEditor/Wrappers/GUI/BsScriptGUIEnumField.h

@@ -48,7 +48,7 @@ namespace bs
 		static MonoArray* internal_getElementStates(ScriptGUIEnumField* nativeInstance);
 		static void internal_setElementStates(ScriptGUIEnumField* nativeInstance, MonoArray* states);
 
-		typedef void(__stdcall *OnSelectionChangedThunkDef) (MonoObject*, UINT64, MonoException**);
+		typedef void(BS_THUNKCALL *OnSelectionChangedThunkDef) (MonoObject*, UINT64, MonoException**);
 
 		static OnSelectionChangedThunkDef onSelectionChangedThunk;
 	};

Source/SBansheeEditor/Wrappers/GUI/BsScriptGUIFloatField.cpp

@@ -26,14 +26,14 @@ namespace bs
 
 	void ScriptGUIFloatField::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptGUIFloatField::internal_createInstance);
-		metaData.scriptClass->addInternalCall("Internal_GetValue", &ScriptGUIFloatField::internal_getValue);
-		metaData.scriptClass->addInternalCall("Internal_SetValue", &ScriptGUIFloatField::internal_setValue);
-		metaData.scriptClass->addInternalCall("Internal_HasInputFocus", &ScriptGUIFloatField::internal_hasInputFocus);
-		metaData.scriptClass->addInternalCall("Internal_SetTint", &ScriptGUIFloatField::internal_setTint);
-		metaData.scriptClass->addInternalCall("Internal_SetRange", &ScriptGUIFloatField::internal_setRange);
-		metaData.scriptClass->addInternalCall("Internal_SetStep", &ScriptGUIFloatField::internal_setStep);
-		metaData.scriptClass->addInternalCall("Internal_GetStep", &ScriptGUIFloatField::internal_getStep);
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", (void*)&ScriptGUIFloatField::internal_createInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetValue", (void*)&ScriptGUIFloatField::internal_getValue);
+		metaData.scriptClass->addInternalCall("Internal_SetValue", (void*)&ScriptGUIFloatField::internal_setValue);
+		metaData.scriptClass->addInternalCall("Internal_HasInputFocus", (void*)&ScriptGUIFloatField::internal_hasInputFocus);
+		metaData.scriptClass->addInternalCall("Internal_SetTint", (void*)&ScriptGUIFloatField::internal_setTint);
+		metaData.scriptClass->addInternalCall("Internal_SetRange", (void*)&ScriptGUIFloatField::internal_setRange);
+		metaData.scriptClass->addInternalCall("Internal_SetStep", (void*)&ScriptGUIFloatField::internal_setStep);
+		metaData.scriptClass->addInternalCall("Internal_GetStep", (void*)&ScriptGUIFloatField::internal_getStep);
 
 		onChangedThunk = (OnChangedThunkDef)metaData.scriptClass->getMethod("Internal_DoOnChanged", 1)->getThunk();
 		onConfirmedThunk = (OnConfirmedThunkDef)metaData.scriptClass->getMethod("Internal_DoOnConfirmed", 0)->getThunk();

Source/SBansheeEditor/Wrappers/GUI/BsScriptGUIFloatField.h

@@ -49,8 +49,8 @@ namespace bs
 		static void internal_setStep(ScriptGUIFloatField* nativeInstance, float step);
 		static float internal_getStep(ScriptGUIFloatField* nativeInstance);
 
-		typedef void(__stdcall *OnChangedThunkDef) (MonoObject*, float, MonoException**);
-		typedef void(__stdcall *OnConfirmedThunkDef) (MonoObject*, MonoException**);
+		typedef void(BS_THUNKCALL *OnChangedThunkDef) (MonoObject*, float, MonoException**);
+		typedef void(BS_THUNKCALL *OnConfirmedThunkDef) (MonoObject*, MonoException**);
 
 		static OnChangedThunkDef onChangedThunk;
 		static OnConfirmedThunkDef onConfirmedThunk;