Share
La fotocamera è uno degli elementi più importanti in un gioco 3D. Agisce come gli occhi del giocatore, permettendo loro di vedere il mondo di gioco da diversi punti di vista. In Unity3D, una fotocamera 3D funziona come una cinepresa. Può essere ruotato, inclinato e ingrandito per inquadrare le scene. Questo tutorial ti insegnerà come creare più prospettive per la fotocamera in terza persona.
Per trarre ispirazione, o per utilizzare un punto di partenza per il tuo lavoro, dai un'occhiata ad alcuni dei modelli 3D più popolari su Envato Market. Oppure ottieni l'aiuto uno-a-uno scegliendo uno dei servizi di progettazione e modellazione 3D su Envato Studio.
Abbiamo bisogno di un semplice progetto per testare i nostri script di fotocamere. Avremo bisogno di una scena con un piano di base che abbia una trama su di esso. Questo renderà più semplice vedere come ogni telecamera si muove e reagisce agli input del giocatore. Quando avremo finito, dovrebbe assomigliare a questo:
Segui questi passaggi per configurare il progetto:
Tutte le telecamere che creeremo avranno bisogno di un obiettivo: qualcosa da guardare o da seguire. Quindi, creiamo un giocatore di base che possiamo spostare con i tasti freccia.
Nello script Player, aggiungi due proprietà pubbliche per il movimento e la velocità di rotazione. Quindi aggiungere il seguente codice al metodo Update ():
Accentsconagua
public class Player: MonoBehaviour public float movementSpeed = 10; public float turningSpeed = 60; void Update () float horizontal = Input.GetAxis ("Horizontal") * turningSpeed * Time.deltaTime; transform.Rotate (0, horizontal, 0); float vertical = Input.GetAxis ("Vertical") * movementSpeed * Time.deltaTime; transform.Translate (0, 0, vertical); Questo dà al giocatore controlli simili a quelli di un carro armato. L'asse orizzontale (i tasti sinistra o destra) gira il giocatore, mentre l'asse verticale (tasti su e giù) muove il giocatore avanti e indietro.
Questa è la fotocamera di terza persona più elementare. Si trova in una posizione fissa nel mondo 3D e segue il suo bersaglio come una torretta.
Nello script LookAtCamera, crea un attributo pubblico per il target della videocamera nella parte superiore della classe. Gli attributi pubblici sono esposti nell'Inspector e ci permetteranno di assegnare al giocatore l'obiettivo della telecamera:
classe pubblica LookAtCamera: MonoBehaviour target pubblico di GameObject;
Successivamente, dobbiamo dire alla nostra trasformazione della macchina fotografica di guardare l'oggetto di destinazione. Per fortuna, gli oggetti trasformati hanno un metodo LookAt () che possiamo usare per fare proprio questo. Potremmo farlo nel metodo Update (), ma invece creiamo un metodo LateUpdate (). Come regola generale, è necessario utilizzare sempre LateUpdate () anziché il metodo Update () in tutti gli script della fotocamera. LateUpdate () si verifica dopo che Update () è terminato, quindi lo script del giocatore ha la possibilità di terminare il calcolo della posizione del giocatore prima che la telecamera calcoli la sua posizione. Ciò si traduce in un movimento della fotocamera più fluido:
void LateUpdate () transform.LookAt (target.transform);
Lo script finale dovrebbe essere simile a:
classe pubblica LookAtCamera: MonoBehaviour target pubblico di GameObject; void LateUpdate () transform.LookAt (target.transform);
Se provi a eseguire il gioco ora, riceverai errori che si lamentano di UnassignedReferenceException. Per evitare ciò, trascina il Player dal pannello Gerarchia e rilasciatelo sulla proprietà Target dello script in Inspector. La fotocamera ora ha un obiettivo valido da guardare.
Questo è il tipo di fotocamera che normalmente si trova in giochi come Diablo, noto anche come gioco "dungeon crawler". La fotocamera si trova sopra il lettore e si muove rispetto al personaggio, ma non ruotando mai.
Nello script di DungeonCamera, abbiamo ancora una volta bisogno di creare un attributo pubblico per il target della nostra videocamera. Abbiamo anche bisogno di creare una variabile per memorizzare l'offset tra la telecamera e il suo obiettivo. L'offset è rappresentato come un Vector3 e verrà utilizzato per mantenere la distanza relativa man mano che il giocatore si muove. Potresti notare che non assegniamo un valore di offset quando lo dichiariamo per la prima volta. Questo perché calcoleremo il valore la prima volta che viene eseguito lo script. Possiamo usare il metodo Start () per fare questo:
DungeonCamera di classe pubblica: MonoBehaviour target pubblico di GameObject; Offset Vector3; void Start () offset = transform.position - target.transform.position;
In ogni fotogramma è necessario aggiornare la posizione della telecamera in base alla posizione del giocatore applicando l'offset. Come al solito, questo dovrebbe essere fatto nel metodo LateUpdate ():
void LateUpdate () Vector3 desiredPosition = target.transform.position + offset; tranform.position = desiredPosition;
Trascina il Player dal pannello Gerarchia alla proprietà Target dello script in Inspector.
Si può notare che il movimento della fotocamera è un po 'rigido. Sarebbe bello smorzare leggermente il movimento in modo che ci vuole del tempo per raggiungere il giocatore. Possiamo farlo usando il metodo Vector3.Lerp (). Lerp interpola linearmente tra due punti, il che significa che transita senza problemi da un punto all'altro in una linea retta.
Per controllare la quantità di smorzamento applicata, possiamo creare un altro attributo pubblico chiamato, cos'altro, smorzamento!
smorzamento del galleggiante pubblico = 1;
I due punti che possiamo inserire sono la posizione corrente della telecamera con lo smorzamento applicato e la posizione desiderata senza smorzamento.
void LateUpdate () Vector3 desiredPosition = target.transform.position + offset; Vector3 position = Vector3.Lerp (transform.position, desiredPosition, Time.deltaTime * damping); transform.position = position;
Infine, vogliamo che la fotocamera continui a guardare il lettore:
transform.LookAt (target.transform.position);
Lo script finale assomiglia a questo:
DungeonCamera di classe pubblica: MonoBehaviour target pubblico di GameObject; smorzamento del galleggiante pubblico = 1; Offset Vector3; void Start () offset = transform.position - target.transform.position; void LateUpdate () Vector3 desiredPosition = target.transform.position + offset; Vector3 position = Vector3.Lerp (transform.position, desiredPosition, Time.deltaTime * damping); transform.position = position; transform.LookAt (target.transform.position);
Questo tipo di fotocamera è comunemente usato nei giochi platform come Mario Galaxy. La fotocamera si trova dietro e sopra il lettore e ruota attorno al personaggio mentre gira.
Come la camera Dungeon Crawler, la fotocamera Follow avrà bisogno di un attributo pubblico per un bersaglio, oltre a un offset. L'offset deve essere impostato nel metodo Start ():
public class FollowCamera: MonoBehaviour target pubblico di GameObject; Offset Vector3; void Start () offset = target.transform.position - transform.position;
Per orientare la telecamera dietro il target, dobbiamo prima ottenere l'angolo del target e trasformarlo in una rotazione nel metodo LateUpdate ():
void LateUpdate () float desiredAngle = target.transform.eulerAngles.y; Rotazione del quaternione = Quaternion.Euler (0, desiredAngle, 0);
Possiamo quindi moltiplicare l'offset per la rotazione per orientare l'offset allo stesso modo del target. Quindi sottraiamo il risultato dalla posizione del bersaglio.
transform.position = target.transform.position - (rotation * offset);
Per continuare a guardare il giocatore:
transform.LookAt (target.transform);
Trascina il Player dal pannello Gerarchia alla proprietà Target dello script in Inspector.
Lo stesso movimento di smorzamento applicato alla videocamera Dungeon può essere applicato alla telecamera Follow. Innanzitutto, aggiungiamo un attributo di smorzamento per rendere più semplice la regolazione dello smorzamento:
smorzamento del galleggiante pubblico = 1;
Invece di lerping tra due punti come abbiamo fatto con la camera dei Dungeon, avremo lerping tra l'angolo della telecamera e l'angolo del bersaglio. Quindi, piuttosto che Vector3.Lerp (), usiamo il metodo Mathf.LerpAngle (). Sostituiamo il codice angolare originale con:
float currentAngle = transform.eulerAngles.y; float desiredAngle = target.transform.eulerAngles.y; float angle = Mathf.LerpAngle (currentAngle, desiredAngle, Time.deltaTime * damping); Rotazione del quaternione = Quaternion.Euler (0, angle, 0);
Lo script finale dovrebbe essere simile a:
public class FollowCamera: MonoBehaviour target pubblico di GameObject; smorzamento del galleggiante pubblico = 1; Offset Vector3; void Start () offset = target.transform.position - transform.position; void LateUpdate () float currentAngle = transform.eulerAngles.y; float desiredAngle = target.transform.eulerAngles.y; float angle = Mathf.LerpAngle (currentAngle, desiredAngle, Time.deltaTime * damping); Rotazione del quaternione = Quaternion.Euler (0, angle, 0); transform.position = target.transform.position - (rotation * offset); transform.LookAt (target.transform);
Questo tipo di fotocamera è simile alla videocamera Follow, tranne per il fatto che la rotazione è controllata dal mouse, che quindi punta il personaggio in qualsiasi direzione verso la fotocamera.
Come la fotocamera Follow, la fotocamera Mouse Aim avrà bisogno di un attributo pubblico per una velocità target e di rotazione, oltre che di un offset. L'offset deve essere impostato nel metodo Start ():
public class MouseAimCamera: MonoBehaviour target pubblico di GameObject; public float rotateSpeed = 5; Offset Vector3; void Start () offset = target.transform.position - transform.position;
Possiamo accedere all'asse orizzontale del mouse (noto anche come Mouse X) e utilizzarlo per ruotare il bersaglio.
float horizontal = Input.GetAxis ("Mouse X") * rotateSpeed; target.transform.Rotate (0, horizontal, 0); Quindi orientiamo l'offset nella stessa direzione e lo sottraggo dalla posizione del bersaglio per mantenere la fotocamera dietro il bersaglio.
float desiredAngle = target.transform.eulerAngles.y; Rotazione del quaternione = Quaternion.Euler (0, desiredAngle, 0); transform.position = target.transform.position - (rotation * offset); transform.LookAt (target.transform);
Trascina il Player dal pannello Gerarchia alla proprietà Target dello script in Inspector.
A differenza degli altri script, non aggiungeremo alcuna attenuazione al movimento della fotocamera. A causa della natura precisa del mouse, può spesso portare a cinetosi.
Lo script finale dovrebbe assomigliare a questo:
public class MouseAimCamera: MonoBehaviour target pubblico di GameObject; public float rotateSpeed = 5; Offset Vector3; void Start () offset = target.transform.position - transform.position; void LateUpdate () float horizontal = Input.GetAxis ("Mouse X") * rotateSpeed; target.transform.Rotate (0, horizontal, 0); float desiredAngle = target.transform.eulerAngles.y; Rotazione del quaternione = Quaternion.Euler (0, desiredAngle, 0); transform.position = target.transform.position - (rotation * offset); transform.LookAt (target.transform); È possibile applicare più di uno script della fotocamera a una singola videocamera contemporaneamente. Per passare da uno script all'altro, abilitare lo script desiderato controllandolo e deselezionando tutti gli altri. Questo potrebbe essere utile per passare a uno stile di fotocamera diverso per stabilire scatti o tagliare scene.
Unity include anche diversi script di fotocamere che è possibile utilizzare fin da subito. Gli script sono ben documentati, facili da personalizzare e costituiscono ottime guide per la creazione e il miglioramento dei propri script di fotocamere.
Unity rende facile costruire un'ampia varietà di telecamere per qualsiasi tipo di gioco. Con solo poche righe di codice, l'elemento più importante nel tuo gioco è pronto. Mentre alcuni potrebbero trovare la matematica un po 'intimidatoria, Unity offre così tante funzioni utili utili che la maggior parte dei calcoli pesanti sono già stati fatti per te.
Clicca qui per scaricare il progetto Unity completo.
