‫Hallo en welkom.
‫In deze lezing gaan we kijken hoe we ons bewegende platform kunnen instellen met behulp van een vectorsnelheid in
‫zijn lidvariabelen.
‫En we gaan kijken hoe we de framesnelheid van de beweging onafhankelijk kunnen maken met behulp van iets dat Delta-tijd
‫wordt genoemd.
‫Oké, laten we erin duiken.
‫Dus tot nu toe hebben we slechts één onderdeel van onze vector tegelijk bijgewerkt.
‫Wat als ik je vertel dat we het niet op deze manier hoeven te doen?
‫Wat als we de hele vector in één keer met een bepaald bedrag kunnen bijwerken?
‫Nou, dat kunnen we.
‫Vectoren kunnen aan andere factoren worden toegevoegd als we in de vorige sectie hebben gezien.
‫Dus wat we zouden kunnen doen is naar ons bewegende platform naar H gaan en iets creëren
‫dat ons bewegende platform is, de snelheidsvector die ons zowel de richting als de snelheid vertelt waarmee we willen gaan.
‫Dus de manier waarop we dit doen, is door nu een vrij bekende U van eigendom te creëren en
‫we gaan het overal bewerken zodat het zichtbaar is in de inspecteur en dan wordt het
‫een type F-vector zoals we eerder hebben gedaan, en we noemen het de platformsnelheid en we kunnen er voorlopig iets aan geven.
‫Dus we gaan een F-vectorconstructor maken en dan geven we die honderden in de X-component en nul en nul in de
‫andere en dan een puntkomma om het af te maken.
‫En ik wil je hier nog een truc laten zien, namelijk dat we samen met bewerken, overal waar we nog een door
‫komma's gescheiden argument kunnen plaatsen in deze U.
‫Eigendomsding, dat een beetje op een functie lijkt.
‫Eigenlijk kun je er een die categorie heet met een hoofdletter C zetten en dan het gelijkteken zetten.
‫En ik laat meestal geen spatie tussen deze zijn gelijktekens, categorie is gelijk aan.
‫En dan kun je een categorie opgeven die je wilt laten zien.
‫Hier beneden kunt u zien dat er categorieën zijn voor replicatie van het renderen van transformaties.
‫Dit zijn het soort categorieën dat we bedoelen, ik ga het mijn bewegend platform noemen, zodat we een soort
‫bewegend platform categorie hebben om deze variabelen in te plaatsen.
‫En merk op dat ik dubbele aanhalingstekens rond die categorie gebruik.
‫Dat is de juiste syntaxis.
‫Die moet je er wel bij hebben.
‫En wat we dan kunnen doen, is dat we deze nieuwe lidvariabele kunnen gebruiken in C++.
‫Dus in plaats van de X-component van de huidige locatie in te stellen, laat ik
‫die regel volledig verwijderen en herschrijven omdat de huidige locatie gelijk is aan de huidige locatie plus platformsnelheid, zoals bijvoorbeeld een puntkomma aan het einde van de regel en
‫laten we naar Unreal gaan en klik op compileren en kijk hoe dit gaat.
‫Dus dat is succesvol gecompileerd.
‫En je kunt zien dat ik nu dit bewegende platformgedeelte op mijn bewegend platform heb met een platformsnelheid
‫en de x-component is ingesteld op 100.
‫Wat gebeurt er als ik ga en op play druk?
‫Wel, het platform snelt snel weg in de verte, want ik voeg honderd eenheden toe aan elk afzonderlijk
‫frame.
‫Dat is veel.
‫Maar ik wil wel dat het beweegt met een snelheid van ongeveer 100 centimeter per seconde.
‫Dat is slechts één meter per seconde.
‫Het is niet erg snel.
‫Dus waarom gaat het zo snel?
‫Nou, vanwege mijn framerate.
‫Als ik op een langzamer systeem zat, zou het langzamer gaan.
‫En als ik op een sneller systeem zat, zou het sneller gaan.
‫Dat lijkt niet logisch.
‫Dus laten we het hebben over het gebruik van Delta-tijd.
‫Wat is Delta-tijd?
‫Welnu, het gebruik van Delta-tijd in Unreal kan ons vertellen hoe lang het duurde om elk frame uit te voeren, Delta-tijd was.
‫Welnu, als je naar Visual Studio-code gaat, kun je zien dat Delta-tijd een variabele is die hier bovenaan de take
‫wordt genoemd.
‫Dit is eigenlijk een invoerparameter.
‫Het is de input voor onze functie.
‫Dus we kunnen het hier gebruiken.
‫Net zoals we een lokale variabele gebruiken, kunnen we deze in de hoofdtekst van de tick-functie gebruiken.
‫Het vertelt ons dus hoe lang het duurde om een frame uit te voeren.
‫Maar waarom is dat belangrijk?
‫Want als we iets vermenigvuldigen met delta-tijd, wordt onze game frame rate onafhankelijk, wat in feite betekent dat
‫de game zich hetzelfde gedraagt op een snelle of een langzame computer.
‫Laten we dus een illustratief voorbeeld bekijken als ik elke seconde iets met één eenheid naar links
‫wil verplaatsen.
‫Hier is hoe het eruit zou zien op verschillende machines.
‫Ik heb een trage computer.
‫Ik kan maar tien frames per seconde doen op een snelle computer, die 100 frames per seconde kan doen.
‫Nu is de duur van die frames anders.
‫Dus op de langzame computer is de duur van het frame 0. 1 seconde.
‫Als ik er maar tien in een seconde kan passen en op een snelle computer zou het zijn. 01 van een seconde, zoveel minder omdat
‫het dingen sneller kan uitvoeren.
‫Het duurt niet zo lang om het frame te berekenen.
‫Dus als ik vermenigvuldig met de duur van het frame, vermenigvuldig ik mijn eenheid met de duur van het frame.
‫Dan ga je dat in 1/2 zien.
‫Dus waar tien frames zijn uitgevoerd, krijg ik één bewegingseenheid.
‫En hetzelfde is waar.
‫Als ik 100 frames van executie heb gedaan, krijg ik nog steeds één bewegingseenheid.
‫Dus ik daag je uit om te vermenigvuldigen met Delta-tijd.
‫Dus wat we gaan doen is onthouden dat we vectoren kunnen vermenigvuldigen met een drijvende-kommawaarde om
‫die grootte te schalen.
‫En de manier waarop we dit in C++ kunnen doen, is door de star-operator te gebruiken.
‫Dat is hoe we vermenigvuldigen.
‫Er is geen operator voor vermenigvuldigingstekens.
‫Het zou worden verward met een X, dus gebruiken we de steroperator om vermenigvuldiging aan te duiden.
‫En ik zou graag willen dat je je resultaten compileert en test.
‫Dus vermenigvuldig met deltatijd, vermenigvuldig de snelheid met deltatijd en kijk wat er gebeurt.
‫Pauzeer, video en ga aan de slag.
‫Oké.
‫Welkom terug.
‫Dus het is de platformsnelheid die we hier willen vermenigvuldigen.
‫We zouden dit naar een aparte variabele kunnen trekken, maar feitelijk kunnen we een vermenigvuldiging met delta-tijd
‫aan het einde van die regel zetten, duidelijk voor de puntkomma, omdat het voor het einde van de verklaring
‫staat.
‫Wat hier interessant is, is dat operators hier een beetje voorrang hebben,
‫omdat de vermenigvuldiging tussen de platformsnelheid en de Delta-tijd zal plaatsvinden vóór de toevoeging aan
‫de huidige locatie.
‫Dit volgt nu de normale wiskundige regels voor een volledige lijst van die regels.
‫Ik ga hier niet in detail treden, maar je kunt een kijkje nemen op de pagina over de
‫volgorde van bewerkingen op Wikipedia.
‫Er zijn veel verschillende regels in verschillende talen, of het nu gaat om lichaamsmassa, bedmassa, huisdiermassa,
‫bedmassa.
‫Er zijn heel veel verschillende afkortingen.
‫Dus welke je ook gebruikt, die zou ik je aanraden te gebruiken.
‫Voor mij was het body mass, maar weet je, op andere plaatsen is het anders.
‫Het is dus vermeldenswaard dat we het gewoon zo kunnen schrijven.
‫Maar als we er zeker van willen zijn dat iets in een andere volgorde gebeurt, dan kun je haakjes
‫gebruiken om dit aan te geven.
‫Dus ik zou, om de zaken duidelijker te maken, haakjes rond deze vermenigvuldiging zetten om je te laten zien dat
‫dat is wat er gebeurt.
‫Eerst de vermenigvuldiging en dan de optelling bij de huidige locatie.
‫Dus laten we naar Unreal gaan en dit testen.
‫We gaan hit, compileren, en als dat klaar is, laten we op play drukken.
‫En nu zien we de platforms met een veel normalere snelheid bewegen, omdat het eigenlijk met één
‫meter per seconde beweegt, wat oké is voor een bewegend platform.
‫Je kunt dus zien dat dit ons allebei heeft geholpen de snelheid te verlagen, maar ook nu is dit een framerate, onafhankelijke
‫snelheid.
‫Als mijn computer aan het puffen was omdat er iets anders op de achtergrond aan de hand was, zou
‫dit er nog steeds hetzelfde uitzien en hetzelfde spelen in het spel.
‫Goed spul.
‫Ik zie je in de volgende lezing.