ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Monomorphisise `Range<T>` to `Int{32,64}Interval`

This commit is contained in:
YoshiRulz 2024-07-10 13:30:02 +10:00
parent a004d2745b
commit 2d5824aa46
No known key found for this signature in database
GPG Key ID: C4DE31C245353FB7
7 changed files with 131 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/BizHawk.Client.EmuHawk/tools/VirtualPads/controls/components/AnalogStickPanel.cs
View File

@ -76,8 +76,10 @@ namespace BizHawk.Client.EmuHawk
Rerange();
}
private Range<int> _rangeX = 0.RangeTo(0);
private Range<int> _rangeY = 0.RangeTo(0);
private Int32Interval _rangeX = 0.RangeTo(0);
private Int32Interval _rangeY = 0.RangeTo(0);
private AxisSpec _fullRangeX;
private AxisSpec _fullRangeY;
@ -286,6 +288,6 @@ namespace BizHawk.Client.EmuHawk
Refresh();
}
private static readonly Range<int> PercentRange = 0.RangeTo(100);
private static readonly Int32Interval PercentRange = 0.RangeTo(100);
}
}

302
src/BizHawk.Common/Ranges.cs
View File

@ -1,251 +1,109 @@
using System.Collections.Generic;
using System.Linq;
using BizHawk.Common.NumberExtensions;
using System.Runtime.CompilerServices;
namespace BizHawk.Common
{
/// <summary>represents a closed range of <typeparamref name="T"/> (class invariant: <see cref="Start"/> ≤ <see cref="EndInclusive"/>)</summary>
public interface Range<out T> where T : unmanaged, IComparable<T>
/// <summary>
/// represents a closed interval (a.k.a. range) of <see cref="int"><c>s32</c>s</see>
/// (class invariant: <see cref="Start"/> ≤ <see cref="EndInclusive"/>)
/// </summary>
public sealed class Int32Interval
{
T Start { get; }
public readonly int Start;
T EndInclusive { get; }
}
public readonly int EndInclusive;
/// <summary>represents a closed range of <typeparamref name="T"/> which can be grown or shrunk (class invariant: <see cref="Start"/> ≤ <see cref="EndInclusive"/>)</summary>
public class MutableRange<T> : Range<T> where T : unmanaged, IComparable<T>
{
private (T Start, T EndInclusive) r;
/// <inheritdoc cref="Overwrite"/>
internal MutableRange(T start, T endInclusive) => Overwrite(start, endInclusive);
/// <exception cref="ArgumentOutOfRangeException">(from setter) <paramref name="value"/> > <see cref="EndInclusive"/></exception>
public T Start
{
get => r.Start;
set => r.Start = r.EndInclusive.CompareTo(value) < 0
? throw new ArgumentOutOfRangeException(nameof(value), value, "attempted to set start > end")
: value;
}
/// <exception cref="ArgumentOutOfRangeException">(from setter) <paramref name="value"/> &lt; <see cref="Start"/></exception>
public T EndInclusive
{
get => r.EndInclusive;
set => r.EndInclusive = value.CompareTo(r.Start) < 0
? throw new ArgumentOutOfRangeException(nameof(value), value, "attempted to set end < start")
: value;
}
/// <exception cref="ArgumentException"><typeparamref name="T"/> is <see langword="float"/>/<see langword="double"/> and either bound is <see cref="float.NaN"/></exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="endInclusive"/> &lt; <paramref name="start"/></exception>
public void Overwrite(T start, T endInclusive)
internal Int32Interval(int start, int endInclusive)
{
if (endInclusive.CompareTo(start) < 0) throw new ArgumentOutOfRangeException(nameof(endInclusive), endInclusive, "range end < start");
if (start is float fs)
{
if (float.IsNaN(fs)) throw new ArgumentException("range start is NaN", nameof(start));
if (endInclusive is float fe && float.IsNaN(fe)) throw new ArgumentException("range end is NaN", nameof(endInclusive));
}
else if (start is double ds)
{
if (double.IsNaN(ds)) throw new ArgumentException("range start is NaN", nameof(start));
if (endInclusive is double de && double.IsNaN(de)) throw new ArgumentException("range end is NaN", nameof(endInclusive));
}
r = (start, endInclusive);
if (endInclusive < start) throw new ArgumentOutOfRangeException(paramName: nameof(endInclusive), actualValue: endInclusive, message: "interval end < start");
Start = start;
EndInclusive = endInclusive;
}
/// <returns>true iff <paramref name="value"/> is contained in this interval (<paramref name="value"/> is considered to be in the interval if it's exactly equal to either bound)</returns>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Contains(int value)
=> Start <= value && value <= EndInclusive;
/// <remarks>beware integer overflow when this interval spans every value</remarks>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public uint Count()
=> (uint) ((long) EndInclusive - Start) + 1U;
}
/// <summary>contains most of the logic for ranges</summary>
/// <remarks>
/// non-generic overloads are used where the method requires an increment or decrement<br/>
/// TODO which Enumerate algorithm is faster - <c>yield return</c> in loop or <see cref="Enumerable.Range"/>?
/// </remarks>
public static class RangeExtensions
/// <summary>
/// represents a closed interval (a.k.a. range) of <see cref="long"><c>s64</c>s</see>
/// (class invariant: <see cref="Start"/> ≤ <see cref="EndInclusive"/>)
/// </summary>
public sealed class Int64Interval
{
private const ulong MIN_LONG_NEGATION_AS_ULONG = 9223372036854775808UL;
public readonly long Start;
public readonly long EndInclusive;
/// <inheritdoc cref="Int32Interval(int,int)"/>
internal Int64Interval(long start, long endInclusive)
{
if (endInclusive < start) throw new ArgumentOutOfRangeException(paramName: nameof(endInclusive), actualValue: endInclusive, message: "interval end < start");
Start = start;
EndInclusive = endInclusive;
}
/// <inheritdoc cref="Int32Interval.Contains"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Contains(long value)
=> Start <= value && value <= EndInclusive;
/// <inheritdoc cref="Int32Interval.Count"/>
public ulong Count()
=> (Contains(0L)
? (Start == long.MinValue ? MIN_LONG_NEGATION_AS_ULONG : (ulong) -Start) + (ulong) EndInclusive
: (ulong) (EndInclusive - Start)
) + 1UL;
}
public static class RangeExtensions
{
private static ArithmeticException ExclusiveRangeMinValExc
=> new("exclusive range end is min value of integral type");
/// <returns><paramref name="value"/> if it's contained in <paramref name="range"/>, or else whichever bound of <paramref name="range"/> is closest to <paramref name="value"/></returns>
public static T ConstrainWithin<T>(this T value, Range<T> range) where T : unmanaged, IComparable<T> => value.CompareTo(range.Start) < 0
? range.Start
: range.EndInclusive.CompareTo(value) < 0
? range.EndInclusive
: value;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int ConstrainWithin(this int value, Int32Interval range)
=> value < range.Start
? range.Start
: range.EndInclusive < value ? range.EndInclusive : value;
/// <returns>true iff <paramref name="value"/> is contained in <paramref name="range"/> (<paramref name="value"/> is considered to be in the range if it's exactly equal to either bound)</returns>
public static bool Contains<T>(this Range<T> range, T value) where T : unmanaged, IComparable<T> => !(value.CompareTo(range.Start) < 0 || range.EndInclusive.CompareTo(value) < 0);
/// <inheritdoc cref="Int32Interval(int,int)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Int32Interval RangeTo(this int start, int endInclusive)
=> new(start: start, endInclusive: endInclusive);
public static uint Count(this Range<byte> range) => (uint) (range.EndInclusive - range.Start + 1);
/// <remarks>beware integer overflow when <paramref name="range"/> contains every value</remarks>
public static uint Count(this Range<int> range) => (uint) ((long) range.EndInclusive - range.Start) + 1U;
/// <inheritdoc cref="Count(Range{int})"/>
public static ulong Count(this Range<long> range) => (range.Contains(0L)
? (range.Start == long.MinValue ? MIN_LONG_NEGATION_AS_ULONG : (ulong) -range.Start) + (ulong) range.EndInclusive
: (ulong) (range.EndInclusive - range.Start)
) + 1UL;
public static uint Count(this Range<sbyte> range) => (uint) (range.EndInclusive - range.Start + 1);
public static uint Count(this Range<short> range) => (uint) (range.EndInclusive - range.Start + 1);
/// <inheritdoc cref="Count(Range{int})"/>
public static uint Count(this Range<uint> range) => range.EndInclusive - range.Start + 1U;
/// <inheritdoc cref="Count(Range{int})"/>
public static ulong Count(this Range<ulong> range) => range.EndInclusive - range.Start + 1UL;
public static uint Count(this Range<ushort> range) => (uint) (range.EndInclusive - range.Start + 1);
public static void Deconstruct<T>(this Range<T> range, out T start, out T endInclusive)
where T : unmanaged, IComparable<T>
{
start = range.Start;
endInclusive = range.EndInclusive;
}
public static IEnumerable<byte> Enumerate(this Range<byte> range) => Enumerable.Range(range.Start, (int) range.Count()).Select(i => (byte) i);
/// <inheritdoc cref="Enumerate(Range{float},float)"/>
public static IEnumerable<double> Enumerate(this Range<double> range, double step)
{
var d = range.Start;
while (d < range.EndInclusive)
{
yield return d;
d += step;
}
if (d.HawkFloatEquality(range.EndInclusive)) yield return d;
}
/// <remarks>beware precision errors</remarks>
public static IEnumerable<float> Enumerate(this Range<float> range, float step)
{
var f = range.Start;
while (f < range.EndInclusive)
{
yield return f;
f += step;
}
if (f.HawkFloatEquality(range.EndInclusive)) yield return f;
}
public static IEnumerable<int> Enumerate(this Range<int> range)
{
var i = range.Start;
while (i < range.EndInclusive) yield return i++;
yield return i;
}
public static IEnumerable<long> Enumerate(this Range<long> range)
{
var l = range.Start;
while (l < range.EndInclusive) yield return l++;
yield return l;
}
public static IEnumerable<sbyte> Enumerate(this Range<sbyte> range) => Enumerable.Range(range.Start, (int) range.Count()).Select(i => (sbyte) i);
public static IEnumerable<short> Enumerate(this Range<short> range) => Enumerable.Range(range.Start, (int) range.Count()).Select(i => (short) i);
public static IEnumerable<uint> Enumerate(this Range<uint> range)
{
var i = range.Start;
while (i < range.EndInclusive) yield return i++;
yield return i;
}
public static IEnumerable<ulong> Enumerate(this Range<ulong> range)
{
var l = range.Start;
while (l < range.EndInclusive) yield return l++;
yield return l;
}
public static IEnumerable<ushort> Enumerate(this Range<ushort> range) => Enumerable.Range(range.Start, (int) range.Count()).Select(i => (ushort) i);
public static Range<T> GetImmutableCopy<T>(this Range<T> range) where T : unmanaged, IComparable<T> => GetMutableCopy(range);
public static MutableRange<T> GetMutableCopy<T>(this Range<T> range) where T : unmanaged, IComparable<T> => new MutableRange<T>(range.Start, range.EndInclusive);
/// <inheritdoc cref="MutableRange{T}(T,T)"/>
public static MutableRange<T> MutableRangeTo<T>(this T start, T endInclusive) where T : unmanaged, IComparable<T> => new MutableRange<T>(start, endInclusive);
/// <inheritdoc cref="RangeToExclusive(int,int)"/>
public static MutableRange<byte> MutableRangeToExclusive(this byte start, byte endExclusive) => endExclusive == byte.MinValue
? throw ExclusiveRangeMinValExc
: new MutableRange<byte>(start, (byte) (endExclusive - 1U));
/// <inheritdoc cref="RangeToExclusive(int,int)"/>
public static MutableRange<int> MutableRangeToExclusive(this int start, int endExclusive) => endExclusive == int.MinValue
? throw ExclusiveRangeMinValExc
: new MutableRange<int>(start, endExclusive - 1);
/// <inheritdoc cref="RangeToExclusive(int,int)"/>
public static MutableRange<long> MutableRangeToExclusive(this long start, long endExclusive) => endExclusive == long.MinValue
? throw ExclusiveRangeMinValExc
: new MutableRange<long>(start, endExclusive - 1L);
/// <inheritdoc cref="RangeToExclusive(int,int)"/>
public static MutableRange<sbyte> MutableRangeToExclusive(this sbyte start, sbyte endExclusive) => endExclusive == sbyte.MinValue
? throw ExclusiveRangeMinValExc
: new MutableRange<sbyte>(start, (sbyte) (endExclusive - 1));
/// <inheritdoc cref="RangeToExclusive(int,int)"/>
public static MutableRange<short> MutableRangeToExclusive(this short start, short endExclusive) => endExclusive == short.MinValue
? throw ExclusiveRangeMinValExc
: new MutableRange<short>(start, (short) (endExclusive - 1));
/// <inheritdoc cref="RangeToExclusive(int,int)"/>
public static MutableRange<uint> MutableRangeToExclusive(this uint start, uint endExclusive) => endExclusive == uint.MinValue
? throw ExclusiveRangeMinValExc
: new MutableRange<uint>(start, endExclusive - 1U);
/// <inheritdoc cref="RangeToExclusive(int,int)"/>
public static MutableRange<ulong> MutableRangeToExclusive(this ulong start, ulong endExclusive) => endExclusive == ulong.MinValue
? throw ExclusiveRangeMinValExc
: new MutableRange<ulong>(start, endExclusive - 1UL);
/// <inheritdoc cref="RangeToExclusive(int,int)"/>
public static MutableRange<ushort> MutableRangeToExclusive(this ushort start, ushort endExclusive) => endExclusive == ushort.MinValue
? throw ExclusiveRangeMinValExc
: new MutableRange<ushort>(start, (ushort) (endExclusive - 1U));
/// <inheritdoc cref="MutableRange{T}(T,T)"/>
public static Range<T> RangeTo<T>(this T start, T endInclusive) where T : unmanaged, IComparable<T> => start.MutableRangeTo(endInclusive);
/// <inheritdoc cref="RangeToExclusive(int,int)"/>
public static Range<byte> RangeToExclusive(this byte start, byte endExclusive) => MutableRangeToExclusive(start, endExclusive);
/// <inheritdoc cref="Int64Interval(long,long)"/>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Int64Interval RangeTo(this long start, long endInclusive)
=> new(start: start, endInclusive: endInclusive);
/// <exception cref="ArgumentOutOfRangeException"><paramref name="endExclusive"/> ≤ <paramref name="start"/> (empty ranges where <paramref name="start"/> = <paramref name="endExclusive"/> are not permitted)</exception>
/// <exception cref="ArithmeticException"><paramref name="endExclusive"/> is min value of integral type (therefore <paramref name="endExclusive"/> ≤ <paramref name="start"/>)</exception>
public static Range<int> RangeToExclusive(this int start, int endExclusive) => MutableRangeToExclusive(start, endExclusive);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Int32Interval RangeToExclusive(this int start, int endExclusive)
=> endExclusive == int.MinValue
? throw ExclusiveRangeMinValExc
: new(start: start, endInclusive: endExclusive - 1);
/// <inheritdoc cref="RangeToExclusive(int,int)"/>
public static Range<long> RangeToExclusive(this long start, long endExclusive) => MutableRangeToExclusive(start, endExclusive);
/// <inheritdoc cref="RangeToExclusive(int,int)"/>
public static Range<sbyte> RangeToExclusive(this sbyte start, sbyte endExclusive) => MutableRangeToExclusive(start, endExclusive);
/// <inheritdoc cref="RangeToExclusive(int,int)"/>
public static Range<short> RangeToExclusive(this short start, short endExclusive) => MutableRangeToExclusive(start, endExclusive);
/// <inheritdoc cref="RangeToExclusive(int,int)"/>
public static Range<uint> RangeToExclusive(this uint start, uint endExclusive) => MutableRangeToExclusive(start, endExclusive);
/// <inheritdoc cref="RangeToExclusive(int,int)"/>
public static Range<ulong> RangeToExclusive(this ulong start, ulong endExclusive) => MutableRangeToExclusive(start, endExclusive);
/// <inheritdoc cref="RangeToExclusive(int,int)"/>
public static Range<ushort> RangeToExclusive(this ushort start, ushort endExclusive) => MutableRangeToExclusive(start, endExclusive);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Int64Interval RangeToExclusive(this long start, long endExclusive)
=> endExclusive == long.MinValue
? throw ExclusiveRangeMinValExc
: new(start: start, endInclusive: endExclusive - 1L);
/// <returns>true iff <paramref name="value"/> is strictly contained in <paramref name="range"/> (<paramref name="value"/> is considered to be OUTSIDE the range if it's exactly equal to either bound)</returns>
public static bool StrictlyBoundedBy<T>(this T value, Range<T> range) where T : unmanaged, IComparable<T> => range.Start.CompareTo(value) < 0 && value.CompareTo(range.EndInclusive) < 0;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool StrictlyBoundedBy(this int value, Int32Interval range)
=> range.Start < value && value < range.EndInclusive;
}
}

4
src/BizHawk.Emulation.Common/Base Implementations/Axes/AxisSpec.cs
View File

@ -25,9 +25,9 @@ namespace BizHawk.Emulation.Common
public string? PairedAxis => Constraint?.PairedAxis;
public readonly Range<int> Range;
public readonly Int32Interval Range;
public AxisSpec(Range<int> range, int neutral, bool isReversed = false, AxisConstraint? constraint = null)
public AxisSpec(Int32Interval range, int neutral, bool isReversed = false, AxisConstraint? constraint = null)
{
Constraint = constraint;
IsReversed = isReversed;

6
src/BizHawk.Emulation.Common/Base Implementations/MemoryDomain.cs
View File

@ -102,7 +102,7 @@ namespace BizHawk.Emulation.Common
}
}
public virtual void BulkPeekByte(Range<long> addresses, byte[] values)
public virtual void BulkPeekByte(Int64Interval addresses, byte[] values)
{
if (addresses is null) throw new ArgumentNullException(paramName: nameof(addresses));
if (values is null) throw new ArgumentNullException(paramName: nameof(values));
@ -121,7 +121,7 @@ namespace BizHawk.Emulation.Common
}
}
public virtual void BulkPeekUshort(Range<long> addresses, bool bigEndian, ushort[] values)
public virtual void BulkPeekUshort(Int64Interval addresses, bool bigEndian, ushort[] values)
{
if (addresses is null) throw new ArgumentNullException(paramName: nameof(addresses));
if (values is null) throw new ArgumentNullException(paramName: nameof(values));
@ -145,7 +145,7 @@ namespace BizHawk.Emulation.Common
}
}
public virtual void BulkPeekUint(Range<long> addresses, bool bigEndian, uint[] values)
public virtual void BulkPeekUint(Int64Interval addresses, bool bigEndian, uint[] values)
{
if (addresses is null) throw new ArgumentNullException(paramName: nameof(addresses));
if (values is null) throw new ArgumentNullException(paramName: nameof(values));

22
src/BizHawk.Emulation.Common/Base Implementations/MemoryDomainImpls.cs
View File

@ -11,9 +11,11 @@ namespace BizHawk.Emulation.Common
private Action<long, byte> _poke;
// TODO: use an array of Ranges
private Action<Range<long>, byte[]> _bulkPeekByte { get; set; }
private Action<Range<long>, bool, ushort[]> _bulkPeekUshort { get; set; }
private Action<Range<long>, bool, uint[]> _bulkPeekUint { get; set; }
private Action<Int64Interval, byte[]> _bulkPeekByte { get; set; }
private Action<Int64Interval, bool, ushort[]> _bulkPeekUshort { get; set; }
private Action<Int64Interval, bool, uint[]> _bulkPeekUint { get; set; }
public Func<long, byte> Peek { get; set; }
@ -37,7 +39,7 @@ namespace BizHawk.Emulation.Common
_poke?.Invoke(addr, val);
}
public override void BulkPeekByte(Range<long> addresses, byte[] values)
public override void BulkPeekByte(Int64Interval addresses, byte[] values)
{
if (_bulkPeekByte != null)
{
@ -49,7 +51,7 @@ namespace BizHawk.Emulation.Common
}
}
public override void BulkPeekUshort(Range<long> addresses, bool bigEndian, ushort[] values)
public override void BulkPeekUshort(Int64Interval addresses, bool bigEndian, ushort[] values)
{
if (_bulkPeekUshort != null)
{
@ -61,7 +63,7 @@ namespace BizHawk.Emulation.Common
}
}
public override void BulkPeekUint(Range<long> addresses, bool bigEndian, uint[] values)
public override void BulkPeekUint(Int64Interval addresses, bool bigEndian, uint[] values)
{
if (_bulkPeekUint != null)
{
@ -80,9 +82,9 @@ namespace BizHawk.Emulation.Common
Func<long, byte> peek,
Action<long, byte> poke,
int wordSize,
Action<Range<long>, byte[]> bulkPeekByte = null,
Action<Range<long>, bool, ushort[]> bulkPeekUshort = null,
Action<Range<long>, bool, uint[]> bulkPeekUint = null)
Action<Int64Interval, byte[]> bulkPeekByte = null,
Action<Int64Interval, bool, ushort[]> bulkPeekUshort = null,
Action<Int64Interval, bool, uint[]> bulkPeekUint = null)
{
Name = name;
EndianType = endian;
@ -210,7 +212,7 @@ namespace BizHawk.Emulation.Common
}
}
public override void BulkPeekByte(Range<long> addresses, byte[] values)
public override void BulkPeekByte(Int64Interval addresses, byte[] values)
{
var start = (ulong)addresses.Start;
var count = addresses.Count();

33
src/BizHawk.Emulation.Common/Extensions.cs
View File

@ -444,7 +444,13 @@ namespace BizHawk.Emulation.Common
/// </summary>
/// <param name="constraint">pass only for one axis in a pair, by convention the X axis</param>
/// <returns>identical reference to <paramref name="def"/>; the object is mutated</returns>
public static ControllerDefinition AddAxis(this ControllerDefinition def, string name, Range<int> range, int neutral, bool isReversed = false, AxisConstraint constraint = null)
public static ControllerDefinition AddAxis(
this ControllerDefinition def,
string name,
Int32Interval range,
int neutral,
bool isReversed = false,
AxisConstraint constraint = null)
{
def.Axes.Add(name, new AxisSpec(range, neutral, isReversed, constraint));
return def;
@ -456,7 +462,15 @@ namespace BizHawk.Emulation.Common
/// </summary>
/// <param name="nameFormat">format string e.g. <c>"P1 Left {0}"</c> (will be used to interpolate <c>"X"</c> and <c>"Y"</c>)</param>
/// <returns>identical reference to <paramref name="def"/>; the object is mutated</returns>
public static ControllerDefinition AddXYPair(this ControllerDefinition def, string nameFormat, AxisPairOrientation pDir, Range<int> rangeX, int neutralX, Range<int> rangeY, int neutralY, AxisConstraint constraint = null)
public static ControllerDefinition AddXYPair(
this ControllerDefinition def,
string nameFormat,
AxisPairOrientation pDir,
Int32Interval rangeX,
int neutralX,
Int32Interval rangeY,
int neutralY,
AxisConstraint constraint = null)
{
var yAxisName = string.Format(nameFormat, "Y");
var finalConstraint = constraint ?? new NoOpAxisConstraint(yAxisName);
@ -470,8 +484,14 @@ namespace BizHawk.Emulation.Common
/// </summary>
/// <param name="nameFormat">format string e.g. <c>"P1 Left {0}"</c> (will be used to interpolate <c>"X"</c> and <c>"Y"</c>)</param>
/// <returns>identical reference to <paramref name="def"/>; the object is mutated</returns>
public static ControllerDefinition AddXYPair(this ControllerDefinition def, string nameFormat, AxisPairOrientation pDir, Range<int> rangeBoth, int neutralBoth, AxisConstraint constraint = null)
=> def.AddXYPair(nameFormat, pDir, rangeBoth, neutralBoth, rangeBoth, neutralBoth, constraint);
public static ControllerDefinition AddXYPair(
this ControllerDefinition def,
string nameFormat,
AxisPairOrientation pDir,
Int32Interval rangeBoth,
int neutralBoth,
AxisConstraint constraint = null)
=> def.AddXYPair(nameFormat, pDir, rangeBoth, neutralBoth, rangeBoth, neutralBoth, constraint);
/// <summary>
/// Adds an X/Y/Z triple of axes to the receiver <see cref="ControllerDefinition"/>, and returns it.
@ -479,12 +499,13 @@ namespace BizHawk.Emulation.Common
/// </summary>
/// <param name="nameFormat">format string e.g. <c>"P1 Tilt {0}"</c> (will be used to interpolate <c>"X"</c>, <c>"Y"</c>, and <c>"Z"</c>)</param>
/// <returns>identical reference to <paramref name="def"/>; the object is mutated</returns>
public static ControllerDefinition AddXYZTriple(this ControllerDefinition def, string nameFormat, Range<int> rangeAll, int neutralAll)
public static ControllerDefinition AddXYZTriple(this ControllerDefinition def, string nameFormat, Int32Interval rangeAll, int neutralAll)
=> def.AddAxis(string.Format(nameFormat, "X"), rangeAll, neutralAll)
.AddAxis(string.Format(nameFormat, "Y"), rangeAll, neutralAll)
.AddAxis(string.Format(nameFormat, "Z"), rangeAll, neutralAll);
public static AxisSpec With(this in AxisSpec spec, Range<int> range, int neutral) => new AxisSpec(range, neutral, spec.IsReversed, spec.Constraint);
public static AxisSpec With(this in AxisSpec spec, Int32Interval range, int neutral)
=> new(range, neutral, spec.IsReversed, spec.Constraint);
public static string SystemIDToDisplayName(string sysID)
=> SystemIDDisplayNames.TryGetValue(sysID, out var dispName) ? dispName : string.Empty;

4
src/BizHawk.Emulation.Cores/Waterbox/WaterboxMemoryDomain.cs
View File

@ -99,7 +99,7 @@ namespace BizHawk.Emulation.Cores.Waterbox
}
}
public override void BulkPeekByte(Range<long> addresses, byte[] values)
public override void BulkPeekByte(Int64Interval addresses, byte[] values)
{
if (_addressMangler != 0)
{
@ -189,7 +189,7 @@ namespace BizHawk.Emulation.Cores.Waterbox
}
}
public override void BulkPeekByte(Range<long> addresses, byte[] values)
public override void BulkPeekByte(Int64Interval addresses, byte[] values)
{
if (_addressMangler != 0)
{