Overlays and the Ingame API

src/Snowflake.Bootstrap.Windows/Program.cs

@@ -3,12 +3,27 @@
 
 class Program
 {
+    private static SnowflakeShell snowflakeShell;
+
     static void Main(string[] args)
     {
         Console.WriteLine("Starting Shell...");
-        var snowflakeShell = new SnowflakeShell();
+        AppDomain.CurrentDomain.ProcessExit += ExitHandler;
+        Program.snowflakeShell = new SnowflakeShell();
         snowflakeShell.StartCore();
         while (Console.ReadLine() != "exit") ;
+
+        Console.WriteLine("Shutting down...");
         snowflakeShell.ShutdownCore();
+
+    }
+
+    private static void ExitHandler(object sender, EventArgs e)
+    {
+        Console.WriteLine("Shutting down due to force exit...");
+        if (!snowflakeShell.IsShutdown)
+        {
+            snowflakeShell.ShutdownCore();
+        }
     }
 }

src/Snowflake.Bootstrap.Windows/Snowflake.Bootstrap.Windows.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net6.0</TargetFramework>
-    <RuntimeIdentifiers>win-x64;win10-x64;</RuntimeIdentifiers>
+    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
   </PropertyGroup>
 
   <ItemGroup>

src/Snowflake.Bootstrap.Windows/SnowflakeShell.cs

@@ -19,6 +19,8 @@ internal class SnowflakeShell
 
         private IServiceContainer loadedCore;
 
+        public bool IsShutdown { get; private set; } = false;
+
         internal SnowflakeShell()
         {
         }
@@ -35,12 +37,14 @@ public void RestartCore()
         {
             this.ShutdownCore();
             this.StartCore();
+            this.IsShutdown = false;
         }
 
         public void ShutdownCore()
         {
             this.loadedCore.Dispose();
             GC.WaitForPendingFinalizers();
+            this.IsShutdown = true;
         }
     }
 }

src/Snowflake.Framework.Primitives/Orchestration/Extensibility/IGameEmulation.cs

@@ -16,6 +16,11 @@ namespace Snowflake.Orchestration.Extensibility
     /// </summary>
     public interface IGameEmulation
     {
+        /// <summary>
+        /// A unique ID used to identify this emulation instance.
+        /// </summary>
+        Guid Guid { get; }
+
         /// <summary>
         /// A list of <see cref="IEmulatedController"/> that representes the input devices that will be used
         /// in this emulation instance.

src/Snowflake.Framework.Primitives/Orchestration/Ingame/CursorEventParams.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Snowflake.Orchestration.Ingame
+{
+
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct CursorEventParams
+    {
+        public Cursor Cursor;
+    }
+
+    /// <summary>
+    /// Cursor types. These are the same as CefSharp cursors
+    /// </summary>
+    public enum Cursor : byte
+    {
+        Pointer = 0,
+        Cross,
+        Hand,
+        IBeam,
+        Wait,
+        Help,
+        EastResize,
+        NorthResize,
+        NortheastResize,
+        NorthwestResize,
+        SouthResize,
+        SoutheastResize,
+        SouthwestResize,
+        WestResize,
+        NorthSouthResize,
+        EastWestResize,
+        NortheastSouthwestResize,
+        NorthwestSoutheastResize,
+        ColumnResize,
+        RowResize,
+        MiddlePanning,
+        EastPanning,
+        NorthPanning,
+        NortheastPanning,
+        NorthwestPanning,
+        SouthPanning,
+        SoutheastPanning,
+        SouthwestPanning,
+        WestPanning,
+        Move,
+        VerticalText,
+        Cell,
+        ContextMenu,
+        Alias,
+        Progress,
+        NoDrop,
+        Copy,
+        None,
+        NotAllowed,
+        ZoomIn,
+        ZoomOut,
+        Grab,
+        Grabbing,
+        MiddlePanningVertical,
+        MiddlePanningHorizontal,
+        Custom,
+        DndNone,
+        DndMove,
+        DndCopy,
+        DndLink
+    }
+}

src/Snowflake.Framework.Primitives/Orchestration/Ingame/GameWindowCommand.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Snowflake.Orchestration.Ingame
+{
+
+
+    [StructLayout(LayoutKind.Explicit, Pack = 1)]
+    public struct GameWindowCommand
+    {
+        public const byte GameWindowMagic = 0x9F;
+
+        [FieldOffset(0)] public byte Magic;
+        [FieldOffset(1)] public GameWindowCommandType Type;
+        [FieldOffset(2)] public HandshakeEventParams HandshakeEvent;
+        [FieldOffset(2)] public WindowResizeEventParams ResizeEvent;
+        [FieldOffset(2)] public WindowMessageEventParams WindowMessageEvent;
+        [FieldOffset(2)] public MouseEventParams MouseEvent;
+        [FieldOffset(2)] public CursorEventParams CursorEvent;
+        [FieldOffset(2)] public OverlayTextureEventParams TextureEvent;
+
+        public ReadOnlyMemory<byte> ToBuffer()
+        {
+            return StructUtils.ToMemory(this);
+        }
+
+        public bool IntoBuffer(ref Span<byte> buffer)
+        {
+            return StructUtils.IntoSpan(this, ref buffer);
+        }
+
+        public static GameWindowCommand? FromBuffer(ReadOnlyMemory<byte> buffer)
+        {
+            return StructUtils.FromSpan<GameWindowCommand>(buffer);
+        }
+
+        public static GameWindowCommand Handshake(Guid id)
+        {
+            return new()
+            {
+                Magic = GameWindowMagic,
+                Type = GameWindowCommandType.Handshake,
+                HandshakeEvent = new()
+                {
+                    Guid = id,
+                }
+            };
+        }
+
+        private static class StructUtils
+        {
+            public static unsafe ReadOnlyMemory<byte> ToMemory<T>(T value) where T : unmanaged
+            {
+                byte* pointer = (byte*)&value;
+
+                Memory<byte> _bytes = new byte[Marshal.SizeOf<GameWindowCommand>()];
+                Span<byte> bytes = _bytes.Span;
+
+                for (int i = 0; i < sizeof(T); i++)
+                {
+                    bytes[i] = pointer[i];
+                }
+
+                return _bytes;
+            }
+
+            public static unsafe bool IntoSpan<T>(T value, ref Span<byte> bytes) where T : unmanaged
+            {
+                if (bytes.Length != Marshal.SizeOf<GameWindowCommand>())
+                    return false;
+
+                byte* pointer = (byte*)&value;
+                for (int i = 0; i < sizeof(T); i++)
+                {
+                    bytes[i] = pointer[i];
+                }
+                return true;
+            }
+
+            public static unsafe T? FromSpan<T>(ReadOnlyMemory<byte> value) where T : unmanaged
+            {
+                if (value.Length != Marshal.SizeOf<T>())
+                {
+                    Console.WriteLine("Expected size " + Marshal.SizeOf<T>() + " but got " + value.Length);
+                    return null;
+                }
+
+                return MemoryMarshal.Cast<byte, T>(value.Span)[0];
+            }
+        }
+    }
+}

src/Snowflake.Framework.Primitives/Orchestration/Ingame/GameWindowCommandType.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Snowflake.Orchestration.Ingame
+{
+    public enum GameWindowCommandType : byte
+    {
+        Handshake = 1,
+        WindowResizeEvent = 2,
+        WindowMessageEvent = 3,
+        MouseEvent = 4,
+        CursorEvent = 5,
+        OverlayTextureEvent = 6,
+        ShutdownEvent = 7,
+    }
+}

src/Snowflake.Framework.Primitives/Orchestration/Ingame/HandshakeEventParams.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Snowflake.Orchestration.Ingame
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct HandshakeEventParams
+    {
+        public Guid Guid;
+    }
+}

src/Snowflake.Framework.Primitives/Orchestration/Ingame/MouseEventParams.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Snowflake.Orchestration.Ingame
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct MouseEventParams
+    {
+        public MouseButton MouseDoubleClick;
+
+        public MouseButton MouseDown;
+        public MouseButton MouseUp;
+        public ModifierKeys Modifiers;
+
+        public float MouseX;
+        public float MouseY;
+        public float WheelX;
+        public float WheelY;
+    }
+
+    [Flags]
+    public enum ModifierKeys : byte
+    {
+        None = 0,
+        Shift = 1 << 0,
+        Control = 1 << 1,
+        Alt = 1 << 2
+    }
+
+    [Flags]
+    public enum MouseButton : byte
+    {
+        None = 0,
+        Mouse1 = 1 << 0,
+        Mouse2 = 1 << 1,
+        Mouse3 = 1 << 2,
+        Mouse4 = 1 << 3,
+        Mouse5 = 1 << 4
+    }
+}

src/Snowflake.Framework.Primitives/Orchestration/Ingame/OverlayTextureEventParams.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Snowflake.Orchestration.Ingame
+{
+
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct OverlayTextureEventParams
+    {
+        public nint TextureHandle;
+        public int SourceProcessId;
+        public uint Width;
+        public uint Height;
+        public ulong Size;
+        public ulong Alignment;
+        public nint SyncHandle;
+    }
+}

src/Snowflake.Framework.Primitives/Orchestration/Ingame/WindowMessageEventParams.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Snowflake.Orchestration.Ingame
+{
+
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct WindowMessageEventParams
+    {
+        public int Message;
+        public ulong WParam;
+        public int LParam;
+    }
+}

src/Snowflake.Framework.Primitives/Orchestration/Ingame/WindowResizeEventParams.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Snowflake.Orchestration.Ingame
+{
+
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct WindowResizeEventParams
+    {
+        public int Height;
+        public int Width;
+        public byte Force;
+    }
+}

src/Snowflake.Framework.Primitives/Snowflake.Framework.Primitives.csproj

@@ -6,6 +6,7 @@
     <LangVersion>10.0</LangVersion>
     <Nullable>enable</Nullable>
     <_SnowflakeUseDevelopmentSDK>true</_SnowflakeUseDevelopmentSDK>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
   <ItemGroup>