Game Screenshot

  • VB.NET

Es gibt 21 Antworten in diesem Thema. Der letzte Beitrag () ist von Bajuvare.

    Game Screenshot

    Hallo

    Ich habe folgendes Problem:

    Ich möchte einen Screenshot von einem Spiel erstellen. Ich habe derzeit versucht über

    VB.NET-Quellcode

    1. CopyFromScreen
    und über das simmulieren des drückens der Druck/S-ABF Taste und anschließenden auslesen der Zwischenablage über

    VB.NET-Quellcode

    1. Clipboard.GetDataObject
    .

    Bei beiden funktionen zeigt er das Spielfenster nicht an sondern screent den normalen Desktop (in der Auflösung des laufenden Spieles)
    Drücke ich selbst die Druck-Taste, öffne Paint und drücke STRG + V so wird ein richtiger Screenshot (auch vom Spiel) in Paint eingefügt.

    Könnte es sein das, dass Spiel über DirectX oder so läuft ?

    Soweit ich weiß geht das per Programm nicht so einfach wie wenn du Ingame bist und DRUCK/STRG+DRUCK drückst.

    Versuchen könntest du über das WindowHandle irgendwas zu basteln bin mir da aber nicht sicher ob das mit DirectX und so funktioniert.
    Falls dies Falsch ist bin ich gerne offen für auch andere Lösungswege zu sehen :P "Man Lernt ja nicht aus"


    Mfg
    Grüße , xChRoNiKx

    Nützliche Links:
    Visual Studio Empfohlene Einstellungen | Try-Catch heißes Eisen

    Ich muss davon ausgehen, dass das Spiel unter DirectX 9.0c läuft. Da ich allerdings durch das drücken von DRUCK einen vollwertigen Screenshot machen kann, dies per Sendkey allerdings nicht wirklich funktioniert verwundert mich. Zeigt allerdings gleichzeitig das es einen weg geben muss dies ohne ohne einen umständlichen Code machen zu können.

    Sollte es doch nicht über einen simplen Code gehen bräuchte ich Tipps wie ich das Problem sonst lösen könnte.

    Die Seiten die du geschikt hast habe ich auch schon gesehen. Leider handelt es sich hierbei um C# und nicht .net

    Ja ich weiß die sprachen sind ähnlich aber ich kann die codeschnipsel, die dort stehen trotzdem nicht in .net übersetzten.

    Hast du evtl noch vorschläge für .net (google spuckt sehr viel zu C# aus)

    Im zweiten Link steht leider auch nichts was mich weiterbringt

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „StormBoomer“ ()

    C# ist ebenso .NET wie VB.Net. Verwechsel das bitte nicht.

    vb-paradise.de/allgemeines/tip…as-ist-aber-c-nicht-gilt/

    Warum nutzt Du für einen Screenshot nicht einfach die Druck-Taste? Einfacher geht es wohl doch kaum. Ferner bieten die meisten Spiele ohnehin einen Hotkey für Screenshots. So gesehen ist Dein Vorhaben ohnehin recht sinnlos, meinst nicht? Wenn schon, dann würde ich, sofern das Spiel nicht selber die Option bietet, Screenshots zu erstellen und zu speichern, ein Programm entwerfen, dass auf Änderungen der Zwischenablage reagiert und ggf. ein Bild entgegennimmt und speichert. Was willst Du letzen Endes erreichen?
    Die Unendlichkeit ist weit. Vor allem gegen Ende. ?(
    Manche Menschen sind gar nicht dumm. Sie haben nur Pech beim Denken. 8o

    StormBoomer schrieb:

    Leider handelt es sich hierbei um C# und nicht .net

    C# ist .NET nur mal so am Rande.

    Was ich beim Folgen der Links gefunden habe ist das hier: C# – Screen capture and Overlays for Direct3D 9, 10 and 11 using API Hooks
    Sieht sehr viel versprechend (DirectX9,10 und 11 abdeckend) aus.
    Du solltest eig. SlimDX (welches hier benötigt wird) mit VB ansteuern können, müsstest Du mal versuchen.
    Ansonsten kann ich mir nicht vorstellen, das Du dein vorhaben mit reinem VB unmsetzen kannst.
    Denn irgendwie muss Du dich ja zwischen DirectX und dem Device (Grafikkarte) werfen und dein Bild anfertigen, dies scheint mir mit reinem VB unmöglich.

    1. du wirst ja wohl zugreben, dass C# schon anders aussieht (für einen Anfänger) und das es für jemanden der sich nicht so perfekt auskennt schwer ist den code in vb zu übersetzten.

    2. Das spiel bietet keine eigene Screenshot funktion.

    3. Es geht darum das das Programm auch screenshots in bestimmten zeitabfolgen erstellen kann. Ohne das man noch einen Hotkey drücken muss. Ich habe bereits versucht über das Simulieren der Druck-Taste den Screenshot in die Zwischenablage zu kopieren und dann auszulesen. (sollte ich aber eig. auch so schon vorher geschrieben haben) @Dodo danke, dass du unseren Kollegen darauf hingewiesen hast

    @Dodo:

    Drücke ich selbst die Druck-Taste, öffne Paint und drücke STRG + V so wird ein richtiger Screenshot (auch vom Spiel) in Paint eingefügt.


    Darum, selber DRUCK-Taste drücken und im Programm auf nen Screenshot warten.
    Die Unendlichkeit ist weit. Vor allem gegen Ende. ?(
    Manche Menschen sind gar nicht dumm. Sie haben nur Pech beim Denken. 8o

    @Dodo

    Ich habe mir deinen Link einmal angeschaut. Ich habe diesen Converter hier benutzt converter.telerik.com/
    Leider gibt dieser dann einen Fehler aus

    HTML-Quellcode

    1. CONVERSION ERROR: Code could not be converted. Details:
    3. -- line 12 col 34: invalid StructMemberDecl
    5. Please check for any errors in the original code and try again.


    eingegeben habe ich den Code von deinem artikel spazzarama.com/2009/02/07/screencapture-with-direct3d/

    Spoiler anzeigen

    VB.NET-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Text;
    4. using System.Drawing;
    5. using System.Runtime.InteropServices;
    7. namespace Spazzarama.ScreenCapture
    8. {
    9. public static class Direct3DCapture
    10. {
    11. private static SlimDX.Direct3D9.Direct3D _direct3D9 = new SlimDX.Direct3D9.Direct3D();
    12. private static Dictionary<IntPtr, SlimDX.Direct3D9.Device> _direct3DDeviceCache = new Dictionary<IntPtr, SlimDX.Direct3D9.Device>();
    14. /// <summary>
    15. /// Capture the entire client area of a window
    16. /// </summary>
    17. /// <param name="hWnd"></param>
    18. /// <returns></returns>
    19. public static Bitmap CaptureWindow(IntPtr hWnd)
    20. {
    21. return CaptureRegionDirect3D(hWnd, NativeMethods.GetAbsoluteClientRect(hWnd));
    22. }
    24. /// <summary>
    25. /// Capture a region of the screen using Direct3D
    26. /// </summary>
    27. /// <param name="handle">The handle of a window</param>
    28. /// <param name="region">The region to capture (in screen coordinates)</param>
    29. /// <returns>A bitmap containing the captured region, this should be disposed of appropriately when finished with it</returns>
    30. public static Bitmap CaptureRegionDirect3D(IntPtr handle, Rectangle region)
    31. {
    32. IntPtr hWnd = handle;
    33. Bitmap bitmap = null;
    35. // We are only supporting the primary display adapter for Direct3D mode
    36. SlimDX.Direct3D9.AdapterInformation adapterInfo = _direct3D9.Adapters.DefaultAdapter;
    37. SlimDX.Direct3D9.Device device;
    39. #region Get Direct3D Device
    40. // Retrieve the existing Direct3D device if we already created one for the given handle
    41. if (_direct3DDeviceCache.ContainsKey(hWnd))
    42. {
    43. device = _direct3DDeviceCache[hWnd];
    44. }
    45. // We need to create a new device
    46. else
    47. {
    48. // Setup the device creation parameters
    49. SlimDX.Direct3D9.PresentParameters parameters = new SlimDX.Direct3D9.PresentParameters();
    50. parameters.BackBufferFormat = adapterInfo.CurrentDisplayMode.Format;
    51. Rectangle clientRect = NativeMethods.GetAbsoluteClientRect(hWnd);
    52. parameters.BackBufferHeight = clientRect.Height;
    53. parameters.BackBufferWidth = clientRect.Width;
    54. parameters.Multisample = SlimDX.Direct3D9.MultisampleType.None;
    55. parameters.SwapEffect = SlimDX.Direct3D9.SwapEffect.Discard;
    56. parameters.DeviceWindowHandle = hWnd;
    57. parameters.PresentationInterval = SlimDX.Direct3D9.PresentInterval.Default;
    58. parameters.FullScreenRefreshRateInHertz = 0;
    60. // Create the Direct3D device
    61. device = new SlimDX.Direct3D9.Device(_direct3D9, adapterInfo.Adapter, SlimDX.Direct3D9.DeviceType.Hardware, hWnd, SlimDX.Direct3D9.CreateFlags.SoftwareVertexProcessing, parameters);
    62. _direct3DDeviceCache.Add(hWnd, device);
    63. }
    64. #endregion
    66. // Capture the screen and copy the region into a Bitmap
    67. using (SlimDX.Direct3D9.Surface surface = SlimDX.Direct3D9.Surface.CreateOffscreenPlain(device, adapterInfo.CurrentDisplayMode.Width, adapterInfo.CurrentDisplayMode.Height, SlimDX.Direct3D9.Format.A8R8G8B8, SlimDX.Direct3D9.Pool.SystemMemory))
    68. {
    69. device.GetFrontBufferData(0, surface);
    71. // Update: thanks digitalutopia1 for pointing out that SlimDX have fixed a bug
    72. // where they previously expected a RECT type structure for their Rectangle
    73. bitmap = new Bitmap(SlimDX.Direct3D9.Surface.ToStream(surface, SlimDX.Direct3D9.ImageFileFormat.Bmp, new Rectangle(region.Left, region.Top, region.Width, region.Height)));
    74. // Previous SlimDX bug workaround: new Rectangle(region.Left, region.Top, region.Right, region.Bottom)));
    76. }
    78. return bitmap;
    79. }
    80. }
    82. #region Native Win32 Interop
    83. /// <summary>
    84. /// The RECT structure defines the coordinates of the upper-left and lower-right corners of a rectangle.
    85. /// </summary>
    86. [Serializable, StructLayout(LayoutKind.Sequential)]
    87. internal struct RECT
    88. {
    89. public int Left;
    90. public int Top;
    91. public int Right;
    92. public int Bottom;
    94. public RECT(int left, int top, int right, int bottom)
    95. {
    96. this.Left = left;
    97. this.Top = top;
    98. this.Right = right;
    99. this.Bottom = bottom;
    100. }
    102. public Rectangle AsRectangle
    103. {
    104. get
    105. {
    106. return new Rectangle(this.Left, this.Top, this.Right - this.Left, this.Bottom - this.Top);
    107. }
    108. }
    110. public static RECT FromXYWH(int x, int y, int width, int height)
    111. {
    112. return new RECT(x, y, x + width, y + height);
    113. }
    115. public static RECT FromRectangle(Rectangle rect)
    116. {
    117. return new RECT(rect.Left, rect.Top, rect.Right, rect.Bottom);
    118. }
    119. }
    121. [System.Security.SuppressUnmanagedCodeSecurity()]
    122. internal sealed class NativeMethods
    123. {
    124. [DllImport("user32.dll")]
    125. internal static extern bool GetClientRect(IntPtr hWnd, out RECT lpRect);
    127. [DllImport("user32.dll")]
    128. [return: MarshalAs(UnmanagedType.Bool)]
    129. internal static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
    131. /// <summary>
    132. /// Get a windows client rectangle in a .NET structure
    133. /// </summary>
    134. /// <param name="hwnd">The window handle to look up</param>
    135. /// <returns>The rectangle</returns>
    136. internal static Rectangle GetClientRect(IntPtr hwnd)
    137. {
    138. RECT rect = new RECT();
    139. GetClientRect(hwnd, out rect);
    140. return rect.AsRectangle;
    141. }
    143. /// <summary>
    144. /// Get a windows rectangle in a .NET structure
    145. /// </summary>
    146. /// <param name="hwnd">The window handle to look up</param>
    147. /// <returns>The rectangle</returns>
    148. internal static Rectangle GetWindowRect(IntPtr hwnd)
    149. {
    150. RECT rect = new RECT();
    151. GetWindowRect(hwnd, out rect);
    152. return rect.AsRectangle;
    153. }
    155. internal static Rectangle GetAbsoluteClientRect(IntPtr hWnd)
    156. {
    157. Rectangle windowRect = NativeMethods.GetWindowRect(hWnd);
    158. Rectangle clientRect = NativeMethods.GetClientRect(hWnd);
    160. // This gives us the width of the left, right and bottom chrome - we can then determine the top height
    161. int chromeWidth = (int)((windowRect.Width - clientRect.Width) / 2);
    163. return new Rectangle(new Point(windowRect.X + chromeWidth, windowRect.Y + (windowRect.Height - clientRect.Height - chromeWidth)), clientRect.Size);
    164. }
    165. }
    166. #endregion
    167. }

Facebook
Telefonspende