cleanup

Author: domportera

sources/Input/Input/Implementations/SDL3/DataStructures/SdlArray.cs

@@ -18,7 +18,7 @@ namespace Silk.NET.Input.SDL3.DataStructures;
 /// <typeparam name="T">The type of values in the array - usually SDL struct types.</typeparam>
 internal readonly unsafe ref struct SdlArray<T> : IDisposable, IEquatable<SdlArray<T>> where T : unmanaged
 {
-    private readonly Ptr<T> _ptr;
+    private readonly T* _ptr;
     public int Count { get; }
     private readonly ISdl? _sdl;
 
@@ -47,15 +47,18 @@ public void Dispose()
     {
         if (!CanDispose)
         {
+            #if DEBUG
+            InputLog.Error("SdlArray disposal attempt without permission");
+            #endif
             return;
         }
 
-        if (_ptr.Native == null)
+        if (_ptr == null)
         {
             return;
         }
 
-        _sdl.Free(_ptr.Native);
+        _sdl.Free(_ptr);
     }
 
     public static implicit operator Ptr<T>(SdlArray<T> array) => array._ptr;
@@ -72,19 +75,19 @@ public void Dispose()
 
 
 
-    public bool IsNull => _ptr.Native == null;
+    public bool IsNull => _ptr == null;
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Span<T> AsSpan() => _ptr.Native == null ? default : new Span<T>(_ptr.Native, Count);
+    public Span<T> AsSpan() => _ptr == null ? default : new Span<T>(_ptr, Count);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public ReadOnlySpan<T> AsReadOnlySpan() => _ptr.Native == null ? default : new ReadOnlySpan<T>(_ptr.Native, Count);
+    public ReadOnlySpan<T> AsReadOnlySpan() => _ptr == null ? default : new ReadOnlySpan<T>(_ptr, Count);
 
     public ref T this[int index]
     {
         get
         {
-            if (_ptr.Native == null)
+            if (_ptr == null)
             {
                 throw new NullReferenceException();
             }
@@ -96,7 +99,7 @@ public ref T this[int index]
 
             ArgumentOutOfRangeException.ThrowIfNegative(index);
 
-            return ref _ptr.Native[index];
+            return ref _ptr[index];
         }
     }
 
@@ -108,6 +111,6 @@ public ref T this[uint index]
 
     public bool Equals(SdlArray<T> other) => this == other;
 
-    public override bool Equals(object? obj) => obj == null && _ptr.Native == null;
-    public override int GetHashCode() => HashCode.Combine(_ptr, Count, _sdl);
+    public override bool Equals(object? obj) => obj == null && _ptr == null;
+    public override int GetHashCode() => HashCode.Combine((nuint)_ptr, Count, _sdl);
 }

sources/Input/Input/Implementations/SDL3/Devices/SilkSdlDisplayHandle.cs

@@ -1,11 +1,16 @@
 // 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.InteropServices;
+
 namespace Silk.NET.Input.SDL3.Devices.Pointers.Targets;
 
+[StructLayout(LayoutKind.Explicit, Size = sizeof(uint), Pack = 1)]
 internal readonly struct SilkSdlDisplayHandle
 {
+    [FieldOffset(0)] public readonly uint Id;
+
+    private SilkSdlDisplayHandle(uint id) => Id = id;
+
     public static readonly SilkSdlDisplayHandle AllDisplays = new(uint.MaxValue);
-    public uint Id { get; }
-    public SilkSdlDisplayHandle(uint id) => Id = id;
 }

sources/Input/Input/Implementations/SDL3/SdlInputBackend.cs

@@ -166,21 +166,30 @@ public void Update(IInputHandler? handler = null)
         var rawEvents = _rawEvents.ConsumeWithoutClearing();
 
 #if DEBUG
-        var previousTimestamp = 0ul;
-        var previousStopwatchTimestamp = 0L;
+        TimedRawSdlEvent? previous = null;
 #endif
 
         for(var i = 0; i < rawEvents.Length; ++i)
         {
             ref readonly var evt = ref rawEvents[i];
 #if DEBUG
-            if (evt.Event.Common.Timestamp < previousTimestamp || evt.StopwatchTimestamp < previousStopwatchTimestamp)
+            const string fmt = "Needs pre-sort by {0} timestamp. Please alert maintainer.\nPrevious:{1}\nCurrent:{2}\nDifference: SDL {3} Stopwatch {4}";
+            if (previous is { } prev)
             {
-                InputLog.Error("Needs pre-sort by timestamp - please alert maintainer");
+                if (prev.Event.Common.Timestamp > evt.Event.Common.Timestamp)
+                {
+                    evt.TimeMinus(prev, out var stopwatchDiff, out var sdlDiff);
+                    InputLog.Error(string.Format(fmt, "SDL", previous?.ToString() ?? "null", evt.ToString(), sdlDiff, stopwatchDiff));
+                }
+
+                if (prev.StopwatchTimestamp > evt.StopwatchTimestamp)
+                {
+                    evt.TimeMinus(prev, out var stopwatchDiff, out var sdlDiff);
+                    InputLog.Error(string.Format(fmt, "SDL", previous?.ToString() ?? "null", evt.ToString(), sdlDiff, stopwatchDiff));
+                }
             }
 
-            previousTimestamp = evt.Event.Common.Timestamp;
-            previousStopwatchTimestamp = evt.StopwatchTimestamp;
+            previous = evt;
 #endif
 
             ProcessEvent(evt.Event, evt.StopwatchTimestamp, ref eventArgs);
@@ -623,6 +632,20 @@ public TimedRawSdlEvent(Event @event, long timestamp)
             Event = @event;
             StopwatchTimestamp = timestamp;
         }
+
+        #if DEBUG
+        public override string ToString()
+        {
+            var type = (EventType)Event.Type;
+            return $"{type} | SDL Timestamp: {Event.Common.Timestamp} | Stopwatch Timestamp: {StopwatchTimestamp}";
+        }
+
+        public void TimeMinus(in TimedRawSdlEvent other, out long stopwatchDiff, out long sdlDiff)
+        {
+            stopwatchDiff = StopwatchTimestamp - other.StopwatchTimestamp;
+            sdlDiff = (long)(Event.Common.Timestamp - other.Event.Common.Timestamp);
+        }
+        #endif
     }