[GDI+/GDI/Sonstiges] VSync nachrüsten mit D2D

**Mars**

Moin,

Wir wir alle wissen funktioniert der VSync mit D2D wunderbar. Ich hatte schon 50x vor die 3 dafür nötigen Schritte zusammenzufassen, damit man in GDI+/GDI/usw Skripten den VSync einfach nachrüsten kann.

Wie funktioniert es ?
- Die UDF ermöglicht es auf den VSync zu warten, dabei wird das Skript auf 60 FPS beschränkt.
- Hat man gewartet, so kann man DANACH die eigentliche Zeichenoperation ausführen. Man hat dann ca. 16 Millisekunden Zeit das neue Bild ins Fenster zu schaffen, wenn man diese Zeit nicht einhalten kann (z.B. wenn man GDI+ nutzt und das Fenster zu groß ist), so tritt selbstverständlich trotzdem Tearing auf. Sinn macht diese UDF also nur, sofern der eigentliche Zeichenvorgang schneller als die 16ms läuft (BitBlt ist da so ein Kandidat der das kann) und das Skript (wenn man jedes Sleep ausbaut) wesentlich schneller als mit 60 FPS läuft.
- Es wird an keiner Stelle D2D zum Zeichnen benutzt, sondern nur zum Warten. Dadurch kann man die UDF in jedes beliebige Skript integrieren.

Edit: Als Beispiele sind 2 Skripte (eins mit GDI, eins mit GDI+) beigelegt. Das GDI+ Beispiel wird auf einigen Rechnern trotzdem Tearing zeigen, da das Zeichnen für die gewählte Fenstergröße ggf zu lange dauert.

Anregungen, Verbesserungen, Gefundene Fehler, usw sind gerne gesehen.

Edit1: Eine verbesserte Version von eukalyptus mit Errorhandling gibt es in Post 5.

lg
M

**Andy**

Hi,
in der vorliegenden Form erreichen beide Scripte auf meinem Laptop 60fps.

Vergrößere ich das Fenster im GDI+-Script auf das 1,5-fache, bricht die Framerate auf knapp die Hälfte zusammen, anders gesagt benötigt _GDIPlus_GraphicsDrawImage() statt 10ms nun 25...

Im GDI-Script kann ich aber machen was ich will, Fenstergröße und auch das Quadrat bis aufs 3-fache vergrößern ändert nichts an der konstanten Framerate von 60.

Ich würde wirklich gerne mal den GDI+Code sehen, ab und zu bin ich schon mit dem Debugger durch den Code einiger GDI+-Funktionen gepflügt, aber nach 1/2h rumgespringe durch den Speicher ohne wirkliches Ergebnis verlässt einen dann doch die Lust

**autoBert**

Zitat von Andy

Vergrößere ich das Fenster im GDI+-Script auf das 1,5-fache, bricht die Framerate auf knapp die Hälfte zusammen, anders gesagt benötigt _GDIPlus_GraphicsDrawImage() statt 10ms nun 25...

10*1,5 = 25, wann wurde das neu festgelegt

http://www.der-postillon.com/2012/08/mathem…-von-x-ein.html

**Andy**

Zitat von autoBert

10*1,5 = 25, wann wurde das neu festgelegt

Richtig ist (ungefähr), dass 10*1,5*1,5 = 25, vergrößert man B und H um je 1,5, vergrößert sich die Fläche auf Faktor 2,25

Wenn ich jetzt mal klugscheißern wollte würde ich feststellen, dass im ursprünglichen Script die Framerate auf 60FPS limitiert ist! Ohne diese Limitierung sind es ca. 80 FPS, einfach herauszufinden indem man _VSync_Wait() auskommentiert.
Wird jetzt das Fenster vergrößert ($iH und $iW = 512*1.5 ), verändert sich die Framerate von ca. 80 auf die von mir festgestellten 33-35FPS. Das wiederum ist ausschließlich auf die Laufzeit von _GDIPlus_GraphicsDrawImage() zurückzuführen (profiling FTW)!

Beim "Blitten" erreiche ich ohne Limitierung 750-760 FPS, bei Vergrößerung des Fensters auf B*2.5 und H*1.5 (Fläche vergrößert auf das 3.75-fache) werden 215 FPS erreicht, also genau die gleiche lineare Abhängigkeit der Laufzeit der Funktion von der Fenstergröße.

Deshalb sollte man sich bei der Programmierung im Hinblick auf Geschwindigkeit auch Gedanken machen, ob der gesamte Fensterinhalt "erneuert" werden sollte! Wenn ein (oder mehrere) "Sprites" im Fenster vor konstantem Hintergrund bewegt werden sollen, dann ist es wesentlich sinnvoller, statt eines "Backbuffers" des gesamten Fensterinhalts nur den aktuellen "Hintergrund" des Sprites (plus nächste Bewegungsänderung) zu sichern und diesen dann nach der Bewegung des Sprites wieder zu restaurieren. Mal angenommen, die Fenstergröße ist 300x300 und das einzelne Sprite 30x30 groß, dann ist der Geschwindigkeitsgewinn nur durch das "teilweise" Blitten ca. Faktor 100 (naja, zumindes irgendwas größer als 80 ) !
Natürlich ist die Verwaltung bei mehreren Sprites aufwendig und kostet entsprechend Laufzeit, daher ist irgendwann der Break-Even erreicht und der Overhead der Sprite-Verwaltung frisst den Zeitgewinn auf....Hier das Optimum zu finden ist der Job des Programmierers!

Anbei ein uraltes Script von mir, eine Demo was per "Blitten" so geht^^
Spirale-Donut-Mona-Lisa.zip

**eukalyptus**

Sehr interessant!

Alternativ hätte ich diese Version, welche nur mehr eine globale Variable verwendet und etwas schlanker ist:

Code

#include-once




Global $__t_VSYNC




Func _VSync_Startup()
	If IsDllStruct($__t_VSYNC) Then Return True


	$__t_VSYNC = DllStructCreate("struct; handle Dll; hwnd Gui; ptr Fac; ptr Tar; endstruct; ")
	$__t_VSYNC.Dll = DllOpen('d2d1.dll') ; Direct2D Dll
	If @error Or Not $__t_VSYNC.Dll Then Return SetError(1, 1, False)


	$__t_VSYNC.Gui = GUICreate("VSync", 1, 1, 0, 0, 0x80000000) ; GUI mit der Größe 1x1px oben links im Bildschirm, unsichtbar


	Local $tIID_ID2D1Factory = DllStructCreate("struct; ulong Data1; ushort Data2; ushort Data3; byte Data4[8]; endstruct; ")
	DllCall("ole32.dll", "long", "CLSIDFromString", "wstr", "{06152247-6f50-465a-9245-118bfd3b6007}", "struct*", $tIID_ID2D1Factory)
	Local $aResult = DllCall($__t_VSYNC.Dll, "int", "D2D1CreateFactory", "uint", 0, "struct*", $tIID_ID2D1Factory, "uint*", 0, "ptr*", 0)
	If @error Or $aResult[0] Or Not $aResult[4] Then
		_VSync_Shutdown()
		Return SetError(1, 2, False)
	EndIf
	$__t_VSYNC.Fac = $aResult[4]


	Local $pHwndRenderTarget, $tRenderTargetProperties = DllStructCreate("struct; uint Type; uint PixelFormat; uint AlphaMode; float DpiX; float DpiY; uint Usage; uint MinLevel; endstruct; ")
	Local $tHWNDRenderTargetProperties = DllStructCreate("struct; hwnd Hwnd; uint Width; uint Height; uint PresentOptions; endstruct; ")
	$tHWNDRenderTargetProperties.Hwnd = $__t_VSYNC.Gui
	$tHWNDRenderTargetProperties.Width = 1
	$tHWNDRenderTargetProperties.Height = 1


	Local $tObj = DllStructCreate("struct; ptr VTBL; endstruct; ", $__t_VSYNC.Fac)
	Local $tCall = DllStructCreate("struct; ptr[15]; endstruct; ", $tObj.VTBL)
	$aResult = DllCallAddress("int", DllStructGetData($tCall, 1, 15), "struct*", $__t_VSYNC.Fac, "struct*", $tRenderTargetProperties, "struct*", $tHWNDRenderTargetProperties, "ptr*", 0)
	If @error Or $aResult[0] Or Not $aResult[4] Then
		_VSync_Shutdown()
		Return SetError(1, 3, False)
	EndIf
	$__t_VSYNC.Tar = $aResult[4]


	Return $__t_VSYNC
EndFunc   ;==>_VSync_Startup




Func _VSync_Shutdown()
	If Not IsDllStruct($__t_VSYNC) Then Return SetError(1, 1, False)
	Local $tObj, $tCall, $aResult


	If $__t_VSYNC.Tar Then
		$tObj = DllStructCreate("struct; ptr VTBL; endstruct; ", $__t_VSYNC.Tar)
		$tCall = DllStructCreate("struct; ptr[3]; endstruct; ", $tObj.VTBL)
		$aResult = DllCallAddress("int", DllStructGetData($tCall, 1, 3), "struct*", $__t_VSYNC.Tar) ;Release
	EndIf


	If $__t_VSYNC.Fac Then
		$tObj = DllStructCreate("struct; ptr VTBL; endstruct; ", $__t_VSYNC.Fac)
		$tCall = DllStructCreate("struct; ptr[3]; endstruct; ", $tObj.VTBL)
		$aResult = DllCallAddress("int", DllStructGetData($tCall, 1, 3), "struct*", $__t_VSYNC.Fac) ;Release
	EndIf


	GUIDelete($__t_VSYNC.Gui)
	DllClose($__t_VSYNC.Dll)
	$__t_VSYNC = Null
	Return True
EndFunc   ;==>_VSync_Shutdown




Func _VSync_Wait()
	If Not IsDllStruct($__t_VSYNC) Then Return SetError(1, 1, False)
	Local $tObj = DllStructCreate("struct; ptr VTBL; endstruct; ", $__t_VSYNC.Tar)
	Local $tCall = DllStructCreate("struct; ptr[50]; endstruct; ", $tObj.VTBL)
	DllCallAddress("int", DllStructGetData($tCall, 1, 49), "struct*", $__t_VSYNC.Tar) ;BeginDraw
	DllCallAddress("int", DllStructGetData($tCall, 1, 50), "struct*", $__t_VSYNC.Tar, "uint64*", 0, "uint64*", 0) ;EndDraw
	Return True
EndFunc   ;==>_VSync_Wait

Alles anzeigen

Um ganz auf globale Variablen zu verzichten, könnte man $__t_VSYNC auch als Return bzw. Byref übergeben...

**UEZ**

Irgendwie gefällt mir das VSync von GDI+ nicht richtig, wenn ich Beispiele z.B. in JS mir ansehe, wo die Animationen echt butterweich abgespielt werden.

Irgendwie ist immer ein leichtes zucken drinne...

Beispiel:

AutoIt

;coded by UEZ build 2016-04-08
#pragma compile(Icon, "c:\Program Files (x86)\AutoIt3\Icons\au3.ico")
#AutoIt3Wrapper_Run_Au3Stripper=y
#Au3Stripper_Parameters=/so /pe /rm
#AutoIt3Wrapper_Run_After=del /f /q "%scriptdir%\%scriptfile%_stripped.au3"


#include <GDIPlus.au3>
#include <GuiConstantsEx.au3>
#include <WindowsConstants.au3>


_GDIPlus_Startup()
Global $hGUI, $iFPS = 0, $iShowFPS = 0, $bExit, $i, $__t_VSYNC
Global Const $iW = 800, $iH = 600, $iWh = $iW / 2, $iHh = $iH / 2, $sTitle = "GDI+ 3D Object Rotation v1.0"
Global Const $fRad = ACos(-1) / 180
Global Const $iAmountDots = 8, $fDist = 125
Global $tCoords = DllStructCreate("struct;float x[" & $iAmountDots & "];float y[" & $iAmountDots & "];float z[" & $iAmountDots & "];float fX[" & $iAmountDots & "];float fY[" & $iAmountDots & "];float fZ[" & $iAmountDots & "];endstruct")
;create dots for cube
$tCoords.x((1)) = -$fDist
$tCoords.y((1)) = -$fDist
$tCoords.z((1)) = -$fDist
$tCoords.x((2)) = $fDist
$tCoords.y((2)) = -$fDist
$tCoords.z((2)) = -$fDist
$tCoords.x((3)) = $fDist
$tCoords.y((3)) = $fDist
$tCoords.z((3)) = -$fDist
$tCoords.x((4)) = -$fDist
$tCoords.y((4)) = $fDist
$tCoords.z((4)) = -$fDist


$tCoords.x((5)) = -$fDist
$tCoords.y((5)) = -$fDist
$tCoords.z((5)) = $fDist
$tCoords.x((6)) = $fDist
$tCoords.y((6)) = -$fDist
$tCoords.z((6)) = $fDist
$tCoords.x((7)) = $fDist
$tCoords.y((7)) = $fDist
$tCoords.z((7)) = $fDist
$tCoords.x((8)) = -$fDist
$tCoords.y((8)) = $fDist
$tCoords.z((8)) = $fDist


AutoItSetOption("GUIOnEventMode", 1)


_VSync_Startup()


GDIPlus_3DRotation()


_VSync_Shutdown()


AutoItSetOption("GUIOnEventMode", 0)
_GDIPlus_Shutdown()




Func GDIPlus_3DRotation()
	$bExit = False
	$hGUI = GUICreate($sTitle, $iW, $iH) ;, -1, -1, $WS_POPUP)
	GUISetState(@SW_SHOW, $hGUI)


	;create canvas elements
	Local Const $hDC = _WinAPI_GetDC($hGUI)
	Local Const $hHBitmap = _WinAPI_CreateCompatibleBitmap($hDC, $iW, $iH)
	Local Const $hDC_backbuffer = _WinAPI_CreateCompatibleDC($hDC)
	Local Const $DC_obj = _WinAPI_SelectObject($hDC_backbuffer, $hHBitmap)
	Local Const $hCanvas = _GDIPlus_GraphicsCreateFromHDC($hDC_backbuffer)
	_GDIPlus_GraphicsSetSmoothingMode($hCanvas, $GDIP_SMOOTHINGMODE_HIGHQUALITY)
	_GDIPlus_GraphicsSetPixelOffsetMode($hCanvas, $GDIP_PIXELOFFSETMODE_HIGHQUALITY)


	Local Const $hBrush_Clr = _GDIPlus_BrushCreateSolid(0xFF000000), _
				$hBrush_FPS = _GDIPlus_BrushCreateSolid(0xF0808080), _
				$hBrush_Dots = _GDIPlus_BrushCreateSolid(0xFFFFFFFF), _
				$hPen_Line = _GDIPlus_PenCreate(0xFFFFFFFF, 1), _
				$hFormat_FPS = _GDIPlus_StringFormatCreate(), _
				$hFamily_FPS = _GDIPlus_FontFamilyCreate("Arial"), _
				$hFont_FPS = _GDIPlus_FontCreate($hFamily_FPS, 8), _
				$tLayout_FPS = _GDIPlus_RectFCreate(0, 0, 60, 16)


	$iFPS = 0
	GUISetOnEvent($GUI_EVENT_CLOSE, "_Exit_About")
	AdlibRegister("CalcFPS", 1000)


	Local $i, $fRotX = 0, $fRotY = 0


	Do
		DllCall($__g_hGDIPDll, "int", "GdipFillRectangle", "handle", $hCanvas, "handle", $hBrush_Clr, "float", 0, "float", 0, _
				"float", $iW, "float", $iH) ;erase canvas background


		For $i = 1 To $iAmountDots
			Translate3Dto2D($tCoords, $i, $fRotX, $fRotY, $fRotY - $fRotX, $iWh, $iHh)
			_GDIPlus_GraphicsFillEllipse($hCanvas, $tCoords.fX(($i)) - 4, $tCoords.fY(($i)) - 4, 8, 8, $hBrush_Dots)
		Next
		_GDIPlus_GraphicsDrawLine($hCanvas, $tCoords.fX((1)), $tCoords.fY((1)), $tCoords.fX((2)), $tCoords.fY((2)), $hPen_Line)
		_GDIPlus_GraphicsDrawLine($hCanvas, $tCoords.fX((2)), $tCoords.fY((2)), $tCoords.fX((3)), $tCoords.fY((3)), $hPen_Line)
		_GDIPlus_GraphicsDrawLine($hCanvas, $tCoords.fX((3)), $tCoords.fY((3)), $tCoords.fX((4)), $tCoords.fY((4)), $hPen_Line)
		_GDIPlus_GraphicsDrawLine($hCanvas, $tCoords.fX((4)), $tCoords.fY((4)), $tCoords.fX((1)), $tCoords.fY((1)), $hPen_Line)


		_GDIPlus_GraphicsDrawLine($hCanvas, $tCoords.fX((5)), $tCoords.fY((5)), $tCoords.fX((6)), $tCoords.fY((6)), $hPen_Line)
		_GDIPlus_GraphicsDrawLine($hCanvas, $tCoords.fX((6)), $tCoords.fY((6)), $tCoords.fX((7)), $tCoords.fY((7)), $hPen_Line)
		_GDIPlus_GraphicsDrawLine($hCanvas, $tCoords.fX((7)), $tCoords.fY((7)), $tCoords.fX((8)), $tCoords.fY((8)), $hPen_Line)
		_GDIPlus_GraphicsDrawLine($hCanvas, $tCoords.fX((8)), $tCoords.fY((8)), $tCoords.fX((5)), $tCoords.fY((5)), $hPen_Line)


		_GDIPlus_GraphicsDrawLine($hCanvas, $tCoords.fX((1)), $tCoords.fY((1)), $tCoords.fX((5)), $tCoords.fY((5)), $hPen_Line)
		_GDIPlus_GraphicsDrawLine($hCanvas, $tCoords.fX((2)), $tCoords.fY((2)), $tCoords.fX((6)), $tCoords.fY((6)), $hPen_Line)
		_GDIPlus_GraphicsDrawLine($hCanvas, $tCoords.fX((4)), $tCoords.fY((4)), $tCoords.fX((8)), $tCoords.fY((8)), $hPen_Line)
		_GDIPlus_GraphicsDrawLine($hCanvas, $tCoords.fX((3)), $tCoords.fY((3)), $tCoords.fX((7)), $tCoords.fY((7)), $hPen_Line)


		$fRotX += 0.01
		$fRotY += 0.02


		_GDIPlus_GraphicsDrawStringEx($hCanvas, "FPS: " & $iShowFPS, $hFont_FPS, $tLayout_FPS, $hFormat_FPS, $hBrush_FPS) ;draw background message text
		_WinAPI_BitBlt($hDC, 0, 0, $iW, $iH, $hDC_backbuffer, 0, 0, $SRCCOPY) ;blit drawn bitmap to GUI


		$iFPS += 1
		If $bExit Then ExitLoop
	Until Not _VSync_Wait()


	AdlibUnRegister("CalcFPS")
	;release resources
	_GDIPlus_FontDispose($hFont_FPS)
	_GDIPlus_FontFamilyDispose($hFamily_FPS)
	_GDIPlus_StringFormatDispose($hFormat_FPS)
	_GDIPlus_BrushDispose($hBrush_Clr)
	_GDIPlus_BrushDispose($hBrush_FPS)
	_GDIPlus_BrushDispose($hBrush_Dots)
	_GDIPlus_PenDispose($hPen_Line)
	_GDIPlus_GraphicsDispose($hCanvas)
	_WinAPI_SelectObject($hDC_backbuffer, $DC_obj)
	_WinAPI_DeleteDC($hDC_backbuffer)
	_WinAPI_DeleteObject($hHBitmap)
	_WinAPI_ReleaseDC($hGUI, $hDC)
	GUIDelete($hGUI)
EndFunc   ;==>GDIPlus_3DRotation


Func Translate3Dto2D(ByRef $tStruct, $iPos, $fRotX, $fRotY, $fRotZ, $fCenterX = 0, $fCenterY = 0, $fZDeepCorrection = 512)
	Local Const $fCosRotX = Cos($fRotX), $fSinRotX = Sin($fRotX), _
				$fCosRotY = Cos($fRotY), $fSinRotY = Sin($fRotY), _
				$fCosRotZ = Cos($fRotZ), $fSinRotZ = Sin($fRotZ)
	Local Const $fXPos = $fCosRotZ * ($fCosRotY * $tStruct.x(($iPos)) - $fSinRotY * ($fSinRotX * $tStruct.y(($iPos)) + $fCosRotX * $tStruct.z(($iPos)))) - $fSinRotZ * ($fCosRotX * $tStruct.y(($iPos)) - $fSinRotX * $tStruct.z(($iPos)))
	Local Const $fYPos = $fSinRotZ * ($fCosRotY * $tStruct.x(($iPos)) - $fSinRotY * ($fSinRotX * $tStruct.y(($iPos)) + $fCosRotX * $tStruct.z(($iPos)))) + $fCosRotZ * ($fCosRotX * $tStruct.y(($iPos)) - $fSinRotX * $tStruct.z(($iPos)))
	Local Const $fZPos = $fSinRotY * $tStruct.x(($iPos)) + $fCosRotY * ($fSinRotX * $tStruct.y(($iPos)) + $fCosRotX * $tStruct.z(($iPos)))
	Local Const $fZPerspCorrection = 1 / ($fZPos / $fZDeepCorrection + 1)
	$tStruct.fX(($iPos)) = $fXPos * $fZPerspCorrection + $fCenterX
	$tStruct.fY(($iPos)) = $fYPos * $fZPerspCorrection + $fCenterY
EndFunc   ;==>Translate3Dto2D


Func _Exit_About()
	$bExit = True
EndFunc   ;==>_Exit_About


Func CalcFPS() ;display FPS
	$iShowFPS = $iFPS
	$iFPS = 0
EndFunc   ;==>CalcFPS


Func _VSync_Startup()
	If IsDllStruct($__t_VSYNC) Then Return True
	$__t_VSYNC = DllStructCreate("struct; handle Dll; hwnd Gui; ptr Fac; ptr Tar; endstruct; ")
	$__t_VSYNC.Dll = DllOpen('d2d1.dll') ; Direct2D Dll
	If @error Or Not $__t_VSYNC.Dll Then Return SetError(1, 1, False)
	$__t_VSYNC.Gui = GUICreate("VSync", 1, 1, 0, 0, 0x80000000) ; GUI mit der Größe 1x1px oben links im Bildschirm, unsichtbar
	Local $tIID_ID2D1Factory = DllStructCreate("struct; ulong Data1; ushort Data2; ushort Data3; byte Data4[8]; endstruct; ")
	DllCall("ole32.dll", "long", "CLSIDFromString", "wstr", "{06152247-6f50-465a-9245-118bfd3b6007}", "struct*", $tIID_ID2D1Factory)
	Local $aResult = DllCall($__t_VSYNC.Dll, "int", "D2D1CreateFactory", "uint", 0, "struct*", $tIID_ID2D1Factory, "uint*", 0, "ptr*", 0)
	If @error Or $aResult[0] Or Not $aResult[4] Then
		_VSync_Shutdown()
		Return SetError(1, 2, False)
	EndIf
	$__t_VSYNC.Fac = $aResult[4]
	Local $pHwndRenderTarget, $tRenderTargetProperties = DllStructCreate("struct; uint Type; uint PixelFormat; uint AlphaMode; float DpiX; float DpiY; uint Usage; uint MinLevel; endstruct; ")
	Local $tHWNDRenderTargetProperties = DllStructCreate("struct; hwnd Hwnd; uint Width; uint Height; uint PresentOptions; endstruct; ")
	$tHWNDRenderTargetProperties.Hwnd = $__t_VSYNC.Gui
	$tHWNDRenderTargetProperties.Width = 1
	$tHWNDRenderTargetProperties.Height = 1
	Local $tObj = DllStructCreate("struct; ptr VTBL; endstruct; ", $__t_VSYNC.Fac)
	Local $tCall = DllStructCreate("struct; ptr[15]; endstruct; ", $tObj.VTBL)
	$aResult = DllCallAddress("int", DllStructGetData($tCall, 1, 15), "struct*", $__t_VSYNC.Fac, "struct*", $tRenderTargetProperties, "struct*", $tHWNDRenderTargetProperties, "ptr*", 0)
	If @error Or $aResult[0] Or Not $aResult[4] Then
		_VSync_Shutdown()
		Return SetError(1, 3, False)
	EndIf
	$__t_VSYNC.Tar = $aResult[4]
	Return $__t_VSYNC
EndFunc   ;==>_VSync_Startup
Func _VSync_Shutdown()
	If Not IsDllStruct($__t_VSYNC) Then Return SetError(1, 1, False)
	Local $tObj, $tCall, $aResult
	If $__t_VSYNC.Tar Then
		$tObj = DllStructCreate("struct; ptr VTBL; endstruct; ", $__t_VSYNC.Tar)
		$tCall = DllStructCreate("struct; ptr[3]; endstruct; ", $tObj.VTBL)
		$aResult = DllCallAddress("int", DllStructGetData($tCall, 1, 3), "struct*", $__t_VSYNC.Tar) ;Release
	EndIf
	If $__t_VSYNC.Fac Then
		$tObj = DllStructCreate("struct; ptr VTBL; endstruct; ", $__t_VSYNC.Fac)
		$tCall = DllStructCreate("struct; ptr[3]; endstruct; ", $tObj.VTBL)
		$aResult = DllCallAddress("int", DllStructGetData($tCall, 1, 3), "struct*", $__t_VSYNC.Fac) ;Release
	EndIf
	GUIDelete($__t_VSYNC.Gui)
	DllClose($__t_VSYNC.Dll)
	$__t_VSYNC = Null
	Return True
EndFunc   ;==>_VSync_Shutdown
Func _VSync_Wait()
	If Not IsDllStruct($__t_VSYNC) Then Return SetError(1, 1, False)
	Local $tObj = DllStructCreate("struct; ptr VTBL; endstruct; ", $__t_VSYNC.Tar)
	Local $tCall = DllStructCreate("struct; ptr[50]; endstruct; ", $tObj.VTBL)
	DllCallAddress("int", DllStructGetData($tCall, 1, 49), "struct*", $__t_VSYNC.Tar) ;BeginDraw
	DllCallAddress("int", DllStructGetData($tCall, 1, 50), "struct*", $__t_VSYNC.Tar, "uint64*", 0, "uint64*", 0) ;EndDraw
	Return True
EndFunc   ;==>_VSync_Wait

Alles anzeigen

**Kanashius**

Bei mir läuft das mit 3-5% CPU Auslastung komplett flüssig.
(Intel Xeon CPU E3-1231 v3 (3.4GHz))

**Mars**

eukalyptus: Vielen Dank für die verbesserte Version (die sogar Errorhandling enhthält :D).

UEZ: Auf meinem Zweitrechner (Intel Q6600, GeForce GT630, Win8.1 x64) läuft jede Animation (meine 2 Beispiele und deins) ohne Einwände. Was ich aber bemerkt habe ist, dass es manchmal doch Probleme gibt, sofern man mehr als einen Bildschirm angeschlossen hat. Auf meinem Hauptrechner (i5 3570k, GTX260.216, Win8.1 x64) der wesentlich mehr Leistung hat ruckelt z.B. das GDI+ Beispiel von mir, deins konnte ich noch nicht testen, das hole ich aber nach sobald ich zu Hause bin.

Edit1: UEZ: In deinem Beispiel hast zu das Warten auf den VSync nach deinem Zeichenvorgang. Das Funktioniert mit BitBlt und einem nicht voll ausgelasteten Skript wahrscheinlich in den meisten Fällen. Sicherheitshalber ist die umgekehrte Reihenfolge aber besser (also vor den BitBlt in z112).

Edit2: wobei ich da auch etwas verwirrt bin... auf meinem kleinen Rechner funktionieren alle Beispiele absolut flüssig, egal ob ich das Warten vor- oder nachschalte. Auf meinem großen Rechner hat das aber einen Effekt...

Edit3: Der Test ergab folgendes:
2 Bildschirme: (Schneller Computer)
- GDI Skript (Rechteck), ruckelt ein wenig (zyklisch), kein Tearing (ist bei BitBlt auch ungewöhnlich), Last 1%
- GDI+ Skript (Kreis), ruckelt nicht, ab und zu Tearing (DrawImage braucht einfach manchmal 20ms+ da kann man nix machen), Last 4,5%
- GDI/GDI+ von UEZ, ruckelt ein wenig (zyklisch), kein Tearing, Last 5,5%
1 Bildschirm: (Schneller Computer)
- GDI Skript (Rechteck), ruckelt ein wenig (zufällig), kein Tearing
- GDI+ Skript, ruckelt nicht, kein Tearing (scheint flotter zu gehen, wenn nur 1 Bildschirm läuft ? seltsam...)
- GDI/GDI+ von UEZ, ruckelt ein wenig (zufällig), kein Tearing
1 Bildschirm: (Langsamer Computer)
- Alle Skripte, ruckelt nicht, kein Tearing. (das verstehe ich nicht, aber okay...)

Ich weiß nicht genau wie D2D beim VSync arbeitet. Entweder wird das Bild unmittelbar VOR dem Takt übermittelt (Grafikkartenintern geht das ja sehr schnell), und das Skript läuft weiter, obwohl der Takt erst in Bälde kommt, oder es wird auf den Takt gewartet und unmittelbar DANACH gezeichnet. Jedenfalls konnte ich das zufällige Ruckeln (1 Bildschirm) reduzieren, indem ich eine 0 bis 9999er For-Schleife nach _VSync_Wait() gepackt habe und anschließend den BitBlt durchgeführt habe. Ob das auf jedem Rechner klappt weiß ich nicht. Falls dem so ist müsste man nach dem Warten noch einen möglichst konstanten kurzen Recheneinschub einbauen und dann erst BitBlt benutzen.

UEZ: Ersetze bitte mal Folgendes in deinem Skript und schau ob es dann immernoch ruckelt:

AutoIt

$fRotX += 0.01
		$fRotY += 0.02
		_VSync_Wait()


		_GDIPlus_GraphicsDrawStringEx($hCanvas, "FPS: " & $iShowFPS, $hFont_FPS, $tLayout_FPS, $hFormat_FPS, $hBrush_FPS) ;draw background message text


		_WinAPI_BitBlt($hDC, 0, 0, $iW, $iH, $hDC_backbuffer, 0, 0, $SRCCOPY) ;blit drawn bitmap to GUI


		$iFPS += 1
		If $bExit Then ExitLoop
	Until False

Alles anzeigen

Die GraphicsDrawStringEx Funktion ist immer im Bereich von 0.2ms bis 0.3ms und stellt damit einen geeigneten Abstandhalter dar.

lg
M