641 lines
27 KiB
C#
641 lines
27 KiB
C#
using SharpDX;
|
|
using SharpDX.Direct3D11;
|
|
using SharpDX.DXGI;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Drawing.Imaging;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using Valve.VR;
|
|
using VDash.Overlay.Actions;
|
|
using VDash.Utilities;
|
|
using VDash.WindowSelectors;
|
|
using System.Linq;
|
|
using VDash.Overlay.Config;
|
|
|
|
namespace VDash.Overlay
|
|
{
|
|
public class WindowOverlay : IOverlay
|
|
{
|
|
public event EventHandler OverlayShown;
|
|
public event EventHandler OverlayHidden;
|
|
public int CurrentFPS { get; private set; }
|
|
|
|
private Task m_EventPumpTask = null;
|
|
/// <summary>
|
|
/// Tracks whether or not this overlay is actually created.
|
|
/// </summary>
|
|
bool m_Created = false;
|
|
bool m_Running = true;
|
|
|
|
internal ulong m_OverlayHandle;
|
|
public ulong OverlayHandle { get { return m_OverlayHandle; } }
|
|
internal ulong m_ThumbnailIcon;
|
|
public ulong ThumbnailIcon { get { return m_ThumbnailIcon; } }
|
|
public IOverlayConfig OverlayConfig { get { return Config; } }
|
|
|
|
public WindowOverlayConfig Config { get; set; }
|
|
|
|
//internal string m_Key;
|
|
|
|
//internal string m_Name;
|
|
|
|
|
|
//public IWindowSelector Selector { get; private set; } = null;
|
|
|
|
public List<IOverlayAction> OverlayShownActions { get; private set; } = new List<IOverlayAction>();
|
|
public List<IOverlayAction> OverlayHiddenActions { get; private set; } = new List<IOverlayAction>();
|
|
|
|
char[] specialKeys = { '+', '^', '%', '~', '(', ')', '{', '}', '[', ']' };
|
|
|
|
public WindowOverlay(WindowOverlayConfig config)
|
|
{
|
|
//Selector = selector;
|
|
Config = config;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents whether or not an external caller wants this to stay destroyed, really.
|
|
/// To keep the DestroyOnNoWindowFound stuff in check. Don't want it creating when it shouldn't.
|
|
/// </summary>
|
|
bool m_Destroyed = true;
|
|
|
|
public void Create()
|
|
{
|
|
m_Destroyed = false;
|
|
createInternal();
|
|
}
|
|
|
|
private void createInternal()
|
|
{
|
|
if (m_Created) { throw new Exception("This overlay has already been created."); }
|
|
|
|
|
|
//Actually create the overlay
|
|
var overlay = OpenVR.Overlay;
|
|
EVROverlayError err = overlay.CreateDashboardOverlay(Config.Key, Config.Name, ref m_OverlayHandle, ref m_ThumbnailIcon);
|
|
|
|
if (err != EVROverlayError.None)
|
|
{
|
|
throw new Exception($"Error creating overlay: {err}");
|
|
}
|
|
overlay.SetOverlayInputMethod(m_OverlayHandle, VROverlayInputMethod.Mouse);
|
|
|
|
m_Running = true;
|
|
m_EventPumpTask = Task.Factory.StartNew(() => { EventPump(); });
|
|
m_Created = true;
|
|
}
|
|
|
|
public bool IsCreated() { return m_Created; }
|
|
|
|
|
|
public void Destroy()
|
|
{
|
|
m_Destroyed = true;
|
|
destroyInternal();
|
|
}
|
|
|
|
private void destroyInternal()
|
|
{
|
|
if (!m_Created) { throw new Exception("This object is not created."); }
|
|
m_Created = false;
|
|
|
|
//Signal render thread to exit
|
|
m_Running = false;
|
|
|
|
//Wait for render thread to exit
|
|
m_EventPumpTask.Wait();
|
|
|
|
var err = OpenVR.Overlay.DestroyOverlay(m_OverlayHandle);
|
|
|
|
if( err != EVROverlayError.None)
|
|
{
|
|
throw new Exception($"Error destroying overlay: {err}");
|
|
}
|
|
|
|
m_OverlayHandle = OpenVR.k_ulOverlayHandleInvalid;
|
|
m_ThumbnailIcon = OpenVR.k_ulOverlayHandleInvalid;
|
|
}
|
|
|
|
private void EventPump()
|
|
{
|
|
var overlay = OpenVR.Overlay;
|
|
|
|
DateTime lastClick = DateTime.MinValue;
|
|
|
|
#region Rendering setup
|
|
|
|
//Partially taken from here: https://stackoverflow.com/questions/6812068/c-sharp-which-is-the-fastest-way-to-take-a-screen-shot
|
|
//Desktop Duplication didn't work well, hence is why we're sticking with GDI. Still this is faster than using SetTextureRaw.
|
|
|
|
var factory = new Factory1();
|
|
//Get first adapter
|
|
var adapter = factory.GetAdapter1(0);
|
|
//Get device from adapter
|
|
var device = new SharpDX.Direct3D11.Device(adapter);
|
|
|
|
int lastWidth = 0;
|
|
int lastHeight = 0;
|
|
|
|
|
|
// Create Staging texture CPU-accessible
|
|
//Actual screen texture.
|
|
//var screenTexture = new Texture2D(device, textureDesc);
|
|
Texture2D screenTexture = null;
|
|
DataStream stream = null;
|
|
#endregion
|
|
|
|
//For FPS counter.
|
|
int frames = 0;
|
|
DateTime lastFps = DateTime.MinValue;
|
|
DateTime lastNameCheck = DateTime.MinValue;
|
|
|
|
while (m_Running)
|
|
{
|
|
if (Config.DestroyOnNoWindowFound)
|
|
{
|
|
//Check to see if the window actually exists. Act accordingly.
|
|
if (!Config.Selector.WindowExists())
|
|
{
|
|
if (IsCreated())
|
|
{
|
|
destroyInternal();
|
|
Console.WriteLine($"Destroyed {Config.Key} because it's window does not exist.");
|
|
}
|
|
|
|
Thread.Sleep(100);
|
|
continue;
|
|
}
|
|
else if(Config.Selector.WindowExists() && !m_Created && !m_Destroyed)
|
|
{
|
|
createInternal();
|
|
}
|
|
}
|
|
|
|
//This technically should never happen, buuuut...
|
|
IntPtr windowHandle = IntPtr.Zero;
|
|
try
|
|
{
|
|
windowHandle = Config.Selector.GetWindowHandle();
|
|
}
|
|
catch (WindowNotFoundException)
|
|
{
|
|
}
|
|
|
|
//Update the SteamVR dash name if necessary, only once a second.
|
|
if (Config.Selector.WindowExists() && Config.UpdateDashboardName && DateTime.Now.Subtract(lastNameCheck).TotalMilliseconds >= 1000)
|
|
{
|
|
var window = Config.Selector.GetWindowInfo();
|
|
if(GetOverlayName() != window.Title)
|
|
{
|
|
SetOverlayName(window.Title);
|
|
}
|
|
|
|
lastNameCheck = DateTime.Now;
|
|
|
|
|
|
#region Thumbnail rendering
|
|
using (var icon = User32.GetAppIcon(windowHandle))
|
|
{
|
|
using (var iconBmp = icon.ToBitmap())
|
|
{
|
|
var data = iconBmp.LockBits(new Rectangle(0, 0, iconBmp.Width, iconBmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
|
|
|
|
overlay.SetOverlayRaw(m_ThumbnailIcon, data.Scan0, (uint)data.Width, (uint)data.Height, 4);
|
|
|
|
iconBmp.UnlockBits(data);
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
//Skip rendering if overlay isn't visible
|
|
#if !DEBUG
|
|
if ((m_OverlayHandle == OpenVR.k_ulOverlayHandleInvalid) || overlay == null || (!overlay.IsOverlayVisible(m_OverlayHandle)))
|
|
{
|
|
Thread.Sleep(100);
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
#region VR Events
|
|
VREvent_t vrEvent = new VREvent_t();
|
|
|
|
while (OpenVR.Overlay.PollNextOverlayEvent(m_OverlayHandle, ref vrEvent, (uint)Marshal.SizeOf(vrEvent)))
|
|
{
|
|
switch ((EVREventType)vrEvent.eventType)
|
|
{
|
|
case EVREventType.VREvent_MouseMove:
|
|
{
|
|
//Prevent the cursor from moving while we click. Super fkn annoying.
|
|
if(DateTime.Now.Subtract(lastClick).TotalMilliseconds < 400)
|
|
{
|
|
break;
|
|
}
|
|
//Make sure the window still exists
|
|
if (windowHandle != IntPtr.Zero)
|
|
{
|
|
var vrX = vrEvent.data.mouse.x;
|
|
var vrY = vrEvent.data.mouse.y;
|
|
|
|
var rect = new User32.Rect();
|
|
|
|
User32.GetClientRect(windowHandle, ref rect);
|
|
|
|
int width = rect.right - rect.left;
|
|
int height = rect.bottom - rect.top;
|
|
|
|
var point = new System.Drawing.Point() { X = (int)vrX, Y = height - (int)vrY };
|
|
|
|
|
|
var succ = User32.ClientToScreen(windowHandle, ref point);
|
|
|
|
if (!succ)
|
|
{
|
|
Console.WriteLine("ClientToScreen failed.");
|
|
}
|
|
|
|
|
|
succ = User32.SetCursorPos((int)point.X, (int)point.Y);
|
|
|
|
if (!succ)
|
|
{
|
|
Console.WriteLine("SetCursorPos failed.");
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case EVREventType.VREvent_MouseButtonDown:
|
|
{
|
|
var clickType = (EVRMouseButton)vrEvent.data.mouse.button;
|
|
|
|
var winClickType = User32.MouseEventFlags.MOUSEEVENTF_LEFTDOWN;
|
|
|
|
switch (clickType)
|
|
{
|
|
case EVRMouseButton.Left:
|
|
{
|
|
winClickType = User32.MouseEventFlags.MOUSEEVENTF_LEFTDOWN;
|
|
break;
|
|
}
|
|
case EVRMouseButton.Middle:
|
|
{
|
|
winClickType = User32.MouseEventFlags.MOUSEEVENTF_MIDDLEDOWN;
|
|
break;
|
|
}
|
|
case EVRMouseButton.Right:
|
|
{
|
|
winClickType = User32.MouseEventFlags.MOUSEEVENTF_RIGHTDOWN;
|
|
break;
|
|
}
|
|
}
|
|
|
|
User32.mouse_event(winClickType, 0, 0, 0, UIntPtr.Zero);
|
|
lastClick = DateTime.Now;
|
|
break;
|
|
}
|
|
|
|
case EVREventType.VREvent_MouseButtonUp:
|
|
{
|
|
var clickType = (EVRMouseButton)vrEvent.data.mouse.button;
|
|
var winClickType = User32.MouseEventFlags.MOUSEEVENTF_LEFTUP;
|
|
|
|
switch (clickType)
|
|
{
|
|
case EVRMouseButton.Left:
|
|
{
|
|
winClickType = User32.MouseEventFlags.MOUSEEVENTF_LEFTUP;
|
|
break;
|
|
}
|
|
case EVRMouseButton.Middle:
|
|
{
|
|
winClickType = User32.MouseEventFlags.MOUSEEVENTF_MIDDLEUP;
|
|
break;
|
|
}
|
|
case EVRMouseButton.Right:
|
|
{
|
|
winClickType = User32.MouseEventFlags.MOUSEEVENTF_RIGHTUP;
|
|
break;
|
|
}
|
|
}
|
|
|
|
User32.mouse_event(winClickType, 0, 0, 0, UIntPtr.Zero);
|
|
lastClick = DateTime.MinValue;
|
|
break;
|
|
}
|
|
case EVREventType.VREvent_OverlayShown:
|
|
{
|
|
OverlayShown?.Invoke(this, new EventArgs());
|
|
|
|
if (Config.Selector.WindowExists())
|
|
{
|
|
foreach (var action in OverlayShownActions)
|
|
{
|
|
action.PreformAction(this);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case EVREventType.VREvent_OverlayHidden:
|
|
{
|
|
OverlayHidden?.Invoke(this, new EventArgs());
|
|
|
|
if (Config.Selector.WindowExists())
|
|
{
|
|
foreach (var action in OverlayHiddenActions)
|
|
{
|
|
action.PreformAction(this);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case EVREventType.VREvent_KeyboardCharInput:
|
|
{
|
|
//Console.WriteLine($"Got char input: {vrEvent.data.keyboard.cNewInput}");
|
|
var input = vrEvent.data.keyboard.cNewInput;
|
|
|
|
//We should only be getting one keypress at a time.
|
|
switch (input)
|
|
{
|
|
case "\b":
|
|
{
|
|
SendKeys.SendWait("{BACKSPACE}");
|
|
break;
|
|
}
|
|
case "\n":
|
|
{
|
|
SendKeys.SendWait("{ENTER}");
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
if (specialKeys.Contains(input[0]))
|
|
{
|
|
SendKeys.SendWait("{" + input + "}");
|
|
}
|
|
else
|
|
{
|
|
SendKeys.SendWait(input);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
case EVREventType.VREvent_ButtonPress:
|
|
{
|
|
EVRButtonId button = (EVRButtonId)vrEvent.data.controller.button;
|
|
//Console.WriteLine($"Button pressed: {button}");
|
|
|
|
switch (button)
|
|
{
|
|
case EVRButtonId.k_EButton_Knuckles_A:
|
|
{
|
|
overlay.ShowKeyboardForOverlay(m_OverlayHandle, (int)EGamepadTextInputMode.k_EGamepadTextInputModeNormal,
|
|
(int)EGamepadTextInputLineMode.k_EGamepadTextInputLineModeSingleLine, "desc", 1024, "", true, 0);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
#region Acutally Render
|
|
//Redundant check, but w/e
|
|
if (Config.Selector.WindowExists() && windowHandle != IntPtr.Zero)
|
|
{
|
|
var rect = new User32.Rect();
|
|
User32.GetClientRect(windowHandle, ref rect);
|
|
System.Drawing.Point pnt = new Point { X = 0, Y = 0 };
|
|
|
|
User32.ClientToScreen(windowHandle, ref pnt);
|
|
|
|
int width = rect.right - rect.left;
|
|
int height = rect.bottom - rect.top;
|
|
|
|
//Make sure the coords are actually valid. Could be minimized or something.
|
|
if (width > 0 && height > 0)
|
|
{
|
|
using (var bmp = new Bitmap(width, height, PixelFormat.Format32bppArgb))
|
|
{
|
|
using (Graphics graphics = Graphics.FromImage(bmp))
|
|
{
|
|
graphics.CopyFromScreen((int)pnt.X, (int)pnt.Y, 0, 0, new Size(width, height), CopyPixelOperation.SourceCopy);
|
|
|
|
#region Cursor drawing
|
|
User32.CURSORINFO pci;
|
|
pci.cbSize = System.Runtime.InteropServices.Marshal.SizeOf(typeof(User32.CURSORINFO));
|
|
|
|
if (User32.GetCursorInfo(out pci))
|
|
{
|
|
|
|
System.Drawing.Point cursorPoint = new System.Drawing.Point() { X = pci.ptScreenPos.X, Y = pci.ptScreenPos.Y };
|
|
|
|
if (User32.ScreenToClient(windowHandle, ref cursorPoint))
|
|
{
|
|
|
|
if (pci.flags == User32.CURSOR_SHOWING)
|
|
{
|
|
User32.DrawIcon(graphics.GetHdc(), (int)cursorPoint.X, (int)cursorPoint.Y, pci.hCursor);
|
|
graphics.ReleaseHdc();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("Error getting coords to draw cursor.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string errorMessage = new Win32Exception(Marshal.GetLastWin32Error()).Message;
|
|
Console.WriteLine($"Error getting cursor info: {errorMessage}");
|
|
}
|
|
#endregion
|
|
|
|
var data = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
|
|
|
|
if (screenTexture == null || (lastWidth != data.Width || lastHeight != data.Height))
|
|
{
|
|
lastWidth = data.Width;
|
|
lastHeight = data.Height;
|
|
|
|
if (screenTexture != null)
|
|
{
|
|
screenTexture.Dispose();
|
|
|
|
//Dispose not freeing screenTexture: https://gamedev.stackexchange.com/questions/93311/freeing-texture-memory-in-sharpdx-what-am-i-missing
|
|
device.ImmediateContext.ClearState();
|
|
device.ImmediateContext.Flush();
|
|
}
|
|
|
|
var textureDesc = new Texture2DDescription
|
|
{
|
|
CpuAccessFlags = CpuAccessFlags.Write,
|
|
BindFlags = BindFlags.ShaderResource,
|
|
Format = Format.B8G8R8A8_UNorm,
|
|
//Format = Format.B8G8R8A8_UNorm_SRgb,
|
|
Width = data.Width,
|
|
Height = data.Height,
|
|
OptionFlags = ResourceOptionFlags.None,
|
|
MipLevels = 1,
|
|
ArraySize = 1,
|
|
SampleDescription = { Count = 1, Quality = 0 },
|
|
Usage = ResourceUsage.Dynamic
|
|
};
|
|
screenTexture = new Texture2D(device, textureDesc);
|
|
stream = new DataStream(4 * width * height, true, true);
|
|
|
|
overlay.SetOverlayWidthInMeters(m_OverlayHandle, 2.5f);
|
|
|
|
HmdVector2_t vecWindowSize = new HmdVector2_t() { v0 = data.Width, v1 = data.Height };
|
|
OpenVR.Overlay.SetOverlayMouseScale(m_OverlayHandle, ref vecWindowSize);
|
|
Console.WriteLine("Updated!");
|
|
|
|
|
|
}
|
|
//Render using graphics card, in DirectX context.
|
|
|
|
//using ()
|
|
{
|
|
var screenView = new ShaderResourceView(device, screenTexture);
|
|
device.ImmediateContext.PixelShader.SetShaderResource(0, screenView);
|
|
|
|
var dr = new SharpDX.DataRectangle(data.Scan0, data.Stride);
|
|
|
|
DataBox databox = device.ImmediateContext.MapSubresource(screenTexture, 0, MapMode.WriteDiscard,
|
|
SharpDX.Direct3D11.MapFlags.None, out stream);
|
|
|
|
|
|
|
|
if (!databox.IsEmpty)
|
|
{
|
|
int count = 4 * data.Width * data.Height;
|
|
|
|
//Stride compensation. Sometimes the BMP and DX texture strides are different. This fixes it.
|
|
if (databox.RowPitch == data.Stride)
|
|
{
|
|
stream.Write(data.Scan0, 0, count);
|
|
}
|
|
//Truncate the extra BMP bytes.
|
|
else if (databox.RowPitch < data.Stride)
|
|
{
|
|
for (int i = 0; i < data.Height; i++)
|
|
{
|
|
stream.Write(data.Scan0, (data.Stride * i), databox.RowPitch);
|
|
}
|
|
}
|
|
//Add some junk on empty bytes on the end to make everyone happy.
|
|
else if (databox.RowPitch > data.Stride)
|
|
{
|
|
int difference = databox.RowPitch - data.Stride;
|
|
byte[] junk = new byte[difference];
|
|
for (int i = 0; i < data.Height; i++)
|
|
{
|
|
stream.Write(data.Scan0, (data.Stride * i), data.Stride);
|
|
stream.Write(junk, 0, difference);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
VRTextureBounds_t bounds = new VRTextureBounds_t();
|
|
OpenVR.Overlay.GetOverlayTextureBounds(m_OverlayHandle, ref bounds);
|
|
|
|
var texture = new Texture_t();
|
|
texture.handle = screenTexture.NativePointer;
|
|
texture.eType = ETextureType.DirectX;
|
|
texture.eColorSpace = EColorSpace.Auto;
|
|
EVROverlayError result = overlay.SetOverlayTexture(m_OverlayHandle, ref texture);
|
|
if (result != EVROverlayError.None)
|
|
{
|
|
|
|
Console.WriteLine($"Error rendering: {result}");
|
|
}
|
|
|
|
device.ImmediateContext.UnmapSubresource(screenTexture, 0);
|
|
|
|
|
|
|
|
frames++;
|
|
|
|
bmp.UnlockBits(data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
Thread.Sleep(20);
|
|
|
|
if (DateTime.Now.Subtract(lastFps).TotalMilliseconds > 1000)
|
|
{
|
|
//Console.WriteLine($"{frames} fps.");
|
|
CurrentFPS = frames;
|
|
frames = 0;
|
|
lastFps = DateTime.Now;
|
|
}
|
|
}
|
|
|
|
//Clean up after we exit while loop.
|
|
screenTexture.Dispose();
|
|
device.ImmediateContext.ClearState();
|
|
device.ImmediateContext.Flush();
|
|
|
|
CurrentFPS = 0;
|
|
|
|
device.Dispose();
|
|
adapter.Dispose();
|
|
factory.Dispose();
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Destroy();
|
|
}
|
|
|
|
public string GetOverlayName()
|
|
{
|
|
EVROverlayError err = EVROverlayError.None;
|
|
StringBuilder sb = new StringBuilder(255);
|
|
uint res = OpenVR.Overlay.GetOverlayName(m_OverlayHandle, sb, 255, ref err);
|
|
return sb.ToString();
|
|
}
|
|
|
|
public void SetOverlayName(string newName)
|
|
{
|
|
OpenVR.Overlay.SetOverlayName(m_OverlayHandle, newName);
|
|
//Config.Name = newName;
|
|
}
|
|
|
|
public float GetOverlayWidth()
|
|
{
|
|
float width = 0f;
|
|
OpenVR.Overlay.GetOverlayWidthInMeters(m_OverlayHandle, ref width);
|
|
return width;
|
|
}
|
|
|
|
public void SetOverlayWidth(float width)
|
|
{
|
|
OpenVR.Overlay.SetOverlayWidthInMeters(m_OverlayHandle, width);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return Config.Name;
|
|
}
|
|
}
|
|
}
|