#pragma ist nebenbei dasselbe wie Andys #AutoIt3Wrapper, nur für die neueren AutoIt-Versionen. Eine komplette Übersicht über #pragma findest du hier: https://www.autoitscript.com/autoit3/docs/keywords/pragma.htm
Beiträge von chesstiger
-
-
Schau dir mal die Einstellungsmöglichkeiten von #pragma compile an. Das Version-Feld könnte das sein, was du suchst.
-
Ich nutze selber kein FreeBASIC, allerdings habe ich trotzdem eine Vermutung. Strings sind ja eigentlich nichts anderes als Arrays von Char-Elementen. Wenn man einen String an eine Funktion übergibt (und hier erleichtert AutoIt uns die Arbeit), übergibt man eigentlich nur die Adresse des ersten Char-Elements. Die Funktion liest dann ab dieser Adresse so lange den Speicher aus, bis sie auf das NUL-Zeichen (ASCII 0) stößt. FreeBASIC nimmt einem aber - vermutlich - nicht so viel Arbeit ab wie AutoIt. Dazu kommt auch, dass FreeBASIC generell zwischen Variablen und Pointern unterscheidet, AutoIt kennt ja keine Pointer. Daher würde ich vermuten, dass man aus FreeBASIC heraus auch wieder einen Pointer übergeben muss, den AutoIt dann intern als String interpretiert und weiterverarbeitet. Eine schnelle Google-Suche ergibt, dass dazu ein @ vor den Variablennamen gesetzt werden muss. Vielleicht ist's das ja, keine Ahnung.
Gruß
-
Man kann das grundsätzlich auf zwei Arten lösen... Einerseits kann man mit Programmierlogik und den normalen String-Funktionen arbeiten. Das ist gut verständlich und machbar. Eleganter ist es aber meistens, StringRegExp zu nutzen. Damit kann man sowas prinzipiell in einer Zeile abhandeln, das ist aber schwieriger, fast schon eine eigene Sprache. Ich würde dir daher erstmal die String-Funktionen empfehlen. Dabei würde sich dann die folgende Grundlogik anbieten, in Klammern immer ein paar Stichwörter: Datei lesen (FileRead), Array erstellen (StringSplit), in Schleife einen neuen Dateiinhalt erzeugen (For-Schleife) und in jedem dritten Schleifendurchlauf (Mod) eine Leerzeile einfügen, dann alles zurückschreiben (FileWrite).
-
-
Das wäre sicherlich auch sehr komfortabel mit regulären Ausdrücken zu lösen. Ich meine auch, mich an eine INI-UDF hier im Forum erinnern zu können... Ich bin mir aber nicht sicher, einen Link habe ich leider auch nicht zur Hand.
-
Ach ja, ich hatte das "Smoothing" aus dem Funktionsnamen einfach übersetzt, "smooth" => "weich". Damit war nicht das eigentliche Weichzeichnen gemeint, sondern weiches Zeichnen. Der Begriff Kantenglättung kam mir gerade nicht in den Sinn, deshalb hatte ich ein Synonym gesucht. Sobald ich wieder am PC bin, korrigiere ich das.

-
Freut mich, dass es euch gefällt.
Ich habe gerade den Teil mit den Bewegungen noch ein wenig um gängige Bewegungsformen und ihre Berechnung erweitert, parabelförmige Bewegungen kommen auch noch.
Ich werde wohl früher oder später auch noch etwas über Transformationen usw schreiben.
Gruß
-
Oh, ja, stimmt, danke.
Kleiner Begrifflichkeitsfehler, wird sofort korrigiert.
-
GDI+ Tutorial
Inhaltsverzeichnis
Einleitung
Grundlegendes Zeichnen
Linie
Rechteck
Kreis / Ellipse
Farben
Farben mischen
Füllen
Erweitertes Zeichnen
Weichzeichnen
Text
Bilder
Techniken
Doublebuffer
FPS-Anzeige
WM_PAINT
Animationen und ihre Mathematik
Simple Animation
Vollsynchrone Kreisbewegungen
Synchrone Kreisbewegungen mittels Vorzeichenwechsel
Synchrone Kreisbewegungen mittels Periodenverschiebung
Gleichmäßige Geradenbewegungen
Gebremste Geradenbewegungen
Realitätsnahe Geradenbewegung
SchlusswortEinleitung
So, hier stehen wir, am Anfang eines neuen Tutorials. Wir wollen uns hier mit den Grundlagen der "modernen" GDI+-Programmierung in AutoIt beschäftigen. Um es gleich vorweg zu nehmen: Ich bin kein "Meister" auf diesem Gebiet. Wenn ich mir anschaue, was Mars, eukalyptus oder UEZ so schreiben... Nein, da kann ich nicht mithalten.
Ich kann aber mit GDI+ umgehen, sogar vergleichsweise gut und ordentlich. Ich weiß, wie es funktioniert und wo ich etwas sinnvoll einsetzen kann. Leider gibt es kaum verständliche Anleitungen für diesen Teil der AutoIt-Programmierung, mal abgesehen von einem Uralt-Tutorial von Ubuntu aus dem Jahre 2010, in dem (meiner Meinung nach) ein paar wichtige Dinge unzureichend oder gar nicht angesprochen werden. Was jetzt natürlich keine direkte Kritik an dem Tutorial darstellen soll.
Ich dachte nur, es wäre Zeit, mal eine ordentliche Neuauflage zu produzieren.
Inhaltlich werden wir uns mit den grundlegenden GDI+-Funktionen auseinandersetzen, ein wenig "Good Practice" und "Bad Practice" anschauen und – als kleines Schmankerl – das ganze ein wenig mit der normalen Win32-API verbinden. Da die Code-Darstellung hier im Forum zur Zeit nicht ganz so optimal ist, sind einerseits alle Skripte in [ code ]-Tags gesetzt (bei AutoIt-Tags steht alles in einer Reihe), andererseits hängen alle Skripte nochmal als ZIP-Datei im Anhang. Damit sollten alle klarkommen.
Und so stehen wir hier, am Anfang eines neuen Tutorials.
Download der Skripte: Skripte.zip
Grundlegendes Zeichnen
Wir beschränken uns am Anfang zunächst auf die simpelsten Zeichenaktionen, die es gibt. Dazu ist aber natürlich erstmal ein Grundgerüst notwendig! Nun, um etwas unter Windows "sichtbar" zu machen, benötigt man in den meisten Fällen zunächst ein Fenster. Wir erstellen uns also ein kleines Fenster mit dazugehörigem Main-Loop:
Skript 1.1Code
Alles anzeigen$hWnd = GUICreate("GDI+", 400, 400) GUISetState() While True Switch GUIGetMsg() Case -3 Exit EndSwitch WendNun, das sieht doch schon ganz gut aus. Wenn wir unser Skript jetzt ausführen, haben wir eine schöne kleine Zeichenoberfläche. Nun, jetzt brauchen wir nur noch GDI+, nicht war? Dazu inkludieren wir die Datei GDIPlus.au3 in unser Skript. Um die Grafikengine GDI+ auch wirklich benutzen zu können, muss sie zunächst gestartet werden. Dabei wird dann die GDI+-DLL geöffnet und geladen, die auf jedem modernen Windows-System vorhanden sein müsste. Dazu nutzen wir die Funktion _GDIPlus_Startup(). An dieser Stelle könnten wir theoretisch den Pfad zur besagten DLL-Datei angeben, in der Praxis ist das aber eigentlich nicht relevant.
Skript 1.2Code
Alles anzeigen#include <GDIPlus.au3> $hWnd = GUICreate("GDI+", 400, 400) GUISetState() _GDIPlus_Startup() While True Switch GUIGetMsg() Case -3 Exit EndSwitch WendSo, wir wollen direkt lernen, ordentlich mit GDI+ umzugehen. Dazu gehört auch das sogenannte Resourcen-Managment. Konkret heißt das, dass wir innerhalb der GDI+-Funktionen die Möglichkeit haben, bestimmte Objekte oder Resourcen zu erstellen. Die entsprechenden Befehle tragen fast immer ein "Create" im Namen. Auch Funktionen, die eine Resource laden, erstellen prinzipiell solch ein Objekt. Der ordentliche Programmierer muss lernen, mit diesen Resourcen umzugehen und sie richtig zu verwalten. Alles andere kann sich negativ auf die Gesamtleistung des Skriptes auswirken. Konkret heißt das: Was man öffnet, muss man auch wieder schließen.
Wir fangen damit an, dass wir beim Beenden des Skriptes die GDI+-DLL wieder freigeben. Um den Überblick nicht zu verlieren, werden wir unsere "Aufräumarbeiten" in eine Funktion auslagern, die vor dem Beenden aufgerufen wird. In dieser Funktion steht dann erstmal nur der Aufruf von _GDIPlus_Shutdown. Ganz simpel.
Skript 1.3Code
Alles anzeigen#include <GDIPlus.au3> $hWnd = GUICreate("GDI+", 400, 400) GUISetState() _GDIPlus_Startup() While True Switch GUIGetMsg() Case -3 GDIPlusFree() Exit EndSwitch WEnd Func GDIPlusFree() _GDIPlus_Shutdown() EndFuncBisher haben wir aber nur eine GUI erstellt und GDI+ gestartet. Um etwas zeichnen zu können, müssen wir zunächst die GUI zu unserer "Leinwand" machen. Im GDI+-Slang nennt man diese Leinwand Graphics. Wenn wir eine Leinwand aus einem Fenster erzeugen wollen, nutzen wir dafür die Funktion _GDIPlus_GraphicsCreateFromHWND. Dieser Funktion übergeben wir natürlich das Handle unserer GUI, also den Rückgabewert von GUICreate. Wir speichern das ganze dann in der Variable $hGraphics. Da wir ja ordentlich programmieren, fügen wir auch gleich den Freigabebefehl zu unserer Aufräum-Funktion hinzu.
Wichtig ist, dass die Funktion _GDIPlus_GraphicsDispose vor der Freigabe der GDI+-DLL mittels _GDIPlus_Shutdown aufgerufen wird. Sonst wird der Vorgang fehlschlagen!
Skript 1.4Code
Alles anzeigen#include <GDIPlus.au3> $hWnd = GUICreate("GDI+", 400, 400) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) While True Switch GUIGetMsg() Case -3 GDIPlusFree() Exit EndSwitch WEnd Func GDIPlusFree() _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFunc
LinieSo, jetzt wollen wir mal den ersten richtigen Schritt tun, nämlich etwas zeichnen!
Dazu muss man noch wissen, dass wir uns auf unserer "Leinwand" mittels eines Koordinatensystems bewegen. Unsere GUI hat eine Größe von 400x400 Pixeln, die Ecke oben links (nicht unten links!!!) hat die Koordinaten (0|0). Daraus ergibt sich, dass die untere rechte Ecke die Koordinaten (399|399) besitzt. Dies sollte man bei seinen Berechnungen berücksichtigen. Wir widmen uns unserer Aufgabe: Eine Linie von der oberen linken Ecke in die Mitte zeichnen!
Wir machen uns zunächst klar, welche beiden Punkte wir denn mit der Linie verbinden wollen. Nun, zunächst natürlich den Punkt A mit den Koordinaten (0|0), also die linke obere Ecke. Doch wo liegt jetzt der Mittelpunkt? Man könnte meinen, dass der Mittelpunkt bei (200|200) liegt. Dem ist aber nicht so! Und warum? Das ist einfach erklärt: Wir nehmen einmal an, unser Koordinatensystem würde nicht auf beiden Achsen von 0 bis 399 laufen, sondern von 1 bis 400. In diesem Koordinatensystem würde der Mittelpunkt tatsächlich bei (200|200) liegen, unsere Linie würde von (1|1) nach (200|200) laufen. Wir wissen aber, dass unser eigentliches Koordinatensystem um genau eine Einheit verschoben ist, daher ziehen wir von jeder Koordinate genau 1 ab. Und schon landen wir bei den Werten (0|0) und (199|199).
Diese beiden Punkte können wir mittels der Funktion _GDIPlus_GraphicsDrawLine verbinden. Zuerst übergeben wir die Referenz zu der "Leinwand", also $hGraphics. Dann nacheinander die Koordinaten, in der Reihenfolge X1, Y1, X2 und Y2. Den letzten Parameter lassen wir erst einmal außen vor.
Skript 1.5Code
Alles anzeigen#include <GDIPlus.au3> $hWnd = GUICreate("GDI+", 400, 400) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) _GDIPlus_GraphicsDrawLine($hGraphics, 0, 0, 199, 199) While True Switch GUIGetMsg() Case -3 GDIPlusFree() Exit EndSwitch WEnd Func GDIPlusFree() _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFuncNun, eine Linie ist zwar ganz schön, aber doch irgendwie langweilig. GDI+ kennt noch ein paar weitere, komplexere Formen. Dazu zählen: Rechtecke, Ellipsen, Ellipsensegmente und unregelmäßige Polygone. Darüber hinaus gibt es auch noch eine Reihe von nicht geschlossenen Formen: Bögen, Kurven und Bezier-Kurven. Außerdem sind noch zwei Sonderformen vorhanden: Bilder und Texte. Eine ganze Reihe also! Wir werden uns exemplarisch mit Rechtecken, Ellipsen, Bildern und Texten außeinandersetzen. Bleiben wir zunächst im Reich der simplen Formen.
Rechteck
Das Rechteck wird ein wenig anders gehandhabt als die Linie. Anstatt zwei Koordinaten anzugeben, müssen wir hier nur eine Koordinate (die obere linke Ecke des Rechtecks) und jeweils Breite und Höhe angeben. Das eigentliche Zeichnen erledigt der Befehl _GDIPlus_GraphicsDrawRect, die Parameterreihenfolge ist weitestgehend logisch. Den letzten Parameter ignorieren wir wieder.
Zeichnen wir doch mal in unsere quadratische GUI mittig ein weiteres Quadrat mit den halben Seitenlängen, also 200x200 Pixel. Dazu zeichnen wir vom Startpunkt (99|99) aus.
Unsere altehrwürdige Linie können wir auch gleich wieder löschen, die brauchen wir nicht mehr.
Skript 1.6Code
Alles anzeigen#include <GDIPlus.au3> $hWnd = GUICreate("GDI+", 400, 400) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) _GDIPlus_GraphicsDrawRect($hGraphics, 99, 99, 200, 200) While True Switch GUIGetMsg() Case -3 GDIPlusFree() Exit EndSwitch WEnd Func GDIPlusFree() _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFuncIst es nicht wunderschön? Nun, es geht noch schöner!
Kreis / Ellipse
Nun wollen wir unserem Quadrat den letzten Schliff verpassen – wir packen einen Kreis in die Mitte! Dazu nutzen wir die Funktion _GDIPlus_GraphicsDrawEllipse.
Man könnte meinen, die Funktion würde die Koordinaten des Kreismittelpunktes erwarten. In der klassischen Mathematik wird ein Kreis schließlich über den Mittelpunkt und den Radius definiert. Hier aber ist eine andere Vorgehensweise gefragt. Da auch Ellipsen gezeichnet werden können müssen, reicht ein einfacher Radius nicht. Die Technik ist eigentlich ganz simpel: Man stelle sich ein Rechteck vor, welches genau um die Ellipse (bzw. Kreis) herum aufgebaut ist. Unser Kreis wird über dieses Rechteck definiert. Keine Angst, du wirst gleich sehen, was ich meine. Wir wollen den Kreis genau in das innere unseres Rechtecks zeichnen, wir können die Koordinaten und Größenangaben also 1:1 übernehmen.
Skript 1.7Code
Alles anzeigen#include <GDIPlus.au3> $hWnd = GUICreate("GDI+", 400, 400) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) _GDIPlus_GraphicsDrawRect($hGraphics, 99, 99, 200, 200) _GDIPlus_GraphicsDrawEllipse($hGraphics, 99, 99, 200, 200) While True Switch GUIGetMsg() Case -3 GDIPlusFree() Exit EndSwitch WEnd Func GDIPlusFree() _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFuncBeim Ausführen wird ganz schnell klar, was mit dem umgebenden Rechteck gemeint war, denke ich. Wenden wir uns nun dem unterdrückten, letzten Parameter der ...Draw-Funktionen zu!
Farben
Bisher sehen alle unsere Formen so aus, als ob sie mit einem dünnen Filzstift gezogen worden wären. Allesamt schwarz und 1 Pixel dick. Das wollen wir nun ändern. Innerhalb der GDI+-Engine haben wir nicht die Möglichkeit, die Farbe und Dicke beim Zeichnen direkt anzugeben. Diese Farben und Dicken werden zentral verwaltet, nämlich in Form von... Stiften, oder eben auf Englisch: Pens. So einen Stift erstellen wir ganz fix mit _GDIPlus_PenCreate. Der erste Parameter stellt die Farbe des Stiftes im AARRGGBB-Format dar. Wenn du nicht weißt, was für eine Farbe 0xFFFF00FF ist, dann solltest dich im Internet mal ein wenig über Farbdarstellungen mittels des Hexadezimalsystems schlau machen. Der zweite Parameter der Funktion gibt die Dicke des Stiftes in Pixel an. Der dritte Parameter wäre prinzipiell dafür gedacht, für die Breitenangabe eine andere Einheit wählen zu können. Mit der Standardeinstellung Pixel ist man aber eigentlich ganz gut bedient. Wir erstellen direkt zwei Stifte, denn wir wollen Kreis und Quadrat unterschiedlich färben: Der Kreis wird rot, das Quadrat blau! Dazu wählen wir noch eine ordentliche Dicke von 5 Pixeln. Die Rückgabewerte der Erstell-Funktionen übergeben wir schließlich als letzten Parameter an unsere jeweiligen Zeichenfunktionen.
ABER STOP!
Na, hast du dran gedacht? Wir haben gerade zwei Stifte erstellt, nun müssen wir auch dafür sorgen, dass sie am Ende wieder freigegeben werden. Dazu nutzen wir _GDIPlus_PenDispose.
Skript 1.8Code
Alles anzeigen#include <GDIPlus.au3> $hWnd = GUICreate("GDI+", 400, 400) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) $hPenRed = _GDIPlus_PenCreate(0xFFFF0000, 5) $hPenBlue = _GDIPlus_PenCreate(0xFF0000FF, 5) _GDIPlus_GraphicsDrawRect($hGraphics, 99, 99, 200, 200, $hPenBlue) _GDIPlus_GraphicsDrawEllipse($hGraphics, 99, 99, 200, 200, $hPenRed) While True Switch GUIGetMsg() Case -3 GDIPlusFree() Exit EndSwitch WEnd Func GDIPlusFree() _GDIPlus_PenDispose($hPenRed) _GDIPlus_PenDispose($hPenBlue) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFuncNun, wie man sieht, übermalen wir mit dem später gezeichneten Kreis einen Teil von dem Quadrat. Um den nächsten Schritt besser kenntlich zu machen, werden wir zuerst den Hintergrund unserer Leinwand wirklich weiss färben müssen. Um eine komplette Leinwand in einer Farbe einzufärben, können wir einfach die Funktion _GDIPlus_GraphicsClear benutzen. Diese Funktion akzeptiert ausnahmsweise direkt den Farbwert. Dieses Einfärben muss vor dem Zeichnen der Formen erfolgen, ansonsten würden wir diese komplett übermalen. Als Farbe nutzen wir ein komplett reines Weiss: 0xFFFFFFFF.
Skript 1.10Code
Alles anzeigen#include <GDIPlus.au3> $hWnd = GUICreate("GDI+", 400, 400) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) $hPenRed = _GDIPlus_PenCreate(0xFFFF0000, 5) $hPenBlue = _GDIPlus_PenCreate(0xFF0000FF, 5) _GDIPlus_GraphicsClear($hGraphics, 0xFFFFFFFF) _GDIPlus_GraphicsDrawRect($hGraphics, 99, 99, 200, 200, $hPenBlue) _GDIPlus_GraphicsDrawEllipse($hGraphics, 99, 99, 200, 200, $hPenRed) While True Switch GUIGetMsg() Case -3 GDIPlusFree() Exit EndSwitch WEnd Func GDIPlusFree() _GDIPlus_PenDispose($hPenRed) _GDIPlus_PenDispose($hPenBlue) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFunc
Farben mischenSo, wir wollen jetzt vermeiden, dass das Rechteck an den Schnittstellen komplett vom Kreis überdeckt wird. Dazu verändern wir einfach den Alpha-Wert unserer Farbstifte. Wenn dieser nicht auf 100% steht, dann überdecken sich die Farben nur teilweise, sprich: Sie vermischen sich. Um den Effekt besser kenntlich zu machen, vergrößern wir auch direkt unsere Stiftbreite von 5 Pixel auf 15 Pixel.
Skript 1.11Code
Alles anzeigen#include <GDIPlus.au3> $hWnd = GUICreate("GDI+", 400, 400) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) $hPenRed = _GDIPlus_PenCreate(0x7FFF0000, 15) $hPenBlue = _GDIPlus_PenCreate(0x7F0000FF, 15) _GDIPlus_GraphicsClear($hGraphics, 0xFFFFFFFF) _GDIPlus_GraphicsDrawRect($hGraphics, 99, 99, 200, 200, $hPenBlue) _GDIPlus_GraphicsDrawEllipse($hGraphics, 99, 99, 200, 200, $hPenRed) While True Switch GUIGetMsg() Case -3 GDIPlusFree() Exit EndSwitch WEnd Func GDIPlusFree() _GDIPlus_PenDispose($hPenRed) _GDIPlus_PenDispose($hPenBlue) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFunc
FüllenNun, bisher haben wir nur leere Kreise und Quadrate gezeichnet. Wir werden jetzt beides mit ein wenig Farbe füllen. GDI+ bietet dazu eine ganz neue Reihe von Funktionen an, die nicht mit _GDIPlus_GraphicsDraw... beginnen, sondern mit _GDIPlus_GraphicsFill..., was auch irgendwie logisch ist. Die Parameter der beiden Funktionsklassen unterscheiden sich kaum, nur kann man eben nicht mit einem Stift zeichnen! Dazu verlangt GDI+, dass wir den Pinsel benutzen, auf Englisch Brush. Dieser kennt natürlich keine Breite, denn Füllen ist Füllen. Somit akzeptiert _GDIPlus_BrushCreateSolid nur ein Argument, nämlich die Farbe im AARRGGBB-Format. Demnach müssen wir auch unsere Freigabe-Funktion ein wenig anpassen:
Skript 1.12Code
Alles anzeigen#include <GDIPlus.au3> $hWnd = GUICreate("GDI+", 400, 400) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) $hBrushRed = _GDIPlus_BrushCreateSolid(0x7FFF0000) $hBrushBlue = _GDIPlus_BrushCreateSolid(0x7F0000FF) _GDIPlus_GraphicsClear($hGraphics, 0xFFFFFFFF) _GDIPlus_GraphicsFillRect($hGraphics, 99, 99, 200, 200, $hBrushBlue) _GDIPlus_GraphicsFillEllipse($hGraphics, 99, 99, 200, 200, $hBrushRed) While True Switch GUIGetMsg() Case -3 GDIPlusFree() Exit EndSwitch WEnd Func GDIPlusFree() _GDIPlus_BrushDispose($hBrushRed) _GDIPlus_BrushDispose($hBrushBlue) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFuncWunderschön, nicht wahr?
Erweitertes Zeichnen
Weichzeichnen
Wenn man sich das Ergebnis des letzten Skriptes mal genau anschaut, dann entdeckt man, dass der Kreis ein wenig... Eckig aussieht. Er wirkt relativ rau gezeichnet. Das ist natürlich nicht ganz das, was wir uns wünschen. Das, was uns fehlt, ist das weiche Zeichnen. Dieses weiche Zeichnen können wir mittels _GDIPlus_GraphicsSetSmoothingMode aktivieren. Wir nutzen dafür den Smoothing Mode Nummer 2.
Skript 1.13Code
Alles anzeigen#include <GDIPlus.au3> $hWnd = GUICreate("GDI+", 400, 400) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) _GDIPlus_GraphicsSetSmoothingMode($hGraphics, 2) $hBrushRed = _GDIPlus_BrushCreateSolid(0x7FFF0000) $hBrushBlue = _GDIPlus_BrushCreateSolid(0x7F0000FF) _GDIPlus_GraphicsClear($hGraphics, 0xFFFFFFFF) _GDIPlus_GraphicsFillRect($hGraphics, 99, 99, 200, 200, $hBrushBlue) _GDIPlus_GraphicsFillEllipse($hGraphics, 99, 99, 200, 200, $hBrushRed) While True Switch GUIGetMsg() Case -3 GDIPlusFree() Exit EndSwitch WEnd Func GDIPlusFree() _GDIPlus_BrushDispose($hBrushRed) _GDIPlus_BrushDispose($hBrushBlue) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFuncDer Kreis sieht nun weich aus, wie Butter.

Text
Nachdem wir auch diese Hürde gemeistert haben, wollen wir nun eine kleine Botschaft übermitteln, d.h. ein wenig Text schreiben. Auch, wenn sich das nicht so schwer anhört, ist das Zeichnen von Text eine relativ aufwändige Sache. Wir beschränken uns zunächst auf einen simplen Text in schwarz in der oberen linken Ecke. Wir lassen auch die Standardschrift (Arial, Größe 10) so, wie sie ist. Die entsprechende Funktion trägt den Namen _GDIPlus_GraphicsDrawString.
Skript 1.14Code
Alles anzeigen#include <GDIPlus.au3> $hWnd = GUICreate("GDI+", 400, 400) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) _GDIPlus_GraphicsSetSmoothingMode($hGraphics, 2) $hBrushRed = _GDIPlus_BrushCreateSolid(0x7FFF0000) $hBrushBlue = _GDIPlus_BrushCreateSolid(0x7F0000FF) _GDIPlus_GraphicsClear($hGraphics, 0xFFFFFFFF) _GDIPlus_GraphicsFillRect($hGraphics, 99, 99, 200, 200, $hBrushBlue) _GDIPlus_GraphicsFillEllipse($hGraphics, 99, 99, 200, 200, $hBrushRed) $sText = "Das Runde muss ins Eckige." _GDIPlus_GraphicsDrawString($hGraphics, $sText, 0, 0) While True Switch GUIGetMsg() Case -3 GDIPlusFree() Exit EndSwitch WEnd Func GDIPlusFree() _GDIPlus_BrushDispose($hBrushRed) _GDIPlus_BrushDispose($hBrushBlue) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFuncNun, das war noch einfach. Allerdings erlaubt _GDIPlus_GraphicsDrawString nur rudimentäre Textzeichenoperationen. Die wirklich interessanten Sachen – Farbe, Ausrichtung, Endgröße – kann man nur mit _GDIPlus_GraphicsDrawStringEx kontrollieren. Dabei gelangen wir dann aber schon zu einer Funktion, die sehr aufwändig aufgerufen wird. Als Beispiel sollte man sich einmal die Definition von _GDIPlus_GraphicsDrawString anschauen, denn diese Funktion ruft letztendlich auch nur die erweiterte Variante auf. Dieses Wissen machen wir uns im Weiteren zunutze. Wir bewegen den Mauscursor in SciTE auf _GDIPlus_GraphicsDrawString und drücken Strg + J. Zumindest in der erweiterten SciTE-Variante springt man so zur Funktionsdefinition. Hier kopieren wir uns die Funktion und fügen sie in unserem eigenen Skript wieder ein. Nun haben wir einen Codeschnipsel, den wir als Grundlage benutzen können.
Skript 1.15ACode
Alles anzeigenFunc _GDIPlus_GraphicsDrawString($hGraphics, $sString, $nX, $nY, $sFont = "Arial", $nSize = 10, $iFormat = 0) Local $hBrush = _GDIPlus_BrushCreateSolid() Local $hFormat = _GDIPlus_StringFormatCreate($iFormat) Local $hFamily = _GDIPlus_FontFamilyCreate($sFont) Local $hFont = _GDIPlus_FontCreate($hFamily, $nSize) Local $tLayout = _GDIPlus_RectFCreate($nX, $nY, 0.0, 0.0) Local $aInfo = _GDIPlus_GraphicsMeasureString($hGraphics, $sString, $hFont, $tLayout, $hFormat) If @error Then Return SetError(@error, @extended, 0) Local $aResult = _GDIPlus_GraphicsDrawStringEx($hGraphics, $sString, $hFont, $aInfo[0], $hFormat, $hBrush) Local $iError = @error, $iExtended = @extended _GDIPlus_FontDispose($hFont) _GDIPlus_FontFamilyDispose($hFamily) _GDIPlus_StringFormatDispose($hFormat) _GDIPlus_BrushDispose($hBrush) Return SetError($iError, $iExtended, $aResult) EndFunc ;==>_GDIPlus_GraphicsDrawStringEs gilt nun, diese Funktion so zu verändern, dass wir eine Farbe, eine umschließende Box und eine (horizontale und vertikale) Ausrichtung angeben können. Die Farbe ist leicht gemacht, wir ersetzen den Parameter $iFormat durch den Parameter $iColor, als Standardwert wählen wir 0xFF000000 (volles schwarz). Diese Variable setzen wir direkt bei _GDIPlus_BrushCreateSolid ein. Damit könnten wir jetzt schon die Farbe verändern. Widmen wir uns der umschließenden Box. Das kann man sich in etwa wie bei den GUICtrlCreate-Funktionen vorstellen. Bei einem Label hat man auch die Möglichkeit, die Größe des umgebenden Kastens anzugeben. Wird er leer gelassen, wird die Größe automatisch angepasst. Das passiert hier auch, und zwar in der Zeile mit _GDIPlus_RectFCreate. Wir erweitern die Funktion um die Parameter $nW und $nH mit den Standardwerten 0.0. Zum Schluss fehlt noch die Ausrichtung, welche durch _GDIPlus_StringFormatSetAlignment (horizontal) bzw. _GDIPlus_StringFormatSetLineAlignment (vertikal) beeinflusst werden kann. Wieder fügen wir zwei Parameter hinzu. Diese Funktion müsst ihr noch nicht zur Gänze verstehen, es reicht, wenn ihr sie anwenden könnt.
Skript 1.15BCode
Alles anzeigenFunc _GDIPlus_GraphicsDrawStringBox($hGraphics, $sString, $nX, $nY, $sFont = "Arial", $nSize = 10, $iColor = 0xFF000000, $iAlignX = 0, $nW = 0.0, $iAlignY = 0, $nH = 0.0) Local $hBrush = _GDIPlus_BrushCreateSolid($iColor) Local $hFormat = _GDIPlus_StringFormatCreate(0) _GDIPlus_StringFormatSetAlign($hFormat, $iAlignX) _GDIPlus_StringFormatSetLineAlign($hFormat, $iAlignY) Local $hFamily = _GDIPlus_FontFamilyCreate($sFont) Local $hFont = _GDIPlus_FontCreate($hFamily, $nSize) Local $tLayout = _GDIPlus_RectFCreate($nX, $nY, $nW, $nH) Local $aInfo = _GDIPlus_GraphicsMeasureString($hGraphics, $sString, $hFont, $tLayout, $hFormat) If @error Then Return SetError(@error, @extended, 0) Local $aResult = _GDIPlus_GraphicsDrawStringEx($hGraphics, $sString, $hFont, $aInfo[0], $hFormat, $hBrush) Local $iError = @error, $iExtended = @extended _GDIPlus_FontDispose($hFont) _GDIPlus_FontFamilyDispose($hFamily) _GDIPlus_StringFormatDispose($hFormat) _GDIPlus_BrushDispose($hBrush) Return SetError($iError, $iExtended, $aResult) EndFunc ;==>_GDIPlus_GraphicsDrawStringBoxWenn wir die Funktion nun anwenden, sieht das ganze so aus:
Skript 1.15Code
Alles anzeigen#include <GDIPlus.au3> $hWnd = GUICreate("GDI+", 400, 400) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) _GDIPlus_GraphicsSetSmoothingMode($hGraphics, 2) $hBrushRed = _GDIPlus_BrushCreateSolid(0x7FFF0000) $hBrushBlue = _GDIPlus_BrushCreateSolid(0x7F0000FF) _GDIPlus_GraphicsClear($hGraphics, 0xFFFFFFFF) _GDIPlus_GraphicsFillRect($hGraphics, 99, 99, 200, 200, $hBrushBlue) _GDIPlus_GraphicsFillEllipse($hGraphics, 99, 99, 200, 200, $hBrushRed) $sText = "Das Runde muss ins Eckige." _GDIPlus_GraphicsDrawStringBox($hGraphics, $sText, 99, 99, "Arial", 10, 0xFF00FF00, 1, 200, 1, 200) While True Switch GUIGetMsg() Case -3 GDIPlusFree() Exit EndSwitch WEnd Func GDIPlusFree() _GDIPlus_BrushDispose($hBrushRed) _GDIPlus_BrushDispose($hBrushBlue) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFunc Func _GDIPlus_GraphicsDrawStringBox($hGraphics, $sString, $nX, $nY, $sFont = "Arial", $nSize = 10, $iColor = 0xFF000000, $iAlignX = 0, $nW = 0.0, $iAlignY = 0, $nH = 0.0) Local $hBrush = _GDIPlus_BrushCreateSolid($iColor) Local $hFormat = _GDIPlus_StringFormatCreate(0) _GDIPlus_StringFormatSetAlign($hFormat, $iAlignX) _GDIPlus_StringFormatSetLineAlign($hFormat, $iAlignY) Local $hFamily = _GDIPlus_FontFamilyCreate($sFont) Local $hFont = _GDIPlus_FontCreate($hFamily, $nSize) Local $tLayout = _GDIPlus_RectFCreate($nX, $nY, $nW, $nH) Local $aInfo = _GDIPlus_GraphicsMeasureString($hGraphics, $sString, $hFont, $tLayout, $hFormat) If @error Then Return SetError(@error, @extended, 0) Local $aResult = _GDIPlus_GraphicsDrawStringEx($hGraphics, $sString, $hFont, $aInfo[0], $hFormat, $hBrush) Local $iError = @error, $iExtended = @extended _GDIPlus_FontDispose($hFont) _GDIPlus_FontFamilyDispose($hFamily) _GDIPlus_StringFormatDispose($hFormat) _GDIPlus_BrushDispose($hBrush) Return SetError($iError, $iExtended, $aResult) EndFunc ;==>_GDIPlus_GraphicsDrawStringBoxWie man sieht, haben wir einen wunderbar zentrierten, grünen Text in unserem Quadratkreis.
Und ja, mir ist bewusst, dass ich das Thema ziemlich gekürzt habe. Aber mit dieser Funktion kommt man eigentlich immer gut klar.
Bilder
Zum Ende des Kapitels wollen wir noch schnell ein Bild laden und zeichnen. GDI+ unterstützt dabei laut Dokumentation eine Fülle an Bildformaten: BMP, DIB, RLE, JPG, JPEG, JPE, JFIF, GIF, EMF, WMF, TIF, TIFF, PNG und ICO. Wir werden uns mit dem Windows-7-Standardbild von einem Koala, welches im JPG-Format vorliegt, begnügen. Zunächst muss das Bild mittels _GDIPlus_ImageLoadFromFile geladen werden. Und jetzt muss man natürlich wieder an das Freigeben des Bildes denken, ein _GDIPlus_ImageDispose und das Problem ist erledigt. Nun, das Bild ist geladen, doch wie zeichnen wir es? Die Funktion _GDIPlus_GraphicsDrawImage erlaubt es uns, unter Angabe des Graphics-Handels, des Image-Handles und der oberen linken Koordinate das Bild zu zeichnen.
Skript 1.16Code
Alles anzeigen#include <GDIPlus.au3> $hWnd = GUICreate("GDI+", 400, 400) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) _GDIPlus_GraphicsSetSmoothingMode($hGraphics, 2) _GDIPlus_GraphicsClear($hGraphics, 0xFFFFFFFF) $sPath = "C:\Users\Public\Pictures\Sample Pictures\Koala.jpg" $hImage = _GDIPlus_ImageLoadFromFile($sPath) _GDIPlus_GraphicsDrawImage($hGraphics, $hImage, 0, 0) While True Switch GUIGetMsg() Case -3 GDIPlusFree() Exit EndSwitch WEnd Func GDIPlusFree() _GDIPlus_ImageDispose($hImage) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFuncWie man ganz klar sehen kann, wird das Bild in Originalgröße gezeichnet. Klar, wir haben ja auch keine Größenangabe gemacht. So erkennt man unseren Koala aber leider nicht. Dazu wiederum gibt es die Funktion _GDIPlus_GraphicsDrawImageRect, mit welcher wir ein umgebendes Rechteck angeben können. Wir füllen einmal unsere ganze GUI mit dem Koala:
Skript 1.17Code
Alles anzeigen#include <GDIPlus.au3> $hWnd = GUICreate("GDI+", 400, 400) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) _GDIPlus_GraphicsSetSmoothingMode($hGraphics, 2) _GDIPlus_GraphicsClear($hGraphics, 0xFFFFFFFF) $sPath = "C:\Users\Public\Pictures\Sample Pictures\Koala.jpg" $hImage = _GDIPlus_ImageLoadFromFile($sPath) _GDIPlus_GraphicsDrawImageRect($hGraphics, $hImage, 0, 0, 400, 400) While True Switch GUIGetMsg() Case -3 GDIPlusFree() Exit EndSwitch WEnd Func GDIPlusFree() _GDIPlus_ImageDispose($hImage) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFuncWenn man das Seitenverhältnis beibehalten wollte, könnte man es zuerst mit _GDIPlus_ImageGetWidth bzw. _GDIPlus_ImageGetHeight ermitteln, um es dann auf unsere 400 Pixel Breite zu beziehen.
Techniken
BufferVielleicht ist es dem ein oder anderen schon aufgefallen, vielleicht auch nicht... Jedenfalls, sobald man das Fenster einer unserer bisherigen Zeichnungen aus dem Bildschirm raus schiebt und zurückholt, fehlt ein Teil des Bildes. Auch beim Mini- und wieder Maximieren des Bildes tritt dieser Effekt auf. Wir können diesen unschönen Nebeneffekt vermeiden, indem wir das Bild immer wieder neu zeichnen. Dazu nutzen wir die Hauptschleife, wechseln aber der Einfachkeit halber in den OnEvent-Mode.
Skript 2.1Code
Alles anzeigen#include <GDIPlus.au3> Opt("GUIOnEventMode", True) $hWnd = GUICreate("GDI+", 400, 400) GUISetOnEvent(-3, OnExit) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) $hBrushBlue = _GDIPlus_BrushCreateSolid(0xFF0000FF) While True Sleep(10) _GDIPlus_GraphicsClear($hGraphics, 0xFFFFFFFF) _GDIPlus_GraphicsFillEllipse($hGraphics, 99, 99, 200, 200, $hBrushBlue) WEnd Func OnExit() GDIPlusFree() Exit EndFunc ;==>OnExit Func GDIPlusFree() _GDIPlus_BrushDispose($hBrushBlue) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFunc ;==>GDIPlusFreeNun, jetzt können wir das Fenster beliebig verschieben und minimieren, das Bild bleibt uns erhalten. Allerdings flackert das Bild jetzt, wenn man ein wenig darauf achtet. Das liegt daran, dass der von uns durchgeführte Zeichenvorgang zu aufwändig ist. Wenn man ihn zu schnell wiederholt, sieht man irgendwann den Zeichenvorgang. Das wollen wir natürlich vermeiden. Die bekannteste Technik, dies zu erreichen, trägt den Namen Buffering. Dabei zeichnen wir unser Bild in ein zweites, unsichtbares Graphics, welches dann ganz am Ende mit einem Schlag in das sichtbare Graphics kopiert wird. Konkret nutzen wir zuerst die Funktion _GDIPlus_BitmapCreateFromGraphics, um von unserem vorhandenen Graphics eine Kopie als Bitmap zu erhalten. Dabei müssen wir zuerst (!) die Bildgröße angeben (400x400), danach das Handle des Graphics. Von unserer erzeugten Bitmap holen wir uns dann mittels _GDIPlus_ImageGetGraphicsContext wieder einen Graphics-Kontext. Somit können wir auf die Kopie von unserer Bitmap zeichnen. Perfekt!
Von nun an müssen sich alle Zeichenoperationen auf diese Kopie beziehen, außerdem muss am Schleifenende die Bitmap auf unser Haupt-Graphics gezeichnet werden. Dazu nutzen wir das bereits bekannte _GDIPlus_GraphicsDrawImage. Natürlich dürfen wir auch nicht vergessen, dass wir die erzeugte Bitmap sowie das zweite Graphics wieder freigeben müssen.
Skript 2.2Code
Alles anzeigen#include <GDIPlus.au3> Opt("GUIOnEventMode", True) $hWnd = GUICreate("GDI+", 400, 400) GUISetOnEvent(-3, OnExit) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) $hGraphicsBMP = _GDIPlus_BitmapCreateFromGraphics(400, 400, $hGraphics) $hBuffer = _GDIPlus_ImageGetGraphicsContext($hGraphicsBMP) $hBrushBlue = _GDIPlus_BrushCreateSolid(0xFF0000FF) While Sleep(10) _GDIPlus_GraphicsClear($hBuffer, 0xFFFFFFFF) _GDIPlus_GraphicsFillEllipse($hBuffer, 99, 99, 200, 200, $hBrushBlue) _GDIPlus_GraphicsDrawImage($hGraphics, $hGraphicsBMP, 0, 0) ;draw buffer WEnd Func OnExit() GDIPlusFree() Exit EndFunc ;==>OnExit Func GDIPlusFree() _GDIPlus_BrushDispose($hBrushBlue) _GDIPlus_BitmapDispose($hGraphicsBMP) _GDIPlus_GraphicsDispose($hBuffer) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFunc ;==>GDIPlusFreeFPS-Anzeige
Sicherlich kennen die meisten von euch die FPS-Anzeige aus manchen Spielen. Wir werden jetzt in das Bild vom blauen Kreis eine FPS-Anzeige implementieren. "FPS" heißt eigentlich nur "Frames Per Second", sprich: Wie viele Bilder pro Sekunde gezeichnet werden. In unserem Fall heißt das, dass wir rausfinden müssen, wie oft in der Sekunde unsere Hauptschleife durchlaufen wird. In AutoIt wird das typischerweise mit AdlibRegister umgesetzt. Wir lassen in der Schleife eine Variable (FramesPerSecond) oben links auf unser Graphics zeichnen. Weiterhin addieren wir pro Schleifendurchlauf 1 zu einer anderen Variable (CurrentFrameCount). Einmal jede Sekunde lassen wir dann pro AdlibRegister den aktuellen Wert von CurrentFrameCount in FramesPerSecond übertragen und setzen CurrentFrameCount zurück auf 0. So einfach funktioniert unsere FPS-Anzeige.
Dabei muss aber gesagt werden, dass das Sleep(10), welches die CPU-Last begrenzen soll, auch unseren FPS-Wert beeinflusst bzw. begrenzt. Auf meinem Rechner schafft das Skript 100 FPS, wer jetzt ein wenig rumrechnet, erkennt, dass 100 FPS * 10ms = 1 Sekunde aufgeht. Das heißt, dass das Zeichnen an sich extrem wenig Zeit in Anspruch nimmt.
Skript 2.3Code
Alles anzeigen#include <GDIPlus.au3> Opt("GUIOnEventMode", True) $hWnd = GUICreate("GDI+", 400, 400) GUISetOnEvent(-3, OnExit) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) $hGraphicsBMP = _GDIPlus_BitmapCreateFromGraphics(400, 400, $hGraphics) $hBuffer = _GDIPlus_ImageGetGraphicsContext($hGraphicsBMP) $hBrushBlue = _GDIPlus_BrushCreateSolid(0xFF0000FF) $iFPS = 0 ;FramesPerSecond $iFrames = 0 ;CurrentFrameCount AdlibRegister(FPS, 1000) While Sleep(10) _GDIPlus_GraphicsClear($hBuffer, 0xFFFFFFFF) _GDIPlus_GraphicsFillEllipse($hBuffer, 99, 99, 200, 200, $hBrushBlue) _GDIPlus_GraphicsDrawString($hBuffer, "FPS: " & $iFPS, 0, 0) _GDIPlus_GraphicsDrawImage($hGraphics, $hGraphicsBMP, 0, 0) ;draw buffer $iFrames += 1 WEnd Func FPS() $iFPS = $iFrames $iFrames = 0 EndFunc Func OnExit() GDIPlusFree() Exit EndFunc ;==>OnExit Func GDIPlusFree() _GDIPlus_BrushDispose($hBrushBlue) _GDIPlus_BitmapDispose($hGraphicsBMP) _GDIPlus_GraphicsDispose($hBuffer) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFunc ;==>GDIPlusFree
WM_PAINT
Nun, wir haben gesehen, dass wir das Verschwinden unserer Zeichnung durch Neuzeichnen in einer Schleife verhindern können. Das ist auch die Lösung, die man meistens in der AutoIt-Szene sieht. Allerdings kommt jetzt das große ABER! Sofern wir ein bewegtes Bild zeichnen, ist diese Technik voll und ganz berechtigt, denn jedes Frame ist anders. Wenn wir aber ein unbewegtes Bild zeichnen, wie in Skript 2.2, dann verschwenden wir damit nur Rechenpower, weil unser Bild andauernd neugezeichnet wird, obwohl es noch vorhanden ist. Auch, wenn es gar nicht mehr zu sehen ist, wird weitergezeichnet. Das ist natürlich alles andere als optimal. Deshalb stellt Windows uns auch eine Möglichkeit zur Verfügung, um dieses Problem zu umgehen. Windows teilt jedem Fenster gewisse Events über die Fensternachrichten (Window Messages) mit, auf die jenes dann reagieren kann. Eine dieser Nachrichten trägt den Namen WM_PAINT. Das Betriebssystem sendet diese Nachricht an ein Fenster, wenn ein Neuzeichnen nötig ist. Das hört sich ja schon wesentlich besser an, nicht? AutoIt gibt uns eine einfache Funktion an die Hand, mit der wir WM_PAINT leicht abfangen können. Sie trägt den Namen GUIRegisterMsg. Wir registrieren für die Konstante $WM_PAINT (WindowsConstants.au3) eine Callback-Funktion, die aufgerufen wird, sobald die Nachricht empfangen wird. Diese Funktion muss bestimmte Merkmale erfüllen, hinsichtlich der Anzahl der Parameter und dem Rückgabewert. Durch die Rückgabe von $GUI_RUNDEFMSG (GUIConstants.au3) wird die Nachrichtenverarbeitung fortgesetzt, sprich der interne Handler für WM_PAINT greift nach unserer Funktion. Das ist für ein fehlerfreies Arbeiten unseres Programmes extrem wichtig.
In unserer WM_PAINT-Funktion führen wir jetzt einen Teil aus unserem eigentlichen Zeichenvorgang aus, nämlich das Übertragen des Buffers auf das Haupt-Graphics. Den restlichen Zeichenvorgang verlegen wir aus der Schleife heraus vor die Schleife. Somit wird unser Bild einmal komplett aufgebaut und gezeichnet, danach nur noch kopiert, wenn es nötig ist. Ganz einfach, nicht? Damit unsere WM_PAINT-Funktion auch fehlerfrei arbeitet, ist es wichtig, dass das Registrieren von WM_PAINT erst nach dem Zeichnen unseres Hauptbildes geschieht. Was soll sonst kopiert werden? Um uns einen unnötigen Aufruf zu ersparen, machen wir das Fenster erst nach dem Registrieren sichtbar. So wird gewährleistet, dass unsere Funktion schon beim ersten Zeichnen des Fensters greift.
Skript 2.5C
Alles anzeigen#include <GDIPlus.au3> #include <GUIConstants.au3> #include <WindowsConstants.au3> Opt("GUIOnEventMode", True) $hWnd = GUICreate("GDI+", 400, 400) GUISetOnEvent(-3, OnExit) _GDIPlus_Startup() $hBrushBlue = _GDIPlus_BrushCreateSolid(0xFF0000FF) $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) _GDIPlus_GraphicsSetSmoothingMode($hGraphics, 2) $hGraphicsBMP = _GDIPlus_BitmapCreateFromGraphics(400, 400, $hGraphics) $hBuffer = _GDIPlus_ImageGetGraphicsContext($hGraphicsBMP) _GDIPlus_GraphicsClear($hBuffer, 0xFFFFFFFF) _GDIPlus_GraphicsFillEllipse($hBuffer, 99, 99, 200, 200, $hBrushBlue) GUIRegisterMsg($WM_PAINT, OnPaint) GUISetState() While True Sleep(10) WEnd Func OnPaint($hWnd, $iMsg, $iWParam, $iLParam) _GDIPlus_GraphicsDrawImage($hGraphics, $hGraphicsBMP, 0, 0) ;draw buffer Return $GUI_RUNDEFMSG EndFunc Func OnExit() GDIPlusFree() Exit EndFunc ;==>OnExit Func GDIPlusFree() _GDIPlus_BrushDispose($hBrushBlue) _GDIPlus_BitmapDispose($hGraphicsBMP) _GDIPlus_GraphicsDispose($hBuffer) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFunc ;==>GDIPlusFreeBewegungen und ihre Mathematik
Simple Bewegung
Nun, wenn wir schon eine FPS-Anzeige haben, wollen wir doch auch mal unseren Kreis bewegen. Am einfachsten lässt sich eine simple, gleichmäßige Kreisbewegung realisieren. Ich gehe davon aus, dass jeder Leser mit den trigonometrischen Funktionen vertraut ist. Ich hoffe es zumindest. Ich schreibe trotzdem nochmal die vollendeten Formeln auf:
x = x[Drehpunkt] – Kreisradius + Drehradius * sin(alpha)
y = y[Drehpunkt] – Kreisradius + Drehradius * cos(alpha)
alpha ist dabei der Winkel, der bestimmt, an welchem Punkt der Drehung wir uns momentan befinden. Dieser Winkel wird fortlaufend erhöht und bei 360° wieder auf 0° zurückgesetzt.
Der Drehradius ist der Radius, mit dem der Kreis um den Mittelpunkt rotieren soll.
Der Kreisradius ist der bekannte Radius des Kreises.
Die Drehpunktkoordinate ist die jeweilige Koordinate des Drehpunktes.
Außerdem ist es nötig, den Winkel vor der Rechnung mit Sinus und Cosinus ins Bogenmaß (Radiant) umzurechnen, da die AutoIt-Funktionen Winkelangaben in Grad (Degree) nicht akzeptieren. Diese Umrechnung folgt der Formel rad = deg * (PI / 180).
Skript 3.1Code
Alles anzeigen#include <GDIPlus.au3> Opt("GUIOnEventMode", True) $hWnd = GUICreate("GDI+", 400, 400) GUISetOnEvent(-3, OnExit) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) $hGraphicsBMP = _GDIPlus_BitmapCreateFromGraphics(400, 400, $hGraphics) $hBuffer = _GDIPlus_ImageGetGraphicsContext($hGraphicsBMP) _GDIPlus_GraphicsSetSmoothingMode($hBuffer, 2) $hBrushBlue = _GDIPlus_BrushCreateSolid(0xFF0000FF) $nDeg2Rad = 3.141592654/180 $iAngle = 0 $iFPS = 0 ;FramesPerSecond $iFrames = 0 ;CurrentFrameCount AdlibRegister(FPS, 1000) While Sleep(10) _GDIPlus_GraphicsClear($hBuffer, 0xFFFFFFFF) _GDIPlus_GraphicsFillEllipse($hBuffer, 199 - (100/2) + 100 * Sin($iAngle*$nDeg2Rad), 199 - (100/2) + 100 * Cos($iAngle*$nDeg2Rad), 100, 100, $hBrushBlue) $iAngle += 1 If $iAngle >=360 Then $iAngle = 0 _GDIPlus_GraphicsDrawString($hBuffer, "FPS: " & $iFPS, 0, 0) _GDIPlus_GraphicsDrawImage($hGraphics, $hGraphicsBMP, 0, 0) ;draw buffer $iFrames += 1 WEnd Func FPS() $iFPS = $iFrames $iFrames = 0 EndFunc Func OnExit() GDIPlusFree() Exit EndFunc ;==>OnExit Func GDIPlusFree() _GDIPlus_BrushDispose($hBrushBlue) _GDIPlus_BitmapDispose($hGraphicsBMP) _GDIPlus_GraphicsDispose($hBuffer) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFunc ;==>GDIPlusFreeUnd voilá, unsere Kugel bewegt sich kreisförmig. Bei mir erreicht dieses Skript immer noch 100 FPS. Wer mag, kann testweise das Sleep(10) im Schleifenkopf durch ein True ersetzen. Somit wird die Framerate nur noch durch die Leistung des Computers begrenzt. Mein Mittelklassensystem erreicht so immerhin noch 480 FPS.

Vollsynchrone Kreisbewegungen
So, wir haben einen großen, sich bewegenden, blauen Kreis. Wir wollen daraus jetzt einen blauen Kreis mit einem schwarzen Rand machen. Dieser Rand muss sich natürlich vollsynchron mit dem Kreis bewegen. Dazu nutzen wir unsere GDI+-Grundlagen und zeichnen an den selben Koordinaten mittels _GDIPlus_GraphicsDrawEllipse einen schwarzen, hohlen Kreis mit derselben Größe. Damit wir einen 3px dicken Rand bekommen, müssen wir natürlich noch einen neuen Stift erstellen. Dazu lagern wir dann auch unsere Koordinatenberechnungen in eine Variable aus.
Skript 3.2Code
Alles anzeigen#include <GDIPlus.au3> Opt("GUIOnEventMode", True) $hWnd = GUICreate("GDI+", 400, 400) GUISetOnEvent(-3, OnExit) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) $hGraphicsBMP = _GDIPlus_BitmapCreateFromGraphics(400, 400, $hGraphics) $hBuffer = _GDIPlus_ImageGetGraphicsContext($hGraphicsBMP) _GDIPlus_GraphicsSetSmoothingMode($hBuffer, 2) $hBrushBlue = _GDIPlus_BrushCreateSolid(0xFF0000FF) $hPenBorder = _GDIPlus_PenCreate(0xFF000000, 3) $nDeg2Rad = 3.141592654/180 $iAngle = 0 $iFPS = 0 ;FramesPerSecond $iFrames = 0 ;CurrentFrameCount AdlibRegister(FPS, 1000) While Sleep(10) ;/True _GDIPlus_GraphicsClear($hBuffer, 0xFFFFFFFF) $nX = 199 - (100/2) + 100 * Sin($iAngle*$nDeg2Rad) $nY = 199 - (100/2) + 100 * Cos($iAngle*$nDeg2Rad) _GDIPlus_GraphicsFillEllipse($hBuffer, $nX, $nY, 100, 100, $hBrushBlue) _GDIPlus_GraphicsDrawEllipse($hBuffer, $nX, $nY, 100, 100, $hPenBorder) $iAngle += 1 If $iAngle >=360 Then $iAngle = 0 _GDIPlus_GraphicsDrawString($hBuffer, "FPS: " & $iFPS, 0, 0) _GDIPlus_GraphicsDrawImage($hGraphics, $hGraphicsBMP, 0, 0) ;draw buffer $iFrames += 1 WEnd Func FPS() $iFPS = $iFrames $iFrames = 0 EndFunc Func OnExit() GDIPlusFree() Exit EndFunc ;==>OnExit Func GDIPlusFree() _GDIPlus_PenDispose($hPenBorder) _GDIPlus_BrushDispose($hBrushBlue) _GDIPlus_BitmapDispose($hGraphicsBMP) _GDIPlus_GraphicsDispose($hBuffer) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFunc ;==>GDIPlusFreeSiehe da, es hat funktioniert. Theoretisch bewegen sich jetzt schon zwei Objekte in unser Animation, Rahmen und Füllung. Machen wir weiter.
Synchrone Kreisbewegungen mittels Vorzeichenwechsel
So, nun wollen wir zwei Objekte unterschiedlich bewegen. Wir wählen dafür – um keine neue Berechnung aufstellen zu müssen – zwei Kreise, die in je eine Richtung kreisen. Dazu behalten wir unseren blauen Kreis bei, fügen aber noch einen roten hinzu. Die Berechnung können wir fast 1:1 übernehmen, für die Bewegung in die andere Richtung ist lediglich ein Vorzeichenwechsel in der jeweiligen trigonometrischen Funktion nötig: Aus sin(x) wird also sin(-x).
Weil der Effekt so schöner ist, schrauben wir die Deckkraft der Farben noch ein wenig runter. Nehmen wir 0xA7FF0000 und 0xA70000FF.
Skript 3.3Code
Alles anzeigen#include <GDIPlus.au3> Opt("GUIOnEventMode", True) $hWnd = GUICreate("GDI+", 400, 400) GUISetOnEvent(-3, OnExit) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) $hGraphicsBMP = _GDIPlus_BitmapCreateFromGraphics(400, 400, $hGraphics) $hBuffer = _GDIPlus_ImageGetGraphicsContext($hGraphicsBMP) _GDIPlus_GraphicsSetSmoothingMode($hBuffer, 2) $hBrushRed = _GDIPlus_BrushCreateSolid(0xA7FF0000) $hBrushBlue = _GDIPlus_BrushCreateSolid(0xA70000FF) $hPenBorder = _GDIPlus_PenCreate(0xFF000000, 3) $nPi = 3.141592654 $nDeg2Rad = $nPi/180 $iAngle = 0 $iFPS = 0 ;FramesPerSecond $iFrames = 0 ;CurrentFrameCount AdlibRegister(FPS, 1000) While Sleep(10) ;/True _GDIPlus_GraphicsClear($hBuffer, 0xFFFFFFFF) $nX1 = 199 - (100/2) + 100 * Sin($iAngle*$nDeg2Rad) $nY1 = 199 - (100/2) + 100 * Cos($iAngle*$nDeg2Rad) $nX2 = 199 - (100/2) + 100 * Sin(-$iAngle*$nDeg2Rad) $nY2 = 199 - (100/2) + 100 * Cos(-$iAngle*$nDeg2Rad) _GDIPlus_GraphicsFillEllipse($hBuffer, $nX1, $nY1, 100, 100, $hBrushBlue) _GDIPlus_GraphicsDrawEllipse($hBuffer, $nX1, $nY1, 100, 100, $hPenBorder) _GDIPlus_GraphicsFillEllipse($hBuffer, $nX2, $nY2, 100, 100, $hBrushRed) _GDIPlus_GraphicsDrawEllipse($hBuffer, $nX2, $nY2, 100, 100, $hPenBorder) $iAngle += 1 If $iAngle >=360 Then $iAngle = 0 _GDIPlus_GraphicsDrawString($hBuffer, "FPS: " & $iFPS, 0, 0) _GDIPlus_GraphicsDrawImage($hGraphics, $hGraphicsBMP, 0, 0) ;draw buffer $iFrames += 1 WEnd Func FPS() $iFPS = $iFrames $iFrames = 0 EndFunc Func OnExit() GDIPlusFree() Exit EndFunc ;==>OnExit Func GDIPlusFree() _GDIPlus_PenDispose($hPenBorder) _GDIPlus_BrushDispose($hBrushRed) _GDIPlus_BrushDispose($hBrushBlue) _GDIPlus_BitmapDispose($hGraphicsBMP) _GDIPlus_GraphicsDispose($hBuffer) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFunc ;==>GDIPlusFreeSynchrone Kreisbewegungen mittels Periodenverschiebung
Unser Ziel ist es nun, drei (!) Kugeln mit immer gleichem Abstand zueinander in einer Richtung auf unserer Kreisbahn zu bewegen. Prinzipiell könnte man jetzt einfach mehrere Zählervariablen a la $iAngle verwenden. Das ist aber nicht die feine englische Art. Wir bedienen uns einfach der Mathematik der trigonometrischen Funktionen. Für den einen oder anderen könnte diese Skizze hier bei den folgenden Erklärungen eine Hilfe sein.
Wir wissen, dass die Sinuskurve eine simple Kreisbewegung darstellt. Dieses Wissen haben wir uns auch schon zur Nutze gemacht. Den Bereich von -5 bis 5 auf der verlinkten Skizze nennen wir eine Periode. Nach dieser Periode wiederholt sich dasselbe immer wieder. Eine Periode ist also eine komplette Drehung um 360° oder im Bogenmaß um 2PI. Unser Ziel ist es nun, diese Periode ein wenig zu verschieben. Das heißt, wir müssen unsere Drehfunktionen so anpassen, dass sie auf diesem Graphen versetzt beginnen. Da wir einen gleichmäßigen Abstand haben wollten, müssen wir den ersten Graphen einfach bei 0° beginnen lassen, also keine Veränderung vornehmen. Den zweiten Graphen verschieben wir dann durch die Addition von 120° ein wenig nach rechts, der Dritte wird dann demnach um 240° verschoben.
Kleine Bemerkung nebenbei, dem geneigten Elektrotechniker wird diese Verschiebung durchaus bekannt vorkommen. Die Phasen des Drehstroms sind auch jeweils um 120° verschoben. Daher findet man hier auch eine anschauliche Darstellung der Verschiebung. Das ganze Skript sieht dann so aus:
Skript 3.4Code
Alles anzeigen#include <GDIPlus.au3> Opt("GUIOnEventMode", True) $hWnd = GUICreate("GDI+", 400, 400) GUISetOnEvent(-3, OnExit) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) $hGraphicsBMP = _GDIPlus_BitmapCreateFromGraphics(400, 400, $hGraphics) $hBuffer = _GDIPlus_ImageGetGraphicsContext($hGraphicsBMP) _GDIPlus_GraphicsSetSmoothingMode($hBuffer, 2) $hBrushRed = _GDIPlus_BrushCreateSolid(0xA7FF0000) $hBrushGreen = _GDIPlus_BrushCreateSolid(0xA700FF00) $hBrushBlue = _GDIPlus_BrushCreateSolid(0xA70000FF) $hPenBorder = _GDIPlus_PenCreate(0xFF000000, 3) $nPi = 3.141592654 $nDeg2Rad = $nPi/180 $iAngle = 0 $iFPS = 0 ;FramesPerSecond $iFrames = 0 ;CurrentFrameCount AdlibRegister(FPS, 1000) While Sleep(10) ;/True _GDIPlus_GraphicsClear($hBuffer, 0xFFFFFFFF) $nX1 = 199 - (100/2) + 100 * Sin($iAngle*$nDeg2Rad + 0*$nDeg2Rad) $nY1 = 199 - (100/2) + 100 * Cos($iAngle*$nDeg2Rad + 0*$nDeg2Rad) $nX2 = 199 - (100/2) + 100 * Sin($iAngle*$nDeg2Rad + 120*$nDeg2Rad) $nY2 = 199 - (100/2) + 100 * Cos($iAngle*$nDeg2Rad + 120*$nDeg2Rad) $nX3 = 199 - (100/2) + 100 * Sin($iAngle*$nDeg2Rad + 240*$nDeg2Rad) $nY3 = 199 - (100/2) + 100 * Cos($iAngle*$nDeg2Rad + 240*$nDeg2Rad) _GDIPlus_GraphicsFillEllipse($hBuffer, $nX1, $nY1, 100, 100, $hBrushRed) _GDIPlus_GraphicsDrawEllipse($hBuffer, $nX1, $nY1, 100, 100, $hPenBorder) _GDIPlus_GraphicsFillEllipse($hBuffer, $nX2, $nY2, 100, 100, $hBrushGreen) _GDIPlus_GraphicsDrawEllipse($hBuffer, $nX2, $nY2, 100, 100, $hPenBorder) _GDIPlus_GraphicsFillEllipse($hBuffer, $nX3, $nY3, 100, 100, $hBrushBlue) _GDIPlus_GraphicsDrawEllipse($hBuffer, $nX3, $nY3, 100, 100, $hPenBorder) $iAngle += 1 If $iAngle >=360 Then $iAngle = 0 _GDIPlus_GraphicsDrawString($hBuffer, "FPS: " & $iFPS, 0, 0) _GDIPlus_GraphicsDrawImage($hGraphics, $hGraphicsBMP, 0, 0) ;draw buffer $iFrames += 1 WEnd Func FPS() $iFPS = $iFrames $iFrames = 0 EndFunc Func OnExit() GDIPlusFree() Exit EndFunc ;==>OnExit Func GDIPlusFree() _GDIPlus_PenDispose($hPenBorder) _GDIPlus_BrushDispose($hBrushRed) _GDIPlus_BrushDispose($hBrushGreen) _GDIPlus_BrushDispose($hBrushBlue) _GDIPlus_BitmapDispose($hGraphicsBMP) _GDIPlus_GraphicsDispose($hBuffer) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFunc ;==>GDIPlusFreeIch erwähnte schon öfters mal das Bogenmaß... Anstatt unsere Kugeln um je 120° zu verschieben, hätten wir auch einfach eine Verschiebung von 2/3*PI nehmen können. Dann spart man sich bei den AutoIt-Internen Funktionen das Umrechnen mittels $nDeg2Rad.
Gleichmäßige Geradenbewegungen
Das, was die Bewegung auf einer Geraden von der Kreisbewegung unterscheidet, ist, dass es sich nicht um eine geschlossene Bewegung handelt. An einem gewissen Punkt müssen wir die Bewegung umkehren oder beenden. Wir wollen einmal einen blauen Ball auf dem Boden auf- und abhüpfen lassen. Den Boden symbolisieren wir ganz einfach mit einer schwarzen Linie. Als Laufvariable benutzen wir diesmal einfach den Abstand zum Startpunkt, sodass sich die folgende Gleichung ergibt:
X = X[start] + Abstand
Jetzt müssen wir natürlich noch die Richtungsänderung implementieren. Bisher haben wir zu unser Laufvariable immer eins dazu addiert und beim Überschreiten eines gewissen Wertes wieder auf 0 gesetzt. Jetzt müssen wir beim Überschreiten eines gewissen Grenzwertes veranlassen, dass sich unsere Laufvariable um eins verringert. Konkret heißt das, dass wir eine neue Variable einführen, die die Bewegungsrichtung angibt. Dabei steht +1 für unten und -1 für oben, denn der Koordinatenursprung ist ja oben links.
Skript 3.5Code
Alles anzeigen#include <GDIPlus.au3> Opt("GUIOnEventMode", True) $hWnd = GUICreate("GDI+", 400, 400) GUISetOnEvent(-3, OnExit) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) $hGraphicsBMP = _GDIPlus_BitmapCreateFromGraphics(400, 400, $hGraphics) $hBuffer = _GDIPlus_ImageGetGraphicsContext($hGraphicsBMP) _GDIPlus_GraphicsSetSmoothingMode($hBuffer, 2) $hBrushBlue = _GDIPlus_BrushCreateSolid(0xA70000FF) $hPenBorder = _GDIPlus_PenCreate(0xFF000000, 3) $iJump = 0 $iJumpDirection = +1 $iFPS = 0 ;FramesPerSecond $iFrames = 0 ;CurrentFrameCount AdlibRegister(FPS, 1000) While Sleep(10) ;/True _GDIPlus_GraphicsClear($hBuffer, 0xFFFFFFFF) $nX = 149 $nY = 49 + $iJump _GDIPlus_GraphicsDrawLine($hBuffer, 0, 349, 399, 349, $hPenBorder) _GDIPlus_GraphicsFillEllipse($hBuffer, $nX, $nY, 100, 100, $hBrushBlue) _GDIPlus_GraphicsDrawEllipse($hBuffer, $nX, $nY, 100, 100, $hPenBorder) $iJump += $iJumpDirection ;Richtungsänderung If $iJump >= 200 Then $iJumpDirection = -1 If $iJump <= 0 Then $iJumpDirection = +1 _GDIPlus_GraphicsDrawString($hBuffer, "FPS: " & $iFPS, 0, 0) _GDIPlus_GraphicsDrawImage($hGraphics, $hGraphicsBMP, 0, 0) ;draw buffer $iFrames += 1 WEnd Func FPS() $iFPS = $iFrames $iFrames = 0 EndFunc Func OnExit() GDIPlusFree() Exit EndFunc ;==>OnExit Func GDIPlusFree() _GDIPlus_PenDispose($hPenBorder) _GDIPlus_BrushDispose($hBrushBlue) _GDIPlus_BitmapDispose($hGraphicsBMP) _GDIPlus_GraphicsDispose($hBuffer) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFunc ;==>GDIPlusFreeUnd siehe da, unser Ball springt!
Gebremste Geradenbewegungen
Wir schauen nochmal kurz zu unserem springenden Ball zurück... Das ist ja schon ganz gut geworden, sieht aber nicht allzu realistisch aus. Und warum? Na, der Ball wird in der Luft beim Höhepunkt der Bewegung sicherlich nicht bei voller Geschwindigkeit einfach nach unten fallen. Er wird zunächst langsamer. Wir müssen also unsere gleichmäßige Beschleunigung durch etwas anderes ersetzen. Es gäbe an dieser Stelle einige Möglichkeiten, die physikalisch richtige Variante wäre, eine Parabelgleichung nachzubilden. Wir wählen jedoch eine weniger aufwändige Variante, die genau so gut aussieht... Man stelle sich folgendes vor: Eine Kreiskontur, auf welcher sich ein Punkt im Uhrzeigersinn bewegt. Diese Kreiskontur drehen wir jetzt um 90° und betrachten das ganze von der Seite. Theoretisch sähe man jetzt nur noch eine Linie... Stellt es euch vor, als ob man die Kante einer Münze betrachten würde. Wenn wir jetzt unsere Kreiskontur verschwinden lassen, bleibt nur noch der Punkt, der auf- und abhüpft. Doch diese Bewegung erfolgt nicht gleichmäßig! Sie wird kurz vor dem Umkehren auf beiden Seiten jeweils langsamer. Genau das, was wir gesucht haben.
Wir ersetzen also unsere Distanzberechnung durch die Formel, die wir schon einmal rausgearbeitet hatten:
x = x[Drehpunkt] – Kreisradius + Drehradius * sin(alpha)
Hier müssen noch ein paar Sachen verändert werden...
x = x[Startpunkt] + Drehradius * (1 + sin(alpha))
Woher das +Drehradius kommt, ist einfach erklärt: In der Originalformel ist unser Basiswert der Drehpunkt, also der Mittelpunkt der Drehung. Wir wollen jedoch eine Geradenbewegung simulieren, bei der wir eigentlich nicht den Mittelpunkt der Bewegung angeben wollen, sondern den Startpunkt. Um vom Startpunkt auf den Mittelpunkt zu kommen, muss man eben nochmal den Drehradius addieren. Der Kreisradius ist hier einfach nicht relevant und beträgt 0.
Skript 3.6Code
Alles anzeigen#include <GDIPlus.au3> Opt("GUIOnEventMode", True) $hWnd = GUICreate("GDI+", 400, 400) GUISetOnEvent(-3, OnExit) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) $hGraphicsBMP = _GDIPlus_BitmapCreateFromGraphics(400, 400, $hGraphics) $hBuffer = _GDIPlus_ImageGetGraphicsContext($hGraphicsBMP) _GDIPlus_GraphicsSetSmoothingMode($hBuffer, 2) $hBrushBlue = _GDIPlus_BrushCreateSolid(0xA70000FF) $hPenBorder = _GDIPlus_PenCreate(0xFF000000, 3) $nPi = 3.141592654 $nDeg2Rad = $nPi/180 $iAngle = 0 $iFPS = 0 ;FramesPerSecond $iFrames = 0 ;CurrentFrameCount AdlibRegister(FPS, 1000) While Sleep(10) ;/True _GDIPlus_GraphicsClear($hBuffer, 0xFFFFFFFF) $nX = 149 $nY = 49 + 100*(1 + Sin($iAngle*$nDeg2Rad)) _GDIPlus_GraphicsDrawLine($hBuffer, 0, 349, 399, 349, $hPenBorder) _GDIPlus_GraphicsFillEllipse($hBuffer, $nX, $nY, 100, 100, $hBrushBlue) _GDIPlus_GraphicsDrawEllipse($hBuffer, $nX, $nY, 100, 100, $hPenBorder) $iAngle += 1 If $iAngle >= 360 Then $iAngle = 0 _GDIPlus_GraphicsDrawString($hBuffer, "FPS: " & $iFPS, 0, 0) _GDIPlus_GraphicsDrawImage($hGraphics, $hGraphicsBMP, 0, 0) ;draw buffer $iFrames += 1 WEnd Func FPS() $iFPS = $iFrames $iFrames = 0 EndFunc Func OnExit() GDIPlusFree() Exit EndFunc ;==>OnExit Func GDIPlusFree() _GDIPlus_PenDispose($hPenBorder) _GDIPlus_BrushDispose($hBrushBlue) _GDIPlus_BitmapDispose($hGraphicsBMP) _GDIPlus_GraphicsDispose($hBuffer) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFunc ;==>GDIPlusFreeIm oberen Bereich sieht das ganze jetzt schon relativ realistisch aus. Im unteren Bereich dagegen wird unsere Bewegung auch langsamer, was ja eigentlich nicht sehr realistisch ist.
Realitätsnahe Geradenbewegung
Im Vergleich zum Vorgängerskript wollen wir nun den unteren Teil der Bewegung ein wenig verschnellern, die Bremsung also rausnehmen. Sicherlich könnte man hier jetzt mit einer quadratischen Gleichung arbeiten, wir bleiben aber erstmal bei dem bekannten Sinus. Wir schauen uns nochmal den Graphen des Sinus' an. Im Moment findet unsere Bewegung von -5 bis +5 statt, wir stellen also eine komplette Periode dar. Dabei ist der Tiefpunkt des Graphen der Hochpunkt unseres Wurfes und demnach umgekehrt der Hochpunkt des Graphen der Tiefpunkt des Wurfes, also der Moment, wo Bodenkontakt herrscht. An diesen Stellen erkennen wir anhand der flachen Steigung, dass die Geschwindigkeit sehr gering wird.
An dieser Stelle benutzen wir einen einfachen Trick: Wir durchlaufen die Sinus-Funktion nicht immer wieder von 0° bis 360°, sondern nur von 0° bis 180°! Somit haben wir nur noch einen Punkt, an dem die Geschwindigkeit gering wird. Praktisch bedeutet das, dass wir unsere Bewegungslänge verdoppeln, aber nur noch die Hälfte darstellen. Dazu muss unsere Bewegungsgleichung ein wenig angepasst werden:
x = x[Startpunkt] + 2 * Drehradius * (1 + sin(alpha+180°))
Das *2 des Drehradius' ist die Verdopplung der Bewegungslänge, die +180° sagen nur aus, dass der zweite Teil der Bewegung dargestellt wird. Ansonsten würde unser Ball durch den Boden durchhüpfen, ihr könnt es ja mal ausprobieren. Zudem legen wir die Bedingung zum Zurücksetzen der Laufvariable auf >=180°.
Skript 3.7Code
Alles anzeigen#include <GDIPlus.au3> Opt("GUIOnEventMode", True) $hWnd = GUICreate("GDI+", 400, 400) GUISetOnEvent(-3, OnExit) GUISetState() _GDIPlus_Startup() $hGraphics = _GDIPlus_GraphicsCreateFromHWND($hWnd) $hGraphicsBMP = _GDIPlus_BitmapCreateFromGraphics(400, 400, $hGraphics) $hBuffer = _GDIPlus_ImageGetGraphicsContext($hGraphicsBMP) _GDIPlus_GraphicsSetSmoothingMode($hBuffer, 2) $hBrushBlue = _GDIPlus_BrushCreateSolid(0xA70000FF) $hPenBorder = _GDIPlus_PenCreate(0xFF000000, 3) $nPi = 3.141592654 $nDeg2Rad = $nPi/180 $iAngle = 0 $iFPS = 0 ;FramesPerSecond $iFrames = 0 ;CurrentFrameCount AdlibRegister(FPS, 1000) While Sleep(10) ;/True _GDIPlus_GraphicsClear($hBuffer, 0xFFFFFFFF) $nX = 149 $nY = 49 + 2 * 100 * (1 + Sin($iAngle*$nDeg2Rad+180*$nDeg2Rad)) _GDIPlus_GraphicsDrawLine($hBuffer, 0, 349, 399, 349, $hPenBorder) _GDIPlus_GraphicsFillEllipse($hBuffer, $nX, $nY, 100, 100, $hBrushBlue) _GDIPlus_GraphicsDrawEllipse($hBuffer, $nX, $nY, 100, 100, $hPenBorder) $iAngle += 1 If $iAngle >= 180 Then $iAngle = 0 _GDIPlus_GraphicsDrawString($hBuffer, "FPS: " & $iFPS, 0, 0) _GDIPlus_GraphicsDrawImage($hGraphics, $hGraphicsBMP, 0, 0) ;draw buffer $iFrames += 1 WEnd Func FPS() $iFPS = $iFrames $iFrames = 0 EndFunc Func OnExit() GDIPlusFree() Exit EndFunc ;==>OnExit Func GDIPlusFree() _GDIPlus_PenDispose($hPenBorder) _GDIPlus_BrushDispose($hBrushBlue) _GDIPlus_BitmapDispose($hGraphicsBMP) _GDIPlus_GraphicsDispose($hBuffer) _GDIPlus_GraphicsDispose($hGraphics) _GDIPlus_Shutdown() EndFunc ;==>GDIPlusFreeFür mein Empfinden ist das Hüpfen jetzt schon ziemlich realistisch. Wer mag, kann pro Schleifendurchlauf die Laufvariable auch nur um 0.5 erhöhen, siehe Skript 3.7A im Anhang. Das lässt die Bewegung langsamer, aber sauberer wirken.
Natürlich könnte man jetzt auch noch die plastische Verformung nachstellen, die auftritt, sobald der Ball den Boden berührt, aber das ist dann ein ganz anderes Thema.
Man kann den meisten Bewegungen mit der Verwendung der Sinus-Funktion einen natürlicheren Touch verpassen, das klappt meistens. Wie man den Sinus konkret einsetzt, kommt natürlich auf den Anwendungsfall an.
Schlusswort
So, jetzt bin ich einmal durch, nach knapp 6 Stunden. Das sind die imho wichtigsten Themen im Bezug auf GDI+. Damit sollte sich eigentlich ganz gut arbeiten lassen. Falls ich dennoch trotz sorgfältiger Überlegung einen Punkt vergessen oder gar falsch erklärt haben sollte, meldet euch. Wie immer ist Lob und (konstruktive) Kritik ausdrücklich erwünscht.
chesstiger -
Nein, das ist nur indirekt über eine Dummy-Funktion möglich.
[autoit]
[/autoit][autoit][/autoit][autoit]
OnAutoItExitRegister(Dummy)While True
[/autoit][autoit][/autoit][autoit]
Sleep(20)
WEndFunc Dummy()
[/autoit][autoit][/autoit][autoit]
Funktion($arg1)
EndFuncFunc Funktion($arg1)
[/autoit]
ConsoleWrite($arg1)
EndFuncUnd - woher auch immer diese Frage kommt... Ja. Jede natürliche Zahl lässt sich als Produkt von n Primzahlen darstellen. Das nennt man Primfaktorzerlegung. Im Umkehrschluss folgt daraus, dass jede natürliche Zahl mindestens eine Primzahl als Teiler besitzt.
Selbstverständlich gilt jeweils die Ausnahme für die 1.
-
Wobei die Schreibweise "Funktion" nur aus Gründen der Abwärtskompatibilität gewählt werden sollte, denn die neueren AutoIt-Versionen bieten dafür den Syntax Funktion an. Man beachte: Die Klammern fehlen! So wird auch direkt im Quelltext klar ersichtlich, dass es sich um eine Funktionsreferenz und nicht um eine Zeichenkette handelt. IsFunc funktioniert dann auch richtig.
[autoit]
Nochmal in der Übersicht:
[/autoit][autoit][/autoit][autoit]
;FALSCH: Die Funktion wird direkt ausgeführt, OnAutoItExitRegister erhält nur den Rückgabewert
OnAutoItExitRegister(Funktion());RICHTIG: Der Funktionsname wird als String übergeben
[/autoit][autoit][/autoit][autoit]
;ALLERDINGS nur wegen Abwärtskompatibilität zu empfehlen
OnAutoItExitRegister("Funktion");RICHTIG: Die Funktion wird als Funktionsreferenz übergeben
[/autoit]
OnAutoItExitRegister(Funktion) -
Die SetEQ-Funktion kommt mir bekannt vor.

Vermutlich macht die Bass-UDF genau das, was sie soll: Sie erhöht die Lautstärke der angegebenen Frequenz um X dB. Nicht mehr und nicht weniger. Wenn noch irgendwelche Filter oder so benutzt werden würden, wäre die Funktion ja "ungenau", sie soll aber möglichst "genau" sein.
Der Handy-Equalizer aber muss nicht möglichst "genau" sein, er soll in erster Linie gut klingen. Darum werden dort wahrscheinlich diverse Filter angewendet.
Wohlgemerkt alles Vermutungen ohne Gewähr.Davon ab, halte ich eine Verstärkung von 9dB für den Bass schon für relativ viel. Was hörst du denn, damit sowas nötig wird?

-
Ich habe meinen Raspberry Pi B seit ca. 1 1/2 Jahren (glaube ich). Dabei fungiert er als einiges... Zunächst für Spielereien und Experimente gedacht, hat er schon bald seinen Dienst als NAS getan. Dabei hatte ich hin und wieder auch das Problem, dass er mir das Dateisystem zerschossen hat. Irgendwann ging es dann gar nicht mehr, die SD-Karte war hinüber. Ich hatte zum Glück direkt nach der Installation das Image gesichert (bzw. das Image mit einer Emulatorsoftware unter Linux hergerichtet und dann erst auf die Karte kopiert) und musste so nur eine neue Karte bestellen und das Image draufschieben, fertig, lief wieder. Eine Kontrolle gerade hat ergeben, dass der Pi mit der neuen Karte seit 160 Tagen (> 5 Monate) ohne Fehler dauerhaft (!) läuft. Nachdem ich dann einen WDMyCloud-NAS angeschafft habe (der nebenbei mittlerweile tot ist), hat der Pi mit viel Bastelei ein paar neue Funktionen bekommen. Zuerst der eigentlich obligatorische Webserver (Apache2) mit PHP und MySQL, läuft zwar nicht mit Spitzengeschwindigkeit, aber das ist ja auch gar nicht nötig. Dann kam noch ein VPN-Server mit DynDNS-Service dazu, sodass ich von Außen an mein Netzwerk rankomme. Super Sache, läuft auch einwandfrei seit ca. 160 Tagen. Der wirkliche Clou ist aber die Heimautomatisierung geworden. Ein 433MHz-Funkmodul, ein Elro-Funksteckdosenset, ein paar Software-Bibliotheken und eine Menge Zeit waren nötig, um mein Zimmer fast komplett steuern zu können. Dabei verlasse ich mich möglichst wenig auf fertige Lösungen, ein eigenes Webinterface für die Steuerung in PHP mit Datenbank für die einzelnen Steckdosen war also auch nötig. Diese dann noch auf Mobilgeräte optimiert, damit man alles schön von einem Android-Gerät aus unter Kontrolle hat. Alles kein Problem, dank des VPN-Servers kann ich die ganze Geschichte sogar von überall auf der Welt aus steuern. :w00t:
Da ich mir so aber nur eine (coolere) Funkfernbedienung gebaut habe, kommen hier jetzt die weiteren Möglichkeiten eines Linux-Systems ins Spiel. Zunächst war dann noch meine Onkyo-HiFi-Endstufe mit Netzwerkanschluss ein Ziel. Ein schlauer Mensch hat die Pakete der (zugegeben eher schlechten) Steuerungs-App von Onkyo analysiert und mit diesen Infos ein Python-Skript zum Steuern geschrieben. Ich musste also nur noch ein paar Steuerungselemente in mein Webinterface integrieren, um auch die meisten Funktionen meiner Musikanlage über meine eigene Oberfläche zu kontrollieren. So kann man dann auch Arbeitsabläufe zusammenfassen, z.B. sobald die Steckdose für die Anlage angeht, die Lautstärke auf 25% setzen. Sobald die Steckdose für den Fernseher angeht, die Quelle der Endstufe auf TV setzen... Alles sehr komfortabel.
Und um dem ganzen die Krone aufzusetzen, habe ich auch noch /etc/crontab für meine Heimautomatisierung genutzt.
An jedem Werktag geht bei mir um 5.55 Uhr automatisch die Endstufe auf Lautstärke 30 mit Quelle Radio auf 87.65 MHz (hr3 ftw!) an, um 5.57 Uhr dann schließlich das Licht... Sehr gemütliches Aufstehen. 
Für die Zukunft ist dann noch die ein oder andere Erweiterung geplant, z.B. ein Unterputz-Funkmodul für die Deckenbeleuchtung und so weiter... Alles in allem hat man mit so einem Pi extrem viele Möglichkeiten.Wobei ein Arduino natürlich auch nicht zu unterschätzen ist. Bei einem Laptop oder Tablet hätten mir dann aber z.B. die entsprechenden Schnittstellen für ein Funkmodul gefehlt...
Grüße!
-
Dazu wäre es aber nötig, die jeweiligen Möglichkeiten für [P] und [Q] im Bezug auf [J] zu kennen.
Es sei denn, du willst bei jedem Datensatz die Eingaben von Hand machen... Pro Eingabe geschätzte 2.5 Sekunden, also 5 Sekunden pro Eintrag...
5 * 46.000 = 230.000
((230.000 / 60) / 60) / 24 = ~2.7 Tage
-
Nein, das geht so nicht. Du kannst dir aber anders helfen.
Bei jeder Änderung an der Oberfläche muss dein Fenster neugezeichnet werden. Du musst dieses Neuzeichnen nur verhindern, bis alle Änderungen vorgenommen worden sind. In Win32-Manier würdest du einfach die WM_PAINT-Nachricht dementsprechend abfangen und je nach dem durchreichen. Wenn du nicht weißt, was WM_PAINT ist, dann vergiss es.
Ansonsten kannst du theoretisch auch per GUISetState(@SW_LOCK) das Neuzeichnen verhindern. Das habe ich allerdings noch nie benutzt. Du musst nur daran denken, die "Sperre" wieder zu lösen (@SW_UNLOCK). -
Eine Sache habe ich noch gefunden. Irgendein Mensch mit viel Langeweile hat mal ein Gecko-ActiveX-Control geschrieben, dass allerdings seit längerem nicht mehr weiterentwickelt wird (Aktueller Gecko-Stand: Mozilla 1.7.12 :D). Wenn die Seite nicht zu aufwändig ist, dann sollte das damit gehen. Grundlegendes HTML, JavaScript und CSS sind jedenfall möglich. Nach der Installation (siehe Link oben) kannst du dieses Skript hier zum Testen benutzen:
Spoiler anzeigen
[autoit]
[/autoit] [autoit][/autoit] [autoit]
GUICreate("Embedded Mozilla 1.7.12", 640, 580)
Local $oFF = _FFCreateEmbedded()
GUICtrlCreateObj($oFF, 0, 0, 640, 580)
$oFF.Navigate("http://whatsmyuseragent.com/")
GUISetState()While True
[/autoit] [autoit][/autoit] [autoit]
Switch GUIGetMsg()
Case -3
Exit
EndSwitch
WEndFunc _FFCreateEmbedded()
[/autoit]
$sCLSID = "{1339B54C-3453-11D2-93B9-000000000000}"
Local $oObject = ObjCreate($sCLSID)
Return $oObject
EndFunc ;==>_FFCreateEmbedded -
@Micha
Gut, dann kann man unter Umständen mit der Schiebe-Lösung arbeiten, wenn sonst keine Möglichkeit mit annehmbarem Aufwand-Nutzen-Verhältnis existiert.
Ich dachte, Firefox schmiert ab? Oder hast du das Fenster nicht so eingebettet?@Teare
Ja, mag sein. Ich bin Firefox-Nutzer, daher hatte ich nebenbei kein "Standalone"-Chrome offen. Das ist ja auch eher ein Proof of Concept.
-
Dann nehmen wir eben Chrome.

Spoiler anzeigen
[autoit]
[/autoit] [autoit][/autoit] [autoit]
#include <WindowsConstants.au3>
#include <Constants.au3>
#include <WinAPI.au3>$hParent = GUICreate("_WinAPI_SetParent", 360, 280, Default, Default, BitOR($WS_MINIMIZEBOX, $WS_CAPTION, $WS_POPUP, $WS_SYSMENU, $WS_CLIPCHILDREN))
[/autoit] [autoit][/autoit] [autoit]
GUISetState()ChromeCreateEmbedded("autoit.de", 20, 20, 320, 240, $hParent)
[/autoit] [autoit][/autoit] [autoit]Do
[/autoit] [autoit][/autoit] [autoit]
;nop
Until GUIGetMsg() = -3 ;GUI_EVENT_CLOSEFunc ChromeCreateEmbedded($sURL, $iX, $iY, $iWidth, $iHeight, $hParent, $iWindowFindTimeout = 1000)
[/autoit] [autoit][/autoit] [autoit]
$sChromeExecutable = RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\chrome.exe", "")
If @error Then Return SetError(1) ;chrome not installed
$iPID = Run(StringFormat('"%s" "%s"', $sChromeExecutable, $sURL), "", @SW_HIDE)$hChrome = Null
[/autoit] [autoit][/autoit] [autoit]
$hTimer = TimerInit()
While True
$aWindows = _WinAPI_EnumWindows()
For $i = 1 To $aWindows[0][0]
If $aWindows[$i][1] <> "Chrome_WidgetWin_1" Then ContinueLoop
;maybe it is our window?
If $iPID = WinGetProcess($aWindows[$i][0]) Then
$hChrome = $aWindows[$i][0]
ExitLoop 2
EndIf
Next
If TimerDiff($hTimer) > $iWindowFindTimeout Then Return SetError(2)
If $hChrome = Null Then ContinueLoop
WEnd$hChild = GUICreate("", $iWidth, $iHeight, $iX, $iY, $WS_CHILD, -1, $hParent)
[/autoit] [autoit][/autoit] [autoit]
GUISetState()
GUISwitch($hParent) ;switching autoit-interna back_WinAPI_SetParent($hChrome, $hChild)
[/autoit] [autoit][/autoit] [autoit]WinMove($hChrome, "", -8, -100 - 5, $iWidth + 16, $iHeight + 100 + 14) ; Korrekturfaktoren
[/autoit]
EndFunc ;==>ChromeCreateEmbedded
Das ist allerdings nicht sehr professionel. Damit man die Ränder des Browser nicht sieht, habe ich ihn einfach so geschoben, dass die Ränder verdeckt werden. Das ganze dann noch auf eine Child-GUI damit man frei damit arbeiten kann... Und voilá!
In welchem Maß willst du diese Technik denn einsetzen? Geht es um ein Privatprojekt oder hast du was größeres, evtl. sogar kommerzielles? Wenn es sich nur um ein Privatprojekt handelt, ist das hier wahrscheinlich ausreichend. Wenn das allerdings nicht der Fall ist, würde ich an deiner Stelle ernsthaft überlegen, ob es sich vielleicht lohnen würde, ein AutoIt-Binding für eine Rendering Engine nach Wahl zu schreiben, Gecko und Webkit z.B. sind ja OpenSource.Gruß
-
Du könntest theoretisch auf die grundlegenden Win32-Methoden zurückgreifen, sogar ganz ohne FF.au3... Das passende Stichwort ist hier die Funktion SetParent, weitere Informationen findest du im MSDN. Es gibt sogar eine AutoIt-Umsetzung aus der WinAPI.au3: _WinAPI_SetParent. Wie der Name schon andeutet, kannst du damit das Elternfenster (Parent Window) eines beliebigen Fensters (Child Window) festlegen. Dann musst du nur noch die Styles des Fenster richtig anpassen, WS_POPUP sowie WS_CHILD würden sich bspw. anbieten. Die Funktion _WinAPI_SetWindowLong mit dem Parameter GWL_STYLE hilft hier weiter. Dann ist ggf. noch eine Positionsänderung des neuen Child Window nötig. Du kannst dich ja mal an diesem Beispiel von der Integration von notepad.exe orientieren:
Spoiler anzeigen
[autoit]
[/autoit] [autoit][/autoit] [autoit]
#include <WindowsConstants.au3>
#include <Constants.au3>
#include <WinAPI.au3>$hParent = GUICreate("_WinAPI_SetParent", 320, 240, Default, Default, BitOR($WS_MINIMIZEBOX, $WS_CAPTION, $WS_POPUP, $WS_SYSMENU, $WS_CLIPCHILDREN))
[/autoit] [autoit][/autoit] [autoit]
GUISetState()$iPID = Run("notepad.exe", "", @SW_HIDE)
[/autoit] [autoit][/autoit] [autoit]
WinWait("[CLASS:Notepad]")
$hChild = WinGetHandle("[CLASS:Notepad]")_WinAPI_SetParent($hChild, $hParent)
[/autoit] [autoit][/autoit] [autoit]
_WinAPI_SetWindowLong($hChild, $GWL_STYLE, BitOR($WS_CHILD, $WS_BORDER, $WS_POPUP))WinMove($hChild, "", 0, 0) ; an 0,0 des Hauptfensters schieben
[/autoit] [autoit][/autoit] [autoit]
WinSetState($hChild, "", @SW_SHOW)Do
[/autoit]
;nop
Until GUIGetMsg() = -3 ;GUI_EVENT_CLOSE
(Abgeändertes Beispiel, Originalquelle ist leider verloren gegangen...)