Programmeren van een 3D omgeving in Unreal Engine – Object Georiënteerd Programmeren

print
Deze handleiding maakt deel uit van het programmeertraject:



Wat vooraf ging

De gebruikte video’s bouwen verder op de video’s gebruikt in bovenstaande gelinkte handleiding.


Gebruikte terminologie

Objects

The base building blocks in the Unreal Engine are called Objects and contain a lot of the essential “under the hood” functionality for your game assets. Just about everything in Unreal Engine 4 inherits (or gets some functionality) from an Object.

Actors

An Actor is any object that can be placed into a level. Actors are a generic Class that support 3D transformations such as translation, rotation, and scale. Actors can be created (spawned) and destroyed through gameplay code (C++ or Blueprints).

Classes

A Class defines the behaviors and properties of a particular Object used in the creation of an Unreal Engine game. Classes are hierarchical, meaning a Class inherits information from its parent Classes (the Classes it was derived or “sub-classed” from) and passes that information to its children. Classes can be created in C++ code or in Blueprints.

Blueprints

The Blueprints Visual Scripting system in Unreal Engine is a complete gameplay scripting system based on the concept of using a node-based interface to create gameplay elements from within Unreal Editor. As with many common scripting languages, it is used to define object-oriented (OO) classes or objects in the engine. As you use UE4, you’ll often find that objects defined using Blueprint are colloquially referred to as just “Blueprints.”

Level

A Level is a user defined area of gameplay. Levels are created, viewed, and modified mainly by placing, transforming, and editing the properties of the Actors it contains. In the Unreal Editor, each Level is saved as a separate .umap file, which is also why you will sometimes see them referred to as Maps.

Components

A Component is a piece of functionality that can be added to an Actor. Components cannot exist by themselves, however when added to an Actor, the Actor will have access to and can use functionality provided by the Component. For example, a Spot Light Component will allow your Actor to emit light like a spot light, a Rotating Movement Component will make your Actor spin around, or an Audio Component will make your Actor able to play sounds.


Inleiding

C++, de achterliggende programmeertaal van Unreal Engine, is een objectgeoriënteerde programmeertaal. Het programmeren in C++, en bij uitbreiding dus ook in Unreal Engine en in Blueprint Visual Scripting, is dus object georiënteerd.

Laten we dus eerst even stilstaan bij een aantal kenmerken van object georiënteerd programmeren en vervolgens hoe dit wordt toegepast in Unreal Engine Blueprint Visual Scripting.


Object Georiënteerd Programmeren (OOP) – Algemeen

Deze bespreking is een algemene bespreking van object georiënteerd programma los van Unreal Engine.

Vele programmeertalen werken object georiënteerd. Dit betekent dat er geprogrammeerd wordt georiënteerd, rond objecten. Ook C++, de achterliggende programmeertaal van Unreal Engine en bijgevolg de programmeertaal die gebruikt wordt binnen Unreal Engine, is object georiënteerd.

In een objectgeoriënteerde programmeertaal staan objecten centraal.

Objecten

Een object is de basisbouwsteen bij object georiënteerd programmeren. Zowat alles is opgebouwd uit objecten.

In een 3D-omgeving is dit nog duidelijker omdat de objecten, meestal, visueel te zien zijn: muren, deuren, ramen, stoelen, tafels, bomen,… dit zijn allemaal objecten. Maar ook de karakters, lichten,… zijn in wezen objecten. Objecten die we kunnen plaatsen en transformeren in level worden ook actors genoemd.

Al deze objecten hebben eigenschappen en functionaliteiten.

Eigenschappen zijn kenmerken zoals hoogte, breedte, kleur,… die een waarde kunnen hebben.

Functionaliteiten (functies) zijn acties die met, op of door het object kunnen worden uitgevoerd. Denk aan lopen, springen, instorten, licht geven,… Functionaliteiten kunnen ook gebruikt worden om de correcte, gewenste waarden toe te wijzen aan de eigenschappen.

Ieder object dat we gebruiken in ons programma, iedere actor in het level, is in wezen een instantie van een specifieke klasse (Class in het Engels).

Class

Een Class is een verzameling van eigenschappen en functionaliteiten die samen één geheel vormen.

Bijvoorbeeld, u kunt een Class Muur aanmaken. Deze Class Muur zal de eigenschappen bevatten die de muur kenmerken. Denk aan hoogte, breedte, diepte en materiaal. Deze eigenschappen kunnen, binnen een Blueprint Class, aangemaakt worden als variabelen (later volgt een specifieke handleiding rond variabelen).

De Class Muur zal ook de functionaliteiten bevatten die van toepassing zijn op deze muur. Bv. een muur kan instorten. De programmeercode die nodig is om de muur te laten instorten wordt geplaatst in een functie Instorten. (Sommige object georiënteerde programmeertalen spreken van methoden als ze verwijzen naar functies binnenin een klasse. In C++, en bij uitbreiding dus in Unreal Engine, spreken we gewoon van functies en wordt het begrip methoden niet gebruikt).

Wanneer we nu een object, op basis van een specifieke klasse, aanmaken (bv. we willen een muur op basis van de klasse Muur toevoegen aan een level) dan wordt een instantie van deze klasse gemaakt. De muur in ons level is dus een instantie van de klasse Muur. Deze instantie, deze specifieke muur, heeft toegang tot eigenschappen en functionaliteiten van de klasse. Met andere woorden, we kunnen specifieke waarden geven aan de eigenschappen hoogte, breedte, diepte en materiaal, specifiek voor deze muur (voor dit object van de klasse Muur) en onze muur heeft de functionaliteit om in te storten.

De belangrijkste reden om een klasse aan te maken is de herbruikbaarheid van een klasse.

Overerving

Een klasse kan een andere klasse als parent hebben en zo de eigenschappen en functionaliteiten overerven van deze parent klasse (inheritance).

Bijvoorbeeld, u wilt een middeleeuws spelletje aanmaken bevolkt door boeren, soldaten en tovenaars. U zou nu 3 klassen kunnen aanmaken, een klasse Boer, een klasse Soldaat en een klasse Tovenaar. Maar moest u dit doen dan zal u al snel merken dat u dezelfde eigenschappen (lengte, breedte, gewicht,…) en dezelfde functionaliteiten (lopen, springen, zwemmen,…) hebben. Uiteindelijk zijn al boeren, soldaten en tovenaars allen mensen.

U kunt dus beter een klasse Mens aanmaken. Deze klasse bevat dan alle eigenschappen (lengte, breedte, gewicht,…) en alle functionaliteiten (lopen, springen, zwemmen,…) eigen aan de mens.

Nadien kan u een klasse Tovenaar aanmaken die de klasse Mens als parent klasse heeft en dus alle eigenschappen en functionaliteiten van de klasse Mens overerft en aanvult met typische eigenschappen en functionaliteiten voor een Tovenaar (bv. de functionaliteit Toveren).

Hetzelfde kunnen we doen met voor de klasse Boer en de klasse Soldaat.

En misschien wilt u wel verschillende klassen van soldaten maken, een boogschutter, een zwaardvechter, een lansier,… U kunt dus voor elk van deze “soldatenklasse” een klasse maken die de Klasse Soldaat als parent heeft (dat op zijn beurt overerft van de klasse Mens).

Let op, we moeten onderscheid maken tussen de eigenschappen en de waarde die we toekennen aan de eigenschappen. Bijvoorbeeld, lengte is een eigenschap die eigen is aan een mens en de eigenschap Lengte wordt dan ook aangemaakt in de klasse Mens en overgeërfd door de klasse Boer, Soldaat, Tovenaar,…. We kunnen nu elk mens, boer, soldaat, tovenaar hun eigen specifieke lengte geven zonder daarvoor een nieuwe klasse te moeten aanmaken.

Een nieuwe, overgeërfde, klasse is dus niet nodig wanneer u enkel andere waarden wilt geven, enkel nodig wanneer u andere eigenschappen of functionaliteiten wilt toevoegen.

Encapsulation

Bepaalde eigenschappen en functionaliteiten binnen een klasse zullen enkel gekend zijn binnen deze klasse en zijn niet toegankelijk van buiten de klasse, vanuit andere klassen of het level. We spreken dan van inkapselen (Encapsulation). Inkapselen is bepalen hoe men toegang krijgt tot een bepaalde klasse. Welke eigenschappen en functionaliteiten zijn van buitenaf toegankelijk (de interface) en welke zijn afgeschermd voor de “buitenwereld” en zijn enkel gekend binnen de klasse.

Event-driven

Object georiënteerd programmeren is vaak Event-driven. Events zijn gebeurtenissen, bv. het klikken op een knop, in een klassieke 2D-omgeving, is een event, het laden van een webpagina is een ander voorbeeld van een event (deze keer niet aangedreven door de gebruiker maar door het systeem). Er wordt dus geprogrammeerd volgens “Wat moet er gebeuren als de gebruiker klikt op die knop?”, “Wat moet er gebeuren als die webpagina geladen wordt?”.

De instructies, programmeercode, worden geplaatst binnen deze events.

Constructor

De constructor is een speciale functie die in elke klasse aanwezig moet zijn. De constructor stelt de beginwaarden in op het moment dat een object, een instantie van de klasse, wordt aangemaakt.

Voortbouwend op ons bovenstaand voorbeeld van de klasse Mens, Tovenaar, Boer, Soldaat,…

De klasse Mens heeft een constructor die de eigenschappen (lengte, breedte, gewicht,…) een standaardwaarde geeft. Bijvoorbeeld, de standaardlengte van een mens kan 180 cm zijn. Deze wordt ingesteld via de constructor in de klasse Mens. Pas op, deze eigenschappen kunnen later nog gewijzigd worden. De constructor stelt gewoon een standaardwaarde is, geen vastliggende definitieve waarde.

Nu kan het zijn dat we wensen dat onze boeren standaard iets groter zijn. We wensen de standaardlengte van de boer in te stellen op 185 cm. Dit kan gebeuren in de constructor van de klasse Boer die de eigenschap “lengte” overerft uit de klasse Mens.

Het gebruik van een constructor sluit niet uit dat we geen specifieke mens (of boer, of soldaat,…) kunnen maken met een specifieke lengte van 160 cm, afwijkend van de standaard lengte. We dienen hiervoor geen nieuwe klasse aan te maken, maar gewoon een andere waarde te geven aan de eigenschap Lengte.

Polymorphisme en Function Override

Polymorphisme is de mogelijkheid om meerdere varianten van eenzelfde functie, met behoud van de naam van de functie, te programmeren. Het onderscheid tussen de varianten wordt bepaald door de “interface”, de parameters die worden meegegeven aan de functie.

Ok, dit is op dit ogenblik nogal abstract, onthoud gewoon het begrip.

Function Override is de mogelijkheid om een functionaliteit, een functie, uit een parent class te overschrijven met een nieuwe invulling van deze functie.

Bijvoorbeeld, de klasse Tovenaar erft de functionaliteit Lopen van de parent klasse Mens. Maar stel nu dat onze tovenaar op een geheel eigenzinnige manier loopt, zodanig zelfs dat de instructies, programmeercode, uit de functionaliteit Lopen van de parent klasse Mens, moeten gewijzigd worden. Dan kan men deze functionaliteit Lopen, binnen de klasse Tovenaar herprogrammeren met het behoudt van de naam Lopen. De originele functionaliteit Lopen uit de parent klasse Mens wordt overschreven door een gelijknamige functionaliteit Lopen in de klasse Tovenaar.

Iedere mens, instantie van de klasse Mens, iedere boer, instantie van de klasse Boer, iedere soldaat, instantie van de klasse Soldaat, zal nog steeds lopen op de originele manier zoals beschreven in de functionaliteit Lopen uit de parent klasse Mens, door de Boer en Soldaat overgeërfd. Maar de tovenaar, instantie van de klasse Tovenaar zal lopen volgens de hergeprogrammeerde functionaliteit Lopen uit de klasse Tovenaar.


Object Georiënteerd Programmeren (OOP) – Unreal Engine Blueprints Visual scripting

Na deze algemene kennismaking met object georiënteerd programmeren gaan we nu bekijken hoe binnen Unreal Engine Blueprints Visual Scripting de basis van object georiënteerd programmeren gebruikt wordt.

  • Start een nieuw Third Person Desktop/Console project van Maximum Quality With Starters Content en geef het een passende naam of open een reeds aangemaakt project.

Objecten

Een object is de basisbouwsteen bij object georiënteerd programmeren. Zowat alles is opgebouwd uit objecten.

Eens het project opgestart ziet u dat het Level reeds gevuld is met een aantal objecten, in Unreal Engine noemen we objecten die u in een level kunt plaatsen actors. Objecten of actors, in wezen zijn ze hetzelfde en ik durf ze dan ook wel eens door mekaar te gebruiken.

In onderstaande afbeelding ziet u deze actors met de actor CubeMesh geselecteerd.

Een overzicht van alle actors in een level vindt u in de World Outliner. De geselecteerde actor is ook hier geselecteerd.

Al deze objecten hebben eigenschappen en functionaliteiten.

De eigenschappen van de geselecteerde actor vindt u in het Details-panel. Hier kunt u ook waarden toekennen aan deze eigenschappen.

Functionaliteiten worden gebruikt om de waarden van eigenschappen via programmeercode te wijzigen. We hebben dit reeds in een vorige post gedaan. We hebben toen de functies Set Visibility en Toggle Visibility gebruikt om de eigenschap Visibility van het object PointLight te wijzigen.

Class

Een Class is een verzameling van eigenschappen en functionaliteiten die samen één geheel vormen. Een object is een instantie, een voorkomen, van een klasse en heeft dezelfde eigenschappen en functionaliteiten als die klasse.

In Unreal Engine spreken we van Blueprint Classes of kortweg Blueprints.

Ingebouwde klassen

Unreal Engine biedt een hele reeks ingebouwde klassen die we eventueel zelf kunnen wijzigen via de World Outliner in de Level Designer.

U herkent de klassen aan de mogelijkheid om ze te “editen”. Het gaat hem in dit voorbeeld om BP_Sky_Sphere (het object dat de “lucht” toevoegt aan het level) en ThirdPersonCharacter (ons “karakter” dat we besturen). Door de “Edit …” aan te klikken komt u in de Blueprint.

Zelfgebouwde klassen

U kunt ook zelf Blueprint Classes aanmaken. De StarterContent komt met een aantal “zelfgemaakte” Blueprints.

  • U vindt ze in de Content Browser onder ContentStarterContentBlueprints.

  • U kunt eventueel ook filteren op Blueprint Class.

Open onderstaande klassen en plaats ze in tabbladen naast elkaar zodat we ze gemakkelijk kunnen vergelijken.

Om er geen warboel van te maken neem ik de Blueprint_CeilingLight als basis voor de onderstaande uitleg (al zal ik geregeld specifiek naar een andere Blueprint verwijzen).

Overerving

Een klasse kan een andere klasse als parent hebben en zo de eigenschappen en functionaliteiten overerven van deze parent klasse (inheritance).

Deze overerving komt in Unreal Engine tot uiting wanneer we een nieuwe klasse gaan aanmaken. Een nieuwe klasse zal immers, meestal maar niet noodzakelijk altijd, aangemaakt worden om basis van een reeds bestaande parent klasse.

Om te weten wat de Parent Class is van een bestaande Blueprint Class.

  • Open de Blueprint Class door te dubbelklikken (bv. de Blueprint_CeilingLight).
  • Duid linksboven de naam van de Blueprint Class aan.

U krijgt een informatievenstertje waar de Parent Class aangegeven is. De Parent Class van Blueprint_CeilingLight is Actor.

Een nieuwe klasse aanmaken

Tip, voor u begint nieuwe klassen aan te maken kunt u het best eerst een nieuwe folder aanmaken waarin u al uw eigen aangemaakte klassen bewaart.

  • In de Content Browser, klik op Add NewNew Folder.

Er zijn verschillende manieren om een nieuwe klasse aan te maken.

  • In de Content Browser, klik op Add NewBlueprint Class (of klik met de rechtermuisknop in de net aangemaakte folder en klik op Blueprint Class).

  • Of, klik in het menu op BlueprintsNew Empty Blueprint Class….

U komt in onderstaand scherm waar u een Parent Class kunt selecteren. Bovenaan vindt u de meest gebruikte Parent Classes, onderaan kunt u eventueel een specifieke klasse zoeken (nadien verschijnt een knop Select om deze specifieke klasse als Parent Class te selecteren).

  • Klik op de gewenste Parent Class.

Een actor converteren in een herbruikbare Blueprint Class

Een andere mogelijkheid is een bestaande actor te converteren naar een Blueprint Class.

  • Selecteer de actor, eventueel in de World Outliner en klik op Blueprint/Add Script.

Gevorderde technieken

Er zijn een paar gevorderde technieken om klassen aan te maken, u vindt die onder de knop Blueprints.

Onderstaande video is een eerste in een reeks, de anderen staan verderop in deze handleiding, waarin een eigen klasse wordt aangemaakt.

Componenten

Componenten is iets dat eigen is aan een Unreal Engine Blueprint Class en dat u niet in alle andere object georiënteerde programmeertalen terugvindt (u vindt het dan ook niet terug in bovenstaande algemene opsomming). Componenten zijn de onderdelen (objecten) waarmee het object in deze Blueprint gebouwd is.

Zo zal onze “hangende lamp”-blueprint componenten bevatten voor de “hangende lamp” zelf (een StaticMesh) en een lichtbron (PointLight).

  • Dubbelklik Blueprint_CeilingLight om deze te openen. Deze klasse kan gebruikt worden om “hangende lamp”-objecten toe te voegen.
  • U komt wellicht in tabblad Construction Script, maar laten we dit even negeren. Klik op het tabblad Viewport. Hier vindt u de onderdelen, de componenten, waaruit deze klasse bestaat.

In het Components-panel ziet u eveneens de componenten en kunt u er nog anderen aan toevoegen.

Een belangrijk component is Scene1 of DefaultSceneRoot, of welk ander component er zich ook als eerste aan de basis bevindt. Het is dit basiscomponent dat de locatie (transformatie) van het object in de wereld bepaalt. De andere componenten hebben een locatie (transformatie) relatief ten opzichte van dit basiscomponent.

Componenten van andere Blueprints bekijken

De componenten van Blueprint_Wallsconce zijn bijna identiek aan de constructor van Blueprint_Ceilinglight. Er wordt gewoon een andere StaticMesh gebruikt die tegen een muur kan worden geplaatst.

De componenten van ThirdPersonCharacter zijn wel anders.

U ziet er het CapsuleComponent als basis dat een Mesh (het eigenlijke karaktermodel (de Mannequin)) en een ArrowComponent (die blauwe pijl die de kijkrichting van het karakter aanduidt en niet te verwarren is met een ) bevat. Verder is er ook een FollowCamera toegevoegd die zich achter het karakter bevindt (en zo voor de “ThirdPersonCharacter”-view zorgt). De camera hangt vast aan een zogenaamde CameraBoom.

Omdat ons ThirdPersonCharacter moet kunnen bewegen heeft het ook nog een CharacterMovement-component.

Onderstaande video voegt componenten toe aan de eigen Blueprint Class.

Encapsulation

Bepaalde eigenschappen en functionaliteiten binnen een klasse zullen enkel gekend zijn binnen deze klasse en zijn niet toegankelijk van buiten de klasse, vanuit andere klassen of het level. We spreken dan van inkapselen (Encapsulation). Inkapselen is bepalen hoe men toegang krijgt tot een bepaalde klasse. Welke eigenschappen en functionaliteiten zijn van buitenaf toegankelijk (de interface) en welke zijn afgeschermd voor de “buitenwereld” en zijn enkel gekend binnen de klasse.

  • Keer terug naar Blueprint_Ceilinglight.

De onderdelen waaruit de Blueprint Class bestaat ziet u in het My Blueprint-panel.

U ziet hier alle onderdelen waaruit de Blueprint Class bestaat.

  • EventGraph – de Events (zie hieronder).
  • Functions – met momenteel enkel de speciale ConstructionScript (zie hieronder).
  • Macros – een Macro is variant op functies (zie later)
  • Variablesvariabelen zijn als het ware “opslagplaatsen” waar u waarden kunt bijhouden die u kunt (her)gebruiken. Deze waarden zijn niet constant maar kunnen variëren.  De variabelen zijn hier onderverdeeld in twee groepen, de componenten en variabelen die vallen onder “Light”. Ze zijn, binnen een Blueprint Class, te vergelijken met eigenschappen.
  • Event DispatchersEvent dispatchers bundelen events om deze gezamenlijk uit te voeren (zie later).

De communicatie met de Blueprint Class verloopt via één van deze wegen.

Variabelen zijn standaard Public, dit betekent dat de waarde van de variabele ook van buiten de Blueprint Class kan gewijzigd worden.

Wilt u dit niet, wilt u niet dat de waarde van de variabele van buiten de Blueprint Class kan gewijzigd worden, dan selecteert u de variabele en vinkt u Private aan in het Details-panel.

Merk op dat een variabele een Default Value heeft (een standaardwaarde). De variabele Brightness heeft een standaardwaarde van 1700.0. Uiteraard kunt u deze veranderen, het is immer een variabele.

Event-driven

Object georiënteerd programmeren is vaak Event-driven. Events zijn gebeurtenissen.

De instructies, programmeercode, worden geplaatst binnen deze events via de Event Graph.

Weet dat deze events, binnen de klasse, enkel kunnen werken met de componenten toegevoegd aan deze klasse.

Om de beschikbare events te zien, die beschikbaar zijn voor ene specifiek component:

  • Selecteer onder My BlueprintComponents het gewenste component (bv. SM_Lamp_Ceiling).
  • Rechts ziet u in het Details-panel de beschikbare events.
  • Als u een event aanklikt wordt deze toegevoegd aan de Event Graph en kan het programmeren beginnen.

Merk op dat er in onze voorbeeldklasse Blueprint_Ceilinglight geen events aanwezig zijn.

Moest u een nieuwe Blueprint Class aanmaken met de Actor Class als Parent dan ziet u dat er reeds een aantal events klaar staan (zij het in het grijs omdat ze momenteel nog niet verbonden zijn.

 

Constructor

De constructor is een speciale functie die in elke klasse aanwezig moet zijn. De constructor stelt de beginwaarden in op het moment dat een object, een instantie van de klasse, wordt aangemaakt. De Constructor maakt het mogelijk dat aan bepaalde eigenschappen door iedere instantie van de klasse (ieder object van de klasse) eigen specifieke waarden (voor die specifieke instantie) worden toegekend.

Concreet in ons voorbeeld, iedere keer we een nieuw “hangende lamp”-object toevoegen aan een level, wordt een nieuwe instantie van de klasse Blueprint_CeilingLight genomen en worden een aantal eigenschappen (de intensiteit, kleur en radius van het licht) ingesteld.

In de Blueprint Class vindt u de constructor in de ConstructionScript.

  • Klik op het tabblad Construction Script om de constructor te bekijken.

Hieronder ziet u indentiek dezelfde constructor maar gewoon anders geordend.

Hoe is deze constructor gebouwd?

De Construction Script start bij de Construction Script-node.

Vandaaruit worden drie functies aangeroepen Set IntensitySet Light ColorSet Source Radius. Set betekent dat een waarde aan een eigenschap wordt toegewezen/ingesteld (geSet). Merk hoe deze functies allen met elkaar verbonden zijn.

Deze 3 functies hebben allen dezelfde Target, namelijk het object PointLight1. De Target is dus het object waarvoor de eigenschap een waarde wordt toegewezen. Het is de intensiteit, kleur en radius van het object PointLight1 dat wordt ingesteld.

Om de waarden aan de eigenschap toe te wijzen worden initieel de Default Values (standaardwaarden) van de variabelen Brightness, Color, Source Radius gebruikt. Merk op dat deze variabelen een andere kleur hebben, dat is omdat ze van een andere type zijn (Brightness en Source Radius van het type Float (decimale getallen), Color van het type Linear Color).

De initieel toegekende standaardwaarden van deze variabelen kunnen eventueel per instantie gewijzigd worden, het zijn immer variabelen, en vervangen door meer specifieke waarde voor die specifieke instantie van onze “hangende lamp”-klasse. Dit maakt dat, ondanks de standaardwaarden, iedere instantie van onze “hangende lamp” een andere intensiteit, kleur en straal kan hebben.

Hoe werkt een constructor?

Als u de klasse Blueprint_CeilingLight sleept in het level dan wordt een instantie van die klasse, een “hangende lamp”-object (of nog correcter, een “hangende lamp”-actor) aan het level toegevoegd. Deze actor wordt gebouwd met de toegewezen componenten maar, door de constructor, heeft deze actor ook al meteen een intensiteit, kleur en radius meegekregen (op basis van de standaardwaarden van de specifieke variabelen).

Deze variabelen zijn echter, als eigenschappen, aanwezig in het Detail-panel en kunt u daar wijzigen om zo deze instantie van onze “hangende lamp” specifieke waarden voor de intensiteit, kleur en radius te geven.

Constructors van andere Blueprints bekijken

De constructor van Blueprint_Wallsconce is bijna identiek aan de constructor van Blueprint_Ceilinglight. Er zijn wel bijkomende settings (en bijhorende variabelen) nodig voor de Inner Cone Angle en Outer Cone Angle.

De constructor van BP_LightStudio is duidelijk veel complexer (breek er momenteel uw hoofd nog maar niet over).

Lege constructor

Iedere klasse (Blueprint) moet een Constructor hebben maar er moet niet altijd iets mee te gebeuren.

Neem maar eens een kijkje in de Blueprint van ThirdPersonCharacter (door het aan te klikken in de World Outliner in de Level Designer).

De Constructor Script-node is aanwezig maar bevat geen verdere verbindingen. Eigenlijk is dit logisch. Ons ThirdPersonCharacter is immer uniek, er hoeven dus geen andere instanties, met eigen specifieke waarden, genomen te worden.

Onderstaande video maakt een eenvoudige constructor aan die toelaat de kleur van een licht te wijzigen per instantie.

Polymorphisme en Function Override

Polymorphisme is de mogelijkheid om meerdere varianten van eenzelfde functie, met behoud van de naam van de functie, te programmeren. Het onderscheid tussen de varianten wordt bepaald door de “interface”, de parameters die worden meegegeven aan de functie.

Function Override is de mogelijkheid om een functionaliteit, een functie, uit een parent class te overschrijven met een nieuwe invulling van deze functie.

In een Blueprint Class kunt u een functie van een parent class overschrijven door in het My Blueprint-panel te klikken op Add NewOverride Function en vervolgens de gewenste functie aan te klikken die u wenst te overschrijven.

De ConstructionScript is op zich ook telkens een “Override” (u herkent het aan het pijltje voor de F in het icoontje). Hieronder ziet u een voorbeeld komende uit BP_LightStudio waar u het verschil kunt opmerken tussen de “gewone” functies (zonder pijltje) en de “overschreven” functie (met pijltje).


Object Georiënteerd Programmeren (OOP) – Alternatieve werkwijzen

Onderstaande video’s tonen alternatieve werkwijzen en aanvullende voorbeelden voor het aanmaken van Blueprint Classes.


Project Level Creation – Lighting and polishing

De Lighting pass en Polishing pass zijn de twee laatste fasen in het ontwerpen van een level. Hoewel deze twee fasen hier in slechts één video worden samengenomen zijn ze zeker niet minder belangrijk en worden ze ook vaak door specialisten uitgevoerd. Maar wij houden het nog eenvoudig.

Adding props and lighting

Zo, dit was het laatste deel in deze reeks van tutorials die de nadruk legde op het bouwen van een level.

In een volgende reeks zal de nadruk meer op het programmeren liggen.


Masterclass – Foliage

In de vorige Masterclass -Landscape hebt u misschien gezien hoe u een landschap kunt bouwen. Nu gaan we zien hoe we Foliage (begroeiing zoals gras, struiken, bomen, bloemen,…) kunnen toevoegen.

Onderstaande video, met dezelfde “master” als in de Masterclass – Landscape legt uit hoe Foliage kunt toevoegen aan uw landschap.

In de video wordt aangekocht materiaal gebruikt (voor gras, bomen,…) wilt u gratis materiaal:

  • Start dan Epic Games Launcher en ga dan naar de Marketplace (of naar Learn).
  • Zoek en voeg de Open World Demo Collection toe aan uw project via Add To Project.

 

De video zelf begint met wat gevorderde uitleg rond materialen. Voor wie dit net iets te veel van het goede is, op dit ogenblik, raad ik aan te beginnen vanaf 16:25 tot 30:00 en dan opnieuw vanaf 44:40 tot 53:50.


Artclass – Create a Photorealistic World in UE4

Onderstaande video is een nieuwe Artclass nog steeds rond het bouwen van een realistische 3D-omgeving.

Deze video maakt gebruik van assets komende van Quixel MegaScans.


Quickshots

Quickshots zijn korte, op zichzelf staande video’s, rond een specifiek onderwerp. Meestal aansluitend bij wat net besproken is.

Triggerable Light


Sidekick – Materialen

Bij het bouwen van een 3D omgeving komt veel meer kijken dan enkel maar het programmeren. Denk aan belichting, AI (Artificiële Intelligentie), animaties, cinematics, geluid, particle effects, materialen,….

Het is teveel gevraagd om gespecialiseerd te zijn in al deze materie, specialisatie dringt zich op. Ik leg in deze handleidingen de nadruk op het leren programmeren en zal al heel tevreden zijn als u dit onder de knie krijgt. Maar toch wil ik u ook, via deze Sidekicks, laten kennismaken met de andere aspecten nodig om een 3D omgeving te bouwen. Ik doe dit aan de hand van videoreeksen die ik gespreid aanbied als aanvulling bij de eigenlijke handleidingen. Deze Sidekicks maken geen deel uit van de eigenlijke “leerstof”, voel u vrij ze al dan niet te bekijken.

Dit is een derde reeks van video’s over Materialen die het object georiënteerd begrip Instances toepast op Materialen.

Material Instancing

Dynamic Material Instances

Dynamic Material Instances continue

Geef een reactie

  • Abonneer je op deze website d.m.v. e-mail

    Voer je e-mailadres in om je in te schrijven op deze website en e-mailmeldingen te ontvangen van nieuwe berichten.