EffectParticle.c

См. документацию.

class EffectParticle : Effect
{
    protected Particle  m_ParticleObj;
    

    protected int           m_ParticleID;
    protected vector      m_Orientation;
    protected EffectSound    m_EffectSound;
    protected int           m_PPFlags;
        
    protected vector          m_ParticleOrientation;
    protected Object      m_Object;
    
    
    
    void EffectParticle()
    {
    }
    
    void ~EffectParticle()
    {
        if(m_EffectSound)
        {
            SEffectManager.DestroySound(m_EffectSound);
        }
    }
        
    override void InitEffect()
    {
        super.InitEffect();
        
        // Would be neat, but since particles are often already playing
        // BEFORE they are even registered as the particle for the Effect
        // Better to just keep that one I guess..
        // Event_OnStarted.Remove(Event_OnEffectStarted);
        
        // Will be called by the particle events
        Event_OnStopped.Remove(Event_OnEffectEnded);
    }
    
    
    override string GetDebugName()
    {
        string identifier;
        if (GetParticle())
        {
            identifier = GetParticle().GetDebugNameNative();
        }
        else
        {
            identifier = "NO_PARTICLE";
        }
        
        return string.Format("%1:%2:%3", super.GetDebugName(), m_ParticleID, identifier);
    }
    
    override void ValidateStart()
    {
        if (!GetParticle())
        {
            //ErrorEx(string.Format("No Particle started playing, stopping EffectParticle: %1", GetDebugName()), ErrorExSeverity.WARNING);
            Stop();
        }
    }
    
    
    
    
    override EffectType GetEffectType()
    {
        return EffectType.PARTICLE;
    }
    
    override bool IsParticle()
    {
        return true;
    }
    
    
    
    
    
    void SetParticle(Particle p)
    {
        // Unregister the events on the old
        if (m_ParticleObj)
        {
            ParticleEvents ope = m_ParticleObj.GetEvents();
            ope.Event_OnParticleStart.Remove(Event_OnEffectStarted);
            ope.Event_OnParticleStop.Remove(Event_OnEffectEnded);
        }
        
        // Assign the new main Particle
        m_ParticleObj = p;
        
        // Register the events on the new
        if (m_ParticleObj)
        {
            ParticleEvents npe = m_ParticleObj.GetEvents();
            npe.Event_OnParticleStart.Insert(Event_OnEffectStarted);
            // We will use Stop instead of End, as old particles were destroyed when they stopped
            // And this system kinda relies on that
            npe.Event_OnParticleStop.Insert(Event_OnEffectEnded);
        }
    }
    
    Particle GetParticle()
    {
        return m_ParticleObj;
    }
    
    
    
    
    
    override void Start()
    {       
        if (m_ParticleID > 0)
        {
            vector pos = GetPosition();    
            vector ori = GetOrientation();
            
            if (m_ParentObject)
            {
                pos = GetLocalPosition();
                ori = GetAttachedLocalOri();
            }   
    
            SetParticle(ParticleManager.GetInstance().CreateParticleEx(m_ParticleID, pos, m_PPFlags, GetParent(), ori));
            if (m_ParticleObj)
            {
                if (m_EffectSound)
                {
                    if (GetParent())
                    {
                        SEffectManager.PlayOnObject(m_EffectSound, GetParent());
                    }
                    else
                    {
                        m_EffectSound.Start();
                    }   
                }
 
                m_ParticleObj.PlayParticleEx(m_ParticleID);
            }
        }
 
        super.Start();
    }
    
    override void Stop()
    {
        if ( GetParticle() )
        {
            GetParticle().Stop();
            SetParticle(null);
        }
        
        if (m_EffectSound)
        {
            m_EffectSound.Stop();
        }
        
        super.Stop();
    }   

    
    
    
    
    void AttachTo(Object obj, vector local_pos = "0 0 0", vector local_ori = "0 0 0", bool force_rotation_to_world = false)
    {
        // Update the cached variables...
        SetParent(obj);
        SetLocalPosition(local_pos);
        SetAttachedLocalOri(local_ori);
        ForceParticleRotationRelativeToWorld(force_rotation_to_world);
        
        // Now attach it
        AddAsChild(obj, local_pos, local_ori, force_rotation_to_world);
    }
    
    void ReAttach()
    {
        // Skip the updating, as we are going to reuse what was set before
        AddAsChild( GetParent(), GetLocalPosition(), GetAttachedLocalOri(), IsParticleRotationRelativeToWorld());
    }
    
    protected void AddAsChild(Object obj, vector local_pos, vector local_ori, bool force_rotation_to_world)
    {
        Particle p = GetParticle();      
        if (p)
        {
            p.AddAsChild(obj, local_pos, local_ori, force_rotation_to_world);
        }
    }
    
    
    
    
    
    void Event_OnPlayStart()
    {
        
    }
    
    void Event_OnPlayStarted()
    {
 
    }

    
    
    
    
    void SetParticleID( int id )
    {
        m_ParticleID = id;
    }
    
    int GetParticleID()
    {
        return m_ParticleID;
    }
    
    void SetCurrentParticleID( int id )
    {
        m_ParticleID = id;
        
        Particle p = GetParticle();
        if (p)
        {
            p.SetSource(id);
        }
    }
    
    int GetCurrentParticleID()
    {
        Particle p = GetParticle();
        if (p)
        {
            return p.GetParticleID();
        }
        else
        {
            return ParticleList.INVALID;
        }
    }
    
    override void SetCurrentParent( Object parent_obj, bool updateCached = true )
    {
        super.SetCurrentParent(parent_obj, updateCached);
        
        ReAttach();
    }
    
    override Object GetCurrentParent()
    {
        Particle p = GetParticle();
            
        if (p)
            return Object.Cast(p.GetParent());
        else
            return super.GetParent();
    }
    
    override void SetCurrentPosition( vector pos, bool updateCached = true )
    {
        super.SetCurrentPosition(pos, updateCached);
        
        Particle p = GetParticle();
        
        if (p)
            p.SetPosition(pos);
    }
    
    override vector GetCurrentPosition()
    {
        Particle p = GetParticle();  
        
        if (p)
            return p.GetPosition();
        else
            return super.GetPosition();
    }
    
    override void SetCurrentLocalPosition( vector pos, bool updateCached = true )
    {
        super.SetCurrentLocalPosition(pos, updateCached);
        
        Particle p = GetParticle();          
        if (p)
        {
            Object parent = GetParent();
            
            if (parent)
                ReAttach();
            else
                p.SetPosition(pos);
        }
    }

    override vector GetCurrentLocalPosition()
    {
        Particle p = GetParticle(); 
        
        if (p)
        {
            Object parent = GetParent();
            
            if (parent)
                return parent.WorldToModel(p.GetPosition());
            else
                return p.GetPosition();
        }
        else
            return super.GetLocalPosition();
    }
    
    void SetOrientation( vector ori )
    {
        m_Orientation = ori;
    }
    
    vector GetOrientation()
    {
        return m_Orientation;
    }
    
    void SetCurrentOrientation( vector ori, bool updateCached = true )
    {
        if ( updateCached)
            SetOrientation(ori);
        
        Particle p = GetParticle();  
                
        if (p)
            p.SetOrientation(ori);
    }
    
    vector GetCurrentOrientation()
    {
        Particle p = GetParticle();  
        
        if (p)
            return p.GetOrientation();
        else
            return vector.Zero;
    }
    
    protected void AddParticlePropertiesFlag(ParticlePropertiesFlags flag)
    {
        m_PPFlags = m_PPFlags | flag;
    }
    
    protected void RemoveParticlePropertiesFlag(ParticlePropertiesFlags flag)
    {
        m_PPFlags = m_PPFlags & ~flag;
    }
    
    protected bool IsSetParticlePropertiesFlag(ParticlePropertiesFlags flag)
    {
        return m_PPFlags & flag;
    }
    
    void ForceParticleRotationRelativeToWorld(bool state)
    {
        if (state)
            AddParticlePropertiesFlag(ParticlePropertiesFlags.FORCE_WORLD_ROT);
        else
            RemoveParticlePropertiesFlag(ParticlePropertiesFlags.FORCE_WORLD_ROT);
    }
    
    bool IsParticleRotationRelativeToWorld()
    {
        Particle p = GetParticle();
 
        if (p)
            return p.IsHierarchyPositionOnly();
        else
            return IsSetParticlePropertiesFlag(ParticlePropertiesFlags.FORCE_WORLD_ROT);
    }
    
    void DisableParticleInUI(bool disable)
    {
        if (disable)
            AddParticlePropertiesFlag(ParticlePropertiesFlags.DISABLED_IN_UI);
        else
            RemoveParticlePropertiesFlag(ParticlePropertiesFlags.DISABLED_IN_UI);
    }
 
    bool IsDisableParticleInUI()
    {
        return IsSetParticlePropertiesFlag(ParticlePropertiesFlags.DISABLED_IN_UI);
    }
    
    bool IsParticleCurrentRotationRelativeToWorld()
    {
        Particle p = GetParticle();  
        
        if (p)
            return p.IsHierarchyPositionOnly();
        else
            return false;
    }
      
    void SetEffectSound(EffectSound effectSound)
    {
        if (m_EffectSound)
        {
            SEffectManager.DestroySound(m_EffectSound);
        }
        m_EffectSound = effectSound;
    }
    
    void SelectFromSurface(string surface);
    void SelectFromSurface(SurfaceInfo surfaceInfo);
    
    void SetParticleState(int state);

    void ParticleParamsOverride(notnull ParticleParamsOverrideData data);
    
    
    void CheckLifeSpan()
    {
        /*
        if ( !m_ParticleObj )
        {
            delete this;
        }
        
        OnCheckUpdate();
        */
    }
 
    void SetDecalOwner(Object o)
    {
        m_Object = o;
    }
    
}
 
class ParticleParamsOverrideData
{
    ref TFloatArray m_FloatModifiers = new TFloatArray();
    
    void ClearAll()
    {
        m_FloatModifiers.Clear();
    }
}