diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json index 03efa87b74..b9f6941232 100644 --- a/.config/dotnet-tools.json +++ b/.config/dotnet-tools.json @@ -3,10 +3,11 @@ "isRoot": true, "tools": { "csharpier": { - "version": "0.29.2", + "version": "1.0.1", "commands": [ - "dotnet-csharpier" - ] + "csharpier" + ], + "rollForward": false } } } \ No newline at end of file diff --git a/Silk.NET.sln b/Silk.NET.sln index 7c83ca6760..ff14ca8dae 100644 --- a/Silk.NET.sln +++ b/Silk.NET.sln @@ -118,6 +118,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "OpenAL", "OpenAL", "{662A1A EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tutorial001.HelloSound", "examples\CSharp\OpenAL\Tutorial001.HelloSound\Tutorial001.HelloSound.csproj", "{946C912C-5BBB-446A-A566-0D1696D19F59}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Input", "Input", "{61DB4B9A-9EF6-4F31-A8F5-BEAF37FA8AD1}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silk.NET.Input", "sources\Input\Input\Silk.NET.Input.csproj", "{DDADB0F1-DFC9-4297-B0B0-92984D6F6F4C}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -196,6 +200,10 @@ Global {946C912C-5BBB-446A-A566-0D1696D19F59}.Debug|Any CPU.Build.0 = Debug|Any CPU {946C912C-5BBB-446A-A566-0D1696D19F59}.Release|Any CPU.ActiveCfg = Release|Any CPU {946C912C-5BBB-446A-A566-0D1696D19F59}.Release|Any CPU.Build.0 = Release|Any CPU + {DDADB0F1-DFC9-4297-B0B0-92984D6F6F4C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {DDADB0F1-DFC9-4297-B0B0-92984D6F6F4C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {DDADB0F1-DFC9-4297-B0B0-92984D6F6F4C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {DDADB0F1-DFC9-4297-B0B0-92984D6F6F4C}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -233,8 +241,8 @@ Global {12B4D1CB-8938-4EC4-8895-79C4E6ABD1E8} = {6077EDD4-F16F-4CA4-B72E-E4627D64B104} {662A1AEC-91F2-48FA-AA29-6F27038D30F2} = {12B4D1CB-8938-4EC4-8895-79C4E6ABD1E8} {946C912C-5BBB-446A-A566-0D1696D19F59} = {662A1AEC-91F2-48FA-AA29-6F27038D30F2} - {5E20252F-E2A0-46C9-BBEF-4CE5C96D0E07} = {DD29EA8F-B1A6-45AA-8D2E-B38DA56D9EF6} - {E5E8FFBF-1319-4D33-B084-E732656E8A04} = {5E20252F-E2A0-46C9-BBEF-4CE5C96D0E07} + {61DB4B9A-9EF6-4F31-A8F5-BEAF37FA8AD1} = {DD29EA8F-B1A6-45AA-8D2E-B38DA56D9EF6} + {DDADB0F1-DFC9-4297-B0B0-92984D6F6F4C} = {61DB4B9A-9EF6-4F31-A8F5-BEAF37FA8AD1} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {78D2CF6A-60A1-43E3-837B-00B73C9DA384} diff --git a/docs/silk.net/diagnostics/ST0001.md b/docs/silk.net/diagnostics/ST0001.md new file mode 100644 index 0000000000..f04906d857 --- /dev/null +++ b/docs/silk.net/diagnostics/ST0001.md @@ -0,0 +1,21 @@ +# ST0001 - ProcessClass failure + +## Overview + +This internal error was raised by SilkTouch when failing to generate an implementation for a binding at source +generation time. It provided details regarding the exception that led to the entire native API class failing to have its +implementation generated. + +| Attribute | Value | +|--------------------|----------------------| +| Diagnostic ID | ST0001 | +| Title | ProcessClass failure | +| Category | SilkTouch.Internal | +| Default Severity | Error | +| Enabled by Default | Yes | + +Example message: `ProcessClass failed. Exception: '...'` + +## Explanation & Solutions + +This functionality is no longer supported in 3.0, where this diagnostic is never raised. diff --git a/docs/silk.net/diagnostics/ST0002.md b/docs/silk.net/diagnostics/ST0002.md new file mode 100644 index 0000000000..89742a49a7 --- /dev/null +++ b/docs/silk.net/diagnostics/ST0002.md @@ -0,0 +1,21 @@ +# ST0002 - MethodClass failure + +## Overview + +This internal error was raised by SilkTouch when failing to generate an implementation for a binding at source +generation time. It provided details regarding the exception that led to a specific native API method failing to have +its implementation generated. + +| Attribute | Value | +|--------------------|---------------------| +| Diagnostic ID | ST0002 | +| Title | MethodClass failure | +| Category | SilkTouch.Internal | +| Default Severity | Error | +| Enabled by Default | Yes | + +Example message: `MethodClass failed. Exception: '...'` + +## Explanation & Solutions + +This functionality is no longer supported in 3.0, where this diagnostic is never raised. diff --git a/docs/silk.net/diagnostics/ST0003.md b/docs/silk.net/diagnostics/ST0003.md new file mode 100644 index 0000000000..d722f5f6d7 --- /dev/null +++ b/docs/silk.net/diagnostics/ST0003.md @@ -0,0 +1,20 @@ +# ST0003 - Silk.NET.Core is Missing + +## Overview + +This internal diagnostic was raised by SilkTouch when failing to generate an implementation for bindings at source +generation time due to the binding project missing a reference to Silk.NET.Core. + +| Attribute | Value | +|--------------------|---------------------| +| Diagnostic ID | ST0003 | +| Title | MethodClass failure | +| Category | SilkTouch.Internal | +| Default Severity | Info | +| Enabled by Default | Yes | + +Example message: `Silk.NET.Core is missing from references. You should use SilkTouch with Silk.NET.Core` + +## Explanation & Solutions + +This functionality is no longer supported in 3.0, where this diagnostic is never raised. diff --git a/docs/silk.net/diagnostics/ST0004.md b/docs/silk.net/diagnostics/ST0004.md new file mode 100644 index 0000000000..4680d3faa3 --- /dev/null +++ b/docs/silk.net/diagnostics/ST0004.md @@ -0,0 +1,20 @@ +# ST0004 - Build Info + +## Overview + +This internal diagnostic was raised by SilkTouch when configured to do so. It provided diagnostic information relating +to the performance and characteristics of SilkTouch's internals. + +| Attribute | Value | +|--------------------|--------------------| +| Diagnostic ID | ST0004 | +| Title | Build Info | +| Category | SilkTouch.Internal | +| Default Severity | Warning | +| Enabled by Default | Yes | + +Example message: `GCSlotCount: '127'. Time: '6437ms'` + +## Explanation & Solutions + +This functionality is no longer supported in 3.0, where this diagnostic is never raised. diff --git a/docs/silk.net/diagnostics/ST0005.md b/docs/silk.net/diagnostics/ST0005.md new file mode 100644 index 0000000000..8a7c730766 --- /dev/null +++ b/docs/silk.net/diagnostics/ST0005.md @@ -0,0 +1,15 @@ +# ST0005 - Intentionally Unstable API + +## Overview + +This diagnostic is raised when trying to use a Silk.NET API that has been marked with the `Experimental` attribute due +to its API and/or ABI being unstable. When this diagnostic ID is used, it indicates that it is intentional that this is +the case and that this API is extremely unlikely to ever graduate to a stable, versioned API. + +## Explanation & Solutions + +Typically, APIs meeting this description are internal APIs and are not intended for use outside of the assembly they're +defined in. As a result, where this diagnostic is raised, you should cease use of this API or at least only continue if +you can guarantee that you will never update Silk.NET ever again and that your downstream consumers, if applicable, will +lock their version to the same version referenced by your project. However, please reconsider use of the API if this is +the case. diff --git a/eng/build/Silk.NET.NUKE.csproj b/eng/build/Silk.NET.NUKE.csproj index b6071aa7bd..a485d81551 100644 --- a/eng/build/Silk.NET.NUKE.csproj +++ b/eng/build/Silk.NET.NUKE.csproj @@ -19,4 +19,10 @@ + + + + Directory.Build\tests\Input\Input\Silk.NET.Input.UnitTests.csproj + + diff --git a/eng/submodules/openal-soft b/eng/submodules/openal-soft index 6e0d0b39b3..9f6fa42d90 160000 --- a/eng/submodules/openal-soft +++ b/eng/submodules/openal-soft @@ -1 +1 @@ -Subproject commit 6e0d0b39b3d9e5b027f01bdd2fbf18ca8ce5a2db +Subproject commit 9f6fa42d902609bb9f77e4831d9183effad546f5 diff --git a/eng/submodules/silk.net-2.x b/eng/submodules/silk.net-2.x index c87fc664cc..ca36450946 160000 --- a/eng/submodules/silk.net-2.x +++ b/eng/submodules/silk.net-2.x @@ -1 +1 @@ -Subproject commit c87fc664cc5d15abd754997b0a9ad138470554c4 +Subproject commit ca364509467f0fb40af40f7ed040b4c63670a4c6 diff --git a/sources/Core/Core/Pointers/PointerExtensions.cs b/sources/Core/Core/Pointers/PointerExtensions.cs index cfacf2de27..41f57aa519 100644 --- a/sources/Core/Core/Pointers/PointerExtensions.cs +++ b/sources/Core/Core/Pointers/PointerExtensions.cs @@ -1,3 +1,4 @@ +using System.Diagnostics; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Text; @@ -232,6 +233,43 @@ public static string ReadToString(this Ptr @this) } } + /// + /// Populates the given span with the characters of this as a c-style string. + /// + /// + /// The span to populate characters into + /// True if the given span is of sufficient length and can be filled - false otherwise, in which case + /// no data has been modified in the given span + public static bool TryReadToSpan(this Ptr @this, ref Span span) + { + fixed (void* raw = @this) + { + var bytes = MemoryMarshal.CreateReadOnlySpanFromNullTerminated((byte*)raw); + var count = Encoding.UTF8.GetCharCount(bytes); + if (span.Length < count) + { + return false; + } + + #if DEBUG + // This if-def is here to prevent this constant string from taking up space in extremely constrained + // release environments. + const string assertionLog = $"{nameof(Encoding)}.{nameof(Encoding.UTF8)}." + + $"{nameof(Encoding.UTF8.GetChars)}) returned an unexpected number of " + + $"characters"; + + var charCount = Encoding.UTF8.GetChars(bytes, span); + Debug.Assert(charCount == count, assertionLog);; + #else + Encoding.UTF8.GetChars(bytes, span); + #endif + + span = span[..count]; + return true; + } + } + + /// /// Creates a string from this with the given length /// diff --git a/sources/Core/Core/PublicAPI/net10.0/PublicAPI.Unshipped.txt b/sources/Core/Core/PublicAPI/net10.0/PublicAPI.Unshipped.txt index c1f3456ebc..9addc7e060 100644 --- a/sources/Core/Core/PublicAPI/net10.0/PublicAPI.Unshipped.txt +++ b/sources/Core/Core/PublicAPI/net10.0/PublicAPI.Unshipped.txt @@ -481,6 +481,7 @@ static Silk.NET.Core.PointerExtensions.ReadToStringArray(this Silk.NET.Core.Ref3 static Silk.NET.Core.PointerExtensions.ReadToStringArray(this Silk.NET.Core.Ref3D this, int length, int[]! lengths) -> string?[]?[]? static Silk.NET.Core.PointerExtensions.ReadToStringArray(this Silk.NET.Core.Ref3D this, int length, int[]! lengths) -> string?[]?[]? static Silk.NET.Core.PointerExtensions.ReadToStringArray(this Silk.NET.Core.Ref3D this, int length, int[]! lengths) -> string?[]?[]? +static Silk.NET.Core.PointerExtensions.TryReadToSpan(this Silk.NET.Core.Ptr this, ref System.Span span) -> bool static Silk.NET.Core.Ptr.explicit operator nint(Silk.NET.Core.Ptr ptr) -> nint static Silk.NET.Core.Ptr.explicit operator Silk.NET.Core.Ptr(nint ptr) -> Silk.NET.Core.Ptr static Silk.NET.Core.Ptr.explicit operator Silk.NET.Core.Ptr(Silk.NET.Core.Ref ptr) -> Silk.NET.Core.Ptr diff --git a/sources/Core/Core/PublicAPI/net8.0/PublicAPI.Unshipped.txt b/sources/Core/Core/PublicAPI/net8.0/PublicAPI.Unshipped.txt index 8123f98932..2b7101b7a3 100644 --- a/sources/Core/Core/PublicAPI/net8.0/PublicAPI.Unshipped.txt +++ b/sources/Core/Core/PublicAPI/net8.0/PublicAPI.Unshipped.txt @@ -416,6 +416,7 @@ static Silk.NET.Core.PointerExtensions.ReadToStringArray(this Silk.NET.Core.Ref3 static Silk.NET.Core.PointerExtensions.ReadToStringArray(this Silk.NET.Core.Ref3D this, int length, int[]! lengths) -> string?[]?[]? static Silk.NET.Core.PointerExtensions.ReadToStringArray(this Silk.NET.Core.Ref3D this, int length, int[]! lengths) -> string?[]?[]? static Silk.NET.Core.PointerExtensions.ReadToStringArray(this Silk.NET.Core.Ref3D this, int length, int[]! lengths) -> string?[]?[]? +static Silk.NET.Core.PointerExtensions.TryReadToSpan(this Silk.NET.Core.Ptr this, ref System.Span span) -> bool static Silk.NET.Core.Ptr.explicit operator nint(Silk.NET.Core.Ptr ptr) -> nint static Silk.NET.Core.Ptr.explicit operator Silk.NET.Core.Ptr(nint ptr) -> Silk.NET.Core.Ptr static Silk.NET.Core.Ptr.explicit operator Silk.NET.Core.Ptr(Silk.NET.Core.Ref ptr) -> Silk.NET.Core.Ptr diff --git a/sources/Input/Input/Button.cs b/sources/Input/Input/Button.cs new file mode 100644 index 0000000000..1ae8875c65 --- /dev/null +++ b/sources/Input/Input/Button.cs @@ -0,0 +1,24 @@ +namespace Silk.NET.Input; + +/// +/// Represents a button the user can push. +/// +/// The name of the button. +/// Whether the user is pushing the button. +/// +/// The pressure with which the user is pushing the button, where 0.0 is the smallest measurable pressure and +/// 1.0 is the largest measurable pressure. +/// +/// +/// The button type (e.g. , , etc). +/// +public readonly record struct Button(T Name, bool IsDown, float Pressure) + where T : unmanaged, Enum +{ + /// + /// Collapses this struct into just its value. + /// + /// The button state. + /// The value. + public static implicit operator bool(Button state) => state.IsDown; +} diff --git a/sources/Input/Input/ButtonChangedEvent.cs b/sources/Input/Input/ButtonChangedEvent.cs new file mode 100644 index 0000000000..eb2c07ad73 --- /dev/null +++ b/sources/Input/Input/ButtonChangedEvent.cs @@ -0,0 +1,22 @@ +using System.Diagnostics; +using Silk.NET.Input.SDL3; + +namespace Silk.NET.Input; + +/// +/// Contains information pertaining to a button state change (e.g. press, depress, etc). +/// +/// The device on which the button being pressed or depressed resides. +/// +/// The timestamp (as retrieved from ) at which the event occurred. +/// +/// The new state of the button being pressed or depressed. +/// The previous state of the button. +/// The button type e.g. , , etc. +public readonly record struct ButtonChangedEvent( + IButtonDevice Device, + long Timestamp, + Button Button, + Button Previous +) + : ITimestampedEvent where T : unmanaged, Enum; diff --git a/sources/Input/Input/ButtonReadOnlyList.cs b/sources/Input/Input/ButtonReadOnlyList.cs new file mode 100644 index 0000000000..1cd98aa366 --- /dev/null +++ b/sources/Input/Input/ButtonReadOnlyList.cs @@ -0,0 +1,47 @@ +using System.Collections; + +namespace Silk.NET.Input; + +/// +/// An implementation of providing utility APIs for getting a +/// given a button name , that is optimised for storing s with the +/// given button name type using the most memory-efficient mechanism available. +/// +/// +/// The button type (e.g. , , etc). +/// +public readonly record struct ButtonReadOnlyList : IReadOnlyList> + where T : unmanaged, Enum +{ + private readonly Func _indexMap; + private readonly IReadOnlyList> _list; + + /// + /// A constructor for an input list that takes in: + /// + /// A list of buttons that will be indexed + /// A pre-built mapping function, if required, + /// used for iterating through the button list in order, regardless of the backend's internal button order. + public ButtonReadOnlyList(IReadOnlyList> buttonList, Func? indexMap = null) + { + _list = buttonList; + _indexMap = indexMap ?? (i => i); + } + + /// + /// Gets the state for the button with the given name. + /// + /// The button name. + public Button this[T name] => _list[EnumInfo.ValueIndexOf(name)]; + + /// + public IEnumerator> GetEnumerator() => _list.GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + + /// + public int Count => _list.Count; + + /// + public Button this[int index] => _list[_indexMap(index)]; +} diff --git a/sources/Input/Input/ConnectionEvent.cs b/sources/Input/Input/ConnectionEvent.cs new file mode 100644 index 0000000000..85d57230c2 --- /dev/null +++ b/sources/Input/Input/ConnectionEvent.cs @@ -0,0 +1,14 @@ +using System.Diagnostics; +using Silk.NET.Input.SDL3; + +namespace Silk.NET.Input; + +/// +/// Contains information pertaining to a device connection or disconnection event. +/// +/// The device that has disconnected or connected. +/// +/// The timestamp (as retrieved from ) at which the event occurred. +/// +/// Whether the device has connected (true) or disconnected (false). +public readonly record struct ConnectionEvent(IInputDevice Device, long Timestamp, bool IsConnected) : ITimestampedEvent; diff --git a/sources/Input/Input/CursorModes.cs b/sources/Input/Input/CursorModes.cs new file mode 100644 index 0000000000..a5ce021ea8 --- /dev/null +++ b/sources/Input/Input/CursorModes.cs @@ -0,0 +1,57 @@ +namespace Silk.NET.Input; + +/// +/// Enumerates the modes in which a mouse cursor can operate. +/// +/// +/// implementations for implementations typically have two +/// : +/// +/// +/// Bounded +/// +/// An that is bounded to the desktop environment i.e. the +/// are not infinite and reflect the total screen space that is available to the +/// running application in window coordinates. This is typically the sum of all monitor resolutions, with the positions +/// being defined using an implementation-defined mechanism. The window bounds operate in this same coordinate space. +/// It is highly unlikely that you will be unable to determine the individual points for multiple mice on this target, +/// as desktop environments typically aggregate all movement from all mice into a single . +/// This target is used for every cursor mode except . +/// +/// +/// +/// Unbounded +/// +/// An that is unbounded and operates in an arbitrary coordinate space. This target is used +/// for raw mouse mode and points on this target represent the net mouse movement from a mouse. Implementations +/// are more likely to be able to give multiple s for each mouse when this target is used. This +/// target is used when the cursor mode is enabled. will +/// represent an infinitely large unbounded target. +/// +/// +/// +/// +[Flags] +public enum CursorModes +{ + /// + /// The cursor is visible to the user and operating within the bounds of the desktop environment. The + /// coordinates received are in desktop coordinates, operating in the same coordinate space as the window + /// position/size. + /// + Normal = 1 << 0, + + /// + /// The cursor is visible to the user but is constrained to the window's client area. The coordinates + /// received are in desktop coordinates, operating in the same coordinate space as the window position/size. + /// The bounded to the desktop environment is used. + /// + Confined = 1 << 1, + + /// + /// The cursor is invisible to the user and is unconstrained/unbounded. The coordinates received are + /// arbitrary values that have no bounds representing the net mouse movement since entering into this cursor mode. + /// The unbounded is used. This is the equivalent of raw mouse mode. + /// + Unbounded = 1 << 2, +} \ No newline at end of file diff --git a/sources/Input/Input/CursorStyles.cs b/sources/Input/Input/CursorStyles.cs new file mode 100644 index 0000000000..65ecfc6f55 --- /dev/null +++ b/sources/Input/Input/CursorStyles.cs @@ -0,0 +1,61 @@ +namespace Silk.NET.Input; + +/// +/// Enumerates the cursor styles with which the desktop environment should render the cursor. +/// +[Flags] +public enum CursorStyles +{ + /// + /// The cursor should be rendered using its default image. + /// + Default, + + /// + /// The cursor should be rendered using an arrow cursor image. + /// + Arrow = 1 << 0, + + /// + /// The cursor should be rendered using an I-beam cursor image, which is used to show where the text cursor appears + /// when the mouse is clicked. + /// + IBeam = 1 << 1, + + /// + /// The cursor should be rendered using a crosshair cursor image. + /// + Crosshair = 1 << 2, + + /// + /// The cursor should be rendered using a hand cursor image, typically used when hovering over a web link. + /// + Hand = 1 << 3, + + /// + /// The cursor should be rendered using a two-headed horizontal sizing cursor image. + /// + HResize = 1 << 4, + + /// + /// The cursor should be rendered using a two-headed vertical sizing cursor image. + /// + VResize = 1 << 5, + + /// + /// The cursor should not be rendered. + /// + /// + /// When is used, the cursor ceases to exist anyway. As such, while the + /// property may not reflect this (as it is retained across changes to + /// and just ignored when is used), + /// can be implied as being when + /// is used. + /// + Hidden = 1 << 6, + + /// + /// The cursor should be rendered using a custom application-provided image. + /// + Custom = 1 << 7, +} \ No newline at end of file diff --git a/sources/Input/Input/CustomCursor.cs b/sources/Input/Input/CustomCursor.cs new file mode 100644 index 0000000000..2a38345bd0 --- /dev/null +++ b/sources/Input/Input/CustomCursor.cs @@ -0,0 +1,69 @@ +namespace Silk.NET.Input; + +/// +/// Represents a custom image for a mouse cursor. +/// +public readonly ref struct CustomCursor : IEquatable +{ + /// + /// The number of pixels in the X axis. + /// + public int Width { get; init; } + + /// + /// The number of pixels in the Y axis. + /// + public int Height { get; init; } + + /// + /// The row-major 32-bit RGBA pixel data (i.e. 8 bits for each colour component). + /// + public ReadOnlySpan Data { get; init; } // Rgba32 + + // equality operator override + /// + /// Value-based equality operator + /// + /// Note that this operator does not consider reference equality + public static bool operator ==(CustomCursor left, CustomCursor right) => left.Width == right.Width && + left.Height == right.Height && + left.Data.Length == right.Data.Length && + left.Data.SequenceEqual(right.Data); + + /// + /// Value-based inequality operator + /// + /// Note that this operator does not consider reference equality + public static bool operator !=(CustomCursor left, CustomCursor right) => !(left == right); + + /// + /// Value-based equality check. + /// + /// + /// + public bool Equals(CustomCursor other) => Width == other.Width && Height == other.Height && Data.SequenceEqual(other.Data); + + /// + /// Value-based hashcode + /// + public override int GetHashCode() + { + HashCode hashCode = new(); + hashCode.Add(Width); + hashCode.Add(Height); + for (var i = 0; i < Data.Length; ++i) + { + hashCode.Add(Data[i]); + } + + return hashCode.ToHashCode(); + } + + /// + /// Reference-based equality check. Because this is a ref struct, this will always return false, as + /// this cannot escape the stack, and thus cannot be boxed, and thus cannot be cast to/from object. + /// + /// + /// + public override bool Equals(object? o) => false; +} diff --git a/sources/Input/Input/DualReadOnlyList.cs b/sources/Input/Input/DualReadOnlyList.cs new file mode 100644 index 0000000000..2181706f22 --- /dev/null +++ b/sources/Input/Input/DualReadOnlyList.cs @@ -0,0 +1,58 @@ +using System.Collections; + +namespace Silk.NET.Input; + +/// +/// Represents a list that has exactly two elements. +/// +/// The element type. +public readonly struct DualReadOnlyList : IReadOnlyList +{ + /// + /// Represents a list that has exactly two elements. + /// + /// The element type. + + public DualReadOnlyList(Func left, Func right) + { + _left = left; + _right = right; + } + + /// + /// The first/leftmost element. + /// + public T Left => _left(); + + /// + /// The second/rightmost element. + /// + public T Right => _right(); + + + /// + public IEnumerator GetEnumerator() + { + yield return Left; + yield return Right; + } + + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + + /// + public int Count => 2; + + /// + public T this[int index] => + index switch + { + 0 => Left, + 1 => Right, + _ => throw new IndexOutOfRangeException(), + }; + + + + private readonly Func _left; + private readonly Func _right; +} diff --git a/sources/Input/Input/GamepadState.cs b/sources/Input/Input/GamepadState.cs new file mode 100644 index 0000000000..62ea3e9605 --- /dev/null +++ b/sources/Input/Input/GamepadState.cs @@ -0,0 +1,59 @@ +using System.Numerics; + +namespace Silk.NET.Input; + +/// +/// Contains user input received from an . +/// +public class GamepadState +{ + /// + /// The constructor for a new GamepadState object + /// + /// The list of buttons + /// The list of states of the controllers axes that the triggers and joysticks will + /// be read from via their specific indices in this array + /// The joystick X axes. + /// The Joystick Y axes. + /// + /// + /// For and , the must be either of length + /// 2 or 4. + /// + /// If two are provided, the first is assumed to be the left stick, and the second is assumed to be the right stick + /// + /// if 4 are provided, it is assumed that the first two are - and + sides of the first axis, and so on. + ///[leftX, rightX] OR [-leftX, +leftX, -rightX, +rightX] + /// + /// + /// + public GamepadState(IReadOnlyList> buttons, IReadOnlyList axisStates) + { + _axisStates = axisStates; + Buttons = new ButtonReadOnlyList(buttons); + Triggers = new DualReadOnlyList( + left: () => _axisStates[JoystickAxis.LeftTrigger.Index()], + right: () =>_axisStates[JoystickAxis.RightTrigger.Index()]); + Thumbsticks = new DualReadOnlyList( + left: () => new Vector2(_axisStates[JoystickAxis.LeftX.Index()], _axisStates[JoystickAxis.LeftY.Index()]), + right: () => new Vector2(_axisStates[JoystickAxis.RightX.Index()], _axisStates[JoystickAxis.RightY.Index()])); + } + + /// + /// Gets the gamepad button state denoting the buttons being pressed or depressed. + /// + public ButtonReadOnlyList Buttons { get; } + + /// + /// Gets the state of the twin sticks on the gamepad. + /// + public DualReadOnlyList Thumbsticks { get; internal set; } + + /// + /// Gets the state of the triggers on the gamepad. + /// + public DualReadOnlyList Triggers { get; internal set; } + + // ReSharper disable PrivateFieldCanBeConvertedToLocalVariable <- keeps closures consistent + private readonly IReadOnlyList _axisStates; +} diff --git a/sources/Input/Input/GamepadThumbstickMoveEvent.cs b/sources/Input/Input/GamepadThumbstickMoveEvent.cs new file mode 100644 index 0000000000..4fccbeb7b1 --- /dev/null +++ b/sources/Input/Input/GamepadThumbstickMoveEvent.cs @@ -0,0 +1,22 @@ +using System.Diagnostics; +using System.Numerics; +using Silk.NET.Input.SDL3; + +namespace Silk.NET.Input; + +/// +/// Contains information pertaining to the movement of a thumbstick. +/// +/// The gamepad on which the thumbstick resides. +/// +/// The timestamp (as retrieved from ) at which the event occurred. +/// +/// +/// The new position of the thumbstick, where each axis is between -1.0 and 1.0. +/// +/// The change in as a result of this event. +/// +/// Todo: this should probably include a thumbstick/axis identifier, right? At least left/right? +/// see , which has an Axis field +/// +public readonly record struct GamepadThumbstickMoveEvent(IGamepad Gamepad, long Timestamp, Vector2 Value, Vector2 Delta) : ITimestampedEvent; diff --git a/sources/Input/Input/GamepadTriggerMoveEvent.cs b/sources/Input/Input/GamepadTriggerMoveEvent.cs new file mode 100644 index 0000000000..1711de71aa --- /dev/null +++ b/sources/Input/Input/GamepadTriggerMoveEvent.cs @@ -0,0 +1,18 @@ +using System.Diagnostics; +using Silk.NET.Input.SDL3; + +namespace Silk.NET.Input; + +/// +/// Contains information pertaining to the movement of a trigger. +/// +/// The gamepad on which the trigger resides. +/// +/// The timestamp (as retrieved from ) at which the event occurred. +/// +/// The index of the trigger that has moved. +/// +/// The new value of the trigger, between 0.0 (fully depressed) and 1.0 (fully pressed). +/// +/// The change in as a result of this event. +public readonly record struct GamepadTriggerMoveEvent(IGamepad Gamepad, long Timestamp, int Axis, float Value, float Delta) : ITimestampedEvent; diff --git a/sources/Input/Input/Handlers/Gamepads.cs b/sources/Input/Input/Handlers/Gamepads.cs new file mode 100644 index 0000000000..74501a9aad --- /dev/null +++ b/sources/Input/Input/Handlers/Gamepads.cs @@ -0,0 +1,45 @@ +namespace Silk.NET.Input; + +/// +/// Represents a collection of s from which input events can be received. +/// +public sealed class Gamepads : InputContextDeviceList, IGamepadInputHandler +{ + internal Gamepads(InputContext ctx) + : base(ctx) + { + } + + /// + /// Raised when state pertaining to a pushable button on the gamepad changes (e.g. button up, button down). + /// + public event Action>? ButtonChanged; + + /// + /// Raised when a thumbstick on the gamepad moves. + /// + public event Action? ThumbstickMove; + + /// + /// Raised when a trigger on the gamepad moves. + /// + public event Action? TriggerMove; + + internal void HandleButtonChanged(ButtonChangedEvent @event) => + ButtonChanged?.Invoke(@event); + + void IButtonInputHandler.HandleButtonChanged( + ButtonChangedEvent @event + ) => HandleButtonChanged(@event); + + internal void HandleThumbstickMove(GamepadThumbstickMoveEvent @event) => + ThumbstickMove?.Invoke(@event); + + void IGamepadInputHandler.HandleThumbstickMove(GamepadThumbstickMoveEvent @event) => + HandleThumbstickMove(@event); + + internal void HandleTriggerMove(GamepadTriggerMoveEvent @event) => TriggerMove?.Invoke(@event); + + void IGamepadInputHandler.HandleTriggerMove(GamepadTriggerMoveEvent @event) => + HandleTriggerMove(@event); +} diff --git a/sources/Input/Input/Handlers/InputContext.cs b/sources/Input/Input/Handlers/InputContext.cs new file mode 100644 index 0000000000..b32bd34d72 --- /dev/null +++ b/sources/Input/Input/Handlers/InputContext.cs @@ -0,0 +1,288 @@ +using System.Collections; +using System.Diagnostics; + +namespace Silk.NET.Input; + +/// +/// Represents an "input context" containing multiple s from which +/// s, their state, and their events are aggregated and laid-out in a user-friendly fashion. +/// +/// +/// The onus is on the user to coordinate using this type across threads, as the input backend is not thread safe +/// In addition, certain backends may have (unavoidable) restrictions on what thread can be called +/// on - the user is responsible for respecting these threading rules as well. +/// +public class InputContext + : IJoystickInputHandler, + IGamepadInputHandler, + IMouseInputHandler, + IPointerInputHandler, + IKeyboardInputHandler, + IList, + IReadOnlyList +{ + // These are lazy-initialized as they contain their own device lists in addition to the device list stored here and + // the device lists stored in each of the backends. You could argue having this many duplicated lists is inefficient + // and you'd be absolutely right, but realistically: how many devices will the average user have connected to their + // PC? If you're worried about your game's memory consumption, you're probably not looking at the small lists that + // input allocates... This way we can also provide sane/consistent indices. + private Pointers? _pointers; + private Keyboards? _keyboards; + private Gamepads? _gamepads; + private Joysticks? _joysticks; + private readonly List _backends = []; + private List? _devices; + + /// + /// Gets the s enumerated by the s attached to this context. + /// + public Pointers Pointers => _pointers ??= new Pointers(this); + + /// + /// Gets the s enumerated by the s attached to this context. + /// + public Keyboards Keyboards => _keyboards ??= new Keyboards(this); + + /// + /// Gets the s enumerated by the s attached to this context. + /// + public Gamepads Gamepads => _gamepads ??= new Gamepads(this); + + /// + /// Gets the s enumerated by the s attached to this context. + /// + public Joysticks Joysticks => _joysticks ??= new Joysticks(this); + + /// + /// Gets the s enumerated by the s attached to this context. + /// + public IReadOnlyList Devices + { + get + { + if (_devices is not null) + { + return _devices; + } + + if (Backends.Count == 0) + { + return _devices = []; + } + + var deviceCount = 0; + + foreach(var backend in Backends) + { + deviceCount += backend.Devices.Count; + } + + _devices = new List(deviceCount); + + foreach (var backend in Backends) + { + _devices ??= new List(backend.Devices.Count); + _devices.AddRange(backend.Devices); + } + + return _devices ??= []; + } + } + + /// + /// Gets a list denoting the attached to this context. + /// + public IList Backends => this; + + /// + /// Raised when a device is added or removed from the list of connected . + /// + public event Action? ConnectionChanged; + + /// + /// Polls and updates the state of the objects connected to each + /// attached to this context, raising appropriate events for each state change. + /// + /// + /// This calls for each attached to this context. + /// + public void Update() + { + foreach (var backend in Backends) + { + backend.Update(this); + } + + _pointers?.ProcessClicks(); + } + + private void HandleBackendRemoval(IInputBackend backend) + { + var timestamp = Stopwatch.GetTimestamp(); + foreach (var device in backend.Devices) + { + HandleDeviceConnectionChanged(new ConnectionEvent(device, timestamp, false)); + } + } + + private void HandleBackendAddition(IInputBackend backend) + { + var timestamp = Stopwatch.GetTimestamp(); + foreach (var device in backend.Devices) + { + HandleDeviceConnectionChanged(new ConnectionEvent(device, timestamp, true)); + } + } + + private void HandleDeviceConnectionChanged(ConnectionEvent e) + { + _pointers?.HandleDeviceConnectionChanged(e); + _joysticks?.HandleDeviceConnectionChanged(e); + _gamepads?.HandleDeviceConnectionChanged(e); + _keyboards?.HandleDeviceConnectionChanged(e); + + if (_devices is null) + { + return; + } + + if (e.IsConnected) + { + _devices.Add(e.Device); + } + else + { + _devices.Remove(e.Device); + } + } + + void IInputHandler.Handle(PointerTargetChangedEvent @event) => + _pointers?.HandleTargetChanged(@event); + + void IInputHandler.Handle(PointChangedEvent @event) => + _pointers?.HandlePointChanged(@event); + + void IInputHandler.Handle(PointerGripChangedEvent @event) => + _pointers?.HandleGripChanged(@event); + + void IButtonInputHandler.HandleButtonChanged(ButtonChangedEvent @event) => + _joysticks?.HandleButtonChanged(@event); + + void IJoystickInputHandler.HandleAxisMove(JoystickAxisMoveEvent @event) => + _joysticks?.HandleAxisMove(@event); + + void IJoystickInputHandler.HandleHatMove(JoystickHatMoveEvent @event) => + _joysticks?.HandleHatMove(@event); + + void IGamepadInputHandler.HandleThumbstickMove(GamepadThumbstickMoveEvent @event) => + _gamepads?.HandleThumbstickMove(@event); + + void IGamepadInputHandler.HandleTriggerMove(GamepadTriggerMoveEvent @event) => + _gamepads?.HandleTriggerMove(@event); + + void IButtonInputHandler.HandleButtonChanged(ButtonChangedEvent @event) => + _pointers?.HandleButtonChanged(@event); + + void IMouseInputHandler.HandleScroll(MouseScrollEvent @event) => + _pointers?.HandleScroll(@event); + + void IPointerInputHandler.HandleTargetChanged(PointerTargetChangedEvent @event) => + _pointers?.HandleTargetChanged(@event); + + void IPointerInputHandler.HandlePointChanged(PointChangedEvent @event) => + _pointers?.HandlePointChanged(@event); + + void IPointerInputHandler.HandleGripChanged(PointerGripChangedEvent @event) => + _pointers?.HandleGripChanged(@event); + + void IButtonInputHandler.HandleButtonChanged(ButtonChangedEvent @event) => + _keyboards?.HandleButtonChanged(@event); + + void IKeyboardInputHandler.HandleKeyChanged(KeyChangedEvent @event) => + _keyboards?.HandleKeyChanged(@event); + + void IKeyboardInputHandler.HandleKeyChar(KeyCharEvent @event) => + _keyboards?.HandleKeyChar(@event); + + void IInputHandler.HandleDeviceConnectionChanged(ConnectionEvent @event) + { + HandleDeviceConnectionChanged(@event); + ConnectionChanged?.Invoke(@event); + } + + IEnumerator IEnumerable.GetEnumerator() => + _backends.GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() => _backends.GetEnumerator(); + + void ICollection.Add(IInputBackend item) + { + HandleBackendAddition(item); + _backends.Add(item); + } + + void ICollection.Clear() + { + foreach (var backend in Backends) + { + HandleBackendRemoval(backend); + } + } + + bool ICollection.Contains(IInputBackend item) => _backends.Contains(item); + + void ICollection.CopyTo(IInputBackend[] array, int arrayIndex) => + _backends.CopyTo(array, arrayIndex); + + bool ICollection.Remove(IInputBackend item) + { + HandleBackendRemoval(item); + return _backends.Remove(item); + } + + int ICollection.Count => _backends.Count; + + bool ICollection.IsReadOnly => false; + + int IList.IndexOf(IInputBackend item) => _backends.IndexOf(item); + + void IList.Insert(int index, IInputBackend item) + { + HandleBackendAddition(item); + _backends.Insert(index, item); + } + + void IList.RemoveAt(int index) + { + var backend = _backends[index]; + HandleBackendRemoval(backend); + _backends.RemoveAt(index); + } + + IInputBackend IList.this[int index] + { + get => _backends[index]; + set + { + ArgumentNullException.ThrowIfNull(value); + + var existing = _backends[index]; + if(existing == value) + { + return; + } + + HandleBackendRemoval(existing); + HandleBackendAddition(value); + _backends[index] = value; + } + } + + int IReadOnlyCollection.Count => _backends.Count; + + /// + /// Returns the at the specified index. + /// + /// + public IInputBackend this[int index] => _backends[index]; +} diff --git a/sources/Input/Input/Handlers/Joysticks.cs b/sources/Input/Input/Handlers/Joysticks.cs new file mode 100644 index 0000000000..f576e6f85f --- /dev/null +++ b/sources/Input/Input/Handlers/Joysticks.cs @@ -0,0 +1,41 @@ +namespace Silk.NET.Input; + +/// +/// Represents a collection of s from which input events can be received. +/// +public sealed class Joysticks : InputContextDeviceList, IJoystickInputHandler +{ + internal Joysticks(InputContext ctx) + : base(ctx) { } + + /// + /// Raised when state pertaining to a pushable button on the joystick changes (e.g. button up, button down). + /// + public event Action>? ButtonChanged; + + /// + /// Raised when a movable axis on the joystick changes position. + /// + public event Action? AxisMove; + + /// + /// Raised when a joystick hat moves. + /// + public event Action? HatMove; + + internal void HandleButtonChanged(ButtonChangedEvent @event) => + ButtonChanged?.Invoke(@event); + + void IButtonInputHandler.HandleButtonChanged( + ButtonChangedEvent @event + ) => HandleButtonChanged(@event); + + internal void HandleAxisMove(JoystickAxisMoveEvent @event) => AxisMove?.Invoke(@event); + + void IJoystickInputHandler.HandleAxisMove(JoystickAxisMoveEvent @event) => + HandleAxisMove(@event); + + internal void HandleHatMove(JoystickHatMoveEvent @event) => HatMove?.Invoke(@event); + + void IJoystickInputHandler.HandleHatMove(JoystickHatMoveEvent @event) => HandleHatMove(@event); +} diff --git a/sources/Input/Input/Handlers/Keyboards.cs b/sources/Input/Input/Handlers/Keyboards.cs new file mode 100644 index 0000000000..4d1597867c --- /dev/null +++ b/sources/Input/Input/Handlers/Keyboards.cs @@ -0,0 +1,35 @@ +namespace Silk.NET.Input; + +/// +/// Represents a collection of s from which input events can be received. +/// +public sealed class Keyboards : InputContextDeviceList, IKeyboardInputHandler +{ + internal Keyboards(InputContext ctx) + : base(ctx) + { + } + + /// + /// Raised when state pertaining to a pushable key on the keyboard changes (e.g. key up, key down, key repeat). + /// + public event Action? KeyChanged; + + /// + /// Raised when the user types a character using the keyboard. + /// + public event Action? KeyChar; + + internal void HandleButtonChanged(ButtonChangedEvent @event) { } + + void IButtonInputHandler.HandleButtonChanged(ButtonChangedEvent @event) => + HandleButtonChanged(@event); + + internal void HandleKeyChanged(KeyChangedEvent @event) => KeyChanged?.Invoke(@event); + + void IKeyboardInputHandler.HandleKeyChanged(KeyChangedEvent @event) => HandleKeyChanged(@event); + + internal void HandleKeyChar(KeyCharEvent @event) => KeyChar?.Invoke(@event); + + void IKeyboardInputHandler.HandleKeyChar(KeyCharEvent @event) => HandleKeyChar(@event); +} diff --git a/sources/Input/Input/Handlers/Pointers.cs b/sources/Input/Input/Handlers/Pointers.cs new file mode 100644 index 0000000000..c0b6cc9beb --- /dev/null +++ b/sources/Input/Input/Handlers/Pointers.cs @@ -0,0 +1,397 @@ +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Numerics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using Silk.NET.Input.SDL3; + +namespace Silk.NET.Input; + +/// +/// Represents a collection of s from which input events can be received. +/// +public sealed class Pointers + : InputContextDeviceList, + IMouseInputHandler, + IPointerInputHandler +{ + private long _doubleClickTime; + private float _doubleClickRange; + private List? _clicks; + + internal Pointers(InputContext ctx) + : base(ctx) => ClickConfiguration = PointerClickConfiguration.Default; + + /// + /// Gets or sets the configuration that denotes the behaviour of /. + /// + public PointerClickConfiguration ClickConfiguration + { + get => new((int)((double)_doubleClickTime / Stopwatch.Frequency * 1000), _doubleClickRange); + set => + (_doubleClickTime, _doubleClickRange) = ( + (long)((double)value.DoubleClickTime / 1000 * Stopwatch.Frequency), + value.DoubleClickRange + ); + } + + /// + /// Raised when state pertaining to a pushable button on the pointer device changes (e.g. button up, button down). + /// + public event Action>? ButtonChanged; + + /// + /// Raised when one or more events indicate a single click as defined by the + /// . + /// + public event Action? Click; + + /// + /// Raised when one or more events indicate a double click as defined by the + /// . + /// + public event Action? DoubleClick; + + /// + /// Raised when a 's state changes (e.g. mouse move). + /// + public event Action? PointChanged; + + /// + /// Raised when a user scrolls using a pointer device's mouse wheel. + /// + public event Action? MouseScroll; + + /// + /// Raised when a "target" at which the user can point using a pointer device changes. + /// + public event Action? TargetChanged; + + /// + /// Raised when the user adjusts their grip on the pointer device. + /// + public event Action? GripChanged; + + void IButtonInputHandler.HandleButtonChanged( + ButtonChangedEvent @event + ) => HandleButtonChanged(@event); + + internal void HandleButtonChanged(ButtonChangedEvent @event) + { + if (@event.Device is not IPointerDevice device) + { + return; + } + + ButtonChanged?.Invoke(@event); + if (@event.Previous.IsDown || !@event.Button.IsDown) + { + return; + } + + foreach (var target in device.Targets) + { + var pointCnt = target.GetPointCount(device); + for (var i = 0; i < pointCnt; i++) + { + HandlePointerDown( + device, + target.GetPoint(device, i), + @event.Button.Name, + @event.Timestamp + ); + } + } + } + + void IMouseInputHandler.HandleScroll(MouseScrollEvent @event) => HandleScroll(@event); + + internal void HandleScroll(MouseScrollEvent @event) => MouseScroll?.Invoke(@event); + + void IPointerInputHandler.HandleTargetChanged(PointerTargetChangedEvent @event) => + HandleTargetChanged(@event); + + internal void HandleTargetChanged(PointerTargetChangedEvent @event) + { + TargetChanged?.Invoke(@event); + if (_clicks is null || @event.IsAdded is not false) + { + return; + } + + var clicks = CollectionsMarshal.AsSpan(_clicks); + for (var i = 0; i < clicks.Length; i++) + { + ref var click = ref clicks[i]; + if (click.FirstClickPosition.Target != @event.Target) + { + continue; + } + + // Raise a click event for posterity. + HandleDoubleClickExceedsParameters(ref click); + _clicks.RemoveAt(i--); + + // SAFETY: We have to replace the span now as the RemoveAt could've in theory reallocated. + clicks = CollectionsMarshal.AsSpan(_clicks); + } + } + + void IPointerInputHandler.HandlePointChanged(PointChangedEvent @event) => + HandlePointChanged(@event); + + internal void HandlePointChanged(PointChangedEvent @event) + { + try + { + PointChanged?.Invoke(@event); + } + catch (Exception e) + { + InputLog.Error($"Exception while handling point changed event: {e.Message}\n{e.StackTrace}"); + } + + if (_clicks is null || @event is not { OldPoint: not null, NewPoint: { } @new }) + { + return; + } + + var span = CollectionsMarshal.AsSpan(_clicks); + for (var i = 0; i < _clicks.Count; i++) + { + ref var click = ref span[i]; + if (!click.IsMatch(@event.Pointer, in @new)) + { + continue; + } + + if (!click.HasMovedTooFar(_doubleClickRange, @new.Position)) + { + return; + } + + HandleDoubleClickExceedsParameters(ref click); + _clicks.RemoveAt(i); + return; + } + } + + void IPointerInputHandler.HandleGripChanged(PointerGripChangedEvent @event) => + HandleGripChanged(@event); + + internal void HandleGripChanged(PointerGripChangedEvent @event) => GripChanged?.Invoke(@event); + + private record struct ClickData( + IPointerDevice Device, + PointerButton? FirstClickButton, + TargetPoint FirstClickPosition, + long? FirstClickTime, + bool IsFirstClick + ) + { + public bool IsMatch(IPointerDevice device, ref readonly TargetPoint point) => + point.Id == FirstClickPosition.Id + && Device == device + && point.Target == FirstClickPosition.Target; + + public bool HasMovedTooFar(float range, Vector3 position) + { + var fcp = FirstClickPosition.Position; + return MathF.Abs(position.X - fcp.X) >= range + && MathF.Abs(position.Y - fcp.Y) >= range + && MathF.Abs(position.Z - fcp.Z) >= range; + } + } + + [MemberNotNull(nameof(_clicks))] + private ref ClickData GetClickData( + IPointerDevice device, + ref readonly TargetPoint point, + out int idx + ) + { + idx = 0; + foreach (ref var ret in CollectionsMarshal.AsSpan(_clicks ??= [])) + { + if (ret.IsMatch(device, in point)) + { + return ref ret; + } + + idx++; + } + + _clicks.Add( + new ClickData( + device, + null, + default(TargetPoint) with + { + Target = point.Target, + Id = point.Id, + }, + null, + true + ) + ); + return ref CollectionsMarshal.AsSpan(_clicks)[idx]; + } + + private void HandlePointerDown( + IPointerDevice device, + TargetPoint point, + PointerButton button, + long timestamp + ) + { + if ((_clicks is null && DoubleClick is null && Click is null) || point.Target is null) + { + return; + } + + ref var click = ref GetClickData(device, in point, out var idx); + if (click.IsFirstClick || (click.FirstClickButton is { } firstBtn && firstBtn != button)) + { + // This is the first click with the given mouse button. + var time = click.FirstClickTime; + click.FirstClickTime = null; + + if ( + click is { IsFirstClick: false, FirstClickButton: { } prevBtn } + && time is { } clickTime + ) + { + // Only the mouse buttons differ so treat last click as a single click. + InvokeClick(new PointerClickEvent(device, clickTime, click.FirstClickPosition, prevBtn)); + } + } + else + { + // This is the second click with the same mouse button. + if (click.FirstClickTime is { } fct && timestamp - fct <= _doubleClickTime) + { + // Within the maximum double click time. + click.FirstClickTime = null; + if (!click.HasMovedTooFar(_doubleClickRange, point.Position)) + { + // Second click was in time and in range -> double click. + DoubleClick?.Invoke(new PointerClickEvent(device, timestamp, point, button)); + + // SAFETY: Must not use the click ref from now on! Returning instantly. + _clicks.RemoveAt(idx); + return; + } + + // Second click was in time but outside range -> single click. + // The second click is another "first click". + InvokeClick(new PointerClickEvent(device, timestamp, point, button)); + } + else + { + // The double click time elapsed. + + // If Update() would have detected the time elapse before, + // it would have set _firstClick back to true and we won't be here. + // Therefore Update() has not detected time elapse here and we have + // to handle it. + HandleDoubleClickExceedsParameters(ref click); + } + } + + // Process the first click. We process the second click as another "first click" if: + // - the double click time elapsed + // - the pointer moved too much before doing the second click + ProcessFirstClick(ref click, button, point, timestamp); + } + + private static void ProcessFirstClick( + ref ClickData click, + PointerButton button, + TargetPoint point, + long timestamp + ) + { + click.IsFirstClick = false; // for next time... + click.FirstClickButton = button; + click.FirstClickPosition = point; + click.FirstClickTime = timestamp; + } + + private void HandleDoubleClickExceedsParameters(ref ClickData click) + { + if (click is { FirstClickButton: { } fcb, FirstClickTime: { } fct }) + { + InvokeClick(new PointerClickEvent(click.Device, fct, click.FirstClickPosition, fcb)); + } + + click.FirstClickTime = null; + click.IsFirstClick = true; + } + + internal void ProcessClicks() + { + if (_clicks is null) + { + return; + } + + var updateTime = Stopwatch.GetTimestamp(); + var clicks = CollectionsMarshal.AsSpan(_clicks); + for (var i = 0; i < clicks.Length; i++) + { + ref var click = ref clicks[i]; + if (click.FirstClickTime is not { } firstTime || updateTime - firstTime <= _doubleClickTime) + { + continue; + } + + // No second click in maximum double click time. + HandleDoubleClickExceedsParameters(ref click); + _clicks.RemoveAt(i--); + + // SAFETY: We have to replace the span now as the RemoveAt could've in theory reallocated. + clicks = CollectionsMarshal.AsSpan(_clicks); + } + } + + private void InvokeClick(PointerClickEvent evt) + { + try + { + Click?.Invoke(evt); + } + catch (Exception e) + { + InputLog.Error($"Exception during click event: {e.Message}\n{e.StackTrace}"); + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + void IInputHandler.Handle(PointerTargetChangedEvent @event) => HandleTargetChanged(@event); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + void IInputHandler.Handle(PointChangedEvent @event) => HandlePointChanged(@event); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + void IInputHandler.Handle(PointerGripChangedEvent @event) => HandleGripChanged(@event); + + /// + protected internal override void HandleDeviceConnectionChanged(ConnectionEvent @event) + { + base.HandleDeviceConnectionChanged(@event); + if (_clicks is null || @event.IsConnected || @event.Device is not IPointerDevice) + { + return; + } + + for (var i = 0; i < _clicks.Count; i++) + { + if (_clicks[i].Device != @event.Device) + { + continue; + } + + _clicks.RemoveAt(i--); + } + } +} diff --git a/sources/Input/Input/IButtonDevice.cs b/sources/Input/Input/IButtonDevice.cs new file mode 100644 index 0000000000..70b88af9d3 --- /dev/null +++ b/sources/Input/Input/IButtonDevice.cs @@ -0,0 +1,17 @@ +namespace Silk.NET.Input; + +/// +/// Represents an input device that has buttons. +/// +/// The type of buttons the input device has. +public interface IButtonDevice : IInputDevice + where T : unmanaged, Enum +{ + /// + /// Gets the current button state for this device. + /// + /// + /// Only updated when is called. + /// + ButtonReadOnlyList State { get; } +} diff --git a/sources/Input/Input/IButtonInputHandler.cs b/sources/Input/Input/IButtonInputHandler.cs new file mode 100644 index 0000000000..a657ad9435 --- /dev/null +++ b/sources/Input/Input/IButtonInputHandler.cs @@ -0,0 +1,22 @@ +namespace Silk.NET.Input; + +/// +/// An that also receives events. +/// +/// The device's button type. +public interface IButtonInputHandler : IInputHandler> + where T : unmanaged, Enum +{ + /// + /// Called when a button's state changes (e.g. button down, button up). + /// + /// The event details. + void HandleButtonChanged(ButtonChangedEvent @event); + + void IInputHandler>.Handle(ButtonChangedEvent @event) => HandleButtonChanged(@event); +} + +public interface IInputHandler : IInputHandler where T : struct +{ + void Handle(T @event); +} diff --git a/sources/Input/Input/ICursorConfiguration.cs b/sources/Input/Input/ICursorConfiguration.cs new file mode 100644 index 0000000000..0d0209d4e5 --- /dev/null +++ b/sources/Input/Input/ICursorConfiguration.cs @@ -0,0 +1,45 @@ +namespace Silk.NET.Input; + +/// +/// Configuration for the behaviour of a mouse cursor. +/// +public interface ICursorConfiguration +{ + /// + /// Gets a bitmask denoting the supported values for . + /// + CursorModes SupportedModes { get; } + + /// + /// Gets or sets the current cursor mode. Only one bit shall be set at a time. + /// + /// + /// Note that this property affects the in use, see the + /// documentation for more info. + /// + CursorModes Mode { get; set; } + + /// + /// Gets a bitmask denoting the supported values for . + /// + CursorStyles SupportedStyles { get; } + + /// + /// Gets or sets the current cursor style. Only one bit shall be set at a time. + /// shall use the provided. + /// + /// + /// When is used, the cursor ceases to exist anyway. As such, while the + /// property may not reflect this (as it is retained across changes to + /// and just ignored when is used), + /// can be implied as being when + /// is used. + /// + CursorStyles Style { get; set; } + + /// + /// Gets or sets the current custom cursor image. This has no effect if is not + /// used, but the value is stored nonetheless for use when that is the case. + /// + CustomCursor Image { get; set; } +} \ No newline at end of file diff --git a/sources/Input/Input/IGamepad.cs b/sources/Input/Input/IGamepad.cs new file mode 100644 index 0000000000..1dc37823b6 --- /dev/null +++ b/sources/Input/Input/IGamepad.cs @@ -0,0 +1,20 @@ +namespace Silk.NET.Input; + +/// +/// Represents a gamepad that follows a typical layout. +/// +public interface IGamepad : IButtonDevice +{ + /// + /// Gets the device state. + /// + /// + /// Only updated when is called. + /// + new GamepadState State { get; } + ButtonReadOnlyList IButtonDevice.State => State.Buttons; + /// + /// Gets a collection enumerating the vibration motors available to the application to enable haptics. + /// + IReadOnlyList VibrationMotors { get; } +} \ No newline at end of file diff --git a/sources/Input/Input/IGamepadInputHandler.cs b/sources/Input/Input/IGamepadInputHandler.cs new file mode 100644 index 0000000000..123be89c8e --- /dev/null +++ b/sources/Input/Input/IGamepadInputHandler.cs @@ -0,0 +1,22 @@ +namespace Silk.NET.Input; + +/// +/// An that also receives input. +/// +public interface IGamepadInputHandler : IButtonInputHandler, IInputHandler, IInputHandler +{ + /// + /// Called when one of the twin sticks moves. + /// + /// The event details. + void HandleThumbstickMove(GamepadThumbstickMoveEvent @event); + + /// + /// Called when one of the two triggers moves. + /// + /// The event details. + void HandleTriggerMove(GamepadTriggerMoveEvent @event); + + void IInputHandler.Handle(GamepadThumbstickMoveEvent @event) => HandleThumbstickMove(@event); + void IInputHandler.Handle(GamepadTriggerMoveEvent @event) => HandleTriggerMove(@event); +} diff --git a/sources/Input/Input/IInputBackend.cs b/sources/Input/Input/IInputBackend.cs new file mode 100644 index 0000000000..e67ce94d0f --- /dev/null +++ b/sources/Input/Input/IInputBackend.cs @@ -0,0 +1,49 @@ +namespace Silk.NET.Input; + +/// +/// Represents an input backend capable of receiving human input from Human Input Devices (HIDs). +/// +/// +/// The onus is on the user to coordinate using this type across threads, as the input backend is not thread safe +/// In addition, certain backends may have (unavoidable) restrictions on what thread can be called +/// on - the user is responsible for respecting these threading rules as well. +/// +public interface IInputBackend : IDisposable +{ + /// + /// Gets a rough human-readable description of the input backend. Its value is not intrinsically meaningful. + /// + string Name { get; } + + /// + /// Gets a globally-unique integral identifier for this device. + /// + nint Id { get; } + + /// + /// Get a list containing all the connected devices available from this input backend. + /// + /// + /// When a device is disconnected, its shall no longer function and will not be + /// enumerated by this list. When a device is connected, an with that physical device ID + /// shall be added to this list. In addition, upon connection any past objects previously + /// enumerated by this list on this instance shall also regain function if the device + /// being added to this list shares the same physical device ID as those previous instances. All such previous + /// instances shall be equatable to one another and to the instance added to this list. + /// An implementation is welcome to reuse old objects, but this is strictly implementation-defined. A device not + /// being present in the (checked using s + /// implementation) list is sufficient evidence that a device has been + /// disconnected. + /// + IReadOnlyList Devices { get; } + + /// + /// Polls and updates the state of the objects connected using this backend, sending + /// input events to the given to reflect the human input received. + /// + /// + /// The value of the State properties on each device must not change until this method is called. + /// + /// The input handler. + void Update(IInputHandler? handler = null); +} diff --git a/sources/Input/Input/IInputDevice.cs b/sources/Input/Input/IInputDevice.cs new file mode 100644 index 0000000000..a53a47d750 --- /dev/null +++ b/sources/Input/Input/IInputDevice.cs @@ -0,0 +1,36 @@ +namespace Silk.NET.Input; + +/// +/// Represents a connected Human Input Device (HID). +/// +/// +/// All devices originate from a backend.
+///
+/// An object shall be equatable to any such object retrieved from the same backend where +/// is equal.
+///
+/// objects must not store any managed state, and if there is a requirement for this in a +/// future extension of this API then this must be defined in such a way that the state storage and lifetime is +/// user-controlled. While objects are equatable based on s, if a physical +/// device disconnects and reconnects the does not provide a guarantee that the same object +/// will be returned (primarily because doing so would require the to keep track of every +/// object it's ever created), rather a "compatible" one that acts identically to the original object. This is +/// completely benign if the object is nothing but a wrapper to the backend anyway. If there is unmanaged state (e.g. a +/// handle to a device that must be explicitly closed upon disconnection), then it is expected that even in the event of +/// reconnection, old objects (e.g. created with a now-disposed handle) shall still work for the newly-reconnected +/// device. A common way this could be implemented is storing the handles in the +/// implementation instead in the form of a mapping of physical device IDs () to those handles. This +/// solves the object lifetime problem while also not adding undue complications to user code. +/// +public interface IInputDevice : IEquatable +{ + /// + /// Gets a globally-unique integral identifier for this device. + /// + nint Id { get; } + + /// + /// Gets a rough human-readable description of the input device. Its value is not intrinsically meaningful. + /// + string Name { get; } +} \ No newline at end of file diff --git a/sources/Input/Input/IInputHandler.cs b/sources/Input/Input/IInputHandler.cs new file mode 100644 index 0000000000..3a7c7bbccc --- /dev/null +++ b/sources/Input/Input/IInputHandler.cs @@ -0,0 +1,15 @@ +namespace Silk.NET.Input; + +/// +/// Represents a handler of human input. Implementations of this type will receive a method call for each distinctive +/// HID event received in the order they were received, to the best of the backend's ability. All visible changes to +/// device state correspond to a method call using this interface. +/// +public interface IInputHandler +{ + /// + /// Called when an disconnects from the application. + /// + /// The event details. + void HandleDeviceConnectionChanged(ConnectionEvent @event); +} \ No newline at end of file diff --git a/sources/Input/Input/IJoystick.cs b/sources/Input/Input/IJoystick.cs new file mode 100644 index 0000000000..df5bb9b3b3 --- /dev/null +++ b/sources/Input/Input/IJoystick.cs @@ -0,0 +1,16 @@ +namespace Silk.NET.Input; + +/// +/// Represents a joystick with axes, buttons, and hats. +/// +public interface IJoystick : IButtonDevice +{ + /// + /// Gets the device state. + /// + /// + /// Only updated when is called. + /// + new JoystickState State { get; } + ButtonReadOnlyList IButtonDevice.State => State.Buttons; +} \ No newline at end of file diff --git a/sources/Input/Input/IJoystickInputHandler.cs b/sources/Input/Input/IJoystickInputHandler.cs new file mode 100644 index 0000000000..2fc3de848a --- /dev/null +++ b/sources/Input/Input/IJoystickInputHandler.cs @@ -0,0 +1,22 @@ +namespace Silk.NET.Input; + +/// +/// An that also receives input. +/// +public interface IJoystickInputHandler : IButtonInputHandler, IInputHandler, IInputHandler +{ + /// + /// Called when an axis on the joystick moves. + /// + /// The event details. + void HandleAxisMove(JoystickAxisMoveEvent @event); + + /// + /// Called when a hat on the joystick moves. + /// + /// The event details. + void HandleHatMove(JoystickHatMoveEvent @event); + + void IInputHandler.Handle(JoystickAxisMoveEvent @event) => HandleAxisMove(@event); + void IInputHandler.Handle(JoystickHatMoveEvent @event) => HandleHatMove(@event); +} diff --git a/sources/Input/Input/IKeyboard.cs b/sources/Input/Input/IKeyboard.cs new file mode 100644 index 0000000000..5dcbf4896c --- /dev/null +++ b/sources/Input/Input/IKeyboard.cs @@ -0,0 +1,51 @@ +using System.Diagnostics.CodeAnalysis; + +namespace Silk.NET.Input; + +/// +/// Represents a keyboard device. +/// +public interface IKeyboard : IButtonDevice +{ + /// + /// Gets the device state. + /// + /// + /// Only updated when is called. + /// + new KeyboardState State { get; } + + ButtonReadOnlyList IButtonDevice.State => State.Keys; + + /// + /// Gets or sets the current text on the clipboard. + /// + string? ClipboardText { get; set; } + + /// + /// Attempts to get a user-displayable string in the user's locale for the key at the physical position represented + /// by in the user's current keyboard layout. + /// + /// The physical key name. Consult documentation for more info. + /// The user-displayable name of the key. + /// Whether the name was successfully retrieved. + bool TryGetKeyName(KeyName key, [NotNullWhen(true)] out string? name); + + /// + /// Begins recording keyboard input. Without /, there is no + /// guarantee that will be raised as this might require displaying + /// a concept/touchscreen keyboard on certain platforms (e.g. phones). It is recommended that you call + /// when you'd like to capture text input (e.g. in a text box), followed by + /// when you have completed collecting such input. + /// + void BeginInput(); + + /// + /// Concludes recording keyboard input. Without /, there is no + /// guarantee that will be raised as this might require displaying + /// a concept/touchscreen keyboard on certain platforms (e.g. phones). It is recommended that you call + /// when you'd like to capture text input (e.g. in a text box), followed by + /// when you have completed collecting such input. + /// + string? EndInput(); +} diff --git a/sources/Input/Input/IKeyboardInputHandler.cs b/sources/Input/Input/IKeyboardInputHandler.cs new file mode 100644 index 0000000000..5e89264b89 --- /dev/null +++ b/sources/Input/Input/IKeyboardInputHandler.cs @@ -0,0 +1,25 @@ +namespace Silk.NET.Input; + +/// +/// An that also receives events. +/// +public interface IKeyboardInputHandler : IButtonInputHandler, IInputHandler +{ + /// + /// Called when a key is pressed or depressed. + /// + /// The event details. + void HandleKeyChanged(KeyChangedEvent @event); + + /// + /// Called when a character is typed. + /// + /// + /// Ensure you have called to start receiving text, after which events will be + /// sent for each character until is called. + /// + /// The event details. + void HandleKeyChar(KeyCharEvent @event); + + void IInputHandler.Handle(KeyChangedEvent @event) => HandleKeyChanged(@event); +} diff --git a/sources/Input/Input/IMotor.cs b/sources/Input/Input/IMotor.cs new file mode 100644 index 0000000000..f8875e7149 --- /dev/null +++ b/sources/Input/Input/IMotor.cs @@ -0,0 +1,13 @@ +namespace Silk.NET.Input; + +/// +/// Represents a vibration motor. +/// +public interface IMotor +{ + /// + /// Gets or sets the speed at which the motor is operating, where 0.0 represents no vibration and 1.0 + /// represents the maximum amount of vibration. + /// + float Speed { get; set; } +} \ No newline at end of file diff --git a/sources/Input/Input/IMouse.cs b/sources/Input/Input/IMouse.cs new file mode 100644 index 0000000000..e71c8d7162 --- /dev/null +++ b/sources/Input/Input/IMouse.cs @@ -0,0 +1,34 @@ +using System.Numerics; + +namespace Silk.NET.Input; + +/// +/// Represents a mouse - a type of pointer device. +/// +public interface IMouse : IPointerDevice +{ + /// + /// Gets the device state. + /// + /// + /// Only updated when is called. + /// + new MouseState State { get; } + + PointerState IPointerDevice.State => State; + + /// + /// Gets the cursor configuration of the mouse. + /// + /// + /// This will determine which points shall lie on. + /// + ICursorConfiguration Cursor { get; } + + /// + /// Attempts to set the position of the mouse. + /// + /// The position of the mouse in window coordinates. + /// Whether the requested position has been applied. + bool TrySetPosition(Vector2 position); +} \ No newline at end of file diff --git a/sources/Input/Input/IMouseInputHandler.cs b/sources/Input/Input/IMouseInputHandler.cs new file mode 100644 index 0000000000..5e51c613c6 --- /dev/null +++ b/sources/Input/Input/IMouseInputHandler.cs @@ -0,0 +1,15 @@ +namespace Silk.NET.Input; + +/// +/// An that receives input from an . +/// +public interface IMouseInputHandler : IButtonInputHandler, IInputHandler +{ + /// + /// Called when the user scrolls using the scroll wheel. + /// + /// The event details. + void HandleScroll(MouseScrollEvent @event); + + void IInputHandler.Handle(MouseScrollEvent @event) => HandleScroll(@event); +} diff --git a/sources/Input/Input/IPointerDevice.cs b/sources/Input/Input/IPointerDevice.cs new file mode 100644 index 0000000000..de4e803f28 --- /dev/null +++ b/sources/Input/Input/IPointerDevice.cs @@ -0,0 +1,20 @@ +namespace Silk.NET.Input; + +/// +/// Represents a device with which the user can point at a target. +/// +public interface IPointerDevice : IButtonDevice +{ + /// + /// Gets the device state. + /// + /// + /// Only updated when is called. + /// + new PointerState State { get; } + ButtonReadOnlyList IButtonDevice.State => State.Buttons; + /// + /// Gets the targets at which the user can point with their pointer. + /// + IReadOnlyList Targets { get; } +} \ No newline at end of file diff --git a/sources/Input/Input/IPointerInputHandler.cs b/sources/Input/Input/IPointerInputHandler.cs new file mode 100644 index 0000000000..d1315a8477 --- /dev/null +++ b/sources/Input/Input/IPointerInputHandler.cs @@ -0,0 +1,26 @@ +namespace Silk.NET.Input; + +/// +/// An that also receives events. +/// +public interface IPointerInputHandler : IButtonInputHandler, IInputHandler, IInputHandler, IInputHandler +{ + /// + /// Called when the properties of a target at which the user can point using the pointer change. This includes the + /// addition and removal of targets. + /// + /// The event details. + void HandleTargetChanged(PointerTargetChangedEvent @event); + + /// + /// Called when the user adds, removes, or changes a point at which they're pointing at a target. + /// + /// The event details. + void HandlePointChanged(PointChangedEvent @event); + + /// + /// Called when the user changes the pressure with which they're gripping the pointer device. + /// + /// The event details. + void HandleGripChanged(PointerGripChangedEvent @event); +} diff --git a/sources/Input/Input/IPointerTarget.cs b/sources/Input/Input/IPointerTarget.cs new file mode 100644 index 0000000000..5bf3595bda --- /dev/null +++ b/sources/Input/Input/IPointerTarget.cs @@ -0,0 +1,41 @@ +using Silk.NET.Maths; + +namespace Silk.NET.Input; + +/// +/// Represents a target at which the user can point using their pointer device. +/// +public interface IPointerTarget +{ + /// + /// The boundary in which positions of points on this target shall fall. For , + /// shall represent the lack of a lower bound on a particular axis. For + /// For , shall represent the lack of a lower bound + /// on a particular axis. 0 represents an unused axis that axis is 0 on both + /// and . + /// + Box3D Bounds { get; } + + /// + /// Gets the number of points with which the given pointer is pointing at this target. + /// + /// The number of points. + /// + /// A single "logical" pointer device may have many points, and can optionally represent multiple physical pointers + /// as a single logical device - this is the case where a backend supports multiple mice to control an + /// cursor on its "raw mouse input" target, but combines these all to a single point on its "windowed" target. This + /// is also true for touch input - a touch screen is represented as a single touch device, + /// where each finger is its own point. + /// + int GetPointCount(IPointerDevice pointer); + + /// + /// Gets a point with which the given pointer is pointing at this target. + /// + /// The pointer device. + /// + /// The index of the point, between 0 and the number sourced from . + /// + /// The point at the given index with which the given pointer device is pointing at the target. + TargetPoint GetPoint(IPointerDevice pointer, int point); +} \ No newline at end of file diff --git a/sources/Input/Input/Implementations/EnumInfo.cs b/sources/Input/Input/Implementations/EnumInfo.cs new file mode 100644 index 0000000000..95c3914a12 --- /dev/null +++ b/sources/Input/Input/Implementations/EnumInfo.cs @@ -0,0 +1,274 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Reflection; +using System.Runtime.CompilerServices; + +namespace Silk.NET.Input; + +// ReSharper disable StaticMemberInGenericType +// ^ that's the point +/// +/// A helper class for quickly converting enum values into indexes, particularly +/// when there is a possibility of unknown/unnamed enum values. See for an example +/// of an appropriate implementation along with +/// +/// +internal static class EnumInfo where T : unmanaged, Enum +{ + /// + /// All enum values sorted in increasing order (unstable sort) + /// + public static IReadOnlyList All => _all; + + /// + /// All enum values with distinct numerical values sorted in increasing order. + /// In the case of multiple enum entries with the same numerical value, this makes no guarantees about + /// which version ends up here. + /// + public static readonly IReadOnlyList UniqueValues; + + /// + /// The value with the highest numerical value + /// + public static readonly T MaxValue; + + /// + /// The value with the lowest numerical value + /// + public static readonly T MinValue; + + /// + /// The numerical type of the enum + /// + public static readonly Type UnderlyingType = typeof(T).GetEnumUnderlyingType(); + + private static readonly T[] _all; + private static readonly string[] _names; + private static readonly Dictionary _numericallyDistinctValues; + private static readonly ulong[] _allEnumValuesRaw; + private static readonly bool _unnamedAreIndexable; + + static unsafe EnumInfo() + { + var customAttributeDatas = typeof(T).CustomAttributes; + var hasFlagsAttribute = false; + foreach (var attr in customAttributeDatas) + { + if (attr.AttributeType == typeof(FlagsAttribute)) + { + hasFlagsAttribute = true; + } + + if (attr.AttributeType == typeof(OrderedIndexUsageAttribute)) + { + _unnamedAreIndexable = true; + } + } + + if (hasFlagsAttribute) + { + throw new InvalidOperationException("Enums with the FlagsAttribute cannot be used with EnumInfo"); + } + + var underlyingType = UnderlyingType; + T[] vals; + T[] all; + if (underlyingType == typeof(int)) + { + all = OrderedValues(false); + vals = OrderedValues(true); + _allEnumValuesRaw = vals.Select(x => (ulong)*(uint*)&x).ToArray(); + } + else if (underlyingType == typeof(uint)) + { + all = OrderedValues(false); + vals = OrderedValues(true); + _allEnumValuesRaw = vals.Select(x => (ulong)*(uint*)&x).ToArray(); + } + else if (underlyingType == typeof(byte)) + { + all = OrderedValues(false); + vals = OrderedValues(true); + _allEnumValuesRaw = vals.Select(x => (ulong)*(byte*)&x).ToArray(); + } + else if (underlyingType == typeof(sbyte)) + { + all = OrderedValues(false); + vals = OrderedValues(true); + _allEnumValuesRaw = vals.Select(x => (ulong)*(byte*)&x).ToArray(); + } + else if (underlyingType == typeof(short)) + { + all = OrderedValues(false); + vals = OrderedValues(true); + _allEnumValuesRaw = vals.Select(x => (ulong)*(ushort*)&x).ToArray(); + } + else if (underlyingType == typeof(ushort)) + { + all = OrderedValues(false); + vals = OrderedValues(true); + _allEnumValuesRaw = vals.Select(x => (ulong)*(ushort*)&x).ToArray(); + } + else if (underlyingType == typeof(long)) + { + all = OrderedValues(false); + vals = OrderedValues(true); + _allEnumValuesRaw = vals.Select(x => *(ulong*)&x).ToArray(); + } + else if (underlyingType == typeof(ulong)) + { + all = OrderedValues(false); + vals = OrderedValues(true); + _allEnumValuesRaw = vals.Select(x => *(ulong*)&x).ToArray(); + } + else + { + throw new InvalidOperationException("Enum provided uses an unknown numeric base??"); + } + + + var names = new string[all.Length]; + for (var index = 0; index < all.Length; index++) + { + names[index] = all[index].ToString(); // todo: readable name attributes? + } + + var dict = new Dictionary(vals.Length); + for (var i = 0; i < vals.Length; i++) + { + var enumVal = vals[i]; + + // get attribute and check for ignore + + dict.Add(enumVal, i); + } + + _names = names; + _all = all; + UniqueValues = vals; + _numericallyDistinctValues = dict; + MinValue = All[0]; + MaxValue = All[^1]; + } + + /// + /// Get the ordered index of the value provided. + /// Values with the same numerical value will *not* return the same index, and are not guaranteed to be + /// stably sorted across application runs. + /// The index provided + /// + /// + /// The index of the sorted enum value + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int NameIndexOf(T value) => Array.IndexOf(_all, value); + + /// + + /// + /// Returns the names of an enum value, pre-allocated + /// + public static string NameOf(T value) => _names[NameIndexOf(value)]; + + /// + /// Get the ordered index of the value provided. + /// Values with the same numerical value will return the same index + /// + /// + /// The index of the sorted enum numerical value, or -1 if not a named enum member. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int ValueIndexOf(T value) => !_unnamedAreIndexable + ? ValueOf(value) + : _numericallyDistinctValues.GetValueOrDefault(value, -1); + + /// + /// Gets the ordered index of the unnamed enum value provided. This index is calculated by: + /// (the number of named members in this enum type) + (the raw value of the number if unnamed) + /// + /// Negative values or values that are above the lowest enum value will return -1, as they cannot be used for indexing + /// + /// + /// + public static int ValueIndexOfUnnamed(T value) + { + if (!_unnamedAreIndexable) + { + return ValueOf(value); + } + + if(_numericallyDistinctValues.TryGetValue(value, out var index)) + { + return index; + } + + var rawValue = ValueOf(value); + + // todo - don't rely on joystickButton's unknown - find the MinValue + if (rawValue <= 0 || rawValue >= ValueOf(_allEnumValuesRaw[0])) + { + return -1; + } + + return _all.Length + rawValue; + } + + /// + /// Returns the numerical value of the enum value provided in a type-safe way + /// + /// + /// + /// + /// + private static unsafe TNumber ValueOf(TValue value) where TNumber : unmanaged where TValue : unmanaged + { + if (sizeof(T) == sizeof(TNumber)) + { + return Unsafe.Read(&value); + } + + var minSize = Math.Min(sizeof(TNumber), sizeof(T)); + + var originalValuePtr = (byte*)&value; + + var valuePtr = &originalValuePtr[Math.Abs(minSize - sizeof(T))]; // does this assume little-endianness? + var numberPtr = stackalloc byte[sizeof(TNumber)]; + + // ensure block is initialized (as it isnt guaranteed?) so any missing bytes of the output will stay 0 + // if type TNumber is a larger size than type T + Unsafe.InitBlock(numberPtr, 0, (uint)sizeof(TNumber)); + + var copyToPtr = &numberPtr[Math.Abs(minSize - sizeof(TNumber))]; + Buffer.MemoryCopy(valuePtr, copyToPtr, sizeof(TNumber), minSize); + return *(TNumber*)numberPtr; + } + + private static T[] OrderedValues(bool byNumericValue) + where TNumber : unmanaged, IComparable + { + // numerically distinct numbers + var allValues = Enum.GetValues().Where(x => !IsIgnored(x)).ToArray(); + + if (byNumericValue) + { + allValues = allValues.DistinctBy(ValueOf).ToArray(); + } + + // sort by increasing order + allValues.AsSpan().StableSort((a, b) => { + var aNumber = ValueOf(a); + var bNumber = ValueOf(b); + return aNumber.CompareTo(bNumber); + }); + + return allValues; + } + + private static bool IsIgnored(T value) + { + var attr = value.GetType().GetField(value.ToString())?.GetCustomAttribute(); + return attr is not null; + } + + public static unsafe bool HasValue(int value) => _allEnumValuesRaw.Contains(*(uint*)&value); +} diff --git a/sources/Input/Input/Implementations/KeyHandling/ICharacterConverter.cs b/sources/Input/Input/Implementations/KeyHandling/ICharacterConverter.cs new file mode 100644 index 0000000000..2ee4c27b12 --- /dev/null +++ b/sources/Input/Input/Implementations/KeyHandling/ICharacterConverter.cs @@ -0,0 +1,188 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics.CodeAnalysis; +using System.Globalization; + +namespace Silk.NET.Input.KeyHandling; + +/// +/// A simple interface for an implementation that converts keyboard input into characters for text entry +/// +internal interface ICharacterConverter +{ + public bool TryConvert(KeyName key, KeyModifiers modifiers, [NotNullWhen(true)] out char? c); +} + +internal class DummyCharConverter : ICharacterConverter +{ + // todo - proper VK key support for various languages and layouts + public bool TryConvert(KeyName key, KeyModifiers modifiers, [NotNullWhen(true)] out char? c) + { + if (!key.IsChar()) + { + c = null; + return false; + } + + if (key is >= KeyName.A and <= KeyName.Z) + { + var diff = (int)key - (int)KeyName.A; + c = (char)('a' + diff); + if (modifiers.ShouldCapitalize()) + { + c = CultureInfo.CurrentCulture.TextInfo.ToUpper(c.Value); + } + + return true; + } + + var isShifted = modifiers.IsShift(); + switch (key) + { + case KeyName.Number1: + c = isShifted ? '!' : '1'; + return true; + case KeyName.Keypad1: + c = '1'; + return true; + case KeyName.Number2: + c = isShifted ? '@' : '2'; + return true; + case KeyName.Keypad2: + c = '2'; + return true; + case KeyName.Number3: + c = isShifted ? '#' : '3'; + return true; + case KeyName.Keypad3: + c = '3'; + return true; + case KeyName.Number4: + c = isShifted ? '$' : '4'; + return true; + case KeyName.Keypad4: + c = '4'; + return true; + case KeyName.Number5: + c = isShifted ? '%' : '5'; + return true; + case KeyName.Keypad5: + c = '5'; + return true; + case KeyName.Number6: + c = isShifted ? '^' : '6'; + return true; + case KeyName.Keypad6: + c = '6'; + return true; + case KeyName.Number7: + c = isShifted ? '&' : '7'; + return true; + case KeyName.Keypad7: + c = '7'; + return true; + case KeyName.Number8: + c = isShifted ? '*' : '8'; + return true; + case KeyName.Keypad8: + c = '8'; + return true; + case KeyName.Number9: + c = isShifted ? '(' : '9'; + return true; + case KeyName.Keypad9: + c = '9'; + return true; + case KeyName.Number0: + c = isShifted ? ')' : '0'; + return true; + case KeyName.Keypad0: + c = '0'; + return true; + case KeyName.Minus: + c = isShifted ? '_' : '-'; + return true; + case KeyName.Equals: + c = isShifted ? '+' : '='; + return true; + case KeyName.Tab: + c = '\t'; + return true; + case KeyName.Apostrophe: + c = isShifted ? '\"' : '\''; + return true; + case KeyName.Backslash: + c = isShifted ? '|' : '\\'; + return true; + case KeyName.Semicolon: + c = isShifted ? ':' : ';'; + return true; + case KeyName.Comma: + c = isShifted ? '<' : ','; + return true; + case KeyName.Period: + c = isShifted ? '>' : '.'; + return true; + case KeyName.Slash: + c = isShifted ? '?' : '/'; + return true; + case KeyName.Space: + c = ' '; + return true; + case KeyName.KeypadAmpersand: + c = '&'; + return true; + case KeyName.KeypadPercent: + c = '%'; + return true; + case KeyName.KeypadColon: + c = ':'; + return true; + case KeyName.KeypadLeftParenthesis: + c = '('; + return true; + case KeyName.KeypadRightParenthesis: + c = ')'; + return true; + case KeyName.KeypadPlus: + c = '+'; + return true; + case KeyName.KeypadComma: + c = ','; + return true; + case KeyName.KeypadMinus: + c = '-'; + return true; + case KeyName.KeypadPeriod: + c = '.'; + return true; + case KeyName.KeypadDivide: + c = '/'; + return true; + case KeyName.KeypadEquals: + c = '='; + return true; + case KeyName.KeypadEnter: + case KeyName.Return: + case KeyName.Return2: + c = '\n'; + return true; + case KeyName.KeypadExclamation: + c = '!'; + return true; + case KeyName.KeypadMultiply: + c = '*'; + return true; + case KeyName.Grave: + c = '`'; + return true; + case KeyName.CurrencyUnit: + c = RegionInfo.CurrentRegion.CurrencySymbol[0]; + return true; + } + + c = null; + return false; + } +} diff --git a/sources/Input/Input/Implementations/KeyHandling/KeyNameExtensions.cs b/sources/Input/Input/Implementations/KeyHandling/KeyNameExtensions.cs new file mode 100644 index 0000000000..a8343fc9ff --- /dev/null +++ b/sources/Input/Input/Implementations/KeyHandling/KeyNameExtensions.cs @@ -0,0 +1,111 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; + +namespace Silk.NET.Input.KeyHandling; + +/// +/// A series of extension methods for making sense of values +/// +internal static class KeyNameExtensions +{ + /// + /// Returns true if the key would produce a character in common text editing scenarios. Includes whitespace. + /// + public static bool IsChar(this KeyName name) => + name is >= KeyName.A and <= KeyName.Return + or >= KeyName.KeypadDivide and <= KeyName.KeypadPeriod + or >= KeyName.Tab and <= KeyName.Slash + or >= KeyName.KeypadMultiply and <= KeyName.KeypadEnter + or >= KeyName.KeypadA and <= KeyName.KeypadExclamation + or >= KeyName.Keypad00 and <= KeyName.KeypadTab + or KeyName.Return2 or KeyName.Separator or KeyName.KeypadPlusMinus + or KeyName.KeypadComma + or KeyName.KeypadEquals or KeyName.OtherKeypadEquals; + + /// + /// Returns true if the given key would produce a deletion of one or more characters in common text + /// editing scenarios. + /// + public static bool IsDeletion(this KeyName name) => + name is KeyName.Backspace + or KeyName.Delete + or KeyName.KeypadBackspace + or KeyName.Clear + or KeyName.KeypadClear + or KeyName.KeypadClearEntry + or KeyName.ClearAgain; + + public static TextDeletionType GetDeletionType(this KeyName name) + { + Debug.Assert(name.IsDeletion()); + + return name switch { + KeyName.Backspace => TextDeletionType.Back, + KeyName.Delete => TextDeletionType.Forward, + KeyName.KeypadBackspace => TextDeletionType.Back, + KeyName.Clear => TextDeletionType.All, + KeyName.KeypadClear => TextDeletionType.All, + KeyName.KeypadClearEntry => TextDeletionType.All, + KeyName.ClearAgain => TextDeletionType.All, + _ => TextDeletionType.None + }; + } + + /// + /// An enum representing the type of text deletion, if any. For example, + /// would be , would be , etc. + /// + public enum TextDeletionType + { + /// + /// Key represents a deletion of one (or more) character(s) behind the cursor. + /// + Back, + + /// + /// Key represents a deletion of one (or more) character(s) ahead of the cursor. + /// + Forward, + + /// + /// Key represents a deletion of all characters in current text entry context + /// + All, + + /// + /// Key does not represent a deletion. + /// + None = -1 + } + + /// + /// Returns true if the modifiers signify that the next character should be capitalized. + /// + public static bool ShouldCapitalize(this KeyModifiers modifiers) => + ((modifiers & KeyModifiers.CapsLock) == KeyModifiers.CapsLock) ^ + ((modifiers & KeyModifiers.ShiftLeft) == KeyModifiers.ShiftLeft + || (modifiers & KeyModifiers.ShiftRight) == KeyModifiers.ShiftRight); + + public static bool IsControl(this KeyName name) => + name is KeyName.ControlLeft or KeyName.ControlRight; + + public static bool IsControl(this KeyModifiers mod) => + (mod & KeyModifiers.ControlLeft) == KeyModifiers.ControlLeft || + (mod & KeyModifiers.ControlRight) == KeyModifiers.ControlRight; + + public static bool IsShift(this KeyName name) => + name is KeyName.ShiftLeft or KeyName.ShiftRight; + + public static bool IsShift(this KeyModifiers mod) => + (mod & KeyModifiers.ShiftLeft) == KeyModifiers.ShiftLeft || + (mod & KeyModifiers.ShiftRight) == KeyModifiers.ShiftRight; + + public static bool IsAlt(this KeyName name) => + name is KeyName.AltLeft or KeyName.AltRight; + + public static bool IsAlt(this KeyModifiers mod) => + (mod & KeyModifiers.AltLeft) == KeyModifiers.AltLeft || + (mod & KeyModifiers.AltRight) == KeyModifiers.AltRight; +} diff --git a/sources/Input/Input/Implementations/KeyHandling/TextRecorder.cs b/sources/Input/Input/Implementations/KeyHandling/TextRecorder.cs new file mode 100644 index 0000000000..e8c06b4006 --- /dev/null +++ b/sources/Input/Input/Implementations/KeyHandling/TextRecorder.cs @@ -0,0 +1,407 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Text; +using Silk.NET.Input.SDL3; +using Silk.NET.SDL; + +namespace Silk.NET.Input.KeyHandling; + +/// +/// A utility class for recording text input. +/// Where possible, it may be preferable to use and +/// instead, but this requires the use of the SDL windowing API, which may not be available in all contexts. +/// This class is a work in progress, and not yet sufficient for full text-editor support. +/// +internal sealed class TextRecorder +{ + private readonly ICharacterConverter _converter; + + /// + /// Constructor + /// + public TextRecorder(ICharacterConverter? converter) + { + _converter = converter ?? new DummyCharConverter(); + } + + /// + /// The number of characters currently in the buffer. + /// + public int Count => _sb.Length; + + /// + /// Modify the buffer and recorder state based on the input key name and the state of the keyboard. + /// + /// The keystroke to add + /// The keyboard whose state we are recording + public bool AddKeyStroke(KeyName name, IKeyboard keyboard, [NotNullWhen(true)] out char? newChar) + { + var isChar = name.IsChar(); + var isDeletion = name.IsDeletion(); + + if (!isChar && !isDeletion) + { + newChar = null; + return false; + } + + if (name == KeyName.Paste) + { + var clipboardText = keyboard.ClipboardText; + if (!string.IsNullOrEmpty(clipboardText)) + { + InsertText(clipboardText); + } + + newChar = null; + return false; + } + + var state = keyboard.State; + var activeModifiers = state.Modifiers; + if (name.IsChar()) + { + if (activeModifiers.IsAlt() || activeModifiers.IsControl()) + { + newChar = null; + return false; + } + + // insert the appropriate character + // first, we need the virtual key represented by the scancode (KeyName) + + if (_converter.TryConvert(name, activeModifiers, out newChar)) + { + InsertText(newChar.Value); + return true; + } + + return false; + } + + if (name.IsDeletion()) + { + var deletionType = name.GetDeletionType(); + Debug.Assert(deletionType != KeyNameExtensions.TextDeletionType.None); + switch (deletionType) + { + case KeyNameExtensions.TextDeletionType.Back: + if (_selectionLength > 0) + { + RemoveSelectedTextAndClearSelection(); + } + else if (_cursorStart > 0) + { + // remove from behind cursor and move cursor back accordingly + if (activeModifiers.IsControl()) + { + // find first whitespace character prior to current cursor position + var cursorPos = _cursorStart; + while (cursorPos > 0 && !char.IsWhiteSpace(_sb[cursorPos - 1])) + { + --cursorPos; + } + + var count = Math.Min(_cursorStart - cursorPos, 1); + _sb.Remove(cursorPos, count); + _cursorStart = cursorPos; + } + else + { + _sb.Remove(--_cursorStart, 1); + } + } + + break; + case KeyNameExtensions.TextDeletionType.Forward: + if (_selectionLength > 0) + { + RemoveSelectedTextAndClearSelection(); + } + else if (_cursorStart < _sb.Length) + { + // remove from front of cursor + if (activeModifiers.IsControl()) + { + // find first whitespace character after current cursor position + var cursorPos = _cursorStart; + while (cursorPos < _sb.Length && !char.IsWhiteSpace(_sb[cursorPos])) + { + ++cursorPos; + } + + var count = Math.Min(_sb.Length - cursorPos, 1); + _sb.Remove(cursorPos, count); + } + else + { + _sb.Remove(_cursorStart, 1); + } + } + break; + case KeyNameExtensions.TextDeletionType.All: + _sb.Clear(); + SetCursorPositionRaw(0); + SetSelectionLength(0); + break; + default: + InputLog.Error($"Unexpected text deletion type: {deletionType}"); + break; + } + } + + newChar = null; + return false; + } + + /// + /// Removes the currently selected text and sets the current selection length to 0. + /// + private void RemoveSelectedTextAndClearSelection() + { + // remove the currently selected text + var selectedLength = _selectionLength; + SetSelectionLength(0); + if (selectedLength > 0 && _cursorStart < _sb.Length) + { + Debug.Assert(_cursorStart + selectedLength <= _sb.Length); + _sb.Remove(_cursorStart, selectedLength); + } + } + + /// + /// Inserts the given text into the buffer at the current cursor/selection position. + /// + /// + public void InsertText(ReadOnlySpan str) + { + RemoveSelectedTextAndClearSelection(); + + if (str.Length > 0) + { + _sb.Insert(_cursorStart, str); + SetCursorPositionRaw(_cursorStart + str.Length); + } + } + + /// + /// Inserts the given text into the buffer at the current cursor/selection position. + /// + /// + public void InsertText(char c) + { + ReadOnlySpan span = [c]; + InsertText(span); + } + + /// + /// Inserts the given text into the buffer at the given cursor position. Given cursor position is always + /// clamped to the bounds of the buffer. Clears any current selection if the actual cursor position is different from + /// the provided cursor position. + /// + /// + /// The cursor position in the buffer to inject + public void InsertTextAt(ReadOnlySpan str, int cursorStart) + { + if (_cursorStart != cursorStart) + { + SetCursorPositionRaw(cursorStart); + SetSelectionLength(0); + } + + InsertText(str); + } + + /// + /// Inserts the given text into the buffer at the given cursor position. Given cursor position is always + /// clamped to the bounds of the buffer. Clears any current selection if the actual cursor position is different from + /// the provided cursor position. + /// + /// + /// The cursor position in the buffer to inject + /// + public unsafe void InsertTextAt(sbyte* textPtrUnsafe, int cursorStart, int textLength) => + InsertTextAt(textPtr: new Ptr(textPtrUnsafe), cursorStart, textLength); + + /// + /// Inserts the given text into the buffer at the given cursor position. Given cursor position is always + /// clamped to the bounds of the buffer. Clears any current selection if the actual cursor position is different from + /// the provided cursor position. + /// + /// + /// The cursor position in the buffer to inject + public void InsertTextAt(Ptr textPtr, int cursorStart) + { + // count to end + const char terminator = '\0'; + for (uint i = 0; i < int.MaxValue; ++i) + { + if (textPtr[i] == terminator) + { + InsertTextAt(textPtr, cursorStart, (int)i); + return; + } + + ++i; + } + } + + /// + /// Inserts the given text into the buffer at the given cursor position. Given cursor position is always + /// clamped to the bounds of the buffer. Clears any current selection if the actual cursor position is different from + /// the provided cursor position. + /// + /// + /// The cursor position in the buffer to inject + /// + public void InsertTextAt(Ptr textPtr, int cursorStart, int textLength) + { + Span textSpan = stackalloc char[textLength]; + + if (textPtr.TryReadToSpan(ref textSpan)) + { + Debug.Assert(textSpan.Length == textLength); + InsertTextAt(textSpan, cursorStart); + } + else + { + InputLog.Error("Failed to read text from text editing event."); + // insert empty just to synchronize cursor position + SetSelection(cursorStart, 0); + } + } + + /// + /// Sets the selection appropriately for the given positions. Positions can be provided in any order, + /// and resulting selection will be clamped to a valid range for the current buffer. + /// + /// + /// + public void SetSelectionPositions(int positionA, int positionB) + { + if (positionA > positionB) + { + SetSelection(positionB, positionA - positionB); + } + else + { + SetSelection(positionA, positionB - positionA); + } + } + + /// + /// Set the selection to the given start and length. Position and length are clamped to the bounds of the buffer. + /// + /// + /// + public void SetSelection(int startPosition, int length) + { + SetCursorPositionRaw(startPosition); + SetSelectionLength(length); + } + + /// + /// Moves the cursor start to the given position, and adjusts the selection length such that + /// the selection's end does not move + /// + /// + public void MoveCursorStart(int newPosition) + { + var pCursor = _cursorStart; + SetCursorPositionRaw(newPosition); + var diff = pCursor - _cursorStart; + SetSelectionLength(_selectionLength + diff); + } + + /// + /// Adjusts the selection length based on a given end position. The end position is clamped to the bounds of the + /// buffer. This may modify the selection start position if the provided position is less than the current + /// start cursor position. + /// + /// + public void MoveCursorEnd(int endPosition) + { + if (endPosition < _cursorStart) + { + SetCursorPositionRaw(endPosition); + SetSelectionLength(0); + return; + } + + var clampedEndPosition = Math.Clamp(endPosition, _cursorStart, _sb.Length); + SetSelectionLength(clampedEndPosition - _cursorStart); + } + + /// + /// Sets the selection length to the given value. The value is clamped to the bounds of the buffer. + /// + /// + private void SetSelectionLength(int newLength) => + _selectionLength = Math.Clamp(newLength, 0, _sb.Length - _cursorStart); + + /// + /// Sets the value of to the given value. The value is clamped to the bounds of the buffer. + /// Selection length is not affected. + /// + /// + private void SetCursorPositionRaw(int newPosition) => _cursorStart = Math.Clamp(newPosition, 0, _sb.Length); + + /// + /// Fills a span with current buffer contents. Will fill the given span up to the length of the contents or the + /// length of the span. + /// + /// + /// + public int GetCurrentBuffer(Span buffer) + { + var maxCount = Math.Min(buffer.Length, _sb.Length); + _sb.CopyTo(0, buffer, maxCount); + return maxCount; + } + + /// + /// Fills a span with the currently selected text. Will fill the given span up to the length of the selection or the + /// length of the span. + /// + /// + /// + public int GetSelectedRegion(Span buffer) + { + var maxCount = Math.Min(buffer.Length, _selectionLength); + if (maxCount == 0) + { + return 0; + } + + _sb.CopyTo(_cursorStart, buffer, maxCount); + return maxCount; + } + + /// + /// Retrieves the current buffer contents and clears the buffer, resetting the cursor and selection positions. + /// + /// + public string ConsumeInput() + { + var result = _sb.ToString(); + Clear(); + return result; + } + + /// + /// Clears the buffer and resets the cursor and selection positions. + /// + public void Clear() + { + _sb.Clear(); + _cursorStart = 0; + _selectionLength = 0; + } + + + private int _cursorStart, _selectionLength; + private readonly StringBuilder _sb = new(); +} diff --git a/sources/Input/Input/Implementations/OrderedIndexUsageAttribute.cs b/sources/Input/Input/Implementations/OrderedIndexUsageAttribute.cs new file mode 100644 index 0000000000..9be4e953ae --- /dev/null +++ b/sources/Input/Input/Implementations/OrderedIndexUsageAttribute.cs @@ -0,0 +1,10 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Input; + +[AttributeUsage(AttributeTargets.Enum)] +internal class OrderedIndexUsageAttribute : Attribute; + +[AttributeUsage(AttributeTargets.Field)] +internal class OrderedIndexIgnoreAttribute : Attribute; diff --git a/sources/Input/Input/Implementations/SDL3/Devices/ISdlDevice.cs b/sources/Input/Input/Implementations/SDL3/Devices/ISdlDevice.cs new file mode 100644 index 0000000000..c751f79e6a --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/ISdlDevice.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Input.SDL3; + +/// +/// An interface defining a generic constructor for managed SDL devices. +/// +/// +internal interface ISdlDevice : IInputDevice where T : SdlDevice +{ + public static abstract T? CreateDevice(ulong sdlDeviceId, SdlInputBackend backend, SilkEventContext context); +} + +internal interface INeedFinalizationEachFrame +{ + public void FinalizeUpdate(); +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/IOrderedDevice.cs b/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/IOrderedDevice.cs new file mode 100644 index 0000000000..f9687a12db --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/IOrderedDevice.cs @@ -0,0 +1,13 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Input.SDL3.Devices.Joysticks; + +/// +/// For devices such as gamepads and joysticks, their SDL IDs are likely to change when other devices +/// are removed. +/// +internal interface IOrderedDevice +{ + public void RefreshSdlId(); +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/ISdlJoystick.cs b/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/ISdlJoystick.cs new file mode 100644 index 0000000000..5b584358fa --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/ISdlJoystick.cs @@ -0,0 +1,37 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3.Devices.Joysticks; + +/// +/// An interface for implementing different joystick types +/// +/// Currently, only Gamepad is explicitly supported, however this interface leaves room +/// for extensions such as those seen in . +/// +internal interface ISdlJoystick : IOrderedDevice +{ + public SdlJoystick Joystick { get; } + /// + /// Raw joystick axis input events are forwarded here + /// + /// Input axis (which axis) + /// Input axis value + public void UpdateFromJoyAxis(int axis, short joystickInput, ulong sdlTimestamp, long timestamp); + + /// + /// Raw joystick hat input events are forwarded here + /// + /// Input hat (which hat) + /// Input hat value + public void UpdateFromJoyHat(int hatIdx, SdlJoystick.HatState hatState, ulong sdlTimestamp, long timestamp); + + /// + /// Raw joystick button input events are forwarded here + /// + /// Input button (which button) + /// Button state + public void UpdateFromJoyButton(int buttonIdx, bool down, ulong sdlTimestamp, long timestamp); +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/SdlGamepad.cs b/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/SdlGamepad.cs new file mode 100644 index 0000000000..a6047784c3 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/SdlGamepad.cs @@ -0,0 +1,411 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3.Devices.Joysticks; + +/// +/// provides the IGamepad implementation for a joystick +/// +internal sealed unsafe class SdlGamepad : SdlDevice, IGamepad, ISdlDevice, ISdlJoystick, IJoystick +{ + private GamepadHandle _gamepadHandle; + + public SdlJoystick Joystick { get; } + + + // todo - do we want this to be an actual unique device? or should it have the same "unique id" as the joystick? + private SdlGamepad(SdlJoystick joystick, nint uniqueId) : base(joystick.Backend, uniqueId, joystick.SdlDeviceId) + { + Joystick = joystick; + + } + + private void Remap(GamepadHandle gamepadHandle) + { + _bindings.Clear(); + _outputBindings.Clear(); + _hatBindings.Clear(); + var bindingsCount = 0; + var mappings = NativeBackend.GetGamepadBindings(gamepadHandle, &bindingsCount); + + if (bindingsCount == 0) + { + if (mappings != null) + { + NativeBackend.Free(mappings); + } + + SdlLog.Error("No gamepad mappings found."); + return; + } + + for (var i = 0; i < bindingsCount; i++) + { + var binding = mappings[i]; + + if (binding->OutputType == GamepadBindingType.None) + { + continue; + } + + int? id = null; + + switch (binding->InputType) + { + case GamepadBindingType.Button: + id = binding->Input.Button << _buttonShift; + break; + case GamepadBindingType.Axis: + id = binding->Input.Axis.Axis << _axisShift; + break; + case GamepadBindingType.Hat: + id = binding->Input.Hat.Hat; + break; + } + + if (id == null) + { + continue; + } + + switch (binding->OutputType) + { + case GamepadBindingType.Axis: + case GamepadBindingType.Button: + _outputBindings.Add(*binding); + break; + } + + if (binding->InputType == GamepadBindingType.Hat) + { + while (_hatBindings.Count <= id.Value) + { + _hatBindings.Add(null); + } + + _hatBindings[id.Value] ??= []; + _hatBindings[id.Value]!.Add(*binding); + } + else + { + _bindings.Add(id.Value, *binding); + } + } + + NativeBackend.Free(mappings); + } + + public void Remap() => Remap(_gamepadHandle); + + public override ulong SdlDeviceId => _sdlDeviceId; + private uint _sdlDeviceId; + + public void RefreshSdlId() => _sdlDeviceId = NativeBackend.GetGamepadID(_gamepadHandle); + + public override string Name => Joystick.Name; + + protected internal override void Initialize() + { + var joystickHandle = Joystick.JoystickHandle; + var gamepadHandle = *(GamepadHandle*)&joystickHandle; //NativeBackend.OpenGamepad(sdlDeviceId); + _gamepadHandle = gamepadHandle; + Remap(gamepadHandle); + + _state = new GamepadState(Joystick.RawButtonState, Joystick.RawAxisState); + Joystick.AddDeviceMapping(this); + } + + protected override void Release() + { + Joystick.RemoveDeviceMapping(this); + + // todo: does this close the joystick as well? + NativeBackend.CloseGamepad(_gamepadHandle); + } + private GamepadState _state; + + #region IGamepad + + GamepadState IGamepad.State => GamepadState; + private GamepadState GamepadState => _state; + + public IReadOnlyList VibrationMotors => + _rumbler ??= SdlRumble.Create(_gamepadHandle.Handle, NativeBackend, 2); + + private SdlRumble? _rumbler; + + #endregion + + public static SdlGamepad? CreateDevice(ulong sdlDeviceId, SdlInputBackend backend, SilkEventContext context) + { + if (!backend.TryGetOrCreateDevice(sdlDeviceId, out var joystick)) + { + return null; + } + + var joystickUniqueId = joystick.Id; + var gpn = backend.Sdl.GetRealGamepadTypeForID((uint)sdlDeviceId); + + if (backend.AttemptUniqueId(gpn, ref joystickUniqueId)) + { + return new SdlGamepad(joystick, uniqueId: joystickUniqueId) { + _thumbstickEvents = context.GamepadThumbstickMoveSdlEvents + }; + } + + // manipulate the joystick id to make a unique gamepad id + var guid = backend.Sdl.GetGamepadGuidForID((uint)sdlDeviceId); + if (backend.AttemptUniqueId(guid, ref joystickUniqueId)) + { + return new SdlGamepad(joystick, uniqueId: joystickUniqueId) { + _thumbstickEvents = context.GamepadThumbstickMoveSdlEvents + }; + } + + joystickUniqueId = SdlInputBackend.FallbackUniqueId(sdlDeviceId, joystickUniqueId); + var sdlGamepad = new SdlGamepad(joystick, uniqueId: joystickUniqueId) { + _thumbstickEvents = context.GamepadThumbstickMoveSdlEvents + }; + return sdlGamepad; + } + + private void UpdateGamepadAxis(GamepadAxis gAxis, int value, int min, int max, ulong sdlTimestamp, long timestamp) + { + var mappedValue = (float)(value + min) / (max - min); + switch (gAxis) + { + case GamepadAxis.Invalid: + return; + case GamepadAxis.Leftx or GamepadAxis.Lefty or GamepadAxis.Rightx or GamepadAxis.Righty: + { + var axis = ToJoystickAxis(gAxis); + var axes = GetJoystickAxis2(axis); + var xIndex = axes.X.Index(); + var yIndex = axes.Y.Index(); + var previous = Joystick.GetAxisStateByIndex2D(xIndex, yIndex); + + if (Joystick.UpdateRawAxisState(axis, mappedValue, out _, sdlTimestamp, timestamp)) + { + var latest = Joystick.GetAxisStateByIndex2D(xIndex, yIndex); + _thumbstickEvents.Enqueue(new GamepadThumbstickMoveEvent(Gamepad: this, + Timestamp: timestamp, + Value: latest, + Delta: latest - previous), sdlTimestamp); + + ToSplitPair(axis, out var minusAxis, out var plusAxis); + var split = SdlJoystick.SplitValue(mappedValue); + Joystick.UpdateRawAxisState(minusAxis, split.X, out _, sdlTimestamp, timestamp); + Joystick.UpdateRawAxisState(plusAxis, split.Y, out _, sdlTimestamp, timestamp); + } + + break; + + } + case GamepadAxis.LeftTrigger or GamepadAxis.RightTrigger: + { + if (Joystick.UpdateRawAxisState(ToJoystickAxis(gAxis), mappedValue, out var moveEvt, sdlTimestamp, timestamp)) + { + _triggerEvents.Enqueue(new GamepadTriggerMoveEvent(this, moveEvt.Timestamp, moveEvt.Axis, + moveEvt.Value, moveEvt.Delta)); + } + + break; + } + default: + throw new ArgumentOutOfRangeException(nameof(gAxis), gAxis, null); + } + + return; + + static JoystickAxis ToJoystickAxis(GamepadAxis gamepadAxis) => gamepadAxis switch { + GamepadAxis.Leftx => JoystickAxis.LeftX, + GamepadAxis.Lefty => JoystickAxis.LeftY, + GamepadAxis.Rightx => JoystickAxis.RightX, + GamepadAxis.Righty => JoystickAxis.RightY, + GamepadAxis.LeftTrigger => JoystickAxis.LeftTrigger, + GamepadAxis.RightTrigger => JoystickAxis.RightTrigger, + _ => throw new ArgumentOutOfRangeException(nameof(gamepadAxis), gamepadAxis, null) + }; + + static (JoystickAxis X, JoystickAxis Y) GetJoystickAxis2(JoystickAxis axis) => + axis switch { + JoystickAxis.LeftX or JoystickAxis.LeftY => (JoystickAxis.LeftX, JoystickAxis.LeftY), + JoystickAxis.RightX or JoystickAxis.RightY => (JoystickAxis.RightX, JoystickAxis.RightY), + _ => throw new ArgumentOutOfRangeException(nameof(axis), axis, null) + }; + } + + private static void ToSplitPair(JoystickAxis axis, out JoystickAxis splitMinus, out JoystickAxis splitPlus) + { + switch (axis) + { + case JoystickAxis.LeftX: + splitMinus = JoystickAxis.MinusLeftX; + splitPlus = JoystickAxis.PlusLeftX; + break; + case JoystickAxis.RightX: + splitMinus = JoystickAxis.MinusRightX; + splitPlus = JoystickAxis.PlusRightX; + break; + case JoystickAxis.LeftY: + splitMinus = JoystickAxis.MinusLeftY; + splitPlus = JoystickAxis.PlusLeftY; + break; + case JoystickAxis.RightY: + splitMinus = JoystickAxis.MinusRightY; + splitPlus = JoystickAxis.PlusRightY; + break; + default: + throw new ArgumentOutOfRangeException(nameof(axis), axis, null); + } + } + + #region ISdlJoystick + + public void UpdateFromJoyButton(int buttonIdx, bool down, ulong sdlTimestamp, long timestamp) + { + if (!_bindings.TryGetValue(buttonIdx << _buttonShift, out var binding)) + { + return; + } + + Debug.Assert(binding.InputType == GamepadBindingType.Button && binding.Input.Button == buttonIdx); + var bindingType = binding.OutputType; + var output = &binding.Output; + switch (bindingType) + { + case GamepadBindingType.Axis: + var axis = output->Axis; + UpdateGamepadAxis( + gAxis: axis.Axis, + value: down ? axis.AxisMax : axis.AxisMin, + min: axis.AxisMin, + max: axis.AxisMax, + sdlTimestamp: sdlTimestamp, + timestamp: timestamp); + break; + + case GamepadBindingType.Button: + UpdateButton(output->Button, down, sdlTimestamp, timestamp); + break; + } + } + + public void AddButtonEvent(byte sdlButtonId, byte sdlButtonDown, ulong sdlTimestamp, long timestamp) => + UpdateButton((GamepadButton)sdlButtonId, sdlButtonDown > 0, sdlTimestamp, timestamp); + + public void AddAxisEvent(byte evtAxis, short evtValue, ulong sdlTimestamp, long timestamp) => + UpdateGamepadAxis((GamepadAxis)evtAxis, evtValue, Sdl.JoystickAxisMin, Sdl.JoystickAxisMax, sdlTimestamp, timestamp); + + public void UpdateFromJoyAxis(int axis, short joystickInput, ulong sdlTimestamp, long timestamp) + { + if (!_bindings.TryGetValue(axis << _axisShift, out var binding)) + { + return; + } + + Debug.Assert(binding.InputType == GamepadBindingType.Axis); + + var output = &binding.Output; + var input = &binding.Input.Axis; + + switch (binding.OutputType) + { + case GamepadBindingType.Axis: + UpdateGamepadAxis(output->Axis.Axis, joystickInput, input->AxisMin, input->AxisMax, sdlTimestamp, timestamp); + break; + case GamepadBindingType.Button: + UpdateButton(output->Button, joystickInput >= input->AxisMin && joystickInput <= input->AxisMax, sdlTimestamp, timestamp); + break; + } + } + + public void UpdateFromJoyHat(int hatIdx, SdlJoystick.HatState hatState, ulong sdlTimestamp, long timestamp) + { + if (_hatBindings.Count <= hatIdx) + { + return; + } + + var bindings = _hatBindings[index: hatIdx]; + if (bindings is not { Count: > 0 }) + { + return; + } + + foreach (var binding in bindings) + { + Debug.Assert(condition: binding.InputType == GamepadBindingType.Hat && binding.Input.Hat.Hat == hatIdx); + var input = &binding.Input.Hat; + var mask = (SdlJoystick.HatState)input->HatMask; + var bindingState = hatState & mask; + switch (binding.OutputType) + { + case GamepadBindingType.Axis: + var axis = binding.Output.Axis; + UpdateGamepadAxis( + gAxis: axis.Axis, + value: bindingState == SdlJoystick.HatState.Centered ? axis.AxisMin : axis.AxisMax, + min: axis.AxisMin, + max: axis.AxisMax, + sdlTimestamp: sdlTimestamp, + timestamp: timestamp); + break; + case GamepadBindingType.Button: + var button = binding.Output.Button; + UpdateButton(button, bindingState != SdlJoystick.HatState.Centered, sdlTimestamp, timestamp);; + break; + } + } + } + + #endregion + + private void UpdateButton(GamepadButton button, bool value, ulong sdlTimestamp, long timestamp) + { + var asJoystickButton = AsJoystickButton(button); + Joystick.UpdateRawButtonState(asJoystickButton, value, value ? 1 : 0, sdlTimestamp, timestamp); + return; + + static JoystickButton AsJoystickButton(GamepadButton buttonIndex) => + buttonIndex switch { + GamepadButton.South => JoystickButton.ButtonDown, + GamepadButton.East => JoystickButton.ButtonRight, + GamepadButton.West => JoystickButton.ButtonLeft, + GamepadButton.North => JoystickButton.ButtonUp, + GamepadButton.Back => JoystickButton.Back, + GamepadButton.Guide => JoystickButton.Home, + GamepadButton.Start => JoystickButton.Start, + GamepadButton.LeftStick => JoystickButton.LeftStick, + GamepadButton.RightStick => JoystickButton.RightStick, + GamepadButton.LeftShoulder => JoystickButton.LeftBumper, + GamepadButton.RightShoulder => JoystickButton.RightBumper, + GamepadButton.DpadUp => JoystickButton.DPadUp, + GamepadButton.DpadDown => JoystickButton.DPadDown, + GamepadButton.DpadLeft => JoystickButton.DPadLeft, + GamepadButton.DpadRight => JoystickButton.DPadRight, + // TODO not exposed today + _ => (JoystickButton)buttonIndex + }; + } + + private readonly Dictionary _bindings = new(); + private readonly List?> _hatBindings = []; + private readonly List _outputBindings = []; + internal required ISdlEventQueue _thumbstickEvents { get; init; } + private readonly Queue _triggerEvents = new(); + + + // SDL indexes the 3 of these separately, but it is more convenient + // for us to index buttons/hats/axes as a single list. + // Since SDL only uses a single byte for a device index, + // we can safely use an integer key with a bit shift like this. + private const int _buttonShift = 0; + private const int _axisShift = 8; + + JoystickState IJoystick.State => Joystick.State; + ButtonReadOnlyList IButtonDevice.State => GamepadState.Buttons; +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/SdlJoystick.Extended.cs b/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/SdlJoystick.Extended.cs new file mode 100644 index 0000000000..5c6b570740 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/SdlJoystick.Extended.cs @@ -0,0 +1,90 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Numerics; +using System.Runtime.CompilerServices; + +namespace Silk.NET.Input.SDL3.Devices.Joysticks; + +// This partial class contains the logic for handling joystick-based device types such as SdlGamepad. +internal sealed partial class SdlJoystick +{ + public bool TryGetDevice([NotNullWhen(true)] out T? device) where T : class, ISdlJoystick + { + foreach (var d in _devices) + { + if (d is T typedDevice) + { + device = typedDevice; + return true; + } + } + + device = null; + return false; + } + + internal IReadOnlyList RawHatState => _rawHatState; + internal IReadOnlyList> RawButtonState => _rawButtonState; + internal IReadOnlyList RawAxisState => _rawAxisState; + internal void AddDeviceMapping(ISdlJoystick device) => _devices.Add(device); + internal void RemoveDeviceMapping(ISdlJoystick device) => _devices.Remove(device); + + internal void UpdateRawButtonState(JoystickButton button, bool isDown, float pressure, ulong sdlTimestamp, long timestamp) + { + var idx = button.Index(); + if (idx < 0) + { + throw new Exception("Received an invalid SDL button??"); + } + + ref var buttonState = ref _rawButtonState[idx]; + + var previous = buttonState; + + buttonState = new Button(button, isDown, pressure); + + // ReSharper disable once CompareOfFloatsByEqualityOperator + if (previous.IsDown != buttonState.IsDown || previous.Pressure != buttonState.Pressure) + { + ButtonEvents.Enqueue(new ButtonChangedEvent(this, timestamp, buttonState, previous), sdlTimestamp); + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal float GetAxisState(JoystickAxis axis) => _rawAxisState[axis.Index()]; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private float GetAxisStateByIndex(int index) => _rawAxisState[index]; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal Vector2 GetAxisStateByIndex2D(int xIndex, int yIndex) => new(GetAxisStateByIndex(xIndex), GetAxisStateByIndex(yIndex)); + + internal bool UpdateRawAxisState(JoystickAxis axis, float value, out JoystickAxisMoveEvent evt, ulong sdlTimestamp, long timestamp) + { + var index = axis.Index(); + if (index < 0) + { + throw new Exception("Received an invalid SDL axis??"); + } + + ref var state = ref _rawAxisState[index]; + var p = state; + state = value; + + var delta = value - p; + if (delta != 0) + { + evt = new JoystickAxisMoveEvent(this, timestamp, index, value, delta); + AxisEvents.Enqueue(evt, sdlTimestamp); + return true; + } + + evt = default; + return false; + } + + private readonly List _devices = []; +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/SdlJoystick.cs b/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/SdlJoystick.cs new file mode 100644 index 0000000000..cd260544ad --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/SdlJoystick.cs @@ -0,0 +1,231 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Numerics; +using System.Runtime.CompilerServices; +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3.Devices.Joysticks; + +internal sealed unsafe partial class SdlJoystick : SdlDevice, IJoystick, ISdlDevice, IOrderedDevice +{ + public JoystickState State { get; private set; } + private JoystickType _joystickType; + internal JoystickHandle JoystickHandle { get; private set; } + + public static SdlJoystick CreateDevice(ulong sdlDeviceId, SdlInputBackend backend, SilkEventContext silkEvents) + { + nint uniqueId = 0; + + var guid = backend.Sdl.GetJoystickGuidForID((uint)sdlDeviceId); + if (backend.AttemptUniqueId(new ReadOnlySpan(&guid, 16), ref uniqueId)) + { + return CreatePls(backend, uniqueId, sdlDeviceId, silkEvents); + } + + var pathPtr = backend.Sdl.GetJoystickPathForID((uint)sdlDeviceId); + if (backend.AttemptUniqueId(pathPtr, ref uniqueId)) + { + return CreatePls(backend, uniqueId, sdlDeviceId, silkEvents); + } + + var name = backend.Sdl.GetJoystickNameForID((uint)sdlDeviceId); + if (backend.AttemptUniqueId(name, ref uniqueId)) + { + return CreatePls(backend, uniqueId, sdlDeviceId, silkEvents); + } + + var type = backend.Sdl.GetJoystickTypeForID((uint)sdlDeviceId); + if (backend.AttemptUniqueId(type, ref uniqueId)) + { + return CreatePls(backend, uniqueId, sdlDeviceId, silkEvents); + } + + uniqueId = SdlInputBackend.FallbackUniqueId(sdlDeviceId, uniqueId); + return CreatePls(backend, uniqueId, sdlDeviceId, silkEvents); + + static SdlJoystick CreatePls(SdlInputBackend sdlInputBackend, nint uniqueId, ulong sdlDeviceId, + SilkEventContext context) + { + return new SdlJoystick(sdlDeviceId, uniqueId, sdlInputBackend) { + ButtonEvents = context.ButtonChangedSdlEvents, + AxisEvents = context.JoystickAxisMoveSdlEvents, + HatEvents = context.JoystickHatMoveSdlEvents + }; + } + } + + + public override string Name => NativeBackend.GetJoystickNameForID((uint)SdlDeviceId).ReadToString(); + + public override ulong SdlDeviceId + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get => SdlDeviceId; + } + + + private SdlJoystick(ulong sdlDeviceId, nint uniqueId, SdlInputBackend backend) : base(backend, uniqueId, + sdlDeviceId) + { + _sdlDeviceId = sdlDeviceId; + } + + + [Flags] + internal enum HatState : byte + { + Up = (byte)Sdl.HatUp, + Right = (byte)Sdl.HatRight, + Down = (byte)Sdl.HatDown, + Left = (byte)Sdl.HatLeft, + Centered = (byte)Sdl.HatCentered, + LeftUp = (byte)Sdl.HatLeftup, + RightUp = (byte)Sdl.HatRightup, + LeftDown = (byte)Sdl.HatLeftdown, + RightDown = (byte)Sdl.HatRightdown + } + + #region Sdl Events + + public void AddHatEvent(int hatIdx, byte hatInput, ulong sdlTimestamp, long timestamp) + { + var hatState = (HatState)hatInput; + var left = (hatState & HatState.Left) == HatState.Left; + var right = (hatState & HatState.Right) == HatState.Right; + + var x = (float)(*(byte*)&right - *(byte*)&left); + var up = (hatState & HatState.Up) == HatState.Up; + var down = (hatState & HatState.Down) == HatState.Down; + var y = (float)(*(byte*)&up - *(byte*)&down); + + ref var hatStateRef = ref _rawHatState[hatIdx]; + var previous = hatStateRef; + hatStateRef = new Vector2(x, y); + + foreach (var device in _devices) + { + device.UpdateFromJoyHat(hatIdx, hatState, sdlTimestamp, timestamp); + } + + var delta = hatStateRef - previous; + if (delta != Vector2.Zero) + { + HatEvents.Enqueue(new JoystickHatMoveEvent(this, timestamp, hatIdx, hatStateRef, delta), sdlTimestamp); + } + } + + public void AddAxisEvent(int axis, short joystickInput, ulong sdlTimestamp, long timestamp) + { + _rawAxisState[axis] = (float)(joystickInput + short.MaxValue) / ushort.MaxValue; + foreach (var device in _devices) + { + device.UpdateFromJoyAxis(axis, joystickInput, sdlTimestamp, timestamp); + } + } + + public void AddButtonEvent(byte sdlButtonId, byte sdlButtonDown, ulong sdlTimestamp, long timestamp) + { + var down = sdlButtonDown > 0; + _rawButtonState[sdlButtonId] = new Button((JoystickButton)sdlButtonId, down, down ? 1 : 0); + foreach (var device in _devices) + { + device.UpdateFromJoyButton(sdlButtonId, down, sdlTimestamp, timestamp); + } + } + + #endregion + + /// + /// Returns a "split" axis vector, taking what would be a single axis value (e.g. Left Thumbstick X) from (0, 1) + /// and splitting it into two separate axes from (0, 1) + /// + /// The axis value on a scale of 0 to 1 + /// + /// A vector representing the split axis values with
+ /// X as the 'minus' component and + /// Y as the 'plus' component + /// + /// + /// Todo: the gamepad api demands that joystick axes are (-1, 1) + /// + internal static Vector2 SplitValue(float value) + { + value = (float)((value - 0.5d) * 2d); + return value > 0 ? new Vector2(0, value) : new Vector2(value, 0); + } + + protected internal override void Initialize() + { + var joystickHandle = NativeBackend.OpenJoystick((uint)SdlDeviceId); + if (joystickHandle.Handle == null) + { + var error = NativeBackend.GetError(); + string? errorStr = null; + if (error.Native != null) + { + errorStr = error.ReadToString(); + NativeBackend.Free(error.Native); + } + + throw new Exception($"Failed to open joystick: {errorStr ?? "Unknown error."}"); + } + + // init current joystick state + var buttonCount = NativeBackend.GetNumJoystickButtons(joystickHandle); + var nowTimestamp = System.Diagnostics.Stopwatch.GetTimestamp(); + var nowSdlTimestamp = NativeBackend.GetTicks(); + for (byte i = 0; i < buttonCount; i++) + { + var joystickInput = NativeBackend.GetJoystickButtonRaw(JoystickHandle, i); + AddButtonEvent(i, joystickInput, nowSdlTimestamp, nowTimestamp); + } + + var axisCount = NativeBackend.GetNumJoystickAxes(joystickHandle); + for (var i = 0; i < axisCount; i++) + { + var joystickInput = NativeBackend.GetJoystickAxis(JoystickHandle, i); + if (joystickInput == 0) + { + // this indicates an sdl error, so just set our internal axis to 0 + joystickInput = short.MinValue; + } + + AddAxisEvent(i, joystickInput, nowSdlTimestamp, nowTimestamp); + } + + var hatCount = NativeBackend.GetNumJoystickHats(joystickHandle); + for (var i = 0; i < hatCount; ++i) + { + var hatInput = NativeBackend.GetJoystickHat(joystickHandle, i); + AddHatEvent(i, hatInput, nowSdlTimestamp, nowTimestamp); + } + + JoystickHandle = joystickHandle; + _joystickType = NativeBackend.GetJoystickType(joystickHandle); + _rawAxisState = new float[EnumInfo.UniqueValues.Count + axisCount]; + _rawButtonState = new Button[EnumInfo.UniqueValues.Count + buttonCount]; + State = new JoystickState(_rawAxisState, _rawButtonState, _rawHatState); + } + + protected override void Release() => NativeBackend.CloseJoystick(JoystickHandle); + + + public void RefreshSdlId() => _sdlDeviceId = NativeBackend.GetJoystickID(JoystickHandle); + private ulong _sdlDeviceId; + + // State + private Button[] _rawButtonState; + private float[] _rawAxisState; + private Vector2[] _rawHatState = []; + + // Constants + internal const short DigitalThreshold = short.MaxValue / 8; + + // events + internal required ISdlEventQueue> ButtonEvents { get; init; } + internal required ISdlEventQueue AxisEvents { get; init; } + internal required ISdlEventQueue HatEvents { get; init; } + + ButtonReadOnlyList IButtonDevice.State => State.Buttons; +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/SdlRumble.cs b/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/SdlRumble.cs new file mode 100644 index 0000000000..c3fcee7a76 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/Joysticks/SdlRumble.cs @@ -0,0 +1,136 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections; +using System.Runtime.CompilerServices; +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3.Devices.Joysticks; + +internal unsafe class SdlRumble : IReadOnlyList +{ + public IMotor this[int index] => _motors[index]; + public int Count => _motors.Length; + + public static SdlRumble Create(void* handle, ISdl sdl, int count) where T : unmanaged + { + SetRumbleDelegate setRumble; + if (typeof(T) == typeof(GamepadHandle)) + { + setRumble = SetGamepadRumble; + } + else if (typeof(T) == typeof(JoystickHandle)) + { + setRumble = SetJoystickRumble; + } + else + { + throw new InvalidOperationException("Invalid device type"); + } + + return new SdlRumble(handle, sdl, count, setRumble); + } + + private SdlRumble(void* handle, ISdl nativeBackend, int count, SetRumbleDelegate setRumble) + { + _setRumble = setRumble; + _handle = handle; + _motors = new IMotor[count]; + _motorFrequencies = new ushort[count]; + _nativeBackend = nativeBackend; + CreateMotors(_motors); + } + + private void CreateMotors(IMotor[] motors) + { + for (var i = 0; i < motors.Length; i++) + { + motors[i] = new Motor(this, i); + } + } + + IEnumerator IEnumerable.GetEnumerator() => (IEnumerator)_motors.GetEnumerator(); + IEnumerator IEnumerable.GetEnumerator() => _motors.GetEnumerator(); + + private float GetRumble01(int motor) => _motorFrequencies[motor] * _toFloat; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private void SetRumble01(int motor, float value) => + SetRumble01(motor, (ushort)(value * ushort.MaxValue), _motorFrequencies); + + private void SetRumble01(int motor, ushort value, ushort[] motorFrequencies) + { + // todo - use Haptics API instead? + // todo - dispatch this to the correct input thread + + // TODO this entire API needs to be redesigned as right now this is literally only ever going to be useful if it's + // just left or right. The original intention was that this would be useful for things like 3D haptics, but what did + // I know. The SDL people seem to have done a good job with their haptic API, let's see what we can do with it. + // For now, this has the same implementation as it always has. + var valueShort = value; + motorFrequencies[motor] = valueShort; + var left = motorFrequencies[0]; + var right = motorFrequencies[1]; + _setRumble(_nativeBackend, _handle, left, right); + } + + private static void SetJoystickRumble(ISdl backend, void* handle, ushort left, ushort right) + { + var average = (ushort)((left + right) >> 2); + var joystickHandle = *(JoystickHandle*)&handle; + if (!backend.RumbleJoystick(joystickHandle, average, average, _durationMs)) + { + backend.ThrowError(); + } + + if (!backend.RumbleJoystickTriggers(joystickHandle, left, right, _durationMs)) + { + backend.ThrowError(); + } + } + + private static void SetGamepadRumble(ISdl backend, void* handle, ushort left, ushort right) + { + var average = (ushort)((left + right) >> 2); + var gamepadHandle = *(GamepadHandle*)&handle; + if (!backend.RumbleGamepad(gamepadHandle, average, average, _durationMs)) + { + backend.ThrowError(); + } + + if (!backend.RumbleGamepadTriggers(gamepadHandle, left, right, _durationMs)) + { + backend.ThrowError(); + } + } + + private readonly SetRumbleDelegate _setRumble; + private readonly void* _handle; + private readonly IMotor[] _motors; + private readonly ushort[] _motorFrequencies; + private readonly ISdl _nativeBackend; + private const float _toFloat = 1f / ushort.MaxValue; + private const uint _durationMs = uint.MaxValue; + + + private delegate void SetRumbleDelegate(ISdl nativeBackend, void* handle, ushort left, ushort right); + + private class Motor : IMotor + { + private readonly int _freqIndex; + private readonly SdlRumble _rumbler; + + public Motor(SdlRumble rumbler, int freqIdx) + { + _freqIndex = freqIdx; + _rumbler = rumbler; + } + + public float Speed + { + get => _rumbler.GetRumble01(_freqIndex); + set => _rumbler.SetRumble01(_freqIndex, value); + } + } +} + diff --git a/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlCursor.cs b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlCursor.cs new file mode 100644 index 0000000000..486b016409 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlCursor.cs @@ -0,0 +1,295 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Frozen; +using System.Runtime.InteropServices; +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3.Devices.Pointers; + +internal unsafe class SdlCursor : ICursorConfiguration, IDisposable +{ + private readonly ISdl _sdl; + + private CursorHandle _handle; + + /// + /// Internal style of the current cursor handle - may differ from the property, + /// + private CursorStyles _handleStyle = _noStyle; + private const CursorStyles _noStyle = (CursorStyles)(-1); + + private static readonly FrozenDictionary _cursorStyles = + new Dictionary { + [CursorStyles.Default] = SystemCursor.Default, + [CursorStyles.Arrow] = SystemCursor.Default, + [CursorStyles.IBeam] = SystemCursor.Text, + [CursorStyles.Crosshair] = SystemCursor.Crosshair, + [CursorStyles.Hand] = SystemCursor.Pointer, + [CursorStyles.HResize] = SystemCursor.EwResize, + [CursorStyles.VResize] = SystemCursor.NsResize + }.ToFrozenDictionary(); + + + public SdlCursor(ISdl sdl) + { + _sdl = sdl; + Mode = CursorModes.Normal; + SupportedStyles = TestCursorCompatibility(sdl); + Style = CursorStyles.Arrow; + } + + private bool SetCursorStyle(CursorStyles style) + { + CursorHandle handle; + if (style == CursorStyles.Custom) + { + if (_customCursorImage == null || _customCursorSurface == null) + { + return false; + } + + var canReuseCurrentCursorHandle = _handleStyle == CursorStyles.Custom; // todo - compare cursor hotspot + if (canReuseCurrentCursorHandle) + { + return true; + } + + // todo: cursor hotspot, not supported by sdl? + handle = _sdl.CreateColorCursor(_customCursorSurface, 0, 0); + } + else if (style == _handleStyle) + { + return true; + } + else + { + handle = _sdl.CreateSystemCursor(_cursorStyles[style]); + } + + if (handle.Handle == null) + { + SdlLog.Error("Failed to create cursor"); + return false; + } + + if (_handle != handle) + { + FreeCurrentCursor(); + } + + _handle = handle; + _handleStyle = style; + + if (_sdl.SetCursor(_handle)) + { + return true; + } + + SdlLog.Error("Failed to set cursor"); + return false; + } + + public void Dispose() + { + FreeCurrentCursor(); + DisposeCursorSurface(ref _customCursorSurface); + } + + private void FreeCurrentCursor() + { + if (_handle == default) + { + return; + } + + _sdl.DestroyCursor(_handle); + _handle = default; + + if (_handleStyle == CursorStyles.Custom) + { + DisposeCursorSurface(ref _customCursorSurface); + } + + _handleStyle = _noStyle; + } + + private void DisposeCursorSurface(ref Surface* surface) + { + if(surface != null) + { + _sdl.DestroySurface(surface); + _customCursorSurface = null; + } + } + + private static CursorStyles TestCursorCompatibility(ISdl sdl) + { + // check cursor style availability + ReadOnlySpan mainStyles = [ + CursorStyles.Arrow, CursorStyles.IBeam, CursorStyles.Crosshair, CursorStyles.Hand, CursorStyles.HResize, + CursorStyles.VResize + ]; + + // todo: is it necessary to check for the Default style? can some platforms just not support any cursor? + // if so, the result of this evaluation will still report that "Default" is available.. + // lest we make it nullable... nah i'll leave it to the Sdl gods for now + var successfulStyles = CursorStyles.Default; + for (var i = 0; i < mainStyles.Length; i++) + { + var cursorStyle = mainStyles[i]; + var sdlStyle = _cursorStyles[cursorStyle]; + var cursor = sdl.CreateSystemCursor(sdlStyle); + if (cursor.Handle == null) + { + SdlLog.Debug($"System cursor style {sdlStyle} unavailable"); + } + else + { + successfulStyles |= cursorStyle; + sdl.Free(cursor.Handle); + } + } + + return successfulStyles; + } + + public CursorModes SupportedModes => + CursorModes.Normal | CursorModes.Confined | CursorModes.Unbounded; + + public CursorModes Mode + { + get; + set + { + field = value; + try + { + ModeChanged?.Invoke(this, value); + } + catch (Exception e) + { + InputLog.Error(e.ToString()); + } + } + } + + public event EventHandler? ModeChanged; + + public CursorStyles SupportedStyles { get; } + + public CursorStyles Style + { + get; + set + { + if (value == CursorStyles.Hidden && field != CursorStyles.Hidden) + { + SetCursorVisibility(false); + return; + } + + SetCursorStyle(value); + if(field == CursorStyles.Hidden) + { + SetCursorVisibility(true); + } + + field = value; + } + } + + private void SetCursorVisibility(bool visible) + { + if (_handle == default) + { + return; + } + + if (visible ? _sdl.HideCursor() : _sdl.ShowCursor()) + { + return; + } + + SdlLog.Error("Failed to hide cursor"); + } + + public CustomCursor Image + { + get + { + var byteCount = _customCursorWidth * _customCursorHeight * 4; + var myBytes = _customCursorImage.AsSpan(..byteCount); + var asInts = MemoryMarshal.Cast(myBytes); + return new CustomCursor { Width = _customCursorWidth, Height = _customCursorHeight, Data = asInts }; + } + set + { + var necessaryLength = value.Width * value.Height; + if(value.Data.Length < necessaryLength) + { + throw new ArgumentException($"Custom cursor image of size ({value.Width}, {value.Height}) " + + $"must be at least {value.Width * value.Height * 4} bytes long, " + + $"got {value.Data.Length} bytes instead"); + } + + // ensure we have a fixed byte array to work with so updates would automatically apply to sdl + _customCursorHeight = value.Height; + _customCursorWidth = value.Width; + var byteCount = necessaryLength * 4; + if (_customCursorImage is null || _customCursorImage.Length < byteCount) + { + _customCursorImage = GC.AllocateUninitializedArray(byteCount, pinned: true); + } + + // copy the user data to our fixed array + var myBytes = _customCursorImage.AsSpan(..byteCount); + var providedBytes = MemoryMarshal.Cast(value.Data); + providedBytes.CopyTo(myBytes); + + ApplyToCursorSurface(ref _customCursorSurface, value); + + if (Style == CursorStyles.Custom && _handleStyle != CursorStyles.Custom) + { + SetCursorStyle(CursorStyles.Custom); + } + + return; + + void ApplyToCursorSurface(ref Surface* customCursorSurface, in CustomCursor val) + { + // create a new sdl surface if necessary + if(customCursorSurface != null) + { + if (customCursorSurface->H != val.Height || customCursorSurface->W != val.Width) + { + DisposeCursorSurface(ref customCursorSurface); + customCursorSurface = CreateSurface(val); + } + } + else + { + customCursorSurface = _sdl.CreateSurface(val.Width, val.Height, PixelFormat.Argb8888); + } + + // ensure the surface's pixel data is our fixed array + fixed (byte* ptr = _customCursorImage) + { + customCursorSurface->Pixels = ptr; + } + + return; + + Ptr CreateSurface(CustomCursor customCursor) + { + return _sdl.CreateSurface(customCursor.Width, customCursor.Height, PixelFormat.Argb8888); + } + } + } + } + + private Surface* _customCursorSurface; + private int _customCursorHeight, _customCursorWidth; + private byte[]? _customCursorImage; + +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlMouse.cs b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlMouse.cs new file mode 100644 index 0000000000..432b91ff7d --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlMouse.cs @@ -0,0 +1,233 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Numerics; +using System.Runtime.CompilerServices; +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3.Devices.Pointers; + +internal sealed class SdlMouse : SdlPointerDevice, IMouse, ISdlDevice +{ + public override PointerState State => _state; + public ICursorConfiguration Cursor { get; } + + private readonly MouseState _state; + + // the mouse is always considered "down" - there is no up/down state for the mouse pointer itself - only its buttons. + private const bool DownState = true; + + private SdlMouse(ulong sdlDeviceId, nint uniqueId, SdlInputBackend backend, IPointerTarget unboundedPointerTarget, + ICursorConfiguration cursor) + : base(backend, uniqueId, sdlDeviceId, unboundedPointerTarget) + { + _state = new MouseState(Buttons, Points, Vector2.Zero); + Cursor = cursor; + } + + protected internal override void Initialize() + { + float x = 0, y = 0; + var nowSdl = NativeBackend.GetTicks(); + var now = Stopwatch.GetTimestamp(); + var mouseInputFlags = GetMouseState(ref x, ref y); + ApplyMouseButtonState(mouseInputFlags, nowSdl, now); + + var window = NativeBackend.GetMouseFocus(); + uint windowId; + if (window == nullptr) + { + windowId = 0; + } + else + { + windowId = NativeBackend.GetWindowID(window); + if (windowId == 0) + { + SdlLog.Error("Mouse has no window"); + } + } + + + // var pressure = _state.Buttons[PointerButton.Primary].Pressure; + AddOrUpdatePoint(null, windowId, new Vector3(x, y, 0), null, DownState, null, true, nowSdl, now); + // var point = _unboundedPointerTarget.GetPoint(this, 0); + } + + + private void ApplyMouseButtonState(SdlMouseInputFlags mouseState, ulong nowSdl, long now) + { + foreach (var pointerButtonName in EnumInfo.UniqueValues) + { + if (mouseState.Has(pointerButtonName)) + { + AddButtonEvent(pointerButtonName, now, nowSdl, true); + } + } + } + + private unsafe SdlMouseInputFlags GetMouseState(ref float x, ref float y) => + (SdlMouseInputFlags)NativeBackend.GetMouseState((float*)Unsafe.AsPointer(ref x), + (float*)Unsafe.AsPointer(ref y)); + + public static SdlMouse CreateDevice(ulong sdlDeviceId, SdlInputBackend backend, SilkEventContext silkEvents) + { + var deviceName = backend.Sdl.GetMouseNameForID((uint)sdlDeviceId); + nint uniqueId = 0; + if (!backend.AttemptUniqueId(deviceName, ref uniqueId)) + { + uniqueId = SdlInputBackend.FallbackUniqueId(sdlDeviceId, uniqueId); + } + + var mouse = + new SdlMouse(sdlDeviceId, uniqueId, backend, backend.UnboundedPointerTarget, backend.CursorConfiguration) { + ScrollEvents = silkEvents.MouseScrollSdlEvents, + PointEvents = silkEvents.PointChangedSdlEvents, + ClickEvents = silkEvents.PointerClickSdlEvents, + ButtonEvents = silkEvents.PointerButtonSdlEvents, + GripEvents = silkEvents.PointerGripChangedSdlEvents, + TargetEvents = silkEvents.PointerTargetChangedSdlEvents + }; + + return mouse; + } + + public override string Name => NativeBackend.GetMouseNameForID((uint)SdlDeviceId).ReadToString(); + + protected override void Release() + { + } + + MouseState IMouse.State => _state; + + // todo (maybe): pair with simulated touch device if simulated touch events occur + // though, we can probably only pair if there is *one* mouse - multiple mice + // would make it difficult to pair, as simulated touch input does not specify the mouse + // it comes from + public int? TouchId { get; private set; } + + private bool IsMouseRelative + { + get + { + //var focus = NativeBackend.GetMouseFocus(); + if (!Backend.TryGetWindowHandles(out var windows)) + { + return false; + } + + var isRelative = false; + + for (var i = 0; i < windows.Count; i++) + { + isRelative |= NativeBackend.GetWindowRelativeMouseMode(windows[i]); + } + + windows.Dispose(); + return isRelative; + } + } + + protected override bool OnePointOnly => true; + private bool _hintsAsEvents = false; + + + /// + /// + /// + /// The window-relative position of the mouse + /// True if success, but see the below remarks + /// + /// todo: this is the most straightforward way to do window-relative movement, + /// but we don't actually get any information about whether or not + /// it succeeds. The SDL documentation seems to suggest that it "just works" as opposed to their global mouse warp + /// method, which provides a success result. instead of translating this "global" position to a window-specific one, + /// we're gonna use SDL's implementation of window-relative movement to keep things simple.

+ /// As a result, we always return true, though the documentation suggests that it does not work specifically for + /// Microsoft Remote Desktop. not sure how to detect that at the moment.

+ /// Another consequence of doing it this way is that we need to wait for SDL to push these events through the event + /// queue, so while this may return 'true', this mouse object will not necessarily be in the correct position until + /// the next time pumped events are processed.

+ /// We could just create a mouse motion event and push it through our internal event queues, bypassing SDL's event + /// queue, but that could result in a situation where we set our internal state to represent the + /// movement, even though SDL did not meaningfully succeed.

+ /// The best way around this would probably be to try global mouse warping with translated coordinates, + /// and if that fails, fall back to window-relative movement. + /// + public bool TrySetPosition(Vector2 position) + { + // make sure we get pumped mouse events for setting the position this way + if (!_hintsAsEvents) + { + var currentHintVal = NativeBackend.GetHintBoolean(Sdl.HintMouseRelativeWarpMotion, new MaybeBool(0)); + if (currentHintVal == 0) + { + sbyte hintVal = 1; + if (NativeBackend.SetHint(Sdl.HintMouseRelativeWarpMotion, new Ref(ref hintVal))) + { + _hintsAsEvents = true; + } + } + else + { + _hintsAsEvents = true; + } + } + + // providing a null window handle means that SDL will use the latest position + NativeBackend.WarpMouseInWindow(default, position.X, position.Y); + NeedsPump = true; // we should "pump" events immediately, but this isn't a good place to do it. + return true; + } + + /// + /// A user has attempted to modify the hardware mouse position - we need a pump to process these events. + /// + public bool NeedsPump { get; private set; } + + public void AddMotion(in MouseMotionEvent evtMotion, long timestamp) => + AddOrUpdatePoint(null, evtMotion.WindowID, new Vector3(evtMotion.X, evtMotion.Y, 0), 1, null, null, + evtMotion.WindowID != 0, evtMotion.Timestamp, timestamp); + + + public void AddButtonEvent(in MouseButtonEvent evtButton, long timestamp) + { + var button = evtButton.Button switch { + 1 => PointerButton.Primary, + 2 => PointerButton.MiddleButton, + 3 => PointerButton.Secondary, + 4 => PointerButton.Button4, + 5 => PointerButton.Button5, + _ => throw new ArgumentOutOfRangeException(nameof(evtButton.Button), evtButton.Button, null) + }; + //var button = PointerButton.Primary + (evtButton.Button - 1); + const float mult = 1 / 255f; + AddButtonEvent(button, timestamp, evtButton.Timestamp, evtButton.Down > 0, evtButton.Down * mult); + } + + public void AddWheelEvent(in MouseWheelEvent evtWheel, long timestamp) + { + var pWheelPosition = _state.WheelPosition; + const float max = 100f; + var delta = new Vector2(evtWheel.X, evtWheel.Y); + if (delta.X != 0 && pWheelPosition.X is > max or < -max) + { + pWheelPosition.X = 0; + } + + if (delta.Y != 0 && pWheelPosition.Y is > max or < -max) + { + pWheelPosition.Y = 0; + } + + AddMouseScrollEvent( + scrollWheelPosition: _state.WheelPosition = pWheelPosition + delta, + scrollWheelDelta: delta, + windowId: evtWheel.WindowID, + sdlTimestamp: evtWheel.Timestamp, + mousePos: new Vector3(evtWheel.X, evtWheel.Y, 0), + timestamp: timestamp); + } + +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlPen.cs b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlPen.cs new file mode 100644 index 0000000000..7ffdf1e3c5 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlPen.cs @@ -0,0 +1,184 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Numerics; +using System.Runtime.CompilerServices; +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3.Devices.Pointers; + +internal class SdlPen : SdlPointerDevice, ISdlDevice +{ + public SdlPen(SdlInputBackend backend, nint silkId, ulong sdlDeviceId, string name, IPointerTarget unbounded) : + base(backend, silkId, sdlDeviceId, unbounded) + { + Name = name; + State = new PointerState(Buttons, Points); + } + + public static SdlPen CreateDevice(ulong sdlDeviceId, SdlInputBackend backend, SilkEventContext silkEvents) + { + nint uniqueId = 0; + + var name = backend.Sdl.GetTouchDeviceName(sdlDeviceId); + if (name == nullptr) + { + SdlLog.Error("Failed to get pen name"); + } + + if (backend.AttemptUniqueId(name, ref uniqueId)) + { + return Create(); + } + + if (backend.AttemptUniqueId(name, ref uniqueId)) + { + return Create(); + } + + if (backend.AttemptUniqueId(sdlDeviceId, ref uniqueId)) + { + return Create(); + } + + uniqueId = SdlInputBackend.FallbackUniqueId(sdlDeviceId, uniqueId); + return Create(); + + + SdlPen Create() + { + return new SdlPen(backend, uniqueId, sdlDeviceId, name.ReadToString(), backend.UnboundedPointerTarget) { + ScrollEvents = silkEvents.MouseScrollSdlEvents, + PointEvents = silkEvents.PointChangedSdlEvents, + ClickEvents = silkEvents.PointerClickSdlEvents, + ButtonEvents = silkEvents.PointerButtonSdlEvents, + GripEvents = silkEvents.PointerGripChangedSdlEvents, + TargetEvents = silkEvents.PointerTargetChangedSdlEvents + }; + } + } + + public override PointerState State + { + get; + } + + protected override bool OnePointOnly => true; + + public override string Name + { + get; + } + + protected internal override void Initialize() + { + // todo ? + } + + protected override void Release() + { + } + + public void UpDownEvent(in PenTouchEvent evt, long timestamp) + { + MotionEvent(evt.WindowID, evt.X, evt.Y, evt.Timestamp, timestamp); + + if (evt.Down > 0) + { + const float divisor = 1f / 255f; + var downPressure = evt.Down * divisor; + AddButtonEvent(PointerButton.Primary, timestamp, evt.Timestamp, true, downPressure); + } + else + { + AddButtonEvent(PointerButton.Primary, timestamp, evt.Timestamp, false, 0); + } + } + + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void MotionEvent(in PenMotionEvent evt, long timestamp) => MotionEvent(evt.WindowID, evt.X, evt.Y, evt.Timestamp, timestamp); + + private void MotionEvent(in uint windowId, float x, float y, ulong sdlTimestamp, long timestamp) => + AddOrUpdatePoint( + touchId: null, + windowId: windowId == 0 ? null : windowId, + pos: new Vector3(x, y, 0), + pressure: null, + isDown: null, + ray: null, + isPositionInWindowSpace: true, + sdlTimestamp: sdlTimestamp, + timestamp: timestamp); + + public void ButtonEvent(in PenButtonEvent evt, long timestamp) + { + var button = (SdlPenButton)evt.Button; + var pointerButton = button switch { + SdlPenButton.Button1 => PointerButton.Primary, + SdlPenButton.Button2 => PointerButton.Secondary, + SdlPenButton.Button3 => PointerButton.MiddleButton, + SdlPenButton.Button4 => PointerButton.Button4, + SdlPenButton.Button5 => PointerButton.Button5, + _ => throw new ArgumentOutOfRangeException(nameof(button), button, null) + }; + + AddButtonEvent(pointerButton, timestamp, evt.Timestamp, evt.Down > 0, evt.Down / 255f); + } + + private enum SdlPenButton : byte + { + Button1 = 1, + Button2, + Button3, + Button4, + Button5, + } + + public void AxisEvent(in PenAxisEvent evt, long timestamp) + { + switch (evt.Axis) + { + case PenAxis.Pressure: + { + AddOrUpdatePoint(null, null, new Vector3(evt.X, evt.Y, 0), evt.Value, null, null, true, evt.Timestamp, timestamp); + break; + } + case PenAxis.Xtilt: + { + UpdatePointRay(null, evt.Value, null, null, distance: null, evt.Timestamp, timestamp); + break; + } + case PenAxis.Ytilt: + { + UpdatePointRay(null, null, evt.Value, null, distance: null, evt.Timestamp, timestamp); + break; + } + case PenAxis.Distance: + { + UpdatePointRay(null, null, null, null, distance: evt.Value, evt.Timestamp, timestamp); + break; + } + case PenAxis.Rotation: // barrel rotation + { + UpdatePointRay(null, null, null, evt.Value, distance: null, evt.Timestamp, timestamp); + break; + } + case PenAxis.Slider: + { + // additional "button" or additional "axis" or "pressure"? + // SetPointSlider(0, evt.Value); + break; + } + case PenAxis.TangentialPressure: + { + SetGripPressure(evt.Value, evt.Timestamp, timestamp); + break; + } + default: + { + return; + } + } + } +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlPointerDevice.cs b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlPointerDevice.cs new file mode 100644 index 0000000000..0f1970c400 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlPointerDevice.cs @@ -0,0 +1,379 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Numerics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using Silk.NET.Maths; + +namespace Silk.NET.Input.SDL3.Devices.Pointers; + +/// +/// A base class for SDL input devices that operate in terms of a window's or DWMs bounds. +/// +internal abstract class SdlPointerDevice : SdlDevice, IPointerDevice, INeedFinalizationEachFrame +{ + protected SdlPointerDevice(SdlInputBackend backend, nint silkId, + ulong sdlDeviceId, IPointerTarget unboundedPointerTarget) : base(backend, silkId, sdlDeviceId) + { + _unboundedPointerTarget = unboundedPointerTarget; + _unboundedTargetList = [unboundedPointerTarget]; + _allTargets.AddRange(_unboundedTargetList); + for (var i = 0; i < EnumInfo.UniqueValues.Count; i++) + { + var button = EnumInfo.UniqueValues[i]; + _buttons.Add(new Button(button, false, 0f)); + } + } + + protected void AddButtonEvent(PointerButton button, long timestamp, ulong sdlTimestamp, bool isDown, + float? pressure = null) + { + pressure ??= isDown ? 1.0f : 0.0f; + var idx = EnumInfo.ValueIndexOfUnnamed(button); + + while (idx >= _buttons.Count) + { + _buttons.Add(_unknownButton); + } + + ref var myButton = ref CollectionsMarshal.AsSpan(_buttons)[idx]; + var original = myButton; + myButton = new Button(button, isDown, pressure.Value); + + if (myButton != original) + { + ButtonEvents.Enqueue(new ButtonChangedEvent(this, timestamp, myButton, original), + sdlTimestamp); + } + } + + private static readonly Button _unknownButton = new(PointerButton.Unknown, false, 0f); + + + private readonly List> _buttons = new(EnumInfo.UniqueValues.Count); + protected ButtonReadOnlyList Buttons => new(_buttons); + protected InputReadOnlyList Points => new(_points); + private readonly List _points = []; + + public abstract PointerState State { get; } + + public IReadOnlyList Targets => _allTargets; + + /// + /// True if the device only supports one point - e.g., a mouse.
+ /// False otherwise - e.g., a multitouch screen. + /// + protected abstract bool OnePointOnly { get; } + + public void FinalizeUpdate() + { + RepopulateActiveTargets(); + + return; + + void RepopulateActiveTargets() + { + // todo - optimize target collection population + _activeTargets.Clear(); + foreach (var point in _points) + { + if (!_activeTargets.Contains(point.Target!)) + { + _activeTargets.Add(point.Target!); + if (!_allTargets.Contains(point.Target!)) + { + _allTargets.Add(point.Target!); + } + } + } + } + } + + private unsafe ref TargetPoint CreateOrUpdateTargetPoint(IPointerTarget target, uint touchId, + in Vector3? positionOnTarget, + Ray3D? ray, float? pressure, out TargetPoint? oldPoint) + { + if (touchId != 0 && OnePointOnly) + { + throw new InvalidOperationException( + "A single-point device cannot have multiple points per-target, so the " + + "provided touchId must be 0."); + } + + Debug.Assert(target != null, "The target must be non-null for a valid point."); + + target ??= _unboundedPointerTarget; + + int? pointIndex = null; + int? defaultIndex = null; + + for (var i = 0; i < _points.Count; i++) + { + var candidatePoint = GetPointRef(i); + if (candidatePoint.Target == target && candidatePoint.Id == touchId) + { + pointIndex = i; + break; + } + + if (defaultIndex is null && candidatePoint == default) + { + defaultIndex = i; + } + } + + bool isNewPoint; + if (pointIndex == null) + { + pointIndex = defaultIndex ?? _points.Count; + isNewPoint = true; + } + else + { + isNewPoint = false; + } + + ref var point = ref GetPointRef(pointIndex.Value); + + // note: a null oldPoint means this is a new point + // see PointChangedEvent for more info + oldPoint = isNewPoint ? null : point; + + point = ToTargetPoint( + windowTarget: target, + touchId: *(int*)&touchId, + posOnTarget: positionOnTarget ?? point.Position, + pressure: pressure ?? point.Pressure, + + // if a ray is provided, use it. otherwise, if it's a new point, use the default ray. + // if it's a pre-existing point, use the existing ray. + ray: ray ?? (isNewPoint + ? new Ray3D(origin: Vector3D.Zero, direction: Vector3D.UnitZ) + : point.Pointer)); + + return ref point; + } + + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static Ray3D ConstructRay(in Vector3D origin, Vector3D? direction = null) => + new(origin, direction ?? Vector3D.UnitZ); + + /// + /// Adds or updates a point. + /// + /// Touch id. Must be null for single-point-only devices (e.g. a mouse) + /// The window id the touch applies to + /// The touch position. Set null if it has not changed + /// The pressure, set null if it has not changed + /// "Down" status. Set null if has not changed + /// The ray - set null if has not changed or is simply computed in 2D without extra calculation + /// True if the provided position (if present) is relative to the given window id + /// + /// + /// + protected void AddOrUpdatePoint(uint? touchId, uint? windowId, in Vector3? pos, float? pressure, bool? isDown, + Ray3D? ray, bool isPositionInWindowSpace, ulong sdlTimestamp, long timestamp) + { + if (pos == null && pressure == null && isDown == null && ray == null) + { + throw new InvalidOperationException("At least one parameter must have a value"); + } + + GetPointIdentifiers(ref touchId, windowId ?? _previousWindowId, out var windowTarget); + + if (pos != null) + { + if (windowId == null && isPositionInWindowSpace) + { + throw new InvalidOperationException("WindowId must be specified if position is in window space"); + } + + if (!isPositionInWindowSpace) + { + throw new NotImplementedException("Non-window space positions are not yet supported."); + } + } + + ref var point = + ref CreateOrUpdateTargetPoint(windowTarget, touchId.Value, pos, ray, pressure, out var oldPoint); + + PointEvents.Enqueue(new PointChangedEvent(this, timestamp, OldPoint: oldPoint, + NewPoint: point), sdlTimestamp); + + if (isDown is false) + { + // point was actually removed - after that point changed event, we should remove it + // note - a null newPoint means the point was removed + var previous = point; + for (int i = 0; i < _points.Count; i++) + { + ref var candidatePoint = ref GetPointRef(i); + if (candidatePoint.Id == previous.Id) + { + candidatePoint = default; + } + } + + PointEvents.Enqueue(new PointChangedEvent(this, timestamp, OldPoint: previous, + NewPoint: point), sdlTimestamp); + } + + if (windowId != null && windowId.Value != _previousWindowId) + { +#if DEBUG + if (_previousWindowId != windowId) + { + InputLog.Warn($"Pointer window changed from {_previousWindowId} to {windowId}"); + } +#endif + _previousWindowId = windowId.Value; + } + } + + private void GetPointIdentifiers([NotNull] ref uint? touchId, [DisallowNull] uint? windowId, + out IPointerTarget windowTarget) + { + touchId = ValidateTouchId(touchId); + var success = Backend.TryGetPointerTargetForWindow(windowId.Value, out windowTarget!); + Debug.Assert(success, "No pointer target found for window id {windowId} - this should never happen."); + + return; + + uint ValidateTouchId(uint? touchId) + { + if (OnePointOnly) + { + return touchId != null + ? throw new InvalidOperationException( + "A single-point device cannot have a touchId - it must be null.") + : 0u; + } + + return touchId ?? throw new ArgumentNullException($"TouchId cannot be null for device {this}."); + } + } + + + /// + /// Creates a target point + /// + /// Position projected to target-space + /// Touch/etc point pressure + /// If null, will be considered unbounded + /// The unique ID of the touch/pointer point, persisting through its lifetime + /// A ray that determines the final point on the target + private TargetPoint ToTargetPoint(in Vector3 posOnTarget, float pressure, IPointerTarget? windowTarget, int touchId, + Ray3D ray) + { + var hasTarget = windowTarget is not null; + var flags = hasTarget ? TargetPointFlags.PointingAtTarget : TargetPointFlags.NotPointingAtTarget; + + Vector3 normalizedPositionOnTarget; + + if (hasTarget && windowTarget != _unboundedPointerTarget) + { + var bounds = windowTarget!.Bounds; + var min = bounds.Min.ToSystem(); + normalizedPositionOnTarget = (posOnTarget - min) / (bounds.Max.ToSystem() - min); + } + else + { + normalizedPositionOnTarget = default; + } + + return new TargetPoint(touchId, + Flags: flags, + Position: posOnTarget, + NormalizedPosition: normalizedPositionOnTarget, + Pointer: ray, + Pressure: pressure, + Target: windowTarget + ); + } + + protected void AddMouseScrollEvent(Vector2 scrollWheelPosition, Vector2 scrollWheelDelta, Vector3 mousePos, uint? windowId, ulong sdlTimestamp, long timestamp) + { + if (this is not IMouse mouse) + { + throw new InvalidOperationException("This device does not support scrolling."); + } + + uint? touchId = null; + GetPointIdentifiers(ref touchId, windowId ?? _previousWindowId, out var windowTarget); + + ref var point = ref CreateOrUpdateTargetPoint(windowTarget, touchId.Value, mousePos, null, null, out _); + + ScrollEvents.Enqueue(new MouseScrollEvent( + Mouse: mouse, + Timestamp: timestamp, + Point: point, + WheelPosition: scrollWheelPosition, + Delta: scrollWheelDelta), sdlTimestamp); + + } + + protected void UpdatePointRay(uint? touchId, float? xTilt, float? yTilt, float? zTwist, float? distance, + ulong sdlTimestamp, long timestamp) + { + if (xTilt == null && yTilt == null && zTwist == null && distance == null) + { + throw new InvalidOperationException("At least one parameter must have a value"); + } + + GetPointIdentifiers(ref touchId, _previousWindowId, out var windowTarget); + + ref var point = ref CreateOrUpdateTargetPoint(windowTarget, touchId.Value, null, null, null, out var oldPoint); + var ray = point.Pointer; + xTilt ??= ray.Direction.X; + yTilt ??= ray.Direction.Y; + zTwist ??= ray.Direction.Z; + distance ??= ray.Origin.Z; + + point = point with { + Pointer = new Ray3D( + origin: ray.Origin with { Z = distance.Value }, + direction: new Vector3D(xTilt.Value, yTilt.Value, zTwist.Value)) + }; + + PointEvents.Enqueue(new PointChangedEvent(this, timestamp, OldPoint: oldPoint, + NewPoint: point), sdlTimestamp); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + protected void SetGripPressure(float pressure, ulong sdlTimestamp, long timestamp) + { + // todo - use only the given events to update the state? is that possible? keyboard character input would probably be a problem.. + State.GripPressure = pressure; + GripEvents.Enqueue(new PointerGripChangedEvent(this, timestamp, pressure, pressure - State.GripPressure), + sdlTimestamp); + } + + + private ref TargetPoint GetPointRef(int index) + { + _points.EnsureCapacity(index + 1); + while (index >= _points.Count) + { + _points.Add(default); + } + + return ref CollectionsMarshal.AsSpan(_points)[index]; + } + + private uint _previousWindowId; + private readonly List _activeTargets = []; + private readonly List _allTargets = []; + private readonly IPointerTarget _unboundedPointerTarget; + private readonly IReadOnlyList _unboundedTargetList; + + internal required ISdlEventQueue ScrollEvents { private get; init; } + internal required ISdlEventQueue PointEvents { private get; init; } + internal required ISdlEventQueue ClickEvents { private get; init; } + internal required ISdlEventQueue> ButtonEvents { private get; init; } + internal required ISdlEventQueue GripEvents { private get; init; } + internal required ISdlEventQueue TargetEvents { private get; init; } +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlTimestampCalculator.cs b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlTimestampCalculator.cs new file mode 100644 index 0000000000..7d236a6b13 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlTimestampCalculator.cs @@ -0,0 +1,103 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Runtime.InteropServices; + +namespace Silk.NET.Input.SDL3.Devices.Pointers; + +internal static class SdlTimestampCalculator +{ + // sdl's timestamp is in nanoseconds + private const long _sdlTicksPerSecond = 1_000_000_000; + private const long _halfSdlTicksPerSecond = _sdlTicksPerSecond / 2; + + private static readonly Int128 _sdlTicksPerSecond128 = _sdlTicksPerSecond; + private static readonly Int128 _halfSdlTicksPerSecond128 = _halfSdlTicksPerSecond; + private static readonly Int128 _stopwatchFrequency128 = Stopwatch.Frequency; + + [StructLayout(LayoutKind.Explicit, Size = 16 * 3)] + public readonly struct Basis + { + [FieldOffset(0)] + public readonly Int128 SdlRef; + [FieldOffset(16)] + public readonly Int128 TimestampRef; + + public Basis(ulong sdlRef, long timestampRef) + { + SdlRef = sdlRef; + TimestampRef = timestampRef; + } + } + + public static Basis Average(this ReadOnlySpan calibrations) + { + var sdlRef = Int128.Zero; + var timestampRef = Int128.Zero; + for(var i = 0; i < calibrations.Length; i++) + { + ref readonly var calibration = ref calibrations[i]; + sdlRef += calibration.SdlRef; + timestampRef += calibration.TimestampRef; + } + + var avgSdl = sdlRef / calibrations.Length; + var avgTimestamp = timestampRef / calibrations.Length; + return new Basis((ulong)avgSdl, (long)avgTimestamp); + } + + public static FractionalTimestamp ToTimestamp(ulong sdlTime, in Basis basis) + { + var deltaNsSdl = checked(sdlTime - basis.SdlRef); + + // Exact conversion in "ns * stopwatchTicksPerSecond" + var scaled = deltaNsSdl * _stopwatchFrequency128; + + // Branchless round-to-nearest, ties away from zero. + var signMask = scaled >> 127; // 0 for non-negative, -1 for negative + var magnitude = (scaled ^ signMask) - signMask; + var roundedMagnitude = (magnitude + _halfSdlTicksPerSecond128) / _sdlTicksPerSecond128; + var roundedDeltaTicks = (roundedMagnitude ^ signMask) - signMask; + + var timestamp = checked((long)(basis.TimestampRef + roundedDeltaTicks)); + + // Exact residual after rounding, expressed in "sub-tick units". + // This is scaled - (rounded tick count * ns-per-second). + var remainderScaled = scaled - (roundedDeltaTicks * _sdlTicksPerSecond128); + var remainderAsFractionOfStopwatchTick = (double)remainderScaled / (double)_sdlTicksPerSecond128; + + return new FractionalTimestamp(timestamp, remainderAsFractionOfStopwatchTick); + } +} + +internal readonly struct FractionalTimestamp : IComparable +{ + /// + /// The converted time from sdl time to stopwatch time. + /// + public readonly long Timestamp; + + /// + /// A fraction of a single stopwatch tick (Timestamp value 1) - for scenarios where SDL's time is more accurate + /// than our stopwatch. This may never happen, but it's worth getting ahead of. + /// + public readonly double Fraction; + + public FractionalTimestamp(long timestamp, double fraction) + { + Timestamp = timestamp; + Fraction = fraction; + } + + public int CompareTo(FractionalTimestamp other) + { + var timestampComparison = Timestamp.CompareTo(other.Timestamp); + if (timestampComparison != 0) + { + return timestampComparison; + } + + return Fraction.CompareTo(other.Fraction); + } +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlTouchSurface.cs b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlTouchSurface.cs new file mode 100644 index 0000000000..117fe1189f --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/SdlTouchSurface.cs @@ -0,0 +1,140 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Numerics; +using Silk.NET.Maths; +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3.Devices.Pointers; + +/// +/// Our internal representation of an SDL Touch Device. +/// See SDL's documentation for more information. +///

+/// A touch device, according to SDL, can be one of three types: +/// +/// Direct: touch screen with window-relative coordinates +/// IndirectAbsolute: trackpad with absolute device coordinates +/// IndirectRelative: trackpad with screen cursor-relative coordinates +/// +/// +internal class SdlTouchSurface : SdlPointerDevice, ISdlDevice, IPointerDevice +{ + public static SdlTouchSurface CreateDevice(ulong sdlDeviceId, SdlInputBackend backend, SilkEventContext silkEvents) + { + var namePtr = backend.Sdl.GetTouchDeviceName(sdlDeviceId); + + nint uniqueId = 0; + if (backend.AttemptUniqueId(sdlDeviceId, ref uniqueId)) + { + return Create(); + } + if (backend.AttemptUniqueId(namePtr, ref uniqueId)) + { + return Create(); + } + + uniqueId = SdlInputBackend.FallbackUniqueId(sdlDeviceId, uniqueId); + + return Create(); + + SdlTouchSurface Create() + { + // https://wiki.libsdl.org/SDL3/SDL_MOUSE_TOUCHID + // todo - did i get this right ?? + const ulong simulatedId = ulong.MaxValue; + //const ulong simulatedId = (1UL << 63) & 1UL; + //const ulong simulatedId = (1UL << 31) & 1UL; + var isSimulated = sdlDeviceId == simulatedId; + var deviceType = backend.Sdl.GetTouchDeviceType(sdlDeviceId); + return new SdlTouchSurface(sdlDeviceId, uniqueId, backend, backend.UnboundedPointerTarget, deviceType, + isSimulated) { + ScrollEvents = silkEvents.MouseScrollSdlEvents, + PointEvents = silkEvents.PointChangedSdlEvents, + ClickEvents = silkEvents.PointerClickSdlEvents, + ButtonEvents = silkEvents.PointerButtonSdlEvents, + GripEvents = silkEvents.PointerGripChangedSdlEvents, + TargetEvents = silkEvents.PointerTargetChangedSdlEvents + }; + } + } + + public bool IsSimulated { get; } + + public override string Name + { + get + { + var ptr = NativeBackend.GetTouchDeviceName(SdlDeviceId); + if (ptr == nullptr) + { + SdlLog.Debug("Failed to get touch device name"); + return "Unknown Touch Surface"; + } + + return ptr.ReadToString(); + } + } + + + protected internal override void Initialize() + { + + } + + protected override void Release() => InputLog.Debug("Releasing touch device, but touch devices have no special release logic."); + + // todo - consider whether we want to use the related mouse device's buttons here + // (if this is a simulated touch device), + // or some other simulation method? + // protected override uint GetButtonMaskSdl() => 0; + + public override PointerState State { get; } + + protected override bool OnePointOnly => false; + private readonly TouchDeviceType _type; + + private SdlTouchSurface(ulong sdlDeviceId, nint uniqueId, SdlInputBackend backend, IPointerTarget unbounded, TouchDeviceType type, bool isSimulated) : base(backend, uniqueId, sdlDeviceId, unbounded) + { + _type = type; + IsSimulated = isSimulated; + if (type == TouchDeviceType.Invalid) + { + throw new ArgumentException("Invalid touch device type"); + } + + State = new PointerState(Buttons, Points); + } + + public void Event(in TouchFingerEvent finger, SdlInputBackend.FingerEventType fingerType, long timestamp) + { + var position = new Vector3(finger.X, finger.Y, 0); + var fingerId = (uint)(finger.TouchID % int.MaxValue); + var whichWindowId = finger.WindowID; + if (Backend.TryGetPointerTargetForWindow(whichWindowId, out var target)) + { + position *= target.Bounds.Size.ToSystem(); + } + else + { + throw new InvalidOperationException($"Touch device {this} has no target with window id {whichWindowId}"); + } + + switch (fingerType) + { + case SdlInputBackend.FingerEventType.Motion: + AddOrUpdatePoint(fingerId, whichWindowId, position, finger.Pressure, null, null, true, finger.Timestamp, timestamp); + break; + case SdlInputBackend.FingerEventType.Down: + AddOrUpdatePoint(fingerId, whichWindowId, position, finger.Pressure, true, null, true, finger.Timestamp, timestamp); + break; + case SdlInputBackend.FingerEventType.Up: + AddOrUpdatePoint(fingerId, whichWindowId, position, finger.Pressure, false, null, true, finger.Timestamp, timestamp); + break; + case SdlInputBackend.FingerEventType.Canceled: + break; + default: + throw new ArgumentOutOfRangeException(nameof(fingerType), fingerType, null); + } + } +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/Pointers/Targets/SdlBoundedPointerTarget.cs b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/Targets/SdlBoundedPointerTarget.cs new file mode 100644 index 0000000000..fe5daad5e1 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/Targets/SdlBoundedPointerTarget.cs @@ -0,0 +1,134 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Silk.NET.Maths; +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3.Devices.Pointers.Targets; + +internal interface ISdlBoundedPointerTarget + where T : SdlBoundedPointerTarget + where THandle : unmanaged +{ + uint Id { get; } + THandle Handle { get; } + + public static abstract T? Create(SdlInputBackend backend, uint id, THandle handle); + public void UpdateBounds(); +} + +internal abstract class SdlBoundedPointerTarget : IPointerTarget +{ + protected SdlBoundedPointerTarget(SdlInputBackend backend) + { + Backend = backend; + } + + internal SdlInputBackend Backend { get; } + private Box2D Bounds2D + { + get + { + var bounds = Bounds; + return new Box2D(bounds.Min.X, bounds.Min.Y, bounds.Max.X, bounds.Max.Y); + } + } + + public Box3D Bounds { get; private set; } + + public void UpdateBounds() => Bounds = CalculateBounds(); + protected abstract Box3D CalculateBounds(); + + /// + public int GetPointCount(IPointerDevice pointer) => PointerTargetExtensions.GetPointCount(this, pointer); + + /// + public TargetPoint GetPoint(IPointerDevice pointer, int point) => PointerTargetExtensions.GetPoint(this, pointer, point); + + public static unsafe Box2D CalculateAllDisplayBounds(ISdl sdl) + { + var displayCount = 0; + var displays = sdl.GetDisplays(&displayCount); + if (displays == nullptr) + { + // Looks like we can't support windowed mouse input. + sdl.ClearError(); + return default; + } + + if (displayCount == 0) // ??? + { + sdl.Free(displays); + return default; + } + + var bounds = new Box2D(float.MaxValue, float.MaxValue, float.MinValue, float.MinValue); + + for (var i = 0; i < displayCount; i++) + { + var b = CalculateDisplayBounds(sdl, displays[i]); + bounds = bounds.ExtendBy(b); + } + + sdl.Free(displays); + return default; + } + + public static unsafe Box2D CalculateDisplayBounds(ISdl sdl, uint sdlDisplayId) + { + if (sdlDisplayId == 0) + { + // https://wiki.libsdl.org/SDL3/SDL_DisplayID + return default; + } + + Rect rect = default; + var gotDisplayBounds = sdl.GetDisplayBounds(sdlDisplayId, &rect); + if (gotDisplayBounds == 0) + { + SdlLog.Error($"Failed to get display from ID {sdlDisplayId}."); + return default; + } + + return new Box2D(rect.X, rect.Y, rect.X + rect.W, rect.Y + rect.H); + } + + public static unsafe Box2D CalculateWindowBounds(ISdl sdl, WindowHandle window) + { + Vector2D windowSize = default; + var gotSize = sdl.GetWindowSize(window, &windowSize.X, &windowSize.Y);; + if (gotSize == 0) + { + SdlLog.Error("Failed to get window size for window."); + return default; + } + + Vector2D windowPosition = default; + var gotPos = sdl.GetWindowPosition(window, &windowPosition.X, &windowPosition.Y); + if (gotPos == 0) + { + SdlLog.Error("Failed to get window position for window."); + return default; + } + + var windowEndPos = windowPosition + windowSize; + return new Box2D(windowPosition.X, windowPosition.Y, windowEndPos.X, windowEndPos.Y); + } + + public static Box2D CalculateWindowBounds(ISdl sdl, uint windowId) + { + var window = sdl.GetWindowFromID(windowId); + if (window == nullptr) + { + SdlLog.Error($"Failed to get window from ID {windowId}."); + return default; + } + + return CalculateWindowBounds(sdl, window); + } + + public void Dispose() + { + + } +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/Pointers/Targets/SdlDisplayTarget.cs b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/Targets/SdlDisplayTarget.cs new file mode 100644 index 0000000000..e74d245faa --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/Targets/SdlDisplayTarget.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Silk.NET.Maths; + +namespace Silk.NET.Input.SDL3.Devices.Pointers.Targets; + +internal sealed class SdlDisplayTarget : SdlBoundedPointerTarget, ISdlBoundedPointerTarget +{ + private SdlDisplayTarget(SdlInputBackend backend, SilkSdlDisplayHandle id) : base(backend) + { + Id = id.Id; + Handle = id; + } + + protected override Box3D CalculateBounds() + { + var bounds2d = CalculateDisplayBounds(Backend.Sdl, Id); + return new Box3D(bounds2d.Min.X, bounds2d.Min.Y, 0, bounds2d.Max.X, bounds2d.Max.Y, 1); + } + + public uint Id { get; } + public SilkSdlDisplayHandle Handle { get; } + public static SdlDisplayTarget Create(SdlInputBackend backend, uint id, SilkSdlDisplayHandle handle) => + new(backend, handle); +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/Pointers/Targets/SdlUnboundedPointerTarget.cs b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/Targets/SdlUnboundedPointerTarget.cs new file mode 100644 index 0000000000..4b43cf3ddf --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/Targets/SdlUnboundedPointerTarget.cs @@ -0,0 +1,45 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Silk.NET.Maths; + +namespace Silk.NET.Input.SDL3.Devices.Pointers.Targets; + +internal class SdlUnboundedPointerTarget(SdlInputBackend backend) : IPointerTarget +{ + private static readonly Box3D _bounds = new( + float.MinValue, + float.MinValue, + float.MinValue, + float.MaxValue, + float.MaxValue, + float.MaxValue + ); + + public Box3D Bounds => _bounds; + + public int GetPointCount(IPointerDevice pointer) => PointerTargetExtensions.GetPointCount(this, pointer); + + public TargetPoint GetPoint(IPointerDevice pointer, int pointIdx) => PointerTargetExtensions.GetPoint(this, pointer, pointIdx); + /* + { + var point = pointer.State.Points[pointIdx]; + var valid = IsValidDevice(pointer); + return new TargetPoint( + Id: point.Id, // todo : follow spec with unique ids + Flags: valid ? TargetPointFlags.PointingAtTarget : TargetPointFlags.NotPointingAtTarget, + Position: point.Position, // in this case, should the position be provided at all? + NormalizedPosition: default, + Pointer: new Ray3D(), + Pressure: point.Pressure < 0 ? 0 : point.Pressure > 1 ? 1 : point.Pressure, + Target: this + ); + } + */ + + // todo - do we really want to limit this to SDL devices? or to our specific sdl backend? + // i dont think so, but.... technically... + private bool IsValidDevice(IPointerDevice pointer) => + pointer is SdlDevice device && device.Backend == backend && + (device.Backend.CursorConfiguration.Mode & CursorModes.Unbounded) != 0; +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/Pointers/Targets/SdlWindowTarget.cs b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/Targets/SdlWindowTarget.cs new file mode 100644 index 0000000000..ea9e6e0a3a --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/Pointers/Targets/SdlWindowTarget.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Silk.NET.Maths; +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3.Devices.Pointers.Targets; + +internal sealed class SdlWindowTarget : SdlBoundedPointerTarget, ISdlBoundedPointerTarget +{ + private SdlWindowTarget(SdlInputBackend backend, uint id, WindowHandle handle) : base(backend) + { + Id = id; + Handle = handle; + } + + protected override Box3D CalculateBounds() + { + var bounds2d = SdlBoundedPointerTarget.CalculateWindowBounds(Backend.Sdl, Handle); + return new Box3D(bounds2d.Min.X, bounds2d.Min.Y, 0, bounds2d.Max.X, bounds2d.Max.Y, 1); + } + + public uint Id { get; } + public WindowHandle Handle { get; } + public static SdlWindowTarget? Create(SdlInputBackend backend, uint id, WindowHandle handle) => new(backend, id, handle); +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/SdlDevice.cs b/sources/Input/Input/Implementations/SDL3/Devices/SdlDevice.cs new file mode 100644 index 0000000000..f95878fc2e --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/SdlDevice.cs @@ -0,0 +1,63 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Silk.NET.Input.SDL3.Devices.Pointers; +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3; + +/// +/// A base class for all SDL input devices. +/// +internal abstract class SdlDevice : IInputDevice, IDisposable +{ + bool IEquatable.Equals(IInputDevice? other) => + other?.GetType() == GetType() + && other.Id == Id + && (other as SdlDevice)!.NativeBackend == NativeBackend; + + public nint Id { get; } + + public virtual ulong SdlDeviceId { get; } + + public SdlInputBackend Backend { get; } + + /// + /// For readability and refactorability - provides the SDL interface instance. + /// + protected ISdl NativeBackend => Backend.Sdl; + + public abstract string Name { get; } + + protected SdlDevice(SdlInputBackend backend, nint uniqueId, ulong sdlDeviceId) + { + Backend = backend; + Id = uniqueId; + SdlDeviceId = sdlDeviceId; + } + + protected internal abstract void Initialize(); + + protected abstract void Release(); + + public void Dispose() + { + ObjectDisposedException.ThrowIf(_isDisposed, GetType()); + _isDisposed = true; + Release(); + GC.SuppressFinalize(this); + } + + ~SdlDevice() + { + if (!_isDisposed) + { + InputLog.Error($"Failed to properly dispose {GetType().Name} {Id} (sdl ID: {SdlDeviceId})."); + } + + _isDisposed = true; + Release(); + } + + private bool _isDisposed; +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/SdlKeyboard.cs b/sources/Input/Input/Implementations/SDL3/Devices/SdlKeyboard.cs new file mode 100644 index 0000000000..cce8ad05c7 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/SdlKeyboard.cs @@ -0,0 +1,303 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using Silk.NET.Input.KeyHandling; +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3; + +internal class SdlKeyboard : SdlDevice, IKeyboard, ISdlDevice, INeedFinalizationEachFrame +{ + public KeyboardState State { get; } + public override string Name => NativeBackend.GetKeyboardNameForID((uint)SdlDeviceId).ReadToString(); + public string? ClipboardText + { + get => NativeBackend.HasClipboardText() ? NativeBackend.GetClipboardText().ReadToString() : null; + set => NativeBackend.SetClipboardText(value); + } + + private bool _hasUpdates; + + public static SdlKeyboard CreateDevice(ulong sdlDeviceId, SdlInputBackend backend, SilkEventContext silkEvents) + { + var namePtr = backend.Sdl.GetKeyboardNameForID((uint)sdlDeviceId); + + var uniqueId = (nint)sdlDeviceId; + if (namePtr == nullptr) + { + InputLog.Warn($"Failed to get keyboard name for device {sdlDeviceId}."); + } + else + { + if (backend.AttemptUniqueId(namePtr, ref uniqueId)) + { + return new SdlKeyboard(sdlDeviceId, uniqueId, backend) { + KeyChangedEvents = silkEvents.KeyChangedSdlEvents, KeyCharEvents = silkEvents.KeyCharSdlEvents + }; + } + } + + uniqueId = SdlInputBackend.FallbackUniqueId(sdlDeviceId, uniqueId); + return new SdlKeyboard(sdlDeviceId, uniqueId, backend) { + KeyChangedEvents = silkEvents.KeyChangedSdlEvents, KeyCharEvents = silkEvents.KeyCharSdlEvents + }; + } + + private SdlKeyboard(ulong sdlDeviceId, nint uniqueId, SdlInputBackend backend) : base(backend, uniqueId, sdlDeviceId) + { + _modState = NativeBackend.GetModState(); + _keyStates = new ButtonStates(); + + State = new KeyboardState( + keys: _keyStates, + capsLockActive: () => (_modState & Sdl.KmodCaps) == Sdl.KmodCaps, + numLockActive: () => (_modState & Sdl.KmodNum) == Sdl.KmodNum); + } + + protected internal override void Initialize() + { + + } + + protected override void Release() + { + } + + public bool TryGetKeyName(KeyName key, [NotNullWhen(true)] out string? name) + { + // todo: should 'asKeyEvent' be true? + var sdlKey = SdlKeyConversions.KeyNameToSdl(key, NativeBackend, true, _modState); + var namePtr = NativeBackend.GetKeyName(sdlKey); + name = namePtr.ReadToString(); + return !string.IsNullOrWhiteSpace(name); + } + + + // todo - there should be a backend-independent way to do this text input handling via KeyboardState? + public void BeginInput() + { + var sdlWindow = Backend.FocusedWindow; + if (sdlWindow != null && NativeBackend.StartTextInput(sdlWindow.Value)) + { + BeginRecordingSdl(sdlWindow.Value); + } + else + { + _textIsRecording = TextRecorderState.RecordingNoSdl; + } + } + + private void BeginRecordingSdl(WindowHandle sdlWindow) + { + _textIsRecording = TextRecorderState.RecordingSdl; + _textEntryWindow = sdlWindow; + } + + public string? EndInput() + { + switch (_textIsRecording) + { + case TextRecorderState.None: + return null; + case TextRecorderState.RecordingNoSdl: + _textIsRecording = TextRecorderState.None; + break; + case TextRecorderState.RecordingSdl: + _textIsRecording = TextRecorderState.None; + var sdlWindow = _textEntryWindow; + if (sdlWindow != null) + { + NativeBackend.StopTextInput(sdlWindow.Value); + } + break; + } + _textIsRecording = TextRecorderState.None; + return _textRecorder?.ConsumeInput(); + } + + public void FinalizeUpdate() + { + if (_hasUpdates) + { + // This should be called every frame the keyboard is updated in . + // This mod state is purely used for sdl-related calls and modifiers that are independent of key state (e.g. numlock, caps lock) + // - otherwise, we handle the modifier states with our standard key handling logic + _modState = NativeBackend.GetModState(); + } + } + + public void AddKeyEvent(in KeyboardEvent key, long timestamp) + { + _hasUpdates = true; + var keyName = SdlKeyConversions.ScancodeToKeyName(key.Scancode); // SdlToKeyName(key.Which); + + if (ButtonStates.IsDefined(keyName)) + { + var isDown = key.Down != 0; + var button = _keyStates[keyName]; + var stateChanged = button.IsDown != isDown; + var isRepeat = key.Repeat != 0; + _keyStates.SetKeyState(keyName, key.Down); + + var shouldRecord = _textIsRecording == TextRecorderState.RecordingNoSdl && + ((stateChanged && isDown) || + (!stateChanged && isRepeat)); + if (shouldRecord) + { + _textRecorder ??= new TextRecorder(null); + if(_textRecorder.AddKeyStroke(keyName, this, out var newChar)) + { + KeyCharEvents.Enqueue(new KeyCharEvent(this, timestamp, newChar.Value), key.Timestamp); + } + } + else + { + KeyChangedEvents.Enqueue(new KeyChangedEvent( + Keyboard: this, + Timestamp: timestamp, + Key: _keyStates[keyName], + Previous: button, + Modifiers: State.Modifiers, + IsRepeat: isRepeat), key.Timestamp); + } + } + } + + public unsafe void AddTextEditingEvent(in TextEditingEvent evt) + { + _hasUpdates = true; + if (_textEntryWindow == null) + { + var windowHandle = NativeBackend.GetWindowFromID(evt.WindowID); + if (windowHandle.Handle != null) + { + InputLog.Warn("Unexpected text editing event"); + BeginRecordingSdl(windowHandle); + } + } + else if (evt.WindowID != NativeBackend.GetWindowID(_textEntryWindow.Value)) + { + InputLog.Error("Received text editing event for a different window than the " + + "one we're recording text for."); + } + + _textRecorder ??= new TextRecorder(null); + + if (evt.Length == 0) + { + _textRecorder.SetSelection(evt.Start, 0); + } + else + { + if (evt.Text == null) + { + return; + } + + _textRecorder.InsertTextAt(evt.Text, evt.Start, evt.Length); + } + } + + public unsafe void AddTextCandidatesEvent(in TextEditingCandidatesEvent evt) + { + _hasUpdates = true; + if (evt.SelectedCandidate == -1 || evt.NumCandidates == 0) + { + return; + } + + Debug.Assert(evt.NumCandidates > evt.SelectedCandidate); + + var candidate = new Ptr(evt.Candidates[evt.SelectedCandidate]); + var str = candidate.ReadToString(); + _textRecorder ??= new TextRecorder(null); + _textRecorder.InsertText(str); + } + + public unsafe void AddTextInputEvent(in TextInputEvent evt) + { + _hasUpdates = true; + if (_textEntryWindow == null) + { + var windowHandle = NativeBackend.GetWindowFromID(evt.WindowID); + if (windowHandle.Handle != null) + { + InputLog.Warn("Unexpected text input event"); + BeginRecordingSdl(windowHandle); + } + } + else if (evt.WindowID != NativeBackend.GetWindowID(_textEntryWindow.Value)) + { + InputLog.Error("Received text input event for a different window than the " + + "one we're recording text for."); + } + + + var str = evt.Text == null ? "" : new Ptr(evt.Text).ReadToString(); + + _textRecorder ??= new TextRecorder(null); + _textRecorder.InsertText(str); + } + + + private WindowHandle? _textEntryWindow; + private TextRecorder? _textRecorder; + private enum TextRecorderState {None, RecordingNoSdl, RecordingSdl} + private TextRecorderState _textIsRecording; + private ushort _modState; + private const float _pressureMultiplier = 1f / 255f; + private readonly ButtonStates _keyStates; + internal required ISdlEventQueue KeyChangedEvents; + internal required ISdlEventQueue KeyCharEvents; + + private class ButtonStates : IReadOnlyList> + { + private static readonly int _keyCount; + private readonly byte[] _keyPressures = new byte[_keyCount]; + private static readonly int[] _indices; + + static ButtonStates() + { + _indices = new int[512]; + for (var i = 0; i < 512; i++) + { + _indices[i] = Enum.IsDefined((KeyName)i) ? _keyCount++ : -1; + } + } + + public int SetKeyState(KeyName key, byte pressure) => _keyPressures[_indices[(int)key]] = pressure; + + public IEnumerator> GetEnumerator() + { + for (var i = 0; i < _keyCount; i++) + { + var index = _indices[i]; + if(index != -1) + { + yield return GetButton(index); + } + } + } + + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + + public int Count => _keyCount; + + public Button this[int index] => GetButton(index); + public Button this[KeyName key] => GetButton((int)key); + + private Button GetButton(KeyName key) => GetButton((int)key); + private Button GetButton(int key) + { + var keyIdx = _indices[key]; + return CreateButton((KeyName)key, _keyPressures[keyIdx]); + } + + private static Button CreateButton(KeyName key, byte pressure) => new(key, pressure > 0, pressure * _pressureMultiplier); + + public static bool IsDefined(KeyName keyName) => _indices[(int)keyName] >= 0; + } +} diff --git a/sources/Input/Input/Implementations/SDL3/Devices/SilkSdlDisplayHandle.cs b/sources/Input/Input/Implementations/SDL3/Devices/SilkSdlDisplayHandle.cs new file mode 100644 index 0000000000..a7d65afe56 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Devices/SilkSdlDisplayHandle.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Input.SDL3.Devices.Pointers.Targets; + +internal readonly struct SilkSdlDisplayHandle +{ + public static readonly SilkSdlDisplayHandle AllDisplays = new(uint.MaxValue); + public uint Id { get; } + public SilkSdlDisplayHandle(uint id) => Id = id; +} diff --git a/sources/Input/Input/Implementations/SDL3/Extensions/BackendExtensions.cs b/sources/Input/Input/Implementations/SDL3/Extensions/BackendExtensions.cs new file mode 100644 index 0000000000..d18264ca38 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Extensions/BackendExtensions.cs @@ -0,0 +1,87 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Text; +using System.Runtime.CompilerServices; + +namespace Silk.NET.Input.SDL3; + +internal static unsafe class BackendExtensions +{ + extension(SdlInputBackend backend) + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static nint FallbackUniqueId(ulong sdlDeviceId, nint uniqueId) + { + InputLog.Warn($"Failed to create a deterministically unique identifier for device {sdlDeviceId} ({typeof(T).Name})."); + + // set the highest bit of the unique id as a hint that the id was not unique + var highestBit = (nint)1 << ((sizeof(nint) * 8) - 1); + var typeHash = (nint)typeof(T).GetHashCode(); + + if (sdlDeviceId == 0 && uniqueId == 0) + { + return highestBit ^ typeHash; + } + + if (uniqueId == 0) + { + return highestBit ^ (typeHash & (nint)sdlDeviceId); + } + + if (sdlDeviceId == 0) + { + return highestBit ^ (typeHash & uniqueId); + } + + return uniqueId ^ ( highestBit | ((nint)sdlDeviceId ^ ((nint)sdlDeviceId << (sizeof(nint) / 2)))); + } + + public bool AttemptUniqueId(Ptr ptr, ref nint uniqueId1) + { + if (ptr.Native == null) + { + return false; + } + + var name = ptr.ReadToString(); + var bytes = Encoding.Default.GetBytes(name); + return backend.AttemptUniqueId(bytes, ref uniqueId1); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool AttemptUniqueId(T value, ref nint uniqueId1) + where T : unmanaged => + backend.AttemptUniqueId(new ReadOnlySpan(&value, sizeof(T)), ref uniqueId1); + + public bool AttemptUniqueId(ReadOnlySpan bytes, ref nint uniqueId1) + { + uniqueId1 = Modify(uniqueId1, bytes); + return backend.RegisterDevice(uniqueId1); + static nint Modify(nint original, ReadOnlySpan withBytes) + { + if (sizeof(nint) == 4) + { + var hash = new HashCode(); + foreach(var b in withBytes) + { + hash.Add(b); + } + + var hashCode = hash.ToHashCode(); + return original ^ *(nint*)(&hashCode); + } + + var hash64Bytes = (byte*)&original; + + for (int i = 0; i < withBytes.Length; i += 8) + { + hash64Bytes[i % 8] ^= withBytes[i]; + } + + return *(nint*)hash64Bytes; + } + + } + } +} diff --git a/sources/Input/Input/Implementations/SDL3/Extensions/InputWindowExtensions.cs b/sources/Input/Input/Implementations/SDL3/Extensions/InputWindowExtensions.cs new file mode 100644 index 0000000000..bd515dc85e --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Extensions/InputWindowExtensions.cs @@ -0,0 +1,28 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +// ReSharper disable CheckNamespace + +using Silk.NET.Input.SDL3; +using Silk.NET.SDL; + +namespace Silk.NET.Input; + +/// +/// Contains extensions for creating input backends and contexts from s. +/// +public static partial class InputWindowExtensions +{ + public static partial IInputBackend CreateInputBackend(this INativeWindow window) + { + if (!window.TryGetPlatformInfo(out SdlPlatformInfo info)) + { + throw new ArgumentException( + "When using the Silk.NET.Input reference implementation, a native window compatible with that " + + "implementation (such as those sourced from Silk.NET.Windowing) must be used." + ); + } + + return new SdlInputBackend(info); + } +} diff --git a/sources/Input/Input/Implementations/SDL3/Extensions/MathExtensions.cs b/sources/Input/Input/Implementations/SDL3/Extensions/MathExtensions.cs new file mode 100644 index 0000000000..f0b8c943df --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Extensions/MathExtensions.cs @@ -0,0 +1,13 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Runtime.CompilerServices; +using Silk.NET.Maths; + +namespace Silk.NET.Input.SDL3.Devices.Pointers; + +internal static class MathExtensions +{ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static Box2D ExtendBy(this Box2D box, Box2D other) => new(Scalar.Min(box.Min, other.Min), Scalar.Max(box.Max, other.Max)); +} diff --git a/sources/Input/Input/Implementations/SDL3/Extensions/PointerTargetExtensions.cs b/sources/Input/Input/Implementations/SDL3/Extensions/PointerTargetExtensions.cs new file mode 100644 index 0000000000..7ffbe45b9d --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/Extensions/PointerTargetExtensions.cs @@ -0,0 +1,77 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Numerics; +using System.Runtime.CompilerServices; +using Silk.NET.Maths; + +namespace Silk.NET.Input.SDL3.Devices.Pointers.Targets; + +internal static class PointerTargetExtensions +{ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool AppliesTo(this IPointerDevice device, IPointerTarget target) => device.Targets.Contains(target); + + extension(IPointerTarget target) + { + /// + /// Normalizes a 2D position to the range [0, 1] in both dimensions. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public Vector3 SimpleNormalizedPosition(in Vector3 input) => + SimpleRelativePosition(target, input) / target.Bounds.Size.ToSystem(); + + public Vector3 SimpleRelativePosition(in Vector3 input) + { + var bounds = target.Bounds; + if (Scalar.IsInfinity(bounds.Min) || Scalar.IsInfinity(bounds.Max)) + { + throw new InvalidOperationException("Target bounds are infinite."); + } + + return input - bounds.Min.ToSystem(); + } + + /// + /// A default implementation of + /// that iterates over all points. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public int GetPointCount(IPointerDevice pointer) + { + var points = pointer.State.Points; + var count = 0; + var pointerPointsCount = points.Count; + for (var i = 0; i < pointerPointsCount; i++) + { + if (points[i].Target == target) + { + ++count; + } + } + + return count; + } + + /// + /// A default implementation of + /// that iterates over all points. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public TargetPoint GetPoint(IPointerDevice pointer, int point) + { + var points = pointer.State.Points; + var allPtCount = points.Count; + for (var i = 0; i < allPtCount; i++) + { + var targetPoint = points[i]; + if (targetPoint.Target == target && point-- == 0) + { + return targetPoint; + } + } + + return default; + } + } +} diff --git a/sources/Input/Input/Implementations/SDL3/FlagExtensions.cs b/sources/Input/Input/Implementations/SDL3/FlagExtensions.cs new file mode 100644 index 0000000000..236f790f4f --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/FlagExtensions.cs @@ -0,0 +1,28 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Frozen; + +namespace Silk.NET.Input.SDL3; + +internal static class FlagExtensions +{ + /// + extension(SdlMouseInputFlags flags) + { + public bool Has(PointerButton button) => _pointerButtonToMouseFlags.TryGetValue(button, out var converted) + && (flags & converted) == converted; + } + + private static readonly FrozenDictionary _mouseButtonFlagsToPointerButton = + new Dictionary { + { SdlMouseInputFlags.LeftButtonDown, PointerButton.Primary }, + { SdlMouseInputFlags.MiddleButtonDown, PointerButton.MiddleButton }, // same as PointerButton.Button3 + { SdlMouseInputFlags.RightButtonDown, PointerButton.Secondary }, + { SdlMouseInputFlags.XButton1Down, PointerButton.Button4 }, + { SdlMouseInputFlags.XButton2Down, PointerButton.Button5 }, + }.ToFrozenDictionary(); + + private static readonly FrozenDictionary _pointerButtonToMouseFlags = + _mouseButtonFlagsToPointerButton.ToFrozenDictionary(v => v.Value, v => v.Key); +} diff --git a/sources/Input/Input/Implementations/SDL3/SdlArray.cs b/sources/Input/Input/Implementations/SDL3/SdlArray.cs new file mode 100644 index 0000000000..596be23cea --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/SdlArray.cs @@ -0,0 +1,134 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3; + +// note - this probably doesn't need to be a ref struct, but is bc that's the extents +// of the struct's current use cases +// todo - can this struct be represented as a NativeArray where TBackend has a +// Free(void*) or Free(void*, int) method? +internal readonly unsafe ref struct SdlArray : IDisposable, IEquatable>, IReadOnlyList where T : unmanaged +{ + private readonly Ptr _ptr; + public int Count { get; } + private readonly ISdl? _sdl; + + [MemberNotNullWhen(true, nameof(_sdl))] + private bool CanDispose { get; } + + public static SdlArray Null => default; + + public SdlArray(Ptr ptr, int count, ISdl? sdl, bool consumerCanDispose = true) + { + if (consumerCanDispose) + { + ArgumentNullException.ThrowIfNull(ptr.Native); + ArgumentNullException.ThrowIfNull(sdl); + } + + ArgumentOutOfRangeException.ThrowIfNegative(count); + + _ptr = ptr; + Count = count; + _sdl = sdl; + CanDispose = consumerCanDispose; + } + + public void Dispose() + { + if (!CanDispose) + { + return; + } + + if (_ptr.Native == null) + { + return; + } + + _sdl.Free(_ptr.Native); + } + + public static implicit operator Ptr(SdlArray array) => array._ptr; + public static implicit operator Span(SdlArray array) => array.AsSpan(); + public static implicit operator ReadOnlySpan(SdlArray array) => array.AsReadOnlySpan(); + + // equality operators against null and other collections + public static bool operator ==(SdlArray left, SdlArray right) => left._sdl == right._sdl && left._ptr == right._ptr; + public static bool operator !=(SdlArray left, SdlArray right) => left._sdl == right._sdl && left._ptr != right._ptr; + public static bool operator ==(SdlArray left, NullPtr right) => left._ptr == right; + public static bool operator !=(SdlArray left, NullPtr right) => left._ptr != right; + public static bool operator ==(NullPtr left, SdlArray right) => left == right._ptr; + public static bool operator !=(NullPtr left, SdlArray right) => left != right._ptr; + + + + public bool IsNull => _ptr.Native == null; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public Span AsSpan() => _ptr.Native == null ? default : new Span(_ptr.Native, Count); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public ReadOnlySpan AsReadOnlySpan() => _ptr.Native == null ? default : new ReadOnlySpan(_ptr.Native, Count); + + T IReadOnlyList.this[int index] => this[index]; + + public ref T this[int index] + { + get + { + if (_ptr.Native == null) + { + throw new NullReferenceException(); + } + + if (Count <= index) + { + throw new IndexOutOfRangeException(nameof(index)); + } + + ArgumentOutOfRangeException.ThrowIfNegative(index); + + return ref _ptr.Native[index]; + } + } + + public ref T this[uint index] + { + get + { + if (_ptr.Native == null) + { + throw new NullReferenceException(); + } + + if (Count <= index) + { + throw new IndexOutOfRangeException(nameof(index)); + } + + return ref _ptr.Native[index]; + } + } + + public bool Equals(SdlArray other) => this == other; + + public IEnumerator GetEnumerator() + { + if (_ptr == nullptr) + { + throw new NullReferenceException(); + } + + return (IEnumerator)AsReadOnlySpan().ToArray().GetEnumerator(); + } + + public override bool Equals(object? obj) => obj == null && _ptr.Native == null; + public override int GetHashCode() => HashCode.Combine(_ptr, Count, _sdl); + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); +} diff --git a/sources/Input/Input/Implementations/SDL3/SdlEventQueue.cs b/sources/Input/Input/Implementations/SDL3/SdlEventQueue.cs new file mode 100644 index 0000000000..d59f955fd2 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/SdlEventQueue.cs @@ -0,0 +1,139 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; +using Silk.NET.Input.SDL3.Devices.Pointers; + +namespace Silk.NET.Input.SDL3; + +internal class SdlEventQueue : ISdlEventQueue where T : struct +{ + private T[] _events = GC.AllocateUninitializedArray(8); + private ulong[] _sdlTimestamps = new ulong[8]; + +#pragma warning disable CS8500 // This takes the address of, gets the size of, or declares a pointer to a managed type + protected ref T GetPtr(int index, out ulong sdlTimestamp) + { + sdlTimestamp = _sdlTimestamps[index]; + return ref _events[index]; + } +#pragma warning restore CS8500 // This takes the address of, gets the size of, or declares a pointer to a managed type + + protected int Count; + + + public void Enqueue(in T item, ulong sdlTimestamp) + { + if (Count == _events.Length) + { + var newLen = _events.Length * 2; + var newEvents = GC.AllocateUninitializedArray(newLen); + _events.CopyTo(newEvents, 0); + _events = newEvents; + + Array.Resize(ref _sdlTimestamps, newLen); + } + + _sdlTimestamps[Count] = sdlTimestamp; + _events[Count++] = item; + } + + + internal readonly ref struct ValuePair(TValue[] values, ulong[] sdlTimestamps, int count) + { + public readonly TValue[] Values = values; + public readonly ulong[] SdlTimestamps = sdlTimestamps; + public readonly int Count = count; + } + + internal ValuePair Consume() + { + var count = Count; + Count = 0; + return new ValuePair(_events, _sdlTimestamps, count); + } + + public void Clear() + { + _events.AsSpan().Clear(); + Count = 0; + } +} + +internal sealed class GenericEventQueue : SdlEventQueue +{ + private readonly SdlTimestampCalculator.Basis _basis; + public GenericEventQueue(SdlTimestampCalculator.Basis basis) => _basis = basis; + + + public unsafe void ConsumeQueue(in SdlEventQueue queue) where T : struct, ITimestampedEvent + { + var q = queue.Consume(); + for (var i = 0; i < q.Count; i++) + { + ref var src = ref q.Values[i]; + var genericEvent = new GenericEvent( + EventPtr: (nint)Unsafe.AsPointer(ref Unsafe.AsRef(ref src)), + Type: typeof(T)); + + Enqueue(genericEvent, q.SdlTimestamps[i]); + } + } + + public ReadOnlySpan ConsumeAndGetSorted() + { + var pair = Consume(); + var valuesToSort = pair.Values.AsSpan(0, pair.Count); + var sdlTimestamps = pair.SdlTimestamps.AsSpan(0, pair.Count); + + Span sortKeys = stackalloc FractionalTimestamp[valuesToSort.Length]; + for (var i = 0; i < valuesToSort.Length; i++) + { + sortKeys[i] = SdlTimestampCalculator.ToTimestamp(sdlTimestamps[i], _basis); + } + + sortKeys.StableSortWith(valuesToSort, (timeA, timeB) => timeA.CompareTo(timeB)); + + return valuesToSort; + } + + + // taking a pointer to this type is safe, as we're not using any + + private readonly ref struct Timing(long timestamp, ulong sdlTimestamp) + { + public readonly ulong SdlTimestamp = sdlTimestamp; + public readonly long StopwatchTimestamp = timestamp; + } + + public unsafe bool TryDequeue([NotNullWhen(true)] out void* value, out ulong timestamp) + { + if (Count == 0) + { + value = null; + timestamp = 0; + return false; + } + + + ref var valRef = ref GetPtr(--Count, out timestamp); + value = Unsafe.AsPointer(ref valRef); + return true; + } +} + +internal interface ISdlEventQueue where T : struct +{ + public void Enqueue(in T item, ulong sdlTimestamp); +} + +internal readonly record struct GenericEvent(nint EventPtr, Type Type) +{ + public unsafe T Value() => Unsafe.AsRef((void*)EventPtr); +} + +internal interface ITimestampedEvent +{ + public long Timestamp { get; } +} diff --git a/sources/Input/Input/Implementations/SDL3/SdlInputBackend.Devices.cs b/sources/Input/Input/Implementations/SDL3/SdlInputBackend.Devices.cs new file mode 100644 index 0000000000..45b0ee9431 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/SdlInputBackend.Devices.cs @@ -0,0 +1,121 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics.CodeAnalysis; +using Silk.NET.Input.SDL3.Devices.Joysticks; + +namespace Silk.NET.Input.SDL3; + +internal partial class SdlInputBackend +{ + internal bool TryGetOrCreateDevice(ulong id, [NotNullWhen(true)] out T? device) + where T : SdlDevice, ISdlDevice + { + // If we already have a device with this ID, return it. + var sdlDevices = _eventProcessingArgs.Devices; + for (var i = 0; i < sdlDevices.Count; i++) + { + if (sdlDevices[i] is T typedDevice && typedDevice.SdlDeviceId == id) + { + device = typedDevice; + return true; + } + } + + try + { + device = T.CreateDevice(id, this, _silkEvents); + } + catch (Exception e) + { + InputLog.Error($"Failed to create device {nameof(T)} with id '{id}': {e}"); + device = null; + return false; + } + + if (device is null) + { + InputLog.Error($"Failed to create device {nameof(T)} with id '{id}'"); + return false; + } + + try + { + device.Initialize(); + } + catch (Exception e) + { + InputLog.Error($"Failed to initialize device {nameof(T)} with id '{id}': {e}"); + device.Dispose(); + device = null; + return false; + } + + sdlDevices.Add(device); + InputLog.Debug($"{typeof(T)} added: (sdl ID: {id})"); + return true; + } + + private bool RemoveDevice(List devices, uint id) + { + var deviceIdx = devices.FindIndex(x => x is T && x.SdlDeviceId == id); + + if (deviceIdx == -1) + { + // we never used this device to begin with, so just ignore its removal + return false; + } + + var device = devices[deviceIdx]; + device.Dispose(); + devices.RemoveAt(deviceIdx); + _ = UnregisterDevice(device.Id); + + // device IDs may have changed when a device was removed, so we need to refresh them + RefreshDeviceIds(devices); + return true; + } + + private bool UnregisterDevice(nint uniqueId) + { +#if DEBUG + if (_deviceRegistry.Remove(uniqueId)) + { + return true; + } + + InputLog.Error($"Tried to unregister device with id {uniqueId} that was not registered"); + return false; + +#else + return _deviceRegistry.Remove(uniqueId); +#endif + } + + public bool RegisterDevice(nint uniqueId) + { +#if DEBUG + if (_deviceRegistry.Add(uniqueId)) + { + return true; + } + + InputLog.Error($"Tried to register device with id {uniqueId} that was already registered"); + return false; + +#else + return _deviceRegistry.Add(uniqueId); +#endif + } + + private static void RefreshDeviceIds(List devices) + { + for (var i = 0; i < devices.Count; i++) + { + if (devices[i] is IOrderedDevice d) + { + d.RefreshSdlId(); + } + } + } +} diff --git a/sources/Input/Input/Implementations/SDL3/SdlInputBackend.Targets.cs b/sources/Input/Input/Implementations/SDL3/SdlInputBackend.Targets.cs new file mode 100644 index 0000000000..cd2f9805ec --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/SdlInputBackend.Targets.cs @@ -0,0 +1,174 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using Silk.NET.Input.SDL3.Devices.Pointers.Targets; +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3; + +internal partial class SdlInputBackend +{ + private delegate SdlArray GetHandlesCallback(ISdl sdl) where T : unmanaged; + private readonly List _tempTargets = new(); + + private readonly GetHandlesCallback _getWindowHandles; + private readonly GetHandlesCallback _getDisplayHandles; + private readonly Func _getWindowId; + private readonly Func _getDisplayId; + + private void UpdatePointerTargets(in List windowTargets, in List displayTargets) + { + PopulateTargets(windowTargets, Sdl, _getWindowHandles, _getWindowId); + PopulateTargets(displayTargets, Sdl, _getDisplayHandles, _getDisplayId); + } + + private uint? GetDisplayId(SilkSdlDisplayHandle x) => x.Id; + + private unsafe uint? GetWindowId(WindowHandle x) + { + if (x.Handle == null) + { + return null; + } + + var windowId = Sdl.GetWindowID(x); + if (windowId == 0) + { + SdlLog.Error("Failed to get window ID"); + return null; + } + + return windowId; + } + + internal bool TryGetWindowHandles(out SdlArray handles) + { + handles = GetWindowHandles(Sdl); + return handles != nullptr; + } + + internal static unsafe SdlArray GetWindowHandles(ISdl sdl) + { + var windowCount = 0; + var windows = sdl.GetWindows(&windowCount); + if (windows != null) + { + return new SdlArray(windows, windowCount, sdl, true); + } + + SdlLog.Error("Failed to get window handles"); + return SdlArray.Null; + + } + + + private static unsafe SdlArray GetDisplayHandles(ISdl sdl) + { + var displayCount = 0; + var displays = sdl.GetDisplays(&displayCount); + if (displays != null) + { + return new SdlArray(displays, displayCount, sdl); + } + + SdlLog.Error("Failed to get display handles"); + return SdlArray.Null; + + } + + private unsafe void PopulateTargets(List targets, ISdl sdl, GetHandlesCallback getHandles, + Func getId) + where THandle : unmanaged + where T : SdlBoundedPointerTarget, ISdlBoundedPointerTarget + { + using var handles = getHandles(sdl); + if (handles == nullptr || handles.Count == 0) + { + ClearTargets(targets); + return; + } + + Debug.Assert(_tempTargets.Count == 0, "Temp targets should be empty when populating targets"); + + Span ids = stackalloc uint?[handles.Count]; + + for (var i = 0; i < handles.Count; i++) + { + ref var handle = ref handles[i]; + var id = ids[i] = getId(handle); + if (id == null) + { + // ??? we were given an invalid handle + continue; + } + + // check if we already have a target for this handle + // note: not using 'FindIndex' here to avoid closure allocation + var targetIndex = -1; + for(var j = 0; j < targets.Count; j++) + { + if (targets[j].Id == id.Value) + { + targetIndex = j; + break; + } + } + + T target; + if (targetIndex == -1) + { + // create a new one + var newTarget = T.Create(this, id.Value, handle); + if (newTarget == null) + { + InputLog.Error($"Failed to create target for handle {handle}"); + continue; + } + + target = newTarget; + + // add new target to temp targets to avoid including them in the search for removed targets + _tempTargets.Add(newTarget); + } + else + { + target = targets[targetIndex]; + } + + target.UpdateBounds(); + } + + // check for removed targets + for (var i = targets.Count - 1; i >= 0; --i) + { + var target = targets[i]; + if (!ids.Contains(target.Id)) + { + target.Dispose(); + targets.RemoveAt(i); + } + } + + // add new targets to the list + foreach (var target in _tempTargets) + { + targets.Add((T)target); + } + + _tempTargets.Clear(); + } + + private static void ClearTargets(List targets) + where T : SdlBoundedPointerTarget, ISdlBoundedPointerTarget + where THandle : unmanaged + { + foreach (var target in targets) + { + target.Dispose(); + } + + targets.Clear(); + } + +} diff --git a/sources/Input/Input/Implementations/SDL3/SdlInputBackend.cs b/sources/Input/Input/Implementations/SDL3/SdlInputBackend.cs new file mode 100644 index 0000000000..aff0cf7925 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/SdlInputBackend.cs @@ -0,0 +1,686 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using Silk.NET.Input.SDL3.Devices.Joysticks; +using Silk.NET.Input.SDL3.Devices.Pointers; +using Silk.NET.Input.SDL3.Devices.Pointers.Targets; +using Silk.NET.Maths; +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3; + +internal partial class SdlInputBackend : IInputBackend +{ + [field: MaybeNull] + public SdlUnboundedPointerTarget UnboundedPointerTarget => + field ??= new SdlUnboundedPointerTarget(this); + + public ISdl Sdl { get; } + + public string Name => + $"Silk.NET.Input Reference Implementation using SDL3 ({Sdl.GetPlatform().ReadToString()})"; + + public nint Id { get; } + + public IReadOnlyList Devices => _eventProcessingArgs.Devices; + + // todo - properly implement window focus tracking + public WindowHandle? FocusedWindow { get; private set; } + + public readonly ICursorConfiguration CursorConfiguration; + + public unsafe SdlInputBackend(SdlPlatformInfo info) + { + Sdl = info.Sdl ?? SDL.Sdl.Instance; + if (Sdl == null) + { + throw new ArgumentNullException(nameof(info), "No SDL instance was provided or found."); + } + + if (info.Window == nullptr) + { + var focusedWindow = Sdl.GetMouseFocus(); + if (focusedWindow == nullptr) + { + focusedWindow = Sdl.GetKeyboardFocus(); + } + + if (focusedWindow == nullptr) + { + throw new ArgumentNullException(nameof(info), "No window was provided and no window had focus."); + } + + FocusedWindow = focusedWindow; + } + + _getDisplayHandles = GetDisplayHandles; + _getWindowHandles = GetWindowHandles; + _getWindowId = GetWindowId; + _getDisplayId = GetDisplayId; + _eventProcessingArgs = new ProcessEventArgs(this); + + var ptr = new EventFilter(OnEvent); + // TODO overload resolution priority? + if (!Sdl.AddEventWatch(ptr, (Ref)nullptr)) + { + Sdl.ThrowError(); + } + + Id = (nint)ptr.Handle; + CursorConfiguration = new SdlCursor(Sdl); + InitializeEventQueue(out _silkEvents); + + // =============================================================================================== + // === If we ever need to share common state across window-specific "backends", use the below: === + // =============================================================================================== + // // Get the root surface - our windowing backend assumes there is only one root surface. If this is not the + // // case then this is undefined behaviour. + // var rootSurface = info.Window; + // var parent = rootSurface; + // while ((parent = Sdl.GetWindowParent(rootSurface)) != nullptr) + // { + // rootSurface = parent; + // } + // // Get the surface properties. + // var props = Sdl.GetWindowProperties(rootSurface); + // if (props == 0) + // { + // Sdl.ThrowError(); + // } + // // Get or create the root object. + // Ref pname = "org.dotnetfoundation.silkdotnet.inputroot"; + // var root = (nint)Sdl.GetPointerProperty(props, pname, nullptr); + // if (root != 0) + // { + // Root = + // GCHandle.FromIntPtr(root).Target as SdlBackendRoot + // ?? throw new InvalidOperationException( + // "The global input data for this ancestry of SDL windows was not in an expected format." + // ); + // } + // else + // { + // Root = new SdlBackendRoot(); + // var newHandle = GCHandle.Alloc(Root); + // if ( + // Sdl.SetPointerPropertyWithCleanup( + // props, + // pname, + // (Ptr)GCHandle.ToIntPtr(newHandle), + // new CleanupPropertyCallback(&CleanupRoot), + // nullptr + // ) + // ) + // { + // return; + // } + // newHandle.Free(); + // Sdl.ThrowError(); + // } + // // Register ourselves with the root. + // Root.Backends.Add(this, null); + // Id = (nint)Root.EventFilter.Handle + Root.Backends.Count() - 1; + + return; + static void InitializeEventQueue(out SilkEventContext context) + { + // Create our event queue with maximal timestamp accuracy + + // The SDL timestamps deal in nanoseconds, so we take multiple measurements to get the most accurate + // relationship between SDL and Stopwatch timeestamps + const byte measurementCount = 4; + Span calibrations = stackalloc SdlTimestampCalculator.Basis[measurementCount]; + for (byte i = 0; i < measurementCount; i++) + { + long nowTimestamp; + ulong nowSdl; + + // alternate the order in which we do it, so we get a more accurate average that is not influenced + // as much by the time it takes to acquire each type of measurement + if (i % 2 == 0) + { + nowTimestamp = Stopwatch.GetTimestamp(); + nowSdl = Silk.NET.SDL.Sdl.GetTicksNS(); + } + else + { + nowSdl = Silk.NET.SDL.Sdl.GetTicksNS(); + nowTimestamp = Stopwatch.GetTimestamp(); + } + + calibrations[i] = new SdlTimestampCalculator.Basis(nowSdl, nowTimestamp); + } + + context = new SilkEventContext(calibrations.Average()); + } + } + + // [UnmanagedCallersOnly] + // private static unsafe void CleanupRoot(void* _, void* value) + // { + // var gch = GCHandle.FromIntPtr((nint)value); + // (gch.Target as SdlBackendRoot)?.Dispose(); + // gch.Free(); + // } + // public SdlBackendRoot Root { get; } + + + // TODO we can't query support for these modes, but should we try-it-and-see to be accurate? + + // TODO if you're using one input context for all windows, there is no way to specify a window for grabbed cursor mode + + + // This is complicated, as the input proposal mandates that nothing happens until Update is called (so the events + // can be received on the given actor) but to also track logical events that happen between calls (i.e. from a + // timestamp perspective). Compound this with the fact that the user might do something silly like make multiple + // input backends (which is feasible for multiple windows I guess), or not be running anything other than input + // (having obviously created a window beforehand but not actually polling events I guess) + public void Update(IInputHandler? handler = null) + { + if (!_pumped) + { + Sdl.PumpEvents(); + } + + _pumped = false; + if (handler == null) + { + _pumpedSdlEvents.Clear(); + return; + } + + // todo - do we want this before or after the event processing? or should + // it always just be done in the same way as other input events? e.g. via events + // windows can change without input events being processed... but who cares? as long as the devices + // have the latest information when they're updated, we should be good? + UpdatePointerTargets(_eventProcessingArgs.SdlWindowTargets, _eventProcessingArgs.SdlDisplayTargets); + + // actually process the events + if (!_pumpedSdlEvents.HasEvents) + { + return; + } + + while (_pumpedSdlEvents.TryDequeue(out var evt)) + { + _pumpedSdlEventsSorted.Add(evt); + } + + var sortedSpan = CollectionsMarshal.AsSpan(_pumpedSdlEventsSorted); + sortedSpan.StableSort((x, y) => x.Event.Common.Timestamp.CompareTo(y.Event.Common.Timestamp)); + + foreach (var evt in _pumpedSdlEventsSorted) + { + ProcessEvent(evt.Event, evt.Timestamp, ref _eventProcessingArgs); + } + + _pumpedSdlEventsSorted.Clear(); + + foreach (var device in _eventProcessingArgs.Devices) + { + if (device is INeedFinalizationEachFrame needer) + { + needer.FinalizeUpdate(); + } + } + + _silkEvents.RaiseEvents(handler); + } + + + + // ?? [UnmanagedFunctionPointer()] + private unsafe byte OnEvent(void* arg0, Event* arg1) + { + _pumped = true; + _pumpedSdlEvents.Add(ref *arg1); + return 1; + } + + private static void ProcessEvent(in Event evt, long timestamp, ref ProcessEventArgs processEventArgs) + { + var backend = processEventArgs.Backend; + var devices = processEventArgs.Devices; + Debug.Assert(evt.Common.Timestamp >= processEventArgs.PreviousTimestamp, "Events out of order"); + processEventArgs.PreviousTimestamp = evt.Common.Timestamp; + + // ReSharper disable once SwitchStatementMissingSomeEnumCasesNoDefault + var type = (EventType)evt.Common.Type; + + switch (type) + { + case EventType.GamepadAdded: + return; + case EventType.GamepadRemoved: + backend.RemoveDevice(devices, evt.Gdevice.Which); + return; + case EventType.JoystickRemoved: + backend.RemoveDevice(devices, evt.Jdevice.Which); + return; + case EventType.KeyboardRemoved: + backend.RemoveDevice(devices, evt.Kdevice.Which); + return; + case EventType.MouseRemoved: + backend.RemoveDevice(devices, evt.Mdevice.Which); + return; + case EventType.PenProximityOut: + backend.RemoveDevice(devices, evt.Ptouch.Which); + break; + + // Keyboard events + case >= EventType.KeyDown and <= EventType.TextEditingCandidates: + { + if (!backend.TryGetOrCreateDevice(evt.Kdevice.Which, out var keyboard)) + { + return; + } + + switch (type) + { + case EventType.KeyboardAdded: + return; + case EventType.KeyDown: + case EventType.KeyUp: + keyboard.AddKeyEvent(evt.Key, timestamp); + break; + case EventType.TextEditing: + keyboard.AddTextEditingEvent(evt.Edit); + break; + case EventType.TextEditingCandidates: + keyboard.AddTextCandidatesEvent(evt.EditCandidates); + break; + case EventType.TextInput: + keyboard.AddTextInputEvent(evt.Text); + break; + } + + break; + } + + #region Joysticks + + // Gamepad events + case >= EventType.GamepadAxisMotion and <= EventType.GamepadSteamHandleUpdated: + { + if (!backend.TryGetOrCreateDevice(evt.Gdevice.Which, out var gamepad)) + { + return; + } + + switch (type) + { + case EventType.GamepadAxisMotion: + gamepad.AddAxisEvent(evt.Gaxis.Axis, evt.Gaxis.Value, evt.Gaxis.Timestamp, timestamp); + break; + case EventType.GamepadButtonDown: + case EventType.GamepadButtonUp: + gamepad.AddButtonEvent(evt.Gbutton.Button, evt.Gbutton.Down, evt.Gbutton.Timestamp, timestamp); + break; + case EventType.GamepadRemapped: + gamepad.Remap(); + break; + + // todo - sensor + touchpad + case EventType.GamepadTouchpadDown: + case EventType.GamepadTouchpadMotion: + case EventType.GamepadTouchpadUp: + case EventType.GamepadSensorUpdate: + case EventType.GamepadUpdateComplete: + case EventType.GamepadSteamHandleUpdated: + break; + } + + break; + } + + // Joystick events + case >= EventType.JoystickAxisMotion and <= EventType.JoystickUpdateComplete: + { + if (!backend.TryGetOrCreateDevice(evt.Jdevice.Which, out var joystick)) + { + return; + } + + switch (type) + { + case EventType.JoystickAdded: + return; + case EventType.JoystickAxisMotion: + joystick.AddAxisEvent(evt.Jaxis.Axis, evt.Jaxis.Value, evt.Jaxis.Timestamp, timestamp); + break; + case EventType.JoystickBallMotion: + // todo: ball events? + break; + case EventType.JoystickHatMotion: + joystick.AddHatEvent(evt.Jhat.Hat, evt.Jhat.Value, evt.Jhat.Timestamp, timestamp); + break; + case EventType.JoystickButtonDown: + case EventType.JoystickButtonUp: + joystick.AddButtonEvent(evt.Jbutton.Button, evt.Jbutton.Down, evt.Jbutton.Timestamp, timestamp); + break; + case EventType.JoystickBatteryUpdated: + break; + case EventType.JoystickUpdateComplete: + break; + } + + break; + } + + #endregion + + #region Pointers + + // Mouse events + case >= EventType.MouseMotion and <= EventType.MouseAdded: + { + if (!backend.TryGetOrCreateDevice(evt.Mdevice.Which, out var mouse)) + { + return; + } + + switch (type) + { + case EventType.MouseAdded: + return; + case EventType.MouseMotion: + mouse.AddMotion(evt.Motion, timestamp); + break; + case EventType.MouseButtonDown: + case EventType.MouseButtonUp: + mouse.AddButtonEvent(evt.Button, timestamp); + break; + case EventType.MouseWheel: + mouse.AddWheelEvent(evt.Wheel, timestamp); + break; + } + + break; + } + + // Pen events + case >= EventType.PenProximityIn and <= EventType.PenAxis: + { + Debug.Assert(type != EventType.PenProximityOut); + + var which = evt.Ptouch.Which; + if (!backend.TryGetOrCreateDevice(which, out var penDevice)) + { + return; + } + + + switch (type) + { + case EventType.PenProximityIn: + { + return; + } + case EventType.PenDown: + case EventType.PenUp: + { + penDevice.UpDownEvent(evt.Ptouch, timestamp); + break; + } + case EventType.PenButtonDown: + case EventType.PenButtonUp: + { + penDevice.ButtonEvent(evt.Pbutton, timestamp); + break; + } + case EventType.PenMotion: + { + penDevice.MotionEvent(evt.Pmotion, timestamp); + break; + } + case EventType.PenAxis: + { + penDevice.AxisEvent(evt.Paxis, timestamp); + break; + } + } + + break; + } + + // Touch events + case >= EventType.FingerDown and <= EventType.FingerCanceled: + { + var finger = evt.Tfinger; + var device = finger.TouchID; + if (!backend.TryGetOrCreateDevice(device, out var touchDevice)) + { + return; + } + + touchDevice.Event(finger, (FingerEventType)finger.Type, timestamp); + break; + } + + #endregion + } + + #region unimplemented + + switch (type) + { + // Input events ---------------------------------------------------------- + + // sensor? for what? + case EventType.SensorUpdate: + { + break; + } + + // Display & window (pointer target) events ---------------------------- + // todo - update pointer targets list based on add/remove? + // unless the way we currently collect them is sufficient + // (see PopulatePointerTargets in SdlInputBackend.Targets.cs) + case EventType.DisplayOrientation: + case EventType.DisplayAdded: + case EventType.DisplayRemoved: + case EventType.DisplayMoved: + case EventType.DisplayDesktopModeChanged: + case EventType.DisplayCurrentModeChanged: + case EventType.DisplayContentScaleChanged: + { + var bounds = SdlBoundedPointerTarget.CalculateAllDisplayBounds(backend.Sdl); + var x = (QueuedEventType.BoundedPointerTargetUpdate, + evt.Common.Timestamp, + bounds.Min.ToSystem(), + bounds.Max.ToSystem() + ); + + InputLog.Debug($"Display bounds changed: {x.BoundedPointerTargetUpdate}"); + break; + } + case EventType.WindowMouseLeave + : // do we need to do anything? we should probably track the current window of the pointer + { + //var x = (QueuedEventType.MouseExitedWindow, timestamp); + break; + } + } + + #endregion + } + + + private unsafe void ReleaseUnmanagedResources() + { + Sdl.RemoveEventWatch( + new EventFilter((delegate* unmanaged)(void*)Id), + nullptr + ); + SilkMarshal.Free((Ptr)Id); + } + + public void Dispose() + { + ReleaseUnmanagedResources(); + GC.SuppressFinalize(this); + } + + + ~SdlInputBackend() => ReleaseUnmanagedResources(); + + internal unsafe bool TryGetPointerTargetForWindow(WindowHandle window, + [NotNullWhen(true)] out IPointerTarget? target) + { + if (window.Handle == null) + { + target = null; + return false; + } + + var id = Sdl!.GetWindowID(window); + return TryGetPointerTargetForWindow(id, out target); + } + + internal bool TryGetPointerTargetForWindow(uint id, + [NotNullWhen(true)] out IPointerTarget? target) + { + if (id == 0) + { + target = null; + return false; + } + + target = _eventProcessingArgs.SdlWindowTargets.FirstOrDefault(x => x.Id == id); + return target != null; + } + + private readonly struct TimedRawSdlEvent + { + public readonly long Timestamp; + public readonly Event Event; + + public TimedRawSdlEvent(Event @event, long timestamp) + { + Event = @event; + Timestamp = timestamp; + } + } + + private class SdlEventQueue + { + private TimedRawSdlEvent[] _events = new TimedRawSdlEvent[256]; + private int _nextEventIndex; + public void Add(ref Event p0) + { + var timestamp = Stopwatch.GetTimestamp(); + _isSorted = false; + if (_nextEventIndex == _events.Length) + { + Array.Resize(ref _events, _events.Length * 2); + } + + _events[_nextEventIndex++] = new TimedRawSdlEvent(p0, timestamp); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public bool TryDequeue(out TimedRawSdlEvent p0) + { + if (_nextEventIndex == 0) + { + p0 = default; + return false; + } + + if (!_isSorted) + { + // sort the events by timestamp + var span = _events.AsSpan(0, _nextEventIndex); + + // order in descending order, such that "de-queueing" the last event will return the first chronological event in the queue (last event in the array) + span.StableSort((e1, e2) => e2.Timestamp.CompareTo(e1.Timestamp)); + _isSorted = true; + } + + p0 = _events[--_nextEventIndex]; + return true; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void Clear() + { + _nextEventIndex = 0; + _isSorted = false; + } + + public bool HasEvents => _nextEventIndex > 0; + + private bool _isSorted; + + } + + private struct ProcessEventArgs + { + public readonly SdlInputBackend Backend; + public readonly List Devices; + public readonly List SdlWindowTargets; + public readonly List SdlDisplayTargets; + public ulong PreviousTimestamp; + + public ProcessEventArgs(SdlInputBackend backend) + { + Backend = backend; + PreviousTimestamp = ulong.MinValue; + Devices = []; + SdlWindowTargets = []; + SdlDisplayTargets = []; + } + } + + internal enum FingerEventType : uint + { + Down = EventType.FingerDown, + Up = EventType.FingerUp, + Motion = EventType.FingerMotion, + Canceled = EventType.FingerCanceled + } + + private enum QueuedEventType : byte + { + /// + /// The mouse has exited the window and the shared point should be marked inactive until proven otherwise by + /// further mouse motion (indicating it has entered another window). + /// + /// + /// We do not track the mouse enter events as this would cause us to fire twice for a mouse entering a window: + /// once for the entering, and once for new position. + /// + MouseExitedWindow, + + /// + /// The display bounds have been changed, meaning that 's + /// will have changed. + /// + BoundedPointerTargetUpdate, + } + + private readonly HashSet _deviceRegistry = []; + + // NOTE: Be careful where these are used! + + private ProcessEventArgs _eventProcessingArgs; + private bool _pumped; + private readonly List _pumpedSdlEventsSorted = new(); + private readonly SdlEventQueue _pumpedSdlEvents = new(); + private readonly SilkEventContext _silkEvents; +} + + +[Flags] +internal enum SdlMouseInputFlags : uint +{ + LeftButtonDown = SDL.Sdl.ButtonLmask, + MiddleButtonDown = SDL.Sdl.ButtonMiddle, + RightButtonDown = SDL.Sdl.ButtonRmask, + XButton1Down = SDL.Sdl.ButtonX1Mask, + XButton2Down = SDL.Sdl.ButtonX2Mask, +} diff --git a/sources/Input/Input/Implementations/SDL3/SdlKeyConversions.cs b/sources/Input/Input/Implementations/SDL3/SdlKeyConversions.cs new file mode 100644 index 0000000000..fdcf6cb689 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/SdlKeyConversions.cs @@ -0,0 +1,104 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Runtime.CompilerServices; +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3; + +internal static class SdlKeyConversions +{ + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static KeyName ScancodeToKeyName(uint scancode) => (KeyName)scancode; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static KeyName ScancodeToKeyName(Scancode scancode) => ScancodeToKeyName((uint)scancode); + + public static unsafe KeyName SdlToKeyName(uint key, ISdl sdl, ushort? modState = null) + { + modState ??= sdl.GetModState(); + var modStateVal = modState.Value; + return (KeyName)sdl.GetScancodeFromKey(key, &modStateVal); + } + + /// + /// Maps an SDL key id to a without a reference to an SDL backend instance. + /// + /// The sdl key id + /// The associated key name + public static KeyName SdlToKeyName(uint key) => + // * indicates a shifted key + key switch { + Sdl.KApplication => KeyName.Application, + + >= Sdl.K1 and <= Sdl.K9 => (KeyName)(key - _numKeyDiff), + >= Sdl.Ka and <= Sdl.Kz => (KeyName)(key - _letterKeyDiff), + >= Sdl.KCapslock and <= Sdl.KKpEqualsas400 => (KeyName)(key - _systemAndKeypadDiff), + >= Sdl.KCancel and <= Sdl.KRgui => (KeyName)(key - _systemAndKeypadDiff), + >= Sdl.KMode and <= Sdl.KAcBookmarks => (KeyName)(key - _systemAndKeypadDiff), + >= Sdl.KSoftleft and <= Sdl.KEndcall => (KeyName)(key - _systemNonHidKeyDiff), + + Sdl.KDelete => KeyName.Delete, + Sdl.KUnknown => KeyName.Unknown, + Sdl.KReturn => KeyName.Return, + Sdl.KEscape => KeyName.Escape, + Sdl.KBackspace => KeyName.Backspace, + Sdl.KTab => KeyName.Tab, + Sdl.KSpace => KeyName.Space, + Sdl.KExclaim => KeyName.Number1, // * + Sdl.KDblapostrophe => KeyName.Apostrophe, // * + Sdl.KHash => KeyName.Number3, // * + Sdl.KDollar => KeyName.Number4, // * + Sdl.KPercent => KeyName.Number5, // * + Sdl.KAmpersand => KeyName.KeypadAmpersand, + Sdl.KApostrophe => KeyName.Apostrophe, + Sdl.KLeftparen => KeyName.KeypadLeftParenthesis, + Sdl.KRightparen => KeyName.KeypadRightParenthesis, + Sdl.KAsterisk => KeyName.KeypadAmpersand, + Sdl.KPlus => KeyName.Equals, // * + Sdl.KComma => KeyName.Comma, + Sdl.KMinus => KeyName.Minus, + Sdl.KPeriod => KeyName.Period, + Sdl.KSlash => KeyName.Slash, + Sdl.K0 => KeyName.Number0, + Sdl.KColon => KeyName.Semicolon, // * + Sdl.KSemicolon => KeyName.Semicolon, + Sdl.KLess => KeyName.Comma, // * + Sdl.KEquals => KeyName.Equals, + Sdl.KGreater => KeyName.Period, // * + Sdl.KQuestion => KeyName.Slash, // * + Sdl.KAt => KeyName.Number2, // * + Sdl.KLeftbracket => KeyName.LeftBracket, + Sdl.KBackslash => KeyName.Backslash, + Sdl.KRightbracket => KeyName.RightBracket, + Sdl.KCaret => KeyName.Number6, // * + Sdl.KUnderscore => KeyName.Minus, // * + Sdl.KGrave => KeyName.Grave, + Sdl.KLeftbrace => KeyName.LeftBracket, // * + Sdl.KPipe => KeyName.Backslash, // * + Sdl.KRightbrace => KeyName.RightBracket, // * + Sdl.KTilde => KeyName.Grave, // * + _ => (KeyName)key + }; + + /// + /// Converts a to an SDL key id. + /// + /// The name of the key you would like to get an Sdl key id for + /// Sdl backend instance + /// Will this key be used in a key event? + /// The current modifier key state + /// The sdl key id + public static uint KeyNameToSdl(KeyName key, ISdl sdl, bool asKeyEvent, ushort? modState = null) + { + modState ??= sdl.GetModState(); + var scanCode = (uint)key; + var asKeyEventByte = asKeyEvent ? (byte)1 : (byte)0; + return sdl.GetKeyFromScancode((Scancode)scanCode, modState.Value, asKeyEventByte); + } + + private const uint _letterKeyDiff = Sdl.Ka - (uint)KeyName.A; + private const uint _numKeyDiff = Sdl.K1 - (uint)KeyName.Number1; + private const uint _systemAndKeypadDiff = Sdl.KPrintscreen - (uint)KeyName.PrintScreen; + private const uint _systemNonHidKeyDiff = Sdl.KSoftleft - (uint)KeyName.SoftLeft; +} diff --git a/sources/Input/Input/Implementations/SDL3/SdlLog.cs b/sources/Input/Input/Implementations/SDL3/SdlLog.cs new file mode 100644 index 0000000000..ef8dd9d1c4 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/SdlLog.cs @@ -0,0 +1,45 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Runtime.CompilerServices; +using Silk.NET.SDL; + +namespace Silk.NET.Input.SDL3; + +internal static class SdlLog +{ + [Conditional("DEBUG")] + public static void Error(string? message = null, + [CallerFilePath] string? path = null, + [CallerLineNumber] int line = 0, + [CallerMemberName] string? member = null) + { + var log = GenerateLog(message); + InputLog.Error(log, path, line, member); + } + + + [Conditional("DEBUG")] + public static void Debug(string? message = null, + [CallerFilePath] string? path = null, + [CallerLineNumber] int line = 0, + [CallerMemberName] string? member = null) + { + var log = GenerateLog(message); + InputLog.Debug(log, path, line, member); + } + + private static unsafe string GenerateLog(string? message) + { + var error = Sdl.GetError(); + if (error.Native != null) + { + var sdlError = error.ReadToString(); + Sdl.ClearError(); + return $"{message ?? "SDL Error: "} {sdlError}"; + } + + return message ?? "Error: "; + } +} diff --git a/sources/Input/Input/Implementations/SDL3/SilkEventContext.cs b/sources/Input/Input/Implementations/SDL3/SilkEventContext.cs new file mode 100644 index 0000000000..5c9b93b932 --- /dev/null +++ b/sources/Input/Input/Implementations/SDL3/SilkEventContext.cs @@ -0,0 +1,170 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Silk.NET.Input.SDL3.Devices.Pointers; + +namespace Silk.NET.Input.SDL3; + +internal class SilkEventContext +{ + public ISdlEventQueue> ButtonChangedSdlEvents => _buttonChangedSdlEvents; + + public ISdlEventQueue ConnectionSdlEvents => _connectionSdlEvents; + + public ISdlEventQueue KeyChangedSdlEvents => _keyChangedSdlEvents; + + public ISdlEventQueue GamepadThumbstickMoveSdlEvents => + _gamepadThumbstickMoveSdlEvents; + + public ISdlEventQueue GamepadTriggerMoveSdlEvents => _gamepadTriggerMoveSdlEvents; + + public ISdlEventQueue JoystickAxisMoveSdlEvents => _joystickAxisMoveSdlEvents; + + public ISdlEventQueue JoystickHatMoveSdlEvents => _joystickHatMoveSdlEvents; + + public ISdlEventQueue KeyCharSdlEvents => _keyCharSdlEvents; + + public ISdlEventQueue MouseScrollSdlEvents => _mouseScrollSdlEvents; + + public ISdlEventQueue PointChangedSdlEvents => _pointChangedSdlEvents; + + public ISdlEventQueue PointerClickSdlEvents => _pointerClickSdlEvents; + + public ISdlEventQueue PointerGripChangedSdlEvents => _pointerGripChangedSdlEvents; + + public ISdlEventQueue PointerTargetChangedSdlEvents => + _pointerTargetChangedSdlEvents; + + public ISdlEventQueue> PointerButtonSdlEvents => _pointerButtonSdlEvents; + + private readonly SdlEventQueue> _buttonChangedSdlEvents = new(); + private readonly SdlEventQueue _connectionSdlEvents = new(); + private readonly SdlEventQueue _keyChangedSdlEvents = new(); + private readonly SdlEventQueue _gamepadThumbstickMoveSdlEvents = new(); + private readonly SdlEventQueue _gamepadTriggerMoveSdlEvents = new(); + private readonly SdlEventQueue _joystickAxisMoveSdlEvents = new(); + private readonly SdlEventQueue _joystickHatMoveSdlEvents = new(); + private readonly SdlEventQueue _keyCharSdlEvents = new(); + private readonly SdlEventQueue _mouseScrollSdlEvents = new(); + private readonly SdlEventQueue _pointChangedSdlEvents = new(); + private readonly SdlEventQueue _pointerClickSdlEvents = new(); + private readonly SdlEventQueue> _pointerButtonSdlEvents = new(); + private readonly SdlEventQueue _pointerGripChangedSdlEvents = new(); + private readonly SdlEventQueue _pointerTargetChangedSdlEvents = new(); + private readonly GenericEventQueue _orderedSdlEvents; + + public SilkEventContext(SdlTimestampCalculator.Basis basis) => + _orderedSdlEvents = new GenericEventQueue(basis); + + public void RaiseEvents(params Span handlers) + { + _orderedSdlEvents.ConsumeQueue(_buttonChangedSdlEvents); + _orderedSdlEvents.ConsumeQueue(_connectionSdlEvents); + _orderedSdlEvents.ConsumeQueue(_keyChangedSdlEvents); + _orderedSdlEvents.ConsumeQueue(_gamepadThumbstickMoveSdlEvents); + _orderedSdlEvents.ConsumeQueue(_gamepadTriggerMoveSdlEvents); + _orderedSdlEvents.ConsumeQueue(_joystickAxisMoveSdlEvents); + _orderedSdlEvents.ConsumeQueue(_joystickHatMoveSdlEvents); + _orderedSdlEvents.ConsumeQueue(_keyCharSdlEvents); + _orderedSdlEvents.ConsumeQueue(_mouseScrollSdlEvents); + _orderedSdlEvents.ConsumeQueue(_pointChangedSdlEvents); + _orderedSdlEvents.ConsumeQueue(_pointerClickSdlEvents); + _orderedSdlEvents.ConsumeQueue(_pointerGripChangedSdlEvents); + _orderedSdlEvents.ConsumeQueue(_pointerTargetChangedSdlEvents); + _orderedSdlEvents.ConsumeQueue(_pointerButtonSdlEvents); + + var genericEvents = _orderedSdlEvents.ConsumeAndGetSorted(); + + if (handlers is not { Length: > 0 }) + { + return; + } + + foreach (var evt in genericEvents) + { + if (evt.Type == typeof(PointChangedEvent)) + { + RaiseEvent(handlers, evt.Value()); + } + else if (evt.Type == typeof(PointerClickEvent)) + { + RaiseEvent(handlers, evt.Value()); + } + else if (evt.Type == typeof(ButtonChangedEvent)) + { + RaiseEvent(handlers, evt.Value>()); + } + else if (evt.Type == typeof(PointerGripChangedEvent)) + { + RaiseEvent(handlers, evt.Value()); + } + else if (evt.Type == typeof(PointerTargetChangedEvent)) + { + RaiseEvent(handlers, evt.Value()); + } + else if (evt.Type == typeof(ButtonChangedEvent)) + { + RaiseEvent(handlers, evt.Value>()); + } + else if (evt.Type == typeof(ButtonChangedEvent)) + { + RaiseEvent(handlers, evt.Value>()); + } + else if (evt.Type == typeof(ConnectionEvent)) + { + RaiseEvent(handlers, evt.Value()); + } + else if (evt.Type == typeof(KeyChangedEvent)) + { + RaiseEvent(handlers, evt.Value()); + } + else if (evt.Type == typeof(GamepadThumbstickMoveEvent)) + { + RaiseEvent(handlers, evt.Value()); + } + else if (evt.Type == typeof(GamepadTriggerMoveEvent)) + { + RaiseEvent(handlers, evt.Value()); + } + else if (evt.Type == typeof(JoystickAxisMoveEvent)) + { + RaiseEvent(handlers, evt.Value()); + } + else if (evt.Type == typeof(JoystickHatMoveEvent)) + { + RaiseEvent(handlers, evt.Value()); + } + else if (evt.Type == typeof(KeyCharEvent)) + { + RaiseEvent(handlers, evt.Value()); + } + else if (evt.Type == typeof(MouseScrollEvent)) + { + RaiseEvent(handlers, evt.Value()); + } + else + { + throw new InvalidOperationException("Invalid type: " + evt.Type); + } + } + + return; + + static void RaiseEvent(Span handlers, in TItem evt) + where TItem : struct, ITimestampedEvent + { + for (var index = 0; index < handlers.Length; index++) + { + var handler = handlers[index]; + if (handler is IInputHandler appropriateHandler) + { + appropriateHandler.Handle(evt); + } + else + { + InputLog.Debug($"Unhandled event type {typeof(TItem).Name} from {handler.GetType().Name}."); + } + } + } + } +} diff --git a/sources/Input/Input/InputContextDeviceList.cs b/sources/Input/Input/InputContextDeviceList.cs new file mode 100644 index 0000000000..2ca6107083 --- /dev/null +++ b/sources/Input/Input/InputContextDeviceList.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections; +using System.Diagnostics.CodeAnalysis; + +namespace Silk.NET.Input; + +/// +/// An internal class that represents a list of that are assignable to +/// . The backing list is lazily initialized. +/// +/// The device type. +/// +/// This type is not intended for public consumption and has no API/ABI stability guarantees. +/// +[Experimental( + "ST0005", + UrlFormat = "https://dotnet.github.io/Silk.NET/docs/v3/silk.net/diagnostics/{0}" +)] +public abstract class InputContextDeviceList : IReadOnlyList, IInputHandler +{ + private readonly InputContext _ctx; + private List? _list; + + internal InputContextDeviceList(InputContext ctx) => _ctx = ctx; + + private List List => _list ??= _ctx.Devices.OfType().ToList(); + + /// + public IEnumerator GetEnumerator() => List.GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + + /// + public int Count => List.Count; + + /// + public T this[int index] => List[index]; + + void IInputHandler.HandleDeviceConnectionChanged(ConnectionEvent @event) => + HandleDeviceConnectionChanged(@event); + + /// + protected internal virtual void HandleDeviceConnectionChanged(ConnectionEvent @event) + { + if (_list is null || @event.Device is not T t) + { + return; + } + + if (@event.IsConnected) + { + _list.Add(t); + } + else + { + _list.Remove(t); + } + } +} diff --git a/sources/Input/Input/InputLog.cs b/sources/Input/Input/InputLog.cs new file mode 100644 index 0000000000..fdc0c51e40 --- /dev/null +++ b/sources/Input/Input/InputLog.cs @@ -0,0 +1,47 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Runtime.CompilerServices; + +namespace Silk.NET.Input; + +internal static class InputLog +{ + [Conditional("DEBUG")] + public static void Error(string? message = null, + [CallerFilePath] string? path = null, + [CallerLineNumber] int line = 0, + [CallerMemberName] string? member = null) + { + var log = GenerateLog(message, path, line, member); + Console.Error.WriteLine(log); + } + + private static string GenerateLog(string? message, string? path, int line, string? member) + { + const string traceFmt = "{0} at {1}:{2}"; + return $"{message} ({string.Format(traceFmt, member, path, line)})"; + } + + [Conditional("DEBUG")] + public static void Debug(string? message = null, + [CallerFilePath] string? path = null, + [CallerLineNumber] int line = 0, + [CallerMemberName] string? member = null) + { + var log = GenerateLog(message, path, line, member); + Console.WriteLine(log); + } + + + [Conditional("DEBUG")] + public static void Warn(string? message = null, + [CallerFilePath] string? path = null, + [CallerLineNumber] int line = 0, + [CallerMemberName] string? member = null) + { + var log = GenerateLog(message, path, line, member); + Console.WriteLine(log); + } +} diff --git a/sources/Input/Input/InputMarshal.cs b/sources/Input/Input/InputMarshal.cs new file mode 100644 index 0000000000..cd9d45e4de --- /dev/null +++ b/sources/Input/Input/InputMarshal.cs @@ -0,0 +1,685 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections; +using System.Diagnostics; +using System.Numerics; +using System.Runtime.CompilerServices; + +namespace Silk.NET.Input; + +/// +/// Contains utilities for creating and manipulating s. This is a very unsafe set of +/// APIs that are extremely prone to misuse, and therefore is not recommended to be consumed by anyone other than input +/// backends. +/// +/// +/// This class is ABI/API stable, but new APIs that obsolete the old ones may be added at any time as more efficient +/// implementations are discovered. +/// +// NOTE: Not experimental so that we don't eliminate the prospects of third-party implementations. +public static class InputMarshal +{ + /// + /// A wrapper class denoting ownership of a . This is used to attempt to stop + /// misuse of these methods, but of course it's fairly trivial to work around this for a user determined to do + /// terrible things. + /// + /// The list element type. + public struct ListOwner + { + internal ListOwner(InputReadOnlyList list) => List = list; + + /// + /// Gets the list owned by this owner. + /// + public InputReadOnlyList List { get; } + } + + internal class ButtonList(uint[] binary, Dictionary>? other) + : IReadOnlyList> + where T : unmanaged, Enum + { + private Dictionary>? _other = other; + + public ButtonList() + : this(new uint[(GetButtonListCount() + 32 - 1) / 32], null) { } + + public ButtonList Clone() => + new([.. binary], _other is null ? null : new Dictionary>(_other)); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] // <-- generic specialisation + public IEnumerator> GetEnumerator() => + typeof(T) == typeof(KeyName) ? GetKeyNameEnumerator() : GetButtonEnumerator(); + + private IEnumerator> GetKeyNameEnumerator() + { + var idx = 0; + var bit = 0; + // To determine the gaps, run the GetButtonCount unit test. The equality check is the LHS from the output + + // 1, and the assignment is the RHS - 1. Example output below: + // 0 (Unknown), 4 (A) + // 129 (VolumeDown), 133 (KeypadComma) + // 164 (ExtendSelect), 176 (Keypad00) + // 221 (KeypadHexadecimal), 224 (ControlLeft) + // 231 (SuperRight), 257 (Mode) + // 286 (ApplicationBookmarks), 501 (SoftLeft) + for (var cur = (int)KeyName.A; cur <= (int)KeyName.EndCall; cur++) + { + switch (cur) + { + case (int)KeyName.VolumeDown + 1: + cur = (int)KeyName.KeypadComma - 1; + continue; + case (int)KeyName.ExtendSelect + 1: + cur = (int)KeyName.Keypad00 - 1; + continue; + case (int)KeyName.KeypadHexadecimal + 1: + cur = (int)KeyName.ControlLeft - 1; + continue; + case (int)KeyName.SuperRight + 1: + cur = (int)KeyName.Mode - 1; + continue; + case (int)KeyName.ApplicationBookmarks + 1: + cur = (int)KeyName.SoftLeft - 1; + continue; + } + + var ret = ElementAt((T)(object)(KeyName)cur, idx, bit); + (idx, bit) = BitIterate(idx, bit); + yield return ret; + } + } + + private IEnumerator> GetButtonEnumerator() + { + var max = GetButtonListCount(); + int idx = 0, + bit = 0; + for (var i = 1; i <= max; i++) + { + var ret = ElementAt(SilkMarshal.ConstCast(i), idx, bit); + (idx, bit) = BitIterate(idx, bit); + yield return ret; + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private Button ElementAt(T name, int idx, int bit) + { + var ret = new Button(name, false, 0); + var isBinaryDown = BitOperations.PopCount(binary[idx] & (1U << (7 - bit))) > 0; + if (isBinaryDown) + { + ret = ret with { IsDown = true, Pressure = 1 }; + } + else + { + _other?.TryGetValue(name, out ret); + } + + return ret; + } + + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + private static (int, int) BitIterate(int idx, int bit) => + ++bit == 32 ? (++idx, 0) : (idx, bit); + + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + + public int Count => GetButtonListCount(); + + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + internal static T IndexName(int index) + { + var name = index; + if (typeof(T) == typeof(KeyName)) + { + // To determine the gaps, run the GetButtonCount unit test. The condition is to check whether name + // is greater than the LHS, and if so add the RHS less the LHS less 1. Example output: + // 0 (Unknown), 4 (A) + // 129 (VolumeDown), 133 (KeypadComma) + // 164 (ExtendSelect), 176 (Keypad00) + // 221 (KeypadHexadecimal), 224 (ControlLeft) + // 231 (SuperRight), 257 (Mode) + // 286 (ApplicationBookmarks), 501 (SoftLeft) + name += 4; + if (name > 129) + { + name += 133 - 129 - 1; + } + + if (name > 164) + { + name += 176 - 164 - 1; + } + + if (name > 221) + { + name += 224 - 221 - 1; + } + + if (name > 231) + { + name += 257 - 231 - 1; + } + + if (name > 286) + { + name += 501 - 286 - 1; + } + } + else + { + // To account for Unknown = 0. + name++; + } + + return SilkMarshal.ConstCast(name); + } + + [MethodImpl( + MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization + )] + internal static int NameIndex(T name) + { + var index = SilkMarshal.ConstCast(name); + if (typeof(T) == typeof(KeyName)) + { + // To determine the gaps, run the GetButtonCount unit test. The condition is to check whether name + // is greater than the LHS, and if so subtract the RHS less the LHS less 1. Note that the conditions + // should be in reverse order i.e. from the last output line to the first output line. Example output: + // 0 (Unknown), 4 (A) + // 129 (VolumeDown), 133 (KeypadComma) + // 164 (ExtendSelect), 176 (Keypad00) + // 221 (KeypadHexadecimal), 224 (ControlLeft) + // 231 (SuperRight), 257 (Mode) + // 286 (ApplicationBookmarks), 501 (SoftLeft) + if (index > 286) + { + index -= 501 - 286 - 1; + } + + if (index > 231) + { + index -= 257 - 231 - 1; + } + + if (index > 221) + { + index -= 224 - 221 - 1; + } + + if (index > 164) + { + index -= 176 - 164 - 1; + } + + if (index > 129) + { + index -= 133 - 129 - 1; + } + index -= 4; + } + else + { + // To account for Unknown = 0. + index--; + } + + return index; + } + + public Button this[int index] + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ArgumentOutOfRangeException.ThrowIfNegative(index); + ArgumentOutOfRangeException.ThrowIfGreaterThan(index, Count); + return ElementAt( + IndexName(index), + Math.DivRem(index, 32, out var remainder), + remainder + ); + } + } + + public Button this[T name] + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + var index = NameIndex(name); + if (index >= 0 && index < GetButtonListCount()) + { + return ElementAt(name, Math.DivRem(index, 32, out var remainder), remainder); + } + + Throw(); + return default; + [StackTraceHidden] + static void Throw() => throw new ArgumentOutOfRangeException(nameof(name)); + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public void Set(Button btn, bool isBinary) + { + if (btn.IsDown && isBinary) + { + binary[Math.DivRem(NameIndex(btn.Name), 32, out var bit)] |= 1U << (7 - bit); + _other?.Remove(btn.Name); + } + else + { + binary[Math.DivRem(NameIndex(btn.Name), 32, out var bit)] &= ~(1U << (7 - bit)); + } + + if (!isBinary) + { + (_other ??= [])[btn.Name] = btn; + } + } + } + + /// + /// Gets the reported by s created with + /// for the given . + /// + /// The button name type. + /// + /// The number of buttons that will be in a button list created with , or -1 if + /// is not a supported button name type. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)] + public static int GetButtonListCount() + { + if (typeof(T) == typeof(JoystickButton)) + { + return EnumInfo.UniqueValues.Count; + } + + if (typeof(T) == typeof(PointerButton)) + { + return EnumInfo.UniqueValues.Count; + } + + if (typeof(T) == typeof(KeyName)) + { + // To determine the ranges, run the GetButtonCount unit test. The RHS of the subtraction statements below + // are the RHS of the line output, and the LHS is the LHS of the following line in its output. There is a + // final addition that is the number of preceding additions to account for the boundary values. Example + // output from that test: + // 0 (Unknown), 4 (A) + // 129 (VolumeDown), 133 (KeypadComma) + // 164 (ExtendSelect), 176 (Keypad00) + // 221 (KeypadHexadecimal), 224 (ControlLeft) + // 231 (SuperRight), 257 (Mode) + // 286 (ApplicationBookmarks), 501 (SoftLeft) + // ReSharper disable once ArrangeRedundantParentheses <-- stylistic choice + return ((int)KeyName.VolumeDown - (int)KeyName.A) + + ((int)KeyName.ExtendSelect - (int)KeyName.KeypadComma) + + ((int)KeyName.KeypadHexadecimal - (int)KeyName.Keypad00) + + ((int)KeyName.SuperRight - (int)KeyName.ControlLeft) + + ((int)KeyName.ApplicationBookmarks - (int)KeyName.Mode) + + ((int)KeyName.EndCall - (int)KeyName.SoftLeft) + + 6; + } + + return -1; + } + + /// + /// Creates a wrapping the given button . + /// + /// The list. + /// The button name type. + /// The button list. + [MethodImpl(MethodImplOptions.AggressiveInlining)] // <-- generic specialisation + public static ButtonReadOnlyList AsButtonList(this InputReadOnlyList> list) + where T : unmanaged, Enum => new(list); + + /// + /// Creates a wrapping the given . + /// + /// The list. + /// The button name type. + /// The button list. + public static InputReadOnlyList> AsInputList(this ButtonReadOnlyList list) + where T : unmanaged, Enum => new(list); + + /// + /// Creates a new for the given , optionally with the + /// given where is applicable for this + /// . + /// + /// The capacity. + /// The element type. + /// The list. + [MethodImpl(MethodImplOptions.AggressiveInlining)] // <-- generic specialisation + public static ListOwner CreateList(int capacity = 0) + { + if (typeof(T) == typeof(Button)) + { + return (ListOwner) + (object) + new ListOwner>( + new InputReadOnlyList>(new ButtonList()) + ); + } + + if (typeof(T) == typeof(Button)) + { + return (ListOwner) + (object) + new ListOwner>( + new InputReadOnlyList>( + new ButtonList() + ) + ); + } + + if (typeof(T) == typeof(Button)) + { + return (ListOwner) + (object) + new ListOwner>( + new InputReadOnlyList>( + new ButtonList() + ) + ); + } + + return new ListOwner(new InputReadOnlyList((new List(capacity)))); + } + + /// + /// Creates a new from the given . This is + /// equivalent to , but returns a + /// instead. + /// + /// The elements to populate the list with. + /// + /// + /* public static ListOwner Clone(IReadOnlyList other) + { + // ReSharper disable once InvertIf <-- starting to really dislike this as it duplicates code + if (other is InputReadOnlyList irl) + { + if (typeof(T) == typeof(Button)) + { + return new ListOwner( + new InputReadOnlyList(Unsafe.As>(irl.Data).Clone()) + ); + } + + if (typeof(T) == typeof(Button)) + { + return new ListOwner( + new InputReadOnlyList(Unsafe.As>(irl.Data).Clone()) + ); + } + + if (typeof(T) == typeof(Button)) + { + return new ListOwner( + new InputReadOnlyList( + Unsafe.As>(irl.Data).Clone() + ) + ); + } + } + + if (typeof(T) == typeof(Button)) + { + return new ListOwner( + new InputReadOnlyList(CloneButtonList((IReadOnlyList>)other)) + ); + } + + if (typeof(T) == typeof(Button)) + { + return new ListOwner( + new InputReadOnlyList( + CloneButtonList((IReadOnlyList>)other) + ) + ); + } + + // ReSharper disable once ConvertIfStatementToReturnStatement <-- stylistic choice + if (typeof(T) == typeof(Button)) + { + return new ListOwner( + new InputReadOnlyList( + CloneButtonList((IReadOnlyList>)other) + ) + ); + } + + return new ListOwner(new InputReadOnlyList((object)new List(other))); + static ButtonList CloneButtonList(IReadOnlyList> list) + where TEnum : unmanaged, Enum + { + var ret = new ButtonList(); + foreach (var button in list) + { + ret.Set( + button, + (button.IsDown && button.Pressure >= 1.0) + || (!button.IsDown && button.Pressure <= 0.0) + ); + } + + return ret; + } + } +*/ + /// + /// Sets the button state in the given button list. + /// + /// The list to update. + /// The new state of the button. + /// + /// Whether the of can only be 1.0 when + /// is true, and 0.0 when is + /// false. + /// + /// The button type. + [MethodImpl(MethodImplOptions.AggressiveInlining)] // <-- generic specialisation + public static void SetButtonState(ListOwner> list, Button value, bool isBinary) + where T : unmanaged, Enum + { + if ( + typeof(T) == typeof(KeyName) + || typeof(T) == typeof(JoystickButton) + || typeof(T) == typeof(PointerButton) + ) + { + Unsafe.As>(list.List.Data).Set(value, isBinary); + return; + } + + var underlying = GetUnderlyingList(list)!; + for (var i = 0; i < underlying.Count; i++) + { + // ReSharper disable once InvertIf <-- this literally results in more lines of code!!!!! + if (underlying[i].Name.Equals(value.Name)) + { + underlying[i] = value; + return; + } + } + + underlying.Add(value); + } + + /// + /// Attempts to retrieve the underlying implementation, provided that + /// for the given is implemented as a sequential list + /// with individually addressable and a variable number of elements. + /// + /// The list. + /// The list element type. + /// + /// The list, or null if the optimised implementation of cannot be + /// expressed as an . + /// + /// + /// Currently, this can be assumed to not null except for the following types: + /// + /// where T is + /// where T is + /// where T is + /// + /// It is a breaking change to change the underlying implementation of the list such that this method returns + /// null where it previously did not return null, therefore Silk.NET will only do this in a + /// major release. As a result, it is safe to use the ! operator for code targeting a specific major + /// release. Ideally, this is also the case for major releases, but the Silk.NET team cannot guarantee this at this + /// time. + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] // <-- generic specialisation + public static IList? GetUnderlyingList(this ListOwner list) => + typeof(T) == typeof(Button) + || typeof(T) == typeof(Button) + || typeof(T) == typeof(Button) + ? null + : Unsafe.As>(list.List.Data); + + /// + /// Unsafely creates a for the given list. Note that you should really only do this if + /// you are actually the owner of the list and are for some reason not storing the , using + /// this API to gain mutable access to an input list is almost always breaking assumptions throughout the input API. + /// + /// The list. + /// The type of the elements in the list. + /// The list owner. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static ListOwner AsOwned(InputReadOnlyList list) => new(list); + + /// + /// Given an owned mutable , swaps out the value of . + /// Note that this should not be used unexpectedly, and if there are any doubts about ownership or usage then create + /// a new instance of for safe mutation. + /// + /// The . + /// The new triggers. + public static void SetTriggers(GamepadState state, DualReadOnlyList triggers) => + state.Triggers = triggers; + + /// + /// Given an owned mutable , swaps out the value of + /// . Note that this should not be used unexpectedly, and if there are any + /// doubts about ownership or usage then create a new instance of for safe mutation. + /// + /// The . + /// The new thumbsticks. + public static void SetThumbsticks(GamepadState state, DualReadOnlyList thumbsticks) => + state.Thumbsticks = thumbsticks; + + /// + /// Given an owned mutable , swaps out the value of + /// . Note that this should not be used unexpectedly, and if there are any + /// doubts about ownership or usage then create a new instance of for safe mutation. + /// + /// The . + /// The new grip pressure. + public static void SetGripPressure(PointerState state, float gripPressure) => + state.GripPressure = gripPressure; + + // These are APIs defined on InputReadOnlyList or ButtonReadOnlyList but are implemented here to keep the + // implementation of the backing list in one file, the hope being that this decreases the likelihood of bugs. + + [MethodImpl(MethodImplOptions.AggressiveInlining)] // <-- generic specialisation + internal static Button GetButtonState(InputReadOnlyList> list, T name) + where T : unmanaged, Enum + { + if ( + typeof(T) == typeof(KeyName) + || typeof(T) == typeof(JoystickButton) + || typeof(T) == typeof(PointerButton) + ) + { + return Unsafe.As>(list.Data)[name]; + } + + var underlying = Unsafe.As>>(list.Data); + foreach (var t in underlying) + { + // ReSharper disable once InvertIf <-- this literally results in more lines of code!!!!! + if (t.Name.Equals(name)) + { + return t; + } + } + + return new Button(name, false, 0); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static int GetListCount(InputReadOnlyList list) + { + if (typeof(T) == typeof(Button)) + { + return GetButtonListCount(); + } + + if (typeof(T) == typeof(Button)) + { + return GetButtonListCount(); + } + + if (typeof(T) == typeof(Button)) + { + return GetButtonListCount(); + } + + return Unsafe.As>(list.Data).Count; + } + + // ReSharper disable NotDisposedResourceIsReturned - Nope, sorry, not adding a reference to JetBrains.Annotations. + internal static IEnumerator EnumerateList(InputReadOnlyList list) + { + if (typeof(T) == typeof(Button)) + { + return (IEnumerator)Unsafe.As>(list.Data).GetEnumerator(); + } + + if (typeof(T) == typeof(Button)) + { + return (IEnumerator)Unsafe.As>(list.Data).GetEnumerator(); + } + + if (typeof(T) == typeof(Button)) + { + return (IEnumerator)Unsafe.As>(list.Data).GetEnumerator(); + } + + return Unsafe.As>(list.Data).GetEnumerator(); + } // ReSharper restore NotDisposedResourceIsReturned + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static T ElementAt(InputReadOnlyList list, int index) + { + if (typeof(T) == typeof(Button)) + { + return (T)(object)Unsafe.As>(list.Data)[index]; + } + + if (typeof(T) == typeof(Button)) + { + return (T)(object)Unsafe.As>(list.Data)[index]; + } + + if (typeof(T) == typeof(Button)) + { + return (T)(object)Unsafe.As>(list.Data)[index]; + } + + return Unsafe.As>(list.Data)[index]; + } +} diff --git a/sources/Input/Input/InputReadOnlyList.cs b/sources/Input/Input/InputReadOnlyList.cs new file mode 100644 index 0000000000..aa176623a4 --- /dev/null +++ b/sources/Input/Input/InputReadOnlyList.cs @@ -0,0 +1,32 @@ +using System.Collections; + +namespace Silk.NET.Input; + +/// +/// An opaque implementation of that is optimised for storing a Silk.NET.Input +/// type specified by using the most memory-efficient mechanism available. +/// +/// The Silk.NET.Input type to store. +public readonly struct InputReadOnlyList : IReadOnlyList +{ + internal object Data => _list; + + /// + /// Creates an from a . + /// + /// The list to copy. + public InputReadOnlyList(IReadOnlyList other) => _list = other; + + /// + public IEnumerator GetEnumerator() => _list.GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + + /// + public int Count => _list.Count; + + /// + public T this[int index] => _list[index]; + + private readonly IReadOnlyList _list; +} diff --git a/sources/Input/Input/InputWindowExtensions.cs b/sources/Input/Input/InputWindowExtensions.cs new file mode 100644 index 0000000000..7eb3201841 --- /dev/null +++ b/sources/Input/Input/InputWindowExtensions.cs @@ -0,0 +1,58 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Numerics; +using Silk.NET.Maths; + +namespace Silk.NET.Input; + +/// +/// Contains extensions for creating input backends and contexts from s. +/// +public static partial class InputWindowExtensions +{ + /// + /// Creates an instance of the "reference implementation" of for the given + /// , provided that this was also sourced from the "reference implementation" of the + /// windowing API. The returned backend will capture input for the provided and all + /// descendants of that i.e. spawned children do not need their own backend. + /// + /// + /// Regarding the threading rules documented on , + /// must only be called on the "main thread," i.e. the same thread that windowing operates on. + /// + /// The window to create an input backend from. + /// The input backend. + /// + /// If the given is not compatible with the reference implementation for this platform. + /// + public static partial IInputBackend CreateInputBackend(this INativeWindow window); + + /// + /// Creates an that uses the "reference implementation" of + /// for the given as its only backend, provided that the was + /// also sourced from the "reference implementation" of the windowing API. The returned backend will capture input + /// for the provided and all descendants of that i.e. + /// spawned children do not need their own backend. + /// + /// + /// Regarding the threading rules documented on , + /// must only be called on the "main thread," i.e. the same thread that windowing operates on. + /// + /// The window to create an input backend from. + /// + /// The created with the instantiated input backend as its only backend. + /// + /// + /// If the given is not compatible with the reference implementation for this platform. + /// + public static InputContext CreateInput(this INativeWindow window) + { + var ret = new InputContext(); + ret.Backends.Add(window.CreateInputBackend()); + return ret; + } +} diff --git a/sources/Input/Input/JoystickAxis.cs b/sources/Input/Input/JoystickAxis.cs new file mode 100644 index 0000000000..be09cf3bb9 --- /dev/null +++ b/sources/Input/Input/JoystickAxis.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Input; + +[OrderedIndexUsage] +internal enum JoystickAxis +{ + [OrderedIndexIgnore] + Unknown = int.MaxValue - ushort.MaxValue, + + MinusLeftX, PlusLeftX, MinusLeftY, PlusRightY, + MinusRightX, PlusRightX, MinusRightY, PlusLeftY, + LeftX, LeftY, RightX, RightY, + LeftTrigger, RightTrigger, +} diff --git a/sources/Input/Input/JoystickAxisMoveEvent.cs b/sources/Input/Input/JoystickAxisMoveEvent.cs new file mode 100644 index 0000000000..afb850a4a4 --- /dev/null +++ b/sources/Input/Input/JoystickAxisMoveEvent.cs @@ -0,0 +1,16 @@ +using System.Diagnostics; +using Silk.NET.Input.SDL3; + +namespace Silk.NET.Input; + +/// +/// Contains information pertaining to the movement of a joystick axis. +/// +/// The joystick on which the axis being moved resides. +/// +/// The timestamp (as retrieved from ) at which the event occurred. +/// +/// The index of the axis being moved. +/// The new value of the axis, typically between 0.0 and 1.0. +/// The change in as a result of this event. +public readonly record struct JoystickAxisMoveEvent(IJoystick Joystick, long Timestamp, int Axis, float Value, float Delta) : ITimestampedEvent; diff --git a/sources/Input/Input/JoystickButton.cs b/sources/Input/Input/JoystickButton.cs new file mode 100644 index 0000000000..99e9547b0b --- /dev/null +++ b/sources/Input/Input/JoystickButton.cs @@ -0,0 +1,131 @@ +namespace Silk.NET.Input; + +/// +/// Enumerates the buttons of a joystick. +/// +[OrderedIndexUsage] +public enum JoystickButton // todo : should we include XInput, PSX, and Nintendo button names here? +{ + /// + /// The button was not recognised. + /// + /// This is defined as such a large number such that unknown buttons can still be a JoystickButton, + /// and we can define up to predefined unique joystick buttons. + /// + [OrderedIndexIgnore] + Unknown = JoystickAxis.Unknown, + + /// + /// The down-most button of the primary button cluster. + /// + ButtonDown, + + /// + /// The "A" button on Xbox (and similar) controllers. Equivalent to . + /// + A = ButtonDown, + + /// + /// The rightmost button of the primary button cluster. + /// + ButtonRight, + + /// + /// The "B" button on Xbox (and similar) controllers. Equivalent to . + /// + B = ButtonRight, + + /// + /// The leftmost button of the primary button cluster. + /// + ButtonLeft, + + /// + /// The "X" button on Xbox (and similar) controllers. Equivalent to . + /// + X = ButtonLeft, + + /// + /// The upmost button of the primary button cluster. + /// + ButtonUp, + + /// + /// The "Y" button on Xbox (and similar) controllers. Equivalent to . + /// + Y = ButtonUp, + + /// + /// The leftmost bumper/shoulder button. + /// + LeftBumper, + + /// + /// The rightmost bumper/shoulder button. + /// + RightBumper, + + /// + /// The "back" button. + /// + Back, + + /// + /// The "start" button. + /// + Start, + + /// + /// The "home" button. + /// + Home, + + /// + /// The leftmost thumbstick. This button represents the stick being pressed down. + /// + LeftStick, + + /// + /// The rightmost thumbstick. This button represents the stick being pressed down. + /// + RightStick, + + /// + /// The upmost button of the D-Pad button cluster. + /// + DPadUp, + + /// + /// The rightmost button of the D-Pad button cluster. + /// + DPadRight, + + /// + /// The down-most button of the D-Pad button cluster. + /// + DPadDown, + + /// + /// The leftmost button of the D-Pad button cluster. + /// + DPadLeft, + + // BEFORE ADDING A NEW ITEM MAKE SURE YOU CHANGE LastJoystickButton IN InputMarshal +} + +/// +/// Additional functions for making sense of s +/// +public static class JoystickButtonExtensions +{ + /// + /// Returns true if we have identified this button as a known button + /// + /// + /// + public static bool IsIdentified(this JoystickButton button) => button > JoystickButton.Unknown; + + /// + public static int Index(this T value) where T : unmanaged, Enum => EnumInfo.ValueIndexOf(value); +} + diff --git a/sources/Input/Input/JoystickHatMoveEvent.cs b/sources/Input/Input/JoystickHatMoveEvent.cs new file mode 100644 index 0000000000..3840d2be2b --- /dev/null +++ b/sources/Input/Input/JoystickHatMoveEvent.cs @@ -0,0 +1,18 @@ +using System.Diagnostics; +using System.Numerics; +using Silk.NET.Input.SDL3; + +namespace Silk.NET.Input; + +/// +/// Contains information pertaining to the movement of a joystick hat. +/// +/// The joystick on which the hat being moved resides. +/// +/// The timestamp (as retrieved from ) at which the event occurred. +/// +/// The position of the hat after this event. +/// The change in as a result of this event. +// todo: hats are not class objects in and of themselves, and a joystick could have > 1 hat. we should include a hat index here. +// and so I am for now - though this should not be accepted without review since it goes against the initial design of the API. +public readonly record struct JoystickHatMoveEvent(IJoystick Joystick, long Timestamp, int WhichHat, Vector2 Value, Vector2 Delta) : ITimestampedEvent; diff --git a/sources/Input/Input/JoystickState.cs b/sources/Input/Input/JoystickState.cs new file mode 100644 index 0000000000..290d5b1f61 --- /dev/null +++ b/sources/Input/Input/JoystickState.cs @@ -0,0 +1,38 @@ +using System.Numerics; + +namespace Silk.NET.Input; + +/// +/// Contains user input received from an . +/// +public class JoystickState +{ + /// + /// Gets the state of the joystick axes between -1.0 and 1.0 + /// + public InputReadOnlyList Axes { get; } + + /// + /// Gets the joystick button state, denoting which buttons are pressed/depressed. + /// + public ButtonReadOnlyList Buttons { get; } + + /// + /// Gets the state of the joystick hats as vectors between -1.0 and 1.0. + /// + public InputReadOnlyList Hats { get; } + + /// + /// + /// + /// + /// + /// + public JoystickState(IReadOnlyList axes, IReadOnlyList> buttons, IReadOnlyList hats) + { + Axes = new InputReadOnlyList(axes); + Buttons = new ButtonReadOnlyList(buttons); + Hats = new InputReadOnlyList(hats); + + } +} diff --git a/sources/Input/Input/KeyChangedEvent.cs b/sources/Input/Input/KeyChangedEvent.cs new file mode 100644 index 0000000000..a113ed9a83 --- /dev/null +++ b/sources/Input/Input/KeyChangedEvent.cs @@ -0,0 +1,17 @@ +using System.Diagnostics; +using Silk.NET.Input.SDL3; + +namespace Silk.NET.Input; + +/// +/// Contains information pertaining to a key press state change. +/// +/// The keyboard on which the key being pressed or depressed resides. +/// +/// The timestamp (as retrieved from ) at which the event occurred. +/// +/// The new state of the key being pressed or depressed. +/// The previous state of the key. +/// Whether this is an event that has been repeated at an implementation-defined rate. +/// The active key modifiers at the time the event was raised. +public readonly record struct KeyChangedEvent(IKeyboard Keyboard, long Timestamp, Button Key, Button Previous, bool IsRepeat, KeyModifiers Modifiers) : ITimestampedEvent; diff --git a/sources/Input/Input/KeyCharEvent.cs b/sources/Input/Input/KeyCharEvent.cs new file mode 100644 index 0000000000..b64acacc0c --- /dev/null +++ b/sources/Input/Input/KeyCharEvent.cs @@ -0,0 +1,14 @@ +using System.Diagnostics; +using Silk.NET.Input.SDL3; + +namespace Silk.NET.Input; + +/// +/// Contains information pertaining to a character being typed on a keyboard. +/// +/// The keyboard with which the end user typed a character. +/// +/// The timestamp (as retrieved from ) at which the event occurred. +/// +/// The character that was typed. A null character denotes a backspace. +public readonly record struct KeyCharEvent(IKeyboard Keyboard, long Timestamp, char? Character) : ITimestampedEvent; diff --git a/sources/Input/Input/KeyModifiers.cs b/sources/Input/Input/KeyModifiers.cs new file mode 100644 index 0000000000..8b6660641f --- /dev/null +++ b/sources/Input/Input/KeyModifiers.cs @@ -0,0 +1,40 @@ +namespace Silk.NET.Input; + +/// +/// A bitmask denoting the modifier keys that can be active when a key press occurs to modify its behaviour. +/// +[Flags] +public enum KeyModifiers +{ + /// No modifier keys are active. + None = 0, + /// The left "shift" key. + ShiftLeft = 1 << 0, + + /// The right "shift" key. + ShiftRight = 1 << 1, + + /// The left "control" key. + ControlLeft = 1 << 2, + + /// The right "control" key. + ControlRight = 1 << 3, + + /// The left "alt" key. + AltLeft = 1 << 4, + + /// The right "alt" key. + AltRight = 1 << 5, + + /// The left "super" (e.g. Windows/Start) key. + SuperLeft = 1 << 6, + + /// The right "super" (e.g. Windows/Start) key. + SuperRight = 1 << 7, + + /// The "num lock" key. + NumLock = 1 << 8, + + /// The "caps lock" key. + CapsLock = 1 << 9 +} \ No newline at end of file diff --git a/sources/Input/Input/KeyName.cs b/sources/Input/Input/KeyName.cs new file mode 100644 index 0000000000..2def1ba7d7 --- /dev/null +++ b/sources/Input/Input/KeyName.cs @@ -0,0 +1,828 @@ +namespace Silk.NET.Input; + +/// +/// Enumerates names for physical key positions as defined by the +/// USB HID Usage Tables published by +/// the USB-IF. Note that these denote an en-US-centric definition of the keys that reside at each physical position, +/// and does not take account of keyboard layout. That is, represents the Q key on a QWERTY +/// keyboard but represents the " key on a Dvorak keyboard. Use to +/// determine the localised name of a physical key position name () when taking account of the +/// user's selected keyboard layout. +/// +public enum KeyName +{ + // BEFORE ADDING ANYTHING TO THIS FILE MAKE SURE YOU REALISE THAT InputMarshal RELIES ON ASSUMPTIONS ON THE VALUES + + // These values are from usage page 0x07 (USB keyboard page). + /// + /// A key that was not recognised. + /// + Unknown = 0, + + /// The "A" key. + A = 4, + + /// The "B" key. + B = 5, + + /// The "C" key. + C = 6, + + /// The "D" key. + D = 7, + + /// The "E" key. + E = 8, + + /// The "F" key. + F = 9, + + /// The "G" key. + G = 10, + + /// The "H" key. + H = 11, + + /// The "I" key. + I = 12, + + /// The "J" key. + J = 13, + + /// The "K" key. + K = 14, + + /// The "L" key. + L = 15, + + /// The "M" key. + M = 16, + + /// The "N" key. + N = 17, + + /// The "O" key. + O = 18, + + /// The "P" key. + P = 19, + + /// The "Q" key. + Q = 20, + + /// The "R" key. + R = 21, + + /// The "S" key. + S = 22, + + /// The "T" key. + T = 23, + + /// The "U" key. + U = 24, + + /// The "V" key. + V = 25, + + /// The "W" key. + W = 26, + + /// The "X" key. + X = 27, + + /// The "Y" key. + Y = 28, + + /// The "Z" key. + Z = 29, + + /// The "1" key. + Number1 = 30, + + /// The "2" key. + Number2 = 31, + + /// The "3" key. + Number3 = 32, + + /// The "4" key. + Number4 = 33, + + /// The "5" key. + Number5 = 34, + + /// The "6" key. + Number6 = 35, + + /// The "7" key. + Number7 = 36, + + /// The "8" key. + Number8 = 37, + + /// The "9" key. + Number9 = 38, + + /// The "0" key. + Number0 = 39, + + /// The "return" key. + Return = 40, + + /// The "escape" key. + Escape = 41, + + /// The "backspace" key. + Backspace = 42, + + /// The "tab" key. + Tab = 43, + + /// The "space" key. + Space = 44, + + /// The "minus" key. + Minus = 45, + + /// The "equals" key. + Equals = 46, + + /// The "left bracket" key. + LeftBracket = 47, + + /// The "right bracket" key. + RightBracket = 48, + + /// The "backslash" key. + Backslash = 49, + + /// + /// A key with region-specific meanings. + /// + /// + /// + /// American \| + /// Belgium µ`£ + /// Canadian-French <}> + /// Danish’* + /// Dutch <> + /// French*µ + /// German #’ + /// Italian ù§ + /// Latin-American }`] + /// Norwegian,* + /// Spanish }Ç + /// Swedish , * + /// Swiss $£ + /// British #~. + /// + /// + NonUs1 = 50, + + /// The "semicolon" key. + Semicolon = 51, + + /// The "apostrophe" key. + Apostrophe = 52, + + /// The "grave" key. + Grave = 53, + + /// The "comma" key. + Comma = 54, + + /// The "period" key. + Period = 55, + + /// The "slash" key. + Slash = 56, + + /// The "caps lock" key. + CapsLock = 57, + + /// The first function key. + F1 = 58, + + /// The second function key. + F2 = 59, + + /// The third function key. + F3 = 60, + + /// The fourth function key. + F4 = 61, + + /// The fifth function key. + F5 = 62, + + /// The sixth function key. + F6 = 63, + + /// The seventh function key. + F7 = 64, + + /// The eighth function key. + F8 = 65, + + /// The ninth function key. + F9 = 66, + + /// The tenth function key. + F10 = 67, + + /// The eleventh function key. + F11 = 68, + + /// The twelfth function key. + F12 = 69, + + /// The "print screen" key. + PrintScreen = 70, + + /// The "scroll lock" key. + ScrollLock = 71, + + /// The "pause" key. + Pause = 72, + + /// The "insert" key. + Insert = 73, + + /// The "home" key. + Home = 74, + + /// The "page up" key. + PageUp = 75, + + /// The "delete" key. + Delete = 76, + + /// The "end" key. + End = 77, + + /// The "page down" key. + PageDown = 78, + + /// The "right" key. + Right = 79, + + /// The "left" key. + Left = 80, + + /// The "down" key. + Down = 81, + + /// The "up" key. + Up = 82, + + /// The "num lock clear" key. + NumLockClear = 83, + + /// The "divide" key on the keypad. + KeypadDivide = 84, + + /// The "multiply" key on the keypad. + KeypadMultiply = 85, + + /// The "minus" key on the keypad. + KeypadMinus = 86, + + /// The "plus" key on the keypad. + KeypadPlus = 87, + + /// The "enter" key on the keypad. + KeypadEnter = 88, + + /// The "1" key on the keypad. + Keypad1 = 89, + + /// The "2" key on the keypad. + Keypad2 = 90, + + /// The "3" key on the keypad. + Keypad3 = 91, + + /// The "4" key on the keypad. + Keypad4 = 92, + + /// The "5" key on the keypad. + Keypad5 = 93, + + /// The "6" key on the keypad. + Keypad6 = 94, + + /// The "7" key on the keypad. + Keypad7 = 95, + + /// The "8" key on the keypad. + Keypad8 = 96, + + /// The "9" key on the keypad. + Keypad9 = 97, + + /// The "0" key on the keypad. + Keypad0 = 98, + + /// The "period" key on the keypad. + KeypadPeriod = 99, + + /// + /// A key with region-specific meanings, typically near the Left-Shift key in AT-102 implementations. + /// + /// + /// Belg<\> + /// FrCa«°» + /// Dan<\> + /// Dutch]|[ + /// Fren<> + /// Ger<|> + /// Ital<> + /// LatAm<> + /// Nor<> + /// Span<> + /// Swed<|> + /// Swiss<\> + /// UK\| + /// Brazil\| + /// + NonUs2 = 100, + + /// A key for application-defined functions. + Application = 101, + + /// The "power" key. + Power = 102, + + /// The "equals" key on the keypad. + KeypadEquals = 103, + + /// The thirteenth function key. + F13 = 104, + + /// The fourteenth function key. + F14 = 105, + + /// The fifteenth function key. + F15 = 106, + + /// The sixteenth function key. + F16 = 107, + + /// The seventeenth function key. + F17 = 108, + + /// The eighteenth function key. + F18 = 109, + + /// The nineteenth function key. + F19 = 110, + + /// The twentieth function key. + F20 = 111, + + /// The twenty-first function key. + F21 = 112, + + /// The twenty-second function key. + F22 = 113, + + /// The twenty-third function key. + F23 = 114, + + /// The twenty-fourth function key. + F24 = 115, + + /// The "execute" key. + Execute = 116, + + /// The "help" key. + Help = 117, + + /// The "menu" key. + Menu = 118, + + /// The "select" key. + Select = 119, + + /// The "stop" key. + Stop = 120, + + /// The "again" key. + Again = 121, + + /// The "undo" key. + Undo = 122, + + /// The "cut" key. + Cut = 123, + + /// The "copy" key. + Copy = 124, + + /// The "paste" key. + Paste = 125, + + /// The "find" key. + Find = 126, + + /// The "mute" key. + Mute = 127, + + /// The "volume up" key. + VolumeUp = 128, + + /// The "volume down" key. + VolumeDown = 129, + + // BEFORE ADDING ANYTHING TO THIS FILE MAKE SURE YOU REALISE THAT InputMarshal RELIES ON ASSUMPTIONS ON THE VALUES + + /// The "comma" key on the keypad. + KeypadComma = 133, + + /// The alternative "equals" key on the keypad as typically found on AS-400 keyboards. + OtherKeypadEquals = 134, + + /// The first international key. + International1 = 135, + + /// The second international key. + International2 = 136, + + /// The third international key. + International3 = 137, + + /// The fourth international key. + International4 = 138, + + /// The fifth international key. + International5 = 139, + + /// The sixth international key. + International6 = 140, + + /// The seventh international key. + International7 = 141, + + /// The eighth international key. + International8 = 142, + + /// The ninth international key. + International9 = 143, + + /// The first language key. + Lang1 = 144, + + /// The second language key. + Lang2 = 145, + + /// The third language key. + Lang3 = 146, + + /// The fourth language key. + Lang4 = 147, + + /// The fifth language key. + Lang5 = 148, + + /// The sixth language key. + Lang6 = 149, + + /// The seventh language key. + Lang7 = 150, + + /// The eighth language key. + Lang8 = 151, + + /// The ninth language key. + Lang9 = 152, + + /// The alternative "erase" key, for example an Erase-Eaze™ key. + AlternativeErase = 153, + + /// The "system request" key. + SystemRequest = 154, + + /// The "cancel" key. + Cancel = 155, + + /// The "clear" key. + Clear = 156, + + /// The "prior" key. + Prior = 157, + + /// An alternative "return" key. + Return2 = 158, + + /// The "separator" key. + Separator = 159, + + /// The "out" key. + Out = 160, + + /// The "operation" key. + Oper = 161, + + /// The "clear again" key. + ClearAgain = 162, + + /// The "cursor select" key. + /// + /// For more information consult IBM's "3174 Establishment Controller - Terminal User's Reference for Expanded + /// Functions" (GA23-03320-02, May 1989) + /// + CursorSelect = 163, + + /// The "extend select" key. + /// + /// For more information consult IBM's "3174 Establishment Controller - Terminal User's Reference for Expanded + /// Functions" (GA23-03320-02, May 1989) + /// + ExtendSelect = 164, + + // BEFORE ADDING ANYTHING TO THIS FILE MAKE SURE YOU REALISE THAT InputMarshal RELIES ON ASSUMPTIONS ON THE VALUES + + /// The "00" key on the keypad. + Keypad00 = 176, + + /// The "000" key on the keypad. + Keypad000 = 177, + + /// The "thousands separator" key. + /// Interpreted as a comma for en-US. + ThousandsSeparator = 178, + + /// The "decimal separator" key. + /// Interpreted as a period for en-US. + DecimalSeparator = 179, + + /// The "currency unit" key. + /// Interpreted as a dollar sign for en-US. + CurrencyUnit = 180, + + /// The "currencySubunit" key. + /// Interpreted as a cents symbol for en-US. + CurrencySubunit = 181, + + /// The "leftParenthesis" key on the keypad. + KeypadLeftParenthesis = 182, + + /// The "rightParenthesis" key on the keypad. + KeypadRightParenthesis = 183, + + /// The "leftBrace" key on the keypad. + KeypadLeftBrace = 184, + + /// The "rightBrace" key on the keypad. + KeypadRightBrace = 185, + + /// The "tab" key on the keypad. + KeypadTab = 186, + + /// The "backspace" key on the keypad. + KeypadBackspace = 187, + + /// The "a" key on the keypad. + KeypadA = 188, + + /// The "b" key on the keypad. + KeypadB = 189, + + /// The "c" key on the keypad. + KeypadC = 190, + + /// The "d" key on the keypad. + KeypadD = 191, + + /// The "e" key on the keypad. + KeypadE = 192, + + /// The "f" key on the keypad. + KeypadF = 193, + + /// The "xor" key on the keypad. + KeypadXor = 194, + + /// The "power" key on the keypad. + KeypadPower = 195, + + /// The "percent" key on the keypad. + KeypadPercent = 196, + + /// The "less" key on the keypad. + KeypadLess = 197, + + /// The "greater" key on the keypad. + KeypadGreater = 198, + + /// The "ampersand" key on the keypad. + KeypadAmpersand = 199, + + /// The "doubleAmpersand" key on the keypad. + KeypadDoubleAmpersand = 200, + + /// The "vertical bar" key on the keypad. + KeypadVerticalBar = 201, + + /// The "double vertical bar" key on the keypad. + KeypadDoubleVerticalBar = 202, + + /// The "colon" key on the keypad. + KeypadColon = 203, + + /// The "hash" key on the keypad. + KeypadHash = 204, + + /// The "space" key on the keypad. + KeypadSpace = 205, + + /// The "@" key on the keypad. + KeypadAt = 206, + + /// The "exclamation" key on the keypad. + KeypadExclamation = 207, + + /// The "memory store" key on the keypad. + KeypadMemoryStore = 208, + + /// The "memory recall" key on the keypad. + KeypadMemoryRecall = 209, + + /// The "memory clear" key on the keypad. + KeypadMemoryClear = 210, + + /// The "memory add" key on the keypad. + KeypadMemoryAdd = 211, + + /// The "memory subtract" key on the keypad. + KeypadMemorySubtract = 212, + + /// The "memory multiply" key on the keypad. + KeypadMemoryMultiply = 213, + + /// The "memory divide" key on the keypad. + KeypadMemoryDivide = 214, + + /// The "plus/minus" key on the keypad. + KeypadPlusMinus = 215, + + /// The "clear" key on the keypad. + KeypadClear = 216, + + /// The "clear entry" key on the keypad. + KeypadClearEntry = 217, + + /// The "binary" key on the keypad. + KeypadBinary = 218, + + /// The "octal" key on the keypad. + KeypadOctal = 219, + + /// The "decimal" key on the keypad. + KeypadDecimal = 220, + + /// The "hexadecimal" key on the keypad. + KeypadHexadecimal = 221, + + // BEFORE ADDING ANYTHING TO THIS FILE MAKE SURE YOU REALISE THAT InputMarshal RELIES ON ASSUMPTIONS ON THE VALUES + + /// The left "control" key. + ControlLeft = 224, + + /// The left "shift" key. + ShiftLeft = 225, + + /// The left "alt" key. + AltLeft = 226, + + /// The left "super" (e.g. Windows/Start) key. + SuperLeft = 227, + + /// The right "control" key. + ControlRight = 228, + + /// The right "shift" key. + ShiftRight = 229, + + /// The right "alt" key. + AltRight = 230, + + /// The right "super" (e.g. Windows/Start) key. + SuperRight = 231, + + // 232-256..... wtf? + // BEFORE ADDING ANYTHING TO THIS FILE MAKE SURE YOU REALISE THAT InputMarshal RELIES ON ASSUMPTIONS ON THE VALUES + + /// The "mode" key. + Mode = 257, + + // These values are mapped from usage page 0x0C (USB consumer page). + /// The "sleep" key. + Sleep = 258, + + /// The "wake" key. + Wake = 259, + + /// The "channel increment" key. + ChannelIncrement = 260, + + /// The "channel decrement" key. + ChannelDecrement = 261, + + /// The "play" media key. + MediaPlay = 262, + + /// The "pause" media key. + MediaPause = 263, + + /// The "record" media key. + MediaRecord = 264, + + /// The "fast forward" media key. + MediaFastForward = 265, + + /// The "rewind" media key. + MediaRewind = 266, + + /// The "next track" media key. + MediaNextTrack = 267, + + /// The "previous track" media key. + MediaPreviousTrack = 268, + + /// The "stop" media key. + MediaStop = 269, + + /// The "eject" media key. + MediaEject = 270, + + /// The "play/pause" media key. + MediaPlayPause = 271, + + /// The "select" media key. + MediaSelect = 272, + + /// The "new" application key. + ApplicationNew = 273, + + /// The "open" application key. + ApplicationOpen = 274, + + /// The "close" application key. + ApplicationClose = 275, + + /// The "exit" application key. + ApplicationExit = 276, + + /// The "save" application key. + ApplicationSave = 277, + + /// The "print" application key. + ApplicationPrint = 278, + + /// The "properties" application key. + ApplicationProperties = 279, + + /// The "search" application key. + ApplicationSearch = 280, + + /// The "home" application key. + ApplicationHome = 281, + + /// The "back" application key. + ApplicationBack = 282, + + /// The "forward" application key. + ApplicationForward = 283, + + /// The "stop" application key. + ApplicationStop = 284, + + /// The "refresh" application key. + ApplicationRefresh = 285, + + /// The "bookmarks" application key. + ApplicationBookmarks = 286, + + // BEFORE ADDING ANYTHING TO THIS FILE MAKE SURE YOU REALISE THAT InputMarshal RELIES ON ASSUMPTIONS ON THE VALUES + + // 501-512 is reserved for non-standard (i.e. not from an industry-standard HID page) keys. + /// The left soft key e.g. the left button on a mobile phone. + /// This is not from an industry-standard HID page. + SoftLeft = 501, + + /// The right soft key e.g. the right button on a mobile phone. + /// This is not from an industry-standard HID page. + SoftRight = 502, + + /// The "call" key. + /// This is not from an industry-standard HID page. + Call = 503, + + /// The "end call" key. + /// This is not from an industry-standard HID page. + EndCall = 504, + + // BEFORE ADDING ANYTHING TO THIS FILE MAKE SURE YOU REALISE THAT InputMarshal RELIES ON ASSUMPTIONS ON THE VALUES +} diff --git a/sources/Input/Input/KeyboardState.cs b/sources/Input/Input/KeyboardState.cs new file mode 100644 index 0000000000..0209f9fe56 --- /dev/null +++ b/sources/Input/Input/KeyboardState.cs @@ -0,0 +1,78 @@ +namespace Silk.NET.Input; + +/// +/// Contains user input received from an . +/// +public class KeyboardState +{ + /// + /// Gets the text that has been typed since has been called. This will be cleared + /// when is called. + /// + public InputReadOnlyList? Text { get; } + + /// + /// Gets the key state, denoting which keys are pressed on the keyboard. + /// + public ButtonReadOnlyList Keys { get; } + + /// + /// Gets the active modifier keys. + /// + public KeyModifiers Modifiers + { + get + { + // todo - optimize? + var state = KeyModifiers.None; + if(Keys[KeyName.ControlLeft]) + state |= KeyModifiers.ControlLeft; + + if(Keys[KeyName.ControlRight]) + state |= KeyModifiers.ControlRight; + + if(Keys[KeyName.AltLeft]) + state |= KeyModifiers.AltLeft; + + if(Keys[KeyName.AltRight]) + state |= KeyModifiers.AltRight; + + if(Keys[KeyName.ShiftLeft]) + state |= KeyModifiers.ShiftLeft; + + if(Keys[KeyName.ShiftRight]) + state |= KeyModifiers.ShiftRight; + + if(Keys[KeyName.SuperLeft]) + state |= KeyModifiers.SuperLeft; + + if(Keys[KeyName.SuperRight]) + state |= KeyModifiers.SuperRight; + + if(_capsLockActive()) + state |= KeyModifiers.CapsLock; + + if(_numLockActive()) + state |= KeyModifiers.NumLock; + + return state; + } + } + + /// + /// Constructor for the keyboard state - the provided button list should be continuously updated by the + /// implementation + /// + /// The collection of keys that are modified at runtime to give the current keyboard its state + /// Return true if caps lock is currently active, irrespective of pressed status + /// Return true if num lock is currently active, irrespective of pressed status + public KeyboardState(IReadOnlyList> keys, Func capsLockActive, Func numLockActive) + { + Keys = new ButtonReadOnlyList(keys); + _capsLockActive = capsLockActive; + _numLockActive = numLockActive; + } + + private readonly Func _numLockActive; + private readonly Func _capsLockActive; +} diff --git a/sources/Input/Input/MouseScrollEvent.cs b/sources/Input/Input/MouseScrollEvent.cs new file mode 100644 index 0000000000..c07291342a --- /dev/null +++ b/sources/Input/Input/MouseScrollEvent.cs @@ -0,0 +1,19 @@ +using System.Diagnostics; +using System.Numerics; +using Silk.NET.Input.SDL3; + +namespace Silk.NET.Input; + +/// +/// Contains information pertaining to the user scrolling using a mouse scroll wheel. +/// +/// The mouse on which the scroll wheel resides. +/// +/// The timestamp (as retrieved from ) at which the event occurred. +/// +/// The mouse's active point when the scroll event occurred. +/// The after the event occurred. +/// +/// The change in as a result of this event represented as a number of ratchets. +/// +public readonly record struct MouseScrollEvent(IMouse Mouse, long Timestamp, TargetPoint Point, Vector2 WheelPosition, Vector2 Delta) : ITimestampedEvent; diff --git a/sources/Input/Input/MouseState.cs b/sources/Input/Input/MouseState.cs new file mode 100644 index 0000000000..545a7704ae --- /dev/null +++ b/sources/Input/Input/MouseState.cs @@ -0,0 +1,34 @@ +using System.Numerics; + +namespace Silk.NET.Input; + +/// +/// Contains user input received from an . +/// +public class MouseState( + ButtonReadOnlyList buttons, + InputReadOnlyList points, + Vector2 wheelPosition, + float gripPressure = 0 +) : PointerState(buttons, points, gripPressure) +{ + /// + /// Clones a object. + /// + /// The object to clone. + /// + /// This object will not receive any changes from the object it was created from as they are distinct clones. + /// + public MouseState(MouseState other) + : this( + new ButtonReadOnlyList(other.Buttons), + new InputReadOnlyList(other.Points), + other.WheelPosition, + other.GripPressure + ) { } + + /// + /// Gets the current position of the scroll wheel in number of ratchets. + /// + public Vector2 WheelPosition { get; internal set; } = wheelPosition; +} diff --git a/sources/Input/Input/PointChangedEvent.cs b/sources/Input/Input/PointChangedEvent.cs new file mode 100644 index 0000000000..db330e4a6c --- /dev/null +++ b/sources/Input/Input/PointChangedEvent.cs @@ -0,0 +1,27 @@ +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using Silk.NET.Input.SDL3; + +namespace Silk.NET.Input; + +/// +/// Contains information pertaining to a change on a , +/// +/// The pointer device with which the user is pointing. +/// +/// The timestamp (as retrieved from ) at which the event occurred. +/// +/// +/// The previous state for this . If this is a new point (e.g. a finger has only just touched a +/// touch screen), this shall be null. +/// +/// +/// The new state for this . If the point is no longer valid (e.g. a finger is no longer +/// touching a touch screen), this shall be null. +/// +public readonly record struct PointChangedEvent( + IPointerDevice Pointer, + long Timestamp, + TargetPoint? OldPoint, + TargetPoint? NewPoint +) : ITimestampedEvent; diff --git a/sources/Input/Input/PointerButton.cs b/sources/Input/Input/PointerButton.cs new file mode 100644 index 0000000000..00eebdc9a0 --- /dev/null +++ b/sources/Input/Input/PointerButton.cs @@ -0,0 +1,186 @@ +namespace Silk.NET.Input; + +/// +/// Enumerates the buttons available on pointer devices. +/// +[OrderedIndexUsage] +public enum PointerButton +{ + /// + /// An unrecognised button. + /// + [OrderedIndexIgnore] + Unknown = JoystickAxis.Unknown, + + /// + /// The primary button e.g. left click. + /// + Primary, + + /// + /// The secondary button e.g. right click. + /// + Secondary, + + /// + /// The third button. + /// + Button3, + + /// + /// The middle button i.e. clicking the scroll wheel down. This acts as the third button. + /// + MiddleButton = Button3, + + /// + /// The fourth button. + /// + Button4, + + /// + /// The fifth button. + /// + Button5, + + /// + /// The sixth button. + /// + Button6, + + /// + /// The seventh button. + /// + Button7, + + /// + /// The eighth button. + /// + Button8, + + /// + /// The ninth button. + /// + Button9, + + /// + /// The tenth button. + /// + Button10, + + /// + /// The eleventh button. + /// + Button11, + + /// + /// The twelveth button. + /// + Button12, + + /// + /// The thirteenth button. + /// + Button13, + + /// + /// The fourteenth button. + /// + Button14, + + /// + /// The fifteenth button. + /// + Button15, + + /// + /// The sixteenth button. + /// + Button16, + + /// + /// The seventeenth button. + /// + Button17, + + /// + /// The eighteenth button. + /// + Button18, + + /// + /// The nineteenth button. + /// + Button19, + + /// + /// The twentieth button. + /// + Button20, + + /// + /// The twenty-first button. + /// + Button21, + + /// + /// The twenty-second button. + /// + Button22, + + /// + /// The twenty-third button. + /// + Button23, + + /// + /// The twenty-fourth button. + /// + Button24, + + /// + /// The twenty-fifth button. + /// + Button25, + + /// + /// The twenty-sixth button. + /// + Button26, + + /// + /// The twenty-seventh button. + /// + Button27, + + /// + /// The twenty-eighth button. + /// + Button28, + + /// + /// The twenty-ninth button. + /// + Button29, + + /// + /// The thirtieth button. + /// + Button30, + + /// + /// The eraser tip of a pen pointer device. This acts as the thirtieth button. + /// + EraserTip = Button30, + + /// + /// The thirty-first button. + /// + Button31, + + /// + /// The thirty-second button. + /// + Button32, + + // BEFORE ADDING MORE BUTTONS, ENSURE YOU CHANGE InputMarshal TO ACCOUNT FOR THE NEW MAX +} diff --git a/sources/Input/Input/PointerClickConfiguration.cs b/sources/Input/Input/PointerClickConfiguration.cs new file mode 100644 index 0000000000..4612da0780 --- /dev/null +++ b/sources/Input/Input/PointerClickConfiguration.cs @@ -0,0 +1,19 @@ +namespace Silk.NET.Input; + +/// +/// Denotes the configuration for recognising events apart from single +/// events. +/// +/// +/// The maximum time in milliseconds between two consecutive clicks to count as a double click. +/// +/// +/// The maximum distance in pixels between two consecutive clicks to count as a double click. +/// +public record struct PointerClickConfiguration(int DoubleClickTime, float DoubleClickRange) +{ + /// + /// Gets the default configuration. + /// + public static PointerClickConfiguration Default => new(500, 4); +} diff --git a/sources/Input/Input/PointerClickEvent.cs b/sources/Input/Input/PointerClickEvent.cs new file mode 100644 index 0000000000..a79105cb8e --- /dev/null +++ b/sources/Input/Input/PointerClickEvent.cs @@ -0,0 +1,18 @@ +using System.Diagnostics; +using Silk.NET.Input.SDL3; + +namespace Silk.NET.Input; + +/// +/// Contains information pertaining to a pointer button being pressed and released (i.e. clicked). +/// +/// The pointer device on which the button being pressed and released resides. +/// +/// The timestamp (as retrieved from ) at which the event occurred. +/// +/// +/// A specific for which the button press occurred, check to +/// validate if such a point was available. +/// +/// The button that was pressed and released in succession. +public readonly record struct PointerClickEvent(IPointerDevice Pointer, long Timestamp, TargetPoint Point, PointerButton Button) : ITimestampedEvent; diff --git a/sources/Input/Input/PointerGripChangedEvent.cs b/sources/Input/Input/PointerGripChangedEvent.cs new file mode 100644 index 0000000000..48080723e4 --- /dev/null +++ b/sources/Input/Input/PointerGripChangedEvent.cs @@ -0,0 +1,19 @@ +using System.Diagnostics; +using Silk.NET.Input.SDL3; + +namespace Silk.NET.Input; + +/// +/// Contains information pertaining to the user changing the pressure with which they're applying their grip on the +/// given pointer device. +/// +/// The pointer device the user is gripping. +/// +/// The timestamp (as retrieved from ) at which the event occurred. +/// +/// +/// The grip pressure being applied to the device, where 0.0 is the lowest amount of pressure measurable by the +/// device and 1.0 is the maximum amount of pressure measurable by the device. +/// +/// The change in from its previous value. +public readonly record struct PointerGripChangedEvent(IPointerDevice Pointer, long Timestamp, float GripPressure, float Delta): ITimestampedEvent; diff --git a/sources/Input/Input/PointerState.cs b/sources/Input/Input/PointerState.cs new file mode 100644 index 0000000000..375efa66f8 --- /dev/null +++ b/sources/Input/Input/PointerState.cs @@ -0,0 +1,47 @@ +namespace Silk.NET.Input; + +/// +/// Contains user input state received from an . +/// +public class PointerState( + ButtonReadOnlyList buttons, + InputReadOnlyList points, + float gripPressure = 0 +) +{ + /// + /// Clones a object. + /// + /// The object to clone. + /// + /// This object will not receive any changes from the object it was created from as they are distinct clones. + /// + public PointerState(PointerState other) + : this( + new ButtonReadOnlyList(other.Buttons), + new InputReadOnlyList(other.Points), + other.GripPressure + ) { } + + public PointerState(IReadOnlyList> buttons, IReadOnlyList points, float gripPressure = 0): + this(new ButtonReadOnlyList(buttons), new InputReadOnlyList(points), gripPressure) + { + + } + + /// + /// Gets the captured state of each of the buttons on the device. + /// + public ButtonReadOnlyList Buttons { get; } = buttons; + + /// + /// Gets the points on the targets at which the user is pointing using the device. + /// + public InputReadOnlyList Points { get; } = points; + + /// + /// Gets the pressure the user is applying to the grip of the pointer device, where 0.0 is the lowest + /// measurable pressure and 1.0 is the highest measurable pressure. + /// + public float GripPressure { get; internal set; } = gripPressure; +} diff --git a/sources/Input/Input/PointerTargetChangedEvent.cs b/sources/Input/Input/PointerTargetChangedEvent.cs new file mode 100644 index 0000000000..fbb8c6a128 --- /dev/null +++ b/sources/Input/Input/PointerTargetChangedEvent.cs @@ -0,0 +1,28 @@ +using System.Diagnostics; +using Silk.NET.Input.SDL3; +using Silk.NET.Maths; + +namespace Silk.NET.Input; + +/// +/// Contains information pertaining to changes to a "target" at which the user can point using a pointer device. +/// +/// The pointer with which the user can point at the given target. +/// +/// The timestamp (as retrieved from ) at which the event occurred. +/// +/// The target at which the user can point. +/// +/// true if this is a newly-added target to , +/// false if this target has been removed from the list of available , +/// null if there has been no change to the target's validity. +/// +/// +/// The old of the target. This may be the same as if there +/// has been no change. +/// +/// +/// The new of the target. This may be the same as if there +/// has been no change. +/// +public readonly record struct PointerTargetChangedEvent(IPointerDevice Pointer, long Timestamp, IPointerTarget Target, bool? IsAdded, Box3D OldBounds, Box3D NewBounds) : ITimestampedEvent; diff --git a/sources/Input/Input/Silk.NET.Input.csproj b/sources/Input/Input/Silk.NET.Input.csproj new file mode 100644 index 0000000000..52c401b925 --- /dev/null +++ b/sources/Input/Input/Silk.NET.Input.csproj @@ -0,0 +1,17 @@ + + + + net10.0 + enable + enable + ST0005;$(NoWarn) + false + + + + + + + + + diff --git a/sources/Input/Input/Silk.NET.Input.csproj.DotSettings b/sources/Input/Input/Silk.NET.Input.csproj.DotSettings new file mode 100644 index 0000000000..10361e88b3 --- /dev/null +++ b/sources/Input/Input/Silk.NET.Input.csproj.DotSettings @@ -0,0 +1,2 @@ + + True \ No newline at end of file diff --git a/sources/Input/Input/SortExtensions.cs b/sources/Input/Input/SortExtensions.cs new file mode 100644 index 0000000000..30b3f90417 --- /dev/null +++ b/sources/Input/Input/SortExtensions.cs @@ -0,0 +1,357 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.Input; + +internal static class SortExtensions +{ + extension(Span span) + { + /// + /// Sorts the given span of items using the given comparison, using merge sort. + /// + /// + public void StableSort(Comparison comparison) + { + if (span.Length < 2) + { + return; + } + + const int insertionSortThreshold = 16; + + if (span.Length <= insertionSortThreshold) + { + InsertionSort(span, comparison); + return; + } + + var mid = span.Length >> 1; + var left = span[..mid]; + var right = span[mid..]; + + left.StableSort(comparison); + right.StableSort(comparison); + Merge(span, mid, comparison); + + return; + + static void InsertionSort(Span span, Comparison comparison) + { + for (var i = 1; i < span.Length; i++) + { + var value = span[i]; + var j = i - 1; + + while (j >= 0 && comparison(span[j], value) > 0) + { + span[j + 1] = span[j]; + j--; + } + + span[j + 1] = value; + } + } + + static void Merge(Span span, int mid, Comparison comparison) + { + if (mid <= 0 || mid >= span.Length) + { + return; + } + + if (comparison(span[mid - 1], span[mid]) <= 0) + { + return; + } + + MergeRange(span, 0, mid, span.Length, comparison); + return; + + static void MergeRange(Span span, int start, int mid, int end, Comparison comparison) + { + while (true) + { + if (start >= mid || mid >= end) + { + return; + } + + if (end - start == 2) + { + if (comparison(span[mid], span[start]) < 0) + { + (span[start], span[mid]) = (span[mid], span[start]); + } + + return; + } + + var leftLen = mid - start; + var rightLen = end - mid; + + if (leftLen > rightLen) + { + var firstCut = start + (leftLen >> 1); + var secondCut = LowerBound(span, mid, end, span[firstCut], comparison); + var newMid = firstCut + (secondCut - mid); + + Rotate(span, firstCut, mid, secondCut); + MergeRange(span, start, firstCut, newMid, comparison); + start = newMid; + mid = secondCut; + } + else + { + var secondCut = mid + (rightLen >> 1); + var firstCut = UpperBound(span, start, mid, span[secondCut], comparison); + var newMid = firstCut + (secondCut - mid); + + Rotate(span, firstCut, mid, secondCut); + MergeRange(span, start, firstCut, newMid, comparison); + start = newMid; + mid = secondCut; + } + + continue; + + + static int LowerBound(Span span, int start, int end, T value, Comparison comparison) + { + while (start < end) + { + var mid = start + ((end - start) >> 1); + if (comparison(span[mid], value) < 0) + { + start = mid + 1; + } + else + { + end = mid; + } + } + + return start; + } + + static int UpperBound(Span span, int start, int end, T value, Comparison comparison) + { + while (start < end) + { + var mid = start + ((end - start) >> 1); + if (comparison(span[mid], value) <= 0) + { + start = mid + 1; + } + else + { + end = mid; + } + } + + return start; + } + + + static void Rotate(Span span, int first, int middle, int last) + { + Reverse(span, first, middle); + Reverse(span, middle, last); + Reverse(span, first, last); + + + static void Reverse(Span span, int start, int end) + { + for (int i = start, j = end - 1; i < j; i++, j--) + { + (span[i], span[j]) = (span[j], span[i]); + } + } + } + } + } + } + } + + /// + /// Sorts the given spans of keys and values by comparing the keys using the given comparison. It is expected that + /// keys[1] is directly associated with values[1], etc. + /// Uses merge sort. + /// + public void StableSortWith(Span values, + Comparison comparison) + { + if (span.Length != values.Length) + { + throw new ArgumentException("Keys and values must have the same length."); + } + + if (span.Length < 2) + { + return; + } + + const int insertionSortThreshold = 16; + if (span.Length <= insertionSortThreshold) + { + InsertionSort(span, values, comparison); + return; + } + + var mid = span.Length >> 1; + var leftKeys = span[..mid]; + var rightKeys = span[mid..]; + var leftValues = values[..mid]; + var rightValues = values[mid..]; + + leftKeys.StableSortWith(leftValues, comparison); + rightKeys.StableSortWith(rightValues, comparison); + Merge(span, values, mid, comparison); + return; + + static void InsertionSort(Span keys, Span values, Comparison comparison) + { + for (var i = 1; i < keys.Length; i++) + { + var key = keys[i]; + var value = values[i]; + var j = i - 1; + + while (j >= 0 && comparison(keys[j], key) > 0) + { + keys[j + 1] = keys[j]; + values[j + 1] = values[j]; + j--; + } + + keys[j + 1] = key; + values[j + 1] = value; + } + } + + + static void Merge(Span keys, Span values, int mid, Comparison comparison) + { + if (mid <= 0 || mid >= keys.Length) + { + return; + } + + if (comparison(keys[mid - 1], keys[mid]) <= 0) + { + return; + } + + MergeRange(keys, values, 0, mid, keys.Length, comparison); + return; + + static void MergeRange(Span keys, Span values, int start, int mid, int end, + Comparison comparison) + { + while (true) + { + if (start >= mid || mid >= end) + { + return; + } + + if (end - start == 2) + { + if (comparison(keys[mid], keys[start]) < 0) + { + (keys[start], keys[mid]) = (keys[mid], keys[start]); + (values[start], values[mid]) = (values[mid], values[start]); + } + + return; + } + + var leftLen = mid - start; + var rightLen = end - mid; + + if (leftLen > rightLen) + { + var firstCut = start + (leftLen >> 1); + var secondCut = LowerBound(keys, mid, end, keys[firstCut], comparison); + var newMid = firstCut + (secondCut - mid); + + Rotate(keys, values, firstCut, mid, secondCut); + MergeRange(keys, values, start, firstCut, newMid, comparison); + start = newMid; + mid = secondCut; + } + else + { + var secondCut = mid + (rightLen >> 1); + var firstCut = UpperBound(keys, start, mid, keys[secondCut], comparison); + var newMid = firstCut + (secondCut - mid); + + Rotate(keys, values, firstCut, mid, secondCut); + MergeRange(keys, values, start, firstCut, newMid, comparison); + start = newMid; + mid = secondCut; + } + + continue; + + static int LowerBound(Span keys, int start, int end, T value, + Comparison comparison) + { + while (start < end) + { + var mid = start + ((end - start) >> 1); + if (comparison(keys[mid], value) < 0) + { + start = mid + 1; + } + else + { + end = mid; + } + } + + return start; + } + + static int UpperBound(Span keys, int start, int end, T value, + Comparison comparison) + { + while (start < end) + { + var mid = start + ((end - start) >> 1); + if (comparison(keys[mid], value) <= 0) + { + start = mid + 1; + } + else + { + end = mid; + } + } + + return start; + } + + static void Rotate(Span keys, Span values, int first, int middle, int last) + { + Reverse(keys, values, first, middle); + Reverse(keys, values, middle, last); + Reverse(keys, values, first, last); + + return; + + static void Reverse(Span keys, Span values, int start, int end) + { + for (int i = start, j = end - 1; i < j; i++, j--) + { + (keys[i], keys[j]) = (keys[j], keys[i]); + (values[i], values[j]) = (values[j], values[i]); + } + } + } + } + } + } + } + } +} diff --git a/sources/Input/Input/TargetPoint.cs b/sources/Input/Input/TargetPoint.cs new file mode 100644 index 0000000000..4607643ae7 --- /dev/null +++ b/sources/Input/Input/TargetPoint.cs @@ -0,0 +1,54 @@ +using System.Diagnostics.CodeAnalysis; +using System.Numerics; +using Silk.NET.Maths; + +namespace Silk.NET.Input; + +/// +/// Represents a point on a target at which a pointer is pointing. +/// +/// +/// An integral identifier for the point. This point must be the only point for the device currently pointing at a +/// target with this identifier at any given time. If this point ceases to point at the target, then the identifier +/// becomes free for another device point. This means that this identifier can just be a counter, but may be globally +/// unique depending on the backend's capabilities. If an index is used, points with greater indices should not be +/// "moved" into this point's place should it no longer point at the target. This is to allow applications to track +/// distinct points. +/// +/// Flags describing the state of the point. +/// The absolute position on the target at which the pointer is pointing. +/// +/// The normalized position on the target at which the pointer is pointing, if applicable. If this is not available +/// (e.g. due to the target being infinitely large a.k.a. "unbounded"), then this property shall have a value of +/// default. +/// +/// +/// A ray representing the distance and angle at which the pointer is pointing at the point on the target. A ray with an +/// orientation equivalent to an identity quaternion shall be interpreted as the point directly perpendicular to and +/// facing towards the target, with this being the default value should this information be unavailable. If distance +/// information is unavailable, this shall be equivalent to a default vector. +/// +/// +/// The pressure applied to the point on the target by the pointer, between 0.0 representing the minimum amount +/// of pressure and 1.0 representing the maximum amount of pressure. This shall be 1.0 if such data is +/// unavailable but the point is otherwise valid. +/// +/// The pointer being pointed at. +public readonly record struct TargetPoint( + int Id, + TargetPointFlags Flags, + Vector3 Position, + Vector3 NormalizedPosition, + Ray3D Pointer, + float Pressure, + IPointerTarget? Target +) +{ + /// + /// Gets a value indicating whether this is a valid instance of a point on a + /// that the user is pointing at using their pointer device. + /// + [MemberNotNullWhen(true, nameof(Target))] + public bool IsValid => + (Flags & TargetPointFlags.PointingAtTarget) != TargetPointFlags.NotPointingAtTarget; +} diff --git a/sources/Input/Input/TargetPointFlags.cs b/sources/Input/Input/TargetPointFlags.cs new file mode 100644 index 0000000000..091cb74fb4 --- /dev/null +++ b/sources/Input/Input/TargetPointFlags.cs @@ -0,0 +1,18 @@ +namespace Silk.NET.Input; + +/// +/// Flags describing a state. +/// +[Flags] +public enum TargetPointFlags +{ + /// + /// No flags are set, indicating that the point is not being pointed at and therefore may not be valid. + /// + NotPointingAtTarget = 0, + + /// + /// Indicates that the point has been resolved as a valid point at which the pointer is pointing. + /// + PointingAtTarget = 1 << 0 +} \ No newline at end of file diff --git a/sources/Playground/InputTesting.cs b/sources/Playground/InputTesting.cs new file mode 100644 index 0000000000..27921df214 --- /dev/null +++ b/sources/Playground/InputTesting.cs @@ -0,0 +1,122 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Silk.NET.Input; +using Surface = Silk.NET.Windowing.Surface; + +internal partial class InputTesting +{ + + private static InputContext InitInputContext(TSurface surface) where TSurface : Surface + { + TestLog.Debug("Initializing input context"); + var inputContext = surface.CreateInput(); + inputContext.ConnectionChanged += OnInputConnectionChanged; + + // keyboard events + inputContext.Keyboards.KeyChanged += OnKeyChanged; + inputContext.Keyboards.KeyChar += OnKeyChar; + + // gamepad events + inputContext.Gamepads.ThumbstickMove += OnGamepadThumbstickMove; + inputContext.Gamepads.TriggerMove += OnGamepadTriggerMove; + inputContext.Gamepads.ButtonChanged += OnGamepadButtonChanged; + + // joystick events + inputContext.Joysticks.AxisMove += OnJoystickAxisMove; + inputContext.Joysticks.ButtonChanged += OnJoystickButtonChanged; + inputContext.Joysticks.HatMove += OnJoystickHatMove; + + // pointer events + inputContext.Pointers.ButtonChanged += OnPointerButtonChanged; + inputContext.Pointers.Click += OnPointerClick; + inputContext.Pointers.DoubleClick += OnPointerDoubleClick; + inputContext.Pointers.GripChanged += OnPointerGripChanged; + inputContext.Pointers.PointChanged += OnPointerPointChanged; + inputContext.Pointers.TargetChanged += OnPointerTargetChanged; + inputContext.Pointers.MouseScroll += OnPointerScroll; + + return inputContext; + } + + private static void OnInputConnectionChanged(ConnectionEvent obj) + { + TestLog.Debug($"{obj.Device.Name} {obj.Device.Id} {(obj.IsConnected ? "connected" : "disconnected")}"); + } + + private static void OnJoystickHatMove(JoystickHatMoveEvent obj) + { + TestLog.Debug($"{nameof(JoystickAxisMoveEvent)} from {obj.Joystick} moved to {obj.Value}");; + } + + private static void OnJoystickButtonChanged(ButtonChangedEvent obj) + { + TestLog.Debug($"{nameof(ButtonChangedEvent<>)} {obj.Button.Name} from {obj.Device} changed to {obj.Button.IsDown}"); + } + + private static void OnPointerScroll(MouseScrollEvent obj) + { + TestLog.Debug($"{nameof(MouseScrollEvent)} from {obj.Mouse} changed from {obj.WheelPosition - obj.Delta} to {obj.WheelPosition}"); + } + + private static void OnPointerTargetChanged(PointerTargetChangedEvent obj) + { + TestLog.Debug($"{nameof(PointerTargetChangedEvent)} from {obj.Pointer} changed from to {obj.Target} with bounds {obj.OldBounds} to new bounds: {obj.NewBounds}"); + } + + private static void OnPointerPointChanged(PointChangedEvent obj) + { + TestLog.Debug($"{nameof(PointChangedEvent)} from {obj.Pointer} changed from {obj.OldPoint} to {obj.NewPoint}"); + } + + private static void OnPointerGripChanged(PointerGripChangedEvent obj) + { + TestLog.Debug($"{nameof(PointerGripChangedEvent)} from {obj.Pointer} changed from {obj.GripPressure - obj.Delta} to {obj.GripPressure}"); + } + + private static void OnPointerDoubleClick(PointerClickEvent obj) + { + TestLog.Debug($"Double-{nameof(PointerClickEvent)} from {obj.Pointer} with button {obj.Button} at {obj.Point}"); + } + + private static void OnPointerClick(PointerClickEvent obj) + { + TestLog.Debug($"{nameof(PointerClickEvent)} from {obj.Pointer} with button {obj.Button} at {obj.Point}"); + } + + private static void OnPointerButtonChanged(ButtonChangedEvent obj) + { + TestLog.Debug($"{nameof(ButtonChangedEvent<>)} {obj.Button.Name} from {obj.Device} changed to {obj.Button.IsDown}"); + } + + private static void OnJoystickAxisMove(JoystickAxisMoveEvent obj) + { + TestLog.Debug($"{nameof(JoystickAxisMoveEvent)} {obj.Axis} from {obj.Joystick} changed from {obj.Value - obj.Delta} to {obj.Value}"); + } + + private static void OnGamepadButtonChanged(ButtonChangedEvent obj) + { + TestLog.Debug($"{nameof(ButtonChangedEvent<>)} {obj.Button.Name} from {obj.Device} changed to {obj.Button.IsDown}"); + } + + private static void OnGamepadTriggerMove(GamepadTriggerMoveEvent obj) + { + TestLog.Debug($"{nameof(GamepadTriggerMoveEvent)} from {obj.Gamepad} changed from {obj.Value - obj.Delta} to {obj.Value}"); + } + + private static void OnGamepadThumbstickMove(GamepadThumbstickMoveEvent obj) + { + TestLog.Debug($"{nameof(GamepadThumbstickMoveEvent)} from {obj.Gamepad} changed from {obj.Value - obj.Delta} to {obj.Value}"); + } + + private static void OnKeyChar(KeyCharEvent obj) + { + TestLog.Debug($"{nameof(KeyCharEvent)} {obj.Character} from {obj.Keyboard} pressed"); + } + + private static void OnKeyChanged(KeyChangedEvent obj) + { + var key = obj.Key; + TestLog.Debug($"{nameof(KeyCharEvent)} {key} from {obj.Keyboard} changed to {key.IsDown}"); + } +} diff --git a/sources/Playground/Playground.csproj b/sources/Playground/Playground.csproj index 50b59c5c80..4d35932cf1 100644 --- a/sources/Playground/Playground.csproj +++ b/sources/Playground/Playground.csproj @@ -12,6 +12,7 @@ + diff --git a/sources/Playground/Program.cs b/sources/Playground/Program.cs index 2a7afc3c8d..c198675a2d 100644 --- a/sources/Playground/Program.cs +++ b/sources/Playground/Program.cs @@ -2,11 +2,12 @@ using System.Runtime.InteropServices; using Silk.NET.Core; +using Silk.NET.Input; using Silk.NET.OpenGL; using Silk.NET.Windowing; using Surface = Silk.NET.Windowing.Surface; -internal class MyApplication : ISurfaceApplication +internal partial class InputTesting : ISurfaceApplication { public static void Initialize(TSurface surface) where TSurface : Surface @@ -22,9 +23,11 @@ public static void Initialize(TSurface surface) surface.OpenGL.Profile = OpenGLContextProfile.Core; surface.OpenGL.Version = new Version32(3, 3); + var vbo = 0u; var vao = 0u; var prog = 0u; + InputContext? inputContext = null; surface.Created += _ => { // Make the OpenGL context current, this will allow us to use GL static functions. @@ -92,18 +95,25 @@ void main() GL.DeleteShader(vert); GL.DeleteShader(frag); GL.UseProgram(prog); + + + inputContext = InitInputContext(surface); + }; + surface.Update += _ => + { + ExecuteInput(inputContext, surface); }; surface.Render += _ => { GL.Clear(ClearBufferMask.ColorBufferBit); GL.DrawArrays(PrimitiveType.Triangles, 0, 3); }; - surface.Terminating += _ => + surface.Terminating += evt => { GL.DeleteVertexArray(vao); GL.DeleteBuffer(vbo); }; } - public static void Main() => ISurfaceApplication.Run(); + public static void Main() => ISurfaceApplication.Run(); } diff --git a/sources/SDL/SDL/SdlPlatformInfo.cs b/sources/SDL/SDL/SdlPlatformInfo.cs new file mode 100644 index 0000000000..68deed5cf8 --- /dev/null +++ b/sources/SDL/SDL/SdlPlatformInfo.cs @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Silk.NET.SDL; + +/// +/// The SDL platform-specific handles. +/// +/// . +/// The SDL API interface. If null, use . +public readonly record struct SdlPlatformInfo(WindowHandle Window, ISdl? Sdl = null); diff --git a/sources/Windowing/Windowing/Implementations/SDL3/SdlSurface.cs b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurface.cs index 60a50c27e6..a4d0421c17 100644 --- a/sources/Windowing/Windowing/Implementations/SDL3/SdlSurface.cs +++ b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurface.cs @@ -89,6 +89,12 @@ public override bool TryGetPlatformInfo( return false; } + if (typeof(TPlatformInfo) == typeof(SdlPlatformInfo)) + { + info = (TPlatformInfo)(object)new SdlPlatformInfo(Impl.Handle, Sdl.Instance); + return true; + } + var props = Sdl.GetWindowProperties(Impl.Handle); if (typeof(TPlatformInfo) == typeof(CocoaPlatformInfo)) { diff --git a/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.cs b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.cs index 59ba9bc46a..f84bb8092f 100644 --- a/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.cs +++ b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceComponents.cs @@ -106,7 +106,14 @@ public static WindowHandle InitializePlatform() DebugPrintWithError(IsChildrenEnabled ? "Children supported" : "Children unsupported"); Sdl.ClearError(); - IsWindowEnabled = Sdl.SetWindowPosition(tempWindow, 1, 1); + var videoDriverNamePtr = Sdl.GetVideoDriver(0); + Span videoDriverName = stackalloc char[64]; + var isWayland = videoDriverNamePtr != nullptr + && videoDriverNamePtr.TryReadToSpan(ref videoDriverName) + && videoDriverName.StartsWith("wayland"); + + IsWindowEnabled = isWayland || Sdl.SetWindowPosition(tempWindow, 1, 1); + DebugPrintWithError($"Window decoration {(IsWindowEnabled ? "supported" : "unsupported")}"); Sdl.ClearError(); return tempWindow; diff --git a/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceLifecycle.cs b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceLifecycle.cs index 60a30150e6..3d1b451d9b 100644 --- a/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceLifecycle.cs +++ b/sources/Windowing/Windowing/Implementations/SDL3/SdlSurfaceLifecycle.cs @@ -125,7 +125,7 @@ private static AppResult AttachedEvent(void* appstate, Event* @event) private static void CoreEvent(SdlSurface surface, ref Event @event) { - DebugPrint($"got {(EventType)@event.Type}, root surface is {surface}."); + // DebugPrint($"got {(EventType)@event.Type}, root surface is {surface}."); SdlEventProcessor.DeliverEvent(ref @event); } diff --git a/sources/Windowing/Windowing/Surface.cs b/sources/Windowing/Windowing/Surface.cs index e2605e428d..28d38f47a1 100644 --- a/sources/Windowing/Windowing/Surface.cs +++ b/sources/Windowing/Windowing/Surface.cs @@ -284,7 +284,24 @@ protected internal virtual void OnUpdate() /// Centers this window to the given monitor or, if null, the current monitor the window's on. /// /// The specific display to center the window to, if any. - public void Center(IDisplay? display = null) => throw new NotImplementedException(); + public void Center(IDisplay? display = null) + { + if ( + Window is null + || Display is null + || display is not null && !Display.Available.Contains(display) + ) + { + return; + } + + if (display is not null) + { + Display.Current = display; + } + + Window.Position = (Vector2)Display.Current.WorkArea.Center - (Window.Size / 2); + } /// /// Converts a point that is defined in the same coordinate space as to instead be @@ -293,7 +310,15 @@ protected internal virtual void OnUpdate() /// /// The point to transform. /// The transformed point. - public Vector2 ScreenToClient(Vector2 point) => throw new NotImplementedException(); + public Vector2 ScreenToClient(Vector2 point) + { + if (Window is null || Display is null) + { + return point; + } + + return point - Window.Position; + } /// /// Converts a point that is defined relative to to instead be defined in the @@ -302,7 +327,15 @@ protected internal virtual void OnUpdate() /// /// The point to transform. /// The transformed point. - public Vector2 ClientToScreen(Vector2 point) => throw new NotImplementedException(); + public Vector2 ClientToScreen(Vector2 point) + { + if (Window is null || Display is null) + { + return point; + } + + return point + Window.Position; + } /// /// Converts a point that is defined relative to by multiplying it with the @@ -310,7 +343,31 @@ protected internal virtual void OnUpdate() /// /// The point to transform. /// The transformed point. - public Vector2 ClientToDrawable(Vector2 point) => throw new NotImplementedException(); + public Vector2 ClientToDrawable(Vector2 point) + { + if (Window is null) + { + return point; + } + + return point * (DrawableSize / Window.ClientSize); + } + + /// + /// Converts a point that is defined in terms of by dividing it by the division of + /// by 's size. + /// + /// The point to transform. + /// The transformed point. + public Vector2 DrawableToClient(Vector2 point) + { + if (Window is null) + { + return point; + } + + return point / (DrawableSize / Window.ClientSize); + } /// public abstract bool TryGetPlatformInfo( diff --git a/tests/Input/Input/InputMarshalTests.cs b/tests/Input/Input/InputMarshalTests.cs new file mode 100644 index 0000000000..e75c730077 --- /dev/null +++ b/tests/Input/Input/InputMarshalTests.cs @@ -0,0 +1,160 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Reflection; +using NUnit.Framework; + +namespace Silk.NET.Input.UnitTests; + +[TestFixture] +public class InputMarshalTests +{ + [TestCase(TypeArgs = [typeof(PointerButton)])] + [TestCase(TypeArgs = [typeof(JoystickButton)])] + [TestCase(TypeArgs = [typeof(KeyName)])] + public void GetButtonCount() + where T : unmanaged, Enum + { + // This is to determine the gaps in KeyName. + var prev = -1; + foreach (var @enum in Enum.GetValues().Order()) + { + var val = SilkMarshal.ConstCast(@enum); + if (val - 1 != prev) + { + Console.WriteLine( + $"{prev} ({SilkMarshal.ConstCast(prev)}), {val} ({@enum})" + ); + } + + prev = val; + } + } + + [TestCase(TypeArgs = [typeof(PointerButton)])] + [TestCase(TypeArgs = [typeof(JoystickButton)])] + [TestCase(TypeArgs = [typeof(KeyName)])] + public void EnumerateButtonList() + where T : unmanaged, Enum + { + var list = InputMarshal.CreateList>(); + var expectedCount = Enum.GetNames(typeof(T)) + .DistinctBy(Enum.Parse) + .Count(x => x != "Unknown"); + Assert.That(list.List, Has.Count.EqualTo(expectedCount)); + var encountered = 0; + var values = Enum.GetValues() + .Where(x => x.ToString() != "Unknown") + .Distinct() + .Order() + .GetEnumerator(); + foreach (var btn in list.List) + { + encountered++; + Assert.Multiple(() => + { + Assert.That(values.MoveNext(), Is.True); + Assert.That(btn.Name, Is.EqualTo(values.Current)); + Assert.That(btn.Pressure, Is.EqualTo(0)); + Assert.That(btn.IsDown, Is.False); + }); + } + + Assert.That(encountered, Is.EqualTo(expectedCount)); + } + + [TestCase(TypeArgs = [typeof(PointerButton)])] + [TestCase(TypeArgs = [typeof(JoystickButton)])] + [TestCase(TypeArgs = [typeof(KeyName)])] + public void IndexButtonList() + where T : unmanaged, Enum + { + var list = InputMarshal.CreateList>(); + var idx = 0; + foreach ( + var name in Enum.GetValues().Where(x => x.ToString() != "Unknown").Distinct().Order() + ) + { + var btn = list.List[idx++]; + Assert.Multiple(() => + { + Assert.That(btn.Name, Is.EqualTo(name)); + Assert.That(btn.Pressure, Is.EqualTo(0)); + Assert.That(btn.IsDown, Is.False); + }); + } + } + + [TestCase(TypeArgs = [typeof(PointerButton)])] + [TestCase(TypeArgs = [typeof(JoystickButton)])] + [TestCase(TypeArgs = [typeof(KeyName)])] + public void GetButtonState() + where T : unmanaged, Enum + { + var list = InputMarshal.CreateList>().List.AsButtonList(); + foreach ( + var name in Enum.GetValues().Where(x => x.ToString() != "Unknown").Distinct().Order() + ) + { + var btn = list[name]; + Assert.Multiple(() => + { + Assert.That(btn.Name, Is.EqualTo(name)); + Assert.That(btn.Pressure, Is.EqualTo(0)); + Assert.That(btn.IsDown, Is.False); + }); + } + } + + [TestCase(TypeArgs = [typeof(PointerButton)])] + [TestCase(TypeArgs = [typeof(JoystickButton)])] + [TestCase(TypeArgs = [typeof(KeyName)])] + public void IndexNameTranslationRoundTrip() + where T : unmanaged, Enum + { + var values = Enum.GetValues() + .Where(x => x.ToString() != "Unknown") + .Distinct() + .Order() + .GetEnumerator(); + for (var i = 0; i < InputMarshal.GetButtonListCount(); i++) + { + Assert.That(values.MoveNext(), Is.True); + var name = InputMarshal.ButtonList.IndexName(i); + Assert.Multiple(() => + { + Assert.That(name, Is.EqualTo(values.Current)); + Assert.That(InputMarshal.ButtonList.NameIndex(name), Is.EqualTo(i)); + }); + } + } + + [TestCase(TypeArgs = [typeof(PointerButton)])] + [TestCase(TypeArgs = [typeof(JoystickButton)])] + [TestCase(TypeArgs = [typeof(KeyName)])] + public void SetGetBinaryButtonState() + where T : unmanaged, Enum + { + var arr = Enum.GetValues() + .Where(x => x.ToString() != "Unknown") + .Distinct() + .Order() + .ToArray(); + foreach (var name in arr) + { + var list = InputMarshal.CreateList>(); + InputMarshal.SetButtonState(list, new Button(name, true, 1), true); + foreach (var testName in arr) + { + var btn = list.List.AsButtonList()[testName]; + Assert.Multiple(() => + { + Assert.That(btn.Name, Is.EqualTo(testName)); + Assert.That(btn.Pressure, Is.EqualTo(testName.Equals(name) ? 1 : 0)); + Assert.That(btn.IsDown, Is.EqualTo(testName.Equals(name))); + }); + } + } + } +} diff --git a/tests/Input/Input/Silk.NET.Input.UnitTests.csproj b/tests/Input/Input/Silk.NET.Input.UnitTests.csproj new file mode 100644 index 0000000000..2daa2e92e6 --- /dev/null +++ b/tests/Input/Input/Silk.NET.Input.UnitTests.csproj @@ -0,0 +1,19 @@ + + + + net8.0 + enable + enable + + + + + + + + + Silk.NET.Core.cs + + + +