Der Gültigkeitsbereich einer Variable ist der Abschnitt eines Programms, in dem die Variable "sichtbar" ist, in dem wir die Variable verwenden können. Dieser Gültigkeitsbereich wird auch Scope (englisch für Rahmen, Bereich, Reichweite) genannt.
int grayColor = 127; // Globale Variable
void setup() {
size(400, 400);
background(grayColor); // kann hier verwendet werden
}
void draw() {
stroke(grayColor); // und hier auch
line(0, 0, mouseX, mouseY);
}
void setup() {
size(400, 400);
int grayColor = 255; // Lokale Variable
background(grayColor);
}
void draw() {
stroke(grayColor); // FEHLER! Kann hier nicht verwendet werden.
line(0, 0, mouseX, mouseY);
}
Siehe auch Variablen in draw().
Ein Programmblock ist jeder Teilbereich eines Programms, der von geschweiften Klammern umfasst wird. Also beispielsweise:
void draw() {
line(x, 10, x, 100); // Von hier
x = x + 2; // bis hier ein Block.
}
while (y < height) {
stroke(127); // Dies ist auch ein Block
ellipse(width, height / 2, 10, 10); //
line(10, 20, 50, 40); // der bis hier geht.
}
(Vorsicht! Lokale Variablen überschreiben globale Variablen mit gleichem Namen. Daher am Besten für verschiedene Variablen immer auch unterschiedliche Namen verwenden.)
Es gibt verschiedene Farbsysteme, oder Farbmodelle.
RGB steht für Rot, Grün, Blau. Dies ist ein additives Farbmodell, bei dem sich die Grundfarben zu Weiß addieren (Lichtmischung). Eine Farbe wird durch drei Werte beschrieben: den Rot-, den Grün- und den Blauanteil.
HSB steht für Hue (englisch für Farbton), Saturation (Sättigung), Brightness (Helligkeit). Eine Farbe im HSB-Farbraum wird mit Hilfe dieser drei Werte beschrieben.
CMYK steht für Cyan, Magenta, Yellow (gelb) und blacK (schwarz). Dies ist ein subtraktives Farbmodell, welches die technische Grundlage für den modernen Vierfarbdruck bildet. Der Schwarz-Anteil ist zur Erhöhung des Kontrastes in dunklen Stellen. Vereinfacht kann es als komplementär zum RGB-Farbmodell verstanden werden.
In Processing werden wir die beiden Farbmodelle RGB und HSB verwenden.
Üblicherweise wird RGB in Werten von 0 bis 255 angegeben, und HSB von 0 bis 360.
Wir haben bereits gesehen, wie wir Grauwerte benutzen. Um Farben zu verwenden, kann man statt eines Wertes drei in den Farbanweisungen angeben.
background(0); // schwarzer Hintergrund fill(255); // weiße Füllfarbe background(209, 241, 255); // pastell-blauer Hintergrund stroke(255, 255, 0); // gelbe Linienfarbe
Um Farben wieder verwenden zu können, benutzen wir den Datentyp color. Hierin können wir die drei Werte RGB oder HSB speichern.
color white = color(255, 255, 255); fill(white);
Um die Elemente transparent werden zu lassen, können wir einen vierten Alpha-Wert angeben. Dieser geht ebenso von 0 bis 255 (d.h. von unsichtbar bis nicht-transparent).
Eins der zentralen Grundkonzepte des Programmierens ist, komplexe Prozesse zu vereinfachen und mit möglichst wenig Zeilen Programmcode
auszukommen. Ein wichtiges Hilfsmittel dafür sind Schleifen.
In Processing gibt es verschiedene Möglichkeiten, solch eine Schleife zu programmieren. Die wichtigste ist die while-Schleife:
Diese läuft so lange ab, solange die Bedingung wahr ist.
Bisher mussten wir etwa fünf parallele Linien so programmieren:
int i = 0; line(30, i, 50, i); i = i + 10; line(30, i, 50, i); i = i + 10; line(30, i, 50, i); i = i + 10; line(30, i, 50, i); i = i + 10; line(30, i, 50, i);
Dies kann durch eine Schleife folgendermaßen vereinfacht werden:
int i = 0;
while (i < 50) {
line(30, i, 50, i);
i = i + 10;
}
oder auch durch folgenden äquivalenten Code:
int i = 0;
while (i < 5) {
line(30, i * 10, 50, i * 10);
i = i + 1;
}
Wichtig ist dabei, dass die Bedingung irgendwann erfüllt werden muss (sonst endet das Programm nie und gerät in eine sogenannte Endlosschleife).
Eine berechnete Form wird erzeugt durch die Anwendung eines Algorithmus, der als klar definierte Reihe von Anweisungen und Ausdrücken beschrieben wird. Dieser Algorithmus ist üblicherweise parametrisiert, d.h. dass ihr Aussehen und Verhalten von einer Reihe von Variablen kontrolliert wird.
Eine dynamische Form ist eine Form, die sich über die Zeit verändert oder auf Interaktion reagiert.
Wir haben dynamische Formen bereits im Umgang mit draw() kennen gelernt.
Durch Bedingungen und Einschränkungen können wir dynamische Formen beschreiben, und ihr Verhalten beeinflussen. Verwenden wir für Eigenschaften der Form Zufallszahlen, so befreien wir die Form in gewissen Rahmen von ihrer Determiniertheit, von der exakten Vorhersagbarkeit, und können Benutzer wie auch uns Programm-Entwerfer überraschen.
random(value);random(minValue, maxValue);
Erzeugt einen Zufallswert. Jedes Mal wenn random() aufgerufen wird, wird ein zufälliger, "unerwarteter" Wert zurück gegeben.
Der erzeugte Wert liegt dabei zwischen 0 und value, bzw. zwischen minValue und maxValue
und ist vom Datentyp float.
random(10); // Erzeugt einen Wert zwischen 0 und 10, z.B. 3 random(10); // diesmal vielleicht 8 random(5, 10); // Erzeugt einen Wert zwischen 5 und 10, z.B. 9 random(-5, 5); // Erzeugt einen Wert zwischen -5 und 5, z.B. -3 random(0.4, 0.9); // Erzeugt einen Wert zwischen 0.4 und 0.9, z.B. 0.773 point(random(100), random(50)); // Zeichnet einen Punkt irgendwo zwischen Position (0, 0) und (100, 50) point(random(50,80), random(20)); // Zeichnet einen Punkt irgendwo zwischen Position (50, 0) und (80, 20)
Folgendes Beispiel zeichnet vertikale Linien, deren Grauwert zufällig ist:
Einschränkungen siehe Dynamische Formen 2.