Een kijkje onder de motorkap naar componenten

uit de cursus Starten met Unity

Leuk dat je onze site bezoekt,

Ben jij leergierig?. Jij abonnee en dan ik geef jou 5% korting op de eerste maand! Wat vind je daar van? gebruik als kortingscode: DIEHARD

Geef een reactie of stel een vraag

Geef een reactie

Registreer als je wilt reageren.

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

Starten met Unity

perm_identity Hans Wichman | video_library 21 video's | query_builder 01:33

Snel op weg met Unity

Unity is een populaire game engine, gratis voor persoonlijk gebruik, om 2D en 3D games mee te maken. In dit uitgebreide en complexe pakket kun je vrijwel alles maken wat je maar kan bedenken op game gebied, maar dat zorgt er vaak ook voor dat je als nieuwkomer geen idee hebt waar je moet beginnen. In deze bijna 1,5 uur durende cursus neem ik je in vogelvlucht mee door alle beginstappen en basisprincipes, terwijl je bouwt aan je eerste eigen Unity product.

 

Wat ga je leren?

In deze cursus leg ik je stap voor stap uit:

  • Wat Unity is en wat je met Unity kan.
  • Waar je Unity kunt vinden en hoe je Unity kunt installeren.
  • Wat de basis kennis & vaardigheden zijn die je minimaal nodig hebt om met Unity aan de slag te gaan:
    • Hoe de Unity interface werkt.
    • Wat Scenes, GameObjecten, Componenten, Assets en Prefabs nou precies zijn.
    • Hoe je zelf een eenvoudige omgeving kunt maken waar je in rond kunt lopen.

Alles wat je leert, pas je direct in de praktijk toe en daarvoor hoef je op dit moment nog helemaal niets van Unity af te weten.

In deze video duiken we met behulp van de InspectorWindow

onder de motorkap van GameObjecten

en gaan we het hebben over Componenten.

Ik laat je zien hoe je hiermee sneller dan voorheen je Scene kunt editen,

en hoe je bijvoorbeeld zwaartekracht toe kunt voegen aan je GameObjecten.

We hebben ondertussen allerlei verschillende GameObjecten gezien:

kubussen, bollen, vlakken, particle systemen, licht, camera etc.

Allemaal GameObjecten, maar tegelijkertijd heel verschillend.

Hoe een GameObject eruit ziet en zich gedraagt,

wordt namelijk niet alleen bepaald door assets,

maar vooral door zijn componenten.

Welke componenten dat precies zijn,

kun je hier rechts zien met behulp van de InspectorWindow.

Hier zie je ten eerste een paar instellingen die ieder GameObject heeft,

zoals een naam, tag en layer.

Daaronder staat een lijst van alle componenten van je gameobject,

inclusief hun eigenschappen.

Zo een component kun je herkennen aan een dikgedrukte naam met links daarvan een pijltje.

Hiermee kun je alle eigenschappen van dat component tonen of verbergen.

Er is verplicht component en dat is het Transform component.

Deze bepaalt de plek van een GameObject in je Scene en moet altijd aanwezig zijn.

Alle andere componenten zijn optioneel.

Zo zien we bijvoorbeeld:

een Light component voor het Directional Light GameObject

een Camera component voor het Camera GameObject

en een MeshRenderer component wat er voor zorgt

dat dit vlak daadwerkelijk op het scherm getekend wordt

Zo zijn er heel veel verschillende componenten,

met heel veel verschillende eigenschappen,

waarmee je het gedrag & uiterlijk van je GameObject aan kunt passen.

Welke componenten er allemaal zijn

en welke eigenschappen ze precies hebben,

is voor nu niet zo heel belangrijk.

Wat wel belangrijk is, is snappen,

dat vrijwel iedere bewerking die je op je GameObject doet,

onder water een of ander component aanpast.

Transformeer je een GameObject in de SceneView,

dan zie je hier rechts ook de getallen van zijn Transform component veranderen.

Sleep je een Materiaal over een GameObject in je Scene,

dan wordt in het MeshRenderer component het materiaal veld ook aangepast.

Andersom geldt precies t zelfde.

Pas ik hier een waarde van mijn transform component aan,

dan verandert de positie van mijn GameObject in de SceneView ook.

Sleep ik een Material asset over mijn MeshRenderer component

dan wordt het materiaal van mijn GameObject ook aangepast.

Hoe je zo een waarde in de InspectorView zet,

hangt helemaal af van het specifieke type veld waar je mee te maken hebt.

Sommige velden kun je alleen maar veranderen door er in te typen,

andere velden kun je veranderen door typen of door het slepen van een label,

en weer andere velden kun je alleen maar veranderen

door te kiezen uit een vaste waarde, zoals bij dropdowns en colorpickers.

Tot slot zijn er ook nog velden met zo een rondje erachter.

Dit soort velden bevatten geen vaste waarde,

maar een verwijzing naar iets anders uit je project.

Dat kan een asset zijn, een GameObject, of totaal iets anders.

Op deze manier verbinden componenten dus als het ware

allerlei verschillende onderdelen van je project.

Wil je zo een waarde aanpassen,

dan kun je dat doen door op het rondje achter het veld te klikken.

Je krijgt dan een lijst te zien van alle items in Unity die daar zouden passen.

In dit geval is dat een lijst van al je eigen materialen

plus een aantal standaard ingebouwde Unity materialen

die geen onderdeel uitmaken van je ProjectWindow.

In zo een lijst kun je keer op een item klikken om deze te selecteren,

of dubbelklikken om het item te selecteren en de lijst gelijk weer af te sluiten.

Klik je daarna op het veld zelf, dan probeert Unity, indien mogelijk,

je te tonen waar dat veld naar verwijst, in dit geval deze material asset.

Dubbelklik je op zo een veld, dan selecteer je het gelinkte item,

en moet je handmatig weer terug wisselen naar het GameObject wat je aan het editen was.

Een andere manier om de waarde van zo een veld te zetten,

is door direct een object van het juiste type in het veld te slepen.

Unity beschermt je daarbij in die zin, dat je geen ongeldige combinaties kunt maken

door het verkeerde ding in het verkeerde veld te slepen.

Dit lijkt wellicht allemaal een stuk complexer

dan gewoon een materiaal op je GameObject te slepen,

maar het grote voordeel van het direct met componenten werken

is dat je op deze manier veel meer controle hebt over je GameObjecten.

Zo kun je via componenten je GameObjecten bijvoorbeeld ook multi-editen.

Dat betekent dat je meerdere GameObjecten tegelijk kunt selecteren,

en in keer een bepaalde waarde kunt zetten voor al die GameObjecten.

Met behulp van de InspectorView kunnen we ook componenten toevoegen & verwijderen

om onze GameObjecten aan te passen.

Daarbij kun je kiezen uit alle standaard Unity componenten

of zoals we in de vorige video hebben gezien,

door middel van scripting je eigen componenten maken.

In deze video leg ik je wat meer uit over Rigidbodies en Colliders.

Maak hiervoor eerst even een kubus aan en zet deze een stuk boven je plane.

Je kunt een component aan dit GameObject toevoegen via het Component menu,

of via de Add component button hier.

Beide bevatten exact dezelfde lijst.

Echter deze Add.. button heeft ook een handige filter optie

en daarom gebruik ik deze vaker.

Zoek hier bijvoorbeeld maar eens op de naam Rigidbody

en kies dan de versie uit zonder D achter de naam.

Druk nu op Play.

Zoals je ziet, zorgt dit component er voor dat je object nu ineens meedraait

in een natuurkundige simulatie.

Met andere woorden, je object kan nu vallen,

heen en weer geduwd worden

en weggeschoten worden met sneeuwballen.

Ook kun je nu vanuit Scripts, botsingen detecteren met dit object.

Rigidbodies werken vrijwel altijd samen met colliders in dit geval, deze BoxCollider.

BoxCollider betekent bijvoorbeeld zoiets als 'Botsend object in de vorm van een kubus'.

Componenten kun je ook weer verwijderen in de InspectorView

via het uitklapmenu hier rechts.

Wat er daarbij gebeurt is compleet afhankelijk van het component dat je verwijderd.

Verwijder ik bijvoorbeeld mijn BoxCollider

dan valt mijn object nog steeds vanwege de RigidBody,

maar omdat deze nu nergens meer mee botst, valt ie direct door de vloer.

Stuk voor stuk kunnen we ieder component verwijderen,

totdat er niets meer over is behalve het Transform component.

Zo een GameObject met alleen een Transform component,

noemen we ook wel een Empty.

Wat daar het nut van is laat ik je verderop in de cursus zien.

Door Componenten toe te voegen en te verwijderen,

kun je dus ieder GameObject namaken uit het GameObject menu.

Je kunt een kubus in een lamp veranderen en een lamp in een kubus.

Je kunt t zo gek niet bedenken, of je kunt het doen met behulp van componenten.

Probeer voordat je verder gaat, het aanpassen en toevoegen van componenten maar eens uit.

Dat kun je doen door net zoals ik wat bouwwerken in elkaar te knutselen

die je om kunt gooien met sneeuwballen.

Let goed op hoe ik in keer alle objecten van kleur voorzie,

en hoe ik er met het RigidBody component voor zorg dat ik dingen om kan gooien.