Added C# PlainText and ScriptCode

BansheeEngine/Include/BsPlainText.h

@@ -12,10 +12,15 @@ namespace BansheeEngine
 	{
 	public:
 		/**
-		 * @brief	Text contained in the file.
+		 * @brief	Returns the text contained in the resource.
 		 */
 		const WString& getString() const { return mString; }
 
+		/**
+		 * @brief	Modifies the text contained in the resource.
+		 */
+		void setString(const WString& data) { mString = data; }
+
 		/**
 		 * @brief	Creates a new text file resource with the specified string.
 		 */

BansheeEngine/Include/BsPrerequisites.h

@@ -91,6 +91,7 @@ namespace BansheeEngine
 	class RenderableHandlerCore;
 	class PlainText;
 	class ScriptCode;
+	class ScriptCodeImportOptions;
 
 	// 2D
 	class TextSprite;

BansheeEngine/Include/BsScriptCode.h

@@ -16,6 +16,11 @@ namespace BansheeEngine
 		 */
 		const WString& getString() const { return mString; }
 
+		/**
+		 * @brief	Modifies the source code contained in the resource.
+		 */
+		void setString(const WString& data) { mString = data; }
+
 		/**
 		 * @brief	Creates a new script code resource with the specified source code.
 		 */

MBansheeEditor/ImportOptions.cs

@@ -173,4 +173,27 @@ namespace BansheeEditor
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_SetCharRanges(IntPtr thisPtr, CharRange[] value);
     }
+
+    public class ScriptCodeImportOptions : ImportOptions
+    {
+        public ScriptCodeImportOptions()
+        {
+            Internal_CreateInstance(this);
+        }
+
+        public bool EditorScript
+        {
+            get { return Internal_IsEditorScript(mCachedPtr); }
+            set { Internal_SetEditorScript(mCachedPtr, value); }
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_CreateInstance(ScriptCodeImportOptions instance);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool Internal_IsEditorScript(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetEditorScript(IntPtr thisPtr, bool value);
+    }
 }

MBansheeEngine/MBansheeEngine.csproj

@@ -101,6 +101,7 @@
     <Compile Include="MissingComponent.cs" />
     <Compile Include="PixelData.cs" />
     <Compile Include="PixelUtility.cs" />
+    <Compile Include="PlainText.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Math\Quaternion.cs" />
@@ -109,6 +110,7 @@
     <Compile Include="RenderTexture2D.cs" />
     <Compile Include="Resource.cs" />
     <Compile Include="SceneObject.cs" />
+    <Compile Include="ScriptCode.cs" />
     <Compile Include="ScriptObject.cs" />
     <Compile Include="SerializableArray.cs" />
     <Compile Include="SerializableDictionary.cs" />

MBansheeEngine/PlainText.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace BansheeEngine
+{
+    public class PlainText : Resource
+    {
+        // For internal use by the runtime
+        private PlainText()
+        { }
+
+        public PlainText(string text)
+        {
+            Internal_CreateInstance(this, text);
+        }
+
+        public string Text
+        {
+            get { return Internal_GetText(mCachedPtr); }
+            set { Internal_SetText(mCachedPtr, value); }
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_CreateInstance(PlainText instance, string text);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern string Internal_GetText(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetText(IntPtr thisPtr, string value);
+    }
+}

MBansheeEngine/ScriptCode.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace BansheeEngine
+{
+    public class ScriptCode : Resource
+    {
+        public string Text
+        {
+            get { return Internal_GetText(mCachedPtr); }
+            set { Internal_SetText(mCachedPtr, value); }
+        }
+
+        public bool EditorScript
+        {
+            get { return Internal_IsEditorScript(mCachedPtr); }
+            set { Internal_SetEditorScript(mCachedPtr, value); }
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern string Internal_GetText(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetText(IntPtr thisPtr, string value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool Internal_IsEditorScript(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetEditorScript(IntPtr thisPtr, bool value);
+    }
+}

SBansheeEditor/Include/BsScriptImportOptions.h

@@ -104,4 +104,22 @@ namespace BansheeEngine
 
 		ScriptGpuProgramImportOptions(MonoObject* instance);
 	};
+
+	class BS_SCR_BED_EXPORT ScriptScriptCodeImportOptions : public ScriptObject <ScriptScriptCodeImportOptions, ScriptImportOptionsBase>
+	{
+	public:
+		SCRIPT_OBJ(EDITOR_ASSEMBLY, "BansheeEditor", "ScriptCodeImportOptions")
+
+		static MonoObject* create();
+		static MonoObject* create(const SPtr<ScriptCodeImportOptions>& options);
+
+	private:
+		SPtr<ScriptCodeImportOptions> getCodeImportOptions();
+
+		static void internal_CreateInstance(MonoObject* instance);
+		static bool internal_IsEditorScript(ScriptScriptCodeImportOptions* thisPtr);
+		static void internal_SetEditorScript(ScriptScriptCodeImportOptions* thisPtr, bool value);
+
+		ScriptScriptCodeImportOptions(MonoObject* instance);
+	};
 }

SBansheeEditor/Source/BsScriptImportOptions.cpp

@@ -8,6 +8,7 @@
 #include "BsTextureImportOptions.h"
 #include "BsFontImportOptions.h"
 #include "BsGpuProgramImportOptions.h"
+#include "BsScriptCodeImportOptions.h"
 #include "BsRenderer.h"
 #include "BsScriptFont.h"
 #include "BsRTTIType.h"
@@ -310,4 +311,51 @@ namespace BansheeEngine
 	{
 		thisPtr->getGpuProgImportOptions()->setType(value);
 	}
+
+	ScriptScriptCodeImportOptions::ScriptScriptCodeImportOptions(MonoObject* instance)
+		:ScriptObject(instance)
+	{
+		mImportOptions = bs_shared_ptr<ScriptCodeImportOptions>();
+	}
+
+	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);
+	}
+
+	SPtr<ScriptCodeImportOptions> ScriptScriptCodeImportOptions::getCodeImportOptions()
+	{
+		return std::static_pointer_cast<ScriptCodeImportOptions>(mImportOptions);
+	}
+
+	MonoObject* ScriptScriptCodeImportOptions::create()
+	{
+		return metaData.scriptClass->createInstance();
+	}
+
+	MonoObject* ScriptScriptCodeImportOptions::create(const SPtr<ScriptCodeImportOptions>& options)
+	{
+		MonoObject* managedInstance = metaData.scriptClass->createInstance();
+		ScriptScriptCodeImportOptions* scriptObj = ScriptScriptCodeImportOptions::toNative(managedInstance);
+		scriptObj->mImportOptions = options;
+
+		return managedInstance;
+	}
+
+	void ScriptScriptCodeImportOptions::internal_CreateInstance(MonoObject* instance)
+	{
+		ScriptScriptCodeImportOptions* nativeInstance = new (bs_alloc<ScriptScriptCodeImportOptions>()) ScriptScriptCodeImportOptions(instance);
+	}
+
+	bool ScriptScriptCodeImportOptions::internal_IsEditorScript(ScriptScriptCodeImportOptions* thisPtr)
+	{
+		return thisPtr->getCodeImportOptions()->isEditorScript();
+	}
+
+	void ScriptScriptCodeImportOptions::internal_SetEditorScript(ScriptScriptCodeImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getCodeImportOptions()->setEditorScript(value);
+	}
 }

SBansheeEngine/Include/BsManagedSerializableObjectInfo.h

@@ -24,6 +24,8 @@ namespace BansheeEngine
 		TextureRef,
 		SpriteTextureRef,
 		ManagedResourceRef,
+		PlainTextRef,
+		ScriptCodeRef,
 		SceneObjectRef,
 		ComponentRef
 	};

SBansheeEngine/Include/BsScriptAssemblyManager.h

@@ -30,6 +30,8 @@ namespace BansheeEngine
 		MonoClass* getTextureClass() const { return mTextureClass; }
 		MonoClass* getSpriteTextureClass() const { return mSpriteTextureClass; }
 		MonoClass* getFontClass() const { return mFontClass; }
+		MonoClass* getPlainTextClass() const { return mPlainTextClass; }
+		MonoClass* getScriptCodeClass() const { return mScriptCodeClass; }
 
 		ManagedSerializableTypeInfoPtr determineType(MonoClass* monoClass);
 	private:
@@ -48,6 +50,8 @@ namespace BansheeEngine
 		MonoClass* mSpriteTextureClass;
 		MonoClass* mManagedResourceClass;
 		MonoClass* mFontClass;
+		MonoClass* mPlainTextClass;
+		MonoClass* mScriptCodeClass;
 
 		MonoClass* mSerializeObjectAttribute;
 		MonoClass* mDontSerializeFieldAttribute;

SBansheeEngine/Include/BsScriptEnginePrerequisites.h

@@ -28,6 +28,8 @@ namespace BansheeEngine
 	class ScriptTexture2D;
 	class ScriptTexture3D;
 	class ScriptTextureCube;
+	class ScriptPlainText;
+	class ScriptScriptCode;
 	class ScriptGUIElementStyle;
 	class ScriptGUIElementStateStyle;
 	class ScriptGUIPanel;

SBansheeEngine/Include/BsScriptPlainText.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptResource.h"
+#include "BsScriptObject.h"
+#include "BsPlainText.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ScriptPlainText : public ScriptObject <ScriptPlainText, ScriptResourceBase>
+	{
+	public:
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "PlainText")
+
+		void* getNativeRaw() const { return mPlainText.get(); }
+
+		HResource getNativeHandle() const { return mPlainText; }
+		void setNativeHandle(const HResource& resource);
+
+		HPlainText getPlainTextHandle() const { return mPlainText; }
+	private:
+		friend class ScriptResourceManager;
+
+		static void internal_createInstance(MonoObject* instance, MonoString* text);
+		static MonoString* internal_getText(ScriptPlainText* thisPtr);
+		static void internal_setText(ScriptPlainText* thisPtr, MonoString* text);
+
+		ScriptPlainText(MonoObject* instance, const HPlainText& plainText);
+
+		void _onManagedInstanceDeleted();
+
+		HPlainText mPlainText;
+	};
+}

SBansheeEngine/Include/BsScriptResourceManager.h

@@ -47,6 +47,30 @@ namespace BansheeEngine
 		 */
 		ScriptTextureCube* createScriptTextureCube(MonoObject* existingInstance, const HTexture& resourceHandle);
 
+		/**
+		 * @note Throws an exception if resource for the handle already exists.
+		 * 		 Initializes the ScriptResource with an existing managed instance.
+		 */
+		ScriptPlainText* createScriptPlainText(const HPlainText& resourceHandle);
+
+		/**
+		 * @note Throws an exception if resource for the handle already exists.
+		 * 		 Initializes the ScriptResource with an existing managed instance.
+		 */
+		ScriptPlainText* createScriptPlainText(MonoObject* existingInstance, const HPlainText& resourceHandle);
+
+		/**
+		 * @note Throws an exception if resource for the handle already exists.
+		 * 		 Initializes the ScriptResource with an existing managed instance.
+		 */
+		ScriptScriptCode* createScriptScriptCode(const HScriptCode& resourceHandle);
+
+		/**
+		 * @note Throws an exception if resource for the handle already exists.
+		 * 		 Initializes the ScriptResource with an existing managed instance.
+		 */
+		ScriptScriptCode* createScriptScriptCode(MonoObject* existingInstance, const HScriptCode& resourceHandle);
+
 		/**
 		 * @note Throws an exception if resource for the handle already exists.
 		 * 		 Creates a new managed instance of the object.
@@ -87,6 +111,16 @@ namespace BansheeEngine
 		 */
 		ScriptSpriteTexture* getScriptSpriteTexture(const HSpriteTexture& resourceHandle);
 
+		/**
+		 * @note Returns nullptr if script resource doesn't exist.
+		 */
+		ScriptPlainText* getScriptPlainText(const HPlainText& resourceHandle);
+
+		/**
+		 * @note Returns nullptr if script resource doesn't exist.
+		 */
+		ScriptScriptCode* getScriptScriptCode(const HScriptCode& resourceHandle);
+
 		/**
 		 * @note Returns nullptr if script resource doesn't exist.
 		 */

SBansheeEngine/Include/BsScriptScriptCode.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptResource.h"
+#include "BsScriptObject.h"
+#include "BsScriptCode.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ScriptScriptCode : public ScriptObject <ScriptScriptCode, ScriptResourceBase>
+	{
+	public:
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "ScriptCode")
+
+		void* getNativeRaw() const { return mScriptCode.get(); }
+
+		HResource getNativeHandle() const { return mScriptCode; }
+		void setNativeHandle(const HResource& resource);
+
+		HScriptCode getScriptCodeHandle() const { return mScriptCode; }
+	private:
+		friend class ScriptResourceManager;
+
+		static void internal_createInstance(MonoObject* instance, MonoString* text);
+		static MonoString* internal_getText(ScriptScriptCode* thisPtr);
+		static void internal_setText(ScriptScriptCode* thisPtr, MonoString* text);
+
+		ScriptScriptCode(MonoObject* instance, const HScriptCode& scriptCode);
+
+		void _onManagedInstanceDeleted();
+
+		HScriptCode mScriptCode;
+	};
+}

SBansheeEngine/SBansheeEngine.vcxproj

@@ -291,6 +291,7 @@
     <ClInclude Include="Include\BsScriptObjectManager.h" />
     <ClInclude Include="Include\BsScriptPixelData.h" />
     <ClInclude Include="Include\BsScriptPixelUtility.h" />
+    <ClInclude Include="Include\BsScriptPlainText.h" />
     <ClInclude Include="Include\BsScriptRenderTarget.h" />
     <ClInclude Include="Include\BsScriptRenderTexture.h" />
     <ClInclude Include="Include\BsScriptRenderTexture2D.h" />
@@ -299,6 +300,7 @@
     <ClInclude Include="Include\BsScriptSceneObject.h" />
     <ClInclude Include="Include\BsManagedSerializableObjectInfoRTTI.h" />
     <ClInclude Include="Include\BsManagedSerializableObjectRTTI.h" />
+    <ClInclude Include="Include\BsScriptScriptCode.h" />
     <ClInclude Include="Include\BsScriptSerializableArray.h" />
     <ClInclude Include="Include\BsScriptSerializableDictionary.h" />
     <ClInclude Include="Include\BsScriptSerializableField.h" />
@@ -364,6 +366,7 @@
     <ClCompile Include="Source\BsScriptObjectManager.cpp" />
     <ClCompile Include="Source\BsScriptPixelData.cpp" />
     <ClCompile Include="Source\BsScriptPixelUtility.cpp" />
+    <ClCompile Include="Source\BsScriptPlainText.cpp" />
     <ClCompile Include="Source\BsScriptRenderTarget.cpp" />
     <ClCompile Include="Source\BsScriptRenderTexture.cpp" />
     <ClCompile Include="Source\BsScriptRenderTexture2D.cpp" />
@@ -376,6 +379,7 @@
     <ClCompile Include="Source\BsManagedSerializableList.cpp" />
     <ClCompile Include="Source\BsManagedSerializableObject.cpp" />
     <ClCompile Include="Source\BsManagedSerializableObjectInfo.cpp" />
+    <ClCompile Include="Source\BsScriptScriptCode.cpp" />
     <ClCompile Include="Source\BsScriptSerializableArray.cpp" />
     <ClCompile Include="Source\BsScriptSerializableDictionary.cpp" />
     <ClCompile Include="Source\BsScriptSerializableField.cpp" />

SBansheeEngine/SBansheeEngine.vcxproj.filters

@@ -288,6 +288,12 @@
     <ClInclude Include="Include\BsScriptGUIProgressBar.h">
       <Filter>Header Files\GUI</Filter>
     </ClInclude>
+    <ClInclude Include="Include\BsScriptPlainText.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\BsScriptScriptCode.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\BsScriptTexture2D.cpp">
@@ -512,5 +518,11 @@
     <ClCompile Include="Source\BsScriptGUIProgressBar.cpp">
       <Filter>Source Files\GUI</Filter>
     </ClCompile>
+    <ClCompile Include="Source\BsScriptPlainText.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Source\BsScriptScriptCode.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

SBansheeEngine/Source/BsManagedSerializableField.cpp

@@ -8,6 +8,8 @@
 #include "BsScriptTexture2D.h"
 #include "BsScriptSpriteTexture.h"
 #include "BsScriptManagedResource.h"
+#include "BsScriptPlainText.h"
+#include "BsScriptScriptCode.h"
 #include "BsScriptSceneObject.h"
 #include "BsScriptComponent.h"
 #include "BsManagedSerializableObject.h"
@@ -172,6 +174,30 @@ namespace BansheeEngine
 
 					return fieldData;
 				}
+			case ScriptPrimitiveType::PlainTextRef:
+			{
+				auto fieldData = bs_shared_ptr<ManagedSerializableFieldDataResourceRef>();
+
+				if (value != nullptr)
+				{
+					ScriptPlainText* scriptPlainResource = ScriptPlainText::toNative(value);
+					fieldData->value = static_resource_cast<PlainText>(scriptPlainResource->getNativeHandle());
+				}
+
+				return fieldData;
+			}
+			case ScriptPrimitiveType::ScriptCodeRef:
+			{
+				auto fieldData = bs_shared_ptr<ManagedSerializableFieldDataResourceRef>();
+
+				if (value != nullptr)
+				{
+					ScriptScriptCode* scriptScriptCode = ScriptScriptCode::toNative(value);
+					fieldData->value = static_resource_cast<ScriptCode>(scriptScriptCode->getNativeHandle());
+				}
+
+				return fieldData;
+			}
 			case ScriptPrimitiveType::SceneObjectRef:
 				{
 					auto fieldData = bs_shared_ptr<ManagedSerializableFieldDataGameObjectRef>();
@@ -435,6 +461,36 @@ namespace BansheeEngine
 				else
 					return nullptr;
 			}
+			else if (primitiveTypeInfo->mType == ScriptPrimitiveType::PlainTextRef)
+			{
+				if (value)
+				{
+					HPlainText plainText = static_resource_cast<PlainText>(value);
+					ScriptPlainText* scriptResource = ScriptResourceManager::instance().getScriptPlainText(plainText);
+					if (scriptResource == nullptr)
+						scriptResource = ScriptResourceManager::instance().createScriptPlainText(plainText);
+
+					if (scriptResource != nullptr)
+						return scriptResource->getManagedInstance();
+				}
+				else
+					return nullptr;
+			}
+			else if (primitiveTypeInfo->mType == ScriptPrimitiveType::ScriptCodeRef)
+			{
+				if (value)
+				{
+					HScriptCode scriptCode = static_resource_cast<ScriptCode>(value);
+					ScriptScriptCode* scriptResource = ScriptResourceManager::instance().getScriptScriptCode(scriptCode);
+					if (scriptResource == nullptr)
+						scriptResource = ScriptResourceManager::instance().createScriptScriptCode(scriptCode);
+
+					if (scriptResource != nullptr)
+						return scriptResource->getManagedInstance();
+				}
+				else
+					return nullptr;
+			}
 			else if (primitiveTypeInfo->mType == ScriptPrimitiveType::ManagedResourceRef)
 			{
 				if (value)

SBansheeEngine/Source/BsManagedSerializableObjectInfo.cpp

@@ -135,6 +135,10 @@ namespace BansheeEngine
 			return ScriptAssemblyManager::instance().getSpriteTextureClass()->_getInternalClass();
 		case ScriptPrimitiveType::ManagedResourceRef:
 			return ScriptAssemblyManager::instance().getManagedResourceClass()->_getInternalClass();
+		case ScriptPrimitiveType::PlainTextRef:
+			return ScriptAssemblyManager::instance().getPlainTextClass()->_getInternalClass();
+		case ScriptPrimitiveType::ScriptCodeRef:
+			return ScriptAssemblyManager::instance().getScriptCodeClass()->_getInternalClass();
 		case ScriptPrimitiveType::SceneObjectRef:
 			return ScriptAssemblyManager::instance().getSceneObjectClass()->_getInternalClass();
 		case ScriptPrimitiveType::ComponentRef:

SBansheeEngine/Source/BsScriptAssemblyManager.cpp

@@ -17,7 +17,8 @@ namespace BansheeEngine
 		:mBaseTypesInitialized(false), mSerializeObjectAttribute(nullptr), mDontSerializeFieldAttribute(nullptr), 
 		mComponentClass(nullptr), mSceneObjectClass(nullptr), mTextureClass(nullptr), mSpriteTextureClass(nullptr),
 		mSerializeFieldAttribute(nullptr), mHideInInspectorAttribute(nullptr), mSystemArrayClass(nullptr), mSystemGenericListClass(nullptr),
-		mSystemGenericDictionaryClass(nullptr), mManagedResourceClass(nullptr), mFontClass(nullptr), mMissingComponentClass(nullptr)
+		mSystemGenericDictionaryClass(nullptr), mManagedResourceClass(nullptr), mFontClass(nullptr), mMissingComponentClass(nullptr),
+		mPlainTextClass(nullptr), mScriptCodeClass(nullptr)
 	{
 
 	}
@@ -282,6 +283,18 @@ namespace BansheeEngine
 				typeInfo->mType = ScriptPrimitiveType::ManagedResourceRef;
 				return typeInfo;
 			}
+			else if (monoClass->isSubClassOf(mPlainTextClass))
+			{
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = bs_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
+				typeInfo->mType = ScriptPrimitiveType::PlainTextRef;
+				return typeInfo;
+			}
+			else if (monoClass->isSubClassOf(mScriptCodeClass))
+			{
+				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = bs_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
+				typeInfo->mType = ScriptPrimitiveType::ScriptCodeRef;
+				return typeInfo;
+			}
 			else if(monoClass->isSubClassOf(mSceneObjectClass))
 			{
 				std::shared_ptr<ManagedSerializableTypeInfoPrimitive> typeInfo = bs_shared_ptr<ManagedSerializableTypeInfoPrimitive>();
@@ -388,6 +401,8 @@ namespace BansheeEngine
 		mTextureClass = nullptr;
 		mSpriteTextureClass = nullptr;
 		mFontClass = nullptr;
+		mPlainTextClass = nullptr;
+		mScriptCodeClass = nullptr;
 
 		mSerializeFieldAttribute = nullptr;
 		mHideInInspectorAttribute = nullptr;
@@ -452,6 +467,14 @@ namespace BansheeEngine
 		if (mFontClass == nullptr)
 			BS_EXCEPT(InvalidStateException, "Cannot find Font managed class.");
 
+		mPlainTextClass = bansheeEngineAssembly->getClass("BansheeEngine", "PlainText");
+		if (mPlainTextClass == nullptr)
+			BS_EXCEPT(InvalidStateException, "Cannot find PlainText managed class.");
+
+		mScriptCodeClass = bansheeEngineAssembly->getClass("BansheeEngine", "ScriptCode");
+		if (mScriptCodeClass == nullptr)
+			BS_EXCEPT(InvalidStateException, "Cannot find ScriptCode managed class.");
+
 		mSerializeFieldAttribute = bansheeEngineAssembly->getClass("BansheeEngine", "SerializeField");
 		if(mSerializeFieldAttribute == nullptr)
 			BS_EXCEPT(InvalidStateException, "Cannot find SerializeField managed class.");

SBansheeEngine/Source/BsScriptPlainText.cpp

@@ -0,0 +1,61 @@
+#include "BsScriptPlainText.h"
+#include "BsScriptResourceManager.h"
+#include "BsScriptMeta.h"
+#include "BsMonoField.h"
+#include "BsMonoClass.h"
+#include "BsMonoManager.h"
+#include "BsMonoUtil.h"
+#include "BsPlainText.h"
+
+using namespace std::placeholders;
+
+namespace BansheeEngine
+{
+	ScriptPlainText::ScriptPlainText(MonoObject* instance, const HPlainText& plainText)
+		:ScriptObject(instance), mPlainText(plainText)
+	{
+
+	}
+
+	void ScriptPlainText::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptPlainText::internal_createInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetText", &ScriptPlainText::internal_getText);
+		metaData.scriptClass->addInternalCall("Internal_SetText", &ScriptPlainText::internal_setText);
+	}
+
+	void ScriptPlainText::internal_createInstance(MonoObject* instance, MonoString* text)
+	{
+		WString strText = MonoUtil::monoToWString(text);
+		HPlainText plainText = PlainText::create(strText);
+
+		ScriptResourceManager::instance().createScriptPlainText(instance, plainText);
+	}
+
+	MonoString* ScriptPlainText::internal_getText(ScriptPlainText* thisPtr)
+	{
+		HPlainText plainText = thisPtr->mPlainText;
+
+		return MonoUtil::wstringToMono(MonoManager::instance().getDomain(), plainText->getString());
+	}
+
+	void ScriptPlainText::internal_setText(ScriptPlainText* thisPtr, MonoString* text)
+	{
+		HPlainText plainText = thisPtr->mPlainText;
+
+		plainText->setString(MonoUtil::monoToWString(text));
+	}
+
+	void ScriptPlainText::_onManagedInstanceDeleted()
+	{
+		mManagedInstance = nullptr;
+
+		if (!mRefreshInProgress)
+			ScriptResourceManager::instance().destroyScriptResource(this);
+	}
+
+	void ScriptPlainText::setNativeHandle(const HResource& resource)
+	{
+		mPlainText = static_resource_cast<PlainText>(resource);
+	}
+}

SBansheeEngine/Source/BsScriptResourceManager.cpp

@@ -6,6 +6,8 @@
 #include "BsScriptTexture3D.h"
 #include "BsScriptTextureCube.h"
 #include "BsScriptSpriteTexture.h"
+#include "BsScriptPlainText.h"
+#include "BsScriptScriptCode.h"
 #include "BsScriptFont.h"
 #include "BsScriptManagedResource.h"
 #include "BsScriptAssemblyManager.h"
@@ -79,6 +81,48 @@ namespace BansheeEngine
 		return scriptResource;
 	}
 
+	ScriptPlainText* ScriptResourceManager::createScriptPlainText(const HPlainText& resourceHandle)
+	{
+		MonoClass* plainTextClass = ScriptAssemblyManager::instance().getPlainTextClass();
+		MonoObject* monoInstance = plainTextClass->createInstance();
+
+		return createScriptPlainText(monoInstance, resourceHandle);
+	}
+
+	ScriptPlainText* ScriptResourceManager::createScriptPlainText(MonoObject* instance, const HPlainText& resourceHandle)
+	{
+		const String& uuid = resourceHandle.getUUID();
+#if BS_DEBUG_MODE
+		throwExceptionIfInvalidOrDuplicate(uuid);
+#endif
+
+		ScriptPlainText* scriptResource = new (bs_alloc<ScriptPlainText>()) ScriptPlainText(instance, resourceHandle);
+		mScriptResources[uuid] = scriptResource;
+
+		return scriptResource;
+	}
+
+	ScriptScriptCode* ScriptResourceManager::createScriptScriptCode(const HScriptCode& resourceHandle)
+	{
+		MonoClass* scriptCodeClass = ScriptAssemblyManager::instance().getScriptCodeClass();
+		MonoObject* monoInstance = scriptCodeClass->createInstance();
+
+		return createScriptScriptCode(monoInstance, resourceHandle);
+	}
+
+	ScriptScriptCode* ScriptResourceManager::createScriptScriptCode(MonoObject* instance, const HScriptCode& resourceHandle)
+	{
+		const String& uuid = resourceHandle.getUUID();
+#if BS_DEBUG_MODE
+		throwExceptionIfInvalidOrDuplicate(uuid);
+#endif
+
+		ScriptScriptCode* scriptResource = new (bs_alloc<ScriptScriptCode>()) ScriptScriptCode(instance, resourceHandle);
+		mScriptResources[uuid] = scriptResource;
+
+		return scriptResource;
+	}
+
 	ScriptSpriteTexture* ScriptResourceManager::createScriptSpriteTexture(const HSpriteTexture& resourceHandle)
 	{
 		MonoClass* spriteTextureClass = ScriptAssemblyManager::instance().getSpriteTextureClass();
@@ -142,6 +186,16 @@ namespace BansheeEngine
 		return static_cast<ScriptSpriteTexture*>(getScriptResource(resourceHandle.getUUID()));
 	}
 
+	ScriptPlainText* ScriptResourceManager::getScriptPlainText(const HPlainText& resourceHandle)
+	{
+		return static_cast<ScriptPlainText*>(getScriptResource(resourceHandle.getUUID()));
+	}
+
+	ScriptScriptCode* ScriptResourceManager::getScriptScriptCode(const HScriptCode& resourceHandle)
+	{
+		return static_cast<ScriptScriptCode*>(getScriptResource(resourceHandle.getUUID()));
+	}
+
 	ScriptManagedResource* ScriptResourceManager::getScriptManagedResource(const HManagedResource& resourceHandle)
 	{
 		return static_cast<ScriptManagedResource*>(getScriptResource(resourceHandle.getUUID()));

SBansheeEngine/Source/BsScriptScriptCode.cpp

@@ -0,0 +1,60 @@
+#include "BsScriptScriptCode.h"
+#include "BsScriptResourceManager.h"
+#include "BsScriptMeta.h"
+#include "BsMonoField.h"
+#include "BsMonoClass.h"
+#include "BsMonoManager.h"
+#include "BsMonoUtil.h"
+
+using namespace std::placeholders;
+
+namespace BansheeEngine
+{
+	ScriptScriptCode::ScriptScriptCode(MonoObject* instance, const HScriptCode& scriptCode)
+		:ScriptObject(instance), mScriptCode(scriptCode)
+	{
+
+	}
+
+	void ScriptScriptCode::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptScriptCode::internal_createInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetText", &ScriptScriptCode::internal_getText);
+		metaData.scriptClass->addInternalCall("Internal_SetText", &ScriptScriptCode::internal_setText);
+	}
+
+	void ScriptScriptCode::internal_createInstance(MonoObject* instance, MonoString* text)
+	{
+		WString strText = MonoUtil::monoToWString(text);
+		HScriptCode scriptCode = ScriptCode::create(strText);
+
+		ScriptResourceManager::instance().createScriptScriptCode(instance, scriptCode);
+	}
+
+	MonoString* ScriptScriptCode::internal_getText(ScriptScriptCode* thisPtr)
+	{
+		HScriptCode scriptCode = thisPtr->mScriptCode;
+
+		return MonoUtil::wstringToMono(MonoManager::instance().getDomain(), scriptCode->getString());
+	}
+
+	void ScriptScriptCode::internal_setText(ScriptScriptCode* thisPtr, MonoString* text)
+	{
+		HScriptCode scriptCode = thisPtr->mScriptCode;
+
+		scriptCode->setString(MonoUtil::monoToWString(text));
+	}
+
+	void ScriptScriptCode::_onManagedInstanceDeleted()
+	{
+		mManagedInstance = nullptr;
+
+		if (!mRefreshInProgress)
+			ScriptResourceManager::instance().destroyScriptResource(this);
+	}
+
+	void ScriptScriptCode::setNativeHandle(const HResource& resource)
+	{
+		mScriptCode = static_resource_cast<ScriptCode>(resource);
+	}
+}

TODO.txt

@@ -26,6 +26,10 @@ VS integration will likely not work with VSExpress or Community edition
  - VSExpress doesn't support EnvDTE so the only option is to open it using a shell command which doesn't seem to offer precise parameters
  - Community edition should work similarily to Pro, but might have a different executable and/or registry paths
 
+Test:
+ - If string::format works
+ - If VS open and sync works
+
 For later:
  - Make sure that 3rd party assemblies can be imported in the project, and that they are properly referenced in VS project generation