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

print
Deze handleiding maakt deel uit van het programmeertraject:



Wat vooraf ging


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.

  • 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

In een objectgeoriënteerde programmeertaal staan objecten centraal.

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.

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.


Klassen

Maar waar komen nu al die eigenschappen en functionaliteiten van deze objecten vandaan?

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). De belangrijkste reden om een klasse aan te maken is de herbruikbaarheid van de klasse.

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

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.

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). We hebben reeds gezien hoe u functies kunt aanmaken.

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.

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.

De StarterContent komt met een aantal Blueprints Classes.

  • 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).

Voor we zelf een klasse aanmaken moet u vertrouwd zijn met het begrip Overerving.


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. Een nieuwe, overgeërfde, klasse is enkel nodig wanneer u andere eigenschappen of functionaliteiten wilt toevoegen.

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.

Nu we weten dat een nieuwe klasse kan gebouwd worden op basis van een bestaande klasse kunnen we bekijken hoe klassen worden aangemaakt in Unreal Engine.

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.


De onderdelen van een klasse

Een klasse bestaat uit:

  • Componenten
  • Events
  • Constructor

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. Componenten zijn de onderdelen (objecten) waarmee de Blueprint class is gebouwd.

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.

Events

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.


Children

Een gevolg van overerving (zie hierboven) is dat er Children klassen kunnen gemaakt worden die dezelfde functionaliteit en eigenschappen/variabelen erven van de Parent klas.

Stel, u maakt een FPS (First Person Shooter) en u wilt meerdere types van wapens kunnen gebruiken. Nu elk wapen heeft eenzelfde aantal eigenschappen en functionaliteiten gemeen, ik denk aan de eigenschappen Ammo, Isfiring (variabelen) en de functionaliteiten Fire en StopFiring.

Ook al hebben alle wapens deze eigenschappen en functionaliteiten gemeen, toch kan ieder type wapen de functionaliteit Fire anders uitwerken.

In zo’n situatie kan het werken met een Parent klasse en verschillende Children klassen handig zijn.

Praktisch

Laat ons dit eens praktisch uitwerken.

Maak zoals hierboven reeds uitgelegd een nieuwe klasse aan van het type Actor.

  • 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.

  • Klik op de Actor Class.
  • Geef de nieuwe klasse bv. de naam GunParent.
  • Dubbelklik om deze klasse te openen en maak twee variabelen aan Ammo (float) en IsFiring (Boolean) en de heel eenvoudige functie Fire, zoals u hieronder kunt zien.

  • Om nu een Child te maken voor deze Parent, klik in de Content Browser met de rechtermuisknop op de Parent klasse en kies voor Create Child Blueprint Class.

  • Hieronder heb ik 2 Children aangemaakt MachineGun en SmallGun.

Achterafgezien zijn deze namen wat ongelukkig gekozen, het ware misschien beter geweest te kiezen voor Gun_Parent, Gun_Machine en Gun_Small. Aan u de keuze.

  • Dubbelklik op een Child klasse om deze te openen. Rechtsboven ziet u de Parent klasse. In de Event Graph ziet u achter de gekende events, zoals Event BeginPlay, een verwijzing staan naar dezelfde event in de Parent klasse. Dit betekent dat wat in dezelfde event in de Parent klasse staat wordt uitgevoerd.

Merk op dat er geen variabelen te zien zijn, ook niet deze van de Parent klasse Ammo en IsFiring.

  • Toch zijn ze er, wilt u ze ook zien, vink dan Show Inhereted Variables aan.

  • Zoek naar de Event Fire uit de Parent klasse en u zal deze vinden.

Als we nu meteen code toevoegen aan de Event Fire vervangt deze de code van de Parent klasse.

  • Wilt u echter de code uit de Parent klasse behouden en er nieuwe code aan toevoegen dan moet u rechts klikken op de event en kiezen voor Add call to parent function.

  • Verbind de nodes en nu wordt eerst de code van de Parent Event Fire uitgevoerd. Hierachter kan u nieuwe specifieke code toevoegen voor deze specifieke Child klasse.


Een aantal typische kenmerken van object georiënteerd programmeren

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.

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.

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).


Praktisch voorbeelden

Een MijnDeur klasse

In een vorige handleiding hebben we een deur gemaakt die automatisch open ging. We hebben dit toen geprogrammeerd in de Level Blueprint.

De kans is echter groot dat we deze deur op meerdere plaatsen, in meerdere levels, ja, zelfs in meerdere projecten gaan hergebruiken.

Ideaal dus om hier een eigen klasse van te maken.

Maak eventueel een nieuwe folder aan waar u alle Blueprint Classes wenst te verzamelen.

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

Maak in deze nieuwe folder een nieuwe Blueprint Class aan met als Parent Class Actor.

  • 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….

  • Kies de Parent Class Actor.

  • Geef het een gepaste naam (bv. MijnDeur).
  • Dubbelklik om te openen.

Merk de DefaultSceneRoot op die de positie in het level zal bepalen, deze is reeds Movable.

Componenten toevoegen

Er moeten 2 componenten worden toegevoegd:

  • Een Static Mesh dat de deur bevat (met de naam Deur).

  • Een Box Collision (te vergelijken met een TriggerBox) voor de interactie (met de naam DeurTriggerBox).

  • U ziet de hieronder de toegevoegde componenten.

  • Voeg de Static Mesh SM_Door toe aan de eigenschap Static Mesh van Deur.

  • Eens toegevoegd, dubbelklik de deur (in de Eigenschap Static Mesh) en voeg Collision toe.
  • Plaats de DeurTriggerBox rond de deur.

Events

De deur moet opengaan als de DeurTriggerBox overlapt wordt en nadien weer gesloten bij het beëindigen van de overlapping.

  • Selecteer de DeurTriggerBox en vindt onderaan, bij Events, de event On component Begin Overlap en On component End Overlap.

  • Klik op de +-knoppen.
  • Ga naar Event Graph.
  • Voeg onderstaande code toe, voor de uitleg verwijs ik naar de vorige handleiding (merk het kleine verschil op, het is niet SetActorRelativeRotation maar SetRelativeRotation en gebruik de Static Mesh Deur).

Constructor

Constructors stellen waarden in, of voeren functionaliteiten uit, bij het aanmaken van het object (toevoegen aan het level). Dit is in dit voorbeeld niet nodig. De Constructor blijft dan ook leeg.

  • Compile en Save.
  • Sleep een paar instanties van de klasse MijnDeur in het level en test het uit.

Videovoorbeeld

Onderstaande video’s tonen hoe u een klasse kunt maken van een muurlamp die geactiveerd wordt door het drukken op een toets aangegeven via een tekst.

Alternatieve werkwijze

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.


Quickshots

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

Triggerable Light


Behandelde Basiscompetenties uit de module ICT Programmeren – Specifieke ontwikkelomgeving: eenvoudige functionaliteiten

  • IC BC017 – kan ICT veilig en duurzaam gebruiken
  • IC BC234 – kan de basisprincipes van programmeren in een specifieke ontwikkelomgeving toepassen
  • IC BC236 – kan eenvoudige wijzigingen aan een programma aanbrengen
  • IC BC241 – kan een programma in een specifieke ontwikkelomgeving maken
  • IC BC247 – kan de bouwstenen van een specifieke ontwikkelomgeving gebruiken
  • IC BC249 – kan de instellingen van een specifieke ontwikkelomgeving wijzigen
  • IC BC250 – kan bij het programmeren in functie van een specifieke ontwikkelomgeving, een juiste logica volgen
  • IC BC288 – kan ICT-problemen oplossen

Geef een reactie

Deze website gebruikt Akismet om spam te verminderen. Bekijk hoe je reactie-gegevens worden verwerkt.

  • 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.