ParticleManager.c

Go to the documentation of this file.

 
enum ParticleManagerSettingsFlags
{
  NONE,
  FIXED_INDEX,
  BLOCKING,
  DISABLE_VIRTUAL,
  REUSE_OWNED,
};
 
class ParticleManagerConstants
{
  static const int POOL_SIZE = 10000;
  static const int FLAGS = ParticleManagerSettingsFlags.NONE;
}
 
class ParticleManagerSettings
{
  void ParticleManagerSettings(int poolSize, int flags = ParticleManagerSettingsFlags.NONE)
  {
  }
 
  void ~ParticleManagerSettings()
  {
  }
}
 
class ParticleManagerEvents
{
  ref ScriptInvoker Event_OnAllocation = new ScriptInvoker();
  ref ScriptInvoker Event_OnAllocationEnd = new ScriptInvoker();
}
 
class ParticleManager : Managed
{
  private static ref ParticleManager g_ParticleManager;
 
  static ParticleManager GetInstance()
  {
    if (!g_ParticleManager && !GetGame().IsDedicatedServer())
    {
      g_ParticleManager = new ParticleManager(
        new ParticleManagerSettings(
          ParticleManagerConstants.POOL_SIZE,
          ParticleManagerConstants.FLAGS));
      g_ParticleManager.SetName("GlobalParticleManager");
    }
 
    return g_ParticleManager;
  }
 
  static void CleanupInstance()
  {
    if (g_ParticleManager)
      delete g_ParticleManager;
  }
 
  void ParticleManager(ParticleManagerSettings settings)
  {
  }
 
  void ~ParticleManager()
  {
  }
 
 
 
  ParticleSource CreateParticle(int id, vector pos, bool playOnCreation = false, Object parent = null, vector ori = vector.Zero, bool forceWorldRotation = false, Class owner = null)
  {
    int flags = ParticlePropertiesFlags.NONE;
 
    if (playOnCreation)
      flags = flags | ParticlePropertiesFlags.PLAY_ON_CREATION;
 
    if (forceWorldRotation)
      flags = flags | ParticlePropertiesFlags.FORCE_WORLD_ROT;
 
    return CreateParticleEx(id, pos, flags, parent, ori, owner);
  }
 
  ParticleSource CreateParticleEx(int id, vector pos, int flags = ParticlePropertiesFlags.NONE, Object parent = null, vector ori = vector.Zero, Class owner = null)
  {
    string particlePath = ParticleList.GetParticleFullPath(id);
    if (particlePath == "") // There is already an error inside of ParticleList signaling this
    {
      ErrorEx(string.Format("Could not create ParticleSource as particle id %1 is invalid.", id));
      return null;
    }
 
    ParticleProperties props = new ParticleProperties(pos, flags, parent, ori, owner);
    ParticleSource p = CreateParticleByPath(particlePath, props);
    return p;
  }
 
  ParticleSource CreateOnObject(
    int particle_id,
    Object parent_obj,
    vector local_pos = "0 0 0",
    vector local_ori = "0 0 0",
    bool force_world_rotation = false)
  {
    return CreateParticle(particle_id, local_pos, false, parent_obj, local_ori, force_world_rotation);
  }
 
  ParticleSource Create(int particle_id, Object parent_obj, vector local_pos = "0 0 0", vector local_ori = "0 0 0")
  {
    return CreateOnObject(particle_id, parent_obj, local_pos, local_ori);
  }
 
  ParticleSource CreateInWorld(int particle_id, vector global_pos, vector global_ori = "0 0 0", bool force_world_rotation = false)
  {
    return CreateParticle(particle_id, global_pos, false, null, global_ori, force_world_rotation);
  }
 
  ParticleSource Create(int particle_id, vector global_pos, vector global_ori = "0 0 0")
  {
    return CreateInWorld(particle_id, global_pos, global_ori);
  }
 
 
 
 
  ParticleSource PlayOnObject(int particle_id, Object parent_obj, vector local_pos = "0 0 0", vector local_ori = "0 0 0", bool force_world_rotation = false)
  {
    return CreateParticle(particle_id, local_pos, true, parent_obj, local_ori, force_world_rotation);
  }
 
  ParticleSource Play(int particle_id, Object parent_obj, vector local_pos = "0 0 0", vector local_ori = "0 0 0")
  {
    return PlayOnObject(particle_id, parent_obj, local_pos, local_ori);
  }
 
  ParticleSource PlayInWorld(int particle_id, vector global_pos)
  {
    return PlayInWorldEx(particle_id, null, global_pos);
  }
 
  ParticleSource PlayInWorldEx(int particle_id, Object parent_obj, vector global_pos, vector global_ori = "0 0 0", bool force_world_rotation = false)
  {
    return CreateParticle(particle_id, global_pos, true, parent_obj, global_ori, force_world_rotation);
 
  }
 
  ParticleSource Play(int particle_id, vector global_pos)
  {
    return PlayInWorld(particle_id, global_pos);
  }
 
 
 
 
  proto native int CreateParticles(array<ParticleSource> particles, string path, notnull ParticlePropertiesArray properties, int count = 1);
 
  ParticleSource CreateParticleByPath(string path, notnull ParticleProperties properties)
  {
    array<ParticleSource> tempArr = new array<ParticleSource>;
    CreateParticles(tempArr, path, {properties}, 1);
 
    if (tempArr.Count() > 0)
      return tempArr[0];
    else
      return null;
  }
 
  int CreateParticlesById(int id, notnull ParticlePropertiesArray properties, int count)
  {
    return CreateParticles(null, ParticleList.GetParticleFullPath(id), properties, count);
  }
 
  array<ParticleSource> CreateParticlesByIdArr(int id, notnull ParticlePropertiesArray properties, int count)
  {
    array<ParticleSource> outArr = new array<ParticleSource>;
    CreateParticles(outArr, ParticleList.GetParticleFullPath(id), properties, count);
    return outArr;
  }
 
  ParticleSource CreateParticleById(int id, ParticleProperties properties)
  {
    array<ParticleSource> tempArr = new array<ParticleSource>;
    CreateParticles(tempArr, ParticleList.GetParticleFullPath(id), {properties}, 1);
 
    if (tempArr.Count() > 0)
      return tempArr[0];
    else
      return null;
  }
 
  proto native int PlayParticles(out array<ParticleSource> particles, string path, notnull array<vector> positions, int count = 1);
 
  array<ParticleSource> PlayParticlesById(int id, array<vector> positions, int count)
  {
    array<ParticleSource> outArr = new array<ParticleSource>;
    PlayParticles(outArr, ParticleList.GetParticleFullPath(id), positions, count);
    return outArr;
  }
 
  ParticleSource PlayParticleById(int id, array<vector> position)
  {
    array<ParticleSource> tempArr = new array<ParticleSource>;
    PlayParticles(tempArr, ParticleList.GetParticleFullPath(id), position, 1);
 
    if (tempArr.Count() > 0)
      return tempArr[0];
    else
      return null;
  }
 
  proto native ParticleSource GetParticle(int index);
 
  proto native int GetParticles(out array<ParticleSource> outArray, int startIndex, int count);
 
  array<ParticleSource> GetParticlesEx(int startIndex, int count)
  {
    array<ParticleSource> outArr = new array<ParticleSource>;
    GetParticles(outArr, startIndex, count);
    return outArr;
  }
 
 
 
 
  proto native void SetName(string name);
 
  proto string GetName();
 
  proto string GetDebugNameNative();
 
  override string GetDebugName()
  {
    return GetDebugNameNative();
  }
 
  proto int GetCountID();
 
  proto native static int GetStaticCount();
 
  proto native static int GetStaticActiveCount();
 
 
 
 
  proto native int GetPoolSize();
 
  proto native int GetAllocatedCount();
 
  proto native int GetVirtualCount();
 
  proto native int GetPlayingCount();
 
  proto native bool IsFinishedAllocating();
 
 
 
 
  private proto void SetScriptEvents(Managed events);
 
  private proto Managed GetScriptEvents();
 
  ParticleManagerEvents GetEvents()
  {
    return ParticleManagerEvents.Cast(GetScriptEvents());
  }
 
 
 
 
  void OnAllocation(array<ParticleSource> allocatedParticles)
  {
    GetEvents().Event_OnAllocation.Invoke(this, allocatedParticles);
  }
 
  void OnAllocationEnd()
  {
    GetEvents().Event_OnAllocationEnd.Invoke(this);
  }
 
}