rokojori_action_library/Runtime/Animation/Flash/Flash.cs

using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Text;
using Godot;
using System.Linq;

namespace Rokojori
{  
  [Tool]
  [GlobalClass, Icon("res://addons/rokojori_action_library/Icons/Flash.svg")]
  public partial class Flash:SequenceAction
  { 
    [Export]
    public FlashEffect flashEffect;

    // Node3D[] _targets = [];

    [Export]
    public Node3D[] targets;
    // {
    //   get => _targets;
    //   set 
    //   {
    //     _targets = value;
    //     _allTargets = null;
    //   } 
    // }

    [Export]
    public bool includeChildren = false;

    bool refresh = false;
    
    // Node3D[] _allTargets;
    // public Node3D[] allTargets 
    // {
    //   get 
    //   {
    //     if ( _allTargets != null )
    //     {
    //       return _allTargets;
    //     }

    //     if ( includeChildren )
    //     {
    //       _allTargets = Nodes.GetAnyChildren( _targets ).ToArray();
    //     }
    //     else
    //     {
    //       _allTargets = _targets;
    //     }

    //     _allTargets = Lists.Filter( Lists.From( allTargets ), t =>  t as GeometryInstance3D != null ).ToArray(); 

    //     return _allTargets;
      
    //   }  
    // }


    // int animationID = -1;
    // int actionID = -1;

    // Vector3 randomization;
    // List<Material> _materials;

    // OmniLight3D light = null;

    // [Export]
    // public Node3D debugProcessIndicator;

    // [Export]
    // public Vector3 debugProcessIndicatorFull = new Vector3( 5, 0, 0 );

    // [Export]
    // public StandardMaterial3D debugMaterial;

    public override string[] _GetConfigurationWarnings()
    {
      var warnigns = new List<string>();

      if ( flashEffect == null )
      {
        warnigns.Add( HierarchyName.Of( this ) + ":" + "No flash effect assigned");
      }

      for ( int i = 0; i < targets.Length; i++ )
      {
        if ( targets[ i ] == null )
        {
         warnigns.Add( HierarchyName.Of( this ) + ":" +"A null target is assigned in the targets array at index " + i );
        }
        
      }

      return warnigns.ToArray();
    }

    Color ComputeLightColor( Color color, float phase )
    {
      if ( phase < 5/100f )
      {
        var n = MathX.NormalizeClamped( phase, 0, 5/100f );
        color *= n;
        
      }
      else if ( phase > 95/100f )
      {
        var n = MathX.NormalizeClamped( phase, 1, 95/100f );
        color *= n;
      }
      
      return color;
    }

    List<Node3D> GetAllTargets()
    {
      var allTargets = new List<Node3D>();

      if ( includeChildren )
      {
        allTargets = Nodes.GetAnyChildren( targets );
      }
      else
      {
        allTargets.AddRange( targets );
      }

      allTargets = Lists.Filter( Lists.From( allTargets ), t =>  t as GeometryInstance3D != null ); 

      return allTargets;
    }

    int actionID = -1;

    protected override void _OnTrigger()
    {
      if ( actionID != -1 )
      {
        CancelAction( actionID );
      }


      actionID = DispatchStart();

      var currentTargets = GetAllTargets();

      if ( currentTargets.Count == 0 )
      {
        DispatchEnd( actionID );
        return;
      } 

      var runner = new FlashRunnerData();
      runner.targets = currentTargets;

      _runnerData[ actionID ] = runner;
      

      var random = LCG.WithSeed( networkSeed );

      // RJLog.Log( "Setting actionID id", actionID, GetLastSequenceActionID() ); 

      var flashCurve = flashEffect.flashCurve;
      var color = flashEffect.color.GetHDRColor();
      var timeline = TimeLineManager.Ensure( flashEffect.timeline );

      runner.randomization = flashCurve.Randomize( random );
      var duration = flashCurve.GetRandomizedDuration( runner.randomization );

      
      var transparentColor = color;
      var initialAlpha = transparentColor.A;

      transparentColor.A = 0;

      Material material = null;
      
      

      

      this.LogInfo( "Applying Targets:", currentTargets );

      OmniLight3D light;

      if ( FlashEffect.FlashLightMode.No_Light != flashEffect.lightMode )
      {
        runner.light = currentTargets[ 0 ].CreateChild<OmniLight3D>();
        light = runner.light;
        light.LightColor = ComputeLightColor( color, 0 );
        light.LightEnergy = 0;
        light.OmniRange = flashEffect.lightRange;
        light.ShadowEnabled = flashEffect.lightHasShadows;

        // RJLog.Log( "Created Light", light.Name );

      }

      if ( FlashEffect.MaterialMode.Flat_Standard3D == flashEffect.materialMode )
      {
        var standardMaterial = new StandardMaterial3D();
        standardMaterial.AlbedoColor = transparentColor;
        standardMaterial.ShadingMode = BaseMaterial3D.ShadingModeEnum.Unshaded;
        standardMaterial.Transparency = BaseMaterial3D.TransparencyEnum.Alpha;

        material = standardMaterial;
      }
      else if ( FlashEffect.MaterialMode.Fresnel_FresnelOverlay == flashEffect.materialMode )
      {
        var fresnelMaterial = new FresnelOverlayMaterial();
        fresnelMaterial.albedo.Set( transparentColor );

        material = fresnelMaterial;
      }
      else if ( FlashEffect.MaterialMode.Scan_ScanGradient == flashEffect.materialMode )
      {
        var scanMaterial = ScanGradientMaterial.White.Get();
        
        scanMaterial.albedo.Set( transparentColor );

        material = scanMaterial;
      }
      else if ( FlashEffect.MaterialMode.Shield_TriPlanarOverlay == flashEffect.materialMode )
      {
        var shieldMaterial = TriPlanarOverlayMaterial.WhiteShield.Get();
        
        shieldMaterial.albedo.Set( transparentColor );

        material = shieldMaterial;
      }
      else 
      {
        material = flashEffect.customMaterial;
        flashEffect.customFlashColorProperty.Set( material, transparentColor );
      } 

      

      runner.materials = new List<Material>();

      currentTargets.ForEach( 
        t =>
        {
          var m = (Material) material.Duplicate( true );

          runner.materials.Add( m );

          Materials.AddOverlay( t, m ); 

        }
      ); 

      var start = timeline.position;
      var end   = start + duration;



      runner.animationID = TimeLineManager.ScheduleSpanIn( timeline, 0, duration, 
        ( TimeLineSpan span, TimeLineSpanUpdateType type )=>
          {         

          // debugProcessIndicator.Position = debugProcessIndicatorFull * span.phase;

          if ( runner.animationID != span.id )
          {
            return;
          }          

          // debugProcessIndicator.Position = debugProcessIndicatorFull * span.phase;

          var phase = span.phase; 

          
          var value = flashCurve.Sample( span.elapsed );


          
          
          var phaseColor = color;
          phaseColor.A = value * initialAlpha;         

          this.LogInfo( phase, value );

          // debugMaterial.AlbedoColor = phaseColor;
 
          if ( runner.light != null )
          {
            runner.light.LightEnergy = value * flashEffect.lightFlashCurveScale;
            runner.light.LightColor = ComputeLightColor( color, phase );
          }

          runner.materials.ForEach(
            ( m )=>
            {
              if ( FlashEffect.MaterialMode.Flat_Standard3D == flashEffect.materialMode )
              {
                var sm = m as StandardMaterial3D;
                sm.AlbedoColor = phaseColor;
              }
              else if ( FlashEffect.MaterialMode.Fresnel_FresnelOverlay == flashEffect.materialMode )
              {
                var sm = m as FresnelOverlayMaterial;
                sm.albedo.Set( phaseColor );
              } 
              else if ( FlashEffect.MaterialMode.Scan_ScanGradient == flashEffect.materialMode )
              {
                var sm = m as ScanGradientMaterial;
                sm.albedo.Set( phaseColor );
                sm.offset.Set( phase );
              }     
              else if ( FlashEffect.MaterialMode.Shield_TriPlanarOverlay == flashEffect.materialMode )
              {
                var sm = m as TriPlanarOverlayMaterial;
                sm.albedo.Set( phaseColor );
              }     
              else if ( FlashEffect.MaterialMode.Custom_Material == flashEffect.materialMode )
              {
                var sm = m as ShaderMaterial;
                flashEffect.customFlashColorProperty.Set( sm, phaseColor );
              }      

            }
          );


          if ( type == TimeLineSpanUpdateType.End )
          {
            if ( runner.light != null )
            {
              runner.light.LightEnergy = 0;
              runner.light.LightColor = new Color( 0, 0, 0, 0 );
            }

            CancelAction( actionID );
            DispatchEnd( actionID );
          }
          

        },
        this
      ).id; 

 
    } 

    Dictionary<int,FlashRunnerData> _runnerData = new Dictionary<int, FlashRunnerData>();

    public override void CancelAction( int id )
    {
      if ( ! _runnerData.ContainsKey( id ))
      { 
        return;
      }

      var data = _runnerData[ id ];
      var light = data.light;
      var nodes = data.targets;
      var materials = data.materials;

      if ( light != null )
      {
        // RJLog.Log( "Removing Light", light.Name );
        Nodes.RemoveAndDelete( light );
      }

      RemoveMaterials( nodes, materials );      

      _runnerData.Remove( id );
    }

    void RemoveMaterials( List<Node3D> allTargets, List<Material> materials )
    {

      for ( int i = 0; i < allTargets.Count ; i++ )
      {
        Materials.RemoveOverlay( allTargets[ i ], materials[ i ] ); 
      }

      // _materials.Clear();
    }

    public class FlashRunnerData
    {
      public List<Node3D> targets;
      public List<Material> materials;
      public OmniLight3D light;
      public int animationID;
      public int actionID;
      public Vector3 randomization;
    }
  } 
}