Beiträge von Andy

[autoit]

#include <opencl_inc.au3>#include <opencl_easy.au3>;OpenCl kann benutzt werden, um rechenintensive, gut parallel zu verarbeitende Programme auf Grafikkarten der neueren Generation auszuführen.;Diese Grafikkarten haben eine GPU, welche aus hunderten von einzelnen Prozessoren besteht, die wiederum unabhängig voneinander parallel arbeiten können.;Die Hardware unterteilt sich in mehrere Compute-Units, die sich wiederum in Workgroups und diese wiederum in Workitems (Shader) unterteilen.;Man kann diese vielen Prozessoren (Shader) der GPU gleichzeitig nutzen, ohne eine komplizierte Threadverwaltung (wie bei einer CPU) zu verwenden.;OpenCl verteilt das programmtechnische "Problem" selbstständig auf die verfügbaren Ressourcen.;Wenn keine von OpenCl unterstützte GPU gefunden wird, kann eine geeignete CPU die Berechnungen übernehmen. Durch Verwendung von SIMD wird auch bei einer CPU der;verwendete Code stark beschleunigt!;Um OpenCl zu nutzen, wird ein sog. "Kernel" benötigt.;Der "Kernel" ist ein Programm, dass GLEICHZEITIG auf jedem der vielen verfügbaren Shader(Prozessoren in einer GPU) der Grafikkarte läuft. Die Verwaltung der parallel;ausgeführten Threads übernimmt OpenCl.;Die im Kernel verwendeten sog. Thread-ID´s verweisen auf die Daten im Eingangs- bzw. Ausgangspuffer.;Beispiel: Es sollen 1024 Floatzahlen aus dem Eingangspuffer gelesen, im Kernel(Thread) quadriert, und anschliessend in den Ausgangspuffer geschrieben werden.;Abhängig von der Hardware werden für (fast) jede zu quadrierende Zahl ein einzelner Thread erzeugt und einem Shader zugewiesen.;Dies geschieht automatisch! Man muss sich nicht um die Verwaltung dieser Threads kümmern.;Der Kernel mit der Thread-ID=1 quadriert die 1. Zahl im Eingangspuffer und schreibt sie in den Ausgangspufferan die 1. Stelle.;Der Kernel mit der Thread-ID=17 quadriert die 17. Zahl im Eingangspuffer und schreibt sie in den Ausgangspuffer an die 17. Stelle.;Der Kernel mit der Thread-ID=1022 quadriert die 1022. Zahl im Eingangspuffer und schreibt sie in den Ausgangspuffer an die 1022. Stelle.;usw, bis alle Threads abgearbeitet sind. Die Threads werden je nach Menge der verfügbaren Shader parallel verarbeitet!;Sind weniger Shader als Daten vorhanden, werden die Shader mehrmals nacheinander benutzt, mit jeweils anderer Thread-ID.;Wird eine geeignete Grafikkarte verwendet, arbeiten dort hunderte Shader parallel und sind zig- mal schneller als eine CPU!;;Der Kernel ist eine Funktion in C-Syntax, deren Funktionsparameter im Kernel verarbeitet werden.;Der Kernel wird entweder zur Laufzeit compiliert (wie hier im Beispiel) und auf die Shader übertragen, oder als vorkompilierter Kernel verarbeitet.;Der folgende Kernel hat als Funktionsparameter den Eingangspuffer und den Ausgangspuffer und einen Parameter, welcher die Anzahl der zu berechnenden;Quadratzahlen bestimmt. Die Puffer werden über ihre Pointer (Zeiger in den Speicherbereich) angesprochen, weitere Parameter;übergibt man entweder als Zeiger oder als Wert direkt....C-Versteher haben Vorteile^^;Im Compiler ist eine Syntaxanalyse des Kernels eingebaut, bei fehlerhaftem Kernel erscheint eine Info-Box mit Beschreibung des Fehlers!Global $KernelSource = "__kernel void quadrat( __global float* inputbuffer, __global float* outputbuffer, const unsigned int count)" & @CRLF & _ "{" & @CRLF & _ "int ThreadID = get_global_id(0);" & @CRLF & _ ;hier wird von OpenCl das zu bearbeitende Element zugewiesen "if(ThreadID < count)" & @CRLF & _ ;count kann benutzt werden, um weniger Daten zu berechnen, als Shader zur Verfügung stehen "outputbuffer[ThreadID] = inputbuffer[ThreadID] * inputbuffer[ThreadID];" & @CRLF & _;holt Element aus dem Eingangspuffer, berechnet Ergebnis und schreibt in den Ausgangspuffer "}";Nun muss OpenCl bzw. die Grafikkarte auf den Kernel vorbereitet werden:;Ich habe die folgenden EINFACHEN Funktionen geschrieben um das Prinzip von OpenCl zu verdeutlichen, die Funktionen haben es in sich....;Im einfachen Beispiel hier wird die erste gefundene Grafikkarte verwendet, wer mehrere Grafikkarten (und CPU´s) parallel verwenden möchte, sollte sich;in OpenCl einarbeiten^^;;Zunächst werden die verfügbaren Geräte(Devices) gesucht._CL_GetDevice("ALL") ;..oder CPU oder GPU, ermittelt das Gerät, auf dem die Berechnungen durchgeführt werden.;u.a. werden auch noch die OpenCl-spezifischen Variablen Context, CommandQueue, Program ermittelt, und der Kernel kompiliert.;Wird keine geeignete Grafikkarte gefunden, wird der Kernel mit SSE-Unterstützung kompiliert und auf der CPU (auf allen Cores) ausgeführt.;Die Puffer (Buffer) werden benutzt, um die Daten an die Grafikkarte zu übergeben oder von dort zurückzubekommen.;Es gibt Eingangs- und Ausgangspuffer, welche im Hauptspeicher als Struct abgebildet werden.;Diese Speicherbereiche MÜSSEN an 16-Byte aligned Speicheradressen liegen! Da align16 bei DllstructCreate() nicht zuverlässig funktioniert,;habe ich eine eigene Funktion geschrieben, _DllStructCreate16(), welche dafür sorgt, dass die Structs mit ihren Anfangsadressen entsprechend ausgerichtet sind.;Um im Beispiel 1024 Floatzahlen zu quadrieren, benötigen wir jeweils einen Puffer:;Der Eingangspuffer übergibt die Daten an den Kernel:;dazu wird im Hauptspeicher ein Bereich mit der Anzahl der Eingangsdaten beschrieben und dieser Bereich dann zur Grafikkarte transferiert$anzahl = 1024 ;Anzahl der Floatzahlen$input_buffer = _DllStructCreate16("float[" & $anzahl & "]");Rückgabe ist "Eine Variable für den Gebrauch in DllStruct-Aufrufen", sic (aus der Hilfe^^);der Puffer wird mit $anzahl zufälliger Floatzahlen gefülltFor $i = 1 To $anzahl DllStructSetData($input_buffer, 1, Random(1, 100), $i)Next;nun wird dieser Puffer für die Bearbeitung mit OpenCl verfügbar gemacht$CL_buffer_in = _CL_CreateBuffer($input_buffer);und die Daten aus dem Hauptspeicher werden in den Speicher der Grafikkarte geschrieben_CL_WriteBuffer($CL_buffer_in, $input_buffer) ;vom Hauptspeicher in die Grafikkarte;Ausgangspuffer, hier sollen die Quadratzahlen abgespeichert werden:$output_buffer = _DllStructCreate16("float[" & $anzahl & "]");Rückgabe ist "Eine Variable für den Gebrauch in DllStruct-Aufrufen";nun wird dieser Puffer für die Bearbeitung mit OpenCl verfügbar gemacht$CL_buffer_out = _CL_CreateBuffer($output_buffer);Man könnte auch nur einen Puffer für Ein-und Ausgabe verwenden....dann überschreiben die Ergebnisse die Eingangsdaten...;Jetzt werden die Funktionsparameter (Argumente) an alle Kernelprogramme übergeben;Die Funktionsparameter werden von 0 an durchnummeriert und der Parameter übergeben;Diese Funktion verwendet nur 4Byte grosse Parameter, also dword, int, uint, float usw!!!_CL_SetArg(0, "ptr*", $CL_buffer_in) ;Kernelparameter: __global float* inputbuffer erwartet das Handle des Eingangspuffers_CL_SetArg(1, "ptr*", $CL_buffer_out) ;Kernelparameter: __global float* outputbuffer erwartet das Handle des Ausgangspuffers_CL_SetArg(2, "uint*", 100) ;Kernelparameter: const unsigned int count kann die Anzahl der zu berechnenden Zahlen begrenzen!;Jetzt lassen wir alle Kernelprogramme auf allen verfügbaren Shadern gleichzeitig laufen, OpenCl verteilt die verfügbare Anzahl Shader automatisch!;Die THREADID im Kernel ist wie ein Index in einem Array, welcher auf die einzelnen Elemente (in diesem Fall im Puffer) zeigt.;Ist keine geeignete Grafikkarte vorhanden, wird die CPU mit allen Cores zur Berechnung verwendet!;Da in diesem Fall der Kernel ein mit SSE-Unterstützung kompiliertes C-Programm ist, wird so eine fast optimale Geschwindigkeit auf der CPU erreicht!;Wird eine geeignete Grafikkarte verwendet, arbeiten dort hunderte Shader parallel und sind zig- mal schneller als die CPU!$Global_Worksize = $anzahl ;die gesamte Anzahl der zu berechnenden Workitems$Local_Worksize = 0 ;Workitems/Workgroup, legt die Auslastung der Shader fest...( davon wird noch die Rede sein^^). Wenn 0, legt der Compiler einen Wert fest_CL_RunKernel($Global_Worksize, $Local_Worksize) ;liest die Anzahl Floatzahlen aus dem Eingangspuffer und schreibt das Quadrat dieser Zahlen in den Ausgangspuffer;die berechneten Daten stehen nun im Ausgangspuffer der Grafikkarte und können in den Hauptspeicher transferiert werden_CL_ReadBuffer($CL_buffer_out, $output_buffer) ;von der Grafikkarte in den Hauptspeicher;die Daten stehen nun in der Struct im Hauptspeicher und können von dort ausgelesen und angezeigt werdenFor $i = 1 To $anzahl $in = DllStructGetData($input_buffer, 1, $i) ;eingangspuffer $out = DllStructGetData($output_buffer, 1, $i) ;ausgangspuffer ConsoleWrite("Thread-ID: " & $i - 1 & " " & $in & " " & $out & @CRLF)Next;das wars schon.....

[/autoit]

[autoit]

#include <opencl_inc.au3>#include <opencl_easy.au3>#include <GUIConstantsEx.au3>#include <WinAPI.au3>#include <GDIConstants.au3>;der schon im ASM-Tut optimierte "Tunnelflug" hier in der einfachsten Version;ich bin nicht der C-Freak, bitte also um Nachsicht mit meinen Kernels, Verbesserungsvorschläge werden selbstverständlich umgesetzt^^Global $KernelSource = "__kernel void tunnelflug( __global int* output, const unsigned int width,const unsigned int height,const float stepx)" & @CRLF & _ "{" & @CRLF & _ "uint threadid = get_global_id(0);" & @CRLF & _ ;thread-id, d.h. jedes pixel von 1 bis b*h "float y = threadid/width;" & @CRLF & _ ;pixelkoordinaten "float x = threadid%width;" & @CRLF & _ ;pixelkoordinaten "float dy = (y / height) - 0.5f;" & @CRLF & _ ;...Berechnungen "float dx = (x / width) - 0.5f;" & @CRLF & _ "float wurzel = sqrt(dy * dy + dx * dx);" & @CRLF & _ "int tu = 203.718330624f * atan2(dy ,dx);" & @CRLF & _ "int tv = (((100 / wurzel) + stepx));" & @CRLF & _ "int t = (tu^tv)&255;" & @CRLF & _ ;farbe pixel "output[threadid] = 0xFF000000+(t<<16)+(t<<8)+t;" & @CRLF & _ ;Pixel schreiben 0xFFBBGGRR, BB=GG=RR=t "}";Daten$width = 256 * 3 ;breite und höhe der gui/grafik, die Anzahl der "Threads" sollte ein Vielfaches von 16 sein!$height = 256 * 3$step = 1.02 ;das ist die Schrittweite, um die der Tunnelflug ein Frame weiter gezeichnet wird$steps = 0 ;Beginn des Fluges...Opt("GUIOnEventMode", 1)$hgui = GUICreate("", $width, $height, 1, 1) ;GUI erstellen$hdc_gui = _WinAPI_GetDC($hgui) ;HDC holen zum blittenGUISetState()GUISetOnEvent($GUI_EVENT_CLOSE, "_Exit")AdlibRegister("_fps", 1000) ;FramesPerSecond$fps = 0;bitmap erzeugen, in $ptr_bitmap steht nach dem Funktionsaufruf der Pointer auf die PixeldatenLocal $ptr_bitmap, $hbmp_bitmap ;byref$hDC_bitmap = _CreateNewBmp32($width, $height, $ptr_bitmap, $hbmp_bitmap) ;DC, Pointer auf die Bitmapdaten und ein Handle für GDI+....eine eierlegende WollmilchsauGlobal $DATA_SIZE = $width * $height ;bildgröße=anzahl pixel (rgba)Global $NULL = 0;ab hier gehts mit OpenCl los;was wird gebraucht?;Buffer für Output der Daten in der Größe der Bitmap, also;Zunächst werden die verfügbaren Geräte(Devices) gesucht._CL_GetDevice("ALL") ;..oder CPU oder GPU, ermittelt das Gerät, auf dem die Berechnungen durchgeführt werden.;Puffer für die Bitmap$output_buffer = DllStructCreate("dword[" & $DATA_SIZE & "]", $ptr_bitmap);halleluja! bitmaps werden immer 16byte-aligned!$CL_buffer_out = _CL_CreateBuffer($output_buffer);Parameter an den Kernel übergeben_CL_SetArg(0, "ptr*", $CL_buffer_out)_CL_SetArg(1, "uint*", $width)_CL_SetArg(2, "uint*", $height)_CL_SetArg(3, "float*", $steps)$CL_DEBUGFLAG = 0 ;Debug-Ausgabe ausschalten, um Geschwindigkeit zu erhöhen;Schleife zur Anzeige für den TunnelflugWhile 1 ;endless loop... $steps += $step ;schrittweite für den nächsten frame erhöhen... _CL_SetArg(3, "float*", $steps) ;...und an kernel übergeben _CL_RunKernel($DATA_SIZE, 0) ;Kernel ausführen _CL_ReadBuffer($CL_buffer_out, $output_buffer);Puffer(alle Pixel) lesen _WinAPI_BitBlt($hdc_gui, 0, 0, $width, $height, $hDC_bitmap, 0, 0, $srccopy) ;Bitmap in die GUI blitten $fps += 1 ;Frames pro Sekunde zählenWEnd;...das wars schon^^Func _CreateNewBmp32($iwidth, $iheight, ByRef $ptr, ByRef $hbmp) ;erstellt leere 32-bit-Bitmap; Rückgabe DC und ptr und handle auf die Bitmapdaten ;by Andy Local $hcdc = _WinAPI_CreateCompatibleDC(0) ;Desktop-Kompatiblen DeviceContext erstellen lassen Local $tBMI = DllStructCreate($tagBITMAPINFO) ;Struktur der Bitmapinfo erstellen und Daten eintragen DllStructSetData($tBMI, "Size", DllStructGetSize($tBMI) - 4) ;Structgröße abzüglich der Daten für die Palette DllStructSetData($tBMI, "Width", $iwidth) DllStructSetData($tBMI, "Height", -$iheight) ;minus =standard = bottomup DllStructSetData($tBMI, "Planes", 1) DllStructSetData($tBMI, "BitCount", 32) ;32 Bit = 4 Bytes => AABBGGRR Local $adib = DllCall('gdi32.dll', 'ptr', 'CreateDIBSection', 'hwnd', 0, 'ptr', DllStructGetPtr($tBMI), 'uint', $DIB_RGB_COLORS, 'ptr*', 0, 'ptr', 0, 'uint', 0) $hbmp = $adib[0] ;hbitmap handle auf die Bitmap, auch per GDI+ zu verwenden $ptr = $adib[4] ;pointer auf den Anfang der Bitmapdaten, vom Assembler verwendet _WinAPI_SelectObject($hcdc, $hbmp) ;objekt hbitmap in DC Return $hcdc ;DC der Bitmap zurückgebenEndFunc ;==>_CreateNewBmp32Func _fps() WinSetTitle($hgui, "", $fps & " FPS") $fps = 0EndFunc ;==>_fpsFunc _Exit() ExitEndFunc ;==>_Exit;ein Kernel, der die SIMD-Fähigkeiten vor allem der CPU´s wesentlich besser ausnutzt!;es werden 4 Pixel gleichzeitig berechnet, auf der GPU bringt das nur ca. 10-20%, aber auf der CPU ca. 50-60% mehr Geschwindigkeit!;~ Global $KernelSource = "__kernel void tunnelflug( __global int* output, const unsigned int width,const unsigned int height,const float stepx)" & @CRLF & _;~ "{" & @CRLF & _;~ "uint threadid = get_global_id(0)*4;" & @CRLF & _ ;thread-id, d.h. jedes 4. pixel von 1 bis b*h;~ "float4 y = {threadid/width,(threadid+1)/width,(threadid+2)/width,(threadid+3)/width};" & @CRLF & _ ;pixelkoordinaten;~ "float4 x = {threadid%width,(threadid+1)%width,(threadid+2)%width,(threadid+3)%width};" & @CRLF & _ ;pixelkoordinaten;~ "float4 dy = (y / height) - 0.5f;" & @CRLF & _;...Berechnungen;~ "float4 dx = (x / width) - 0.5f;" & @CRLF & _;~ "float4 wurzel = sqrt(dy * dy + dx * dx);" & @CRLF & _;~ "float4 tu = 203.718330624f * atan2(dy ,dx);" & @CRLF & _;~ "float4 tv = (100 / wurzel) + stepx;" & @CRLF & _;~ "int4 tu1 = convert_int4(tu);" & @CRLF & _;~ "int4 tv1 = convert_int4(tv);" & @CRLF & _;~ "int4 t = (tu1^tv1)&255;" & @CRLF & _ ;farbe pixel;~ "output[threadid] = (4278190080+(t.s0<<16)+(t.s0<<8)+t.s0);" & @CRLF & _ ;Pixel schreiben 0xFFBBGGRR, BB=GG=RR=t;~ "output[threadid+1] = 4278190080+(t.s1<<16)+(t.s1<<8)+t.s1;" & @CRLF & _ ;Pixel schreiben 0xFFBBGGRR, BB=GG=RR=t;~ "output[threadid+2] = 4278190080+(t.s2<<16)+(t.s2<<8)+t.s2;" & @CRLF & _ ;Pixel schreiben 0xFFBBGGRR, BB=GG=RR=t;~ "output[threadid+3] = 4278190080+(t.s3<<16)+(t.s3<<8)+t.s3;" & @CRLF & _ ;Pixel schreiben 0xFFBBGGRR, BB=GG=RR=t;~ "}";Den Kernel nach oben kopieren und;CL_RunKernel($DATA_SIZE, 0) ;Kernel ausführen;ersetzen durch;CL_RunKernel($DATA_SIZE/4, 0) ;Kernel ausführen;da nur noch jedes vierte Workitem Daten aus dem Puffer holen muss!!!

[/autoit]

[autoit]

#include <opencl_inc.au3>#include <opencl_easy.au3>#include <GUIConstantsEx.au3>#include <WinAPI.au3>#include <GDIConstants.au3>;diesen Kernel zur Berechnung der Mandelbrotmenge habe ich mir "ausgeliehen" ^^Global $KernelSource = FileRead("mandelbrot_kernels.cl")ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $KernelSource = ' & $KernelSource & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console;Daten$width = 256 * 3 ;breite und höhe der gui/grafik, die Anzahl der "Threads" sollte ein Vielfaches von 16 sein!$height = $width ; einfacher^^$cx = -1.76853670262974 ;koordinaten des Flugziels$cy = -0.000753954632767545$stepx = 4 / $width$stepy = 4 / $width$maxiter = 120 ;Start IterationenOpt("GUIOnEventMode", 1)$hgui = GUICreate("", $width, $height, 1, 1) ;GUI erstellen$hdc_gui = _WinAPI_GetDC($hgui) ;HDC holen zum blittenGUISetState()GUISetOnEvent($GUI_EVENT_CLOSE, "_Exit")AdlibRegister("_fps", 1000) ;FramesPerSecond$fps = 0;bitmap erzeugen, in $ptr_bitmap steht nach dem Funktionsaufruf der Pointer auf die PixeldatenLocal $ptr_bitmap, $hbmp_bitmap ;byref$hDC_bitmap = _CreateNewBmp32($width, $height, $ptr_bitmap, $hbmp_bitmap) ;DC, Pointer auf die Bitmapdaten und ein Handle für GDI+....eine eierlegende WollmilchsauGlobal $DATA_SIZE = $width * $height ;bildgröße=anzahl pixel (rgba)Global $NULL = 0;ab hier gehts mit OpenCl los;Zunächst werden die verfügbaren Geräte(Devices) gesucht._CL_GetDevice("ALL") ;..oder CPU oder GPU, ermittelt das Gerät, auf dem die Berechnungen durchgeführt werden.;Puffer für die Bitmap$output_buffer = DllStructCreate("dword[" & $DATA_SIZE & "]", $ptr_bitmap);halleluja! bitmaps werden immer 16byte-aligned!$CL_buffer_out = _CL_CreateBuffer($output_buffer);Parameter an den Kernel übergeben_CL_SetArg(0, "ptr*", $CL_buffer_out)_CL_SetArg(6, "uint*", $width)_CL_SetArg(7, "uint*", 0)$CL_DEBUGFLAG = 0 ;Debug-Ausgabe ausschalten, um Geschwindigkeit zu erhöhenWhile $maxiter < 4000 ;so lange, bis float an seine Grenzen stößt $stepx *= 0.995 ;schrittweite des frames erhöhen... $maxiter /= 0.9985 ;Iterationen erhöhen _CL_SetArg(1, "float*", $cx - ($width / 2) * $stepx) _CL_SetArg(2, "float*", $cy - ($width / 2) * $stepx) _CL_SetArg(3, "float*", $stepx) _CL_SetArg(4, "float*", $stepx) _CL_SetArg(5, "uint*", $maxiter) _CL_RunKernel($DATA_SIZE / 4, 0) ;Kernel ausführen, da im Kernel SIMD verwendet wird, nur 1/4 der Threads nötig! _CL_ReadBuffer($CL_buffer_out, $output_buffer);Puffer(alle Pixel) lesen _WinAPI_BitBlt($hdc_gui, 0, 0, $width, $height, $hDC_bitmap, 0, 0, $srccopy) ;Bitmap in die GUI blitten $fps += 1 ;Frames pro Sekunde zählenWEndMsgbox(0,"OpenCl-Demo","Ende!");...das wars schon^^Func _CreateNewBmp32($iwidth, $iheight, ByRef $ptr, ByRef $hbmp) ;erstellt leere 32-bit-Bitmap; Rückgabe DC und ptr und handle auf die Bitmapdaten ;by Andy Local $hcdc = _WinAPI_CreateCompatibleDC(0) ;Desktop-Kompatiblen DeviceContext erstellen lassen Local $tBMI = DllStructCreate($tagBITMAPINFO) ;Struktur der Bitmapinfo erstellen und Daten eintragen DllStructSetData($tBMI, "Size", DllStructGetSize($tBMI) - 4) ;Structgröße abzüglich der Daten für die Palette DllStructSetData($tBMI, "Width", $iwidth) DllStructSetData($tBMI, "Height", -$iheight) ;minus =standard = bottomup DllStructSetData($tBMI, "Planes", 1) DllStructSetData($tBMI, "BitCount", 32) ;32 Bit = 4 Bytes => AABBGGRR Local $adib = DllCall('gdi32.dll', 'ptr', 'CreateDIBSection', 'hwnd', 0, 'ptr', DllStructGetPtr($tBMI), 'uint', $DIB_RGB_COLORS, 'ptr*', 0, 'ptr', 0, 'uint', 0) $hbmp = $adib[0] ;hbitmap handle auf die Bitmap, auch per GDI+ zu verwenden $ptr = $adib[4] ;pointer auf den Anfang der Bitmapdaten, vom Assembler verwendet _WinAPI_SelectObject($hcdc, $hbmp) ;objekt hbitmap in DC Return $hcdc ;DC der Bitmap zurückgebenEndFunc ;==>_CreateNewBmp32Func _fps() WinSetTitle($hgui, "", $fps & " FPS") $fps = 0EndFunc ;==>_fpsFunc _Exit() ExitEndFunc ;==>_Exit

[/autoit]

[autoit]

$user32 = DllOpen("user32.dll");dll-handle holen
$gdi32 = DllOpen("gdi32.dll")

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

$GUI = GUICreate("Apfelmännchen", 200,200) ;Fenster erstellen
$dc = GetDC(WinGetHandle($GUI)) ;Device Context des Fensters holen
GUISetState(@SW_SHOW) ;Fenster anzeigen

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

For $x=1 to 100 ;spalten
for $y=1 to 100 ;zeilen
$color= random(0,0xFFFFFF,1) ;zufallsfarbe (hier kommt der code fürs apfelmännchen hin^^)
setpixel($dc,$x,$y,$color) ;pixel setzen
next
next

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

while GUIGetMsg()<>-3 ;fenster schließen
wend

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

Func setpixel($dc, $x, $y, $color) ;pixel mit farbe an koordinaten setzen
DllCall($gdi32, "long", "SetPixel", "long", $dc, "long", $x, "long", $y, "long", $color)
EndFunc ;==>pix

[/autoit] [autoit][/autoit] [autoit]

Func GetDC($handle)
$dc = DllCall($user32, "int", "GetDC", "hwnd", $handle)
Return $dc[0]
EndFunc ;==>GetDC

[/autoit]