Added C# versions of many editor fields

BansheeEditor/Include/BsEditorPrerequisites.h

@@ -34,6 +34,11 @@ namespace BansheeEngine
 	class GUIIntField;
 	class GUIFloatField;
 	class GUITextField;
+	class GUIToggleField;
+	class GUIVector2Field;
+	class GUIVector3Field;
+	class GUIVector4Field;
+	class GUIColorField;
 	class GUIColor;
 	class GUIFoldout;
 	class GUIDropButton;

BansheeEditor/Include/BsGUIColorField.h

@@ -1,47 +1,23 @@
 #pragma once
 
 #include "BsEditorPrerequisites.h"
-#include "BsGUIElementContainer.h"
+#include "BsGUIFieldBase.h"
 #include "BsColor.h"
 
 namespace BansheeEngine
 {
-	class BS_ED_EXPORT GUIColorField : public GUIElementContainer
+	class BS_ED_EXPORT GUIColorField : public TGUIField<GUIColorField>
 	{
-		struct PrivatelyConstruct {};
-
 	public:
 		static const String& getGUITypeName();
-		static const String& getLabelStyleType();
 		static const String& getColorInputStyleType();
 
-		static GUIColorField* create(const GUIContent& labelContent, 
-			const GUIOptions& layoutOptions, const String& style = StringUtil::BLANK);
-
-		static GUIColorField* create(const HString& labelText, 
-			const GUIOptions& layoutOptions, const String& style = StringUtil::BLANK);
-
-		static GUIColorField* create(const GUIOptions& layoutOptions, const String& style = StringUtil::BLANK);
-
-		static GUIColorField* create(const GUIContent& labelContent, const String& style = StringUtil::BLANK);
-
-		static GUIColorField* create(const HString& labelText, const String& style = StringUtil::BLANK);
-
-		static GUIColorField* create(const String& style = StringUtil::BLANK);
-
-		GUIColorField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, 
-			const String& style, const GUILayoutOptions& layoutOptions);
-
-		GUIColorField(const PrivatelyConstruct& dummy, const String& style, const GUILayoutOptions& layoutOptions);
+		GUIColorField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth,
+			const String& style, const GUILayoutOptions& layoutOptions, bool withLabel);
 
 		Color getValue() const { return mValue; }
 		void setValue(const Color& value);
 
-		void setLabelWidth(UINT32 width);
-
-		void _updateLayoutInternal(INT32 x, INT32 y, UINT32 width, UINT32 height,
-			RectI clipRect, UINT8 widgetDepth, UINT16 areaDepth);
-
 		Vector2I _getOptimalSize() const;
 
 		Event<void(const Color&)> onValueChanged;

BansheeEditor/Source/BsGUIColorField.cpp

@@ -13,150 +13,29 @@ using namespace std::placeholders;
 
 namespace BansheeEngine
 {
-	GUIColorField::GUIColorField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, 
-		const String& style, const GUILayoutOptions& layoutOptions)
-		:GUIElementContainer(layoutOptions, style), mLabel(nullptr), mColor(nullptr), mLabelWidth(100)
+	GUIColorField::GUIColorField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth,
+		const String& style, const GUILayoutOptions& layoutOptions, bool withLabel)
+		:TGUIField(dummy, labelContent, labelWidth, style, layoutOptions, withLabel), 
+		mLabel(nullptr), mColor(nullptr), mLabelWidth(100)
 	{
-		mLabel = GUILabel::create(labelContent, getSubStyleName(getLabelStyleType()));
 		mColor = GUIColor::create(getSubStyleName(getColorInputStyleType()));
-
 		mColor->onValueChanged.connect(std::bind(&GUIColorField::valueChanged, this, _1));
 
-		_registerChildElement(mLabel);
-		_registerChildElement(mColor);
+		mLayout->addElement(mColor);
 	}
 
-	GUIColorField::GUIColorField(const PrivatelyConstruct& dummy, 
-		const String& style, const GUILayoutOptions& layoutOptions)
-		:GUIElementContainer(layoutOptions, style), mLabel(nullptr), mColor(nullptr), mLabelWidth(100)
-	{
-		mColor = GUIColor::create(style);
-
-		_registerChildElement(mColor);
-	}
 
 	GUIColorField::~GUIColorField()
 	{
 
 	}
 
-	GUIColorField* GUIColorField::create(const GUIContent& labelContent, const GUIOptions& layoutOptions, 
-		const String& style)
-	{
-		const String* curStyle = &style;
-		if (*curStyle == StringUtil::BLANK)
-			curStyle = &getGUITypeName();
-
-		return bs_new<GUIColorField>(PrivatelyConstruct(), labelContent, *curStyle,
-			GUILayoutOptions::create(layoutOptions));
-	}
-
-	GUIColorField* GUIColorField::create(const GUIContent& labelContent, const String& style)
-	{
-		const String* curStyle = &style;
-		if (*curStyle == StringUtil::BLANK)
-			curStyle = &getGUITypeName();
-
-		return bs_new<GUIColorField>(PrivatelyConstruct(), labelContent, *curStyle,
-			GUILayoutOptions::create());
-	}
-
-	GUIColorField* GUIColorField::create(const HString& labelContent, const GUIOptions& layoutOptions, 
-		const String& style)
-	{
-		const String* curStyle = &style;
-		if (*curStyle == StringUtil::BLANK)
-			curStyle = &getGUITypeName();
-
-		return bs_new<GUIColorField>(PrivatelyConstruct(), GUIContent(labelContent), *curStyle,
-			GUILayoutOptions::create(layoutOptions));
-	}
-
-	GUIColorField* GUIColorField::create(const HString& labelContent, const String& style)
-	{
-		const String* curStyle = &style;
-		if (*curStyle == StringUtil::BLANK)
-			curStyle = &getGUITypeName();
-
-		return bs_new<GUIColorField>(PrivatelyConstruct(), GUIContent(labelContent), *curStyle,
-			GUILayoutOptions::create());
-	}
-
-	GUIColorField* GUIColorField::create(const GUIOptions& layoutOptions, const String& style)
-	{
-		const String* curStyle = &style;
-		if (*curStyle == StringUtil::BLANK)
-			curStyle = &getGUITypeName();
-
-		return bs_new<GUIColorField>(PrivatelyConstruct(), *curStyle,
-			GUILayoutOptions::create(layoutOptions));
-	}
-
-	GUIColorField* GUIColorField::create(const String& style)
-	{
-		const String* curStyle = &style;
-		if (*curStyle == StringUtil::BLANK)
-			curStyle = &getGUITypeName();
-
-		return bs_new<GUIColorField>(PrivatelyConstruct(), *curStyle, GUILayoutOptions::create());
-	}
-
 	void GUIColorField::setValue(const Color& color)
 	{
 		mValue = color;
 		mColor->setColor(color);
 	}
 
-	void GUIColorField::setLabelWidth(UINT32 width)
-	{
-		mLabelWidth = width;
-
-		markContentAsDirty();
-	}
-
-	void GUIColorField::_updateLayoutInternal(INT32 x, INT32 y, UINT32 width, UINT32 height,
-		RectI clipRect, UINT8 widgetDepth, UINT16 areaDepth)
-	{
-		UINT32 colorOffset = 0;
-		UINT32 colorWidth = width;
-
-		if(mLabel != nullptr)
-		{
-			UINT32 labelWidth = mLabelWidth;
-
-			Vector2I optimalSize = mLabel->_getOptimalSize();
-			INT32 yOffset = Math::roundToInt((height - optimalSize.y) * 0.5f);
-
-			Vector2I offset(x, y + yOffset);
-			mLabel->_setOffset(offset);
-			mLabel->_setWidth(labelWidth);
-			mLabel->_setHeight(optimalSize.y);
-			mLabel->_setAreaDepth(areaDepth);
-			mLabel->_setWidgetDepth(widgetDepth);
-
-			RectI elemClipRect(clipRect.x - offset.x, clipRect.y - offset.y, clipRect.width, clipRect.height);
-			mLabel->_setClipRect(elemClipRect);
-
-			colorOffset = labelWidth;
-			colorWidth = width - labelWidth;
-		}
-
-		{
-			Vector2I optimalSize = mColor->_getOptimalSize();
-			INT32 yOffset = Math::roundToInt((height - optimalSize.y) * 0.5f);
-
-			Vector2I offset(x + colorOffset, y + yOffset);
-			mColor->_setOffset(offset);
-			mColor->_setWidth(colorWidth);
-			mColor->_setHeight(optimalSize.y);
-			mColor->_setAreaDepth(areaDepth);
-			mColor->_setWidgetDepth(widgetDepth);
-
-			RectI elemClipRect(clipRect.x - offset.x, clipRect.y - offset.y, clipRect.width, clipRect.height);
-			mColor->_setClipRect(elemClipRect);
-		}
-	}
-
 	Vector2I GUIColorField::_getOptimalSize() const
 	{
 		Vector2I optimalsize = mColor->_getOptimalSize();
@@ -192,12 +71,6 @@ namespace BansheeEngine
 		return typeName;
 	}
 
-	const String& GUIColorField::getLabelStyleType()
-	{
-		static String STYLE_TYPE = "EditorFieldLabel";
-		return STYLE_TYPE;
-	}
-
 	const String& GUIColorField::getColorInputStyleType()
 	{
 		static String STYLE_TYPE = "EditorFieldColor";

Inspector.txt

@@ -1,6 +1,3 @@
-Update all elements to use new sub-styles
- - Including GUIFoldout and potentially others
- - Override styleUpdated()
 Update C# GUIElementStyle
 
 TODO:
@@ -65,6 +62,8 @@ KEEP IN MIND:
 
 
 
+
+
 
 
 

MBansheeEditor/GUI/GUIColorField.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Runtime.CompilerServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+    public sealed class GUIColorField : GUIElement
+    {
+        public delegate void OnChangedDelegate(Color newValue);
+
+        public event OnChangedDelegate OnChanged;
+
+        public Color Value
+        {
+            get
+            {
+                Color value;
+                Internal_GetValue(mCachedPtr, out value);
+                return value;
+            }
+
+            set { Internal_SetValue(mCachedPtr, value); }
+        }
+
+        public GUIColorField(GUIContent title, int titleWidth = 100, string style = "", params GUIOption[] options)
+        {
+            Internal_CreateInstance(this, title, titleWidth, style, options, true);
+        }
+
+        public GUIColorField(string style = "", params GUIOption[] options)
+        {
+            Internal_CreateInstance(this, null, 0, style, options, false);
+        }
+
+        private void DoOnChanged(Color newValue)
+        {
+            if (OnChanged != null)
+                OnChanged(newValue);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_CreateInstance(GUIColorField instance, GUIContent title, int titleWidth,
+            string style, GUIOption[] options, bool withTitle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_GetValue(IntPtr nativeInstance, out Color value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetValue(IntPtr nativeInstance, Color value);
+    }
+}

MBansheeEditor/GUI/GUIFloatField.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Runtime.CompilerServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+    public sealed class GUIFloatField : GUIElement
+    {
+        public delegate void OnChangedDelegate(float newValue);
+
+        public event OnChangedDelegate OnChanged;
+
+        public float Value
+        {
+            get
+            {
+                float value;
+                Internal_GetValue(mCachedPtr, out value);
+                return value;
+            }
+
+            set { Internal_SetValue(mCachedPtr, value); }
+        }
+
+        public GUIFloatField(GUIContent title, int titleWidth = 100, string style = "", params GUIOption[] options)
+        {
+            Internal_CreateInstance(this, title, titleWidth, style, options, true);
+        }
+
+        public GUIFloatField(string style = "", params GUIOption[] options)
+        {
+            Internal_CreateInstance(this, null, 0, style, options, false);
+        }
+
+        public bool HasInputFocus()
+        {
+            bool value;
+            Internal_HasInputFocus(mCachedPtr, out value);
+            return value;
+        }
+
+        private void DoOnChanged(float newValue)
+        {
+            if (OnChanged != null)
+                OnChanged(newValue);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_CreateInstance(GUIFloatField instance, GUIContent title, int titleWidth,
+            string style, GUIOption[] options, bool withTitle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_GetValue(IntPtr nativeInstance, out float value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetValue(IntPtr nativeInstance, float value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_HasInputFocus(IntPtr nativeInstance, out bool value);
+    }
+}

MBansheeEditor/GUI/GUIIntField.cs

@@ -12,7 +12,13 @@ namespace BansheeEditor
 
         public int Value
         {
-            get { return Internal_GetValue(mCachedPtr); }
+            get
+            {
+                int value; 
+                Internal_GetValue(mCachedPtr, out value);
+                return value;
+            }
+
             set { Internal_SetValue(mCachedPtr, value); }
         }
 
@@ -26,6 +32,13 @@ namespace BansheeEditor
             Internal_CreateInstance(this, null, 0, style, options, false);
         }
 
+        public bool HasInputFocus()
+        {
+            bool value;
+            Internal_HasInputFocus(mCachedPtr, out value);
+            return value;
+        }
+
         private void DoOnChanged(int newValue)
         {
             if (OnChanged != null)
@@ -37,9 +50,12 @@ namespace BansheeEditor
             string style, GUIOption[] options, bool withTitle);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern int Internal_GetValue(IntPtr nativeInstance);
+        private static extern void Internal_GetValue(IntPtr nativeInstance, out int value);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_SetValue(IntPtr nativeInstance, int value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_HasInputFocus(IntPtr nativeInstance, out bool value);
     }
 }

MBansheeEditor/GUI/GUITextField.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Runtime.CompilerServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+    public sealed class GUITextField : GUIElement
+    {
+        public delegate void OnChangedDelegate(String newValue);
+
+        public event OnChangedDelegate OnChanged;
+
+        public String Value
+        {
+            get
+            {
+                String value;
+                Internal_GetValue(mCachedPtr, out value);
+                return value;
+            }
+
+            set { Internal_SetValue(mCachedPtr, value); }
+        }
+
+        public GUITextField(GUIContent title, int titleWidth = 100, string style = "", params GUIOption[] options)
+        {
+            Internal_CreateInstance(this, title, titleWidth, style, options, true);
+        }
+
+        public GUITextField(string style = "", params GUIOption[] options)
+        {
+            Internal_CreateInstance(this, null, 0, style, options, false);
+        }
+
+        public bool HasInputFocus()
+        {
+            bool value;
+            Internal_HasInputFocus(mCachedPtr, out value);
+            return value;
+        }
+
+        private void DoOnChanged(String newValue)
+        {
+            if (OnChanged != null)
+                OnChanged(newValue);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_CreateInstance(GUITextField instance, GUIContent title, int titleWidth,
+            string style, GUIOption[] options, bool withTitle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_GetValue(IntPtr nativeInstance, out String value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetValue(IntPtr nativeInstance, String value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_HasInputFocus(IntPtr nativeInstance, out bool value);
+    }
+}

MBansheeEditor/GUI/GUIToggleField.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Runtime.CompilerServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+    public sealed class GUIToggleField : GUIElement
+    {
+        public delegate void OnChangedDelegate(bool newValue);
+
+        public event OnChangedDelegate OnChanged;
+
+        public bool Value
+        {
+            get
+            {
+                bool value;
+                Internal_GetValue(mCachedPtr, out value);
+                return value;
+            }
+
+            set { Internal_SetValue(mCachedPtr, value); }
+        }
+
+        public GUIToggleField(GUIContent title, int titleWidth = 100, string style = "", params GUIOption[] options)
+        {
+            Internal_CreateInstance(this, title, titleWidth, style, options, true);
+        }
+
+        public GUIToggleField(string style = "", params GUIOption[] options)
+        {
+            Internal_CreateInstance(this, null, 0, style, options, false);
+        }
+
+        private void DoOnChanged(bool newValue)
+        {
+            if (OnChanged != null)
+                OnChanged(newValue);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_CreateInstance(GUIToggleField instance, GUIContent title, int titleWidth,
+            string style, GUIOption[] options, bool withTitle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_GetValue(IntPtr nativeInstance, out bool value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetValue(IntPtr nativeInstance, bool value);
+    }
+}

MBansheeEditor/GUI/GUIVector2Field.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Runtime.CompilerServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+    public sealed class GUIVector2Field : GUIElement
+    {
+        public delegate void OnChangedDelegate(Vector2 newValue);
+
+        public event OnChangedDelegate OnChanged;
+
+        public Vector2 Value
+        {
+            get
+            {
+                Vector2 value;
+                Internal_GetValue(mCachedPtr, out value);
+                return value;
+            }
+
+            set { Internal_SetValue(mCachedPtr, value); }
+        }
+
+        public GUIVector2Field(GUIContent title, int titleWidth = 100, string style = "", params GUIOption[] options)
+        {
+            Internal_CreateInstance(this, title, titleWidth, style, options, true);
+        }
+
+        public GUIVector2Field(string style = "", params GUIOption[] options)
+        {
+            Internal_CreateInstance(this, null, 0, style, options, false);
+        }
+
+        public bool HasInputFocus()
+        {
+            bool value;
+            Internal_HasInputFocus(mCachedPtr, out value);
+            return value;
+        }
+
+        private void DoOnChanged(Vector2 newValue)
+        {
+            if (OnChanged != null)
+                OnChanged(newValue);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_CreateInstance(GUIVector2Field instance, GUIContent title, int titleWidth,
+            string style, GUIOption[] options, bool withTitle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_GetValue(IntPtr nativeInstance, out Vector2 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetValue(IntPtr nativeInstance, Vector2 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_HasInputFocus(IntPtr nativeInstance, out bool value);
+    }
+}

MBansheeEditor/GUI/GUIVector3Field.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Runtime.CompilerServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+    public sealed class GUIVector3Field : GUIElement
+    {
+        public delegate void OnChangedDelegate(Vector3 newValue);
+
+        public event OnChangedDelegate OnChanged;
+
+        public Vector3 Value
+        {
+            get
+            {
+                Vector3 value;
+                Internal_GetValue(mCachedPtr, out value);
+                return value;
+            }
+
+            set { Internal_SetValue(mCachedPtr, value); }
+        }
+
+        public GUIVector3Field(GUIContent title, int titleWidth = 100, string style = "", params GUIOption[] options)
+        {
+            Internal_CreateInstance(this, title, titleWidth, style, options, true);
+        }
+
+        public GUIVector3Field(string style = "", params GUIOption[] options)
+        {
+            Internal_CreateInstance(this, null, 0, style, options, false);
+        }
+
+        public bool HasInputFocus()
+        {
+            bool value;
+            Internal_HasInputFocus(mCachedPtr, out value);
+            return value;
+        }
+
+        private void DoOnChanged(Vector3 newValue)
+        {
+            if (OnChanged != null)
+                OnChanged(newValue);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_CreateInstance(GUIVector3Field instance, GUIContent title, int titleWidth,
+            string style, GUIOption[] options, bool withTitle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_GetValue(IntPtr nativeInstance, out Vector3 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetValue(IntPtr nativeInstance, Vector3 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_HasInputFocus(IntPtr nativeInstance, out bool value);
+    }
+}

MBansheeEditor/GUI/GUIVector4Field.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Runtime.CompilerServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+    public sealed class GUIVector4Field : GUIElement
+    {
+        public delegate void OnChangedDelegate(Vector4 newValue);
+
+        public event OnChangedDelegate OnChanged;
+
+        public Vector4 Value
+        {
+            get
+            {
+                Vector4 value;
+                Internal_GetValue(mCachedPtr, out value);
+                return value;
+            }
+
+            set { Internal_SetValue(mCachedPtr, value); }
+        }
+
+        public GUIVector4Field(GUIContent title, int titleWidth = 100, string style = "", params GUIOption[] options)
+        {
+            Internal_CreateInstance(this, title, titleWidth, style, options, true);
+        }
+
+        public GUIVector4Field(string style = "", params GUIOption[] options)
+        {
+            Internal_CreateInstance(this, null, 0, style, options, false);
+        }
+
+        public bool HasInputFocus()
+        {
+            bool value;
+            Internal_HasInputFocus(mCachedPtr, out value);
+            return value;
+        }
+
+        private void DoOnChanged(Vector4 newValue)
+        {
+            if (OnChanged != null)
+                OnChanged(newValue);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_CreateInstance(GUIVector4Field instance, GUIContent title, int titleWidth,
+            string style, GUIOption[] options, bool withTitle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_GetValue(IntPtr nativeInstance, out Vector4 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetValue(IntPtr nativeInstance, Vector4 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_HasInputFocus(IntPtr nativeInstance, out bool value);
+    }
+}

MBansheeEditor/MBansheeEditor.csproj

@@ -45,9 +45,16 @@
     <Compile Include="Debug_Component2.cs" />
     <Compile Include="EditorApplication.cs" />
     <Compile Include="EditorWindow.cs" />
+    <Compile Include="GUI\GUIVector3Field.cs" />
+    <Compile Include="GUI\GUIColorField.cs" />
+    <Compile Include="GUI\GUIFloatField.cs" />
     <Compile Include="GUI\GUIFoldout.cs" />
     <Compile Include="GUI\GUIIntField.cs" />
     <Compile Include="GUI\GUIPanelContainer.cs" />
+    <Compile Include="GUI\GUITextField.cs" />
+    <Compile Include="GUI\GUIToggleField.cs" />
+    <Compile Include="GUI\GUIVector2Field.cs" />
+    <Compile Include="GUI\GUIVector4Field.cs" />
     <Compile Include="Inspector\CustomInspector.cs" />
     <Compile Include="Inspector\GenericInspector.cs" />
     <Compile Include="Inspector\InspectableArray.cs" />

SBansheeEditor/Include/BsScriptGUIColorField.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptGUIElement.h"
+#include "BsColor.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BED_EXPORT ScriptGUIColorField : public TScriptGUIElement<ScriptGUIColorField>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "GUIColorField")
+
+	private:
+		static void internal_createInstance(MonoObject* instance, MonoObject* title, UINT32 titleWidth,
+			MonoString* style, MonoArray* guiOptions, bool withTitle);
+
+		static void internal_getValue(ScriptGUIColorField* nativeInstance, Color* output);
+		static void internal_setValue(ScriptGUIColorField* nativeInstance, Color value);
+
+		static void onChanged(MonoObject* instance, Color newValue);
+
+		ScriptGUIColorField(MonoObject* instance, GUIColorField* colorField);
+
+		typedef void(__stdcall *OnChangedThunkDef) (MonoObject*, Color, MonoException**);
+
+		static OnChangedThunkDef onChangedThunk;
+	};
+}

SBansheeEditor/Include/BsScriptGUIFloatField.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptGUIElement.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BED_EXPORT ScriptGUIFloatField : public TScriptGUIElement<ScriptGUIFloatField>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "GUIFloatField")
+
+	private:
+		static void internal_createInstance(MonoObject* instance, MonoObject* title, UINT32 titleWidth,
+			MonoString* style, MonoArray* guiOptions, bool withTitle);
+
+		static void internal_getValue(ScriptGUIFloatField* nativeInstance, float* output);
+		static void internal_setValue(ScriptGUIFloatField* nativeInstance, float value);
+		static void internal_hasInputFocus(ScriptGUIFloatField* nativeInstance, bool* output);
+
+		static void onChanged(MonoObject* instance, float newValue);
+
+		ScriptGUIFloatField(MonoObject* instance, GUIFloatField* floatField);
+
+		typedef void(__stdcall *OnChangedThunkDef) (MonoObject*, float, MonoException**);
+
+		static OnChangedThunkDef onChangedThunk;
+	};
+}

SBansheeEditor/Include/BsScriptGUIIntField.h

@@ -14,8 +14,9 @@ namespace BansheeEngine
 		static void internal_createInstance(MonoObject* instance, MonoObject* title, UINT32 titleWidth, 
 			MonoString* style, MonoArray* guiOptions, bool withTitle);
 
-		static INT32 internal_getValue(ScriptGUIIntField* nativeInstance);
+		static void internal_getValue(ScriptGUIIntField* nativeInstance, INT32* output);
 		static void internal_setValue(ScriptGUIIntField* nativeInstance, INT32 value);
+		static void internal_hasInputFocus(ScriptGUIIntField* nativeInstance, bool* output);
 
 		static void onChanged(MonoObject* instance, INT32 newValue);
 

SBansheeEditor/Include/BsScriptGUITextField.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptGUIElement.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BED_EXPORT ScriptGUITextField : public TScriptGUIElement<ScriptGUITextField>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "GUITextField")
+
+	private:
+		static void internal_createInstance(MonoObject* instance, MonoObject* title, UINT32 titleWidth,
+			MonoString* style, MonoArray* guiOptions, bool withTitle);
+
+		static void internal_getValue(ScriptGUITextField* nativeInstance, MonoString** output);
+		static void internal_setValue(ScriptGUITextField* nativeInstance, MonoString* value);
+		static void internal_hasInputFocus(ScriptGUITextField* nativeInstance, bool* output);
+
+		static void onChanged(MonoObject* instance, const WString& newValue);
+
+		ScriptGUITextField(MonoObject* instance, GUITextField* textField);
+
+		typedef void(__stdcall *OnChangedThunkDef) (MonoObject*, MonoString*, MonoException**);
+
+		static OnChangedThunkDef onChangedThunk;
+	};
+}

SBansheeEditor/Include/BsScriptGUIToggleField.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptGUIElement.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BED_EXPORT ScriptGUIToggleField : public TScriptGUIElement<ScriptGUIToggleField>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "GUIToggleField")
+
+	private:
+		static void internal_createInstance(MonoObject* instance, MonoObject* title, UINT32 titleWidth,
+			MonoString* style, MonoArray* guiOptions, bool withTitle);
+
+		static void internal_getValue(ScriptGUIToggleField* nativeInstance, bool* output);
+		static void internal_setValue(ScriptGUIToggleField* nativeInstance, bool value);
+
+		static void onChanged(MonoObject* instance, bool newValue);
+
+		ScriptGUIToggleField(MonoObject* instance, GUIToggleField* toggleField);
+
+		typedef void(__stdcall *OnChangedThunkDef) (MonoObject*, bool, MonoException**);
+
+		static OnChangedThunkDef onChangedThunk;
+	};
+}

SBansheeEditor/Include/BsScriptGUIVector2Field.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptGUIElement.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BED_EXPORT ScriptGUIVector2Field : public TScriptGUIElement<ScriptGUIVector2Field>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "GUIVector2Field")
+
+	private:
+		static void internal_createInstance(MonoObject* instance, MonoObject* title, UINT32 titleWidth,
+			MonoString* style, MonoArray* guiOptions, bool withTitle);
+
+		static void internal_getValue(ScriptGUIVector2Field* nativeInstance, Vector2* output);
+		static void internal_setValue(ScriptGUIVector2Field* nativeInstance, Vector2 value);
+		static void internal_hasInputFocus(ScriptGUIVector2Field* nativeInstance, bool* output);
+
+		static void onChanged(MonoObject* instance, Vector2 newValue);
+
+		ScriptGUIVector2Field(MonoObject* instance, GUIVector2Field* vector2Field);
+
+		typedef void(__stdcall *OnChangedThunkDef) (MonoObject*, Vector2, MonoException**);
+
+		static OnChangedThunkDef onChangedThunk;
+	};
+}

SBansheeEditor/Include/BsScriptGUIVector3Field.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptGUIElement.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BED_EXPORT ScriptGUIVector3Field : public TScriptGUIElement<ScriptGUIVector3Field>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "GUIVector3Field")
+
+	private:
+		static void internal_createInstance(MonoObject* instance, MonoObject* title, UINT32 titleWidth,
+			MonoString* style, MonoArray* guiOptions, bool withTitle);
+
+		static void internal_getValue(ScriptGUIVector3Field* nativeInstance, Vector3* output);
+		static void internal_setValue(ScriptGUIVector3Field* nativeInstance, Vector3 value);
+		static void internal_hasInputFocus(ScriptGUIVector3Field* nativeInstance, bool* output);
+
+		static void onChanged(MonoObject* instance, Vector3 newValue);
+
+		ScriptGUIVector3Field(MonoObject* instance, GUIVector3Field* vector3Field);
+
+		typedef void(__stdcall *OnChangedThunkDef) (MonoObject*, Vector3, MonoException**);
+
+		static OnChangedThunkDef onChangedThunk;
+	};
+}

SBansheeEditor/Include/BsScriptGUIVector4Field.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptGUIElement.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BED_EXPORT ScriptGUIVector4Field : public TScriptGUIElement<ScriptGUIVector4Field>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "GUIVector4Field")
+
+	private:
+		static void internal_createInstance(MonoObject* instance, MonoObject* title, UINT32 titleWidth,
+			MonoString* style, MonoArray* guiOptions, bool withTitle);
+
+		static void internal_getValue(ScriptGUIVector4Field* nativeInstance, Vector4* output);
+		static void internal_setValue(ScriptGUIVector4Field* nativeInstance, Vector4 value);
+		static void internal_hasInputFocus(ScriptGUIVector4Field* nativeInstance, bool* output);
+
+		static void onChanged(MonoObject* instance, Vector4 newValue);
+
+		ScriptGUIVector4Field(MonoObject* instance, GUIVector4Field* vector4Field);
+
+		typedef void(__stdcall *OnChangedThunkDef) (MonoObject*, Vector4, MonoException**);
+
+		static OnChangedThunkDef onChangedThunk;
+	};
+}

SBansheeEditor/SBansheeEditor.vcxproj

@@ -229,17 +229,31 @@
     <ClInclude Include="Include\BsGUIPanelContainer.h" />
     <ClInclude Include="Include\BsScriptEditorPrerequisites.h" />
     <ClInclude Include="Include\BsScriptEditorWindow.h" />
+    <ClInclude Include="Include\BsScriptGUIColorField.h" />
+    <ClInclude Include="Include\BsScriptGUIFloatField.h" />
     <ClInclude Include="Include\BsScriptGUIFoldout.h" />
     <ClInclude Include="Include\BsScriptGUIIntField.h" />
     <ClInclude Include="Include\BsScriptGUIPanelContainer.h" />
+    <ClInclude Include="Include\BsScriptGUITextField.h" />
+    <ClInclude Include="Include\BsScriptGUIToggleField.h" />
+    <ClInclude Include="Include\BsScriptGUIVector2Field.h" />
+    <ClInclude Include="Include\BsScriptGUIVector3Field.h" />
+    <ClInclude Include="Include\BsScriptGUIVector4Field.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\BsGUIPanelContainer.cpp" />
     <ClCompile Include="Source\BsScriptEditorPlugin.cpp" />
     <ClCompile Include="Source\BsScriptEditorWindow.cpp" />
+    <ClCompile Include="Source\BsScriptGUIColorField.cpp" />
+    <ClCompile Include="Source\BsScriptGUIFloatField.cpp" />
     <ClCompile Include="Source\BsScriptGUIFoldout.cpp" />
     <ClCompile Include="Source\BsScriptGUIIntField.cpp" />
     <ClCompile Include="Source\BsScriptGUIPanelContainer.cpp" />
+    <ClCompile Include="Source\BsScriptGUITextField.cpp" />
+    <ClCompile Include="Source\BsScriptGUIToggleField.cpp" />
+    <ClCompile Include="Source\BsScriptGUIVector2Field.cpp" />
+    <ClCompile Include="Source\BsScriptGUIVector3Field.cpp" />
+    <ClCompile Include="Source\BsScriptGUIVector4Field.cpp" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

SBansheeEditor/SBansheeEditor.vcxproj.filters

@@ -33,6 +33,27 @@
     <ClInclude Include="Include\BsScriptGUIPanelContainer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\BsScriptGUIFloatField.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsScriptGUITextField.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsScriptGUIToggleField.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsScriptGUIColorField.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsScriptGUIVector2Field.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsScriptGUIVector3Field.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsScriptGUIVector4Field.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\BsScriptEditorPlugin.cpp">
@@ -53,5 +74,26 @@
     <ClCompile Include="Source\BsScriptGUIPanelContainer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Source\BsScriptGUIFloatField.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsScriptGUITextField.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsScriptGUIToggleField.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsScriptGUIColorField.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsScriptGUIVector2Field.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsScriptGUIVector3Field.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsScriptGUIVector4Field.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

SBansheeEditor/Source/BsScriptGUIColorField.cpp

@@ -0,0 +1,88 @@
+#include "BsScriptGUIColorField.h"
+#include "BsScriptMeta.h"
+#include "BsMonoField.h"
+#include "BsMonoClass.h"
+#include "BsMonoManager.h"
+#include "BsMonoMethod.h"
+#include "BsSpriteTexture.h"
+#include "BsMonoUtil.h"
+#include "BsGUILayout.h"
+#include "BsGUIColorField.h"
+#include "BsGUIOptions.h"
+#include "BsGUIContent.h"
+#include "BsScriptGUIElementStyle.h"
+#include "BsScriptGUILayout.h"
+#include "BsScriptGUIArea.h"
+#include "BsScriptHString.h"
+#include "BsScriptGUIContent.h"
+
+using namespace std::placeholders;
+
+namespace BansheeEngine
+{
+	ScriptGUIColorField::OnChangedThunkDef ScriptGUIColorField::onChangedThunk;
+
+	ScriptGUIColorField::ScriptGUIColorField(MonoObject* instance, GUIColorField* colorField)
+		:TScriptGUIElement(instance, colorField)
+	{
+
+	}
+
+	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);
+
+		onChangedThunk = (OnChangedThunkDef)metaData.scriptClass->getMethod("DoOnChanged", 1).getThunk();
+	}
+
+	void ScriptGUIColorField::internal_createInstance(MonoObject* instance, MonoObject* title, UINT32 titleWidth,
+		MonoString* style, MonoArray* guiOptions, bool withTitle)
+	{
+		GUIOptions options;
+
+		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		for (UINT32 i = 0; i < arrayLen; i++)
+			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+
+		String styleName = toString(MonoUtil::monoToWString(style));
+
+		GUIColorField* guiField = nullptr;
+		if (withTitle)
+		{
+			GUIContent nativeContent(ScriptGUIContent::getText(title), ScriptGUIContent::getImage(title), ScriptGUIContent::getTooltip(title));
+			guiField = GUIColorField::create(nativeContent, titleWidth, options, styleName);
+		}
+		else
+		{
+			guiField = GUIColorField::create(options, styleName);
+		}
+
+		guiField->onValueChanged.connect(std::bind(&ScriptGUIColorField::onChanged, instance, _1));
+
+		ScriptGUIColorField* nativeInstance = new (bs_alloc<ScriptGUIColorField>()) ScriptGUIColorField(instance, guiField);
+	}
+
+	void ScriptGUIColorField::internal_getValue(ScriptGUIColorField* nativeInstance, Color* output)
+	{
+		GUIColorField* colorField = static_cast<GUIColorField*>(nativeInstance->getGUIElement());
+
+		*output = colorField->getValue();
+	}
+
+	void ScriptGUIColorField::internal_setValue(ScriptGUIColorField* nativeInstance, Color value)
+	{
+		GUIColorField* colorField = static_cast<GUIColorField*>(nativeInstance->getGUIElement());
+
+		return colorField->setValue(value);
+	}
+
+	void ScriptGUIColorField::onChanged(MonoObject* instance, Color newValue)
+	{
+		MonoException* exception = nullptr;
+		onChangedThunk(instance, newValue, &exception);
+
+		MonoUtil::throwIfException(exception);
+	}
+}

SBansheeEditor/Source/BsScriptGUIFloatField.cpp

@@ -0,0 +1,96 @@
+#include "BsScriptGUIFloatField.h"
+#include "BsScriptMeta.h"
+#include "BsMonoField.h"
+#include "BsMonoClass.h"
+#include "BsMonoManager.h"
+#include "BsMonoMethod.h"
+#include "BsSpriteTexture.h"
+#include "BsMonoUtil.h"
+#include "BsGUILayout.h"
+#include "BsGUIFloatField.h"
+#include "BsGUIOptions.h"
+#include "BsGUIContent.h"
+#include "BsScriptGUIElementStyle.h"
+#include "BsScriptGUILayout.h"
+#include "BsScriptGUIArea.h"
+#include "BsScriptHString.h"
+#include "BsScriptGUIContent.h"
+
+using namespace std::placeholders;
+
+namespace BansheeEngine
+{
+	ScriptGUIFloatField::OnChangedThunkDef ScriptGUIFloatField::onChangedThunk;
+
+	ScriptGUIFloatField::ScriptGUIFloatField(MonoObject* instance, GUIFloatField* floatField)
+		:TScriptGUIElement(instance, floatField)
+	{
+
+	}
+
+	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);
+
+		onChangedThunk = (OnChangedThunkDef)metaData.scriptClass->getMethod("DoOnChanged", 1).getThunk();
+	}
+
+	void ScriptGUIFloatField::internal_createInstance(MonoObject* instance, MonoObject* title, UINT32 titleWidth,
+		MonoString* style, MonoArray* guiOptions, bool withTitle)
+	{
+		GUIOptions options;
+
+		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		for (UINT32 i = 0; i < arrayLen; i++)
+			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+
+		String styleName = toString(MonoUtil::monoToWString(style));
+
+		GUIFloatField* guiFloatField = nullptr;
+		if (withTitle)
+		{
+			GUIContent nativeContent(ScriptGUIContent::getText(title), ScriptGUIContent::getImage(title), ScriptGUIContent::getTooltip(title));
+			guiFloatField = GUIFloatField::create(nativeContent, titleWidth, options, styleName);
+		}
+		else
+		{
+			guiFloatField = GUIFloatField::create(options, styleName);
+		}
+
+		guiFloatField->onValueChanged.connect(std::bind(&ScriptGUIFloatField::onChanged, instance, _1));
+
+		ScriptGUIFloatField* nativeInstance = new (bs_alloc<ScriptGUIFloatField>()) ScriptGUIFloatField(instance, guiFloatField);
+	}
+
+	void ScriptGUIFloatField::internal_getValue(ScriptGUIFloatField* nativeInstance, float* output)
+	{
+		GUIFloatField* floatField = static_cast<GUIFloatField*>(nativeInstance->getGUIElement());
+
+		*output = floatField->getValue();
+	}
+
+	void ScriptGUIFloatField::internal_setValue(ScriptGUIFloatField* nativeInstance, float value)
+	{
+		GUIFloatField* floatField = static_cast<GUIFloatField*>(nativeInstance->getGUIElement());
+
+		return floatField->setValue(value);
+	}
+
+	void ScriptGUIFloatField::internal_hasInputFocus(ScriptGUIFloatField* nativeInstance, bool* output)
+	{
+		GUIFloatField* floatField = static_cast<GUIFloatField*>(nativeInstance->getGUIElement());
+
+		*output = floatField->hasInputFocus();
+	}
+
+	void ScriptGUIFloatField::onChanged(MonoObject* instance, float newValue)
+	{
+		MonoException* exception = nullptr;
+		onChangedThunk(instance, newValue, &exception);
+
+		MonoUtil::throwIfException(exception);
+	}
+}

SBansheeEditor/Source/BsScriptGUIIntField.cpp

@@ -33,6 +33,7 @@ namespace BansheeEngine
 		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptGUIIntField::internal_createInstance);
 		metaData.scriptClass->addInternalCall("Internal_GetValue", &ScriptGUIIntField::internal_getValue);
 		metaData.scriptClass->addInternalCall("Internal_SetValue", &ScriptGUIIntField::internal_setValue);
+		metaData.scriptClass->addInternalCall("Internal_HasInputFocus", &ScriptGUIIntField::internal_hasInputFocus);
 
 		onChangedThunk = (OnChangedThunkDef)metaData.scriptClass->getMethod("DoOnChanged", 1).getThunk();
 	}
@@ -64,11 +65,11 @@ namespace BansheeEngine
 		ScriptGUIIntField* nativeInstance = new (bs_alloc<ScriptGUIIntField>()) ScriptGUIIntField(instance, guiIntField);
 	}
 
-	INT32 ScriptGUIIntField::internal_getValue(ScriptGUIIntField* nativeInstance)
+	void ScriptGUIIntField::internal_getValue(ScriptGUIIntField* nativeInstance, INT32* output)
 	{
 		GUIIntField* intField = static_cast<GUIIntField*>(nativeInstance->getGUIElement());
 
-		return intField->getValue();
+		*output = intField->getValue();
 	}
 
 	void ScriptGUIIntField::internal_setValue(ScriptGUIIntField* nativeInstance, INT32 value)
@@ -78,6 +79,13 @@ namespace BansheeEngine
 		return intField->setValue(value);
 	}
 
+	void ScriptGUIIntField::internal_hasInputFocus(ScriptGUIIntField* nativeInstance, bool* output)
+	{
+		GUIIntField* intField = static_cast<GUIIntField*>(nativeInstance->getGUIElement());
+
+		*output = intField->hasInputFocus();
+	}
+
 	void ScriptGUIIntField::onChanged(MonoObject* instance, INT32 newValue)
 	{
 		MonoException* exception = nullptr;

SBansheeEditor/Source/BsScriptGUITextField.cpp

@@ -0,0 +1,98 @@
+#include "BsScriptGUITextField.h"
+#include "BsScriptMeta.h"
+#include "BsMonoField.h"
+#include "BsMonoClass.h"
+#include "BsMonoManager.h"
+#include "BsMonoMethod.h"
+#include "BsSpriteTexture.h"
+#include "BsMonoUtil.h"
+#include "BsGUILayout.h"
+#include "BsGUITextField.h"
+#include "BsGUIOptions.h"
+#include "BsGUIContent.h"
+#include "BsScriptGUIElementStyle.h"
+#include "BsScriptGUILayout.h"
+#include "BsScriptGUIArea.h"
+#include "BsScriptHString.h"
+#include "BsScriptGUIContent.h"
+
+using namespace std::placeholders;
+
+namespace BansheeEngine
+{
+	ScriptGUITextField::OnChangedThunkDef ScriptGUITextField::onChangedThunk;
+
+	ScriptGUITextField::ScriptGUITextField(MonoObject* instance, GUITextField* textField)
+		:TScriptGUIElement(instance, textField)
+	{
+
+	}
+
+	void ScriptGUITextField::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptGUITextField::internal_createInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetValue", &ScriptGUITextField::internal_getValue);
+		metaData.scriptClass->addInternalCall("Internal_SetValue", &ScriptGUITextField::internal_setValue);
+		metaData.scriptClass->addInternalCall("Internal_HasInputFocus", &ScriptGUITextField::internal_hasInputFocus);
+
+		onChangedThunk = (OnChangedThunkDef)metaData.scriptClass->getMethod("DoOnChanged", 1).getThunk();
+	}
+
+	void ScriptGUITextField::internal_createInstance(MonoObject* instance, MonoObject* title, UINT32 titleWidth,
+		MonoString* style, MonoArray* guiOptions, bool withTitle)
+	{
+		GUIOptions options;
+
+		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		for (UINT32 i = 0; i < arrayLen; i++)
+			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+
+		String styleName = toString(MonoUtil::monoToWString(style));
+
+		GUITextField* guiField = nullptr;
+		if (withTitle)
+		{
+			GUIContent nativeContent(ScriptGUIContent::getText(title), ScriptGUIContent::getImage(title), ScriptGUIContent::getTooltip(title));
+			guiField = GUITextField::create(nativeContent, titleWidth, options, styleName);
+		}
+		else
+		{
+			guiField = GUITextField::create(options, styleName);
+		}
+
+		guiField->onValueChanged.connect(std::bind(&ScriptGUITextField::onChanged, instance, _1));
+
+		ScriptGUITextField* nativeInstance = new (bs_alloc<ScriptGUITextField>()) ScriptGUITextField(instance, guiField);
+	}
+
+	void ScriptGUITextField::internal_getValue(ScriptGUITextField* nativeInstance, MonoString** output)
+	{
+		GUITextField* field = static_cast<GUITextField*>(nativeInstance->getGUIElement());
+
+		*output = MonoUtil::wstringToMono(MonoManager::instance().getDomain(), field->getValue());
+	}
+
+	void ScriptGUITextField::internal_setValue(ScriptGUITextField* nativeInstance, MonoString* value)
+	{
+		GUITextField* field = static_cast<GUITextField*>(nativeInstance->getGUIElement());
+
+		return field->setValue(MonoUtil::monoToWString(value));
+	}
+
+	void ScriptGUITextField::internal_hasInputFocus(ScriptGUITextField* nativeInstance, bool* output)
+	{
+		GUITextField* field = static_cast<GUITextField*>(nativeInstance->getGUIElement());
+
+		*output = field->hasInputFocus();
+	}
+
+	void ScriptGUITextField::onChanged(MonoObject* instance, const WString& newValue)
+	{
+		MonoException* exception = nullptr;
+		MonoString* monoNewValue = MonoUtil::wstringToMono(MonoManager::instance().getDomain(), newValue);
+
+		onChangedThunk(instance, monoNewValue, &exception);
+
+		MonoUtil::throwIfException(exception);
+	}
+}

SBansheeEditor/Source/BsScriptGUIToggleField.cpp

@@ -0,0 +1,88 @@
+#include "BsScriptGUIToggleField.h"
+#include "BsScriptMeta.h"
+#include "BsMonoField.h"
+#include "BsMonoClass.h"
+#include "BsMonoManager.h"
+#include "BsMonoMethod.h"
+#include "BsSpriteTexture.h"
+#include "BsMonoUtil.h"
+#include "BsGUILayout.h"
+#include "BsGUIToggleField.h"
+#include "BsGUIOptions.h"
+#include "BsGUIContent.h"
+#include "BsScriptGUIElementStyle.h"
+#include "BsScriptGUILayout.h"
+#include "BsScriptGUIArea.h"
+#include "BsScriptHString.h"
+#include "BsScriptGUIContent.h"
+
+using namespace std::placeholders;
+
+namespace BansheeEngine
+{
+	ScriptGUIToggleField::OnChangedThunkDef ScriptGUIToggleField::onChangedThunk;
+
+	ScriptGUIToggleField::ScriptGUIToggleField(MonoObject* instance, GUIToggleField* toggleField)
+		:TScriptGUIElement(instance, toggleField)
+	{
+
+	}
+
+	void ScriptGUIToggleField::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptGUIToggleField::internal_createInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetValue", &ScriptGUIToggleField::internal_getValue);
+		metaData.scriptClass->addInternalCall("Internal_SetValue", &ScriptGUIToggleField::internal_setValue);
+
+		onChangedThunk = (OnChangedThunkDef)metaData.scriptClass->getMethod("DoOnChanged", 1).getThunk();
+	}
+
+	void ScriptGUIToggleField::internal_createInstance(MonoObject* instance, MonoObject* title, UINT32 titleWidth,
+		MonoString* style, MonoArray* guiOptions, bool withTitle)
+	{
+		GUIOptions options;
+
+		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		for (UINT32 i = 0; i < arrayLen; i++)
+			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+
+		String styleName = toString(MonoUtil::monoToWString(style));
+
+		GUIToggleField* guiField = nullptr;
+		if (withTitle)
+		{
+			GUIContent nativeContent(ScriptGUIContent::getText(title), ScriptGUIContent::getImage(title), ScriptGUIContent::getTooltip(title));
+			guiField = GUIToggleField::create(nativeContent, titleWidth, options, styleName);
+		}
+		else
+		{
+			guiField = GUIToggleField::create(options, styleName);
+		}
+
+		guiField->onValueChanged.connect(std::bind(&ScriptGUIToggleField::onChanged, instance, _1));
+
+		ScriptGUIToggleField* nativeInstance = new (bs_alloc<ScriptGUIToggleField>()) ScriptGUIToggleField(instance, guiField);
+	}
+
+	void ScriptGUIToggleField::internal_getValue(ScriptGUIToggleField* nativeInstance, bool* output)
+	{
+		GUIToggleField* toggleField = static_cast<GUIToggleField*>(nativeInstance->getGUIElement());
+
+		*output = toggleField->getValue();
+	}
+
+	void ScriptGUIToggleField::internal_setValue(ScriptGUIToggleField* nativeInstance, bool value)
+	{
+		GUIToggleField* toggleField = static_cast<GUIToggleField*>(nativeInstance->getGUIElement());
+
+		return toggleField->setValue(value);
+	}
+
+	void ScriptGUIToggleField::onChanged(MonoObject* instance, bool newValue)
+	{
+		MonoException* exception = nullptr;
+		onChangedThunk(instance, newValue, &exception);
+
+		MonoUtil::throwIfException(exception);
+	}
+}

SBansheeEditor/Source/BsScriptGUIVector2Field.cpp

@@ -0,0 +1,96 @@
+#include "BsScriptGUIVector2Field.h"
+#include "BsScriptMeta.h"
+#include "BsMonoField.h"
+#include "BsMonoClass.h"
+#include "BsMonoManager.h"
+#include "BsMonoMethod.h"
+#include "BsSpriteTexture.h"
+#include "BsMonoUtil.h"
+#include "BsGUILayout.h"
+#include "BsGUIVector2Field.h"
+#include "BsGUIOptions.h"
+#include "BsGUIContent.h"
+#include "BsScriptGUIElementStyle.h"
+#include "BsScriptGUILayout.h"
+#include "BsScriptGUIArea.h"
+#include "BsScriptHString.h"
+#include "BsScriptGUIContent.h"
+
+using namespace std::placeholders;
+
+namespace BansheeEngine
+{
+	ScriptGUIVector2Field::OnChangedThunkDef ScriptGUIVector2Field::onChangedThunk;
+
+	ScriptGUIVector2Field::ScriptGUIVector2Field(MonoObject* instance, GUIVector2Field* vector2Field)
+		:TScriptGUIElement(instance, vector2Field)
+	{
+
+	}
+
+	void ScriptGUIVector2Field::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptGUIVector2Field::internal_createInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetValue", &ScriptGUIVector2Field::internal_getValue);
+		metaData.scriptClass->addInternalCall("Internal_SetValue", &ScriptGUIVector2Field::internal_setValue);
+		metaData.scriptClass->addInternalCall("Internal_HasInputFocus", &ScriptGUIVector2Field::internal_hasInputFocus);
+
+		onChangedThunk = (OnChangedThunkDef)metaData.scriptClass->getMethod("DoOnChanged", 1).getThunk();
+	}
+
+	void ScriptGUIVector2Field::internal_createInstance(MonoObject* instance, MonoObject* title, UINT32 titleWidth,
+		MonoString* style, MonoArray* guiOptions, bool withTitle)
+	{
+		GUIOptions options;
+
+		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		for (UINT32 i = 0; i < arrayLen; i++)
+			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+
+		String styleName = toString(MonoUtil::monoToWString(style));
+
+		GUIVector2Field* field = nullptr;
+		if (withTitle)
+		{
+			GUIContent nativeContent(ScriptGUIContent::getText(title), ScriptGUIContent::getImage(title), ScriptGUIContent::getTooltip(title));
+			field = GUIVector2Field::create(nativeContent, titleWidth, options, styleName);
+		}
+		else
+		{
+			field = GUIVector2Field::create(options, styleName);
+		}
+
+		field->onValueChanged.connect(std::bind(&ScriptGUIVector2Field::onChanged, instance, _1));
+
+		ScriptGUIVector2Field* nativeInstance = new (bs_alloc<ScriptGUIVector2Field>()) ScriptGUIVector2Field(instance, field);
+	}
+
+	void ScriptGUIVector2Field::internal_getValue(ScriptGUIVector2Field* nativeInstance, Vector2* output)
+	{
+		GUIVector2Field* field = static_cast<GUIVector2Field*>(nativeInstance->getGUIElement());
+
+		*output = field->getValue();
+	}
+
+	void ScriptGUIVector2Field::internal_setValue(ScriptGUIVector2Field* nativeInstance, Vector2 value)
+	{
+		GUIVector2Field* field = static_cast<GUIVector2Field*>(nativeInstance->getGUIElement());
+
+		return field->setValue(value);
+	}
+
+	void ScriptGUIVector2Field::internal_hasInputFocus(ScriptGUIVector2Field* nativeInstance, bool* output)
+	{
+		GUIVector2Field* field = static_cast<GUIVector2Field*>(nativeInstance->getGUIElement());
+
+		*output = field->hasInputFocus();
+	}
+
+	void ScriptGUIVector2Field::onChanged(MonoObject* instance, Vector2 newValue)
+	{
+		MonoException* exception = nullptr;
+		onChangedThunk(instance, newValue, &exception);
+
+		MonoUtil::throwIfException(exception);
+	}
+}

SBansheeEditor/Source/BsScriptGUIVector3Field.cpp

@@ -0,0 +1,96 @@
+#include "BsScriptGUIVector3Field.h"
+#include "BsScriptMeta.h"
+#include "BsMonoField.h"
+#include "BsMonoClass.h"
+#include "BsMonoManager.h"
+#include "BsMonoMethod.h"
+#include "BsSpriteTexture.h"
+#include "BsMonoUtil.h"
+#include "BsGUILayout.h"
+#include "BsGUIVector3Field.h"
+#include "BsGUIOptions.h"
+#include "BsGUIContent.h"
+#include "BsScriptGUIElementStyle.h"
+#include "BsScriptGUILayout.h"
+#include "BsScriptGUIArea.h"
+#include "BsScriptHString.h"
+#include "BsScriptGUIContent.h"
+
+using namespace std::placeholders;
+
+namespace BansheeEngine
+{
+	ScriptGUIVector3Field::OnChangedThunkDef ScriptGUIVector3Field::onChangedThunk;
+
+	ScriptGUIVector3Field::ScriptGUIVector3Field(MonoObject* instance, GUIVector3Field* vector3Field)
+		:TScriptGUIElement(instance, vector3Field)
+	{
+
+	}
+
+	void ScriptGUIVector3Field::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptGUIVector3Field::internal_createInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetValue", &ScriptGUIVector3Field::internal_getValue);
+		metaData.scriptClass->addInternalCall("Internal_SetValue", &ScriptGUIVector3Field::internal_setValue);
+		metaData.scriptClass->addInternalCall("Internal_HasInputFocus", &ScriptGUIVector3Field::internal_hasInputFocus);
+
+		onChangedThunk = (OnChangedThunkDef)metaData.scriptClass->getMethod("DoOnChanged", 1).getThunk();
+	}
+
+	void ScriptGUIVector3Field::internal_createInstance(MonoObject* instance, MonoObject* title, UINT32 titleWidth,
+		MonoString* style, MonoArray* guiOptions, bool withTitle)
+	{
+		GUIOptions options;
+
+		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		for (UINT32 i = 0; i < arrayLen; i++)
+			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+
+		String styleName = toString(MonoUtil::monoToWString(style));
+
+		GUIVector3Field* field = nullptr;
+		if (withTitle)
+		{
+			GUIContent nativeContent(ScriptGUIContent::getText(title), ScriptGUIContent::getImage(title), ScriptGUIContent::getTooltip(title));
+			field = GUIVector3Field::create(nativeContent, titleWidth, options, styleName);
+		}
+		else
+		{
+			field = GUIVector3Field::create(options, styleName);
+		}
+
+		field->onValueChanged.connect(std::bind(&ScriptGUIVector3Field::onChanged, instance, _1));
+
+		ScriptGUIVector3Field* nativeInstance = new (bs_alloc<ScriptGUIVector3Field>()) ScriptGUIVector3Field(instance, field);
+	}
+
+	void ScriptGUIVector3Field::internal_getValue(ScriptGUIVector3Field* nativeInstance, Vector3* output)
+	{
+		GUIVector3Field* field = static_cast<GUIVector3Field*>(nativeInstance->getGUIElement());
+
+		*output = field->getValue();
+	}
+
+	void ScriptGUIVector3Field::internal_setValue(ScriptGUIVector3Field* nativeInstance, Vector3 value)
+	{
+		GUIVector3Field* field = static_cast<GUIVector3Field*>(nativeInstance->getGUIElement());
+
+		return field->setValue(value);
+	}
+
+	void ScriptGUIVector3Field::internal_hasInputFocus(ScriptGUIVector3Field* nativeInstance, bool* output)
+	{
+		GUIVector3Field* field = static_cast<GUIVector3Field*>(nativeInstance->getGUIElement());
+
+		*output = field->hasInputFocus();
+	}
+
+	void ScriptGUIVector3Field::onChanged(MonoObject* instance, Vector3 newValue)
+	{
+		MonoException* exception = nullptr;
+		onChangedThunk(instance, newValue, &exception);
+
+		MonoUtil::throwIfException(exception);
+	}
+}

SBansheeEditor/Source/BsScriptGUIVector4Field.cpp

@@ -0,0 +1,96 @@
+#include "BsScriptGUIVector4Field.h"
+#include "BsScriptMeta.h"
+#include "BsMonoField.h"
+#include "BsMonoClass.h"
+#include "BsMonoManager.h"
+#include "BsMonoMethod.h"
+#include "BsSpriteTexture.h"
+#include "BsMonoUtil.h"
+#include "BsGUILayout.h"
+#include "BsGUIVector4Field.h"
+#include "BsGUIOptions.h"
+#include "BsGUIContent.h"
+#include "BsScriptGUIElementStyle.h"
+#include "BsScriptGUILayout.h"
+#include "BsScriptGUIArea.h"
+#include "BsScriptHString.h"
+#include "BsScriptGUIContent.h"
+
+using namespace std::placeholders;
+
+namespace BansheeEngine
+{
+	ScriptGUIVector4Field::OnChangedThunkDef ScriptGUIVector4Field::onChangedThunk;
+
+	ScriptGUIVector4Field::ScriptGUIVector4Field(MonoObject* instance, GUIVector4Field* vector4Field)
+		:TScriptGUIElement(instance, vector4Field)
+	{
+
+	}
+
+	void ScriptGUIVector4Field::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptGUIVector4Field::internal_createInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetValue", &ScriptGUIVector4Field::internal_getValue);
+		metaData.scriptClass->addInternalCall("Internal_SetValue", &ScriptGUIVector4Field::internal_setValue);
+		metaData.scriptClass->addInternalCall("Internal_HasInputFocus", &ScriptGUIVector4Field::internal_hasInputFocus);
+
+		onChangedThunk = (OnChangedThunkDef)metaData.scriptClass->getMethod("DoOnChanged", 1).getThunk();
+	}
+
+	void ScriptGUIVector4Field::internal_createInstance(MonoObject* instance, MonoObject* title, UINT32 titleWidth,
+		MonoString* style, MonoArray* guiOptions, bool withTitle)
+	{
+		GUIOptions options;
+
+		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		for (UINT32 i = 0; i < arrayLen; i++)
+			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+
+		String styleName = toString(MonoUtil::monoToWString(style));
+
+		GUIVector4Field* field = nullptr;
+		if (withTitle)
+		{
+			GUIContent nativeContent(ScriptGUIContent::getText(title), ScriptGUIContent::getImage(title), ScriptGUIContent::getTooltip(title));
+			field = GUIVector4Field::create(nativeContent, titleWidth, options, styleName);
+		}
+		else
+		{
+			field = GUIVector4Field::create(options, styleName);
+		}
+
+		field->onValueChanged.connect(std::bind(&ScriptGUIVector4Field::onChanged, instance, _1));
+
+		ScriptGUIVector4Field* nativeInstance = new (bs_alloc<ScriptGUIVector4Field>()) ScriptGUIVector4Field(instance, field);
+	}
+
+	void ScriptGUIVector4Field::internal_getValue(ScriptGUIVector4Field* nativeInstance, Vector4* output)
+	{
+		GUIVector4Field* field = static_cast<GUIVector4Field*>(nativeInstance->getGUIElement());
+
+		*output = field->getValue();
+	}
+
+	void ScriptGUIVector4Field::internal_setValue(ScriptGUIVector4Field* nativeInstance, Vector4 value)
+	{
+		GUIVector4Field* field = static_cast<GUIVector4Field*>(nativeInstance->getGUIElement());
+
+		return field->setValue(value);
+	}
+
+	void ScriptGUIVector4Field::internal_hasInputFocus(ScriptGUIVector4Field* nativeInstance, bool* output)
+	{
+		GUIVector4Field* field = static_cast<GUIVector4Field*>(nativeInstance->getGUIElement());
+
+		*output = field->hasInputFocus();
+	}
+
+	void ScriptGUIVector4Field::onChanged(MonoObject* instance, Vector4 newValue)
+	{
+		MonoException* exception = nullptr;
+		onChangedThunk(instance, newValue, &exception);
+
+		MonoUtil::throwIfException(exception);
+	}
+}