Feature: Exposed parts of particle system & decal system to script code

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

@@ -0,0 +1,97 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Rendering
+	 *  @{
+	 */
+
+	/// <summary>Settings that control the bloom effect. Bloom adds an extra highlight to bright areas of the scene.</summary>
+	public partial class BloomSettings : ScriptObject
+	{
+		private BloomSettings(bool __dummy0) { }
+
+		public BloomSettings()
+		{
+			Internal_BloomSettings(this);
+		}
+
+		/// <summary>Enables or disables the bloom effect.</summary>
+		public bool Enabled
+		{
+			get { return Internal_getenabled(mCachedPtr); }
+			set { Internal_setenabled(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Quality of the bloom effect. Higher values will use higher resolution texture for calculating bloom, at the cost of 
+		/// lower performance. Valid range is [0, 3], default is 2.
+		/// </summary>
+		public uint Quality
+		{
+			get { return Internal_getquality(mCachedPtr); }
+			set { Internal_setquality(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the minimal threshold of pixel luminance to be included in the bloom calculations. Any pixel with 
+		/// luminance below this value will be ignored for the purposes of bloom. The value represents luminance after it is 
+		/// scaled by exposure. Set to zero or negative to disable the threshold and include all pixels in the calculations.
+		/// </summary>
+		public float Threshold
+		{
+			get { return Internal_getthreshold(mCachedPtr); }
+			set { Internal_setthreshold(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the intensity of the bloom effect. Ideally should be in [0, 4] range but higher values are allowed.
+		/// </summary>
+		public float Intensity
+		{
+			get { return Internal_getintensity(mCachedPtr); }
+			set { Internal_setintensity(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Tint color to apply to the bloom highlight. A pure white means the bloom inherits the underlying scene color.
+		/// </summary>
+		public Color Tint
+		{
+			get
+			{
+				Color temp;
+				Internal_gettint(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_settint(mCachedPtr, ref value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_BloomSettings(BloomSettings 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 uint Internal_getquality(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setquality(IntPtr thisPtr, uint value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getthreshold(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setthreshold(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 void Internal_gettint(IntPtr thisPtr, out Color __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_settint(IntPtr thisPtr, ref Color value);
+	}
+
+	/** @} */
+}

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

@@ -0,0 +1,76 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Rendering
+	 *  @{
+	 */
+
+	/// <summary>Wraps Decal as a Component.</summary>
+	public partial class Decal : Component
+	{
+		private Decal(bool __dummy0) { }
+		protected Decal() { }
+
+		/// <summary>Determines the material to use when rendering the decal.</summary>
+		[ShowInInspector]
+		public RRef<Material> Material
+		{
+			get { return Internal_getMaterial(mCachedPtr); }
+			set { Internal_setMaterial(mCachedPtr, value); }
+		}
+
+		/// <summary>Size of the decal in world space units.</summary>
+		[ShowInInspector]
+		public Vector2 Size
+		{
+			get
+			{
+				Vector2 temp;
+				Internal_getSize(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setSize(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Determines the maximum distance (from its origin) at which the decal is displayed.</summary>
+		[ShowInInspector]
+		public float MaxDistance
+		{
+			get { return Internal_getMaxDistance(mCachedPtr); }
+			set { Internal_setMaxDistance(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the layer bitfield that controls whether a system is considered visible in a specific camera.  Layer must 
+		/// match camera layer in order for the camera to render the component.
+		/// </summary>
+		[ShowInInspector]
+		public ulong Layer
+		{
+			get { return Internal_getLayer(mCachedPtr); }
+			set { Internal_setLayer(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMaterial(IntPtr thisPtr, RRef<Material> material);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern RRef<Material> Internal_getMaterial(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setSize(IntPtr thisPtr, ref Vector2 size);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getSize(IntPtr thisPtr, out Vector2 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setMaxDistance(IntPtr thisPtr, float distance);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getMaxDistance(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);
+	}
+
+	/** @} */
+}

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

@@ -0,0 +1,76 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Particles
+	 *  @{
+	 */
+
+	/// <summary>Controls depth buffer collisions for GPU simulated particles.</summary>
+	public partial class ParticleDepthCollisionSettings : ScriptObject
+	{
+		private ParticleDepthCollisionSettings(bool __dummy0) { }
+
+		public ParticleDepthCollisionSettings()
+		{
+			Internal_ParticleDepthCollisionSettings(this);
+		}
+
+		/// <summary>Determines if depth collisions are enabled.</summary>
+		public bool Enabled
+		{
+			get { return Internal_getenabled(mCachedPtr); }
+			set { Internal_setenabled(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the elasticity (bounciness) of the particle collision. Lower values make the collision less bouncy and 
+		/// higher values more.
+		/// </summary>
+		public float Restitution
+		{
+			get { return Internal_getrestitution(mCachedPtr); }
+			set { Internal_setrestitution(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines how much velocity should a particle lose after a collision, in percent of its current velocity. In range 
+		/// [0, 1].
+		/// </summary>
+		public float Dampening
+		{
+			get { return Internal_getdampening(mCachedPtr); }
+			set { Internal_setdampening(mCachedPtr, value); }
+		}
+
+		/// <summary>Scale which to apply to particle size in order to determine the collision radius.</summary>
+		public float RadiusScale
+		{
+			get { return Internal_getradiusScale(mCachedPtr); }
+			set { Internal_setradiusScale(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_ParticleDepthCollisionSettings(ParticleDepthCollisionSettings 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_getrestitution(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setrestitution(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getdampening(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setdampening(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getradiusScale(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setradiusScale(IntPtr thisPtr, float value);
+	}
+
+	/** @} */
+}

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

@@ -0,0 +1,92 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Particles
+	 *  @{
+	 */
+
+	/// <summary>Settings used for controlling particle system GPU simulation.</summary>
+	public partial class ParticleGpuSimulationSettings : ScriptObject
+	{
+		private ParticleGpuSimulationSettings(bool __dummy0) { }
+		protected ParticleGpuSimulationSettings() { }
+
+		public ParticleVectorFieldSettings VectorField
+		{
+			get { return Internal_getvectorField(mCachedPtr); }
+			set { Internal_setvectorField(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines particle color, evaluated over the particle lifetime.</summary>
+		public ColorDistribution ColorOverLifetime
+		{
+			get { return Internal_getcolorOverLifetime(mCachedPtr); }
+			set { Internal_setcolorOverLifetime(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines particle size, evaluated over the particle lifetime. Multiplied by the initial particle size.
+		/// </summary>
+		public Vector2Distribution SizeScaleOverLifetime
+		{
+			get { return Internal_getsizeScaleOverLifetime(mCachedPtr); }
+			set { Internal_setsizeScaleOverLifetime(mCachedPtr, value); }
+		}
+
+		/// <summary>Constant acceleration to apply for each step of the simulation.</summary>
+		public Vector3 Acceleration
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getacceleration(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setacceleration(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Amount of resistance to apply in the direction opposite of the particle's velocity.</summary>
+		public float Drag
+		{
+			get { return Internal_getdrag(mCachedPtr); }
+			set { Internal_setdrag(mCachedPtr, value); }
+		}
+
+		/// <summary>Settings controlling particle depth buffer collisions.</summary>
+		public ParticleDepthCollisionSettings DepthCollision
+		{
+			get { return Internal_getdepthCollision(mCachedPtr); }
+			set { Internal_setdepthCollision(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern ParticleVectorFieldSettings Internal_getvectorField(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setvectorField(IntPtr thisPtr, ParticleVectorFieldSettings value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern ColorDistribution Internal_getcolorOverLifetime(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setcolorOverLifetime(IntPtr thisPtr, ColorDistribution value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Vector2Distribution Internal_getsizeScaleOverLifetime(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setsizeScaleOverLifetime(IntPtr thisPtr, Vector2Distribution value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getacceleration(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setacceleration(IntPtr thisPtr, ref Vector3 value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getdrag(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setdrag(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern ParticleDepthCollisionSettings Internal_getdepthCollision(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setdepthCollision(IntPtr thisPtr, ParticleDepthCollisionSettings value);
+	}
+
+	/** @} */
+}

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

@@ -0,0 +1,23 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Particles
+	 *  @{
+	 */
+
+	/// <summary>Possible orientations when rendering billboard particles.</summary>
+	public enum ParticleOrientation
+	{
+		/// <summary>Orient towards view (camera) plane.</summary>
+		ViewPlane = 0,
+		/// <summary>Orient towards view (camera) position.</summary>
+		ViewPosition = 1,
+		/// <summary>Orient with a user-provided plane.</summary>
+		Plane = 2
+	}
+
+	/** @} */
+}

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

@@ -0,0 +1,21 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Particles
+	 *  @{
+	 */
+
+	/// <summary>Determines how are particles represented on the screen.</summary>
+	public enum ParticleRenderMode
+	{
+		/// <summary>Particle is represented using a 2D quad.</summary>
+		Billboard = 0,
+		/// <summary>Particle is represented using a 3D mesh.</summary>
+		Mesh = 1
+	}
+
+	/** @} */
+}

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

@@ -0,0 +1,27 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Particles
+	 *  @{
+	 */
+
+	/// <summary>Space in which to spawn/transform particles.</summary>
+	public enum ParticleSimulationSpace
+	{
+		/// <summary>
+		/// Particles will always remain local to their transform parent. This means if the transform parent moves so will all 
+		/// the particles.
+		/// </summary>
+		Local = 0,
+		/// <summary>
+		/// Particles will be placed in world space. This means they will spawn at the location of the transform parent, but are 
+		/// no longer affected by its transform after spawn (e.g. smoke rising from a moving train).
+		/// </summary>
+		World = 1
+	}
+
+	/** @} */
+}

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

@@ -0,0 +1,25 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Particles
+	 *  @{
+	 */
+
+	/// <summary>Determines how to sort particles before rendering.</summary>
+	public enum ParticleSortMode
+	{
+		/// <summary>Do not sort the particles.</summary>
+		None = 0,
+		/// <summary>Sort by distance from the camera, furthest to nearest.</summary>
+		Distance = 1,
+		/// <summary>Sort by age, oldest to youngest.</summary>
+		OldToYoung = 2,
+		/// <summary>Sort by age, youngest to oldest.</summary>
+		YoungToOld = 3
+	}
+
+	/** @} */
+}

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

@@ -0,0 +1,239 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Particles
+	 *  @{
+	 */
+
+	/// <summary>Generic settings used for controlling a ParticleSystem.</summary>
+	public partial class ParticleSystemSettings : ScriptObject
+	{
+		private ParticleSystemSettings(bool __dummy0) { }
+		protected ParticleSystemSettings() { }
+
+		/// <summary>Material to render the particles with.</summary>
+		public RRef<Material> Material
+		{
+			get { return Internal_getmaterial(mCachedPtr); }
+			set { Internal_setmaterial(mCachedPtr, value); }
+		}
+
+		/// <summary>Mesh used for representing individual particles when using the Mesh rendering mode.</summary>
+		public RRef<Mesh> Mesh
+		{
+			get { return Internal_getmesh(mCachedPtr); }
+			set { Internal_setmesh(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// If true the particle system will be simulated on the GPU. This allows much higher particle counts at lower 
+		/// performance cost. GPU simulation ignores any provided evolvers and instead uses ParticleGpuSimulationSettings to 
+		/// customize the GPU simulation.
+		/// </summary>
+		public bool GpuSimulation
+		{
+			get { return Internal_getgpuSimulation(mCachedPtr); }
+			set { Internal_setgpuSimulation(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines in which space are particles in.</summary>
+		public ParticleSimulationSpace SimulationSpace
+		{
+			get { return Internal_getsimulationSpace(mCachedPtr); }
+			set { Internal_setsimulationSpace(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines how are particles oriented when rendering.</summary>
+		public ParticleOrientation Orientation
+		{
+			get { return Internal_getorientation(mCachedPtr); }
+			set { Internal_setorientation(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines should the particles only be allowed to orient themselves around the Y axis, or freely. Ignored if using 
+		/// the Plane orientation mode.
+		/// </summary>
+		public bool OrientationLockY
+		{
+			get { return Internal_getorientationLockY(mCachedPtr); }
+			set { Internal_setorientationLockY(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines a plane to orient particles towards. Only used if particle orientation mode is set to  
+		/// ParticleOrientation::Plane.
+		/// </summary>
+		public Plane OrientationPlane
+		{
+			get
+			{
+				Plane temp;
+				Internal_getorientationPlane(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setorientationPlane(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Determines how (and if) are particles sorted. Sorting controls in what order are particles rendered.  If GPU 
+		/// simulation is enabled only distance based sorting is supported.
+		/// </summary>
+		public ParticleSortMode SortMode
+		{
+			get { return Internal_getsortMode(mCachedPtr); }
+			set { Internal_setsortMode(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the time period during which the system runs, in seconds. This effects evaluation of distributions with 
+		/// curves using particle system time for evaluation.
+		/// </summary>
+		public float Duration
+		{
+			get { return Internal_getduration(mCachedPtr); }
+			set { Internal_setduration(mCachedPtr, value); }
+		}
+
+		/// <summary>Determines should the particle system time wrap around once it reaches its duration.</summary>
+		public bool IsLooping
+		{
+			get { return Internal_getisLooping(mCachedPtr); }
+			set { Internal_setisLooping(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the maximum number of particles that can ever be active in this system. This number is ignored if GPU 
+		/// simulation is enabled, and instead particle count is instead only limited by the size of the internal buffers (shared 
+		/// between all particle systems).
+		/// </summary>
+		public uint MaxParticles
+		{
+			get { return Internal_getmaxParticles(mCachedPtr); }
+			set { Internal_setmaxParticles(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines should an automatic seed be used for the internal random number generator. This ensures the particle 
+		/// system yields different results each time it is ran.
+		/// </summary>
+		public bool UseAutomaticSeed
+		{
+			get { return Internal_getuseAutomaticSeed(mCachedPtr); }
+			set { Internal_setuseAutomaticSeed(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines the seed to use for the internal random number generator. Allows you to guarantee identical behaviour 
+		/// between different runs. Only relevant if automatic seed is disabled.
+		/// </summary>
+		public uint ManualSeed
+		{
+			get { return Internal_getmanualSeed(mCachedPtr); }
+			set { Internal_setmanualSeed(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines should the particle system bounds be automatically calculated, or should the fixed value provided be used. 
+		/// Bounds are used primarily for culling purposes. Note that automatic bounds are not supported when GPU simulation is 
+		/// enabled.
+		/// </summary>
+		public bool UseAutomaticBounds
+		{
+			get { return Internal_getuseAutomaticBounds(mCachedPtr); }
+			set { Internal_setuseAutomaticBounds(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Custom bounds to use them <see cref="useAutomaticBounds"/> is disabled. The bounds are in the simulation space of the 
+		/// particle system.
+		/// </summary>
+		public AABox CustomBounds
+		{
+			get
+			{
+				AABox temp;
+				Internal_getcustomBounds(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setcustomBounds(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Determines how is each particle represented on the screen.</summary>
+		public ParticleRenderMode RenderMode
+		{
+			get { return Internal_getrenderMode(mCachedPtr); }
+			set { Internal_setrenderMode(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern RRef<Material> Internal_getmaterial(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setmaterial(IntPtr thisPtr, RRef<Material> value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern RRef<Mesh> Internal_getmesh(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setmesh(IntPtr thisPtr, RRef<Mesh> value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getgpuSimulation(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setgpuSimulation(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern ParticleSimulationSpace Internal_getsimulationSpace(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setsimulationSpace(IntPtr thisPtr, ParticleSimulationSpace value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern ParticleOrientation Internal_getorientation(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setorientation(IntPtr thisPtr, ParticleOrientation value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getorientationLockY(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setorientationLockY(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getorientationPlane(IntPtr thisPtr, out Plane __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setorientationPlane(IntPtr thisPtr, ref Plane value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern ParticleSortMode Internal_getsortMode(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setsortMode(IntPtr thisPtr, ParticleSortMode value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float Internal_getduration(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setduration(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getisLooping(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setisLooping(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getmaxParticles(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setmaxParticles(IntPtr thisPtr, uint value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getuseAutomaticSeed(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setuseAutomaticSeed(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern uint Internal_getmanualSeed(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setmanualSeed(IntPtr thisPtr, uint value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_getuseAutomaticBounds(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setuseAutomaticBounds(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getcustomBounds(IntPtr thisPtr, out AABox __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setcustomBounds(IntPtr thisPtr, ref AABox value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern ParticleRenderMode Internal_getrenderMode(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setrenderMode(IntPtr thisPtr, ParticleRenderMode value);
+	}
+
+	/** @} */
+}

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

@@ -0,0 +1,160 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/// <summary>Settings used for controlling a vector field in a GPU simulated particle system.</summary>
+	public partial class ParticleVectorFieldSettings : ScriptObject
+	{
+		private ParticleVectorFieldSettings(bool __dummy0) { }
+		protected ParticleVectorFieldSettings() { }
+
+		/// <summary>Vector field resource used for influencing the particles.</summary>
+		public RRef<VectorField> VectorField
+		{
+			get { return Internal_getvectorField(mCachedPtr); }
+			set { Internal_setvectorField(mCachedPtr, value); }
+		}
+
+		/// <summary>Intensity of the forces and velocities applied by the vector field.</summary>
+		public float Intensity
+		{
+			get { return Internal_getintensity(mCachedPtr); }
+			set { Internal_setintensity(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines how closely does the particle velocity follow the vectors in the field. If set to 1 particles will be 
+		/// snapped to the exact velocity of the value in the field, and if set to 0 the field will not influence particle 
+		/// velocities directly.
+		/// </summary>
+		public float Tightness
+		{
+			get { return Internal_gettightness(mCachedPtr); }
+			set { Internal_settightness(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Scale to apply to the vector field bounds. This is multiplied with the bounds of the vector field resource.
+		/// </summary>
+		public Vector3 Scale
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getscale(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setscale(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Amount of to move the vector field by relative to the parent particle system. This is added to the bounds provided in 
+		/// the vector field resource.
+		/// </summary>
+		public Vector3 Offset
+		{
+			get
+			{
+				Vector3 temp;
+				Internal_getoffset(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setoffset(mCachedPtr, ref value); }
+		}
+
+		/// <summary>Initial rotation of the vector field.</summary>
+		public Quaternion Rotation
+		{
+			get
+			{
+				Quaternion temp;
+				Internal_getrotation(mCachedPtr, out temp);
+				return temp;
+			}
+			set { Internal_setrotation(mCachedPtr, ref value); }
+		}
+
+		/// <summary>
+		/// Determines the amount to rotate the vector field every second, in degrees, around XYZ axis respectively.  Evaluated 
+		/// over the particle system lifetime.
+		/// </summary>
+		public Vector3Distribution RotationRate
+		{
+			get { return Internal_getrotationRate(mCachedPtr); }
+			set { Internal_setrotationRate(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines should the field influence particles outside of the field bounds. If true the field will be tiled 
+		/// infinitely in the X direction.
+		/// </summary>
+		public bool TilingX
+		{
+			get { return Internal_gettilingX(mCachedPtr); }
+			set { Internal_settilingX(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines should the field influence particles outside of the field bounds. If true the field will be tiled 
+		/// infinitely in the Y direction.
+		/// </summary>
+		public bool TilingY
+		{
+			get { return Internal_gettilingY(mCachedPtr); }
+			set { Internal_settilingY(mCachedPtr, value); }
+		}
+
+		/// <summary>
+		/// Determines should the field influence particles outside of the field bounds. If true the field will be tiled 
+		/// infinitely in the Z direction.
+		/// </summary>
+		public bool TilingZ
+		{
+			get { return Internal_gettilingZ(mCachedPtr); }
+			set { Internal_settilingZ(mCachedPtr, value); }
+		}
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern RRef<VectorField> Internal_getvectorField(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setvectorField(IntPtr thisPtr, RRef<VectorField> 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_gettightness(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_settightness(IntPtr thisPtr, float value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getscale(IntPtr thisPtr, out Vector3 __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setscale(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);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_getrotation(IntPtr thisPtr, out Quaternion __output);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setrotation(IntPtr thisPtr, ref Quaternion value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Vector3Distribution Internal_getrotationRate(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setrotationRate(IntPtr thisPtr, Vector3Distribution value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_gettilingX(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_settilingX(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_gettilingY(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_settilingY(IntPtr thisPtr, bool value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool Internal_gettilingZ(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_settilingZ(IntPtr thisPtr, bool value);
+	}
+}

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

@@ -8,7 +8,7 @@ namespace BansheeEngine
 	 *  @{
 	 */
 
-	/// <summary>Light type that determines how is light information parsed by the renderer and other systems.</summary>
+	/// <summary>Probe type that determines the shape of the probe and how is it interpreted by the renderer.</summary>
 	public enum ReflectionProbeType
 	{
 		/// <summary>

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

@@ -98,6 +98,13 @@ namespace BansheeEngine
 			set { Internal_setscreenSpaceReflections(mCachedPtr, value); }
 		}
 
+		/// <summary>Parameters used for customizing the bloom effect.</summary>
+		public BloomSettings Bloom
+		{
+			get { return Internal_getbloom(mCachedPtr); }
+			set { Internal_setbloom(mCachedPtr, value); }
+		}
+
 		/// <summary>Enables the fast approximate anti-aliasing effect.</summary>
 		public bool EnableFXAA
 		{
@@ -228,6 +235,10 @@ namespace BansheeEngine
 		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern void Internal_setscreenSpaceReflections(IntPtr thisPtr, ScreenSpaceReflectionsSettings value);
 		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern BloomSettings Internal_getbloom(IntPtr thisPtr);
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void Internal_setbloom(IntPtr thisPtr, BloomSettings value);
+		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern bool Internal_getenableFXAA(IntPtr thisPtr);
 		[MethodImpl(MethodImplOptions.InternalCall)]
 		private static extern void Internal_setenableFXAA(IntPtr thisPtr, bool value);

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

@@ -109,7 +109,7 @@ namespace BansheeEngine
 		}
 
 		/// <summary>
-		/// Reads texture pixels directly from the GPU. This is similar to GetPixels" but the texture doesn't need to be created 
+		/// Reads texture pixels directly from the GPU. This is similar to GetPixels but the texture doesn't need to be created 
 		/// with TextureUsage.CPUCached, and the data will contain any updates performed by the GPU. This method can be 
 		/// potentially slow as it introduces a CPU-GPU synchronization point. Additionally this method is asynchronous which 
 		/// means the data is not available immediately.

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

@@ -0,0 +1,35 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+	/** @addtogroup Particles
+	 *  @{
+	 */
+
+	/// <summary>
+	/// Represents a three dimensional field of vectors. It is represented by spatial bounds which are split into a grid of 
+	/// values with user-defined density, where each grid cell is assigned a vector.
+	/// </summary>
+	public partial class VectorField : Resource
+	{
+		private VectorField(bool __dummy0) { }
+		protected VectorField() { }
+
+		/// <summary>Returns a reference wrapper for this resource.</summary>
+		public RRef<VectorField> Ref
+		{
+			get { return Internal_GetRef(mCachedPtr); }
+		}
+
+		/// <summary>Returns a reference wrapper for this resource.</summary>
+		public static implicit operator RRef<VectorField>(VectorField x)
+		{ return Internal_GetRef(x.mCachedPtr); }
+
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern RRef<VectorField> Internal_GetRef(IntPtr thisPtr);
+	}
+
+	/** @} */
+}

Source/Scripting/MBansheeEngine/MBansheeEngine.csproj

@@ -43,6 +43,7 @@
     <Compile Include="GUI\GUICanvas.cs" />
     <Compile Include="GUI\GUIScrollBar.cs" />
     <Compile Include="Math\Line2.cs" />
+    <Compile Include="Math\Plane.cs" />
     <Compile Include="Rendering\Material.cs" />
     <Compile Include="Serialization\ShowInInspector.cs" />
     <Compile Include="Serialization\Step.cs" />

Source/Scripting/MBansheeEngine/Math/Plane.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace BansheeEngine
+{
+    /** @addtogroup Math
+     *  @{
+     */
+
+    /// <summary>
+    /// A plane represented by a normal and a distance.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential), SerializeObject]
+    public struct Plane // Note: Must match C++ class Plane
+    {
+        /// <summary>
+        /// The "positive side" of the plane is the half space to which the plane normal points. The "negative side" is the 
+        /// other half space. The flag "no side" indicates the plane itself.
+        /// </summary>
+        public enum Side
+        {
+            None,
+            Positive,
+            Negative,
+            Both
+        };
+
+        public Vector3 normal;
+        public float d;
+
+        /// <summary>
+        /// Creates a plane from a normal and a distance from the plane.
+        /// </summary>
+        /// <param name="normal">Plane normal pointing in the positive half-space.</param>
+        /// <param name="d">Distance of the plane from the origin, along the normal.</param>
+        public Plane(Vector3 normal, float d)
+        {
+            this.normal = normal;
+            this.d = d;
+        }
+
+        /// <summary>
+        /// Creates a plane from three points on the plane. The points must not be colinear.
+        /// </summary>
+        /// <param name="a">A point in the plane.</param>
+        /// <param name="b">A point in the plane.</param>
+        /// <param name="c">A point in the plane.</param>
+        public Plane(Vector3 a, Vector3 b, Vector3 c)
+        {
+            Vector3 e0 = b - a;
+            Vector3 e1 = c - a;
+            normal = Vector3.Cross(e0, e1);
+            normal.Normalize();
+
+            d = Vector3.Dot(normal, a);
+        }
+
+        /// <summary>
+        /// Returns a distance from point to plane.
+        /// </summary>
+        /// <param name="point">Point to test.</param>
+        /// <returns>
+        /// Distance to the plane. Will be positive if the point is on the positive side of the plane, negative if on the
+        /// negative side of the plane, or zero if the point is on the plane.
+        /// </returns>
+        float GetDistance(Vector3 point)
+        {
+            return Vector3.Dot(normal, point) - d;
+        }
+
+        /// <summary>
+        /// Returns the side of the plane where the point is located on. No side signifies the point is on the plane.
+        /// </summary>
+        /// <param name="point">Point to test.</param>
+        /// <param name="epsilon">Extra depth of the plane to help with precision issues.</param>
+        /// <returns>Side on the plane the point is located on.</returns>
+        public Side GetSide(Vector3 point, float epsilon = 0.0f)
+        {
+            float dist = GetDistance(point);
+
+            if (dist > epsilon)
+                return Side.Positive;
+
+            if (dist < -epsilon)
+                return Side.Negative;
+
+            return Side.None;
+        }
+    }
+
+    /** @} */
+}

Source/Scripting/SBansheeEngine/BsScriptEnginePrerequisites.h

@@ -192,7 +192,8 @@ namespace bs
 	enum class ScriptResourceType // Note: Must be the same as C# enum ResourceType
 	{
 		Texture, SpriteTexture, Mesh, Font, Shader, ShaderInclude, Material, Prefab,
-		PlainText, ScriptCode, StringTable, GUISkin, PhysicsMaterial, PhysicsMesh, AudioClip, AnimationClip, Undefined
+		PlainText, ScriptCode, StringTable, GUISkin, PhysicsMaterial, PhysicsMesh, AudioClip, AnimationClip, 
+		VectorField, Undefined
 	};
 
 	/** Information about a builtin resource wrapped as a script object. */

Source/Scripting/SBansheeEngine/Extensions/BsParticleDistributionEx.h

@@ -21,7 +21,7 @@ namespace bs
 		BS_SCRIPT_EXPORT(e:ColorDistribution)
 		static Color evaluate(const SPtr<ColorDistribution>& thisPtr, float t, float factor);
 
-		/** @copydoc ColorDistribution::evaluate(float, Random&) */
+		/** @copydoc ColorDistribution::evaluate(float, const Random&) */
 		BS_SCRIPT_EXPORT(e:ColorDistribution)
 		static Color evaluate(const SPtr<ColorDistribution>& thisPtr, float t, Random& factor);
 	}; 

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

@@ -52,6 +52,8 @@
 #include "BsScriptCSkybox.generated.h"
 #include "../../../bsf/Source/Foundation/bsfCore/Components/BsCLightProbeVolume.h"
 #include "BsScriptCLightProbeVolume.generated.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Components/BsCDecal.h"
+#include "BsScriptCDecal.generated.h"
 
 namespace bs
 {
@@ -81,6 +83,7 @@ namespace bs
 		ADD_ENTRY(CBone, ScriptCBone)
 		ADD_ENTRY(CSkybox, ScriptCSkybox)
 		ADD_ENTRY(CLightProbeVolume, ScriptCLightProbeVolume)
+		ADD_ENTRY(CDecal, ScriptCDecal)
 	LOOKUP_END
 }
 #undef LOOKUP_BEGIN

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

@@ -0,0 +1,126 @@
+#include "BsScriptBloomSettings.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Renderer/BsRenderSettings.h"
+#include "Wrappers/BsScriptColor.h"
+
+namespace bs
+{
+	ScriptBloomSettings::ScriptBloomSettings(MonoObject* managedInstance, const SPtr<BloomSettings>& value)
+		:ScriptObject(managedInstance), mInternal(value)
+	{
+	}
+
+	void ScriptBloomSettings::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_BloomSettings", (void*)&ScriptBloomSettings::Internal_BloomSettings);
+		metaData.scriptClass->addInternalCall("Internal_getenabled", (void*)&ScriptBloomSettings::Internal_getenabled);
+		metaData.scriptClass->addInternalCall("Internal_setenabled", (void*)&ScriptBloomSettings::Internal_setenabled);
+		metaData.scriptClass->addInternalCall("Internal_getquality", (void*)&ScriptBloomSettings::Internal_getquality);
+		metaData.scriptClass->addInternalCall("Internal_setquality", (void*)&ScriptBloomSettings::Internal_setquality);
+		metaData.scriptClass->addInternalCall("Internal_getthreshold", (void*)&ScriptBloomSettings::Internal_getthreshold);
+		metaData.scriptClass->addInternalCall("Internal_setthreshold", (void*)&ScriptBloomSettings::Internal_setthreshold);
+		metaData.scriptClass->addInternalCall("Internal_getintensity", (void*)&ScriptBloomSettings::Internal_getintensity);
+		metaData.scriptClass->addInternalCall("Internal_setintensity", (void*)&ScriptBloomSettings::Internal_setintensity);
+		metaData.scriptClass->addInternalCall("Internal_gettint", (void*)&ScriptBloomSettings::Internal_gettint);
+		metaData.scriptClass->addInternalCall("Internal_settint", (void*)&ScriptBloomSettings::Internal_settint);
+
+	}
+
+	MonoObject* ScriptBloomSettings::create(const SPtr<BloomSettings>& value)
+	{
+		if(value == nullptr) return nullptr; 
+
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance("bool", ctorParams);
+		new (bs_alloc<ScriptBloomSettings>()) ScriptBloomSettings(managedInstance, value);
+		return managedInstance;
+	}
+	void ScriptBloomSettings::Internal_BloomSettings(MonoObject* managedInstance)
+	{
+		SPtr<BloomSettings> instance = bs_shared_ptr_new<BloomSettings>();
+		new (bs_alloc<ScriptBloomSettings>())ScriptBloomSettings(managedInstance, instance);
+	}
+
+	bool ScriptBloomSettings::Internal_getenabled(ScriptBloomSettings* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->enabled;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptBloomSettings::Internal_setenabled(ScriptBloomSettings* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->enabled = value;
+	}
+
+	uint32_t ScriptBloomSettings::Internal_getquality(ScriptBloomSettings* thisPtr)
+	{
+		uint32_t tmp__output;
+		tmp__output = thisPtr->getInternal()->quality;
+
+		uint32_t __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptBloomSettings::Internal_setquality(ScriptBloomSettings* thisPtr, uint32_t value)
+	{
+		thisPtr->getInternal()->quality = value;
+	}
+
+	float ScriptBloomSettings::Internal_getthreshold(ScriptBloomSettings* thisPtr)
+	{
+		float tmp__output;
+		tmp__output = thisPtr->getInternal()->threshold;
+
+		float __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptBloomSettings::Internal_setthreshold(ScriptBloomSettings* thisPtr, float value)
+	{
+		thisPtr->getInternal()->threshold = value;
+	}
+
+	float ScriptBloomSettings::Internal_getintensity(ScriptBloomSettings* thisPtr)
+	{
+		float tmp__output;
+		tmp__output = thisPtr->getInternal()->intensity;
+
+		float __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptBloomSettings::Internal_setintensity(ScriptBloomSettings* thisPtr, float value)
+	{
+		thisPtr->getInternal()->intensity = value;
+	}
+
+	void ScriptBloomSettings::Internal_gettint(ScriptBloomSettings* thisPtr, Color* __output)
+	{
+		Color tmp__output;
+		tmp__output = thisPtr->getInternal()->tint;
+
+		*__output = tmp__output;
+
+
+	}
+
+	void ScriptBloomSettings::Internal_settint(ScriptBloomSettings* thisPtr, Color* value)
+	{
+		thisPtr->getInternal()->tint = *value;
+	}
+}

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

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptObject.h"
+#include "Image/BsColor.h"
+
+namespace bs
+{
+	struct BloomSettings;
+
+	class BS_SCR_BE_EXPORT ScriptBloomSettings : public ScriptObject<ScriptBloomSettings>
+	{
+	public:
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "BloomSettings")
+
+		ScriptBloomSettings(MonoObject* managedInstance, const SPtr<BloomSettings>& value);
+
+		SPtr<BloomSettings> getInternal() const { return mInternal; }
+		static MonoObject* create(const SPtr<BloomSettings>& value);
+
+	private:
+		SPtr<BloomSettings> mInternal;
+
+		static void Internal_BloomSettings(MonoObject* managedInstance);
+		static bool Internal_getenabled(ScriptBloomSettings* thisPtr);
+		static void Internal_setenabled(ScriptBloomSettings* thisPtr, bool value);
+		static uint32_t Internal_getquality(ScriptBloomSettings* thisPtr);
+		static void Internal_setquality(ScriptBloomSettings* thisPtr, uint32_t value);
+		static float Internal_getthreshold(ScriptBloomSettings* thisPtr);
+		static void Internal_setthreshold(ScriptBloomSettings* thisPtr, float value);
+		static float Internal_getintensity(ScriptBloomSettings* thisPtr);
+		static void Internal_setintensity(ScriptBloomSettings* thisPtr, float value);
+		static void Internal_gettint(ScriptBloomSettings* thisPtr, Color* __output);
+		static void Internal_settint(ScriptBloomSettings* thisPtr, Color* value);
+	};
+}

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

@@ -0,0 +1,101 @@
+#include "BsScriptCDecal.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Components/BsCDecal.h"
+#include "BsScriptResourceManager.h"
+#include "Wrappers/BsScriptRRefBase.h"
+#include "Wrappers/BsScriptVector.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Material/BsMaterial.h"
+
+namespace bs
+{
+	ScriptCDecal::ScriptCDecal(MonoObject* managedInstance, const GameObjectHandle<CDecal>& value)
+		:TScriptComponent(managedInstance, value)
+	{
+	}
+
+	void ScriptCDecal::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_setMaterial", (void*)&ScriptCDecal::Internal_setMaterial);
+		metaData.scriptClass->addInternalCall("Internal_getMaterial", (void*)&ScriptCDecal::Internal_getMaterial);
+		metaData.scriptClass->addInternalCall("Internal_setSize", (void*)&ScriptCDecal::Internal_setSize);
+		metaData.scriptClass->addInternalCall("Internal_getSize", (void*)&ScriptCDecal::Internal_getSize);
+		metaData.scriptClass->addInternalCall("Internal_setMaxDistance", (void*)&ScriptCDecal::Internal_setMaxDistance);
+		metaData.scriptClass->addInternalCall("Internal_getMaxDistance", (void*)&ScriptCDecal::Internal_getMaxDistance);
+		metaData.scriptClass->addInternalCall("Internal_setLayer", (void*)&ScriptCDecal::Internal_setLayer);
+		metaData.scriptClass->addInternalCall("Internal_getLayer", (void*)&ScriptCDecal::Internal_getLayer);
+
+	}
+
+	void ScriptCDecal::Internal_setMaterial(ScriptCDecal* thisPtr, MonoObject* material)
+	{
+		ResourceHandle<Material> tmpmaterial;
+		ScriptRRefBase* scriptmaterial;
+		scriptmaterial = ScriptRRefBase::toNative(material);
+		if(scriptmaterial != nullptr)
+			tmpmaterial = static_resource_cast<Material>(scriptmaterial->getHandle());
+		thisPtr->getHandle()->setMaterial(tmpmaterial);
+	}
+
+	MonoObject* ScriptCDecal::Internal_getMaterial(ScriptCDecal* thisPtr)
+	{
+		ResourceHandle<Material> tmp__output;
+		tmp__output = thisPtr->getHandle()->getMaterial();
+
+		MonoObject* __output;
+		ScriptRRefBase* script__output;
+		script__output = ScriptResourceManager::instance().getScriptRRef(tmp__output);
+		if(script__output != nullptr)
+			__output = script__output->getManagedInstance();
+		else
+			__output = nullptr;
+
+		return __output;
+	}
+
+	void ScriptCDecal::Internal_setSize(ScriptCDecal* thisPtr, Vector2* size)
+	{
+		thisPtr->getHandle()->setSize(*size);
+	}
+
+	void ScriptCDecal::Internal_getSize(ScriptCDecal* thisPtr, Vector2* __output)
+	{
+		Vector2 tmp__output;
+		tmp__output = thisPtr->getHandle()->getSize();
+
+		*__output = tmp__output;
+	}
+
+	void ScriptCDecal::Internal_setMaxDistance(ScriptCDecal* thisPtr, float distance)
+	{
+		thisPtr->getHandle()->setMaxDistance(distance);
+	}
+
+	float ScriptCDecal::Internal_getMaxDistance(ScriptCDecal* thisPtr)
+	{
+		float tmp__output;
+		tmp__output = thisPtr->getHandle()->getMaxDistance();
+
+		float __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptCDecal::Internal_setLayer(ScriptCDecal* thisPtr, uint64_t layer)
+	{
+		thisPtr->getHandle()->setLayer(layer);
+	}
+
+	uint64_t ScriptCDecal::Internal_getLayer(ScriptCDecal* thisPtr)
+	{
+		uint64_t tmp__output;
+		tmp__output = thisPtr->getHandle()->getLayer();
+
+		uint64_t __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+}

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

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "Wrappers/BsScriptComponent.h"
+
+namespace bs
+{
+	class CDecal;
+	class Material;
+
+	class BS_SCR_BE_EXPORT ScriptCDecal : public TScriptComponent<ScriptCDecal, CDecal>
+	{
+	public:
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "Decal")
+
+		ScriptCDecal(MonoObject* managedInstance, const GameObjectHandle<CDecal>& value);
+
+	private:
+		static void Internal_setMaterial(ScriptCDecal* thisPtr, MonoObject* material);
+		static MonoObject* Internal_getMaterial(ScriptCDecal* thisPtr);
+		static void Internal_setSize(ScriptCDecal* thisPtr, Vector2* size);
+		static void Internal_getSize(ScriptCDecal* thisPtr, Vector2* __output);
+		static void Internal_setMaxDistance(ScriptCDecal* thisPtr, float distance);
+		static float Internal_getMaxDistance(ScriptCDecal* thisPtr);
+		static void Internal_setLayer(ScriptCDecal* thisPtr, uint64_t layer);
+		static uint64_t Internal_getLayer(ScriptCDecal* thisPtr);
+	};
+}

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

@@ -0,0 +1,108 @@
+#include "BsScriptParticleDepthCollisionSettings.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Particles/BsParticleSystem.h"
+
+namespace bs
+{
+	ScriptParticleDepthCollisionSettings::ScriptParticleDepthCollisionSettings(MonoObject* managedInstance, const SPtr<ParticleDepthCollisionSettings>& value)
+		:ScriptObject(managedInstance), mInternal(value)
+	{
+	}
+
+	void ScriptParticleDepthCollisionSettings::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_ParticleDepthCollisionSettings", (void*)&ScriptParticleDepthCollisionSettings::Internal_ParticleDepthCollisionSettings);
+		metaData.scriptClass->addInternalCall("Internal_getenabled", (void*)&ScriptParticleDepthCollisionSettings::Internal_getenabled);
+		metaData.scriptClass->addInternalCall("Internal_setenabled", (void*)&ScriptParticleDepthCollisionSettings::Internal_setenabled);
+		metaData.scriptClass->addInternalCall("Internal_getrestitution", (void*)&ScriptParticleDepthCollisionSettings::Internal_getrestitution);
+		metaData.scriptClass->addInternalCall("Internal_setrestitution", (void*)&ScriptParticleDepthCollisionSettings::Internal_setrestitution);
+		metaData.scriptClass->addInternalCall("Internal_getdampening", (void*)&ScriptParticleDepthCollisionSettings::Internal_getdampening);
+		metaData.scriptClass->addInternalCall("Internal_setdampening", (void*)&ScriptParticleDepthCollisionSettings::Internal_setdampening);
+		metaData.scriptClass->addInternalCall("Internal_getradiusScale", (void*)&ScriptParticleDepthCollisionSettings::Internal_getradiusScale);
+		metaData.scriptClass->addInternalCall("Internal_setradiusScale", (void*)&ScriptParticleDepthCollisionSettings::Internal_setradiusScale);
+
+	}
+
+	MonoObject* ScriptParticleDepthCollisionSettings::create(const SPtr<ParticleDepthCollisionSettings>& value)
+	{
+		if(value == nullptr) return nullptr; 
+
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance("bool", ctorParams);
+		new (bs_alloc<ScriptParticleDepthCollisionSettings>()) ScriptParticleDepthCollisionSettings(managedInstance, value);
+		return managedInstance;
+	}
+	void ScriptParticleDepthCollisionSettings::Internal_ParticleDepthCollisionSettings(MonoObject* managedInstance)
+	{
+		SPtr<ParticleDepthCollisionSettings> instance = bs_shared_ptr_new<ParticleDepthCollisionSettings>();
+		new (bs_alloc<ScriptParticleDepthCollisionSettings>())ScriptParticleDepthCollisionSettings(managedInstance, instance);
+	}
+
+	bool ScriptParticleDepthCollisionSettings::Internal_getenabled(ScriptParticleDepthCollisionSettings* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->enabled;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleDepthCollisionSettings::Internal_setenabled(ScriptParticleDepthCollisionSettings* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->enabled = value;
+	}
+
+	float ScriptParticleDepthCollisionSettings::Internal_getrestitution(ScriptParticleDepthCollisionSettings* thisPtr)
+	{
+		float tmp__output;
+		tmp__output = thisPtr->getInternal()->restitution;
+
+		float __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleDepthCollisionSettings::Internal_setrestitution(ScriptParticleDepthCollisionSettings* thisPtr, float value)
+	{
+		thisPtr->getInternal()->restitution = value;
+	}
+
+	float ScriptParticleDepthCollisionSettings::Internal_getdampening(ScriptParticleDepthCollisionSettings* thisPtr)
+	{
+		float tmp__output;
+		tmp__output = thisPtr->getInternal()->dampening;
+
+		float __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleDepthCollisionSettings::Internal_setdampening(ScriptParticleDepthCollisionSettings* thisPtr, float value)
+	{
+		thisPtr->getInternal()->dampening = value;
+	}
+
+	float ScriptParticleDepthCollisionSettings::Internal_getradiusScale(ScriptParticleDepthCollisionSettings* thisPtr)
+	{
+		float tmp__output;
+		tmp__output = thisPtr->getInternal()->radiusScale;
+
+		float __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleDepthCollisionSettings::Internal_setradiusScale(ScriptParticleDepthCollisionSettings* thisPtr, float value)
+	{
+		thisPtr->getInternal()->radiusScale = value;
+	}
+}

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

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptObject.h"
+
+namespace bs
+{
+	struct ParticleDepthCollisionSettings;
+
+	class BS_SCR_BE_EXPORT ScriptParticleDepthCollisionSettings : public ScriptObject<ScriptParticleDepthCollisionSettings>
+	{
+	public:
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "ParticleDepthCollisionSettings")
+
+		ScriptParticleDepthCollisionSettings(MonoObject* managedInstance, const SPtr<ParticleDepthCollisionSettings>& value);
+
+		SPtr<ParticleDepthCollisionSettings> getInternal() const { return mInternal; }
+		static MonoObject* create(const SPtr<ParticleDepthCollisionSettings>& value);
+
+	private:
+		SPtr<ParticleDepthCollisionSettings> mInternal;
+
+		static void Internal_ParticleDepthCollisionSettings(MonoObject* managedInstance);
+		static bool Internal_getenabled(ScriptParticleDepthCollisionSettings* thisPtr);
+		static void Internal_setenabled(ScriptParticleDepthCollisionSettings* thisPtr, bool value);
+		static float Internal_getrestitution(ScriptParticleDepthCollisionSettings* thisPtr);
+		static void Internal_setrestitution(ScriptParticleDepthCollisionSettings* thisPtr, float value);
+		static float Internal_getdampening(ScriptParticleDepthCollisionSettings* thisPtr);
+		static void Internal_setdampening(ScriptParticleDepthCollisionSettings* thisPtr, float value);
+		static float Internal_getradiusScale(ScriptParticleDepthCollisionSettings* thisPtr);
+		static void Internal_setradiusScale(ScriptParticleDepthCollisionSettings* thisPtr, float value);
+	};
+}

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

@@ -0,0 +1,157 @@
+#include "BsScriptParticleGpuSimulationSettings.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Particles/BsParticleSystem.h"
+#include "BsScriptParticleDepthCollisionSettings.generated.h"
+#include "BsScriptParticleVectorFieldSettings.generated.h"
+#include "BsScriptColorDistribution.generated.h"
+#include "BsScriptTDistribution.generated.h"
+#include "Wrappers/BsScriptVector.h"
+
+namespace bs
+{
+	ScriptParticleGpuSimulationSettings::ScriptParticleGpuSimulationSettings(MonoObject* managedInstance, const SPtr<ParticleGpuSimulationSettings>& value)
+		:ScriptObject(managedInstance), mInternal(value)
+	{
+	}
+
+	void ScriptParticleGpuSimulationSettings::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_getvectorField", (void*)&ScriptParticleGpuSimulationSettings::Internal_getvectorField);
+		metaData.scriptClass->addInternalCall("Internal_setvectorField", (void*)&ScriptParticleGpuSimulationSettings::Internal_setvectorField);
+		metaData.scriptClass->addInternalCall("Internal_getcolorOverLifetime", (void*)&ScriptParticleGpuSimulationSettings::Internal_getcolorOverLifetime);
+		metaData.scriptClass->addInternalCall("Internal_setcolorOverLifetime", (void*)&ScriptParticleGpuSimulationSettings::Internal_setcolorOverLifetime);
+		metaData.scriptClass->addInternalCall("Internal_getsizeScaleOverLifetime", (void*)&ScriptParticleGpuSimulationSettings::Internal_getsizeScaleOverLifetime);
+		metaData.scriptClass->addInternalCall("Internal_setsizeScaleOverLifetime", (void*)&ScriptParticleGpuSimulationSettings::Internal_setsizeScaleOverLifetime);
+		metaData.scriptClass->addInternalCall("Internal_getacceleration", (void*)&ScriptParticleGpuSimulationSettings::Internal_getacceleration);
+		metaData.scriptClass->addInternalCall("Internal_setacceleration", (void*)&ScriptParticleGpuSimulationSettings::Internal_setacceleration);
+		metaData.scriptClass->addInternalCall("Internal_getdrag", (void*)&ScriptParticleGpuSimulationSettings::Internal_getdrag);
+		metaData.scriptClass->addInternalCall("Internal_setdrag", (void*)&ScriptParticleGpuSimulationSettings::Internal_setdrag);
+		metaData.scriptClass->addInternalCall("Internal_getdepthCollision", (void*)&ScriptParticleGpuSimulationSettings::Internal_getdepthCollision);
+		metaData.scriptClass->addInternalCall("Internal_setdepthCollision", (void*)&ScriptParticleGpuSimulationSettings::Internal_setdepthCollision);
+
+	}
+
+	MonoObject* ScriptParticleGpuSimulationSettings::create(const SPtr<ParticleGpuSimulationSettings>& value)
+	{
+		if(value == nullptr) return nullptr; 
+
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance("bool", ctorParams);
+		new (bs_alloc<ScriptParticleGpuSimulationSettings>()) ScriptParticleGpuSimulationSettings(managedInstance, value);
+		return managedInstance;
+	}
+	MonoObject* ScriptParticleGpuSimulationSettings::Internal_getvectorField(ScriptParticleGpuSimulationSettings* thisPtr)
+	{
+		SPtr<ParticleVectorFieldSettings> tmp__output = bs_shared_ptr_new<ParticleVectorFieldSettings>();
+		*tmp__output = thisPtr->getInternal()->vectorField;
+
+		MonoObject* __output;
+		__output = ScriptParticleVectorFieldSettings::create(tmp__output);
+
+		return __output;
+	}
+
+	void ScriptParticleGpuSimulationSettings::Internal_setvectorField(ScriptParticleGpuSimulationSettings* thisPtr, MonoObject* value)
+	{
+		SPtr<ParticleVectorFieldSettings> tmpvalue;
+		ScriptParticleVectorFieldSettings* scriptvalue;
+		scriptvalue = ScriptParticleVectorFieldSettings::toNative(value);
+		tmpvalue = scriptvalue->getInternal();
+		thisPtr->getInternal()->vectorField = *tmpvalue;
+	}
+
+	MonoObject* ScriptParticleGpuSimulationSettings::Internal_getcolorOverLifetime(ScriptParticleGpuSimulationSettings* thisPtr)
+	{
+		SPtr<ColorDistribution> tmp__output = bs_shared_ptr_new<ColorDistribution>();
+		*tmp__output = thisPtr->getInternal()->colorOverLifetime;
+
+		MonoObject* __output;
+		__output = ScriptColorDistribution::create(tmp__output);
+
+		return __output;
+	}
+
+	void ScriptParticleGpuSimulationSettings::Internal_setcolorOverLifetime(ScriptParticleGpuSimulationSettings* thisPtr, MonoObject* value)
+	{
+		SPtr<ColorDistribution> tmpvalue;
+		ScriptColorDistribution* scriptvalue;
+		scriptvalue = ScriptColorDistribution::toNative(value);
+		tmpvalue = scriptvalue->getInternal();
+		thisPtr->getInternal()->colorOverLifetime = *tmpvalue;
+	}
+
+	MonoObject* ScriptParticleGpuSimulationSettings::Internal_getsizeScaleOverLifetime(ScriptParticleGpuSimulationSettings* thisPtr)
+	{
+		SPtr<TDistribution<Vector2>> tmp__output = bs_shared_ptr_new<TDistribution<Vector2>>();
+		*tmp__output = thisPtr->getInternal()->sizeScaleOverLifetime;
+
+		MonoObject* __output;
+		__output = ScriptTDistributionVector2::create(tmp__output);
+
+		return __output;
+	}
+
+	void ScriptParticleGpuSimulationSettings::Internal_setsizeScaleOverLifetime(ScriptParticleGpuSimulationSettings* thisPtr, MonoObject* value)
+	{
+		SPtr<TDistribution<Vector2>> tmpvalue;
+		ScriptTDistributionVector2* scriptvalue;
+		scriptvalue = ScriptTDistributionVector2::toNative(value);
+		tmpvalue = scriptvalue->getInternal();
+		thisPtr->getInternal()->sizeScaleOverLifetime = *tmpvalue;
+	}
+
+	void ScriptParticleGpuSimulationSettings::Internal_getacceleration(ScriptParticleGpuSimulationSettings* thisPtr, Vector3* __output)
+	{
+		Vector3 tmp__output;
+		tmp__output = thisPtr->getInternal()->acceleration;
+
+		*__output = tmp__output;
+
+
+	}
+
+	void ScriptParticleGpuSimulationSettings::Internal_setacceleration(ScriptParticleGpuSimulationSettings* thisPtr, Vector3* value)
+	{
+		thisPtr->getInternal()->acceleration = *value;
+	}
+
+	float ScriptParticleGpuSimulationSettings::Internal_getdrag(ScriptParticleGpuSimulationSettings* thisPtr)
+	{
+		float tmp__output;
+		tmp__output = thisPtr->getInternal()->drag;
+
+		float __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleGpuSimulationSettings::Internal_setdrag(ScriptParticleGpuSimulationSettings* thisPtr, float value)
+	{
+		thisPtr->getInternal()->drag = value;
+	}
+
+	MonoObject* ScriptParticleGpuSimulationSettings::Internal_getdepthCollision(ScriptParticleGpuSimulationSettings* thisPtr)
+	{
+		SPtr<ParticleDepthCollisionSettings> tmp__output = bs_shared_ptr_new<ParticleDepthCollisionSettings>();
+		*tmp__output = thisPtr->getInternal()->depthCollision;
+
+		MonoObject* __output;
+		__output = ScriptParticleDepthCollisionSettings::create(tmp__output);
+
+		return __output;
+	}
+
+	void ScriptParticleGpuSimulationSettings::Internal_setdepthCollision(ScriptParticleGpuSimulationSettings* thisPtr, MonoObject* value)
+	{
+		SPtr<ParticleDepthCollisionSettings> tmpvalue;
+		ScriptParticleDepthCollisionSettings* scriptvalue;
+		scriptvalue = ScriptParticleDepthCollisionSettings::toNative(value);
+		tmpvalue = scriptvalue->getInternal();
+		thisPtr->getInternal()->depthCollision = *tmpvalue;
+	}
+}

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

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptObject.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Particles/BsParticleSystem.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Particles/BsParticleSystem.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Particles/BsParticleDistribution.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Particles/BsParticleDistribution.h"
+#include "Math/BsVector3.h"
+
+namespace bs
+{
+	struct ParticleGpuSimulationSettings;
+
+	class BS_SCR_BE_EXPORT ScriptParticleGpuSimulationSettings : public ScriptObject<ScriptParticleGpuSimulationSettings>
+	{
+	public:
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "ParticleGpuSimulationSettings")
+
+		ScriptParticleGpuSimulationSettings(MonoObject* managedInstance, const SPtr<ParticleGpuSimulationSettings>& value);
+
+		SPtr<ParticleGpuSimulationSettings> getInternal() const { return mInternal; }
+		static MonoObject* create(const SPtr<ParticleGpuSimulationSettings>& value);
+
+	private:
+		SPtr<ParticleGpuSimulationSettings> mInternal;
+
+		static MonoObject* Internal_getvectorField(ScriptParticleGpuSimulationSettings* thisPtr);
+		static void Internal_setvectorField(ScriptParticleGpuSimulationSettings* thisPtr, MonoObject* value);
+		static MonoObject* Internal_getcolorOverLifetime(ScriptParticleGpuSimulationSettings* thisPtr);
+		static void Internal_setcolorOverLifetime(ScriptParticleGpuSimulationSettings* thisPtr, MonoObject* value);
+		static MonoObject* Internal_getsizeScaleOverLifetime(ScriptParticleGpuSimulationSettings* thisPtr);
+		static void Internal_setsizeScaleOverLifetime(ScriptParticleGpuSimulationSettings* thisPtr, MonoObject* value);
+		static void Internal_getacceleration(ScriptParticleGpuSimulationSettings* thisPtr, Vector3* __output);
+		static void Internal_setacceleration(ScriptParticleGpuSimulationSettings* thisPtr, Vector3* value);
+		static float Internal_getdrag(ScriptParticleGpuSimulationSettings* thisPtr);
+		static void Internal_setdrag(ScriptParticleGpuSimulationSettings* thisPtr, float value);
+		static MonoObject* Internal_getdepthCollision(ScriptParticleGpuSimulationSettings* thisPtr);
+		static void Internal_setdepthCollision(ScriptParticleGpuSimulationSettings* thisPtr, MonoObject* value);
+	};
+}

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

@@ -0,0 +1,339 @@
+#include "BsScriptParticleSystemSettings.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Particles/BsParticleSystem.h"
+#include "BsScriptResourceManager.h"
+#include "Wrappers/BsScriptRRefBase.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Material/BsMaterial.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Mesh/BsMesh.h"
+
+namespace bs
+{
+	ScriptParticleSystemSettings::ScriptParticleSystemSettings(MonoObject* managedInstance, const SPtr<ParticleSystemSettings>& value)
+		:ScriptObject(managedInstance), mInternal(value)
+	{
+	}
+
+	void ScriptParticleSystemSettings::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_getmaterial", (void*)&ScriptParticleSystemSettings::Internal_getmaterial);
+		metaData.scriptClass->addInternalCall("Internal_setmaterial", (void*)&ScriptParticleSystemSettings::Internal_setmaterial);
+		metaData.scriptClass->addInternalCall("Internal_getmesh", (void*)&ScriptParticleSystemSettings::Internal_getmesh);
+		metaData.scriptClass->addInternalCall("Internal_setmesh", (void*)&ScriptParticleSystemSettings::Internal_setmesh);
+		metaData.scriptClass->addInternalCall("Internal_getgpuSimulation", (void*)&ScriptParticleSystemSettings::Internal_getgpuSimulation);
+		metaData.scriptClass->addInternalCall("Internal_setgpuSimulation", (void*)&ScriptParticleSystemSettings::Internal_setgpuSimulation);
+		metaData.scriptClass->addInternalCall("Internal_getsimulationSpace", (void*)&ScriptParticleSystemSettings::Internal_getsimulationSpace);
+		metaData.scriptClass->addInternalCall("Internal_setsimulationSpace", (void*)&ScriptParticleSystemSettings::Internal_setsimulationSpace);
+		metaData.scriptClass->addInternalCall("Internal_getorientation", (void*)&ScriptParticleSystemSettings::Internal_getorientation);
+		metaData.scriptClass->addInternalCall("Internal_setorientation", (void*)&ScriptParticleSystemSettings::Internal_setorientation);
+		metaData.scriptClass->addInternalCall("Internal_getorientationLockY", (void*)&ScriptParticleSystemSettings::Internal_getorientationLockY);
+		metaData.scriptClass->addInternalCall("Internal_setorientationLockY", (void*)&ScriptParticleSystemSettings::Internal_setorientationLockY);
+		metaData.scriptClass->addInternalCall("Internal_getorientationPlane", (void*)&ScriptParticleSystemSettings::Internal_getorientationPlane);
+		metaData.scriptClass->addInternalCall("Internal_setorientationPlane", (void*)&ScriptParticleSystemSettings::Internal_setorientationPlane);
+		metaData.scriptClass->addInternalCall("Internal_getsortMode", (void*)&ScriptParticleSystemSettings::Internal_getsortMode);
+		metaData.scriptClass->addInternalCall("Internal_setsortMode", (void*)&ScriptParticleSystemSettings::Internal_setsortMode);
+		metaData.scriptClass->addInternalCall("Internal_getduration", (void*)&ScriptParticleSystemSettings::Internal_getduration);
+		metaData.scriptClass->addInternalCall("Internal_setduration", (void*)&ScriptParticleSystemSettings::Internal_setduration);
+		metaData.scriptClass->addInternalCall("Internal_getisLooping", (void*)&ScriptParticleSystemSettings::Internal_getisLooping);
+		metaData.scriptClass->addInternalCall("Internal_setisLooping", (void*)&ScriptParticleSystemSettings::Internal_setisLooping);
+		metaData.scriptClass->addInternalCall("Internal_getmaxParticles", (void*)&ScriptParticleSystemSettings::Internal_getmaxParticles);
+		metaData.scriptClass->addInternalCall("Internal_setmaxParticles", (void*)&ScriptParticleSystemSettings::Internal_setmaxParticles);
+		metaData.scriptClass->addInternalCall("Internal_getuseAutomaticSeed", (void*)&ScriptParticleSystemSettings::Internal_getuseAutomaticSeed);
+		metaData.scriptClass->addInternalCall("Internal_setuseAutomaticSeed", (void*)&ScriptParticleSystemSettings::Internal_setuseAutomaticSeed);
+		metaData.scriptClass->addInternalCall("Internal_getmanualSeed", (void*)&ScriptParticleSystemSettings::Internal_getmanualSeed);
+		metaData.scriptClass->addInternalCall("Internal_setmanualSeed", (void*)&ScriptParticleSystemSettings::Internal_setmanualSeed);
+		metaData.scriptClass->addInternalCall("Internal_getuseAutomaticBounds", (void*)&ScriptParticleSystemSettings::Internal_getuseAutomaticBounds);
+		metaData.scriptClass->addInternalCall("Internal_setuseAutomaticBounds", (void*)&ScriptParticleSystemSettings::Internal_setuseAutomaticBounds);
+		metaData.scriptClass->addInternalCall("Internal_getcustomBounds", (void*)&ScriptParticleSystemSettings::Internal_getcustomBounds);
+		metaData.scriptClass->addInternalCall("Internal_setcustomBounds", (void*)&ScriptParticleSystemSettings::Internal_setcustomBounds);
+		metaData.scriptClass->addInternalCall("Internal_getrenderMode", (void*)&ScriptParticleSystemSettings::Internal_getrenderMode);
+		metaData.scriptClass->addInternalCall("Internal_setrenderMode", (void*)&ScriptParticleSystemSettings::Internal_setrenderMode);
+
+	}
+
+	MonoObject* ScriptParticleSystemSettings::create(const SPtr<ParticleSystemSettings>& value)
+	{
+		if(value == nullptr) return nullptr; 
+
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance("bool", ctorParams);
+		new (bs_alloc<ScriptParticleSystemSettings>()) ScriptParticleSystemSettings(managedInstance, value);
+		return managedInstance;
+	}
+	MonoObject* ScriptParticleSystemSettings::Internal_getmaterial(ScriptParticleSystemSettings* thisPtr)
+	{
+		ResourceHandle<Material> tmp__output;
+		tmp__output = thisPtr->getInternal()->material;
+
+		MonoObject* __output;
+		ScriptRRefBase* script__output;
+		script__output = ScriptResourceManager::instance().getScriptRRef(tmp__output);
+		if(script__output != nullptr)
+			__output = script__output->getManagedInstance();
+		else
+			__output = nullptr;
+
+		return __output;
+	}
+
+	void ScriptParticleSystemSettings::Internal_setmaterial(ScriptParticleSystemSettings* thisPtr, MonoObject* value)
+	{
+		ResourceHandle<Material> tmpvalue;
+		ScriptRRefBase* scriptvalue;
+		scriptvalue = ScriptRRefBase::toNative(value);
+		if(scriptvalue != nullptr)
+			tmpvalue = static_resource_cast<Material>(scriptvalue->getHandle());
+		thisPtr->getInternal()->material = tmpvalue;
+	}
+
+	MonoObject* ScriptParticleSystemSettings::Internal_getmesh(ScriptParticleSystemSettings* thisPtr)
+	{
+		ResourceHandle<Mesh> tmp__output;
+		tmp__output = thisPtr->getInternal()->mesh;
+
+		MonoObject* __output;
+		ScriptRRefBase* script__output;
+		script__output = ScriptResourceManager::instance().getScriptRRef(tmp__output);
+		if(script__output != nullptr)
+			__output = script__output->getManagedInstance();
+		else
+			__output = nullptr;
+
+		return __output;
+	}
+
+	void ScriptParticleSystemSettings::Internal_setmesh(ScriptParticleSystemSettings* thisPtr, MonoObject* value)
+	{
+		ResourceHandle<Mesh> tmpvalue;
+		ScriptRRefBase* scriptvalue;
+		scriptvalue = ScriptRRefBase::toNative(value);
+		if(scriptvalue != nullptr)
+			tmpvalue = static_resource_cast<Mesh>(scriptvalue->getHandle());
+		thisPtr->getInternal()->mesh = tmpvalue;
+	}
+
+	bool ScriptParticleSystemSettings::Internal_getgpuSimulation(ScriptParticleSystemSettings* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->gpuSimulation;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleSystemSettings::Internal_setgpuSimulation(ScriptParticleSystemSettings* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->gpuSimulation = value;
+	}
+
+	ParticleSimulationSpace ScriptParticleSystemSettings::Internal_getsimulationSpace(ScriptParticleSystemSettings* thisPtr)
+	{
+		ParticleSimulationSpace tmp__output;
+		tmp__output = thisPtr->getInternal()->simulationSpace;
+
+		ParticleSimulationSpace __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleSystemSettings::Internal_setsimulationSpace(ScriptParticleSystemSettings* thisPtr, ParticleSimulationSpace value)
+	{
+		thisPtr->getInternal()->simulationSpace = value;
+	}
+
+	ParticleOrientation ScriptParticleSystemSettings::Internal_getorientation(ScriptParticleSystemSettings* thisPtr)
+	{
+		ParticleOrientation tmp__output;
+		tmp__output = thisPtr->getInternal()->orientation;
+
+		ParticleOrientation __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleSystemSettings::Internal_setorientation(ScriptParticleSystemSettings* thisPtr, ParticleOrientation value)
+	{
+		thisPtr->getInternal()->orientation = value;
+	}
+
+	bool ScriptParticleSystemSettings::Internal_getorientationLockY(ScriptParticleSystemSettings* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->orientationLockY;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleSystemSettings::Internal_setorientationLockY(ScriptParticleSystemSettings* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->orientationLockY = value;
+	}
+
+	void ScriptParticleSystemSettings::Internal_getorientationPlane(ScriptParticleSystemSettings* thisPtr, Plane* __output)
+	{
+		Plane tmp__output;
+		tmp__output = thisPtr->getInternal()->orientationPlane;
+
+		*__output = tmp__output;
+
+
+	}
+
+	void ScriptParticleSystemSettings::Internal_setorientationPlane(ScriptParticleSystemSettings* thisPtr, Plane* value)
+	{
+		thisPtr->getInternal()->orientationPlane = *value;
+	}
+
+	ParticleSortMode ScriptParticleSystemSettings::Internal_getsortMode(ScriptParticleSystemSettings* thisPtr)
+	{
+		ParticleSortMode tmp__output;
+		tmp__output = thisPtr->getInternal()->sortMode;
+
+		ParticleSortMode __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleSystemSettings::Internal_setsortMode(ScriptParticleSystemSettings* thisPtr, ParticleSortMode value)
+	{
+		thisPtr->getInternal()->sortMode = value;
+	}
+
+	float ScriptParticleSystemSettings::Internal_getduration(ScriptParticleSystemSettings* thisPtr)
+	{
+		float tmp__output;
+		tmp__output = thisPtr->getInternal()->duration;
+
+		float __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleSystemSettings::Internal_setduration(ScriptParticleSystemSettings* thisPtr, float value)
+	{
+		thisPtr->getInternal()->duration = value;
+	}
+
+	bool ScriptParticleSystemSettings::Internal_getisLooping(ScriptParticleSystemSettings* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->isLooping;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleSystemSettings::Internal_setisLooping(ScriptParticleSystemSettings* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->isLooping = value;
+	}
+
+	uint32_t ScriptParticleSystemSettings::Internal_getmaxParticles(ScriptParticleSystemSettings* thisPtr)
+	{
+		uint32_t tmp__output;
+		tmp__output = thisPtr->getInternal()->maxParticles;
+
+		uint32_t __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleSystemSettings::Internal_setmaxParticles(ScriptParticleSystemSettings* thisPtr, uint32_t value)
+	{
+		thisPtr->getInternal()->maxParticles = value;
+	}
+
+	bool ScriptParticleSystemSettings::Internal_getuseAutomaticSeed(ScriptParticleSystemSettings* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->useAutomaticSeed;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleSystemSettings::Internal_setuseAutomaticSeed(ScriptParticleSystemSettings* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->useAutomaticSeed = value;
+	}
+
+	uint32_t ScriptParticleSystemSettings::Internal_getmanualSeed(ScriptParticleSystemSettings* thisPtr)
+	{
+		uint32_t tmp__output;
+		tmp__output = thisPtr->getInternal()->manualSeed;
+
+		uint32_t __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleSystemSettings::Internal_setmanualSeed(ScriptParticleSystemSettings* thisPtr, uint32_t value)
+	{
+		thisPtr->getInternal()->manualSeed = value;
+	}
+
+	bool ScriptParticleSystemSettings::Internal_getuseAutomaticBounds(ScriptParticleSystemSettings* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->useAutomaticBounds;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleSystemSettings::Internal_setuseAutomaticBounds(ScriptParticleSystemSettings* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->useAutomaticBounds = value;
+	}
+
+	void ScriptParticleSystemSettings::Internal_getcustomBounds(ScriptParticleSystemSettings* thisPtr, AABox* __output)
+	{
+		AABox tmp__output;
+		tmp__output = thisPtr->getInternal()->customBounds;
+
+		*__output = tmp__output;
+
+
+	}
+
+	void ScriptParticleSystemSettings::Internal_setcustomBounds(ScriptParticleSystemSettings* thisPtr, AABox* value)
+	{
+		thisPtr->getInternal()->customBounds = *value;
+	}
+
+	ParticleRenderMode ScriptParticleSystemSettings::Internal_getrenderMode(ScriptParticleSystemSettings* thisPtr)
+	{
+		ParticleRenderMode tmp__output;
+		tmp__output = thisPtr->getInternal()->renderMode;
+
+		ParticleRenderMode __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleSystemSettings::Internal_setrenderMode(ScriptParticleSystemSettings* thisPtr, ParticleRenderMode value)
+	{
+		thisPtr->getInternal()->renderMode = value;
+	}
+}

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

@@ -0,0 +1,64 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptObject.h"
+#include "Math/BsAABox.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Particles/BsParticleSystem.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Particles/BsParticleSystem.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Particles/BsParticleSystem.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Particles/BsParticleSystem.h"
+#include "Math/BsPlane.h"
+
+namespace bs
+{
+	struct ParticleSystemSettings;
+	class Material;
+	class Mesh;
+
+	class BS_SCR_BE_EXPORT ScriptParticleSystemSettings : public ScriptObject<ScriptParticleSystemSettings>
+	{
+	public:
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "ParticleSystemSettings")
+
+		ScriptParticleSystemSettings(MonoObject* managedInstance, const SPtr<ParticleSystemSettings>& value);
+
+		SPtr<ParticleSystemSettings> getInternal() const { return mInternal; }
+		static MonoObject* create(const SPtr<ParticleSystemSettings>& value);
+
+	private:
+		SPtr<ParticleSystemSettings> mInternal;
+
+		static MonoObject* Internal_getmaterial(ScriptParticleSystemSettings* thisPtr);
+		static void Internal_setmaterial(ScriptParticleSystemSettings* thisPtr, MonoObject* value);
+		static MonoObject* Internal_getmesh(ScriptParticleSystemSettings* thisPtr);
+		static void Internal_setmesh(ScriptParticleSystemSettings* thisPtr, MonoObject* value);
+		static bool Internal_getgpuSimulation(ScriptParticleSystemSettings* thisPtr);
+		static void Internal_setgpuSimulation(ScriptParticleSystemSettings* thisPtr, bool value);
+		static ParticleSimulationSpace Internal_getsimulationSpace(ScriptParticleSystemSettings* thisPtr);
+		static void Internal_setsimulationSpace(ScriptParticleSystemSettings* thisPtr, ParticleSimulationSpace value);
+		static ParticleOrientation Internal_getorientation(ScriptParticleSystemSettings* thisPtr);
+		static void Internal_setorientation(ScriptParticleSystemSettings* thisPtr, ParticleOrientation value);
+		static bool Internal_getorientationLockY(ScriptParticleSystemSettings* thisPtr);
+		static void Internal_setorientationLockY(ScriptParticleSystemSettings* thisPtr, bool value);
+		static void Internal_getorientationPlane(ScriptParticleSystemSettings* thisPtr, Plane* __output);
+		static void Internal_setorientationPlane(ScriptParticleSystemSettings* thisPtr, Plane* value);
+		static ParticleSortMode Internal_getsortMode(ScriptParticleSystemSettings* thisPtr);
+		static void Internal_setsortMode(ScriptParticleSystemSettings* thisPtr, ParticleSortMode value);
+		static float Internal_getduration(ScriptParticleSystemSettings* thisPtr);
+		static void Internal_setduration(ScriptParticleSystemSettings* thisPtr, float value);
+		static bool Internal_getisLooping(ScriptParticleSystemSettings* thisPtr);
+		static void Internal_setisLooping(ScriptParticleSystemSettings* thisPtr, bool value);
+		static uint32_t Internal_getmaxParticles(ScriptParticleSystemSettings* thisPtr);
+		static void Internal_setmaxParticles(ScriptParticleSystemSettings* thisPtr, uint32_t value);
+		static bool Internal_getuseAutomaticSeed(ScriptParticleSystemSettings* thisPtr);
+		static void Internal_setuseAutomaticSeed(ScriptParticleSystemSettings* thisPtr, bool value);
+		static uint32_t Internal_getmanualSeed(ScriptParticleSystemSettings* thisPtr);
+		static void Internal_setmanualSeed(ScriptParticleSystemSettings* thisPtr, uint32_t value);
+		static bool Internal_getuseAutomaticBounds(ScriptParticleSystemSettings* thisPtr);
+		static void Internal_setuseAutomaticBounds(ScriptParticleSystemSettings* thisPtr, bool value);
+		static void Internal_getcustomBounds(ScriptParticleSystemSettings* thisPtr, AABox* __output);
+		static void Internal_setcustomBounds(ScriptParticleSystemSettings* thisPtr, AABox* value);
+		static ParticleRenderMode Internal_getrenderMode(ScriptParticleSystemSettings* thisPtr);
+		static void Internal_setrenderMode(ScriptParticleSystemSettings* thisPtr, ParticleRenderMode value);
+	};
+}

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

@@ -0,0 +1,226 @@
+#include "BsScriptParticleVectorFieldSettings.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Particles/BsParticleSystem.h"
+#include "BsScriptResourceManager.h"
+#include "Wrappers/BsScriptRRefBase.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Particles/BsVectorField.h"
+#include "Wrappers/BsScriptVector.h"
+#include "BsScriptTDistribution.generated.h"
+#include "Wrappers/BsScriptQuaternion.h"
+
+namespace bs
+{
+	ScriptParticleVectorFieldSettings::ScriptParticleVectorFieldSettings(MonoObject* managedInstance, const SPtr<ParticleVectorFieldSettings>& value)
+		:ScriptObject(managedInstance), mInternal(value)
+	{
+	}
+
+	void ScriptParticleVectorFieldSettings::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_getvectorField", (void*)&ScriptParticleVectorFieldSettings::Internal_getvectorField);
+		metaData.scriptClass->addInternalCall("Internal_setvectorField", (void*)&ScriptParticleVectorFieldSettings::Internal_setvectorField);
+		metaData.scriptClass->addInternalCall("Internal_getintensity", (void*)&ScriptParticleVectorFieldSettings::Internal_getintensity);
+		metaData.scriptClass->addInternalCall("Internal_setintensity", (void*)&ScriptParticleVectorFieldSettings::Internal_setintensity);
+		metaData.scriptClass->addInternalCall("Internal_gettightness", (void*)&ScriptParticleVectorFieldSettings::Internal_gettightness);
+		metaData.scriptClass->addInternalCall("Internal_settightness", (void*)&ScriptParticleVectorFieldSettings::Internal_settightness);
+		metaData.scriptClass->addInternalCall("Internal_getscale", (void*)&ScriptParticleVectorFieldSettings::Internal_getscale);
+		metaData.scriptClass->addInternalCall("Internal_setscale", (void*)&ScriptParticleVectorFieldSettings::Internal_setscale);
+		metaData.scriptClass->addInternalCall("Internal_getoffset", (void*)&ScriptParticleVectorFieldSettings::Internal_getoffset);
+		metaData.scriptClass->addInternalCall("Internal_setoffset", (void*)&ScriptParticleVectorFieldSettings::Internal_setoffset);
+		metaData.scriptClass->addInternalCall("Internal_getrotation", (void*)&ScriptParticleVectorFieldSettings::Internal_getrotation);
+		metaData.scriptClass->addInternalCall("Internal_setrotation", (void*)&ScriptParticleVectorFieldSettings::Internal_setrotation);
+		metaData.scriptClass->addInternalCall("Internal_getrotationRate", (void*)&ScriptParticleVectorFieldSettings::Internal_getrotationRate);
+		metaData.scriptClass->addInternalCall("Internal_setrotationRate", (void*)&ScriptParticleVectorFieldSettings::Internal_setrotationRate);
+		metaData.scriptClass->addInternalCall("Internal_gettilingX", (void*)&ScriptParticleVectorFieldSettings::Internal_gettilingX);
+		metaData.scriptClass->addInternalCall("Internal_settilingX", (void*)&ScriptParticleVectorFieldSettings::Internal_settilingX);
+		metaData.scriptClass->addInternalCall("Internal_gettilingY", (void*)&ScriptParticleVectorFieldSettings::Internal_gettilingY);
+		metaData.scriptClass->addInternalCall("Internal_settilingY", (void*)&ScriptParticleVectorFieldSettings::Internal_settilingY);
+		metaData.scriptClass->addInternalCall("Internal_gettilingZ", (void*)&ScriptParticleVectorFieldSettings::Internal_gettilingZ);
+		metaData.scriptClass->addInternalCall("Internal_settilingZ", (void*)&ScriptParticleVectorFieldSettings::Internal_settilingZ);
+
+	}
+
+	MonoObject* ScriptParticleVectorFieldSettings::create(const SPtr<ParticleVectorFieldSettings>& value)
+	{
+		if(value == nullptr) return nullptr; 
+
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		MonoObject* managedInstance = metaData.scriptClass->createInstance("bool", ctorParams);
+		new (bs_alloc<ScriptParticleVectorFieldSettings>()) ScriptParticleVectorFieldSettings(managedInstance, value);
+		return managedInstance;
+	}
+	MonoObject* ScriptParticleVectorFieldSettings::Internal_getvectorField(ScriptParticleVectorFieldSettings* thisPtr)
+	{
+		ResourceHandle<VectorField> tmp__output;
+		tmp__output = thisPtr->getInternal()->vectorField;
+
+		MonoObject* __output;
+		ScriptRRefBase* script__output;
+		script__output = ScriptResourceManager::instance().getScriptRRef(tmp__output);
+		if(script__output != nullptr)
+			__output = script__output->getManagedInstance();
+		else
+			__output = nullptr;
+
+		return __output;
+	}
+
+	void ScriptParticleVectorFieldSettings::Internal_setvectorField(ScriptParticleVectorFieldSettings* thisPtr, MonoObject* value)
+	{
+		ResourceHandle<VectorField> tmpvalue;
+		ScriptRRefBase* scriptvalue;
+		scriptvalue = ScriptRRefBase::toNative(value);
+		if(scriptvalue != nullptr)
+			tmpvalue = static_resource_cast<VectorField>(scriptvalue->getHandle());
+		thisPtr->getInternal()->vectorField = tmpvalue;
+	}
+
+	float ScriptParticleVectorFieldSettings::Internal_getintensity(ScriptParticleVectorFieldSettings* thisPtr)
+	{
+		float tmp__output;
+		tmp__output = thisPtr->getInternal()->intensity;
+
+		float __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleVectorFieldSettings::Internal_setintensity(ScriptParticleVectorFieldSettings* thisPtr, float value)
+	{
+		thisPtr->getInternal()->intensity = value;
+	}
+
+	float ScriptParticleVectorFieldSettings::Internal_gettightness(ScriptParticleVectorFieldSettings* thisPtr)
+	{
+		float tmp__output;
+		tmp__output = thisPtr->getInternal()->tightness;
+
+		float __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleVectorFieldSettings::Internal_settightness(ScriptParticleVectorFieldSettings* thisPtr, float value)
+	{
+		thisPtr->getInternal()->tightness = value;
+	}
+
+	void ScriptParticleVectorFieldSettings::Internal_getscale(ScriptParticleVectorFieldSettings* thisPtr, Vector3* __output)
+	{
+		Vector3 tmp__output;
+		tmp__output = thisPtr->getInternal()->scale;
+
+		*__output = tmp__output;
+
+
+	}
+
+	void ScriptParticleVectorFieldSettings::Internal_setscale(ScriptParticleVectorFieldSettings* thisPtr, Vector3* value)
+	{
+		thisPtr->getInternal()->scale = *value;
+	}
+
+	void ScriptParticleVectorFieldSettings::Internal_getoffset(ScriptParticleVectorFieldSettings* thisPtr, Vector3* __output)
+	{
+		Vector3 tmp__output;
+		tmp__output = thisPtr->getInternal()->offset;
+
+		*__output = tmp__output;
+
+
+	}
+
+	void ScriptParticleVectorFieldSettings::Internal_setoffset(ScriptParticleVectorFieldSettings* thisPtr, Vector3* value)
+	{
+		thisPtr->getInternal()->offset = *value;
+	}
+
+	void ScriptParticleVectorFieldSettings::Internal_getrotation(ScriptParticleVectorFieldSettings* thisPtr, Quaternion* __output)
+	{
+		Quaternion tmp__output;
+		tmp__output = thisPtr->getInternal()->rotation;
+
+		*__output = tmp__output;
+
+
+	}
+
+	void ScriptParticleVectorFieldSettings::Internal_setrotation(ScriptParticleVectorFieldSettings* thisPtr, Quaternion* value)
+	{
+		thisPtr->getInternal()->rotation = *value;
+	}
+
+	MonoObject* ScriptParticleVectorFieldSettings::Internal_getrotationRate(ScriptParticleVectorFieldSettings* thisPtr)
+	{
+		SPtr<TDistribution<Vector3>> tmp__output = bs_shared_ptr_new<TDistribution<Vector3>>();
+		*tmp__output = thisPtr->getInternal()->rotationRate;
+
+		MonoObject* __output;
+		__output = ScriptTDistributionVector3::create(tmp__output);
+
+		return __output;
+	}
+
+	void ScriptParticleVectorFieldSettings::Internal_setrotationRate(ScriptParticleVectorFieldSettings* thisPtr, MonoObject* value)
+	{
+		SPtr<TDistribution<Vector3>> tmpvalue;
+		ScriptTDistributionVector3* scriptvalue;
+		scriptvalue = ScriptTDistributionVector3::toNative(value);
+		tmpvalue = scriptvalue->getInternal();
+		thisPtr->getInternal()->rotationRate = *tmpvalue;
+	}
+
+	bool ScriptParticleVectorFieldSettings::Internal_gettilingX(ScriptParticleVectorFieldSettings* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->tilingX;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleVectorFieldSettings::Internal_settilingX(ScriptParticleVectorFieldSettings* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->tilingX = value;
+	}
+
+	bool ScriptParticleVectorFieldSettings::Internal_gettilingY(ScriptParticleVectorFieldSettings* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->tilingY;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleVectorFieldSettings::Internal_settilingY(ScriptParticleVectorFieldSettings* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->tilingY = value;
+	}
+
+	bool ScriptParticleVectorFieldSettings::Internal_gettilingZ(ScriptParticleVectorFieldSettings* thisPtr)
+	{
+		bool tmp__output;
+		tmp__output = thisPtr->getInternal()->tilingZ;
+
+		bool __output;
+		__output = tmp__output;
+
+		return __output;
+	}
+
+	void ScriptParticleVectorFieldSettings::Internal_settilingZ(ScriptParticleVectorFieldSettings* thisPtr, bool value)
+	{
+		thisPtr->getInternal()->tilingZ = value;
+	}
+}

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

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptObject.h"
+#include "Math/BsVector3.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Particles/BsParticleDistribution.h"
+#include "Math/BsQuaternion.h"
+
+namespace bs
+{
+	struct ParticleVectorFieldSettings;
+	class VectorField;
+
+	class BS_SCR_BE_EXPORT ScriptParticleVectorFieldSettings : public ScriptObject<ScriptParticleVectorFieldSettings>
+	{
+	public:
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "ParticleVectorFieldSettings")
+
+		ScriptParticleVectorFieldSettings(MonoObject* managedInstance, const SPtr<ParticleVectorFieldSettings>& value);
+
+		SPtr<ParticleVectorFieldSettings> getInternal() const { return mInternal; }
+		static MonoObject* create(const SPtr<ParticleVectorFieldSettings>& value);
+
+	private:
+		SPtr<ParticleVectorFieldSettings> mInternal;
+
+		static MonoObject* Internal_getvectorField(ScriptParticleVectorFieldSettings* thisPtr);
+		static void Internal_setvectorField(ScriptParticleVectorFieldSettings* thisPtr, MonoObject* value);
+		static float Internal_getintensity(ScriptParticleVectorFieldSettings* thisPtr);
+		static void Internal_setintensity(ScriptParticleVectorFieldSettings* thisPtr, float value);
+		static float Internal_gettightness(ScriptParticleVectorFieldSettings* thisPtr);
+		static void Internal_settightness(ScriptParticleVectorFieldSettings* thisPtr, float value);
+		static void Internal_getscale(ScriptParticleVectorFieldSettings* thisPtr, Vector3* __output);
+		static void Internal_setscale(ScriptParticleVectorFieldSettings* thisPtr, Vector3* value);
+		static void Internal_getoffset(ScriptParticleVectorFieldSettings* thisPtr, Vector3* __output);
+		static void Internal_setoffset(ScriptParticleVectorFieldSettings* thisPtr, Vector3* value);
+		static void Internal_getrotation(ScriptParticleVectorFieldSettings* thisPtr, Quaternion* __output);
+		static void Internal_setrotation(ScriptParticleVectorFieldSettings* thisPtr, Quaternion* value);
+		static MonoObject* Internal_getrotationRate(ScriptParticleVectorFieldSettings* thisPtr);
+		static void Internal_setrotationRate(ScriptParticleVectorFieldSettings* thisPtr, MonoObject* value);
+		static bool Internal_gettilingX(ScriptParticleVectorFieldSettings* thisPtr);
+		static void Internal_settilingX(ScriptParticleVectorFieldSettings* thisPtr, bool value);
+		static bool Internal_gettilingY(ScriptParticleVectorFieldSettings* thisPtr);
+		static void Internal_settilingY(ScriptParticleVectorFieldSettings* thisPtr, bool value);
+		static bool Internal_gettilingZ(ScriptParticleVectorFieldSettings* thisPtr);
+		static void Internal_settilingZ(ScriptParticleVectorFieldSettings* thisPtr, bool value);
+	};
+}

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

@@ -5,11 +5,12 @@
 #include "../../../bsf/Source/Foundation/bsfCore/Renderer/BsRenderSettings.h"
 #include "BsScriptAutoExposureSettings.generated.h"
 #include "BsScriptShadowSettings.generated.h"
-#include "BsScriptScreenSpaceReflectionsSettings.generated.h"
 #include "BsScriptTonemappingSettings.generated.h"
+#include "BsScriptScreenSpaceReflectionsSettings.generated.h"
 #include "BsScriptWhiteBalanceSettings.generated.h"
 #include "BsScriptColorGradingSettings.generated.h"
 #include "BsScriptDepthOfFieldSettings.generated.h"
+#include "BsScriptBloomSettings.generated.h"
 #include "BsScriptAmbientOcclusionSettings.generated.h"
 
 namespace bs
@@ -40,6 +41,8 @@ namespace bs
 		metaData.scriptClass->addInternalCall("Internal_setambientOcclusion", (void*)&ScriptRenderSettings::Internal_setambientOcclusion);
 		metaData.scriptClass->addInternalCall("Internal_getscreenSpaceReflections", (void*)&ScriptRenderSettings::Internal_getscreenSpaceReflections);
 		metaData.scriptClass->addInternalCall("Internal_setscreenSpaceReflections", (void*)&ScriptRenderSettings::Internal_setscreenSpaceReflections);
+		metaData.scriptClass->addInternalCall("Internal_getbloom", (void*)&ScriptRenderSettings::Internal_getbloom);
+		metaData.scriptClass->addInternalCall("Internal_setbloom", (void*)&ScriptRenderSettings::Internal_setbloom);
 		metaData.scriptClass->addInternalCall("Internal_getenableFXAA", (void*)&ScriptRenderSettings::Internal_getenableFXAA);
 		metaData.scriptClass->addInternalCall("Internal_setenableFXAA", (void*)&ScriptRenderSettings::Internal_setenableFXAA);
 		metaData.scriptClass->addInternalCall("Internal_getexposureScale", (void*)&ScriptRenderSettings::Internal_getexposureScale);
@@ -252,6 +255,26 @@ namespace bs
 		thisPtr->getInternal()->screenSpaceReflections = *tmpvalue;
 	}
 
+	MonoObject* ScriptRenderSettings::Internal_getbloom(ScriptRenderSettings* thisPtr)
+	{
+		SPtr<BloomSettings> tmp__output = bs_shared_ptr_new<BloomSettings>();
+		*tmp__output = thisPtr->getInternal()->bloom;
+
+		MonoObject* __output;
+		__output = ScriptBloomSettings::create(tmp__output);
+
+		return __output;
+	}
+
+	void ScriptRenderSettings::Internal_setbloom(ScriptRenderSettings* thisPtr, MonoObject* value)
+	{
+		SPtr<BloomSettings> tmpvalue;
+		ScriptBloomSettings* scriptvalue;
+		scriptvalue = ScriptBloomSettings::toNative(value);
+		tmpvalue = scriptvalue->getInternal();
+		thisPtr->getInternal()->bloom = *tmpvalue;
+	}
+
 	bool ScriptRenderSettings::Internal_getenableFXAA(ScriptRenderSettings* thisPtr)
 	{
 		bool tmp__output;

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

@@ -10,6 +10,7 @@
 #include "../../../bsf/Source/Foundation/bsfCore/Renderer/BsRenderSettings.h"
 #include "../../../bsf/Source/Foundation/bsfCore/Renderer/BsRenderSettings.h"
 #include "../../../bsf/Source/Foundation/bsfCore/Renderer/BsRenderSettings.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Renderer/BsRenderSettings.h"
 
 namespace bs
 {
@@ -47,6 +48,8 @@ namespace bs
 		static void Internal_setambientOcclusion(ScriptRenderSettings* thisPtr, MonoObject* value);
 		static MonoObject* Internal_getscreenSpaceReflections(ScriptRenderSettings* thisPtr);
 		static void Internal_setscreenSpaceReflections(ScriptRenderSettings* thisPtr, MonoObject* value);
+		static MonoObject* Internal_getbloom(ScriptRenderSettings* thisPtr);
+		static void Internal_setbloom(ScriptRenderSettings* thisPtr, MonoObject* value);
 		static bool Internal_getenableFXAA(ScriptRenderSettings* thisPtr);
 		static void Internal_setenableFXAA(ScriptRenderSettings* thisPtr, bool value);
 		static float Internal_getexposureScale(ScriptRenderSettings* thisPtr);

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

@@ -0,0 +1,32 @@
+#include "BsScriptVectorField.generated.h"
+#include "BsMonoMethod.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "../../../bsf/Source/Foundation/bsfCore/Particles/BsVectorField.h"
+
+namespace bs
+{
+	ScriptVectorField::ScriptVectorField(MonoObject* managedInstance, const ResourceHandle<VectorField>& value)
+		:TScriptResource(managedInstance, value)
+	{
+	}
+
+	void ScriptVectorField::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_GetRef", (void*)&ScriptVectorField::Internal_getRef);
+
+	}
+
+	 MonoObject*ScriptVectorField::createInstance()
+	{
+		bool dummy = false;
+		void* ctorParams[1] = { &dummy };
+
+		return metaData.scriptClass->createInstance("bool", ctorParams);
+	}
+	MonoObject* ScriptVectorField::Internal_getRef(ScriptVectorField* thisPtr)
+	{
+		return thisPtr->getRRef();
+	}
+
+}

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

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "Wrappers/BsScriptResource.h"
+
+namespace bs
+{
+	class VectorField;
+
+	class BS_SCR_BE_EXPORT ScriptVectorField : public TScriptResource<ScriptVectorField, VectorField>
+	{
+	public:
+		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "VectorField")
+
+		ScriptVectorField(MonoObject* managedInstance, const ResourceHandle<VectorField>& value);
+
+		static MonoObject* createInstance();
+
+	private:
+		static MonoObject* Internal_getRef(ScriptVectorField* thisPtr);
+
+	};
+}

Source/Scripting/SBansheeEngine/Serialization/BsScriptAssemblyManager.cpp

@@ -28,6 +28,7 @@
 #include "Physics/BsPhysicsMesh.h"
 #include "Audio/BsAudioClip.h"
 #include "Animation/BsAnimationClip.h"
+#include "Particles/BsVectorField.h"
 
 #include "BsScriptTexture.generated.h"
 #include "Wrappers/BsScriptPlainText.h"
@@ -47,6 +48,7 @@
 #include "BsScriptFont.generated.h"
 #include "BsScriptSpriteTexture.generated.h"
 #include "BsScriptStringTable.generated.h"
+#include "BsScriptVectorField.generated.h"
 #include "Wrappers/BsScriptRRefBase.h"
 
 namespace bs
@@ -68,6 +70,7 @@ namespace bs
 		ADD_ENTRY(PhysicsMesh, ScriptPhysicsMesh, ScriptResourceType::PhysicsMesh)
 		ADD_ENTRY(AudioClip, ScriptAudioClip, ScriptResourceType::AudioClip)
 		ADD_ENTRY(AnimationClip, ScriptAnimationClip, ScriptResourceType::AnimationClip)
+		ADD_ENTRY(VectorField, ScriptVectorField, ScriptResourceType::VectorField)
 	LOOKUP_END
 
 #undef LOOKUP_BEGIN

Source/bsf

@@ -1 +1 @@
-Subproject commit 0c6a549dcb437e3eb972174b7f173051d5edc798
+Subproject commit 28485cc1a61082b82f895ee3731eeaea0e7695c4