void TriggerParticleEffects(AnimatePerOptions animate_per, PLAY_ITEM_EVENTS play_when)
{
if (m_current_letter_action.NumParticleEffectSetups > 0)
{
foreach (ParticleEffectSetup effect_setup in m_current_letter_action.ParticleEffectSetups)
{
if (effect_setup.m_play_when == play_when &&
(effect_setup.m_effect_assignment == PLAY_ITEM_ASSIGNMENT.PER_LETTER || effect_setup.m_effect_assignment_custom_letters.Contains(m_progression_variables.m_letter_value)))
{
if (!effect_setup.m_loop_play_once ||
m_anim_state_vars.m_active_loop_cycles == null ||
m_anim_state_vars.m_active_loop_cycles.Count == 0 ||
m_anim_state_vars.m_active_loop_cycles[0].FirstPass)
{
m_effect_manager_handle.PlayParticleEffect(
m_mesh,
m_flipped,
effect_setup,
m_progression_variables,
animate_per
);
}
}
}
}
}
public ParticleEffectInstanceManager(EffectManager effect_manager, Mesh character_mesh, bool letter_flipped, ParticleEffectSetup effect_setup, AnimationProgressionVariables progression_vars, AnimatePerOptions animate_per, ParticleEmitter particle_emitter = null, ParticleSystem particle_system = null)
{
m_particle_emitter = particle_emitter;
m_particle_system = particle_system;
m_letter_mesh = character_mesh;
m_letter_flipped = letter_flipped;
m_follow_mesh = effect_setup.m_follow_mesh;
m_duration = effect_setup.m_duration.GetValue(progression_vars, animate_per);
m_delay = effect_setup.m_delay.GetValue(progression_vars, animate_per);
m_position_offset = effect_setup.m_position_offset.GetValue(progression_vars, animate_per);
m_rotation_offset = Quaternion.Euler(effect_setup.m_rotation_offset.GetValue(progression_vars, animate_per));
m_rotate_with_letter = effect_setup.m_rotate_relative_to_letter;
m_effect_manager_handle = effect_manager;
m_active = false;
if(m_particle_emitter != null)
{
m_transform = m_particle_emitter.transform;
m_particle_emitter.emit = true;
m_particle_emitter.enabled = false;
}
else if(m_particle_system != null)
{
m_transform = m_particle_system.transform;
m_particle_system.playOnAwake = false;
m_particle_system.Play();
#if !UNITY_3_5 && UNITY_EDITOR
p_system_timer = 0;
#endif
}
}
public void ContinueAction(float animation_timer, LetterAnimation animation, AnimatePerOptions animate_per)
{
if (m_anim_state_vars.m_waiting_to_sync)
{
m_anim_state_vars.m_break_delay = 0;
m_anim_state_vars.m_waiting_to_sync = false;
// reset timer offset to compensate for the sync-up wait time
m_anim_state_vars.m_timer_offset = animation_timer;
// Progress letter animation index to next, and break out of the loop
int prev_action_idx = m_anim_state_vars.m_action_index;
// Set next action index
SetNextActionIndex(animation);
if (m_anim_state_vars.m_active)
{
if (!m_anim_state_vars.m_reverse && m_anim_state_vars.m_action_index_progress > m_anim_state_vars.m_action_index)
{
// Repeating the action again; check for unqiue random variable requests.
animation.GetAction(m_anim_state_vars.m_action_index).SoftReset(animation.GetAction(prev_action_idx), m_progression_variables, animate_per);
}
if (prev_action_idx != m_anim_state_vars.m_action_index)
{
UpdateLoopList(animation);
}
}
}
}
public int GetValue(AnimatePerOptions animate_per)
{
switch (animate_per)
{
case AnimatePerOptions.LETTER:
return m_letter_value;
case AnimatePerOptions.WORD:
return m_word_value;
case AnimatePerOptions.LINE:
return m_line_value;
}
return m_letter_value;
}
public int GetValue(AnimatePerOptions animate_per, bool consider_white_space = false)
{
switch (animate_per)
{
case AnimatePerOptions.LETTER:
return(consider_white_space ? m_letter_value_inc_white_space : m_letter_value);
case AnimatePerOptions.WORD:
return(m_word_value);
case AnimatePerOptions.LINE:
return(m_line_value);
}
return(m_letter_value);
}
int GetProgressionTotal(int num_letters, int num_words, int num_lines, AnimatePerOptions animate_per_default, AnimatePerOptions animate_per_override, bool overriden)
{
switch (overriden ? animate_per_override : animate_per_default)
{
case AnimatePerOptions.LETTER:
return(num_letters);
case AnimatePerOptions.WORD:
return(num_words);
case AnimatePerOptions.LINE:
return(num_lines);
}
return(num_letters);
}
public int GetValue(AnimatePerOptions animate_per)
{
switch (animate_per)
{
case AnimatePerOptions.LETTER:
return(m_letter_value);
case AnimatePerOptions.WORD:
return(m_word_value);
case AnimatePerOptions.LINE:
return(m_line_value);
}
return(m_letter_value);
}
public ParticleEffectInstanceManager(TextFxAnimationManager animation_manager, LetterSetup letter_setup_ref, ParticleEffectSetup effect_setup, AnimationProgressionVariables progression_vars, AnimatePerOptions animate_per, ParticleEmitter particle_emitter = null, ParticleSystem particle_system = null)
{
m_particle_emitter = particle_emitter;
m_particle_system = particle_system;
m_letter_setup_ref = letter_setup_ref;
m_follow_mesh = effect_setup.m_follow_mesh;
m_duration = effect_setup.m_duration.GetValue(progression_vars, animate_per);
m_delay = effect_setup.m_delay.GetValue(progression_vars, animate_per);
m_position_offset = effect_setup.m_position_offset.GetValue(null, progression_vars, animate_per);
m_rotation_offset = Quaternion.Euler(effect_setup.m_rotation_offset.GetValue(null, progression_vars, animate_per));
m_rotate_with_letter = effect_setup.m_rotate_relative_to_letter;
m_animation_manager = animation_manager;
m_active = false;
if(m_particle_emitter != null)
{
m_transform = m_particle_emitter.transform;
m_particle_emitter.emit = true;
m_particle_emitter.enabled = false;
// Set the layer of the effect if an override is specified
if(animation_manager.AnimationInterface.LayerOverride >= 0)
m_particle_emitter.gameObject.layer = animation_manager.AnimationInterface.LayerOverride;
}
else if(m_particle_system != null)
{
m_transform = m_particle_system.transform;
m_particle_system.playOnAwake = false;
m_particle_system.Play();
#if !UNITY_3_5 && UNITY_EDITOR
p_system_timer = 0;
#endif
// Set the layer of the effect if an override is specified
if(animation_manager.AnimationInterface.LayerOverride >= 0)
m_particle_system.gameObject.layer = animation_manager.AnimationInterface.LayerOverride;
}
}
void SetCurrentLetterAction(LetterAction letter_action, AnimatePerOptions animate_per)
{
m_current_letter_action = letter_action;
if (letter_action.m_action_type == ACTION_TYPE.ANIM_SEQUENCE)
{
m_action_delay = Mathf.Max(m_current_letter_action.m_delay_progression.GetValue(m_progression_variables, m_last_animate_per), 0);
}
m_action_duration = Mathf.Max(m_current_letter_action.m_duration_progression.GetValue(m_progression_variables, m_last_animate_per), 0);
// Check if action is in a loopreverse_onetime delay case. If so, set delay to 0.
if (m_anim_state_vars.m_active_loop_cycles != null &&
m_anim_state_vars.m_active_loop_cycles.Count > 0 &&
m_anim_state_vars.m_active_loop_cycles[0].m_delay_first_only &&
!m_anim_state_vars.m_active_loop_cycles[0].FirstPass &&
m_current_letter_action.m_delay_progression.Progression != (int)ValueProgression.Constant)
{
if (m_anim_state_vars.m_reverse || !m_current_letter_action.m_force_same_start_time)
{
m_action_delay = 0;
}
}
}
public void CalculateUniqueRandom(AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per, Vector3[] offset_vec)
{
int progression_idx = GetProgressionIndex(progression_variables, animate_per);
bool constant_offset = offset_vec != null && offset_vec.Length == 1;
m_values[progression_idx] = m_is_offset_from_last ? offset_vec[constant_offset ? 0 : progression_idx] : Vector3.zero;
m_values[progression_idx] += new Vector3(m_from.x + (m_to.x - m_from.x) * UnityEngine.Random.value, m_from.y + (m_to.y - m_from.y) * UnityEngine.Random.value, m_from.z + (m_to.z - m_from.z) * UnityEngine.Random.value);
}
public void CalculateUniqueRandom(AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per)
{
m_values[GetProgressionIndex(progression_variables, animate_per)] = m_from + (m_to - m_from) * UnityEngine.Random.value;
}
public void CalculateUniqueRandom(AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per, VertexColour[] offset_colours)
{
int progression_idx = GetProgressionIndex(progression_variables, animate_per);
bool constant_offset = offset_colours != null && offset_colours.Length == 1;
m_values[progression_idx] = m_is_offset_from_last ? offset_colours[constant_offset ? 0 : progression_idx].Clone() : new VertexColour(new Color(0, 0, 0, 0));
m_values[progression_idx] = m_values[progression_idx].Add(m_from.Add(m_to.Sub(m_from).Multiply(UnityEngine.Random.value)));
}
public void CalculateUniqueRandom(AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per, Vector3[] offset_vec)
{
int progression_idx = GetProgressionIndex(progression_variables, animate_per);
bool constant_offset = offset_vec != null && offset_vec.Length == 1;
m_values[progression_idx] = m_is_offset_from_last ? offset_vec[constant_offset ? 0 : progression_idx] : Vector3.zero;
m_values[progression_idx] += new Vector3(m_from.x + (m_to.x - m_from.x) * UnityEngine.Random.value, m_from.y + (m_to.y - m_from.y) * UnityEngine.Random.value, m_from.z + (m_to.z - m_from.z) * UnityEngine.Random.value);
}
public ParticleEffectInstanceManager(EffectManager effect_manager, Mesh character_mesh, bool letter_flipped, ParticleEffectSetup effect_setup, AnimationProgressionVariables progression_vars, AnimatePerOptions animate_per, ParticleEmitter particle_emitter = null, ParticleSystem particle_system = null)
{
m_particle_emitter = particle_emitter;
m_particle_system = particle_system;
m_letter_mesh = character_mesh;
m_letter_flipped = letter_flipped;
m_follow_mesh = effect_setup.m_follow_mesh;
m_duration = effect_setup.m_duration.GetValue(progression_vars, animate_per);
m_delay = effect_setup.m_delay.GetValue(progression_vars, animate_per);
m_position_offset = effect_setup.m_position_offset.GetValue(progression_vars, animate_per);
m_rotation_offset = Quaternion.Euler(effect_setup.m_rotation_offset.GetValue(progression_vars, animate_per));
m_rotate_with_letter = effect_setup.m_rotate_relative_to_letter;
m_effect_manager_handle = effect_manager;
m_active = false;
if (m_particle_emitter != null)
{
m_transform = m_particle_emitter.transform;
m_particle_emitter.emit = true;
m_particle_emitter.enabled = false;
}
else if (m_particle_system != null)
{
m_transform = m_particle_system.transform;
m_particle_system.playOnAwake = false;
m_particle_system.Play();
#if !UNITY_3_5 && UNITY_EDITOR
p_system_timer = 0;
#endif
}
}
public void ImportData(string data, bool force_clear_old_audio_particles = false)
{
if (force_clear_old_audio_particles)
ClearCachedAudioParticleInstances(true);
var json_data = JSONObject.Parse(data, true);
if (json_data != null)
{
m_animate_per = (AnimatePerOptions)(int)json_data["m_animate_per"].Number;
m_display_axis = (TextDisplayAxis)(int)json_data["m_display_axis"].Number;
if (json_data.ContainsKey("m_begin_delay"))
m_begin_delay = (float)json_data["m_begin_delay"].Number;
if (json_data.ContainsKey("m_begin_on_start"))
m_begin_on_start = json_data["m_begin_on_start"].Boolean;
if (json_data.ContainsKey("m_character_size"))
m_character_size = (float)json_data["m_character_size"].Number;
if (json_data.ContainsKey("m_line_height"))
m_line_height_factor = (float)json_data["m_line_height"].Number;
if (json_data.ContainsKey("m_max_width"))
m_max_width = (float)json_data["m_max_width"].Number;
if (json_data.ContainsKey("m_on_finish_action"))
m_on_finish_action = (ON_FINISH_ACTION)(int)json_data["m_on_finish_action"].Number;
if (json_data.ContainsKey("m_px_offset"))
m_px_offset = json_data["m_px_offset"].Obj.JSONtoVector2();
// if(json_data.ContainsKey("m_text")) m_text = json_data["m_text"].Str;
if (json_data.ContainsKey("m_text_alignment"))
m_text_alignment = (TextAlignment)(int)json_data["m_text_alignment"].Number;
if (json_data.ContainsKey("m_text_anchor"))
m_text_anchor = (TextAnchor)(int)json_data["m_text_anchor"].Number;
if (json_data.ContainsKey("m_time_type"))
m_time_type = (AnimationTime)(int)json_data["m_time_type"].Number;
m_master_animations = new List<LetterAnimation>();
LetterAnimation letter_anim;
foreach (var animation_data in json_data["LETTER_ANIMATIONS_DATA"].Array)
{
letter_anim = new LetterAnimation();
letter_anim.ImportData(animation_data.Obj);
m_master_animations.Add(letter_anim);
}
}
else
// Import string is not valid JSON, therefore assuming it is in the legacy data import format.
this.ImportLegacyData(data);
if (!Application.isPlaying && m_text.Equals(""))
m_text = "TextFx";
if (!m_text.Equals(""))
SetText(m_text);
ResetAnimation();
}
public void ImportData(string data, bool force_clear_old_audio_particles = false)
{
if(force_clear_old_audio_particles)
ClearCachedAudioParticleInstances(true);
Boomlagoon.JSON.JSONObject json_data = Boomlagoon.JSON.JSONObject.Parse(data, true);
if(json_data != null)
{
m_animate_per = (AnimatePerOptions) (int) json_data["m_animate_per"].Number;
if(json_data.ContainsKey("m_begin_delay")) m_begin_delay = (float) json_data["m_begin_delay"].Number;
if(json_data.ContainsKey("m_begin_on_start")) m_begin_on_start = json_data["m_begin_on_start"].Boolean;
if(json_data.ContainsKey("m_on_finish_action")) m_on_finish_action = (ON_FINISH_ACTION) (int) json_data["m_on_finish_action"].Number;
if(json_data.ContainsKey("m_time_type")) m_time_type = (AnimationTime) (int) json_data["m_time_type"].Number;
m_master_animations = new List<LetterAnimation>();
LetterAnimation letter_anim;
foreach(Boomlagoon.JSON.JSONValue animation_data in json_data["LETTER_ANIMATIONS_DATA"].Array)
{
letter_anim = new LetterAnimation();
letter_anim.ImportData(animation_data.Obj, m_animation_interface_reference.AssetNameSuffix);
m_master_animations.Add(letter_anim);
}
#if UNITY_EDITOR
m_preset_effect_settings = new List<PresetEffectSetting>();
// Import any Quick setup settings info
if(json_data.ContainsKey("PRESET_EFFECT_SETTINGS"))
{
PresetEffectSetting effectSetting;
foreach(Boomlagoon.JSON.JSONValue effectSettingData in json_data["PRESET_EFFECT_SETTINGS"].Array)
{
effectSetting = new PresetEffectSetting();
effectSetting.ImportData(effectSettingData.Obj);
m_preset_effect_settings.Add(effectSetting);
}
}
#endif
}
else
{
// Import string is not valid JSON, therefore assuming it is in the legacy data import format.
Debug.LogError("TextFx animation import failed. Non-valid JSON data provided");
this.ImportLegacyData(data);
#if UNITY_EDITOR
m_preset_effect_settings = new List<PresetEffectSetting>();
#endif
}
if(!Application.isPlaying && m_animation_interface_reference.Text.Equals(""))
m_animation_interface_reference.SetText("TextFx");
PrepareAnimationData ();
ResetAnimation();
// Update mesh
m_animation_interface_reference.UpdateTextFxMesh(MeshVerts, MeshColours);
#if UNITY_EDITOR
SceneView.RepaintAll();
#endif
}
void SetupMesh(LetterAction letter_action, float action_progress, bool first_action_call, AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per, float linear_progress)
{
if (first_action_call || !letter_action.StaticPosition || !letter_action.StaticRotation || !letter_action.StaticScale)
{
Vector3[] mesh_verts = new Vector3[4];
for (int idx = 0; idx < 4; idx++)
{
// rotate vertices
// handle letter anchor x-offset
Vector3 anchor_offset = Vector3.zero;
if (letter_action.m_letter_anchor == TextAnchor.UpperRight || letter_action.m_letter_anchor == TextAnchor.MiddleRight || letter_action.m_letter_anchor == TextAnchor.LowerRight)
{
anchor_offset += new Vector3(m_width, 0, 0);
}
else if (letter_action.m_letter_anchor == TextAnchor.UpperCenter || letter_action.m_letter_anchor == TextAnchor.MiddleCenter || letter_action.m_letter_anchor == TextAnchor.LowerCenter)
{
anchor_offset += new Vector3(m_width / 2, 0, 0);
}
// handle letter anchor y-offset
if (letter_action.m_letter_anchor == TextAnchor.MiddleLeft || letter_action.m_letter_anchor == TextAnchor.MiddleCenter || letter_action.m_letter_anchor == TextAnchor.MiddleRight)
{
anchor_offset += new Vector3(0, m_height / 2, 0);
}
else if (letter_action.m_letter_anchor == TextAnchor.LowerLeft || letter_action.m_letter_anchor == TextAnchor.LowerCenter || letter_action.m_letter_anchor == TextAnchor.LowerRight)
{
anchor_offset += new Vector3(0, m_height, 0);
}
mesh_verts[idx] = m_base_vertices[idx];
mesh_verts[idx] -= anchor_offset;
// Scale verts
// if(first_action_call) // || !letter_action.StaticScale)
// {
Vector3 from_scale = letter_action.m_start_scale.GetValue(progression_variables, animate_per);
Vector3 to_scale = letter_action.m_end_scale.GetValue(progression_variables, animate_per);
if (letter_action.m_scale_axis_ease_data.m_override_default)
{
mesh_verts[idx] = Vector3.Scale(mesh_verts[idx],
new Vector3(EffectManager.FloatLerp(from_scale.x, to_scale.x, EasingManager.GetEaseProgress(letter_action.m_scale_axis_ease_data.m_x_ease, linear_progress)),
EffectManager.FloatLerp(from_scale.y, to_scale.y, EasingManager.GetEaseProgress(letter_action.m_scale_axis_ease_data.m_y_ease, linear_progress)),
EffectManager.FloatLerp(from_scale.z, to_scale.z, EasingManager.GetEaseProgress(letter_action.m_scale_axis_ease_data.m_z_ease, linear_progress))));
}
else
{
mesh_verts[idx] = Vector3.Scale(mesh_verts[idx],
EffectManager.Vector3Lerp(
from_scale,
to_scale,
action_progress)
);
}
// }
// Rotate vert
// if(first_action_call) // || !letter_action.StaticRotation)
// {
Vector3 from_rotation = letter_action.m_start_euler_rotation.GetValue(progression_variables, animate_per);
Vector3 to_rotation = letter_action.m_end_euler_rotation.GetValue(progression_variables, animate_per);
if (letter_action.m_rotation_axis_ease_data.m_override_default)
{
mesh_verts[idx] = Quaternion.Euler
(
EffectManager.FloatLerp(from_rotation.x, to_rotation.x, EasingManager.GetEaseProgress(letter_action.m_rotation_axis_ease_data.m_x_ease, linear_progress)),
EffectManager.FloatLerp(from_rotation.y, to_rotation.y, EasingManager.GetEaseProgress(letter_action.m_rotation_axis_ease_data.m_y_ease, linear_progress)),
EffectManager.FloatLerp(from_rotation.z, to_rotation.z, EasingManager.GetEaseProgress(letter_action.m_rotation_axis_ease_data.m_z_ease, linear_progress))
) * mesh_verts[idx];;
}
else
{
mesh_verts[idx] = Quaternion.Euler(
EffectManager.Vector3Lerp(
from_rotation,
to_rotation,
action_progress)
)
* mesh_verts[idx];
}
// }
mesh_verts[idx] += anchor_offset;
// translate vert
Vector3 from_pos = (!letter_action.m_start_pos.m_force_position_override ? m_base_offset : Vector3.zero) + letter_action.m_start_pos.GetValue(progression_variables, animate_per);
Vector3 to_pos = (!letter_action.m_end_pos.m_force_position_override ? m_base_offset : Vector3.zero) + letter_action.m_end_pos.GetValue(progression_variables, animate_per);
if (letter_action.m_position_axis_ease_data.m_override_default)
{
mesh_verts[idx] += new Vector3(EffectManager.FloatLerp(from_pos.x, to_pos.x, EasingManager.GetEaseProgress(letter_action.m_position_axis_ease_data.m_x_ease, linear_progress)),
EffectManager.FloatLerp(from_pos.y, to_pos.y, EasingManager.GetEaseProgress(letter_action.m_position_axis_ease_data.m_y_ease, linear_progress)),
EffectManager.FloatLerp(from_pos.z, to_pos.z, EasingManager.GetEaseProgress(letter_action.m_position_axis_ease_data.m_z_ease, linear_progress)));
}
else
{
mesh_verts[idx] += EffectManager.Vector3Lerp(
from_pos,
to_pos,
action_progress);
}
}
m_mesh.vertices = mesh_verts;
}
if (first_action_call || !letter_action.StaticColour)
{
if (letter_action.m_use_gradient_start || letter_action.m_use_gradient)
{
start_colour = letter_action.m_start_vertex_colour.GetValue(progression_variables, animate_per);
}
else
{
start_colour = new VertexColour(letter_action.m_start_colour.GetValue(progression_variables, animate_per));
}
if (letter_action.m_use_gradient_end || letter_action.m_use_gradient)
{
end_colour = letter_action.m_end_vertex_colour.GetValue(progression_variables, animate_per);
}
else
{
end_colour = new VertexColour(letter_action.m_end_colour.GetValue(progression_variables, animate_per));
}
if (!m_flipped)
{
m_mesh.colors = new Color[] {
Color.Lerp(start_colour.top_right, end_colour.top_right, action_progress),
Color.Lerp(start_colour.top_left, end_colour.top_left, action_progress),
Color.Lerp(start_colour.bottom_left, end_colour.bottom_left, action_progress),
Color.Lerp(start_colour.bottom_right, end_colour.bottom_right, action_progress)
};
}
else
{
m_mesh.colors = new Color[] {
Color.Lerp(start_colour.top_left, end_colour.top_left, action_progress),
Color.Lerp(start_colour.bottom_left, end_colour.bottom_left, action_progress),
Color.Lerp(start_colour.bottom_right, end_colour.bottom_right, action_progress),
Color.Lerp(start_colour.top_right, end_colour.top_right, action_progress)
};
}
}
}
// Animates the letter mesh and return the current action index in use
public LETTER_ANIMATION_STATE AnimateMesh(bool force_render,
float timer,
TextAnchor text_anchor,
int lowest_action_progress,
LetterAnimation animation,
AnimatePerOptions animate_per,
float delta_time,
EffectManager effect_manager)
{
m_last_animate_per = animate_per;
if (animation.m_letter_actions.Count > 0 && m_anim_state_vars.m_action_index < animation.m_letter_actions.Count)
{
if (!m_anim_state_vars.m_active && !force_render)
{
return(LETTER_ANIMATION_STATE.STOPPED);
}
bool first_action_call = false;
if (m_anim_state_vars.m_action_index != m_anim_state_vars.m_prev_action_index)
{
SetCurrentLetterAction(animation.m_letter_actions[m_anim_state_vars.m_action_index]);
first_action_call = true;
m_anim_state_vars.m_started_action = false;
}
else if (m_current_letter_action == null)
{
SetCurrentLetterAction(animation.m_letter_actions[m_anim_state_vars.m_action_index]);
}
m_anim_state_vars.m_prev_action_index = m_anim_state_vars.m_action_index;
if (force_render)
{
SetupMesh(m_current_letter_action, m_anim_state_vars.m_action_progress, true, m_progression_variables, animate_per, m_anim_state_vars.m_linear_progress);
}
if (m_anim_state_vars.m_waiting_to_sync)
{
if (m_current_letter_action.m_action_type == ACTION_TYPE.BREAK)
{
if (!force_render && m_anim_state_vars.m_break_delay > 0)
{
m_anim_state_vars.m_break_delay -= delta_time;
if (m_anim_state_vars.m_break_delay <= 0)
{
ContinueAction(timer, animation, animate_per);
return(LETTER_ANIMATION_STATE.PLAYING);
}
}
return(LETTER_ANIMATION_STATE.WAITING);
}
else if (lowest_action_progress < m_anim_state_vars.m_action_index_progress)
{
return(LETTER_ANIMATION_STATE.PLAYING);
}
else if (!force_render)
{
m_anim_state_vars.m_waiting_to_sync = false;
// reset timer offset to compensate for the sync-up wait time
m_anim_state_vars.m_timer_offset = timer;
}
}
else if (!force_render && (m_current_letter_action.m_action_type == ACTION_TYPE.BREAK || (!m_anim_state_vars.m_reverse && m_current_letter_action.m_force_same_start_time && lowest_action_progress < m_anim_state_vars.m_action_index_progress)))
{
// Force letter to wait for rest of letters to be in sync
m_anim_state_vars.m_waiting_to_sync = true;
m_anim_state_vars.m_break_delay = Mathf.Max(m_current_letter_action.m_duration_progression.GetValue(m_progression_variables, animate_per), 0);
return(LETTER_ANIMATION_STATE.PLAYING);
}
if (force_render)
{
return(m_anim_state_vars.m_active ? LETTER_ANIMATION_STATE.PLAYING : LETTER_ANIMATION_STATE.STOPPED);
}
finished_action = -1;
m_anim_state_vars.m_action_progress = 0;
m_anim_state_vars.m_linear_progress = 0;
m_action_timer = timer - m_anim_state_vars.m_timer_offset;
if ((m_anim_state_vars.m_reverse || m_action_timer > m_action_delay))
{
m_anim_state_vars.m_linear_progress = (m_action_timer - (m_anim_state_vars.m_reverse ? 0 : m_action_delay)) / m_action_duration;
if (m_anim_state_vars.m_reverse)
{
if (m_action_timer >= m_action_duration)
{
m_anim_state_vars.m_linear_progress = 0;
}
else
{
m_anim_state_vars.m_linear_progress = 1 - m_anim_state_vars.m_linear_progress;
}
}
if (!m_anim_state_vars.m_started_action)
{
// TODO: implement more robust check for "in-sync" actions having already played the asigned audio/effect
// Just started animating action after delay. Handle any OnStart events
if (m_current_letter_action.m_audio_on_start != null && (m_progression_variables.m_letter_value == 0 || !m_current_letter_action.m_starting_in_sync || m_current_letter_action.m_audio_on_start_delay.m_progression != ValueProgression.Constant))
{
effect_manager.PlayAudioClip(m_current_letter_action.m_audio_on_start,
m_current_letter_action.m_audio_on_start_delay.GetValue(m_progression_variables, animate_per),
m_current_letter_action.m_audio_on_start_offset.GetValue(m_progression_variables, animate_per),
m_current_letter_action.m_audio_on_start_volume.GetValue(m_progression_variables, animate_per),
m_current_letter_action.m_audio_on_start_pitch.GetValue(m_progression_variables, animate_per));
}
if (m_current_letter_action.m_emitter_on_start != null && (m_current_letter_action.m_emitter_on_start_per_letter || m_progression_variables.m_letter_value == 0))
{
effect_manager.PlayParticleEffect(m_current_letter_action.m_emitter_on_start,
m_current_letter_action.m_emitter_on_start_delay.GetValue(m_progression_variables, animate_per),
m_current_letter_action.m_emitter_on_start_duration.GetValue(m_progression_variables, animate_per),
m_mesh,
m_current_letter_action.m_emitter_on_start_offset.GetValue(m_progression_variables, animate_per),
m_current_letter_action.m_emitter_on_start_follow_mesh);
}
m_anim_state_vars.m_started_action = true;
}
m_anim_state_vars.m_action_progress = EasingManager.GetEaseProgress(m_current_letter_action.m_ease_type, m_anim_state_vars.m_linear_progress);
if ((!m_anim_state_vars.m_reverse && m_anim_state_vars.m_linear_progress >= 1) || (m_anim_state_vars.m_reverse && m_action_timer >= m_action_duration + m_action_delay))
{
m_anim_state_vars.m_action_progress = m_anim_state_vars.m_reverse ? 0 : 1;
m_anim_state_vars.m_linear_progress = m_anim_state_vars.m_reverse ? 0 : 1;
if (!m_anim_state_vars.m_reverse)
{
finished_action = m_anim_state_vars.m_action_index;
}
int prev_action_idx = m_anim_state_vars.m_action_index;
float prev_delay = m_action_delay;
// Set next action index
SetNextActionIndex(animation);
if (m_anim_state_vars.m_active)
{
if (!m_anim_state_vars.m_reverse)
{
m_anim_state_vars.m_started_action = false;
}
if (!m_anim_state_vars.m_reverse && m_anim_state_vars.m_action_index_progress > m_anim_state_vars.m_action_index)
{
// Repeating the action again; check for unqiue random variable requests.
animation.m_letter_actions[m_anim_state_vars.m_action_index].SoftReset(animation.m_letter_actions[prev_action_idx], m_progression_variables, animate_per, m_anim_state_vars.m_action_index == 0);
}
else if (m_anim_state_vars.m_reverse)
{
animation.m_letter_actions[m_anim_state_vars.m_action_index].SoftResetStarts(animation.m_letter_actions[prev_action_idx], m_progression_variables, animate_per);
}
// Add to the timer offset
m_anim_state_vars.m_timer_offset += prev_delay + m_action_duration;
if (prev_action_idx != m_anim_state_vars.m_action_index)
{
UpdateLoopList(animation);
}
else
{
SetCurrentLetterAction(animation.m_letter_actions[m_anim_state_vars.m_action_index]);
}
}
}
}
SetupMesh(m_current_letter_action, m_anim_state_vars.m_action_progress, force_render || first_action_call, m_progression_variables, animate_per, m_anim_state_vars.m_linear_progress);
if (finished_action > -1)
{
// TODO: implement more robust check for "in-sync" actions having already played the asigned audio/effect
if (m_current_letter_action.m_audio_on_finish != null && (m_progression_variables.m_letter_value == 0 || !m_current_letter_action.m_starting_in_sync))
{
effect_manager.PlayAudioClip(m_current_letter_action.m_audio_on_finish,
m_current_letter_action.m_audio_on_finish_delay.GetValue(m_progression_variables, animate_per),
m_current_letter_action.m_audio_on_finish_offset.GetValue(m_progression_variables, animate_per),
m_current_letter_action.m_audio_on_finish_volume.GetValue(m_progression_variables, animate_per),
m_current_letter_action.m_audio_on_finish_pitch.GetValue(m_progression_variables, animate_per));
}
if (m_current_letter_action.m_emitter_on_finish != null && (m_current_letter_action.m_emitter_on_finish_per_letter || m_progression_variables.m_letter_value == 0))
{
effect_manager.PlayParticleEffect(m_current_letter_action.m_emitter_on_finish,
m_current_letter_action.m_emitter_on_finish_delay.GetValue(m_progression_variables, animate_per),
m_current_letter_action.m_emitter_on_finish_duration.GetValue(m_progression_variables, animate_per),
m_mesh,
m_current_letter_action.m_emitter_on_finish_offset.GetValue(m_progression_variables, animate_per),
m_current_letter_action.m_emitter_on_finish_follow_mesh);
}
}
}
else
{
// no actions found for this letter. Position letter in its default position
Vector3[] mesh_verts = new Vector3[4];
for (int idx = 0; idx < 4; idx++)
{
mesh_verts[idx] = m_base_vertices[idx] + m_base_offset;
}
m_mesh.vertices = mesh_verts;
m_anim_state_vars.m_active = false;
}
return(m_anim_state_vars.m_active ? LETTER_ANIMATION_STATE.PLAYING : LETTER_ANIMATION_STATE.STOPPED);
}
public void SetMeshState(int action_idx, float action_progress, LetterAnimation animation, AnimatePerOptions animate_per)
{
if (action_idx >= 0 && action_idx < animation.m_letter_actions.Count)
{
SetupMesh(animation.m_letter_actions[action_idx], Mathf.Clamp(action_progress, 0, 1), true, m_progression_variables, animate_per, Mathf.Clamp(action_progress, 0, 1));
}
else
{
// action not found for this letter. Position letter in its default position
Vector3[] mesh_verts = new Vector3[4];
for (int idx = 0; idx < 4; idx++)
{
mesh_verts[idx] = m_base_vertices[idx] + m_base_offset;
}
m_mesh.vertices = mesh_verts;
m_mesh.colors = new Color[] { Color.white, Color.white, Color.white, Color.white };
}
}
public VertexColour GetValue(AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per_default)
{
return GetValue(GetProgressionIndex(progression_variables,animate_per_default));
}
public void SetMeshState(int action_idx, float action_progress, LetterAnimation animation, AnimatePerOptions animate_per, EffectManager effect_manager)
{
if (action_idx >= 0 && action_idx < animation.NumActions)
{
SetupMesh(animation.GetAction(action_idx), action_idx > 0 ? animation.GetAction(action_idx - 1) : null, Mathf.Clamp(action_progress, 0, 1), m_progression_variables, animate_per, Mathf.Clamp(action_progress, 0, 1), effect_manager);
}
else
{
// action not found for this letter. Position letter in its default position
if (mesh_verts == null || mesh_verts.Length == 0)
{
mesh_verts = new Vector3[4];
}
for (int idx = 0; idx < 4; idx++)
{
mesh_verts[idx] = m_base_vertices[idx] + m_base_offset;
}
m_mesh.vertices = mesh_verts;
m_mesh.colors = new Color[] { Color.white, Color.white, Color.white, Color.white };
}
}
public void PlayAudioClip(AudioEffectSetup effect_setup, AnimationProgressionVariables progression_vars, AnimatePerOptions animate_per)
{
var sound_played = false;
AudioSource source = null;
if (m_audio_sources != null)
{
foreach (var a_source in m_audio_sources)
if (!a_source.isPlaying)
{
// audio source free to play a sound
source = a_source;
sound_played = true;
break;
}
if (!sound_played)
source = AddNewAudioChild();
}
else
source = AddNewAudioChild();
PlayClip(source, effect_setup.m_audio_clip, effect_setup.m_delay.GetValue(progression_vars, animate_per), effect_setup.m_offset_time.GetValue(progression_vars, animate_per), effect_setup.m_volume.GetValue(progression_vars, animate_per), effect_setup.m_pitch.GetValue(progression_vars, animate_per));
}
public void SoftReset(LetterAction prev_action, AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per, bool first_action = false)
{
if (m_use_gradient_start)
{
if (!m_offset_from_last && m_start_vertex_colour.UniqueRandom && !first_action)
m_start_vertex_colour.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_vertex_colour.Values : null);
}
else if (!m_offset_from_last && m_start_colour.UniqueRandom && !first_action)
m_start_colour.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_colour.Values : null);
if (!m_offset_from_last && !first_action)
{
if (m_start_pos.UniqueRandom)
m_start_pos.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_pos.Values : null);
if (m_start_euler_rotation.UniqueRandom)
m_start_euler_rotation.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_euler_rotation.Values : null);
if (m_start_scale.UniqueRandom)
m_start_scale.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_scale.Values : null);
}
// End State Unique Randoms
if (m_use_gradient_end)
{
if (m_end_vertex_colour.UniqueRandom)
m_end_vertex_colour.CalculateUniqueRandom(progression_variables, animate_per, m_start_vertex_colour.Values);
}
else if (m_end_colour.UniqueRandom)
m_end_colour.CalculateUniqueRandom(progression_variables, animate_per, m_start_colour.Values);
if (m_end_pos.UniqueRandom)
m_end_pos.CalculateUniqueRandom(progression_variables, animate_per, m_start_pos.Values);
if (m_end_euler_rotation.UniqueRandom)
m_end_euler_rotation.CalculateUniqueRandom(progression_variables, animate_per, m_start_euler_rotation.Values);
if (m_end_scale.UniqueRandom)
m_end_scale.CalculateUniqueRandom(progression_variables, animate_per, m_start_scale.Values);
// Timing unique randoms
if (m_delay_progression.UniqueRandom)
m_delay_progression.CalculateUniqueRandom(progression_variables, animate_per);
if (m_duration_progression.UniqueRandom)
m_duration_progression.CalculateUniqueRandom(progression_variables, animate_per);
if (m_audio_effects != null)
foreach (var effect_setup in m_audio_effects)
{
if (effect_setup.m_delay.UniqueRandom)
effect_setup.m_delay.CalculateUniqueRandom(progression_variables, animate_per);
if (effect_setup.m_offset_time.UniqueRandom)
effect_setup.m_offset_time.CalculateUniqueRandom(progression_variables, animate_per);
if (effect_setup.m_volume.UniqueRandom)
effect_setup.m_volume.CalculateUniqueRandom(progression_variables, animate_per);
if (effect_setup.m_pitch.UniqueRandom)
effect_setup.m_pitch.CalculateUniqueRandom(progression_variables, animate_per);
}
if (m_particle_effects != null)
foreach (var effect_setup in m_particle_effects)
{
if (effect_setup.m_position_offset.UniqueRandom)
effect_setup.m_position_offset.CalculateUniqueRandom(progression_variables, animate_per, null);
if (effect_setup.m_rotation_offset.UniqueRandom)
effect_setup.m_rotation_offset.CalculateUniqueRandom(progression_variables, animate_per, null);
if (effect_setup.m_delay.UniqueRandom)
effect_setup.m_delay.CalculateUniqueRandom(progression_variables, animate_per);
if (effect_setup.m_duration.UniqueRandom)
effect_setup.m_duration.CalculateUniqueRandom(progression_variables, animate_per);
}
}
public void PlayParticleEffect(Mesh character_mesh, bool m_letter_flipped, ParticleEffectSetup effect_setup, AnimationProgressionVariables progression_vars, AnimatePerOptions animate_per)
{
var effect_played = false;
if (effect_setup.m_legacy_particle_effect != null)
{
if (m_particle_emitters == null)
m_particle_emitters = new List<ParticleEmitter>();
foreach (var p_emitter in m_particle_emitters)
if (!p_emitter.emit && p_emitter.particleCount == 0 && p_emitter.name.Equals(effect_setup.m_legacy_particle_effect.name + "(Clone)"))
{
m_effect_managers.Add(new ParticleEffectInstanceManager(this, character_mesh, m_letter_flipped, effect_setup, progression_vars, animate_per, p_emitter));
effect_played = true;
break;
}
if (!effect_played)
{
var p_emitter = Instantiate(effect_setup.m_legacy_particle_effect) as ParticleEmitter;
m_particle_emitters.Add(p_emitter);
#if !UNITY_3_5
p_emitter.gameObject.SetActive(true);
#else
p_emitter.gameObject.SetActiveRecursively(true);
#endif
p_emitter.emit = false;
p_emitter.transform.parent = transform;
m_effect_managers.Add(new ParticleEffectInstanceManager(this, character_mesh, m_letter_flipped, effect_setup, progression_vars, animate_per, p_emitter));
}
}
else if (effect_setup.m_shuriken_particle_effect != null)
{
if (m_particle_systems == null)
m_particle_systems = new List<ParticleSystem>();
foreach (var p_system in m_particle_systems)
// check if particle system instance is currently not being used, and if it's the same type of effect that we're looking for.
if (!p_system.isPlaying && p_system.particleCount == 0 && p_system.name.Equals(effect_setup.m_shuriken_particle_effect.name + "(Clone)"))
{
m_effect_managers.Add(new ParticleEffectInstanceManager(this, character_mesh, m_letter_flipped, effect_setup, progression_vars, animate_per, particle_system: p_system));
effect_played = true;
break;
}
if (!effect_played)
{
// Make a new instance of the particleSystem effect and add to pool
var p_system = Instantiate(effect_setup.m_shuriken_particle_effect) as ParticleSystem;
m_particle_systems.Add(p_system);
#if !UNITY_3_5
p_system.gameObject.SetActive(true);
#else
p_system.gameObject.SetActiveRecursively(true);
#endif
p_system.playOnAwake = false;
p_system.Stop();
p_system.transform.parent = transform;
m_effect_managers.Add(new ParticleEffectInstanceManager(this, character_mesh, m_letter_flipped, effect_setup, progression_vars, animate_per, particle_system: p_system));
}
}
}
public void CalculateUniqueRandom(AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per, Color[] offset_cols)
{
int progression_idx = GetProgressionIndex(progression_variables, animate_per);
bool constant_offset = offset_cols != null && offset_cols.Length == 1;
m_values[progression_idx] = m_is_offset_from_last ? offset_cols[constant_offset ? 0 : progression_idx] : new Color(0, 0, 0, 0);
m_values[progression_idx] += m_from + (m_to - m_from) * UnityEngine.Random.value;
}
public VertexColour GetValue(List<LetterAction> all_letter_actions, AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per_default, ActionColorProgression defaultAnimColourProg)
{
return GetValue(all_letter_actions, GetProgressionIndex(progression_variables,animate_per_default), defaultAnimColourProg);
}
public void SoftReset(LetterAction prev_action, AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per, bool first_action = false)
{
if (m_use_gradient_start)
{
if (!m_offset_from_last && m_start_vertex_colour.UniqueRandom && !first_action)
{
m_start_vertex_colour.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_vertex_colour.Values : null);
}
}
else
{
if (!m_offset_from_last && m_start_colour.UniqueRandom && !first_action)
{
m_start_colour.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_colour.Values : null);
}
}
if (!m_offset_from_last && !first_action)
{
if (m_start_pos.UniqueRandom)
{
m_start_pos.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_pos.Values : null);
}
if (m_start_euler_rotation.UniqueRandom)
{
m_start_euler_rotation.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_euler_rotation.Values : null);
}
if (m_start_scale.UniqueRandom)
{
m_start_scale.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_scale.Values : null);
}
}
// End State Unique Randoms
if (m_use_gradient_end)
{
if (m_end_vertex_colour.UniqueRandom)
{
m_end_vertex_colour.CalculateUniqueRandom(progression_variables, animate_per, m_start_vertex_colour.Values);
}
}
else
{
if (m_end_colour.UniqueRandom)
{
m_end_colour.CalculateUniqueRandom(progression_variables, animate_per, m_start_colour.Values);
}
}
if (m_end_pos.UniqueRandom)
{
m_end_pos.CalculateUniqueRandom(progression_variables, animate_per, m_start_pos.Values);
}
if (m_end_euler_rotation.UniqueRandom)
{
m_end_euler_rotation.CalculateUniqueRandom(progression_variables, animate_per, m_start_euler_rotation.Values);
}
if (m_end_scale.UniqueRandom)
{
m_end_scale.CalculateUniqueRandom(progression_variables, animate_per, m_start_scale.Values);
}
// Timing unique randoms
if (m_delay_progression.UniqueRandom)
{
m_delay_progression.CalculateUniqueRandom(progression_variables, animate_per);
}
if (m_duration_progression.UniqueRandom)
{
m_duration_progression.CalculateUniqueRandom(progression_variables, animate_per);
}
if (m_audio_effects != null)
{
foreach (AudioEffectSetup effect_setup in m_audio_effects)
{
if (effect_setup.m_delay.UniqueRandom)
{
effect_setup.m_delay.CalculateUniqueRandom(progression_variables, animate_per);
}
if (effect_setup.m_offset_time.UniqueRandom)
{
effect_setup.m_offset_time.CalculateUniqueRandom(progression_variables, animate_per);
}
if (effect_setup.m_volume.UniqueRandom)
{
effect_setup.m_volume.CalculateUniqueRandom(progression_variables, animate_per);
}
if (effect_setup.m_pitch.UniqueRandom)
{
effect_setup.m_pitch.CalculateUniqueRandom(progression_variables, animate_per);
}
}
}
if (m_particle_effects != null)
{
foreach (ParticleEffectSetup effect_setup in m_particle_effects)
{
if (effect_setup.m_position_offset.UniqueRandom)
{
effect_setup.m_position_offset.CalculateUniqueRandom(progression_variables, animate_per, null);
}
if (effect_setup.m_rotation_offset.UniqueRandom)
{
effect_setup.m_rotation_offset.CalculateUniqueRandom(progression_variables, animate_per, null);
}
if (effect_setup.m_delay.UniqueRandom)
{
effect_setup.m_delay.CalculateUniqueRandom(progression_variables, animate_per);
}
if (effect_setup.m_duration.UniqueRandom)
{
effect_setup.m_duration.CalculateUniqueRandom(progression_variables, animate_per);
}
}
}
}
public int GetProgressionIndex(AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per_default, bool consider_white_space = false)
{
return progression_variables.GetValue(m_override_animate_per_option ? m_animate_per : animate_per_default, consider_white_space);
}
public void SoftReset(LetterAction prev_action, AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per, bool first_action = false)
{
if (m_use_gradient || m_use_gradient_start)
{
if (!m_offset_from_last && m_start_vertex_colour.UniqueRandom && !first_action)
{
m_start_vertex_colour.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_vertex_colour.m_values : null);
}
}
else
{
if (!m_offset_from_last && m_start_colour.UniqueRandom && !first_action)
{
m_start_colour.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_colour.m_values : null);
}
}
if (!m_offset_from_last && !first_action)
{
if (m_start_pos.UniqueRandom)
{
m_start_pos.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_pos.m_values : null);
}
if (m_start_euler_rotation.UniqueRandom)
{
m_start_euler_rotation.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_euler_rotation.m_values : null);
}
if (m_start_scale.UniqueRandom)
{
m_start_scale.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_scale.m_values : null);
}
}
// End State Unique Randoms
if (m_use_gradient || m_use_gradient_end)
{
if (m_end_vertex_colour.UniqueRandom)
{
m_end_vertex_colour.CalculateUniqueRandom(progression_variables, animate_per, m_start_vertex_colour.m_values);
}
}
else
{
if (m_end_colour.UniqueRandom)
{
m_end_colour.CalculateUniqueRandom(progression_variables, animate_per, m_start_colour.m_values);
}
}
if (m_end_pos.UniqueRandom)
{
m_end_pos.CalculateUniqueRandom(progression_variables, animate_per, m_start_pos.m_values);
}
if (m_end_euler_rotation.UniqueRandom)
{
m_end_euler_rotation.CalculateUniqueRandom(progression_variables, animate_per, m_start_euler_rotation.m_values);
}
if (m_end_scale.UniqueRandom)
{
m_end_scale.CalculateUniqueRandom(progression_variables, animate_per, m_start_scale.m_values);
}
// Timing unique randoms
if (m_delay_progression.UniqueRandom)
{
m_delay_progression.CalculateUniqueRandom(progression_variables, animate_per);
}
if (m_duration_progression.UniqueRandom)
{
m_duration_progression.CalculateUniqueRandom(progression_variables, animate_per);
}
if (m_audio_on_start != null)
{
if (m_audio_on_start_volume.UniqueRandom)
{
m_audio_on_start_volume.CalculateUniqueRandom(progression_variables, animate_per);
}
if (m_audio_on_start_delay.UniqueRandom)
{
m_audio_on_start_delay.CalculateUniqueRandom(progression_variables, animate_per);
}
if (m_audio_on_start_offset.UniqueRandom)
{
m_audio_on_start_offset.CalculateUniqueRandom(progression_variables, animate_per);
}
if (m_audio_on_start_pitch.UniqueRandom)
{
m_audio_on_start_pitch.CalculateUniqueRandom(progression_variables, animate_per);
}
}
if (m_audio_on_finish != null)
{
if (m_audio_on_finish_volume.UniqueRandom)
{
m_audio_on_finish_volume.CalculateUniqueRandom(progression_variables, animate_per);
}
if (m_audio_on_finish_delay.UniqueRandom)
{
m_audio_on_finish_delay.CalculateUniqueRandom(progression_variables, animate_per);
}
if (m_audio_on_finish_offset.UniqueRandom)
{
m_audio_on_finish_offset.CalculateUniqueRandom(progression_variables, animate_per);
}
if (m_audio_on_finish_pitch.UniqueRandom)
{
m_audio_on_finish_pitch.CalculateUniqueRandom(progression_variables, animate_per);
}
}
if (m_emitter_on_start != null)
{
if (m_emitter_on_start_offset.UniqueRandom)
{
m_emitter_on_start_offset.CalculateUniqueRandom(progression_variables, animate_per, null);
}
if (m_emitter_on_start_delay.UniqueRandom)
{
m_emitter_on_start_delay.CalculateUniqueRandom(progression_variables, animate_per);
}
if (m_emitter_on_start_duration.UniqueRandom)
{
m_emitter_on_start_duration.CalculateUniqueRandom(progression_variables, animate_per);
}
}
if (m_emitter_on_finish != null)
{
if (m_emitter_on_finish_offset.UniqueRandom)
{
m_emitter_on_finish_offset.CalculateUniqueRandom(progression_variables, animate_per, null);
}
if (m_emitter_on_finish_delay.UniqueRandom)
{
m_emitter_on_finish_delay.CalculateUniqueRandom(progression_variables, animate_per);
}
if (m_emitter_on_finish_duration.UniqueRandom)
{
m_emitter_on_finish_duration.CalculateUniqueRandom(progression_variables, animate_per);
}
}
}
public float GetValue(AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per_default, bool consider_white_space = false)
{
return GetValue(GetProgressionIndex(progression_variables,animate_per_default, consider_white_space));
}
public void CalculateUniqueRandom(AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per, Color[] offset_cols)
{
int progression_idx = GetProgressionIndex(progression_variables, animate_per);
bool constant_offset = offset_cols != null && offset_cols.Length == 1;
m_values[progression_idx] = m_is_offset_from_last ? offset_cols[constant_offset ? 0 : progression_idx] : new Color(0,0,0,0);
m_values[progression_idx] += m_from + (m_to - m_from) * UnityEngine.Random.value;
}
public Vector3 GetValue(List<LetterAction> all_letter_actions, AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per_default, bool consider_white_space = false)
{
int prog_index = GetProgressionIndex (progression_variables, animate_per_default, consider_white_space);
return GetValue(all_letter_actions, prog_index);
}
public int GetProgressionIndex(AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per_default)
{
return progression_variables.GetValue(m_override_animate_per_option ? m_animate_per : animate_per_default);
}
public void PrepareData(TextFxAnimationManager anim_manager,
ref LetterSetup[] letters,
LetterAnimation animation_ref,
int action_idx,
ANIMATION_DATA_TYPE what_to_update,
int num_letters,
int num_white_space_chars_to_include,
int num_words,
int num_lines,
LetterAction prev_action,
AnimatePerOptions animate_per,
ActionColorProgression defaultTextColour,
bool prev_action_end_state = true)
{
// Set progression reference datas
m_start_colour.SetReferenceData(action_idx, ANIMATION_DATA_TYPE.COLOUR, true);
m_start_euler_rotation.SetReferenceData(action_idx, ANIMATION_DATA_TYPE.LOCAL_ROTATION, true);
m_start_pos.SetReferenceData(action_idx, ANIMATION_DATA_TYPE.POSITION, true);
m_start_scale.SetReferenceData(action_idx, ANIMATION_DATA_TYPE.LOCAL_SCALE, true);
m_global_start_euler_rotation.SetReferenceData(action_idx, ANIMATION_DATA_TYPE.GLOBAL_ROTATION, true);
m_global_start_scale.SetReferenceData(action_idx, ANIMATION_DATA_TYPE.GLOBAL_SCALE, true);
m_end_colour.SetReferenceData(action_idx, ANIMATION_DATA_TYPE.COLOUR, false);
m_end_euler_rotation.SetReferenceData(action_idx, ANIMATION_DATA_TYPE.LOCAL_ROTATION, false);
m_end_pos.SetReferenceData(action_idx, ANIMATION_DATA_TYPE.POSITION, false);
m_end_scale.SetReferenceData(action_idx, ANIMATION_DATA_TYPE.LOCAL_SCALE, false);
m_global_end_euler_rotation.SetReferenceData(action_idx, ANIMATION_DATA_TYPE.GLOBAL_ROTATION, false);
m_global_end_scale.SetReferenceData(action_idx, ANIMATION_DATA_TYPE.GLOBAL_SCALE, false);
// Prepare Data
if(what_to_update == ANIMATION_DATA_TYPE.DURATION || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_duration_progression.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_duration_progression.AnimatePer, m_duration_progression.OverrideAnimatePerOption));
if((what_to_update == ANIMATION_DATA_TYPE.AUDIO_EFFECTS || what_to_update == ANIMATION_DATA_TYPE.ALL) && m_audio_effects != null)
{
foreach(AudioEffectSetup effect_setup in m_audio_effects)
{
effect_setup.m_delay.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_delay.AnimatePer, effect_setup.m_delay.OverrideAnimatePerOption));
effect_setup.m_offset_time.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_offset_time.AnimatePer, effect_setup.m_offset_time.OverrideAnimatePerOption));
effect_setup.m_volume.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_volume.AnimatePer, effect_setup.m_volume.OverrideAnimatePerOption));
effect_setup.m_pitch.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_pitch.AnimatePer, effect_setup.m_pitch.OverrideAnimatePerOption));
}
}
if((what_to_update == ANIMATION_DATA_TYPE.PARTICLE_EFFECTS || what_to_update == ANIMATION_DATA_TYPE.ALL) && m_particle_effects != null)
{
foreach(ParticleEffectSetup effect_setup in m_particle_effects)
{
effect_setup.m_position_offset.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_position_offset.AnimatePer, effect_setup.m_position_offset.OverrideAnimatePerOption), null);
effect_setup.m_rotation_offset.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_rotation_offset.AnimatePer, effect_setup.m_rotation_offset.OverrideAnimatePerOption), null);
effect_setup.m_delay.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_delay.AnimatePer, effect_setup.m_delay.OverrideAnimatePerOption));
effect_setup.m_duration.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_duration.AnimatePer, effect_setup.m_duration.OverrideAnimatePerOption));
}
}
if(m_action_type == ACTION_TYPE.BREAK)
{
if(prev_action != null)
{
m_start_colour.SetValueReference(prev_action_end_state ? prev_action.m_end_colour : prev_action.m_start_colour);
m_start_euler_rotation.SetValueReference( prev_action_end_state ? prev_action.m_end_euler_rotation : prev_action.m_start_euler_rotation );
m_start_pos.SetValueReference( prev_action_end_state ? prev_action.m_end_pos : prev_action.m_start_pos );
m_start_scale.SetValueReference( prev_action_end_state ? prev_action.m_end_scale : prev_action.m_start_scale );
m_global_start_euler_rotation.SetValueReference( prev_action_end_state ? prev_action.m_global_end_euler_rotation : prev_action.m_global_start_euler_rotation );
m_global_start_scale.SetValueReference( prev_action_end_state ? prev_action.m_global_end_scale : prev_action.m_global_start_scale );
}
m_end_colour.SetValueReference(m_start_colour);
m_end_euler_rotation.SetValueReference(m_start_euler_rotation );
m_end_pos.SetValueReference( prev_action.m_start_pos );
m_end_scale.SetValueReference( prev_action.m_start_scale );
m_global_end_euler_rotation.SetValueReference(prev_action.m_global_start_euler_rotation );
m_global_end_scale.SetValueReference( prev_action.m_global_start_scale );
return;
}
if (animation_ref.m_letters_to_animate_option != LETTERS_TO_ANIMATE.ALL_LETTERS || (((ValueProgression)m_delay_progression.Progression) != ValueProgression.Eased && ((ValueProgression)m_delay_progression.Progression) != ValueProgression.EasedCustom))
m_delay_with_white_space_influence = false;
if(what_to_update == ANIMATION_DATA_TYPE.DELAY || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_delay_progression.CalculateProgressions(GetProgressionTotal(num_letters + (m_delay_with_white_space_influence ? num_white_space_chars_to_include : 0), num_words, num_lines, animate_per, m_delay_progression.AnimatePer, m_delay_progression.OverrideAnimatePerOption));
if(what_to_update == ANIMATION_DATA_TYPE.COLOUR || what_to_update == ANIMATION_DATA_TYPE.ALL)
{
if(m_offset_from_last && prev_action != null)
{
m_start_colour.SetValueReference(prev_action_end_state ? prev_action.m_end_colour : prev_action.m_start_colour );
}
else
{
m_start_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_colour.AnimatePer, m_start_colour.OverrideAnimatePerOption),
prev_action != null ? prev_action.m_end_colour : defaultTextColour,
prev_action == null || m_colour_transition_active);
}
m_end_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_colour.AnimatePer, m_end_colour.OverrideAnimatePerOption),
m_start_colour,
prev_action == null || m_colour_transition_active);
}
if(m_offset_from_last && prev_action != null)
{
if(what_to_update == ANIMATION_DATA_TYPE.POSITION || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_start_pos.SetValueReference( prev_action_end_state ? prev_action.m_end_pos : prev_action.m_start_pos );
if(what_to_update == ANIMATION_DATA_TYPE.LOCAL_ROTATION || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_start_euler_rotation.SetValueReference( prev_action_end_state ? prev_action.m_end_euler_rotation : prev_action.m_start_euler_rotation );
if(what_to_update == ANIMATION_DATA_TYPE.LOCAL_SCALE || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_start_scale.SetValueReference( prev_action_end_state ? prev_action.m_end_scale : prev_action.m_start_scale );
if(what_to_update == ANIMATION_DATA_TYPE.GLOBAL_ROTATION || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_global_start_euler_rotation.SetValueReference( prev_action_end_state ? prev_action.m_global_end_euler_rotation : prev_action.m_global_start_euler_rotation );
if(what_to_update == ANIMATION_DATA_TYPE.GLOBAL_SCALE || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_global_start_scale.SetValueReference( prev_action_end_state ? prev_action.m_global_end_scale : prev_action.m_global_start_scale );
}
else
{
float[] start_pos_curve_letter_progressions = null;
if( ( what_to_update == ANIMATION_DATA_TYPE.POSITION ||
what_to_update == ANIMATION_DATA_TYPE.LOCAL_ROTATION ||
what_to_update == ANIMATION_DATA_TYPE.GLOBAL_ROTATION ||
what_to_update == ANIMATION_DATA_TYPE.ALL
)
&& m_start_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX)
{
// Pre calculate letter progression values based on letter spacing
start_pos_curve_letter_progressions = m_start_pos.BezierCurve.GetLetterProgressions(anim_manager, ref letters, m_letter_anchor_start);
}
if(what_to_update == ANIMATION_DATA_TYPE.POSITION || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_start_pos.CalculatePositionProgressions( anim_manager,
animation_ref,
ref start_pos_curve_letter_progressions,
letters,
GetProgressionTotal(num_letters + num_white_space_chars_to_include, num_words, num_lines, animate_per, m_start_pos.AnimatePer, m_start_pos.OverrideAnimatePerOption),
prev_action != null ? prev_action.m_end_pos : null,
prev_action == null || m_position_transition_active);
if(what_to_update == ANIMATION_DATA_TYPE.LOCAL_ROTATION || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_start_euler_rotation.CalculateRotationProgressions(ref start_pos_curve_letter_progressions, GetProgressionTotal(num_letters + num_white_space_chars_to_include, num_words, num_lines, animate_per, m_start_euler_rotation.AnimatePer, m_start_euler_rotation.OverrideAnimatePerOption),
prev_action != null ? prev_action.m_end_euler_rotation : null,
m_start_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX ? m_start_pos.BezierCurve : null,
prev_action == null || m_local_rotation_transition_active);
if(what_to_update == ANIMATION_DATA_TYPE.LOCAL_SCALE || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_start_scale.CalculateProgressions(GetProgressionTotal(num_letters + num_white_space_chars_to_include, num_words, num_lines, animate_per, m_start_scale.AnimatePer, m_start_scale.OverrideAnimatePerOption),
prev_action != null ? prev_action.m_end_scale : null,
prev_action == null || m_local_scale_transition_active);
if(what_to_update == ANIMATION_DATA_TYPE.GLOBAL_ROTATION || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_global_start_euler_rotation.CalculateRotationProgressions(ref start_pos_curve_letter_progressions, GetProgressionTotal(num_letters + num_white_space_chars_to_include, num_words, num_lines, animate_per, m_global_start_euler_rotation.AnimatePer, m_global_start_euler_rotation.OverrideAnimatePerOption),
prev_action != null ? prev_action.m_global_end_euler_rotation : null,
null,
prev_action == null || m_global_rotation_transition_active);
if(what_to_update == ANIMATION_DATA_TYPE.GLOBAL_SCALE || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_global_start_scale.CalculateProgressions( GetProgressionTotal(num_letters + num_white_space_chars_to_include, num_words, num_lines, animate_per, m_global_start_scale.AnimatePer, m_global_start_scale.OverrideAnimatePerOption),
prev_action != null ? prev_action.m_global_end_scale : null,
prev_action == null || m_global_scale_transition_active);
}
float[] end_pos_curve_letter_progressions = null;
if( ( what_to_update == ANIMATION_DATA_TYPE.POSITION ||
what_to_update == ANIMATION_DATA_TYPE.LOCAL_ROTATION ||
what_to_update == ANIMATION_DATA_TYPE.GLOBAL_ROTATION ||
what_to_update == ANIMATION_DATA_TYPE.ALL
)
&& m_end_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX)
{
// Pre calculate letter progression values based on letter spacing
end_pos_curve_letter_progressions = m_end_pos.BezierCurve.GetLetterProgressions(anim_manager, ref letters, m_letter_anchor_end);
}
if(what_to_update == ANIMATION_DATA_TYPE.POSITION || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_end_pos.CalculatePositionProgressions(anim_manager,
animation_ref,
ref end_pos_curve_letter_progressions,
letters,
GetProgressionTotal(num_letters + num_white_space_chars_to_include, num_words, num_lines, animate_per, m_end_pos.AnimatePer, m_end_pos.OverrideAnimatePerOption),
m_start_pos,
prev_action == null || m_position_transition_active);
if(what_to_update == ANIMATION_DATA_TYPE.LOCAL_ROTATION || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_end_euler_rotation.CalculateRotationProgressions(ref end_pos_curve_letter_progressions, GetProgressionTotal(num_letters + num_white_space_chars_to_include, num_words, num_lines, animate_per, m_end_euler_rotation.AnimatePer, m_end_euler_rotation.OverrideAnimatePerOption),
m_start_euler_rotation,
m_end_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX ? m_end_pos.BezierCurve : null,
prev_action == null || m_local_rotation_transition_active);
if(what_to_update == ANIMATION_DATA_TYPE.LOCAL_SCALE || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_end_scale.CalculateProgressions(GetProgressionTotal(num_letters + num_white_space_chars_to_include, num_words, num_lines, animate_per, m_end_scale.AnimatePer, m_end_scale.OverrideAnimatePerOption),
m_start_scale,
prev_action == null || m_local_scale_transition_active);
if(what_to_update == ANIMATION_DATA_TYPE.GLOBAL_ROTATION || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_global_end_euler_rotation.CalculateRotationProgressions(ref end_pos_curve_letter_progressions, GetProgressionTotal(num_letters + num_white_space_chars_to_include, num_words, num_lines, animate_per, m_global_end_euler_rotation.AnimatePer, m_global_end_euler_rotation.OverrideAnimatePerOption),
m_global_start_euler_rotation,
null,
prev_action == null || m_global_rotation_transition_active);
if(what_to_update == ANIMATION_DATA_TYPE.GLOBAL_SCALE || what_to_update == ANIMATION_DATA_TYPE.ALL)
m_global_end_scale.CalculateProgressions(GetProgressionTotal(num_letters + num_white_space_chars_to_include, num_words, num_lines, animate_per, m_global_end_scale.AnimatePer, m_global_end_scale.OverrideAnimatePerOption),
m_global_start_scale,
prev_action == null || m_global_scale_transition_active);
if(what_to_update == ANIMATION_DATA_TYPE.POSITION
|| what_to_update == ANIMATION_DATA_TYPE.POSITION
|| what_to_update == ANIMATION_DATA_TYPE.LETTER_ANCHOR
|| what_to_update == ANIMATION_DATA_TYPE.ALL)
CalculateLetterAnchorOffset();
}
public void CalculateUniqueRandom(AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per, VertexColour[] offset_colours)
{
int progression_idx = GetProgressionIndex(progression_variables, animate_per);
bool constant_offset = offset_colours != null && offset_colours.Length == 1;
m_values[progression_idx] = m_is_offset_from_last ? offset_colours[constant_offset ? 0 : progression_idx].Clone() : new VertexColour(new Color(0,0,0,0));
m_values[progression_idx] = m_values[progression_idx].Add(m_from.Add(m_to.Sub(m_from).Multiply(UnityEngine.Random.value)));
}
public void SetMeshState(int action_idx, float action_progress, LetterAnimation animation, AnimatePerOptions animate_per)
{
if(action_idx >= 0 && action_idx < animation.m_letter_actions.Count)
{
SetupMesh(animation.m_letter_actions[action_idx], Mathf.Clamp(action_progress, 0,1), true, m_progression_variables, animate_per, Mathf.Clamp(action_progress, 0,1));
}
else
{
// action not found for this letter. Position letter in its default position
Vector3[] mesh_verts = new Vector3[4];
for(int idx=0; idx < 4; idx++)
{
mesh_verts[idx] = m_base_vertices[idx] + m_base_offset;
}
m_mesh.vertices = mesh_verts;
m_mesh.colors = new Color[]{Color.white, Color.white, Color.white, Color.white};
}
}
public void PrepareData(LetterSetup[] letters, int num_words, int num_lines, AnimatePerOptions animate_per)
{
if (letters == null || letters.Length == 0)
{
return;
}
int num_letters = letters.Length;
// Populate list of letters to animate by index, and set Letter indexes accordingly
if (m_letters_to_animate_option == LETTERS_TO_ANIMATE.ALL_LETTERS)
{
m_letters_to_animate = new List <int>();
for (int letter_idx = 0; letter_idx < num_letters; letter_idx++)
{
m_letters_to_animate.Add(letter_idx);
letters[letter_idx].m_progression_variables.m_letter_value = letter_idx;
}
}
else if (m_letters_to_animate_option == LETTERS_TO_ANIMATE.FIRST_LETTER || m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LETTER)
{
m_letters_to_animate = new List <int>();
m_letters_to_animate.Add(m_letters_to_animate_option == LETTERS_TO_ANIMATE.FIRST_LETTER ? 0 : letters.Length - 1);
letters[m_letters_to_animate_option == LETTERS_TO_ANIMATE.FIRST_LETTER ? 0 : letters.Length - 1].m_progression_variables.m_letter_value = 0;
}
else if (m_letters_to_animate_option != LETTERS_TO_ANIMATE.CUSTOM)
{
m_letters_to_animate = new List <int>();
int line_idx = m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LETTER_LINES ? 0 : -1;
int word_idx = m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LETTER_WORDS ? 0 : -1;
int target_idx = 0;
if (m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_WORD)
{
target_idx = letters[letters.Length - 1].m_progression_variables.m_word_value;
}
else if (m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LINE)
{
target_idx = letters[letters.Length - 1].m_progression_variables.m_line_value;
}
else if (m_letters_to_animate_option == LETTERS_TO_ANIMATE.NTH_WORD || m_letters_to_animate_option == LETTERS_TO_ANIMATE.NTH_LINE)
{
target_idx = m_letters_to_animate_custom_idx - 1;
}
int letter_idx = 0;
int progression_idx = 0;
foreach (LetterSetup letter in letters)
{
if (m_letters_to_animate_option == LETTERS_TO_ANIMATE.FIRST_LINE || m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LINE || m_letters_to_animate_option == LETTERS_TO_ANIMATE.NTH_LINE)
{
if (letter.m_progression_variables.m_line_value == target_idx)
{
letter.m_progression_variables.m_letter_value = progression_idx;
m_letters_to_animate.Add(letter_idx);
progression_idx++;
}
}
else if (letter.m_progression_variables.m_line_value > line_idx)
{
if (m_letters_to_animate_option == LETTERS_TO_ANIMATE.FIRST_LETTER_LINES)
{
letter.m_progression_variables.m_letter_value = progression_idx;
m_letters_to_animate.Add(letter_idx);
progression_idx++;
}
else if (m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LETTER_LINES)
{
letter.m_progression_variables.m_letter_value = progression_idx - 1;
m_letters_to_animate.Add(letter_idx - 1);
progression_idx++;
}
line_idx = letter.m_progression_variables.m_line_value;
}
if (m_letters_to_animate_option == LETTERS_TO_ANIMATE.FIRST_WORD || m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_WORD || m_letters_to_animate_option == LETTERS_TO_ANIMATE.NTH_WORD)
{
if (letter.m_progression_variables.m_word_value == target_idx)
{
letter.m_progression_variables.m_letter_value = progression_idx;
m_letters_to_animate.Add(letter_idx);
progression_idx++;
}
}
else if (letter.m_progression_variables.m_word_value > word_idx)
{
if (m_letters_to_animate_option == LETTERS_TO_ANIMATE.FIRST_LETTER_WORDS)
{
letter.m_progression_variables.m_letter_value = progression_idx;
m_letters_to_animate.Add(letter_idx);
progression_idx++;
}
else if (m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LETTER_WORDS)
{
letter.m_progression_variables.m_letter_value = progression_idx;
m_letters_to_animate.Add(letter_idx - 1);
progression_idx++;
}
word_idx = letter.m_progression_variables.m_word_value;
}
letter_idx++;
}
if (m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LETTER_WORDS || m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LETTER_LINES)
{
letters[num_letters - 1].m_progression_variables.m_letter_value = letter_idx - 1;
m_letters_to_animate.Add(letter_idx - 1);
}
}
else
{
int progression_idx = 0;
for (int letter_idx = 0; letter_idx < num_letters; letter_idx++)
{
if (m_letters_to_animate.Contains(letter_idx))
{
letters[letter_idx].m_progression_variables.m_letter_value = progression_idx;
progression_idx++;
}
}
}
// Prepare data progression data in all actions
LetterAction letter_action;
LetterAction prev_action = null;
bool letters_in_sync = true;
bool prev_action_end_state = true;
for (int action_idx = 0; action_idx < m_letter_actions.Count; action_idx++)
{
letter_action = m_letter_actions[action_idx];
letter_action.PrepareData(m_letters_to_animate.Count, num_words, num_lines, prev_action, animate_per, prev_action_end_state);
if (letter_action.m_action_type == ACTION_TYPE.ANIM_SEQUENCE)
{
// Set default previous action settings
prev_action_end_state = true;
prev_action = letter_action;
}
// Check for reverse loops, and how the animation should progress from there
foreach (ActionLoopCycle loop_cycle in m_loop_cycles)
{
if (loop_cycle.m_end_action_idx == action_idx && loop_cycle.m_loop_type == LOOP_TYPE.LOOP_REVERSE)
{
prev_action = m_letter_actions[loop_cycle.m_start_action_idx];
prev_action_end_state = false;
}
}
// Set whether letters in the action are still in sync (starting/ending at the same time)
if (letter_action.m_force_same_start_time)
{
letters_in_sync = true;
}
if (letter_action.m_delay_progression.m_progression != ValueProgression.Constant)
{
letters_in_sync = false;
}
letter_action.m_starting_in_sync = letters_in_sync;
if (letter_action.m_duration_progression.m_progression != ValueProgression.Constant)
{
letters_in_sync = false;
}
letter_action.m_ending_in_sync = letters_in_sync;
}
}
private int GetProgressionTotal(int num_letters, int num_words, int num_lines, AnimatePerOptions animate_per_default, AnimatePerOptions animate_per_override, bool overriden)
{
switch (overriden ? animate_per_override : animate_per_default)
{
case AnimatePerOptions.LETTER:
return num_letters;
case AnimatePerOptions.WORD:
return num_words;
case AnimatePerOptions.LINE:
return num_lines;
}
return num_letters;
}
public void PrepareData(TextFxAnimationManager anim_manager, LetterSetup[] letters, ANIMATION_DATA_TYPE what_to_update, int num_words, int num_lines, AnimatePerOptions animate_per)
{
if (letters == null || letters.Length == 0)
{
return;
}
if (m_letters_to_animate == null || what_to_update == ANIMATION_DATA_TYPE.ALL || what_to_update == ANIMATION_DATA_TYPE.ANIMATE_ON)
{
CalculateLettersToAnimate(letters);
}
if (what_to_update == ANIMATION_DATA_TYPE.ALL || what_to_update == ANIMATION_DATA_TYPE.COLOUR || m_defaultTextColourProgression == null)
{
// Set values for default text colour progression
VertexColour[] defaultextColours = new VertexColour[m_letters_to_animate.Count];
for (int idx = 0; idx < m_letters_to_animate.Count; idx++)
{
defaultextColours[idx] = letters[m_letters_to_animate[idx]].BaseColour;
}
m_defaultTextColourProgression.SetValues(defaultextColours);
// Mark as the default colour progression
m_defaultTextColourProgression.SetReferenceData(-1, ANIMATION_DATA_TYPE.COLOUR, true);
}
// Prepare progression data in all actions
LetterAction letter_action;
LetterAction prev_action = null;
bool prev_action_end_state = true;
for (int action_idx = 0; action_idx < m_letter_actions.Count; action_idx++)
{
letter_action = m_letter_actions[action_idx];
letter_action.PrepareData(anim_manager, ref letters, this, action_idx, what_to_update, m_letters_to_animate.Count, m_num_white_space_chars_to_include, num_words, num_lines, prev_action, animate_per, m_defaultTextColourProgression, prev_action_end_state);
if (letter_action.m_action_type == ACTION_TYPE.ANIM_SEQUENCE)
{
// Set default previous action settings
prev_action_end_state = true;
prev_action = letter_action;
}
// Check for reverse loops, and how the animation should progress from there
foreach (ActionLoopCycle loop_cycle in m_loop_cycles)
{
if (loop_cycle.m_end_action_idx == action_idx && loop_cycle.m_loop_type == LOOP_TYPE.LOOP_REVERSE && !loop_cycle.m_finish_at_end)
{
prev_action = m_letter_actions[loop_cycle.m_start_action_idx];
prev_action_end_state = false;
}
}
}
}
void SetupMesh(LetterAction letter_action, float action_progress, bool first_action_call, AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per, float linear_progress)
{
if(first_action_call || !letter_action.StaticPosition || !letter_action.StaticRotation || !letter_action.StaticScale)
{
Vector3[] mesh_verts = new Vector3[4];
for(int idx=0; idx < 4; idx++)
{
// rotate vertices
// handle letter anchor x-offset
Vector3 anchor_offset = Vector3.zero;
if(letter_action.m_letter_anchor == TextAnchor.UpperRight || letter_action.m_letter_anchor == TextAnchor.MiddleRight || letter_action.m_letter_anchor == TextAnchor.LowerRight)
{
anchor_offset += new Vector3(m_width, 0, 0);
}
else if(letter_action.m_letter_anchor == TextAnchor.UpperCenter || letter_action.m_letter_anchor == TextAnchor.MiddleCenter || letter_action.m_letter_anchor == TextAnchor.LowerCenter)
{
anchor_offset += new Vector3(m_width / 2, 0, 0);
}
// handle letter anchor y-offset
if(letter_action.m_letter_anchor == TextAnchor.MiddleLeft || letter_action.m_letter_anchor == TextAnchor.MiddleCenter || letter_action.m_letter_anchor == TextAnchor.MiddleRight)
{
anchor_offset += new Vector3(0, m_height / 2, 0);
}
else if(letter_action.m_letter_anchor == TextAnchor.LowerLeft || letter_action.m_letter_anchor == TextAnchor.LowerCenter || letter_action.m_letter_anchor == TextAnchor.LowerRight)
{
anchor_offset += new Vector3(0, m_height, 0);
}
mesh_verts[idx] = m_base_vertices[idx];
mesh_verts[idx] -= anchor_offset;
// Scale verts
// if(first_action_call) // || !letter_action.StaticScale)
// {
Vector3 from_scale = letter_action.m_start_scale.GetValue(progression_variables, animate_per);
Vector3 to_scale = letter_action.m_end_scale.GetValue(progression_variables, animate_per);
if(letter_action.m_scale_axis_ease_data.m_override_default)
{
mesh_verts[idx] = Vector3.Scale(mesh_verts[idx],
new Vector3( EffectManager.FloatLerp(from_scale.x, to_scale.x, EasingManager.GetEaseProgress(letter_action.m_scale_axis_ease_data.m_x_ease, linear_progress)),
EffectManager.FloatLerp(from_scale.y, to_scale.y, EasingManager.GetEaseProgress(letter_action.m_scale_axis_ease_data.m_y_ease, linear_progress)),
EffectManager.FloatLerp(from_scale.z, to_scale.z, EasingManager.GetEaseProgress(letter_action.m_scale_axis_ease_data.m_z_ease, linear_progress))));
}
else
{
mesh_verts[idx] = Vector3.Scale(mesh_verts[idx],
EffectManager.Vector3Lerp(
from_scale,
to_scale,
action_progress)
);
}
// }
// Rotate vert
// if(first_action_call) // || !letter_action.StaticRotation)
// {
Vector3 from_rotation = letter_action.m_start_euler_rotation.GetValue(progression_variables, animate_per);
Vector3 to_rotation = letter_action.m_end_euler_rotation.GetValue(progression_variables, animate_per);
if(letter_action.m_rotation_axis_ease_data.m_override_default)
{
mesh_verts[idx] = Quaternion.Euler
(
EffectManager.FloatLerp(from_rotation.x, to_rotation.x, EasingManager.GetEaseProgress(letter_action.m_rotation_axis_ease_data.m_x_ease, linear_progress)),
EffectManager.FloatLerp(from_rotation.y, to_rotation.y, EasingManager.GetEaseProgress(letter_action.m_rotation_axis_ease_data.m_y_ease, linear_progress)),
EffectManager.FloatLerp(from_rotation.z, to_rotation.z, EasingManager.GetEaseProgress(letter_action.m_rotation_axis_ease_data.m_z_ease, linear_progress))
) * mesh_verts[idx];;
}
else
{
mesh_verts[idx] = Quaternion.Euler(
EffectManager.Vector3Lerp(
from_rotation,
to_rotation,
action_progress)
)
* mesh_verts[idx];
}
// }
mesh_verts[idx] += anchor_offset;
// translate vert
Vector3 from_pos = (!letter_action.m_start_pos.m_force_position_override ? m_base_offset : Vector3.zero) + letter_action.m_start_pos.GetValue(progression_variables, animate_per);
Vector3 to_pos = (!letter_action.m_end_pos.m_force_position_override ? m_base_offset : Vector3.zero) + letter_action.m_end_pos.GetValue(progression_variables, animate_per);
if(letter_action.m_position_axis_ease_data.m_override_default)
{
mesh_verts[idx] += new Vector3( EffectManager.FloatLerp(from_pos.x, to_pos.x, EasingManager.GetEaseProgress(letter_action.m_position_axis_ease_data.m_x_ease, linear_progress)),
EffectManager.FloatLerp(from_pos.y, to_pos.y, EasingManager.GetEaseProgress(letter_action.m_position_axis_ease_data.m_y_ease, linear_progress)),
EffectManager.FloatLerp(from_pos.z, to_pos.z, EasingManager.GetEaseProgress(letter_action.m_position_axis_ease_data.m_z_ease, linear_progress)));
}
else
{
mesh_verts[idx] += EffectManager.Vector3Lerp(
from_pos,
to_pos,
action_progress);
}
}
m_mesh.vertices = mesh_verts;
}
if(first_action_call || !letter_action.StaticColour)
{
if(letter_action.m_use_gradient_start || letter_action.m_use_gradient)
{
start_colour = letter_action.m_start_vertex_colour.GetValue(progression_variables, animate_per);
}
else
{
start_colour = new VertexColour(letter_action.m_start_colour.GetValue(progression_variables, animate_per));
}
if(letter_action.m_use_gradient_end || letter_action.m_use_gradient)
{
end_colour = letter_action.m_end_vertex_colour.GetValue(progression_variables, animate_per);
}
else
{
end_colour = new VertexColour(letter_action.m_end_colour.GetValue(progression_variables, animate_per));
}
if(!m_flipped)
{
m_mesh.colors = new Color[]{
Color.Lerp(start_colour.top_right, end_colour.top_right, action_progress),
Color.Lerp(start_colour.top_left, end_colour.top_left, action_progress),
Color.Lerp(start_colour.bottom_left, end_colour.bottom_left, action_progress),
Color.Lerp(start_colour.bottom_right, end_colour.bottom_right, action_progress)};
}
else
{
m_mesh.colors = new Color[]{
Color.Lerp(start_colour.top_left, end_colour.top_left, action_progress),
Color.Lerp(start_colour.bottom_left, end_colour.bottom_left, action_progress),
Color.Lerp(start_colour.bottom_right, end_colour.bottom_right, action_progress),
Color.Lerp(start_colour.top_right, end_colour.top_right, action_progress)
};
}
}
}
// Animates the letter mesh and return the current action index in use
public LETTER_ANIMATION_STATE AnimateMesh(bool force_render,
float timer,
TextAnchor text_anchor,
int lowest_action_progress,
LetterAnimation animation,
AnimatePerOptions animate_per,
float delta_time,
EffectManager effect_manager)
{
m_last_animate_per = animate_per;
m_effect_manager_handle = effect_manager;
if (animation.NumActions > 0 && m_anim_state_vars.m_action_index < animation.NumActions)
{
if (!m_anim_state_vars.m_active && !force_render)
{
return(LETTER_ANIMATION_STATE.STOPPED);
}
if (m_anim_state_vars.m_action_index != m_anim_state_vars.m_prev_action_index)
{
SetCurrentLetterAction(animation.GetAction(m_anim_state_vars.m_action_index), animate_per);
m_anim_state_vars.m_started_action = false;
}
else if (m_current_letter_action == null)
{
SetCurrentLetterAction(animation.GetAction(m_anim_state_vars.m_action_index), animate_per);
}
m_anim_state_vars.m_prev_action_index = m_anim_state_vars.m_action_index;
if (force_render)
{
SetupMesh(m_current_letter_action, m_anim_state_vars.m_action_index > 0 ? animation.GetAction(m_anim_state_vars.m_action_index - 1) : null, m_anim_state_vars.m_action_progress, m_progression_variables, animate_per, m_anim_state_vars.m_linear_progress, m_effect_manager_handle);
}
if (m_anim_state_vars.m_waiting_to_sync)
{
if (m_current_letter_action.m_action_type == ACTION_TYPE.BREAK)
{
if (!force_render && m_anim_state_vars.m_break_delay > 0)
{
m_anim_state_vars.m_break_delay -= delta_time;
if (m_anim_state_vars.m_break_delay <= 0)
{
ContinueAction(timer, animation, animate_per);
return(LETTER_ANIMATION_STATE.PLAYING);
}
}
return(LETTER_ANIMATION_STATE.WAITING);
}
else if (lowest_action_progress < m_anim_state_vars.m_action_index_progress)
{
return(LETTER_ANIMATION_STATE.PLAYING);
}
else if (!force_render)
{
m_anim_state_vars.m_waiting_to_sync = false;
// reset timer offset to compensate for the sync-up wait time
m_anim_state_vars.m_timer_offset = timer;
}
}
else if (!force_render && (m_current_letter_action.m_action_type == ACTION_TYPE.BREAK || (!m_anim_state_vars.m_reverse && m_current_letter_action.m_force_same_start_time && lowest_action_progress < m_anim_state_vars.m_action_index_progress)))
{
// Force letter to wait for rest of letters to be in sync
m_anim_state_vars.m_waiting_to_sync = true;
m_anim_state_vars.m_break_delay = Mathf.Max(m_current_letter_action.m_duration_progression.GetValue(m_progression_variables, animate_per), 0);
return(LETTER_ANIMATION_STATE.PLAYING);
}
if (force_render)
{
return(m_anim_state_vars.m_active ? LETTER_ANIMATION_STATE.PLAYING : LETTER_ANIMATION_STATE.STOPPED);
}
m_anim_state_vars.m_action_progress = 0;
m_anim_state_vars.m_linear_progress = 0;
m_action_timer = timer - m_anim_state_vars.m_timer_offset;
if ((m_anim_state_vars.m_reverse || m_action_timer > m_action_delay))
{
m_anim_state_vars.m_linear_progress = (m_action_timer - (m_anim_state_vars.m_reverse ? 0 : m_action_delay)) / m_action_duration;
if (m_anim_state_vars.m_reverse)
{
if (m_action_timer >= m_action_duration)
{
m_anim_state_vars.m_linear_progress = 0;
}
else
{
m_anim_state_vars.m_linear_progress = 1 - m_anim_state_vars.m_linear_progress;
}
}
if (!m_anim_state_vars.m_started_action)
{
// Trigger any action onStart audio or particle effects
TriggerAudioEffect(animate_per, PLAY_ITEM_EVENTS.ON_START);
TriggerParticleEffects(animate_per, PLAY_ITEM_EVENTS.ON_START);
m_anim_state_vars.m_started_action = true;
}
m_anim_state_vars.m_action_progress = EasingManager.GetEaseProgress(m_current_letter_action.m_ease_type, m_anim_state_vars.m_linear_progress);
if ((!m_anim_state_vars.m_reverse && m_anim_state_vars.m_linear_progress >= 1) || (m_anim_state_vars.m_reverse && m_action_timer >= m_action_duration + m_action_delay))
{
m_anim_state_vars.m_action_progress = m_anim_state_vars.m_reverse ? 0 : 1;
m_anim_state_vars.m_linear_progress = m_anim_state_vars.m_reverse ? 0 : 1;
if (!m_anim_state_vars.m_reverse && m_anim_state_vars.m_action_index != -1)
{
TriggerParticleEffects(animate_per, PLAY_ITEM_EVENTS.ON_FINISH);
TriggerAudioEffect(animate_per, PLAY_ITEM_EVENTS.ON_FINISH);
}
int prev_action_idx = m_anim_state_vars.m_action_index;
float prev_delay = m_action_delay;
// Set next action index
SetNextActionIndex(animation);
if (m_anim_state_vars.m_active)
{
if (!m_anim_state_vars.m_reverse)
{
m_anim_state_vars.m_started_action = false;
}
if (!m_anim_state_vars.m_reverse && m_anim_state_vars.m_action_index_progress > m_anim_state_vars.m_action_index)
{
// Repeating the action again; check for unqiue random variable requests.
animation.GetAction(m_anim_state_vars.m_action_index).SoftReset(animation.GetAction(prev_action_idx), m_progression_variables, animate_per, m_anim_state_vars.m_action_index == 0);
}
else if (m_anim_state_vars.m_reverse)
{
animation.GetAction(m_anim_state_vars.m_action_index).SoftResetStarts(animation.GetAction(prev_action_idx), m_progression_variables, animate_per);
}
// Add to the timer offset
m_anim_state_vars.m_timer_offset += prev_delay + m_action_duration;
if (prev_action_idx != m_anim_state_vars.m_action_index)
{
UpdateLoopList(animation);
}
else
{
SetCurrentLetterAction(animation.GetAction(m_anim_state_vars.m_action_index), animate_per);
}
}
}
}
SetupMesh(m_current_letter_action, m_anim_state_vars.m_action_index > 0 ? animation.GetAction(m_anim_state_vars.m_action_index - 1) : null, m_anim_state_vars.m_action_progress, m_progression_variables, animate_per, m_anim_state_vars.m_linear_progress, m_effect_manager_handle);
}
else
{
// no actions found for this letter. Position letter in its default position
if (mesh_verts == null || mesh_verts.Length == 0)
{
mesh_verts = new Vector3[4];
}
for (int idx = 0; idx < 4; idx++)
{
mesh_verts[idx] = m_base_vertices[idx] + m_base_offset;
}
m_mesh.vertices = mesh_verts;
m_anim_state_vars.m_active = false;
}
return(m_anim_state_vars.m_active ? LETTER_ANIMATION_STATE.PLAYING : LETTER_ANIMATION_STATE.STOPPED);
}
public void ImportBaseLagacyData(KeyValuePair<string, string> value_pair)
{
switch(value_pair.Key)
{
case "m_progression": m_progression_idx = int.Parse(value_pair.Value); break;
case "m_ease_type": m_ease_type = (EasingEquation) int.Parse(value_pair.Value); break;
case "m_is_offset_from_last": m_is_offset_from_last = bool.Parse(value_pair.Value); break;
case "m_to_to_bool": m_to_to_bool = bool.Parse(value_pair.Value); break;
case "m_unique_randoms": m_unique_randoms = bool.Parse(value_pair.Value); break;
case "m_animate_per": m_animate_per = (AnimatePerOptions) int.Parse(value_pair.Value); break;
case "m_override_animate_per_option": m_override_animate_per_option = bool.Parse(value_pair.Value); break;
case "m_custom_ease_curve": m_custom_ease_curve = value_pair.Value.ToAnimationCurve(); break;
}
}
void SetupMesh(LetterAction letter_action, LetterAction prev_action, float action_progress, AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per, float linear_progress, EffectManager effect_manager)
{
// construct current anchor offset vector
m_anchor_offset = letter_action.AnchorOffsetStart;
m_anchor_offset = new Vector3(m_anchor_offset.x * m_width,
letter_action.m_letter_anchor_start == (int)TextfxTextAnchor.BaselineLeft || letter_action.m_letter_anchor_start == (int)TextfxTextAnchor.BaselineCenter || letter_action.m_letter_anchor_start == (int)TextfxTextAnchor.BaselineRight
? 0 // zero because letters are based around the baseline already.
: (effect_manager.IsFontBaseLineSet
? (effect_manager.FontBaseLine + m_y_offset) - (m_anchor_offset.y * -m_height)
: (m_anchor_offset.y * m_height)), // Legacy effect support when baseline isn't already set.
0);
if (letter_action.m_letter_anchor_2_way)
{
m_anchor_offset = letter_action.AnchorOffsetEnd;
m_anchor_offset = Vector3.Lerp(m_anchor_offset,
new Vector3(
m_anchor_offset.x * m_width,
letter_action.m_letter_anchor_end == (int)TextfxTextAnchor.BaselineLeft || letter_action.m_letter_anchor_end == (int)TextfxTextAnchor.BaselineCenter || letter_action.m_letter_anchor_end == (int)TextfxTextAnchor.BaselineRight
? 0 // zero because letters are based around the baseline already.
: (effect_manager.IsFontBaseLineSet
? (effect_manager.FontBaseLine + m_y_offset) - (m_anchor_offset.y * -m_height)
: (m_anchor_offset.y * m_height)), // Legacy effect support when baseline isn't already set.
0),
action_progress);
}
// Calculate Scale Vector
from_vec = letter_action.m_start_scale.GetValue(progression_variables, animate_per);
to_vec = letter_action.m_end_scale.GetValue(progression_variables, animate_per);
if (letter_action.m_scale_axis_ease_data.m_override_default)
{
m_letter_scale = new Vector3(EffectManager.FloatLerp(from_vec.x, to_vec.x, EasingManager.GetEaseProgress(letter_action.m_scale_axis_ease_data.m_x_ease, linear_progress)),
EffectManager.FloatLerp(from_vec.y, to_vec.y, EasingManager.GetEaseProgress(letter_action.m_scale_axis_ease_data.m_y_ease, linear_progress)),
EffectManager.FloatLerp(from_vec.z, to_vec.z, EasingManager.GetEaseProgress(letter_action.m_scale_axis_ease_data.m_z_ease, linear_progress)));
}
else
{
m_letter_scale = EffectManager.Vector3Lerp(
from_vec,
to_vec,
action_progress);
}
// Calculate Rotation
from_vec = letter_action.m_start_euler_rotation.GetValue(progression_variables, animate_per);
to_vec = letter_action.m_end_euler_rotation.GetValue(progression_variables, animate_per);
if (letter_action.m_rotation_axis_ease_data.m_override_default)
{
m_letter_rotation = Quaternion.Euler
(
EffectManager.FloatLerp(from_vec.x, to_vec.x, EasingManager.GetEaseProgress(letter_action.m_rotation_axis_ease_data.m_x_ease, linear_progress)),
EffectManager.FloatLerp(from_vec.y, to_vec.y, EasingManager.GetEaseProgress(letter_action.m_rotation_axis_ease_data.m_y_ease, linear_progress)),
EffectManager.FloatLerp(from_vec.z, to_vec.z, EasingManager.GetEaseProgress(letter_action.m_rotation_axis_ease_data.m_z_ease, linear_progress))
);
}
else
{
m_letter_rotation = Quaternion.Euler(
EffectManager.Vector3Lerp(
from_vec,
to_vec,
action_progress)
);
}
// Calculate Position
if (letter_action.m_start_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX || (letter_action.m_offset_from_last && prev_action != null && prev_action.m_end_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX))
{
from_vec = new Vector3(-m_anchor_offset.x, m_base_offset.y, 0);
}
else if (letter_action.m_start_pos.m_force_position_override)
{
from_vec = new Vector3(-m_anchor_offset.x, 0, 0);
}
else
{
from_vec = BaseOffset;
}
from_vec += letter_action.m_start_pos.GetValue(progression_variables, animate_per);
if (letter_action.m_end_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX || (letter_action.m_end_pos.IsOffsetFromLast && letter_action.m_start_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX))
{
to_vec = new Vector3(-m_anchor_offset.x, m_base_offset.y, 0);
}
else if (letter_action.m_end_pos.m_force_position_override)
{
to_vec = new Vector3(-m_anchor_offset.x, 0, 0);
}
else
{
to_vec = BaseOffset;
}
to_vec += letter_action.m_end_pos.GetValue(progression_variables, animate_per);
if (letter_action.m_position_axis_ease_data.m_override_default)
{
m_letter_position = new Vector3(EffectManager.FloatLerp(from_vec.x, to_vec.x, EasingManager.GetEaseProgress(letter_action.m_position_axis_ease_data.m_x_ease, linear_progress)),
EffectManager.FloatLerp(from_vec.y, to_vec.y, EasingManager.GetEaseProgress(letter_action.m_position_axis_ease_data.m_y_ease, linear_progress)),
EffectManager.FloatLerp(from_vec.z, to_vec.z, EasingManager.GetEaseProgress(letter_action.m_position_axis_ease_data.m_z_ease, linear_progress)));
}
else
{
m_letter_position = EffectManager.Vector3Lerp(
from_vec,
to_vec,
action_progress);
}
// Calculate letter center position
m_letter_center = new Vector3(m_width / 2, m_height / 2, 0);
m_letter_center -= m_anchor_offset;
m_letter_center = Vector3.Scale(m_letter_center, m_letter_scale);
m_letter_center = m_letter_rotation * m_letter_center;
m_letter_center += m_anchor_offset + m_letter_position;
if (mesh_verts == null || mesh_verts.Length == 0)
{
mesh_verts = new Vector3[4];
}
for (int idx = 0; idx < 4; idx++)
{
mesh_verts[idx] = m_base_vertices[idx];
// normalise vert position to the anchor point before scaling and rotating.
mesh_verts[idx] -= m_anchor_offset;
// Scale verts
mesh_verts[idx] = Vector3.Scale(mesh_verts[idx], m_letter_scale);
// Rotate vert
mesh_verts[idx] = m_letter_rotation * mesh_verts[idx];
mesh_verts[idx] += m_anchor_offset;
// translate vert
mesh_verts[idx] += m_letter_position;
}
m_mesh.vertices = mesh_verts;
// Sort out letters colour
if (letter_action.m_use_gradient_start)
{
start_colour = letter_action.m_start_vertex_colour.GetValue(progression_variables, animate_per);
}
else
{
start_colour = new VertexColour(letter_action.m_start_colour.GetValue(progression_variables, animate_per));
}
if (letter_action.m_use_gradient_end)
{
end_colour = letter_action.m_end_vertex_colour.GetValue(progression_variables, animate_per);
}
else
{
end_colour = new VertexColour(letter_action.m_end_colour.GetValue(progression_variables, animate_per));
}
if (!m_flipped)
{
m_mesh.colors = new Color[] {
Color.Lerp(start_colour.top_right, end_colour.top_right, action_progress),
Color.Lerp(start_colour.top_left, end_colour.top_left, action_progress),
Color.Lerp(start_colour.bottom_left, end_colour.bottom_left, action_progress),
Color.Lerp(start_colour.bottom_right, end_colour.bottom_right, action_progress)
};
}
else
{
m_mesh.colors = new Color[] {
Color.Lerp(start_colour.top_left, end_colour.top_left, action_progress),
Color.Lerp(start_colour.bottom_left, end_colour.bottom_left, action_progress),
Color.Lerp(start_colour.bottom_right, end_colour.bottom_right, action_progress),
Color.Lerp(start_colour.top_right, end_colour.top_right, action_progress)
};
}
}
public float DrawProgressionEditorHeader(GUIContent label, Rect position, bool offset_legal, bool unique_randoms_legal, bool bold_label = true, string[] extra_options = null, int[] extra_option_indexes = null)
{
float x_offset = position.x;
float y_offset = position.y;
if(bold_label)
{
EditorGUI.LabelField(new Rect(x_offset, y_offset, position.width, LINE_HEIGHT), label, EditorStyles.boldLabel);
}
else
{
EditorGUI.LabelField(new Rect(x_offset, y_offset, position.width, LINE_HEIGHT), label);
}
x_offset += PROGRESSION_HEADER_LABEL_WIDTH;
string[] options = Enum.GetNames( typeof(ValueProgression) );
int[] option_indexes = PROGRESSION_ENUM_VALUES;
if(extra_options != null && extra_option_indexes != null && extra_options.Length > 0 && extra_options.Length == extra_option_indexes.Length)
{
int original_length = options.Length;
Array.Resize<string>(ref options, options.Length + extra_options.Length);
Array.Copy(extra_options, 0, options, original_length, extra_options.Length);
original_length = option_indexes.Length;
Array.Resize<int>(ref option_indexes, option_indexes.Length + extra_option_indexes.Length);
Array.Copy(extra_option_indexes, 0, option_indexes, original_length, extra_option_indexes.Length);
}
m_progression_idx = EditorGUI.IntPopup(new Rect(x_offset, y_offset, ENUM_SELECTOR_WIDTH_SMALL + 18, LINE_HEIGHT), Progression, options, option_indexes);
x_offset += ENUM_SELECTOR_WIDTH_SMALL + 25;
if(m_progression_idx == (int) ValueProgression.Eased)
{
EditorGUI.LabelField(new Rect(x_offset, y_offset, position.width, LINE_HEIGHT), new GUIContent("Function :", "Easing function used to lerp values between 'from' and 'to'."));
x_offset += 65;
m_ease_type = (EasingEquation) EditorGUI.EnumPopup(new Rect(x_offset, y_offset, ENUM_SELECTOR_WIDTH_MEDIUM, LINE_HEIGHT), m_ease_type);
x_offset += ENUM_SELECTOR_WIDTH_MEDIUM + 10;
EditorGUI.LabelField(new Rect(x_offset, y_offset, position.width, LINE_HEIGHT), new GUIContent("3rd?", "Option to add a third state to lerp values between."));
x_offset += 35;
m_to_to_bool = EditorGUI.Toggle(new Rect(x_offset, y_offset, ENUM_SELECTOR_WIDTH_MEDIUM, LINE_HEIGHT), m_to_to_bool);
}
else if(m_progression_idx == (int) ValueProgression.Random && unique_randoms_legal)
{
m_unique_randoms = EditorGUI.Toggle(new Rect(x_offset, y_offset, 200, LINE_HEIGHT), new GUIContent("Unique Randoms?", "Denotes whether a new random value will be picked each time this action is repeated (like when in a loop)."), m_unique_randoms);
}
y_offset += LINE_HEIGHT;
if(offset_legal)
{
m_is_offset_from_last = EditorGUI.Toggle(new Rect(position.x + ACTION_INDENT_LEVEL_1, y_offset, 200, LINE_HEIGHT), new GUIContent("Offset From Last?", "Denotes whether this value will offset from whatever value it had in the last state. End states offset the start state. Start states offset the previous actions end state."), m_is_offset_from_last);
y_offset += LINE_HEIGHT;
}
if((m_progression_idx == (int) ValueProgression.Eased || m_progression_idx == (int) ValueProgression.Random))
{
m_override_animate_per_option = EditorGUI.Toggle(new Rect(position.x + ACTION_INDENT_LEVEL_1, y_offset, 200, LINE_HEIGHT), new GUIContent("Override AnimatePer?", "Denotes whether this state value progression will use the global 'Animate Per' setting, or define its own."), m_override_animate_per_option);
if(m_override_animate_per_option)
{
m_animate_per = (AnimatePerOptions) EditorGUI.EnumPopup(new Rect(position.x + ACTION_INDENT_LEVEL_1 + 200, y_offset, ENUM_SELECTOR_WIDTH_SMALL, LINE_HEIGHT), m_animate_per);
}
y_offset += LINE_HEIGHT;
}
else
{
m_override_animate_per_option = false;
}
return position.y + (y_offset - position.y);
}
public void PrepareData(ref LetterSetup[] letters, int num_letters, int num_words, int num_lines, LetterAction prev_action, AnimatePerOptions animate_per, bool prev_action_end_state = true)
{
m_duration_progression.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_duration_progression.AnimatePer, m_duration_progression.OverrideAnimatePerOption));
if (m_audio_effects != null)
foreach (var effect_setup in m_audio_effects)
{
effect_setup.m_delay.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_delay.AnimatePer, effect_setup.m_delay.OverrideAnimatePerOption));
effect_setup.m_offset_time.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_offset_time.AnimatePer, effect_setup.m_offset_time.OverrideAnimatePerOption));
effect_setup.m_volume.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_volume.AnimatePer, effect_setup.m_volume.OverrideAnimatePerOption));
effect_setup.m_pitch.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_pitch.AnimatePer, effect_setup.m_pitch.OverrideAnimatePerOption));
}
if (m_particle_effects != null)
foreach (var effect_setup in m_particle_effects)
{
effect_setup.m_position_offset.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_position_offset.AnimatePer, effect_setup.m_position_offset.OverrideAnimatePerOption), null);
effect_setup.m_rotation_offset.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_rotation_offset.AnimatePer, effect_setup.m_rotation_offset.OverrideAnimatePerOption), null);
effect_setup.m_delay.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_delay.AnimatePer, effect_setup.m_delay.OverrideAnimatePerOption));
effect_setup.m_duration.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_duration.AnimatePer, effect_setup.m_duration.OverrideAnimatePerOption));
}
if (m_action_type == ACTION_TYPE.BREAK)
return;
m_delay_progression.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_delay_progression.AnimatePer, m_delay_progression.OverrideAnimatePerOption));
if (m_offset_from_last && prev_action != null)
{
m_use_gradient_start = prev_action.m_use_gradient_end;
if (prev_action_end_state)
if (m_use_gradient_start)
m_start_vertex_colour.Values = prev_action.m_end_vertex_colour.Values;
else
m_start_colour.Values = prev_action.m_end_colour.Values;
else if (m_use_gradient_start)
m_start_vertex_colour.Values = prev_action.m_start_vertex_colour.Values;
else
m_start_colour.Values = prev_action.m_start_colour.Values;
}
else if (m_use_gradient_start || (prev_action != null && (prev_action.m_use_gradient_end)))
{
if (!m_use_gradient_start)
{
// Need to convert flat colour into a vertex colour
m_use_gradient_start = true;
m_start_vertex_colour.ConvertFromFlatColourProg(m_start_colour);
}
// add this colour to previous state
m_start_vertex_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_vertex_colour.AnimatePer, m_start_vertex_colour.OverrideAnimatePerOption), prev_action != null && (prev_action.m_use_gradient_end) ? prev_action.m_end_vertex_colour.Values : null, prev_action != null && (!prev_action.m_use_gradient_end) ? prev_action.m_end_colour.Values : null);
}
else
m_start_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_colour.AnimatePer, m_start_colour.OverrideAnimatePerOption), prev_action != null ? prev_action.m_end_colour.Values : null);
if (m_use_gradient_end || m_use_gradient_start)
{
if (!m_use_gradient_end)
{
// Need to convert flat colour into a vertex colour
m_use_gradient_end = true;
m_end_vertex_colour.ConvertFromFlatColourProg(m_end_colour);
}
m_end_vertex_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_vertex_colour.AnimatePer, m_end_vertex_colour.OverrideAnimatePerOption), (m_use_gradient_start) ? m_start_vertex_colour.Values : null, (!m_use_gradient_start) ? m_start_colour.Values : null);
}
else
m_end_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_colour.AnimatePer, m_end_colour.OverrideAnimatePerOption), m_start_colour.Values);
if (m_offset_from_last && prev_action != null)
{
m_start_pos.Values = prev_action_end_state ? prev_action.m_end_pos.Values : prev_action.m_start_pos.Values;
m_start_euler_rotation.Values = prev_action_end_state ? prev_action.m_end_euler_rotation.Values : prev_action.m_start_euler_rotation.Values;
m_start_scale.Values = prev_action_end_state ? prev_action.m_end_scale.Values : prev_action.m_start_scale.Values;
}
else
{
float[] start_pos_curve_letter_progressions = null;
if (m_start_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX)
// Pre calculate letter progression values based on letter spacing
start_pos_curve_letter_progressions = m_start_pos.BezierCurve.GetLetterProgressions(ref letters, m_letter_anchor_start);
m_start_pos.CalculatePositionProgressions(ref start_pos_curve_letter_progressions, GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_pos.AnimatePer, m_start_pos.OverrideAnimatePerOption), prev_action != null ? prev_action.m_end_pos.Values : new[] { Vector3.zero });
m_start_euler_rotation.CalculateRotationProgressions(ref start_pos_curve_letter_progressions, GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_euler_rotation.AnimatePer, m_start_euler_rotation.OverrideAnimatePerOption), prev_action != null ? prev_action.m_end_euler_rotation.Values : new[] { Vector3.zero }, m_start_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX ? m_start_pos.BezierCurve : null);
m_start_scale.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_scale.AnimatePer, m_start_scale.OverrideAnimatePerOption), prev_action != null ? prev_action.m_end_scale.Values : new[] { Vector3.zero });
}
float[] end_pos_curve_letter_progressions = null;
if (m_end_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX)
// Pre calculate letter progression values based on letter spacing
end_pos_curve_letter_progressions = m_end_pos.BezierCurve.GetLetterProgressions(ref letters, m_letter_anchor_end);
m_end_pos.CalculatePositionProgressions(ref end_pos_curve_letter_progressions, GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_pos.AnimatePer, m_end_pos.OverrideAnimatePerOption), m_start_pos.Values);
m_end_euler_rotation.CalculateRotationProgressions(ref end_pos_curve_letter_progressions, GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_euler_rotation.AnimatePer, m_end_euler_rotation.OverrideAnimatePerOption), m_start_euler_rotation.Values, m_end_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX ? m_end_pos.BezierCurve : null);
m_end_scale.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_scale.AnimatePer, m_end_scale.OverrideAnimatePerOption), m_start_scale.Values);
CalculateLetterAnchorOffset();
}
protected void ImportBaseData(JSONObject json_data)
{
m_progression_idx = (int) json_data["m_progression"].Number;
m_ease_type = (EasingEquation) (int) json_data["m_ease_type"].Number;
m_is_offset_from_last = json_data["m_is_offset_from_last"].Boolean;
m_to_to_bool = json_data["m_to_to_bool"].Boolean;
m_unique_randoms = json_data["m_unique_randoms"].Boolean;
m_animate_per = (AnimatePerOptions) (int) json_data["m_animate_per"].Number;
m_override_animate_per_option = json_data["m_override_animate_per_option"].Boolean;
if(json_data.ContainsKey("m_custom_ease_curve"))
m_custom_ease_curve = json_data["m_custom_ease_curve"].Array.JSONtoAnimationCurve();
}
public void SoftResetStarts(LetterAction prev_action, AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per)
{
if (m_use_gradient_start)
{
if (!m_offset_from_last && m_start_vertex_colour.UniqueRandom)
m_start_vertex_colour.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_vertex_colour.Values : null);
}
else if (!m_offset_from_last && m_start_colour.UniqueRandom)
m_start_colour.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_colour.Values : null);
if (!m_offset_from_last)
{
if (m_start_pos.UniqueRandom)
m_start_pos.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_pos.Values : null);
if (m_start_euler_rotation.UniqueRandom)
m_start_euler_rotation.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_euler_rotation.Values : null);
if (m_start_scale.UniqueRandom)
m_start_scale.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_scale.Values : null);
}
}
public void PrepareData(LetterSetup[] letters, int num_words, int num_lines, AnimatePerOptions animate_per)
{
if(letters == null || letters.Length == 0)
{
return;
}
int num_letters = letters.Length;
// Populate list of letters to animate by index, and set Letter indexes accordingly
if(m_letters_to_animate_option == LETTERS_TO_ANIMATE.ALL_LETTERS)
{
m_letters_to_animate = new List<int>();
for(int letter_idx=0; letter_idx < num_letters; letter_idx++)
{
m_letters_to_animate.Add(letter_idx);
letters[letter_idx].m_progression_variables.m_letter_value = letter_idx;
}
}
else if(m_letters_to_animate_option == LETTERS_TO_ANIMATE.FIRST_LETTER || m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LETTER)
{
m_letters_to_animate = new List<int>();
m_letters_to_animate.Add(m_letters_to_animate_option == LETTERS_TO_ANIMATE.FIRST_LETTER ? 0 : letters.Length -1);
letters[m_letters_to_animate_option == LETTERS_TO_ANIMATE.FIRST_LETTER ? 0 : letters.Length - 1].m_progression_variables.m_letter_value = 0;
}
else if(m_letters_to_animate_option != LETTERS_TO_ANIMATE.CUSTOM)
{
m_letters_to_animate = new List<int>();
int line_idx = m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LETTER_LINES ? 0 : -1;
int word_idx = m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LETTER_WORDS ? 0 : -1;
int target_idx = 0;
if(m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_WORD)
target_idx = letters[letters.Length-1].m_progression_variables.m_word_value;
else if(m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LINE)
target_idx = letters[letters.Length-1].m_progression_variables.m_line_value;
else if(m_letters_to_animate_option == LETTERS_TO_ANIMATE.NTH_WORD || m_letters_to_animate_option == LETTERS_TO_ANIMATE.NTH_LINE)
target_idx = m_letters_to_animate_custom_idx - 1;
int letter_idx = 0;
int progression_idx = 0;
foreach(LetterSetup letter in letters)
{
if(m_letters_to_animate_option == LETTERS_TO_ANIMATE.FIRST_LINE || m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LINE || m_letters_to_animate_option == LETTERS_TO_ANIMATE.NTH_LINE)
{
if(letter.m_progression_variables.m_line_value == target_idx)
{
letter.m_progression_variables.m_letter_value = progression_idx;
m_letters_to_animate.Add(letter_idx);
progression_idx ++;
}
}
else if(letter.m_progression_variables.m_line_value > line_idx)
{
if(m_letters_to_animate_option == LETTERS_TO_ANIMATE.FIRST_LETTER_LINES)
{
letter.m_progression_variables.m_letter_value = progression_idx;
m_letters_to_animate.Add(letter_idx);
progression_idx ++;
}
else if(m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LETTER_LINES)
{
letter.m_progression_variables.m_letter_value = progression_idx - 1;
m_letters_to_animate.Add(letter_idx - 1);
progression_idx ++;
}
line_idx = letter.m_progression_variables.m_line_value;
}
if(m_letters_to_animate_option == LETTERS_TO_ANIMATE.FIRST_WORD || m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_WORD || m_letters_to_animate_option == LETTERS_TO_ANIMATE.NTH_WORD)
{
if(letter.m_progression_variables.m_word_value == target_idx)
{
letter.m_progression_variables.m_letter_value = progression_idx;
m_letters_to_animate.Add(letter_idx);
progression_idx ++;
}
}
else if(letter.m_progression_variables.m_word_value > word_idx)
{
if(m_letters_to_animate_option == LETTERS_TO_ANIMATE.FIRST_LETTER_WORDS)
{
letter.m_progression_variables.m_letter_value = progression_idx;
m_letters_to_animate.Add(letter_idx);
progression_idx ++;
}
else if(m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LETTER_WORDS)
{
letter.m_progression_variables.m_letter_value = progression_idx;
m_letters_to_animate.Add(letter_idx - 1);
progression_idx ++;
}
word_idx = letter.m_progression_variables.m_word_value;
}
letter_idx++;
}
if(m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LETTER_WORDS || m_letters_to_animate_option == LETTERS_TO_ANIMATE.LAST_LETTER_LINES)
{
letters[num_letters - 1].m_progression_variables.m_letter_value = letter_idx - 1;
m_letters_to_animate.Add(letter_idx - 1);
}
}
else
{
int progression_idx = 0;
for(int letter_idx=0; letter_idx < num_letters; letter_idx++)
{
if(m_letters_to_animate.Contains(letter_idx))
{
letters[letter_idx].m_progression_variables.m_letter_value = progression_idx;
progression_idx ++;
}
}
}
// Prepare data progression data in all actions
LetterAction letter_action;
LetterAction prev_action = null;
bool letters_in_sync = true;
bool prev_action_end_state = true;
for(int action_idx = 0; action_idx < m_letter_actions.Count; action_idx ++)
{
letter_action = m_letter_actions[action_idx];
letter_action.PrepareData(m_letters_to_animate.Count, num_words, num_lines, prev_action, animate_per, prev_action_end_state);
if(letter_action.m_action_type == ACTION_TYPE.ANIM_SEQUENCE)
{
// Set default previous action settings
prev_action_end_state = true;
prev_action = letter_action;
}
// Check for reverse loops, and how the animation should progress from there
foreach(ActionLoopCycle loop_cycle in m_loop_cycles)
{
if(loop_cycle.m_end_action_idx == action_idx && loop_cycle.m_loop_type == LOOP_TYPE.LOOP_REVERSE)
{
prev_action = m_letter_actions[loop_cycle.m_start_action_idx];
prev_action_end_state = false;
}
}
// Set whether letters in the action are still in sync (starting/ending at the same time)
if(letter_action.m_force_same_start_time)
{
letters_in_sync = true;
}
if(letter_action.m_delay_progression.m_progression != ValueProgression.Constant)
{
letters_in_sync = false;
}
letter_action.m_starting_in_sync = letters_in_sync;
if(letter_action.m_duration_progression.m_progression != ValueProgression.Constant)
{
letters_in_sync = false;
}
letter_action.m_ending_in_sync = letters_in_sync;
}
}
public int GetProgressionIndex(AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per_default)
{
return(progression_variables.GetValue(m_override_animate_per_option ? m_animate_per : animate_per_default));
}
public ParticleEffectInstanceManager(TextFxAnimationManager animation_manager, LetterSetup letter_setup_ref, ParticleEffectSetup effect_setup, AnimationProgressionVariables progression_vars, AnimatePerOptions animate_per, ParticleEmitter particle_emitter = null, ParticleSystem particle_system = null)
public VertexColour GetValue(AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per_default)
{
return(GetValue(GetProgressionIndex(progression_variables, animate_per_default)));
}
public ParticleEffectInstanceManager(TextFxAnimationManager animation_manager, LetterSetup letter_setup_ref, ParticleEffectSetup effect_setup, AnimationProgressionVariables progression_vars, AnimatePerOptions animate_per, ParticleSystem particle_system = null)
#endif
{
#if !UNITY_5_4_OR_NEWER
m_particle_emitter = particle_emitter;
#endif
m_particle_system = particle_system;
m_letter_setup_ref = letter_setup_ref;
m_follow_mesh = effect_setup.m_follow_mesh;
m_duration = effect_setup.m_duration.GetValue(progression_vars, animate_per);
m_delay = effect_setup.m_delay.GetValue(progression_vars, animate_per);
m_position_offset = effect_setup.m_position_offset.GetValue(null, progression_vars, animate_per);
m_rotation_offset = Quaternion.Euler(effect_setup.m_rotation_offset.GetValue(null, progression_vars, animate_per));
m_rotate_with_letter = effect_setup.m_rotate_relative_to_letter;
m_animation_manager = animation_manager;
m_active = false;
#if !UNITY_5_4_OR_NEWER
if (m_particle_emitter != null)
{
m_transform = m_particle_emitter.transform;
m_particle_emitter.emit = true;
m_particle_emitter.enabled = false;
// Set the layer of the effect if an override is specified
if (animation_manager.AnimationInterface.LayerOverride >= 0)
{
m_particle_emitter.gameObject.layer = animation_manager.AnimationInterface.LayerOverride;
}
}
else
#endif
if (m_particle_system != null)
{
m_transform = m_particle_system.transform;
#if UNITY_5_5_OR_NEWER
ParticleSystem.MainModule mainMod = m_particle_system.main;
mainMod.playOnAwake = false;
#else
m_particle_system.playOnAwake = false;
#endif
if (m_delay <= 0)
{
m_particle_system.Play();
}
#if !UNITY_3_5 && UNITY_EDITOR
p_system_timer = 0;
#endif
// Set the layer of the effect if an override is specified
if (animation_manager.AnimationInterface.LayerOverride >= 0)
{
m_particle_system.gameObject.layer = animation_manager.AnimationInterface.LayerOverride;
}
}
}
public void CalculateUniqueRandom(AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per)
{
m_values[GetProgressionIndex(progression_variables, animate_per)] = m_from + (m_to - m_from) * UnityEngine.Random.value;
}
public void PrepareData(int num_letters, int num_words, int num_lines, LetterAction prev_action, AnimatePerOptions animate_per, bool prev_action_end_state = true)
{
m_static_position = false;
m_static_rotation = false;
m_static_scale = false;
m_static_colour = false;
m_duration_progression.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_duration_progression.m_animate_per, m_duration_progression.m_override_animate_per_option));
if(m_audio_on_start != null)
{
m_audio_on_start_volume.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_audio_on_start_volume.m_animate_per, m_audio_on_start_volume.m_override_animate_per_option));
m_audio_on_start_offset.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_audio_on_start_offset.m_animate_per, m_audio_on_start_offset.m_override_animate_per_option));
m_audio_on_start_delay.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_audio_on_start_delay.m_animate_per, m_audio_on_start_delay.m_override_animate_per_option));
m_audio_on_start_pitch.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_audio_on_start_pitch.m_animate_per, m_audio_on_start_pitch.m_override_animate_per_option));
}
if(m_audio_on_finish != null)
{
m_audio_on_finish_volume.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_audio_on_finish_volume.m_animate_per, m_audio_on_finish_volume.m_override_animate_per_option));
m_audio_on_finish_offset.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_audio_on_finish_offset.m_animate_per, m_audio_on_finish_offset.m_override_animate_per_option));
m_audio_on_finish_delay.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_audio_on_finish_delay.m_animate_per, m_audio_on_finish_delay.m_override_animate_per_option));
m_audio_on_finish_pitch.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_audio_on_finish_pitch.m_animate_per, m_audio_on_finish_pitch.m_override_animate_per_option));
}
if(m_emitter_on_start != null)
{
m_emitter_on_start_offset.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_emitter_on_start_offset.m_animate_per, m_emitter_on_start_offset.m_override_animate_per_option), null);
m_emitter_on_start_delay.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_emitter_on_start_delay.m_animate_per, m_emitter_on_start_delay.m_override_animate_per_option));
m_emitter_on_start_duration.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_emitter_on_start_duration.m_animate_per, m_emitter_on_start_duration.m_override_animate_per_option));
}
if(m_emitter_on_finish != null)
{
m_emitter_on_finish_offset.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_emitter_on_finish_offset.m_animate_per, m_emitter_on_finish_offset.m_override_animate_per_option), null);
m_emitter_on_finish_delay.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_emitter_on_finish_delay.m_animate_per, m_emitter_on_finish_delay.m_override_animate_per_option));
m_emitter_on_finish_duration.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_emitter_on_finish_duration.m_animate_per, m_emitter_on_finish_duration.m_override_animate_per_option));
}
if(m_action_type == ACTION_TYPE.BREAK)
{
return;
}
m_delay_progression.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_delay_progression.m_animate_per, m_delay_progression.m_override_animate_per_option));
if(m_offset_from_last && prev_action != null)
{
m_use_gradient_start = prev_action.m_use_gradient_end || prev_action.m_use_gradient;
if(prev_action_end_state)
{
if(m_use_gradient_start)
{
m_start_vertex_colour.m_values = prev_action.m_end_vertex_colour.m_values;
}
else
{
m_start_colour.m_values = prev_action.m_end_colour.m_values;
}
}
else
{
if(m_use_gradient_start)
{
m_start_vertex_colour.m_values = prev_action.m_start_vertex_colour.m_values;
}
else
{
m_start_colour.m_values = prev_action.m_start_colour.m_values;
}
}
}
else
{
if(m_use_gradient_start || m_use_gradient || (prev_action != null && (prev_action.m_use_gradient_end || prev_action.m_use_gradient)))
{
if(!m_use_gradient_start && !m_use_gradient)
{
// Need to convert flat colour into a vertex colour
m_use_gradient_start = true;
m_use_gradient = false;
m_start_vertex_colour.ConvertFromFlatColourProg(m_start_colour);
}
// add this colour to previous state
m_start_vertex_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_vertex_colour.m_animate_per, m_start_vertex_colour.m_override_animate_per_option),
prev_action != null && (prev_action.m_use_gradient_end || prev_action.m_use_gradient) ? prev_action.m_end_vertex_colour.m_values : null,
prev_action != null && (!prev_action.m_use_gradient_end && !prev_action.m_use_gradient) ? prev_action.m_end_colour.m_values : null);
}
else
{
m_start_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_colour.m_animate_per, m_start_colour.m_override_animate_per_option),
prev_action != null ? prev_action.m_end_colour.m_values : null);
}
}
if(m_use_gradient_end || m_use_gradient || m_use_gradient_start || m_use_gradient)
{
if(!m_use_gradient_end && !m_use_gradient)
{
// Need to convert flat colour into a vertex colour
m_use_gradient_end = true;
m_use_gradient = false;
m_end_vertex_colour.ConvertFromFlatColourProg(m_end_colour);
}
m_end_vertex_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_vertex_colour.m_animate_per, m_end_vertex_colour.m_override_animate_per_option),
(m_use_gradient_start || m_use_gradient) ? m_start_vertex_colour.m_values : null,
(!m_use_gradient_start && !m_use_gradient) ? m_start_colour.m_values : null);
}
else
{
m_end_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_colour.m_animate_per, m_end_colour.m_override_animate_per_option),
m_start_colour.m_values);
}
// Static Colour check
if(m_use_gradient_start && m_use_gradient_end && m_start_vertex_colour.m_values.Length == 1 && m_end_vertex_colour.m_values.Length == 1 && m_start_vertex_colour.GetValue(0).Equals(m_end_vertex_colour.GetValue(0)))
{
m_static_colour = true;
// Debug.LogError("Static vertex colours");
}
else if(!m_use_gradient_start && !m_use_gradient_end && m_start_colour.m_values.Length == 1 && m_end_colour.m_values.Length == 1 && m_start_colour.GetValue(0).Equals(m_end_colour.GetValue(0)))
{
m_static_colour = true;
// Debug.LogError("Static flat colours");
}
if(m_offset_from_last && prev_action != null)
{
m_start_pos.m_values = prev_action_end_state ? prev_action.m_end_pos.m_values : prev_action.m_start_pos.m_values;
m_start_euler_rotation.m_values = prev_action_end_state ? prev_action.m_end_euler_rotation.m_values : prev_action.m_start_euler_rotation.m_values;
m_start_scale.m_values = prev_action_end_state ? prev_action.m_end_scale.m_values : prev_action.m_start_scale.m_values;
}
else
{
m_start_pos.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_pos.m_animate_per, m_start_pos.m_override_animate_per_option),
prev_action != null ? prev_action.m_end_pos.m_values : new Vector3[]{Vector3.zero});
m_start_euler_rotation.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_euler_rotation.m_animate_per, m_start_euler_rotation.m_override_animate_per_option),
prev_action != null ? prev_action.m_end_euler_rotation.m_values : new Vector3[]{Vector3.zero});
m_start_scale.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_scale.m_animate_per, m_start_scale.m_override_animate_per_option),
prev_action != null ? prev_action.m_end_scale.m_values : new Vector3[]{Vector3.zero});
}
m_end_pos.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_pos.m_animate_per, m_end_pos.m_override_animate_per_option), m_start_pos.m_values);
m_end_euler_rotation.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_euler_rotation.m_animate_per, m_end_euler_rotation.m_override_animate_per_option), m_start_euler_rotation.m_values);
m_end_scale.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_scale.m_animate_per, m_end_scale.m_override_animate_per_option), m_start_scale.m_values);
if(m_start_pos.m_values.Length == 1 && m_end_pos.m_values.Length == 1 && m_start_pos.m_values[0].Equals(m_end_pos.m_values[0]) && m_start_pos.m_force_position_override == m_end_pos.m_force_position_override)
{
m_static_position = true;
// Debug.Log("Static positions");
}
if(m_start_euler_rotation.m_values.Length == 1 && m_end_euler_rotation.m_values.Length == 1 && m_start_euler_rotation.m_values[0].Equals(m_end_euler_rotation.m_values[0]))
{
m_static_rotation = true;
// Debug.Log("Static rotations");
}
if(m_start_scale.m_values.Length == 1 && m_end_scale.m_values.Length == 1 && m_start_scale.m_values[0].Equals(m_end_scale.m_values[0]))
{
m_static_scale = true;
// Debug.Log("Static scales");
}
}
public void SoftResetStarts(LetterAction prev_action, AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per)
{
if (m_use_gradient_start)
{
if (!m_offset_from_last && m_start_vertex_colour.UniqueRandom)
{
m_start_vertex_colour.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_vertex_colour.Values : null);
}
}
else
{
if (!m_offset_from_last && m_start_colour.UniqueRandom)
{
m_start_colour.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_colour.Values : null);
}
}
if (!m_offset_from_last)
{
if (m_start_pos.UniqueRandom)
{
m_start_pos.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_pos.Values : null);
}
if (m_start_euler_rotation.UniqueRandom)
{
m_start_euler_rotation.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_euler_rotation.Values : null);
}
if (m_start_scale.UniqueRandom)
{
m_start_scale.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_scale.Values : null);
}
}
}
public void SoftReset(LetterAction prev_action, AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per, bool first_action = false)
{
if(m_use_gradient || m_use_gradient_start)
{
if(!m_offset_from_last && m_start_vertex_colour.UniqueRandom && !first_action)
{
m_start_vertex_colour.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_vertex_colour.m_values : null);
}
}
else
{
if(!m_offset_from_last && m_start_colour.UniqueRandom && !first_action)
{
m_start_colour.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_colour.m_values : null);
}
}
if(!m_offset_from_last && !first_action)
{
if(m_start_pos.UniqueRandom)
{
m_start_pos.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_pos.m_values : null);
}
if(m_start_euler_rotation.UniqueRandom)
{
m_start_euler_rotation.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_euler_rotation.m_values : null);
}
if(m_start_scale.UniqueRandom)
{
m_start_scale.CalculateUniqueRandom(progression_variables, animate_per, prev_action != null ? prev_action.m_end_scale.m_values : null);
}
}
// End State Unique Randoms
if(m_use_gradient || m_use_gradient_end)
{
if(m_end_vertex_colour.UniqueRandom)
{
m_end_vertex_colour.CalculateUniqueRandom(progression_variables, animate_per, m_start_vertex_colour.m_values);
}
}
else
{
if(m_end_colour.UniqueRandom)
{
m_end_colour.CalculateUniqueRandom(progression_variables, animate_per, m_start_colour.m_values);
}
}
if(m_end_pos.UniqueRandom)
{
m_end_pos.CalculateUniqueRandom(progression_variables, animate_per, m_start_pos.m_values);
}
if(m_end_euler_rotation.UniqueRandom)
{
m_end_euler_rotation.CalculateUniqueRandom(progression_variables, animate_per, m_start_euler_rotation.m_values);
}
if(m_end_scale.UniqueRandom)
{
m_end_scale.CalculateUniqueRandom(progression_variables, animate_per, m_start_scale.m_values);
}
// Timing unique randoms
if(m_delay_progression.UniqueRandom)
{
m_delay_progression.CalculateUniqueRandom(progression_variables, animate_per);
}
if(m_duration_progression.UniqueRandom)
{
m_duration_progression.CalculateUniqueRandom(progression_variables, animate_per);
}
if(m_audio_on_start != null)
{
if(m_audio_on_start_volume.UniqueRandom)
m_audio_on_start_volume.CalculateUniqueRandom(progression_variables, animate_per);
if(m_audio_on_start_delay.UniqueRandom)
m_audio_on_start_delay.CalculateUniqueRandom(progression_variables, animate_per);
if(m_audio_on_start_offset.UniqueRandom)
m_audio_on_start_offset.CalculateUniqueRandom(progression_variables, animate_per);
if(m_audio_on_start_pitch.UniqueRandom)
m_audio_on_start_pitch.CalculateUniqueRandom(progression_variables, animate_per);
}
if(m_audio_on_finish != null)
{
if(m_audio_on_finish_volume.UniqueRandom)
m_audio_on_finish_volume.CalculateUniqueRandom(progression_variables, animate_per);
if(m_audio_on_finish_delay.UniqueRandom)
m_audio_on_finish_delay.CalculateUniqueRandom(progression_variables, animate_per);
if(m_audio_on_finish_offset.UniqueRandom)
m_audio_on_finish_offset.CalculateUniqueRandom(progression_variables, animate_per);
if(m_audio_on_finish_pitch.UniqueRandom)
m_audio_on_finish_pitch.CalculateUniqueRandom(progression_variables, animate_per);
}
if(m_emitter_on_start != null)
{
if(m_emitter_on_start_offset.UniqueRandom)
m_emitter_on_start_offset.CalculateUniqueRandom(progression_variables, animate_per, null);
if(m_emitter_on_start_delay.UniqueRandom)
m_emitter_on_start_delay.CalculateUniqueRandom(progression_variables, animate_per);
if(m_emitter_on_start_duration.UniqueRandom)
m_emitter_on_start_duration.CalculateUniqueRandom(progression_variables, animate_per);
}
if(m_emitter_on_finish != null)
{
if(m_emitter_on_finish_offset.UniqueRandom)
m_emitter_on_finish_offset.CalculateUniqueRandom(progression_variables, animate_per, null);
if(m_emitter_on_finish_delay.UniqueRandom)
m_emitter_on_finish_delay.CalculateUniqueRandom(progression_variables, animate_per);
if(m_emitter_on_finish_duration.UniqueRandom)
m_emitter_on_finish_duration.CalculateUniqueRandom(progression_variables, animate_per);
}
}
public void PrepareData(ref LetterSetup[] letters, int num_letters, int num_words, int num_lines, LetterAction prev_action, AnimatePerOptions animate_per, bool prev_action_end_state = true)
{
m_duration_progression.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_duration_progression.AnimatePer, m_duration_progression.OverrideAnimatePerOption));
if (m_audio_effects != null)
{
foreach (AudioEffectSetup effect_setup in m_audio_effects)
{
effect_setup.m_delay.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_delay.AnimatePer, effect_setup.m_delay.OverrideAnimatePerOption));
effect_setup.m_offset_time.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_offset_time.AnimatePer, effect_setup.m_offset_time.OverrideAnimatePerOption));
effect_setup.m_volume.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_volume.AnimatePer, effect_setup.m_volume.OverrideAnimatePerOption));
effect_setup.m_pitch.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_pitch.AnimatePer, effect_setup.m_pitch.OverrideAnimatePerOption));
}
}
if (m_particle_effects != null)
{
foreach (ParticleEffectSetup effect_setup in m_particle_effects)
{
effect_setup.m_position_offset.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_position_offset.AnimatePer, effect_setup.m_position_offset.OverrideAnimatePerOption), null);
effect_setup.m_rotation_offset.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_rotation_offset.AnimatePer, effect_setup.m_rotation_offset.OverrideAnimatePerOption), null);
effect_setup.m_delay.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_delay.AnimatePer, effect_setup.m_delay.OverrideAnimatePerOption));
effect_setup.m_duration.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, effect_setup.m_duration.AnimatePer, effect_setup.m_duration.OverrideAnimatePerOption));
}
}
if (m_action_type == ACTION_TYPE.BREAK)
{
return;
}
m_delay_progression.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_delay_progression.AnimatePer, m_delay_progression.OverrideAnimatePerOption));
if (m_offset_from_last && prev_action != null)
{
m_use_gradient_start = prev_action.m_use_gradient_end;
if (prev_action_end_state)
{
if (m_use_gradient_start)
{
m_start_vertex_colour.Values = prev_action.m_end_vertex_colour.Values;
}
else
{
m_start_colour.Values = prev_action.m_end_colour.Values;
}
}
else
{
if (m_use_gradient_start)
{
m_start_vertex_colour.Values = prev_action.m_start_vertex_colour.Values;
}
else
{
m_start_colour.Values = prev_action.m_start_colour.Values;
}
}
}
else
{
if (m_use_gradient_start || (prev_action != null && (prev_action.m_use_gradient_end)))
{
if (!m_use_gradient_start)
{
// Need to convert flat colour into a vertex colour
m_use_gradient_start = true;
m_start_vertex_colour.ConvertFromFlatColourProg(m_start_colour);
}
// add this colour to previous state
m_start_vertex_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_vertex_colour.AnimatePer, m_start_vertex_colour.OverrideAnimatePerOption),
prev_action != null && (prev_action.m_use_gradient_end) ? prev_action.m_end_vertex_colour.Values : null,
prev_action != null && (!prev_action.m_use_gradient_end) ? prev_action.m_end_colour.Values : null);
}
else
{
m_start_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_colour.AnimatePer, m_start_colour.OverrideAnimatePerOption),
prev_action != null ? prev_action.m_end_colour.Values : null);
}
}
if (m_use_gradient_end || m_use_gradient_start)
{
if (!m_use_gradient_end)
{
// Need to convert flat colour into a vertex colour
m_use_gradient_end = true;
m_end_vertex_colour.ConvertFromFlatColourProg(m_end_colour);
}
m_end_vertex_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_vertex_colour.AnimatePer, m_end_vertex_colour.OverrideAnimatePerOption),
(m_use_gradient_start) ? m_start_vertex_colour.Values : null,
(!m_use_gradient_start) ? m_start_colour.Values : null);
}
else
{
m_end_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_colour.AnimatePer, m_end_colour.OverrideAnimatePerOption),
m_start_colour.Values);
}
if (m_offset_from_last && prev_action != null)
{
m_start_pos.Values = prev_action_end_state ? prev_action.m_end_pos.Values : prev_action.m_start_pos.Values;
m_start_euler_rotation.Values = prev_action_end_state ? prev_action.m_end_euler_rotation.Values : prev_action.m_start_euler_rotation.Values;
m_start_scale.Values = prev_action_end_state ? prev_action.m_end_scale.Values : prev_action.m_start_scale.Values;
}
else
{
float[] start_pos_curve_letter_progressions = null;
if (m_start_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX)
{
// Pre calculate letter progression values based on letter spacing
start_pos_curve_letter_progressions = m_start_pos.BezierCurve.GetLetterProgressions(ref letters, m_letter_anchor_start);
}
m_start_pos.CalculatePositionProgressions(ref start_pos_curve_letter_progressions, GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_pos.AnimatePer, m_start_pos.OverrideAnimatePerOption),
prev_action != null ? prev_action.m_end_pos.Values : new Vector3[] { Vector3.zero });
m_start_euler_rotation.CalculateRotationProgressions(ref start_pos_curve_letter_progressions, GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_euler_rotation.AnimatePer, m_start_euler_rotation.OverrideAnimatePerOption),
prev_action != null ? prev_action.m_end_euler_rotation.Values : new Vector3[] { Vector3.zero },
m_start_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX ? m_start_pos.BezierCurve : null);
m_start_scale.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_scale.AnimatePer, m_start_scale.OverrideAnimatePerOption),
prev_action != null ? prev_action.m_end_scale.Values : new Vector3[] { Vector3.zero });
}
float[] end_pos_curve_letter_progressions = null;
if (m_end_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX)
{
// Pre calculate letter progression values based on letter spacing
end_pos_curve_letter_progressions = m_end_pos.BezierCurve.GetLetterProgressions(ref letters, m_letter_anchor_end);
}
m_end_pos.CalculatePositionProgressions(ref end_pos_curve_letter_progressions, GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_pos.AnimatePer, m_end_pos.OverrideAnimatePerOption), m_start_pos.Values);
m_end_euler_rotation.CalculateRotationProgressions(ref end_pos_curve_letter_progressions, GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_euler_rotation.AnimatePer, m_end_euler_rotation.OverrideAnimatePerOption),
m_start_euler_rotation.Values,
m_end_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX ? m_end_pos.BezierCurve : null);
m_end_scale.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_scale.AnimatePer, m_end_scale.OverrideAnimatePerOption), m_start_scale.Values);
CalculateLetterAnchorOffset();
}
public void PrepareData(int num_letters, int num_words, int num_lines, LetterAction prev_action, AnimatePerOptions animate_per, bool prev_action_end_state = true)
{
m_static_position = false;
m_static_rotation = false;
m_static_scale = false;
m_static_colour = false;
m_duration_progression.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_duration_progression.m_animate_per, m_duration_progression.m_override_animate_per_option));
if (m_audio_on_start != null)
{
m_audio_on_start_volume.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_audio_on_start_volume.m_animate_per, m_audio_on_start_volume.m_override_animate_per_option));
m_audio_on_start_offset.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_audio_on_start_offset.m_animate_per, m_audio_on_start_offset.m_override_animate_per_option));
m_audio_on_start_delay.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_audio_on_start_delay.m_animate_per, m_audio_on_start_delay.m_override_animate_per_option));
m_audio_on_start_pitch.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_audio_on_start_pitch.m_animate_per, m_audio_on_start_pitch.m_override_animate_per_option));
}
if (m_audio_on_finish != null)
{
m_audio_on_finish_volume.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_audio_on_finish_volume.m_animate_per, m_audio_on_finish_volume.m_override_animate_per_option));
m_audio_on_finish_offset.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_audio_on_finish_offset.m_animate_per, m_audio_on_finish_offset.m_override_animate_per_option));
m_audio_on_finish_delay.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_audio_on_finish_delay.m_animate_per, m_audio_on_finish_delay.m_override_animate_per_option));
m_audio_on_finish_pitch.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_audio_on_finish_pitch.m_animate_per, m_audio_on_finish_pitch.m_override_animate_per_option));
}
if (m_emitter_on_start != null)
{
m_emitter_on_start_offset.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_emitter_on_start_offset.m_animate_per, m_emitter_on_start_offset.m_override_animate_per_option), null);
m_emitter_on_start_delay.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_emitter_on_start_delay.m_animate_per, m_emitter_on_start_delay.m_override_animate_per_option));
m_emitter_on_start_duration.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_emitter_on_start_duration.m_animate_per, m_emitter_on_start_duration.m_override_animate_per_option));
}
if (m_emitter_on_finish != null)
{
m_emitter_on_finish_offset.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_emitter_on_finish_offset.m_animate_per, m_emitter_on_finish_offset.m_override_animate_per_option), null);
m_emitter_on_finish_delay.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_emitter_on_finish_delay.m_animate_per, m_emitter_on_finish_delay.m_override_animate_per_option));
m_emitter_on_finish_duration.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_emitter_on_finish_duration.m_animate_per, m_emitter_on_finish_duration.m_override_animate_per_option));
}
if (m_action_type == ACTION_TYPE.BREAK)
{
return;
}
m_delay_progression.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_delay_progression.m_animate_per, m_delay_progression.m_override_animate_per_option));
if (m_offset_from_last && prev_action != null)
{
m_use_gradient_start = prev_action.m_use_gradient_end || prev_action.m_use_gradient;
if (prev_action_end_state)
{
if (m_use_gradient_start)
{
m_start_vertex_colour.m_values = prev_action.m_end_vertex_colour.m_values;
}
else
{
m_start_colour.m_values = prev_action.m_end_colour.m_values;
}
}
else
{
if (m_use_gradient_start)
{
m_start_vertex_colour.m_values = prev_action.m_start_vertex_colour.m_values;
}
else
{
m_start_colour.m_values = prev_action.m_start_colour.m_values;
}
}
}
else
{
if (m_use_gradient_start || m_use_gradient || (prev_action != null && (prev_action.m_use_gradient_end || prev_action.m_use_gradient)))
{
if (!m_use_gradient_start && !m_use_gradient)
{
// Need to convert flat colour into a vertex colour
m_use_gradient_start = true;
m_use_gradient = false;
m_start_vertex_colour.ConvertFromFlatColourProg(m_start_colour);
}
// add this colour to previous state
m_start_vertex_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_vertex_colour.m_animate_per, m_start_vertex_colour.m_override_animate_per_option),
prev_action != null && (prev_action.m_use_gradient_end || prev_action.m_use_gradient) ? prev_action.m_end_vertex_colour.m_values : null,
prev_action != null && (!prev_action.m_use_gradient_end && !prev_action.m_use_gradient) ? prev_action.m_end_colour.m_values : null);
}
else
{
m_start_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_colour.m_animate_per, m_start_colour.m_override_animate_per_option),
prev_action != null ? prev_action.m_end_colour.m_values : null);
}
}
if (m_use_gradient_end || m_use_gradient || m_use_gradient_start || m_use_gradient)
{
if (!m_use_gradient_end && !m_use_gradient)
{
// Need to convert flat colour into a vertex colour
m_use_gradient_end = true;
m_use_gradient = false;
m_end_vertex_colour.ConvertFromFlatColourProg(m_end_colour);
}
m_end_vertex_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_vertex_colour.m_animate_per, m_end_vertex_colour.m_override_animate_per_option),
(m_use_gradient_start || m_use_gradient) ? m_start_vertex_colour.m_values : null,
(!m_use_gradient_start && !m_use_gradient) ? m_start_colour.m_values : null);
}
else
{
m_end_colour.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_colour.m_animate_per, m_end_colour.m_override_animate_per_option),
m_start_colour.m_values);
}
// Static Colour check
if (m_use_gradient_start && m_use_gradient_end && m_start_vertex_colour.m_values.Length == 1 && m_end_vertex_colour.m_values.Length == 1 && m_start_vertex_colour.GetValue(0).Equals(m_end_vertex_colour.GetValue(0)))
{
m_static_colour = true;
// Debug.LogError("Static vertex colours");
}
else if (!m_use_gradient_start && !m_use_gradient_end && m_start_colour.m_values.Length == 1 && m_end_colour.m_values.Length == 1 && m_start_colour.GetValue(0).Equals(m_end_colour.GetValue(0)))
{
m_static_colour = true;
// Debug.LogError("Static flat colours");
}
if (m_offset_from_last && prev_action != null)
{
m_start_pos.m_values = prev_action_end_state ? prev_action.m_end_pos.m_values : prev_action.m_start_pos.m_values;
m_start_euler_rotation.m_values = prev_action_end_state ? prev_action.m_end_euler_rotation.m_values : prev_action.m_start_euler_rotation.m_values;
m_start_scale.m_values = prev_action_end_state ? prev_action.m_end_scale.m_values : prev_action.m_start_scale.m_values;
}
else
{
m_start_pos.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_pos.m_animate_per, m_start_pos.m_override_animate_per_option),
prev_action != null ? prev_action.m_end_pos.m_values : new Vector3[] { Vector3.zero });
m_start_euler_rotation.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_euler_rotation.m_animate_per, m_start_euler_rotation.m_override_animate_per_option),
prev_action != null ? prev_action.m_end_euler_rotation.m_values : new Vector3[] { Vector3.zero });
m_start_scale.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_start_scale.m_animate_per, m_start_scale.m_override_animate_per_option),
prev_action != null ? prev_action.m_end_scale.m_values : new Vector3[] { Vector3.zero });
}
m_end_pos.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_pos.m_animate_per, m_end_pos.m_override_animate_per_option), m_start_pos.m_values);
m_end_euler_rotation.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_euler_rotation.m_animate_per, m_end_euler_rotation.m_override_animate_per_option), m_start_euler_rotation.m_values);
m_end_scale.CalculateProgressions(GetProgressionTotal(num_letters, num_words, num_lines, animate_per, m_end_scale.m_animate_per, m_end_scale.m_override_animate_per_option), m_start_scale.m_values);
if (m_start_pos.m_values.Length == 1 && m_end_pos.m_values.Length == 1 && m_start_pos.m_values[0].Equals(m_end_pos.m_values[0]) && m_start_pos.m_force_position_override == m_end_pos.m_force_position_override)
{
m_static_position = true;
// Debug.Log("Static positions");
}
if (m_start_euler_rotation.m_values.Length == 1 && m_end_euler_rotation.m_values.Length == 1 && m_start_euler_rotation.m_values[0].Equals(m_end_euler_rotation.m_values[0]))
{
m_static_rotation = true;
// Debug.Log("Static rotations");
}
if (m_start_scale.m_values.Length == 1 && m_end_scale.m_values.Length == 1 && m_start_scale.m_values[0].Equals(m_end_scale.m_values[0]))
{
m_static_scale = true;
// Debug.Log("Static scales");
}
}
