ParticleSource.c

Go to the documentation of this file.

 
enum ParticleAutoDestroyFlags
{
  NONE,
  ON_END,
  ON_STOP,
  ALL,
}
 
enum PlayParticleFlags
{
  NONE,
  // Is just a placeholder for now
}
 
enum StopParticleFlags
{
  NONE,
  RESET,
  IMMEDIATE,
  VISIBLE,
  PAUSE,
}
 
enum EGetParticleMode
{
  FULL,
  NO_EXT,
  FILE,
}
 
enum ParticlePropertiesFlags
{
  NONE,
  PLAY_ON_CREATION,
  FORCE_WORLD_ROT,
  KEEP_PARENT_ON_END,
};
 
class ParticleProperties
{
  void ParticleProperties(vector localPos, int flags, Object parent = null, vector localOri = vector.Zero, Class owner = null)
  {
  }
 
  void ~ParticleProperties()
  {
  }
 
  proto Object GetParent();
  proto Class GetOwner();
  proto vector GetLocalPos();
  proto vector GetLocalOri();
  proto int GetPPFlags();
  proto bool IsPlayOnCreation();
  proto bool IsForceWorldRotation();
  proto bool IsKeepParentOnEnd();
}
 
typedef array<ref ParticleProperties> ParticlePropertiesArray;
typedef array<ParticleSource> ParticleSourceArray;
 
class ParticleSource : Particle
{
  void ParticleSource()
  {
    m_ParticleEffect = this;
  }
 
  void ~ParticleSource()
  {
  }
 
  override protected void ParticleInit() {}
 
  proto native void SetParticleAutoDestroyFlags(ParticleAutoDestroyFlags flags);
 
  void DisableAutoDestroy()
  {
    SetParticleAutoDestroyFlags(ParticleAutoDestroyFlags.NONE);
  }
 
  proto native int GetParticleAutoDestroyFlags();
 
 
  static 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);
  }
 
  static 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;
    }
 
    vector localPos = pos;
 
    if (parent)
      pos = parent.GetPosition();
 
    ParticleSource p = ParticleSource.Cast(GetGame().CreateObjectEx("ParticleSource", pos, ECE_LOCAL));
    p.SetParticle(particlePath);
    ParticleProperties props = new ParticleProperties(localPos, flags, parent, ori, owner);
    p.ApplyProperties(props);
 
    return p;
  }
 
  override static Particle 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);
  }
 
  override static Particle 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);
  }
 
  override static Particle 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);
  }
 
  override static ParticleSource Create(int particle_id, vector global_pos, vector global_ori = "0 0 0")
  {
    return CreateInWorld(particle_id, global_pos, global_ori);
  }
 
 
 
 
  override static Particle 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);
  }
 
  override static Particle 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);
  }
 
  override static Particle PlayInWorld(int particle_id, vector global_pos)
  {
    return CreateParticle(particle_id, global_pos, true);
  }
 
  override static Particle Play(int particle_id, vector global_pos)
  {
    return PlayInWorld(particle_id, global_pos);
  }
 
 
 
 
  private proto bool PlayParticleNative(int flags);
 
  override bool PlayParticleEx(int particle_id = -1, int flags = 0)
  {
    if (particle_id > -1)
    {
      // Here we can just do it directly
      // While with the old system it will not work when the particle is already created
      SetParticleByID(particle_id);
    }
 
    return PlayParticleNative(flags);
  }
 
  private proto bool StopParticleNative(int flags);
 
  override bool StopParticle(int flags = 0)
  {
    return StopParticleNative(flags);
  }
 
  private proto native bool ResetParticleNative();
 
  override bool ResetParticle()
  {
    return ResetParticleNative();
  }
 
  private proto native bool RestartParticleNative();
 
  override bool RestartParticle()
  {
    return RestartParticleNative();
  }
 
  private proto bool IsParticlePlayingNative();
 
  override bool IsParticlePlaying()
  {
    return IsParticlePlayingNative();
  }
 
 
 
 
  private proto native bool SetParticleNative(string path);
 
  private bool SetParticle(string path)
  {
    return SetParticleNative(path);
  }
 
  bool SetParticleByID(int id)
  {
    return SetParticle(ParticleList.GetParticleFullPath(id));
  }
 
  override void SetSource(int particle_id)
  {
    SetParticleByID(particle_id);
  }
 
 
 
 
  private proto bool GetParticleNative(out string path, EGetParticleMode mode);
 
  bool GetParticle(out string path, EGetParticleMode mode)
  {
    return GetParticleNative(path, mode);
  }
 
  override int GetParticleID()
  {
    string path;
    if (GetParticle(path, EGetParticleMode.FILE))
      return ParticleList.GetParticleIDByName(path);
    else
      return -1;
  }
 
  int GetParticleIDLegacy()
  {
    string path;
    if (GetParticle(path, EGetParticleMode.NO_EXT))
      return ParticleList.GetParticleID(path);
    else
      return -1;
  }
 
 
 
 
  private proto native bool ApplyPropertiesNative(ParticleProperties properties);
 
  bool ApplyProperties(ParticleProperties properties)
  {
    return ApplyPropertiesNative(properties);
  }
 
 
 
 
  override Object GetDirectParticleEffect()
  {
    return this;
  }
 
  override Object GetParticleParent()
  {
    return Object.Cast(GetParent());
  }
 
  private proto bool HasActiveParticleNative();
 
  override bool HasActiveParticle()
  {
    return HasActiveParticleNative();
  }
 
  private proto int GetParticleCountNative();
 
  override int GetParticleCount()
  {
    return GetParticleCountNative();
  }
 
  private proto bool IsRepeatNative();
 
  override bool IsRepeat()
  {
    return IsRepeatNative();
  }
 
  private proto float GetMaxLifetimeNative();
 
  override float GetMaxLifetime()
  {
    return GetMaxLifetimeNative();
  }
 
  proto native Class GetOwner();
 
  proto native void SetOwner(Class owner);
 
  proto native void Orphan();
 
 
 
 
  proto native ParticleManager GetParticleManager();
 
  proto native int GetIndex();
 
 
 
 
  proto int GetCountID();
 
  proto native static int GetStaticCount();
 
  proto native static int GetStaticActiveCount();
 
 
 
 
  override protected void OnParticleParented(IEntity parent)
  {
    m_ParentObject = Object.Cast(parent);
 
    super.OnParticleParented(parent);
  }
 
  override protected void OnParticleUnParented(IEntity parent)
  {
    m_ParentObject = null;
 
    // Since we have lost the parent, we will need to refresh the wiggle
    // As it uses a cached local position, which is now no longer correct
    if (!m_WiggleProcessing && IsWiggling())
    {
      float randomAngle = m_MaxOriWiggle;
      float randomInterval = m_MaxOriInterval;
      m_DefaultPos = m_DefaultWorldPos;
      m_DefaultOri = m_DefaultWorldOri;
 
      StopWiggle();
      SetWiggle(randomAngle, randomInterval);
    }
 
    super.OnParticleUnParented(parent);
  }
 
  override protected void OnParticleStop()
  {
    if (IsWiggling())
    {
      StopWiggle();
      delete m_RandomizeOri;
    }
 
    super.OnParticleStop();
  }
 
 
 
 
  override void AddAsChild(Object parent, vector local_pos = "0 0 0", vector local_ori = "0 0 0", bool force_rotation_to_world = false)
  {
    int flags = ParticlePropertiesFlags.NONE;
 
    if (force_rotation_to_world)
      flags = ParticlePropertiesFlags.FORCE_WORLD_ROT;
 
    ParticleProperties props = new ParticleProperties(local_pos, flags, parent, local_ori);
    ApplyProperties(props);
  }
 
 
 
 
  override void SetParticleParam(int parameter_id, float value)
  {
    SetParticleParm(this, -1, parameter_id, value);
  }
 
  override void SetParameter(int emitter, int parameter, float value)
  {
    SetParticleParm(this, emitter, parameter, value);
  }
 
  override void GetParameter(int emitter, int parameter, out float value)
  {
    GetParticleParm(this, emitter, parameter, value);
  }
 
  override float GetParameterEx(int emitter, int parameter)
  {
    float value;
    GetParticleParm(this, emitter, parameter, value);
    return value;
  }
 
  override void ScaleParticleParamFromOriginal(int parameter_id, float coef)
  {
    int emitors = GetParticleEmitorCount(this);
    for (int i = 0; i < emitors; ++i)
    {
      float value;
      GetParticleParmOriginal(this, i, parameter_id, value);
      SetParticleParm(this, i, parameter_id, value * coef);
    }
  }
 
  override void ScaleParticleParam(int parameter_id, float coef)
  {
    int emitors = GetParticleEmitorCount(this);
    for (int i = 0; i < emitors; ++i)
    {
      float value;
      GetParticleParm(this, i, parameter_id, value);
      SetParticleParm(this, i, parameter_id, value * coef);
    }
  }
 
  override void IncrementParticleParamFromOriginal(int parameter_id, float value)
  {
    int emitors = GetParticleEmitorCount(this);
    for (int i = 0; i < emitors; ++i)
    {
      float param;
      GetParticleParmOriginal(this, i, parameter_id, param);
      SetParticleParm(this, i, parameter_id, param + value);
    }
  }
 
  override void IncrementParticleParam(int parameter_id, float value)
  {
    int emitors = GetParticleEmitorCount(this);
    for (int i = 0; i < emitors; ++i)
    {
      float param;
      GetParticleParm(this, i, parameter_id, param);
      SetParticleParm(this, i, parameter_id, param + value);
    }
  }
 
 
 
 
  override void SetWiggle(float random_angle, float random_interval)
  {
    if (random_angle != 0 || random_interval != 0)
    {
      if (IsWiggling())
      {
        m_MaxOriWiggle = random_angle;
        m_MaxOriInterval = random_interval;
        return;
      }
 
      // We need the position to be accurate before storing it
      Update();
 
      // These are only ever used within the Wiggle API
      // To restore the properties after wiggling
      // So let's only set them within the Wiggle API c:
 
      m_DefaultPos = GetLocalPosition();
      m_DefaultOri = GetLocalYawPitchRoll();
      m_DefaultWorldPos = GetWorldPosition();
      m_DefaultWorldOri = GetYawPitchRoll();
      m_ForceOrientationRelativeToWorld = IsHierarchyPositionOnly();
    }
 
    super.SetWiggle(random_angle, random_interval);
  }
 
  override void StopWiggle()
  {
    bool wiggling = IsWiggling();
 
    super.StopWiggle();
 
    if (wiggling)
    {
      // Restore pre-wiggle orientation
      int flags = ParticlePropertiesFlags.NONE;
 
      if (m_ForceOrientationRelativeToWorld)
        flags = ParticlePropertiesFlags.FORCE_WORLD_ROT;
 
      ParticleProperties prop = new ParticleProperties(m_DefaultPos, flags, GetParticleParent(), m_DefaultOri, GetOwner());
      ApplyProperties(prop);
    }
  }
 
  override private void RandomizeOrientation()
  {
    if (ToDelete())
      return;
 
    m_WiggleProcessing = true;
 
    if (!m_RandomizeOri.IsRunning())
      m_RandomizeOri.Run(Math.RandomFloat(0, m_MaxOriInterval), this, "RandomizeOrientation", null, false);
 
    int flags = ParticlePropertiesFlags.NONE;
 
    if (m_ForceOrientationRelativeToWorld)
      flags = ParticlePropertiesFlags.FORCE_WORLD_ROT;
 
    ParticleProperties prop = new ParticleProperties(m_DefaultPos, flags, GetParticleParent(), m_DefaultOri + RandWiggleVector(), GetOwner());
    ApplyProperties(prop);
 
    m_WiggleProcessing = false;
  }
 
 
 
 
  override private void UpdateState() { ErrorEx("Should not be in use on ParticleSource."); }
 
  override private void DestroyParticleEffect() { ErrorEx("Should not be in use on ParticleSource."); }
 
  override private void CreateParticleEffect() { ErrorEx("Should not be in use on ParticleSource."); }
 
  override protected void EOnFrame(IEntity other, float timeSlice) { ErrorEx("Should not be in use on ParticleSource."); }
 
  override private void OnCheckAutoDelete() { ErrorEx("Should not be in use on ParticleSource."); }
 
  override private void OnToDelete() { ErrorEx("Should not be in use on ParticleSource."); }
 
}