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

// WARNING - AUTOGENERATED - DO NOT EDIT
// 
// Generated using `sharpie urho`
// 
// ParticleEffect.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
{
	/// <summary>
	/// %Particle effect definition.
	/// </summary>
	public unsafe partial class ParticleEffect : Resource
	{
		unsafe partial void OnParticleEffectCreated ();

		[Preserve]
		public ParticleEffect (IntPtr handle) : base (handle)
		{
			OnParticleEffectCreated ();
		}

		[Preserve]
		protected ParticleEffect (UrhoObjectFlag emptyFlag) : base (emptyFlag)
		{
			OnParticleEffectCreated ();
		}

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

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

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

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

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

		private static StringHash GetTypeStatic ()
		{
			Runtime.Validate (typeof(ParticleEffect));
			return new StringHash (ParticleEffect_GetTypeStatic ());
		}

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

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

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

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

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

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

		/// <summary>
		/// Register object factory.
		/// </summary>
		public static void RegisterObject (Context context)
		{
			Runtime.Validate (typeof(ParticleEffect));
			ParticleEffect_RegisterObject ((object)context == null ? IntPtr.Zero : context.Handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern bool ParticleEffect_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 ParticleEffect_BeginLoad_File (handle, (object)source == null ? IntPtr.Zero : source.Handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern bool ParticleEffect_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 ParticleEffect_BeginLoad_MemoryBuffer (handle, (object)source == null ? IntPtr.Zero : source.Handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern bool ParticleEffect_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 ParticleEffect_EndLoad (handle);
		}

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

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

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

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

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

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

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

		/// <summary>
		/// Load resource from XMLElement synchronously. Return true if successful.
		/// </summary>
		public bool Load (XmlElement source)
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_Load (handle, (object)source == null ? IntPtr.Zero : source.Handle);
		}

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

		/// <summary>
		/// Set material.
		/// </summary>
		private void SetMaterial (Material material)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetMaterial (handle, (object)material == null ? IntPtr.Zero : material.Handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect_SetNumParticles (IntPtr handle, uint num);

		/// <summary>
		/// Set maximum number of particles.
		/// </summary>
		private void SetNumParticles (uint num)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetNumParticles (handle, num);
		}

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

		/// <summary>
		/// Set whether to update when particles are not visible.
		/// </summary>
		private void SetUpdateInvisible (bool enable)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetUpdateInvisible (handle, enable);
		}

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

		/// <summary>
		/// Set whether billboards are relative to the scene node.
		/// </summary>
		private void SetRelative (bool enable)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetRelative (handle, enable);
		}

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

		/// <summary>
		/// Set whether scene node scale affects billboards' size.
		/// </summary>
		private void SetScaled (bool enable)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetScaled (handle, enable);
		}

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

		/// <summary>
		/// Set whether billboards are sorted by distance.
		/// </summary>
		private void SetSorted (bool enable)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetSorted (handle, enable);
		}

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

		/// <summary>
		/// Set whether billboards have fixed size on screen (measured in pixels) regardless of distance to camera.
		/// </summary>
		private void SetFixedScreenSize (bool enable)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetFixedScreenSize (handle, enable);
		}

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

		/// <summary>
		/// Set animation LOD bias.
		/// </summary>
		private void SetAnimationLodBias (float lodBias)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetAnimationLodBias (handle, lodBias);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect_SetEmitterType (IntPtr handle, EmitterType type);

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

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect_SetEmitterSize (IntPtr handle, ref Urho.Vector3 size);

		/// <summary>
		/// Set emitter size.
		/// </summary>
		private void SetEmitterSize (Urho.Vector3 size)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetEmitterSize (handle, ref size);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect_SetMinDirection (IntPtr handle, ref Urho.Vector3 direction);

		/// <summary>
		/// Set negative direction limit.
		/// </summary>
		private void SetMinDirection (Urho.Vector3 direction)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetMinDirection (handle, ref direction);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect_SetMaxDirection (IntPtr handle, ref Urho.Vector3 direction);

		/// <summary>
		/// Set positive direction limit.
		/// </summary>
		private void SetMaxDirection (Urho.Vector3 direction)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetMaxDirection (handle, ref direction);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect_SetConstantForce (IntPtr handle, ref Urho.Vector3 force);

		/// <summary>
		/// Set constant force acting on particles.
		/// </summary>
		private void SetConstantForce (Urho.Vector3 force)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetConstantForce (handle, ref force);
		}

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

		/// <summary>
		/// Set particle velocity damping force.
		/// </summary>
		private void SetDampingForce (float force)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetDampingForce (handle, force);
		}

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

		/// <summary>
		/// Set emission active period length (0 = infinite.)
		/// </summary>
		private void SetActiveTime (float time)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetActiveTime (handle, time);
		}

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

		/// <summary>
		/// Set emission inactive period length (0 = infinite.)
		/// </summary>
		private void SetInactiveTime (float time)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetInactiveTime (handle, time);
		}

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

		/// <summary>
		/// Set minimum emission rate.
		/// </summary>
		private void SetMinEmissionRate (float rate)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetMinEmissionRate (handle, rate);
		}

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

		/// <summary>
		/// Set maximum emission rate.
		/// </summary>
		private void SetMaxEmissionRate (float rate)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetMaxEmissionRate (handle, rate);
		}

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

		/// <summary>
		/// Set particle minimum size.
		/// </summary>
		private void SetMinParticleSize (Urho.Vector2 size)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetMinParticleSize (handle, ref size);
		}

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

		/// <summary>
		/// Set particle maximum size.
		/// </summary>
		private void SetMaxParticleSize (Urho.Vector2 size)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetMaxParticleSize (handle, ref size);
		}

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

		/// <summary>
		/// Set particle minimum time to live.
		/// </summary>
		private void SetMinTimeToLive (float time)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetMinTimeToLive (handle, time);
		}

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

		/// <summary>
		/// Set particle maximum time to live.
		/// </summary>
		private void SetMaxTimeToLive (float time)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetMaxTimeToLive (handle, time);
		}

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

		/// <summary>
		/// Set particle minimum velocity.
		/// </summary>
		private void SetMinVelocity (float velocity)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetMinVelocity (handle, velocity);
		}

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

		/// <summary>
		/// Set particle maximum velocity.
		/// </summary>
		private void SetMaxVelocity (float velocity)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetMaxVelocity (handle, velocity);
		}

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

		/// <summary>
		/// Set particle minimum rotation.
		/// </summary>
		private void SetMinRotation (float rotation)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetMinRotation (handle, rotation);
		}

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

		/// <summary>
		/// Set particle maximum rotation.
		/// </summary>
		private void SetMaxRotation (float rotation)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetMaxRotation (handle, rotation);
		}

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

		/// <summary>
		/// Set particle minimum rotation speed.
		/// </summary>
		private void SetMinRotationSpeed (float speed)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetMinRotationSpeed (handle, speed);
		}

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

		/// <summary>
		/// Set particle maximum rotation speed.
		/// </summary>
		private void SetMaxRotationSpeed (float speed)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetMaxRotationSpeed (handle, speed);
		}

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

		/// <summary>
		/// Set particle size additive modifier.
		/// </summary>
		private void SetSizeAdd (float sizeAdd)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetSizeAdd (handle, sizeAdd);
		}

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

		/// <summary>
		/// Set particle size multiplicative modifier.
		/// </summary>
		private void SetSizeMul (float sizeMul)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetSizeMul (handle, sizeMul);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect_SetFaceCameraMode (IntPtr handle, FaceCameraMode mode);

		/// <summary>
		/// Set how the particles should rotate in relation to the camera. Default is to follow camera rotation on all axes (FC_ROTATE_XYZ.)
		/// </summary>
		private void SetFaceCameraMode (FaceCameraMode mode)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetFaceCameraMode (handle, mode);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect_AddColorTime (IntPtr handle, ref Urho.Color color, float time);

		/// <summary>
		/// Add a color frame sorted in the correct position based on time.
		/// </summary>
		public void AddColorTime (Urho.Color color, float time)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_AddColorTime (handle, ref color, time);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect_RemoveColorFrame (IntPtr handle, uint index);

		/// <summary>
		/// Remove color frame at index
		/// </summary>
		public void RemoveColorFrame (uint index)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_RemoveColorFrame (handle, index);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect_SetNumColorFrames (IntPtr handle, uint number);

		/// <summary>
		/// Set number of color frames.
		/// </summary>
		private void SetNumColorFrames (uint number)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetNumColorFrames (handle, number);
		}

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

		/// <summary>
		/// Sort the list of color frames based on time.
		/// </summary>
		public void SortColorFrames ()
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SortColorFrames (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect_RemoveTextureFrame (IntPtr handle, uint index);

		/// <summary>
		/// Remove texture frame at index
		/// </summary>
		public void RemoveTextureFrame (uint index)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_RemoveTextureFrame (handle, index);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern void ParticleEffect_SetNumTextureFrames (IntPtr handle, uint number);

		/// <summary>
		/// Set number of texture frames.
		/// </summary>
		private void SetNumTextureFrames (uint number)
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SetNumTextureFrames (handle, number);
		}

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

		/// <summary>
		/// Sort the list of texture frames based on time.
		/// </summary>
		public void SortTextureFrames ()
		{
			Runtime.ValidateRefCounted (this);
			ParticleEffect_SortTextureFrames (handle);
		}

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

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

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

		/// <summary>
		/// Return material.
		/// </summary>
		private Material GetMaterial ()
		{
			Runtime.ValidateRefCounted (this);
			return Runtime.LookupObject<Material> (ParticleEffect_GetMaterial (handle));
		}

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

		/// <summary>
		/// Return maximum number of particles.
		/// </summary>
		private uint GetNumParticles ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetNumParticles (handle);
		}

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

		/// <summary>
		/// Return whether to update when particles are not visible.
		/// </summary>
		private bool GetUpdateInvisible ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetUpdateInvisible (handle);
		}

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

		/// <summary>
		/// Return whether billboards are relative to the scene node.
		/// </summary>
		private bool IsRelative ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_IsRelative (handle);
		}

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

		/// <summary>
		/// Return whether scene node scale affects billboards' size.
		/// </summary>
		private bool IsScaled ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_IsScaled (handle);
		}

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

		/// <summary>
		/// Return whether billboards are sorted.
		/// </summary>
		private bool IsSorted ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_IsSorted (handle);
		}

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

		/// <summary>
		/// Return whether billboards are fixed screen size.
		/// </summary>
		private bool IsFixedScreenSize ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_IsFixedScreenSize (handle);
		}

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

		/// <summary>
		/// Return animation Lod bias.
		/// </summary>
		private float GetAnimationLodBias ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetAnimationLodBias (handle);
		}

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

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

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

		/// <summary>
		/// Return emitter size.
		/// </summary>
		private Urho.Vector3 GetEmitterSize ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetEmitterSize (handle);
		}

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

		/// <summary>
		/// Return negative direction limit.
		/// </summary>
		private Urho.Vector3 GetMinDirection ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetMinDirection (handle);
		}

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

		/// <summary>
		/// Return positive direction limit.
		/// </summary>
		private Urho.Vector3 GetMaxDirection ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetMaxDirection (handle);
		}

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

		/// <summary>
		/// Return constant force acting on particles.
		/// </summary>
		private Urho.Vector3 GetConstantForce ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetConstantForce (handle);
		}

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

		/// <summary>
		/// Return particle velocity damping force.
		/// </summary>
		private float GetDampingForce ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetDampingForce (handle);
		}

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

		/// <summary>
		/// Return emission active period length (0 = infinite.)
		/// </summary>
		private float GetActiveTime ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetActiveTime (handle);
		}

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

		/// <summary>
		/// Return emission inactive period length (0 = infinite.)
		/// </summary>
		private float GetInactiveTime ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetInactiveTime (handle);
		}

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

		/// <summary>
		/// Return minimum emission rate.
		/// </summary>
		private float GetMinEmissionRate ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetMinEmissionRate (handle);
		}

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

		/// <summary>
		/// Return maximum emission rate.
		/// </summary>
		private float GetMaxEmissionRate ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetMaxEmissionRate (handle);
		}

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

		/// <summary>
		/// Return particle minimum size.
		/// </summary>
		private Urho.Vector2 GetMinParticleSize ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetMinParticleSize (handle);
		}

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

		/// <summary>
		/// Return particle maximum size.
		/// </summary>
		private Urho.Vector2 GetMaxParticleSize ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetMaxParticleSize (handle);
		}

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

		/// <summary>
		/// Return particle minimum time to live.
		/// </summary>
		private float GetMinTimeToLive ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetMinTimeToLive (handle);
		}

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

		/// <summary>
		/// Return particle maximum time to live.
		/// </summary>
		private float GetMaxTimeToLive ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetMaxTimeToLive (handle);
		}

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

		/// <summary>
		/// Return particle minimum velocity.
		/// </summary>
		private float GetMinVelocity ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetMinVelocity (handle);
		}

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

		/// <summary>
		/// Return particle maximum velocity.
		/// </summary>
		private float GetMaxVelocity ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetMaxVelocity (handle);
		}

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

		/// <summary>
		/// Return particle minimum rotation.
		/// </summary>
		private float GetMinRotation ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetMinRotation (handle);
		}

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

		/// <summary>
		/// Return particle maximum rotation.
		/// </summary>
		private float GetMaxRotation ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetMaxRotation (handle);
		}

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

		/// <summary>
		/// Return particle minimum rotation speed.
		/// </summary>
		private float GetMinRotationSpeed ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetMinRotationSpeed (handle);
		}

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

		/// <summary>
		/// Return particle maximum rotation speed.
		/// </summary>
		private float GetMaxRotationSpeed ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetMaxRotationSpeed (handle);
		}

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

		/// <summary>
		/// Return particle size additive modifier.
		/// </summary>
		private float GetSizeAdd ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetSizeAdd (handle);
		}

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

		/// <summary>
		/// Return particle size multiplicative modifier.
		/// </summary>
		private float GetSizeMul ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetSizeMul (handle);
		}

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

		/// <summary>
		/// Return number of color animation frames.
		/// </summary>
		private uint GetNumColorFrames ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetNumColorFrames (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern ColorFrame* ParticleEffect_GetColorFrame (IntPtr handle, uint index);

		/// <summary>
		/// Return a color animation frame, or null if outside range.
		/// </summary>
		public ColorFrame* GetColorFrame (uint index)
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetColorFrame (handle, index);
		}

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

		/// <summary>
		/// Return number of texture animation frames.
		/// </summary>
		private uint GetNumTextureFrames ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetNumTextureFrames (handle);
		}

		[DllImport (Consts.NativeImport, CallingConvention = CallingConvention.Cdecl)]
		internal static extern TextureFrame* ParticleEffect_GetTextureFrame (IntPtr handle, uint index);

		/// <summary>
		/// Return a texture animation frame, or null if outside range.
		/// </summary>
		public TextureFrame* GetTextureFrame (uint index)
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetTextureFrame (handle, index);
		}

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

		/// <summary>
		/// Return how the particles rotate in relation to the camera.
		/// </summary>
		private FaceCameraMode GetFaceCameraMode ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetFaceCameraMode (handle);
		}

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

		/// <summary>
		/// Return random direction.
		/// </summary>
		private Vector3 GetRandomDirection ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetRandomDirection (handle);
		}

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

		/// <summary>
		/// Return random size.
		/// </summary>
		private Vector2 GetRandomSize ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetRandomSize (handle);
		}

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

		/// <summary>
		/// Return random velocity.
		/// </summary>
		private float GetRandomVelocity ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetRandomVelocity (handle);
		}

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

		/// <summary>
		/// Return random timetolive.
		/// </summary>
		private float GetRandomTimeToLive ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetRandomTimeToLive (handle);
		}

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

		/// <summary>
		/// Return random rotationspeed.
		/// </summary>
		private float GetRandomRotationSpeed ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetRandomRotationSpeed (handle);
		}

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

		/// <summary>
		/// Return random rotation.
		/// </summary>
		private float GetRandomRotation ()
		{
			Runtime.ValidateRefCounted (this);
			return ParticleEffect_GetRandomRotation (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 material.
		/// Or
		/// Set material.
		/// </summary>
		public Material Material {
			get {
				return GetMaterial ();
			}
			set {
				SetMaterial (value);
			}
		}

		/// <summary>
		/// Return maximum number of particles.
		/// Or
		/// Set maximum number of particles.
		/// </summary>
		public uint NumParticles {
			get {
				return GetNumParticles ();
			}
			set {
				SetNumParticles (value);
			}
		}

		/// <summary>
		/// Return whether to update when particles are not visible.
		/// Or
		/// Set whether to update when particles are not visible.
		/// </summary>
		public bool UpdateInvisible {
			get {
				return GetUpdateInvisible ();
			}
			set {
				SetUpdateInvisible (value);
			}
		}

		/// <summary>
		/// Return whether billboards are relative to the scene node.
		/// Or
		/// Set whether billboards are relative to the scene node.
		/// </summary>
		public bool Relative {
			get {
				return IsRelative ();
			}
			set {
				SetRelative (value);
			}
		}

		/// <summary>
		/// Return whether scene node scale affects billboards' size.
		/// Or
		/// Set whether scene node scale affects billboards' size.
		/// </summary>
		public bool Scaled {
			get {
				return IsScaled ();
			}
			set {
				SetScaled (value);
			}
		}

		/// <summary>
		/// Return whether billboards are sorted.
		/// Or
		/// Set whether billboards are sorted by distance.
		/// </summary>
		public bool Sorted {
			get {
				return IsSorted ();
			}
			set {
				SetSorted (value);
			}
		}

		/// <summary>
		/// Return whether billboards are fixed screen size.
		/// Or
		/// Set whether billboards have fixed size on screen (measured in pixels) regardless of distance to camera.
		/// </summary>
		public bool FixedScreenSize {
			get {
				return IsFixedScreenSize ();
			}
			set {
				SetFixedScreenSize (value);
			}
		}

		/// <summary>
		/// Return animation Lod bias.
		/// Or
		/// Set animation LOD bias.
		/// </summary>
		public float AnimationLodBias {
			get {
				return GetAnimationLodBias ();
			}
			set {
				SetAnimationLodBias (value);
			}
		}

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

		/// <summary>
		/// Return emitter size.
		/// Or
		/// Set emitter size.
		/// </summary>
		public Urho.Vector3 EmitterSize {
			get {
				return GetEmitterSize ();
			}
			set {
				SetEmitterSize (value);
			}
		}

		/// <summary>
		/// Return negative direction limit.
		/// Or
		/// Set negative direction limit.
		/// </summary>
		public Urho.Vector3 MinDirection {
			get {
				return GetMinDirection ();
			}
			set {
				SetMinDirection (value);
			}
		}

		/// <summary>
		/// Return positive direction limit.
		/// Or
		/// Set positive direction limit.
		/// </summary>
		public Urho.Vector3 MaxDirection {
			get {
				return GetMaxDirection ();
			}
			set {
				SetMaxDirection (value);
			}
		}

		/// <summary>
		/// Return constant force acting on particles.
		/// Or
		/// Set constant force acting on particles.
		/// </summary>
		public Urho.Vector3 ConstantForce {
			get {
				return GetConstantForce ();
			}
			set {
				SetConstantForce (value);
			}
		}

		/// <summary>
		/// Return particle velocity damping force.
		/// Or
		/// Set particle velocity damping force.
		/// </summary>
		public float DampingForce {
			get {
				return GetDampingForce ();
			}
			set {
				SetDampingForce (value);
			}
		}

		/// <summary>
		/// Return emission active period length (0 = infinite.)
		/// Or
		/// Set emission active period length (0 = infinite.)
		/// </summary>
		public float ActiveTime {
			get {
				return GetActiveTime ();
			}
			set {
				SetActiveTime (value);
			}
		}

		/// <summary>
		/// Return emission inactive period length (0 = infinite.)
		/// Or
		/// Set emission inactive period length (0 = infinite.)
		/// </summary>
		public float InactiveTime {
			get {
				return GetInactiveTime ();
			}
			set {
				SetInactiveTime (value);
			}
		}

		/// <summary>
		/// Return minimum emission rate.
		/// Or
		/// Set minimum emission rate.
		/// </summary>
		public float MinEmissionRate {
			get {
				return GetMinEmissionRate ();
			}
			set {
				SetMinEmissionRate (value);
			}
		}

		/// <summary>
		/// Return maximum emission rate.
		/// Or
		/// Set maximum emission rate.
		/// </summary>
		public float MaxEmissionRate {
			get {
				return GetMaxEmissionRate ();
			}
			set {
				SetMaxEmissionRate (value);
			}
		}

		/// <summary>
		/// Return particle minimum size.
		/// Or
		/// Set particle minimum size.
		/// </summary>
		public Urho.Vector2 MinParticleSize {
			get {
				return GetMinParticleSize ();
			}
			set {
				SetMinParticleSize (value);
			}
		}

		/// <summary>
		/// Return particle maximum size.
		/// Or
		/// Set particle maximum size.
		/// </summary>
		public Urho.Vector2 MaxParticleSize {
			get {
				return GetMaxParticleSize ();
			}
			set {
				SetMaxParticleSize (value);
			}
		}

		/// <summary>
		/// Return particle minimum time to live.
		/// Or
		/// Set particle minimum time to live.
		/// </summary>
		public float MinTimeToLive {
			get {
				return GetMinTimeToLive ();
			}
			set {
				SetMinTimeToLive (value);
			}
		}

		/// <summary>
		/// Return particle maximum time to live.
		/// Or
		/// Set particle maximum time to live.
		/// </summary>
		public float MaxTimeToLive {
			get {
				return GetMaxTimeToLive ();
			}
			set {
				SetMaxTimeToLive (value);
			}
		}

		/// <summary>
		/// Return particle minimum velocity.
		/// Or
		/// Set particle minimum velocity.
		/// </summary>
		public float MinVelocity {
			get {
				return GetMinVelocity ();
			}
			set {
				SetMinVelocity (value);
			}
		}

		/// <summary>
		/// Return particle maximum velocity.
		/// Or
		/// Set particle maximum velocity.
		/// </summary>
		public float MaxVelocity {
			get {
				return GetMaxVelocity ();
			}
			set {
				SetMaxVelocity (value);
			}
		}

		/// <summary>
		/// Return particle minimum rotation.
		/// Or
		/// Set particle minimum rotation.
		/// </summary>
		public float MinRotation {
			get {
				return GetMinRotation ();
			}
			set {
				SetMinRotation (value);
			}
		}

		/// <summary>
		/// Return particle maximum rotation.
		/// Or
		/// Set particle maximum rotation.
		/// </summary>
		public float MaxRotation {
			get {
				return GetMaxRotation ();
			}
			set {
				SetMaxRotation (value);
			}
		}

		/// <summary>
		/// Return particle minimum rotation speed.
		/// Or
		/// Set particle minimum rotation speed.
		/// </summary>
		public float MinRotationSpeed {
			get {
				return GetMinRotationSpeed ();
			}
			set {
				SetMinRotationSpeed (value);
			}
		}

		/// <summary>
		/// Return particle maximum rotation speed.
		/// Or
		/// Set particle maximum rotation speed.
		/// </summary>
		public float MaxRotationSpeed {
			get {
				return GetMaxRotationSpeed ();
			}
			set {
				SetMaxRotationSpeed (value);
			}
		}

		/// <summary>
		/// Return particle size additive modifier.
		/// Or
		/// Set particle size additive modifier.
		/// </summary>
		public float SizeAdd {
			get {
				return GetSizeAdd ();
			}
			set {
				SetSizeAdd (value);
			}
		}

		/// <summary>
		/// Return particle size multiplicative modifier.
		/// Or
		/// Set particle size multiplicative modifier.
		/// </summary>
		public float SizeMul {
			get {
				return GetSizeMul ();
			}
			set {
				SetSizeMul (value);
			}
		}

		/// <summary>
		/// Return how the particles rotate in relation to the camera.
		/// Or
		/// Set how the particles should rotate in relation to the camera. Default is to follow camera rotation on all axes (FC_ROTATE_XYZ.)
		/// </summary>
		public FaceCameraMode FaceCameraMode {
			get {
				return GetFaceCameraMode ();
			}
			set {
				SetFaceCameraMode (value);
			}
		}

		/// <summary>
		/// Return number of color animation frames.
		/// Or
		/// Set number of color frames.
		/// </summary>
		public uint NumColorFrames {
			get {
				return GetNumColorFrames ();
			}
			set {
				SetNumColorFrames (value);
			}
		}

		/// <summary>
		/// Return number of texture animation frames.
		/// Or
		/// Set number of texture frames.
		/// </summary>
		public uint NumTextureFrames {
			get {
				return GetNumTextureFrames ();
			}
			set {
				SetNumTextureFrames (value);
			}
		}

		/// <summary>
		/// Return random direction.
		/// </summary>
		public Vector3 RandomDirection {
			get {
				return GetRandomDirection ();
			}
		}

		/// <summary>
		/// Return random size.
		/// </summary>
		public Vector2 RandomSize {
			get {
				return GetRandomSize ();
			}
		}

		/// <summary>
		/// Return random velocity.
		/// </summary>
		public float RandomVelocity {
			get {
				return GetRandomVelocity ();
			}
		}

		/// <summary>
		/// Return random timetolive.
		/// </summary>
		public float RandomTimeToLive {
			get {
				return GetRandomTimeToLive ();
			}
		}

		/// <summary>
		/// Return random rotationspeed.
		/// </summary>
		public float RandomRotationSpeed {
			get {
				return GetRandomRotationSpeed ();
			}
		}

		/// <summary>
		/// Return random rotation.
		/// </summary>
		public float RandomRotation {
			get {
				return GetRandomRotation ();
			}
		}
	}
}