Das ist eigentlich fast schon eine Nebensache, da sie für das Programm keine Relevanz haben: Kommentare.
Sie sind dazu da, um den Überblick zu behalten, oder auch, um anderen etwas zu verdeutlichen.
Es gibt zwei Sorten von Kommentaren: Einzeilige und Blockkommentare.

Einzeilig:

//Dies ist ein Kommentar und wird nicht vom Programm beachtet

Block:

/* Hiermit gehen auch mehrzeilige Kommentare */

Kommentare werden von ordentlichen Editoren (und der Unity-Scripteditor gehört dazu) farblich abgesondert; praktisch. Kommentare haben einen weiteren Nutzen: Man kann Programmteile “auskommentieren”. Setzt man vor eine Anweisung die beiden // , dann wird sie natürlich nicht mehr ausgeführt. So kann man, falls man will, den Script testen, wie er ohne läuft.

2. Die If-Abfrage

Eine Funktion löst eine andere aus – das ist ja schon ganz nett.
Aber will man ein Spiel schreiben, reicht das noch lange nicht aus.
Es gibt ein paar Strukturen in der Programmierung, die sollte jeder kennen.
Da wäre zum ersten die If-Abfrage.
“if” bedeutet auf deutsch “falls”.Die If-Abfrage besteht aus einem Kopf, in dem eine Bedingung steht – diese ist eine Variable vom Typ boolean (erinnere: ja oder nein) – und einem Körper, in dem wie bei der Funktion Anweisungen stehen.

if(bedingung)
{
}

Sollte die Bedingung den Wert “true”, also “ja”, haben, dann werden die Funktionen im Körper, also zwischen den geschweiften Klammern, ausgeführt, sonst nicht.

Beispiel:

if(true)
{
 print("Ich scripte hier!");
}
if(false)
{
  print("Ich scripte nicht.");
}

Sollte in dem Körper der Abfrage nur eine einzige Anweisung stehen, darf man die geschweiften Klammern weg lassen.

Ein weiteres Besipiel:

var klappt : boolean = true;
function Start()
{
 if(klappt)
   print("Es klappt.");
 klappt = false;
 if(klappt)
   print("Wenn das klappt, fress ich einen Besen.");
}

Du bemerkt vielleicht, dass ich Zeilen einrücke. Das macht man für gewöhnlich mit Tab (Die Taste links neben Deinem Q), das klappt hier aber nicht so gut, daher hier nur Leerzeichen. Der Sinn dahinter ist, dass man auch bei komplexeren Strukturen nicht den Überblick verliert, welche Anweisung in welcher Abfrage steht. Da hat jeder so seine eigene Methode, ich zum Besipiel setze die öffnende geschweifte Klammer immer unter den Funktions- / Abfragen-Kopf, die meisten setzen sie dahinter. Hauptsache ist, man selbst hat noch den Überblick, optimalerweise auch andere, falls man mal anderen etwas zeigen will.

Nun aber weiter im Text: In If-Abfragen kann man auch andere Variablen benutzen als boolean. Dafür muss man den Wert mit einem anderen vergleichen. Dabei kommt dann heraus: “Ist gleich” oder “ist ungleich”, und das ist dann wieder unser benötigter boolean-Wert. Zum Vergleichen benutzt man ein doppeltes Gleichzeichen ( == ), denn das einfache ist ja schon für die Wertzuweisung zuständig.

Beispiel:

if(3 == 4)
  print("Diese Anweisung wird nicht ausgeführt werden.");

var hi : String = "Hallo";
if(hi == "Hallo")
  print("Diese Anweisung wird ausgeführt.");

Mehrere Bedingungen ( = boolean-Variablen) lassen sich zu einer zusammenfügen, indem man so genannte logische Operatoren verwendet. So kann man im Script abfragen, ob zwei Bedingungen stimmen, oder nur eine von beiden. Da wäre zum einen das logische Und ( && ).

if(4 > 3.5 && "wurst" != "käse")
 print("Das hier wird ausgeführt");
if(4 > 3.5 && "wurst" == 5)
  print("Das hier bestimmt nicht.");

Auf diese Weise lassen sich belieblig viele Bedingungen kombinieren.
So spart man sich das Stapeln von Abfragen:

if(4 > 3.5)
{
 if("wurst" != "käse")
  print("Das hier würde genau so funktionieren wie das oben.");
}

Dann gibt es noch das logische Oder ( || ).
Einen | erzeugt man mit AltGr+< (die Taste neben der linken Umschalttaste).
Eine Oder-Bedingung gilt dann als wahr, wenn eine ihrer Teilbedingungen wahr sind:

var zahl : int = 4;
if(zahl == 2 || zahl == 4)
print("Das hier wird sowas von ausgeführt...");

Mehrere logische Operationen sollten unbedingt voneinander abgetrennt werden, das geschieht mit normalen Klammern ( ( und ) ):

if(("a" == "b" || 3 == 3) && 2 > 0)
  print("Auch das hier wird ausgeführt.");

4. Else

“else” heißt auf deutsch “sonst”, und das passt.
Wer aufgepasst hat, kann sich die Funktion schon denken:

if(3 > 5)
  print("Das wird nicht ausgeführt");
else 
  print("Das aber schon.")

auch else kann einen Körper mit geschweiften Klammern haben, damit es mehrere Anweisungen gibt:

if(false)
{
  //...
}
else
{
  //...
}

5. While-Schleife

Jetzt kommt noch eine weitere Struktur. Sie ist der If-Abfrage sehr ähnlich, hat aber den Unterschied, dass die Anweisungen im Körper nicht nur ein Mal ausgeführt werden, wenn im Kopf “true” steht, sondern immer wieder ausgeführt werden, bis “false” im Kopf steht. Das ist in den allermeisten Fällen nur sinnvoll, wenn der Wert, um den es im Kopf geht, im Körper geändert wird.

var zahl : int = 0;
while(zahl < 5)
{
  print("Es wird getan!");
  zahl = zahl + 1;
}

Am Ende haben wir hier fünf Mal den angegebenen Satz in der Konsole stehen. Daran sieht man schon einmal den primären Nutzen von Schleifen: etwas soll x Mal ausgeführt werden. Für diesen Zweck allerdings ist die For-Schleife nützlicher. Bevor die dran kommt, erst einmal neue Operatoren!

6. Neue Operatoren

Es gibt ein paar nützliche Operatoren, die noch gar nicht dran kamen.
Da gibt es z.B. + als “Concat”-Operator, der Strings zusammenfügt:

var name : String = "Hase";
print("Mein Name ist "+name+".");

Wer errät’s? Am Ende steht da “Mein Name ist Hase.”
Sehr wichtig!
Das funktioniert auch mit Strings und Zahlen:

var zahl : int = 3;
print("Die Nummer lautet "+zahl);

Aber Vorsicht bei Rechnungen in diesem Falle, benutze Klammern!

print("Drei plus zwei ist "+(3+2));

…denn das + ist immernoch auch zum Rechnen da.
Jetzt gibt es noch schnelle Rechenoperatoren:

zahl++;

Erhöht “zahl” um 1, genau wie

zahl--;

…”zahl” um 1 verringert.
Dann gibt es noch diese:

zahl += 5; //entspricht zahl = zahl + 5;
zahl -= 5; //entspricht zahl = zahl - 5;
zahl *= 5; //entspricht zahl = zahl * 5;
zahl /= 5; //entspricht zahl = zahl / 5;

…für schnelleres Rechnen. Yay!
Dann gibt es noch das Ausrufezeichen ( ! ). Dieses kann man benutzen, um boolean-Werte umzukehren.
Dieser Code:

if(lebtNoch == false)

…entspricht diesem:

if(!lebtNoch)

Das ist nicht notwendig, aber ganz schön praktisch!

7. For-Schleife

Mit der For-Schleife geht Zählen besser als je zuvor!
Anstatt sie aber im Detail zu erläutern, werde ich jetzt erstmal einfach die gängigste Verwendungsweise vorstellen:

var wieOft : int = 5;
for(var i : int = 0; i < wieOft; i++)
{
  print("Wir sind bei "+i);
}

Der Kopf der For-Schleife besteht aus drei Teilen, die per Semikolon ( ; ) voneinander getrennt sind. Der erste Teil ist eine Anweisung, die am Anfang der Schleife ausgeführt wird (hier kann man eine Variable deklarieren und initialisieren!), der zweite Teil ist eine Bedingung, die vor jedem Durchlauf der Schleife abgefragt wird (genau wie in der While-Schleife, bei false wird die Schleife abgebrochen), der dritte Teil ist wieder eine Anweisung, die nach jedem Durchlauf ausgeführt wird. Dieser Code ist also von der Funktion her identisch mit diesem:

var wieOft : int = 5;
var i : int = 0;
while(i < wieOft)
{
  print("Wir sind bei "+i);
 i++;
}

…und ist dabei wesentlich sauberer und schicker.

8. Return und Break

Return wurde im vorherigen Tutorial benutzt; mit return lassen sich Werte von einer Funktion zurück geben.
Wer sich nicht erinnert: Die Funktion wird dadurch beendet.
Man kann return auch ohne Wert benutzen:

return;

…einfach, um die Funktion zu beenden. Das hat einen ganz einfachen nutzen: Man spart sich jede Menge geschweifter Klammern. Denn anstatt einen riesigen Anweisungsblock einer Funktion komplett in eine If-Anweisung zu packen (man denke nur ans nachträgliche Einrücken…), kann man einfach die Funktion am Anfang mit diesem Code versehen:

if(!wirdGemacht)
  return;
//...

Break ist ein Befehl, der ähnlich wie return verwendet wird, er beendet aber nicht die Funktion, sondern die Schleife, in der er steht.
Logischerweise gibt’s hier keinen Rückgabewert, Schleifen haben ja keinen.

while(zahl < 5)
{
  if(zahl == 4) //Ich würd gerne vorher abbrechen...     break;
  print("Wetten, das hier wird nicht ausgeführt, wenn zahl gleich 4 ist?");
}

Dieser Code macht nicht viel Sinn, aber break kann durchaus von großem Nutzen sein.

9. Switch-Case-Abfrage

Eine interessante Abfrage gibt es noch:
Man stelle sich vor, man hat eine Zahl, und abhängig von dieser möchte man etwas tun. Eine KI zum Beispiel hat eine Variable “modus”. Ist modus 1, so steht sie herum, bei 2 sucht sie den Spieler, bei 3 schießt sie wild umher und bei 4 tanzt sie Disco Fox. Will man das Verhalten nun abhängig vom Modus gestalten, bietet sich theoretisch eine Reihe von If-Abfragen an:

if(mode == 1)
 Idle();
else if(mode == 2)
 Search(player);
//usw.

Das ist etwas unschön und verstößt auch gegen einige Regeln für sauberes Programmieren. Ändert man nämlich den Namen der Variable, schaut man doof aus der Wäsche. Deshalb schafft switch-case Abhilfe. Der Code oben lässt sich in einer Case-Abfrage so ausdrücken:

switch(mode)
{
  case 1:
    Idle();
    break;
  case 2:
    Search(player);
    break;
 //usw. }

Das break ist wichtig, weil die Engine ohne das Schlüsselwort auch bei einer Übereinstimmung den Switch-Block weiter abarbeitet. Sollte in einem Case-Block “return” mit Sicherheit aufgerufen werden, darf man sich das break natürlich sparen.
Ein Schlüsselwort gibt es noch: default.

switch(mode)
{
  default:
    //... 
  break;
}

Der Code in einem default-Block wird immer ausgeführt und kommt daher z.B. an die Reihe, wenn mode aus irgendeinem Grund -1 ist. Er kommt nach allen case-Blöcken vor Ende des Switch-Blocks. Er sollte samt break immer vorhanden sein, auch wenn kein Code darin steht, sonst gibt es ja kein break!

10. Abschließende Worte

All das hat in Unity überhaupt keinen direkten Nutzen gehabt. Wir haben ja nicht einmal einen neuen Script geschrieben. Aber sicherlich kannst Du Dir denken, dass man ohne Abfragen und Schleifen nicht weit kommt.

Da das Kreieren von Spiele nicht nur dem Erstellen von Objekten und die Animationen von diesen besteht, möchte ich hier eine kurze Einführung in Javascript präsentieren. Dieses Tutorial besteht aus drei einzelnen Teilen, welche aufeinander aufbauen.

        1. Die Grundlagen

Wer Unity 3D schon einmal gestartet und sich ein wenig damit beschäftigt hat, hat vielleicht schon folgendes erkannt:

• Ein Spiel besteht aus mehreren Szenen (Level)
• Eine Szene besteht aus den mehreren GameObjects
• Ein GameObject besteht aus mehreren Components

Ein GameObject ist eine Instanz, was soviel bedeutet wie, dass es aus nichts besteht. Es hat keine Form oder Animation. Erst das Hinzufügen von Komponente definiert das Aussehen und das Verhalten von GameObjects.
Wenn man dem Gameobjects nun also ein Mesh hinzufügt, so ist dieses später auch im Spiel sichtbar. Ein zusätzlicher Script veranlasst, dass dieses GameObject auch einem bestimmten Verhalten folgt.

Es ist also für das Kreieren von Spielen notwendig, auch das Programmieren zu beherrschen, denn ohne Scripts lässt sich das Spiel nicht steuern.
Zwar stellt Unity 3D einige nützliche Scripts zu Verfügung, doch reichen diese nicht aus um ein anständiges Spiel zu machen.

In Unity 3D verwendet man ein anderes System für die Scripts als in vergleichbaren Engines.
Nicht ein Script steuert alle GameObjects – was die Übersichtlichkeit und Einfachheit beeinträchtigt -, sondern jedes GameObject besitzt seinen eigenen Script.
Natürlich kommt es auch vor, dass ein Script bei mehreren GameObjects Verwendung findet.

                1.1 Die Variablen

Eine Variable besteht im Grunde aus drei Bestandteilen: Aus einem Namen, einem Datentyp und dem passenden Wert.
Sie sind notwendig, um beim Programmieren Werte zu speichern, Rechnungen durchzuführen oder Wert übergeben zu können. Ohne Variablen könnte man – schlicht gesagt – nicht programmieren.

Ein Dateityp bestimmt welche Art von Wert eine Variable beinhaltet.
So enthält eine Integer-Variable eine Ganzzahl und kann keine Buchstaben bzw. andere Zeichen speichern. (Abgesehen vom Vorzeichen)
Eine String-Variable beinhaltet hingegen einen Zeichenfolge, z.B. “Hallo”. Bei dieser Art von Variable können allerdings alle Zeichen gespeichert werden, z.B. “Hallo123@”. Allerdings kann man mit dieser String-Variable nicht rechnen.
Was dies genau bedeutet, werdet ihr später erkennen.
Es gibt unendlich viele Dateitypen, zumal man sich eigene Dateitypen schreiben kann – sogenannte Klassen.
Ihr werdet allerdings für den Anfang nur folgende primitive Dateitypen benötigen:

• int – Integer-Variable um Ganzzahlen zu speichern
• float – Float-Variable um Kommazahlen zu speichern
• double – Double-Variable um Kommazahlen mit hoher Genauigkeit zu speichern
• boolean – Boolean-Variable um Wahrheitswerte – Wahr und Falsch – zu speichern
• string – String-Variable um eine Zeichenfolge zu speichern

Eine Variable wird in Javascript wie folgt deklariert:

var name;

Das “var” wird vom Editor blau unterlegt, um zu kennzeichnen, dass es sich um einen bekannten Befehl handelt und gibt dem Compiler bekannt, dass man hier eine Variable deklarieren möchte
Direkt an das “var” anschließend folgt der Name der Variable.
In Javascript ist es üblich die Namen kleinzuschreiben.
Weiters sind folgende Regeln, bei der Namensgebung zu beachten:

• Nur Buchstaben und Ziffern
• Keine Sonderzeichen, Umlaute oder Leerzeichen, ausgenommen Tiefstrich “_”
• Name muss mit einem Buchstaben beginnen

Man kann der Variable direkt bei der Deklaration auch einen Wert zuweisen.
Dafür verwendet man einfach das “=”. In anderen Programmiersprachen muss man dafür allerdings auch zuvor bekannt geben, um welchen Dateitypen es sich handelt.
Nicht so in Javascript. Die Programmiersprache findet von selbst heraus, welcher Typ übergeben wird.
Eine Wertübergabe bei der Deklaration sieht wie folgt aus:

var name = 123;

Javascript definiert nun “name” als Integer-Variable, da es sich bei dem Wert um einen Integer handelt.
Das Erkennen des Dateitypen beeinflusst allerdings die Performance des Scripts, weswegen man immer den Dateitypen von Hand bekanntgeben sollte.
Die macht man mit einem “:”

var name : int = 123;

Natürlich muss man den Wert nicht direkt bei der Deklaration bekannt geben, sondern kann ihn auch später zuweisen.

var name : int;
name = 123;

Man wird dies so nicht schreiben, allerdings könnte es sein, dass man eine Rechnung durchführen will, wodurch man eine leere Variable benötigt, in welche das spätere Ergebnis gespeichert werden soll.

Euch sind vielleicht die Semikolon “;” nach jeder Zeile aufgefallen. Diese sind notwendig um einen Befehl abzuschließen und werden somit auch nach jedem Befehl benötigt. Es gibt ein paar Ausnahmen, bei welchen kein Semikolon notwendig ist.

In Unity 3D gibt es ein Fenster namens Inspector in welchen sich die einzelnen Variablen der Scripts auch einstellen lassen. Deklariert man nun so wie oben gezeicht eine Variable, erscheint diese mit ihrem Namen im Inspector.
Will man dies allerdings nicht, so muss man eine Variable als “private” markieren.

private var name : int = 123

Diese Variable wird nicht im Inspector erscheinen, wodurch sie sich auch nicht von außerhalb verändern lässt.

Hat man nun einen Script bei mehreren GameObjects in Verwendung und stellt man im Inspector eines GameObjects den Wert einer Variable um, so wird nur der Wert des einzelnen GameObjects verstellt und nicht die Werte aller GameObjects.
Verändert man allerdings einen Wert im Script selbst, so wird der Wert bei allen GameObjects verändert.

                1.2 Die Funktionen

Eine Funktion ist das entscheidende in jeder Programmiersprache. Sie enthält die einzelnen Anweisungen, wie z.B Wertzuweisungen, Rechenschritte oder ruft eine weitere Funktion auf. Eine Funktion wird wie folgt deklariert:

function Name ()
{
//Die einzelnen Anweisungen
}

Bei der Namensgebung sind die Regeln wie bei den Variablen zu beachten, nur das der erste Buchstabe groß geschrieben wird.
Zwischen den runden Klammern ”(” und “)” stehen die Parameter, welche beim Aufrufen der Funktion übergeben werden müssen. Dies werden ihr noch nicht verstehen, da noch die Grundlagen dazu fehlen. Später dazu mehr.
Zwischen den geschweiften Klammern “{” und “}” stehen die Anweisungen welche die Funktion später durchführen soll.

Bei der Deklaration von Funktionen ist kein Semikolon notwendig.

Ruft man nun eine Funktion in einer Funktion auf, so wird die aufgerufene Funktion zuerst abgearbeitet und gibt anschließend – wenn so programmiert – einen Rückgabewert zurück.
Eine Funktion wird wie folgt aufgerufen:

funktion Name ()
{
AufzurufendeFunktion ();
}

Dazu ist allerdings notwendig, dass die aufzurufende Funktion auch existiert, da ansonsten der Script nicht funktioniert und eine Fehlermeldung ausgegeben wird.

In Unity 3D gibt es drei vordefinierte Funktionsnamen:

• Awake ()
  Wird aufgerufen, wenn das GameObject initialisiert wird
• Start ()
  Wird aufgerufen, wenn das GameObject fertig initialisiert worden ist
• Update ()
  Wird bei jedem neuen Frame (Bild) aufgerufen

                1.3 Die Parameter

Beim Aufrufen einer Funktion können Parameter übergeben werden, mit welchen dann die aufgerufene Funktion weiterarbeiten kann. Diese Parameter müssen allerdings schon beim Schreiben der Funktion deklariert werden.

function Addieren (zahl : int)
{
return (zahl + 2);
}

Diese Funktion enthält auch schon den Befehl “return”, welcher im Kapitel “Der Rückgabewert” weiter behandelt wird.
Hier ist nur zu wissen, dass diese Funktion eine Zahl mit 2 addiert und das Ergebnis danach als Rückgabewert an die aufrufende Funktion zurückgibt. Ruft man also die Funktion wie folgt auf:

function Name ()
{
Addieren(3);
}

… so erhält man den Wert 5 zurück.

Zusammengefasst bedeute dies nun: Man deklariert beim Schreiben einer Funktion die einzelnen Parameter, welche beim späteren Aufrufen der Funktion übergeben werden müssen. Die Funktion kann dann mit diesen übergebenen Parameter/Werten weiterarbeiten.

Natürlich kann man alternativ auch eine Variable mit dem passenden Dateitypen übergeben. Wenn wir nun die zuvor geschriebene Funktion “Addieren (zahl : int)” verwenden:

var geschwindigkeit : int = 10;

function Update ()
{
Addieren(geschwindigkeit);
}

… so wird die Variable “geschwindigkeit” jedes Frame um 2 erhöht.

Dabei ist natürlich zu beachten, dass die übergebenen Parameter auch die richtigen Dateitypen besitzen.

                1.4 Der Rückgabewert

Der Rückgabewert ist jener Wert, den eine Funktion zurückgibt, wenn sie beendet wird. Beispielsweise kann eine Funktion eine bestimmte Rechnung durchführen und danach das Ergebnis als Rückgabewert an die aufrufende Funktion zurückgeben, damit diese mit dem Ergebnis weiterarbeiten kann. Natürlich könnte man auch die Rechnung direkt in der aufrufenden Funktion durchführen, aber durch das verschachteln der Funktionen wahrt man die Übersichtlichkeit. Außerdem kann es vorkommen, dass man eine bestimmte Rechnung mehrmals im Programmcode benötigt, wodurch man sich das mehrmalige Schreiben der Rechnung erspart und stattdessen nur immer wieder die benötigte Funktion aufruft.

Das Schlüsselwort für einen solchen Rückgabewert ist “return”. Sobald return aufgerufen wurde, beendet sich die Funktion, wodurch es natürlich immer am Ende steht.
Als Beispiel werde ich eine Funktion schreiben, welche die Quadratzahl eines übergebenen Parameters ausrechnet und das Ergebnis danach zurückliefert.

function Quadratzahl (zahl :  int)
{
zahl = zahl * zahl;
return zahl;
}

Wie man sieht, rechnet diese Funktion das Quadrat des übergebenen Parameters aus und gibt in zurück.
Alternativ dazu kann man die Rechnung auch so durchführen lassen:

function Quadratzahl (zahl :  int)
{
return zahl * zahl;
}

Die lässt sich aber natürlich nur bei einfachen Rechnungen so durchführen.

Ruft man diese Funktion nun in einer anderen Funktion auf, so erhält man das Ergebnis zurück. Um dies zu veranschaulichen, habe ich folgendes Programm geschrieben:

var ergebnis : int;
var zahl : int = 5;

function AufrufendeFunktion ()
{
ergebnis = QuadratZahl (zahl);
}

Dieses Programm ruft die Funktion “QuadratZahl(zahl : int)” auf und übergibt ihr den Wert 5. Diese wiederrum liefert den Wert 25 zurück, welcher in der Variable “ergebnis” gespeichert wird.
Dies ist ein sehr einfaches Beispiel, aber es veranschaulicht alle Themen, welche in diesem Tutorial durchgenommen wurden.

        2. Was haben wir gelernt…

Ihr habt nun die Grundlagen für das Programmieren in Unity gelernt, allerdings fehlen hier noch einige wichtige Themen. Diese werden aber in den folgenden Teilen behandelt.
Nach diesem Tutorial wisst ihr:

• wie man Variablen korrekt deklariert
• … und diese auch im Programmcode verwendet
• Funktionen schreibt
• … und aufruft
• Parameter benutzt
• Rückgabewerte verwendet

Wie euch vielleicht aufgefallen ist, habe ich hier schon einige simple Rechenoperatoren wie + (addieren) und * (multiplizieren) verwendet. Diese werden noch in den folgenden Teilen genauer untersuchen.
Weiters habe ich auch den Programmcode im inneren einer Funktion eingerückt. Dies soll die Übersichtlichkeit fördern. Generell ist es so, dass man Programmcode, welcher sich innerhalb einer Funktion oder Schleife (wird noch behandelt) einrückt.

Aber was ist Blender Planet eigentlich??
Kurz gesagt werden auf dieser Website deutschprachige Tutorials frei zur Verfügung gestellt.
Die Idee dazu hatte ich schon seit geraumer Zeit, da sich im Web nur englische Tutorials zu Blender finden lassen, welche gleichzeitig auch qulitativ hochwertig sind. Um aber auch denjenigen einen Einstieg in Blender zu ermöglichen, die nicht so fit in Englisch sind, habe ich mich dazu überrungen endlich mit dem Projekt “Eigene Homepage” anzufangen.

Nun aber zu meiner Person:
Mein Name ist Lukas Huber und habe mich mit meinen 17 Jahren schon 5 Jahre lang mit Blender beschäftigt.
Als ich mir mit 11 das Programm zum ersten Mal heruntergeladen habe, habe ich es installiert, geöffnet und daraufhin sofort wieder geschlossen. Die unübersichtliche Oberfläche war damals zu kompliziert und hätte zu viel Zeit gebraucht um mich einzuarbeiten. Kurz darauf habe ich es wieder deinstalliert. Vielleicht wäre auch noch dazu zu sagen, dass es sich damals um die Version 2.49 handelte.
Ein Jahr später hatte mich nochmals die Neugierde gepackt, woraufhin ich es wieder installierte. Von da an habe ich mich geduldig mit Blender beschäftigt und will mein Wissen nun auch an andere weitergeben.

PS: Da sich die Website noch in der Aufbauphase befindet, kann sich das Aussehen der Website jederzeit ändern.