private List <RangeFloat> getPossibleRanges()
{
List <RangeFloat> ranges = new List <RangeFloat>();
blocked.Sort(new RangeFloatComparer());
float start = 0.0F;
if (blocked.Count > 0)
{
foreach (RangeFloat rf in blocked)
{
RangeFloat crf = rf.clean;
if (start < crf.start)
{
ranges.Add(new RangeFloat(start, crf.start));
}
start = crf.end;
}
RangeFloat last = blocked[blocked.Count - 1];
if (last.end < 1.0F)
{
ranges.Add(new RangeFloat(last.end, 1.0F - last.end));
}
}
else
{
ranges.Add(new RangeFloat(0.0F, 1.0F));
}
return(ranges);
}
private RangeFloat IntervalForChecking(RangeFloat interval)
{
RangeFloat newInterval = interval.Inflated(mistakeTimingLeeway);
newInterval.max = Mathf.Floor(newInterval.max) + 1.0f;
return(newInterval);
}
public void RangeFloatInvalid()
{
RangeFloat range = new RangeFloat()
{
Value = 0.9f
};
range = ValidateSettings <RangeFloat> .Validate(range);
}
public void RangeFloatValid2()
{
RangeFloat range = new RangeFloat()
{
Value = 40f
};
range = ValidateSettings <RangeFloat> .Validate(range);
}
public static bool Intersects(this RangeFloat a, RangeFloat b)
{
if (a.min <= b.min && b.max <= a.max)
{
return(true);
}
if (b.min <= a.min && a.max <= b.max)
{
return(true);
}
return(a.Contains(b.min) || a.Contains(b.max));
}
public void LimitMovement(PhysicsObject phObj)
{
if (phObj.HMobile)
{
var currentX = phObj.CurrentX;
var nextX = phObj.NextX;
var left = phObj.HSpeed < 0.0f;
var wall = GetWall(phObj.FhId, left, phObj.NextY);
var collision = left ? currentX >= wall && nextX <= wall : currentX <= wall && nextX >= wall;
if (!collision && phObj.IsFlagSet(PhysicsObject.Flag.TurnAtEdges))
{
wall = GetEdge(phObj.FhId, left);
collision = left ? currentX >= wall && nextX <= wall : currentX <= wall && nextX >= wall;
}
if (collision)
{
phObj.LimitX(wall);
phObj.ClearFlag(PhysicsObject.Flag.TurnAtEdges);
}
}
if (!phObj.VMobile)
{
return;
}
{
var currentY = phObj.CurrentY;
var nextY = phObj.NextY;
var ground = new RangeFloat(GetFh(phObj.FhId).GroundBelow(phObj.CurrentY),
GetFh(phObj.FhId).GroundBelow(phObj.NextX));
var collision = currentY <= ground.First && nextY >= ground.Second;
if (collision)
{
phObj.LimitY(ground.Second);
LimitMovement(phObj);
}
else
{
phObj.LimitY(nextY < Borders.First ? Borders.First : Borders.Second);
}
}
}
private bool getPosition(float where, List <RangeFloat> possible, out float position, out RangeFloat range)
{
float localBlockRange = blockRange / transform.localScale.x;
foreach (RangeFloat rf in possible)
{
if (where <= rf.length)
{
position = rf.start + where;
range = new RangeFloat(position - (localBlockRange / 2.0F), localBlockRange);
range = new RangeFloat(position - (localBlockRange / 2.0F), localBlockRange);
return(true);
}
}
position = 0;
range = RangeFloat.zero;
return(false);
}
public IEnumerator Show(VideoPlayer player, RangeFloat interval, Color color)
{
Assert.IsNotNull(image);
image.color = color;
float NormalizedTime(float time) => (float)(time / player.length);
var rt = GetComponent <RectTransform>();
float anchorMinX = NormalizedTime(interval.min);
rt.anchorMin = new Vector2(anchorMinX, 0.0f);
rt.anchorMax = new Vector2(anchorMinX, 1.0f);
while ((float)player.time <= interval.max)
{
rt.anchorMax = new Vector2(NormalizedTime(interval.Clamp((float)player.time)), 1.0f);
yield return(null);
}
}
/// <summary>
/// Initializes the linear correction filter.
/// </summary>
/// <param name="delta">Delta [-100, 100]</param>
/// <param name="space">Color space</param>
public LinearCorrection(float delta, Space space)
{
Range = new RangeFloat(0, 1); Delta = delta; this.Space = space;
}
/// <summary>
/// Initializes the linear correction filter.
/// </summary>
/// <param name="range">Range values</param>
/// <param name="delta">Delta [-1, 1]</param>
/// <param name="space">Color space</param>
public LinearCorrection(RangeFloat range, float delta, Space space)
{
Range = range; Delta = delta; this.Space = space;
}
/// <summary>
/// Returns the correction mask.
/// </summary>
/// <param name="input">Input values</param>
/// <param name="output">Output values</param>
/// <param name="length">Length</param>
/// <returns>Array</returns>
public static float[] Levels(RangeFloat input, RangeFloat output, int length)
{
return(Intensity.Levels(input.Min, input.Max, output.Min, output.Max, length));
}
/// <summary>
/// Returns the correction mask.
/// </summary>
/// <param name="range">Pair of numbers Max и Min</param>
/// <param name="delta">Delta</param>
/// <param name="length">Length</param>
/// <returns>Array</returns>
public static float[] Linear(RangeFloat range, float delta, int length)
{
return(Intensity.Linear(range.Max, range.Min, delta, length));
}
public static bool Intersects(this RangeFloat a, RangeFloat b, float margin)
{
return(a.Inflated(margin).Intersects(b));
}
public static float InRangeScale(this RangeFloat _value, float _check) => Mathf.InverseLerp(_value.start, _value.end, _check);
public static float normalizeRange(float value, RangeFloat range, bool clamp = true)
{
return(normalizeRange(value, range.min, range.max, clamp));
}
public static bool InRange(this RangeFloat _value, float _check) => _value.start <= _check && _check <= _value.end;
public static float GetRandomRange(RangeFloat range)
{
return(Random.Range(range.MinValue, range.MaxValue));
}
public static float Random(this RangeFloat ir, System.Random seed = null) => seed?.Next((int)(ir.start * 1000), (int)(ir.end * 1000)) / 1000f ?? UnityEngine.Random.Range(ir.start, ir.end);
/// <summary>
/// Initializes the global histogram stretch filter.
/// </summary>
/// <param name="range">Intensity range</param>
/// <param name="space">Color space</param>
public HistogramStretch(RangeFloat range, Space space)
{
Range = range;
Space = space;
}
/// <summary>
/// Initializes the global histogram stretch filter.
/// </summary>
/// <param name="min">Minimum intensity [0, 1]</param>
/// <param name="max">Maximum intensity [0, 1]</param>
/// <param name="space">Color space</param>
public HistogramStretch(float min, float max, Space space)
{
Range = new RangeFloat(min, max);
Space = space;
}
/// <summary>
/// Initializes the linear correction filter.
/// </summary>
public LinearCorrection()
{
Range = new RangeFloat(0, 1); Delta = 0.5f; this.Space = space;
}
public static RangeFloat Inflated(this RangeFloat range, float marginMin, float marginMax)
{
return(new RangeFloat(range.min - marginMin, range.max + marginMax));
}
public static float remap(float value, RangeFloat from, RangeFloat to, bool clamp = true)
{
return(remap(value, from.min, from.max, to.min, to.max, clamp));
}
public bool Equals(RangeFloat other)
{
return(start == other.start && length == other.length);
}
/// <summary>
/// Initializes the levels correction filter.
/// </summary>
/// <param name="input">Input channel values</param>
/// <param name="output">Output channel values</param>
/// <param name="space">Color space</param>
public LevelsCorrection(RangeFloat input, RangeFloat output, Space space)
{
Input = input; Output = output; this.Space = space;
}
public IEnumerator Add(VideoPlayer videoPlayer, RangeFloat timeInterval, Color color)
{
MistakeIntervalIndicator intervalIndicator = Instantiate(indicatorPrefab, transform);
yield return(intervalIndicator.Show(videoPlayer, timeInterval, color));
}
/// <summary>
/// Initializes the levels correction filter.
/// </summary>
public LevelsCorrection()
{
Input = new RangeFloat(0, 1);
Output = new RangeFloat(0, 1);
}
