Work on more of the implementation

Author: Perksey

Silk.NET.sln

@@ -13,6 +13,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		LICENSE.md = LICENSE.md
 		generator.json = generator.json
 		Silk.NET.sln.DotSettings = Silk.NET.sln.DotSettings
+		global.json = global.json
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "docs", "docs", "{9DB0EA3E-7216-4F9C-98F5-8A7483E9F083}"

docs/for-contributors/README.md

@@ -0,0 +1,8 @@
+# Welcome to the Silk.NET Contributors' Documentation
+
+Silk.NET 3.0 development was approved on mandate of a documentation regime that included "for-contributors"
+documentation, with the goal of increasing the maintainability and ease of contribution to the library. You've landed in
+the home of that documentations!
+
+The goal of this documentation area, like `tests`, is to mirror the directory structure of `sources` to allow easy
+navigation to the corresponding design notes for a given portion of the library.

docs/for-contributors/Windowing/Implementations/SDL3/event-pump.md

@@ -0,0 +1,18 @@
+# The Event Pump
+
+The largest influence in the `ISurfaceApplication` design is the fact that for many platforms only the entry thread is
+allowed to interact with the window manager (e.g. for the purposes of events). This creates a problem because rendering
+is very much not single-threaded, nor are most use cases where the user has multiple windows. As such,
+`ISurfaceApplication` gives the implementation freedom to decide what the most appropriate thread is to call into the
+surface to raise events. This is further emphasised by the definition of `ISurfaceChildren` where the user can only
+`Spawn` a surface, and not have a blocking call they can send off to their own thread. This allows the child windows to
+use the same event thread and synchronization. This is likely inconvenient for rendering scenarios though
+(e.g. for OpenGL where it's one thread per context/window, but all surfaces use the same thread by default...), for
+which I expect that we'll add the ability to multithread for certain events in `SurfaceTimingOptions` or
+`SurfaceTickOptions`. This however has been excluded from the initial 3.0 proposal.
+
+Note that `SDL_AppEvent` is only guaranteed to be called on the event thread for events raised by the window
+manager/operating system. As such, we always assume that those events are on the event thread when received and invoke
+the window directly. For other events, we should be wary of concurrency. Note that I have absolutely no idea what this
+means for things like our `Surface.Continue` method for `IsEventDriven` - right now this isn't implemented. Read more
+here: https://github.com/libsdl-org/SDL/issues/11387

docs/for-contributors/Windowing/README.md

@@ -0,0 +1,32 @@
+# Silk.NET.Windowing
+
+Silk.NET.Windowing is our cross-platform windowing abstraction. For more information about what it is, see the [proposal](../../proposals/Proposal%20-%20Windowing%203.0.md).
+
+As per the proposal, Windowing is implemented in exactly one project/assembly containing the abstractions and one
+"reference implementation" given available target information (e.g. TFM). Today, this includes:
+- SDL3, used for every platform.
+
+If the user doesn't want to use our reference implementation, it is expected that they use the trimmer to make its
+presence benign.
+
+Note that for each "reference implementation" it is expected that there shall be a matching Silk.NET.Input "reference
+implementation" capable of receiving an `INativeWindow` from the Silk.NET.Windowing implementation in use. How you
+interpret this requirement is up to you, e.g. we could have a Silk.NET.Input Win32-specific implementation that uses
+`Win32PlatformInfo` for our SDL3 surface, likewise we could have a Silk.NET.Input SDL3 implementation that receives a
+`Win32PlatformInfo` from a Silk.NET.Windowing implementation and automatically creates a wrapping window - this is up to
+you (but try to keep it sane please, that last one sounded extremely cursed). Ultimately, the goal is the user being
+able to pull in `Silk.NET.Windowing` and `Silk.NET.Input`, create a surface, be able to do `surface.CreateInput()` and
+it all Just Work. Right now, this equates to a 1:1 match of Silk.NET.Windowing/Silk.NET.Input implementations, and is
+not expected to change.
+
+Silk.NET.Input is completely independent from Silk.NET.Windowing this time around, unlike 1.X/2.X. This is because we
+believe the Input HLU can target wider applicability beyond just receiving input for a window, with VR being the
+principal use case in mind when making this decision. For more information, read the [Multi-Backend Input proposal](../../proposals/Proposal%20-%20Multi-Backend%20Input.md).
+
+Most of the files within the top-level Windowing directory are exactly as proposed. The exception is the `Surface`
+class, which seeks to make as much common as humanly possible (this includes the Render/Update timing logic and some
+other auxiliary functions). Beyond that, this is functionally an interface. The actual entry-points into the Windowing
+API, `ISurfaceApplication.Run` and `IDetachedSurfaceLifecycle.TryCreate`, are defined `partial`ly with matching
+implementation parts in the `Implementations` subdirectories.
+
+To find out more about the implementation details, see the `Implementations` directory.

eng/silktouch/sdl/SDL3/sdl-SDL.h

@@ -1,2 +1,3 @@
-#define SDL_MAIN_USE_CALLBACKS
 #include <SDL3/SDL.h>
+#include <SDL3/SDL_main.h>
+#include <SDL3/SDL_vulkan.h>

eng/silktouch/sdl/remap.rsp

@@ -1,2 +1,6 @@
 --remap
 SDL_fabsf=float.Abs
+VkSurfaceKHR=ulong
+VkInstance=void*
+VkPhysicalDevice=ulong
+VkAllocationCallbacks=void

global.json

@@ -0,0 +1,6 @@
+{
+    "sdk": {
+        "version": "9.0.100",
+        "rollForward": "major"
+    }
+}

sources/SDL/SDL/Extensions.cs

@@ -27,17 +27,17 @@ public static void ThrowError(this ISdl sdl)
         }
     }
 
-    public static void ThrowSdlError(this int ec)
+    public static void ThrowSdlError(this bool ec)
     {
-        if (ec != 0)
+        if (!ec)
         {
             Sdl.ThrowError();
         }
     }
 
-    public static void ThrowSdlError(this int ec, ISdl sdl)
+    public static void ThrowSdlError(this bool ec, ISdl sdl)
     {
-        if (ec != 0)
+        if (!ec)
         {
             sdl.ThrowError();
         }

sources/SDL/SDL/SDL3/AppEventFunc.gen.cs

@@ -0,0 +1,30 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// Ported from SDL.h and corresponding dependencies of SDL3.
+// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license.
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Silk.NET.SDL;
+
+public readonly unsafe struct AppEventFunc : IDisposable
+{
+    private readonly void* Pointer;
+    public delegate* unmanaged<void*, Event*, AppResult> Handle =>
+        (delegate* unmanaged<void*, Event*, AppResult>)Pointer;
+
+    public AppEventFunc(delegate* unmanaged<void*, Event*, AppResult> ptr) => Pointer = ptr;
+
+    public AppEventFunc(AppEventFuncDelegate proc) => Pointer = SilkMarshal.DelegateToPtr(proc);
+
+    public void Dispose() => SilkMarshal.Free(Pointer);
+
+    public static implicit operator AppEventFunc(
+        delegate* unmanaged<void*, Event*, AppResult> pfn
+    ) => new(pfn);
+
+    public static implicit operator delegate* unmanaged<void*, Event*, AppResult>(
+        AppEventFunc pfn
+    ) => (delegate* unmanaged<void*, Event*, AppResult>)pfn.Pointer;
+}

sources/SDL/SDL/SDL3/AppEventFuncDelegate.gen.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.
+// Ported from SDL.h and corresponding dependencies of SDL3.
+// Original source is Copyright (C) 1997-2024 Sam Lantinga. Licensed under the zlib license.
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Silk.NET.SDL;
+
+public unsafe delegate AppResult AppEventFuncDelegate(void* arg0, Event* arg1);