Build: Updated 'bsf' version

Source/EditorCore/Build/BsBuiltinEditorResources.cpp

@@ -3,33 +3,7 @@
 #include "Utility/BsBuiltinEditorResources.h"
 #include "Resources/BsBuiltinResources.h"
 #include "GUI/BsGUIElementStyle.h"
-#include "GUI/BsGUILabel.h"
-#include "GUI/BsGUITexture.h"
-#include "GUI/BsGUIButton.h"
-#include "GUI/BsGUIInputBox.h"
-#include "GUI/BsGUIToggle.h"
-#include "GUI/BsGUIColor.h"
-#include "2D/BsTextSprite.h"
-#include "2D/BsSpriteTexture.h"
-#include "GUI/BsGUITreeViewEditBox.h"
-#include "GUI/BsGUIIntField.h"
-#include "GUI/BsGUIFloatField.h"
-#include "GUI/BsGUIColorField.h"
-#include "GUI/BsGUITextField.h"
-#include "GUI/BsGUIToggleField.h"
-#include "GUI/BsGUIVector2Field.h"
-#include "GUI/BsGUIVector3Field.h"
-#include "GUI/BsGUIVector4Field.h"
-#include "GUI/BsGUIListBoxField.h"
-#include "GUI/BsGUISliderField.h"
-#include "GUI/BsGUIProgressBar.h"
-#include "GUI/BsGUISlider.h"
-#include "GUI/BsGUIDropDownContent.h"
-#include "GUI/BsGUIStatusBar.h"
-#include "GUI/BsGUIMenuBar.h"
-#include "GUI/BsGUIListBox.h"
-#include "GUI/BsGUIScrollBar.h"
-#include "CoreThread/BsCoreThread.h"
+#include "Image/BsSpriteTexture.h"
 #include "Text/BsFont.h"
 #include "Image/BsTexture.h"
 #include "Material/BsShader.h"

Source/EditorCore/GUI/BsGUIColor.cpp

@@ -6,7 +6,7 @@
 #include "GUI/BsGUIMouseEvent.h"
 #include "GUI/BsGUIHelper.h"
 #include "Resources/BsBuiltinResources.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 
 namespace bs
 {

Source/EditorCore/SceneView/BsGizmoManager.cpp

@@ -7,7 +7,7 @@
 #include "RenderAPI/BsVertexDataDesc.h"
 #include "Utility/BsShapeMeshes3D.h"
 #include "Components/BsCCamera.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "CoreThread/BsCoreThread.h"
 #include "Utility/BsBuiltinEditorResources.h"
 #include "Material/BsMaterial.h"

Source/Scripting/MBansheeEditor/Windows/Scene/Gizmos/ColliderGizmos.cs

@@ -29,6 +29,9 @@ namespace BansheeEditor
             Vector3 scaledExtents = collider.Extents*scale;
 
             Gizmos.DrawWireCube(collider.Center * scale, scaledExtents);
+
+            Gizmos.DrawText(Vector3.Zero, "Test test test");
+            Gizmos.DrawText(new Vector3(0, 1, 0), "WTest Wtest Wtest");
         }
 
         /// <summary>

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

@@ -50,7 +50,7 @@ namespace BansheeEngine
 
 		/// <summary>
 		/// Distance (in view space, in meters) after which AO starts fading out. The fade process will happen over the range as 
-		/// specified by
+		/// specified by <see cref="fadeRange"/>.
 		/// </summary>
 		public float FadeDistance
 		{
@@ -60,7 +60,7 @@ namespace BansheeEngine
 
 		/// <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
+		/// specified in <see cref="fadeDistance"/>.
 		/// </summary>
 		public float FadeRange
 		{

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

@@ -139,8 +139,8 @@ namespace BansheeEngine
 
 		/// <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.
+		/// animations are not advanced with the progress of time, and is instead expected the user manually changes the 
+		/// <paramref name="t"/> parameter.
 		/// </summary>
 		/// <param name="info">
 		/// Information about the clips to blend. Clip positions must be sorted from lowest to highest.
@@ -155,7 +155,8 @@ namespace BansheeEngine
 
 		/// <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.
+		/// are not advanced with the progress of time, and is instead expected the user manually changes the <paramref 
+		/// name="t"/> parameter.
 		/// </summary>
 		/// <param name="info">Information about the clips to blend.</param>
 		/// <param name="t">

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

@@ -258,7 +258,7 @@ namespace BansheeEngine
 
 		/// <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>
+		/// <param name="mode">Determines what is the type of <paramref name="force"/>.</param>
 		public void AddForce(Vector3 force, ForceMode mode = ForceMode.Force)
 		{
 			Internal_addForce(mCachedPtr, ref force, mode);
@@ -266,7 +266,7 @@ namespace BansheeEngine
 
 		/// <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>
+		/// <param name="mode">Determines what is the type of <paramref name="torque"/>.</param>
 		public void AddTorque(Vector3 torque, ForceMode mode = ForceMode.Force)
 		{
 			Internal_addTorque(mCachedPtr, ref torque, mode);
@@ -278,7 +278,7 @@ namespace BansheeEngine
 		/// </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>
+		/// <param name="mode">Determines what is the type of <paramref name="force"/>.</param>
 		public void AddForceAtPoint(Vector3 force, Vector3 position, PointForceMode mode = PointForceMode.Force)
 		{
 			Internal_addForceAtPoint(mCachedPtr, ref force, ref position, mode);

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

@@ -0,0 +1,69 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Image
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Represents a range of color values over some parameters, similar to a curve. Internally represented as a set of keys 
+	/// that get interpolated between.
+	/// </summary>
+	public partial class ColorGradient : ScriptObject
+	{
+		private ColorGradient(bool __dummy0) { }
+
+		public ColorGradient()
+		{
+			Internal_ColorGradient(this);
+		}
+
+		public ColorGradient(Color color)
+		{
+			Internal_ColorGradient0(this, ref color);
+		}
+
+		public ColorGradient(ColorGradientKey[] keys)
+		{
+			Internal_ColorGradient1(this, keys);
+		}
+
+		/// <summary>Set of keys that control the gradient, sorted by time from first to last.</summary>
+		public void SetKeys(ColorGradientKey[] keys)
+		{
+			Internal_setKeys(mCachedPtr, keys);
+		}
+
+		/// <summary>Specify a "gradient" that represents a single color value.</summary>
+		public void SetConstant(Color color)
+		{
+			Internal_setConstant(mCachedPtr, ref color);
+		}
+
+		/// <summary>Evaluates a color at the specified <paramref name="t"/>.</summary>
+		public Color Evaluate(float t)
+		{
+			Color temp;
+			Internal_evaluate(mCachedPtr, t, out temp);
+			return temp;
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_ColorGradient(ColorGradient managedInstance);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_ColorGradient0(ColorGradient managedInstance, ref Color color);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_ColorGradient1(ColorGradient managedInstance, ColorGradientKey[] keys);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setKeys(IntPtr thisPtr, ColorGradientKey[] keys);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setConstant(IntPtr thisPtr, ref Color color);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_evaluate(IntPtr thisPtr, float t, out Color __output);
+	}
+
+	/** @} */
+}

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

@@ -0,0 +1,30 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Image
+	 *  @{
+	 */
+
+	/// <summary>Single key in a ColorGradient.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct ColorGradientKey
+	{
+		/// <summary>Initializes the struct with default values.</summary>
+		public static ColorGradientKey Default()
+		{
+			ColorGradientKey value = new ColorGradientKey();
+			value.color = new Color();
+			value.time = 0f;
+
+			return value;
+		}
+
+		public Color color;
+		public float time;
+	}
+
+	/** @} */
+}

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

@@ -28,8 +28,8 @@ namespace BansheeEngine
 		/// <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="lower">Lower angle of the limit. Must be less than <paramref name="upper"/>.</param>
+		/// <param name="upper">Upper angle of the limit. Must be more than <paramref name="lower"/>.</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.
@@ -47,8 +47,8 @@ namespace BansheeEngine
 		/// 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="lower">Lower angle of the limit. Must be less than <paramref name="upper"/>.</param>
+		/// <param name="upper">Upper angle of the limit. Must be more than <paramref name="lower"/>.</param>
 		/// <param name="spring">
 		/// Spring that controls how are the bodies pulled back towards the limit when they breach it.
 		/// </param>

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

@@ -30,8 +30,8 @@ namespace BansheeEngine
 		/// <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 distance of the limit. Must be less than</param>
-		/// <param name="upper">Upper distance of the limit. Must be more than</param>
+		/// <param name="lower">Lower distance of the limit. Must be less than <paramref name="upper"/>.</param>
+		/// <param name="upper">Upper distance of the limit. Must be more than <paramref name="lower"/>.</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.
@@ -49,8 +49,8 @@ namespace BansheeEngine
 		/// 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 distance of the limit. Must be less than</param>
-		/// <param name="upper">Upper distance of the limit. Must be more than</param>
+		/// <param name="lower">Lower distance of the limit. Must be less than <paramref name="upper"/>.</param>
+		/// <param name="upper">Upper distance of the limit. Must be more than <paramref name="lower"/>.</param>
 		/// <param name="spring">
 		/// Spring that controls how are the bodies pulled back towards the limit when they breach it.
 		/// </param>

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

@@ -54,6 +54,11 @@ namespace BansheeEngine
 			Internal_setFloat(mCachedPtr, name, value, arrayIdx);
 		}
 
+		public void SetFloatCurve(string name, AnimationCurve value, uint arrayIdx = 0)
+		{
+			Internal_setFloatCurve(mCachedPtr, name, value, arrayIdx);
+		}
+
 		/// <summary>
 		/// Assigns a color to the shader parameter with the specified name.
 		///
@@ -64,6 +69,17 @@ namespace BansheeEngine
 			Internal_setColor(mCachedPtr, name, ref value, arrayIdx);
 		}
 
+		/// <summary>
+		/// Assigns a color gradient to the shader parameter with the specified name. The system will automatically evaluate the 
+		/// gradient with the passage of time and apply the evaluated value to the parameter.
+		///
+		/// Optionally if the parameter is an array you may provide an array index to assign the value to.
+		/// </summary>
+		public void SetColorGradient(string name, ColorGradient value, uint arrayIdx = 0)
+		{
+			Internal_setColorGradient(mCachedPtr, name, value, arrayIdx);
+		}
+
 		/// <summary>
 		/// Assigns a 2D vector to the shader parameter with the specified name.
 		///
@@ -115,7 +131,8 @@ namespace BansheeEngine
 		}
 
 		/// <summary>
-		/// Returns a float value assigned with the parameter with the specified name.
+		/// Returns a float value assigned with the parameter with the specified name. If a curve is assigned to this parameter, 
+		/// returns the curve value evaluated at time 0. Use getBoundParamType() to determine the type of the parameter.
 		///
 		/// Optionally if the parameter is an array you may provide an array index you which to retrieve.
 		/// </summary>
@@ -125,7 +142,21 @@ namespace BansheeEngine
 		}
 
 		/// <summary>
-		/// Returns a color assigned with the parameter with the specified name.
+		/// Returns a curve value assigned to the parameter with the specified name. If the parameter has a constant value bound 
+		/// instead of a curve then this method returns an empty curve. Use getBoundParamType() to determine the type of the 
+		/// parameter.
+		///
+		/// Optionally if the parameter is an array you may provide an array index you which to retrieve.
+		/// </summary>
+		public AnimationCurve GetFloatCurve(string name, uint arrayIdx = 0)
+		{
+			return Internal_getFloatCurve(mCachedPtr, name, arrayIdx);
+		}
+
+		/// <summary>
+		/// Returns a color assigned with the parameter with the specified name. If a color gradient is assigned to this 
+		/// parameter, returns the gradient color evaluated at time 0. Use getBoundParamType() to determine the type of the 
+		/// parameter.
 		///
 		/// Optionally if the parameter is an array you may provide an array index you which to retrieve.
 		/// </summary>
@@ -136,6 +167,18 @@ namespace BansheeEngine
 			return temp;
 		}
 
+		/// <summary>
+		/// Returns a color gradient assigned with the parameter with the specified name. If the parameter has a constant value 
+		/// bound instead of a gradient then this method returns an empty gradient. Use getBoundParamType() to determine the type 
+		/// of the parameter.
+		///
+		/// Optionally if the parameter is an array you may provide an array index you which to retrieve.
+		/// </summary>
+		public ColorGradient GetColorGradient(string name, uint arrayIdx = 0)
+		{
+			return Internal_getColorGradient(mCachedPtr, name, arrayIdx);
+		}
+
 		/// <summary>
 		/// Returns a 2D vector assigned with the parameter with the specified name.
 		///
@@ -205,8 +248,12 @@ namespace BansheeEngine
 		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern void Internal_setFloat(IntPtr thisPtr, string name, float value, uint arrayIdx);
 		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setFloatCurve(IntPtr thisPtr, string name, AnimationCurve value, uint arrayIdx);
+		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern void Internal_setColor(IntPtr thisPtr, string name, ref Color value, uint arrayIdx);
 		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setColorGradient(IntPtr thisPtr, string name, ColorGradient value, uint arrayIdx);
+		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern void Internal_setVec2(IntPtr thisPtr, string name, ref Vector2 value, uint arrayIdx);
 		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern void Internal_setVec3(IntPtr thisPtr, string name, ref Vector3 value, uint arrayIdx);
@@ -219,8 +266,12 @@ namespace BansheeEngine
 		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern float Internal_getFloat(IntPtr thisPtr, string name, uint arrayIdx);
 		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern AnimationCurve Internal_getFloatCurve(IntPtr thisPtr, string name, uint arrayIdx);
+		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern void Internal_getColor(IntPtr thisPtr, string name, uint arrayIdx, out Color __output);
 		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern ColorGradient Internal_getColorGradient(IntPtr thisPtr, string name, uint arrayIdx);
+		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern void Internal_getVec2(IntPtr thisPtr, string name, uint arrayIdx, out Vector2 __output);
 		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern void Internal_getVec3(IntPtr thisPtr, string name, uint arrayIdx, out Vector3 __output);
@@ -238,6 +289,10 @@ namespace BansheeEngine
 		private static extern void Internal_setTexture(IntPtr thisPtr, string name, Texture value, uint mipLevel, uint numMipLevels, uint arraySlice, uint numArraySlices);
 		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern Texture Internal_getTexture(IntPtr thisPtr, string name);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setSpriteTexture(IntPtr thisPtr, string name, SpriteTexture value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern SpriteTexture Internal_getSpriteTexture(IntPtr thisPtr, string name);
 	}
 
 	/** @} */

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

@@ -25,7 +25,8 @@ namespace BansheeEngine
 		/// <param name="gammaCorrection">Determines should the pixels written on the texture be gamma corrected.</param>
 		/// <param name="createDepth">Should the render texture also contain a depth/stencil buffer.</param>
 		/// <param name="depthStencilFormat">
-		/// Format of the depth/stencil buffer, if  is enabled. Format must be a valid depth/stencil format.
+		/// Format of the depth/stencil buffer, if <paramref name="createDepth"/> is enabled. Format must be a valid 
+		/// depth/stencil format.
 		/// </param>
 		public RenderTexture(PixelFormat format, int width, int height, int numSamples = 1, bool gammaCorrection = false, bool createDepth = false, PixelFormat depthStencilFormat = PixelFormat.D32)
 		{

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

@@ -0,0 +1,25 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Rendering
+	 *  @{
+	 */
+
+	/// <summary>Type of playback to use for an animation of a SpriteTexture.</summary>
+	public enum SpriteAnimationPlayback
+	{
+		/// <summary>Do not animate.</summary>
+		None = 0,
+		/// <summary>Animate once until the end of the animation is reached.</summary>
+		Normal = 1,
+		/// <summary>Animate to the end of the animation then loop around.</summary>
+		Loop = 2,
+		/// <summary>Loop the animation but reverse playback when the end is reached.</summary>
+		PingPong = 3
+	}
+
+	/** @} */
+}

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

@@ -0,0 +1,60 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Rendering
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Descriptor that describes a simple sprite sheet animation. The parent texture is split into a grid of  <paramref 
+	/// name="numRows"/> x <paramref name="numColumns"/>, each representing one frame of the animation. Every frame is of 
+	/// equal size. Frames are sequentially evaluated starting from the top-most row, iterating over all columns in a row and 
+	/// then moving to next row, up to <paramref name="count"/> frames. Frames in rows/colums past <paramref name="count"/>. 
+	/// <paramref name="fps"/> frames are evaluated every second, allowing you to control animation speed.
+	/// </summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct SpriteSheetGridAnimation
+	{
+		/// <summary>Initializes the struct with default values.</summary>
+		public static SpriteSheetGridAnimation Default()
+		{
+			SpriteSheetGridAnimation value = new SpriteSheetGridAnimation();
+			value.numRows = 1;
+			value.numColumns = 1;
+			value.count = 1;
+			value.fps = 8;
+
+			return value;
+		}
+
+		public SpriteSheetGridAnimation(uint numRows, uint numColumns, uint count, uint fps)
+		{
+			this.numRows = numRows;
+			this.numColumns = numColumns;
+			this.count = count;
+			this.fps = fps;
+		}
+
+		/// <summary>
+		/// Number of rows to divide the parent's texture area. Determines height of the individual frame (depends on  parent 
+		/// texture size).
+		/// </summary>
+		public uint numRows;
+		/// <summary>
+		/// Number of columns to divide the parent's texture area. Determines column of the individual frame (depends on  parent 
+		/// texture size).
+		/// </summary>
+		public uint numColumns;
+		/// <summary>
+		/// Number of frames in the animation. Must be less or equal than <see cref="numRows"/> * <see cref="numColumns"/>.
+		/// </summary>
+		public uint count;
+		/// <summary>How many frames to evaluate each second. Determines the animation speed.</summary>
+		public uint fps;
+	}
+
+	/** @} */
+}

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

@@ -9,8 +9,10 @@ namespace BansheeEngine
 	 */
 
 	/// <summary>
-	/// Texture interface that encapsulates underlying texture which allows us to create a sprite texture atlas (for example  
-	/// multiple SpriteTexture%s referencing different parts of a single Texture).
+	/// Texture that references a part of a larger texture by specifying an UV subset. When the sprite texture is rendererd 
+	/// only the portion of the texture specified by the UV subset will be rendered. This allows you to use the same texture 
+	/// for multiple sprites (texture atlasing). Sprite textures also allow you to specify sprite sheet animation by varying 
+	/// which portion of the UV is selected over time.
 	/// </summary>
 	public partial class SpriteTexture : Resource
 	{
@@ -36,6 +38,18 @@ namespace BansheeEngine
 			set { Internal_setTexture(mCachedPtr, value); }
 		}
 
+		/// <summary>Returns width of the sprite texture in pixels.</summary>
+		public uint Width
+		{
+			get { return Internal_getWidth(mCachedPtr); }
+		}
+
+		/// <summary>Returns height of the sprite texture in pixels.</summary>
+		public uint Height
+		{
+			get { return Internal_getHeight(mCachedPtr); }
+		}
+
 		/// <summary>
 		/// Determines the offset into the referenced texture where the sprite starts. The offset is in UV coordinates, in range 
 		/// [0, 1].
@@ -65,16 +79,26 @@ namespace BansheeEngine
 			set { Internal_setScale(mCachedPtr, ref value); }
 		}
 
-		/// <summary>Returns width of the sprite texture in pixels.</summary>
-		public uint Width
+		/// <summary>
+		/// Sets properties describing sprite animation. The animation splits the sprite area into a grid of sub-images which can 
+		/// be evaluated over time. In order to view the animation you must also enable playback through setAnimationPlayback().
+		/// </summary>
+		public SpriteSheetGridAnimation Animation
 		{
-			get { return Internal_getWidth(mCachedPtr); }
+			get
+			{
+				SpriteSheetGridAnimation temp;
+				Internal_getAnimation(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setAnimation(mCachedPtr, ref value); }
 		}
 
-		/// <summary>Returns height of the sprite texture in pixels.</summary>
-		public uint Height
+		/// <summary>Determines if and how should the sprite animation play.</summary>
+		public SpriteAnimationPlayback AnimationPlayback
 		{
-			get { return Internal_getHeight(mCachedPtr); }
+			get { return Internal_getAnimationPlayback(mCachedPtr); }
+			set { Internal_setAnimationPlayback(mCachedPtr, value); }
 		}
 
 		[MethodImpl(MethodImplOptions.InternalCall)]
@@ -82,6 +106,10 @@ namespace BansheeEngine
 		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern Texture Internal_getTexture(IntPtr thisPtr);
 		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getWidth(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getHeight(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern void Internal_setOffset(IntPtr thisPtr, ref Vector2 offset);
 		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern void Internal_getOffset(IntPtr thisPtr, out Vector2 __output);
@@ -90,9 +118,13 @@ namespace BansheeEngine
 		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern void Internal_getScale(IntPtr thisPtr, out Vector2 __output);
 		[MethodImpl(MethodImplOptions.InternalCall)]
-		private static extern uint Internal_getWidth(IntPtr thisPtr);
+		private static extern void Internal_setAnimation(IntPtr thisPtr, ref SpriteSheetGridAnimation anim);
 		[MethodImpl(MethodImplOptions.InternalCall)]
-		private static extern uint Internal_getHeight(IntPtr thisPtr);
+		private static extern void Internal_getAnimation(IntPtr thisPtr, out SpriteSheetGridAnimation __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setAnimationPlayback(IntPtr thisPtr, SpriteAnimationPlayback playback);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern SpriteAnimationPlayback Internal_getAnimationPlayback(IntPtr thisPtr);
 		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern void Internal_create(SpriteTexture managedInstance, Texture texture);
 		[MethodImpl(MethodImplOptions.InternalCall)]

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

@@ -157,4 +157,54 @@ namespace BansheeEngine
 	}
 
 	/** @} */
+
+	/** @addtogroup Animation
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Animation spline represented by a set of keyframes, each representing an endpoint of a cubic hermite curve. The spline 
+	/// can be evaluated at any time, and uses caching to speed up multiple sequential evaluations.
+	/// </summary>
+	public partial class IntegerCurve : ScriptObject
+	{
+		private IntegerCurve(bool __dummy0) { }
+		protected IntegerCurve() { }
+
+		/// <summary>Creates a new animation curve.</summary>
+		/// <param name="keyframes">Keyframes to initialize the curve with. They must be sorted by time.</param>
+		public IntegerCurve(KeyFrameInt[] keyframes)
+		{
+			Internal_TAnimationCurve(this, keyframes);
+		}
+
+		/// <summary>Returns a list of all keyframes in the curve.</summary>
+		public KeyFrameInt[] KeyFrames
+		{
+			get { return Internal_getKeyFrames(mCachedPtr); }
+		}
+
+		/// <summary>
+		/// Evaluate the animation curve at the specified time. If evaluating multiple values in a sequential order consider 
+		/// using the cached version of evaluate() for better performance.
+		/// </summary>
+		/// <param name="time">%Time to evaluate the curve at.</param>
+		/// <param name="loop">
+		/// If true the curve will loop when it goes past the end or beggining. Otherwise the curve  value will be clamped.
+		/// </param>
+		/// <returns>Interpolated value from the curve at provided time.</returns>
+		public int Evaluate(float time, bool loop = true)
+		{
+			return Internal_evaluate(mCachedPtr, time, loop);
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_TAnimationCurve(IntegerCurve managedInstance, KeyFrameInt[] keyframes);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int Internal_evaluate(IntPtr thisPtr, float time, bool loop);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern KeyFrameInt[] Internal_getKeyFrames(IntPtr thisPtr);
+	}
+
+	/** @} */
 }

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

@@ -4,6 +4,22 @@ using System.Runtime.InteropServices;
 
 namespace BansheeEngine
 {
+	/** @addtogroup Animation
+	 *  @{
+	 */
+
+	/// <summary>Animation keyframe, represented as an endpoint of a cubic hermite spline.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct KeyFrameInt
+	{
+		/// <summary>Value of the key.</summary>
+		public int value;
+		/// <summary>Position of the key along the animation spline.</summary>
+		public float time;
+	}
+
+	/** @} */
+
 	/** @addtogroup Animation
 	 *  @{
 	 */

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

@@ -153,4 +153,54 @@ namespace BansheeEngine
 	}
 
 	/** @} */
+
+	/** @addtogroup Animation
+	 *  @{
+	 */
+
+	/// <summary>An animation curve and its name.</summary>
+	[StructLayout(LayoutKind.Sequential), SerializeObject]
+	public partial struct NamedIntegerCurve
+	{
+		/// <summary>Initializes the struct with default values.</summary>
+		public static NamedIntegerCurve Default()
+		{
+			NamedIntegerCurve value = new NamedIntegerCurve();
+			value.name = "";
+			value.flags = (AnimationCurveFlags)0;
+			value.curve = null;
+
+			return value;
+		}
+
+		/// <summary>Constructs a new named animation curve.</summary>
+		/// <param name="name">Name of the curve.</param>
+		/// <param name="curve">Curve containing the animation data.</param>
+		public NamedIntegerCurve(string name, IntegerCurve curve)
+		{
+			this.name = name;
+			this.flags = (AnimationCurveFlags)0;
+			this.curve = curve;
+		}
+
+		/// <summary>Constructs a new named animation curve.</summary>
+		/// <param name="name">Name of the curve.</param>
+		/// <param name="flags">Flags that describe the animation curve.</param>
+		/// <param name="curve">Curve containing the animation data.</param>
+		public NamedIntegerCurve(string name, AnimationCurveFlags flags, IntegerCurve curve)
+		{
+			this.name = name;
+			this.flags = (AnimationCurveFlags)0;
+			this.curve = curve;
+		}
+
+		/// <summary>Name of the curve.</summary>
+		public string name;
+		/// <summary>Flags that describe the animation curve.</summary>
+		public AnimationCurveFlags flags;
+		/// <summary>Actual curve containing animation data.</summary>
+		public IntegerCurve curve;
+	}
+
+	/** @} */
 }

Source/Scripting/SBansheeEditor/BsGUITextureField.cpp

@@ -13,7 +13,7 @@
 #include "GUI/BsGUIResourceTreeView.h"
 #include "GUI/BsGUISpace.h"
 #include "Library/BsProjectResourceMeta.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "Scene/BsSelection.h"
 
 using namespace std::placeholders;

Source/Scripting/SBansheeEditor/Wrappers/GUI/BsScriptGUIResourceField.cpp

@@ -5,7 +5,7 @@
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
 #include "BsMonoMethod.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "BsMonoUtil.h"
 #include "BsGUIResourceField.h"
 #include "GUI/BsGUIOptions.h"

Source/Scripting/SBansheeEditor/Wrappers/GUI/BsScriptGUIVector2Field.cpp

@@ -5,7 +5,7 @@
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
 #include "BsMonoMethod.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "BsMonoUtil.h"
 #include "GUI/BsGUIVector2Field.h"
 #include "GUI/BsGUIOptions.h"

Source/Scripting/SBansheeEditor/Wrappers/GUI/BsScriptGUIVector3Field.cpp

@@ -5,7 +5,7 @@
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
 #include "BsMonoMethod.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "BsMonoUtil.h"
 #include "GUI/BsGUIVector3Field.h"
 #include "GUI/BsGUIOptions.h"

Source/Scripting/SBansheeEngine/CMakeSources.cmake

@@ -222,6 +222,7 @@ set(BS_SBANSHEEENGINE_INC_EXTENSIONS
 	"Extensions/BsShaderEx.h"
 	"Extensions/BsMaterialEx.h"
 	"Extensions/BsRenderTargetEx.h"
+	"Extensions/BsColorGradientEx.h"
 )
 
 set(BS_SBANSHEEENGINE_SRC_EXTENSIONS
@@ -236,6 +237,7 @@ set(BS_SBANSHEEENGINE_SRC_EXTENSIONS
 	"Extensions/BsShaderEx.cpp"
 	"Extensions/BsMaterialEx.cpp"
 	"Extensions/BsRenderTargetEx.cpp"
+	"Extensions/BsColorGradientEx.cpp"
 )
 
 source_group("Header Files" FILES ${BS_SBANSHEEENGINE_INC_NOFILTER})

Source/Scripting/SBansheeEngine/Extensions/BsAsyncOpEx.h

@@ -1,4 +1,4 @@
-//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//********************************** Banshee Engine (www.banshee4d.com) **************************************************//
 //**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
 #pragma once
 

Source/Scripting/SBansheeEngine/Extensions/BsColorGradientEx.cpp

@@ -0,0 +1,14 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsColorGradientEx.h"
+
+namespace bs
+{
+	Color ColorGradientEx::evaluate(const SPtr<ColorGradient>& thisPtr, float t)
+	{
+		Color output;
+		output.setAsRGBA(thisPtr->evaluate(t));
+
+		return output;
+	}
+}

Source/Scripting/SBansheeEngine/Extensions/BsColorGradientEx.h

@@ -0,0 +1,27 @@
+//********************************** Banshee Engine (www.banshee4d.com) **************************************************//
+//**************** Copyright (c) 2018 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptObject.h"
+#include "Image/BsColorGradient.h"
+
+namespace bs
+{
+	/** @addtogroup ScriptInteropEngine
+	*  @{
+	*/
+	/** @cond SCRIPT_EXTENSIONS */
+
+	/** Extension class for ColorGradient, for adding additional functionality for the script interface. */
+	class BS_SCRIPT_EXPORT(e:ColorGradient) ColorGradientEx
+	{
+	public:
+		/** @copydoc ColorGradient::evaluate */
+		BS_SCRIPT_EXPORT(e:ColorGradient)
+		static Color evaluate(const SPtr<ColorGradient>& thisPtr, float t);
+	}; 
+
+	/** @endcond */
+	/** @} */
+}

Source/Scripting/SBansheeEngine/Extensions/BsMaterialEx.cpp

@@ -15,4 +15,14 @@ namespace bs
 	{
 		return thisPtr->getTexture(name);
 	}
+
+	void MaterialEx::setSpriteTexture(const HMaterial& thisPtr, const String& name, const HSpriteTexture& value)
+	{
+		thisPtr->setSpriteTexture(name, value);
+	}
+
+	HSpriteTexture MaterialEx::getSpriteTexture(const HMaterial& thisPtr, const String& name)
+	{
+		return thisPtr->getSpriteTexture(name);
+	}
 }

Source/Scripting/SBansheeEngine/Extensions/BsMaterialEx.h

@@ -23,6 +23,12 @@ namespace bs
 
 		BS_SCRIPT_EXPORT(e:Material,in:true)
 		static HTexture getTexture(const HMaterial& thisPtr, const String& name);
+
+		BS_SCRIPT_EXPORT(e:Material,in:true)
+		static void setSpriteTexture(const HMaterial& thisPtr, const String& name, const HSpriteTexture& value);
+
+		BS_SCRIPT_EXPORT(e:Material,in:true)
+		static HSpriteTexture getSpriteTexture(const HMaterial& thisPtr, const String& name);
 	};
 
 	/** @endcond */

Source/Scripting/SBansheeEngine/Extensions/BsPixelDataEx.h

@@ -67,7 +67,7 @@ namespace bs
 		 * Returns all pixels in the buffer as raw bytes.
 		 *
 		 * @return	Raw pixel bytes. It is up to the caller to interpret the pixel format and account for potential 
-         *			row and slice pitch values.
+		 *			row and slice pitch values.
 		 */
 		BS_SCRIPT_EXPORT(e:PixelData,n:GetRawPixels)
 		static Vector<char> getRawPixels(const SPtr<PixelData>& thisPtr);

Source/Scripting/SBansheeEngine/Extensions/BsRenderTargetEx.h

@@ -12,7 +12,7 @@ namespace bs
 	 */
 	/** @cond SCRIPT_EXTENSIONS */
 
-	 /** Extension class for RenderTarget, for adding additional functionality for the script interface. */
+	/** Extension class for RenderTarget, for adding additional functionality for the script interface. */
 	class BS_SCRIPT_EXPORT(e:RenderTarget) RenderTargetEx
 	{
 	public:

Source/Scripting/SBansheeEngine/Generated/BsBuiltinComponentLookup.generated.h

@@ -2,12 +2,12 @@
 
 #include "Serialization/BsBuiltinComponentLookup.h"
 #include "Reflection/BsRTTIType.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Components/BsCD6Joint.h"
+#include "BsScriptCD6Joint.generated.h"
 #include "../../../bsf/Source/Foundation/bsfCore/Components/BsCCamera.h"
 #include "BsScriptCCamera.generated.h"
 #include "../../../bsf/Source/Foundation/bsfCore/Components/BsCJoint.h"
 #include "BsScriptCJoint.generated.h"
-#include "../../../bsf/Source/Foundation/bsfCore/Components/BsCD6Joint.h"
-#include "BsScriptCD6Joint.generated.h"
 #include "../../../bsf/Source/Foundation/bsfCore/Components/BsCBoxCollider.h"
 #include "BsScriptCBoxCollider.generated.h"
 #include "../../../bsf/Source/Foundation/bsfCore/Components/BsCAudioListener.h"
@@ -56,9 +56,9 @@
 namespace bs
 {
 	LOOKUP_BEGIN
+		ADD_ENTRY(CD6Joint, ScriptCD6Joint)
 		ADD_ENTRY(CCamera, ScriptCCamera)
 		ADD_ENTRY(CJoint, ScriptCJoint)
-		ADD_ENTRY(CD6Joint, ScriptCD6Joint)
 		ADD_ENTRY(CBoxCollider, ScriptCBoxCollider)
 		ADD_ENTRY(CAudioListener, ScriptCAudioListener)
 		ADD_ENTRY(CReflectionProbe, ScriptCReflectionProbe)

Source/Scripting/SBansheeEngine/Generated/BsScriptAnimationCurves.generated.h

@@ -5,6 +5,9 @@
 #include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
 #include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
 #include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
 
 namespace bs
 {

Source/Scripting/SBansheeEngine/Generated/BsScriptColorGradient.generated.cpp

@@ -0,0 +1,94 @@
+#include "BsScriptColorGradient.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../../bsf/Source/Foundation/bsfUtility/Image/BsColorGradient.h"
+#include "Wrappers/BsScriptColor.h"
+#include "BsScriptColorGradientKey.generated.h"
+#include "../../SBansheeEngine/Extensions/BsColorGradientEx.h"
+
+namespace bs
+{
+	ScriptColorGradient::ScriptColorGradient(MonoObject* managedInstance, const SPtr<ColorGradient>& value)
+		:ScriptObject(managedInstance), mInternal(value)
+	{
+	}
+
+	void ScriptColorGradient::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_ColorGradient", (void*)&ScriptColorGradient::Internal_ColorGradient);
+		metaData.scriptClass->addInternalCall("Internal_ColorGradient0", (void*)&ScriptColorGradient::Internal_ColorGradient0);
+		metaData.scriptClass->addInternalCall("Internal_ColorGradient1", (void*)&ScriptColorGradient::Internal_ColorGradient1);
+		metaData.scriptClass->addInternalCall("Internal_setKeys", (void*)&ScriptColorGradient::Internal_setKeys);
+		metaData.scriptClass->addInternalCall("Internal_setConstant", (void*)&ScriptColorGradient::Internal_setConstant);
+		metaData.scriptClass->addInternalCall("Internal_evaluate", (void*)&ScriptColorGradient::Internal_evaluate);
+
+	}
+
+	MonoObject* ScriptColorGradient::create(const SPtr<ColorGradient>& value)
+	{
+		if(value == nullptr) return nullptr; 
+
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance("bool", ctorParams);
+		new (bs_alloc<ScriptColorGradient>()) ScriptColorGradient(managedInstance, value);
+		return managedInstance;
+	}
+	void ScriptColorGradient::Internal_ColorGradient(MonoObject* managedInstance)
+	{
+		SPtr<ColorGradient> instance = bs_shared_ptr_new<ColorGradient>();
+		new (bs_alloc<ScriptColorGradient>())ScriptColorGradient(managedInstance, instance);
+	}
+
+	void ScriptColorGradient::Internal_ColorGradient0(MonoObject* managedInstance, Color* color)
+	{
+		SPtr<ColorGradient> instance = bs_shared_ptr_new<ColorGradient>(*color);
+		new (bs_alloc<ScriptColorGradient>())ScriptColorGradient(managedInstance, instance);
+	}
+
+	void ScriptColorGradient::Internal_ColorGradient1(MonoObject* managedInstance, MonoArray* keys)
+	{
+		Vector<ColorGradientKey> veckeys;
+		if(keys != nullptr)
+		{
+			ScriptArray arraykeys(keys);
+			veckeys.resize(arraykeys.size());
+			for(int i = 0; i < (int)arraykeys.size(); i++)
+			{
+				veckeys[i] = ScriptColorGradientKey::fromInterop(arraykeys.get<__ColorGradientKeyInterop>(i));
+			}
+		}
+		SPtr<ColorGradient> instance = bs_shared_ptr_new<ColorGradient>(veckeys);
+		new (bs_alloc<ScriptColorGradient>())ScriptColorGradient(managedInstance, instance);
+	}
+
+	void ScriptColorGradient::Internal_setKeys(ScriptColorGradient* thisPtr, MonoArray* keys)
+	{
+		Vector<ColorGradientKey> veckeys;
+		if(keys != nullptr)
+		{
+			ScriptArray arraykeys(keys);
+			veckeys.resize(arraykeys.size());
+			for(int i = 0; i < (int)arraykeys.size(); i++)
+			{
+				veckeys[i] = ScriptColorGradientKey::fromInterop(arraykeys.get<__ColorGradientKeyInterop>(i));
+			}
+		}
+		thisPtr->getInternal()->setKeys(veckeys);
+	}
+
+	void ScriptColorGradient::Internal_setConstant(ScriptColorGradient* thisPtr, Color* color)
+	{
+		thisPtr->getInternal()->setConstant(*color);
+	}
+
+	void ScriptColorGradient::Internal_evaluate(ScriptColorGradient* thisPtr, float t, Color* __output)
+	{
+		Color tmp__output;
+		tmp__output = ColorGradientEx::evaluate(thisPtr->getInternal(), t);
+
+		*__output = tmp__output;
+	}
+}

Source/Scripting/SBansheeEngine/Generated/BsScriptColorGradient.generated.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptObject.h"
+
+namespace bs
+{
+	class ColorGradient;
+	class ColorGradientEx;
+	struct __ColorGradientKeyInterop;
+
+	class BS_SCR_BE_EXPORT ScriptColorGradient : public ScriptObject<ScriptColorGradient>
+	{
+	public:
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "ColorGradient")
+
+		ScriptColorGradient(MonoObject* managedInstance, const SPtr<ColorGradient>& value);
+
+		SPtr<ColorGradient> getInternal() const { return mInternal; }
+		static MonoObject* create(const SPtr<ColorGradient>& value);
+
+	private:
+		SPtr<ColorGradient> mInternal;
+
+		static void Internal_ColorGradient(MonoObject* managedInstance);
+		static void Internal_ColorGradient0(MonoObject* managedInstance, Color* color);
+		static void Internal_ColorGradient1(MonoObject* managedInstance, MonoArray* keys);
+		static void Internal_setKeys(ScriptColorGradient* thisPtr, MonoArray* keys);
+		static void Internal_setConstant(ScriptColorGradient* thisPtr, Color* color);
+		static void Internal_evaluate(ScriptColorGradient* thisPtr, float t, Color* __output);
+	};
+}

Source/Scripting/SBansheeEngine/Generated/BsScriptColorGradientKey.generated.cpp

@@ -0,0 +1,45 @@
+#include "BsScriptColorGradientKey.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "Wrappers/BsScriptColor.h"
+#include "Wrappers/BsScriptColor.h"
+
+namespace bs
+{
+	ScriptColorGradientKey::ScriptColorGradientKey(MonoObject* managedInstance)
+		:ScriptObject(managedInstance)
+	{ }
+
+	void ScriptColorGradientKey::initRuntimeData()
+	{ }
+
+	MonoObject*ScriptColorGradientKey::box(const __ColorGradientKeyInterop& value)
+	{
+		return MonoUtil::box(metaData.scriptClass->_getInternalClass(), (void*)&value);
+	}
+
+	__ColorGradientKeyInterop ScriptColorGradientKey::unbox(MonoObject* value)
+	{
+		return *(__ColorGradientKeyInterop*)MonoUtil::unbox(value);
+	}
+
+	ColorGradientKey ScriptColorGradientKey::fromInterop(const __ColorGradientKeyInterop& value)
+	{
+		ColorGradientKey output;
+		output.color = value.color;
+		output.time = value.time;
+
+		return output;
+	}
+
+	__ColorGradientKeyInterop ScriptColorGradientKey::toInterop(const ColorGradientKey& value)
+	{
+		__ColorGradientKeyInterop output;
+		output.color = value.color;
+		output.time = value.time;
+
+		return output;
+	}
+
+}

Source/Scripting/SBansheeEngine/Generated/BsScriptColorGradientKey.generated.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptObject.h"
+#include "../../../bsf/Source/Foundation/bsfUtility/Image/BsColorGradient.h"
+#include "Image/BsColor.h"
+
+namespace bs
+{
+	struct __ColorGradientKeyInterop
+	{
+		Color color;
+		float time;
+	};
+
+	class BS_SCR_BE_EXPORT ScriptColorGradientKey : public ScriptObject<ScriptColorGradientKey>
+	{
+	public:
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "ColorGradientKey")
+
+		static MonoObject* box(const __ColorGradientKeyInterop& value);
+		static __ColorGradientKeyInterop unbox(MonoObject* value);
+		static ColorGradientKey fromInterop(const __ColorGradientKeyInterop& value);
+		static __ColorGradientKeyInterop toInterop(const ColorGradientKey& value);
+
+	private:
+		ScriptColorGradientKey(MonoObject* managedInstance);
+
+	};
+}

Source/Scripting/SBansheeEngine/Generated/BsScriptMaterial.generated.cpp

@@ -4,14 +4,17 @@
 #include "BsMonoUtil.h"
 #include "../../../bsf/Source/Foundation/bsfCore/Material/BsMaterial.h"
 #include "BsScriptResourceManager.h"
-#include "BsScriptShader.generated.h"
 #include "Wrappers/BsScriptVector.h"
+#include "BsScriptColorGradient.generated.h"
 #include "Wrappers/BsScriptColor.h"
 #include "BsScriptMaterial.generated.h"
+#include "BsScriptShader.generated.h"
 #include "Wrappers/BsScriptVector.h"
+#include "BsScriptTAnimationCurve.generated.h"
 #include "Wrappers/BsScriptVector.h"
 #include "BsScriptTexture.generated.h"
 #include "../../SBansheeEngine/Extensions/BsMaterialEx.h"
+#include "BsScriptSpriteTexture.generated.h"
 
 namespace bs
 {
@@ -26,14 +29,18 @@ namespace bs
 		metaData.scriptClass->addInternalCall("Internal_clone", (void*)&ScriptMaterial::Internal_clone);
 		metaData.scriptClass->addInternalCall("Internal_getShader", (void*)&ScriptMaterial::Internal_getShader);
 		metaData.scriptClass->addInternalCall("Internal_setFloat", (void*)&ScriptMaterial::Internal_setFloat);
+		metaData.scriptClass->addInternalCall("Internal_setFloatCurve", (void*)&ScriptMaterial::Internal_setFloatCurve);
 		metaData.scriptClass->addInternalCall("Internal_setColor", (void*)&ScriptMaterial::Internal_setColor);
+		metaData.scriptClass->addInternalCall("Internal_setColorGradient", (void*)&ScriptMaterial::Internal_setColorGradient);
 		metaData.scriptClass->addInternalCall("Internal_setVec2", (void*)&ScriptMaterial::Internal_setVec2);
 		metaData.scriptClass->addInternalCall("Internal_setVec3", (void*)&ScriptMaterial::Internal_setVec3);
 		metaData.scriptClass->addInternalCall("Internal_setVec4", (void*)&ScriptMaterial::Internal_setVec4);
 		metaData.scriptClass->addInternalCall("Internal_setMat3", (void*)&ScriptMaterial::Internal_setMat3);
 		metaData.scriptClass->addInternalCall("Internal_setMat4", (void*)&ScriptMaterial::Internal_setMat4);
 		metaData.scriptClass->addInternalCall("Internal_getFloat", (void*)&ScriptMaterial::Internal_getFloat);
+		metaData.scriptClass->addInternalCall("Internal_getFloatCurve", (void*)&ScriptMaterial::Internal_getFloatCurve);
 		metaData.scriptClass->addInternalCall("Internal_getColor", (void*)&ScriptMaterial::Internal_getColor);
+		metaData.scriptClass->addInternalCall("Internal_getColorGradient", (void*)&ScriptMaterial::Internal_getColorGradient);
 		metaData.scriptClass->addInternalCall("Internal_getVec2", (void*)&ScriptMaterial::Internal_getVec2);
 		metaData.scriptClass->addInternalCall("Internal_getVec3", (void*)&ScriptMaterial::Internal_getVec3);
 		metaData.scriptClass->addInternalCall("Internal_getVec4", (void*)&ScriptMaterial::Internal_getVec4);
@@ -43,6 +50,8 @@ namespace bs
 		metaData.scriptClass->addInternalCall("Internal_create0", (void*)&ScriptMaterial::Internal_create0);
 		metaData.scriptClass->addInternalCall("Internal_setTexture", (void*)&ScriptMaterial::Internal_setTexture);
 		metaData.scriptClass->addInternalCall("Internal_getTexture", (void*)&ScriptMaterial::Internal_getTexture);
+		metaData.scriptClass->addInternalCall("Internal_setSpriteTexture", (void*)&ScriptMaterial::Internal_setSpriteTexture);
+		metaData.scriptClass->addInternalCall("Internal_getSpriteTexture", (void*)&ScriptMaterial::Internal_getSpriteTexture);
 
 	}
 
@@ -102,6 +111,17 @@ namespace bs
 		thisPtr->getHandle()->setFloat(tmpname, value, arrayIdx);
 	}
 
+	void ScriptMaterial::Internal_setFloatCurve(ScriptMaterial* thisPtr, MonoString* name, MonoObject* value, uint32_t arrayIdx)
+	{
+		String tmpname;
+		tmpname = MonoUtil::monoToString(name);
+		SPtr<TAnimationCurve<float>> tmpvalue;
+		ScriptTAnimationCurvefloat* scriptvalue;
+		scriptvalue = ScriptTAnimationCurvefloat::toNative(value);
+		tmpvalue = scriptvalue->getInternal();
+		thisPtr->getHandle()->setFloatCurve(tmpname, *tmpvalue, arrayIdx);
+	}
+
 	void ScriptMaterial::Internal_setColor(ScriptMaterial* thisPtr, MonoString* name, Color* value, uint32_t arrayIdx)
 	{
 		String tmpname;
@@ -109,6 +129,17 @@ namespace bs
 		thisPtr->getHandle()->setColor(tmpname, *value, arrayIdx);
 	}
 
+	void ScriptMaterial::Internal_setColorGradient(ScriptMaterial* thisPtr, MonoString* name, MonoObject* value, uint32_t arrayIdx)
+	{
+		String tmpname;
+		tmpname = MonoUtil::monoToString(name);
+		SPtr<ColorGradient> tmpvalue;
+		ScriptColorGradient* scriptvalue;
+		scriptvalue = ScriptColorGradient::toNative(value);
+		tmpvalue = scriptvalue->getInternal();
+		thisPtr->getHandle()->setColorGradient(tmpname, *tmpvalue, arrayIdx);
+	}
+
 	void ScriptMaterial::Internal_setVec2(ScriptMaterial* thisPtr, MonoString* name, Vector2* value, uint32_t arrayIdx)
 	{
 		String tmpname;
@@ -157,6 +188,19 @@ namespace bs
 		return __output;
 	}
 
+	MonoObject* ScriptMaterial::Internal_getFloatCurve(ScriptMaterial* thisPtr, MonoString* name, uint32_t arrayIdx)
+	{
+		SPtr<TAnimationCurve<float>> tmp__output = bs_shared_ptr_new<TAnimationCurve<float>>();
+		String tmpname;
+		tmpname = MonoUtil::monoToString(name);
+		*tmp__output = thisPtr->getHandle()->getFloatCurve(tmpname, arrayIdx);
+
+		MonoObject* __output;
+		__output = ScriptTAnimationCurvefloat::create(tmp__output);
+
+		return __output;
+	}
+
 	void ScriptMaterial::Internal_getColor(ScriptMaterial* thisPtr, MonoString* name, uint32_t arrayIdx, Color* __output)
 	{
 		String tmpname;
@@ -167,6 +211,19 @@ namespace bs
 		*__output = tmp__output;
 	}
 
+	MonoObject* ScriptMaterial::Internal_getColorGradient(ScriptMaterial* thisPtr, MonoString* name, uint32_t arrayIdx)
+	{
+		SPtr<ColorGradient> tmp__output = bs_shared_ptr_new<ColorGradient>();
+		String tmpname;
+		tmpname = MonoUtil::monoToString(name);
+		*tmp__output = thisPtr->getHandle()->getColorGradient(tmpname, arrayIdx);
+
+		MonoObject* __output;
+		__output = ScriptColorGradient::create(tmp__output);
+
+		return __output;
+	}
+
 	void ScriptMaterial::Internal_getVec2(ScriptMaterial* thisPtr, MonoString* name, uint32_t arrayIdx, Vector2* __output)
 	{
 		String tmpname;
@@ -263,4 +320,34 @@ namespace bs
 
 		return __output;
 	}
+
+	void ScriptMaterial::Internal_setSpriteTexture(ScriptMaterial* thisPtr, MonoString* name, MonoObject* value)
+	{
+		String tmpname;
+		tmpname = MonoUtil::monoToString(name);
+		ResourceHandle<SpriteTexture> tmpvalue;
+		ScriptSpriteTexture* scriptvalue;
+		scriptvalue = ScriptSpriteTexture::toNative(value);
+		if(scriptvalue != nullptr)
+			tmpvalue = scriptvalue->getHandle();
+		MaterialEx::setSpriteTexture(thisPtr->getHandle(), tmpname, tmpvalue);
+	}
+
+	MonoObject* ScriptMaterial::Internal_getSpriteTexture(ScriptMaterial* thisPtr, MonoString* name)
+	{
+		ResourceHandle<SpriteTexture> tmp__output;
+		String tmpname;
+		tmpname = MonoUtil::monoToString(name);
+		tmp__output = MaterialEx::getSpriteTexture(thisPtr->getHandle(), tmpname);
+
+		MonoObject* __output;
+		ScriptResourceBase* script__output;
+		script__output = ScriptResourceManager::instance().getScriptResource(tmp__output, true);
+		if(script__output != nullptr)
+			__output = script__output->getManagedInstance();
+		else
+			__output = nullptr;
+
+		return __output;
+	}
 }

Source/Scripting/SBansheeEngine/Generated/BsScriptMaterial.generated.h

@@ -2,6 +2,8 @@
 
 #include "BsScriptEnginePrerequisites.h"
 #include "Wrappers/BsScriptResource.h"
+#include "../../../bsf/Source/Foundation/bsfUtility/Image/BsColorGradient.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
 
 namespace bs
 {
@@ -22,14 +24,18 @@ namespace bs
 		static MonoObject* Internal_clone(ScriptMaterial* thisPtr);
 		static MonoObject* Internal_getShader(ScriptMaterial* thisPtr);
 		static void Internal_setFloat(ScriptMaterial* thisPtr, MonoString* name, float value, uint32_t arrayIdx);
+		static void Internal_setFloatCurve(ScriptMaterial* thisPtr, MonoString* name, MonoObject* value, uint32_t arrayIdx);
 		static void Internal_setColor(ScriptMaterial* thisPtr, MonoString* name, Color* value, uint32_t arrayIdx);
+		static void Internal_setColorGradient(ScriptMaterial* thisPtr, MonoString* name, MonoObject* value, uint32_t arrayIdx);
 		static void Internal_setVec2(ScriptMaterial* thisPtr, MonoString* name, Vector2* value, uint32_t arrayIdx);
 		static void Internal_setVec3(ScriptMaterial* thisPtr, MonoString* name, Vector3* value, uint32_t arrayIdx);
 		static void Internal_setVec4(ScriptMaterial* thisPtr, MonoString* name, Vector4* value, uint32_t arrayIdx);
 		static void Internal_setMat3(ScriptMaterial* thisPtr, MonoString* name, Matrix3* value, uint32_t arrayIdx);
 		static void Internal_setMat4(ScriptMaterial* thisPtr, MonoString* name, Matrix4* value, uint32_t arrayIdx);
 		static float Internal_getFloat(ScriptMaterial* thisPtr, MonoString* name, uint32_t arrayIdx);
+		static MonoObject* Internal_getFloatCurve(ScriptMaterial* thisPtr, MonoString* name, uint32_t arrayIdx);
 		static void Internal_getColor(ScriptMaterial* thisPtr, MonoString* name, uint32_t arrayIdx, Color* __output);
+		static MonoObject* Internal_getColorGradient(ScriptMaterial* thisPtr, MonoString* name, uint32_t arrayIdx);
 		static void Internal_getVec2(ScriptMaterial* thisPtr, MonoString* name, uint32_t arrayIdx, Vector2* __output);
 		static void Internal_getVec3(ScriptMaterial* thisPtr, MonoString* name, uint32_t arrayIdx, Vector3* __output);
 		static void Internal_getVec4(ScriptMaterial* thisPtr, MonoString* name, uint32_t arrayIdx, Vector4* __output);
@@ -39,5 +45,7 @@ namespace bs
 		static void Internal_create0(MonoObject* managedInstance, MonoObject* shader);
 		static void Internal_setTexture(ScriptMaterial* thisPtr, MonoString* name, MonoObject* value, uint32_t mipLevel, uint32_t numMipLevels, uint32_t arraySlice, uint32_t numArraySlices);
 		static MonoObject* Internal_getTexture(ScriptMaterial* thisPtr, MonoString* name);
+		static void Internal_setSpriteTexture(ScriptMaterial* thisPtr, MonoString* name, MonoObject* value);
+		static MonoObject* Internal_getSpriteTexture(ScriptMaterial* thisPtr, MonoString* name);
 	};
 }

Source/Scripting/SBansheeEngine/Generated/BsScriptSpriteSheetGridAnimation.generated.cpp

@@ -0,0 +1,25 @@
+#include "BsScriptSpriteSheetGridAnimation.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+
+namespace bs
+{
+	ScriptSpriteSheetGridAnimation::ScriptSpriteSheetGridAnimation(MonoObject* managedInstance)
+		:ScriptObject(managedInstance)
+	{ }
+
+	void ScriptSpriteSheetGridAnimation::initRuntimeData()
+	{ }
+
+	MonoObject*ScriptSpriteSheetGridAnimation::box(const SpriteSheetGridAnimation& value)
+	{
+		return MonoUtil::box(metaData.scriptClass->_getInternalClass(), (void*)&value);
+	}
+
+	SpriteSheetGridAnimation ScriptSpriteSheetGridAnimation::unbox(MonoObject* value)
+	{
+		return *(SpriteSheetGridAnimation*)MonoUtil::unbox(value);
+	}
+
+}

Source/Scripting/SBansheeEngine/Generated/BsScriptSpriteSheetGridAnimation.generated.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptObject.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Image/BsSpriteTexture.h"
+
+namespace bs
+{
+	class BS_SCR_BE_EXPORT ScriptSpriteSheetGridAnimation : public ScriptObject<ScriptSpriteSheetGridAnimation>
+	{
+	public:
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "SpriteSheetGridAnimation")
+
+		static MonoObject* box(const SpriteSheetGridAnimation& value);
+		static SpriteSheetGridAnimation unbox(MonoObject* value);
+
+	private:
+		ScriptSpriteSheetGridAnimation(MonoObject* managedInstance);
+
+	};
+}

Source/Scripting/SBansheeEngine/Generated/BsScriptSpriteTexture.generated.cpp

@@ -2,10 +2,11 @@
 #include "BsMonoMethod.h"
 #include "BsMonoClass.h"
 #include "BsMonoUtil.h"
-#include "../../../bsf/Source/Foundation/bsfEngine/2D/BsSpriteTexture.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Image/BsSpriteTexture.h"
 #include "BsScriptResourceManager.h"
 #include "BsScriptTexture.generated.h"
 #include "Wrappers/BsScriptVector.h"
+#include "BsScriptSpriteSheetGridAnimation.generated.h"
 #include "BsScriptSpriteTexture.generated.h"
 
 namespace bs
@@ -19,12 +20,16 @@ namespace bs
 	{
 		metaData.scriptClass->addInternalCall("Internal_setTexture", (void*)&ScriptSpriteTexture::Internal_setTexture);
 		metaData.scriptClass->addInternalCall("Internal_getTexture", (void*)&ScriptSpriteTexture::Internal_getTexture);
+		metaData.scriptClass->addInternalCall("Internal_getWidth", (void*)&ScriptSpriteTexture::Internal_getWidth);
+		metaData.scriptClass->addInternalCall("Internal_getHeight", (void*)&ScriptSpriteTexture::Internal_getHeight);
 		metaData.scriptClass->addInternalCall("Internal_setOffset", (void*)&ScriptSpriteTexture::Internal_setOffset);
 		metaData.scriptClass->addInternalCall("Internal_getOffset", (void*)&ScriptSpriteTexture::Internal_getOffset);
 		metaData.scriptClass->addInternalCall("Internal_setScale", (void*)&ScriptSpriteTexture::Internal_setScale);
 		metaData.scriptClass->addInternalCall("Internal_getScale", (void*)&ScriptSpriteTexture::Internal_getScale);
-		metaData.scriptClass->addInternalCall("Internal_getWidth", (void*)&ScriptSpriteTexture::Internal_getWidth);
-		metaData.scriptClass->addInternalCall("Internal_getHeight", (void*)&ScriptSpriteTexture::Internal_getHeight);
+		metaData.scriptClass->addInternalCall("Internal_setAnimation", (void*)&ScriptSpriteTexture::Internal_setAnimation);
+		metaData.scriptClass->addInternalCall("Internal_getAnimation", (void*)&ScriptSpriteTexture::Internal_getAnimation);
+		metaData.scriptClass->addInternalCall("Internal_setAnimationPlayback", (void*)&ScriptSpriteTexture::Internal_setAnimationPlayback);
+		metaData.scriptClass->addInternalCall("Internal_getAnimationPlayback", (void*)&ScriptSpriteTexture::Internal_getAnimationPlayback);
 		metaData.scriptClass->addInternalCall("Internal_create", (void*)&ScriptSpriteTexture::Internal_create);
 		metaData.scriptClass->addInternalCall("Internal_create0", (void*)&ScriptSpriteTexture::Internal_create0);
 
@@ -63,6 +68,28 @@ namespace bs
 		return __output;
 	}
 
+	uint32_t ScriptSpriteTexture::Internal_getWidth(ScriptSpriteTexture* thisPtr)
+	{
+		uint32_t tmp__output;
+		tmp__output = thisPtr->getHandle()->getWidth();
+
+		uint32_t __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	uint32_t ScriptSpriteTexture::Internal_getHeight(ScriptSpriteTexture* thisPtr)
+	{
+		uint32_t tmp__output;
+		tmp__output = thisPtr->getHandle()->getHeight();
+
+		uint32_t __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
 	void ScriptSpriteTexture::Internal_setOffset(ScriptSpriteTexture* thisPtr, Vector2* offset)
 	{
 		thisPtr->getHandle()->setOffset(*offset);
@@ -89,23 +116,30 @@ namespace bs
 		*__output = tmp__output;
 	}
 
-	uint32_t ScriptSpriteTexture::Internal_getWidth(ScriptSpriteTexture* thisPtr)
+	void ScriptSpriteTexture::Internal_setAnimation(ScriptSpriteTexture* thisPtr, SpriteSheetGridAnimation* anim)
 	{
-		uint32_t tmp__output;
-		tmp__output = thisPtr->getHandle()->getWidth();
+		thisPtr->getHandle()->setAnimation(*anim);
+	}
 
-		uint32_t __output;
-		__output = tmp__output;
+	void ScriptSpriteTexture::Internal_getAnimation(ScriptSpriteTexture* thisPtr, SpriteSheetGridAnimation* __output)
+	{
+		SpriteSheetGridAnimation tmp__output;
+		tmp__output = thisPtr->getHandle()->getAnimation();
 
-		return __output;
+		*__output = tmp__output;
 	}
 
-	uint32_t ScriptSpriteTexture::Internal_getHeight(ScriptSpriteTexture* thisPtr)
+	void ScriptSpriteTexture::Internal_setAnimationPlayback(ScriptSpriteTexture* thisPtr, SpriteAnimationPlayback playback)
 	{
-		uint32_t tmp__output;
-		tmp__output = thisPtr->getHandle()->getHeight();
+		thisPtr->getHandle()->setAnimationPlayback(playback);
+	}
 
-		uint32_t __output;
+	SpriteAnimationPlayback ScriptSpriteTexture::Internal_getAnimationPlayback(ScriptSpriteTexture* thisPtr)
+	{
+		SpriteAnimationPlayback tmp__output;
+		tmp__output = thisPtr->getHandle()->getAnimationPlayback();
+
+		SpriteAnimationPlayback __output;
 		__output = tmp__output;
 
 		return __output;

Source/Scripting/SBansheeEngine/Generated/BsScriptSpriteTexture.generated.h

@@ -2,6 +2,7 @@
 
 #include "BsScriptEnginePrerequisites.h"
 #include "Wrappers/BsScriptResource.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Image/BsSpriteTexture.h"
 
 namespace bs
 {
@@ -19,12 +20,16 @@ namespace bs
 	private:
 		static void Internal_setTexture(ScriptSpriteTexture* thisPtr, MonoObject* texture);
 		static MonoObject* Internal_getTexture(ScriptSpriteTexture* thisPtr);
+		static uint32_t Internal_getWidth(ScriptSpriteTexture* thisPtr);
+		static uint32_t Internal_getHeight(ScriptSpriteTexture* thisPtr);
 		static void Internal_setOffset(ScriptSpriteTexture* thisPtr, Vector2* offset);
 		static void Internal_getOffset(ScriptSpriteTexture* thisPtr, Vector2* __output);
 		static void Internal_setScale(ScriptSpriteTexture* thisPtr, Vector2* scale);
 		static void Internal_getScale(ScriptSpriteTexture* thisPtr, Vector2* __output);
-		static uint32_t Internal_getWidth(ScriptSpriteTexture* thisPtr);
-		static uint32_t Internal_getHeight(ScriptSpriteTexture* thisPtr);
+		static void Internal_setAnimation(ScriptSpriteTexture* thisPtr, SpriteSheetGridAnimation* anim);
+		static void Internal_getAnimation(ScriptSpriteTexture* thisPtr, SpriteSheetGridAnimation* __output);
+		static void Internal_setAnimationPlayback(ScriptSpriteTexture* thisPtr, SpriteAnimationPlayback playback);
+		static SpriteAnimationPlayback Internal_getAnimationPlayback(ScriptSpriteTexture* thisPtr);
 		static void Internal_create(MonoObject* managedInstance, MonoObject* texture);
 		static void Internal_create0(MonoObject* managedInstance, Vector2* uvOffset, Vector2* uvScale, MonoObject* texture);
 	};

Source/Scripting/SBansheeEngine/Generated/BsScriptTAnimationCurve.generated.cpp

@@ -7,6 +7,7 @@
 #include "BsScriptTKeyframe.generated.h"
 #include "Wrappers/BsScriptVector.h"
 #include "Wrappers/BsScriptQuaternion.h"
+#include "BsScriptTKeyframe.generated.h"
 
 namespace bs
 {
@@ -207,4 +208,72 @@ namespace bs
 
 		return __output;
 	}
+
+	ScriptTAnimationCurveint32_t::ScriptTAnimationCurveint32_t(MonoObject* managedInstance, const SPtr<TAnimationCurve<int32_t>>& value)
+		:ScriptObject(managedInstance), mInternal(value)
+	{
+	}
+
+	void ScriptTAnimationCurveint32_t::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_TAnimationCurve", (void*)&ScriptTAnimationCurveint32_t::Internal_TAnimationCurve);
+		metaData.scriptClass->addInternalCall("Internal_evaluate", (void*)&ScriptTAnimationCurveint32_t::Internal_evaluate);
+		metaData.scriptClass->addInternalCall("Internal_getKeyFrames", (void*)&ScriptTAnimationCurveint32_t::Internal_getKeyFrames);
+
+	}
+
+	MonoObject* ScriptTAnimationCurveint32_t::create(const SPtr<TAnimationCurve<int32_t>>& value)
+	{
+		if(value == nullptr) return nullptr; 
+
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance("bool", ctorParams);
+		new (bs_alloc<ScriptTAnimationCurveint32_t>()) ScriptTAnimationCurveint32_t(managedInstance, value);
+		return managedInstance;
+	}
+	void ScriptTAnimationCurveint32_t::Internal_TAnimationCurve(MonoObject* managedInstance, MonoArray* keyframes)
+	{
+		Vector<TKeyframe<int32_t>> veckeyframes;
+		if(keyframes != nullptr)
+		{
+			ScriptArray arraykeyframes(keyframes);
+			veckeyframes.resize(arraykeyframes.size());
+			for(int i = 0; i < (int)arraykeyframes.size(); i++)
+			{
+				veckeyframes[i] = arraykeyframes.get<TKeyframe<int32_t>>(i);
+			}
+		}
+		SPtr<TAnimationCurve<int32_t>> instance = bs_shared_ptr_new<TAnimationCurve<int32_t>>(veckeyframes);
+		new (bs_alloc<ScriptTAnimationCurveint32_t>())ScriptTAnimationCurveint32_t(managedInstance, instance);
+	}
+
+	int32_t ScriptTAnimationCurveint32_t::Internal_evaluate(ScriptTAnimationCurveint32_t* thisPtr, float time, bool loop)
+	{
+		int32_t tmp__output;
+		tmp__output = thisPtr->getInternal()->evaluate(time, loop);
+
+		int32_t __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	MonoArray* ScriptTAnimationCurveint32_t::Internal_getKeyFrames(ScriptTAnimationCurveint32_t* thisPtr)
+	{
+		Vector<TKeyframe<int32_t>> vec__output;
+		vec__output = thisPtr->getInternal()->getKeyFrames();
+
+		MonoArray* __output;
+		int arraySize__output = (int)vec__output.size();
+		ScriptArray array__output = ScriptArray::create<ScriptTKeyframeint32_t>(arraySize__output);
+		for(int i = 0; i < arraySize__output; i++)
+		{
+			array__output.set(i, vec__output[i]);
+		}
+		__output = array__output.getInternal();
+
+		return __output;
+	}
 }

Source/Scripting/SBansheeEngine/Generated/BsScriptTAnimationCurve.generated.h

@@ -7,6 +7,8 @@
 #include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
 #include "BsScriptObject.h"
 #include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
+#include "BsScriptObject.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
 #include "Math/BsVector3.h"
 #include "Math/BsQuaternion.h"
 
@@ -69,4 +71,22 @@ namespace bs
 		static void Internal_evaluate(ScriptTAnimationCurveQuaternion* thisPtr, float time, bool loop, Quaternion* __output);
 		static MonoArray* Internal_getKeyFrames(ScriptTAnimationCurveQuaternion* thisPtr);
 	};
+
+	class BS_SCR_BE_EXPORT ScriptTAnimationCurveint32_t : public ScriptObject<ScriptTAnimationCurveint32_t>
+	{
+	public:
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "IntegerCurve")
+
+		ScriptTAnimationCurveint32_t(MonoObject* managedInstance, const SPtr<TAnimationCurve<int32_t>>& value);
+
+		SPtr<TAnimationCurve<int32_t>> getInternal() const { return mInternal; }
+		static MonoObject* create(const SPtr<TAnimationCurve<int32_t>>& value);
+
+	private:
+		SPtr<TAnimationCurve<int32_t>> mInternal;
+
+		static void Internal_TAnimationCurve(MonoObject* managedInstance, MonoArray* keyframes);
+		static int32_t Internal_evaluate(ScriptTAnimationCurveint32_t* thisPtr, float time, bool loop);
+		static MonoArray* Internal_getKeyFrames(ScriptTAnimationCurveint32_t* thisPtr);
+	};
 }

Source/Scripting/SBansheeEngine/Generated/BsScriptTKeyframe.generated.cpp

@@ -9,6 +9,24 @@
 
 namespace bs
 {
+	ScriptTKeyframeint32_t::ScriptTKeyframeint32_t(MonoObject* managedInstance)
+		:ScriptObject(managedInstance)
+	{ }
+
+	void ScriptTKeyframeint32_t::initRuntimeData()
+	{ }
+
+	MonoObject*ScriptTKeyframeint32_t::box(const TKeyframe<int32_t>& value)
+	{
+		return MonoUtil::box(metaData.scriptClass->_getInternalClass(), (void*)&value);
+	}
+
+	TKeyframe<int32_t> ScriptTKeyframeint32_t::unbox(MonoObject* value)
+	{
+		return *(TKeyframe<int32_t>*)MonoUtil::unbox(value);
+	}
+
+
 	ScriptTKeyframefloat::ScriptTKeyframefloat(MonoObject* managedInstance)
 		:ScriptObject(managedInstance)
 	{ }

Source/Scripting/SBansheeEngine/Generated/BsScriptTKeyframe.generated.h

@@ -7,11 +7,26 @@
 #include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
 #include "BsScriptObject.h"
 #include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
+#include "BsScriptObject.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
 #include "Math/BsVector3.h"
 #include "Math/BsQuaternion.h"
 
 namespace bs
 {
+	class BS_SCR_BE_EXPORT ScriptTKeyframeint32_t : public ScriptObject<ScriptTKeyframeint32_t>
+	{
+	public:
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "KeyFrameInt")
+
+		static MonoObject* box(const TKeyframe<int32_t>& value);
+		static TKeyframe<int32_t> unbox(MonoObject* value);
+
+	private:
+		ScriptTKeyframeint32_t(MonoObject* managedInstance);
+
+	};
+
 	class BS_SCR_BE_EXPORT ScriptTKeyframefloat : public ScriptObject<ScriptTKeyframefloat>
 	{
 	public:

Source/Scripting/SBansheeEngine/Generated/BsScriptTNamedAnimationCurve.generated.cpp

@@ -8,6 +8,8 @@
 #include "BsScriptTAnimationCurve.generated.h"
 #include "BsScriptTAnimationCurve.generated.h"
 #include "BsScriptTAnimationCurve.generated.h"
+#include "BsScriptTAnimationCurve.generated.h"
+#include "BsScriptTAnimationCurve.generated.h"
 
 namespace bs
 {
@@ -163,4 +165,55 @@ namespace bs
 		return output;
 	}
 
+
+	ScriptTNamedAnimationCurveint32_t::ScriptTNamedAnimationCurveint32_t(MonoObject* managedInstance)
+		:ScriptObject(managedInstance)
+	{ }
+
+	void ScriptTNamedAnimationCurveint32_t::initRuntimeData()
+	{ }
+
+	MonoObject*ScriptTNamedAnimationCurveint32_t::box(const __TNamedAnimationCurveint32_tInterop& value)
+	{
+		return MonoUtil::box(metaData.scriptClass->_getInternalClass(), (void*)&value);
+	}
+
+	__TNamedAnimationCurveint32_tInterop ScriptTNamedAnimationCurveint32_t::unbox(MonoObject* value)
+	{
+		return *(__TNamedAnimationCurveint32_tInterop*)MonoUtil::unbox(value);
+	}
+
+	TNamedAnimationCurve<int32_t> ScriptTNamedAnimationCurveint32_t::fromInterop(const __TNamedAnimationCurveint32_tInterop& value)
+	{
+		TNamedAnimationCurve<int32_t> output;
+		String tmpname;
+		tmpname = MonoUtil::monoToString(value.name);
+		output.name = tmpname;
+		output.flags = value.flags;
+		SPtr<TAnimationCurve<int32_t>> tmpcurve;
+		ScriptTAnimationCurveint32_t* scriptcurve;
+		scriptcurve = ScriptTAnimationCurveint32_t::toNative(value.curve);
+		if(scriptcurve != nullptr)
+			tmpcurve = scriptcurve->getInternal();
+		output.curve = *tmpcurve;
+
+		return output;
+	}
+
+	__TNamedAnimationCurveint32_tInterop ScriptTNamedAnimationCurveint32_t::toInterop(const TNamedAnimationCurve<int32_t>& value)
+	{
+		__TNamedAnimationCurveint32_tInterop output;
+		MonoString* tmpname;
+		tmpname = MonoUtil::stringToMono(value.name);
+		output.name = tmpname;
+		output.flags = value.flags;
+		MonoObject* tmpcurve;
+		SPtr<TAnimationCurve<int32_t>> tmpcurvecopy;
+		tmpcurvecopy = bs_shared_ptr_new<TAnimationCurve<int32_t>>(value.curve);
+		tmpcurve = ScriptTAnimationCurveint32_t::create(tmpcurvecopy);
+		output.curve = tmpcurve;
+
+		return output;
+	}
+
 }

Source/Scripting/SBansheeEngine/Generated/BsScriptTNamedAnimationCurve.generated.h

@@ -7,6 +7,9 @@
 #include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
 #include "BsScriptObject.h"
 #include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
+#include "BsScriptObject.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
 #include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
 #include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
 #include "../../../bsf/Source/Foundation/bsfCore/Animation/BsAnimationCurve.h"
@@ -79,4 +82,26 @@ namespace bs
 		ScriptTNamedAnimationCurveQuaternion(MonoObject* managedInstance);
 
 	};
+
+	struct __TNamedAnimationCurveint32_tInterop
+	{
+		MonoString* name;
+		Flags<AnimationCurveFlag> flags;
+		MonoObject* curve;
+	};
+
+	class BS_SCR_BE_EXPORT ScriptTNamedAnimationCurveint32_t : public ScriptObject<ScriptTNamedAnimationCurveint32_t>
+	{
+	public:
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "NamedIntegerCurve")
+
+		static MonoObject* box(const __TNamedAnimationCurveint32_tInterop& value);
+		static __TNamedAnimationCurveint32_tInterop unbox(MonoObject* value);
+		static TNamedAnimationCurve<int32_t> fromInterop(const __TNamedAnimationCurveint32_tInterop& value);
+		static __TNamedAnimationCurveint32_tInterop toInterop(const TNamedAnimationCurve<int32_t>& value);
+
+	private:
+		ScriptTNamedAnimationCurveint32_t(MonoObject* managedInstance);
+
+	};
 }

Source/Scripting/SBansheeEngine/Serialization/BsScriptAssemblyManager.cpp

@@ -13,7 +13,7 @@
 #include "BsBuiltinComponentLookup.generated.h"
 
 // Note: This resource registration code is only here because resource lookup auto-generation isn't yet hooked up
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "Mesh/BsMesh.h"
 #include "Text/BsFont.h"
 #include "Material/BsShader.h"

Source/Scripting/SBansheeEngine/Wrappers/GUI/BsScriptGUIButton.cpp

@@ -6,7 +6,7 @@
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
 #include "BsMonoMethod.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "BsMonoUtil.h"
 #include "GUI/BsGUILayout.h"
 #include "GUI/BsGUIButton.h"

Source/Scripting/SBansheeEngine/Wrappers/GUI/BsScriptGUIContent.cpp

@@ -7,7 +7,7 @@
 #include "BsMonoManager.h"
 #include "BsMonoUtil.h"
 #include "Wrappers/BsScriptHString.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "Wrappers/BsScriptGUIContentImages.h"
 
 namespace bs

Source/Scripting/SBansheeEngine/Wrappers/GUI/BsScriptGUIFixedSpace.cpp

@@ -5,7 +5,7 @@
 #include "BsMonoField.h"
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "BsMonoUtil.h"
 #include "GUI/BsGUILayout.h"
 #include "GUI/BsGUISpace.h"

Source/Scripting/SBansheeEngine/Wrappers/GUI/BsScriptGUIFlexibleSpace.cpp

@@ -5,7 +5,7 @@
 #include "BsMonoField.h"
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "BsMonoUtil.h"
 #include "GUI/BsGUILayout.h"
 #include "GUI/BsGUISpace.h"

Source/Scripting/SBansheeEngine/Wrappers/GUI/BsScriptGUILabel.cpp

@@ -5,7 +5,7 @@
 #include "BsMonoField.h"
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "BsMonoUtil.h"
 #include "GUI/BsGUILayout.h"
 #include "GUI/BsGUILabel.h"

Source/Scripting/SBansheeEngine/Wrappers/GUI/BsScriptGUIListBox.cpp

@@ -6,7 +6,7 @@
 #include "BsMonoClass.h"
 #include "BsMonoMethod.h"
 #include "BsMonoManager.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "BsMonoUtil.h"
 #include "GUI/BsGUILayout.h"
 #include "GUI/BsGUIListBox.h"

Source/Scripting/SBansheeEngine/Wrappers/GUI/BsScriptGUIProgressBar.cpp

@@ -6,7 +6,7 @@
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
 #include "BsMonoMethod.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "BsMonoUtil.h"
 #include "GUI/BsGUILayout.h"
 #include "GUI/BsGUIProgressBar.h"

Source/Scripting/SBansheeEngine/Wrappers/GUI/BsScriptGUIRenderTexture.cpp

@@ -5,7 +5,7 @@
 #include "BsMonoField.h"
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "BsMonoUtil.h"
 #include "GUI/BsGUILayout.h"
 #include "GUI/BsGUIRenderTexture.h"

Source/Scripting/SBansheeEngine/Wrappers/GUI/BsScriptGUIScrollArea.cpp

@@ -5,7 +5,7 @@
 #include "BsMonoField.h"
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "BsMonoUtil.h"
 #include "GUI/BsGUILayout.h"
 #include "GUI/BsGUIScrollArea.h"

Source/Scripting/SBansheeEngine/Wrappers/GUI/BsScriptGUISlider.cpp

@@ -6,7 +6,7 @@
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
 #include "BsMonoMethod.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "BsMonoUtil.h"
 #include "GUI/BsGUILayout.h"
 #include "GUI/BsGUISlider.h"

Source/Scripting/SBansheeEngine/Wrappers/GUI/BsScriptGUITexture.cpp

@@ -5,7 +5,7 @@
 #include "BsMonoField.h"
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "BsMonoUtil.h"
 #include "GUI/BsGUILayout.h"
 #include "GUI/BsGUITexture.h"

Source/Scripting/SBansheeEngine/Wrappers/GUI/BsScriptGUIToggle.cpp

@@ -6,7 +6,7 @@
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
 #include "BsMonoMethod.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "BsMonoUtil.h"
 #include "GUI/BsGUILayout.h"
 #include "GUI/BsGUIToggle.h"

Source/Scripting/SBansheeEngine/Wrappers/GUI/BsScriptGUIToggleGroup.cpp

@@ -5,7 +5,7 @@
 #include "BsMonoField.h"
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
-#include "2D/BsSpriteTexture.h"
+#include "Image/BsSpriteTexture.h"
 #include "BsMonoUtil.h"
 #include "GUI/BsGUIToggle.h"
 

Source/bsf

@@ -1 +1 @@
-Subproject commit b6185a4b6c847ed994ad85f77be96cfa5f68baa8
+Subproject commit d797373e1d6ceb54defcfb3752f83a945d25f799