Share
Camera este unul dintre cele mai importante elemente dintr-un joc 3D. Acționează ca ochii jucătorului, lăsându-i să vadă lumea jocurilor din diferite puncte de vedere. În Unity3D, o cameră 3D funcționează la fel ca o cameră de filmat. Acesta poate fi panoramat, înclinat și apropiat de scene. Acest tutorial vă va învăța cum să creați mai multe perspective de cameră terțe.
Pentru inspirație sau pentru a utiliza un punct de pornire pentru propria dvs. activitate, aruncăm o privire la unele dintre cele mai populare modele 3D de pe Envato Market. Sau beneficiați de ajutor individual la alegerea unuia dintre serviciile 3D de design și modelare de pe Envato Studio.
Avem nevoie de un proiect simplu pentru a testa scripturile camerei noastre. Vom avea nevoie de o scenă cu un avion la sol care are o textură pe ea. Acest lucru va facilita vizualizarea modului în care fiecare cameră se mișcă și reacționează la intrările jucătorilor. Când terminăm, ar trebui să arate astfel:
Urmați acești pași pentru a configura proiectul:
Toate camerele pe care le vom crea vor avea nevoie de o țintă: ceva de privit sau de urmat. Deci, să creăm un jucător de bază pe care îl putem muta cu tastele săgeți.
În scriptul Player, adăugați două proprietăți publice pentru viteza de mișcare și rotire. Apoi adăugați următorul cod în metoda Update ():
Accentsconagua
public class Jucător: MonoBehour public float moveSpeed = 10; transferul public al flotoruluiSpeed = 60; void Actualizare () float orizontal = Input.GetAxis ("Orizontal") * turnSpeed * Time.deltaTime; transformați rotația (0, orizontală, 0); float verticale = Input.GetAxis ("Vertical") * moveSpeed * Time.deltaTime; transforma.Translate (0, 0, vertical); Acest lucru oferă jucătorului controale similare cu cele ale unui rezervor. Axa orizontală (tastele stânga sau dreapta) întoarce playerul în jurul valorii, în timp ce axa verticală (tastele sus-jos) deplasează playerul înainte și înapoi.
Aceasta este camera cea mai de bază a celei de-a treia persoane. Se află într-o locație fixă în lumea 3D și își urmărește ținta ca o turelă.
În scriptul LookAtCamera, creați un atribut public pentru obiectivul camerei noastre din partea de sus a clasei. Atributele publice sunt expuse în inspector și ne permit să atribuim Player-ul drept obiectivul camerei:
clasa publică LookAtCamera: MonoBehour public GameObject target;
Apoi, trebuie să spunem transformarea camerei noastre să privească obiectul țintă. Din fericire, transformarea obiectelor are o metodă convenabilă LookAt () pe care o putem folosi pentru a face acest lucru. Am putea face acest lucru în metoda Update (), dar am creat o metodă LateUpdate (). Ca regulă generală, trebuie să utilizați întotdeauna LateUpdate () în locul metodei Update () în toate scripturile pentru camere. LateUpdate () se întâmplă după ce Update () a terminat, astfel încât scriptul Player are șansa de a termina calculul poziției jucătorului înainte ca camera să-și calculeze poziția. Acest lucru duce la o mișcare mai ușoară a camerei:
void LateUpdate () transform.LookAt (target.transform);
Scriptul final ar trebui să arate ca:
clasa publică LookAtCamera: MonoBehour public GameObject target; void LateUpdate () transform.LookAt (target.transform);
Dacă încercați să rulați jocul acum, veți primi erori care se plâng de UnassignedReferenceException. Pentru a preveni acest lucru, glisați Player-ul din panoul Ierarhie și fixați-l pe proprietatea Tutorial a scriptului în Inspector. Camera are acum o țintă valabilă pentru a privi.
Acesta este tipul de aparat de fotografiat pe care l-ați găsi de obicei în jocuri precum Diablo, cunoscut și sub numele de joc "crawler dungeon". Camera este așezată deasupra playerului și se mișcă în raport cu personajul, dar nu se rotește niciodată.
În scriptul DungeonCamera, trebuie din nou să creăm un atribut public pentru obiectivul camerei noastre. De asemenea, trebuie să creăm o variabilă pentru a stoca decalajul dintre cameră și țintă. Offset-ul este reprezentat ca Vector3 și va fi utilizat să mențină distanța relativă în timp ce jucătorul se mișcă. Este posibil să observați că nu acordăm o valoare compensată atunci când o declanșăm pentru prima dată. Acest lucru se datorează faptului că vom calcula valoarea la prima executare a scriptului. Putem folosi metoda Start () pentru a face acest lucru:
clasa publică DungeonCamera: MonoBehavior public GameObject target; Vector3 offset; void Start () offset = transform.position - target.transform.position;
În fiecare cadru trebuie să actualizăm poziția camerei în funcție de poziția jucătorului prin aplicarea offsetului. Ca de obicei, acest lucru ar trebui făcut în metoda LateUpdate ():
void LateUpdate () Vector3 doritPosition = target.transform.position + offset; tranform.position = doritPoziție;
Trageți Playerul de la panoul Ierarhie la proprietatea Tinta a scriptului din Inspector.
Puteți observa că mișcarea camerei este puțin rigidă. Ar fi frumos să ușurați puțin mișcarea, astfel încât să dureze ceva timp pentru a prinde jucătorul. Putem face acest lucru folosind metoda Vector3.Lerp (). Lerp interpolează liniar între două puncte, adică trecând ușor de la un punct la altul în linie dreaptă.
Pentru a controla cât de mult amortizare este aplicată, putem crea un alt atribut public numit, ce altceva, amortizare!
plată amortizoare publice = 1;
Cele două puncte pe care le putem strânge între poziția actuală a aparatului foto cu amortizare aplicată și poziția dorită fără amortizare.
void LateUpdate () Vector3 doritPosition = target.transform.position + offset; Vector3 pozitie = Vector3.Lerp (transformare pozitie, doritPosition, Time.deltaTime * amortizare); pozitie transforma = pozitie;
În cele din urmă, dorim ca camera să urmărească în continuare playerul:
transform.LookAt (target.transform.position);
Scenariul final arată astfel:
clasa publică DungeonCamera: MonoBehavior public GameObject target; plată amortizoare publice = 1; Vector3 offset; void Start () offset = transform.position - target.transform.position; void LateUpdate () Vector3 doritPosition = target.transform.position + offset; Vector3 pozitie = Vector3.Lerp (transformare pozitie, doritPosition, Time.deltaTime * amortizare); pozitie transforma = pozitie; transform.LookAt (target.transform.position);
Acest tip de aparat foto este folosit în mod obișnuit în jocuri de platformă precum Mario Galaxy. Camera este așezată în spatele și deasupra playerului și se rotește în jurul caracterului pe măsură ce se întoarce.
Ca și camera Dungeon Crawler, camera de urmărire va avea nevoie de un atribut public pentru o țintă, precum și un offset. Decalajul trebuie setat în metoda Start ():
clasa publica FollowCamera: MonoBehavior public GameObject target; Vector3 offset; void Start () offset = target.transform.position - transform.position;
Pentru orientarea camerei în spatele țintei, trebuie mai întâi să obținem unghiul țintă și să îl transformăm într-o rotație în metoda LateUpdate ():
void LateUpdate () float doritAngle = target.transform.eulerAngles.y; Rotația quaternion = Quaternion.Euler (0, dorințăAngle, 0);
Apoi, putem multiplica offset-ul prin rotație pentru a orienta offsetul la fel ca țintă. Apoi scădem rezultatul din poziția țintei.
transform.position = target.transform.position - (rotație * offset);
Pentru a continua să priviți jucătorul:
transform.LookAt (target.transform);
Trageți Playerul de la panoul Ierarhie la proprietatea Tinta a scriptului din Inspector.
Aceeași mișcare de amortizare aplicată camerei Dungeon poate fi aplicată camerei Follow. Mai întâi, adăugăm un atribut de amortizare pentru a facilita ajustarea amortizării:
plată amortizoare publice = 1;
În loc de a lerping între două puncte cum am făcut cu camera Dungeon, vom fi lerping între unghiul camerei și unghiul de țintă. Deci, mai degrabă decât Vector3.Lerp (), vom folosi metoda Mathf.LerpAngle (). Înlocuim codul original al unghiului cu:
float currentAngle = transform.eulerAngles.y; float doritAngle = target.transform.eulerAngles.y; unghiul de înclinare = Mathf.LerpAngle (curentulAngle, doritulAngle, timpul.deltaTime * amortizare); Quaternion rotation = Quaternion.Euler (0, unghi, 0);
Scriptul final ar trebui să arate ca:
clasa publica FollowCamera: MonoBehavior public GameObject target; plată amortizoare publice = 1; Vector3 offset; void Start () offset = target.transform.position - transform.position; void LateUpdate () float currentAngle = transform.eulerAngles.y; float doritAngle = target.transform.eulerAngles.y; unghiul de înclinare = Mathf.LerpAngle (curentulAngle, doritulAngle, timpul.deltaTime * amortizare); Quaternion rotation = Quaternion.Euler (0, unghi, 0); transform.position = target.transform.position - (rotație * offset); transform.LookAt (target.transform);
Acest tip de cameră este similar cu camera Urmărire, cu excepția faptului că rotația este controlată de mouse, ceea ce indică caracterul în orice direcție cu care se confruntă camera.
Ca și camera Urmărire, camera de orientare a mouse-ului va avea nevoie de un atribut public pentru o viteză țintă și de rotație, precum și o compensare. Decalajul trebuie setat în metoda Start ():
clasa publică MouseAimCamera: MonoBehavior public GameObject target; float public rotateSpeed = 5; Vector3 offset; void Start () offset = target.transform.position - transform.position;
Putem accesa axa orizontală a mouse-ului (aka: Mouse X) și îl folosim pentru a roti ținta.
float orizontal = Input.GetAxis ("Mouse X") * rotateSpeed; target.transform.Rote (0, orizontal, 0); Apoi, orientăm offsetul în aceeași direcție și îl scădem din poziția țintei pentru a ține camera în spatele țintei.
float doritAngle = target.transform.eulerAngles.y; Rotația quaternion = Quaternion.Euler (0, dorințăAngle, 0); transform.position = target.transform.position - (rotație * offset); transform.LookAt (target.transform);
Trageți Playerul de la panoul Ierarhie la proprietatea Tinta a scriptului din Inspector.
Spre deosebire de alte scenarii, nu vom adăuga nici o amortizare la mișcarea camerei. Datorită naturii precise a mouse-ului, poate duce adesea la boală de mișcare.
Scenariul final ar trebui să arate astfel:
clasa publică MouseAimCamera: MonoBehavior public GameObject target; float public rotateSpeed = 5; Vector3 offset; void Start () offset = target.transform.position - transform.position; void LateUpdate () float orizontal = Input.GetAxis ("Mouse X") * rotateSpeed; target.transform.Rote (0, orizontal, 0); float doritAngle = target.transform.eulerAngles.y; Rotația quaternion = Quaternion.Euler (0, dorințăAngle, 0); transform.position = target.transform.position - (rotație * offset); transform.LookAt (target.transform); Mai mult de un script de cameră poate fi aplicat la o singură cameră în același timp. Pentru a comuta între diferitele script-uri, activați scriptul dorit verificând-l și deblocând toate celelalte. Acest lucru ar putea fi util pentru trecerea la un stil diferit al camerei pentru stabilirea fotografiilor sau a scenelor tăiate.
Unitatea vine, de asemenea, cu mai multe scripturi de cameră pe care le puteți utiliza imediat din cutie. Scripturile sunt bine documentate, ușor de personalizat și de a face ghiduri excelente pentru construirea și îmbunătățirea propriilor scripturi de cameră.
Unitatea facilitează construirea unei game largi de camere pentru orice tip de joc. Cu doar câteva linii de cod, cel mai important element din jocul dvs. este gata să meargă. În timp ce unii pot găsi matematica puțin intimidantă, Unity oferă atât de multe funcții utile, încât majoritatea calculelor grele sunt deja făcute pentru dvs..
Faceți clic aici pentru a descărca proiectul Unity complet.
