urho3d.UrhoSharp/Bindings/Portable/Generated/ParticleEffect2D.cs

// WARNING - AUTOGENERATED - DO NOT EDIT
// 
// Generated using `sharpie urho`
// 
// ParticleEffect2D.cs
// 
// Copyright 2015 Xamarin Inc. All rights reserved.

using System;
using System.Runtime.InteropServices;
using System.Collections.Generic;
using Urho.Urho2D;
using Urho.Gui;
using Urho.Resources;
using Urho.IO;
using Urho.Navigation;
using Urho.Network;

namespace Urho.Urho2D
{
	/// <summary>
	/// 2D particle effect resource.
	/// </summary>
	public unsafe partial class ParticleEffect2D : Resource
	{
		unsafe partial void OnParticleEffect2DCreated ();

		[Preserve]
		public ParticleEffect2D (IntPtr handle) : base (handle)
		{
			OnParticleEffect2DCreated ();
		}

		[Preserve]
		protected ParticleEffect2D (UrhoObjectFlag emptyFlag) : base (emptyFlag)
		{
			OnParticleEffect2DCreated ();
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern int ParticleEffect2D_GetType (IntPtr handle);

		private StringHash UrhoGetType ()
		{
			Runtime.ValidateRefCounted (this);
			return new StringHash (ParticleEffect2D_GetType (handle));
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr ParticleEffect2D_GetTypeName (IntPtr handle);

		private string GetTypeName ()
		{
			Runtime.ValidateRefCounted (this);
			return Marshal.PtrToStringAnsi (ParticleEffect2D_GetTypeName (handle));
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern int ParticleEffect2D_GetTypeStatic ();

		private static StringHash GetTypeStatic ()
		{
			Runtime.Validate (typeof(ParticleEffect2D));
			return new StringHash (ParticleEffect2D_GetTypeStatic ());
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr ParticleEffect2D_GetTypeNameStatic ();

		private static string GetTypeNameStatic ()
		{
			Runtime.Validate (typeof(ParticleEffect2D));
			return Marshal.PtrToStringAnsi (ParticleEffect2D_GetTypeNameStatic ());
		}

		[Preserve]
		public ParticleEffect2D () : this (Application.CurrentContext)
		{
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr ParticleEffect2D_ParticleEffect2D (IntPtr context);

		[Preserve]
		public ParticleEffect2D (Context context) : base (UrhoObjectFlag.Empty)
		{
			Runtime.Validate (typeof(ParticleEffect2D));
			handle = ParticleEffect2D_ParticleEffect2D ((object)context == null ? IntPtr.Zero : context.Handle);
			Runtime.RegisterObject (this);
			OnParticleEffect2DCreated ();
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_RegisterObject (IntPtr context);

		/// <summary>
		/// Register object factory. Drawable2D must be registered first.
		/// </summary>
		public static void RegisterObject (Context context)
		{
			Runtime.Validate (typeof(ParticleEffect2D));
			ParticleEffect2D_RegisterObject ((object)context == null ? IntPtr.Zero : context.Handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern bool ParticleEffect2D_BeginLoad_File (IntPtr handle, IntPtr source);

		/// <summary>
		/// Load resource from stream. May be called from a worker thread. Return true if successful.
		/// </summary>
		public override bool BeginLoad (File source)
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_BeginLoad_File (handle, (object)source == null ? IntPtr.Zero : source.Handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern bool ParticleEffect2D_BeginLoad_MemoryBuffer (IntPtr handle, IntPtr source);

		/// <summary>
		/// Load resource from stream. May be called from a worker thread. Return true if successful.
		/// </summary>
		public override bool BeginLoad (MemoryBuffer source)
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_BeginLoad_MemoryBuffer (handle, (object)source == null ? IntPtr.Zero : source.Handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern bool ParticleEffect2D_EndLoad (IntPtr handle);

		/// <summary>
		/// Finish resource loading. Always called from the main thread. Return true if successful.
		/// </summary>
		public override bool EndLoad ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_EndLoad (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern bool ParticleEffect2D_Save_File (IntPtr handle, IntPtr dest);

		/// <summary>
		/// Save resource. Return true if successful.
		/// </summary>
		public override bool Save (File dest)
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_Save_File (handle, (object)dest == null ? IntPtr.Zero : dest.Handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern bool ParticleEffect2D_Save_MemoryBuffer (IntPtr handle, IntPtr dest);

		/// <summary>
		/// Save resource. Return true if successful.
		/// </summary>
		public override bool Save (MemoryBuffer dest)
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_Save_MemoryBuffer (handle, (object)dest == null ? IntPtr.Zero : dest.Handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetSprite (IntPtr handle, IntPtr sprite);

		/// <summary>
		/// Set sprite.
		/// </summary>
		private void SetSprite (Sprite2D sprite)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetSprite (handle, (object)sprite == null ? IntPtr.Zero : sprite.Handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetSourcePositionVariance (IntPtr handle, ref Urho.Vector2 sourcePositionVariance);

		/// <summary>
		/// Set source position variance.
		/// </summary>
		private void SetSourcePositionVariance (Urho.Vector2 sourcePositionVariance)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetSourcePositionVariance (handle, ref sourcePositionVariance);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetSpeed (IntPtr handle, float speed);

		/// <summary>
		/// Set speed.
		/// </summary>
		private void SetSpeed (float speed)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetSpeed (handle, speed);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetSpeedVariance (IntPtr handle, float speedVariance);

		/// <summary>
		/// Set speed variance.
		/// </summary>
		private void SetSpeedVariance (float speedVariance)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetSpeedVariance (handle, speedVariance);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetParticleLifeSpan (IntPtr handle, float particleLifeSpan);

		/// <summary>
		/// Set particle lifespan.
		/// </summary>
		private void SetParticleLifeSpan (float particleLifeSpan)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetParticleLifeSpan (handle, particleLifeSpan);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetParticleLifespanVariance (IntPtr handle, float particleLifespanVariance);

		/// <summary>
		/// Set particle lifespan variance.
		/// </summary>
		private void SetParticleLifespanVariance (float particleLifespanVariance)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetParticleLifespanVariance (handle, particleLifespanVariance);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetAngle (IntPtr handle, float angle);

		/// <summary>
		/// Set angle.
		/// </summary>
		private void SetAngle (float angle)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetAngle (handle, angle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetAngleVariance (IntPtr handle, float angleVariance);

		/// <summary>
		/// Set angle variance.
		/// </summary>
		private void SetAngleVariance (float angleVariance)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetAngleVariance (handle, angleVariance);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetGravity (IntPtr handle, ref Urho.Vector2 gravity);

		/// <summary>
		/// Set gravity.
		/// </summary>
		private void SetGravity (Urho.Vector2 gravity)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetGravity (handle, ref gravity);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetRadialAcceleration (IntPtr handle, float radialAcceleration);

		/// <summary>
		/// Set radial acceleration.
		/// </summary>
		private void SetRadialAcceleration (float radialAcceleration)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetRadialAcceleration (handle, radialAcceleration);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetTangentialAcceleration (IntPtr handle, float tangentialAcceleration);

		/// <summary>
		/// Set tangential acceleration.
		/// </summary>
		private void SetTangentialAcceleration (float tangentialAcceleration)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetTangentialAcceleration (handle, tangentialAcceleration);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetRadialAccelVariance (IntPtr handle, float radialAccelVariance);

		/// <summary>
		/// Set radial acceleration variance.
		/// </summary>
		private void SetRadialAccelVariance (float radialAccelVariance)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetRadialAccelVariance (handle, radialAccelVariance);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetTangentialAccelVariance (IntPtr handle, float tangentialAccelVariance);

		/// <summary>
		/// Set tangential acceleration variance.
		/// </summary>
		private void SetTangentialAccelVariance (float tangentialAccelVariance)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetTangentialAccelVariance (handle, tangentialAccelVariance);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetStartColor (IntPtr handle, ref Urho.Color startColor);

		/// <summary>
		/// Set start color.
		/// </summary>
		private void SetStartColor (Urho.Color startColor)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetStartColor (handle, ref startColor);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetStartColorVariance (IntPtr handle, ref Urho.Color startColorVariance);

		/// <summary>
		/// Set start color variance.
		/// </summary>
		private void SetStartColorVariance (Urho.Color startColorVariance)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetStartColorVariance (handle, ref startColorVariance);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetFinishColor (IntPtr handle, ref Urho.Color finishColor);

		/// <summary>
		/// Set finish color.
		/// </summary>
		private void SetFinishColor (Urho.Color finishColor)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetFinishColor (handle, ref finishColor);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetFinishColorVariance (IntPtr handle, ref Urho.Color finishColorVariance);

		/// <summary>
		/// Set finish color variance.
		/// </summary>
		private void SetFinishColorVariance (Urho.Color finishColorVariance)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetFinishColorVariance (handle, ref finishColorVariance);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetMaxParticles (IntPtr handle, int maxParticles);

		/// <summary>
		/// Set max particles.
		/// </summary>
		private void SetMaxParticles (int maxParticles)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetMaxParticles (handle, maxParticles);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetStartParticleSize (IntPtr handle, float startParticleSize);

		/// <summary>
		/// Set start particle size.
		/// </summary>
		private void SetStartParticleSize (float startParticleSize)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetStartParticleSize (handle, startParticleSize);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetStartParticleSizeVariance (IntPtr handle, float startParticleSizeVariance);

		/// <summary>
		/// Set start particle size variance.
		/// </summary>
		private void SetStartParticleSizeVariance (float startParticleSizeVariance)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetStartParticleSizeVariance (handle, startParticleSizeVariance);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetFinishParticleSize (IntPtr handle, float finishParticleSize);

		/// <summary>
		/// Set finish particle size.
		/// </summary>
		private void SetFinishParticleSize (float finishParticleSize)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetFinishParticleSize (handle, finishParticleSize);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetFinishParticleSizeVariance (IntPtr handle, float FinishParticleSizeVariance);

		/// <summary>
		/// Set finish particle size variance.
		/// </summary>
		private void SetFinishParticleSizeVariance (float FinishParticleSizeVariance)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetFinishParticleSizeVariance (handle, FinishParticleSizeVariance);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetDuration (IntPtr handle, float duration);

		/// <summary>
		/// Set duration.
		/// </summary>
		private void SetDuration (float duration)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetDuration (handle, duration);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetEmitterType (IntPtr handle, EmitterType2D emitterType);

		/// <summary>
		/// Set emitter type.
		/// </summary>
		private void SetEmitterType (EmitterType2D emitterType)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetEmitterType (handle, emitterType);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetMaxRadius (IntPtr handle, float maxRadius);

		/// <summary>
		/// Set max radius.
		/// </summary>
		private void SetMaxRadius (float maxRadius)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetMaxRadius (handle, maxRadius);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetMaxRadiusVariance (IntPtr handle, float maxRadiusVariance);

		/// <summary>
		/// Set max radius variance.
		/// </summary>
		private void SetMaxRadiusVariance (float maxRadiusVariance)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetMaxRadiusVariance (handle, maxRadiusVariance);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetMinRadius (IntPtr handle, float minRadius);

		/// <summary>
		/// Set min radius.
		/// </summary>
		private void SetMinRadius (float minRadius)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetMinRadius (handle, minRadius);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetMinRadiusVariance (IntPtr handle, float minRadiusVariance);

		/// <summary>
		/// Set min radius variance.
		/// </summary>
		private void SetMinRadiusVariance (float minRadiusVariance)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetMinRadiusVariance (handle, minRadiusVariance);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetRotatePerSecond (IntPtr handle, float rotatePerSecond);

		/// <summary>
		/// Set rotate per second.
		/// </summary>
		private void SetRotatePerSecond (float rotatePerSecond)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetRotatePerSecond (handle, rotatePerSecond);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetRotatePerSecondVariance (IntPtr handle, float rotatePerSecondVariance);

		/// <summary>
		/// Set rotate per second variance.
		/// </summary>
		private void SetRotatePerSecondVariance (float rotatePerSecondVariance)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetRotatePerSecondVariance (handle, rotatePerSecondVariance);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetBlendMode (IntPtr handle, BlendMode blendMode);

		/// <summary>
		/// Set blend mode.
		/// </summary>
		private void SetBlendMode (BlendMode blendMode)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetBlendMode (handle, blendMode);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetRotationStart (IntPtr handle, float rotationStart);

		/// <summary>
		/// Set rotation start.
		/// </summary>
		private void SetRotationStart (float rotationStart)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetRotationStart (handle, rotationStart);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetRotationStartVariance (IntPtr handle, float rotationStartVariance);

		/// <summary>
		/// Set rotation start variance.
		/// </summary>
		private void SetRotationStartVariance (float rotationStartVariance)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetRotationStartVariance (handle, rotationStartVariance);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetRotationEnd (IntPtr handle, float rotationEnd);

		/// <summary>
		/// Set rotation end.
		/// </summary>
		private void SetRotationEnd (float rotationEnd)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetRotationEnd (handle, rotationEnd);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect2D_SetRotationEndVariance (IntPtr handle, float rotationEndVariance);

		/// <summary>
		/// Set rotation end variance.
		/// </summary>
		private void SetRotationEndVariance (float rotationEndVariance)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect2D_SetRotationEndVariance (handle, rotationEndVariance);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr ParticleEffect2D_Clone (IntPtr handle, string cloneName);

		/// <summary>
		/// Clone the 2D particle effect.
		/// </summary>
		public ParticleEffect2D Clone (string cloneName = "")
		{
			Runtime.ValidateRefCounted (this);
			return Runtime.LookupRefCounted<ParticleEffect2D> (ParticleEffect2D_Clone (handle, cloneName));
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr ParticleEffect2D_GetSprite (IntPtr handle);

		/// <summary>
		/// Return sprite.
		/// </summary>
		private Sprite2D GetSprite ()
		{
			Runtime.ValidateRefCounted (this);
			return Runtime.LookupObject<Sprite2D> (ParticleEffect2D_GetSprite (handle));
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern Urho.Vector2 ParticleEffect2D_GetSourcePositionVariance (IntPtr handle);

		/// <summary>
		/// Return source position variance.
		/// </summary>
		private Urho.Vector2 GetSourcePositionVariance ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetSourcePositionVariance (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetSpeed (IntPtr handle);

		/// <summary>
		/// Return speed.
		/// </summary>
		private float GetSpeed ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetSpeed (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetSpeedVariance (IntPtr handle);

		/// <summary>
		/// Return speed variance.
		/// </summary>
		private float GetSpeedVariance ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetSpeedVariance (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetParticleLifeSpan (IntPtr handle);

		/// <summary>
		/// Return particle lifespan.
		/// </summary>
		private float GetParticleLifeSpan ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetParticleLifeSpan (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetParticleLifespanVariance (IntPtr handle);

		/// <summary>
		/// Return particle lifespan variance.
		/// </summary>
		private float GetParticleLifespanVariance ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetParticleLifespanVariance (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetAngle (IntPtr handle);

		/// <summary>
		/// Return angle.
		/// </summary>
		private float GetAngle ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetAngle (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetAngleVariance (IntPtr handle);

		/// <summary>
		/// Return angle variance.
		/// </summary>
		private float GetAngleVariance ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetAngleVariance (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern Urho.Vector2 ParticleEffect2D_GetGravity (IntPtr handle);

		/// <summary>
		/// Return gravity.
		/// </summary>
		private Urho.Vector2 GetGravity ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetGravity (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetRadialAcceleration (IntPtr handle);

		/// <summary>
		/// Return radial acceleration.
		/// </summary>
		private float GetRadialAcceleration ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetRadialAcceleration (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetTangentialAcceleration (IntPtr handle);

		/// <summary>
		/// Return tangential acceleration.
		/// </summary>
		private float GetTangentialAcceleration ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetTangentialAcceleration (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetRadialAccelVariance (IntPtr handle);

		/// <summary>
		/// Return radial acceleration variance.
		/// </summary>
		private float GetRadialAccelVariance ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetRadialAccelVariance (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetTangentialAccelVariance (IntPtr handle);

		/// <summary>
		/// Return tangential acceleration variance.
		/// </summary>
		private float GetTangentialAccelVariance ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetTangentialAccelVariance (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern Urho.Color ParticleEffect2D_GetStartColor (IntPtr handle);

		/// <summary>
		/// Return start color.
		/// </summary>
		private Urho.Color GetStartColor ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetStartColor (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern Urho.Color ParticleEffect2D_GetStartColorVariance (IntPtr handle);

		/// <summary>
		/// Return start color variance.
		/// </summary>
		private Urho.Color GetStartColorVariance ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetStartColorVariance (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern Urho.Color ParticleEffect2D_GetFinishColor (IntPtr handle);

		/// <summary>
		/// Return finish color.
		/// </summary>
		private Urho.Color GetFinishColor ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetFinishColor (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern Urho.Color ParticleEffect2D_GetFinishColorVariance (IntPtr handle);

		/// <summary>
		/// Return finish color variance.
		/// </summary>
		private Urho.Color GetFinishColorVariance ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetFinishColorVariance (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern int ParticleEffect2D_GetMaxParticles (IntPtr handle);

		/// <summary>
		/// Return max particles.
		/// </summary>
		private int GetMaxParticles ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetMaxParticles (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetStartParticleSize (IntPtr handle);

		/// <summary>
		/// Return start particle size.
		/// </summary>
		private float GetStartParticleSize ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetStartParticleSize (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetStartParticleSizeVariance (IntPtr handle);

		/// <summary>
		/// Return start particle size variance.
		/// </summary>
		private float GetStartParticleSizeVariance ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetStartParticleSizeVariance (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetFinishParticleSize (IntPtr handle);

		/// <summary>
		/// Return finish particle size.
		/// </summary>
		private float GetFinishParticleSize ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetFinishParticleSize (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetFinishParticleSizeVariance (IntPtr handle);

		/// <summary>
		/// Return finish particle size variance.
		/// </summary>
		private float GetFinishParticleSizeVariance ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetFinishParticleSizeVariance (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetDuration (IntPtr handle);

		/// <summary>
		/// Return duration.
		/// </summary>
		private float GetDuration ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetDuration (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern EmitterType2D ParticleEffect2D_GetEmitterType (IntPtr handle);

		/// <summary>
		/// Return emitter type.
		/// </summary>
		private EmitterType2D GetEmitterType ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetEmitterType (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetMaxRadius (IntPtr handle);

		/// <summary>
		/// Return max radius.
		/// </summary>
		private float GetMaxRadius ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetMaxRadius (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetMaxRadiusVariance (IntPtr handle);

		/// <summary>
		/// Return max radius variance.
		/// </summary>
		private float GetMaxRadiusVariance ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetMaxRadiusVariance (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetMinRadius (IntPtr handle);

		/// <summary>
		/// Return min radius.
		/// </summary>
		private float GetMinRadius ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetMinRadius (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetMinRadiusVariance (IntPtr handle);

		/// <summary>
		/// Return min radius variance.
		/// </summary>
		private float GetMinRadiusVariance ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetMinRadiusVariance (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetRotatePerSecond (IntPtr handle);

		/// <summary>
		/// Return rotate per second.
		/// </summary>
		private float GetRotatePerSecond ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetRotatePerSecond (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetRotatePerSecondVariance (IntPtr handle);

		/// <summary>
		/// Return rotate per second variance.
		/// </summary>
		private float GetRotatePerSecondVariance ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetRotatePerSecondVariance (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern BlendMode ParticleEffect2D_GetBlendMode (IntPtr handle);

		/// <summary>
		/// Return blend mode.
		/// </summary>
		private BlendMode GetBlendMode ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetBlendMode (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetRotationStart (IntPtr handle);

		/// <summary>
		/// Return rotation start.
		/// </summary>
		private float GetRotationStart ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetRotationStart (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetRotationStartVariance (IntPtr handle);

		/// <summary>
		/// Return rotation start variance.
		/// </summary>
		private float GetRotationStartVariance ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetRotationStartVariance (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetRotationEnd (IntPtr handle);

		/// <summary>
		/// Return rotation end.
		/// </summary>
		private float GetRotationEnd ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetRotationEnd (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern float ParticleEffect2D_GetRotationEndVariance (IntPtr handle);

		/// <summary>
		/// Return rotation end variance.
		/// </summary>
		private float GetRotationEndVariance ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect2D_GetRotationEndVariance (handle);
		}

		public override StringHash Type {
			get {
				return UrhoGetType ();
			}
		}

		public override string TypeName {
			get {
				return GetTypeName ();
			}
		}

		[Preserve]
		public new static StringHash TypeStatic {
			get {
				return GetTypeStatic ();
			}
		}

		public new static string TypeNameStatic {
			get {
				return GetTypeNameStatic ();
			}
		}

		/// <summary>
		/// Return sprite.
		/// Or
		/// Set sprite.
		/// </summary>
		public Sprite2D Sprite {
			get {
				return GetSprite ();
			}
			set {
				SetSprite (value);
			}
		}

		/// <summary>
		/// Return source position variance.
		/// Or
		/// Set source position variance.
		/// </summary>
		public Urho.Vector2 SourcePositionVariance {
			get {
				return GetSourcePositionVariance ();
			}
			set {
				SetSourcePositionVariance (value);
			}
		}

		/// <summary>
		/// Return speed.
		/// Or
		/// Set speed.
		/// </summary>
		public float Speed {
			get {
				return GetSpeed ();
			}
			set {
				SetSpeed (value);
			}
		}

		/// <summary>
		/// Return speed variance.
		/// Or
		/// Set speed variance.
		/// </summary>
		public float SpeedVariance {
			get {
				return GetSpeedVariance ();
			}
			set {
				SetSpeedVariance (value);
			}
		}

		/// <summary>
		/// Return particle lifespan.
		/// Or
		/// Set particle lifespan.
		/// </summary>
		public float ParticleLifeSpan {
			get {
				return GetParticleLifeSpan ();
			}
			set {
				SetParticleLifeSpan (value);
			}
		}

		/// <summary>
		/// Return particle lifespan variance.
		/// Or
		/// Set particle lifespan variance.
		/// </summary>
		public float ParticleLifespanVariance {
			get {
				return GetParticleLifespanVariance ();
			}
			set {
				SetParticleLifespanVariance (value);
			}
		}

		/// <summary>
		/// Return angle.
		/// Or
		/// Set angle.
		/// </summary>
		public float Angle {
			get {
				return GetAngle ();
			}
			set {
				SetAngle (value);
			}
		}

		/// <summary>
		/// Return angle variance.
		/// Or
		/// Set angle variance.
		/// </summary>
		public float AngleVariance {
			get {
				return GetAngleVariance ();
			}
			set {
				SetAngleVariance (value);
			}
		}

		/// <summary>
		/// Return gravity.
		/// Or
		/// Set gravity.
		/// </summary>
		public Urho.Vector2 Gravity {
			get {
				return GetGravity ();
			}
			set {
				SetGravity (value);
			}
		}

		/// <summary>
		/// Return radial acceleration.
		/// Or
		/// Set radial acceleration.
		/// </summary>
		public float RadialAcceleration {
			get {
				return GetRadialAcceleration ();
			}
			set {
				SetRadialAcceleration (value);
			}
		}

		/// <summary>
		/// Return tangential acceleration.
		/// Or
		/// Set tangential acceleration.
		/// </summary>
		public float TangentialAcceleration {
			get {
				return GetTangentialAcceleration ();
			}
			set {
				SetTangentialAcceleration (value);
			}
		}

		/// <summary>
		/// Return radial acceleration variance.
		/// Or
		/// Set radial acceleration variance.
		/// </summary>
		public float RadialAccelVariance {
			get {
				return GetRadialAccelVariance ();
			}
			set {
				SetRadialAccelVariance (value);
			}
		}

		/// <summary>
		/// Return tangential acceleration variance.
		/// Or
		/// Set tangential acceleration variance.
		/// </summary>
		public float TangentialAccelVariance {
			get {
				return GetTangentialAccelVariance ();
			}
			set {
				SetTangentialAccelVariance (value);
			}
		}

		/// <summary>
		/// Return start color.
		/// Or
		/// Set start color.
		/// </summary>
		public Urho.Color StartColor {
			get {
				return GetStartColor ();
			}
			set {
				SetStartColor (value);
			}
		}

		/// <summary>
		/// Return start color variance.
		/// Or
		/// Set start color variance.
		/// </summary>
		public Urho.Color StartColorVariance {
			get {
				return GetStartColorVariance ();
			}
			set {
				SetStartColorVariance (value);
			}
		}

		/// <summary>
		/// Return finish color.
		/// Or
		/// Set finish color.
		/// </summary>
		public Urho.Color FinishColor {
			get {
				return GetFinishColor ();
			}
			set {
				SetFinishColor (value);
			}
		}

		/// <summary>
		/// Return finish color variance.
		/// Or
		/// Set finish color variance.
		/// </summary>
		public Urho.Color FinishColorVariance {
			get {
				return GetFinishColorVariance ();
			}
			set {
				SetFinishColorVariance (value);
			}
		}

		/// <summary>
		/// Return max particles.
		/// Or
		/// Set max particles.
		/// </summary>
		public int MaxParticles {
			get {
				return GetMaxParticles ();
			}
			set {
				SetMaxParticles (value);
			}
		}

		/// <summary>
		/// Return start particle size.
		/// Or
		/// Set start particle size.
		/// </summary>
		public float StartParticleSize {
			get {
				return GetStartParticleSize ();
			}
			set {
				SetStartParticleSize (value);
			}
		}

		/// <summary>
		/// Return start particle size variance.
		/// Or
		/// Set start particle size variance.
		/// </summary>
		public float StartParticleSizeVariance {
			get {
				return GetStartParticleSizeVariance ();
			}
			set {
				SetStartParticleSizeVariance (value);
			}
		}

		/// <summary>
		/// Return finish particle size.
		/// Or
		/// Set finish particle size.
		/// </summary>
		public float FinishParticleSize {
			get {
				return GetFinishParticleSize ();
			}
			set {
				SetFinishParticleSize (value);
			}
		}

		/// <summary>
		/// Return finish particle size variance.
		/// Or
		/// Set finish particle size variance.
		/// </summary>
		public float FinishParticleSizeVariance {
			get {
				return GetFinishParticleSizeVariance ();
			}
			set {
				SetFinishParticleSizeVariance (value);
			}
		}

		/// <summary>
		/// Return duration.
		/// Or
		/// Set duration.
		/// </summary>
		public float Duration {
			get {
				return GetDuration ();
			}
			set {
				SetDuration (value);
			}
		}

		/// <summary>
		/// Return emitter type.
		/// Or
		/// Set emitter type.
		/// </summary>
		public EmitterType2D EmitterType {
			get {
				return GetEmitterType ();
			}
			set {
				SetEmitterType (value);
			}
		}

		/// <summary>
		/// Return max radius.
		/// Or
		/// Set max radius.
		/// </summary>
		public float MaxRadius {
			get {
				return GetMaxRadius ();
			}
			set {
				SetMaxRadius (value);
			}
		}

		/// <summary>
		/// Return max radius variance.
		/// Or
		/// Set max radius variance.
		/// </summary>
		public float MaxRadiusVariance {
			get {
				return GetMaxRadiusVariance ();
			}
			set {
				SetMaxRadiusVariance (value);
			}
		}

		/// <summary>
		/// Return min radius.
		/// Or
		/// Set min radius.
		/// </summary>
		public float MinRadius {
			get {
				return GetMinRadius ();
			}
			set {
				SetMinRadius (value);
			}
		}

		/// <summary>
		/// Return min radius variance.
		/// Or
		/// Set min radius variance.
		/// </summary>
		public float MinRadiusVariance {
			get {
				return GetMinRadiusVariance ();
			}
			set {
				SetMinRadiusVariance (value);
			}
		}

		/// <summary>
		/// Return rotate per second.
		/// Or
		/// Set rotate per second.
		/// </summary>
		public float RotatePerSecond {
			get {
				return GetRotatePerSecond ();
			}
			set {
				SetRotatePerSecond (value);
			}
		}

		/// <summary>
		/// Return rotate per second variance.
		/// Or
		/// Set rotate per second variance.
		/// </summary>
		public float RotatePerSecondVariance {
			get {
				return GetRotatePerSecondVariance ();
			}
			set {
				SetRotatePerSecondVariance (value);
			}
		}

		/// <summary>
		/// Return blend mode.
		/// Or
		/// Set blend mode.
		/// </summary>
		public BlendMode BlendMode {
			get {
				return GetBlendMode ();
			}
			set {
				SetBlendMode (value);
			}
		}

		/// <summary>
		/// Return rotation start.
		/// Or
		/// Set rotation start.
		/// </summary>
		public float RotationStart {
			get {
				return GetRotationStart ();
			}
			set {
				SetRotationStart (value);
			}
		}

		/// <summary>
		/// Return rotation start variance.
		/// Or
		/// Set rotation start variance.
		/// </summary>
		public float RotationStartVariance {
			get {
				return GetRotationStartVariance ();
			}
			set {
				SetRotationStartVariance (value);
			}
		}

		/// <summary>
		/// Return rotation end.
		/// Or
		/// Set rotation end.
		/// </summary>
		public float RotationEnd {
			get {
				return GetRotationEnd ();
			}
			set {
				SetRotationEnd (value);
			}
		}

		/// <summary>
		/// Return rotation end variance.
		/// Or
		/// Set rotation end variance.
		/// </summary>
		public float RotationEndVariance {
			get {
				return GetRotationEndVariance ();
			}
			set {
				SetRotationEndVariance (value);
			}
		}
	}
}