Programmaufbau
Ein Processing Programm besteht aus einer Abfolge von Anweisungen, die der Computer der Reihe nach abarbeitet. Diese Anweisungen teilen dem Computer mit, was er tun soll.
Beispiel:
smooth( );
size( 800, 600 );
ellipse( 400, 300, 200, 200 );
Hier werden nacheinander 3 Funktionen aufgerufen. Funktionen kann man sich als Befehle an den Computer vorstellen. Man erkennt sie an den Klammern nach dem Namen.
Die erste Zeile ruft eine Funktion „smooth( )“ auf. Sie bewirkt, dass alle nachfolgenden Zeichenfunktionen geglättete Linien bekommen.
Processing bietet Hunderte von Funktionen an, die alle in der Referenz beschrieben werden. Wichtig ist dabei, das die Groß- und Kleinschreibung bei Processing eine Rolle spielt. Schreibt man z.B. Smooth(), erkennt Processing das nicht.
Die zweite Zeile ruft die Funktion „size( )“ auf, die die Größe des Fensters festlegt. Damit die Funktion weiss, welche Größe das Fenster haben soll, müssen wir ihr 2 Parameter übergeben (in diesem Fall „640“ und „480“ für die Breite und Höhe des Fensters).
Die Parameter werden durch Kommas getrennt und müssen in der richtigen Reihenfolge angegeben werden.
In der Referenz werden zu allen Funktionen die Anzahl, Art und Bedeutung ihrer Parameter beschrieben. Dort steht dann z.B.
size(width, height)
width und height sind hier die Namen der Parameter.
Viele Funktionen gibt es mit unterschiedlichen Parametern. Die Funktion „size“ kann man z.B. mit einem dritten Parameter aufrufen, der angibt, mit welcher Technik Processing zeichnen soll. Beispiel:
size( 800, 600, OPENGL );
Die dritte Zeile schließlich ruft die Funktion „ellipse(x, y, width, height)“ auf, die eine Ellipse zeichnet. Sie hat folgende Parameter: x und y sind die Position der Ellipse, width und height ihre Breite und Höhe.
Datentypen
Alle Daten und Werte, die wir in einem Processing Programm verwenden, haben einen Datentyp. Die Funktion
size( width, height )
erwartet beispielsweise, dass die beiden Parameter width und height vom Typ „Zahl“ sind (und nicht Farben oder Texte).
Es gibt in Processing zahlreiche Typen, von denen hier die elementarsten beschrieben werden:
int (= Integer) Ganze Zahlen, also Zahlen ohne Komma. Integer sind vor allem zum Zählen geeignet. Beispiele: 1 -2 0 999999
float (= floating point) Kommazahlen, also Zahlen, die ein Komma enthalten. Allerdings werden Zahlen in englischer Schreibweise angegeben, also Punkt statt Komma! floats sind vor allem für Berechnungen geeignet.
Beispiele: 0.0 1.5 0.001 -2543.0
boolean sind „Wahrheitswerte“, d.h. sie können nur zwei Zustände haben: true oder false (stellvertretend für „wahr oder falsch“, „an oder aus“, „ja oder nein“)
Variablen
Variablen sind Speicherplätze für Werte, die über einen Namen angesprochen werden. Damit lassen sich Programme lesbarer machen und häufig verwendete Werte an zentraler Stelle definieren. Variablen kann man überall dort verwenden, wo ein auch normale Werte stehen können (vorausgesetzt, sie haben den richtigen Datentyp).
ellipse( mouseX, mouseY, 100, 100 );
zeichnet eine Ellipse an der aktuellen Mausposition.
mouseX und mouseY sind von Processing vordefinierte Variablen, die immer die aktuelle Mausposition enthalten.
Um eigene Variablen zu definieren, muss der Typ angegeben werden, gefolgt von dem Namen, den wir der Variable geben wollen (hier zur Übersichtlichkeit eingerückt):
float centerX;
int anzahl;
Mit dem Zuweisungsoperator „=“ können wir der Variablen einen Wert zuweisen:
anzahl = 200;
abstand = 1.5;
Optional kann bereits bei der Definition der Variablen ein Wert zugewiesen werden:
float centerX = 1.5;
int anzahl = 200;
boolean allesOk = false;
Funktionen
Funktionen können nicht nur eine Anweisung an den Computer sein, sondern auch einen Wert zurückliefern. In diesem Fall kann man die Funktion fast überall dort verwenden, wo normalerweise ein Wert oder eine Variable verwendet wird:
Die Funktionen max() und min() erwarten z.b. 2 Parameter und liefern den größeren (max) bzw. kleineren (min) der beiden Werte zurück. Das Ergebnis dieser Funktion kann man z.B. einer Variablen zuweisen:
float minimum = min( width, mouseX );
Hier wird der Variablen „minimum“ entweder die Fensterbreite oder die Mausposition zugewiesen, je nach dem, welcher der beiden Werte kleiner ist.
Ebenso kann man die Funktion als Parameter einer anderen Funktion verwenden:
ellipse( min( width, mouseX ), min( height, mouseY), 100, 100 );
So liefert z.B. der folgende Ausdruck:
max( 0, min( width, mouseX ))
die Mausposition zurück, aber stellt dabei sicher, dass die Position immer im Bereich des Fensters bleibt (größer als 0 und kleiner als die Breite des Fensters).
Grundsätzlich lassen sich Funktionen auf diese Art beliebig tief ineinander verschachteln:
ellipse( max( 0, min( width, mouseX )), max( 0, min( height, mouseY )), 00, 100 );
allerdings ist es übersichtlicher, die Zwischenergebnisse in Variablen zu speichern:
float x = max( 0, min( width, mouseX ));
float y = max( 0, min( height, mouseY ));
ellipse( x, y, 100, 100 );
Operatoren
Operatoren wie z.B. die die mathematischen Operatoren * + - / % > < etc. sind im Prinzip ebenfalls Funktionen, nur mit einer anderen Schreibweise. Daher lassen sie sich ebenso verwenden:
// Berechne Gesamtpreis:
float brutto = netto + ( netto * mwst / 100 ) ;
// Zeichne Ellipse in die Mitte des Fensters
ellipse( width / 2, height / 2, 100, 100 );
Das bedeutet auch, dass nicht nur Variablen, sondern auch Funktionen einen Datentyp besitzen, nämlich den Wert den sie zurückliefern.
So hat z.B. die Funktion max den Typ float, (weil sie einen Wert vom Typ float liefert) und überall dort verwendet werden kann, wo ein float benötigt wird; sie kann also einer Variablen vom Typ float zugewiesen werden oder in einer Funktion eingesetzt werden, die einen Parameter vom Typ float erwartet.
Alle Anweisungen, die einen Wert zurückliefern also Variablen, Funktionen oder Operationen, nennt man Ausdrücke. Ausdrücke können überall dort verwendet werden, wo auch einfache Werte stehen können, also z.B. als Parameter für Funktionen oder auf der rechten Seite einer Variablen-Zuweisung.