Feature: SBGen is no longer a required dependency, generated files are instead distributed

 - Also updated to the most recent bsf version

.gitignore

@@ -24,6 +24,4 @@ Documentation/html
 *.aps
 *.opendb
 Source/Experimental
-Source/Scripting/MBansheeEngine/Generated
-Source/Scripting/MBansheeEditor/Generated
 .vs/*

CMakeLists.txt

@@ -2,6 +2,7 @@ cmake_minimum_required (VERSION 3.9.0)
 project (Banshee3D)
 
 set (BSF_SOURCE_DIR ${PROJECT_SOURCE_DIR}/Source/bsf/Source)
+set (APP_ROOT_DIR ${PROJECT_SOURCE_DIR})
 set (BS_IS_BANSHEE3D 1)
 
 # Grab BSF
@@ -24,12 +25,12 @@ include(${BSF_SOURCE_DIR}/CMake/HelperMethods.cmake)
 
 add_subdirectory(${BSF_SOURCE_DIR})
 
-set (BS_PREBUILT_DEPENDENCIES_VERSION 22)
+set (BS_PREBUILT_DEPENDENCIES_VERSION 23)
 set (BS_SRC_DEPENDENCIES_VERSION 15)
 set (BS_BUILTIN_ASSETS_VERSION 4)
 
 # Options
-set(GENERATE_SCRIPT_BINDINGS ON CACHE BOOL "If true, script binding files will be generated. Script bindings are required for the project to build properly, however they take a while to generate. If you are sure the script bindings are up to date, you can turn off their generation (temporarily) to speed up the build.")
+set(GENERATE_SCRIPT_BINDINGS OFF CACHE BOOL "If true, script binding files will be generated. Script bindings are required for the project to build properly, however they take a while to generate. If you are sure the script bindings are up to date, you can turn off their generation (temporarily) to speed up the build.")
 
 # Ensure dependencies are up to date
 ## Check prebuilt dependencies that are downloaded in a .zip

Documentation/GitHub/dependencies.md

@@ -123,6 +123,7 @@ Additionally, if the dependency structure still isn't clear, download one of the
    
 **bison**
 - Bison 3.0.4
+- Only required if BUILD_BSL option is specified during the build (off by default)
 - **Windows**
   - http://sourceforge.net/projects/winflexbison/files/
 - **Linux**
@@ -133,6 +134,7 @@ Additionally, if the dependency structure still isn't clear, download one of the
  
 **flex**
 - Flex 2.6.1
+- Only required if BUILD_BSL option is specified during the build (off by default)
 - **Windows**
   - http://sourceforge.net/projects/winflexbison/files/
 - **Linux**
@@ -143,6 +145,7 @@ Additionally, if the dependency structure still isn't clear, download one of the
 
 **BansheeSBGen**
  - Banshee Script Binding Generator 1.0
+ - Only required if GENERATE_SCRIPT_BINDINGS option is specified during the build (off by default)
  - https://github.com/BearishSun/BansheeSBGen
  - Required for generation of C# script binding files. Not required if not using the scripting sub-system.
  - Executable (tool)

Source/EditorCore/Library/BsProjectLibrary.cpp

@@ -468,7 +468,7 @@ namespace bs
 
 				if (!isNativeResource)
 				{
-					Vector<SubResourceRaw> importedResourcesRaw = gImporter()._importAllRaw(fileEntry->path, curImportOptions);
+					Vector<SubResourceRaw> importedResourcesRaw = gImporter()._importAll(fileEntry->path, curImportOptions);
 					Vector<SPtr<ProjectResourceMeta>> existingResourceMetas = fileEntry->meta->getAllResourceMetaData();
 					fileEntry->meta->clearResourceMetaData();
 

Source/EditorCore/SceneView/BsScenePicking.cpp

@@ -127,21 +127,23 @@ namespace bs
 						UINT32 idx = (UINT32)pickData.size();
 
 						bool useAlphaShader = false;
-						SPtr<RasterizerState> rasterizerState;
+						SPtr<RasterizerState> rasterizerState = RasterizerState::getDefault();
 
 						HMaterial originalMat = renderable->getMaterial(i);
 						if (originalMat != nullptr && originalMat->getNumPasses() > 0)
 						{
 							SPtr<Pass> firstPass = originalMat->getPass(0); // Note: We only ever check the first pass, problem?
-							useAlphaShader = firstPass->hasBlending();
-
-							if (firstPass->getRasterizerState() == nullptr)
-								rasterizerState = RasterizerState::getDefault();
-							else
-								rasterizerState = firstPass->getRasterizerState();
+							const auto& pipelineState = firstPass->getGraphicsPipelineState();
+							if(pipelineState)
+							{
+								useAlphaShader = firstPass->hasBlending();
+
+								if (pipelineState->getRasterizerState() == nullptr)
+									rasterizerState = RasterizerState::getDefault();
+								else
+									rasterizerState = pipelineState->getRasterizerState();
+							}
 						}
-						else
-							rasterizerState = RasterizerState::getDefault();
 
 						CullingMode cullMode = rasterizerState->getProperties().getCullMode();
 

Source/Scripting/MBansheeEngine/Generated/AmbientOcclusionSettings.generated.cs

@@ -0,0 +1,139 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Rendering
+	 *  @{
+	 */
+
+	/// <summary>Settings that control screen space ambient occlusion.</summary>
+	public partial class AmbientOcclusionSettings : ScriptObject
+	{
+		private AmbientOcclusionSettings(bool __dummy0) { }
+
+		public AmbientOcclusionSettings()
+		{
+			Internal_AmbientOcclusionSettings(this);
+		}
+
+		/// <summary>Enables or disabled the screen space ambient occlusion effect.</summary>
+		public bool Enabled
+		{
+			get { return Internal_getenabled(mCachedPtr); }
+			set { Internal_setenabled(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Radius (in world space, in meters) over which occluders are searched for. Smaller radius ensures better sampling 
+		/// precision but can miss occluders. Larger radius ensures far away occluders are considered but can yield lower quality 
+		/// or noise because of low sampling precision. Usually best to keep at around a meter, valid range is roughly [0.05, 
+		/// 5.0].
+		/// </summary>
+		public float Radius
+		{
+			get { return Internal_getradius(mCachedPtr); }
+			set { Internal_setradius(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Bias used to reduce false occlusion artifacts. Higher values reduce the amount of artifacts but will cause details to 
+		/// be lost in areas where occlusion isn't high. Value is in millimeters. Usually best to keep at a few dozen 
+		/// millimeters, valid range is roughly [0, 200].
+		/// </summary>
+		public float Bias
+		{
+			get { return Internal_getbias(mCachedPtr); }
+			set { Internal_setbias(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Distance (in view space, in meters) after which AO starts fading out. The fade process will happen over the range as 
+		/// specified by
+		/// </summary>
+		public float FadeDistance
+		{
+			get { return Internal_getfadeDistance(mCachedPtr); }
+			set { Internal_setfadeDistance(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Range (in view space, in meters) in which AO fades out from 100% to 0%. AO starts fading out after the distance 
+		/// specified in
+		/// </summary>
+		public float FadeRange
+		{
+			get { return Internal_getfadeRange(mCachedPtr); }
+			set { Internal_setfadeRange(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Linearly scales the intensity of the AO effect. Values less than 1 make the AO effect less pronounced, and vice 
+		/// versa. Valid range is roughly [0.2, 2].
+		/// </summary>
+		public float Intensity
+		{
+			get { return Internal_getintensity(mCachedPtr); }
+			set { Internal_setintensity(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Controls how quickly does the AO darkening effect increase with higher occlusion percent. This is a non-linear 
+		/// control and will cause the darkening to ramp up exponentially. Valid range is roughly [1, 4], where 1 means no extra 
+		/// darkening will occur.
+		/// </summary>
+		public float Power
+		{
+			get { return Internal_getpower(mCachedPtr); }
+			set { Internal_setpower(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Quality level of generated ambient occlusion. In range [0, 4]. Higher levels yield higher quality AO at the cost of 
+		/// performance.
+		/// </summary>
+		public uint Quality
+		{
+			get { return Internal_getquality(mCachedPtr); }
+			set { Internal_setquality(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_AmbientOcclusionSettings(AmbientOcclusionSettings managedInstance);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getenabled(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setenabled(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getradius(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setradius(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getbias(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setbias(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getfadeDistance(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setfadeDistance(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getfadeRange(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setfadeRange(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getintensity(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setintensity(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getpower(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setpower(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getquality(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setquality(IntPtr thisPtr, uint value);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/AnimWrapMode.generated.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Animation
+	 *  @{
+	 */
+
+	/// <summary>Determines how an animation clip behaves when it reaches the end.</summary>
+	public enum AnimWrapMode
+	{
+		/// <summary>Loop around to the beginning/end when the last/first frame is reached.</summary>
+		Loop = 0,
+		/// <summary>Clamp to end/beginning, keeping the last/first frame active.</summary>
+		Clamp = 1
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/AnimationClip.generated.cs

@@ -0,0 +1,133 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Animation
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Contains animation curves for translation/rotation/scale of scene objects/skeleton bones, as well as curves for 
+	/// generic property animation.
+	/// </summary>
+	public partial class AnimationClip : Resource
+	{
+		private AnimationClip(bool __dummy0, bool __dummy1) { }
+		protected AnimationClip() { }
+
+		/// <summary>
+		/// Creates an animation clip with no curves. After creation make sure to register some animation curves before using it.
+		/// </summary>
+		public AnimationClip(bool isAdditive = false)
+		{
+			Internal_create(this, isAdditive);
+		}
+
+		/// <summary>Creates an animation clip with specified curves.</summary>
+		/// <param name="curves">Curves to initialize the animation with.</param>
+		/// <param name="isAdditive">
+		/// Determines does the clip contain additive curve data. This will change the behaviour how is the clip blended with 
+		/// other animations.
+		/// </param>
+		/// <param name="sampleRate">
+		/// If animation uses evenly spaced keyframes, number of samples per second. Not relevant if keyframes are unevenly 
+		/// spaced.
+		/// </param>
+		/// <param name="rootMotion">
+		/// Optional set of curves that can be used for animating the root bone. Not used by the animation system directly but is 
+		/// instead provided to the user for manual evaluation.
+		/// </param>
+		public AnimationClip(AnimationCurves curves, bool isAdditive = false, uint sampleRate = 1, RootMotion rootMotion = null)
+		{
+			Internal_create0(this, curves, isAdditive, sampleRate, rootMotion);
+		}
+
+		/// <summary>
+		/// A set of all curves stored in the animation. Returned value will not be updated if the animation clip curves are 
+		/// added or removed, as it is a copy of clip's internal values.
+		/// </summary>
+		public AnimationCurves Curves
+		{
+			get { return Internal_getCurves(mCachedPtr); }
+			set { Internal_setCurves(mCachedPtr, value); }
+		}
+
+		/// <summary>A set of all events to be triggered as the animation is playing.</summary>
+		public AnimationEvent[] Events
+		{
+			get { return Internal_getEvents(mCachedPtr); }
+			set { Internal_setEvents(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Returns a set of curves containing motion of the root bone. This allows the user to evaluate the root bone animation 
+		/// curves manually, instead of through the normal animation process. This property is only available if animation clip 
+		/// was imported with root motion import enabled.
+		/// </summary>
+		public RootMotion RootMotion
+		{
+			get { return Internal_getRootMotion(mCachedPtr); }
+		}
+
+		/// <summary>Checks if animation clip has root motion curves separate from the normal animation curves.</summary>
+		public bool HasRootMotion
+		{
+			get { return Internal_hasRootMotion(mCachedPtr); }
+		}
+
+		/// <summary>
+		/// Checks are the curves contained within the clip additive. Additive clips are intended to be added on top of other 
+		/// clips.
+		/// </summary>
+		public bool IsAddtive
+		{
+			get { return Internal_isAdditive(mCachedPtr); }
+		}
+
+		/// <summary>Returns the length of the animation clip, in seconds.</summary>
+		public float Length
+		{
+			get { return Internal_getLength(mCachedPtr); }
+		}
+
+		/// <summary>
+		/// Number of samples per second the animation clip curves were sampled at. This value is not used by the animation clip 
+		/// or curves directly since unevenly spaced keyframes are supported. But it can be of value when determining the 
+		/// original sample rate of an imported animation or similar.
+		/// </summary>
+		public uint SampleRate
+		{
+			get { return Internal_getSampleRate(mCachedPtr); }
+			set { Internal_setSampleRate(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern AnimationCurves Internal_getCurves(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setCurves(IntPtr thisPtr, AnimationCurves curves);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern AnimationEvent[] Internal_getEvents(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setEvents(IntPtr thisPtr, AnimationEvent[] events);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern RootMotion Internal_getRootMotion(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_hasRootMotion(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_isAdditive(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getLength(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getSampleRate(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setSampleRate(IntPtr thisPtr, uint sampleRate);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_create(AnimationClip managedInstance, bool isAdditive);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_create0(AnimationClip managedInstance, AnimationCurves curves, bool isAdditive, uint sampleRate, RootMotion rootMotion);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/AnimationClipState.generated.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Animation
+	 *  @{
+	 */
+
+	/// <summary>Contains information about a currently playing animation clip.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct AnimationClipState
+	{
+		/// <summary>Initializes the struct with default values.</summary>
+		public static AnimationClipState Default()
+		{
+			AnimationClipState value = new AnimationClipState();
+			value.layer = 0;
+			value.time = 0f;
+			value.speed = 1f;
+			value.weight = 1f;
+			value.wrapMode = AnimWrapMode.Loop;
+			value.stopped = false;
+
+			return value;
+		}
+
+		/// <summary>Layer the clip is playing on. Multiple clips can be played simulatenously on different layers.</summary>
+		public uint layer;
+		/// <summary>Current time the animation is playing from.</summary>
+		public float time;
+		/// <summary>Speed at which the animation is playing.</summary>
+		public float speed;
+		/// <summary>Determines how much of an influence does the clip have on the final pose.</summary>
+		public float weight;
+		/// <summary>Determines what happens to other animation clips when a new clip starts playing.</summary>
+		public AnimWrapMode wrapMode;
+		/// <summary>
+		/// Determines should the time be advanced automatically. Certain type of animation clips don't involve playback  (e.g. 
+		/// for blending where animation weight controls the animation).
+		/// </summary>
+		public bool stopped;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/AnimationCurveFlag.generated.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/// <summary>Flags that describe an animation curve.</summary>
+	public enum AnimationCurveFlags
+	{
+		/// <summary>
+		/// If enabled, the curve was imported from an external file and not created within the engine. This will affect how are 
+		/// animation results applied to scene objects (with imported animations it is assumed the curve is animating bones and 
+		/// with in-engine curves it is assumed the curve is animating scene objects).
+		/// </summary>
+		ImportedCurve = 1,
+		/// <summary>
+		/// Signifies the curve is used to animate between different frames within a morph channel. In range [0, 1].
+		/// </summary>
+		MorphFrame = 2,
+		/// <summary>Signifies the curve is used to adjust the weight of a morph channel. In range [0, 1].</summary>
+		MorphWeight = 4
+	}
+}

Source/Scripting/MBansheeEngine/Generated/AnimationCurves.generated.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Animation
+	 *  @{
+	 */
+
+	/// <summary>A set of animation curves representing translation/rotation/scale and generic animation.</summary>
+	public partial class AnimationCurves : ScriptObject
+	{
+		private AnimationCurves(bool __dummy0) { }
+
+		public AnimationCurves()
+		{
+			Internal_AnimationCurves(this);
+		}
+
+		/// <summary>Curves for animating scene object's position.</summary>
+		public NamedVector3Curve[] Position
+		{
+			get { return Internal_getPositionCurves(mCachedPtr); }
+			set { Internal_setPositionCurves(mCachedPtr, value); }
+		}
+
+		/// <summary>Curves for animating scene object's rotation.</summary>
+		public NamedQuaternionCurve[] Rotation
+		{
+			get { return Internal_getRotationCurves(mCachedPtr); }
+			set { Internal_setRotationCurves(mCachedPtr, value); }
+		}
+
+		/// <summary>Curves for animating scene object's scale.</summary>
+		public NamedVector3Curve[] Scale
+		{
+			get { return Internal_getScaleCurves(mCachedPtr); }
+			set { Internal_setScaleCurves(mCachedPtr, value); }
+		}
+
+		/// <summary>Curves for animating generic component properties.</summary>
+		public NamedFloatCurve[] Generic
+		{
+			get { return Internal_getGenericCurves(mCachedPtr); }
+			set { Internal_setGenericCurves(mCachedPtr, value); }
+		}
+
+		/// <summary>Registers a new curve used for animating position.</summary>
+		/// <param name="name">
+		/// Unique name of the curve. This name will be used mapping the curve to the relevant bone in a skeleton, if any.
+		/// </param>
+		/// <param name="curve">Curve to add to the clip.</param>
+		public void AddPositionCurve(string name, Vector3Curve curve)
+		{
+			Internal_addPositionCurve(mCachedPtr, name, curve);
+		}
+
+		/// <summary>Registers a new curve used for animating rotation.</summary>
+		/// <param name="name">
+		/// Unique name of the curve. This name will be used mapping the curve to the relevant bone in a skeleton, if any.
+		/// </param>
+		/// <param name="curve">Curve to add to the clip.</param>
+		public void AddRotationCurve(string name, QuaternionCurve curve)
+		{
+			Internal_addRotationCurve(mCachedPtr, name, curve);
+		}
+
+		/// <summary>Registers a new curve used for animating scale.</summary>
+		/// <param name="name">
+		/// Unique name of the curve. This name will be used mapping the curve to the relevant bone in a skeleton, if any.
+		/// </param>
+		/// <param name="curve">Curve to add to the clip.</param>
+		public void AddScaleCurve(string name, Vector3Curve curve)
+		{
+			Internal_addScaleCurve(mCachedPtr, name, curve);
+		}
+
+		/// <summary>Registers a new curve used for generic animation.</summary>
+		/// <param name="name">
+		/// Unique name of the curve. This can be used for retrieving the value of the curve from animation.
+		/// </param>
+		/// <param name="curve">Curve to add to the clip.</param>
+		public void AddGenericCurve(string name, AnimationCurve curve)
+		{
+			Internal_addGenericCurve(mCachedPtr, name, curve);
+		}
+
+		/// <summary>Removes an existing curve from the clip.</summary>
+		public void RemovePositionCurve(string name)
+		{
+			Internal_removePositionCurve(mCachedPtr, name);
+		}
+
+		/// <summary>Removes an existing curve from the clip.</summary>
+		public void RemoveRotationCurve(string name)
+		{
+			Internal_removeRotationCurve(mCachedPtr, name);
+		}
+
+		/// <summary>Removes an existing curve from the clip.</summary>
+		public void RemoveScaleCurve(string name)
+		{
+			Internal_removeScaleCurve(mCachedPtr, name);
+		}
+
+		/// <summary>Removes an existing curve from the clip.</summary>
+		public void RemoveGenericCurve(string name)
+		{
+			Internal_removeGenericCurve(mCachedPtr, name);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_AnimationCurves(AnimationCurves managedInstance);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_addPositionCurve(IntPtr thisPtr, string name, Vector3Curve curve);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_addRotationCurve(IntPtr thisPtr, string name, QuaternionCurve curve);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_addScaleCurve(IntPtr thisPtr, string name, Vector3Curve curve);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_addGenericCurve(IntPtr thisPtr, string name, AnimationCurve curve);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_removePositionCurve(IntPtr thisPtr, string name);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_removeRotationCurve(IntPtr thisPtr, string name);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_removeScaleCurve(IntPtr thisPtr, string name);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_removeGenericCurve(IntPtr thisPtr, string name);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern NamedVector3Curve[] Internal_getPositionCurves(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setPositionCurves(IntPtr thisPtr, NamedVector3Curve[] value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern NamedQuaternionCurve[] Internal_getRotationCurves(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setRotationCurves(IntPtr thisPtr, NamedQuaternionCurve[] value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern NamedVector3Curve[] Internal_getScaleCurves(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setScaleCurves(IntPtr thisPtr, NamedVector3Curve[] value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern NamedFloatCurve[] Internal_getGenericCurves(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setGenericCurves(IntPtr thisPtr, NamedFloatCurve[] value);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/AnimationEvent.generated.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Animation
+	 *  @{
+	 */
+
+	/// <summary>Event that is triggered when animation reaches a certain point.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct AnimationEvent
+	{
+		/// <summary>Initializes the struct with default values.</summary>
+		public static AnimationEvent Default()
+		{
+			AnimationEvent value = new AnimationEvent();
+			value.name = "";
+			value.time = 0f;
+
+			return value;
+		}
+
+		/// <summary>Constructs a new animation event.</summary>
+		/// <param name="name">Name used to identify the event when triggered.</param>
+		/// <param name="time">Time at which to trigger the event, in seconds.</param>
+		public AnimationEvent(string name, float time)
+		{
+			this.name = name;
+			this.time = time;
+		}
+
+		/// <summary>Name used to identify the event when triggered.</summary>
+		public string name;
+		/// <summary>Time at which to trigger the event, in seconds.</summary>
+		public float time;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/AnimationUtility.generated.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Animation
+	 *  @{
+	 */
+
+	/// <summary>Helper class for dealing with animations, animation clips and curves.</summary>
+	public partial class AnimationUtility : ScriptObject
+	{
+		private AnimationUtility(bool __dummy0) { }
+		protected AnimationUtility() { }
+
+		/// <summary>Converts a curve in euler angles (in degrees) into a curve using quaternions.</summary>
+		public static QuaternionCurve EulerToQuaternionCurve(Vector3Curve eulerCurve)
+		{
+			return Internal_eulerToQuaternionCurve(eulerCurve);
+		}
+
+		/// <summary>Converts a curve in quaternions into a curve using euler angles (in degrees).</summary>
+		public static Vector3Curve QuaternionToEulerCurve(QuaternionCurve quatCurve)
+		{
+			return Internal_quaternionToEulerCurve(quatCurve);
+		}
+
+		/// <summary>Splits a Vector3 curve into three individual curves, one for each component.</summary>
+		public static AnimationCurve[] SplitCurve(Vector3Curve compoundCurve)
+		{
+			return Internal_splitCurve(compoundCurve);
+		}
+
+		/// <summary>Combines three single component curves into a Vector3 curve.</summary>
+		public static Vector3Curve CombineCurve(AnimationCurve[] curveComponents)
+		{
+			return Internal_combineCurve(curveComponents);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern QuaternionCurve Internal_eulerToQuaternionCurve(Vector3Curve eulerCurve);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Vector3Curve Internal_quaternionToEulerCurve(QuaternionCurve quatCurve);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern AnimationCurve[] Internal_splitCurve(Vector3Curve compoundCurve);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Vector3Curve Internal_combineCurve(AnimationCurve[] curveComponents);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/AsyncOpEx.generated.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/// <summary>
+	/// Object you may use to check on the results of an asynchronous operation. Contains uninitialized data until  IsComplete 
+	/// returns true.
+	/// </summary>
+	public partial class AsyncOp : ScriptObject
+	{
+		private AsyncOp(bool __dummy0) { }
+		protected AsyncOp() { }
+
+		/// <summary>Returns true if the async operation has completed.</summary>
+		public bool IsComplete
+		{
+			get { return Internal_isComplete(mCachedPtr); }
+		}
+
+		/// <summary>Retrieves the value returned by the async operation. Only valid if IsComplete returns true.</summary>
+		public object ReturnValue
+		{
+			get { return Internal_getReturnValue(mCachedPtr); }
+		}
+
+		/// <summary>Blocks the caller thread until the AsyncOp completes.</summary>
+		public void BlockUntilComplete()
+		{
+			Internal_blockUntilComplete(mCachedPtr);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_isComplete(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern object Internal_getReturnValue(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_blockUntilComplete(IntPtr thisPtr);
+	}
+}

Source/Scripting/MBansheeEngine/Generated/Audio.generated.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Audio
+	 *  @{
+	 */
+
+	/// <summary>Provides global functionality relating to sounds and music.</summary>
+	public partial class Audio : ScriptObject
+	{
+		private Audio(bool __dummy0) { }
+		protected Audio() { }
+
+		/// <summary>Determines global audio volume. In range [0, 1].</summary>
+		public static float Volume
+		{
+			get { return Internal_getVolume(); }
+			set { Internal_setVolume(value); }
+		}
+
+		/// <summary>Determines if audio reproduction is paused globally.</summary>
+		public static bool Paused
+		{
+			get { return Internal_isPaused(); }
+			set { Internal_setPaused(value); }
+		}
+
+		/// <summary>Determines the device on which is the audio played back on.</summary>
+		public static AudioDevice ActiveDevice
+		{
+			get
+			{
+				AudioDevice temp;
+				Internal_getActiveDevice(out temp);
+				return temp;
+			}
+			set { Internal_setActiveDevice(ref value); }
+		}
+
+		/// <summary>Returns the default audio device identifier.</summary>
+		public static AudioDevice DefaultDevice
+		{
+			get
+			{
+				AudioDevice temp;
+				Internal_getDefaultDevice(out temp);
+				return temp;
+			}
+		}
+
+		/// <summary>Returns a list of all available audio devices.</summary>
+		public static AudioDevice[] AllDevices
+		{
+			get { return Internal_getAllDevices(); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setVolume(float volume);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getVolume();
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setPaused(bool paused);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_isPaused();
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setActiveDevice(ref AudioDevice device);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getActiveDevice(out AudioDevice __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getDefaultDevice(out AudioDevice __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern AudioDevice[] Internal_getAllDevices();
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/AudioClip.generated.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Audio
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Audio clip stores audio data in a compressed or uncompressed format. Clips can be provided to audio sources or other 
+	/// audio methods to be played.
+	/// </summary>
+	public partial class AudioClip : Resource
+	{
+		private AudioClip(bool __dummy0) { }
+		protected AudioClip() { }
+
+		/// <summary>Returns the size of a single sample, in bits.</summary>
+		public uint BitDepth
+		{
+			get { return Internal_getBitDepth(mCachedPtr); }
+		}
+
+		/// <summary>Returns how many samples per second is the audio encoded in.</summary>
+		public uint SampleRate
+		{
+			get { return Internal_getFrequency(mCachedPtr); }
+		}
+
+		/// <summary>Returns the number of channels provided by the clip.</summary>
+		public uint NumChannels
+		{
+			get { return Internal_getNumChannels(mCachedPtr); }
+		}
+
+		/// <summary>Returns in which format is audio data stored in.</summary>
+		public AudioFormat Format
+		{
+			get { return Internal_getFormat(mCachedPtr); }
+		}
+
+		/// <summary>Returns how is the audio data read/decoded.</summary>
+		public AudioReadMode ReadMode
+		{
+			get { return Internal_getReadMode(mCachedPtr); }
+		}
+
+		/// <summary>Returns the length of the audio clip, in seconds.</summary>
+		public float Duration
+		{
+			get { return Internal_getLength(mCachedPtr); }
+		}
+
+		/// <summary>Returns the total number of samples in the clip (includes all channels).</summary>
+		public uint NumSamples
+		{
+			get { return Internal_getNumSamples(mCachedPtr); }
+		}
+
+		/// <summary>Determines will the clip be played a spatial 3D sound, or as a normal sound (for example music).</summary>
+		public bool Is3D
+		{
+			get { return Internal_is3D(mCachedPtr); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getBitDepth(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getFrequency(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getNumChannels(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern AudioFormat Internal_getFormat(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern AudioReadMode Internal_getReadMode(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getLength(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getNumSamples(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_is3D(IntPtr thisPtr);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/AudioDevice.generated.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Audio
+	 *  @{
+	 */
+
+	/// <summary>Identifier for a device that can be used for playing audio.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct AudioDevice
+	{
+		public string name;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/AudioFormat.generated.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Audio
+	 *  @{
+	 */
+
+	/// <summary>Valid internal engine audio formats.</summary>
+	public enum AudioFormat
+	{
+		/// <summary>Pulse code modulation audio ("raw" uncompressed audio).</summary>
+		PCM = 0,
+		/// <summary>Vorbis compressed audio.</summary>
+		VORBIS = 1
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/AudioReadMode.generated.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Audio
+	 *  @{
+	 */
+
+	/// <summary>Modes that determine how and when is audio data read.</summary>
+	public enum AudioReadMode
+	{
+		/// <summary>Entire audio clip will be loaded and decompressed. Uses most memory but has lowest CPU impact.</summary>
+		LoadDecompressed = 0,
+		/// <summary>
+		/// Entire audio clip will be loaded, but will be decompressed while playing. Uses medium amount of memory and has the 
+		/// highest CPU impact.
+		/// </summary>
+		LoadCompressed = 1,
+		/// <summary>
+		/// Audio will be slowly streamed from the disk, and decompressed if needed. Uses very little memory, and has either low 
+		/// or high CPU impact depending if the audio is in a compressed format. Since data is streamed from the disk, read 
+		/// speeds could also be a bottleneck.
+		/// </summary>
+		Stream = 2
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/AudioSourceState.generated.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Audio
+	 *  @{
+	 */
+
+	/// <summary>Valid states in which AudioSource can be in.</summary>
+	public enum AudioSourceState
+	{
+		/// <summary>Source is currently playing.</summary>
+		Playing = 0,
+		/// <summary>Source is currently paused (play will resume from paused point).</summary>
+		Paused = 1,
+		/// <summary>Source is currently stopped (play will resume from start).</summary>
+		Stopped = 2
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/AutoExposureSettings.generated.cs

@@ -0,0 +1,148 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Rendering
+	 *  @{
+	 */
+
+	/// <summary>Settings that control automatic exposure (eye adaptation) post-process.</summary>
+	public partial class AutoExposureSettings : ScriptObject
+	{
+		private AutoExposureSettings(bool __dummy0) { }
+
+		public AutoExposureSettings()
+		{
+			Internal_AutoExposureSettings(this);
+		}
+
+		/// <summary>
+		/// Determines minimum luminance value in the eye adaptation histogram. The histogram is used for calculating the average 
+		/// brightness of the scene. Any luminance value below this value will not be included in the histogram and ignored in 
+		/// scene brightness calculations. In log2 units (-8 = 1/256). In the range [-16, 0].
+		/// </summary>
+		public float HistogramLog2Min
+		{
+			get { return Internal_gethistogramLog2Min(mCachedPtr); }
+			set { Internal_sethistogramLog2Min(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines maximum luminance value in the eye adaptation histogram. The histogram is used for calculating the average 
+		/// brightness of the scene. Any luminance value above this value will not be included in the histogram and ignored in 
+		/// scene brightness calculations. In log2 units (4 = 16). In the range [0, 16].
+		/// </summary>
+		public float HistogramLog2Max
+		{
+			get { return Internal_gethistogramLog2Max(mCachedPtr); }
+			set { Internal_sethistogramLog2Max(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Percentage below which to ignore values in the eye adaptation histogram. The histogram is used for calculating the 
+		/// average brightness of the scene. Total luminance in the histogram will be summed up and multiplied by this value to 
+		/// calculate minimal luminance. Luminance values below the minimal luminance will be ignored and not used in scene 
+		/// brightness calculations. This allows you to remove outliers on the lower end of the histogram (for example a few very 
+		/// dark pixels in an otherwise bright image). In range [0.0f, 1.0f].
+		/// </summary>
+		public float HistogramPctLow
+		{
+			get { return Internal_gethistogramPctLow(mCachedPtr); }
+			set { Internal_sethistogramPctLow(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Percentage above which to ignore values in the eye adaptation histogram. The histogram is used for calculating the 
+		/// average brightness of the scene. Total luminance in the histogram will be summed up and multiplied by this value to 
+		/// calculate maximum luminance. Luminance values above the maximum luminance will be ignored and not used in scene 
+		/// brightness calculations. This allows you to remove outliers on the high end of the histogram (for  example a few very 
+		/// bright pixels). In range [0.0f, 1.0f].
+		/// </summary>
+		public float HistogramPctHigh
+		{
+			get { return Internal_gethistogramPctHigh(mCachedPtr); }
+			set { Internal_sethistogramPctHigh(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Clamps the minimum eye adaptation scale to this value. This allows you to limit eye adaptation so that exposure is 
+		/// never too high (for example when in a very dark room you probably do not want the exposure to be so high that 
+		/// everything is still visible). In range [0.0f, 10.0f].
+		/// </summary>
+		public float MinEyeAdaptation
+		{
+			get { return Internal_getminEyeAdaptation(mCachedPtr); }
+			set { Internal_setminEyeAdaptation(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Clamps the maximum eye adaptation scale to this value. This allows you to limit eye adaptation so that exposure is 
+		/// never too low (for example when looking at a very bright light source you probably don't want the exposure to be so 
+		/// low that the rest of the scene is all white (overexposed). In range [0.0f, 10.0f].
+		/// </summary>
+		public float MaxEyeAdaptation
+		{
+			get { return Internal_getmaxEyeAdaptation(mCachedPtr); }
+			set { Internal_setmaxEyeAdaptation(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines how quickly does the eye adaptation adjust to larger values. This affects how quickly does the automatic 
+		/// exposure changes when the scene brightness increases. In range [0.01f, 20.0f].
+		/// </summary>
+		public float EyeAdaptationSpeedUp
+		{
+			get { return Internal_geteyeAdaptationSpeedUp(mCachedPtr); }
+			set { Internal_seteyeAdaptationSpeedUp(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines how quickly does the eye adaptation adjust to smaller values. This affects how quickly does the automatic 
+		/// exposure changes when the scene brightness decreases. In range [0.01f, 20.0f].
+		/// </summary>
+		public float EyeAdaptationSpeedDown
+		{
+			get { return Internal_geteyeAdaptationSpeedDown(mCachedPtr); }
+			set { Internal_seteyeAdaptationSpeedDown(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_AutoExposureSettings(AutoExposureSettings managedInstance);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_gethistogramLog2Min(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_sethistogramLog2Min(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_gethistogramLog2Max(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_sethistogramLog2Max(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_gethistogramPctLow(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_sethistogramPctLow(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_gethistogramPctHigh(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_sethistogramPctHigh(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getminEyeAdaptation(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setminEyeAdaptation(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getmaxEyeAdaptation(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setmaxEyeAdaptation(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_geteyeAdaptationSpeedUp(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_seteyeAdaptationSpeedUp(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_geteyeAdaptationSpeedDown(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_seteyeAdaptationSpeedDown(IntPtr thisPtr, float value);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/Blend1DInfo.generated.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Animation
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Defines a 1D blend where multiple animation clips are blended between each other using linear interpolation.
+	/// </summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct Blend1DInfo
+	{
+		public BlendClipInfo[] clips;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/Blend2DInfo.generated.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Animation
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Defines a 2D blend where two animation clips are blended between each other using bilinear interpolation.
+	/// </summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct Blend2DInfo
+	{
+		public AnimationClip topLeftClip;
+		public AnimationClip topRightClip;
+		public AnimationClip botLeftClip;
+		public AnimationClip botRightClip;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/BlendClipInfo.generated.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Animation
+	 *  @{
+	 */
+
+	/// <summary>Represents an animation clip used in 1D blending. Each clip has a position on the number line.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct BlendClipInfo
+	{
+		/// <summary>Initializes the struct with default values.</summary>
+		public static BlendClipInfo Default()
+		{
+			BlendClipInfo value = new BlendClipInfo();
+			value.clip = null;
+			value.position = 0f;
+
+			return value;
+		}
+
+		public AnimationClip clip;
+		public float position;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/BoneWeight.generated.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Utility
+	 *  @{
+	 */
+
+	/// <summary>Contains per-vertex bone weights and indexes used for skinning, for up to four bones.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct BoneWeight
+	{
+		public int index0;
+		public int index1;
+		public int index2;
+		public int index3;
+		public float weight0;
+		public float weight1;
+		public float weight2;
+		public float weight3;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CAnimation.generated.cs

@@ -0,0 +1,313 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Animation
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Handles animation playback. Takes one or multiple animation clips as input and evaluates them every animation update 
+	/// tick depending on set properties. The evaluated data is used by the core thread for skeletal animation, by the sim 
+	/// thread for updating attached scene objects and bones (if skeleton is attached), or the data is made available for 
+	/// manual queries in the case of generic animation.
+	/// </summary>
+	public partial class Animation : Component
+	{
+		private Animation(bool __dummy0) { }
+		protected Animation() { }
+
+		/// <summary>
+		/// Determines the default clip to play as soon as the component is enabled. If more control over playing clips is needed 
+		/// use the play(), blend() and crossFade() methods to queue clips for playback manually, and setState() method for 
+		/// modify their states individually.
+		/// </summary>
+		[ShowInInspector]
+		public AnimationClip DefaultClip
+		{
+			get { return Internal_getDefaultClip(mCachedPtr); }
+			set { Internal_setDefaultClip(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the wrap mode for all active animations. Wrap mode determines what happens when animation reaches the  
+		/// first or last frame.
+		/// </summary>
+		[ShowInInspector]
+		public AnimWrapMode WrapMode
+		{
+			get { return Internal_getWrapMode(mCachedPtr); }
+			set { Internal_setWrapMode(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the speed for all animations. The default value is 1.0f. Use negative values to play-back in reverse.
+		/// </summary>
+		[ShowInInspector]
+		public float Speed
+		{
+			get { return Internal_getSpeed(mCachedPtr); }
+			set { Internal_setSpeed(mCachedPtr, value); }
+		}
+
+		/// <summary>Checks if any animation clips are currently playing.</summary>
+		[ShowInInspector]
+		public bool IsPlaying
+		{
+			get { return Internal_isPlaying(mCachedPtr); }
+		}
+
+		/// <summary>
+		/// Determines bounds that will be used for animation and mesh culling. Only relevant if setUseBounds() is set to true.
+		/// </summary>
+		[ShowInInspector]
+		public AABox Bounds
+		{
+			get
+			{
+				AABox temp;
+				Internal_getBounds(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setBounds(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Determines should animation bounds be used for visibility determination (culling). If false the bounds of the mesh 
+		/// attached to the relevant CRenderable component will be used instead.
+		/// </summary>
+		[ShowInInspector]
+		public bool UseBounds
+		{
+			get { return Internal_getUseBounds(mCachedPtr); }
+			set { Internal_setUseBounds(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Enables or disables culling of the animation when out of view. Culled animation will not be evaluated.
+		/// </summary>
+		[ShowInInspector]
+		public bool Cull
+		{
+			get { return Internal_getEnableCull(mCachedPtr); }
+			set { Internal_setEnableCull(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Triggered when the list of properties animated via generic animation curves needs to be recreated (script only).
+		/// </summary>
+		partial void RebuildFloatProperties(AnimationClip p0);
+
+		/// <summary>
+		/// Triggered when generic animation curves values need be applied to the properties they effect (script only).
+		/// </summary>
+		partial void _UpdateFloatProperties();
+
+		/// <summary>Triggers a callback in script code when animation event is triggered (script only).</summary>
+		partial void EventTriggered(AnimationClip p0, string p1);
+
+		/// <summary>Plays the specified animation clip.</summary>
+		/// <param name="clip">Clip to play.</param>
+		public void Play(AnimationClip clip)
+		{
+			Internal_play(mCachedPtr, clip);
+		}
+
+		/// <summary>
+		/// Plays the specified animation clip on top of the animation currently playing in the main layer. Multiple such clips 
+		/// can be playing at once, as long as you ensure each is given its own layer. Each animation can also have a weight that 
+		/// determines how much it influences the main animation.
+		/// </summary>
+		/// <param name="clip">Clip to additively blend. Must contain additive animation curves.</param>
+		/// <param name="weight">
+		/// Determines how much of an effect will the blended animation have on the final output. In range [0, 1].
+		/// </param>
+		/// <param name="fadeLength">
+		/// Applies the blend over a specified time period, increasing the weight as the time passes. Set to zero to blend 
+		/// immediately. In seconds.
+		/// </param>
+		/// <param name="layer">
+		/// Layer to play the clip in. Multiple additive clips can be playing at once in separate layers and each layer has its 
+		/// own weight.
+		/// </param>
+		public void BlendAdditive(AnimationClip clip, float weight, float fadeLength = 0f, uint layer = 0)
+		{
+			Internal_blendAdditive(mCachedPtr, clip, weight, fadeLength, layer);
+		}
+
+		/// <summary>
+		/// Blend multiple animation clips between each other using linear interpolation. Unlike normal animations these 
+		/// animations are not advanced with the progress of time, and is instead expected the user manually changes the  
+		/// parameter.
+		/// </summary>
+		/// <param name="info">
+		/// Information about the clips to blend. Clip positions must be sorted from lowest to highest.
+		/// </param>
+		/// <param name="t">
+		/// Parameter that controls the blending. Range depends on the positions of the provided animation clips.
+		/// </param>
+		public void Blend1D(Blend1DInfo info, float t)
+		{
+			Internal_blend1D(mCachedPtr, ref info, t);
+		}
+
+		/// <summary>
+		/// Blend four animation clips between each other using bilinear interpolation. Unlike normal animations these animations 
+		/// are not advanced with the progress of time, and is instead expected the user manually changes the  parameter.
+		/// </summary>
+		/// <param name="info">Information about the clips to blend.</param>
+		/// <param name="t">
+		/// Parameter that controls the blending, in range [(0, 0), (1, 1)]. t = (0, 0) means top left animation has full 
+		/// influence, t = (1, 0) means top right animation has full influence, t = (0, 1) means bottom left animation has full 
+		/// influence, t = (1, 1) means bottom right animation has full influence.
+		/// </param>
+		public void Blend2D(Blend2DInfo info, Vector2 t)
+		{
+			Internal_blend2D(mCachedPtr, ref info, ref t);
+		}
+
+		/// <summary>
+		/// Fades the specified animation clip in, while fading other playing animation out, over the specified time period.
+		/// </summary>
+		/// <param name="clip">Clip to fade in.</param>
+		/// <param name="fadeLength">Determines the time period over which the fade occurs. In seconds.</param>
+		public void CrossFade(AnimationClip clip, float fadeLength)
+		{
+			Internal_crossFade(mCachedPtr, clip, fadeLength);
+		}
+
+		/// <summary>
+		/// Samples an animation clip at the specified time, displaying only that particular frame without further playback.
+		/// </summary>
+		/// <param name="clip">Animation clip to sample.</param>
+		/// <param name="time">Time to sample the clip at.</param>
+		public void Sample(AnimationClip clip, float time)
+		{
+			Internal_sample(mCachedPtr, clip, time);
+		}
+
+		/// <summary>
+		/// Stops playing all animations on the provided layer. Specify -1 to stop animation on the main layer  (non-additive 
+		/// animations).
+		/// </summary>
+		public void Stop(uint layer)
+		{
+			Internal_stop(mCachedPtr, layer);
+		}
+
+		/// <summary>Stops playing all animations.</summary>
+		public void StopAll()
+		{
+			Internal_stopAll(mCachedPtr);
+		}
+
+		/// <summary>Retrieves detailed information about a currently playing animation clip.</summary>
+		/// <param name="clip">Clip to retrieve the information for.</param>
+		/// <param name="state">
+		/// Animation clip state containing the requested information. Only valid if the method returns true.
+		/// </param>
+		/// <returns>True if the state was found (animation clip is playing), false otherwise.</returns>
+		public bool GetState(AnimationClip clip, out AnimationClipState state)
+		{
+			return Internal_getState(mCachedPtr, clip, out state);
+		}
+
+		/// <summary>
+		/// Changes the state of a playing animation clip. If animation clip is not currently playing the playback is started for 
+		/// the clip.
+		/// </summary>
+		/// <param name="clip">Clip to change the state for.</param>
+		/// <param name="state">New state of the animation (e.g. changing the time for seeking).</param>
+		public void SetState(AnimationClip clip, AnimationClipState state)
+		{
+			Internal_setState(mCachedPtr, clip, ref state);
+		}
+
+		/// <summary>
+		/// Changes a weight of a single morph channel, determining how much of it to apply on top of the base mesh.
+		/// </summary>
+		/// <param name="name">
+		/// Name of the morph channel to modify. This depends on the mesh the animation is currently animating.
+		/// </param>
+		/// <param name="weight">Weight that determines how much of the channel to apply to the mesh, in range [0, 1].</param>
+		public void SetMorphChannelWeight(string name, float weight)
+		{
+			Internal_setMorphChannelWeight(mCachedPtr, name, weight);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setDefaultClip(IntPtr thisPtr, AnimationClip clip);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern AnimationClip Internal_getDefaultClip(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setWrapMode(IntPtr thisPtr, AnimWrapMode wrapMode);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern AnimWrapMode Internal_getWrapMode(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setSpeed(IntPtr thisPtr, float speed);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getSpeed(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_play(IntPtr thisPtr, AnimationClip clip);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_blendAdditive(IntPtr thisPtr, AnimationClip clip, float weight, float fadeLength, uint layer);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_blend1D(IntPtr thisPtr, ref Blend1DInfo info, float t);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_blend2D(IntPtr thisPtr, ref Blend2DInfo info, ref Vector2 t);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_crossFade(IntPtr thisPtr, AnimationClip clip, float fadeLength);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_sample(IntPtr thisPtr, AnimationClip clip, float time);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_stop(IntPtr thisPtr, uint layer);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_stopAll(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_isPlaying(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getState(IntPtr thisPtr, AnimationClip clip, out AnimationClipState state);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setState(IntPtr thisPtr, AnimationClip clip, ref AnimationClipState state);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMorphChannelWeight(IntPtr thisPtr, string name, float weight);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setBounds(IntPtr thisPtr, ref AABox bounds);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getBounds(IntPtr thisPtr, out AABox __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setUseBounds(IntPtr thisPtr, bool enable);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getUseBounds(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setEnableCull(IntPtr thisPtr, bool enable);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getEnableCull(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getNumClips(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern AnimationClip Internal_getClip(IntPtr thisPtr, uint idx);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal__refreshClipMappings(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal__getGenericCurveValue(IntPtr thisPtr, uint curveIdx, out float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal__togglePreviewMode(IntPtr thisPtr, bool enabled);
+		private void Internal__scriptRebuildFloatProperties(AnimationClip p0)
+		{
+			RebuildFloatProperties(p0);
+		}
+		private void Internal__scriptUpdateFloatProperties()
+		{
+			_UpdateFloatProperties();
+		}
+		private void Internal__scriptOnEventTriggered(AnimationClip p0, string p1)
+		{
+			EventTriggered(p0, p1);
+		}
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CAudioListener.generated.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Audio
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Represents a listener that hears audio sources. For spatial audio the volume and pitch of played audio is determined 
+	/// by the distance, orientation and velocity differences between the source and the listener.
+	/// </summary>
+	public partial class AudioListener : Component
+	{
+		private AudioListener(bool __dummy0) { }
+		protected AudioListener() { }
+
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CAudioSource.generated.cs

@@ -0,0 +1,179 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Audio
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Represents a source for emitting audio. Audio can be played spatially (gun shot), or normally (music). Each audio 
+	/// source must have an AudioClip to play-back, and it can also have a position in the case of spatial (3D) audio.
+	///
+	/// Whether or not an audio source is spatial is controlled by the assigned AudioClip. The volume and the pitch of a 
+	/// spatial audio source is controlled by its position and the AudioListener's position/direction/velocity.
+	/// </summary>
+	public partial class AudioSource : Component
+	{
+		private AudioSource(bool __dummy0) { }
+		protected AudioSource() { }
+
+		/// <summary>Aaudio clip to play.</summary>
+		[ShowInInspector]
+		public AudioClip Clip
+		{
+			get { return Internal_getClip(mCachedPtr); }
+			set { Internal_setClip(mCachedPtr, value); }
+		}
+
+		/// <summary>Volume of the audio played from this source, in [0, 1] range.</summary>
+		[ShowInInspector]
+		public float Volume
+		{
+			get { return Internal_getVolume(mCachedPtr); }
+			set { Internal_setVolume(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines the pitch of the played audio. 1 is the default.</summary>
+		[ShowInInspector]
+		public float Pitch
+		{
+			get { return Internal_getPitch(mCachedPtr); }
+			set { Internal_setPitch(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines whether the audio clip should loop when it finishes playing.</summary>
+		[ShowInInspector]
+		public bool Loop
+		{
+			get { return Internal_getIsLooping(mCachedPtr); }
+			set { Internal_setIsLooping(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the priority of the audio source. If more audio sources are playing than supported by the hardware,  some 
+		/// might get disabled. By setting a higher priority the audio source is guaranteed to be disabled after sources with 
+		/// lower priority.
+		/// </summary>
+		[ShowInInspector]
+		public uint Priority
+		{
+			get { return Internal_getPriority(mCachedPtr); }
+			set { Internal_setPriority(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Minimum distance at which audio attenuation starts. When the listener is closer to the source than this value, audio 
+		/// is heard at full volume. Once farther away the audio starts attenuating.
+		/// </summary>
+		[ShowInInspector]
+		public float MinDistance
+		{
+			get { return Internal_getMinDistance(mCachedPtr); }
+			set { Internal_setMinDistance(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Attenuation that controls how quickly does audio volume drop off as the listener moves further from the source.
+		/// </summary>
+		[ShowInInspector]
+		public float Attenuation
+		{
+			get { return Internal_getAttenuation(mCachedPtr); }
+			set { Internal_setAttenuation(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the current time of playback. If playback hasn't yet started, it specifies the time at which playback will 
+		/// start at. The time is in seconds, in range [0, clipLength].
+		/// </summary>
+		[ShowInInspector]
+		public float Time
+		{
+			get { return Internal_getTime(mCachedPtr); }
+			set { Internal_setTime(mCachedPtr, value); }
+		}
+
+		/// <summary>Sets whether playback should start as soon as the component is enabled.</summary>
+		[ShowInInspector]
+		public bool PlayOnStart
+		{
+			get { return Internal_getPlayOnStart(mCachedPtr); }
+			set { Internal_setPlayOnStart(mCachedPtr, value); }
+		}
+
+		/// <summary>Returns the current state of the audio playback (playing/paused/stopped).</summary>
+		[ShowInInspector]
+		public AudioSourceState State
+		{
+			get { return Internal_getState(mCachedPtr); }
+		}
+
+		/// <summary>Starts playing the currently assigned audio clip.</summary>
+		public void Play()
+		{
+			Internal_play(mCachedPtr);
+		}
+
+		/// <summary>Pauses the audio playback.</summary>
+		public void Pause()
+		{
+			Internal_pause(mCachedPtr);
+		}
+
+		/// <summary>Stops audio playback, rewinding it to the start.</summary>
+		public void Stop()
+		{
+			Internal_stop(mCachedPtr);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setClip(IntPtr thisPtr, AudioClip clip);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern AudioClip Internal_getClip(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setVolume(IntPtr thisPtr, float volume);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getVolume(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setPitch(IntPtr thisPtr, float pitch);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getPitch(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setIsLooping(IntPtr thisPtr, bool loop);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getIsLooping(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setPriority(IntPtr thisPtr, uint priority);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getPriority(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMinDistance(IntPtr thisPtr, float distance);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getMinDistance(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setAttenuation(IntPtr thisPtr, float attenuation);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getAttenuation(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setTime(IntPtr thisPtr, float time);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getTime(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setPlayOnStart(IntPtr thisPtr, bool enable);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getPlayOnStart(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_play(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_pause(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_stop(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern AudioSourceState Internal_getState(IntPtr thisPtr);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CBone.generated.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Animation
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Component that maps animation for specific bone also be applied to the SceneObject this component is attached to.  The 
+	/// component will attach to the first found parent Animation component.
+	/// </summary>
+	public partial class Bone : Component
+	{
+		private Bone(bool __dummy0) { }
+		protected Bone() { }
+
+		/// <summary>Determines the name of the bone the component is referencing.</summary>
+		[ShowInInspector]
+		public string Name
+		{
+			get { return Internal_getBoneName(mCachedPtr); }
+			set { Internal_setBoneName(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setBoneName(IntPtr thisPtr, string name);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern string Internal_getBoneName(IntPtr thisPtr);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CBoxCollider.generated.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Collider with box geometry.</summary>
+	public partial class BoxCollider : Collider
+	{
+		private BoxCollider(bool __dummy0) { }
+		protected BoxCollider() { }
+
+		/// <summary>Determines the extents (half size) of the geometry of the box.</summary>
+		[ShowInInspector]
+		public Vector3 Extents
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getExtents(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setExtents(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Determines the position of the box shape, relative to the component's scene object.</summary>
+		[ShowInInspector]
+		public Vector3 Center
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getCenter(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setCenter(mCachedPtr, ref value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setExtents(IntPtr thisPtr, ref Vector3 extents);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getExtents(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setCenter(IntPtr thisPtr, ref Vector3 center);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getCenter(IntPtr thisPtr, out Vector3 __output);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CCamera.generated.cs

@@ -0,0 +1,452 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Rendering
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Camera determines how is world geometry projected onto a 2D surface. You may position and orient it in space, set 
+	/// options like aspect ratio and field or view and it outputs view and projection matrices required for rendering.
+	/// </summary>
+	public partial class Camera : Component
+	{
+		private Camera(bool __dummy0) { }
+		protected Camera() { }
+
+		/// <summary>Returns the viewport used by the camera.</summary>
+		[ShowInInspector]
+		public Viewport Viewport
+		{
+			get { return Internal_getViewport(mCachedPtr); }
+		}
+
+		/// <summary>
+		/// Determines the camera horizontal field of view. This determines how wide the camera viewing angle is along the 
+		/// horizontal axis. Vertical FOV is calculated from the horizontal FOV and the aspect ratio.
+		/// </summary>
+		[ShowInInspector]
+		public Radian FieldOfView
+		{
+			get
+			{
+				Radian temp;
+				Internal_getHorzFOV(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setHorzFOV(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Determines the distance from the frustum to the near clipping plane. Anything closer than the near clipping plane 
+		/// will not be rendered. Decreasing this value decreases depth buffer precision.
+		/// </summary>
+		[ShowInInspector]
+		public float NearClipPlane
+		{
+			get { return Internal_getNearClipDistance(mCachedPtr); }
+			set { Internal_setNearClipDistance(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the distance from the frustum to the far clipping plane. Anything farther than the far clipping plane will 
+		/// not be rendered. Increasing this value decreases depth buffer precision.
+		/// </summary>
+		[ShowInInspector]
+		public float FarClipPlane
+		{
+			get { return Internal_getFarClipDistance(mCachedPtr); }
+			set { Internal_setFarClipDistance(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines the current viewport aspect ratio (width / height).</summary>
+		[ShowInInspector]
+		public float AspectRatio
+		{
+			get { return Internal_getAspectRatio(mCachedPtr); }
+			set { Internal_setAspectRatio(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Returns the standard projection matrix that determines how are 3D points projected to two dimensions. The layout of 
+		/// this matrix depends on currently used render system.
+		/// </summary>
+		[ShowInInspector]
+		public Matrix4 ProjMatrix
+		{
+			get
+			{
+				Matrix4 temp;
+				Internal_getProjectionMatrixRS(mCachedPtr, out temp);
+				return temp;
+			}
+		}
+
+		/// <summary>Gets the camera view matrix. Used for positioning/orienting the camera.</summary>
+		[ShowInInspector]
+		public Matrix4 ViewMatrix
+		{
+			get
+			{
+				Matrix4 temp;
+				Internal_getViewMatrix(mCachedPtr, out temp);
+				return temp;
+			}
+		}
+
+		/// <summary>
+		/// Determines the type of projection used by the camera. Projection type controls how is 3D geometry projected onto a  
+		/// 2D plane.
+		/// </summary>
+		[ShowInInspector]
+		public ProjectionType ProjectionType
+		{
+			get { return Internal_getProjectionType(mCachedPtr); }
+			set { Internal_setProjectionType(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the orthographic window height, for use with orthographic rendering only. The width of the window will be 
+		/// calculated from the aspect ratio. Value is specified in world units.
+		/// </summary>
+		[ShowInInspector]
+		public float OrthoHeight
+		{
+			get { return Internal_getOrthoWindowHeight(mCachedPtr); }
+			set { Internal_setOrthoWindowHeight(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the orthographic window width, for use with orthographic rendering only. The height of the window will be 
+		/// calculated from the aspect ratio. Value is specified in world units.
+		/// </summary>
+		[ShowInInspector]
+		public float OrthoWidth
+		{
+			get { return Internal_getOrthoWindowWidth(mCachedPtr); }
+			set { Internal_setOrthoWindowWidth(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines a priority that determines in which orders the cameras are rendered. This only applies to cameras 
+		/// rendering to the same render target. Higher value means the camera will be rendered sooner.
+		/// </summary>
+		[ShowInInspector]
+		public int Priority
+		{
+			get { return Internal_getPriority(mCachedPtr); }
+			set { Internal_setPriority(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines layer bitfield that is used when determining which object should the camera render.</summary>
+		[ShowInInspector]
+		public ulong Layers
+		{
+			get { return Internal_getLayers(mCachedPtr); }
+			set { Internal_setLayers(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines number of samples to use when rendering to this camera. Values larger than 1 will enable MSAA rendering.
+		/// </summary>
+		[ShowInInspector]
+		public uint SampleCount
+		{
+			get { return Internal_getMSAACount(mCachedPtr); }
+			set { Internal_setMSAACount(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Settings that control rendering for this view. They determine how will the renderer process this view, which effects 
+		/// will be enabled, and what properties will those effects use.
+		/// </summary>
+		[ShowInInspector]
+		public RenderSettings RenderSettings
+		{
+			get { return Internal_getRenderSettings(mCachedPtr); }
+			set { Internal_setRenderSettings(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines whether this is the main application camera. Main camera controls the final render surface that is 
+		/// displayed to the user.
+		/// </summary>
+		[ShowInInspector]
+		public bool Main
+		{
+			get { return Internal_isMain(mCachedPtr); }
+			set { Internal_setMain(mCachedPtr, value); }
+		}
+
+		/// <summary>Converts a point in world space to screen coordinates.</summary>
+		/// <param name="worldPoint">3D point in world space.</param>
+		/// <returns>2D point on the render target attached to the camera's viewport, in pixels.</returns>
+		public Vector2I WorldToScreenPoint(Vector3 worldPoint)
+		{
+			Vector2I temp;
+			Internal_worldToScreenPoint(mCachedPtr, ref worldPoint, out temp);
+			return temp;
+		}
+
+		/// <summary>Converts a point in world space to normalized device coordinates.</summary>
+		/// <param name="worldPoint">3D point in world space.</param>
+		/// <returns>2D point in normalized device coordinates ([-1, 1] range), relative to the camera's viewport.</returns>
+		public Vector2 WorldToNdcPoint(Vector3 worldPoint)
+		{
+			Vector2 temp;
+			Internal_worldToNdcPoint(mCachedPtr, ref worldPoint, out temp);
+			return temp;
+		}
+
+		/// <summary>Converts a point in world space to view space coordinates.</summary>
+		/// <param name="worldPoint">3D point in world space.</param>
+		/// <returns>3D point relative to the camera's coordinate system.</returns>
+		public Vector3 WorldToViewPoint(Vector3 worldPoint)
+		{
+			Vector3 temp;
+			Internal_worldToViewPoint(mCachedPtr, ref worldPoint, out temp);
+			return temp;
+		}
+
+		/// <summary>Converts a point in screen space to a point in world space.</summary>
+		/// <param name="screenPoint">2D point on the render target attached to the camera's viewport, in pixels.</param>
+		/// <param name="depth">
+		/// Depth to place the world point at, in world coordinates. The depth is applied to the  vector going from camera origin 
+		/// to the point on the near plane.
+		/// </param>
+		/// <returns>3D point in world space.</returns>
+		public Vector3 ScreenToWorldPoint(Vector2I screenPoint, float depth = 0.5f)
+		{
+			Vector3 temp;
+			Internal_screenToWorldPoint(mCachedPtr, ref screenPoint, depth, out temp);
+			return temp;
+		}
+
+		/// <summary>Converts a point in screen space to a point in view space.</summary>
+		/// <param name="screenPoint">2D point on the render target attached to the camera's viewport, in pixels.</param>
+		/// <param name="depth">
+		/// Depth to place the world point at, in device depth. The depth is applied to the  vector going from camera origin to 
+		/// the point on the near plane.
+		/// </param>
+		/// <returns>3D point relative to the camera's coordinate system.</returns>
+		public Vector3 ScreenToViewPoint(Vector2I screenPoint, float depth = 0.5f)
+		{
+			Vector3 temp;
+			Internal_screenToViewPoint(mCachedPtr, ref screenPoint, depth, out temp);
+			return temp;
+		}
+
+		/// <summary>Converts a point in screen space to normalized device coordinates.</summary>
+		/// <param name="screenPoint">2D point on the render target attached to the camera's viewport, in pixels.</param>
+		/// <returns>2D point in normalized device coordinates ([-1, 1] range), relative to  the camera's viewport.</returns>
+		public Vector2 ScreenToNdcPoint(Vector2I screenPoint)
+		{
+			Vector2 temp;
+			Internal_screenToNdcPoint(mCachedPtr, ref screenPoint, out temp);
+			return temp;
+		}
+
+		/// <summary>Converts a point in view space to world space.</summary>
+		/// <param name="viewPoint">3D point relative to the camera's coordinate system.</param>
+		/// <returns>3D point in world space.</returns>
+		public Vector3 ViewToWorldPoint(Vector3 viewPoint)
+		{
+			Vector3 temp;
+			Internal_viewToWorldPoint(mCachedPtr, ref viewPoint, out temp);
+			return temp;
+		}
+
+		/// <summary>Converts a point in view space to screen space.</summary>
+		/// <param name="viewPoint">3D point relative to the camera's coordinate system.</param>
+		/// <returns>2D point on the render target attached to the camera's viewport, in pixels.</returns>
+		public Vector2I ViewToScreenPoint(Vector3 viewPoint)
+		{
+			Vector2I temp;
+			Internal_viewToScreenPoint(mCachedPtr, ref viewPoint, out temp);
+			return temp;
+		}
+
+		/// <summary>Converts a point in view space to normalized device coordinates.</summary>
+		/// <param name="viewPoint">3D point relative to the camera's coordinate system.</param>
+		/// <returns>2D point in normalized device coordinates ([-1, 1] range), relative to  the camera's viewport.</returns>
+		public Vector2 ViewToNdcPoint(Vector3 viewPoint)
+		{
+			Vector2 temp;
+			Internal_viewToNdcPoint(mCachedPtr, ref viewPoint, out temp);
+			return temp;
+		}
+
+		/// <summary>Converts a point in normalized device coordinates to world space.</summary>
+		/// <param name="ndcPoint">
+		/// 2D point in normalized device coordinates ([-1, 1] range), relative to  the camera's viewport.
+		/// </param>
+		/// <param name="depth">
+		/// Depth to place the world point at. The depth is applied to the vector going from camera origin to the point on the 
+		/// near plane.
+		/// </param>
+		/// <returns>3D point in world space.</returns>
+		public Vector3 NdcToWorldPoint(Vector2 ndcPoint, float depth = 0.5f)
+		{
+			Vector3 temp;
+			Internal_ndcToWorldPoint(mCachedPtr, ref ndcPoint, depth, out temp);
+			return temp;
+		}
+
+		/// <summary>Converts a point in normalized device coordinates to view space.</summary>
+		/// <param name="ndcPoint">
+		/// 2D point in normalized device coordinates ([-1, 1] range), relative to  the camera's viewport.
+		/// </param>
+		/// <param name="depth">
+		/// Depth to place the world point at. The depth is applied to the vector going from camera origin to the point on the 
+		/// near plane.
+		/// </param>
+		/// <returns>3D point relative to the camera's coordinate system.</returns>
+		public Vector3 NdcToViewPoint(Vector2 ndcPoint, float depth = 0.5f)
+		{
+			Vector3 temp;
+			Internal_ndcToViewPoint(mCachedPtr, ref ndcPoint, depth, out temp);
+			return temp;
+		}
+
+		/// <summary>Converts a point in normalized device coordinates to screen space.</summary>
+		/// <param name="ndcPoint">
+		/// 2D point in normalized device coordinates ([-1, 1] range), relative to  the camera's viewport.
+		/// </param>
+		/// <returns>2D point on the render target attached to the camera's viewport, in pixels.</returns>
+		public Vector2I NdcToScreenPoint(Vector2 ndcPoint)
+		{
+			Vector2I temp;
+			Internal_ndcToScreenPoint(mCachedPtr, ref ndcPoint, out temp);
+			return temp;
+		}
+
+		/// <summary>Converts a point in screen space to a ray in world space.</summary>
+		/// <param name="screenPoint">2D point on the render target attached to the camera's viewport, in pixels.</param>
+		/// <returns>Ray in world space, originating at the selected point on the camera near plane.</returns>
+		public Ray ScreenPointToRay(Vector2I screenPoint)
+		{
+			Ray temp;
+			Internal_screenPointToRay(mCachedPtr, ref screenPoint, out temp);
+			return temp;
+		}
+
+		/// <summary>
+		/// Projects a point in view space to normalized device coordinates. Similar to viewToNdcPoint() but preserves the depth 
+		/// component.
+		/// </summary>
+		/// <param name="point">3D point relative to the camera's coordinate system.</param>
+		/// <returns>
+		/// 3D point in normalized device coordinates ([-1, 1] range), relative to the  camera's viewport. Z value range depends 
+		/// on active render API.
+		/// </returns>
+		public Vector3 ProjectPoint(Vector3 point)
+		{
+			Vector3 temp;
+			Internal_projectPoint(mCachedPtr, ref point, out temp);
+			return temp;
+		}
+
+		/// <summary>Un-projects a point in normalized device space to view space.</summary>
+		/// <param name="point">
+		/// 3D point in normalized device coordinates ([-1, 1] range), relative to the  camera's viewport. Z value range depends 
+		/// on active render API.
+		/// </param>
+		/// <returns>3D point relative to the camera's coordinate system.</returns>
+		public Vector3 UnprojectPoint(Vector3 point)
+		{
+			Vector3 temp;
+			Internal_unprojectPoint(mCachedPtr, ref point, out temp);
+			return temp;
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Viewport Internal_getViewport(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setHorzFOV(IntPtr thisPtr, ref Radian fovy);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getHorzFOV(IntPtr thisPtr, out Radian __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setNearClipDistance(IntPtr thisPtr, float nearDist);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getNearClipDistance(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setFarClipDistance(IntPtr thisPtr, float farDist);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getFarClipDistance(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setAspectRatio(IntPtr thisPtr, float ratio);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getAspectRatio(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getProjectionMatrixRS(IntPtr thisPtr, out Matrix4 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getViewMatrix(IntPtr thisPtr, out Matrix4 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setProjectionType(IntPtr thisPtr, ProjectionType pt);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern ProjectionType Internal_getProjectionType(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setOrthoWindowHeight(IntPtr thisPtr, float h);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getOrthoWindowHeight(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setOrthoWindowWidth(IntPtr thisPtr, float w);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getOrthoWindowWidth(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setPriority(IntPtr thisPtr, int priority);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int Internal_getPriority(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setLayers(IntPtr thisPtr, ulong layers);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern ulong Internal_getLayers(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMSAACount(IntPtr thisPtr, uint count);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getMSAACount(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setRenderSettings(IntPtr thisPtr, RenderSettings settings);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern RenderSettings Internal_getRenderSettings(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_worldToScreenPoint(IntPtr thisPtr, ref Vector3 worldPoint, out Vector2I __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_worldToNdcPoint(IntPtr thisPtr, ref Vector3 worldPoint, out Vector2 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_worldToViewPoint(IntPtr thisPtr, ref Vector3 worldPoint, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_screenToWorldPoint(IntPtr thisPtr, ref Vector2I screenPoint, float depth, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_screenToViewPoint(IntPtr thisPtr, ref Vector2I screenPoint, float depth, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_screenToNdcPoint(IntPtr thisPtr, ref Vector2I screenPoint, out Vector2 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_viewToWorldPoint(IntPtr thisPtr, ref Vector3 viewPoint, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_viewToScreenPoint(IntPtr thisPtr, ref Vector3 viewPoint, out Vector2I __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_viewToNdcPoint(IntPtr thisPtr, ref Vector3 viewPoint, out Vector2 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_ndcToWorldPoint(IntPtr thisPtr, ref Vector2 ndcPoint, float depth, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_ndcToViewPoint(IntPtr thisPtr, ref Vector2 ndcPoint, float depth, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_ndcToScreenPoint(IntPtr thisPtr, ref Vector2 ndcPoint, out Vector2I __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_screenPointToRay(IntPtr thisPtr, ref Vector2I screenPoint, out Ray __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_projectPoint(IntPtr thisPtr, ref Vector3 point, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_unprojectPoint(IntPtr thisPtr, ref Vector3 point, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMain(IntPtr thisPtr, bool main);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_isMain(IntPtr thisPtr);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CCapsuleCollider.generated.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Collider with a capsule geometry.</summary>
+	public partial class CapsuleCollider : Collider
+	{
+		private CapsuleCollider(bool __dummy0) { }
+		protected CapsuleCollider() { }
+
+		/// <summary>Normal vector that determines how is the capsule oriented.</summary>
+		[ShowInInspector]
+		public Vector3 Normal
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getNormal(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setNormal(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Determines the position of the capsule shape, relative to the component's scene object.</summary>
+		[ShowInInspector]
+		public Vector3 Center
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getCenter(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setCenter(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Determines the half height of the capsule, from the origin to one of the hemispherical centers, along the normal  
+		/// vector.
+		/// </summary>
+		[ShowInInspector]
+		public float HalfHeight
+		{
+			get { return Internal_getHalfHeight(mCachedPtr); }
+			set { Internal_setHalfHeight(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines the radius of the capsule.</summary>
+		[ShowInInspector]
+		public float Radius
+		{
+			get { return Internal_getRadius(mCachedPtr); }
+			set { Internal_setRadius(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setNormal(IntPtr thisPtr, ref Vector3 normal);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getNormal(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setCenter(IntPtr thisPtr, ref Vector3 center);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getCenter(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setHalfHeight(IntPtr thisPtr, float halfHeight);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getHalfHeight(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setRadius(IntPtr thisPtr, float radius);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getRadius(IntPtr thisPtr);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CCharacterController.generated.cs

@@ -0,0 +1,213 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Special physics controller meant to be used for game characters. Uses the "slide-and-collide" physics instead of of 
+	/// the standard physics model to handle various issues with manually moving kinematic objects. Uses a capsule to 
+	/// represent the character's bounds.
+	/// </summary>
+	public partial class CharacterController : Component
+	{
+		private CharacterController(bool __dummy0) { }
+		protected CharacterController() { }
+
+		/// <summary>
+		/// Determines the position of the bottom of the controller. Position takes contact offset into account. Changing this 
+		/// will teleport the character to the location. Use move() for movement that includes physics.
+		/// </summary>
+		[ShowInInspector]
+		public Vector3 FootPosition
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getFootPosition(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setFootPosition(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Determines the radius of the controller capsule.</summary>
+		[ShowInInspector]
+		public float Radius
+		{
+			get { return Internal_getRadius(mCachedPtr); }
+			set { Internal_setRadius(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines the height between the centers of the two spheres of the controller capsule.</summary>
+		[ShowInInspector]
+		public float Height
+		{
+			get { return Internal_getHeight(mCachedPtr); }
+			set { Internal_setHeight(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines the up direction of capsule. Determines capsule orientation.</summary>
+		[ShowInInspector]
+		public Vector3 Up
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getUp(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setUp(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Controls what happens when character encounters a height higher than its step offset.</summary>
+		[ShowInInspector]
+		public CharacterClimbingMode ClimbingMode
+		{
+			get { return Internal_getClimbingMode(mCachedPtr); }
+			set { Internal_setClimbingMode(mCachedPtr, value); }
+		}
+
+		/// <summary>Controls what happens when character encounters a slope higher than its slope offset.</summary>
+		[ShowInInspector]
+		public CharacterNonWalkableMode NonWalkableMode
+		{
+			get { return Internal_getNonWalkableMode(mCachedPtr); }
+			set { Internal_setNonWalkableMode(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Represents minimum distance that the character will move during a call to move(). This is used to stop the recursive 
+		/// motion algorithm when the remaining distance is too small.
+		/// </summary>
+		[ShowInInspector]
+		public float MinMoveDistance
+		{
+			get { return Internal_getMinMoveDistance(mCachedPtr); }
+			set { Internal_setMinMoveDistance(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Contact offset specifies a skin around the object within which contacts will be generated. It should be a small 
+		/// positive non-zero value.
+		/// </summary>
+		[ShowInInspector]
+		public float ContactOffset
+		{
+			get { return Internal_getContactOffset(mCachedPtr); }
+			set { Internal_setContactOffset(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Controls which obstacles will the character be able to automatically step over without being stopped. This is the 
+		/// height of the maximum obstacle that will be stepped over (with exceptions, see climbingMode).
+		/// </summary>
+		[ShowInInspector]
+		public float StepOffset
+		{
+			get { return Internal_getStepOffset(mCachedPtr); }
+			set { Internal_setStepOffset(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Controls which slopes should the character consider too steep and won't be able to move over. See nonWalkableMode for 
+		/// more information.
+		/// </summary>
+		[ShowInInspector]
+		public Radian SlopeLimit
+		{
+			get
+			{
+				Radian temp;
+				Internal_getSlopeLimit(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setSlopeLimit(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Determines the layer that controls what can the controller collide with.</summary>
+		[ShowInInspector]
+		public ulong Layer
+		{
+			get { return Internal_getLayer(mCachedPtr); }
+			set { Internal_setLayer(mCachedPtr, value); }
+		}
+
+		/// <summary>Triggered when the controller hits a collider.</summary>
+		public event Action<ControllerColliderCollision> OnColliderHit;
+
+		/// <summary>Triggered when the controller hits another character controller.</summary>
+		public event Action<ControllerControllerCollision> OnControllerHit;
+
+		/// <summary>
+		/// Moves the controller in the specified direction by the specified amount, while interacting with surrounding geometry. 
+		/// Returns flags signaling where collision occurred after the movement.
+		///
+		/// Does not account for gravity, you must apply it manually.
+		/// </summary>
+		public CharacterCollisionFlag Move(Vector3 displacement)
+		{
+			return Internal_move(mCachedPtr, ref displacement);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern CharacterCollisionFlag Internal_move(IntPtr thisPtr, ref Vector3 displacement);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getFootPosition(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setFootPosition(IntPtr thisPtr, ref Vector3 position);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getRadius(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setRadius(IntPtr thisPtr, float radius);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getHeight(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setHeight(IntPtr thisPtr, float height);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getUp(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setUp(IntPtr thisPtr, ref Vector3 up);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern CharacterClimbingMode Internal_getClimbingMode(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setClimbingMode(IntPtr thisPtr, CharacterClimbingMode mode);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern CharacterNonWalkableMode Internal_getNonWalkableMode(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setNonWalkableMode(IntPtr thisPtr, CharacterNonWalkableMode mode);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getMinMoveDistance(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMinMoveDistance(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getContactOffset(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setContactOffset(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getStepOffset(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setStepOffset(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getSlopeLimit(IntPtr thisPtr, out Radian __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setSlopeLimit(IntPtr thisPtr, ref Radian value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern ulong Internal_getLayer(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setLayer(IntPtr thisPtr, ulong layer);
+		private void Internal_onColliderHit(ref ControllerColliderCollision p0)
+		{
+			OnColliderHit?.Invoke(p0);
+		}
+		private void Internal_onControllerHit(ref ControllerControllerCollision p0)
+		{
+			OnControllerHit?.Invoke(p0);
+		}
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CCollider.generated.cs

@@ -0,0 +1,160 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Collider represents physics geometry that can be in multiple states: - Default: Static geometry that physics objects 
+	/// can collide with. - Trigger: Static geometry that can't be collided with but will report touch events. - Dynamic: 
+	/// Dynamic geometry that is a part of a Rigidbody. A set of colliders defines the shape of the parent  rigidbody.
+	/// </summary>
+	public partial class Collider : Component
+	{
+		private Collider(bool __dummy0) { }
+		protected Collider() { }
+
+		/// <summary>
+		/// Enables/disables a collider as a trigger. A trigger will not be used for collisions (objects will pass  through it), 
+		/// but collision events will still be reported.
+		/// </summary>
+		[ShowInInspector]
+		public bool Trigger
+		{
+			get { return Internal_getIsTrigger(mCachedPtr); }
+			set { Internal_setIsTrigger(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the mass of the collider. Only relevant if the collider is part of a rigidbody. Ultimately this will 
+		/// determine the total mass, center of mass and inertia tensors of the parent rigidbody (if they're being calculated 
+		/// automatically).
+		/// </summary>
+		[ShowInInspector]
+		public float Mass
+		{
+			get { return Internal_getMass(mCachedPtr); }
+			set { Internal_setMass(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the physical material of the collider. The material determines how objects hitting the collider  behave.
+		/// </summary>
+		[ShowInInspector]
+		public PhysicsMaterial Material
+		{
+			get { return Internal_getMaterial(mCachedPtr); }
+			set { Internal_setMaterial(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines how far apart do two shapes need to be away from each other before the physics runtime starts  generating 
+		/// repelling impulse for them. This distance will be the sum of contact offsets of the two interacting objects. If 
+		/// objects are moving fast you can increase this value to start generating the impulse earlier and  potentially prevent 
+		/// the objects from interpenetrating. This value is in meters. Must be positive and greater than rest offset.
+		///
+		/// Also see setRestOffset().
+		/// </summary>
+		[ShowInInspector]
+		public float ContactOffset
+		{
+			get { return Internal_getContactOffset(mCachedPtr); }
+			set { Internal_setContactOffset(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines at what distance should two objects resting on one another come to an equilibrium. The value used in the 
+		/// runtime will be the sum of rest offsets for both interacting objects. This value is in meters. Cannot be  larger than 
+		/// contact offset.
+		///
+		/// Also see setContactOffset().
+		/// </summary>
+		[ShowInInspector]
+		public float RestOffset
+		{
+			get { return Internal_getRestOffset(mCachedPtr); }
+			set { Internal_setRestOffset(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines the layer of the collider. Layer controls with which objects will the collider collide.</summary>
+		[ShowInInspector]
+		public ulong Layer
+		{
+			get { return Internal_getLayer(mCachedPtr); }
+			set { Internal_setLayer(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines which (if any) collision events are reported.</summary>
+		[ShowInInspector]
+		public CollisionReportMode CollisionReportMode
+		{
+			get { return Internal_getCollisionReportMode(mCachedPtr); }
+			set { Internal_setCollisionReportMode(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Triggered when some object starts interacting with the collider. Only triggered if proper collision report mode is 
+		/// turned on.
+		/// </summary>
+		public event Action<CollisionData> OnCollisionBegin;
+
+		/// <summary>
+		/// Triggered for every frame that an object remains interacting with a collider. Only triggered if proper collision 
+		/// report mode is turned on.
+		/// </summary>
+		public event Action<CollisionData> OnCollisionStay;
+
+		/// <summary>
+		/// Triggered when some object stops interacting with the collider. Only triggered if proper collision report mode is 
+		/// turned on.
+		/// </summary>
+		public event Action<CollisionData> OnCollisionEnd;
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setIsTrigger(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getIsTrigger(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMass(IntPtr thisPtr, float mass);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getMass(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMaterial(IntPtr thisPtr, PhysicsMaterial material);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern PhysicsMaterial Internal_getMaterial(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setContactOffset(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getContactOffset(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setRestOffset(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getRestOffset(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setLayer(IntPtr thisPtr, ulong layer);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern ulong Internal_getLayer(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setCollisionReportMode(IntPtr thisPtr, CollisionReportMode mode);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern CollisionReportMode Internal_getCollisionReportMode(IntPtr thisPtr);
+		private void Internal_onCollisionBegin(ref CollisionData p0)
+		{
+			OnCollisionBegin?.Invoke(p0);
+		}
+		private void Internal_onCollisionStay(ref CollisionData p0)
+		{
+			OnCollisionStay?.Invoke(p0);
+		}
+		private void Internal_onCollisionEnd(ref CollisionData p0)
+		{
+			OnCollisionEnd?.Invoke(p0);
+		}
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CD6Joint.generated.cs

@@ -0,0 +1,246 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Represents the most customizable type of joint. This joint type can be used to create all other built-in joint  types, 
+	/// and to design your own custom ones, but is less intuitive to use. Allows a specification of a linear  constraint (for 
+	/// example for slider), twist constraint (rotating around X) and swing constraint (rotating around Y and Z). It also 
+	/// allows you to constrain limits to only specific axes or completely lock specific axes.
+	/// </summary>
+	public partial class D6Joint : Joint
+	{
+		private D6Joint(bool __dummy0) { }
+		protected D6Joint() { }
+
+		/// <summary>Returns the current rotation of the joint around the X axis.</summary>
+		[ShowInInspector]
+		public Radian Twist
+		{
+			get
+			{
+				Radian temp;
+				Internal_getTwist(mCachedPtr, out temp);
+				return temp;
+			}
+		}
+
+		/// <summary>Returns the current rotation of the joint around the Y axis.</summary>
+		[ShowInInspector]
+		public Radian SwingY
+		{
+			get
+			{
+				Radian temp;
+				Internal_getSwingY(mCachedPtr, out temp);
+				return temp;
+			}
+		}
+
+		/// <summary>Returns the current rotation of the joint around the Z axis.</summary>
+		[ShowInInspector]
+		public Radian SwingZ
+		{
+			get
+			{
+				Radian temp;
+				Internal_getSwingZ(mCachedPtr, out temp);
+				return temp;
+			}
+		}
+
+		/// <summary>Determines the linear limit used for constraining translation degrees of freedom.</summary>
+		[ShowInInspector]
+		public LimitLinear LimitLinear
+		{
+			get
+			{
+				LimitLinear temp;
+				Internal_getLimitLinear(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setLimitLinear(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Determines the angular limit used for constraining the twist (rotation around X) degree of freedom.
+		/// </summary>
+		[ShowInInspector]
+		public LimitAngularRange LimitTwist
+		{
+			get
+			{
+				LimitAngularRange temp;
+				Internal_getLimitTwist(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setLimitTwist(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Determines the cone limit used for constraining the swing (rotation around Y and Z) degree of freedom.
+		/// </summary>
+		[ShowInInspector]
+		public LimitConeRange LimitSwing
+		{
+			get
+			{
+				LimitConeRange temp;
+				Internal_getLimitSwing(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setLimitSwing(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Returns the drive's target position relative to the joint's first body.</summary>
+		[ShowInInspector]
+		public Vector3 DrivePosition
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getDrivePosition(mCachedPtr, out temp);
+				return temp;
+			}
+		}
+
+		/// <summary>Returns the drive's target rotation relative to the joint's first body.</summary>
+		[ShowInInspector]
+		public Quaternion DriveRotation
+		{
+			get
+			{
+				Quaternion temp;
+				Internal_getDriveRotation(mCachedPtr, out temp);
+				return temp;
+			}
+		}
+
+		/// <summary>Returns the drive's target linear velocity.</summary>
+		[ShowInInspector]
+		public Vector3 DriveLinearVelocity
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getDriveLinearVelocity(mCachedPtr, out temp);
+				return temp;
+			}
+		}
+
+		/// <summary>Returns the drive's target angular velocity.</summary>
+		[ShowInInspector]
+		public Vector3 DriveAngularVelocity
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getDriveAngularVelocity(mCachedPtr, out temp);
+				return temp;
+			}
+		}
+
+		/// <summary>Returns motion constraint for the specified axis.</summary>
+		public D6JointMotion GetMotion(D6JointAxis axis)
+		{
+			return Internal_getMotion(mCachedPtr, axis);
+		}
+
+		/// <summary>
+		/// Allows you to constrain motion of the specified axis. Be aware that when setting drives for a specific axis you must 
+		/// also take care not to constrain its motion in a conflicting way (for example you cannot add a drive that moves the 
+		/// joint on X axis, and then lock the X axis).
+		///
+		/// Unlocking translations degrees of freedom allows the bodies to move along the subset of the unlocked axes. (for 
+		/// example unlocking just one translational axis is the equivalent of a slider joint.)
+		///
+		/// Angular degrees of freedom are partitioned as twist (around X axis) and swing (around Y and Z axes). Different 
+		/// effects can be achieves by unlocking their various combinations:  - If a single degree of angular freedom is unlocked 
+		/// it should be the twist degree as it has extra options for that case (for example for a hinge joint). - If both swing 
+		/// degrees are unlocked but twist is locked the result is a zero-twist joint.  - If one swing and one twist degree of 
+		/// freedom are unlocked the result is a zero-swing joint (for example an arm attached at the elbow) - If all angular 
+		/// degrees of freedom are unlocked the result is the same as the spherical joint.
+		/// </summary>
+		public void SetMotion(D6JointAxis axis, D6JointMotion motion)
+		{
+			Internal_setMotion(mCachedPtr, axis, motion);
+		}
+
+		/// <summary>
+		/// Determines a drive that will attempt to move the specified degree(s) of freedom to the wanted position and velocity.
+		/// </summary>
+		public D6JointDrive GetDrive(D6JointDriveType type)
+		{
+			D6JointDrive temp;
+			Internal_getDrive(mCachedPtr, type, out temp);
+			return temp;
+		}
+
+		/// <summary>
+		/// Determines a drive that will attempt to move the specified degree(s) of freedom to the wanted position and velocity.
+		/// </summary>
+		public void SetDrive(D6JointDriveType type, D6JointDrive drive)
+		{
+			Internal_setDrive(mCachedPtr, type, ref drive);
+		}
+
+		/// <summary>Sets the drive's target position and rotation relative to the joint's first body.</summary>
+		public void SetDriveTransform(Vector3 position, Quaternion rotation)
+		{
+			Internal_setDriveTransform(mCachedPtr, ref position, ref rotation);
+		}
+
+		/// <summary>Sets the drive's target linear and angular velocities.</summary>
+		public void SetDriveVelocity(Vector3 linear, Vector3 angular)
+		{
+			Internal_setDriveVelocity(mCachedPtr, ref linear, ref angular);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern D6JointMotion Internal_getMotion(IntPtr thisPtr, D6JointAxis axis);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMotion(IntPtr thisPtr, D6JointAxis axis, D6JointMotion motion);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getTwist(IntPtr thisPtr, out Radian __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getSwingY(IntPtr thisPtr, out Radian __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getSwingZ(IntPtr thisPtr, out Radian __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getLimitLinear(IntPtr thisPtr, out LimitLinear __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setLimitLinear(IntPtr thisPtr, ref LimitLinear limit);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getLimitTwist(IntPtr thisPtr, out LimitAngularRange __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setLimitTwist(IntPtr thisPtr, ref LimitAngularRange limit);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getLimitSwing(IntPtr thisPtr, out LimitConeRange __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setLimitSwing(IntPtr thisPtr, ref LimitConeRange limit);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getDrive(IntPtr thisPtr, D6JointDriveType type, out D6JointDrive __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setDrive(IntPtr thisPtr, D6JointDriveType type, ref D6JointDrive drive);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getDrivePosition(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getDriveRotation(IntPtr thisPtr, out Quaternion __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setDriveTransform(IntPtr thisPtr, ref Vector3 position, ref Quaternion rotation);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getDriveLinearVelocity(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getDriveAngularVelocity(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setDriveVelocity(IntPtr thisPtr, ref Vector3 linear, ref Vector3 angular);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CDistanceJoint.generated.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>A joint that maintains an upper or lower (or both) bound on the distance between two bodies.</summary>
+	public partial class DistanceJoint : Joint
+	{
+		private DistanceJoint(bool __dummy0) { }
+		protected DistanceJoint() { }
+
+		/// <summary>Returns the current distance between the two joint bodies.</summary>
+		[ShowInInspector]
+		public float Distance
+		{
+			get { return Internal_getDistance(mCachedPtr); }
+		}
+
+		/// <summary>
+		/// Determines the minimum distance the bodies are allowed to be at, they will get no closer. You must enable min 
+		/// distance flag in order for this limit to be applied.
+		/// </summary>
+		[ShowInInspector]
+		public float MinDistance
+		{
+			get { return Internal_getMinDistance(mCachedPtr); }
+			set { Internal_setMinDistance(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the maximum distance the bodies are allowed to be at, they will get no further. You must enable max 
+		/// distance flag in order for this limit to be applied.
+		/// </summary>
+		[ShowInInspector]
+		public float MaxDistance
+		{
+			get { return Internal_getMaxDistance(mCachedPtr); }
+			set { Internal_setMaxDistance(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the error tolerance of the joint at which the joint becomes active. This value slightly extends the lower 
+		/// and upper limit.
+		/// </summary>
+		[ShowInInspector]
+		public float Tolerance
+		{
+			get { return Internal_getTolerance(mCachedPtr); }
+			set { Internal_setTolerance(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines a spring that controls how the joint responds when a limit is reached. You must enable the spring  flag on 
+		/// the joint in order for this to be recognized.
+		/// </summary>
+		[ShowInInspector]
+		public Spring Spring
+		{
+			get
+			{
+				Spring temp;
+				Internal_getSpring(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setSpring(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Enables or disables a flag that controls joint behaviour.</summary>
+		public void SetFlag(DistanceJointFlag flag, bool enabled)
+		{
+			Internal_setFlag(mCachedPtr, flag, enabled);
+		}
+
+		/// <summary>Checks whether a certain joint flag is enabled.</summary>
+		public bool HasFlag(DistanceJointFlag flag)
+		{
+			return Internal_hasFlag(mCachedPtr, flag);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getDistance(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getMinDistance(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMinDistance(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getMaxDistance(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMaxDistance(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getTolerance(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setTolerance(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getSpring(IntPtr thisPtr, out Spring __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setSpring(IntPtr thisPtr, ref Spring value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setFlag(IntPtr thisPtr, DistanceJointFlag flag, bool enabled);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_hasFlag(IntPtr thisPtr, DistanceJointFlag flag);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CFixedJoint.generated.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Physics joint that will maintain a fixed distance and orientation between its two attached bodies.</summary>
+	public partial class FixedJoint : Joint
+	{
+		private FixedJoint(bool __dummy0) { }
+		protected FixedJoint() { }
+
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CHingeJoint.generated.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Hinge joint removes all but a single rotation degree of freedom from its two attached bodies (for example a door  
+	/// hinge).
+	/// </summary>
+	public partial class HingeJoint : Joint
+	{
+		private HingeJoint(bool __dummy0) { }
+		protected HingeJoint() { }
+
+		/// <summary>Returns the current angle between the two attached bodes.</summary>
+		[ShowInInspector]
+		public Radian Angle
+		{
+			get
+			{
+				Radian temp;
+				Internal_getAngle(mCachedPtr, out temp);
+				return temp;
+			}
+		}
+
+		/// <summary>Returns the current angular speed of the joint.</summary>
+		[ShowInInspector]
+		public float Speed
+		{
+			get { return Internal_getSpeed(mCachedPtr); }
+		}
+
+		/// <summary>
+		/// Determines the limit of the joint. Limit constrains the motion to the specified angle range. You must enable the 
+		/// limit flag on the joint in order for this to be recognized.
+		/// </summary>
+		[ShowInInspector]
+		public LimitAngularRange Limit
+		{
+			get
+			{
+				LimitAngularRange temp;
+				Internal_getLimit(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setLimit(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Determines the drive properties of the joint. It drives the joint's angular velocity towards a particular value.  You 
+		/// must enable the drive flag on the joint in order for the drive to be active.
+		/// </summary>
+		[ShowInInspector]
+		public HingeJointDrive Drive
+		{
+			get
+			{
+				HingeJointDrive temp;
+				Internal_getDrive(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setDrive(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Enables or disables a flag that controls joint behaviour.</summary>
+		public void SetFlag(HingeJointFlag flag, bool enabled)
+		{
+			Internal_setFlag(mCachedPtr, flag, enabled);
+		}
+
+		/// <summary>Checks is the specified option enabled.</summary>
+		public bool HasFlag(HingeJointFlag flag)
+		{
+			return Internal_hasFlag(mCachedPtr, flag);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getAngle(IntPtr thisPtr, out Radian __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getSpeed(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getLimit(IntPtr thisPtr, out LimitAngularRange __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setLimit(IntPtr thisPtr, ref LimitAngularRange limit);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getDrive(IntPtr thisPtr, out HingeJointDrive __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setDrive(IntPtr thisPtr, ref HingeJointDrive drive);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setFlag(IntPtr thisPtr, HingeJointFlag flag, bool enabled);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_hasFlag(IntPtr thisPtr, HingeJointFlag flag);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CJoint.generated.cs

@@ -0,0 +1,116 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Base class for all Joint types. Joints constrain how two rigidbodies move relative to one another (for example a door  
+	/// hinge). One of the bodies in the joint must always be movable (non-kinematic).
+	/// </summary>
+	public partial class Joint : Component
+	{
+		private Joint(bool __dummy0) { }
+		protected Joint() { }
+
+		/// <summary>
+		/// Determines the maximum force the joint can apply before breaking. Broken joints no longer participate in physics  
+		/// simulation.
+		/// </summary>
+		[ShowInInspector]
+		public float BreakForce
+		{
+			get { return Internal_getBreakForce(mCachedPtr); }
+			set { Internal_setBreakForce(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the maximum torque the joint can apply before breaking. Broken joints no longer participate in physics  
+		/// simulation.
+		/// </summary>
+		[ShowInInspector]
+		public float BreakTorque
+		{
+			get { return Internal_getBreakTorque(mCachedPtr); }
+			set { Internal_setBreakTorque(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines whether collision between the two bodies managed by the joint are enabled.</summary>
+		[ShowInInspector]
+		public bool EnableCollision
+		{
+			get { return Internal_getEnableCollision(mCachedPtr); }
+			set { Internal_setEnableCollision(mCachedPtr, value); }
+		}
+
+		/// <summary>Triggered when the joint's break force or torque is exceeded.</summary>
+		public event Action OnJointBreak;
+
+		/// <summary>Determines a body managed by the joint. One of the bodies must be movable (non-kinematic).</summary>
+		public Rigidbody GetBody(JointBody body)
+		{
+			return Internal_getBody(mCachedPtr, body);
+		}
+
+		/// <summary>Determines a body managed by the joint. One of the bodies must be movable (non-kinematic).</summary>
+		public void SetBody(JointBody body, Rigidbody value)
+		{
+			Internal_setBody(mCachedPtr, body, value);
+		}
+
+		/// <summary>Returns the position relative to the body, at which the body is anchored to the joint.</summary>
+		public Vector3 GetPosition(JointBody body)
+		{
+			Vector3 temp;
+			Internal_getPosition(mCachedPtr, body, out temp);
+			return temp;
+		}
+
+		/// <summary>Returns the rotation relative to the body, at which the body is anchored to the joint.</summary>
+		public Quaternion GetRotation(JointBody body)
+		{
+			Quaternion temp;
+			Internal_getRotation(mCachedPtr, body, out temp);
+			return temp;
+		}
+
+		/// <summary>Sets the position and rotation relative to the body, at which the body is anchored to the joint.</summary>
+		public void SetTransform(JointBody body, Vector3 position, Quaternion rotation)
+		{
+			Internal_setTransform(mCachedPtr, body, ref position, ref rotation);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Rigidbody Internal_getBody(IntPtr thisPtr, JointBody body);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setBody(IntPtr thisPtr, JointBody body, Rigidbody value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getPosition(IntPtr thisPtr, JointBody body, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getRotation(IntPtr thisPtr, JointBody body, out Quaternion __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setTransform(IntPtr thisPtr, JointBody body, ref Vector3 position, ref Quaternion rotation);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getBreakForce(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setBreakForce(IntPtr thisPtr, float force);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getBreakTorque(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setBreakTorque(IntPtr thisPtr, float torque);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getEnableCollision(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setEnableCollision(IntPtr thisPtr, bool value);
+		private void Internal_onJointBreak()
+		{
+			OnJointBreak?.Invoke();
+		}
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CLight.generated.cs

@@ -0,0 +1,199 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Rendering
+	 *  @{
+	 */
+
+	/// <summary>Illuminates a portion of the scene covered by the light.</summary>
+	public partial class Light : Component
+	{
+		private Light(bool __dummy0) { }
+		protected Light() { }
+
+		/// <summary>Determines the type of the light.</summary>
+		[ShowInInspector]
+		public LightType Type
+		{
+			get { return Internal_getType(mCachedPtr); }
+			set { Internal_setType(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines does this light cast shadows when rendered.</summary>
+		[ShowInInspector]
+		public bool CastsShadow
+		{
+			get { return Internal_getCastsShadow(mCachedPtr); }
+			set { Internal_setCastsShadow(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Shadow bias determines offset at which the shadows are rendered from the shadow caster. Bias value of 0 means the 
+		/// shadow will be renderered exactly at the casters position. If your geometry has thin areas this will produce an 
+		/// artifact called shadow acne, in which case you can increase the shadow bias value to eliminate it.  Note that 
+		/// increasing the shadow bias will on the other hand make the shadow be offset from the caster and may make the caster 
+		/// appear as if floating (Peter Panning artifact). Neither is perfect, so it is preferable to ensure all your geometry 
+		/// has thickness and keep the bias at zero, or even at negative values.
+		///
+		/// Default value is 0.5. Should be in rough range [-1, 1].
+		/// </summary>
+		[ShowInInspector]
+		public float ShadowBias
+		{
+			get { return Internal_getShadowBias(mCachedPtr); }
+			set { Internal_setShadowBias(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines the color emitted by the light.</summary>
+		[ShowInInspector]
+		public Color Color
+		{
+			get
+			{
+				Color temp;
+				Internal_getColor(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setColor(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Range at which the light contribution fades out to zero. Use setUseAutoAttenuation to provide a radius automatically 
+		/// dependant on light intensity. The radius will cut-off light contribution and therefore manually set very small radius 
+		/// can end up being very physically incorrect.
+		/// </summary>
+		[ShowInInspector]
+		public float AttenuationRadius
+		{
+			get { return Internal_getAttenuationRadius(mCachedPtr); }
+			set { Internal_setAttenuationRadius(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Radius of the light source. If non-zero then this light represents an area light, otherwise it is a punctual light. 
+		/// Area lights have different attenuation then punctual lights, and their appearance in specular reflections is 
+		/// realistic. Shape of the area light depends on light type: - For directional light the shape is a disc projected on 
+		/// the hemisphere on the sky. This parameter represents angular radius (in degrees) of the disk and should be very small 
+		/// (think of how much space the Sun takes on the sky - roughly 0.25 degree radius). - For radial light the shape is a 
+		/// sphere and the source radius is the radius of the sphere. - For spot lights the shape is a disc oriented in the 
+		/// direction of the spot light and the source radius is the radius of the disc.
+		/// </summary>
+		[ShowInInspector]
+		public float SourceRadius
+		{
+			get { return Internal_getSourceRadius(mCachedPtr); }
+			set { Internal_setSourceRadius(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the power of the light source. This will be luminous flux for radial & spot lights,  luminance for 
+		/// directional lights with no area, and illuminance for directional lights with area (non-zero source radius).
+		/// </summary>
+		[ShowInInspector]
+		public float Intensity
+		{
+			get { return Internal_getIntensity(mCachedPtr); }
+			set { Internal_setIntensity(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines the total angle covered by a spot light.</summary>
+		[ShowInInspector]
+		public Degree SpotAngle
+		{
+			get
+			{
+				Degree temp;
+				Internal_getSpotAngle(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setSpotAngle(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Determines the falloff angle covered by a spot light. Falloff angle determines at what point does light intensity  
+		/// starts quadratically falling off as the angle approaches the total spot angle.
+		/// </summary>
+		[ShowInInspector]
+		public Degree SpotAngleFalloff
+		{
+			get
+			{
+				Degree temp;
+				Internal_getSpotFalloffAngle(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setSpotFalloffAngle(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// If enabled the attenuation radius will automatically be controlled in order to provide reasonable light radius,  
+		/// depending on its intensity.
+		/// </summary>
+		[ShowInInspector]
+		public bool UseAutoAttenuation
+		{
+			get { return Internal_getUseAutoAttenuation(mCachedPtr); }
+			set { Internal_setUseAutoAttenuation(mCachedPtr, value); }
+		}
+
+		/// <summary>Returns world space bounds that completely encompass the light's area of influence.</summary>
+		[ShowInInspector]
+		public Sphere Bounds
+		{
+			get
+			{
+				Sphere temp;
+				Internal_getBounds(mCachedPtr, out temp);
+				return temp;
+			}
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setType(IntPtr thisPtr, LightType type);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern LightType Internal_getType(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setCastsShadow(IntPtr thisPtr, bool castsShadow);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getCastsShadow(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setShadowBias(IntPtr thisPtr, float bias);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getShadowBias(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setColor(IntPtr thisPtr, ref Color color);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getColor(IntPtr thisPtr, out Color __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setAttenuationRadius(IntPtr thisPtr, float radius);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getAttenuationRadius(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setSourceRadius(IntPtr thisPtr, float radius);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getSourceRadius(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setIntensity(IntPtr thisPtr, float intensity);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getIntensity(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setSpotAngle(IntPtr thisPtr, ref Degree spotAngle);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getSpotAngle(IntPtr thisPtr, out Degree __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setSpotFalloffAngle(IntPtr thisPtr, ref Degree spotAngle);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getSpotFalloffAngle(IntPtr thisPtr, out Degree __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setUseAutoAttenuation(IntPtr thisPtr, bool enabled);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getUseAutoAttenuation(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getBounds(IntPtr thisPtr, out Sphere __output);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CLightProbeVolume.generated.cs

@@ -0,0 +1,182 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Rendering
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Allows you to define a volume of light probes that will be used for indirect lighting. Lighting information in the 
+	/// scene will be interpolated from nearby probes to calculate the amount of indirect lighting at that position. It is up 
+	/// to the caller to place the light probes in areas where the lighting changes in order to yield the best results.
+	///
+	/// The volume can never have less than 4 probes.
+	/// </summary>
+	public partial class LightProbeVolume : Component
+	{
+		private LightProbeVolume(bool __dummy0) { }
+		protected LightProbeVolume() { }
+
+		/// <summary>Returns the volume that's used for adding probes in a uniform grid pattern.</summary>
+		[ShowInInspector]
+		public AABox GridVolume
+		{
+			get
+			{
+				AABox temp;
+				Internal_getGridVolume(mCachedPtr, out temp);
+				return temp;
+			}
+		}
+
+		/// <summary>Returns the cell count that's used for determining the density of probes within a grid volume.</summary>
+		[ShowInInspector]
+		public Vector3I CellCount
+		{
+			get
+			{
+				Vector3I temp;
+				Internal_getCellCount(mCachedPtr, out temp);
+				return temp;
+			}
+		}
+
+		/// <summary>
+		/// Adds a new probe at the specified position and returns a handle to the probe. The position is relative to the volume 
+		/// origin.
+		/// </summary>
+		public uint AddProbe(Vector3 position)
+		{
+			return Internal_addProbe(mCachedPtr, ref position);
+		}
+
+		/// <summary>Updates the position of the probe with the specified handle.</summary>
+		public void SetProbePosition(uint handle, Vector3 position)
+		{
+			Internal_setProbePosition(mCachedPtr, handle, ref position);
+		}
+
+		/// <summary>Retrieves the position of the probe with the specified handle.</summary>
+		public Vector3 GetProbePosition(uint handle)
+		{
+			Vector3 temp;
+			Internal_getProbePosition(mCachedPtr, handle, out temp);
+			return temp;
+		}
+
+		/// <summary>
+		/// Removes the probe with the specified handle. Note that if this is one of the last four remaining probes in the volume 
+		/// it cannot be removed.
+		/// </summary>
+		public void RemoveProbe(uint handle)
+		{
+			Internal_removeProbe(mCachedPtr, handle);
+		}
+
+		/// <summary>Returns a list of positions of all light probes in the volume.</summary>
+		public LightProbeInfo[] GetProbes()
+		{
+			return Internal_getProbes(mCachedPtr);
+		}
+
+		/// <summary>
+		/// Causes the information for this specific light probe to be updated. You generally want to call this when the probe is 
+		/// moved or the scene around the probe changes.
+		/// </summary>
+		public void RenderProbe(uint handle)
+		{
+			Internal_renderProbe(mCachedPtr, handle);
+		}
+
+		/// <summary>
+		/// Causes the information for all lights probes to be updated. You generally want to call this if you move the entire 
+		/// light volume or the scene around the volume changes.
+		/// </summary>
+		public void RenderProbes()
+		{
+			Internal_renderProbes(mCachedPtr);
+		}
+
+		/// <summary>
+		/// Resizes the light probe grid and inserts new light probes, if the new size is larger than previous size. New probes 
+		/// are inserted in a grid pattern matching the new size and density parameters.
+		///
+		/// Note that shrinking the volume will not remove light probes. In order to remove probes outside of the new volume call 
+		/// clip().
+		///
+		/// Resize will not change the positions of current light probes. If you wish to reset all probes to the currently set 
+		/// grid position, call reset().
+		/// </summary>
+		/// <param name="volume">Axis aligned volume to be covered by the light probes.</param>
+		/// <param name="cellCount">
+		/// Number of grid cells to split the volume into. Minimum number of 1, in which case each corner of the volume is 
+		/// represented by a single probe. Higher values subdivide the volume in an uniform way.
+		/// </param>
+		public void Resize(AABox volume, Vector3I cellCount)
+		{
+			Internal_resize(mCachedPtr, ref volume, ref cellCount);
+		}
+
+		/// <summary>Removes any probes outside of the current grid volume.</summary>
+		public void Clip()
+		{
+			Internal_clip(mCachedPtr);
+		}
+
+		/// <summary>
+		/// Resets all probes to match the original grid pattern. This will reset probe positions, as well as add/remove probes 
+		/// as necessary, essentially losing any custom changes to the probes.
+		/// </summary>
+		public void Reset()
+		{
+			Internal_reset(mCachedPtr);
+		}
+
+		/// <summary>
+		/// Resizes the light probe grid and inserts new light probes, if the new size is larger than previous size. New probes 
+		/// are inserted in a grid pattern matching the new size and density parameters.
+		///
+		/// Note that shrinking the volume will not remove light probes. In order to remove probes outside of the new volume call 
+		/// clip().
+		///
+		/// Resize will not change the positions of current light probes. If you wish to reset all probes to the currently set 
+		/// grid position, call reset().
+		/// </summary>
+		/// <param name="volume">Axis aligned volume to be covered by the light probes.</param>
+		public void Resize(AABox volume)
+		{
+			Vector3I cellCount = new Vector3I(1, 1, 1);
+			Internal_resize(mCachedPtr, ref volume, ref cellCount);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_addProbe(IntPtr thisPtr, ref Vector3 position);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setProbePosition(IntPtr thisPtr, uint handle, ref Vector3 position);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getProbePosition(IntPtr thisPtr, uint handle, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_removeProbe(IntPtr thisPtr, uint handle);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern LightProbeInfo[] Internal_getProbes(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_renderProbe(IntPtr thisPtr, uint handle);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_renderProbes(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_resize(IntPtr thisPtr, ref AABox volume, ref Vector3I cellCount);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_clip(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_reset(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getGridVolume(IntPtr thisPtr, out AABox __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getCellCount(IntPtr thisPtr, out Vector3I __output);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CMeshCollider.generated.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>A collider represented by an arbitrary mesh.</summary>
+	public partial class MeshCollider : Collider
+	{
+		private MeshCollider(bool __dummy0) { }
+		protected MeshCollider() { }
+
+		/// <summary>
+		/// Sets a mesh that represents the collider geometry. This can be a generic triangle mesh, or and convex mesh.  Triangle 
+		/// meshes are not supported as triggers, nor are they supported for colliders that are parts of a  non-kinematic 
+		/// rigidbody.
+		/// </summary>
+		[ShowInInspector]
+		public PhysicsMesh Mesh
+		{
+			get { return Internal_getMesh(mCachedPtr); }
+			set { Internal_setMesh(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMesh(IntPtr thisPtr, PhysicsMesh mesh);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern PhysicsMesh Internal_getMesh(IntPtr thisPtr);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CPlaneCollider.generated.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>A collider with plane geometry. Plane colliders cannot be a part of non-kinematic rigidbodies.</summary>
+	public partial class PlaneCollider : Collider
+	{
+		private PlaneCollider(bool __dummy0) { }
+		protected PlaneCollider() { }
+
+		/// <summary>Normal vector that determines the local orientation of the plane.</summary>
+		[ShowInInspector]
+		public Vector3 Normal
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getNormal(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setNormal(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Determines the distance of the plane from the local origin, along its normal vector.</summary>
+		[ShowInInspector]
+		public float Distance
+		{
+			get { return Internal_getDistance(mCachedPtr); }
+			set { Internal_setDistance(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setNormal(IntPtr thisPtr, ref Vector3 normal);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getNormal(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setDistance(IntPtr thisPtr, float distance);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getDistance(IntPtr thisPtr);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CReflectionProbe.generated.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Rendering
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Specifies a location at which a pre-computed texture containing scene radiance will be generated. This texture will 
+	/// then be used by the renderer to provide specular reflections.
+	/// </summary>
+	public partial class ReflectionProbe : Component
+	{
+		private ReflectionProbe(bool __dummy0) { }
+		protected ReflectionProbe() { }
+
+		/// <summary>Changes the type of the probe.</summary>
+		[ShowInInspector]
+		public ReflectionProbeType Type
+		{
+			get { return Internal_getType(mCachedPtr); }
+			set { Internal_setType(mCachedPtr, value); }
+		}
+
+		/// <summary>Sets the radius of a sphere reflection probe.</summary>
+		[ShowInInspector]
+		public float Radius
+		{
+			get { return Internal_getRadius(mCachedPtr); }
+			set { Internal_setRadius(mCachedPtr, value); }
+		}
+
+		/// <summary>Sets the extents of a box reflection probe. Determines range of influence.</summary>
+		[ShowInInspector]
+		public Vector3 Extents
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getExtents(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setExtents(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Allows you assign a custom texture to use as a reflection map. This will disable automatic generation of reflections. 
+		/// To re-enable auto-generation call this with a null parameter.
+		/// </summary>
+		[ShowInInspector]
+		public Texture CustomTexture
+		{
+			get { return Internal_getCustomTexture(mCachedPtr); }
+			set { Internal_setCustomTexture(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Captures the scene at the current location and generates a filtered reflection cubemap. No action is taken if a 
+		/// custom texture is set.
+		/// </summary>
+		public void Capture()
+		{
+			Internal_capture(mCachedPtr);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern ReflectionProbeType Internal_getType(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setType(IntPtr thisPtr, ReflectionProbeType type);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getRadius(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setRadius(IntPtr thisPtr, float radius);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getExtents(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setExtents(IntPtr thisPtr, ref Vector3 extents);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Texture Internal_getCustomTexture(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setCustomTexture(IntPtr thisPtr, Texture texture);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_capture(IntPtr thisPtr);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CRenderable.generated.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Rendering
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Renderable represents any visible object in the scene. It has a mesh, bounds and a set of materials. Renderer will 
+	/// render any Renderable objects visible by a camera.
+	/// </summary>
+	public partial class Renderable : Component
+	{
+		private Renderable(bool __dummy0) { }
+		protected Renderable() { }
+
+		/// <summary>
+		/// Determines the mesh to render. All sub-meshes of the mesh will be rendered, and you may set individual materials for 
+		/// each sub-mesh.
+		/// </summary>
+		[ShowInInspector]
+		public Mesh Mesh
+		{
+			get { return Internal_getMesh(mCachedPtr); }
+			set { Internal_setMesh(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines all materials used for rendering this renderable. Each of the materials is used for rendering a single 
+		/// sub-mesh. If number of materials is larger than number of sub-meshes, they will be ignored. If lower, the remaining 
+		/// materials will be removed.
+		/// </summary>
+		[ShowInInspector]
+		public Material[] Materials
+		{
+			get { return Internal_getMaterials(mCachedPtr); }
+			set { Internal_setMaterials(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the layer bitfield that controls whether a renderable is considered visible in a specific camera.  
+		/// Renderable layer must match camera layer in order for the camera to render the component.
+		/// </summary>
+		[ShowInInspector]
+		public ulong Layers
+		{
+			get { return Internal_getLayer(mCachedPtr); }
+			set { Internal_setLayer(mCachedPtr, value); }
+		}
+
+		/// <summary>Gets world bounds of the mesh rendered by this object.</summary>
+		[ShowInInspector]
+		public Bounds Bounds
+		{
+			get
+			{
+				Bounds temp;
+				Internal_getBounds(mCachedPtr, out temp);
+				return temp;
+			}
+		}
+
+		/// <summary>
+		/// Sets a material that will be used for rendering a sub-mesh with the specified index. If a sub-mesh doesn't have a 
+		/// specific material set then the primary material will be used.
+		/// </summary>
+		public void SetMaterial(uint idx, Material material)
+		{
+			Internal_setMaterial(mCachedPtr, idx, material);
+		}
+
+		/// <summary>
+		/// Sets a material that will be used for rendering a sub-mesh with the specified index. If a sub-mesh doesn't have a 
+		/// specific material set then the primary material will be used.
+		/// </summary>
+		public void SetMaterial(Material material)
+		{
+			Internal_setMaterial0(mCachedPtr, material);
+		}
+
+		/// <summary>Returns the material used for rendering a sub-mesh with the specified index.</summary>
+		public Material GetMaterial(uint idx)
+		{
+			return Internal_getMaterial(mCachedPtr, idx);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMesh(IntPtr thisPtr, Mesh mesh);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Mesh Internal_getMesh(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMaterial(IntPtr thisPtr, uint idx, Material material);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMaterial0(IntPtr thisPtr, Material material);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Material Internal_getMaterial(IntPtr thisPtr, uint idx);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMaterials(IntPtr thisPtr, Material[] materials);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Material[] Internal_getMaterials(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setLayer(IntPtr thisPtr, ulong layer);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern ulong Internal_getLayer(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getBounds(IntPtr thisPtr, out Bounds __output);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CRigidbody.generated.cs

@@ -0,0 +1,394 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Rigidbody is a dynamic physics object that can be moved using forces (or directly). It will interact with other static 
+	/// and dynamic physics objects in the scene accordingly (it will push other non-kinematic rigidbodies,  and collide with 
+	/// static objects).
+	///
+	/// The shape and mass of a rigidbody is governed by its colliders. You must attach at least one collider for the  
+	/// rigidbody to be valid.
+	/// </summary>
+	public partial class Rigidbody : Component
+	{
+		private Rigidbody(bool __dummy0) { }
+		protected Rigidbody() { }
+
+		/// <summary>
+		/// Determines the mass of the object and all of its collider shapes. Only relevant if RigidbodyFlag::AutoMass or  
+		/// RigidbodyFlag::AutoTensors is turned off. Value of zero means the object is immovable (but can be rotated).
+		/// </summary>
+		[ShowInInspector]
+		public float Mass
+		{
+			get { return Internal_getMass(mCachedPtr); }
+			set { Internal_setMass(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines if the body is kinematic. Kinematic body will not move in response to external forces (for example 
+		/// gravity, or another object pushing it), essentially behaving like collider. Unlike a collider though, you can still 
+		/// move the object and have other dynamic objects respond correctly (meaning it will push other objects).
+		/// </summary>
+		[ShowInInspector]
+		public bool IsKinematic
+		{
+			get { return Internal_getIsKinematic(mCachedPtr); }
+			set { Internal_setIsKinematic(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Checks if the body is sleeping. Objects that aren't moved/rotated for a while are put to sleep to reduce load on the 
+		/// physics system.
+		/// </summary>
+		[ShowInInspector]
+		public bool IsSleeping
+		{
+			get { return Internal_isSleeping(mCachedPtr); }
+		}
+
+		/// <summary>
+		/// Determines a threshold of force and torque under which the object will be considered to be put to sleep.
+		/// </summary>
+		[ShowInInspector]
+		public float SleepThreshold
+		{
+			get { return Internal_getSleepThreshold(mCachedPtr); }
+			set { Internal_setSleepThreshold(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines whether or not the rigidbody will have the global gravity force applied to it.</summary>
+		[ShowInInspector]
+		public bool UseGravity
+		{
+			get { return Internal_getUseGravity(mCachedPtr); }
+			set { Internal_setUseGravity(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines the linear velocity of the body.</summary>
+		[ShowInInspector]
+		public Vector3 Velocity
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getVelocity(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setVelocity(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Determines the angular velocity of the body.</summary>
+		[ShowInInspector]
+		public Vector3 AngularVelocity
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getAngularVelocity(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setAngularVelocity(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Determines the linear drag of the body. Higher drag values means the object resists linear movement more.
+		/// </summary>
+		[ShowInInspector]
+		public float Drag
+		{
+			get { return Internal_getDrag(mCachedPtr); }
+			set { Internal_setDrag(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the angular drag of the body. Higher drag values means the object resists angular movement more.
+		/// </summary>
+		[ShowInInspector]
+		public float AngularDrag
+		{
+			get { return Internal_getAngularDrag(mCachedPtr); }
+			set { Internal_setAngularDrag(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the inertia tensor in local mass space. Inertia tensor determines how difficult is to rotate the object. 
+		/// Values of zero in the inertia tensor mean the object will be unable to rotate around a specific axis.  Only relevant 
+		/// if RigidbodyFlag::AutoTensors is turned off.
+		/// </summary>
+		[ShowInInspector]
+		public Vector3 InertiaTensor
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getInertiaTensor(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setInertiaTensor(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Determines the maximum angular velocity of the rigidbody. Velocity will be clamped to this value.</summary>
+		[ShowInInspector]
+		public float MaxAngularVelocity
+		{
+			get { return Internal_getMaxAngularVelocity(mCachedPtr); }
+			set { Internal_setMaxAngularVelocity(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the rigidbody's center of mass position. Only relevant if RigibodyFlag::AutoTensors is turned off.
+		/// </summary>
+		[ShowInInspector]
+		public Vector3 CenterOfMassPosition
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getCenterOfMassPosition(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setCenterOfMassPosition(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Determines the rigidbody's center of mass rotation. Only relevant if RigibodyFlag::AutoTensors is turned off.
+		/// </summary>
+		[ShowInInspector]
+		public Quaternion CenterOfMassRotation
+		{
+			get
+			{
+				Quaternion temp;
+				Internal_getCenterOfMassRotation(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setCenterOfMassRotation(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Determines the number of iterations to use when solving for position. Higher values can improve precision and  
+		/// numerical stability of the simulation.
+		/// </summary>
+		[ShowInInspector]
+		public uint PositionSolverCount
+		{
+			get { return Internal_getPositionSolverCount(mCachedPtr); }
+			set { Internal_setPositionSolverCount(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the number of iterations to use when solving for velocity. Higher values can improve precision and  
+		/// numerical stability of the simulation.
+		/// </summary>
+		[ShowInInspector]
+		public uint VelocitySolverCount
+		{
+			get { return Internal_getVelocitySolverCount(mCachedPtr); }
+			set { Internal_setVelocitySolverCount(mCachedPtr, value); }
+		}
+
+		/// <summary>Sets a value that determines which (if any) collision events are reported.</summary>
+		[ShowInInspector]
+		public CollisionReportMode CollisionReportMode
+		{
+			get { return Internal_getCollisionReportMode(mCachedPtr); }
+			set { Internal_setCollisionReportMode(mCachedPtr, value); }
+		}
+
+		/// <summary>Flags that control the behaviour of the rigidbody.</summary>
+		[ShowInInspector]
+		public RigidbodyFlag Flags
+		{
+			get { return Internal_getFlags(mCachedPtr); }
+			set { Internal_setFlags(mCachedPtr, value); }
+		}
+
+		/// <summary>Triggered when one of the colliders owned by the rigidbody starts colliding with another object.</summary>
+		public event Action<CollisionData> OnCollisionBegin;
+
+		/// <summary>Triggered when a previously colliding collider stays in collision. Triggered once per frame.</summary>
+		public event Action<CollisionData> OnCollisionStay;
+
+		/// <summary>Triggered when one of the colliders owned by the rigidbody stops colliding with another object.</summary>
+		public event Action<CollisionData> OnCollisionEnd;
+
+		/// <summary>
+		/// Moves the rigidbody to a specific position. This method will ensure physically correct movement, meaning the body 
+		/// will collide with other objects along the way.
+		/// </summary>
+		public void Move(Vector3 position)
+		{
+			Internal_move(mCachedPtr, ref position);
+		}
+
+		/// <summary>
+		/// Rotates the rigidbody. This method will ensure physically correct rotation, meaning the body will collide with  other 
+		/// objects along the way.
+		/// </summary>
+		public void Rotate(Quaternion rotation)
+		{
+			Internal_rotate(mCachedPtr, ref rotation);
+		}
+
+		/// <summary>
+		/// Forces the object to sleep. Useful if you know the object will not move in any significant way for a while.
+		/// </summary>
+		public void Sleep()
+		{
+			Internal_sleep(mCachedPtr);
+		}
+
+		/// <summary>
+		/// Wakes an object up. Useful if you modified properties of this object, and potentially surrounding objects which might 
+		/// result in the object being moved by physics (although the physics system will automatically wake the object up for 
+		/// majority of such cases).
+		/// </summary>
+		public void WakeUp()
+		{
+			Internal_wakeUp(mCachedPtr);
+		}
+
+		/// <summary>Applies a force to the center of the mass of the rigidbody. This will produce linear momentum.</summary>
+		/// <param name="force">Force to apply.</param>
+		/// <param name="mode">Determines what is the type of</param>
+		public void AddForce(Vector3 force, ForceMode mode = ForceMode.Force)
+		{
+			Internal_addForce(mCachedPtr, ref force, mode);
+		}
+
+		/// <summary>Applies a torque to the rigidbody. This will produce angular momentum.</summary>
+		/// <param name="torque">Torque to apply.</param>
+		/// <param name="mode">Determines what is the type of</param>
+		public void AddTorque(Vector3 torque, ForceMode mode = ForceMode.Force)
+		{
+			Internal_addTorque(mCachedPtr, ref torque, mode);
+		}
+
+		/// <summary>
+		/// Applies a force to a specific point on the rigidbody. This will in most cases produce both linear and angular 
+		/// momentum.
+		/// </summary>
+		/// <param name="force">Force to apply.</param>
+		/// <param name="position">World position to apply the force at.</param>
+		/// <param name="mode">Determines what is the type of</param>
+		public void AddForceAtPoint(Vector3 force, Vector3 position, PointForceMode mode = PointForceMode.Force)
+		{
+			Internal_addForceAtPoint(mCachedPtr, ref force, ref position, mode);
+		}
+
+		/// <summary>Returns the total (linear + angular) velocity at a specific point.</summary>
+		/// <param name="point">Point in world space.</param>
+		/// <returns>Total velocity of the point.</returns>
+		public Vector3 GetVelocityAtPoint(Vector3 point)
+		{
+			Vector3 temp;
+			Internal_getVelocityAtPoint(mCachedPtr, ref point, out temp);
+			return temp;
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_move(IntPtr thisPtr, ref Vector3 position);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_rotate(IntPtr thisPtr, ref Quaternion rotation);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMass(IntPtr thisPtr, float mass);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getMass(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setIsKinematic(IntPtr thisPtr, bool kinematic);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getIsKinematic(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_isSleeping(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_sleep(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_wakeUp(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setSleepThreshold(IntPtr thisPtr, float threshold);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getSleepThreshold(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setUseGravity(IntPtr thisPtr, bool gravity);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getUseGravity(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setVelocity(IntPtr thisPtr, ref Vector3 velocity);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getVelocity(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setAngularVelocity(IntPtr thisPtr, ref Vector3 velocity);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getAngularVelocity(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setDrag(IntPtr thisPtr, float drag);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getDrag(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setAngularDrag(IntPtr thisPtr, float drag);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getAngularDrag(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setInertiaTensor(IntPtr thisPtr, ref Vector3 tensor);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getInertiaTensor(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMaxAngularVelocity(IntPtr thisPtr, float maxVelocity);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getMaxAngularVelocity(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setCenterOfMassPosition(IntPtr thisPtr, ref Vector3 position);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getCenterOfMassPosition(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setCenterOfMassRotation(IntPtr thisPtr, ref Quaternion rotation);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getCenterOfMassRotation(IntPtr thisPtr, out Quaternion __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setPositionSolverCount(IntPtr thisPtr, uint count);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getPositionSolverCount(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setVelocitySolverCount(IntPtr thisPtr, uint count);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getVelocitySolverCount(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setCollisionReportMode(IntPtr thisPtr, CollisionReportMode mode);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern CollisionReportMode Internal_getCollisionReportMode(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setFlags(IntPtr thisPtr, RigidbodyFlag flags);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern RigidbodyFlag Internal_getFlags(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_addForce(IntPtr thisPtr, ref Vector3 force, ForceMode mode);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_addTorque(IntPtr thisPtr, ref Vector3 torque, ForceMode mode);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_addForceAtPoint(IntPtr thisPtr, ref Vector3 force, ref Vector3 position, PointForceMode mode);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getVelocityAtPoint(IntPtr thisPtr, ref Vector3 point, out Vector3 __output);
+		private void Internal_onCollisionBegin(ref CollisionData p0)
+		{
+			OnCollisionBegin?.Invoke(p0);
+		}
+		private void Internal_onCollisionStay(ref CollisionData p0)
+		{
+			OnCollisionStay?.Invoke(p0);
+		}
+		private void Internal_onCollisionEnd(ref CollisionData p0)
+		{
+			OnCollisionEnd?.Invoke(p0);
+		}
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CSkybox.generated.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Rendering
+	 *  @{
+	 */
+
+	/// <summary>Allows you to specify an environment map to use for sampling radiance of the sky.</summary>
+	public partial class Skybox : Component
+	{
+		private Skybox(bool __dummy0) { }
+		protected Skybox() { }
+
+		/// <summary>
+		/// Determines an environment map to use for sampling skybox radiance. Must be a cube-map texture, and should ideally 
+		/// contain HDR data.
+		/// </summary>
+		[ShowInInspector]
+		public Texture Texture
+		{
+			get { return Internal_getTexture(mCachedPtr); }
+			set { Internal_setTexture(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Brightness multiplier that will be applied to skybox values before they're being used. Allows you to make the skybox 
+		/// more or less bright. Equal to one by default.
+		/// </summary>
+		[ShowInInspector]
+		public float Brightness
+		{
+			get { return Internal_getBrightness(mCachedPtr); }
+			set { Internal_setBrightness(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Texture Internal_getTexture(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setTexture(IntPtr thisPtr, Texture texture);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setBrightness(IntPtr thisPtr, float brightness);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getBrightness(IntPtr thisPtr);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CSliderJoint.generated.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Joint that removes all but a single translational degree of freedom. Bodies are allowed to move along a single axis.
+	/// </summary>
+	public partial class SliderJoint : Joint
+	{
+		private SliderJoint(bool __dummy0) { }
+		protected SliderJoint() { }
+
+		/// <summary>Returns the current position of the slider.</summary>
+		[ShowInInspector]
+		public float Position
+		{
+			get { return Internal_getPosition(mCachedPtr); }
+		}
+
+		/// <summary>Returns the current speed of the slider.</summary>
+		[ShowInInspector]
+		public float Speed
+		{
+			get { return Internal_getSpeed(mCachedPtr); }
+		}
+
+		/// <summary>
+		/// Determines a limit that constrains the movement of the joint to a specific minimum and maximum distance. You must 
+		/// enable the limit flag on the joint in order for this to be recognized.
+		/// </summary>
+		[ShowInInspector]
+		public LimitLinearRange Limit
+		{
+			get
+			{
+				LimitLinearRange temp;
+				Internal_getLimit(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setLimit(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Enables or disables a flag that controls the joint's behaviour.</summary>
+		public void SetFlag(SliderJointFlag flag, bool enabled)
+		{
+			Internal_setFlag(mCachedPtr, flag, enabled);
+		}
+
+		/// <summary>Checks is the specified flag enabled.</summary>
+		public bool HasFlag(SliderJointFlag flag)
+		{
+			return Internal_hasFlag(mCachedPtr, flag);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getPosition(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getSpeed(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getLimit(IntPtr thisPtr, out LimitLinearRange __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setLimit(IntPtr thisPtr, ref LimitLinearRange limit);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setFlag(IntPtr thisPtr, SliderJointFlag flag, bool enabled);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_hasFlag(IntPtr thisPtr, SliderJointFlag flag);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CSphereCollider.generated.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>A collider with sphere geometry.</summary>
+	public partial class SphereCollider : Collider
+	{
+		private SphereCollider(bool __dummy0) { }
+		protected SphereCollider() { }
+
+		/// <summary>Determines the radius of the sphere geometry.</summary>
+		[ShowInInspector]
+		public float Radius
+		{
+			get { return Internal_getRadius(mCachedPtr); }
+			set { Internal_setRadius(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines position of the sphere shape, relative to the component's scene object.</summary>
+		[ShowInInspector]
+		public Vector3 Center
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getCenter(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setCenter(mCachedPtr, ref value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setRadius(IntPtr thisPtr, float radius);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getRadius(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setCenter(IntPtr thisPtr, ref Vector3 center);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getCenter(IntPtr thisPtr, out Vector3 __output);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CSphericalJoint.generated.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>
+	/// A spherical joint removes all translational degrees of freedom but allows all rotational degrees of freedom.  
+	/// Essentially this ensures that the anchor points of the two bodies are always coincident. Bodies are allowed to rotate 
+	/// around the anchor points, and their rotatation can be limited by an elliptical cone.
+	/// </summary>
+	public partial class SphericalJoint : Joint
+	{
+		private SphericalJoint(bool __dummy0) { }
+		protected SphericalJoint() { }
+
+		/// <summary>
+		/// Determines the limit of the joint. This clamps the rotation inside an eliptical angular cone. You must enable limit 
+		/// flag on the joint in order for this to be recognized.
+		/// </summary>
+		[ShowInInspector]
+		public LimitConeRange Limit
+		{
+			get
+			{
+				LimitConeRange temp;
+				Internal_getLimit(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setLimit(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Enables or disables a flag that controls the joint's behaviour.</summary>
+		public void SetFlag(SphericalJointFlag flag, bool enabled)
+		{
+			Internal_setFlag(mCachedPtr, flag, enabled);
+		}
+
+		/// <summary>Checks is the specified flag enabled.</summary>
+		public bool HasFlag(SphericalJointFlag flag)
+		{
+			return Internal_hasFlag(mCachedPtr, flag);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getLimit(IntPtr thisPtr, out LimitConeRange __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setLimit(IntPtr thisPtr, ref LimitConeRange limit);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setFlag(IntPtr thisPtr, SphericalJointFlag flag, bool enabled);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_hasFlag(IntPtr thisPtr, SphericalJointFlag flag);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CharDesc.generated.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup GUI_Engine
+	 *  @{
+	 */
+
+	/// <summary>Describes a single character in a font of a specific size.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct CharDesc
+	{
+		/// <summary>Character ID, corresponding to a Unicode key.</summary>
+		public uint charId;
+		/// <summary>Index of the texture the character is located on.</summary>
+		public uint page;
+		/// <summary>Texture coordinates of the character in the page texture.</summary>
+		public float uvX;
+		/// <summary>Texture coordinates of the character in the page texture.</summary>
+		public float uvY;
+		/// <summary>Width/height of the character in texture coordinates.</summary>
+		public float uvWidth;
+		/// <summary>Width/height of the character in texture coordinates.</summary>
+		public float uvHeight;
+		/// <summary>Width/height of the character in pixels.</summary>
+		public uint width;
+		/// <summary>Width/height of the character in pixels.</summary>
+		public uint height;
+		/// <summary>Offset for the visible portion of the character in pixels.</summary>
+		public int xOffset;
+		/// <summary>Offset for the visible portion of the character in pixels.</summary>
+		public int yOffset;
+		/// <summary>Determines how much to advance the pen after writing this character, in pixels.</summary>
+		public int xAdvance;
+		/// <summary>Determines how much to advance the pen after writing this character, in pixels.</summary>
+		public int yAdvance;
+		/// <summary>
+		/// Pairs that determine if certain character pairs should be closer or father together. for example "AV" combination.
+		/// </summary>
+		public KerningPair[] kerningPairs;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CharacterClimbingMode.generated.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Controls climbing behaviour for a capsule character controller. Normally the character controller will not 
+	/// automatically climb when heights are greater than the assigned step offset. However due to the shape of the capsule it 
+	/// might automatically climb over slightly larger heights than assigned step offsets.
+	/// </summary>
+	public enum CharacterClimbingMode
+	{
+		/// <summary>
+		/// Normal behaviour. Capsule character controller will be able to auto-step even above the step offset.
+		/// </summary>
+		Normal = 0,
+		/// <summary>The system will attempt to limit auto-step to the provided step offset and no higher.</summary>
+		Constrained = 1
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CharacterCollisionFlag.generated.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Reports in which directions is the character colliding with other objects.</summary>
+	public enum CharacterCollisionFlag
+	{
+		/// <summary>Character is colliding with its sides.</summary>
+		Sides = 1,
+		/// <summary>Character is colliding with the ceiling.</summary>
+		Up = 2,
+		/// <summary>Character is colliding with the ground.</summary>
+		Down = 4
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CharacterNonWalkableMode.generated.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Controls behaviour when a character controller reaches a slope thats larger than its slope offset.</summary>
+	public enum CharacterNonWalkableMode
+	{
+		/// <summary>Character will be prevented from going further, but will be allowed to move laterally.</summary>
+		Prevent = 0,
+		/// <summary>Character will be prevented from going further, but also slide down the slope.</summary>
+		PreventAndSlide = 1
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/ClearFlagBits.generated.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/// <summary>Flags that determine which portion of the viewport to clear.</summary>
+	public enum ClearFlags
+	{
+		Empty = 0,
+		Color = 1,
+		Depth = 2,
+		Stencil = 4
+	}
+}

Source/Scripting/MBansheeEngine/Generated/CollisionData.generated.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Information about a collision between two physics objects.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct CollisionData
+	{
+		/// <summary>Components of the colliders that have collided.</summary>
+		public Collider[] collider;
+		/// <summary>Information about all the contact points for the hit.</summary>
+		public ContactPoint[] contactPoints;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/CollisionReportMode.generated.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Determines which collision events will be reported by physics objects.</summary>
+	public enum CollisionReportMode
+	{
+		/// <summary>No collision events will be triggered.</summary>
+		None = 0,
+		/// <summary>Collision events will be triggered when object enters and/or leaves collision.</summary>
+		Report = 1,
+		/// <summary>
+		/// Collision events will be triggered when object enters and/or leaves collision, but also every frame the object 
+		/// remains in collision.
+		/// </summary>
+		ReportPersistent = 2
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/ColorGradingSettings.generated.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/// <summary>Settings that control color grading post-process.</summary>
+	public partial class ColorGradingSettings : ScriptObject
+	{
+		private ColorGradingSettings(bool __dummy0) { }
+		protected ColorGradingSettings() { }
+
+		/// <summary>
+		/// Saturation to be applied during color grading. Larger values increase vibrancy of the image. In range [0.0f, 2.0f].
+		/// </summary>
+		public Vector3 Saturation
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getsaturation(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setsaturation(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Contrast to be applied during color grading. Larger values increase difference between light and dark areas of the 
+		/// image. In range [0.0f, 2.0f].
+		/// </summary>
+		public Vector3 Contrast
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getcontrast(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setcontrast(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Gain to be applied during color grading. Simply increases all color values by an equal scale. In range [0.0f, 2.0f].
+		/// </summary>
+		public Vector3 Gain
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getgain(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setgain(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Gain to be applied during color grading. Simply offsets all color values by an equal amount. In range [-1.0f, 1.0f].
+		/// </summary>
+		public Vector3 Offset
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getoffset(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setoffset(mCachedPtr, ref value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getsaturation(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setsaturation(IntPtr thisPtr, ref Vector3 value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getcontrast(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setcontrast(IntPtr thisPtr, ref Vector3 value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getgain(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setgain(IntPtr thisPtr, ref Vector3 value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getoffset(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setoffset(IntPtr thisPtr, ref Vector3 value);
+	}
+}

Source/Scripting/MBansheeEngine/Generated/ContactPoint.generated.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Information about a single contact point during physics collision.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct ContactPoint
+	{
+		/// <summary>Contact point in world space.</summary>
+		public Vector3 position;
+		/// <summary>Normal pointing from the second shape to the first shape.</summary>
+		public Vector3 normal;
+		/// <summary>
+		/// Impulse applied to the objects to keep them from penetrating. Divide by simulation step to get the force.
+		/// </summary>
+		public float impulse;
+		/// <summary>Determines how far are the objects. Negative value denotes penetration.</summary>
+		public float separation;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/ControllerColliderCollision.generated.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Contains data about a collision of a character controller and a collider.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct ControllerColliderCollision
+	{
+		///<summary>
+		/// Returns a subset of this struct. This subset usually contains common fields shared with another struct.
+		///</summary>
+		public ControllerCollision GetBase()
+		{
+			ControllerCollision value;
+			value.position = position;
+			value.normal = normal;
+			value.motionDir = motionDir;
+			value.motionAmount = motionAmount;
+			return value;
+		}
+
+		///<summary>
+		/// Assigns values to a subset of fields of this struct. This subset usually contains common field shared with 
+		/// another struct.
+		///</summary>
+		public void SetBase(ControllerCollision value)
+		{
+			position = value.position;
+			normal = value.normal;
+			motionDir = value.motionDir;
+			motionAmount = value.motionAmount;
+		}
+
+		/// <summary>
+		/// Component of the controller that was touched. Can be null if the controller has no component parent, in which  case 
+		/// check #colliderRaw.
+		/// </summary>
+		public Collider collider;
+		/// <summary>Touched triangle index for mesh colliders.</summary>
+		public uint triangleIndex;
+		/// <summary>Contact position.</summary>
+		public Vector3 position;
+		/// <summary>Contact normal.</summary>
+		public Vector3 normal;
+		/// <summary>Direction of motion after the hit.</summary>
+		public Vector3 motionDir;
+		/// <summary>Magnitude of motion after the hit.</summary>
+		public float motionAmount;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/ControllerCollision.generated.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Contains data about a collision of a character controller and another object.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct ControllerCollision
+	{
+		/// <summary>Contact position.</summary>
+		public Vector3 position;
+		/// <summary>Contact normal.</summary>
+		public Vector3 normal;
+		/// <summary>Direction of motion after the hit.</summary>
+		public Vector3 motionDir;
+		/// <summary>Magnitude of motion after the hit.</summary>
+		public float motionAmount;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/ControllerControllerCollision.generated.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Contains data about a collision between two character controllers.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct ControllerControllerCollision
+	{
+		///<summary>
+		/// Returns a subset of this struct. This subset usually contains common fields shared with another struct.
+		///</summary>
+		public ControllerCollision GetBase()
+		{
+			ControllerCollision value;
+			value.position = position;
+			value.normal = normal;
+			value.motionDir = motionDir;
+			value.motionAmount = motionAmount;
+			return value;
+		}
+
+		///<summary>
+		/// Assigns values to a subset of fields of this struct. This subset usually contains common field shared with 
+		/// another struct.
+		///</summary>
+		public void SetBase(ControllerCollision value)
+		{
+			position = value.position;
+			normal = value.normal;
+			motionDir = value.motionDir;
+			motionAmount = value.motionAmount;
+		}
+
+		/// <summary>
+		/// Component of the controller that was touched. Can be null if the controller has no component parent, in which  case 
+		/// check #controllerRaw.
+		/// </summary>
+		public CharacterController controller;
+		/// <summary>Contact position.</summary>
+		public Vector3 position;
+		/// <summary>Contact normal.</summary>
+		public Vector3 normal;
+		/// <summary>Direction of motion after the hit.</summary>
+		public Vector3 motionDir;
+		/// <summary>Magnitude of motion after the hit.</summary>
+		public float motionAmount;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/D6JointAxis.generated.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Specifies axes that the D6 joint can constrain motion on.</summary>
+	public enum D6JointAxis
+	{
+		/// <summary>Movement on the X axis.</summary>
+		X = 0,
+		/// <summary>Movement on the Y axis.</summary>
+		Y = 1,
+		/// <summary>Movement on the Z axis.</summary>
+		Z = 2,
+		/// <summary>Rotation around the X axis.</summary>
+		Twist = 3,
+		/// <summary>Rotation around the Y axis.</summary>
+		SwingY = 4,
+		/// <summary>Rotation around the Z axis.</summary>
+		SwingZ = 5,
+		Count = 6
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/D6JointDrive.generated.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Specifies parameters for a drive that will attempt to move the joint bodies to the specified drive position and 
+	/// velocity.
+	/// </summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct D6JointDrive
+	{
+		/// <summary>Initializes the struct with default values.</summary>
+		public static D6JointDrive Default()
+		{
+			D6JointDrive value = new D6JointDrive();
+			value.stiffness = 0f;
+			value.damping = 0f;
+			value.forceLimit = 3.40282347E+38f;
+			value.acceleration = false;
+
+			return value;
+		}
+
+		/// <summary>Spring strength. Force proportional to the position error.</summary>
+		public float stiffness;
+		/// <summary>Damping strength. Force propertional to the velocity error.</summary>
+		public float damping;
+		/// <summary>Maximum force the drive can apply.</summary>
+		public float forceLimit;
+		/// <summary>
+		/// If true the drive will generate acceleration instead of forces. Acceleration drives are easier to tune as they 
+		/// account for the masses of the actors to which the joint is attached.
+		/// </summary>
+		public bool acceleration;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/D6JointDriveType.generated.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Type of drives that can be used for moving or rotating bodies attached to the joint.</summary>
+	public enum D6JointDriveType
+	{
+		/// <summary>Linear movement on the X axis using the linear drive model.</summary>
+		X = 0,
+		/// <summary>Linear movement on the Y axis using the linear drive model.</summary>
+		Y = 1,
+		/// <summary>Linear movement on the Z axis using the linear drive model.</summary>
+		Z = 2,
+		/// <summary>
+		/// Rotation around the Y axis using the twist/swing angular drive model. Should not be used together with  SLERP mode.
+		/// </summary>
+		Swing = 3,
+		/// <summary>
+		/// Rotation around the Z axis using the twist/swing angular drive model. Should not be used together with  SLERP mode.
+		/// </summary>
+		Twist = 4,
+		/// <summary>
+		/// Rotation using spherical linear interpolation. Uses the SLERP angular drive mode which performs rotation by 
+		/// interpolating the quaternion values directly over the shortest path (applies to all three axes, which they all must 
+		/// be unlocked).
+		/// </summary>
+		SLERP = 5,
+		/// <summary>
+		/// Rotation using spherical linear interpolation. Uses the SLERP angular drive mode which performs rotation by 
+		/// interpolating the quaternion values directly over the shortest path (applies to all three axes, which they all must 
+		/// be unlocked).
+		/// </summary>
+		Count = 6
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/D6JointMotion.generated.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Specifies type of constraint placed on a specific axis.</summary>
+	public enum D6JointMotion
+	{
+		/// <summary>Axis is immovable.</summary>
+		Locked = 0,
+		/// <summary>Axis will be constrained by the specified limits.</summary>
+		Limited = 1,
+		/// <summary>Axis will not be constrained.</summary>
+		Free = 2,
+		Count = 3
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/DepthOfFieldSettings.generated.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/// <summary>Settings that control the depth-of-field effect.</summary>
+	public partial class DepthOfFieldSettings : ScriptObject
+	{
+		private DepthOfFieldSettings(bool __dummy0) { }
+
+		public DepthOfFieldSettings()
+		{
+			Internal_DepthOfFieldSettings(this);
+		}
+
+		/// <summary>Enables or disables the depth of field effect.</summary>
+		public bool Enabled
+		{
+			get { return Internal_getenabled(mCachedPtr); }
+			set { Internal_setenabled(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Distance from the camera at which the focal plane is located in. Objects at this distance will be fully in focus.
+		/// </summary>
+		public float FocalDistance
+		{
+			get { return Internal_getfocalDistance(mCachedPtr); }
+			set { Internal_setfocalDistance(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Range within which the objects remain fully in focus. This range is applied relative to the focal distance.  Only 
+		/// relevant if Gaussian depth of field is used as other methods don't use a constant in-focus range.
+		/// </summary>
+		public float FocalRange
+		{
+			get { return Internal_getfocalRange(mCachedPtr); }
+			set { Internal_setfocalRange(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the size of the range within which objects transition from focused to fully unfocused, at the near  plane. 
+		/// Only relevant for Gaussian depth of field.
+		/// </summary>
+		public float NearTransitionRange
+		{
+			get { return Internal_getnearTransitionRange(mCachedPtr); }
+			set { Internal_setnearTransitionRange(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the size of the range within which objects transition from focused to fully unfocused, at the far  plane. 
+		/// Only relevant for Gaussian depth of field.
+		/// </summary>
+		public float FarTransitionRange
+		{
+			get { return Internal_getfarTransitionRange(mCachedPtr); }
+			set { Internal_setfarTransitionRange(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the amount of blur to apply to fully unfocused objects that are closer to camera than the in-focus zone. 
+		/// Set to zero to disable near-field blur. Only relevant for Gaussian depth of field.
+		/// </summary>
+		public float NearBlurAmount
+		{
+			get { return Internal_getnearBlurAmount(mCachedPtr); }
+			set { Internal_setnearBlurAmount(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the amount of blur to apply to fully unfocused objects that are farther away from camera than the in-focus 
+		/// zone. Set to zero to disable far-field blur. Only relevant for Gaussian depth of field.
+		/// </summary>
+		public float FarBlurAmount
+		{
+			get { return Internal_getfarBlurAmount(mCachedPtr); }
+			set { Internal_setfarBlurAmount(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_DepthOfFieldSettings(DepthOfFieldSettings managedInstance);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getenabled(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setenabled(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getfocalDistance(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setfocalDistance(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getfocalRange(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setfocalRange(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getnearTransitionRange(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setnearTransitionRange(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getfarTransitionRange(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setfarTransitionRange(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getnearBlurAmount(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setnearBlurAmount(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getfarBlurAmount(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setfarBlurAmount(IntPtr thisPtr, float value);
+	}
+}

Source/Scripting/MBansheeEngine/Generated/DistanceJointFlag.generated.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Controls distance joint options.</summary>
+	public enum DistanceJointFlag
+	{
+		/// <summary>Enables minimum distance limit.</summary>
+		MinDistance = 1,
+		/// <summary>Enables maximum distance limit.</summary>
+		MaxDistance = 2,
+		/// <summary>Enables spring when maintaining limits.</summary>
+		Spring = 4
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/DrawOperationType.generated.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Rendering
+	 *  @{
+	 */
+
+	/// <summary>Describes operation that will be used for rendering a certain set of vertices.</summary>
+	public enum MeshTopology
+	{
+		/// <summary>Each vertex represents a point.</summary>
+		PointList = 1,
+		/// <summary>Each sequential pair of vertices represent a line.</summary>
+		LineList = 2,
+		/// <summary>Each vertex (except the first) forms a line with the previous vertex.</summary>
+		LineStrip = 3,
+		/// <summary>Each sequential 3-tuple of vertices represent a triangle.</summary>
+		TriangleList = 4,
+		/// <summary>Each vertex (except the first two) form a triangle with the previous two vertices.</summary>
+		TriangleStrip = 5,
+		/// <summary>Each vertex (except the first two) form a triangle with the first vertex and previous vertex.</summary>
+		TriangleFan = 6
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/Font.generated.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup GUI_Engine
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Font resource containing data about textual characters and how to render text. Contains one or multiple font  bitmaps, 
+	/// each for a specific size.
+	/// </summary>
+	public partial class Font : Resource
+	{
+		private Font(bool __dummy0) { }
+		protected Font() { }
+
+		/// <summary>Returns font bitmap for a specific font size.</summary>
+		/// <param name="size">Size of the bitmap in points.</param>
+		/// <returns>Bitmap object if it exists, false otherwise.</returns>
+		public FontBitmap GetBitmap(uint size)
+		{
+			return Internal_getBitmap(mCachedPtr, size);
+		}
+
+		/// <summary>Finds the available font bitmap size closest to the provided size.</summary>
+		/// <param name="size">Size of the bitmap in points.</param>
+		/// <returns>Nearest available bitmap size.</returns>
+		public int GetClosestSize(uint size)
+		{
+			return Internal_getClosestSize(mCachedPtr, size);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern FontBitmap Internal_getBitmap(IntPtr thisPtr, uint size);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int Internal_getClosestSize(IntPtr thisPtr, uint size);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/FontBitmap.generated.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup GUI_Engine
+	 *  @{
+	 */
+
+	/// <summary>Contains textures and data about every character for a bitmap font of a specific size.</summary>
+	public partial class FontBitmap : ScriptObject
+	{
+		private FontBitmap(bool __dummy0) { }
+		protected FontBitmap() { }
+
+		/// <summary>Font size for which the data is contained.</summary>
+		public uint Size
+		{
+			get { return Internal_getsize(mCachedPtr); }
+			set { Internal_setsize(mCachedPtr, value); }
+		}
+
+		/// <summary>Y offset to the baseline on which the characters are placed, in pixels.</summary>
+		public int BaselineOffset
+		{
+			get { return Internal_getbaselineOffset(mCachedPtr); }
+			set { Internal_setbaselineOffset(mCachedPtr, value); }
+		}
+
+		/// <summary>Height of a single line of the font, in pixels.</summary>
+		public uint LineHeight
+		{
+			get { return Internal_getlineHeight(mCachedPtr); }
+			set { Internal_setlineHeight(mCachedPtr, value); }
+		}
+
+		/// <summary>Character to use when data for a character is missing.</summary>
+		public CharDesc MissingGlyph
+		{
+			get
+			{
+				CharDesc temp;
+				Internal_getmissingGlyph(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setmissingGlyph(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Width of a space in pixels.</summary>
+		public uint SpaceWidth
+		{
+			get { return Internal_getspaceWidth(mCachedPtr); }
+			set { Internal_setspaceWidth(mCachedPtr, value); }
+		}
+
+		/// <summary>Textures in which the character's pixels are stored.</summary>
+		public Texture[] TexturePages
+		{
+			get { return Internal_gettexturePages(mCachedPtr); }
+			set { Internal_settexturePages(mCachedPtr, value); }
+		}
+
+		/// <summary>Returns a character description for the character with the specified Unicode key.</summary>
+		public CharDesc GetCharDesc(uint charId)
+		{
+			CharDesc temp;
+			Internal_getCharDesc(mCachedPtr, charId, out temp);
+			return temp;
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getCharDesc(IntPtr thisPtr, uint charId, out CharDesc __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getsize(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setsize(IntPtr thisPtr, uint value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int Internal_getbaselineOffset(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setbaselineOffset(IntPtr thisPtr, int value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getlineHeight(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setlineHeight(IntPtr thisPtr, uint value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getmissingGlyph(IntPtr thisPtr, out CharDesc __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setmissingGlyph(IntPtr thisPtr, ref CharDesc value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getspaceWidth(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setspaceWidth(IntPtr thisPtr, uint value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Texture[] Internal_gettexturePages(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_settexturePages(IntPtr thisPtr, Texture[] value);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/ForceMode.generated.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Type of force or torque that can be applied to a rigidbody.</summary>
+	public enum ForceMode
+	{
+		/// <summary>Value applied is a force.</summary>
+		Force = 0,
+		/// <summary>Value applied is an impulse (a direct change in its linear or angular momentum).</summary>
+		Impulse = 1,
+		/// <summary>Value applied is velocity.</summary>
+		Velocity = 2,
+		/// <summary>Value applied is accelearation.</summary>
+		Acceleration = 3
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/HingeJointDrive.generated.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Properties of a drive that drives the joint's angular velocity towards a paricular value.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct HingeJointDrive
+	{
+		/// <summary>Initializes the struct with default values.</summary>
+		public static HingeJointDrive Default()
+		{
+			HingeJointDrive value = new HingeJointDrive();
+			value.speed = 0f;
+			value.forceLimit = 3.40282347E+38f;
+			value.gearRatio = 1f;
+			value.freeSpin = false;
+
+			return value;
+		}
+
+		/// <summary>Target speed of the joint.</summary>
+		public float speed;
+		/// <summary>Maximum torque the drive is allowed to apply .</summary>
+		public float forceLimit;
+		/// <summary>Scales the velocity of the first body, and its response to drive torque is scaled down.</summary>
+		public float gearRatio;
+		/// <summary>
+		/// If the joint is moving faster than the drive's target speed, the drive will try to break. If you don't want the 
+		/// breaking to happen set this to true.
+		/// </summary>
+		public bool freeSpin;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/HingeJointFlag.generated.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Flags that control hinge joint options.</summary>
+	public enum HingeJointFlag
+	{
+		/// <summary>Joint limit is enabled.</summary>
+		Limit = 1,
+		/// <summary>Joint drive is enabled.</summary>
+		Drive = 2
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/IndexType.generated.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Rendering
+	 *  @{
+	 */
+
+	/// <summary>Type of mesh indices used, used for determining maximum number of vertices in a mesh.</summary>
+	public enum IndexType
+	{
+		/// <summary>16-bit indices.</summary>
+		Index16 = 0,
+		/// <summary>32-bit indices.</summary>
+		Index32 = 1
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/JointBody.generated.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Specifies first or second body referenced by a Joint.</summary>
+	public enum JointBody
+	{
+		/// <summary>Body the joint is influencing.</summary>
+		Target = 0,
+		/// <summary>Body the joint is attached to (if any).</summary>
+		Anchor = 1
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/KerningPair.generated.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup GUI_Engine
+	 *  @{
+	 */
+
+	/// <summary>Kerning pair representing larger or smaller offset between a specific pair of characters.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct KerningPair
+	{
+		public uint otherCharId;
+		public int amount;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/Language.generated.cs

@@ -0,0 +1,206 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Localization
+	 *  @{
+	 */
+
+	/// <summary>
+	/// A set of all languages that localized strings can be translated to. Loosely based on ISO 639-1 two letter language 
+	/// codes.
+	/// </summary>
+	public enum Language
+	{
+		Assamese = 8,
+		Herero = 64,
+		Afar = 0,
+		Abkhazian = 1,
+		Avestan = 2,
+		Afrikaans = 3,
+		Akan = 4,
+		Amharic = 5,
+		Aragonese = 6,
+		Arabic = 7,
+		Avaric = 9,
+		Aymara = 10,
+		Azerbaijani = 11,
+		Bashkir = 12,
+		Belarusian = 13,
+		Bulgarian = 14,
+		Bihari = 15,
+		Bislama = 16,
+		Bambara = 17,
+		Bengali = 18,
+		Tibetan = 19,
+		Breton = 20,
+		Bosnian = 21,
+		Catalan = 22,
+		Chechen = 23,
+		Chamorro = 24,
+		Corsican = 25,
+		Cree = 26,
+		Czech = 27,
+		ChurchSlavic = 28,
+		Chuvash = 29,
+		Welsh = 30,
+		Danish = 31,
+		German = 32,
+		Maldivian = 33,
+		Bhutani = 34,
+		Ewe = 35,
+		Greek = 36,
+		EnglishUK = 37,
+		EnglishUS = 38,
+		Esperanto = 39,
+		Spanish = 40,
+		Estonian = 41,
+		Basque = 42,
+		Persian = 43,
+		Fulah = 44,
+		Finnish = 45,
+		Fijian = 46,
+		Faroese = 47,
+		French = 48,
+		WesternFrisian = 49,
+		Irish = 50,
+		ScottishGaelic = 51,
+		Galician = 52,
+		Guarani = 53,
+		Gujarati = 54,
+		Manx = 55,
+		Hausa = 56,
+		Hebrew = 57,
+		Hindi = 58,
+		HiriMotu = 59,
+		Croatian = 60,
+		Haitian = 61,
+		Hungarian = 62,
+		Armenian = 63,
+		Interlingua = 65,
+		Indonesian = 66,
+		Interlingue = 67,
+		Igbo = 68,
+		SichuanYi = 69,
+		Inupiak = 70,
+		Ido = 71,
+		Icelandic = 72,
+		Italian = 73,
+		Inuktitut = 74,
+		Japanese = 75,
+		Javanese = 76,
+		Georgian = 77,
+		Kongo = 78,
+		Kikuyu = 79,
+		Kuanyama = 80,
+		Kazakh = 81,
+		Kalaallisut = 82,
+		Cambodian = 83,
+		Kannada = 84,
+		Korean = 85,
+		Kanuri = 86,
+		Kashmiri = 87,
+		Kurdish = 88,
+		Komi = 89,
+		Cornish = 90,
+		Kirghiz = 91,
+		Latin = 92,
+		Luxembourgish = 93,
+		Ganda = 94,
+		Limburgish = 95,
+		Lingala = 96,
+		Laotian = 97,
+		Lithuanian = 98,
+		LubaKatanga = 99,
+		Latvian = 100,
+		Malagasy = 101,
+		Marshallese = 102,
+		Maori = 103,
+		Macedonian = 104,
+		Malayalam = 105,
+		Mongolian = 106,
+		Moldavian = 107,
+		Marathi = 108,
+		Malay = 109,
+		Maltese = 110,
+		Burmese = 111,
+		Nauru = 112,
+		NorwegianBokmal = 113,
+		Ndebele = 114,
+		Nepali = 115,
+		Ndonga = 116,
+		Dutch = 117,
+		NorwegianNynorsk = 118,
+		Norwegian = 119,
+		Navaho = 120,
+		Nyanja = 121,
+		Provencal = 122,
+		Ojibwa = 123,
+		Oromo = 124,
+		Oriya = 125,
+		Ossetic = 126,
+		Punjabi = 127,
+		Pali = 128,
+		Polish = 129,
+		Pushto = 130,
+		Portuguese = 131,
+		Quechua = 132,
+		Romansh = 133,
+		Kirundi = 134,
+		Romanian = 135,
+		Russian = 136,
+		Kinyarwanda = 137,
+		Sanskrit = 138,
+		Sardinian = 139,
+		Sindhi = 140,
+		NorthernSami = 141,
+		Sangro = 142,
+		Sinhalese = 143,
+		Slovak = 144,
+		Slovenian = 145,
+		Samoan = 146,
+		Shona = 147,
+		Somali = 148,
+		Albanian = 149,
+		Serbian = 150,
+		Swati = 151,
+		Sesotho = 152,
+		Sundanese = 153,
+		Swedish = 154,
+		Swahili = 155,
+		Tamil = 156,
+		Telugu = 157,
+		Tajik = 158,
+		Thai = 159,
+		Tigrinya = 160,
+		Turkmen = 161,
+		Tagalog = 162,
+		Setswana = 163,
+		Tonga = 164,
+		Turkish = 165,
+		Tsonga = 166,
+		Tatar = 167,
+		Twi = 168,
+		Tahitian = 169,
+		Uighur = 170,
+		Ukrainian = 171,
+		Urdu = 172,
+		Uzbek = 173,
+		Venda = 174,
+		Vietnamese = 175,
+		Volapuk = 176,
+		Walloon = 177,
+		Wolof = 178,
+		Xhosa = 179,
+		Yiddish = 180,
+		Yoruba = 181,
+		Zhuang = 182,
+		Chinese = 183,
+		Zulu = 184,
+		Count = 185
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/LightProbeInfo.generated.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Rendering
+	 *  @{
+	 */
+
+	/// <summary>Information about a single probe in the light probe volume.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct LightProbeInfo
+	{
+		public uint handle;
+		public Vector3 position;
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/LightType.generated.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Rendering
+	 *  @{
+	 */
+
+	/// <summary>Light type that determines how is light information parsed by the renderer and other systems.</summary>
+	public enum LightType
+	{
+		Directional = 0,
+		Radial = 1,
+		Spot = 2
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/Generated/LimitAngularRange.generated.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/// <summary>Represents a joint limit between two angles.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct LimitAngularRange
+	{
+		/// <summary>Initializes the struct with default values.</summary>
+		public static LimitAngularRange Default()
+		{
+			LimitAngularRange value = new LimitAngularRange();
+			value.lower = new Radian();
+			value.upper = new Radian();
+			value.contactDist = -1f;
+			value.restitution = 0f;
+			value.spring = new Spring();
+
+			return value;
+		}
+
+		/// <summary>
+		/// Constructs a hard limit. Once the limit is reached the movement of the attached bodies will come to a stop.
+		/// </summary>
+		/// <param name="lower">Lower angle of the limit. Must be less than</param>
+		/// <param name="upper">Upper angle of the limit. Must be more than</param>
+		/// <param name="contactDist">
+		/// Distance from the limit at which it becomes active. Allows the solver to activate earlier than the limit is reached 
+		/// to avoid breaking the limit. Specify -1 for the default.
+		/// </param>
+		public LimitAngularRange(Radian lower, Radian upper, float contactDist = -1f)
+		{
+			this.lower = lower;
+			this.upper = upper;
+			this.contactDist = -1f;
+			this.restitution = 0f;
+			this.spring = new Spring();
+		}
+
+		/// <summary>
+		/// Constructs a soft limit. Once the limit is reached the bodies will bounce back according to the resitution parameter 
+		/// and will be pulled back towards the limit by the provided spring.
+		/// </summary>
+		/// <param name="lower">Lower angle of the limit. Must be less than</param>
+		/// <param name="upper">Upper angle of the limit. Must be more than</param>
+		/// <param name="spring">
+		/// Spring that controls how are the bodies pulled back towards the limit when they breach it.
+		/// </param>
+		/// <param name="restitution">
+		/// Controls how do objects react when the limit is reached, values closer to zero specify non-ellastic collision, while 
+		/// those closer to one specify more ellastic (i.e bouncy) collision. Must be in [0, 1] range.
+		/// </param>
+		public LimitAngularRange(Radian lower, Radian upper, Spring spring, float restitution = 0f)
+		{
+			this.lower = lower;
+			this.upper = upper;
+			this.contactDist = -1f;
+			this.restitution = 0f;
+			this.spring = new Spring();
+		}
+
+		///<summary>
+		/// Returns a subset of this struct. This subset usually contains common fields shared with another struct.
+		///</summary>
+		public LimitCommon GetBase()
+		{
+			LimitCommon value;
+			value.contactDist = contactDist;
+			value.restitution = restitution;
+			value.spring = spring;
+			return value;
+		}
+
+		///<summary>
+		/// Assigns values to a subset of fields of this struct. This subset usually contains common field shared with 
+		/// another struct.
+		///</summary>
+		public void SetBase(LimitCommon value)
+		{
+			contactDist = value.contactDist;
+			restitution = value.restitution;
+			spring = value.spring;
+		}
+
+		/// <summary>Lower angle of the limit. Must be less than #upper.</summary>
+		public Radian lower;
+		/// <summary>Upper angle of the limit. Must be less than #lower.</summary>
+		public Radian upper;
+		/// <summary>
+		/// Distance from the limit at which it becomes active. Allows the solver to activate earlier than the limit is reached 
+		/// to avoid breaking the limit.
+		/// </summary>
+		public float contactDist;
+		/// <summary>
+		/// Controls how do objects react when the limit is reached, values closer to zero specify non-ellastic collision, while 
+		/// those closer to one specify more ellastic (i.e bouncy) collision. Must be in [0, 1] range.
+		/// </summary>
+		public float restitution;
+		/// <summary>Spring that controls how are the bodies pulled back towards the limit when they breach it.</summary>
+		public Spring spring;
+	}
+
+	/** @} */
+}