451 lines
8.1 KiB
C#
451 lines
8.1 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
[Serializable]
|
|
public class value_class
|
|
{
|
|
public List<float> value;
|
|
|
|
public List<Vector2> value_multi;
|
|
|
|
public List<float> select_value;
|
|
|
|
public List<bool> active;
|
|
|
|
public List<Rect> rect;
|
|
|
|
public List<string> text;
|
|
|
|
public bool value_active;
|
|
|
|
public float value_total;
|
|
|
|
public int active_total;
|
|
|
|
public AnimationCurve curve;
|
|
|
|
public animation_curve_math_class animation_curve_math;
|
|
|
|
public SliderMode_Enum mode;
|
|
|
|
public value_class()
|
|
{
|
|
value = new List<float>();
|
|
value_multi = new List<Vector2>();
|
|
select_value = new List<float>();
|
|
active = new List<bool>();
|
|
rect = new List<Rect>();
|
|
text = new List<string>();
|
|
value_active = true;
|
|
curve = new AnimationCurve();
|
|
animation_curve_math = new animation_curve_math_class();
|
|
}
|
|
|
|
public virtual void calc_active_total()
|
|
{
|
|
active_total = 0;
|
|
for (int i = 0; i < value.Count; i++)
|
|
{
|
|
if (active[i])
|
|
{
|
|
value_total += value[i];
|
|
active_total++;
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual int calc_index(int index)
|
|
{
|
|
int num = 0;
|
|
for (int i = 0; i < index; i++)
|
|
{
|
|
if (active[i])
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
public virtual void set_values(int value_index)
|
|
{
|
|
if (mode == SliderMode_Enum.One)
|
|
{
|
|
calc_value();
|
|
}
|
|
else
|
|
{
|
|
set_value_multi(value_index);
|
|
}
|
|
}
|
|
|
|
public virtual void Active(int index)
|
|
{
|
|
}
|
|
|
|
public virtual float GetPreviousValue(int index)
|
|
{
|
|
float result = 0f;
|
|
for (int num = index - 1; num >= 0; num--)
|
|
{
|
|
if (active[num])
|
|
{
|
|
result = value_multi[num].y;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public virtual int GetPreviousIndex(int index)
|
|
{
|
|
int num = index - 1;
|
|
int result;
|
|
while (true)
|
|
{
|
|
if (num >= 0)
|
|
{
|
|
if (active[num])
|
|
{
|
|
result = num;
|
|
break;
|
|
}
|
|
num--;
|
|
continue;
|
|
}
|
|
result = -1;
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public virtual float GetNextValue(int index)
|
|
{
|
|
float result = 0f;
|
|
for (int i = index + 1; i < value.Count; i++)
|
|
{
|
|
if (active[i])
|
|
{
|
|
result = value_multi[i].x;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public virtual int GetNextIndex(int index)
|
|
{
|
|
int num = index + 1;
|
|
int result;
|
|
while (true)
|
|
{
|
|
if (num < value.Count)
|
|
{
|
|
if (active[num])
|
|
{
|
|
result = num;
|
|
break;
|
|
}
|
|
num++;
|
|
continue;
|
|
}
|
|
result = value.Count;
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public virtual void calc_value()
|
|
{
|
|
value_total = 0f;
|
|
float num = 0f;
|
|
int num2 = default(int);
|
|
calc_active_total();
|
|
Keyframe[] array = new Keyframe[active_total + 1];
|
|
int num3 = default(int);
|
|
num3 = 0;
|
|
if (mode == SliderMode_Enum.One)
|
|
{
|
|
for (num2 = 0; num2 < value.Count; num2++)
|
|
{
|
|
if (active[num2])
|
|
{
|
|
array[num3].value = 1f / ((float)active_total * 1f) * (float)(num3 + 1);
|
|
array[num3].time = num + value[num2] / value_total;
|
|
select_value[num2] = (num * 2f + value[num2] / value_total) / 2f;
|
|
text[num2] = "(" + num.ToString("F2") + "-" + array[num3].time.ToString("F2") + ")";
|
|
num = array[num3].time;
|
|
num3++;
|
|
}
|
|
else
|
|
{
|
|
text[num2] = "(- )";
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (num2 = 0; num2 < value.Count; num2++)
|
|
{
|
|
if (active[num2])
|
|
{
|
|
array[num3].value = 1f / ((float)active_total * 1f) * (float)(num3 + 1);
|
|
array[num3].time = value_multi[num2].y / 100f;
|
|
if (array[num3].time == num)
|
|
{
|
|
if (!(array[num3].time < 1f))
|
|
{
|
|
array[num3 - 1].time = array[num3 - 1].time - 0.01f;
|
|
}
|
|
else
|
|
{
|
|
array[num3].time = array[num3].time + 0.01f;
|
|
}
|
|
}
|
|
text[num2] = "(" + num.ToString("F2") + "-" + array[num3].time.ToString("F2") + ")";
|
|
num = array[num3].time;
|
|
num3++;
|
|
}
|
|
else
|
|
{
|
|
text[num2] = "(- )";
|
|
}
|
|
}
|
|
}
|
|
curve = animation_curve_math.set_curve_linear(new AnimationCurve(array));
|
|
}
|
|
|
|
public virtual void set_value_multi(int index)
|
|
{
|
|
if (value.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
calc_active_total();
|
|
if (!(value_multi[index].y >= value_multi[index].x))
|
|
{
|
|
value_multi[index] = new Vector2(value_multi[index].x, value_multi[index].x + 0.5f);
|
|
}
|
|
int num = default(int);
|
|
int num2 = 0;
|
|
for (num = 0; num < value.Count; num++)
|
|
{
|
|
if (!active[num] && num > 0)
|
|
{
|
|
num2++;
|
|
continue;
|
|
}
|
|
if (num > index)
|
|
{
|
|
value_multi[num] = new Vector2(value_multi[num - 1 - num2].y, value_multi[num].y);
|
|
if (!(value_multi[num].x <= value_multi[num].y))
|
|
{
|
|
value_multi[num] = new Vector2(value_multi[num].x, value_multi[num].x + 0.5f);
|
|
}
|
|
}
|
|
num2 = 0;
|
|
}
|
|
num2 = 0;
|
|
if (index > 0)
|
|
{
|
|
for (num = index - 1; num >= 0; num--)
|
|
{
|
|
if (!active[num])
|
|
{
|
|
num2++;
|
|
}
|
|
else
|
|
{
|
|
value_multi[num] = new Vector2(value_multi[num].x, value_multi[num + 1 + num2].x);
|
|
if (!(value_multi[num].y >= value_multi[num].x))
|
|
{
|
|
value_multi[num] = new Vector2(value_multi[num].y - 0.5f, value_multi[num].y);
|
|
}
|
|
num2 = 0;
|
|
}
|
|
}
|
|
}
|
|
int num3 = 0;
|
|
for (num = 0; num < value.Count; num++)
|
|
{
|
|
if (active[num])
|
|
{
|
|
if (num3 == 0)
|
|
{
|
|
value_multi[num] = new Vector2(0f, value_multi[num].y);
|
|
}
|
|
if (num3 == active_total - 1)
|
|
{
|
|
value_multi[num] = new Vector3(value_multi[num].x, 100f);
|
|
}
|
|
num3++;
|
|
}
|
|
}
|
|
calc_value();
|
|
}
|
|
|
|
public virtual void reset_values()
|
|
{
|
|
if (mode == SliderMode_Enum.One)
|
|
{
|
|
for (int i = 0; i < value.Count; i++)
|
|
{
|
|
value[i] = 50f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
reset_value_multi();
|
|
}
|
|
calc_value();
|
|
}
|
|
|
|
public virtual void reset_value_multi()
|
|
{
|
|
int num = 0;
|
|
int num2 = 0;
|
|
Vector2 vector = default(Vector2);
|
|
calc_active_total();
|
|
if (active_total == 0)
|
|
{
|
|
return;
|
|
}
|
|
for (int i = 0; i < value.Count; i++)
|
|
{
|
|
if (active[i])
|
|
{
|
|
if (num2 == 0)
|
|
{
|
|
vector.x = 0f;
|
|
}
|
|
else
|
|
{
|
|
vector.x = value_multi[i - 1 - num].y;
|
|
}
|
|
vector.y = vector.x + 100f / (float)active_total;
|
|
if (num2 == active_total)
|
|
{
|
|
vector.y = 100f;
|
|
}
|
|
value_multi[i] = vector;
|
|
num = 0;
|
|
num2++;
|
|
}
|
|
else
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual void reset_single_value(int index)
|
|
{
|
|
if (mode == SliderMode_Enum.One)
|
|
{
|
|
value[index] = 50f;
|
|
calc_value();
|
|
}
|
|
else if (active[index])
|
|
{
|
|
calc_active_total();
|
|
int num = calc_index(index);
|
|
value_multi[index] = new Vector2(1f / (float)active_total * (float)num * 100f, (1f / (float)active_total * (float)num + 1f / (float)active_total) * 100f);
|
|
set_value_multi(index);
|
|
}
|
|
}
|
|
|
|
public virtual void change_value_active(bool invert)
|
|
{
|
|
for (int i = 0; i < value.Count; i++)
|
|
{
|
|
if (!invert)
|
|
{
|
|
active[i] = value_active;
|
|
}
|
|
else
|
|
{
|
|
active[i] = !active[i];
|
|
}
|
|
}
|
|
set_values(0);
|
|
}
|
|
|
|
public virtual void add_value(int index, float number)
|
|
{
|
|
value.Insert(index, number);
|
|
if (index > 0)
|
|
{
|
|
value_multi.Insert(index, new Vector2(100f, 100f));
|
|
}
|
|
else
|
|
{
|
|
value_multi.Insert(index, new Vector2(0f, 100f));
|
|
}
|
|
rect.Insert(index, default(Rect));
|
|
select_value.Insert(index, 0f);
|
|
active.Insert(index, true);
|
|
text.Insert(index, string.Empty);
|
|
calc_value();
|
|
}
|
|
|
|
public virtual void erase_value(int index)
|
|
{
|
|
value.RemoveAt(index);
|
|
rect.RemoveAt(index);
|
|
value_multi.RemoveAt(index);
|
|
select_value.RemoveAt(index);
|
|
active.RemoveAt(index);
|
|
text.RemoveAt(index);
|
|
if (value.Count > 0)
|
|
{
|
|
set_values(0);
|
|
}
|
|
}
|
|
|
|
public virtual void clear_value()
|
|
{
|
|
value.Clear();
|
|
rect.Clear();
|
|
value_multi.Clear();
|
|
select_value.Clear();
|
|
active.Clear();
|
|
text.Clear();
|
|
}
|
|
|
|
public virtual void SyncValueMulti()
|
|
{
|
|
int num = value.Count - value_multi.Count;
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
if (i > 0)
|
|
{
|
|
value_multi.Add(new Vector2(100f, 100f));
|
|
}
|
|
else
|
|
{
|
|
value_multi.Add(new Vector2(0f, 100f));
|
|
}
|
|
rect.Add(default(Rect));
|
|
}
|
|
if (num != 0)
|
|
{
|
|
reset_value_multi();
|
|
}
|
|
}
|
|
|
|
public virtual void swap_value(int index1, int index2)
|
|
{
|
|
float num = value[index1];
|
|
float num2 = select_value[index1];
|
|
bool flag = active[index1];
|
|
value[index1] = value[index2];
|
|
select_value[index1] = select_value[index2];
|
|
active[index1] = active[index2];
|
|
value[index2] = num;
|
|
select_value[index2] = num2;
|
|
active[index2] = flag;
|
|
calc_value();
|
|
}
|
|
}
|