VRDash/VDash/Overlay/WindowOverlay.cs

using SharpDX;
using SharpDX.Direct3D11;
using SharpDX.DXGI;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Valve.VR;

namespace VDash.Overlay
{
    public class WindowOverlay : DashOverlay,IDisposable
    {
        public CVRSystem VRSystem { get; private set; }
        private Task m_EventPumpTask = null;
        bool m_Created = false;
        bool m_Running = true;

        public WindowOverlay(string key, string name) : base(key, name)
        {
        }

        public void Create()
        {
            ConsoleManager.Show();
            ulong thumbHandle = OpenVR.k_ulOverlayHandleInvalid;

            //Actually create the overlay
            var overlay = OpenVR.Overlay;
            EVROverlayError err = overlay.CreateDashboardOverlay(m_Key, m_Name, ref m_Handle, ref thumbHandle);

            if (err != EVROverlayError.None)
            {
                throw new Exception($"Error creating overlay: {err}");
            }

            overlay.SetOverlayWidthInMeters(m_Handle, 2.5f);
            overlay.SetOverlayInputMethod(m_Handle, VROverlayInputMethod.Mouse);
            m_EventPumpTask = Task.Factory.StartNew(() => { EventPump(); });
            m_Created = true;
        }

        private void EventPump()
        {
            #region Rendering setup
            var overlay = OpenVR.Overlay;

            //Skip rendering if overlay isn't visible
            if ((m_Handle == OpenVR.k_ulOverlayHandleInvalid) || overlay == null || (!overlay.IsOverlayVisible(m_Handle)))
            {
                //return;
            }

            //Taken from here: https://stackoverflow.com/questions/6812068/c-sharp-which-is-the-fastest-way-to-take-a-screen-shot

            var factory = new Factory1();
            //Get first adapter
            var adapter = factory.GetAdapter1(0);
            //Get device from adapter
            var device = new SharpDX.Direct3D11.Device(adapter);
            //Get front buffer of the adapter
            var output = adapter.GetOutput(0);
            var output1 = output.QueryInterface<Output1>();

            // Width/Height of desktop to capture
            int width = output.Description.DesktopBounds.Right;
            int height = output.Description.DesktopBounds.Bottom;

            // Create Staging texture CPU-accessible
            var textureDesc = new Texture2DDescription
            {
                CpuAccessFlags = CpuAccessFlags.Read,
                BindFlags = BindFlags.None,
                Format = Format.B8G8R8A8_UNorm,
                Width = width,
                Height = height,
                OptionFlags = ResourceOptionFlags.None,
                MipLevels = 1,
                ArraySize = 1,
                SampleDescription = { Count = 1, Quality = 0 },
                Usage = ResourceUsage.Staging
            };
            var screenTexture = new Texture2D(device, textureDesc);
            #endregion
            int frames = 0;
            DateTime lastFps = DateTime.MinValue;

            while (m_Running)
            {
                VREvent_t vrEvent = new VREvent_t();

                while (OpenVR.Overlay.PollNextOverlayEvent(m_Handle, ref vrEvent, (uint)Marshal.SizeOf(vrEvent)))
                {
                    switch ((EVREventType)vrEvent.eventType)
                    {
                        case EVREventType.VREvent_MouseMove:
                            {
                                var x = vrEvent.data.mouse.x;
                                var y = vrEvent.data.mouse.y;
                                break;
                            }

                        case EVREventType.VREvent_MouseButtonDown:
                            {
                                var clickType = (EVRMouseButton)vrEvent.data.mouse.button;
                                break;
                            }

                        case EVREventType.VREvent_MouseButtonUp:
                            {
                                var clickType = (EVRMouseButton)vrEvent.data.mouse.button;
                                break;
                            }
                        case EVREventType.VREvent_OverlayShown:
                            {
                                Console.WriteLine("Overlay Shown!");
                                break;
                            }
                    }

                }


                #region Acutally Render

                using (var duplicatedOutput = output1.DuplicateOutput(device))
                {
                    SharpDX.DXGI.Resource screenResource = null;
                    try
                    {
                        OutputDuplicateFrameInformation duplicateFrameInformation;
                        

                        // Try to get duplicated frame within given time is ms


                        duplicatedOutput.AcquireNextFrame(10000, out duplicateFrameInformation, out screenResource);



                        #region junk
                        // copy resource into memory that can be accessed by the CPU
                        //using (var screenTexture2D = screenResource.QueryInterface<Texture2D>())
                        //{
                        //    device.ImmediateContext.CopyResource(screenTexture2D, screenTexture);
                        //}

                        // Get the desktop capture texture
                        var mapSource = device.ImmediateContext.MapSubresource(screenTexture, 0, MapMode.Read, SharpDX.Direct3D11.MapFlags.None);

                        // Create Drawing.Bitmap
                        //using (var bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb))
                        //{
                        //    var boundsRect = new Rectangle(0, 0, width, height);

                        //    // Copy pixels from screen capture Texture to GDI bitmap
                        //    var mapDest = bitmap.LockBits(boundsRect, ImageLockMode.WriteOnly, bitmap.PixelFormat);
                        //    var sourcePtr = mapSource.DataPointer;
                        //    var destPtr = mapDest.Scan0;
                        

                        if (duplicateFrameInformation.AccumulatedFrames > 0)
                        {
                            //Console.WriteLine($"Frames: {duplicateFrameInformation.AccumulatedFrames}");
                            var texture = new Texture_t();
                            texture.handle = screenTexture.NativePointer;
                            texture.eType = ETextureType.DirectX;
                            texture.eColorSpace = EColorSpace.Auto;
                            EVROverlayError result = overlay.SetOverlayTexture(m_Handle, ref texture);
                            if (result != EVROverlayError.None)
                            {
                                Console.WriteLine($"Error rendering: {result}");
                            }
                            
                            frames++;
                        }

                        //for (int y = 0; y < height; y++)
                        //{
                        //     Copy a single line 
                        //    Utilities.CopyMemory(destPtr, sourcePtr, width * 4);

                        //     Advance pointers
                        //    sourcePtr = IntPtr.Add(sourcePtr, mapSource.RowPitch);
                        //    destPtr = IntPtr.Add(destPtr, mapDest.Stride);
                        //}

                        ////    // Release source and dest locks
                        //bitmap.UnlockBits(mapDest);
                        device.ImmediateContext.UnmapSubresource(screenTexture, 0);

                        //using (var ms = new FileStream(@"C:\Users\jrhodnik\Desktop\ss.bmp", FileMode.Create))
                        //{
                        //    bitmap.Save(ms, ImageFormat.Bmp);
                        //}

                        //}
                        #endregion
                        
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.ToString());
                    }
                    finally
                    {
                        if (screenResource != null)
                        {
                            screenResource.Dispose();
                        }
                        duplicatedOutput.ReleaseFrame();
                    }
                }
                #endregion

                //Thread.Sleep(20);

                if(DateTime.Now.Subtract(lastFps).TotalMilliseconds > 1000)
                {
                    Console.WriteLine($"{frames} fps.");
                    frames = 0;
                    lastFps = DateTime.Now;
                }
            }
        }

        private class User32
        {
            [StructLayout(LayoutKind.Sequential)]
            public struct Rect
            {
                public int left;
                public int top;
                public int right;
                public int bottom;
            }

            [DllImport("user32.dll")]
            public static extern IntPtr GetWindowRect(IntPtr hWnd, ref Rect rect);
        }

        public void Dispose()
        {
            //FIXME: Actually implement this...
        }
    }
}