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); }