Starten met Programmeren van een 3D omgeving in Unreal Engine – Interactie met de omgeving

print
Deze handleiding maakt deel uit van het programmeertraject:


Inhoud


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

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.


Inleiding

U hebt reeds voldoende kennis van de werkomgeving en u beheerst de basis om een level te bouwen. Tijd om te starten interactie toe te voegen door te programmeren.

Misschien eerst even stilstaan bij wat programmeren eigenlijk is. Een vereenvoudigde definitie zou kunnen zijn:

Programmeren is de computer dingen laten doen door het specifieke instructies te geven in een programmeertaal.

Deze instructies worden gegeven in een programmeertaal. C++ is al vele jaren de belangrijkste programmeertaal voor 3D-applicaties en is ook de programmeertaal die Unreal Engine gebruikt.


Blueprints Visual Scripting

C++ is echter geen toegankelijke programmeertaal en is dus niet eenvoudig om aan te leren. Om het programmeren toegankelijker, eenvoudiger te maken voor beginnende programmeurs heeft Epic, de firma achter Unreal Engine, Blueprints Visual Scripting toegevoegd aan C++.

Blueprints Visual Scripting heeft volgende voordelen:

  • C++ is nog steeds de achterliggende programmeertaal met al zijn kenmerken en voordelen. U leert dus, net als in C++, programmeren met variabelen, objecten, eigenschappen, methoden, events, selecties, lussen, arrays, klassen, interfaces, overerving,… kortom u leert volwaardig programmeren.
  • Blueprints Visual Scripting is speciaal ontwikkeld voor ontwikkelaars zonder programmeerervaring en dus ook voor de startende student.
  • U schrijft geen programmeercode meer maar u verbindt visueel de instructies via nodes. Dit heeft als belangrijkste voordeel dat u zich niets meer moet aantrekken van de syntax, de schrijfwijze van een programmeertaal, maar dat u zich volledig kunt concentreren op de logica, de volgorde van de instructies.

U kunt Blueprints maken op 2 niveaus:

Level Blueprint – Iedere level komt met zijn eigen Level Blueprint. Wat u programmeert binnen deze Level Blueprint is enkel gekend/bruikbaar binnen het level zelf. De Level Blueprint heeft o.a. toegang tot alle actors en kan communiceren met Blueprint Classes die aan het level toegevoegd zijn.

Blueprint Class – Een Blueprint Class wordt gebruikt om assets interactief te maken, om functionaliteiten toe te voegen aan een bestaande asset. Bv. een deur is een asset. Om de deur te openen zijn er instructies nodig, moet er geprogrammeerd worden. Dit kan via een Blueprint Class. Anders dan een Level Blueprint kan een Blueprint Class doorheen het volledige project, en zelfs in meerdere projecten, gebruikt worden (er worden instances van de Blueprint Class gemaakt). Als u wijzigingen aanbrengt aan de eigenlijke Blueprint Class worden deze wijzigingen meteen doorgevoerd in alle gemaakte instances.

Een Class (of klasse) is een typisch begrip binnen object georiënteerd programmeren (OOP), dit zien we later.

Hier gaan we starten met een eerste programma in Level Blueprint.

Onderstaande video toont het verschil tussen een Level Blueprint en een Blueprint Class.


Het level bouwen

  • Maak gebruik van het level dat aangemaakt is in de vorige handleiding Prototyping (Whiteboxing) en dan meer specifiek het level met “MijnHuisje”
  • of maak snel een level dat een kleine ruimte bevat met een licht (Pointlight) in (zoals ook in onderstaande video, verderop deze handleiding gebeurt.

We gaan namelijk zo dadelijk zien hoe we het licht via Blueprint Visual Scripting (programmeren dus) kunnen aan en uit doen.

 


Level Blueprint

We hebben reeds gezien dat we gaan programmeren gebruikmakend van Blueprints en dat er zoiets bestaat als een Level Blueprint die de Blueprint, de programmeercode, bevat horende bij het level.

  • Om de Level Blueprint te openen klikt u in de knoppenbalk van de Viewport op BlueprintsOpen Level Blueprint.

De Level Blueprint wordt geopend in de zogenaamde Event Graph. De Level Blueprint kent enkel maar deze Event Graph (zie later).

In de Events Graph worden de events geprogrammeerd.

Events

Een event is een gebeurtenis, iets dat kan plaatsvinden, die getriggerd wordt door het systeem of door de gebruiker.

In Level Blueprint ziet u reeds twee events klaar staan (al zijn ze beiden nog grijs want geen van beiden is momenteel verbonden met een instructie):

  • BeginPlay – deze event wordt uitgevoerd wanneer het spel start (voor de actor, in het meeste geval voor de speler).

  • Tick – Deze event wordt iedere frame uitgevoerd (bij 60 fps (frames per second) dus 60 keer per seconde).

Merk op dat beiden events dezelfde stijl hebben (rode bovenrand). Alle events gebruiken deze stijl en zijn zo meteen herkenbaar als events.

Node toevoegen

Blueprint Visual Scripting werkt op basis van nodes die verbonden worden.

Nodes worden met mekaar verbonden via de Exec-pin.

  • We vertrekken vanuit de BeginPlay-node en slepen nu vanuit de Exec-pin, met de linkermuisknop ingedrukt, een verbindingslijn.

  • Zoek naar de gewenste actie, bv. de functionaliteit (functie), aangeduid met een F “Print String”. Typ hiertoe “print” en u vindt de functie “Print String”.

 

  • Klik op Print String. De functie wordt als een node toegevoegd en verbonden met de BeginPlay-node.

Merk op dat daar waar events met een rode omkadering worden weergegeven, functies in een blauwe omkadering worden weergegeven.

Nodes verwijderen

  • Selecteer de node Print String en klik op de Delete-toets.
  • Selecteer eveneens Event Tick en klik op de Delete-toets.

Enkel Event BeginPlay staat nog in de Level Blueprint.


Licht aan bij het opstarten

Als het level start, de speler begint te spelen, dan moet het licht branden.

Eerst moeten we even stilstaan bij het begrip objectgeoriënteerd programmeren. Later gaan we hier specifieker op ingaan.

Objectgeoriënteerd programmeren

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.

Eigenschappen

De actors die toegevoegd zijn aan het level ziet u in de World Outliner. Als u een actor selecteert dan ziet u de eigenschappen, de kenmerken, van deze actor in het Detail-panel.

Normaal is er reeds een PointLight toegevoegd, indien niet:

  • Zoek links in het Modes-panel naar LightsPoint Light.
  • Sleep de Point Light dit ergens in het decor van het level. U zou normaal het licht moeten zien branden.

  • Selecteer het toegevoegde PointLight en bekijk de eigenschappen.

Merk op dat de eigenschap Visible aangevinkt is. Inderdaad, als we het level starten brandt het licht reeds.

  • Omdat we het licht willen laten branden via programmeercode vinken we de eigenschap Visible uit.

Blueprint Licht aan

  • Open de Level Blueprint opnieuw door in de knoppenbalk van de Viewport op BlueprintsOpen Level Blueprint aan te klikken.

We willen dat “Als het level start, de speler begint te spelen, het licht brandt”.

Concreet:

Als het spel start, Event BeginPlay, moet de eigenschap Visible van het object PointLight aan, op true, gezet worden.

We moeten dus de eigenschap van het object PointLight wijzigen, object georiënteerd, hiertoe moeten we eerst een referentie naar het object PointLight toevoegen aan Level Blueprint.

Referentie naar een object toevoegen

  • Zorg dat het object PointLight geselecteerd is.
  • Klik nu met de rechtermuisknop in de Level Blueprint.
  • Omdat het object PointLight geselecteerd is kunt u nu klikken op Create a reference to PointLight.

De referentie naar het object PointLight, komende uit het Persistent Level, wordt toegevoegd aan Level Blueprint.

We moeten nu de eigenschap Visible van het object PointLight kunnen wijizgen.

  • Sleep een verbindingslijn vanuit de PointLight-node en zoek naar Visibility.

U ziet verschillende opties verschijnen.

Toggle betekent zet aan indien uit en uit indien aan (schakelen dus). Ik zou hiervoor kunnen kiezen en dit zal werken (onderstaande video doet dit).

Maar eigenlijk wil ik de eigenschap Visibility een andere waarde geven (Set). Ik kies dus voor Set Visibility.

Ik kan nu nog kiezen uit Set Visibility (Lightcomponent) of Set Visibility (PointLightcomponent). Omdat een PointLightcomponent eigenlijk ook een Lightcomponent is maakt ook dit geen verschil uit. Ik kies misschien het meest specifieke, in dit geval dus Set Visibility (PointLightcomponent).

  • Klik op Set Visibility (PointLightcomponent).
  • Versleep de nodes een beetje zodat het er overzichtelijker uitziet.

Merk op dat hij er automatisch een derde node heeft aan toegevoegd. Dit is de conversie (of casting) van ons PointLight naar het PointLightcomponent.

Ok, eigenlijk is deze conversie niet nodig want PointLight is reeds een PointLightcomponent maar C++, de achterliggende programmeertaal is nogal heel strikt en vraagt altijd de juiste conversie (ook al is het op zich niet nodig) en aangezien het automatisch gebeurt laten…

We zien dat de functionaliteit Set Visibility (merk de F op in de blauwe rand) een Target verwacht, het PointLightcomponent waarvoor de Visibility moet gewijzigd worden. Deze Target is reeds verbonden met ons object PointLight. De functionaliteit Set Visibility biedt ook de mogelijkheid een New Visibility in te stellen door het aankruisvakje aan te vinken.

  • Vink New Visibility aan.
  • Verbindt, via de Exec-pin, de event BeginPlay met de functie Set Visibility.

  • Compileer het Level Blueprint door te klikken op de knop Compile. Vergeet dit niet!
  • Build en start het level. Merk op dat het licht aan is (ok, dit was het daarvoor ook al maar nu hebben we het geprogrammeerd (How cool is that?).

Onderstaande video demonstreert het bovenstaande.

Een alternatieve uitvoering uit een andere reeks die ik ga gebruiken.

Oké, dit werkt, maar eigenlijk hebben we nu iets geprogrammeerd dat reeds werkte en dat ook gewoon kon door voor het object PointLight de eigenschap Visibility aan te vinken. Laten we het nog iets praktischer maken, iets dat niet kan zonder te programmeren.


Licht aan bij het binnengaan en uit bij het verlaten

Als u, de speler, het “huisje” binnenstapt moet het licht aangaan, als hij het weer verlaat moet het licht weer uitgaan.

Eerst gaan we ons bestaande Level Blueprint moeten wijzigen. Het licht mag immers niet langer aan staan bij het starten van het level, het moet uit zijn bij starten van het level en pas aan als ik het “huisje” binnenstap.

  • Open Level Blueprint.
  • Vink New Visibility uit.

Triggerbox

Als we het huisje binnen gaan moet het licht aan gaan.

We gaan dus iets nodig hebben, iets moeten plaatsen in het level, waardoor het systeem weet dat het huisje wordt binnen gestapt en dat een event triggert (meer bepaald een Overlap-event). Laten we eens zoeken wat Unreal Engine aan opties biedt.

  • Typ in het zoekvakje van de Place mode de tekst Trigger in.

Unreal Engine komt met een aantal Triggers in een aantal vormen. De Box Trigger past het best in ons “Huisje”.

  • Plaats en schaal een Trigger Box binnen het “Huisje”.
  • Geef het een passende naam (bv. TriggerBoxHuisje)

Event OnActorBeginOverlap

  • Selecteer vervolgens de Trigger Box.
  • Ga naar Level Blueprint.
  • Binnen Level Blueprint, klik met de rechtermuisknop in de editor. Met de TriggerBoxHuisje geselecteerd krijgt u een snelmenu specifiek voor deze Triggerbox.
  • Klik op Add events for Trigger Box Huisje – Collision – Add on Actor Begin Overlap. Dit is de event die wordt getriggerd als een actor, ons karakter, de Triggerbox begint te “overlappen”.


Een nieuwe OnActorBeginOverlap-event is toegevoegd.

Als we deze TriggerBox beginnen te overlappen, als we dus het huisje binnengaan, moet het licht aan gaan, of andersgezegd, moet de Visibility van object PointLight op true staan.

  • Het object PointLight is reeds toegevoegd aan het level, we kunnen dit gewoon kopiëren en plakken.
  • Sleep een verbindingslijn vanuit de PointLight-node en zoek naar Visibility.
  • We kiezen echter deze keer voor Toggle Visibility, dit heeft ons een grotere herbruikbaarheid van de functie (zie hieronder).

Merk de gelijkenissen op met de functionaliteit Set Visibility.

Beiden ontvangen als Target het object PointLight dat eerst nog geconverteerd wordt naar PointLightComponent.

Toggle Visibility zal echter de Visibility automatisch veranderen van aan naar uit of omgekeerd. Er is dus geen setting van een New Visibility beschikbaar.

  • Verbindt, via de Exec-pin, de event OnActorBeginOverlap met de functie Toggle Visibility.

  • Compileer het Level Blueprint door te klikken op de knop Compile. Vergeet dit niet!
  • Build en start het level, het licht is uit en gaat pas aan als u het “Huisje” binnenstapt, dus als u de TriggerBox begint te overlappen.

We hebben echter nog een probleem, het licht gaat wel aan als we het “Huisje” binnengaan, maar niet uit als we het “Huisje” verlaten. Als we dan opnieuw het “Huisje” binnengaan wordt het licht nu uitgedaan. Er wordt dus enkel mar geschakeld bij het binnengaan en niet bij het naar buitengaan.

Maar eerst gaan we nog een kleine pauze inlassen tussen het binnengaan en het licht dat aangaat.

Een delay (pauze) toevoegen

  • Sleep een verbindingslijn vanuit de event OnActorBeginOverlap.
  • Zoek naar de functionaliteit Delay.

Merk op dat deze nieuwe functie zich meteen plaatst tussen event OnActorBeginOverlap en de functie Toggle Visibility zodat er een continuïteit blijft bestaan in de volgorde van de instructies.

  1. Eerst een Delay
  2. Dan pas het licht schakelen.

  • Eventueel kunt u nog de tijdspanne van de Delay (pauze) wijzigen door de eigenschap Duration te wijzigen naar bv. 0,5.

Event OnActorEndOverlap

We hebben echter nog een probleem, het licht gaat wel aan als we het “Huisje” binnengaan, maar niet uit als we het “Huisje” verlaten. Als we dan opnieuw het “Huisje” binnengaan wordt het licht nu uitgedaan. Er wordt dus enkel mar geschakeld bij het binnengaan en niet bij het naar buitengaan.

De oplossing is het licht eveneens te schakelen als het “Huisje” verlaten wordt. We hebben dus ook een event nodig die wordt getriggerd als de TriggerBoxHuisje wordt verlaten.

  • Zorg er eerst voor dat TriggerBoxHuisje geselecteerd is.
  • Binnen Level Blueprint, klik met de rechtermuisknop in de editor. Met de TriggerBoxHuisje geselecteerd krijgt u een snelmenu specifiek voor deze Triggerbox.
  • Klik op Add events for Trigger Box Huisje – Collision – Add on Actor End Overlap. Dit is de event die wordt getriggerd als een actor, ons karakter, de Triggerbox beëindigt met te “overlappen”.


Een nieuwe OnActorEndOverlap-event is toegevoegd.

We kunnen nu identiek hetzelfde doen als bij OnActorBeginOverlap. Maar aangezien de nodes er toch staan kunnen we ze evengoed kopiëren en plakken.

  • Selecteer alle nodes onder OnActorBeginOverlap, maak hiervoor gebruik van de Ctrl-toets.
  • Kopieer en plak ze.
  • Verbindt de gekopieerde Delay-functie met de OnActorEndOverlap-event.

  • Compileer het Level Blueprint door te klikken op de knop Compile. Vergeet dit niet!
  • Build en start het level. Het werkt nu zoals gewenst.

Onderstaande video demonstreert het bovenstaande.


Deur openen

Nu we het licht kunnen aan en uit doen, misschien tijd om een deur toe te voegen aan ons “huisje” en deze deur automatisch te laten openen (ja, we hebben dan ook een heel modern “huisje”.

We gaan eerst een deur zoeken, er komt een deur met de Starter Content.

Een Static Mesh van een deur zoeken

U hebt de Starter Content toegevoegd aan uw project? Als u dit toch zou vergeten zijn, geen probleem:

  • Klik in de Content Browser op Add New.
  • Klik op Add Feature or Content pack….

  • Selecteer Starter Content in het tabblad Content Packs.

De Starter Content is toegevoegd.

  • Gebruik nu de Content Browser om te zoeken naar Door (een deur dus), filter eventueel op Static Mesh.

Collision aan de deur toevoegen

Voor we de deur gaan toevoegen aan het level gaan we eerst Collision toevoegen (anders kunnen we gewoon door de deur door lopen zonder ze te openen).

  • Dubbelklik op de Static Mesh SM_Door.
  • Klik in het menu CollisionAdd Box Simplified Collision (een deur heeft slechts een eenvoudige Collision nodig).

  • Kik op de knop Collision en vink Simple Collision aan om de Collision te bekijken.

  • Kijk ook eens in het Details-panel om te zien of alles voor de Collision staat zoals hieronder (normaal wel).

  • Vergeet niet op Save te klikken om de wijzigingen te bewaren.

Deur toevoegen aan het level

We gaan nu de deur in het level plaatsen.

  • Sleep de Static Meshes SM_Door en SM_DoorFrame in het level.
  • Gebruik de gekende technieken om deze actors de plaatsen en eventueel te roteren en te schalen.

  • Omdat de deur moet kunnen roteren moet de Mobility van SM_Door op Movable staan.

  • Vervolgens voegen we ook weer een BoxTrigger (die ik de naam DeurTriggerBox heb gegeven) toe zodat deze de deur langs beide zijden van de deur overlapt.

Met alle actors op zijn plaats en correct ingesteld kunnen we aan de programmeren slaan.

De deur openen via Blueprints Visual Scripting

Omdat dit nog steeds een intro is gaan we dit stap voor stap bespreken.

Wat moet er gebeuren?

Wel, de deur moet open gaan, of meer specifiek, de deur moet 90° roteren. De deur (SM_Door) is het object waarmee iets moet gebeuren.

  • Selecteer dus SM_Door.

Het programmeren gebeurt in Level Bleuprint.

  • Met SM_Door nog steeds geselecteerd, klik in de knoppenbalk van de Viewport op BlueprintsOpen Level Blueprint.
  • Klik met de rechtermuisknop ingeduwd in Level Blueprint. Omdat we de actor SM_Door geselecteerd hebben kunnen we gemakkelijk een referentie naar de actor aanmaken door te kiezen voor Create a Reference to SM_Door.

Een referentie naar de actor SM-Door uit het persistent level is toegevoegd.

Nu we een referentie naar ons object MS_Door toegevoegd hebben aan Level Blueprint kunnen we dit gebruiken.

Wat moet er gebeuren met deze deur? Wel, de deur moet roteren rond zijn eigen as. Dit kan via de functionaliteit SetActorRelativeRotation (omdat de rotatie relatief is ten opzichte van de actor zal deze ook blijven werken moesten we de actor verplaatsen). Moest u zich afvragen of ik met deze kennis (dat de functionaliteit SetActorRelativeRotation moet gebruikt worden) geboren ben, wel, nee. Dit is een kwestie van opzoeken en een beetje gezond verstand gebruiken.

  • Sleep dus een node vanuit onze referentie naar MS_Door en zoek naar SetActorRelativeRotation.

  • Klik deze aan als u ze gevonden hebt. Merk op dat SM_Door als Target wordt gekoppeld.

  • Er moet 90° geroteerd worden rond de Z-as. U kunt nu gewoon die 90 intypen bij Z.

Wanneer moet dit gebeuren?

Wanneer moet de deur open gaan?

Wel, wanneer de “speler” de ruimte bepaald door de DeurTriggerBox binnen treedt. Of nog meer concreet bij de Event OnActorBeginOverlap van de actor DeurTriggerBox.

  • Selecteer de DeurTriggerBox in uw level.
  • Keer terug naar Level Blueprint en klik met de rechtermuisknop ingedrukt in Level Bleuprint.
  • Omdat onze DeurTriggerBox geselecteerd is, kunt u gemakkelijk events voor deze DeurTriggerBox toevoegen. De event die we zoeken vindt u onder CollisionAdd On Actor Begin Overlap.

  • Klik deze aan.

De Event OnActorBeginOverlap van de actor DeurTriggerBox is toegevoegd.

  • Verbindt de node van de Event OnActorBeginOverlap met de node SetActorRelativeRotation.

Oke, laten we dit testen.

  • Compileer het Level Blueprint door te klikken op de knop Compile. Vergeet dit niet!
  • Build en start het level.

Het werkt!

Alle, toch bijna, de deur vliegt open en eens open gaat ze niet meer dicht.

Ah, geen probleem, we voegen een Delay toe zoals bij de lamp. Oké, maar nee, een Delay zal er enkel voor zorgen dat het iets langer duurt voor de deur met dezelfde snelheid open vliegt. Het is het openen van de deur zelf die moet vertraagd worden.

De oplossing ligt in het gebruik van een Timeline.

Een tijdslijn toevoegen

Een tijdslijn laat toe om een waarde over een zekere tijdspanne te wijzigen.

Dus, onze rotatie van de deur moet niet van 0 naar 90 gaan in 0.0000 seconden maar pakweg in 2 seconden (dit is misschien wat te lang, praktischer zou bv. 1.2 seconden kunnen zijn, maar ik wil zeker zijn dat we het gezien hebben).

Hoe doen we dit?

  1. Eerst gaan we de Timeline-functionaliteit toevoegen. Deze zal moeten starten bij OnActorBeginOverlap.
  2. Binnen deze tijdslijn bepalen we dat de waarde van 0 naar 90 moet wijzigen in een tijdsspanne van 2 seconden.
  3. De tijdslijn wordt vervolgens gebruikt om de Z-waarde van SetActorRelativeRotation te “sturen”.

Laten we dit uitvoeren.

  • sleep een node uit de Event OnActorBeginOverlap en zoek naar Add Timeline.

Deze Timeline plaatst zich mooi tussen de huidige structuur eb is verbonden met OnActorBeginOverlap via Start en verbindt op zijn beurt SetActorRelativeRotation via Update. Na wat schuifwerk ziet u dit beter.

  • Dubbelklik nu de Timeline.

U komt terecht in de Editor voor de Timeline (meer specifiek Timeline_0 omdat we het nagelaten hebben een specifieke naam te geven). Hier moet u eerst bepalen welk soort van tijdslijn u wilt toevoegen, wat u wilt wijzigen over tijd.

In ons voorbeeld moet de waarde voor de rotatie gaan van 0 naar 90 over 2 seconden. We willen dus een waarde, meer specifiek een float wijzigen.

  • Klik dus op de f-knop (Add Float Track).

  • Vul een gewenste naam in (Bv. DeurRotatie).

We moeten nu twee punten toevoegen aan de tijdslijn om van 0 naar 90 te gaan in 2 seconden.

Een beginpunt op tijd 0 en een waarde van 0.

Een eindpunt op tijd 2 (seconden) met een waarde van 90.

  • Klik nu op de tijdslijn terwijl u de Shift-toets ingedrukt houdt. Er verschijnt een punt met als waarde voor de tijd de plek waarop u geklikt hebt.

  • Wijzig nu de Time van dit punt naar 0 (laat de waarde voor Value staan) en druk op Enter. Het punt schuift op helemaal naar links van de tijdslijn.

Doe nu hetzelfde om het tweede punt toe te voegen.

  • Klik met de Shift-toets ingedrukt ergens op de tijdslijn (of klik met de rechtermuisknop ingedrukt op de tijdslijn en kies Add key to …). Wijzig de waarde van Time naar 2 en van Value naar 90 (en druk op Enter).

Wellicht verwacht u een lijn te zien maar ziet u deze niet meteen.

  • Klik dan op de knopjes Zoom To Fit Horizontal en het knopje ernaast Zoom TO Fit Vertical.

Nu ziet u wellicht wel de verwachte lijn.

Eigenlijk zouden we hier kunnen stoppen, de tijdslijn is gemaakt, maar ik ga nog twee kleine aanpassingen doen.

Ten eerste verloopt de overgang nu lineair, op zich niets mis mee maar he zou mooier ogen als de deur in het begin, en op het einde, iets langzamer beweegt.

  • Selecteer beide punten (door ze allebei aan te klikken met de Ctrl-toets ingedrukt).
  • Klik met de rechtermuisknop op één van beide punten en vink Auto aan.

  • Zet de totale lengte van de tijdslijn eveneens op 2 in het vakje Length en klik op de knoppen Compile en Save.

  • Sluit nu het tabblad van de Timeline en keer terug naar de Event Graph
  • Merk op dat er een “optie” Deur rotatie is bijgekomen.

De waarde van Deur rotatie moet nu gekoppeld worden met de Z-waarde van SetActorRelativeRotation.

  • Sleep de Deur rotatie naar New Relative Rotation en… merk op dat er een fout wordt getoond.

Deze fout zou u niet mogen verbazen. De Float-waarde van Deur rotatie is immers maar één waarde die we proberen te koppelen aan 3 rotatiewaarden (X, Y en Z) en dit kan dus niet (bovendien kwamen de kleurtjes groen en paars niet overeen).

De oplossing bestaat er uit de drie waarden van de rotatie op de splitsen in drie afzonderlijke waarden voor X, Y en Z. Dit doe je als volgt:

  • Klik met de rechtermuisknop ingedrukt op New Relative Rotation en kies voor Split Struct Pin.

U ziet nu drie verschillende New Relative Rotation voor X, Y en Z (elk met een groen kleurtje, dus van het type Float).

  • Sleep nu de Deur rotatie naar New Relative Rotation Z(Yaw) en… merk op dat het nu lukt!

Laten we dit testen.

  • Compileer het Level Blueprint door te klikken op de knop Compile. Vergeet dit niet!
  • Build en start het level.

Het werkt!

De deur sluiten

Rest ons nu nog de deur te sluiten.

Wanneer moet de deur sluiten?

Wel, wanneer de “speler” de ruimte bepaald door de DeurTriggerBox verlaat. Of nog meer concreet bij de Event OnActorEndOverlap van de actor DeurTriggerBox.

  • Selecteer de DeurTriggerBox in uw level.
  • Keer terug naar Level Blueprint en klik met de rechtermuisknop ingedrukt in Level Bleuprint.
  • Omdat onze DeurTriggerBox geselecteerd is, kunt u gemakkelijk events voor deze DeurTriggerBox toevoegen. De event die we zoeken vindt u onder CollisionAdd On Actor End Overlap.

  • Klik deze aan.

De Event OnActorEndOverlap van de actor DeurTriggerBox is toegevoegd.

De deur sluiten is eigenlijk het omgekeerde als de deur openen. Je zou kunnen zeggen, het is de tijd van de tijdslijn die de deur opent terugdraaien. Wel, dit gaan we dan ook doen.

  • Verbind de Event OnActorEndOverlap met de Reverse-actie van de Timeline.

Laten we dit testen.

  • Compileer het Level Blueprint door te klikken op de knop Compile. Vergeet dit niet!
  • Build en start het level.

Het werkt, onze deur gaat open en toe!

Extra – LERP

Als aanvulling wil ik even stilstaan bij een veelgebruikte techniek LERP (lineaire interpolatie).

Bij een LERP wordt een waarde tussen A en B gekozen op basis van Alpha. Heel vaak wordt deze Alpha aangestuurd door een Timeline.

Onderstaande video demonstreert dit.


Project Level Creation – Level Blueprint

Ons doorlopend project zit nu ook in de programmeerfase. Er wordt ook een deur geopend (en gesloten) maar deze keer een schuifdeur.

Ons doorlopend project is bijna ten einde. Nog één filmpje maar dit is voor de volgende handleiding.


Masterclass – Landscapes

Waar we tijdens ons lopend project een “interieur” omgeving bouwen, wil ik tijdens een aantal Master Classes een kijkje buiten nemen.

We starten met een Master Class rond het “sculpten” (beeldhouwen als het ware) van een landschap.

Een paar opmerkingen over onderstaande video:

  • Hij duurt echt wel lang (misschien wat te lang om goed te zijn).
  • Deze Master is duidelijk aan zijn eerste Class toe (en is dan ook nogal zenuwachtig).
  • Het tweede gedeelte, rond minuut 50, gaat over het toepassen van materialen. Uiteraard heel belangrijk, maar besef dat het aanmaken van materialen een specialiteit op zich is die u wellicht nog niet beheerst. Het is dus momenteel niet zo belangrijk dat u perfect begrijpt hoe deze materialen gemaakt worden, als u de gemaakte materialen maar kunt gebruiken.

De genoemde Technical guide vindt u hier.

De gebruikte bestanden in deze video kunt u hieronder downloaden.


Quickshots

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

Changing Things over Time

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.