‫Hoi.
‫Welkom terug.
‫Nu weten we dat we het hitresultaat onder de cursor moeten krijgen.
‫In deze video gaan we het nog even hebben over hoe dat werkt en wat dat betekent.
‫Ons doel is dus om de trefferresultaten onder de cursor te krijgen en deze locatie te tonen, en we kunnen dit doen
‫door een debugbol te tekenen.
‫We zullen ook leren hoe we dat moeten doen.
‫Dus laten we het hebben over iets dat een hitresultaat wordt genoemd.
‫In games wil je vaak zoiets doen.
‫We hebben een punt in de ruimte.
‫We noemen dit punt start en het heeft het type F vector en we hebben een eindlocatie.
‫Dit zal ook een punt in de ruimte zijn van het type F vector.
‫Laten we nu zeggen dat we een onzichtbare lijn willen trekken van het beginpunt naar het eindpunt.
‫En op het moment dat we deze lijn trekken, willen we kijken of er objecten tussen de
‫begin- en eindlocatie staan.
‫Als die er zijn, dan zal deze lijn die we in de ruimte tekenen dat object raken.
‫Op het eerste gezicht, als dit gebeurt, noemen we dit een hitgebeurtenis.
‫Als we nu zo'n onzichtbare lijn tekenen, noemen we dat het uitvoeren van een lijntracering.
‫En als we iets raken, zeggen we dat we een trace hit hebben.
‫Als we nu iets raken en een hit krijgen, slaat de trace-hit informatie op in een structuur die
‫een hitresultaat wordt genoemd.
‫Het type is F hit resultaat.
‫Nu bevat de F-hitresultatenstructuur variabelen die informatie opslaan over de hitgebeurtenis, inclusief de hitlocatie
‫als een f-vector in de ruimte en de actor die we raken, naast andere informatie.
‫Wanneer we nu een lijntracering uitvoeren, doen we dit door een botsingskanaal op te geven.
‫Meestal kiezen we bij lijntraceringen voor het kanaal dat zichtbaarheid wordt genoemd.
‫Er bestaat een opsomming genaamd E Collision Channel, en in deze opsomming is er een opsommingsconstante
‫genaamd XY-zichtbaarheid.
‫Dit is een van de parameters die we specificeren bij het uitvoeren van een lijntracering.
‫Als we nu het zichtbaarheidskanaal specificeren, betekent dit dat objecten die zijn ingesteld om het
‫zichtbaarheidskanaal te blokkeren in hun botsingsinstellingen hitgebeurtenissen zullen registreren.
‫Alle objecten die niet zijn ingesteld om het zichtbaarheidskanaal te blokkeren, genereren geen hitgebeurtenissen.
‫Nu willen we het traceerresultaat onder de cursor.
‫Stel je voor dat we het scherm hier hebben en hier is onze cursor nu.
‫Aan het uiteinde van onze cursor hebben we een punt op het scherm wanneer we de functie gebruiken om het hitresultaat onder
‫de cursor te krijgen.
‫Wat er gebeurt, is dat we onze camera hebben en dat hij sommige objecten in de wereld kan zien, zoals de vloer hier.
‫En we voeren een lijntracering uit vanaf de camera op het punt op het scherm dat overeenkomt met
‫onze cursorlocatie, en we schieten de lijntracering recht de wereld in.
‫En als we iets raken, genereren we een hitgebeurtenis en slaan we de informatie op in een hitresultaatstructuur.
‫Dus laten we eens kijken hoe we dit kunnen doen.
‫Ik ben hier in tank CP en wat ik zou willen doen is het hitresultaat onder de cursor elk frame krijgen, wat betekent dat
‫we de tick-functie nodig hebben.
‫Dus nogmaals, we gaan terug naar de basis en vinden hier onze vinkfunctie.
‫Nu gebruiken we het nergens voor in de basispion, dus we kunnen deze functie naar de tankklasse verplaatsen, net zoals we
‫deden met Begin Spelen.
‫Dus ik ga de functiedeclaratie samen met zijn commentaar markeren en kopiëren.
‫En daarna verwijder ik deze hele sectie, openbaar en zo, en dan ga ik terug naar Tank H
‫en hier in de openbare sectie ga ik de vinkfunctiedeclaratie plakken.
‫Nu gebruiken we het niet in de basispion, dus ik ga de tick-functie van de basispont verwijderen.
‫CP Nu is het weg van de basispion.
‫Nu hebben we het hier de intentie verklaard, maar we moeten ook de functie in tank definiëren.
‫CP Ik ga het hier doen in de tank DHCP, net onder de spelerinvoercomponent.
‫Dus we gaan zeggen void tick.
‫Het duurt een float genaamd Delta Time.
‫En daar is ons lichaam.
‫Nogmaals, we hebben een tank nodig net voor de tick-functie, samen met de scope-resolutie-operator.
‫En we moeten ook super tick en pass in Delta-tijd bellen.
‫Dus we hebben nu een vinkje bij de tankklasse.
‫Wat we willen doen, is de hitresultaten onder de cursor krijgen.
‫Dus hier is hoe we het doen.
‫De functie die we gaan gebruiken, bestaat op de spelercontroller, genaamd 'get hit result' onder de cursor.
‫We hebben het hierover gehad.
‫Hier is de syntaxis.
‫Er is een traceerkanaal voor nodig.
‫Onthoud dat we een traceerkanaal moeten specificeren en dat we zichtbaarheid gaan gebruiken.
‫Nu hebben we twee extra invoerparameters.
‫De eerste is een bool genaamd B trace complex.
‫We zullen het zo hebben over wat dat betekent.
‫En de derde invoerparameter is een F-trefferresultaat.
‫Nu ga ik op F-hitresultaat klikken om dit type hier in de documentatie te zien.
‫En als ik naar beneden scrol, zien we enkele variabelen.
‫Een van hen heet acteur en in de beschrijving staat Actor Hit by the Trace.
‫We hebben ook deze B-blokkerende treffer, die aangeeft of deze treffer het gevolg was van een blokkerende botsing.
‫Nu hebben we, naast de andere variabelen, zaken als impactpunt.
‫Dit is de locatie in de ruimte waar we daadwerkelijk iets raken.
‫Dus waarom gaan we niet door en proberen we deze functie aan te roepen?
‫We willen eerst onze speler, controller en dankzij wat we hier hebben gedaan en beginnen met spelen, hebben we
‫speler, controller, ref.
‫Het eerste dat we nu moeten doen, is controleren of de ref van de spelercontroller geldig is.
‫We kunnen altijd een pointer doorgeven aan een if-statement.
‫Het zal true retourneren als de aanwijzer zelf geen null-aanwijzer is.
‫Als het een null-pointer is, retourneert het false in een if-statement en zullen we nooit de binnenkant van
‫het if-statement bereiken.
‫Het is altijd een goed idee om onze aanwijzers te controleren en ervoor te zorgen dat ze niet nul zijn voordat we ze gebruiken.
‫Nu gaan we onze speler, controller ref krijgen en we gaan de pijl-operator gebruiken om
‫de functie aan te roepen, het resultaat onder de cursor te krijgen.
‫Nu kunnen we met de pop-up zien dat we drie invoerparameters hebben.
‫De eerste is het Trace Channel.
‫We gaan EA Collision Channel gebruiken en als we twee dubbele punten typen, krijgen we een vervolgkeuzelijst die ons
‫alle verschillende opsommingsconstanten in de EA Collision Channel-enum laat zien.
‫We willen zichtbaarheid gebruiken, dus we gaan XY-zichtbaarheid typen om aan te geven dat we het zichtbaarheidskanaal
‫gebruiken.
‫Nu heet de volgende parameter B Trace Complex en we gaan hier false aan doorgeven.
‫Nu zullen we in een paar minuten bespreken wat dit betekent.
‫Maar voor nu gaan we false gebruiken.
‫Nu hebben we voor de derde parameter een hitresultaat nodig.
‫Dit is een structuur van het type F-trefferresultaat.
‫Als je er nu overheen beweegt, zie je dat het resultaat van een F-treffer wordt doorgegeven als een referentie, zoals
‫aangegeven door de referentie-operator die eruitziet als een ampersand.
‫Als u iets als referentie doorgeeft, is het meestal een kostenreferentie, wat betekent dat de functie
‫het niet kan wijzigen.
‫Maar hier geven we een F-trefferresultaat door als een niet-contreferentie.
‫Dit is over het algemeen een hint dat de functie is ontworpen om deze invoerparameter rechtstreeks te wijzigen.
‫Wat het resultaat van een treffer onder de cursor gaat doen, is die variabelen in het trefferresultaat invullen met informatie
‫over het trefferresultaat.
‫Dit betekent dat we een van deze f-hitresultaten moeten doorgeven.
‫We gaan hier een lokale variabele maken in de if-controle van het type F-trefferresultaat.
‫En we kunnen dit hitresultaat noemen en we kunnen deze N gewoon doorgeven als de derde invoerparameter.
‫Nu, nadat we deze functie hebben aangeroepen, wordt dit trefferresultaat ingevuld met gegevens over
‫deze lijntracering.
‫We hebben bijvoorbeeld toegang tot het trefferresultaat dot actor om de geraakte acteur of dot impact point te krijgen om het punt in de
‫ruimte te krijgen waar we de treffer hadden.
‫Het resultaat van de treffer is dus wat we zullen gebruiken om informatie over de lijntracering te krijgen.
‫Nu is het vaak leuk om het resultaat van een lijntracering te kunnen zien.
‫We kunnen het resultaat van een lijntracering gemakkelijk visualiseren door een debugbol te tekenen.
‫Debug-bollen zijn eenvoudige vormen die we in de ruimte tekenen, en ze zijn geweldig voor het weergeven van een locatie en we gebruiken
‫deze bij het opsporen van fouten.
‫We gebruiken eigenlijk geen debug-sferen in een shift-game.
‫Dus laten we eens kijken hoe we een van deze foutopsporingsbollen kunnen tekenen.
‫Hier is de documentatie voor een functie genaamd draw debug sphere.
‫Het bestaat in draw debug helpers.
‫Dus we kunnen deze header kopiëren en opnemen waar we debug debug sphere willen noemen.
‫Kijk nu naar alle invoerparameters.
‫Ten eerste is er een wereld nodig die op deze manier weet in welke wereld de bol moet worden getekend.
‫Er is een F-vector nodig voor het middelpunt van de bol en een float voor de straal.
‫Er is een N 32 nodig voor het aantal segmenten voor die bol.
‫Hoe meer segmenten, hoe ronder de bol een F-kleur heeft.
‫Zo weet hij in welke kleur deze bol moet worden getekend.
‫Het wil weten of je aanhoudende lijnen wilt.
‫Met andere woorden, moeten de lijnen onmiddellijk verdwijnen of moeten ze blijven bestaan?
‫Als ze aanhouden, wil het de levensduur van de bol weten.
‫Wanneer moet het stoppen met het tekenen van de bol?
‫Als je geen blijvende lijnen tekent, stel dat je het voor een enkel frame zou willen tekenen, dan
‫zou je de negatieve als de levensduur doorgeven.
‫Nu zijn de laatste twee parameters optioneel, dus we houden het simpel door alleen de eerste zeven parameters
‫te bespreken.
‫Laten we eens kijken hoe dit werkt.
‫Ik ga nu bovenaan een debug-bol tekenen, ik ga debug-helpers tekenen.
‫Dat is waar deze functie voor het opsporen van fouten in de bol wordt gedeclareerd.
‫Laten we nu naar beneden gaan om te beginnen met spelen en gewoon een debugbol tekenen om te zien hoe dit werkt.
‫Dus ik ga draw debug sphere noemen en de.
‫Eerste invoerparameter is een nieuwe wereld.
‫We kunnen onze wereld op elk moment krijgen door Get World, Get World Returns een nieuwe wereldwijzer naar onze huidige wereld
‫te noemen.
‫Dus dat zal voldoen aan de eerste invoer.
‫Vervolgens hebben we een f-vector nodig voor het middelpunt van de bol.
‫Nu noemen we dit en beginnen te spelen, dus ik kan gewoon de locatie van de acteur bellen en dit zal
‫de locatie van onze tankvijver krijgen.
‫Omdat we in de tankklas zitten.
‫Nu ga ik de bol iets omhoog brengen.
‫Dus ik ga een F-vector toevoegen met nulpunt F voor de x nulpunt F voor de Y en zeg 200 F voor de Z.
‫Nu ga ik deze invoerparameters elk op hun eigen regel plaatsen.
‫Het is dus duidelijk wat we doorgeven voor elke invoer.
‫De tweede invoer krijgt deze uitdrukking, de locatie van de acteur, plus een vector die naar boven wijst met een
‫lengte van 200.
‫Als ik deze twee vectoren bij elkaar optel, krijg ik de locatie van de tank met 200 eenheden omhoog in de
‫Z-as.
‫Nu de volgende invoerparameter, het wordt de straal van de bol.
‫Ik ga 100 F kiezen, zodat we kunnen zien hoe een debug-bol met een straal van 100 eruitziet.
‫Het volgende is het aantal segmenten.
‫Ik kies er 12.
‫We zullen zien hoe dat eruit ziet.
‫Voor een F-kleur bestaat er een F-kleurklasse en deze heeft veel ingebouwde kleuren, zoals rood.
‫Nu voor de boolean genaamd B persistente lijnen, ga ik waar kiezen.
‫En voor de volgende invoerparameter hebben we de levensduurmelding.
‫Het heeft een standaardwaarde van negatief één.
‫Dat betekent dat het standaard de debug-bol tekent voor een enkel frame.
‫Maar ik ga in 30 F passen, zodat we de bol 30 seconden krijgen en ik de laatste twee parameters kan weglaten.
‫Dus hier is onze functieaanroep om een debug-bol te tekenen.
‫Laten we dit compileren en kijken hoe het eruit ziet.
‫Oké, ik ben weer terug in de editor.
‫Ik ga een tweede venster openen zodat we dit op volledig scherm kunnen zien.
‫Ik kan naar vensterweergavepoorten gaan en Viewport twee selecteren en nu zie ik dit tweede venster.
‫Het is misschien niet volledig scherm wanneer het wordt geopend, maar u kunt het altijd maximaliseren.
‫Vanaf hier kan ik het spel spelen met alt p.
‫Bekijk dit nu eens.
‫Hier is onze debug-sfeer.
‫Merk op dat het niet perfect rond is.
‫We kozen 12 voor het aantal segmenten.
‫Hoe meer segmenten u kiest, hoe meer lijnen er nodig zijn om de bol te tekenen.
‫Dit is een bol met een straal van 100.
‫Het is behoorlijk groot en het middelpunt van de bol bevindt zich op de plaats van de tank, plus 200 eenheden in
‫de lucht.
‫Dus dit is hoe we debug-bollen kunnen tekenen.
‫Dus jouw uitdaging is om een debugbol te tekenen met behulp van het traceerresultaat onder onze cursor.
‫Teken dus een debug-bol in ons nieuwe if-statement waarin we controleren of spelercontroller ref niet null
‫is.
‫Gebruik nu ons hitresultaat, haal het impactpunt van het hitresultaat en gebruik dat als het centrum voor de
‫bol.
‫Gebruik nu voor de invoerparameter voor persistente regels false en gebruik voor de duur een negatieve.
‫En dit zal resulteren in het tekenen van de bol voor een enkel frame, wat goed is omdat
‫we dit elk frame binnen de tic-functie noemen.
‫Dus pauzeer de video en teken de debug-bol in de tick-functie.
‫Oké.
‫Dus ik ben weer hier in Tank.
‫Nu heb ik deze teken debug bol functie-aanroep hier en begin met spelen, zodat ik door kan gaan en dat kan kopiëren en
‫het gewoon kan verwijderen uit het begin van het spel en we gaan terug naar het vinkje hier in onze if-instructie en
‫ik ben gewoon ga het hier plakken en we gaan enkele invoerparameters wijzigen.
‫Ten eerste veranderen we de locatie voor het middelpunt van de bol.
‫We gaan het hitresultaat gebruiken.
‫Dus ik ga zeggen hit resultaat punt impact punt.
‫Nu voor de straal, ik zou dit een beetje kleiner willen maken.
‫Laten we er ongeveer 25 van maken.
‫Dat is goed.
‫Als je dat niet deed, doe ik dit gewoon.
‫Dus de bol is niet zo groot.
‫Nu, de voorlaatste parameter die we doorgeven is voor persistente lijnen.
‫Ik ga vals doorgeven en voor de duur in plaats van 30 seconden, ga ik negatief één punt F
‫gebruiken.
‫Op die manier krijgen we een bol voor een enkel frame, wat goed is, nogmaals, we noemen dit in
‫de tick-functie, dus we noemen dit elk frame.
‫Laten we doorgaan en dit compileren.
‫Nu terug in de redactie.
‫Als ik nu op play druk, bekijk dit dan eens.
‫Ik heb een debug-bol en deze wordt getekend op het impactpunt voor de lijntracering onder de cursor.
‫Nu kunnen we dit langs de muren en op andere objecten verplaatsen en het spoor raakt deze objecten omdat ze zijn ingesteld
‫om het zichtkanaal te blokkeren.
‫Behoorlijk geweldig nu.
‫Ik beloofde dat we het zouden hebben over complexe tracering versus eenvoudige tracering.
‫Ik ga je iets laten zien terwijl we het spel spelen.
‫Laten we in de viewport klikken zodat we controle hebben over onze handpalm.
‫Druk nu op de tilde-toets en typ het console-commando show collision.
‫Nu is het misschien niet zo gemakkelijk te zien op mijn scherm, maar je kunt het zeker op je scherm zien.
‫Let op de botsing voor onze pionnen.
‫We kunnen niet alleen de capsule zien, maar we kunnen ook dit botsingsvolume rond onze tank en de mazen van de toren zien.
‫Dit is een simpele botsing.
‫Laat me je heel snel laten zien waar we de simpele botsing kunnen zien.
‫Ik ga in op activa en meshes en als ik dubbelklik op, laten we zeggen, tankbasis hier, kijken we naar
‫de complexe botsing.
‫Als ik hier bovenaan op dit pictogram voor weergeven klik en complexe botsing selecteer, kan ik alle polygonen in de
‫complexe botsing zien en dat zijn er veel.
‫Als ik nogmaals op het pictogram Weergeven klik en deze keer het selectievakje naast Simple Collision aanvink, merk ik op dat
‫er nog een botsingsvolume is.
‫Dit wordt een aanvaringsromp genoemd en heeft veel minder geometrie.
‫Er is een kleiner aantal polygonen met dit botsingsvolume.
‫Dit is wat de physics-engine gebruikt om overlap in hitgebeurtenissen te detecteren.
‫Als het de complexe botsing zou gebruiken, zou het veel meer berekeningen vereisen.
‫Dit is de reden waarom we eenvoudige botsingsvolumes hebben, dus het is veel beter voor de prestaties wanneer
‫we een lijntracering uitvoeren als we traceren voor eenvoudige botsingen in plaats van complexe botsingen.
‫Dus nu hebben we het hitresultaat onder de cursor gekregen.
‫Het kostte wat moeite om daar te komen, maar nu hebben we het en we hebben het bewezen door deze locatie te
‫tonen met een debug-bol.
‫Dit is een leuke manier om te bevestigen dat onze traceerhit werkt.
‫Dus nu we weten dat het werkt, kunnen we die locatie gebruiken om de toren op onze tank te draaien.
‫En dat doen we in de volgende video.
‫Ik zie je snel.