‫Hallo en welkom.
‫In deze lezing gaan we leren over objecten en hoe we functionaliteit op objecten en
‫hun gegevens kunnen gebruiken om interessante programma's te maken.
‫Laten we erin duiken.
‫Laten we deze lezing dus beginnen met de introductie van een nieuw concept.
‫Het concept van objecten is absoluut essentieel voor veel programmeertalen.
‫Dus een object is in wezen iets in die zin dat je iets wilt vertegenwoordigen, zoiets als in een spel dat
‫je misschien een avonturier hebt.
‫Hij is een object in jouw wereld en hij heeft misschien wat gegevens die representeren wat hij is.
‫Dingen als zijn ervaringspunten bijvoorbeeld, of misschien zijn niveau.
‫Hij is een niveau twee avonturier.
‫Dat soort dingen zijn de gegevens waaruit een avonturier bestaat.
‫Maar dat is niet alles wat een avonturier is.
‫Een avonturier is ook een functionaliteit, zoals het vermogen om pijlen af te vuren, zoals het
‫kunnen springen enzovoort.
‫Er zijn echter nog andere dingen die objecten kunnen zijn.
‫We kunnen bijvoorbeeld dingen in de echte wereld vertegenwoordigen, in de computer, zoals de speler, en we
‫kunnen relevante eigenschappen voor de speler opslaan, zoals gebruikt de speler een controller?
‫Is de speler nummer één of nummer twee?
‫Dat soort stukjes gegevens en de relevante functionaliteit zoals hun huidige invoer krijgen.
‫Houden ze de spatiebalk ingedrukt, krijgen bijvoorbeeld het vaardigheidsniveau van de speler en dan kun
‫je volledig abstracte objecten hebben, dingen als een lijst.
‫Je zou dus een lijst kunnen hebben met de items één, twee, drie, vier.
‫En het is of misschien kan het alle items bevatten die je leuk vindt.
‫De gegevens kunnen veranderen, maar het kan ook functionaliteit hebben, zoals het laatste item uit de lijst verwijderen of toevoegen
‫aan het einde van de lijst.
‫Dus je kunt zien dat objecten heel, heel flexibel zijn.
‫Ze kunnen worden gebruikt om talloze verschillende dingen weer te geven.
‫En je zult merken dat de functionaliteit aan de onderkant van deze objecten eigenlijk is wat die knooppunten
‫zijn of wat veel knooppunten zijn in Blueprint.
‫Dus ze beginnen een beetje een toewijzing te krijgen tussen de objecten en de functionaliteit.
‫Oké.
‫Daarom hebben we een aantal nieuwe concepten geïntroduceerd, laten we het even kort samenvatten.
‫Dus we hebben gezegd dat objecten verzamelingen van gegevens en functionaliteit zijn.
‫Wat we ons misschien niet hebben gerealiseerd, is dat de acteurs eigenlijk objecten zijn.
‫Acteurs zijn objecten die in een niveau kunnen gaan en je kunt dit zien als je naar je niveau gaat, je
‫de kubus selecteert, je kunt zien dat er een heleboel in de details zit, een lading gegevens schilderen.
‫En zoals we straks zullen zien, is er ook een hoop functionaliteit in de knooppuntvorm en blauwdruk.
‫Dan zijn er componenten.
‫Nu componenten waar we nog niet eerder in detail op in zijn gegaan, maar hier zijn ze.
‫Het zijn objecten die op een acteur kunnen gaan, terwijl acteurs op het niveau gaan, componenten gaan op een acteur
‫zelf.
‫Dus als de kubus is geselecteerd, kun je bovenaan het detailvenster zien dat er een statische
‫mesh-component is.
‫Als u daar daadwerkelijk op klikt, ziet u dat het detailvenster een beperkte set details krijgt.
‫Het toont u niet alle eigenschappen die beschikbaar zijn op de Kubus-actor, maar alleen de subset van eigenschappen die
‫behoren tot de statische mesh-component, die in feite de component is die ons vertelt hoe we
‫een kubus moeten tekenen.
‫Nu kunnen deze objecten vaak veel meer data hebben dan dit, en dat betekent dat ze
‫behoorlijk zwaar kunnen worden om door je computer te manipuleren en zeker als het deze objecten moet kopiëren.
‫Dus in plaats van dat te doen, gebruiken we een slimme structuur, een referentie genaamd, die in wezen gewoon een adres
‫is, of waar moet ik heen om dit object in het geheugen van de computer te vinden, zodat ik het object niet de
‫hele tijd hoef te verplaatsen?
‫We zullen iets meer vertellen over hoe dit in het geheugen werkt als we bij C++ komen, maar voor nu is het voldoende om
‫te weten dat het slechts een adres is.
‫Dus wat we kunnen doen, laten we bijvoorbeeld eens in Unreal duiken.
‫Als we in ons hoofdniveau waren en we wilden wat functionaliteit op onze kubus gebruiken, dan kan ik de kubus in de scène selecteren
‫en dan kan ik naar mijn niveaublauwdruk gaan en met de rechtermuisknop klikken, en
‫dan kan ik klik op een verwijzing naar Cube maken en dit creëert een nieuw knooppunt.
‫Wat doet dat nou?
‫Dat zegt ons eigenlijk dat dit het adres van de Cube is.
‫Als je iets met de kubus wilt doen, kun je hem hier vinden.
‫Wat er in Blueprint gebeurt als je het spel uitvoert, is dat het die kubus gaat zoeken.
‫En dan kun je vragen stellen of functionaliteit op de kubus gebruiken, zoals zeggen: Hé, waar
‫woont je statische mesh-component?
‫En hij gaat, oké, de statische mesh-componenten daar.
‫Dus we gaan op zoek naar de statische mesh-component en dan kunnen we daar vragen over stellen en ze kunnen zeggen:
‫Hé, hoe heet je?
‫Statische mesh-component.
‫En de statische component kan zeggen: Hé, ik ben Bob.
‫En zo kunnen we deze referenties gebruiken en de functionaliteit van meerdere verschillende objecten gebruiken om te komen
‫waar we heen willen.
‫Nu hebben we gezegd dat de a-referentie is waar een object te vinden is.
‫En nu iets anders dat het vermelden waard is, is een gegevensvenster.
‫Wat is een.
‫TAPPIN Nou, deze kubusreferentie heeft er eigenlijk een.
‫Dit kleine blauwe ronde ding aan de rechterkant is een datapin.
‫We hebben deze eerder gezien op de printstring-knooppunten daar aan de linkerkant, en ze
‫zijn paars.
‫En hoe verschilden deze van de andere soorten spelden die we hebben gezien, deze witte spelden?
‫Welnu, de datapin is de invoer of uitvoer van gegevens voor een knooppunt.
‫Dus een knooppunt, als het zich aan de linkerkant bevindt, is de invoer, het zijn de gegevens waarmee het knooppunt kan werken.
‫Als het aan de rechterkant staat, zijn het de gegevens die Node produceert.
‫Dus in het geval van de kubus produceert dit knooppunt een verwijzing naar de kubusacteur en vervolgens naar de uitvoeringspinnen.
‫Dit zijn eigenlijk hoe die witte pinnen echt worden genoemd om ze te onderscheiden van de datapinnen, en ze
‫zijn nog steeds wanneer het knooppunt moet worden uitgevoerd.
‫Dus datapinnen zijn waarmee het knooppunt moet worden uitgevoerd.
‫Uitvoeringspinnen zijn wanneer het moet worden uitgevoerd.
‫Dus laten we met al die informatie een beetje gebruik maken van de functionaliteit van deze objecten.
‫Dus we hebben onze kubusreferentie.
‫Als we de kubusreferentiepin eraf slepen, kunt u alle functionaliteit van die kubus gebruiken.
‫Zoals ik al zei, we hebben een component op de kubus, een statische mesh-component genaamd, en ik wil
‫doorgaan en een verwijzing ernaar krijgen.
‫Dus we gaan op zoek naar statische mesh-componenten.
‫En het onderste item voor mij is om een statische mesh-component te krijgen.
‫Daar kan ik op klikken.
‫We krijgen een nieuw knooppunt waarbij de invoer een kubusreferentie is en de uitvoer een verwijzing hiernaar.
‫Het is een statische mesh-component.
‫Dus als we daar vanaf slepen, dan kunnen we om de functionaliteit van
‫de statische mesh-component vragen, zoals de weergavenaam krijgen en dat geeft ons de invoer van de statische mesh-componentreferentie en het gebruikt de functionaliteit om de weergavenaam
‫te krijgen en dan keert het terug een string of een tekstwaarde die we kunnen printen met behulp van de print
‫string node.
‫Dus we kunnen daar vanaf slepen en print string typen en dan kunnen we de uitvoeringsnotities aansluiten
‫zodat dat na de andere twee printstrings loopt bij Begin Play, je zult merken dat sommige van deze knooppunten
‫geen uitvoeringspinnen hebben en misschien verwarrend.
‫Wanneer worden ze gevlucht?
‫Welnu, ze worden uitgevoerd wanneer de blauwdrukken denken dat het gepast is, in wezen wanneer het nodig is door een
‫knooppunt dat wel een uitvoeringspin heeft.
‫Dus als we doorgaan en op play drukken, kun je zien dat het verschijnt met een naam kubus statische mesh
‫component nul, zoiets als dat is een beetje programma, misschien is het niet, het is niet Bob. Het is een beetje meer betrokken
‫dan dat.
‫Maar je kunt zien dat we in wezen gecodeerd hebben in die reeks vragen die ik op mijn dia had.
‫Dus ik daag je uit om door te gaan en de massa van onze statische mesh-componenten te krijgen.
‫We hebben het in het verleden geconfigureerd.
‫Als je naar het niveau gaat en naar het detailvenster kijkt, kun je zien dat een van de eigenschappen van
‫de fysica de massa was en we hebben dat geconfigureerd als een stukje gegevens over de statische mesh-component.
‫Welnu, als u het knooppunt voor de weergavenaam van de weergave verwijdert en de statische mesh-component wegsleept, zou
‫u in staat moeten zijn om te zoeken naar get mass en dat zou u het stuk gegevens over de statische mesh-component
‫moeten geven en kijken of u die waarde kunt afdrukken met onze print string node pauzeer video en probeer het.
‫Oké.
‫Welkom terug.
‫Dus als we teruggaan naar de blauwdruk, verwijder dan gewoon onze weergavenaam, sleep de statische mesh-component weg en
‫zoek naar get mass.
‫Dan kunnen we dat knooppunt binnenhalen.
‫We hebben hier een retourwaarde en dat wordt onze massawaarde.
‫Je kunt zien dat als je eroverheen zweeft, de massa van dit onderdeel in kilogrammen wordt geretourneerd.
‫En trouwens, retourwaarde betekent alleen de uitvoergegevens en dan kunnen we dat knooppunt naar onze in-tekenreeks
‫slepen voor de afdrukreeks.
‫En je ziet dat het een klein conversieknooppunt creëert dat in orde is.
‫Het converteert van wat deze waarde ook is naar iets dat de printstring zal accepteren.
‫We kunnen doorgaan en op play drukken en je ziet dat we de waarde van 1000 krijgen, waarvan we weten dat het de massa was die we
‫hebben geconfigureerd of wat je ook daadwerkelijk configureert.
‫U kunt dat veranderen en zien dat deze waarde ook zal veranderen.
‫Dat was het dan voor deze lezing.
‫We hebben geleerd over objecten en hun verwijzingen en over het gebruik van functionaliteitsknooppunten in blauwdrukken.