Build: Updated 'bsf' version

 - Adjusted build and app start-up to match new C# scripting setup
 - ImportOptions bindings now auto-generated
 -

Source/Banshee3D/BsEditorExec.cpp

@@ -4,6 +4,7 @@
 #include <stdio.h>
 #include "BsEditorApplication.h"
 #include "Error/BsCrashHandler.h"
+#include "BsEditorScriptLibrary.h"
 
 #if BS_PLATFORM == BS_PLATFORM_WIN32
 #include <windows.h>
@@ -21,6 +22,9 @@ int CALLBACK WinMain(
 
 	__try
 	{
+		SPtr<EditorScriptLibrary> library = bs_shared_ptr_new<EditorScriptLibrary>();
+		ScriptManager::_setScriptLibrary(library);
+
 		EditorApplication::startUp();
 		EditorApplication::instance().runMainLoop();
 		EditorApplication::shutDown();
@@ -39,6 +43,9 @@ using namespace bs;
 
 int main()
 {
+	SPtr<EditorScriptLibrary> library = bs_shared_ptr_new<EditorScriptLibrary>();
+	ScriptManager::_setScriptLibrary(library);
+
 	EditorApplication::startUp();
 	EditorApplication::instance().runMainLoop();
 	EditorApplication::shutDown();

Source/Banshee3D/CMakeLists.txt

@@ -16,14 +16,14 @@ target_include_directories(Banshee3D PRIVATE "./")
 
 # Libraries
 ## Local libs
-target_link_libraries(Banshee3D EditorCore bsf)
+target_link_libraries(Banshee3D EditorScript bsfScript bsfMono EditorCore bsf)
 
 # IDE specific
 set_property(TARGET Banshee3D PROPERTY FOLDER Executable)
 
 # Plugin dependencies
 add_engine_dependencies(Banshee3D)
-add_dependencies(Banshee3D bsfFBXImporter bsfFontImporter bsfFreeImgImporter EditorScript MonoExec)
+add_dependencies(Banshee3D bsfFBXImporter bsfFontImporter bsfFreeImgImporter MonoExec)
 
 # Compiler flags
 if(MSVC)

Source/EditorCore/BsEditorApplication.cpp

@@ -46,7 +46,6 @@ namespace bs
 		startUpDesc.renderer = BS_RENDERER_MODULE;
 		startUpDesc.audio = BS_AUDIO_MODULE;
 		startUpDesc.physics = BS_PHYSICS_MODULE;
-		startUpDesc.scripting = true;
 		startUpDesc.physicsCooking = true;
 
 		startUpDesc.primaryWindowDesc.videoMode = VideoMode(1920, 1080);
@@ -72,7 +71,7 @@ namespace bs
 	}
 
 	EditorApplication::EditorApplication()
-		:Application(createStartupDesc()), mIsProjectLoaded(false), mEditorScriptPlugin(nullptr)
+		:Application(createStartupDesc()), mIsProjectLoaded(false)
 	{
 
 	}
@@ -137,7 +136,7 @@ namespace bs
 		CodeEditorManager::startUp();
 
 		MainEditorWindow::create(getPrimaryWindow());
-		ScriptManager::instance().initialize();
+		ScriptManager::startUp();
 	}
 
 	void EditorApplication::onShutDown()
@@ -160,28 +159,6 @@ namespace bs
 		Application::onShutDown();
 	}
 
-	void EditorApplication::loadScriptSystem()
-	{
-		loadPlugin("bsfMono", &mMonoPlugin);
-		loadPlugin("bsfScript", &mScriptPlugin);
-		loadPlugin("EditorScript", &mEditorScriptPlugin);
-	}
-
-	void EditorApplication::unloadScriptSystem()
-	{
-		// These plugins must be unloaded before any other script plugins, because
-		// they will cause finalizers to trigger and various modules those finalizers
-		// might reference must still be active
-		if(mEditorScriptPlugin != nullptr)
-			unloadPlugin(mEditorScriptPlugin);
-
-		if(mScriptPlugin != nullptr)
-			unloadPlugin(mScriptPlugin);
-
-		if(mMonoPlugin != nullptr)
-			unloadPlugin(mMonoPlugin);
-	}
-
 	void EditorApplication::startUp()
 	{
 		CoreApplication::startUp<EditorApplication>();
@@ -193,6 +170,11 @@ namespace bs
 		SplashScreen::show();
 	}
 
+	void EditorApplication::startUpScriptManager()
+	{
+		// Do nothing, we initialize the script manager at a later stage
+	}
+
 	void EditorApplication::preUpdate()
 	{
 		Application::preUpdate();
@@ -225,12 +207,7 @@ namespace bs
 
 	void EditorApplication::quitRequested()
 	{
-		typedef void(*QuitRequestedFunc)();
-
-		QuitRequestedFunc quitRequestedCall = (QuitRequestedFunc)mEditorScriptPlugin->getSymbol("quitRequested");
-
-		if (quitRequestedCall != nullptr)
-			quitRequestedCall();
+		onQuitRequested();
 	}
 
 	void EditorApplication::saveProject()

Source/EditorCore/BsEditorApplication.h

@@ -76,6 +76,9 @@ namespace bs
 
 		/** @copydoc Application::isEditor */
 		bool isEditor() const override { return true; }
+
+		/** Callback when the user requests application exit. The receiver is expected to handle shutdown if required. */
+		Event<void()> onQuitRequested;
 	private:
 		/** @copydoc Module::onStartUp */
 		void onStartUp() override;
@@ -92,15 +95,12 @@ namespace bs
 		/** @copydoc CoreApplication::quitRequested */
 		void quitRequested() override;
 
-		/** @copydoc Application::loadScriptSystem */
-		void loadScriptSystem() override;
-
-		/** @copydoc Application::unloadScriptSystem */
-		void unloadScriptSystem() override;
-
 		/** @copydoc Application::startUpRenderer */
 		void startUpRenderer() override;
 
+		/** @copydoc Application::startUpScriptManager */
+		void startUpScriptManager() override;
+
 		/**
 		 * Loads the previously saved editor widget layout from the default location. Can return null if no layout was 
 		 * previously saved.
@@ -141,8 +141,6 @@ namespace bs
 
 		Timer mSplashScreenTimer;
 		bool mSplashScreenShown = true;
-
-		DynLib* mEditorScriptPlugin;
 	};
 
 	/**	Easy way to access EditorApplication. */

Source/EditorCore/CodeEditor/BsCodeEditor.cpp

@@ -139,7 +139,7 @@ namespace bs
 
 				bool isEditorScript = false;
 				if (scriptIO != nullptr)
-					isEditorScript = scriptIO->isEditorScript();
+					isEditorScript = scriptIO->editorScript;
 
 				if (isEditorScript)
 					editorProject.codeFiles.push_back(resEntry->path);

Source/EditorCore/GUI/BsGUIColorDistributionField.h

@@ -19,7 +19,7 @@ namespace bs
 	 * A composite GUI object representing an editor field. Editor fields are a combination of a label and an input field.
 	 * Label is optional. This specific implementation displays an input field for a color distribution.
 	 */
-	class BS_ED_EXPORT BS_SCRIPT_EXPORT(ed:true,m:GUIEditor) 
+	class BS_ED_EXPORT BS_SCRIPT_EXPORT(m:GUIEditor,api:bed) 
 	GUIColorDistributionField final : public TGUIField<GUIColorDistributionField>
 	{
 	public:

Source/EditorCore/GUI/BsGUIColorGradient.h

@@ -15,7 +15,7 @@ namespace bs
 	 */
 
 	/** GUI element that displays a color gradient. */
-	class BS_ED_EXPORT BS_SCRIPT_EXPORT(ed:true,m:GUIEditor) GUIColorGradient : public GUIElement
+	class BS_ED_EXPORT BS_SCRIPT_EXPORT(m:GUIEditor,api:bed) GUIColorGradient : public GUIElement
 	{
 	public:
 		/** Returns type name of the GUI element used for finding GUI element styles. */

Source/EditorCore/GUI/BsGUIColorGradientField.h

@@ -16,7 +16,7 @@ namespace bs
 	 * A composite GUI object representing an editor field. Editor fields are a combination of a label and an input field.
 	 * Label is optional. This specific implementation displays a color gradient input field.
 	 */
-	class BS_ED_EXPORT BS_SCRIPT_EXPORT(ed:true,m:GUIEditor) 
+	class BS_ED_EXPORT BS_SCRIPT_EXPORT(m:GUIEditor,api:bed) 
 	GUIColorGradientField final : public TGUIField<GUIColorGradientField>
 	{
 	public:

Source/EditorCore/GUI/BsGUICurves.h

@@ -16,7 +16,7 @@ namespace bs
 	 */
 
 	/** Controls which elements should a GUICurves object draw. */
-	enum class BS_SCRIPT_EXPORT(ed:true,m:GUIEditor,n:CurveDrawOptions) CurveDrawOption
+	enum class BS_SCRIPT_EXPORT(m:GUIEditor,n:CurveDrawOptions,api:bed) CurveDrawOption
 	{
 		/** Draws markers at specific time intervals. */
 		DrawMarkers = 1 << 0,
@@ -32,7 +32,7 @@ namespace bs
 	BS_FLAGS_OPERATORS(CurveDrawOption)
 
 	/** Curve and a color to draw it in. */
-	struct BS_SCRIPT_EXPORT(ed:true,pl:true,m:GUIEditor) CurveDrawInfo
+	struct BS_SCRIPT_EXPORT(pl:true,m:GUIEditor,api:bed) CurveDrawInfo
 	{
 		CurveDrawInfo() = default;
 		CurveDrawInfo(const TAnimationCurve<float>& curve, Color color)
@@ -47,7 +47,7 @@ namespace bs
 	};
 
 	/** GUI element that displays one or multiple curves. */
-	class BS_ED_EXPORT BS_SCRIPT_EXPORT(ed:true,m:GUIEditor) GUICurves : public GUITimeline
+	class BS_ED_EXPORT BS_SCRIPT_EXPORT(m:GUIEditor,api:bed) GUICurves : public GUITimeline
 	{
 	public:
 		/** Returns type name of the GUI element used for finding GUI element styles. */

Source/EditorCore/GUI/BsGUICurvesField.h

@@ -19,7 +19,7 @@ namespace bs
 	 * A composite GUI object representing an editor field. Editor fields are a combination of a label and an input field.
 	 * Label is optional. This specific implementation displays an animation curve or a range between two animation curves.
 	 */
-	class BS_ED_EXPORT BS_SCRIPT_EXPORT(ed:true,m:GUIEditor) GUICurvesField final : public TGUIField<GUICurvesField>
+	class BS_ED_EXPORT BS_SCRIPT_EXPORT(m:GUIEditor,api:bed) GUICurvesField final : public TGUIField<GUICurvesField>
 	{
 	public:
 		/** Returns type name of the GUI element used for finding GUI element styles. */

Source/EditorCore/GUI/BsGUIFloatDistributionField.h

@@ -131,7 +131,7 @@ namespace bs
 	 * A composite GUI object representing an editor field. Editor fields are a combination of a label and an input field.
 	 * Label is optional. This specific implementation displays an input field for a floating point distribution.
 	 */
-	class BS_ED_EXPORT BS_SCRIPT_EXPORT(ed:true,m:GUIEditor) 
+	class BS_ED_EXPORT BS_SCRIPT_EXPORT(m:GUIEditor,api:bed) 
 	GUIFloatDistributionField final : public TGUIDistributionField<float, GUIFloatDistributionField>
 	{
 	public:
@@ -145,7 +145,7 @@ namespace bs
 	 * A composite GUI object representing an editor field. Editor fields are a combination of a label and an input field.
 	 * Label is optional. This specific implementation displays an input field for a 2D vector distribution.
 	 */
-	class BS_ED_EXPORT BS_SCRIPT_EXPORT(ed:true,m:GUIEditor) 
+	class BS_ED_EXPORT BS_SCRIPT_EXPORT(m:GUIEditor,api:bed) 
 	GUIVector2DistributionField final : public TGUIDistributionField<Vector2, GUIVector2DistributionField>
 	{
 	public:
@@ -159,7 +159,7 @@ namespace bs
 	 * A composite GUI object representing an editor field. Editor fields are a combination of a label and an input field.
 	 * Label is optional. This specific implementation displays an input field for a 3D vector distribution.
 	 */
-	class BS_ED_EXPORT BS_SCRIPT_EXPORT(ed:true,m:GUIEditor) 
+	class BS_ED_EXPORT BS_SCRIPT_EXPORT(m:GUIEditor,api:bed) 
 	GUIVector3DistributionField final : public TGUIDistributionField<Vector3, GUIVector3DistributionField>
 	{
 	public:

Source/EditorCore/GUI/BsGUIGraphTicks.h

@@ -12,7 +12,7 @@ namespace bs
 	 */
 
 	/** Determines how should ticks reported by <see cref="GUIGraphTicks"/> be distributed. */
-	enum class BS_SCRIPT_EXPORT(ed:true,m:GUIEditor) GUITickStepType
+	enum class BS_SCRIPT_EXPORT(m:GUIEditor,api:bed) GUITickStepType
 	{
 		/** Ticks represent time values (Multiples of 60). */
 		Time,
@@ -26,7 +26,7 @@ namespace bs
 	 * coordinates along which ticks should be positioned. Ticks are reported as multiple separate levels with different
 	 * strengths, depending on how close their distribution is to the upper valid range.
 	 */
-	class BS_SCRIPT_EXPORT(ed:true,m:GUIEditor) GUIGraphTicks
+	class BS_SCRIPT_EXPORT(m:GUIEditor,api:bed) GUIGraphTicks
 	{
 	public:
 		/**

Source/EditorCore/GUI/BsGUITimeline.h

@@ -14,7 +14,7 @@ namespace bs
 	 */
 
 	/** Base class that can be implemented by GUI elements needing to elements along draw a horizontal timeline. */
-	class BS_ED_EXPORT BS_SCRIPT_EXPORT(ed:true,m:GUIEditor) GUITimeline : public GUIElementContainer
+	class BS_ED_EXPORT BS_SCRIPT_EXPORT(m:GUIEditor,api:bed) GUITimeline : public GUIElementContainer
 	{
 	public:
 		/** Returns type name of the GUI element used for finding GUI element styles. */

Source/EditorCore/Library/BsProjectResourceMeta.h

@@ -12,7 +12,7 @@ namespace bs
 	 */
 
 	/** Different icon sizes for project resource preview icons. */
-	struct BS_SCRIPT_EXPORT(pl:true,ed:true) ProjectResourceIcons
+	struct BS_SCRIPT_EXPORT(pl:true,api:bed) ProjectResourceIcons
 	{
 		HTexture icon16;
 		HTexture icon32;

Source/EditorCore/Utility/BsBuiltinEditorResources.h

@@ -15,14 +15,14 @@ namespace bs
 	 */
 
 	/**	Types of valid icons used when viewing the project library. */
-	enum BS_SCRIPT_EXPORT(ed:true) class ProjectLibraryIcon
+	enum BS_SCRIPT_EXPORT(api:bed) class ProjectLibraryIcon
 	{
 		Folder, Mesh, Font, Texture, PlainText, ScriptCode, SpriteTexture, Shader, ShaderInclude, Material, Prefab, GUISkin,
 		PhysicsMaterial, PhysicsMesh, AudioClip, AnimationClip, VectorField
 	};
 
 	/**	Types of icons that may be displayed on the tool bar. */
-	enum BS_SCRIPT_EXPORT(ed:true) class ToolbarIcon
+	enum BS_SCRIPT_EXPORT(api:bed) class ToolbarIcon
 	{
 		NewCamera, NewRenderable, NewPointLight, NewDirLight, NewSpotLight, NewSceneObject, NewCube, NewSphere, NewCone, 
 		NewQuad, NewMat, NewCSScript, NewShader, NewSpriteTex, Pause, Play, Step, Undo, Redo, OpenProject, SaveProject, 
@@ -30,49 +30,49 @@ namespace bs
 	};
 
 	/** Types of icons that are used as 3D icons in the scene view. */
-	enum BS_SCRIPT_EXPORT(ed:true) class SceneViewIcon
+	enum BS_SCRIPT_EXPORT(api:bed) class SceneViewIcon
 	{
 		Camera, Light, AudioSource, AudioListener, Decal, ParticleSystem, LightProbes, ReflectionProbe
 	};
 
 	/**	Types of icons that may be displayed in the scene window. */
-	enum BS_SCRIPT_EXPORT(ed:true) class SceneWindowIcon
+	enum BS_SCRIPT_EXPORT(api:bed) class SceneWindowIcon
 	{
 		View, Move, Rotate, Scale, Pivot, Center, Local, World, MoveSnap, RotateSnap, SceneCameraOptions
 	};
 
 	/**	Types of icons that may be displayed in the inspector window. */
-	enum BS_SCRIPT_EXPORT(ed:true) class InspectorWindowIcon
+	enum BS_SCRIPT_EXPORT(api:bed) class InspectorWindowIcon
 	{
 		Create, Clone, Clear, Resize, Delete, MoveUp, MoveDown, Edit, Apply, Add, Cancel
 	};
 
 	/**	Types of icons that may be displayed in the library window. */
-	enum BS_SCRIPT_EXPORT(ed:true) class LibraryWindowIcon
+	enum BS_SCRIPT_EXPORT(api:bed) class LibraryWindowIcon
 	{
 		Home, Up, Clear, Options
 	};
 
 	/**	Types of icons that may be displayed in the animation editor window. */
-	enum BS_SCRIPT_EXPORT(ed:true) class AnimationWindowIcon
+	enum BS_SCRIPT_EXPORT(api:bed) class AnimationWindowIcon
 	{
 		Play, Record, FrameForward, FrameBack, AddKeyframe, AddEvent, Keyframe, Event
 	};
 
 	/**	Types of icons used in various areas throughout the editor. */
-	enum BS_SCRIPT_EXPORT(ed:true) class EditorIcon
+	enum BS_SCRIPT_EXPORT(api:bed) class EditorIcon
 	{
 		X, Component, SceneObject
 	};
 
 	/**	Types of icons to be used along with log messages depending on their severity. */
-	enum BS_SCRIPT_EXPORT(ed:true) class LogMessageIcon
+	enum BS_SCRIPT_EXPORT(api:bed) class LogMessageIcon
 	{
 		Info, Warning, Error
 	};
 
 	/**	Contains a set of built-in resources used by the editor. */
-	class BS_ED_EXPORT BS_SCRIPT_EXPORT(ed:true,n:EditorBuiltin,m:Utility-Editor) 
+	class BS_ED_EXPORT BS_SCRIPT_EXPORT(n:EditorBuiltin,m:Utility-Editor,api:bed) 
 	BuiltinEditorResources : public bs::Module<BuiltinEditorResources>
 	{
 	public:

Source/EditorManaged/Generated/AnimationSplitInfo.editor.generated.cs

@@ -0,0 +1,85 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+	/** @addtogroup Importer
+	 *  @{
+	 */
+
+	/// <summary>Information about how to split an AnimationClip into multiple separate clips.</summary>
+	[ShowInInspector]
+	public partial class AnimationSplitInfo : ScriptObject
+	{
+		private AnimationSplitInfo(bool __dummy0) { }
+
+		public AnimationSplitInfo()
+		{
+			Internal_AnimationSplitInfo(this);
+		}
+
+		public AnimationSplitInfo(string name, int startFrame, int endFrame, bool isAdditive = false)
+		{
+			Internal_AnimationSplitInfo0(this, name, startFrame, endFrame, isAdditive);
+		}
+
+		[ShowInInspector]
+		[NativeWrapper]
+		public string Name
+		{
+			get { return Internal_getname(mCachedPtr); }
+			set { Internal_setname(mCachedPtr, value); }
+		}
+
+		[ShowInInspector]
+		[NativeWrapper]
+		public int StartFrame
+		{
+			get { return Internal_getstartFrame(mCachedPtr); }
+			set { Internal_setstartFrame(mCachedPtr, value); }
+		}
+
+		[ShowInInspector]
+		[NativeWrapper]
+		public int EndFrame
+		{
+			get { return Internal_getendFrame(mCachedPtr); }
+			set { Internal_setendFrame(mCachedPtr, value); }
+		}
+
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool IsAdditive
+		{
+			get { return Internal_getisAdditive(mCachedPtr); }
+			set { Internal_setisAdditive(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_AnimationSplitInfo(AnimationSplitInfo managedInstance);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_AnimationSplitInfo0(AnimationSplitInfo managedInstance, string name, int startFrame, int endFrame, bool isAdditive);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern string Internal_getname(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setname(IntPtr thisPtr, string value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int Internal_getstartFrame(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setstartFrame(IntPtr thisPtr, int value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int Internal_getendFrame(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setendFrame(IntPtr thisPtr, int value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getisAdditive(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setisAdditive(IntPtr thisPtr, bool value);
+	}
+
+	/** @} */
+}

Source/EditorManaged/Generated/AudioClipImportOptions.editor.generated.cs

@@ -0,0 +1,86 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+	/** @addtogroup Importer
+	 *  @{
+	 */
+
+	/// <summary>Contains import options you may use to control how an audio clip is imported.</summary>
+	[ShowInInspector]
+	public partial class AudioClipImportOptions : ImportOptions
+	{
+		private AudioClipImportOptions(bool __dummy0) { }
+
+		/// <summary>Creates a new import options object that allows you to customize how are audio clips imported.</summary>
+		public AudioClipImportOptions()
+		{
+			Internal_create(this);
+		}
+
+		/// <summary>Audio format to import the audio clip as.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public AudioFormat Format
+		{
+			get { return Internal_getformat(mCachedPtr); }
+			set { Internal_setformat(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines how is audio data loaded into memory.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public AudioReadMode ReadMode
+		{
+			get { return Internal_getreadMode(mCachedPtr); }
+			set { Internal_setreadMode(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines should the clip be played as spatial (3D) audio or as normal audio. 3D clips will be converted to mono on 
+		/// import.
+		/// </summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool Is3D
+		{
+			get { return Internal_getis3D(mCachedPtr); }
+			set { Internal_setis3D(mCachedPtr, value); }
+		}
+
+		/// <summary>Size of a single sample in bits. The clip will be converted to this bit depth on import.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public int BitDepth
+		{
+			get { return Internal_getbitDepth(mCachedPtr); }
+			set { Internal_setbitDepth(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern AudioFormat Internal_getformat(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setformat(IntPtr thisPtr, AudioFormat value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern AudioReadMode Internal_getreadMode(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setreadMode(IntPtr thisPtr, AudioReadMode value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getis3D(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setis3D(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int Internal_getbitDepth(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setbitDepth(IntPtr thisPtr, int value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_create(AudioClipImportOptions managedInstance);
+	}
+
+	/** @} */
+}

Source/EditorManaged/Generated/CharRange.editor.generated.cs

@@ -0,0 +1,39 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+	/** @addtogroup Text
+	 *  @{
+	 */
+
+	/// <summary>Represents a range of character code.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct CharRange
+	{
+		/// <summary>Initializes the struct with default values.</summary>
+		public static CharRange Default()
+		{
+			CharRange value = new CharRange();
+			value.start = 0;
+			value.end = 0;
+
+			return value;
+		}
+
+		public CharRange(int start, int end)
+		{
+			this.start = start;
+			this.end = end;
+		}
+
+		public int start;
+		public int end;
+	}
+
+	/** @} */
+}

Source/EditorManaged/Generated/CollisionMeshType.editor.generated.cs

@@ -0,0 +1,26 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+	/** @addtogroup Importer
+	 *  @{
+	 */
+
+	/// <summary>Controls what type of collision mesh should be imported during mesh import.</summary>
+	public enum CollisionMeshType
+	{
+		/// <summary>No collision mesh will be imported.</summary>
+		None = 0,
+		/// <summary>Normal triangle mesh will be imported.</summary>
+		Normal = 1,
+		/// <summary>A convex hull will be generated from the source mesh.</summary>
+		Convex = 2
+	}
+
+	/** @} */
+}

Source/EditorManaged/Generated/CubemapSourceType.editor.generated.cs

@@ -0,0 +1,31 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+	/** @addtogroup Utility
+	 *  @{
+	 */
+
+	/// <summary>Determines the type of the source image for generating cubemaps.</summary>
+	public enum CubemapSourceType
+	{
+		/// <summary>Source is a single image that will be replicated on all cubemap faces.</summary>
+		Single = 0,
+		/// <summary>
+		/// Source is a list of 6 images, either sequentially next to each other or in a cross format. The system will  
+		/// automatically guess the layout and orientation based on the aspect ratio.
+		/// </summary>
+		Faces = 1,
+		/// <summary>Source is a single spherical panoramic image.</summary>
+		Spherical = 2,
+		/// <summary>Source is a single cylindrical panoramic image.</summary>
+		Cylindrical = 3
+	}
+
+	/** @} */
+}

Source/EditorManaged/Generated/FontImportOptions.editor.generated.cs

@@ -0,0 +1,109 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+	/** @addtogroup Text
+	 *  @{
+	 */
+
+	/// <summary>Import options that allow you to control how is a font imported.</summary>
+	[ShowInInspector]
+	public partial class FontImportOptions : ImportOptions
+	{
+		private FontImportOptions(bool __dummy0) { }
+
+		/// <summary>Creates a new import options object that allows you to customize how are fonts imported.</summary>
+		public FontImportOptions()
+		{
+			Internal_create(this);
+		}
+
+		/// <summary>Determines font sizes that are to be imported. Sizes are in points.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public int[] FontSizes
+		{
+			get { return Internal_getfontSizes(mCachedPtr); }
+			set { Internal_setfontSizes(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines character index ranges to import. Ranges are defined as unicode numbers.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public CharRange[] CharIndexRanges
+		{
+			get { return Internal_getcharIndexRanges(mCachedPtr); }
+			set { Internal_setcharIndexRanges(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines dots per inch scale that will be used when rendering the characters.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public int Dpi
+		{
+			get { return Internal_getdpi(mCachedPtr); }
+			set { Internal_setdpi(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines the render mode used for rendering the characters into a bitmap.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public FontRenderMode RenderMode
+		{
+			get { return Internal_getrenderMode(mCachedPtr); }
+			set { Internal_setrenderMode(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines whether the bold font style should be used when rendering.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool Bold
+		{
+			get { return Internal_getbold(mCachedPtr); }
+			set { Internal_setbold(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines whether the italic font style should be used when rendering.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool Italic
+		{
+			get { return Internal_getitalic(mCachedPtr); }
+			set { Internal_setitalic(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int[] Internal_getfontSizes(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setfontSizes(IntPtr thisPtr, int[] value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern CharRange[] Internal_getcharIndexRanges(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setcharIndexRanges(IntPtr thisPtr, CharRange[] value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int Internal_getdpi(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setdpi(IntPtr thisPtr, int value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern FontRenderMode Internal_getrenderMode(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setrenderMode(IntPtr thisPtr, FontRenderMode value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getbold(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setbold(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getitalic(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setitalic(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_create(FontImportOptions managedInstance);
+	}
+
+	/** @} */
+}

Source/EditorManaged/Generated/FontRenderMode.editor.generated.cs

@@ -0,0 +1,24 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+	/** @addtogroup Text
+	 *  @{
+	 */
+
+	/// <summary>Determines how is a font rendered into the bitmap texture.</summary>
+	public enum FontRenderMode
+	{
+		Smooth = 0,
+		Raster = 1,
+		HintedSmooth = 2,
+		HintedRaster = 3
+	}
+
+	/** @} */
+}

Source/EditorManaged/Generated/ImportOptions.editor.generated.cs

@@ -0,0 +1,27 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+	/** @addtogroup Importer
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Base class for creating import options from. Import options are specific for each importer and control how is data  
+	/// imported.
+	/// </summary>
+	[ShowInInspector]
+	public partial class ImportOptions : ScriptObject
+	{
+		private ImportOptions(bool __dummy0) { }
+		protected ImportOptions() { }
+
+	}
+
+	/** @} */
+}

Source/EditorManaged/Generated/ImportedAnimationEvents.editor.generated.cs

@@ -0,0 +1,54 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+	/** @addtogroup Importer
+	 *  @{
+	 */
+
+	/// <summary>A set of animation events that will be added to an animation clip during animation import.</summary>
+	[ShowInInspector]
+	public partial class ImportedAnimationEvents : ScriptObject
+	{
+		private ImportedAnimationEvents(bool __dummy0) { }
+
+		public ImportedAnimationEvents()
+		{
+			Internal_ImportedAnimationEvents(this);
+		}
+
+		[ShowInInspector]
+		[NativeWrapper]
+		public string Name
+		{
+			get { return Internal_getname(mCachedPtr); }
+			set { Internal_setname(mCachedPtr, value); }
+		}
+
+		[ShowInInspector]
+		[NativeWrapper]
+		public AnimationEvent[] Events
+		{
+			get { return Internal_getevents(mCachedPtr); }
+			set { Internal_setevents(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_ImportedAnimationEvents(ImportedAnimationEvents managedInstance);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern string Internal_getname(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setname(IntPtr thisPtr, string value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern AnimationEvent[] Internal_getevents(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setevents(IntPtr thisPtr, AnimationEvent[] value);
+	}
+
+	/** @} */
+}

Source/EditorManaged/Generated/MeshImportOptions.editor.generated.cs

@@ -0,0 +1,210 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+	/** @addtogroup Importer
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Contains import options you may use to control how is a mesh imported from some external format into engine format.
+	/// </summary>
+	[ShowInInspector]
+	public partial class MeshImportOptions : ImportOptions
+	{
+		private MeshImportOptions(bool __dummy0) { }
+
+		/// <summary>Creates a new import options object that allows you to customize how are meshes imported.</summary>
+		public MeshImportOptions()
+		{
+			Internal_create(this);
+		}
+
+		/// <summary>Determines whether the texture data is also stored in CPU memory.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool CpuCached
+		{
+			get { return Internal_getcpuCached(mCachedPtr); }
+			set { Internal_setcpuCached(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines should mesh normals be imported if available.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool ImportNormals
+		{
+			get { return Internal_getimportNormals(mCachedPtr); }
+			set { Internal_setimportNormals(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines should mesh tangents and bitangents be imported if available.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool ImportTangents
+		{
+			get { return Internal_getimportTangents(mCachedPtr); }
+			set { Internal_setimportTangents(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines should mesh blend shapes be imported if available.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool ImportBlendShapes
+		{
+			get { return Internal_getimportBlendShapes(mCachedPtr); }
+			set { Internal_setimportBlendShapes(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines should mesh skin data like bone weights, indices and bind poses be imported if available.
+		/// </summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool ImportSkin
+		{
+			get { return Internal_getimportSkin(mCachedPtr); }
+			set { Internal_setimportSkin(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines should animation clips be imported if available.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool ImportAnimation
+		{
+			get { return Internal_getimportAnimation(mCachedPtr); }
+			set { Internal_setimportAnimation(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Enables or disables keyframe reduction. Keyframe reduction will reduce the number of key-frames in an animation clip 
+		/// by removing identical keyframes, and therefore reducing the size of the clip.
+		/// </summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool ReduceKeyFrames
+		{
+			get { return Internal_getreduceKeyFrames(mCachedPtr); }
+			set { Internal_setreduceKeyFrames(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Enables or disables import of root motion curves. When enabled, any animation curves in imported animations  
+		/// affecting the root bone will be available through a set of separate curves in AnimationClip, and they won't be 
+		/// evaluated through normal animation process. Instead it is expected that the user evaluates the curves manually and 
+		/// applies them as required.
+		/// </summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool ImportRootMotion
+		{
+			get { return Internal_getimportRootMotion(mCachedPtr); }
+			set { Internal_setimportRootMotion(mCachedPtr, value); }
+		}
+
+		/// <summary>Uniformly scales the imported mesh by the specified value.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public float ImportScale
+		{
+			get { return Internal_getimportScale(mCachedPtr); }
+			set { Internal_setimportScale(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines what type (if any) of collision mesh should be imported. If enabled the collision mesh will be available 
+		/// as a sub-resource returned by the importer (along with the normal mesh).
+		/// </summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public CollisionMeshType CollisionMeshType
+		{
+			get { return Internal_getcollisionMeshType(mCachedPtr); }
+			set { Internal_setcollisionMeshType(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Animation split infos that determine how will the source animation clip be split. If no splits are present the  data 
+		/// will be imported as one clip, but if splits are present the data will be split according to the split infos. Split 
+		/// infos only affect the primary animation clip, other clips will not be split.
+		/// </summary>
+		[ShowInInspector]
+		[NotNull]
+		[PassByCopy]
+		[NativeWrapper]
+		public AnimationSplitInfo[] AnimationSplits
+		{
+			get { return Internal_getanimationSplits(mCachedPtr); }
+			set { Internal_setanimationSplits(mCachedPtr, value); }
+		}
+
+		/// <summary>Set of events that will be added to the animation clip, if animation import is enabled.</summary>
+		[ShowInInspector]
+		[NotNull]
+		[PassByCopy]
+		[NativeWrapper]
+		public ImportedAnimationEvents[] AnimationEvents
+		{
+			get { return Internal_getanimationEvents(mCachedPtr); }
+			set { Internal_setanimationEvents(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getcpuCached(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setcpuCached(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getimportNormals(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setimportNormals(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getimportTangents(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setimportTangents(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getimportBlendShapes(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setimportBlendShapes(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getimportSkin(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setimportSkin(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getimportAnimation(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setimportAnimation(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getreduceKeyFrames(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setreduceKeyFrames(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getimportRootMotion(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setimportRootMotion(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getimportScale(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setimportScale(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern CollisionMeshType Internal_getcollisionMeshType(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setcollisionMeshType(IntPtr thisPtr, CollisionMeshType value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern AnimationSplitInfo[] Internal_getanimationSplits(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setanimationSplits(IntPtr thisPtr, AnimationSplitInfo[] value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern ImportedAnimationEvents[] Internal_getanimationEvents(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setanimationEvents(IntPtr thisPtr, ImportedAnimationEvents[] value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_create(MeshImportOptions managedInstance);
+	}
+
+	/** @} */
+}

Source/EditorManaged/Generated/ScriptCodeImportOptions.editor.generated.cs

@@ -0,0 +1,46 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+	/** @addtogroup Importer
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Contains import options you may use to control how is a file containing script source code importer.
+	/// </summary>
+	[ShowInInspector]
+	public partial class ScriptCodeImportOptions : ImportOptions
+	{
+		private ScriptCodeImportOptions(bool __dummy0) { }
+
+		/// <summary>Creates a new import options object that allows you to customize how is script code imported.</summary>
+		public ScriptCodeImportOptions()
+		{
+			Internal_create(this);
+		}
+
+		/// <summary>Determines whether the script is editor-only or a normal game script.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool EditorScript
+		{
+			get { return Internal_geteditorScript(mCachedPtr); }
+			set { Internal_seteditorScript(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_geteditorScript(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_seteditorScript(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_create(ScriptCodeImportOptions managedInstance);
+	}
+
+	/** @} */
+}

Source/EditorManaged/Generated/ShaderImportOptions.editor.generated.cs

@@ -0,0 +1,82 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+	/** @addtogroup Importer
+	 *  @{
+	 */
+
+	/// <summary>Contains import options you may use to control how is a shader imported.</summary>
+	[ShowInInspector]
+	public partial class ShaderImportOptions : ImportOptions
+	{
+		private ShaderImportOptions(bool __dummy0) { }
+		protected ShaderImportOptions() { }
+
+		/// <summary>
+		/// Flags that control which shading languages should the BSL shader be converted into. This ultimately controls on  
+		/// which render backends it will be able to run on.
+		/// </summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public ShadingLanguageFlags Languages
+		{
+			get { return Internal_getlanguages(mCachedPtr); }
+			set { Internal_setlanguages(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Sets a define and its value. Replaces an existing define if one already exists with the provided name.
+		/// </summary>
+		/// <param name="define">Name of the define.</param>
+		/// <param name="value">Value to assign to the define.</param>
+		public void SetDefine(string define, string value)
+		{
+			Internal_setDefine(mCachedPtr, define, value);
+		}
+
+		/// <summary>Checks if the define exists and returns its value if it does.</summary>
+		/// <param name="define">Name of the define to get the value for.</param>
+		/// <param name="value">value of the define. Only defined if the method returns true.</param>
+		/// <returns>True if the define was found, false otherwise.</returns>
+		public bool GetDefine(string define, out string value)
+		{
+			return Internal_getDefine(mCachedPtr, define, out value);
+		}
+
+		/// <summary>Checks if the provided define exists.</summary>
+		/// <param name="define">Name of the define to check.</param>
+		/// <returns>True if the define was found, false otherwise.</returns>
+		public bool HasDefine(string define)
+		{
+			return Internal_hasDefine(mCachedPtr, define);
+		}
+
+		/// <summary>Unregisters a previously set define.</summary>
+		/// <param name="define">Name of the define to unregister.</param>
+		public void RemoveDefine(string define)
+		{
+			Internal_removeDefine(mCachedPtr, define);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setDefine(IntPtr thisPtr, string define, string value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getDefine(IntPtr thisPtr, string define, out string value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_hasDefine(IntPtr thisPtr, string define);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_removeDefine(IntPtr thisPtr, string define);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern ShadingLanguageFlags Internal_getlanguages(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setlanguages(IntPtr thisPtr, ShadingLanguageFlags value);
+	}
+
+	/** @} */
+}

Source/EditorManaged/Generated/ShadingLanguageFlag.editor.generated.cs

@@ -0,0 +1,28 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+	/** @addtogroup Importer
+	 *  @{
+	 */
+
+	/// <summary>Supported types of low-level shading languages.</summary>
+	public enum ShadingLanguageFlags
+	{
+		/// <summary>High level shading language used by DirectX backend.</summary>
+		HLSL = 1,
+		/// <summary>OpenGL shading language.</summary>
+		GLSL = 2,
+		/// <summary>Variant of GLSL used for Vulkan.</summary>
+		VKSL = 4,
+		/// <summary>Helper entry that includes all languages.</summary>
+		All = 7
+	}
+
+	/** @} */
+}

Source/EditorManaged/Generated/TextureImportOptions.editor.generated.cs

@@ -0,0 +1,133 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+	/** @addtogroup Importer
+	 *  @{
+	 */
+
+	/// <summary>Contains import options you may use to control how is a texture imported.</summary>
+	[ShowInInspector]
+	public partial class TextureImportOptions : ImportOptions
+	{
+		private TextureImportOptions(bool __dummy0) { }
+
+		/// <summary>Creates a new import options object that allows you to customize how are textures imported.</summary>
+		public TextureImportOptions()
+		{
+			Internal_create(this);
+		}
+
+		/// <summary>Pixel format to import as.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public PixelFormat Format
+		{
+			get { return Internal_getformat(mCachedPtr); }
+			set { Internal_setformat(mCachedPtr, value); }
+		}
+
+		/// <summary>Enables or disables mipmap generation for the texture.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool GenerateMips
+		{
+			get { return Internal_getgenerateMips(mCachedPtr); }
+			set { Internal_setgenerateMips(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Maximum mip level to generate when generating mipmaps. If 0 then maximum amount of mip levels will be generated.
+		/// </summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public int MaxMip
+		{
+			get { return Internal_getmaxMip(mCachedPtr); }
+			set { Internal_setmaxMip(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines whether the texture data is also stored in main memory, available for fast CPU access.</summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool CpuCached
+		{
+			get { return Internal_getcpuCached(mCachedPtr); }
+			set { Internal_setcpuCached(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines whether the texture data should be treated as if its in sRGB (gamma) space. Such texture will be  
+		/// converted by hardware to linear space before use on the GPU.
+		/// </summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool SRGB
+		{
+			get { return Internal_getsRGB(mCachedPtr); }
+			set { Internal_setsRGB(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines should the texture be imported as a cubemap. See setCubemapSource to choose how will the source texture be 
+		/// converted to a cubemap.
+		/// </summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public bool Cubemap
+		{
+			get { return Internal_getcubemap(mCachedPtr); }
+			set { Internal_setcubemap(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines how should the source texture be interpreted when generating a cubemap. Only relevant when <see 
+		/// cref="cubemap"/> is set to true.
+		/// </summary>
+		[ShowInInspector]
+		[NativeWrapper]
+		public CubemapSourceType CubemapSourceType
+		{
+			get { return Internal_getcubemapSourceType(mCachedPtr); }
+			set { Internal_setcubemapSourceType(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern PixelFormat Internal_getformat(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setformat(IntPtr thisPtr, PixelFormat value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getgenerateMips(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setgenerateMips(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int Internal_getmaxMip(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setmaxMip(IntPtr thisPtr, int value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getcpuCached(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setcpuCached(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getsRGB(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setsRGB(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getcubemap(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setcubemap(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern CubemapSourceType Internal_getcubemapSourceType(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setcubemapSourceType(IntPtr thisPtr, CubemapSourceType value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_create(TextureImportOptions managedInstance);
+	}
+
+	/** @} */
+}

Source/EditorManaged/Inspectors/AudioClipInspector.cs

@@ -30,7 +30,7 @@ namespace BansheeEditor
 
             formatField.OnSelectionChanged += x => importOptions.Format = (AudioFormat)x;
             readModeField.OnSelectionChanged += x => importOptions.ReadMode = (AudioReadMode)x;
-            bitDepthField.OnSelectionChanged += x => importOptions.BitDepth = (AudioBitDepth)x;
+            bitDepthField.OnSelectionChanged += x => importOptions.BitDepth = (int)x;
             is3DField.OnChanged += x => importOptions.Is3D = x;
 
             reimportButton.OnClick += TriggerReimport;

Source/EditorManaged/Inspectors/FontInspector.cs

@@ -51,7 +51,7 @@ namespace BansheeEditor
                     rebuildGUI |= newFontSizes.Length != fontSizes.Array.GetLength(0);
             }
 
-            CharRange[] newCharRanges = newImportOptions.CharRanges;
+            CharRange[] newCharRanges = newImportOptions.CharIndexRanges;
             if (newCharRanges == null)
                 rebuildGUI |= charRanges.Array != null;
             else
@@ -71,7 +71,7 @@ namespace BansheeEditor
             renderModeField.Value = (ulong)newImportOptions.RenderMode;
             boldField.Value = newImportOptions.Bold;
             italicField.Value = newImportOptions.Italic;
-            dpiField.Value = newImportOptions.DPI;
+            dpiField.Value = newImportOptions.Dpi;
             importOptions = newImportOptions;
 
             return InspectableState.NotModified;
@@ -91,8 +91,8 @@ namespace BansheeEditor
             fontSizes.OnExpand += x => Persistent.SetBool("fontSizes_Expanded", x);
 
             charRanges = GUIArrayField<CharRange, CharRangeArrayRow>.Create(
-                new LocEdString("Character ranges"), importOptions.CharRanges, Layout);
-            charRanges.OnChanged += x => importOptions.CharRanges = x;
+                new LocEdString("Character ranges"), importOptions.CharIndexRanges, Layout);
+            charRanges.OnChanged += x => importOptions.CharIndexRanges = x;
             charRanges.IsExpanded = Persistent.GetBool("charRanges_Expanded");
             charRanges.OnExpand += x => Persistent.SetBool("charRanges_Expanded", x);
 
@@ -106,7 +106,7 @@ namespace BansheeEditor
             italicField.OnChanged += x => importOptions.Italic = x;
 
             dpiField = new GUIIntField(new LocEdString("DPI"));
-            dpiField.OnChanged += x => importOptions.DPI = x;
+            dpiField.OnChanged += x => importOptions.Dpi = x;
 
             reimportButton = new GUIButton(new LocEdString("Reimport"));
             reimportButton.OnClick += TriggerReimport;

Source/EditorManaged/Inspectors/MeshInspector.cs

@@ -50,10 +50,10 @@ namespace BansheeEditor
             skinField.Value = newImportOptions.ImportSkin;
             blendShapesField.Value = newImportOptions.ImportBlendShapes;
             animationField.Value = newImportOptions.ImportAnimation;
-            scaleField.Value = newImportOptions.Scale;
-            cpuCachedField.Value = newImportOptions.CPUCached;
+            scaleField.Value = newImportOptions.ImportScale;
+            cpuCachedField.Value = newImportOptions.CpuCached;
             collisionMeshTypeField.Value = (ulong)newImportOptions.CollisionMeshType;
-            keyFrameReductionField.Value = newImportOptions.KeyframeReduction;
+            keyFrameReductionField.Value = newImportOptions.ReduceKeyFrames;
             rootMotionField.Value = newImportOptions.ImportRootMotion;
 
             importOptions = newImportOptions;
@@ -85,10 +85,10 @@ namespace BansheeEditor
             skinField.OnChanged += x => importOptions.ImportSkin = x;
             blendShapesField.OnChanged += x => importOptions.ImportBlendShapes = x;
             animationField.OnChanged += x => importOptions.ImportAnimation = x;
-            scaleField.OnChanged += x => importOptions.Scale = x;
-            cpuCachedField.OnChanged += x => importOptions.CPUCached = x;
+            scaleField.OnChanged += x => importOptions.ImportScale = x;
+            cpuCachedField.OnChanged += x => importOptions.CpuCached = x;
             collisionMeshTypeField.OnSelectionChanged += x => importOptions.CollisionMeshType = (CollisionMeshType)x;
-            keyFrameReductionField.OnChanged += x => importOptions.KeyframeReduction = x;
+            keyFrameReductionField.OnChanged += x => importOptions.ReduceKeyFrames = x;
             rootMotionField.OnChanged += x => importOptions.ImportRootMotion = x;
 
             reimportButton.OnClick += TriggerReimport;
@@ -104,7 +104,7 @@ namespace BansheeEditor
             Layout.AddElement(keyFrameReductionField);
             Layout.AddElement(rootMotionField);
 
-            splitInfos = importOptions.AnimationClipSplits;
+            splitInfos = importOptions.AnimationSplits;
 
             animSplitInfoField = GUIArrayField<AnimationSplitInfo, AnimSplitArrayRow>.Create(
                 new LocEdString("Animation splits"), splitInfos, Layout);
@@ -150,7 +150,7 @@ namespace BansheeEditor
         /// </summary>
         private void TriggerReimport()
         {
-            importOptions.AnimationClipSplits = splitInfos;
+            importOptions.AnimationSplits = splitInfos;
 
             ProjectLibrary.Reimport(InspectedResourcePath, importOptions, true);
         }
@@ -200,7 +200,7 @@ namespace BansheeEditor
                 nameField.OnChanged += x =>
                 {
                     AnimationSplitInfo splitInfo = GetValue<AnimationSplitInfo>();
-                    splitInfo.name = x;
+                    splitInfo.Name = x;
  
                     MarkAsModified();
                 };
@@ -211,7 +211,7 @@ namespace BansheeEditor
                 startFrameField.OnChanged += x =>
                 {
                     AnimationSplitInfo splitInfo = GetValue<AnimationSplitInfo>();
-                    splitInfo.startFrame = x;
+                    splitInfo.StartFrame = x;
 
                     MarkAsModified();
                 };
@@ -222,7 +222,7 @@ namespace BansheeEditor
                 endFrameField.OnChanged += x =>
                 {
                     AnimationSplitInfo splitInfo = GetValue<AnimationSplitInfo>();
-                    splitInfo.endFrame = x;
+                    splitInfo.EndFrame = x;
 
                     MarkAsModified();
                 };
@@ -233,7 +233,7 @@ namespace BansheeEditor
                 isAdditiveField.OnChanged += x =>
                 {
                     AnimationSplitInfo splitInfo = GetValue<AnimationSplitInfo>();
-                    splitInfo.isAdditive = x;
+                    splitInfo.IsAdditive = x;
 
                     MarkAsModified();
                     ConfirmModify();
@@ -249,10 +249,10 @@ namespace BansheeEditor
 
                 if (splitInfo != null)
                 {
-                    nameField.Value = splitInfo.name;
-                    startFrameField.Value = splitInfo.startFrame;
-                    endFrameField.Value = splitInfo.endFrame;
-                    isAdditiveField.Value = splitInfo.isAdditive;
+                    nameField.Value = splitInfo.Name;
+                    startFrameField.Value = splitInfo.StartFrame;
+                    endFrameField.Value = splitInfo.EndFrame;
+                    isAdditiveField.Value = splitInfo.IsAdditive;
                 }
 
                 return base.Refresh();

Source/EditorManaged/Inspectors/TextureInspector.cs

@@ -34,11 +34,11 @@ namespace BansheeEditor
             importOptions = GetImportOptions();
 
             formatField.OnSelectionChanged += x => importOptions.Format = (PixelFormat)x;
-            generateMipsField.OnChanged += x => importOptions.GenerateMipmaps = x;
-            maximumMipsField.OnChanged += x => importOptions.MaxMipmapLevel = x;
-            srgbField.OnChanged += x => importOptions.IsSRGB = x;
-            cpuCachedField.OnChanged += x => importOptions.CPUCached = x;
-            isCubemapField.OnChanged += x => importOptions.IsCubemap = x;
+            generateMipsField.OnChanged += x => importOptions.GenerateMips = x;
+            maximumMipsField.OnChanged += x => importOptions.MaxMip = x;
+            srgbField.OnChanged += x => importOptions.SRGB = x;
+            cpuCachedField.OnChanged += x => importOptions.CpuCached = x;
+            isCubemapField.OnChanged += x => importOptions.Cubemap = x;
             cubemapSourceTypeField.OnSelectionChanged += x => importOptions.CubemapSourceType = (CubemapSourceType)x;
             reimportButton.OnClick += TriggerReimport;
 
@@ -62,14 +62,14 @@ namespace BansheeEditor
             TextureImportOptions newImportOptions = GetImportOptions();
 
             formatField.Value = (ulong)newImportOptions.Format;
-            generateMipsField.Value = newImportOptions.GenerateMipmaps;
-            maximumMipsField.Value = newImportOptions.MaxMipmapLevel;
-            srgbField.Value = newImportOptions.IsSRGB;
-            cpuCachedField.Value = newImportOptions.CPUCached;
-            isCubemapField.Value = newImportOptions.IsCubemap;
+            generateMipsField.Value = newImportOptions.GenerateMips;
+            maximumMipsField.Value = newImportOptions.MaxMip;
+            srgbField.Value = newImportOptions.SRGB;
+            cpuCachedField.Value = newImportOptions.CpuCached;
+            isCubemapField.Value = newImportOptions.Cubemap;
             cubemapSourceTypeField.Value = (ulong) newImportOptions.CubemapSourceType;
 
-            cubemapSourceTypeField.Active = importOptions.IsCubemap;
+            cubemapSourceTypeField.Active = importOptions.Cubemap;
 
             importOptions = newImportOptions;
 

Source/EditorManaged/Windows/Animation/EditorAnimInfo.cs

@@ -536,9 +536,9 @@ namespace BansheeEditor
                     bool isExisting = false;
                     for (int i = 0; i < newEvents.Count; i++)
                     {
-                        if (newEvents[i].name == clipName)
+                        if (newEvents[i].Name == clipName)
                         {
-                            newEvents[i].events = events;
+                            newEvents[i].Events = events;
                             isExisting = true;
                             break;
                         }
@@ -547,8 +547,8 @@ namespace BansheeEditor
                     if (!isExisting)
                     {
                         ImportedAnimationEvents newEntry = new ImportedAnimationEvents();
-                        newEntry.name = clipName;
-                        newEntry.events = events;
+                        newEntry.Name = clipName;
+                        newEntry.Events = events;
 
                         newEvents.Add(newEntry);
                     }

Source/EditorManaged/Windows/Library/AudioImportOptions.cs

@@ -0,0 +1,16 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2019 Marko Pintera ([email protected]). All rights reserved. **********************//
+
+namespace BansheeEditor
+{
+    /// <summary>
+    /// Numbers of bits per audio sample.
+    /// </summary>
+    public enum AudioBitDepth
+    {
+        Bits8 = 8,
+        Bits16 = 16,
+        Bits24 = 24,
+        Bits32 = 32
+    }
+}

Source/EditorManaged/Windows/Library/ImportOptions.cs

@@ -1,697 +0,0 @@
-//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
-//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using BansheeEngine;
-
-namespace BansheeEditor
-{
-    /** @addtogroup Library
-     *  @{
-     */
-
-    /// <summary>
-    /// Base class for all import options. Allows control over how is a specific resource type imported.
-    /// </summary>
-    public class ImportOptions : ScriptObject
-    {
-
-    }
-
-    /// <summary>
-    /// Determines the type of the source image for generating cubemaps.
-    /// </summary>
-    public enum CubemapSourceType
-    {
-        /// <summary>
-        /// Source is a single image that will be replicated on all cubemap faces.
-        /// </summary>
-        Single,
-
-        /// <summary>
-        /// Source is a list of 6 images, either sequentially next to each other or in a cross format. The system will 
-        /// automatically guess the layout and orientation based on the aspect ratio.
-        /// </summary>
-        Faces,
-
-        /// <summary>
-        /// Source is a single spherical panoramic image.
-        /// </summary>
-        Spherical,
-
-        /// <summary>
-        /// Source is a single cylindrical panoramic image.
-        /// </summary>
-        Cylindrical
-    };
-
-    /// <summary>
-    /// Provides options for controlling how is a texture resource imported.
-    /// </summary>
-    public class TextureImportOptions : ImportOptions
-    {
-        /// <summary>
-        /// Creates new texture import options with default values.
-        /// </summary>
-        public TextureImportOptions()
-        {
-            Internal_CreateInstance(this);
-        }
-
-        /// <summary>
-        /// Pixel format to import as.
-        /// </summary>
-        public PixelFormat Format
-        {
-            get { return Internal_GetPixelFormat(mCachedPtr); }
-            set { Internal_SetPixelFormat(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Determines whether the imported texture will have mipmaps generated.
-        /// </summary>
-        public bool GenerateMipmaps
-        {
-            get { return Internal_GetGenerateMipmaps(mCachedPtr); }
-            set { Internal_SetGenerateMipmaps(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Maximum mipmap level to generate, if mipmap generation is enabled.
-        /// </summary>
-        public int MaxMipmapLevel
-        {
-            get { return Internal_GetMaxMipmapLevel(mCachedPtr); }
-            set { Internal_SetMaxMipmapLevel(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Determines whether the texture data is also stored in main memory, available for fast CPU access.
-        /// </summary>
-        public bool CPUCached
-        {
-            get { return Internal_GetCPUCached(mCachedPtr); }
-            set { Internal_SetCPUCached(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Determines should the texture data be treated as if its in sRGB (gamma) space. Such texture will be converted by
-        /// hardware to linear space before use on the GPU.
-        /// </summary>
-        public bool IsSRGB
-        {
-            get { return Internal_GetIsSRGB(mCachedPtr); }
-            set { Internal_SetIsSRGB(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Determines should the texture be imported as a cubemap. See <see cref="CubemapSourceType"/> to choose how will
-        /// the source texture be converted to a cubemap.
-        /// </summary>
-        public bool IsCubemap
-        {
-            get { return Internal_GetIsCubemap(mCachedPtr); }
-            set { Internal_SetIsCubemap(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Sets a value that determines how should the source texture be interpreted when generating a cubemap. Only
-        /// relevant when <see cref="IsCubemap"/> is set to true.
-        /// </summary>
-        public CubemapSourceType CubemapSourceType
-        {
-            get { return Internal_GetCubemapSourceType(mCachedPtr); }
-            set { Internal_SetCubemapSourceType(mCachedPtr, value); }
-        }
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_CreateInstance(TextureImportOptions instance);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern PixelFormat Internal_GetPixelFormat(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetPixelFormat(IntPtr thisPtr, PixelFormat value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool Internal_GetGenerateMipmaps(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetGenerateMipmaps(IntPtr thisPtr, bool value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern int Internal_GetMaxMipmapLevel(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetMaxMipmapLevel(IntPtr thisPtr, int value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool Internal_GetCPUCached(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetCPUCached(IntPtr thisPtr, bool value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool Internal_GetIsSRGB(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetIsSRGB(IntPtr thisPtr, bool value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool Internal_GetIsCubemap(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetIsCubemap(IntPtr thisPtr, bool value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern CubemapSourceType Internal_GetCubemapSourceType(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetCubemapSourceType(IntPtr thisPtr, CubemapSourceType value);
-    }
-
-    /// <summary>
-    /// Information about how to split an AnimationClip into multiple separate clips.
-    /// </summary>
-    public class AnimationSplitInfo
-    {
-        public AnimationSplitInfo() { }
-
-        public AnimationSplitInfo(string name, int startFrame, int endFrame, bool isAdditive)
-        {
-            this.name = name;
-            this.startFrame = startFrame;
-            this.endFrame = endFrame;
-            this.isAdditive = isAdditive;
-        }
-
-        public string name;
-        public int startFrame = 0;
-        public int endFrame = 0;
-        public bool isAdditive = false;
-    }
-
-    /// <summary>
-    /// A set of animation events that will be added to an animation clip during animation import.
-    /// </summary>
-    public class ImportedAnimationEvents
-    {
-        public string name;
-        public AnimationEvent[] events;
-    }
-    
-    /// <summary>
-    /// Provides options for controlling how is a mesh resource imported.
-    /// </summary>
-    public class MeshImportOptions : ImportOptions
-    {
-        /// <summary>
-        /// Creates new mesh import options with default values.
-        /// </summary>
-        public MeshImportOptions()
-        {
-            Internal_CreateInstance(this);
-        }
-
-        /// <summary>
-        /// Determines whether the mesh data is also stored in main memory, available for fast CPU access. 
-        /// </summary>
-        public bool CPUCached
-        {
-            get { return Internal_GetCPUCached(mCachedPtr); }
-            set { Internal_SetCPUCached(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Controls should mesh normals be imported if available.
-        /// </summary>
-        public bool ImportNormals
-        {
-            get { return Internal_GetImportNormals(mCachedPtr); }
-            set { Internal_SetImportNormals(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Controls should mesh tangents/bitangents be imported if available.
-        /// </summary>
-        public bool ImportTangents
-        {
-            get { return Internal_GetImportTangents(mCachedPtr); }
-            set { Internal_SetImportTangents(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Controls should mesh skin data like bone weights, indices and bind poses be imported if available.
-        /// </summary>
-        public bool ImportSkin
-        {
-            get { return Internal_GetImportSkin(mCachedPtr); }
-            set { Internal_SetImportSkin(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Controls should animation clips be imported if available.
-        /// </summary>
-        public bool ImportAnimation
-        {
-            get { return Internal_GetImportAnimation(mCachedPtr); }
-            set { Internal_SetImportAnimation(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Controls should mesh blend shapes be imported if available.
-        /// </summary>
-        public bool ImportBlendShapes
-        {
-            get { return Internal_GetImportBlendShapes(mCachedPtr); }
-            set { Internal_SetImportBlendShapes(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Uniformly scales the imported mesh by the specified value.
-        /// </summary>
-        public float Scale
-        {
-            get { return Internal_GetScale(mCachedPtr); }
-            set { Internal_SetScale(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Determines if keyframe reduction is enabled. Keyframe reduction will reduce the number of key-frames in an
-        /// animation clip by removing identical keyframes, and therefore reducing the size of the clip.
-        /// </summary>
-        public bool KeyframeReduction
-        {
-            get { return Internal_GetKeyFrameReduction(mCachedPtr); }
-            set { Internal_SetKeyFrameReduction(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Determines if import of root motion curves is enabled. When enabled, any animation curves in imported animations 
-        /// affecting the root bone will be available through a set of separate curves in AnimationClip, and they won't be
-        /// evaluated through normal animation process. Instead it is expected that the user evaluates the curves manually
-        /// and applies them as required.
-        /// </summary>
-        public bool ImportRootMotion
-        {
-            get { return Internal_GetRootMotion(mCachedPtr); }
-            set { Internal_SetRootMotion(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Controls what type (if any) of collision mesh should be imported.
-        /// </summary>
-        public CollisionMeshType CollisionMeshType
-        {
-            get { return (CollisionMeshType)Internal_GetCollisionMeshType(mCachedPtr); }
-            set { Internal_SetCollisionMeshType(mCachedPtr, (int)value); }
-        }
-
-        /// <summary>
-        /// Split information that allows you to split the animation clip contained in the mesh file into multiple separate
-        /// clips. The split always applies to the first clip in the file (if the file contains multiple), other clips are
-        /// imported as is.
-        /// </summary>
-        public AnimationSplitInfo[] AnimationClipSplits
-        {
-            get { return Internal_GetAnimationClipSplits(mCachedPtr); }
-            set { Internal_SetAnimationClipSplits(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// A set of events that will be added to the animation clip, if animation import is enabled.
-        /// </summary>
-        public ImportedAnimationEvents[] AnimationEvents
-        {
-            get { return Internal_GetAnimationEvents(mCachedPtr); }
-            set { Internal_SetAnimationEvents(mCachedPtr, value); }
-        }
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_CreateInstance(MeshImportOptions instance);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool Internal_GetCPUCached(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetCPUCached(IntPtr thisPtr, bool value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool Internal_GetImportNormals(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetImportNormals(IntPtr thisPtr, bool value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool Internal_GetImportTangents(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetImportTangents(IntPtr thisPtr, bool value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool Internal_GetImportSkin(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetImportSkin(IntPtr thisPtr, bool value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool Internal_GetImportAnimation(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetImportAnimation(IntPtr thisPtr, bool value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool Internal_GetImportBlendShapes(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetImportBlendShapes(IntPtr thisPtr, bool value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool Internal_GetKeyFrameReduction(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetKeyFrameReduction(IntPtr thisPtr, bool value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool Internal_GetRootMotion(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetRootMotion(IntPtr thisPtr, bool value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern AnimationSplitInfo[] Internal_GetAnimationClipSplits(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetAnimationClipSplits(IntPtr thisPtr, AnimationSplitInfo[] value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern ImportedAnimationEvents[] Internal_GetAnimationEvents(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetAnimationEvents(IntPtr thisPtr, ImportedAnimationEvents[] value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern float Internal_GetScale(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetScale(IntPtr thisPtr, float value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern int Internal_GetCollisionMeshType(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetCollisionMeshType(IntPtr thisPtr, int value);
-    }
-
-    /// <summary>
-    /// Controls what type of collision mesh should be imported during mesh import.
-    /// </summary>
-    public enum CollisionMeshType // Note: Must match C++ enum CollisionMeshImport
-    {
-        /// <summary>
-        /// No collision mesh will be imported.
-        /// </summary>
-        None,
-        /// <summary>
-        /// Normal triangle mesh will be imported.
-        /// </summary>
-        Normal,
-        /// <summary>
-        /// A convex hull will be generated from the source mesh.
-        /// </summary>
-        Convex
-    }
-
-    /// <summary>
-    /// Marks a range of characters in a font.
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential), SerializeObject]
-    public struct CharRange
-    {
-        public int start;
-        public int end;
-    }
-
-    /// <summary>
-    /// Import options that provide various options for controlling how is a font resource imported.
-    /// </summary>
-    public class FontImportOptions : ImportOptions
-    {
-        /// <summary>
-        /// Creates new font import options with default values.
-        /// </summary>
-        public FontImportOptions()
-        {
-            Internal_CreateInstance(this);
-        }
-
-        /// <summary>
-        /// Font sizes in points that are to be imported.
-        /// </summary>
-        public int[] FontSizes
-        {
-            get { return Internal_GetFontSizes(mCachedPtr); }
-            set { Internal_SetFontSizes(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Dots per inch resolution to use when rendering the characters into the texture.
-        /// </summary>
-        public int DPI
-        {
-            get { return Internal_GetDPI(mCachedPtr); }
-            set { Internal_SetDPI(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Determines rendering mode used when rendering the characters into the bitmap.
-        /// </summary>
-        public FontRenderMode RenderMode
-        {
-            get { return Internal_GetRenderMode(mCachedPtr); }
-            set { Internal_SetRenderMode(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Determines should the characters be rendered in bold style.
-        /// </summary>
-        public bool Bold
-        {
-            get { return Internal_GetBold(mCachedPtr); }
-            set { Internal_SetBold(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Determines should the characters be rendered in italic style.
-        /// </summary>
-        public bool Italic
-        {
-            get { return Internal_GetItalic(mCachedPtr); }
-            set { Internal_SetItalic(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Determines character ranges to import from the font. Ranges are defined as unicode numbers.
-        /// </summary>
-        public CharRange[] CharRanges
-        {
-            get { return Internal_GetCharRanges(mCachedPtr); }
-            set { Internal_SetCharRanges(mCachedPtr, value); }
-        }
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_CreateInstance(FontImportOptions instance);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern int[] Internal_GetFontSizes(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetFontSizes(IntPtr thisPtr, int[] value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern int Internal_GetDPI(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetDPI(IntPtr thisPtr, int value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern FontRenderMode Internal_GetRenderMode(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetRenderMode(IntPtr thisPtr, FontRenderMode value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool Internal_GetBold(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetBold(IntPtr thisPtr, bool value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool Internal_GetItalic(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetItalic(IntPtr thisPtr, bool value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern CharRange[] Internal_GetCharRanges(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetCharRanges(IntPtr thisPtr, CharRange[] value);
-    }
-
-    /// <summary>
-    /// Provides various options for controlling how is a script file imported.
-    /// </summary>
-    public class ScriptCodeImportOptions : ImportOptions
-    {
-        /// <summary>
-        /// Creates new script import options with default values.
-        /// </summary>
-        public ScriptCodeImportOptions()
-        {
-            Internal_CreateInstance(this);
-        }
-
-        /// <summary>
-        /// Determines whether the script is editor-only or a normal game script. Editor scripts are compiled in a separate
-        /// assembly and may reference editor specific functionality, but are not available in the final game code.
-        /// </summary>
-        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);
-    }
-
-    /// <summary>
-    /// Determines how is a font rendered into the bitmap texture.
-    /// </summary>
-    public enum FontRenderMode // Note: Must match C++ enum FontRenderMode
-    {
-        /// <summary>Render antialiased fonts without hinting (slightly more blurry).</summary>
-        Smooth,
-        /// <summary>Render non-antialiased fonts without hinting (slightly more blurry).</summary>
-        Raster,
-        /// <summary>Render antialiased fonts with hinting.</summary>
-        HintedSmooth,
-        /// <summary>Render non-antialiased fonts with hinting.</summary>
-        HintedRaster
-    }
-
-    /// <summary>
-    /// Numbers of bits per audio sample.
-    /// </summary>
-    public enum AudioBitDepth
-    {
-        Bits8 = 8,
-        Bits16 = 16,
-        Bits24 = 24,
-        Bits32 = 32
-    }
-
-    /// <summary>
-    /// Provides various options for controlling how is an audio clip file imported.
-    /// </summary>
-    public class AudioClipImportOptions : ImportOptions
-    {
-        /// <summary>
-        /// Creates new audio clip import options with default values.
-        /// </summary>
-        public AudioClipImportOptions()
-        {
-            Internal_CreateInstance(this);
-        }
-
-        /// <summary>
-        /// Format to import the audio clip as.
-        /// </summary>
-        public AudioFormat Format
-        {
-            get { return Internal_GetFormat(mCachedPtr); }
-            set { Internal_SetFormat(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Determines how is audio data loaded into memory.
-        /// </summary>
-        public AudioReadMode ReadMode
-        {
-            get { return Internal_GetReadMode(mCachedPtr); }
-            set { Internal_SetReadMode(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Determines will the clip be played as spatial (3D) audio or as normal audio.
-        /// </summary>
-        public bool Is3D
-        {
-            get { return Internal_GetIs3D(mCachedPtr); }
-            set { Internal_SetIs3D(mCachedPtr, value); }
-        }
-
-        /// <summary>
-        /// Size of a single sample in bits.
-        /// </summary>
-        public AudioBitDepth BitDepth
-        {
-            get
-            {
-                int bits = Internal_GetBitDepth(mCachedPtr);
-                switch (bits)
-                {
-                    case 8:
-                        return AudioBitDepth.Bits8;
-                    case 16:
-                        return AudioBitDepth.Bits16;
-                    case 24:
-                        return AudioBitDepth.Bits24;
-                    case 32:
-                        return AudioBitDepth.Bits32;
-                }
-
-                return AudioBitDepth.Bits16;
-            }
-
-            set { Internal_SetBitDepth(mCachedPtr, (int)value); }
-        }
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_CreateInstance(AudioClipImportOptions instance);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern AudioFormat Internal_GetFormat(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetFormat(IntPtr thisPtr, AudioFormat format);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern AudioReadMode Internal_GetReadMode(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetReadMode(IntPtr thisPtr, AudioReadMode readMode);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern bool Internal_GetIs3D(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetIs3D(IntPtr thisPtr, bool is3d);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern int Internal_GetBitDepth(IntPtr thisPtr);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetBitDepth(IntPtr thisPtr, int bitDepth);
-    }
-
-    /** @} */
-}

Source/EditorScript/BsEditorScriptLibrary.cpp

@@ -21,6 +21,16 @@ namespace bs
 		EngineScriptLibrary::initialize();
 
 		EditorScriptManager::startUp();
+		
+		mQuitRequestedEvent = gEditorApplication().onQuitRequested.connect([]()
+		{
+			EditorScriptManager::instance().quitRequested();
+		});
+	}
+
+	void EditorScriptLibrary::update()
+	{
+		EditorScriptManager::instance().update();
 	}
 
 	void EditorScriptLibrary::reload()
@@ -82,6 +92,8 @@ namespace bs
 
 	void EditorScriptLibrary::destroy()
 	{
+		mQuitRequestedEvent.disconnect();
+
 		GameObjectManager::instance().destroyQueuedObjects();
 
 		unloadAssemblies();

Source/EditorScript/BsEditorScriptLibrary.h

@@ -22,6 +22,9 @@ namespace bs
 		/** @copydoc ScriptLibrary::initialize */
 		void initialize() override;
 
+		/** @copydoc ScriptLibrary::update */
+		void update() override;
+
 		/** @copydoc ScriptLibrary::reload */
 		void reload() override;
 
@@ -40,11 +43,12 @@ namespace bs
 		/** Returns the singleton instance of this library. */
 		static EditorScriptLibrary& instance()
 		{
-			return static_cast<EditorScriptLibrary&>(*ScriptManager::instance()._getScriptLibrary());
+			return static_cast<EditorScriptLibrary&>(*ScriptManager::_getScriptLibrary());
 		}
 
 	private:
 		bool mScriptAssembliesLoaded;
+		HEvent mQuitRequestedEvent;
 	};
 
 	/** @} */

Source/EditorScript/BsGUITextureField.h

@@ -13,7 +13,7 @@ namespace bs
 	 */
 
 	/** Type that control what type of texture does a GUITexture field accept. */
-	enum class BS_SCRIPT_EXPORT(ed:true,m:GUI-Editor) GUITextureFieldType
+	enum class BS_SCRIPT_EXPORT(m:GUI-Editor,api:bed) GUITextureFieldType
 	{
 		Texture = 1,
 		SpriteTexture = 2,

Source/EditorScript/BsScriptEditorPlugin.cpp

@@ -1,33 +0,0 @@
-//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
-//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
-#include "BsScriptEditorPrerequisites.h"
-#include "BsEditorScriptManager.h"
-#include "BsEditorScriptLibrary.h"
-#include "Script/BsScriptManager.h"
-
-namespace bs
-{
-	extern "C" BS_SCR_BED_EXPORT const char* getPluginName()
-	{
-		static const char* pluginName = "EditorScript";
-		return pluginName;
-	}
-
-	extern "C" BS_SCR_BED_EXPORT void* loadPlugin()
-	{
-		SPtr<EditorScriptLibrary> library = bs_shared_ptr_new<EditorScriptLibrary>();
-		ScriptManager::instance()._setScriptLibrary(library);
-
-		return nullptr;
-	}
-
-	extern "C" BS_SCR_BED_EXPORT void updatePlugin()
-	{
-		EditorScriptManager::instance().update();
-	}
-
-	extern "C" BS_SCR_BED_EXPORT void quitRequested()
-	{
-		EditorScriptManager::instance().quitRequested();
-	}
-}

Source/EditorScript/BsScriptEditorPrerequisites.h

@@ -8,7 +8,7 @@
 // DLL export
 #if BS_PLATFORM == BS_PLATFORM_WIN32 // Windows
 #  if BS_COMPILER == BS_COMPILER_MSVC
-#    if defined(BS_STATIC_LIB)
+#    if defined(BS_SCR_BED_STATIC_LIB) || defined(BS_SBGEN)
 #      define BS_SCR_BED_EXPORT
 #    else
 #      if defined(BS_SCR_BED_EXPORTS)
@@ -18,7 +18,7 @@
 #      endif
 #	 endif
 #  else
-#    if defined(BS_STATIC_LIB)
+#    if defined(BS_SCR_BED_STATIC_LIB) || defined(BS_SBGEN)
 #      define BS_SCR_BED_EXPORT
 #    else
 #      if defined(BS_SCR_BED_EXPORTS)

Source/EditorScript/CMakeLists.txt

@@ -4,8 +4,10 @@ include(CMakeSources.cmake)
 file(GLOB BS_GENERATED_SCRIPT_H_FILES ${CMAKE_CURRENT_SOURCE_DIR}/Generated/*.h)
 file(GLOB BS_GENERATED_SCRIPT_CPP_FILES ${CMAKE_CURRENT_SOURCE_DIR}/Generated/*.cpp)
 
+source_group("Generated" FILES ${BS_GENERATED_SCRIPT_H_FILES} ${BS_GENERATED_SCRIPT_CPP_FILES})
+
 # Target
-add_library(EditorScript SHARED 
+add_library(EditorScript OBJECT 
 	${BS_EDITORSCRIPT_SRC} 
 	${BS_GENERATED_SCRIPT_H_FILES} 
 	${BS_GENERATED_SCRIPT_CPP_FILES})
@@ -14,14 +16,12 @@ add_library(EditorScript SHARED
 add_common_flags(EditorScript)
 	
 # Includes
-set(EditorScript_INC 
-	"./"
-	"./Generated")
+set(EditorScript_INC "./")
 
-target_include_directories(EditorScript PRIVATE ${EditorScript_INC})
+target_include_directories(EditorScript PUBLIC ${EditorScript_INC})
 	
 # Defines
-target_compile_definitions(EditorScript PRIVATE -DBS_SCR_BED_EXPORTS)
+target_compile_definitions(EditorScript PUBLIC -DBS_SCR_BED_STATIC_LIB)
 
 # Libraries
 ## Local libs

Source/EditorScript/CMakeSources.cmake

@@ -55,7 +55,6 @@ set(BS_EDITORSCRIPT_SRC_WRAPPERS
 	"Wrappers/BsScriptHandleSliderPlane.cpp"
 	"Wrappers/BsScriptHandleSliderSphere.cpp"
 	"Wrappers/BsScriptHandleSlider2D.cpp"
-	"Wrappers/BsScriptImportOptions.cpp"
 	"Wrappers/BsScriptInspectorUtility.cpp"
 	"Wrappers/BsScriptModalWindow.cpp"
 	"Wrappers/BsScriptOSDropTarget.cpp"
@@ -76,7 +75,6 @@ set(BS_EDITORSCRIPT_SRC_WRAPPERS
 )
 
 set(BS_EDITORSCRIPT_SRC_NOFILTER
-	"BsScriptEditorPlugin.cpp"
 	"BsGUIGameObjectField.cpp"
 	"BsGUIResourceField.cpp"
 	"BsEditorScriptManager.cpp"
@@ -118,7 +116,6 @@ set(BS_EDITORSCRIPT_INC_WRAPPERS
 	"Wrappers/BsScriptOSDropTarget.h"
 	"Wrappers/BsScriptModalWindow.h"
 	"Wrappers/BsScriptInspectorUtility.h"
-	"Wrappers/BsScriptImportOptions.h"
 	"Wrappers/BsScriptHandleSliderPlane.h"
 	"Wrappers/BsScriptHandleSliderManager.h"
 	"Wrappers/BsScriptHandleSliderLine.h"

Source/EditorScript/Generated/BsScriptAnimationSplitInfo.editor.generated.cpp

@@ -0,0 +1,121 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#include "BsScriptAnimationSplitInfo.editor.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../bsf/Source/Foundation/bsfCore/Importer/BsMeshImportOptions.h"
+
+namespace bs
+{
+	ScriptAnimationSplitInfo::ScriptAnimationSplitInfo(MonoObject* managedInstance, const SPtr<AnimationSplitInfo>& value)
+		:ScriptObject(managedInstance), mInternal(value)
+	{
+	}
+
+	void ScriptAnimationSplitInfo::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_AnimationSplitInfo", (void*)&ScriptAnimationSplitInfo::Internal_AnimationSplitInfo);
+		metaData.scriptClass->addInternalCall("Internal_AnimationSplitInfo0", (void*)&ScriptAnimationSplitInfo::Internal_AnimationSplitInfo0);
+		metaData.scriptClass->addInternalCall("Internal_getname", (void*)&ScriptAnimationSplitInfo::Internal_getname);
+		metaData.scriptClass->addInternalCall("Internal_setname", (void*)&ScriptAnimationSplitInfo::Internal_setname);
+		metaData.scriptClass->addInternalCall("Internal_getstartFrame", (void*)&ScriptAnimationSplitInfo::Internal_getstartFrame);
+		metaData.scriptClass->addInternalCall("Internal_setstartFrame", (void*)&ScriptAnimationSplitInfo::Internal_setstartFrame);
+		metaData.scriptClass->addInternalCall("Internal_getendFrame", (void*)&ScriptAnimationSplitInfo::Internal_getendFrame);
+		metaData.scriptClass->addInternalCall("Internal_setendFrame", (void*)&ScriptAnimationSplitInfo::Internal_setendFrame);
+		metaData.scriptClass->addInternalCall("Internal_getisAdditive", (void*)&ScriptAnimationSplitInfo::Internal_getisAdditive);
+		metaData.scriptClass->addInternalCall("Internal_setisAdditive", (void*)&ScriptAnimationSplitInfo::Internal_setisAdditive);
+
+	}
+
+	MonoObject* ScriptAnimationSplitInfo::create(const SPtr<AnimationSplitInfo>& value)
+	{
+		if(value == nullptr) return nullptr; 
+
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance("bool", ctorParams);
+		new (bs_alloc<ScriptAnimationSplitInfo>()) ScriptAnimationSplitInfo(managedInstance, value);
+		return managedInstance;
+	}
+	void ScriptAnimationSplitInfo::Internal_AnimationSplitInfo(MonoObject* managedInstance)
+	{
+		SPtr<AnimationSplitInfo> instance = bs_shared_ptr_new<AnimationSplitInfo>();
+		new (bs_alloc<ScriptAnimationSplitInfo>())ScriptAnimationSplitInfo(managedInstance, instance);
+	}
+
+	void ScriptAnimationSplitInfo::Internal_AnimationSplitInfo0(MonoObject* managedInstance, MonoString* name, uint32_t startFrame, uint32_t endFrame, bool isAdditive)
+	{
+		String tmpname;
+		tmpname = MonoUtil::monoToString(name);
+		SPtr<AnimationSplitInfo> instance = bs_shared_ptr_new<AnimationSplitInfo>(tmpname, startFrame, endFrame, isAdditive);
+		new (bs_alloc<ScriptAnimationSplitInfo>())ScriptAnimationSplitInfo(managedInstance, instance);
+	}
+
+	MonoString* ScriptAnimationSplitInfo::Internal_getname(ScriptAnimationSplitInfo* thisPtr)
+	{
+		String tmp__output;
+		tmp__output = thisPtr->getInternal()->name;
+
+		MonoString* __output;
+		__output = MonoUtil::stringToMono(tmp__output);
+
+		return __output;
+	}
+
+	void ScriptAnimationSplitInfo::Internal_setname(ScriptAnimationSplitInfo* thisPtr, MonoString* value)
+	{
+		String tmpvalue;
+		tmpvalue = MonoUtil::monoToString(value);
+		thisPtr->getInternal()->name = tmpvalue;
+	}
+
+	uint32_t ScriptAnimationSplitInfo::Internal_getstartFrame(ScriptAnimationSplitInfo* thisPtr)
+	{
+		uint32_t tmp__output;
+		tmp__output = thisPtr->getInternal()->startFrame;
+
+		uint32_t __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptAnimationSplitInfo::Internal_setstartFrame(ScriptAnimationSplitInfo* thisPtr, uint32_t value)
+	{
+		thisPtr->getInternal()->startFrame = value;
+	}
+
+	uint32_t ScriptAnimationSplitInfo::Internal_getendFrame(ScriptAnimationSplitInfo* thisPtr)
+	{
+		uint32_t tmp__output;
+		tmp__output = thisPtr->getInternal()->endFrame;
+
+		uint32_t __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptAnimationSplitInfo::Internal_setendFrame(ScriptAnimationSplitInfo* thisPtr, uint32_t value)
+	{
+		thisPtr->getInternal()->endFrame = value;
+	}
+
+	bool ScriptAnimationSplitInfo::Internal_getisAdditive(ScriptAnimationSplitInfo* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->isAdditive;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptAnimationSplitInfo::Internal_setisAdditive(ScriptAnimationSplitInfo* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->isAdditive = value;
+	}
+}

Source/EditorScript/Generated/BsScriptAnimationSplitInfo.editor.generated.h

@@ -0,0 +1,36 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptObject.h"
+
+namespace bs
+{
+	struct AnimationSplitInfo;
+
+	class BS_SCR_BED_EXPORT ScriptAnimationSplitInfo : public ScriptObject<ScriptAnimationSplitInfo>
+	{
+	public:
+		SCRIPT_OBJ(EDITOR_ASSEMBLY, EDITOR_NS, "AnimationSplitInfo")
+
+		ScriptAnimationSplitInfo(MonoObject* managedInstance, const SPtr<AnimationSplitInfo>& value);
+
+		SPtr<AnimationSplitInfo> getInternal() const { return mInternal; }
+		static MonoObject* create(const SPtr<AnimationSplitInfo>& value);
+
+	private:
+		SPtr<AnimationSplitInfo> mInternal;
+
+		static void Internal_AnimationSplitInfo(MonoObject* managedInstance);
+		static void Internal_AnimationSplitInfo0(MonoObject* managedInstance, MonoString* name, uint32_t startFrame, uint32_t endFrame, bool isAdditive);
+		static MonoString* Internal_getname(ScriptAnimationSplitInfo* thisPtr);
+		static void Internal_setname(ScriptAnimationSplitInfo* thisPtr, MonoString* value);
+		static uint32_t Internal_getstartFrame(ScriptAnimationSplitInfo* thisPtr);
+		static void Internal_setstartFrame(ScriptAnimationSplitInfo* thisPtr, uint32_t value);
+		static uint32_t Internal_getendFrame(ScriptAnimationSplitInfo* thisPtr);
+		static void Internal_setendFrame(ScriptAnimationSplitInfo* thisPtr, uint32_t value);
+		static bool Internal_getisAdditive(ScriptAnimationSplitInfo* thisPtr);
+		static void Internal_setisAdditive(ScriptAnimationSplitInfo* thisPtr, bool value);
+	};
+}

Source/EditorScript/Generated/BsScriptAudioClipImportOptions.editor.generated.cpp

@@ -0,0 +1,116 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#include "BsScriptAudioClipImportOptions.editor.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../bsf/Source/Foundation/bsfCore/Audio/BsAudioClipImportOptions.h"
+#include "BsScriptAudioClipImportOptions.editor.generated.h"
+
+namespace bs
+{
+	ScriptAudioClipImportOptions::ScriptAudioClipImportOptions(MonoObject* managedInstance, const SPtr<AudioClipImportOptions>& value)
+		:ScriptObject(managedInstance)
+	{
+		mInternal = value;
+	}
+
+	SPtr<AudioClipImportOptions> ScriptAudioClipImportOptions::getInternal() const 
+	{
+		return std::static_pointer_cast<AudioClipImportOptions>(mInternal);
+	}
+
+	void ScriptAudioClipImportOptions::initRuntimeData()
+	{
+		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);
+		metaData.scriptClass->addInternalCall("Internal_create", (void*)&ScriptAudioClipImportOptions::Internal_create);
+
+	}
+
+	MonoObject* ScriptAudioClipImportOptions::create(const SPtr<AudioClipImportOptions>& value)
+	{
+		if(value == nullptr) return nullptr; 
+
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance("bool", ctorParams);
+		new (bs_alloc<ScriptAudioClipImportOptions>()) ScriptAudioClipImportOptions(managedInstance, value);
+		return managedInstance;
+	}
+	void ScriptAudioClipImportOptions::Internal_create(MonoObject* managedInstance)
+	{
+		SPtr<AudioClipImportOptions> instance = AudioClipImportOptions::create();
+		new (bs_alloc<ScriptAudioClipImportOptions>())ScriptAudioClipImportOptions(managedInstance, instance);
+	}
+	AudioFormat ScriptAudioClipImportOptions::Internal_getformat(ScriptAudioClipImportOptions* thisPtr)
+	{
+		AudioFormat tmp__output;
+		tmp__output = thisPtr->getInternal()->format;
+
+		AudioFormat __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptAudioClipImportOptions::Internal_setformat(ScriptAudioClipImportOptions* thisPtr, AudioFormat value)
+	{
+		thisPtr->getInternal()->format = value;
+	}
+
+	AudioReadMode ScriptAudioClipImportOptions::Internal_getreadMode(ScriptAudioClipImportOptions* thisPtr)
+	{
+		AudioReadMode tmp__output;
+		tmp__output = thisPtr->getInternal()->readMode;
+
+		AudioReadMode __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptAudioClipImportOptions::Internal_setreadMode(ScriptAudioClipImportOptions* thisPtr, AudioReadMode value)
+	{
+		thisPtr->getInternal()->readMode = value;
+	}
+
+	bool ScriptAudioClipImportOptions::Internal_getis3D(ScriptAudioClipImportOptions* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->is3D;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptAudioClipImportOptions::Internal_setis3D(ScriptAudioClipImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->is3D = value;
+	}
+
+	uint32_t ScriptAudioClipImportOptions::Internal_getbitDepth(ScriptAudioClipImportOptions* thisPtr)
+	{
+		uint32_t tmp__output;
+		tmp__output = thisPtr->getInternal()->bitDepth;
+
+		uint32_t __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptAudioClipImportOptions::Internal_setbitDepth(ScriptAudioClipImportOptions* thisPtr, uint32_t value)
+	{
+		thisPtr->getInternal()->bitDepth = value;
+	}
+}

Source/EditorScript/Generated/BsScriptAudioClipImportOptions.editor.generated.h

@@ -0,0 +1,36 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptObject.h"
+#include "BsScriptImportOptions.editor.generated.h"
+#include "../../bsf/Source/Foundation/bsfCore/Audio/BsAudioClip.h"
+#include "../../bsf/Source/Foundation/bsfCore/Audio/BsAudioClip.h"
+
+namespace bs
+{
+	class AudioClipImportOptions;
+
+	class BS_SCR_BED_EXPORT ScriptAudioClipImportOptions : public ScriptObject<ScriptAudioClipImportOptions, ScriptImportOptionsBase>
+	{
+	public:
+		SCRIPT_OBJ(EDITOR_ASSEMBLY, EDITOR_NS, "AudioClipImportOptions")
+
+		ScriptAudioClipImportOptions(MonoObject* managedInstance, const SPtr<AudioClipImportOptions>& value);
+
+		SPtr<AudioClipImportOptions> getInternal() const;
+		static MonoObject* create(const SPtr<AudioClipImportOptions>& value);
+
+	private:
+		static AudioFormat Internal_getformat(ScriptAudioClipImportOptions* thisPtr);
+		static void Internal_setformat(ScriptAudioClipImportOptions* thisPtr, AudioFormat value);
+		static AudioReadMode Internal_getreadMode(ScriptAudioClipImportOptions* thisPtr);
+		static void Internal_setreadMode(ScriptAudioClipImportOptions* thisPtr, AudioReadMode value);
+		static bool Internal_getis3D(ScriptAudioClipImportOptions* thisPtr);
+		static void Internal_setis3D(ScriptAudioClipImportOptions* thisPtr, bool value);
+		static uint32_t Internal_getbitDepth(ScriptAudioClipImportOptions* thisPtr);
+		static void Internal_setbitDepth(ScriptAudioClipImportOptions* thisPtr, uint32_t value);
+		static void Internal_create(MonoObject* managedInstance);
+	};
+}

Source/EditorScript/Generated/BsScriptCharRange.editor.generated.cpp

@@ -0,0 +1,27 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#include "BsScriptCharRange.editor.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+
+namespace bs
+{
+	ScriptCharRange::ScriptCharRange(MonoObject* managedInstance)
+		:ScriptObject(managedInstance)
+	{ }
+
+	void ScriptCharRange::initRuntimeData()
+	{ }
+
+	MonoObject*ScriptCharRange::box(const CharRange& value)
+	{
+		return MonoUtil::box(metaData.scriptClass->_getInternalClass(), (void*)&value);
+	}
+
+	CharRange ScriptCharRange::unbox(MonoObject* value)
+	{
+		return *(CharRange*)MonoUtil::unbox(value);
+	}
+
+}

Source/EditorScript/Generated/BsScriptCharRange.editor.generated.h

@@ -0,0 +1,23 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptObject.h"
+#include "../../bsf/Source/Foundation/bsfCore/Text/BsFontImportOptions.h"
+
+namespace bs
+{
+	class BS_SCR_BED_EXPORT ScriptCharRange : public ScriptObject<ScriptCharRange>
+	{
+	public:
+		SCRIPT_OBJ(EDITOR_ASSEMBLY, EDITOR_NS, "CharRange")
+
+		static MonoObject* box(const CharRange& value);
+		static CharRange unbox(MonoObject* value);
+
+	private:
+		ScriptCharRange(MonoObject* managedInstance);
+
+	};
+}

Source/EditorScript/Generated/BsScriptFontImportOptions.editor.generated.cpp

@@ -0,0 +1,187 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#include "BsScriptFontImportOptions.editor.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../bsf/Source/Foundation/bsfCore/Text/BsFontImportOptions.h"
+#include "BsScriptCharRange.editor.generated.h"
+#include "BsScriptFontImportOptions.editor.generated.h"
+
+namespace bs
+{
+	ScriptFontImportOptions::ScriptFontImportOptions(MonoObject* managedInstance, const SPtr<FontImportOptions>& value)
+		:ScriptObject(managedInstance)
+	{
+		mInternal = value;
+	}
+
+	SPtr<FontImportOptions> ScriptFontImportOptions::getInternal() const 
+	{
+		return std::static_pointer_cast<FontImportOptions>(mInternal);
+	}
+
+	void ScriptFontImportOptions::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_getfontSizes", (void*)&ScriptFontImportOptions::Internal_getfontSizes);
+		metaData.scriptClass->addInternalCall("Internal_setfontSizes", (void*)&ScriptFontImportOptions::Internal_setfontSizes);
+		metaData.scriptClass->addInternalCall("Internal_getcharIndexRanges", (void*)&ScriptFontImportOptions::Internal_getcharIndexRanges);
+		metaData.scriptClass->addInternalCall("Internal_setcharIndexRanges", (void*)&ScriptFontImportOptions::Internal_setcharIndexRanges);
+		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_create", (void*)&ScriptFontImportOptions::Internal_create);
+
+	}
+
+	MonoObject* ScriptFontImportOptions::create(const SPtr<FontImportOptions>& value)
+	{
+		if(value == nullptr) return nullptr; 
+
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance("bool", ctorParams);
+		new (bs_alloc<ScriptFontImportOptions>()) ScriptFontImportOptions(managedInstance, value);
+		return managedInstance;
+	}
+	void ScriptFontImportOptions::Internal_create(MonoObject* managedInstance)
+	{
+		SPtr<FontImportOptions> instance = FontImportOptions::create();
+		new (bs_alloc<ScriptFontImportOptions>())ScriptFontImportOptions(managedInstance, instance);
+	}
+	MonoArray* ScriptFontImportOptions::Internal_getfontSizes(ScriptFontImportOptions* thisPtr)
+	{
+		Vector<uint32_t> vec__output;
+		vec__output = thisPtr->getInternal()->fontSizes;
+
+		MonoArray* __output;
+		int arraySize__output = (int)vec__output.size();
+		ScriptArray array__output = ScriptArray::create<uint32_t>(arraySize__output);
+		for(int i = 0; i < arraySize__output; i++)
+		{
+			array__output.set(i, vec__output[i]);
+		}
+		__output = array__output.getInternal();
+
+		return __output;
+	}
+
+	void ScriptFontImportOptions::Internal_setfontSizes(ScriptFontImportOptions* thisPtr, MonoArray* value)
+	{
+		Vector<uint32_t> vecvalue;
+		if(value != nullptr)
+		{
+			ScriptArray arrayvalue(value);
+			vecvalue.resize(arrayvalue.size());
+			for(int i = 0; i < (int)arrayvalue.size(); i++)
+			{
+				vecvalue[i] = arrayvalue.get<uint32_t>(i);
+			}
+
+		}
+		thisPtr->getInternal()->fontSizes = vecvalue;
+	}
+
+	MonoArray* ScriptFontImportOptions::Internal_getcharIndexRanges(ScriptFontImportOptions* thisPtr)
+	{
+		Vector<CharRange> vec__output;
+		vec__output = thisPtr->getInternal()->charIndexRanges;
+
+		MonoArray* __output;
+		int arraySize__output = (int)vec__output.size();
+		ScriptArray array__output = ScriptArray::create<ScriptCharRange>(arraySize__output);
+		for(int i = 0; i < arraySize__output; i++)
+		{
+			array__output.set(i, vec__output[i]);
+		}
+		__output = array__output.getInternal();
+
+		return __output;
+	}
+
+	void ScriptFontImportOptions::Internal_setcharIndexRanges(ScriptFontImportOptions* thisPtr, MonoArray* value)
+	{
+		Vector<CharRange> vecvalue;
+		if(value != nullptr)
+		{
+			ScriptArray arrayvalue(value);
+			vecvalue.resize(arrayvalue.size());
+			for(int i = 0; i < (int)arrayvalue.size(); i++)
+			{
+				vecvalue[i] = arrayvalue.get<CharRange>(i);
+			}
+
+		}
+		thisPtr->getInternal()->charIndexRanges = vecvalue;
+	}
+
+	uint32_t ScriptFontImportOptions::Internal_getdpi(ScriptFontImportOptions* thisPtr)
+	{
+		uint32_t tmp__output;
+		tmp__output = thisPtr->getInternal()->dpi;
+
+		uint32_t __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptFontImportOptions::Internal_setdpi(ScriptFontImportOptions* thisPtr, uint32_t value)
+	{
+		thisPtr->getInternal()->dpi = value;
+	}
+
+	FontRenderMode ScriptFontImportOptions::Internal_getrenderMode(ScriptFontImportOptions* thisPtr)
+	{
+		FontRenderMode tmp__output;
+		tmp__output = thisPtr->getInternal()->renderMode;
+
+		FontRenderMode __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptFontImportOptions::Internal_setrenderMode(ScriptFontImportOptions* thisPtr, FontRenderMode value)
+	{
+		thisPtr->getInternal()->renderMode = value;
+	}
+
+	bool ScriptFontImportOptions::Internal_getbold(ScriptFontImportOptions* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->bold;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptFontImportOptions::Internal_setbold(ScriptFontImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->bold = value;
+	}
+
+	bool ScriptFontImportOptions::Internal_getitalic(ScriptFontImportOptions* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->italic;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptFontImportOptions::Internal_setitalic(ScriptFontImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->italic = value;
+	}
+}

Source/EditorScript/Generated/BsScriptFontImportOptions.editor.generated.h

@@ -0,0 +1,40 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptObject.h"
+#include "BsScriptImportOptions.editor.generated.h"
+#include "../../bsf/Source/Foundation/bsfCore/Text/BsFontImportOptions.h"
+#include "../../bsf/Source/Foundation/bsfCore/Text/BsFontImportOptions.h"
+
+namespace bs
+{
+	class FontImportOptions;
+
+	class BS_SCR_BED_EXPORT ScriptFontImportOptions : public ScriptObject<ScriptFontImportOptions, ScriptImportOptionsBase>
+	{
+	public:
+		SCRIPT_OBJ(EDITOR_ASSEMBLY, EDITOR_NS, "FontImportOptions")
+
+		ScriptFontImportOptions(MonoObject* managedInstance, const SPtr<FontImportOptions>& value);
+
+		SPtr<FontImportOptions> getInternal() const;
+		static MonoObject* create(const SPtr<FontImportOptions>& value);
+
+	private:
+		static MonoArray* Internal_getfontSizes(ScriptFontImportOptions* thisPtr);
+		static void Internal_setfontSizes(ScriptFontImportOptions* thisPtr, MonoArray* value);
+		static MonoArray* Internal_getcharIndexRanges(ScriptFontImportOptions* thisPtr);
+		static void Internal_setcharIndexRanges(ScriptFontImportOptions* thisPtr, MonoArray* value);
+		static uint32_t Internal_getdpi(ScriptFontImportOptions* thisPtr);
+		static void Internal_setdpi(ScriptFontImportOptions* thisPtr, uint32_t value);
+		static FontRenderMode Internal_getrenderMode(ScriptFontImportOptions* thisPtr);
+		static void Internal_setrenderMode(ScriptFontImportOptions* thisPtr, FontRenderMode value);
+		static bool Internal_getbold(ScriptFontImportOptions* thisPtr);
+		static void Internal_setbold(ScriptFontImportOptions* thisPtr, bool value);
+		static bool Internal_getitalic(ScriptFontImportOptions* thisPtr);
+		static void Internal_setitalic(ScriptFontImportOptions* thisPtr, bool value);
+		static void Internal_create(MonoObject* managedInstance);
+	};
+}

Source/EditorScript/Generated/BsScriptImportOptions.editor.generated.cpp

@@ -0,0 +1,42 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#include "BsScriptImportOptions.editor.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../bsf/Source/Foundation/bsfCore/Importer/BsImportOptions.h"
+
+namespace bs
+{
+	ScriptImportOptionsBase::ScriptImportOptionsBase(MonoObject* managedInstance)
+		:ScriptObjectBase(managedInstance)
+	 { }
+
+	ScriptImportOptions::ScriptImportOptions(MonoObject* managedInstance, const SPtr<ImportOptions>& value)
+		:ScriptObject(managedInstance)
+	{
+		mInternal = value;
+	}
+
+	SPtr<ImportOptions> ScriptImportOptions::getInternal() const 
+	{
+		return std::static_pointer_cast<ImportOptions>(mInternal);
+	}
+
+	void ScriptImportOptions::initRuntimeData()
+	{
+
+	}
+
+	MonoObject* ScriptImportOptions::create(const SPtr<ImportOptions>& value)
+	{
+		if(value == nullptr) return nullptr; 
+
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance("bool", ctorParams);
+		new (bs_alloc<ScriptImportOptions>()) ScriptImportOptions(managedInstance, value);
+		return managedInstance;
+	}
+}

Source/EditorScript/Generated/BsScriptImportOptions.editor.generated.h

@@ -0,0 +1,35 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptObject.h"
+
+namespace bs
+{
+	class ImportOptions;
+
+	class BS_SCR_BED_EXPORT ScriptImportOptionsBase : public ScriptObjectBase
+	{
+	public:
+		ScriptImportOptionsBase(MonoObject* instance);
+		virtual ~ScriptImportOptionsBase() {}
+
+		SPtr<ImportOptions> getInternal() const { return mInternal; }
+	protected:
+		SPtr<ImportOptions> mInternal;
+	};
+
+	class BS_SCR_BED_EXPORT ScriptImportOptions : public ScriptObject<ScriptImportOptions, ScriptImportOptionsBase>
+	{
+	public:
+		SCRIPT_OBJ(EDITOR_ASSEMBLY, EDITOR_NS, "ImportOptions")
+
+		ScriptImportOptions(MonoObject* managedInstance, const SPtr<ImportOptions>& value);
+
+		SPtr<ImportOptions> getInternal() const;
+		static MonoObject* create(const SPtr<ImportOptions>& value);
+
+	private:
+	};
+}

Source/EditorScript/Generated/BsScriptImportedAnimationEvents.editor.generated.cpp

@@ -0,0 +1,94 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#include "BsScriptImportedAnimationEvents.editor.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../bsf/Source/Foundation/bsfCore/Importer/BsMeshImportOptions.h"
+#include "BsScriptAnimationEvent.generated.h"
+
+namespace bs
+{
+	ScriptImportedAnimationEvents::ScriptImportedAnimationEvents(MonoObject* managedInstance, const SPtr<ImportedAnimationEvents>& value)
+		:ScriptObject(managedInstance), mInternal(value)
+	{
+	}
+
+	void ScriptImportedAnimationEvents::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_ImportedAnimationEvents", (void*)&ScriptImportedAnimationEvents::Internal_ImportedAnimationEvents);
+		metaData.scriptClass->addInternalCall("Internal_getname", (void*)&ScriptImportedAnimationEvents::Internal_getname);
+		metaData.scriptClass->addInternalCall("Internal_setname", (void*)&ScriptImportedAnimationEvents::Internal_setname);
+		metaData.scriptClass->addInternalCall("Internal_getevents", (void*)&ScriptImportedAnimationEvents::Internal_getevents);
+		metaData.scriptClass->addInternalCall("Internal_setevents", (void*)&ScriptImportedAnimationEvents::Internal_setevents);
+
+	}
+
+	MonoObject* ScriptImportedAnimationEvents::create(const SPtr<ImportedAnimationEvents>& value)
+	{
+		if(value == nullptr) return nullptr; 
+
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance("bool", ctorParams);
+		new (bs_alloc<ScriptImportedAnimationEvents>()) ScriptImportedAnimationEvents(managedInstance, value);
+		return managedInstance;
+	}
+	void ScriptImportedAnimationEvents::Internal_ImportedAnimationEvents(MonoObject* managedInstance)
+	{
+		SPtr<ImportedAnimationEvents> instance = bs_shared_ptr_new<ImportedAnimationEvents>();
+		new (bs_alloc<ScriptImportedAnimationEvents>())ScriptImportedAnimationEvents(managedInstance, instance);
+	}
+
+	MonoString* ScriptImportedAnimationEvents::Internal_getname(ScriptImportedAnimationEvents* thisPtr)
+	{
+		String tmp__output;
+		tmp__output = thisPtr->getInternal()->name;
+
+		MonoString* __output;
+		__output = MonoUtil::stringToMono(tmp__output);
+
+		return __output;
+	}
+
+	void ScriptImportedAnimationEvents::Internal_setname(ScriptImportedAnimationEvents* thisPtr, MonoString* value)
+	{
+		String tmpvalue;
+		tmpvalue = MonoUtil::monoToString(value);
+		thisPtr->getInternal()->name = tmpvalue;
+	}
+
+	MonoArray* ScriptImportedAnimationEvents::Internal_getevents(ScriptImportedAnimationEvents* thisPtr)
+	{
+		Vector<AnimationEvent> vec__output;
+		vec__output = thisPtr->getInternal()->events;
+
+		MonoArray* __output;
+		int arraySize__output = (int)vec__output.size();
+		ScriptArray array__output = ScriptArray::create<ScriptAnimationEvent>(arraySize__output);
+		for(int i = 0; i < arraySize__output; i++)
+		{
+			array__output.set(i, ScriptAnimationEvent::toInterop(vec__output[i]));
+		}
+		__output = array__output.getInternal();
+
+		return __output;
+	}
+
+	void ScriptImportedAnimationEvents::Internal_setevents(ScriptImportedAnimationEvents* thisPtr, MonoArray* value)
+	{
+		Vector<AnimationEvent> vecvalue;
+		if(value != nullptr)
+		{
+			ScriptArray arrayvalue(value);
+			vecvalue.resize(arrayvalue.size());
+			for(int i = 0; i < (int)arrayvalue.size(); i++)
+			{
+				vecvalue[i] = ScriptAnimationEvent::fromInterop(arrayvalue.get<__AnimationEventInterop>(i));
+			}
+
+		}
+		thisPtr->getInternal()->events = vecvalue;
+	}
+}

Source/EditorScript/Generated/BsScriptImportedAnimationEvents.editor.generated.h

@@ -0,0 +1,33 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptObject.h"
+#include "../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationClip.h"
+
+namespace bs
+{
+	struct ImportedAnimationEvents;
+	struct __AnimationEventInterop;
+
+	class BS_SCR_BED_EXPORT ScriptImportedAnimationEvents : public ScriptObject<ScriptImportedAnimationEvents>
+	{
+	public:
+		SCRIPT_OBJ(EDITOR_ASSEMBLY, EDITOR_NS, "ImportedAnimationEvents")
+
+		ScriptImportedAnimationEvents(MonoObject* managedInstance, const SPtr<ImportedAnimationEvents>& value);
+
+		SPtr<ImportedAnimationEvents> getInternal() const { return mInternal; }
+		static MonoObject* create(const SPtr<ImportedAnimationEvents>& value);
+
+	private:
+		SPtr<ImportedAnimationEvents> mInternal;
+
+		static void Internal_ImportedAnimationEvents(MonoObject* managedInstance);
+		static MonoString* Internal_getname(ScriptImportedAnimationEvents* thisPtr);
+		static void Internal_setname(ScriptImportedAnimationEvents* thisPtr, MonoString* value);
+		static MonoArray* Internal_getevents(ScriptImportedAnimationEvents* thisPtr);
+		static void Internal_setevents(ScriptImportedAnimationEvents* thisPtr, MonoArray* value);
+	};
+}

Source/EditorScript/Generated/BsScriptMeshImportOptions.editor.generated.cpp

@@ -0,0 +1,318 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#include "BsScriptMeshImportOptions.editor.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../bsf/Source/Foundation/bsfCore/Importer/BsMeshImportOptions.h"
+#include "BsScriptAnimationSplitInfo.editor.generated.h"
+#include "BsScriptImportedAnimationEvents.editor.generated.h"
+#include "BsScriptMeshImportOptions.editor.generated.h"
+
+namespace bs
+{
+	ScriptMeshImportOptions::ScriptMeshImportOptions(MonoObject* managedInstance, const SPtr<MeshImportOptions>& value)
+		:ScriptObject(managedInstance)
+	{
+		mInternal = value;
+	}
+
+	SPtr<MeshImportOptions> ScriptMeshImportOptions::getInternal() const 
+	{
+		return std::static_pointer_cast<MeshImportOptions>(mInternal);
+	}
+
+	void ScriptMeshImportOptions::initRuntimeData()
+	{
+		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_getimportBlendShapes", (void*)&ScriptMeshImportOptions::Internal_getimportBlendShapes);
+		metaData.scriptClass->addInternalCall("Internal_setimportBlendShapes", (void*)&ScriptMeshImportOptions::Internal_setimportBlendShapes);
+		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_getreduceKeyFrames", (void*)&ScriptMeshImportOptions::Internal_getreduceKeyFrames);
+		metaData.scriptClass->addInternalCall("Internal_setreduceKeyFrames", (void*)&ScriptMeshImportOptions::Internal_setreduceKeyFrames);
+		metaData.scriptClass->addInternalCall("Internal_getimportRootMotion", (void*)&ScriptMeshImportOptions::Internal_getimportRootMotion);
+		metaData.scriptClass->addInternalCall("Internal_setimportRootMotion", (void*)&ScriptMeshImportOptions::Internal_setimportRootMotion);
+		metaData.scriptClass->addInternalCall("Internal_getimportScale", (void*)&ScriptMeshImportOptions::Internal_getimportScale);
+		metaData.scriptClass->addInternalCall("Internal_setimportScale", (void*)&ScriptMeshImportOptions::Internal_setimportScale);
+		metaData.scriptClass->addInternalCall("Internal_getcollisionMeshType", (void*)&ScriptMeshImportOptions::Internal_getcollisionMeshType);
+		metaData.scriptClass->addInternalCall("Internal_setcollisionMeshType", (void*)&ScriptMeshImportOptions::Internal_setcollisionMeshType);
+		metaData.scriptClass->addInternalCall("Internal_getanimationSplits", (void*)&ScriptMeshImportOptions::Internal_getanimationSplits);
+		metaData.scriptClass->addInternalCall("Internal_setanimationSplits", (void*)&ScriptMeshImportOptions::Internal_setanimationSplits);
+		metaData.scriptClass->addInternalCall("Internal_getanimationEvents", (void*)&ScriptMeshImportOptions::Internal_getanimationEvents);
+		metaData.scriptClass->addInternalCall("Internal_setanimationEvents", (void*)&ScriptMeshImportOptions::Internal_setanimationEvents);
+		metaData.scriptClass->addInternalCall("Internal_create", (void*)&ScriptMeshImportOptions::Internal_create);
+
+	}
+
+	MonoObject* ScriptMeshImportOptions::create(const SPtr<MeshImportOptions>& value)
+	{
+		if(value == nullptr) return nullptr; 
+
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance("bool", ctorParams);
+		new (bs_alloc<ScriptMeshImportOptions>()) ScriptMeshImportOptions(managedInstance, value);
+		return managedInstance;
+	}
+	void ScriptMeshImportOptions::Internal_create(MonoObject* managedInstance)
+	{
+		SPtr<MeshImportOptions> instance = MeshImportOptions::create();
+		new (bs_alloc<ScriptMeshImportOptions>())ScriptMeshImportOptions(managedInstance, instance);
+	}
+	bool ScriptMeshImportOptions::Internal_getcpuCached(ScriptMeshImportOptions* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->cpuCached;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptMeshImportOptions::Internal_setcpuCached(ScriptMeshImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->cpuCached = value;
+	}
+
+	bool ScriptMeshImportOptions::Internal_getimportNormals(ScriptMeshImportOptions* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->importNormals;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptMeshImportOptions::Internal_setimportNormals(ScriptMeshImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->importNormals = value;
+	}
+
+	bool ScriptMeshImportOptions::Internal_getimportTangents(ScriptMeshImportOptions* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->importTangents;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptMeshImportOptions::Internal_setimportTangents(ScriptMeshImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->importTangents = value;
+	}
+
+	bool ScriptMeshImportOptions::Internal_getimportBlendShapes(ScriptMeshImportOptions* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->importBlendShapes;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptMeshImportOptions::Internal_setimportBlendShapes(ScriptMeshImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->importBlendShapes = value;
+	}
+
+	bool ScriptMeshImportOptions::Internal_getimportSkin(ScriptMeshImportOptions* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->importSkin;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptMeshImportOptions::Internal_setimportSkin(ScriptMeshImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->importSkin = value;
+	}
+
+	bool ScriptMeshImportOptions::Internal_getimportAnimation(ScriptMeshImportOptions* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->importAnimation;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptMeshImportOptions::Internal_setimportAnimation(ScriptMeshImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->importAnimation = value;
+	}
+
+	bool ScriptMeshImportOptions::Internal_getreduceKeyFrames(ScriptMeshImportOptions* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->reduceKeyFrames;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptMeshImportOptions::Internal_setreduceKeyFrames(ScriptMeshImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->reduceKeyFrames = value;
+	}
+
+	bool ScriptMeshImportOptions::Internal_getimportRootMotion(ScriptMeshImportOptions* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->importRootMotion;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptMeshImportOptions::Internal_setimportRootMotion(ScriptMeshImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->importRootMotion = value;
+	}
+
+	float ScriptMeshImportOptions::Internal_getimportScale(ScriptMeshImportOptions* thisPtr)
+	{
+		float tmp__output;
+		tmp__output = thisPtr->getInternal()->importScale;
+
+		float __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptMeshImportOptions::Internal_setimportScale(ScriptMeshImportOptions* thisPtr, float value)
+	{
+		thisPtr->getInternal()->importScale = value;
+	}
+
+	CollisionMeshType ScriptMeshImportOptions::Internal_getcollisionMeshType(ScriptMeshImportOptions* thisPtr)
+	{
+		CollisionMeshType tmp__output;
+		tmp__output = thisPtr->getInternal()->collisionMeshType;
+
+		CollisionMeshType __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptMeshImportOptions::Internal_setcollisionMeshType(ScriptMeshImportOptions* thisPtr, CollisionMeshType value)
+	{
+		thisPtr->getInternal()->collisionMeshType = value;
+	}
+
+	MonoArray* ScriptMeshImportOptions::Internal_getanimationSplits(ScriptMeshImportOptions* thisPtr)
+	{
+		Vector<AnimationSplitInfo> vec__output;
+		vec__output = thisPtr->getInternal()->animationSplits;
+
+		MonoArray* __output;
+		int arraySize__output = (int)vec__output.size();
+		ScriptArray array__output = ScriptArray::create<ScriptAnimationSplitInfo>(arraySize__output);
+		for(int i = 0; i < arraySize__output; i++)
+		{
+			SPtr<AnimationSplitInfo> arrayElemPtr__output = bs_shared_ptr_new<AnimationSplitInfo>();
+			*arrayElemPtr__output = vec__output[i];
+			MonoObject* arrayElem__output;
+			arrayElem__output = ScriptAnimationSplitInfo::create(arrayElemPtr__output);
+			array__output.set(i, arrayElem__output);
+		}
+		__output = array__output.getInternal();
+
+		return __output;
+	}
+
+	void ScriptMeshImportOptions::Internal_setanimationSplits(ScriptMeshImportOptions* thisPtr, MonoArray* value)
+	{
+		Vector<AnimationSplitInfo> vecvalue;
+		if(value != nullptr)
+		{
+			ScriptArray arrayvalue(value);
+			vecvalue.resize(arrayvalue.size());
+			for(int i = 0; i < (int)arrayvalue.size(); i++)
+			{
+				ScriptAnimationSplitInfo* scriptvalue;
+				scriptvalue = ScriptAnimationSplitInfo::toNative(arrayvalue.get<MonoObject*>(i));
+				if(scriptvalue != nullptr)
+				{
+					SPtr<AnimationSplitInfo> arrayElemPtrvalue = scriptvalue->getInternal();
+					if(arrayElemPtrvalue)
+						vecvalue[i] = *arrayElemPtrvalue;
+				}
+			}
+
+		}
+		thisPtr->getInternal()->animationSplits = vecvalue;
+	}
+
+	MonoArray* ScriptMeshImportOptions::Internal_getanimationEvents(ScriptMeshImportOptions* thisPtr)
+	{
+		Vector<ImportedAnimationEvents> vec__output;
+		vec__output = thisPtr->getInternal()->animationEvents;
+
+		MonoArray* __output;
+		int arraySize__output = (int)vec__output.size();
+		ScriptArray array__output = ScriptArray::create<ScriptImportedAnimationEvents>(arraySize__output);
+		for(int i = 0; i < arraySize__output; i++)
+		{
+			SPtr<ImportedAnimationEvents> arrayElemPtr__output = bs_shared_ptr_new<ImportedAnimationEvents>();
+			*arrayElemPtr__output = vec__output[i];
+			MonoObject* arrayElem__output;
+			arrayElem__output = ScriptImportedAnimationEvents::create(arrayElemPtr__output);
+			array__output.set(i, arrayElem__output);
+		}
+		__output = array__output.getInternal();
+
+		return __output;
+	}
+
+	void ScriptMeshImportOptions::Internal_setanimationEvents(ScriptMeshImportOptions* thisPtr, MonoArray* value)
+	{
+		Vector<ImportedAnimationEvents> vecvalue;
+		if(value != nullptr)
+		{
+			ScriptArray arrayvalue(value);
+			vecvalue.resize(arrayvalue.size());
+			for(int i = 0; i < (int)arrayvalue.size(); i++)
+			{
+				ScriptImportedAnimationEvents* scriptvalue;
+				scriptvalue = ScriptImportedAnimationEvents::toNative(arrayvalue.get<MonoObject*>(i));
+				if(scriptvalue != nullptr)
+				{
+					SPtr<ImportedAnimationEvents> arrayElemPtrvalue = scriptvalue->getInternal();
+					if(arrayElemPtrvalue)
+						vecvalue[i] = *arrayElemPtrvalue;
+				}
+			}
+
+		}
+		thisPtr->getInternal()->animationEvents = vecvalue;
+	}
+}

Source/EditorScript/Generated/BsScriptMeshImportOptions.editor.generated.h

@@ -0,0 +1,53 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptObject.h"
+#include "BsScriptImportOptions.editor.generated.h"
+#include "../../bsf/Source/Foundation/bsfCore/Importer/BsMeshImportOptions.h"
+#include "../../bsf/Source/Foundation/bsfCore/Importer/BsMeshImportOptions.h"
+#include "../../bsf/Source/Foundation/bsfCore/Importer/BsMeshImportOptions.h"
+
+namespace bs
+{
+	class MeshImportOptions;
+
+	class BS_SCR_BED_EXPORT ScriptMeshImportOptions : public ScriptObject<ScriptMeshImportOptions, ScriptImportOptionsBase>
+	{
+	public:
+		SCRIPT_OBJ(EDITOR_ASSEMBLY, EDITOR_NS, "MeshImportOptions")
+
+		ScriptMeshImportOptions(MonoObject* managedInstance, const SPtr<MeshImportOptions>& value);
+
+		SPtr<MeshImportOptions> getInternal() const;
+		static MonoObject* create(const SPtr<MeshImportOptions>& value);
+
+	private:
+		static bool Internal_getcpuCached(ScriptMeshImportOptions* thisPtr);
+		static void Internal_setcpuCached(ScriptMeshImportOptions* thisPtr, bool value);
+		static bool Internal_getimportNormals(ScriptMeshImportOptions* thisPtr);
+		static void Internal_setimportNormals(ScriptMeshImportOptions* thisPtr, bool value);
+		static bool Internal_getimportTangents(ScriptMeshImportOptions* thisPtr);
+		static void Internal_setimportTangents(ScriptMeshImportOptions* thisPtr, bool value);
+		static bool Internal_getimportBlendShapes(ScriptMeshImportOptions* thisPtr);
+		static void Internal_setimportBlendShapes(ScriptMeshImportOptions* thisPtr, bool value);
+		static bool Internal_getimportSkin(ScriptMeshImportOptions* thisPtr);
+		static void Internal_setimportSkin(ScriptMeshImportOptions* thisPtr, bool value);
+		static bool Internal_getimportAnimation(ScriptMeshImportOptions* thisPtr);
+		static void Internal_setimportAnimation(ScriptMeshImportOptions* thisPtr, bool value);
+		static bool Internal_getreduceKeyFrames(ScriptMeshImportOptions* thisPtr);
+		static void Internal_setreduceKeyFrames(ScriptMeshImportOptions* thisPtr, bool value);
+		static bool Internal_getimportRootMotion(ScriptMeshImportOptions* thisPtr);
+		static void Internal_setimportRootMotion(ScriptMeshImportOptions* thisPtr, bool value);
+		static float Internal_getimportScale(ScriptMeshImportOptions* thisPtr);
+		static void Internal_setimportScale(ScriptMeshImportOptions* thisPtr, float value);
+		static CollisionMeshType Internal_getcollisionMeshType(ScriptMeshImportOptions* thisPtr);
+		static void Internal_setcollisionMeshType(ScriptMeshImportOptions* thisPtr, CollisionMeshType value);
+		static MonoArray* Internal_getanimationSplits(ScriptMeshImportOptions* thisPtr);
+		static void Internal_setanimationSplits(ScriptMeshImportOptions* thisPtr, MonoArray* value);
+		static MonoArray* Internal_getanimationEvents(ScriptMeshImportOptions* thisPtr);
+		static void Internal_setanimationEvents(ScriptMeshImportOptions* thisPtr, MonoArray* value);
+		static void Internal_create(MonoObject* managedInstance);
+	};
+}

Source/EditorScript/Generated/BsScriptScriptCodeImportOptions.editor.generated.cpp

@@ -0,0 +1,62 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#include "BsScriptScriptCodeImportOptions.editor.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../bsf/Source/Foundation/bsfEngine/Resources/BsScriptCodeImportOptions.h"
+#include "BsScriptScriptCodeImportOptions.editor.generated.h"
+
+namespace bs
+{
+	ScriptScriptCodeImportOptions::ScriptScriptCodeImportOptions(MonoObject* managedInstance, const SPtr<ScriptCodeImportOptions>& value)
+		:ScriptObject(managedInstance)
+	{
+		mInternal = value;
+	}
+
+	SPtr<ScriptCodeImportOptions> ScriptScriptCodeImportOptions::getInternal() const 
+	{
+		return std::static_pointer_cast<ScriptCodeImportOptions>(mInternal);
+	}
+
+	void ScriptScriptCodeImportOptions::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_geteditorScript", (void*)&ScriptScriptCodeImportOptions::Internal_geteditorScript);
+		metaData.scriptClass->addInternalCall("Internal_seteditorScript", (void*)&ScriptScriptCodeImportOptions::Internal_seteditorScript);
+		metaData.scriptClass->addInternalCall("Internal_create", (void*)&ScriptScriptCodeImportOptions::Internal_create);
+
+	}
+
+	MonoObject* ScriptScriptCodeImportOptions::create(const SPtr<ScriptCodeImportOptions>& value)
+	{
+		if(value == nullptr) return nullptr; 
+
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance("bool", ctorParams);
+		new (bs_alloc<ScriptScriptCodeImportOptions>()) ScriptScriptCodeImportOptions(managedInstance, value);
+		return managedInstance;
+	}
+	void ScriptScriptCodeImportOptions::Internal_create(MonoObject* managedInstance)
+	{
+		SPtr<ScriptCodeImportOptions> instance = ScriptCodeImportOptions::create();
+		new (bs_alloc<ScriptScriptCodeImportOptions>())ScriptScriptCodeImportOptions(managedInstance, instance);
+	}
+	bool ScriptScriptCodeImportOptions::Internal_geteditorScript(ScriptScriptCodeImportOptions* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->editorScript;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptScriptCodeImportOptions::Internal_seteditorScript(ScriptScriptCodeImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->editorScript = value;
+	}
+}

Source/EditorScript/Generated/BsScriptScriptCodeImportOptions.editor.generated.h

@@ -0,0 +1,28 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptObject.h"
+#include "BsScriptImportOptions.editor.generated.h"
+
+namespace bs
+{
+	class ScriptCodeImportOptions;
+
+	class BS_SCR_BED_EXPORT ScriptScriptCodeImportOptions : public ScriptObject<ScriptScriptCodeImportOptions, ScriptImportOptionsBase>
+	{
+	public:
+		SCRIPT_OBJ(EDITOR_ASSEMBLY, EDITOR_NS, "ScriptCodeImportOptions")
+
+		ScriptScriptCodeImportOptions(MonoObject* managedInstance, const SPtr<ScriptCodeImportOptions>& value);
+
+		SPtr<ScriptCodeImportOptions> getInternal() const;
+		static MonoObject* create(const SPtr<ScriptCodeImportOptions>& value);
+
+	private:
+		static bool Internal_geteditorScript(ScriptScriptCodeImportOptions* thisPtr);
+		static void Internal_seteditorScript(ScriptScriptCodeImportOptions* thisPtr, bool value);
+		static void Internal_create(MonoObject* managedInstance);
+	};
+}

Source/EditorScript/Generated/BsScriptShaderImportOptions.editor.generated.cpp

@@ -0,0 +1,103 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#include "BsScriptShaderImportOptions.editor.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../bsf/Source/Foundation/bsfCore/Importer/BsShaderImportOptions.h"
+
+namespace bs
+{
+	ScriptShaderImportOptions::ScriptShaderImportOptions(MonoObject* managedInstance, const SPtr<ShaderImportOptions>& value)
+		:ScriptObject(managedInstance)
+	{
+		mInternal = value;
+	}
+
+	SPtr<ShaderImportOptions> ScriptShaderImportOptions::getInternal() const 
+	{
+		return std::static_pointer_cast<ShaderImportOptions>(mInternal);
+	}
+
+	void ScriptShaderImportOptions::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_setDefine", (void*)&ScriptShaderImportOptions::Internal_setDefine);
+		metaData.scriptClass->addInternalCall("Internal_getDefine", (void*)&ScriptShaderImportOptions::Internal_getDefine);
+		metaData.scriptClass->addInternalCall("Internal_hasDefine", (void*)&ScriptShaderImportOptions::Internal_hasDefine);
+		metaData.scriptClass->addInternalCall("Internal_removeDefine", (void*)&ScriptShaderImportOptions::Internal_removeDefine);
+		metaData.scriptClass->addInternalCall("Internal_getlanguages", (void*)&ScriptShaderImportOptions::Internal_getlanguages);
+		metaData.scriptClass->addInternalCall("Internal_setlanguages", (void*)&ScriptShaderImportOptions::Internal_setlanguages);
+
+	}
+
+	MonoObject* ScriptShaderImportOptions::create(const SPtr<ShaderImportOptions>& value)
+	{
+		if(value == nullptr) return nullptr; 
+
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance("bool", ctorParams);
+		new (bs_alloc<ScriptShaderImportOptions>()) ScriptShaderImportOptions(managedInstance, value);
+		return managedInstance;
+	}
+	void ScriptShaderImportOptions::Internal_setDefine(ScriptShaderImportOptions* thisPtr, MonoString* define, MonoString* value)
+	{
+		String tmpdefine;
+		tmpdefine = MonoUtil::monoToString(define);
+		String tmpvalue;
+		tmpvalue = MonoUtil::monoToString(value);
+		thisPtr->getInternal()->setDefine(tmpdefine, tmpvalue);
+	}
+
+	bool ScriptShaderImportOptions::Internal_getDefine(ScriptShaderImportOptions* thisPtr, MonoString* define, MonoString** value)
+	{
+		bool tmp__output;
+		String tmpdefine;
+		tmpdefine = MonoUtil::monoToString(define);
+		String tmpvalue;
+		tmp__output = thisPtr->getInternal()->getDefine(tmpdefine, tmpvalue);
+
+		bool __output;
+		__output = tmp__output;
+		MonoUtil::referenceCopy(value,  (MonoObject*)MonoUtil::stringToMono(tmpvalue));
+
+		return __output;
+	}
+
+	bool ScriptShaderImportOptions::Internal_hasDefine(ScriptShaderImportOptions* thisPtr, MonoString* define)
+	{
+		bool tmp__output;
+		String tmpdefine;
+		tmpdefine = MonoUtil::monoToString(define);
+		tmp__output = thisPtr->getInternal()->hasDefine(tmpdefine);
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptShaderImportOptions::Internal_removeDefine(ScriptShaderImportOptions* thisPtr, MonoString* define)
+	{
+		String tmpdefine;
+		tmpdefine = MonoUtil::monoToString(define);
+		thisPtr->getInternal()->removeDefine(tmpdefine);
+	}
+
+	ShadingLanguageFlag ScriptShaderImportOptions::Internal_getlanguages(ScriptShaderImportOptions* thisPtr)
+	{
+		Flags<ShadingLanguageFlag> tmp__output;
+		tmp__output = thisPtr->getInternal()->languages;
+
+		ShadingLanguageFlag __output;
+		__output = (ShadingLanguageFlag)(uint32_t)tmp__output;
+
+		return __output;
+	}
+
+	void ScriptShaderImportOptions::Internal_setlanguages(ScriptShaderImportOptions* thisPtr, ShadingLanguageFlag value)
+	{
+		thisPtr->getInternal()->languages = value;
+	}
+}

Source/EditorScript/Generated/BsScriptShaderImportOptions.editor.generated.h

@@ -0,0 +1,32 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptObject.h"
+#include "BsScriptImportOptions.editor.generated.h"
+#include "../../bsf/Source/Foundation/bsfCore/Importer/BsShaderImportOptions.h"
+
+namespace bs
+{
+	class ShaderImportOptions;
+
+	class BS_SCR_BED_EXPORT ScriptShaderImportOptions : public ScriptObject<ScriptShaderImportOptions, ScriptImportOptionsBase>
+	{
+	public:
+		SCRIPT_OBJ(EDITOR_ASSEMBLY, EDITOR_NS, "ShaderImportOptions")
+
+		ScriptShaderImportOptions(MonoObject* managedInstance, const SPtr<ShaderImportOptions>& value);
+
+		SPtr<ShaderImportOptions> getInternal() const;
+		static MonoObject* create(const SPtr<ShaderImportOptions>& value);
+
+	private:
+		static void Internal_setDefine(ScriptShaderImportOptions* thisPtr, MonoString* define, MonoString* value);
+		static bool Internal_getDefine(ScriptShaderImportOptions* thisPtr, MonoString* define, MonoString** value);
+		static bool Internal_hasDefine(ScriptShaderImportOptions* thisPtr, MonoString* define);
+		static void Internal_removeDefine(ScriptShaderImportOptions* thisPtr, MonoString* define);
+		static ShadingLanguageFlag Internal_getlanguages(ScriptShaderImportOptions* thisPtr);
+		static void Internal_setlanguages(ScriptShaderImportOptions* thisPtr, ShadingLanguageFlag value);
+	};
+}

Source/EditorScript/Generated/BsScriptTextureImportOptions.editor.generated.cpp

@@ -0,0 +1,170 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#include "BsScriptTextureImportOptions.editor.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../bsf/Source/Foundation/bsfCore/Importer/BsTextureImportOptions.h"
+#include "BsScriptTextureImportOptions.editor.generated.h"
+
+namespace bs
+{
+	ScriptTextureImportOptions::ScriptTextureImportOptions(MonoObject* managedInstance, const SPtr<TextureImportOptions>& value)
+		:ScriptObject(managedInstance)
+	{
+		mInternal = value;
+	}
+
+	SPtr<TextureImportOptions> ScriptTextureImportOptions::getInternal() const 
+	{
+		return std::static_pointer_cast<TextureImportOptions>(mInternal);
+	}
+
+	void ScriptTextureImportOptions::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_getformat", (void*)&ScriptTextureImportOptions::Internal_getformat);
+		metaData.scriptClass->addInternalCall("Internal_setformat", (void*)&ScriptTextureImportOptions::Internal_setformat);
+		metaData.scriptClass->addInternalCall("Internal_getgenerateMips", (void*)&ScriptTextureImportOptions::Internal_getgenerateMips);
+		metaData.scriptClass->addInternalCall("Internal_setgenerateMips", (void*)&ScriptTextureImportOptions::Internal_setgenerateMips);
+		metaData.scriptClass->addInternalCall("Internal_getmaxMip", (void*)&ScriptTextureImportOptions::Internal_getmaxMip);
+		metaData.scriptClass->addInternalCall("Internal_setmaxMip", (void*)&ScriptTextureImportOptions::Internal_setmaxMip);
+		metaData.scriptClass->addInternalCall("Internal_getcpuCached", (void*)&ScriptTextureImportOptions::Internal_getcpuCached);
+		metaData.scriptClass->addInternalCall("Internal_setcpuCached", (void*)&ScriptTextureImportOptions::Internal_setcpuCached);
+		metaData.scriptClass->addInternalCall("Internal_getsRGB", (void*)&ScriptTextureImportOptions::Internal_getsRGB);
+		metaData.scriptClass->addInternalCall("Internal_setsRGB", (void*)&ScriptTextureImportOptions::Internal_setsRGB);
+		metaData.scriptClass->addInternalCall("Internal_getcubemap", (void*)&ScriptTextureImportOptions::Internal_getcubemap);
+		metaData.scriptClass->addInternalCall("Internal_setcubemap", (void*)&ScriptTextureImportOptions::Internal_setcubemap);
+		metaData.scriptClass->addInternalCall("Internal_getcubemapSourceType", (void*)&ScriptTextureImportOptions::Internal_getcubemapSourceType);
+		metaData.scriptClass->addInternalCall("Internal_setcubemapSourceType", (void*)&ScriptTextureImportOptions::Internal_setcubemapSourceType);
+		metaData.scriptClass->addInternalCall("Internal_create", (void*)&ScriptTextureImportOptions::Internal_create);
+
+	}
+
+	MonoObject* ScriptTextureImportOptions::create(const SPtr<TextureImportOptions>& value)
+	{
+		if(value == nullptr) return nullptr; 
+
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance("bool", ctorParams);
+		new (bs_alloc<ScriptTextureImportOptions>()) ScriptTextureImportOptions(managedInstance, value);
+		return managedInstance;
+	}
+	void ScriptTextureImportOptions::Internal_create(MonoObject* managedInstance)
+	{
+		SPtr<TextureImportOptions> instance = TextureImportOptions::create();
+		new (bs_alloc<ScriptTextureImportOptions>())ScriptTextureImportOptions(managedInstance, instance);
+	}
+	PixelFormat ScriptTextureImportOptions::Internal_getformat(ScriptTextureImportOptions* thisPtr)
+	{
+		PixelFormat tmp__output;
+		tmp__output = thisPtr->getInternal()->format;
+
+		PixelFormat __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptTextureImportOptions::Internal_setformat(ScriptTextureImportOptions* thisPtr, PixelFormat value)
+	{
+		thisPtr->getInternal()->format = value;
+	}
+
+	bool ScriptTextureImportOptions::Internal_getgenerateMips(ScriptTextureImportOptions* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->generateMips;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptTextureImportOptions::Internal_setgenerateMips(ScriptTextureImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->generateMips = value;
+	}
+
+	uint32_t ScriptTextureImportOptions::Internal_getmaxMip(ScriptTextureImportOptions* thisPtr)
+	{
+		uint32_t tmp__output;
+		tmp__output = thisPtr->getInternal()->maxMip;
+
+		uint32_t __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptTextureImportOptions::Internal_setmaxMip(ScriptTextureImportOptions* thisPtr, uint32_t value)
+	{
+		thisPtr->getInternal()->maxMip = value;
+	}
+
+	bool ScriptTextureImportOptions::Internal_getcpuCached(ScriptTextureImportOptions* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->cpuCached;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptTextureImportOptions::Internal_setcpuCached(ScriptTextureImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->cpuCached = value;
+	}
+
+	bool ScriptTextureImportOptions::Internal_getsRGB(ScriptTextureImportOptions* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->sRGB;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptTextureImportOptions::Internal_setsRGB(ScriptTextureImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->sRGB = value;
+	}
+
+	bool ScriptTextureImportOptions::Internal_getcubemap(ScriptTextureImportOptions* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->cubemap;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptTextureImportOptions::Internal_setcubemap(ScriptTextureImportOptions* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->cubemap = value;
+	}
+
+	CubemapSourceType ScriptTextureImportOptions::Internal_getcubemapSourceType(ScriptTextureImportOptions* thisPtr)
+	{
+		CubemapSourceType tmp__output;
+		tmp__output = thisPtr->getInternal()->cubemapSourceType;
+
+		CubemapSourceType __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptTextureImportOptions::Internal_setcubemapSourceType(ScriptTextureImportOptions* thisPtr, CubemapSourceType value)
+	{
+		thisPtr->getInternal()->cubemapSourceType = value;
+	}
+}

Source/EditorScript/Generated/BsScriptTextureImportOptions.editor.generated.h

@@ -0,0 +1,42 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//************** Copyright (c) 2016-2019 Marko Pintera ([email protected]). All rights reserved. *******************//
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptObject.h"
+#include "BsScriptImportOptions.editor.generated.h"
+#include "../../bsf/Source/Foundation/bsfCore/Image/BsPixelData.h"
+#include "../../bsf/Source/Foundation/bsfCore/Utility/BsCommonTypes.h"
+
+namespace bs
+{
+	class TextureImportOptions;
+
+	class BS_SCR_BED_EXPORT ScriptTextureImportOptions : public ScriptObject<ScriptTextureImportOptions, ScriptImportOptionsBase>
+	{
+	public:
+		SCRIPT_OBJ(EDITOR_ASSEMBLY, EDITOR_NS, "TextureImportOptions")
+
+		ScriptTextureImportOptions(MonoObject* managedInstance, const SPtr<TextureImportOptions>& value);
+
+		SPtr<TextureImportOptions> getInternal() const;
+		static MonoObject* create(const SPtr<TextureImportOptions>& value);
+
+	private:
+		static PixelFormat Internal_getformat(ScriptTextureImportOptions* thisPtr);
+		static void Internal_setformat(ScriptTextureImportOptions* thisPtr, PixelFormat value);
+		static bool Internal_getgenerateMips(ScriptTextureImportOptions* thisPtr);
+		static void Internal_setgenerateMips(ScriptTextureImportOptions* thisPtr, bool value);
+		static uint32_t Internal_getmaxMip(ScriptTextureImportOptions* thisPtr);
+		static void Internal_setmaxMip(ScriptTextureImportOptions* thisPtr, uint32_t value);
+		static bool Internal_getcpuCached(ScriptTextureImportOptions* thisPtr);
+		static void Internal_setcpuCached(ScriptTextureImportOptions* thisPtr, bool value);
+		static bool Internal_getsRGB(ScriptTextureImportOptions* thisPtr);
+		static void Internal_setsRGB(ScriptTextureImportOptions* thisPtr, bool value);
+		static bool Internal_getcubemap(ScriptTextureImportOptions* thisPtr);
+		static void Internal_setcubemap(ScriptTextureImportOptions* thisPtr, bool value);
+		static CubemapSourceType Internal_getcubemapSourceType(ScriptTextureImportOptions* thisPtr);
+		static void Internal_setcubemapSourceType(ScriptTextureImportOptions* thisPtr, CubemapSourceType value);
+		static void Internal_create(MonoObject* managedInstance);
+	};
+}

Source/EditorScript/Wrappers/BsScriptEditorApplication.cpp

@@ -23,7 +23,7 @@
 #include "FileSystem/BsFileSystem.h"
 #include "Wrappers/BsScriptPrefab.h"
 
-#include "BsScriptRenderTexture.generated.h"
+#include "Generated/BsScriptRenderTexture.generated.h"
 #include "BsEditorScriptLibrary.h"
 
 namespace bs

Source/EditorScript/Wrappers/BsScriptGizmos.cpp

@@ -6,9 +6,9 @@
 #include "Scene/BsGizmoManager.h"
 #include "BsMonoUtil.h"
 
-#include "BsScriptRendererMeshData.generated.h"
-#include "BsScriptSpriteTexture.generated.h"
-#include "BsScriptFont.generated.h"
+#include "Generated/BsScriptRendererMeshData.generated.h"
+#include "Generated/BsScriptSpriteTexture.generated.h"
+#include "Generated/BsScriptFont.generated.h"
 
 namespace bs
 {

Source/EditorScript/Wrappers/BsScriptHandleDrawing.cpp

@@ -7,7 +7,7 @@
 #include "Handles/BsHandleDrawManager.h"
 #include "BsMonoUtil.h"
 
-#include "BsScriptFont.generated.h"
+#include "Generated/BsScriptFont.generated.h"
 
 namespace bs
 {

Source/EditorScript/Wrappers/BsScriptImportOptions.cpp

@@ -1,793 +0,0 @@
-//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
-//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
-#include "Wrappers/BsScriptImportOptions.h"
-#include "BsScriptMeta.h"
-#include "BsMonoField.h"
-#include "BsMonoClass.h"
-#include "BsMonoManager.h"
-#include "BsMonoMethod.h"
-#include "BsMonoUtil.h"
-#include "Importer/BsTextureImportOptions.h"
-#include "Text/BsFontImportOptions.h"
-#include "Resources/BsScriptCodeImportOptions.h"
-#include "Importer/BsMeshImportOptions.h"
-#include "Renderer/BsRenderer.h"
-#include "Reflection/BsRTTIType.h"
-
-#include "BsScriptAnimationEvent.generated.h"
-#include "BsScriptFont.generated.h"
-
-using namespace std::placeholders;
-
-namespace bs
-{
-	struct CharRange
-	{
-		UINT32 start, end;
-	};
-
-	ScriptCharRange::ScriptCharRange(MonoObject* instance)
-		:ScriptObject(instance)
-	{ }
-
-	void ScriptCharRange::initRuntimeData()
-	{ }
-
-	ScriptImportOptionsBase::ScriptImportOptionsBase(MonoObject* instance)
-		:ScriptObjectBase(instance)
-	{ }
-
-	void ScriptImportOptions::initRuntimeData()
-	{ }
-
-	MonoObject* ScriptImportOptions::create(const SPtr<ImportOptions>& importOptions)
-	{
-		if(!importOptions)
-			return nullptr;
-
-		UINT32 typeId = importOptions->getRTTI()->getRTTIId();
-		switch (typeId)
-		{
-		case TID_TextureImportOptions:
-			return ScriptTextureImportOptions::create(std::static_pointer_cast<TextureImportOptions>(importOptions));
-		case TID_MeshImportOptions:
-			return ScriptMeshImportOptions::create(std::static_pointer_cast<MeshImportOptions>(importOptions));
-		case TID_FontImportOptions:
-			return ScriptFontImportOptions::create(std::static_pointer_cast<FontImportOptions>(importOptions));
-		case TID_ScriptCodeImportOptions:
-			return ScriptScriptCodeImportOptions::create(std::static_pointer_cast<ScriptCodeImportOptions>(importOptions));
-		case TID_AudioClipImportOptions:
-			return ScriptAudioClipImportOptions::create(std::static_pointer_cast<AudioClipImportOptions>(importOptions));
-		}
-
-		MonoObject* managedInstance = metaData.scriptClass->createInstance();
-		ScriptImportOptions* scriptObj = ScriptImportOptions::toNative(managedInstance);
-		scriptObj->mImportOptions = importOptions;
-
-		return managedInstance;
-	}
-
-	ScriptImportOptions::ScriptImportOptions(MonoObject* instance)
-		:ScriptObject(instance)
-	{
-		mImportOptions = bs_shared_ptr_new<ImportOptions>();
-	}
-
-	ScriptTextureImportOptions::ScriptTextureImportOptions(MonoObject* instance)
-		: ScriptObject(instance)
-	{
-		mImportOptions = bs_shared_ptr_new<TextureImportOptions>();
-	}
-
-	void ScriptTextureImportOptions::initRuntimeData()
-	{
-		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()
-	{
-		return std::static_pointer_cast<TextureImportOptions>(mImportOptions);
-	}
-
-	MonoObject* ScriptTextureImportOptions::create()
-	{
-		return metaData.scriptClass->createInstance();
-	}
-
-	MonoObject* ScriptTextureImportOptions::create(const SPtr<TextureImportOptions>& options)
-	{
-		MonoObject* managedInstance = metaData.scriptClass->createInstance();
-		ScriptTextureImportOptions* scriptObj = ScriptTextureImportOptions::toNative(managedInstance);
-		scriptObj->mImportOptions = options;
-
-		return managedInstance;
-	}
-
-	void ScriptTextureImportOptions::internal_CreateInstance(MonoObject* instance)
-	{
-		new (bs_alloc<ScriptTextureImportOptions>()) ScriptTextureImportOptions(instance);
-	}
-
-	PixelFormat ScriptTextureImportOptions::internal_GetPixelFormat(ScriptTextureImportOptions* thisPtr)
-	{
-		return thisPtr->getTexImportOptions()->getFormat();
-	}
-
-	void ScriptTextureImportOptions::internal_SetPixelFormat(ScriptTextureImportOptions* thisPtr, PixelFormat value)
-	{
-		thisPtr->getTexImportOptions()->setFormat(value);
-	}
-
-	bool ScriptTextureImportOptions::internal_GetGenerateMipmaps(ScriptTextureImportOptions* thisPtr)
-	{
-		return thisPtr->getTexImportOptions()->getGenerateMipmaps();
-	}
-
-	void ScriptTextureImportOptions::internal_SetGenerateMipmaps(ScriptTextureImportOptions* thisPtr, bool value)
-	{
-		thisPtr->getTexImportOptions()->setGenerateMipmaps(value);
-	}
-
-	UINT32 ScriptTextureImportOptions::internal_GetMaxMipmapLevel(ScriptTextureImportOptions* thisPtr)
-	{
-		return thisPtr->getTexImportOptions()->getMaxMip();
-	}
-
-	void ScriptTextureImportOptions::internal_SetMaxMipmapLevel(ScriptTextureImportOptions* thisPtr, UINT32 value)
-	{
-		thisPtr->getTexImportOptions()->setMaxMip(value);
-	}
-
-	bool ScriptTextureImportOptions::internal_GetCPUCached(ScriptTextureImportOptions* thisPtr)
-	{
-		return thisPtr->getTexImportOptions()->getCPUCached();
-	}
-
-	void ScriptTextureImportOptions::internal_SetCPUCached(ScriptTextureImportOptions* thisPtr, bool value)
-	{
-		thisPtr->getTexImportOptions()->setCPUCached(value);
-	}
-
-	bool ScriptTextureImportOptions::internal_GetIsSRGB(ScriptTextureImportOptions* thisPtr)
-	{
-		return thisPtr->getTexImportOptions()->getSRGB();
-	}
-
-	void ScriptTextureImportOptions::internal_SetIsSRGB(ScriptTextureImportOptions* thisPtr, bool value)
-	{
-		thisPtr->getTexImportOptions()->setSRGB(value);
-	}
-
-
-	bool ScriptTextureImportOptions::internal_GetIsCubemap(ScriptTextureImportOptions* thisPtr)
-	{
-		return thisPtr->getTexImportOptions()->getIsCubemap();
-	}
-
-	void ScriptTextureImportOptions::internal_SetIsCubemap(ScriptTextureImportOptions* thisPtr, bool value)
-	{
-		thisPtr->getTexImportOptions()->setIsCubemap(value);
-	}
-
-	CubemapSourceType ScriptTextureImportOptions::internal_GetCubemapSourceType(ScriptTextureImportOptions* thisPtr)
-	{
-		return thisPtr->getTexImportOptions()->getCubemapSourceType();
-	}
-
-	void ScriptTextureImportOptions::internal_SetCubemapSourceType(ScriptTextureImportOptions* thisPtr, CubemapSourceType value)
-	{
-		thisPtr->getTexImportOptions()->setCubemapSourceType(value);
-	}
-
-	ScriptMeshImportOptions::ScriptMeshImportOptions(MonoObject* instance)
-		:ScriptObject(instance)
-	{
-		mImportOptions = bs_shared_ptr_new<MeshImportOptions>();
-	}
-
-	void ScriptMeshImportOptions::initRuntimeData()
-	{
-		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()
-	{
-		return std::static_pointer_cast<MeshImportOptions>(mImportOptions);
-	}
-
-	MonoObject* ScriptMeshImportOptions::create()
-	{
-		return metaData.scriptClass->createInstance();
-	}
-
-	MonoObject* ScriptMeshImportOptions::create(const SPtr<MeshImportOptions>& options)
-	{
-		MonoObject* managedInstance = metaData.scriptClass->createInstance();
-		ScriptMeshImportOptions* scriptObj = ScriptMeshImportOptions::toNative(managedInstance);
-		scriptObj->mImportOptions = options;
-
-		return managedInstance;
-	}
-
-	void ScriptMeshImportOptions::internal_CreateInstance(MonoObject* instance)
-	{
-		new (bs_alloc<ScriptMeshImportOptions>()) ScriptMeshImportOptions(instance);
-	}
-
-	bool ScriptMeshImportOptions::internal_GetCPUCached(ScriptMeshImportOptions* thisPtr)
-	{
-		return thisPtr->getMeshImportOptions()->getCPUCached();
-	}
-
-	void ScriptMeshImportOptions::internal_SetCPUCached(ScriptMeshImportOptions* thisPtr, bool value)
-	{
-		thisPtr->getMeshImportOptions()->setCPUCached(value);
-	}
-
-	bool ScriptMeshImportOptions::internal_GetImportNormals(ScriptMeshImportOptions* thisPtr)
-	{
-		return thisPtr->getMeshImportOptions()->getImportNormals();
-	}
-
-	void ScriptMeshImportOptions::internal_SetImportNormals(ScriptMeshImportOptions* thisPtr, bool value)
-	{
-		thisPtr->getMeshImportOptions()->setImportNormals(value);
-	}
-
-	bool ScriptMeshImportOptions::internal_GetImportTangents(ScriptMeshImportOptions* thisPtr)
-	{
-		return thisPtr->getMeshImportOptions()->getImportTangents();
-	}
-
-	void ScriptMeshImportOptions::internal_SetImportTangents(ScriptMeshImportOptions* thisPtr, bool value)
-	{
-		thisPtr->getMeshImportOptions()->setImportTangents(value);
-	}
-
-	bool ScriptMeshImportOptions::internal_GetImportSkin(ScriptMeshImportOptions* thisPtr)
-	{
-		return thisPtr->getMeshImportOptions()->getImportSkin();
-	}
-
-	void ScriptMeshImportOptions::internal_SetImportSkin(ScriptMeshImportOptions* thisPtr, bool value)
-	{
-		thisPtr->getMeshImportOptions()->setImportSkin(value);
-	}
-
-	bool ScriptMeshImportOptions::internal_GetImportAnimation(ScriptMeshImportOptions* thisPtr)
-	{
-		return thisPtr->getMeshImportOptions()->getImportAnimation();
-	}
-
-	void ScriptMeshImportOptions::internal_SetImportAnimation(ScriptMeshImportOptions* thisPtr, bool value)
-	{
-		thisPtr->getMeshImportOptions()->setImportAnimation(value);
-	}
-
-	bool ScriptMeshImportOptions::internal_GetImportBlendShapes(ScriptMeshImportOptions* thisPtr)
-	{
-		return thisPtr->getMeshImportOptions()->getImportBlendShapes();
-	}
-
-	void ScriptMeshImportOptions::internal_SetImportBlendShapes(ScriptMeshImportOptions* thisPtr, bool value)
-	{
-		thisPtr->getMeshImportOptions()->setImportBlendShapes(value);
-	}
-
-	bool ScriptMeshImportOptions::internal_GetKeyFrameReduction(ScriptMeshImportOptions* thisPtr)
-	{
-		return thisPtr->getMeshImportOptions()->getKeyFrameReduction();
-	}
-
-	void ScriptMeshImportOptions::internal_SetKeyFrameReduction(ScriptMeshImportOptions* thisPtr, bool value)
-	{
-		thisPtr->getMeshImportOptions()->setKeyFrameReduction(value);
-	}
-
-	bool ScriptMeshImportOptions::internal_GetRootMotion(ScriptMeshImportOptions* thisPtr)
-	{
-		return thisPtr->getMeshImportOptions()->getImportRootMotion();
-	}
-
-	void ScriptMeshImportOptions::internal_SetRootMotion(ScriptMeshImportOptions* thisPtr, bool value)
-	{
-		thisPtr->getMeshImportOptions()->setImportRootMotion(value);
-	}
-
-	float ScriptMeshImportOptions::internal_GetScale(ScriptMeshImportOptions* thisPtr)
-	{
-		return thisPtr->getMeshImportOptions()->getImportScale();
-	}
-
-	void ScriptMeshImportOptions::internal_SetScale(ScriptMeshImportOptions* thisPtr, float value)
-	{
-		thisPtr->getMeshImportOptions()->setImportScale(value);
-	}
-
-	int ScriptMeshImportOptions::internal_GetCollisionMeshType(ScriptMeshImportOptions* thisPtr)
-	{
-		return (int)thisPtr->getMeshImportOptions()->getCollisionMeshType();
-	}
-
-	void ScriptMeshImportOptions::internal_SetCollisionMeshType(ScriptMeshImportOptions* thisPtr, int value)
-	{
-		thisPtr->getMeshImportOptions()->setCollisionMeshType((CollisionMeshType)value);
-	}
-
-	MonoArray* ScriptMeshImportOptions::internal_GetAnimationClipSplits(ScriptMeshImportOptions* thisPtr)
-	{
-		SPtr<MeshImportOptions> io = thisPtr->getMeshImportOptions();
-
-		Vector<AnimationSplitInfo> splitInfos = io->getAnimationClipSplits();
-		UINT32 numSplitInfos = (UINT32)splitInfos.size();
-		ScriptArray outputArray = ScriptArray::create<ScriptAnimationSplitInfo>(numSplitInfos);
-		for(UINT32 i = 0; i < numSplitInfos; i++)
-			outputArray.set(i, ScriptAnimationSplitInfo::toManaged(splitInfos[i]));
-
-		return outputArray.getInternal();
-	}
-
-	void ScriptMeshImportOptions::internal_SetAnimationClipSplits(ScriptMeshImportOptions* thisPtr, MonoArray* value)
-	{
-		SPtr<MeshImportOptions> io = thisPtr->getMeshImportOptions();
-
-		if(value == nullptr)
-		{
-			io->setAnimationClipSplits({});
-			return;
-		}
-
-		ScriptArray inputArray(value);
-
-		UINT32 numSplits = inputArray.size();
-		Vector<AnimationSplitInfo> splitInfos(numSplits);
-		for (UINT32 i = 0; i < numSplits; i++)
-		{
-			MonoObject* monoSplitInfo = inputArray.get<MonoObject*>(i);
-
-			if(monoSplitInfo != nullptr)
-				splitInfos[i] = ScriptAnimationSplitInfo::fromManaged(monoSplitInfo);
-		}
-
-		io->setAnimationClipSplits(splitInfos);
-	}
-
-	MonoArray* ScriptMeshImportOptions::internal_GetAnimationEvents(ScriptMeshImportOptions* thisPtr)
-	{
-		SPtr<MeshImportOptions> io = thisPtr->getMeshImportOptions();
-
-		Vector<ImportedAnimationEvents> animationEvents = io->getAnimationEvents();
-		UINT32 count = (UINT32)animationEvents.size();
-		ScriptArray outputArray = ScriptArray::create<ScriptImportedAnimationEvents>(count);
-		for (UINT32 i = 0; i < count; i++)
-			outputArray.set(i, ScriptImportedAnimationEvents::toManaged(animationEvents[i]));
-
-		return outputArray.getInternal();
-	}
-
-	void ScriptMeshImportOptions::internal_SetAnimationEvents(ScriptMeshImportOptions* thisPtr, MonoArray* value)
-	{
-		ScriptArray inputArray(value);
-
-		SPtr<MeshImportOptions> io = thisPtr->getMeshImportOptions();
-
-		UINT32 count = inputArray.size();
-		Vector<ImportedAnimationEvents> animationEvents(count);
-		for (UINT32 i = 0; i < count; i++)
-			animationEvents[i] = ScriptImportedAnimationEvents::fromManaged(inputArray.get<MonoObject*>(i));
-
-		io->setAnimationEvents(animationEvents);
-	}
-
-	ScriptFontImportOptions::ScriptFontImportOptions(MonoObject* instance)
-		:ScriptObject(instance)
-	{
-		mImportOptions = bs_shared_ptr_new<FontImportOptions>();
-	}
-
-	void ScriptFontImportOptions::initRuntimeData()
-	{
-		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()
-	{
-		return std::static_pointer_cast<FontImportOptions>(mImportOptions);
-	}
-
-	MonoObject* ScriptFontImportOptions::create()
-	{
-		return metaData.scriptClass->createInstance();
-	}
-
-	MonoObject* ScriptFontImportOptions::create(const SPtr<FontImportOptions>& options)
-	{
-		MonoObject* managedInstance = metaData.scriptClass->createInstance();
-		ScriptFontImportOptions* scriptObj = ScriptFontImportOptions::toNative(managedInstance);
-		scriptObj->mImportOptions = options;
-
-		return managedInstance;
-	}
-
-	void ScriptFontImportOptions::internal_CreateInstance(MonoObject* instance)
-	{
-		new (bs_alloc<ScriptFontImportOptions>()) ScriptFontImportOptions(instance);
-	}
-
-	MonoArray* ScriptFontImportOptions::internal_GetFontSizes(ScriptFontImportOptions* thisPtr)
-	{
-		Vector<UINT32> fontSizes = thisPtr->getFontImportOptions()->getFontSizes();
-
-		ScriptArray outArray = ScriptArray::create<UINT32>((UINT32)fontSizes.size());
-		for (UINT32 i = 0; i < fontSizes.size(); i++)
-			outArray.set(i, fontSizes[i]);
-
-		return outArray.getInternal();
-	}
-
-	void ScriptFontImportOptions::internal_SetFontSizes(ScriptFontImportOptions* thisPtr, MonoArray* value)
-	{
-		ScriptArray inArray(value);
-
-		Vector<UINT32> fontSizes(inArray.size());
-		for (UINT32 i = 0; i < inArray.size(); i++)
-			fontSizes[i] = inArray.get<UINT32>(i);
-
-		thisPtr->getFontImportOptions()->setFontSizes(fontSizes);
-	}
-
-	UINT32 ScriptFontImportOptions::internal_GetDPI(ScriptFontImportOptions* thisPtr)
-	{
-		return thisPtr->getFontImportOptions()->getDPI();
-	}
-
-	void ScriptFontImportOptions::internal_SetDPI(ScriptFontImportOptions* thisPtr, UINT32 value)
-	{
-		thisPtr->getFontImportOptions()->setDPI(value);
-	}
-
-	FontRenderMode ScriptFontImportOptions::internal_GetRenderMode(ScriptFontImportOptions* thisPtr)
-	{
-		return thisPtr->getFontImportOptions()->getRenderMode();
-	}
-
-	void ScriptFontImportOptions::internal_SetRenderMode(ScriptFontImportOptions* thisPtr, FontRenderMode value)
-	{
-		thisPtr->getFontImportOptions()->setRenderMode(value);
-	}
-
-	bool ScriptFontImportOptions::internal_GetBold(ScriptFontImportOptions* thisPtr)
-	{
-		return thisPtr->getFontImportOptions()->getBold();
-	}
-
-	void ScriptFontImportOptions::internal_SetBold(ScriptFontImportOptions* thisPtr, bool value)
-	{
-		thisPtr->getFontImportOptions()->setBold(value);
-	}
-
-	bool ScriptFontImportOptions::internal_GetItalic(ScriptFontImportOptions* thisPtr)
-	{
-		return thisPtr->getFontImportOptions()->getItalic();
-	}
-
-	void ScriptFontImportOptions::internal_SetItalic(ScriptFontImportOptions* thisPtr, bool value)
-	{
-		thisPtr->getFontImportOptions()->setItalic(value);
-	}
-
-	MonoArray* ScriptFontImportOptions::internal_GetCharRanges(ScriptFontImportOptions* thisPtr)
-	{
-		Vector<std::pair<UINT32, UINT32>> charRanges = thisPtr->getFontImportOptions()->getCharIndexRanges();
-
-		ScriptArray outArray = ScriptArray::create<ScriptCharRange>((UINT32)charRanges.size());
-		for (UINT32 i = 0; i < (UINT32)charRanges.size(); i++)
-		{
-			CharRange range;
-			range.start = charRanges[i].first;
-			range.end = charRanges[i].second;
-			outArray.set(i, range);
-		}
-
-		return outArray.getInternal();
-	}
-
-	void ScriptFontImportOptions::internal_SetCharRanges(ScriptFontImportOptions* thisPtr, MonoArray* value)
-	{
-		ScriptArray inArray(value);
-
-		thisPtr->getFontImportOptions()->clearCharIndexRanges();
-		for (UINT32 i = 0; i < inArray.size(); i++)
-		{
-			CharRange range = inArray.get<CharRange>(i);
-			thisPtr->getFontImportOptions()->addCharIndexRange(range.start, range.end);
-		}
-	}
-
-	ScriptScriptCodeImportOptions::ScriptScriptCodeImportOptions(MonoObject* instance)
-		:ScriptObject(instance)
-	{
-		mImportOptions = bs_shared_ptr_new<ScriptCodeImportOptions>();
-	}
-
-	void ScriptScriptCodeImportOptions::initRuntimeData()
-	{
-		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()
-	{
-		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)
-	{
-		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);
-	}
-
-	ScriptAudioClipImportOptions::ScriptAudioClipImportOptions(MonoObject* instance)
-		:ScriptObject(instance)
-	{
-		mImportOptions = bs_shared_ptr_new<AudioClipImportOptions>();
-	}
-
-	void ScriptAudioClipImportOptions::initRuntimeData()
-	{
-		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()
-	{
-		return std::static_pointer_cast<AudioClipImportOptions>(mImportOptions);
-	}
-
-	MonoObject* ScriptAudioClipImportOptions::create()
-	{
-		return metaData.scriptClass->createInstance();
-	}
-
-	MonoObject* ScriptAudioClipImportOptions::create(const SPtr<AudioClipImportOptions>& options)
-	{
-		MonoObject* managedInstance = metaData.scriptClass->createInstance();
-		ScriptAudioClipImportOptions* scriptObj = ScriptAudioClipImportOptions::toNative(managedInstance);
-		scriptObj->mImportOptions = options;
-
-		return managedInstance;
-	}
-
-	void ScriptAudioClipImportOptions::internal_CreateInstance(MonoObject* instance)
-	{
-		new (bs_alloc<ScriptAudioClipImportOptions>()) ScriptAudioClipImportOptions(instance);
-	}
-
-	AudioFormat ScriptAudioClipImportOptions::internal_GetFormat(ScriptAudioClipImportOptions* thisPtr)
-	{
-		auto io = thisPtr->getClipImportOptions();
-		return io->getFormat();
-	}
-
-	void ScriptAudioClipImportOptions::internal_SetFormat(ScriptAudioClipImportOptions* thisPtr, AudioFormat format)
-	{
-		auto io = thisPtr->getClipImportOptions();
-		io->setFormat(format);
-	}
-
-	AudioReadMode ScriptAudioClipImportOptions::internal_GetReadMode(ScriptAudioClipImportOptions* thisPtr)
-	{
-		auto io = thisPtr->getClipImportOptions();
-		return io->getReadMode();
-	}
-
-	void ScriptAudioClipImportOptions::internal_SetReadMode(ScriptAudioClipImportOptions* thisPtr, AudioReadMode readMode)
-	{
-		auto io = thisPtr->getClipImportOptions();
-		io->setReadMode(readMode);
-	}
-
-	bool ScriptAudioClipImportOptions::internal_GetIs3D(ScriptAudioClipImportOptions* thisPtr)
-	{
-		auto io = thisPtr->getClipImportOptions();
-		return io->getIs3D();
-	}
-
-	void ScriptAudioClipImportOptions::internal_SetIs3D(ScriptAudioClipImportOptions* thisPtr, bool is3d)
-	{
-		auto io = thisPtr->getClipImportOptions();
-		io->setIs3D(is3d);
-	}
-
-	UINT32 ScriptAudioClipImportOptions::internal_GetBitDepth(ScriptAudioClipImportOptions* thisPtr)
-	{
-		auto io = thisPtr->getClipImportOptions();
-		return io->getBitDepth();
-	}
-
-	void ScriptAudioClipImportOptions::internal_SetBitDepth(ScriptAudioClipImportOptions* thisPtr, UINT32 bitDepth)
-	{
-		auto io = thisPtr->getClipImportOptions();
-		io->setBitDepth(bitDepth);
-	}
-
-	MonoField* ScriptAnimationSplitInfo::nameField = nullptr;
-	MonoField* ScriptAnimationSplitInfo::startFrameField = nullptr;
-	MonoField* ScriptAnimationSplitInfo::endFrameField = nullptr;
-	MonoField* ScriptAnimationSplitInfo::isAdditiveField = nullptr;
-
-	ScriptAnimationSplitInfo::ScriptAnimationSplitInfo(MonoObject* instance)
-		:ScriptObject(instance)
-	{ }
-
-	void ScriptAnimationSplitInfo::initRuntimeData()
-	{
-		nameField = metaData.scriptClass->getField("name");
-		startFrameField = metaData.scriptClass->getField("startFrame");
-		endFrameField = metaData.scriptClass->getField("endFrame");
-		isAdditiveField = metaData.scriptClass->getField("isAdditive");
-	}
-
-	AnimationSplitInfo ScriptAnimationSplitInfo::fromManaged(MonoObject* instance)
-	{
-		AnimationSplitInfo output;
-
-		MonoString* monoName = nullptr;
-		nameField->get(instance, &monoName);
-
-		output.name = MonoUtil::monoToString(monoName);
-
-		startFrameField->get(instance, &output.startFrame);
-		endFrameField->get(instance, &output.endFrame);
-		isAdditiveField->get(instance, &output.isAdditive);
-
-		return output;
-	}
-
-	MonoObject* ScriptAnimationSplitInfo::toManaged(const AnimationSplitInfo& splitInfo)
-	{
-		MonoString* monoString = MonoUtil::stringToMono(splitInfo.name);
-		UINT32 startFrame = splitInfo.startFrame;
-		UINT32 endFrame = splitInfo.endFrame;
-		bool isAdditive = splitInfo.isAdditive;
-
-		void* params[4] = { monoString, &startFrame, &endFrame, &isAdditive };
-		return metaData.scriptClass->createInstance("string,int,int,bool", params);
-	}
-
-	MonoField* ScriptImportedAnimationEvents::nameField = nullptr;
-	MonoField* ScriptImportedAnimationEvents::eventsField = nullptr;
-
-	ScriptImportedAnimationEvents::ScriptImportedAnimationEvents(MonoObject* instance)
-		:ScriptObject(instance)
-	{ }
-
-	void ScriptImportedAnimationEvents::initRuntimeData()
-	{
-		nameField = metaData.scriptClass->getField("name");
-		eventsField = metaData.scriptClass->getField("events");
-	}
-
-	ImportedAnimationEvents ScriptImportedAnimationEvents::fromManaged(MonoObject* instance)
-	{
-		ImportedAnimationEvents output;
-
-		MonoString* monoName = nullptr;
-		nameField->get(instance, &monoName);
-
-		output.name = MonoUtil::monoToString(monoName);
-
-		MonoArray* monoEvents;
-		eventsField->get(instance, &monoEvents);
-
-		if (monoEvents != nullptr)
-		{
-			ScriptArray scriptEvents(monoEvents);
-			for (UINT32 i = 0; i < scriptEvents.size(); i++)
-			{
-				AnimationEvent event = ScriptAnimationEvent::fromInterop(scriptEvents.get<__AnimationEventInterop>(i));
-				output.events.push_back(event);
-			}
-		}
-
-		return output;
-	}
-
-	MonoObject* ScriptImportedAnimationEvents::toManaged(const ImportedAnimationEvents& events)
-	{
-		MonoString* monoString = MonoUtil::stringToMono(events.name);
-		
-		UINT32 numEvents = (UINT32)events.events.size();
-		ScriptArray scriptEvents = ScriptArray::create<ScriptAnimationEvent>(numEvents);
-
-		for (UINT32 i = 0; i < numEvents; i++)
-			scriptEvents.set(i, ScriptAnimationEvent::toInterop(events.events[i]));
-
-		MonoObject* instance = metaData.scriptClass->createInstance();
-		nameField->set(instance, monoString);
-		eventsField->set(instance, scriptEvents.getInternal());
-
-		return instance;
-	}
-}

Source/EditorScript/Wrappers/BsScriptImportOptions.h

@@ -1,287 +0,0 @@
-//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
-//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
-#pragma once
-
-#include "BsScriptEditorPrerequisites.h"
-#include "BsScriptObject.h"
-#include "Image/BsPixelData.h"
-#include "Audio/BsAudioClipImportOptions.h"
-#include "Importer/BsMeshImportOptions.h"
-#include "RenderAPI/BsGpuProgram.h"
-
-namespace bs
-{
-	/** @addtogroup ScriptInteropEditor
-	 *  @{
-	 */
-
-	enum class FontRenderMode;
-
-	/**	Interop class between C++ & CLR for CharRange. */
-	class BS_SCR_BED_EXPORT ScriptCharRange : public ScriptObject <ScriptCharRange>
-	{
-	public:
-		SCRIPT_OBJ(EDITOR_ASSEMBLY, "BansheeEditor", "CharRange")
-
-	private:
-		ScriptCharRange(MonoObject* instance);
-	};
-
-	/** Base class for all C++/CLR interop objects wrapping various implementations of ImportOptions. */
-	class BS_SCR_BED_EXPORT ScriptImportOptionsBase : public ScriptObjectBase
-	{
-	public:
-		/**	Returns the internal native import options. */
-		SPtr<ImportOptions> getImportOptions() const { return mImportOptions; }
-
-	protected:
-		ScriptImportOptionsBase(MonoObject* instance);
-		virtual ~ScriptImportOptionsBase() {}
-
-		SPtr<ImportOptions> mImportOptions;
-	};
-
-	/**	Interop class between C++ & CLR for ImportOptions. */
-	class BS_SCR_BED_EXPORT ScriptImportOptions : public ScriptObject <ScriptImportOptions, ScriptImportOptionsBase>
-	{
-	public:
-		SCRIPT_OBJ(EDITOR_ASSEMBLY, "BansheeEditor", "ImportOptions")
-
-		/** Creates a new managed ImportOptions instance containing the provided import options. */
-		static MonoObject* create(const SPtr<ImportOptions>& importOptions);
-
-	private:
-		ScriptImportOptions(MonoObject* instance);
-	};
-
-	/**	Interop class between C++ & CLR for TextureImportOptions. */
-	class BS_SCR_BED_EXPORT ScriptTextureImportOptions : public ScriptObject<ScriptTextureImportOptions, ScriptImportOptionsBase>
-	{
-	public:
-		SCRIPT_OBJ(EDITOR_ASSEMBLY, "BansheeEditor", "TextureImportOptions")
-
-		/** Creates a new managed TextureImportOptions instance containing the default import options for textures. */
-		static MonoObject* create();
-
-		/**	Creates a new managed TextureImportOptions instance containing the provided import options. */
-		static MonoObject* create(const SPtr<TextureImportOptions>& options);
-
-	private:
-		ScriptTextureImportOptions(MonoObject* instance);
-
-		/**	Returns the internal native import options. */
-		SPtr<TextureImportOptions> getTexImportOptions();
-
-		/************************************************************************/
-		/* 								CLR HOOKS						   		*/
-		/************************************************************************/
-		static void internal_CreateInstance(MonoObject* instance);
-		static PixelFormat internal_GetPixelFormat(ScriptTextureImportOptions* thisPtr);
-		static void internal_SetPixelFormat(ScriptTextureImportOptions* thisPtr, PixelFormat value);
-		static bool internal_GetGenerateMipmaps(ScriptTextureImportOptions* thisPtr);
-		static void internal_SetGenerateMipmaps(ScriptTextureImportOptions* thisPtr, bool value);
-		static UINT32 internal_GetMaxMipmapLevel(ScriptTextureImportOptions* thisPtr);
-		static void internal_SetMaxMipmapLevel(ScriptTextureImportOptions* thisPtr, UINT32 value);
-		static bool internal_GetCPUCached(ScriptTextureImportOptions* thisPtr);
-		static void internal_SetCPUCached(ScriptTextureImportOptions* thisPtr, bool value);
-		static bool internal_GetIsSRGB(ScriptTextureImportOptions* thisPtr);
-		static void internal_SetIsSRGB(ScriptTextureImportOptions* thisPtr, bool value);
-		static bool internal_GetIsCubemap(ScriptTextureImportOptions* thisPtr);
-		static void internal_SetIsCubemap(ScriptTextureImportOptions* thisPtr, bool value);
-		static CubemapSourceType internal_GetCubemapSourceType(ScriptTextureImportOptions* thisPtr);
-		static void internal_SetCubemapSourceType(ScriptTextureImportOptions* thisPtr, CubemapSourceType value);
-	};
-
-	/**	Interop class between C++ & CLR for MeshImportOptions. */
-	class BS_SCR_BED_EXPORT ScriptMeshImportOptions : public ScriptObject<ScriptMeshImportOptions, ScriptImportOptionsBase>
-	{
-	public:
-		SCRIPT_OBJ(EDITOR_ASSEMBLY, "BansheeEditor", "MeshImportOptions")
-
-		/**	Creates a new managed MeshImportOptions instance containing the default import options for textures. */
-		static MonoObject* create();
-
-		/** Creates a new managed MeshImportOptions instance containing the provided import options. */
-		static MonoObject* create(const SPtr<MeshImportOptions>& options);
-
-	private:
-		ScriptMeshImportOptions(MonoObject* instance);
-
-		/**	Returns the internal native import options. */
-		SPtr<MeshImportOptions> getMeshImportOptions();
-
-		/************************************************************************/
-		/* 								CLR HOOKS						   		*/
-		/************************************************************************/
-		static void internal_CreateInstance(MonoObject* instance);
-		static bool internal_GetCPUCached(ScriptMeshImportOptions* thisPtr);
-		static void internal_SetCPUCached(ScriptMeshImportOptions* thisPtr, bool value);
-		static bool internal_GetImportNormals(ScriptMeshImportOptions* thisPtr);
-		static void internal_SetImportNormals(ScriptMeshImportOptions* thisPtr, bool value);
-		static bool internal_GetImportTangents(ScriptMeshImportOptions* thisPtr);
-		static void internal_SetImportTangents(ScriptMeshImportOptions* thisPtr, bool value);
-		static bool internal_GetImportSkin(ScriptMeshImportOptions* thisPtr);
-		static void internal_SetImportSkin(ScriptMeshImportOptions* thisPtr, bool value);
-		static bool internal_GetImportAnimation(ScriptMeshImportOptions* thisPtr);
-		static void internal_SetImportAnimation(ScriptMeshImportOptions* thisPtr, bool value);
-		static bool internal_GetImportBlendShapes(ScriptMeshImportOptions* thisPtr);
-		static void internal_SetImportBlendShapes(ScriptMeshImportOptions* thisPtr, bool value);
-		static bool internal_GetKeyFrameReduction(ScriptMeshImportOptions* thisPtr);
-		static void internal_SetKeyFrameReduction(ScriptMeshImportOptions* thisPtr, bool value);
-		static bool internal_GetRootMotion(ScriptMeshImportOptions* thisPtr);
-		static void internal_SetRootMotion(ScriptMeshImportOptions* thisPtr, bool value);
-		static float internal_GetScale(ScriptMeshImportOptions* thisPtr);
-		static void internal_SetScale(ScriptMeshImportOptions* thisPtr, float value);
-		static int internal_GetCollisionMeshType(ScriptMeshImportOptions* thisPtr);
-		static void internal_SetCollisionMeshType(ScriptMeshImportOptions* thisPtr, int value);
-		static MonoArray* internal_GetAnimationClipSplits(ScriptMeshImportOptions* thisPtr);
-		static void internal_SetAnimationClipSplits(ScriptMeshImportOptions* thisPtr, MonoArray* value);
-		static MonoArray* internal_GetAnimationEvents(ScriptMeshImportOptions* thisPtr);
-		static void internal_SetAnimationEvents(ScriptMeshImportOptions* thisPtr, MonoArray* value);
-	};
-
-	/**	Interop class between C++ & CLR for FontImportOptions. */
-	class BS_SCR_BED_EXPORT ScriptFontImportOptions : public ScriptObject <ScriptFontImportOptions, ScriptImportOptionsBase>
-	{
-	public:
-		SCRIPT_OBJ(EDITOR_ASSEMBLY, "BansheeEditor", "FontImportOptions")
-
-		/** Creates a new managed FontImportOptions instance containing the default import options for fonts. */
-		static MonoObject* create();
-
-		/**	Creates a new managed FontImportOptions instance containing the provided import options. */
-		static MonoObject* create(const SPtr<FontImportOptions>& options);
-
-	private:
-		ScriptFontImportOptions(MonoObject* instance);
-
-		/**	Returns the internal native import options. */
-		SPtr<FontImportOptions> getFontImportOptions();
-
-		/************************************************************************/
-		/* 								CLR HOOKS						   		*/
-		/************************************************************************/
-		static void internal_CreateInstance(MonoObject* instance);
-		static MonoArray* internal_GetFontSizes(ScriptFontImportOptions* thisPtr);
-		static void internal_SetFontSizes(ScriptFontImportOptions* thisPtr, MonoArray* value);
-		static UINT32 internal_GetDPI(ScriptFontImportOptions* thisPtr);
-		static void internal_SetDPI(ScriptFontImportOptions* thisPtr, UINT32 value);
-		static FontRenderMode internal_GetRenderMode(ScriptFontImportOptions* thisPtr);
-		static void internal_SetRenderMode(ScriptFontImportOptions* thisPtr, FontRenderMode value);
-		static bool internal_GetBold(ScriptFontImportOptions* thisPtr);
-		static void internal_SetBold(ScriptFontImportOptions* thisPtr, bool value);
-		static bool internal_GetItalic(ScriptFontImportOptions* thisPtr);
-		static void internal_SetItalic(ScriptFontImportOptions* thisPtr, bool value);
-		static MonoArray* internal_GetCharRanges(ScriptFontImportOptions* thisPtr);
-		static void internal_SetCharRanges(ScriptFontImportOptions* thisPtr, MonoArray* value);
-	};
-
-	/**	Interop class between C++ & CLR for ScriptCodeImportOptions. */
-	class BS_SCR_BED_EXPORT ScriptScriptCodeImportOptions : public ScriptObject <ScriptScriptCodeImportOptions, ScriptImportOptionsBase>
-	{
-	public:
-		SCRIPT_OBJ(EDITOR_ASSEMBLY, "BansheeEditor", "ScriptCodeImportOptions")
-
-		/**
-		 * Creates a new managed ScriptCodeImportOptions instance containing the default import options for script code 
-		 * files.
-		 */
-		static MonoObject* create();
-
-		/** Creates a new managed ScriptCodeImportOptions instance containing the provided import options. */
-		static MonoObject* create(const SPtr<ScriptCodeImportOptions>& options);
-
-	private:
-		ScriptScriptCodeImportOptions(MonoObject* instance);
-
-		/**	Returns the internal native import options. */
-		SPtr<ScriptCodeImportOptions> getCodeImportOptions();
-
-		/************************************************************************/
-		/* 								CLR HOOKS						   		*/
-		/************************************************************************/
-		static void internal_CreateInstance(MonoObject* instance);
-		static bool internal_IsEditorScript(ScriptScriptCodeImportOptions* thisPtr);
-		static void internal_SetEditorScript(ScriptScriptCodeImportOptions* thisPtr, bool value);
-	};
-
-	/**	Interop class between C++ & CLR for AudioClipImportOptions. */
-	class BS_SCR_BED_EXPORT ScriptAudioClipImportOptions : public ScriptObject <ScriptAudioClipImportOptions, ScriptImportOptionsBase>
-	{
-	public:
-		SCRIPT_OBJ(EDITOR_ASSEMBLY, "BansheeEditor", "AudioClipImportOptions")
-
-		/** Creates a new managed AudioClipImportOptions instance containing the default import options for audio files. */
-		static MonoObject* create();
-
-		/** Creates a new managed AudioClipImportOptions instance containing the provided import options. */
-		static MonoObject* create(const SPtr<AudioClipImportOptions>& options);
-
-	private:
-		ScriptAudioClipImportOptions(MonoObject* instance);
-
-		/**	Returns the internal native import options. */
-		SPtr<AudioClipImportOptions> getClipImportOptions();
-
-		/************************************************************************/
-		/* 								CLR HOOKS						   		*/
-		/************************************************************************/
-		static void internal_CreateInstance(MonoObject* instance);
-		static AudioFormat internal_GetFormat(ScriptAudioClipImportOptions* thisPtr);
-		static void internal_SetFormat(ScriptAudioClipImportOptions* thisPtr, AudioFormat format);
-		static AudioReadMode internal_GetReadMode(ScriptAudioClipImportOptions* thisPtr);
-		static void internal_SetReadMode(ScriptAudioClipImportOptions* thisPtr, AudioReadMode readMode);
-		static bool internal_GetIs3D(ScriptAudioClipImportOptions* thisPtr);
-		static void internal_SetIs3D(ScriptAudioClipImportOptions* thisPtr, bool is3d);
-		static UINT32 internal_GetBitDepth(ScriptAudioClipImportOptions* thisPtr);
-		static void internal_SetBitDepth(ScriptAudioClipImportOptions* thisPtr, UINT32 bitDepth);
-	};
-
-	/** Helper class for dealing with AnimationSplitInfo structure. */
-	class BS_SCR_BED_EXPORT ScriptAnimationSplitInfo : public ScriptObject<ScriptAnimationSplitInfo>
-	{
-	public:
-		SCRIPT_OBJ(EDITOR_ASSEMBLY, "BansheeEditor", "AnimationSplitInfo")
-
-		/** Converts managed split info to its native counterpart. */
-		static AnimationSplitInfo fromManaged(MonoObject* object);
-
-		/** Converts native split info to its managed counterpart. */
-		static MonoObject* toManaged(const AnimationSplitInfo& splitInfo);
-
-	private:
-		ScriptAnimationSplitInfo(MonoObject* instance);
-
-		/************************************************************************/
-		/* 								CLR HOOKS						   		*/
-		/************************************************************************/
-		static MonoField* nameField;
-		static MonoField* startFrameField;
-		static MonoField* endFrameField;
-		static MonoField* isAdditiveField;
-	};
-
-	/** Helper class for dealing with ImportedAnimationEvents structure. */
-	class BS_SCR_BED_EXPORT ScriptImportedAnimationEvents : public ScriptObject<ScriptImportedAnimationEvents>
-	{
-	public:
-		SCRIPT_OBJ(EDITOR_ASSEMBLY, "BansheeEditor", "ImportedAnimationEvents")
-
-		/** Converts managed events info to its native counterpart. */
-		static ImportedAnimationEvents fromManaged(MonoObject* object);
-
-		/** Converts native events info to its managed counterpart. */
-		static MonoObject* toManaged(const ImportedAnimationEvents& events);
-
-	private:
-		ScriptImportedAnimationEvents(MonoObject* instance);
-
-		/************************************************************************/
-		/* 								CLR HOOKS						   		*/
-		/************************************************************************/
-		static MonoField* nameField;
-		static MonoField* eventsField;
-	};
-
-	/** @} */
-}

Source/EditorScript/Wrappers/BsScriptProjectLibrary.cpp

@@ -10,13 +10,13 @@
 #include "Library/BsProjectResourceMeta.h"
 #include "BsScriptResourceManager.h"
 #include "Serialization/BsScriptAssemblyManager.h"
-#include "Wrappers/BsScriptImportOptions.h"
 #include "BsEditorApplication.h"
 #include "Serialization/BsManagedSerializableObject.h"
 #include "Reflection/BsRTTIType.h"
 #include "BsManagedResourceMetaData.h"
 
-#include "BsScriptProjectResourceIcons.generated.h"
+#include "Generated/BsScriptProjectResourceIcons.generated.h"
+#include "Generated/BsScriptImportOptions.editor.generated.h"
 
 using namespace std::placeholders;
 
@@ -130,7 +130,7 @@ namespace bs
 		if (options != nullptr)
 		{
 			ScriptImportOptions* scriptOptions = ScriptImportOptions::toNative(options);
-			nativeOptions = scriptOptions->getImportOptions();
+			nativeOptions = scriptOptions->getInternal();
 		}
 
 		gProjectLibrary().reimport(assetPath, nativeOptions, force);

Source/EditorScript/Wrappers/BsScriptSceneGizmos.cpp

@@ -5,7 +5,7 @@
 #include "BsScriptGizmoManager.h"
 #include "Components/BsCCamera.h"
 
-#include "BsScriptCCamera.generated.h"
+#include "Generated/BsScriptCCamera.generated.h"
 
 namespace bs
 {

Source/EditorScript/Wrappers/BsScriptSceneGrid.cpp

@@ -5,7 +5,7 @@
 #include "Scene/BsSceneGrid.h"
 #include "Components/BsCCamera.h"
 
-#include "BsScriptCCamera.generated.h"
+#include "Generated/BsScriptCCamera.generated.h"
 
 namespace bs
 {

Source/EditorScript/Wrappers/BsScriptSceneHandles.cpp

@@ -10,7 +10,7 @@
 #include "BsEditorApplication.h"
 #include "Components/BsCCamera.h"
 
-#include "BsScriptCCamera.generated.h"
+#include "Generated/BsScriptCCamera.generated.h"
 
 namespace bs
 {

Source/EditorScript/Wrappers/GUI/BsScriptGUITextureField.cpp

@@ -14,8 +14,8 @@
 
 #include "Generated/BsScriptGUIContent.generated.h"
 #include "Generated/BsScriptTexture.generated.h"
+#include "Generated/BsScriptSpriteTexture.generated.h"
 #include "Wrappers/BsScriptRRefBase.h"
-#include "BsScriptSpriteTexture.generated.h"
 
 using namespace std::placeholders;
 

Source/Game/CMakeLists.txt

@@ -52,7 +52,7 @@ endif()
 
 # Libraries
 ## Local libs
-target_link_libraries(Game bsf)
+target_link_libraries(Game bsfScript bsfMono bsf)
 
 # IDE specific
 set_property(TARGET Game PROPERTY FOLDER Executable)

Source/Game/Main.cpp

@@ -14,6 +14,7 @@
 #include "RenderAPI/BsRenderAPI.h"
 #include "Resources/BsGameResourceManager.h"
 #include "BsEngineConfig.h"
+#include "BsEngineScriptLibrary.h"
 
 void runApplication();
 
@@ -56,6 +57,9 @@ using namespace bs;
 
 void runApplication()
 {
+	SPtr<EngineScriptLibrary> library = bs_shared_ptr_new<EngineScriptLibrary>();
+	ScriptManager::_setScriptLibrary(library);
+
 	Path gameSettingsPath = Paths::getGameSettingsPath();
 
 	FileDecoder fd(gameSettingsPath);
@@ -78,7 +82,6 @@ void runApplication()
 	startUpDesc.renderer = BS_RENDERER_MODULE;
 	startUpDesc.audio = BS_AUDIO_MODULE;
 	startUpDesc.physics = BS_PHYSICS_MODULE;
-	startUpDesc.scripting = true;
 	startUpDesc.physicsCooking = false;
 
 	startUpDesc.primaryWindowDesc.videoMode = VideoMode(resolutionWidth, resolutionHeight);
@@ -109,8 +112,8 @@ void runApplication()
 			SPtr<RenderWindow> window = gApplication().getPrimaryWindow();
 			window->setFullscreen(selectedVideoMode);
 
-			resolutionWidth = selectedVideoMode.getWidth();
-			resolutionHeight = selectedVideoMode.getHeight();
+			resolutionWidth = selectedVideoMode.width;
+			resolutionHeight = selectedVideoMode.height;
 		}
 		else
 		{

Source/bsf

@@ -1 +1 @@
-Subproject commit b96c9a9c683bee88a075a71d01e00b73ae52a652
+Subproject commit d517576b91f11f0603dd17d45cc94ce64f360454