Foro de elhacker.net

• https://github.com/sharpdx/SharpDX-Samples/tree/ed7e80cdcac145cf1864c6b9358a558e5fe8deb6/Desktop/Direct3D11.1/ScreenCapture

<SuppressUnmanagedCodeSecurity>
<DllImport("user32.dll")>
Public Shared Function SetForegroundWindow(ByVal hwnd As IntPtr
) As <MarshalAs(UnmanagedType.Bool)> Boolean
End Function
 
<SuppressUnmanagedCodeSecurity>
<DllImport("user32.dll", SetLastError:=True)>
Public Shared Function ShowWindow(ByVal hwnd As IntPtr,
    <MarshalAs(UnmanagedType.I4)> ByVal nCmdShow As WindowState
) As <MarshalAs(UnmanagedType.Bool)> Boolean
End Function
 
<SuppressUnmanagedCodeSecurity>
<DllImport("user32.dll", SetLastError:=True)>
Public Shared Function GetWindowRect(ByVal hwnd As IntPtr,
                               <Out> ByRef rect As Rect
) As <MarshalAs(UnmanagedType.Bool)> Boolean
End Function

Public Enum WindowState As Integer
    Normal = 1
End Enum

• https://github.com/ElektroStudios/ElektroKit/blob/54636a57e20c90186b7915102809b0a2bb134ea0/Solution/Elektro.Interop/Win32/Types/Rect.vb

Public Shared Function TakeScreenshotFromObject(ByVal hwnd As IntPtr, ...) As Image
    ' ...
End Function

Public Shared Function TakeScreenshotFromRegion(ByVal rect As Rectangle, ...) As Image
    ' ...
End Function

 
    Public Shared Function TakeScreenshotFromRegion(ByVal rect As Rectangle, ...) As Image
        ' ...
    End Function
 
 

Dim rc As Rectangle = ...
Debug.WriteLine(String.Format("[Rectangle] Location: {0} Size: {1}", rc.Location.ToString(), rc.Size.ToString()))

TakeScreenshotFromRegion(Rectangle, ...)

TakeScreenshotFromObject(IntPtr, ...)

Public Shared Function TakeScreenshotFromObject(ByVal hwnd As IntPtr,
                                                Optional ByVal includeMouse As Boolean = False,
                                                Optional ByVal pixelFormat As PixelFormat = PixelFormat.Format32bppArgb) As Image
 
    If Not NativeMethods.IsWindow(hwnd) Then
        Throw New ArgumentException(paramName:="hwnd", message:="The specified handle doesn't point to a win32 Window.")
        Return Nothing
    End If
 
    ' Restore and give focus to a minimized window.
    If NativeMethods.IsIconic(hwnd) Then
        NativeMethods.OpenIconicWindow(hwnd)
    End If
 
    ' Show a non-activated window and bring the window to z-top.
    Dim wndPlacement As WindowPlacement
    NativeMethods.GetWindowPlacement(hwnd, wndPlacement)
    Select Case wndPlacement.ShowCmd
 
        Case Elektro.Interop.Win32.Enums.WindowState.Minimize, Elektro.Interop.Win32.Enums.WindowState.ForceMinimize,
             Elektro.Interop.Win32.Enums.WindowState.ShowMinimized, Elektro.Interop.Win32.Enums.WindowState.ShowMinNoActive
            NativeMethods.ShowWindow(hwnd, Elektro.Interop.Win32.Enums.WindowState.Restore)
 
        Case Elektro.Interop.Win32.Enums.WindowState.Hide
            ' Avoid restoring a hidden window, just because the user didn't demanded this.
            If Not NativeMethods.IsWindowVisible(hwnd) Then
                Throw New ArgumentException(paramName:="hwnd", message:="The specified window it's hidden.")
                Return Nothing
            End If
 
        Case Else
            NativeMethods.SetForegroundWindow(hwnd)
 
    End Select
    NativeMethods.BringWindowToTop(hwnd)
 
    Dim rc As Win32.Types.Rect = GetRealWindowRect(hwnd)
    Dim scr As Screen = Screen.FromHandle(hwnd)
    rc = Rectangle.Intersect(rc, scr.WorkingArea)
    Return TakeScreenshotFromRegion(rc, includeMouse, pixelFormat)
 
End Function

''' ----------------------------------------------------------------------------------------------------
''' <summary>
''' Gets the (non-client) <see cref="Rectangle"/> of a window.
''' <para></para>
''' This method supports a borderless <c>Windows 10</c> window.
''' </summary>
''' ----------------------------------------------------------------------------------------------------
Private Shared Function GetRealWindowRect(ByVal hwnd As IntPtr) As Rectangle
 
    Dim rc As Win32.Types.Rect = Rectangle.Empty
 
    If IsWin10 Then
        Dim hResult As Integer
        hResult = NativeMethods.DwmGetWindowAttribute(hwnd, Elektro.Interop.Win32.Enums.DwmWindowAttribute.ExtendedFrameBounds, rc, Marshal.SizeOf(rc))
        If (DirectCast(hResult, HResult) <> Elektro.Interop.Win32.Enums.HResult.S_OK) Then
            Marshal.ThrowExceptionForHR(hResult)
        End If
 
    Else
        Dim result As Boolean
        Dim win32Err As Integer
        result = NativeMethods.GetWindowRect(hwnd, rc)
        win32Err = Marshal.GetLastWin32Error()
        If Not (result) Then
            Throw New Win32Exception(win32Err)
        End If
 
    End If
 
    Return rc
 
End Function

<SuppressUnmanagedCodeSecurity>
<DllImport("dwmapi.dll", SetLastError:=False)>
Public Shared Function DwmGetWindowAttribute(ByVal hwnd As IntPtr,
                                             ByVal attribute As DwmWindowAttribute,
                                             ByRef refAttribute As Rect,
                                             ByVal sizeAttribute As Integer
) As Integer
End Function

''' ----------------------------------------------------------------------------------------------------
''' <summary>
''' Gets a value that determines whether the current operating system is <c>Windows 10</c>.
''' </summary>
''' ----------------------------------------------------------------------------------------------------
Public Shared ReadOnly Property IsWin10() As Boolean
    <DebuggerStepThrough>
    Get
        Return (Environment.OSVersion.Platform = PlatformID.Win32NT) AndAlso (InternalIsWin10())
    End Get
End Property
 
Private Shared Function InternalIsWin10() As Boolean
 
    Using reg As RegistryKey = Microsoft.Win32.Registry.LocalMachine.
                               OpenSubKey("SOFTWARE\Microsoft\Windows NT\CurrentVersion", writable:=False)
 
        Dim productName As String = DirectCast(reg.GetValue("ProductName", "Error", RegistryValueOptions.None), String)
        Return productName.StartsWith("Windows 10", StringComparison.OrdinalIgnoreCase)
 
    End Using
 
End Function

NativeMethods.DwmGetWindowAttribute

Return TakeScreenshotFromRegion(rc, includeMouse, pixelFormat)

NativeMethods.DwmGetWindowAttribute

Return TakeScreenshotFromRegion(rc, includeMouse, pixelFormat)

• http://foro.elhacker.net/net/elektrokit_framework_v17_complementos_para_el_nucleo_de_net_framework-t444997.0.html

• https://github.com/ElektroStudios/ElektroKit/blob/1118151e1c34bcc51d1f6a003b563676db69ab30/Solution/Elektro.Imaging/Tools/ImageUtil.vb

Os.Win10

Os.Win10

Imports Elektro.System.Tools.SystemInfo

Public Shared ReadOnly Property IsWin10() As Boolean
    <DebuggerStepThrough>
    Get
        Return (Environment.OSVersion.Platform = PlatformID.Win32NT) AndAlso (InternalIsWin10())
    End Get
End Property
 
Private Shared Function InternalIsWin10() As Boolean
 
    Using reg As RegistryKey = Microsoft.Win32.Registry.LocalMachine.
                               OpenSubKey("SOFTWARE\Microsoft\Windows NT\CurrentVersion", writable:=False)
 
        Dim productName As String = DirectCast(reg.GetValue("ProductName", "Error", RegistryValueOptions.None), String)
        Return productName.StartsWith("Windows 10", StringComparison.OrdinalIgnoreCase)
 
    End Using
 
End Function

• https://msdn.microsoft.com/en-us/library/windows/desktop/dn424972%28v=vs.85%29.aspx

Imports System.Drawing.Imaging
 
Imports Elektro.Application.Types
Imports Elektro.Core.IO.Enums
Imports Elektro.Imaging.Tools
 
Public NotInheritable Class Form1 : Inherits Form
 
    ' Fullscreen capture.
    Friend WithEvents HotkeyScreenshotType1 As New Hotkey(HotkeyModifiers.None, Keys.D1)
 
    ' BF3 window capture.
    Friend WithEvents HotkeyScreenshotType2 As New Hotkey(HotkeyModifiers.None, Keys.D2)
 
    Private Sub HotkeyScreenshotType1_Press(ByVal sender As Object, ByVal e As HotkeyPressEventArgs) _
    Handles HotkeyScreenshotType1.Press
 
        Static imgIndex As Integer = 0
        Dim path As String = String.Format(".\Fullscreen_{0:00}.png", Interlocked.Increment(imgIndex))
 
        Using screenshot As Image = ImageUtil.TakeScreenshotFromDesktop(includeMouse:=False)
            screenshot.Save(path, ImageFormat.Png)
        End Using
        ' Process.Start(path)
 
    End Sub
 
    Private Sub HotkeyScreenshotType2_Press(ByVal sender As Object, ByVal e As HotkeyPressEventArgs) _
    Handles HotkeyScreenshotType2.Press
 
        Static imgIndex As Integer = 0
 
        Dim name As String = "bf3"
        Dim proc As Process = Process.GetProcessesByName(name).Single()
        Dim hwnd As IntPtr = proc.MainWindowHandle
        Dim path As String = String.Format(".\{0}_{1:00}.png", name, Interlocked.Increment(imgIndex))
 
        Using screenshot As Image = ImageUtil.TakeScreenshotFromObject(hwnd, includeMouse:=False)
            screenshot.Save(path, ImageFormat.Png)
        End Using
        ' Process.Start(path)
 
    End Sub
 
End Class

Imports System.Drawing.Imaging
 
Imports Elektro.Application.Types
Imports Elektro.Core.IO.Enums
Imports Elektro.Imaging.Extensions.Image
Imports Elektro.Imaging.Tools
 
Public NotInheritable Class Form1 : Inherits Form
 
    Friend WithEvents HotkeyScreenshot As New Hotkey(HotkeyModifiers.None, Keys.D0)
 
    Private Sub HotkeyScreenshot_Press(ByVal sender As Object, ByVal e As HotkeyPressEventArgs) _
    Handles HotkeyScreenshot.Press
 
        Static imgIndex As Integer = 0
 
        Dim procName As String = "bf3"
        Dim proc As Process = Process.GetProcessesByName(procName).Single()
        Dim hwnd As IntPtr = proc.MainWindowHandle
        Dim gameRes As New Size(1280, 720)
        Dim scr As Screen = Screen.PrimaryScreen
        Dim path As String = String.Format(".\{0}_{1:00}.png", procName, Interlocked.Increment(imgIndex))
 
        If (scr.Bounds.Width > gameRes.Width) AndAlso (scr.Bounds.Height > gameRes.Height) Then
            Using screenshot As Image = ImageUtil.TakeScreenshotFromRegion(scr.Bounds, includeMouse:=True),
                  cutted As Image = screenshot.Cut(gameRes.Width, gameRes.Height, 0, 0),
                  resized As Image = cutted.Resize(scr.Bounds.Size)
 
                resized.Save(path, ImageFormat.Png)
            End Using
 
        Else
            Using screenshot As Image = ImageUtil.TakeScreenshotFromRegion(scr.Bounds, includeMouse:=True)
                screenshot.Save(path, ImageFormat.Png)
            End Using
 
        End If
 
        ' Process.Start(path)
 
    End Sub
 
End Class

Imports System.Drawing.Imaging
Imports System.IO
 
Imports SharpDX
Imports SharpDX.Direct3D11
Imports SharpDX.DXGI
Imports Device = SharpDX.Direct3D11.Device
Imports MapFlags = SharpDX.Direct3D11.MapFlags
 
'Imports Elektro.Imaging.Tools
 
Namespace Test
 
    Public NotInheritable Class SharpDXUtil
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Capture the screen output using the default graphics card adapter.
        ''' <para></para>
        ''' This DirectX based methodology is useful to take screenshot of games that are running in full screen.
        ''' <para></para>
        ''' However, using this methodology for other common desktop screen captures will produce unexpected results (such as wrong colors);
        ''' so for common screenshots you should use the methods exposed in <see cref="Elektro.Imaging.Tools.ImageUtil"/> instead.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <returns>
        ''' The resulting <see cref="System.Drawing.Image"/>.
        ''' </returns>
        ''' ----------------------------------------------------------------------------------------------------
        Public Shared Function TakeScreenshot() As Image
 
            Return SharpDXUtil.TakeScreenshot(adapterIndex:=0)
 
        End Function
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Captures the screen output using the specified graphics card adapter.
        ''' <para></para>
        ''' This DirectX based methodology is useful to take screenshot of games that are running in full screen.
        ''' <para></para>
        ''' However, using this methodology for other common desktop screen captures will produce unexpected results (such as wrong colors);
        ''' so for common screenshots you should use the methods exposed in <see cref="Elektro.Imaging.Tools.ImageUtil"/> instead.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="adapterIndex">
        ''' The index of the graphics card adapter.
        ''' <para></para>
        ''' Set this value to <c>0</c> if you don't have more than one graphics card.
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <returns>
        ''' The resulting <see cref="System.Drawing.Image"/>.
        ''' </returns>
        ''' ----------------------------------------------------------------------------------------------------
        Public Shared Function TakeScreenshot(ByVal adapterIndex As Integer) As Image
 
            Dim factory As Factory1
            Dim adapter As Adapter1
            Dim device As Device
            Dim output As Output
            Dim output1 As Output1
            Dim scrSize As Size
            Dim textureDesc As Texture2DDescription
            Dim screenTexture As Texture2D
            Dim duplicatedOutput As OutputDuplication
            Dim captureDone As Boolean = False
            Dim capture As Bitmap = Nothing
            Dim i As Integer = 0
 
            factory = New Factory1()
            adapter = factory.GetAdapter1(adapterIndex)
            device = New Device(adapter)
            output = adapter.GetOutput(adapterIndex)
            output1 = output.QueryInterface(Of Output1)()
            scrSize = New Size(width:=CType(output.Description.DesktopBounds, SharpDX.Rectangle).Width,
                               height:=CType(output.Description.DesktopBounds, SharpDX.Rectangle).Height)
 
            ' Create Staging texture CPU-accessible.
            textureDesc = New Texture2DDescription() With {
                .CpuAccessFlags = CpuAccessFlags.Read,
                .BindFlags = BindFlags.None,
                .Format = Format.B8G8R8A8_UNorm,
                .Width = scrSize.Width,
                .Height = scrSize.Height,
                .OptionFlags = ResourceOptionFlags.None,
                .MipLevels = 1,
                .ArraySize = 1,
                .SampleDescription = New SampleDescription With {.Count = 1, .Quality = 0},
                .Usage = ResourceUsage.Staging
            }
            screenTexture = New Texture2D(device, textureDesc)
            duplicatedOutput = output1.DuplicateOutput(device)
 
            While Not (captureDone)
                Try
                    Dim screenResource As DXGI.Resource = Nothing
 
                    Dim duplicateFrameInformation As OutputDuplicateFrameInformation
 
                    ' Try to get duplicated frame within given time.
                    duplicatedOutput.AcquireNextFrame(10000, duplicateFrameInformation, screenResource)
 
                    If (i > 0) Then
                        ' Copy resource into memory that can be accessed by the CPU.
                        Using screenTexture2D As Texture2D = screenResource.QueryInterface(Of Texture2D)()
                            device.ImmediateContext.CopyResource(screenTexture2D, screenTexture)
                        End Using
 
                        ' Get the desktop capture texture.
                        Dim mapSource As DataBox = device.ImmediateContext.MapSubresource(screenTexture, 0, MapMode.Read, MapFlags.None)
 
                        ' Create the bitmap.
                        capture = New System.Drawing.Bitmap(scrSize.Width, scrSize.Height, PixelFormat.Format32bppArgb)
                        Dim boundsRect As New System.Drawing.Rectangle(0, 0, scrSize.Width, scrSize.Height)
 
                        ' Copy pixels from screen capture Texture to GDI bitmap.
                        Dim mapDest As BitmapData = capture.LockBits(boundsRect, ImageLockMode.WriteOnly, capture.PixelFormat)
                        Dim sourcePtr As IntPtr = mapSource.DataPointer
                        Dim destPtr As IntPtr = mapDest.Scan0
 
                        For y As Integer = 0 To (scrSize.Height - 1)
                            ' Copy a single line.
                            Utilities.CopyMemory(destPtr, sourcePtr, (scrSize.Width * 4))
 
                            ' Advance pointers.
                            sourcePtr = IntPtr.Add(sourcePtr, mapSource.RowPitch)
                            destPtr = IntPtr.Add(destPtr, mapDest.Stride)
                        Next y
 
                        capture.UnlockBits(mapDest)
                        device.ImmediateContext.UnmapSubresource(screenTexture, 0)
                        captureDone = True
                    End If
 
                    screenResource.Dispose()
                    duplicatedOutput.ReleaseFrame()
 
                Catch e As SharpDXException
                    If (e.ResultCode.Code <> DXGI.ResultCode.WaitTimeout.Result.Code) Then
                        Throw e
                    End If
 
                End Try
 
                i += 1
 
            End While
 
            If (duplicatedOutput IsNot Nothing) Then
                duplicatedOutput.Dispose()
            End If
 
            If (screenTexture IsNot Nothing) Then
                screenTexture.Dispose()
            End If
 
            If (output1 IsNot Nothing) Then
                output1.Dispose()
            End If
 
            If (output IsNot Nothing) Then
                output.Dispose()
            End If
 
            If (device IsNot Nothing) Then
                device.Dispose()
            End If
 
            If (adapter IsNot Nothing) Then
                adapter.Dispose()
            End If
 
            If (factory IsNot Nothing) Then
                factory.Dispose()
            End If
 
            Return capture
 
        End Function
 
    End Class
 
End Namespace

Test.SharpDXUtil.TakeScreenshot().Save("C:\Screenshot.png")

duplicatedOutput = output1.DuplicateOutput(device)