Screenshots und Windows 7 mit DirectX - .NET Grafik und Sound @ tutorials.de: Forum & Hilfe

Afritus · 06.02.10, 18:55

Hi Leute, ich bins schon wieder.

Diesmal habe ich ein echt "lustiges" Problem.
Zum Erstellen von Screenshots verwende ich folgenden Befehl:

            
                    Code:
                  
                   	' Bildschirmauflösung
        Dim nScreenWidth As Integer
        Dim nScreenHeight As Integer

        With Screen.PrimaryScreen.Bounds
            nScreenWidth = .Width
            nScreenHeight = .Height
        End With
        nScreenWidth.ToString()
        nScreenHeight.ToString()

        ' Erstellt Screenshot

        Dim b As New Bitmap(nScreenWidth, nScreenHeight)
        Using g As Graphics = Graphics.FromImage(b)
            g.CopyFromScreen(0, 0, 0, 0, New Size(nScreenWidth, nScreenHeight))
            b.Save(My.Computer.FileSystem.SpecialDirectories.Desktop & "/screen.jpg", Imaging.ImageFormat.Jpeg)
        End Using

Ein Screenshot mit der jeweiligen Bildschirmauflösung wird nun auf dem Desktop gespeichert. Bei Windows XP und Windows Vista klappt das auch ohne Probleme. Aber bei Windows 7 (was ich derzeit benutze) taucht ein äußerst komisches Problem auf:
Wenn ich in einem Spiel bin (zum Beispiel Counter-Strike: Source) und dann einen Screenshot erstelle, wird lediglich ein Screenshot des Desktops erstellt. Unten in der Taskleiste sieht man jedoch, dass das Spiel geöffnet ist und ich bin ja auch im Spiel drin während der Erstellung des Screenshots. Was auffällt: Oben links vom fehlerhaften Screenshot befindet sich, wenn ich grade in einem Spiel bin, ein dünner kleiner schwarzer Balken. Keine Ahnung, wieso. Also das was bei Windows 7 rauskommt, wenn ich einen Screenshot erstelle während ich im Spiel bin, ist ein ganz normaler Screenshot vom Desktop mit einem dünnen schwarzen Balken oben links.

Gibt es einen Code, der für jedes Windows-Betriebssystem einen normalen Screenshot erstellt, selbst wenn man gerade spielt?

EDIT: Wenn ich das jeweilige Spiel im Fenstermodus spiele, dann funktioniert es. Fragt mich nicht, wieso.

MfG
Markus

WorldRacer · 07.02.10, 02:05

dafür brauchst du einen "lesenden" DirectX Hook. Guckst du hier: http://spazzarama.wordpress.com/2009...with-direct3d/

Afritus · 07.02.10, 08:25

Ok danke, jetzt weiß ich, was der Fehler ist.
Werde nun versuchen, SlimDX zu installieren und danach den Code umzuschreiben. Danke!

MfG

WorldRacer · 07.02.10, 13:10

Kleiner Tipp:

http://www.developerfusion.com/tools.../csharp-to-vb/

Afritus · 07.02.10, 13:14

Jop, hab ich auch so gemacht, danke

Nur weiß ich jetzt nicht, wie ich den Screenshot selbst mache, also mit einem Button oder so.
MfG

WorldRacer · 07.02.10, 13:31

Noch ein Tipp :PP

public static Bitmap CaptureWindow(IntPtr hWnd)

und

GetAsyncKeyState geben ein wunderhübsches Paar ab :P

Afritus · 07.02.10, 13:38

Ich bin neu bei .NET und hab keinen Plan, was du meinst

WorldRacer · 07.02.10, 14:03

Kleines Code-Beispiel:

            
                    csharp Code: 
                  
                        using System;
using System.Runtime.InteropServices;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace exampleApp {
  public partial class Form1 : Form {
    string prozessname = "hl2";
    [DllImport("user32.dll")]
    static extern ushort GetAsyncKeyState(int vKey);
 
    public static bool IsKeyPushedDown(System.Windows.Forms.Keys vKey) {
        return 0 != (GetAsyncKeyState((int)vKey) & 0x8000);
    }
    public void Form1_Load(object sender, EventArgs e)
    {
        // Solange die Anwendung läuft...
        while (true)
        {
            // ...prüfe ob die F10 Taste gedrückt ist.
            if(IsKeyPushedDown(Keys.F10))
            {
                // Wenn ja, ermittle alle Prozesse mit dem Namen "hl2" (Das .exe weglassen!, Anmerkung: CS:S)
                System.Diagnostics.Process[] prcs = System.Diagnostics.Process.GetProcessesByName(prozessname);
                
                int n = 0;
                foreach (System.Diagnostics.Process prc in prcs)
                {
                    // Mache für jeden verfügbaren Prozess ein Screenshot...
                    Bitmap screenshot = Spazzarama.ScreenCapture.Direct3DCapture.CaptureWindow(prc.MainWindowHandle);
 
                    // Und speichere es unter C:\[NUMMER].jpg
                    screenshot.Save("C:\\" + n.ToString() + ".jpg", System.Drawing.Imaging.ImageFormat.Jpeg);
 
                    // Anschließend erhöhe man "n" um eins.
                    n++;
                }
            }
        }
    }
 
  }
}

Und in VB:

            
                    vb Code: 
                  
                        Imports System
Imports System.Runtime.InteropServices
Imports System.Collections.Generic
Imports System.ComponentModel
Imports System.Data
Imports System.Drawing
Imports System.Linq
Imports System.Text
Imports System.Windows.Forms
Namespace exampleApp
  Public Partial Class Form1
    Inherits Form
    Private prozessname As String = "hl2"
    <DllImport("user32.dll")> _
    Private Shared Function GetAsyncKeyState(ByVal vKey As Integer) As UShort
    End Function
    
    Public Shared Function IsKeyPushedDown(ByVal vKey As System.Windows.Forms.Keys) As Boolean
      Return 0 <> (GetAsyncKeyState(CInt(vKey)) And &H8000)
    End Function
    Public Sub Form1_Load(ByVal sender As Object, ByVal e As EventArgs)
      ' Solange die Anwendung läuft...
      While True
        ' ...prüfe ob die F10 Taste gedrückt ist.
        If IsKeyPushedDown(Keys.F10) Then
          ' Wenn ja, ermittle alle Prozesse mit dem Namen "hl2" (Das .exe weglassen!, Anmerkung: CS:S)
          Dim prcs As System.Diagnostics.Process() = System.Diagnostics.Process.GetProcessesByName(prozessname)
          
          Dim n As Integer = 0
          For Each prc As System.Diagnostics.Process In prcs
            ' Mache für jeden verfügbaren Prozess ein Screenshot...
            Dim screenshot As Bitmap = Spazzarama.ScreenCapture.Direct3DCapture.CaptureWindow(prc.MainWindowHandle)
            
            ' Und speichere es unter C:\[NUMMER].jpg
            screenshot.Save("C:\" & n.ToString() & ".jpg", System.Drawing.Imaging.ImageFormat.Jpeg)
            
            ' Anschließend erhöhe man "n" um eins.
            n += 1
          Next
        End If
      End While
    End Sub
    
  End Class
End Namespace

Afritus · 07.02.10, 14:30

Sry, aber ich scheine echt zu blöd für das zu sein.
Bei mir steht jetzt folgendes (den Button sieht man auf der Form gar nicht):

            
            
              
                
                  
                    Code:
                  
                

                  
                   	Imports System.Collections.Generic
Imports System.Text
Imports System.Drawing
Imports System.Runtime.InteropServices
Imports System
Imports System.ComponentModel
Imports System.Data
Imports System.Linq
Imports System.Windows.Forms
Namespace exampleApp
    Partial Public Class Form1
        Inherits Form
        Private prozessname As String = "hl2"
        <DllImport("user32.dll")> _
        Private Shared Function GetAsyncKeyState(ByVal vKey As Integer) As UShort
        End Function

        Public Shared Function IsKeyPushedDown(ByVal vKey As System.Windows.Forms.Keys) As Boolean
            Return 0 <> (GetAsyncKeyState(CInt(vKey)) And &H8000)
        End Function
        Public Sub Form1_Load(ByVal sender As Object, ByVal e As EventArgs)
            ' Solange die Anwendung läuft...
            While True
                ' ...prüfe ob die F10 Taste gedrückt ist.
                If IsKeyPushedDown(Keys.F10) Then
                    ' Wenn ja, ermittle alle Prozesse mit dem Namen "hl2" (Das .exe weglassen!, Anmerkung: CS:S)
                    Dim prcs As System.Diagnostics.Process() = System.Diagnostics.Process.GetProcessesByName(prozessname)

                    Dim n As Integer = 0
                    For Each prc As System.Diagnostics.Process In prcs
                        ' Mache für jeden verfügbaren Prozess ein Screenshot...
                        Dim screenshot As Bitmap = Spazzarama.ScreenCapture.Direct3DCapture.CaptureWindow(prc.MainWindowHandle)

                        ' Und speichere es unter C:\[NUMMER].jpg
                        screenshot.Save("C:\" & n.ToString() & ".jpg", System.Drawing.Imaging.ImageFormat.Jpeg)

                        ' Anschließend erhöhe man "n" um eins.
                        n += 1
                    Next

                End If
            End While
        End Sub
        Friend WithEvents Button1 As System.Windows.Forms.Button

        Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

          

         'ermittle alle Prozesse mit dem Namen "hl2" (Das .exe weglassen!, Anmerkung: CS:S)
            Dim prcs As System.Diagnostics.Process() = System.Diagnostics.Process.GetProcessesByName(prozessname)


            For Each prc As System.Diagnostics.Process In prcs
                ' Mache für jeden verfügbaren Prozess ein Screenshot...
                Dim screenshot As Bitmap = Spazzarama.ScreenCapture.Direct3DCapture.CaptureWindow(prc.MainWindowHandle)

                ' Und speichere es unter C:\[NUMMER].jpg
                screenshot.Save("C:\test.jpg", System.Drawing.Imaging.ImageFormat.Jpeg)

                ' Anschließend erhöhe man "n" um eins.

            Next

        End Sub
        Private Sub InitializeComponent()
            Me.Button1 = New System.Windows.Forms.Button
            Me.SuspendLayout()
            '
            'Button1
            '
            Me.Button1.Location = New System.Drawing.Point(44, 39)
            Me.Button1.Name = "Button1"
            Me.Button1.Size = New System.Drawing.Size(75, 23)
            Me.Button1.TabIndex = 0
            Me.Button1.Text = "Button1"
            Me.Button1.UseVisualStyleBackColor = True
            '
            'Form1
            '
            Me.ClientSize = New System.Drawing.Size(284, 262)
            Me.Controls.Add(Me.Button1)
            Me.Name = "Form1"
            Me.ResumeLayout(False)

        End Sub
    End Class
End Namespace
Namespace Spazzarama.ScreenCapture
    Public NotInheritable Class Direct3DCapture
        Private Sub New()
        End Sub
        Private Shared _direct3D9 As New SlimDX.Direct3D9.Direct3D()
        Private Shared _direct3DDeviceCache As New Dictionary(Of IntPtr, SlimDX.Direct3D9.Device)()

        ''' <summary>
        ''' Capture the entire client area of a window
        ''' </summary>
        ''' <param name="hWnd"></param>
        ''' <returns></returns>
        Public Shared Function CaptureWindow(ByVal hWnd As IntPtr) As Bitmap
            Return CaptureRegionDirect3D(hWnd, NativeMethods.GetAbsoluteClientRect(hWnd))
        End Function

        ''' <summary>
        ''' Capture a region of the screen using Direct3D
        ''' </summary>
        ''' <param name="handle">The handle of a window</param>
        ''' <param name="region">The region to capture (in screen coordinates)</param>
        ''' <returns>A bitmap containing the captured region, this should be disposed of appropriately when finished with it</returns>
        Public Shared Function CaptureRegionDirect3D(ByVal handle As IntPtr, ByVal region As Rectangle) As Bitmap
            Dim hWnd As IntPtr = handle
            Dim bitmap As Bitmap = Nothing

            ' We are only supporting the primary display adapter for Direct3D mode
            Dim adapterInfo As SlimDX.Direct3D9.AdapterInformation = _direct3D9.Adapters.DefaultAdapter
            Dim device As SlimDX.Direct3D9.Device

            '#Region "Get Direct3D Device"
            ' Retrieve the existing Direct3D device if we already created one for the given handle
            If _direct3DDeviceCache.ContainsKey(hWnd) Then
                device = _direct3DDeviceCache(hWnd)
            Else
                ' We need to create a new device
                ' Setup the device creation parameters
                Dim parameters As New SlimDX.Direct3D9.PresentParameters()
                parameters.BackBufferFormat = adapterInfo.CurrentDisplayMode.Format
                Dim clientRect As Rectangle = NativeMethods.GetAbsoluteClientRect(hWnd)
                parameters.BackBufferHeight = clientRect.Height
                parameters.BackBufferWidth = clientRect.Width
                parameters.Multisample = SlimDX.Direct3D9.MultisampleType.None
                parameters.SwapEffect = SlimDX.Direct3D9.SwapEffect.Discard
                parameters.DeviceWindowHandle = hWnd
                parameters.PresentationInterval = SlimDX.Direct3D9.PresentInterval.[Default]
                parameters.FullScreenRefreshRateInHertz = 0

                ' Create the Direct3D device
                device = New SlimDX.Direct3D9.Device(_direct3D9, adapterInfo.Adapter, SlimDX.Direct3D9.DeviceType.Hardware, hWnd, SlimDX.Direct3D9.CreateFlags.SoftwareVertexProcessing, parameters)
                _direct3DDeviceCache.Add(hWnd, device)
            End If
            '#End Region

            ' Capture the screen and copy the region into a Bitmap
            Using surface As SlimDX.Direct3D9.Surface = SlimDX.Direct3D9.Surface.CreateOffscreenPlain(device, adapterInfo.CurrentDisplayMode.Width, adapterInfo.CurrentDisplayMode.Height, SlimDX.Direct3D9.Format.A8R8G8B8, SlimDX.Direct3D9.Pool.SystemMemory)
                device.GetFrontBufferData(0, surface)

                bitmap = New Bitmap(SlimDX.Direct3D9.Surface.ToStream(surface, SlimDX.Direct3D9.ImageFileFormat.Bmp, New Rectangle(region.Left, region.Top, region.Right, region.Bottom)))
            End Using

            Return bitmap
        End Function
    End Class

#Region "Native Win32 Interop"
    ''' <summary>
    ''' The RECT structure defines the coordinates of the upper-left and lower-right corners of a rectangle.
    ''' </summary>
    <Serializable(), StructLayout(LayoutKind.Sequential)> _
    Friend Structure RECT
        Public Left As Integer
        Public Top As Integer
        Public Right As Integer
        Public Bottom As Integer

        Public Sub New(ByVal left As Integer, ByVal top As Integer, ByVal right As Integer, ByVal bottom As Integer)
            Me.Left = left
            Me.Top = top
            Me.Right = right
            Me.Bottom = bottom
        End Sub

        Public ReadOnly Property AsRectangle() As Rectangle
            Get
                Return New Rectangle(Me.Left, Me.Top, Me.Right - Me.Left, Me.Bottom - Me.Top)
            End Get
        End Property

        Public Shared Function FromXYWH(ByVal x As Integer, ByVal y As Integer, ByVal width As Integer, ByVal height As Integer) As RECT
            Return New RECT(x, y, x + width, y + height)
        End Function

        Public Shared Function FromRectangle(ByVal rect As Rectangle) As RECT
            Return New RECT(rect.Left, rect.Top, rect.Right, rect.Bottom)
        End Function
    End Structure

    <System.Security.SuppressUnmanagedCodeSecurity()> _
    Friend NotInheritable Class NativeMethods
        <DllImport("user32.dll")> _
        Friend Shared Function GetClientRect(ByVal hWnd As IntPtr, ByRef lpRect As RECT) As Boolean
        End Function

        <DllImport("user32.dll")> _
        Friend Shared Function GetWindowRect(ByVal hWnd As IntPtr, ByRef lpRect As RECT) As <MarshalAs(UnmanagedType.Bool)> Boolean
        End Function

        ''' <summary>
        ''' Get a windows client rectangle in a .NET structure
        ''' </summary>
        ''' <param name="hwnd">The window handle to look up</param>
        ''' <returns>The rectangle</returns>
        Friend Shared Function GetClientRect(ByVal hwnd As IntPtr) As Rectangle
            Dim rect As New RECT()
            GetClientRect(hwnd, rect)
            Return rect.AsRectangle
        End Function

        ''' <summary>
        ''' Get a windows rectangle in a .NET structure
        ''' </summary>
        ''' <param name="hwnd">The window handle to look up</param>
        ''' <returns>The rectangle</returns>
        Friend Shared Function GetWindowRect(ByVal hwnd As IntPtr) As Rectangle
            Dim rect As New RECT()
            GetWindowRect(hwnd, rect)
            Return rect.AsRectangle
        End Function

        Friend Shared Function GetAbsoluteClientRect(ByVal hWnd As IntPtr) As Rectangle
            Dim windowRect As Rectangle = NativeMethods.GetWindowRect(hWnd)
            Dim clientRect As Rectangle = NativeMethods.GetClientRect(hWnd)

            ' This gives us the width of the left, right and bottom chrome - we can then determine the top height
            Dim chromeWidth As Integer = CInt((windowRect.Width - clientRect.Width) \ 2)

            Return New Rectangle(New Point(windowRect.X + chromeWidth, windowRect.Y + (windowRect.Height - clientRect.Height - chromeWidth)), clientRect.Size)
        End Function
    End Class
#End Region
End Namespace
                  
                

              
            
          

Nun wollte ich eben mit diesem Button-Klick den Screenshot erstellen, funktioniert ebenfalls nicht. Wenn ich ingame F10 drücke, dann minimiert sich das Spiel lediglich.
Außerdem wundert mich, dass es so kompliziert ist. Ist schon traurig, dass man mit vb.NET mit ein paar Zeilen nicht einfach einen Screenshot der aktiven Anwendung erstellen kann.

MfG und vielen Dank für die Hilfe

WorldRacer · 07.02.10, 15:04

Hm, ok.

Du musst im Form-Designer das passende Form.Load Ereignis zuweisen. Das geht so:

Form anklicken, rechts (wo die Eigenschaften der Form sind), auf den Blitz im Eigenschaften-Fenster klicken. Dort dem Ereignis Load die Prozedur Form1_Load zuweisen.

oder so:

Doppelklick auf die Form, dann den Code aus Form_Load in die neue Sub einfügen. Fertig.

Mit dem Button ists schon komisch. Normalerweise sollte er erscheinen. Ausserdem habe ich an deinem Code gemerkt, dass du das Click Ereignis des Buttons irgendwie nicht gesetzt hast. das machst du genauso wie mit Form.Load, nur nimmst du anstatt der Form und des Ereignisses Load den Button und das Ereignis Click.

Nebenbei: Solltest du CS:S für deine Versuche benutzen, nimm bitte ne andre Taste F9 oder so, weil F10 in CS:S bereits eine Funktion hat, wie du ja bemerkt hast. Hab ich gar nicht mehr dran gedacht, sorry.

Afritus · 07.02.10, 16:08

Jo danke, dein Tipp war gut

Aber jetzt kommt folgender Fehler, den man am angehängten Bild sieht.
Btw: Wenn ich ingame die DRUCK-Taste drücke und dann in Paint einfüge, dann klappt das einwandfrei (auch bei Windows 7). Kann man eventuell diese Aktion mit ein paar Zeilen Code definieren? Einziger Nachteil wäre halt, dass ein Bild mit 1920x1080 einen kurzes Ruckeln beim Drücken der DRUCK-Taste verursacht.

MfG

WorldRacer · 07.02.10, 17:14

            
                    vb Code: 
                  
                        ' Sende Drück-Tastendruck
SendKeys.SendWait("{PRTSC}")
' Hole Bild aus Zwischenablage
Dim img As Image = System.Windows.Forms.Clipboard.GetImage()
 
' Wenn in Zwischenablage ein Bild existiert, weise es der PictureBox zu.
' img.Save(Dateiname, System.Drawing.Imaging.ImageFormat.Jpeg); speichert das Bild.
If img IsNot Nothing Then
  pbImage.Image = img
End If

//edit: sorry, falschen text kopiert.

Afritus · 07.02.10, 17:56

So macht er auf einmal wieder nur Screenshots vom Desktop. Aber wenn ich die Drucktaste ingame drücke, dann bleibt das Spiel 2 Sekunden lang stehen, weshalb das sowieso keine gute Lösung ist.
Langsam bin ich echt am verzweifeln. Ist es tatsächlich unmöglich, mit ein paar Zeilen einen simplen Screenshot aus einer Vollbildanwendung hinzubekommen?

EDIT: Habe nun diesen Code hier:

            
                    Code:
                  
                   	Const KEYEVENTF_KEYUP = &H2
        Const VK_MENU = &H12
        Const VK_SNAPSHOT = &H2C

        keybd_event(VK_MENU, 0, 0, 0) ''ALT-Taste 
        keybd_event(VK_SNAPSHOT, 0, 0, 0) ''Druck-Taste 
        keybd_event(VK_SNAPSHOT, 0, KEYEVENTF_KEYUP, 0)

        Dim img As Image = System.Windows.Forms.Clipboard.GetImage()
        If img IsNot Nothing Then
            img.Save(My.Computer.FileSystem.SpecialDirectories.Desktop & "/" & Format$(Now, "dd-MM-yy hh-mm-ss") & ".jpg", System.Drawing.Imaging.ImageFormat.Jpeg)
        End If

Der funktioniert sogar und macht von allen Spielen auch Ingame-Screenshots. Nur ist die Qualität der erstellten Bilder anscheinend so hoch, dass das Spiel während der Erstellung des Screenshots 2 Sekunden lang ruckelt. Kann man nun Sceenshots mit ALT+DRUCK erstellen und gleichzeitig die Qualität runterschrauben?

MfG

Afritus · 09.02.10, 12:53

Habe mir nun das kostenlose Screenshot-Programm "Fraps" runtergeladen, das macht ruckelfrei schöne Screenshots von allen Spielen. Also muss es doch möglich sein, aber anscheinend nur mit DirectX / DirectDraw.
Nun habe ich im Internet geschaut und da finde ich DirectDraw-Tutorials nur für VB5/6. Für VB.NET 2008 ist da nichts dabei. Weiß denn wirklich keiner, wie man mit VB.NET 2008 über DirectX Screenshots erstellen kann?
Bitte, es ist extrem wichtig.
MfG
Afritus

Vorweg gibt es dieses Thema von mir bereits unter ".NET Cafe", aber anscheinend war das das falsche Forum. Bitte entschuldigt das Doppelthema...

Nun zum Problem: Das Aufnehmen von Screenshots hardwarebeschleunigter Spiele (z.B. Call of Duty, Counter-Strike) mit einem einfachen Code ist bei Windows 7 nicht mehr möglich (bei XP und Vista klappts noch). Nach vielem Suchen im Internet bin ich draufgekommen, dass es doch eine Möglichkeit gibt (hat mir das kostenlose Programme "FRAPS" bewiesen), und zwar über DirectX / DirectDraw. Nun habe ich im Internet nach DirectDraw-Tutorials gesucht, aber leider nur Tutorials für VB5/6 gefunden.
Also, wie kann ich mit VB.NET Screenshots über DirectX erstellen?
Wäre euch für eine hilfreiche Antwort extrem dankbar.

MfG
Markus

**Alexander Schuc** · 09.02.10, 13:11

2 Themen brauchts nun wirklich nicht..

Habs mal verschoben, zusammengeführt, und den Titel bearbeitet..