Alle Beiträge

  • Platformer mit LEGO®-Figuren selbst erstellen

    Platformer mit LEGO®-Figuren selbst erstellen

    René Bühling
    in

    Unter dem Begriff „Microgames“ hat Unity Ende 2019 einen Ansatz vorgestellt, bei dem ein interaktives Tutorial zum Erstellen eines Spiels direkt im Editor abläuft. In einer Kooperation mit LEGO® entstand ein neues Microgame-Tutorial bei dem Du nun in wenigen Schritten Deinen eigenen LEGO®-Platformer bauen kannst. 

    Voraussetzungen

    • Unity HUB in der Version 2.4
    • Unity Editor in der Version 2019.4 LTS
    • Du musst mindestens 18 Jahre alt sein.

    Einfacher Einstieg per Vorlage

    • Starte zunächst das Unity HUB und erzeuge ein neues Projekt.
    Projekt anlegen
    Achte darauf mindestens Unity Hub 2.4 und Unity Editor 2019.4 zu verwenden.
    • Wähle das LEGO® Microgame aus der Liste der Vorlagen aus. Bei der ersten Verwendung musst Du es per Klick noch herunterladen und installieren, was über den selben Eintrag möglich ist.
    Micrograme auswählen
    • Klicke auf Create, um die Erstellung des Projekts zu starten.
    • Gib im folgenden Fenster Dein Geburtsdatum ein, da der nachfolgende Vertrag ein Mindestalter von 18 Jahren erfordert.
    • Bestätige den Nutzungsvertrag durch Klick auf Agree & Continue.

    Warte bis Unity das Projekt erzeugt und geöffnet hat.

    Interaktive Führung durch die Funktionen

    • Klicke im Start-Bildschirm auf den Schalter Start Tutorials, um schrittweise durch das Projekt geführt zu werden.
    Tutorial starten

    Die Inhalte des Tutorials sind:

    • Kennenlernen der Szene und Beschleunigung der Figur
    • Plattform hinzufügen, um zur nächsten Insel springen zu können
    • Aktivierung der Aufzugplattform
    • Kriterien für’s Gewinnen ändern: Alles Sammeln müssen + Tod nach Zeitablauf
    • Feind hinzufügen, der schießt und zum Spieler blickt
    • Weitere Elemente einfügen, um z.B. ein Hindernis zu sprengen
    • Hochladen auf Unity Connect, so dass das Spiel im Browser spielbar ist

    Programmieren mit LEGO®-Bausteinen

    Das LEGO®-Microgame ist im Prinzip eine Sammlung aus vorgefertigten Assets, um eine Spielszene per Maus zusammen zu setzen. Es enthält zudem einige interessante Ansätze für den Bearbeitungsvorgang.

    Nicht nur die Szene, sondern auch die Programmlogik wird größtenteils über das Einfügen von Assets realisiert. Statt also Code zu schreiben, wird einfach ein spezieller LEGO­­-Bauklotz in die Szene gesetzt.

    Beispiel für gestapelte Behaviour Bricks.
    Auf der grauen Plattform sitzen ein grüner Gewinn-Stein und ein gelber Sammel-Stein. Dadurch wird das Spiel (erst) gewonnen, wenn alle Kristalle vom Spieler eingesammelt wurden.

    Mehrere Blöcke lassen sich durch Stapeln der Bauklötze in der 3D-Szene logisch verketten. Dabei kommt ein spezieller Bearbeitungsmodus zum Einsatz, der beim Verschieben ein Einrasten der Bausteine ineinander auslöst. Auf diese Weise ähnelt nicht nur die Levelgestaltung, sondern auch der Programmiervorgang dem Spielen mit LEGO®-Steinen.

    Zusammenfassung

    Mit dem LEGO®-Microgame gelingt ein schneller Einstieg in das Grundprinzip der Spieleentwicklung mit Unity über ein interaktives Tutorial. Komplett auf Drag’n’Drop basierend, lässt sich ein Jump’n’Run-Spiel genauso einfach zusammenbauen wie ein LEGO­® -Modell aus Bauklötzen. Das erstellte Spiel kann problemlos über Unity Connect im Internet veröffentlicht werden. Die Lizenzbedingungen schließen kommerzielle Produktionen jeder Art ansonsten aus.

    LEGO® ist eine Marke der LEGO Gruppe. Die vorliegende Website wird nicht von der LEGO Gruppe gesponsert, genehmigt oder unterstützt.

  • Event Bus in Unity und C#

    Event Bus in Unity und C#

    René Bühling
    in ,

    In diesem kostenlosen Mini-Kurs zeige ich Dir, wie Du Spielelemente in Unity lose koppelst. Dadurch können einzelne Elemente miteinander kommunizieren, ohne dass feste Verbindungen entstehen, die z.B. die Arbeit mit Prefabs oder Modulen erschweren würden.

    Konkret sehen wir uns an, wie der Zustand von Szenenobjekten (z.B. Gebäude) im UI dargestellt werden kann. Ist das System aufgebaut, können sowohl UI als auch Szenenobjekte beliebig im Unity-Editor verändert, arrangiert und kombiniert werden, ohne den Code ändern zu müssen. In diesem Zusammenhang bauen wir ein eigenes Event-System auf und nutzen Vererbung in C#, um unseren Code nach Bedarf zu abstrahieren oder konkretisieren.

    [gdpMediathek playURL="https://v26.gamedev-profi.de/lektionen" list="tag-course_QUP"]
  • Lokale Variablen vs. Klassen-Member

    Lokale Variablen vs. Klassen-Member

    René Bühling
    in

    Variablen werden im Code an unterschiedlichen Stellen angelegt, mal innerhalb, mal außerhalb von Funktionen. Worin liegt der Unterschied?

    Variablen werden an unterschiedlicher Stelle angelegt, was ist der Unterschied?

    Der nachfolgende Artikel bezieht sich auf C#, in der Umgebung der Unity-GameEngine.

    Variablen

    Eine Variable ist ein Element der Programmierung bei der ein Speicherplatz festgelegt wird, um Daten über mehrere Befehle hinweg „festzuhalten“. Im Wesentlichen sind zwei Grundoperationen zu unterscheiden:

    • Beim Deklarieren der Variable wird dem Programm mitgeteilt, dass der Speicherplatz überhaupt benötigt wird. Neben dem Namen wird zudem die Art der enthaltenen Daten angegeben.
      • Beispiel: int alter; legt einen Speicherplatz namens alter an, der sich eine Ganze Zahl (Integer) „merken“ kann.
      • Eine Variable kann und muss innerhalb ihres Gültigkeitsbereichs, nur einmal deklariert werden.
    • Beim Zuweisen wird festgelegt, welche Daten in der Variablen enthalten sind.
      • Beispiel: alter=21; könnte z.B. das Alter einer Person von 21 Jahren festlegen.
      • Der Wert einer Variablen kann im Allgemeinen beliebig oft geändert und neu zugewiesen werden.

    Member-Variablen

    Umfangreichere Datenstrukturen wie z.B. die Eigenschaften einer Person werden in Klassen zusammengefasst:

    class Person
{
    int alter;
    string name;
}

    Die Klasse ist ein Datensatz, der eine Person beschreibt und zwar mit den Eigenschaften Alter und Name.

    Um die „Startwerte“ festzulegen, die in diesen Variablen enthalten sind, können Zuweisungen direkt bei der Deklaration oder innerhalb einer Funktion wie z.B. BeiGeburtstag erfolgen:

    class Person
{
    int alter=0;
    string name="Baby";
    
    ... BeiGeburtstag()
   {
        alter=alter+1;    // Das Alter erhöht sich um 1 Jahr
   }
}

    Da die Variablen alter und name zur Struktur Person gehören, spricht man von Membervariablen, also „Mitgliedern“ der Klassenstruktur.

    Sichtbarkeitsmodifikatoren public, private und protected

    Membervariablen werden mit einem Sichtbarkeitsmodifikator dekoriert, der beeinflusst, welche Programmteile Zugriff auf die Variable haben:

    class Person
{
    private int alter=0;
    public string name="Baby";  
    
    ... BeiGeburtstag()
   {
        alter=alter+1;    // Das Alter erhöht sich um 1 Jahr
   }
}

    Neben gewissen Sicherheitsaspekten werden diese Sichtbarkeitsmodifikatoren dazu verwendet, um komplexen, modularen Code wartbarer zu halten. Sie helfen Abhängigkeiten nachzuvollziehen und zu erkennen welche Programmteile ’nur intern‘ verwendet werden.

    • public erlaubt allen Code-Bereichen auf dieses Feld zuzugreifen.
    • private erlaubt nur Zugriff von Funktionen, die innerhalb der selben Klassen deklariert sind. Auf alter kann z.B. nur die Funktion BeiGeburtstag zugreifen.
    • protected sperrt (wie private) den Zugriff von anderen Klassen, erlaubt aber abgeleiteten Klassen (Einwohner als Erweiterung von Person) auf das Feld zuzugreifen.

    Variablen die als Felder einer Klasse deklariert werden, bleiben im Speicher bestehen, so lange das Objekt (hier eine Person) auch im Speicher besteht. Es wäre folglich sehr ineffizient jeglichen Wert als Klassenfeld zu deklarieren.

    Lokale Variablen

    Variablen die innerhalb einer Funktion deklariert werden, sind auch nur dort präsent. Sie verfügen über keinen Sichtbarkeitsmodifikator, da sich die Sichtbarkeit aus dem Ort der Deklaration ergibt:

    class Person
{
    private int alter=0;
    public string name="Baby";  
    
    ... Aktualisieren()
   {
        // Speicher für Jahre wird erst hier konsumiert
        int aktuellesJahr=2020;
        int geburtsJahr=1999;
        alter=aktuellesJahr-geburtsJahr;    // Das Alter errechnet sich
        // Speicher für Jahre wird hier wieder freigegeben
   } 
}

    In diesem Beispiel errechnen wir das Alter in einer Aktualisierungsfunktion. Da wir die für die Berechnung nötigen Jahreszahlen nur kurzzeitig für das Ausrechnen benötigen, werden aktuellesJahr und geburtsJahr lokal innerhalb der Aktualisieren-Funktion angelegt. Dadurch wird der nötige Arbeitsspeicher erst bei Ausführung der jeweiligen Programmzeile angelegt und wieder freigegeben, wenn die Funktion zu Ende ist, also } erreicht wird.

    Zusammenfassung

    Lokale Variablen und Membervariablen unterscheiden sich vor allem durch die Dauer des Speicherverbrauchs im Codeverlauf und die Sichtbarkeit für andere Code-Teile.

    Lokale Variablen werden innerhalb eines Code-Abschnitts angelegt und wieder freigegeben. Sie eignen sich für Kurzzeitspeicher, also wenn mal kurz was für eine Berechnung gespeichert werden muss, danach aber nicht mehr benötigt wird. Lokale Variablen sind nur für Code im selben Codeabschnitt/Block zugänglich.

    Membervariablen sind ein Teil einer komplexeren Datenstruktur (Klasse), die im Speicher liegt, so lange das gesamte Objekt existiert. Sie eignen sich für Datenblöcke die längerfristig oder von mehreren verschiedenen Programmteilen benötigt werden. Welche Programmteile Zugriff auf die Membervariablen haben, wird durch die Sichtbarkeitsmodifikatoren public, private und protected gesteuert.

    Dass die Sichtbarkeit von Membervariablen in Unity auch den Inspector beeinflusst ist übrigens eher ein zweitrangiger Nebeneffekt seitens Unity, nicht der allgemeinen C#-Sprache selbst.

  • 3D Cursor für Unity

    3D Cursor für Unity

    René Bühling
    in

    Bereits seit 2015 ist mein Asset-Paket Hand Cursors for Mystery Adventure im Unity Asset Store erhältlich. Mit dem Update 2020 kommen nicht nur einige häufig nachgefragte Posen hinzu, sondern auch eine komplett neue Fassung, die auf Echtzeit-3D-Modellen basiert.

    Video: Das ist neu (Englisch)

    Update der 2D-Version

    Die klassische Version basiert auf Renderings, d.h. die Hand wird in Form eines statischen Bilds als Mauszeiger gesetzt.

    • Neue Posen: Links, Rechts, Kampf und Zoom.
    • Die 2D-Version bleibt im Paket archiviert, wenngleich sich die neue Version hauptsächlich um die 3D-Version dreht.
    Vorschau der 2D-Cursor
    Überblick der 2D-Cursor

    Neu: 3D-Version

    Wer Myst IV^ kennt, wird sich an die dort auftauchende 3D-Hand erinnern. Die neue 3D-Version meines Cursor-Pakets verfolgt einen ähnlichen Ansatz, bei dem das Modell einer menschlichen Hand direkt über die Unity GameEngine dargestellt und als Mauszeiger verwendet wird.

    Posen der 3D-Hand

    • Kategorie Navigation:
      Vorwärts, Links, Links (Variante), Rechts, Zurück, Zoom, Verboten
    • Kategorie Interaktion:
      Zeigen, Tippen, Greifen, Ziehen, (Kombination Greifen+Ziehen), Ablegen, Aufnehmen, Einsetzen
    • Kategorie Spezial:
      Kämpfen, Lesen, Zaubern, Zaubern (Variante), Handauflegen, Fingerspreizen
    Überblick über die 3D-Posen

    Neue Funktionen

    • Weiche, animierte Übergänge zwischen den Posen.
    • Separate Beleuchtungsmodelle für Handcursor und Szene möglich. (Youtube)
    • Einfacher Austausch und Erweiterung des „Cursor-Symbols“ (Objekte, die in einigen Posen in den Fingern gehalten werden). (Youtube)
    • Funktioniert für 3D-Objekte (Youtube) wie auch 2D/GUI-Elemente (Youtube)!

    Hilfsmittel und Editor-Werkzeuge

    • Script-Module für leichten Einbau und Anpassung.
    • Hilfsmittel für Fehlersuche und Testen.
    • Enthält integrierte Optimierungen und Stellschrauben für weichere und optisch attraktivere Übergänge. (Youtube)
    • Verbesserte Isolation von Demo-Code, so dass sich dieser auf Wunsch sehr leicht löschen lässt.

    Tutorials und erweiterte Dokumentation

    • Inkl. neue, umfangreiche Dokumentation als PDF.
    • Erklärvideos und Tutorials erleichtern den Einbau in Dein Projekt.

    Youtube-Playlist aller Videos (Englisch)

    Kompatibilität

    Das Paket wurde mit Unity 2017.4.18f1 und Unity 2019.3.6f1 getestet. Es müsste theoretisch selbt mit Unity 5.3.3f1 noch laufen, aber da Unity mittlerweile Version 2017 als Mindestvoraussetzung für ihre Asset Store-Werkzeuge voraussetzen, musste ich das Produkt auf Version 2017 hochstufen.

    Hand-Cursor-Set
    Jetzt hier kaufen
  • Unterschied der Pipelines LWRP, URP und HDRP

    Unterschied der Pipelines LWRP, URP und HDRP

    René Bühling
    in

    Beim Thema Grafikpipelines geht es in erster Linie um die Art und Weise wie das Rendering innerhalb der Programmierung abläuft. Daher kann auch ein Low-Poly-Modell in eine High-Pipeline eingebaut werden. Low-Poly-Modellierung und High-Definition-Rendering sind zwei unterschiedliche technische Bestandteile, das eine hat zunächst wenig mit dem anderen zu tun. Auch wenn die neue Unreal 5-Demo behauptet, dass die Polygonanzahl quasi keine Rolle mehr spielen soll, bin ich skeptisch, ob das in der Praxis so funktionieren wird, wie es in der Demo suggeriert wird. Grundsätzlich ist es immer noch ratsam, so wenig wie möglich und so viele Polygone wie nötig zu modellieren.

    Built-in Render Pipeline

    Die eingebaute Render-Pipeline ist der Standard-Renderer, den Unity in der Vergangenheit einsetzte. Er ist einfach zu verwenden, aber nur begrenzt durch eigenen Code ansprechbar und erweiterbar. Ich vermute, dass dieser Renderer früher oder später durch die URP abgelöst wird (siehe unten).

    LWRP – Light Weight Render Pipeline

    Die Light Weight Render Pipeline (LWRP) ist ein minimalistischer Ansatz, der mit geringer Hardwareleistung auskommt und sich daher z.B. für Mobilgeräte eignet. LWRP wurde in Unity 2019.3 durch die URP ersetzt.    

    URP – Universal Render Pipeline

    Die Universal Render Pipeline (URP) ist quasi der neue Standard-Renderer in Unity, der eine breite Plattformunterstützung und leistungsfähige Darstellungseffekte bietet, die sich zudem leicht per Code ansteuern lassen. In den meisten Fällen wird das vorerst die beste Wahl sein, um ein stabiles Produkt zu erzeugen, das weitestgehend überall problemlos läuft. Da viel vorbereitet ist entsteht relativ wenig Programmier- und Wartungsaufwand, weshalb sich dieser Renderer auch kleine Teams eignet.

    HDRP – High Definition Render Pipeline

    Die High Definition Render Pipeline (HDRP) zielt darauf ab, die maximale Darstellungsleistung aus der Hardware heraus zu holen und dadurch sehr realistische und detailreiche Ergebnisse zu erreichen. Dieser Mechanismus ist sehr komplex, anspruchsvoll, hardwareabhängig und wartungsintensiv. Man braucht hier in der Regel einen eigenen Programmierer, der sich nur mit der Grafikprogrammierung und Optimierung beschäftigt. Daher eigenet sich HDRP auch eher für große Teams und weniger für Einzelkämpfer oder Kleinteams. HDRP unterstützt derzeit scheinbar nur einen kleineren Teil der Funktionen im Vergleich zu URP.

    Projekte verwenden nur eine der Pipelines

    Die Pipelines sind untereinander nicht kompatibel, da sie unterschiedliche Darstellungsansätze und Softwarekonzepte benutzen, die sich nicht mischen lassen.

    Es handelt sich auch nicht unbedingt um Qualitätsstufen, also HDRP ist nicht die bessere Version von LWRP, sondern es ist in erster Linie ein anderer technischer Ansatz.

    Link: Entscheidungshilfe zur Renderpipeline

  • 3D-Gestaltung mit Blender 2.8 und Eevee lernen

    3D-Gestaltung mit Blender 2.8 und Eevee lernen

    René Bühling
    in ,

    Das große Update von Blender auf die Version 2.8 hat teils so gravierende Änderungen nach sich gezogen, dass viele Tutorials überarbeitet werden müssen. In diesem Zusammenhang habe ich meinen neuen Videokurs für Blender 2.8 und Eevee veröffentlicht, der eine komplette Überarbeitung, Optimierung und Neuausrichtung meiner Einführung in die 3D-Gestaltung darstellt.

    Lerne die essentiellen Grundlagen von 3D-Design mit aktuellster Technik!

    In diesem Videokurs erwarten Dich mehr als 10 Stunden Videomaterial in über 150 Lektionen. Er ist ein Basiskurs, der sich an Anfänger richtet, die ohne Vorwissen in kürzester Zeit einen umfangreichen Einblick in Blender gewinnen wollen.

     

    Blender 2.8 von A bis Z! – Inhalt des Kurses

    • Animation, Übungsaufgaben, Alpha, Ambient Occlusion, Aura, Ausschnitt
    • Bevel, Bridge, Baumgenerator, BSDF, Bump, Beleuchtungsmodell, Bloom, Bogenverlauf, Beziér, Bildformat
    • Cycles, Clearcoat
    • Datenblock, Drehmaschinenobjekt, Displace, Dopesheet
    • Eevee, Easing, Extrusion, Edges, Emission, Evaluation Time, Einzelbildsequenz
    • Faces, Fake Light, Fortschrittsanzeige, Filmdatei
    • Grundkörper, Graph-Editor, Glas, Generator
    • HDRI, Hierarchien
    • Indirektes Licht, Inset Faces
    • Join
    • Kamera, Kopie & Klon, Keyframes, Knife, Kurven, Konvertieren, Kurvenmodifikatoren
    • Layouts, Lichter, Loopcut, Lathing, Lattice
    • Meshmodelling, Modifikatoren, Material, Merge, Measure, Metaballs, Metallic, mp4
    • Node-Editor, Nebenläufige Bewegungen, Nachfolge
    • Optimieren, Outliner
    • Programmoberfläche, Primitive, Prozedurale Texturen, Parametrische Objekte, Pfadanimation, Platzhalter, Probleme
    • Quick Favorites
    • Renderer, Rip, Roughness, Refraction, Record Button, relative Pfade
    • Splines, Subdivision, Split, Smoothing, Sweep, Surfaces, Specularity, Schatten, Stauchen und Strecken, Shape Keys
    • Texturen, Spline Types, Taper, Text, Transparenz, Timing
    • Unsichtbare Bereiche
    • Vertices, Vorausnahme, Videoschnitt
    • Wave-Modifikation
    • X-, Y– und Z-Arbeitsräume
    • Zeitleiste
    • … und mehr!

     

     

    Trainingskonzept: Theorie + Tutorial + Übung

    Dieser Kurs ist leicht verständlich, einfach nachzuvollziehen und dennoch herausfordernd:

    • Ich erkläre Dir Hintergründe und theoretische Ansätze in einfachen, kleinen Schritten.
    • Danach zeige ich Dir an einem ganz einfachen Beispiel, wie es in der Software funktioniert. Hier werden KEINE fertigen Modelle vorausgesetzt, von denen Du nicht weißt, wie sie entstanden sind!
    • In jedem Kapitel erhältst Du Aufgabenstellungen in denen Du das Gezeigte selbst umsetzen sollst. Die Aufgabenstellungen sind überschaubar und leicht nachzuvollziehen. Wenn Du mal nicht weiter weißt, kannst Du Dir im Video die Lösung ansehen und mitmachen.

    Wir bauen in diesem Kurs konkret die folgenden Modelle:

    • Turm aus Bauklötzen
    • Tube
    • Raupe
    • Cupcake mit Farbgestaltung und Beleuchtung
      • Tischtuch
      • Sahnehaufen
      • Sirup-Kirsche
      • Papierbecher
      • Glückwunschtext + Animation
      • Discokugel + Dreh-Animation
      • Flasche
    • Fußball + Animation

    Selbst wenn Du noch Anfänger bist, bringe ich Dir alle Grundlagen bei, die Du brauchst. Wenn Du Gestalter oder Künstler bist, lernst Du hier, wie Du Deine kreativen Ideen in Form interaktiver und animierter 3D-Objekte umsetzt.

    Hier einschreiben

  • Soll ich Informatik, Game-Development oder Multimedia studieren?

    Soll ich Informatik, Game-Development oder Multimedia studieren?

    René Bühling
    in

    Dieser Artikel ist als Hilfestellung für Schüler/innen gedacht, die kurz vor dem Abschluss stehen und sich beruflich in Richtung Spiele-Entwicklung orientieren wollen.

    Wenn eine professionelle Karriere im Bereich Game- (oder allgemein Software-)Entwicklung angestrebt wird, könnte ein Studium in diesem Bereich in Frage kommen. Ein Studium oder eine ähnliche spezialisierende Fachausbildung ist meines Erachtens einer der besten Wege, um professionelles Fachwissen zu erlangen und zudem eine für den Arbeitsmarkt relevante Qualifikation zu erreichen.

    Die Professoren und Dozenten verfügen über entsprechendes Expertenwissen, der Studienplan sieht ein Durchlaufen aller relevanten Inhalte vor und es gibt viele praktische Projekte. Durch die persönliche Betreuung können auch individuelle Fragen geklärt werden. Ein Studium hat außerdem die angenehme Eigenschaft, dass man wegen der hohen fachlichen Spezialisierung mit vielen anderen Studenten zusammen ist, die sich für die selben Dinge interessieren.

    Wie jeder Beruf ist auch ein Studium nicht für jeden geeignet. Im Zweifelsfall kann man es aber auch relativ einfach ausprobieren und ggf. wieder abbrechen.

    Studiengänge

    Welche Studienrichtung gewählt wird, hängt in erster Linie von den eigenen Interessen und langfristigen Ziele ab. Es gibt im Wesentlichen drei Arten von Studienprogrammen, die im Bereich Spieleentwicklung in Frage kommen:

    1. Reine Informatik

    Sehr allgemein und eine passende Vorbereitung für computer-technische Jobs jeder Art.

    Spiele-Projekte kommen hier vor, aber meist nur am Rande. Wenn einem Spiele-Entwicklung wichtig ist, kann dieses Feld zu einseitig sein, weil wichtige Grundlagen, z.B. die der künstlerischen Gestaltung, im reinen Informatik-Studium fehlen.

    Reine Informatiker arbeiten später meist auch rein am Code. Informatik ist beruflich sehr zukunftssicher, erfordert aber viel technisch-abstraktes Arbeiten. Ein Bachelor-Informatik-Studium dauert etwa 3-4 Jahre.

    2. Reines Game-Development

    Spezialisierung auf reine Spiele-Entwicklungs-Jobs. Kann auch als spätere Zusatzfortbildung in Frage kommen.

    Hier sollte man sorgfältig prüfen, welche Art von Schule gewählt wird und wie genau sie ausgerichtet ist. In den letzten Jahren sind viele Games-Schulen entstanden, die rein Spiele-Entwicklung behandeln. Man bekommt hier auch einen sehr guten Start in die Games-Welt, ist aber relativ stark auf Spiele-Entwicklung festgelegt.

    Obwohl man mit einem solchen Abschluss vermutlich auch keine all zu großen Probleme haben dürfte, einen Job (ggf. auch außerhalb Games) zu bekommen, liegt die Gefahr hierbei darin, sehr auf Spiele-Entwicklung festgelegt zu sein, weil die breitere Ausrichtung fehlt.

    Eine Games-Ausbildung an einer privaten Schule dauert ca. 1-2 Jahre und kann mit Studiengebühren verbunden sein.

    3. Multimedia (Mischung aus Informatik und Design)

    Ein traditionelles Studium (wie reine Informatik), aber mit der Ausrichtung auf interaktive Medien.

    Hier spielt der künstlerische Aspekt eine große Rolle. Multimedia-Studiengänge wurden mit dem Ziel konzipiert, dass die Studenten am Schluss ‚Programmierer, die auch etwas von Gestaltung verstehen‘ oder ‚Künstler, die Ideen auch technisch umsetzen können‘ herauskommen.

    Spiele-Projekte kommen hier an verschiedenen Stellen vor, es werden aber auch andere Projekte bearbeitet, die ebenfalls multimedialen Charakter haben. Da mir die Mischung aus Technik und Gestaltung immer sehr am Herzen lag, habe ich selbst Multimedia studiert und unterrichte heute in diesem Bereich. Daher ist diese Variante natürlich mein Favorit. ?

    Langfristig denken

    Generell wird man mit allen drei Ausbildungsrichtungen später Jobs bekommen, da sie alle eine gemeinsame technische Basis haben, die sich auch auf andere Bereiche übertragen lässt.

    Spiele-Entwicklung ist sogar eher umfangreich, da es das Zusammenspiel vieler einzelner Teilbereiche erfordert. Es gibt viele Jobs bei denen quasi ein Teilbereich dessen was man bei der Spiele-Entwicklung macht, genügt, so dass man tendenziell eher zu viel als zu wenig weiß.

    Reine Spiele-Entwicklung würde ich von den drei genannten Richtungen dennoch als die Option mit dem größten Risiko von Einschränkungen einschätzen.

    Für die Entscheidung, welchen Job man langfristig später mal macht, ist die Berufserfahrung, die man nach dem Studium sammelt, deutlich relevanter. Während des Studiums und in den ersten Jobs ist man noch relativ frei, den eigenen Weg zu finden und auch noch öfter mal zwischen Varianten zu wechseln. Das Risiko hier jetzt also etwas vollkommen falsches zu wählen halte ich für relativ gering.

    Entscheidungshilfe: Was ist mir wichtig?

    Wer sich unsicher ist, in welche Richtung der Weg führen soll, dem würde vorschlagen, sich über die bei 1-3 beschriebenen Aspekte Gedanken zu machen. Das sind in erster Linie:

    • Wie wichtig ist der gestalterisch-künstlerische Aspekt?
      •   sehr wichtig → Multimedia
      •   nicht wichtig → Informatik
    • Wie wichtig ist die Flexibilität, um später leicht auf nicht-Spiele-Bereiche ausweichen zu können?
      • wichtig → Informatik oder Multimedia
      • weniger wichtig → Game-Development

    Was lernt man in Studiengängen neben Programmieren?

    Informatik sowie Multimedia decken in der Regel essentielle Grundlagen der Computertechnik ab. Dazu gehört vieles, das nur indirekt mit Programmieren zu tun hat, wenngleich die Programmierung natürlich DAS Werkzeug zur Steuerung ist und damit auch immer im Mittelpunkt steht.

    An den vielen Hochschulen ist es dabei übrigens so, dass eher das Grundverständnis der Softwaretechnik vermittelt wird und eine konkrete Programmiersprache eher beispielhaft zum Einsatz kommt. Das ist wichtig, um später selbstständig neue Programmiersprachen erlernen zu können.

    Programmierung deckt zudem viele Teilbereiche ab. Darunter fallen die Code-Formulierung selbst, aber auch Techniken zur Berechnung von Ergebnissen, wie z.B. Grafiken oder Datenauswertungen oder die Verwendung von Datenbanken. Diese Bereiche knüpfen meist an andere Bereiche an, wie z.B. Mathematik.

    Es gibt auch Grundlagenfächer, die sich mit der generellen Funktionsweise von Computern, z.B. auch auf Hardware-Ebene, befassen. Wie viel man davon braucht, hängt vom späteren persönlichen Werdegang ab. Bei Mischstudiengängen wie Multimedia kommen noch andere Fächer hinzu, wie z.B. Zeichnen, 3D-Gestaltung, Animation usw.

    Konkrete Studieninhalte

    Du kannst übrigens ganz konkret nachlesen, was in den einzelnen Studiengängen bearbeitet wird, in dem Du Dir die „Studien- und Prüfungsordnungen“ und das „Modulhandbuch“ der Studiengänge ansiehst, die in der Regel öffentlich sind.

    Beispiele der Hochschule Augsburg:

    Bachelor Interaktive Medien (=Multimedia)

    Bachelor Informatik

    Universität oder Hochschule?

    Eine Entscheidung kann auch noch in der Wahl zwischen Universität oder Hochschule liegen. Die Universitäten sind meist theoretischer und näher an der Wissenschaft, die Hochschulen praxisorientierter. Sieh Dir dazu am besten einfach auch die Webseiten infrage kommender Schulen an.

    Zudem bieten viele Ausbildungsstätten übrigens auch Studienberatungen an, wo man hingehen und konkret besprechen kann, was die Studiengänge anbieten und was ggf. für einen selbst geeignet wäre.

    Wo finde ich Schulen für Spiele-Entwicklung?

    Die Seite www.gamesmap.de enthält eine Karte mit Games-Schulen in Deutschland.

    Sehr viele Ergebnisse liefern auch Google-Suchen, nach Begriffen wie Game Development Studium, oder Studium Game Bachelor.

    Zusammenfassung

    Für sehr viele technische Berufe ist ein Hochschul- oder Universitätsstudium erforderlich. Für Schüler, die sich für Berufe im Bereich Computerspielentwicklung interessieren, kommen in etwa drei Richtungen in Frage: reine Informatik, reines Game-Development, Multimedia als Mischform. Um in der kurzlebigen Technikwelt in Zukunft flexibel zu bleiben, empfehle ich eher allgemein ausgerichtete Studiengänge. Die konkreten Studieninhalte sind oft im Internet öffentlich einsehbar. Als Entscheidungshilfe sollte man sich bewusst mit der Frage auseinandersetzen, welche Inhalte einem persönlich wichtig sind.

  • Was bedeutet Fake Light und Fake Transparency?

    Was bedeutet Fake Light und Fake Transparency?

    René Bühling
    in

    Gelegentlich kommen unsichtbare Lichtquellen aus dramaturgischen Gründen zum Einsatz. Dabei werden Akzente durch zusätzliche Lichter gesetzt. Eine Abweichung von Realität/Physik ist erlaubt. Die Lichtquelle ist für den Betrachter unsichtbar.

    Ziel: Verbessern der Gestaltung: Plastizität erhöhen, Störende Schatten entfernen, Figur besser ausleuchten, Details im Schatten zeigen, Kontur des Objekts hervorheben.

    Was ist Fake Transparency?

    Da die Berechnung echter Transparenz relativ viel Rechenaufwand erfordert, wird durch einen transparenten Körper durchscheinendes Licht gelegentlich durch Emission des Materials simuliert. Wie überzeugend der Transparenzeffekt wirkt, hängt dabei im Wesentlichen von der künstlerischen Gestaltung und weniger von der Technik ab.

  • Jahresrückblick 2019

    Jahresrückblick 2019

    René Bühling
    in , , ,
    Feuerwerk 2019 und Logo

    Liebe Leser und Kursteilnehmer,
    ich wünsche Euch allen ein erfolgreiches, gesundes und sorgenfreies Jahr 2020! Zudem bedanke ich mich herzlich für Eure engagierte Teilnahme, großartige Unterstützung und das tolle Feedback, das mich auch 2019 so zahlreich erreichte.

    Das war 2019…

    GameDev-Profi befindet sich nun schon im dritten Jahr. Obwohl ich das Gefühl hatte, dass viele Versuche und Experimente in 2019 letztlich scheiterten, hat sich doch eine ganze Menge getan. Zeit, die Ereignisse der vergangenen zwölf Monate nochmal Revue passieren zu lassen.

    Januar 2019

    • ? Die Marke von 5000 Kursteilnehmern in meinen Kursen auf Udemy wurde erreicht.

    Februar

    März

    April 2019

    Mai

    Juni

    Juli 2019

    • ? Aktualisierter Blog-Beitrag zur Textverarbeitung und Lokalisierung in Unity erscheint.
    • ? In Experimenten mit Java und JavaFX teste ich Ideen für neue Projekte, wenngleich das neue Java-Lizenzmodell das Ausweichen auf Amazons Coretto erfordern könnte . Letztlich werde ich diesen Ansatz am Jahresende 2019 aber ohnehin wieder einstellen, da er nicht zu den gewünschten Ergebnissen führte.

    August

    September

    • ? Aus einer Teilnehmerfrage heraus entsteht der Artikel zum Schützen und Patentieren der eigenen Spielidee.
    • ? Erste Infos zu meinem neuen Spiel Fart Fiasco werden erstmals öffentlich gezeigt.
    • ? Mit der Eröffnung eines Apple Developer Accounts will ich mehr über die Publikation auf iOS-Geräten lernen. Der Entwicklungsprozess wird sich letztlich aber als für mich aufwendig und unwirtschaftlich herausstellen.
    • ? Ich untersuche nodejs und Electron als Alternative zu JavaFX für zukünftige Projekte.

    Oktober 2019

    • ? Ich unterrichte erneut im Wintersemester 3D-Gestaltung an der Hochschule Augsburg.
    • ? Die Dreharbeiten zu einem neuen Blender-2.8-Kurs beginnen.

    November

    • ? GameDev-Profi erreicht 100 Abonnenten auf Youtube.
    • ? FartFiasco wird als Early Access-Titel für Steam und Android verfügbar. Apple verweigert die Veröffentlichung im App Store aufgrund des Themas.
    • ? Die Electron-Experimente konkretisieren sich mit der Entdeckung des Quasar-Frameworks, das nicht nur UI-Komponenten, sondern auch effiziente Voreinstellungen und Werkzeuge des Build-Prozesses mitbringt. Als Alternative zur eher chaotischen JavaScript-Programmierung beschäftige ich mich in diesem Zusammenhang mit TypeScript.

    Dezember

    Und 2020?

    Im kommenden Jahr möchte ich mein Kursprogramm weiter ausbauen, da dieses in der Vergangenheit sehr gut angenommen wurde. Dabei steht zunächst der neue Blender 2.8-Kurs an, der bereits in Arbeit ist. Das Veröffentlichungsdatum ist noch unklar, zumal ich derzeit mit der Bearbeitung etwas in Verzug geraten bin.

    Feuerwerk und Logo

    Außerdem gibt es auch eine ganze Reihe von Ideen zu neuen Themen und auch ganz anderen Online-Unterrichtsformen, mit denen ich derzeit experimentiere. Da an letzteren erhebliche konzeptuelle, technische und auch bürokratisch-rechtliche Herausforderungen einhergehen, bleibt abzuwarten, wie es sich konkret entwickelt und was davon es bis zu einer tatsächlichen Veröffentlichung schafft.

    Symbole: ? Videos & Kurse, ? Kostenlose Inhalte, ? Experimente & sonstiges, ? Persönliche Erfolge

  • Flackernde Weihnachtskerze in Blender 2.8 – Tutorial

    Flackernde Weihnachtskerze in Blender 2.8 – Tutorial

    René Bühling
    in

    In diesem Video nutzen wir u.a. Blenders Funktionen Bevel und Inset, Proportional Editing, Noise-Kurvenmodifikator, Subsurface Scattering Wachsmaterial, Bumpmapping und Animationsrendering.

    Kerze modellieren

    Im Video ab 00:12.

    1. Füge im Layout Tab bzw. Object Mode über das Menü Add → Mesh → Cylinder ein Zylinder-Mesh ein.
    2. Wechsle in den Modelling Tab (bzw. Edit Mode) und dort in den Face Select-Modus (Taste 3).
    3. Wähle die Deckelfläche aus.
    4. Verwende das Bevel-Werkzeug, um eine Rundung am oberen Kerzenrand zu erstellen. Klappe die Bevel-Einstellungen unten links auf und erhöhe den Wert von Segments auf 3.
    5. Wähle wieder die oberste Fläche aus.
    6. Verwende das Inset Faces-Werkzeug, um eine Innenfläche zu erzeugen und verschiebe sie mit dem Move-Werkzeug oder G etwas nach unten.
    7. Falls Zwischenunterteilungen fehlen, verwende das Loop Cut-Werkzeug, um weitere Kanten in den Ring einzuziehen und passe die Größe mit dem Scale-werkzeug an.
    Modellierte Kerze

    Flamme modellieren

    Im Video ab 02:57.

    1. Füge im Layout-Tab (bzw. Object Mode) über das Menü Add → Mesh → UV Sphere eine Kugel. Klappe die Add UV Sphere-Erstellungseigenschaften unten links auf und ändere den Radius auf 0.5.
    2. Wechsle in den Modelling Tab (oder Edit Mode) und dort in den Vertex Select-Modus (Taste 1).
    3. Drücke O (oder den entsprechenden Button), um das Proportional Editing zu aktivieren.
    4. Wähle den Punkt am obersten Pol der Kugel aus und drücke G, um ihn zu verschieben. Drücke ggf. Z, um die Bewegung auf die Z-Achse zu beschränken. Rolle dabei das Mausrad, um den Einflussbereich des Proportional Editing zu steuern.
    5. Deaktiviere das Proportional Editing mittels O.
    6. Wechsle in den Layout Tab (bzw. Object Mode), klicke mit der rechten Maustaste und wähle Shade Smooth aus.
    Modellierte Flamme

    Flamme färben

    Im Video ab 05:33.

    1. Markiere das Flammenobjekt und wechsle in den Shading Tab.
    2. Wechsle im Eigenschaftenbereich unten rechts auf den Material-Tab. Klicke auf New, um ein neues Material für die Flamme zu erzeugen.
    3. Schalte im Material-Eigenschaftenbereich im Abschnitt Surface den Wert Surface von Principled BSDF auf Emission um.
    4. Füge im Diagramm-Editor über das Menü Add → Texture → Gradient Texture einen Farbverlauf ein und verbinde den Color-Ausgabewert des neuen Knotens mit dem Color-Eingabewert des Emission-Knotens.
    5. (Optional) Wechsle in die Object-Eigenschaften und setze dort im Abschnitt Viewport Display den Haken bei Texture Space, um die Texturprojektion der Verständlichkeit halber einzublenden.
    6. Füge im Diagramm-Editor über Add → Input → Texture Coordinate einen Knoten für Texturkoordinaten ein und verbinde den Ausgang Generated mit dem Eingang Vector des Gradient Texture-Knotens.
    7. Füge im Diagramm-Editor über Add → Vector → Mapping einen Mapping-Knoten ein. Platziere ihn direkt auf der Linie zwischen dem Texture Coordinate und dem Gradient Texture-Knoten.
    8. Ändere im Mapping-Knoten den Wert Rotation: Y: auf 90, um den Verlauf zu drehen.
    9. Füge im Diagramm-Editor über das Menü Add → Converter → Color Ramp eine Farbabbildung auf der Verbindungslinie zwischen Gradient Texture und Emission ein.
    10. Ändere die Farben der Color Ramp, so dass von links nach rechts ein Verlauf von Hellblau über Rot nach Gelb entsteht. Klicke mit Strg+LinkeMaustaste auf das Farbband, um neue Farben einzufügen. Klicke auf eine Farbe und dann auf den Minus-Schalter, um eine Farbe wieder zu entfernen.
    11. Eröhe im Emission-Knoten ggf. den Wert Strength auf 4.6, um die Farbe kräftiger wirken zu lassen.
    Gefärbte Flamme

    Boden hinzufügen

    Im Video ab 10:57.

    1. Wechsle in den Layout Tab (bzw. Object Mode) und stelle dort ggf. das Viewport-Shading auf Rendered um, so dass das Material zu sehen ist.
    2. Füge einen Boden über das Menü Add → Mesh → Plane ein und platziere ihn in der Szene.

    Flamme leuchten lassen

    Im Video ab 11:05.

    1. Schiebe die vorhandene Lichtquelle in das Innere der Flammenform. 
      Hinweis: Bei Verwendung des Cycles-Renderers strahlt das Emit-Material bereits selbst Licht aus, so dass keine separate Lichtquelle nötig ist.
    2. Wähle ggf. in den Object-Eigenschaften im Abschnitt Viewport Display die Option In Front aus, damit das Lichtobjekt in der 3D-Ansicht jederzeit sichtbar ist.
    3. Wechsle in die Material-Eigenschaften. Setze im Abschnitt Settings den Wert Shadow Mode auf None. Damit wirft das Mesh der Flamme keinen Schatten mehr und das Licht der Lichtquelle fällt ungehindert in den Raum.
    4. Ändere die Farbe der Lichtquelle von Weiß in einen Gelbton.

    Lichtflackern per Kurvenmodifikator

    Im Video ab 13:00.

    1. Wähle die Lichtquelle und setze in den Lichteigenschaften den Wert Power auf 200W.
    2. Wechsle in den Animation Tab.
      • Stelle das Viewport Shading der 3D-Ansicht in der Mitte auf Rendered.
      • Ändere den Editor Type des Fensterbereichs links oben zu Graph Editor.
    3. Klicke in den Lichteigenschaften auf den kleinen Punkt neben dem Feld Power, um diesen Wert zu animieren.
    4. Falte ggf. die Struktur im Graph Editor auf, so dass das Feld Power zu sehen ist und stelle sicher, dass es markiert ist. Zeige mit der Maus auf den Graph Editor und drücke Pos1, um auf die Daten zu zoomen.
    5. Zeige mit der Maus auf den Graph Editor und drücke N, um den Seitenbereich zu öffnen. Wechsle in den Tab Modifiers und füge über das Add Modifier-Feld einen Noise-Modifikator hinzu.
    6. Setze im Modifikator den Wert Strength auf 286, um den Kurvenausschlag zu vergrößern.
    7. Setze im Modifikator den Wert Scale auf 5, um die Geschwindigkeit des Flackerns zu verändern.

    Drücke die Leertaste, um die Animation abzuspielen oder anzuhalten.

    Flackernde Lichtquelle

    Flammenform animieren

    Im Video ab 16:25.

    1. Wähle die Flammenform aus und wechsle in den Object-Eigenschaftenbereich.
    2. Klicke im Abschnitt Transform auf den kleinen Punkt neben dem Feld Scale Z, um diesen Wert zu animieren.
    3. Stelle sicher, dass im Graph Editor die Z Scale-Eigenschaft ausgewählt ist. Zeige mit der Maus auf den Graph Editor und drücke Pos1, um auf die Daten zu zoomen.
    4. Füge im Modifiers-Bereich des Seitenpanels im Graph Editor über das Add Modifier-Feld einen Noise-Modifikator hinzu.
    5. Setze im Modifikator den Wert Strength auf 0.1.
    6. Setze im Modifikator den Wert Scale auf 3.5.

    Flamme mit Licht verbinden und Animation von Skalierung trennen

    Im Video ab 17:58.

    1. Füge im Layout Tab (bzw. Object Mode) über das Menü Add → Empty → Plain Axes einen Positionshelfer ein.
    2. Wähle die Objekte in dieser Reihenfolge gemeinsam aus: Lichtquelle, Flamme, Empty.
    3. Drücke Strg+P → Object, um Licht und Flamme dem Empty unterzuordnen. Wird das Empty nun verschoben, bewegen sich die untergeordneten Elemente mit.
    4. Wähle das Empty Objekt alleine aus und skaliere es, um die gesamte Flamme unabängig von der Animation des Flammen-Meshs zu verkleinern
    5. Benenne das Empty-Objekt im Object-Eigenschaftenbereich um, z.B. zu „Flamme“.
    Parenting von Empty, Flamme und Licht.

    Kamera platzieren

    Im Video ab 21:34.

    Wähle die Kamera aus und verschiebe sie, so dass ein attraktiver Blickwinkel entsteht.

    • Drücke Num0, um durch die Kamera durchzusehen.
    • Verschiebe die Kamera während des Durchsehens mit:
      • G um seitlich zu fahren.
      • G Z Z, um nach vorne zu fahren.
    • Drehe die Kamera während des Durchsehens mit:
      • R um zu rollen.
      • R R um sich selbst herum zu drehen.

    Lichtschein anpassen

    Im Video ab 22:16.

    • Verschiebe die Lichtquelle nach oben oder unten, um den Schattenwurf des Kerzenkörpers zu beeinflussen.
    • Stelle in den Eigenschaften des Lichts im Abschnitt Shadow den Wert Softness auf 12.9, um einen weicheren Schatten darzustellen.

    Wachs-Material der Kerze

    Im Video ab 22:49.

    1. Wähle die Kerze im Object Mode aus.
    2. Erstelle im Material-Eigenschaftenbereich ein neues Material und ändere im Abschnitt Surface den Wert Surface von Principled BSDF zu Subsurface Scattering.
    3. Ändere den Wert Color des Materials auf Rot.
    4. Setze im Abschnitt Settings des Materials den Haken bei Subsurface Translucency.
    Kerze mit Subsurface Scattering-Material

    Holz-Material des Bodens

    Im Video ab 23:36.

    1. Wähle die Bodenebene im Object Mode aus.
    2. Wechsle in den Shading Tab und erstelle ein neues Material über den New-Schalter.
    3. Lade die Holztextur von Pexels.com herunter.
    4. Füge im Diagramm-Editor über Add → Texture → Image Texture einen Bildknoten ein und verbinde den Ausgang Color mit dem Eingang Base Color des Principled BSDF-Knotens.
    5. Klicke auf Open Image und wähle das heruntergeladene Holz-Foto aus.
    6. Füge im Diagramm-Editor über Add → Vector → Bump einen Unebenheitsgenerator ein. Verbinde den Eingang Height mit dem Ausgang Color des Bild-Knotens. Verbinde den Ausgang Normal mit dem Eingang Normal des Principled BSDF-Knotens.
    7. Ändere im Bump-Knoten den Wert Strength auf 0.1.
    Holzmaterial mit Bump-Kanal

    Hintergrundbild einfügen

    Im Video ab 26:46.

    1. Lade das Hintergrundbild von Pexels.com herunter.
    2. Wechsle in den Layout Tab (bzw. Object Mode).
    3. Aktiviere das Bild-Import-Plugin:
      1. Wähle den Menü-Befehl Edit → Preferences.
      2. Wechsle ggf. in den Add-ons-Abschnitt.
      3. Tippe in das Suchfeld „image“.
      4. Setze den Haken vor das Plugin Import-Export: Import Images as Planes.
    4. Wähle den Menü-Befehl File → Import → Images as Planes und suche die Hintergrunddatei aus.
    5. Platziere die generierte Ebene hinter der Szene.
    6. Wechsel in den Shading Tab und stelle sicher, dass die Ebene ausgewählt ist. Lösche im Diagramm-Editor die Knoten Transparent BSDF, Mix Shader und Diffuse BSDF.
    7. Füge im Diagramm-Editor über Add → Shader → Emission einen neuen Leuchtshader hinzu. Verbinde den Eingang Color mit dem Ausgang Color des Bild-Knotens. Verbinde den Ausgang Emission mit dem Eingang Surface des Material Output-Knoten.

    Schimmer hinzufügen

    Im Video ab 29:02.

    • Setze im Renderer-Eigenschaftenbereich den Haken bei Bloom.

    Animation rendern

    Im Video ab 29:12.

    1. Setze die Länge der Animation im Zeitleistenfenster im Feld End. Schalte ggf. über das Zeitleistenmenü View → Show Seconds auf die Sekundendarstellung um.
    2. Wechsle in den Output-Eigenschaftenbereich und …
      1. … setze im Abschnitt Output das File Format auf FFmpeg video.
      2. … klappe den Abschnitt Encoding auf und schalte den Eintrag Container auf MPEG-4 um.
      3. … wähle einen Ausgabe-Dateinamen.
    3. Speichere die Blender-Datei.
    4. Führe den Menüpunkt Render → Render Animation aus.
    5. Nach Abschluss des Render-Vorgangs kannst Du die Filmdatei im Datei-Explorer oder Finder finden.
    Fertige Szene