Compiling but broken

src/GLWpfControl/DXGLContext.cs

@@ -117,6 +117,7 @@ internal sealed class DxGlContext : IDisposable {
                 var hwndSource = new HwndSource(0, 0, 0, 0, 0, "GLWpfControl", baseHandle);
 
                 _sharedContext = glfwWindow.Context;
+                _sharedContextSettings = settings;
                 _sharedContextResources = new IDisposable[] {hwndSource, glfwWindow};
                 // GL init
                 // var mode = new GraphicsMode(ColorFormat.Empty, 0, 0, 0, 0, 0, false);

src/GLWpfControl/DxGLFramebuffer.cs

@@ -1,6 +1,10 @@
 using System;
+using System.Windows.Interop;
+using System.Windows.Media;
+using JetBrains.Annotations;
 using OpenTK.Graphics.OpenGL;
 using OpenTK.Graphics.Wgl;
+using OpenTK.Platform.Windows;
 using OpenTK.Wpf.Interop;
 
 namespace OpenTK.Wpf {
@@ -12,28 +16,102 @@ namespace OpenTK.Wpf {
     /// The calling class must correctly dispose of this by calling <see cref="Dispose"/>
     /// Prior to releasing references. 
     internal sealed class DxGLFramebuffer : IDisposable {
+
+        private DxGlContext DxGlContext { get; }
 
         /// The width of this buffer in pixels
         public int Width { get; }
 
         /// The height of this buffer in pixels
         public int Height { get; }
 
+        /// The DirectX Render target (framebuffer) handle.
+        public IntPtr DxRenderTargetHandle { get; }
+
         /// The OpenGL Framebuffer handle
-        public int GLFramebuffer { get; }
+        public int GLFramebufferHandle { get; }
+
+        /// The OpenGL shared texture handle (with DX)
+        private int GLSharedTextureHandle { get; }
+
+        /// The OpenGL depth render buffer handle.
+        private int GLDepthRenderBufferHandle { get; }
+
+        /// Specific wgl_dx_interop handle that marks the framebuffer as ready for interop.
+        public IntPtr DxInteropRegisteredHandle { get; }
+
+
+        public D3DImage D3dImage { get; }
+
+        public TranslateTransform TranslateTransform { get; }
+        public ScaleTransform FlipYTransform { get; }
+
+
+        public DxGLFramebuffer([NotNull] DxGlContext context, int width, int height, double dpiScaleX, double dpiScaleY) {
+            DxGlContext = context;
+            Width = width;
+            Height = height;
+
+            var dxSharedHandle = IntPtr.Zero; // Unused windows-vista legacy sharing handle. Must always be null.
+            DXInterop.CreateRenderTarget(
+                context.DxDeviceHandle,
+                Width,
+                Height,
+                Format.X8R8G8B8,// this is like A8 R8 G8 B8, but avoids issues with Gamma correction being applied twice.
+                MultisampleType.None,
+                0,
+                false,
+                out var dxRenderTargetHandle,
+                ref dxSharedHandle);
+
+            DxRenderTargetHandle = dxRenderTargetHandle;
+
+            Wgl.DXSetResourceShareHandleNV(dxRenderTargetHandle, dxSharedHandle);
+
+            GLFramebufferHandle = GL.GenFramebuffer();
+            GLSharedTextureHandle = GL.GenTexture();
+
+            var genHandle = Wgl.DXRegisterObjectNV(
+                context.GlDeviceHandle,
+                dxRenderTargetHandle,
+                (uint)GLSharedTextureHandle,
+                (uint)TextureTarget.Texture2D,
+                WGL_NV_DX_interop.AccessReadWrite);
 
-        /// The shared texture handle
-        private int GLSharedTexture { get; }
+            DxInteropRegisteredHandle = genHandle;
 
+            GL.BindFramebuffer(FramebufferTarget.Framebuffer, GLFramebufferHandle);
+            GL.FramebufferTexture2D(
+                FramebufferTarget.Framebuffer,
+                FramebufferAttachment.ColorAttachment0,
+                TextureTarget.Texture2D,
+                GLSharedTextureHandle, 0);
 
-        public DxGLFramebuffer() {
+            GLDepthRenderBufferHandle = GL.GenRenderbuffer();
+            GL.BindRenderbuffer(RenderbufferTarget.Renderbuffer, GLDepthRenderBufferHandle);
+            GL.RenderbufferStorage(RenderbufferTarget.Renderbuffer, RenderbufferStorage.DepthComponent24, Width, Height);
+            GL.FramebufferRenderbuffer(
+                FramebufferTarget.Framebuffer,
+                FramebufferAttachment.DepthAttachment,
+                RenderbufferTarget.Renderbuffer,
+                GLDepthRenderBufferHandle);
 
+            GL.BindFramebuffer(FramebufferTarget.Framebuffer, 0);
+
+
+            D3dImage = new D3DImage(96.0 * dpiScaleX, 96.0 * dpiScaleY);
+
+            TranslateTransform = new TranslateTransform(0, height);
+            FlipYTransform = new ScaleTransform(1, -1);
         }
 
 
         public void Dispose() {
-            GL.DeleteBuffer(GLFramebuffer);
-            GL.DeleteTexture(GLSharedTexture);
+            GL.DeleteBuffer(GLFramebufferHandle);
+            GL.DeleteRenderbuffer(GLDepthRenderBufferHandle);
+            GL.DeleteTexture(GLSharedTextureHandle);
+            Wgl.DXUnregisterObjectNV(DxGlContext.GlDeviceHandle, DxInteropRegisteredHandle);
+            DXInterop.Release(DxRenderTargetHandle);
         }
     }
 }