In giochi di corse 3D molto semplici, come vengono gestite le collisioni?

Mi chiedevo come si fanno le collisioni in alcuni semplici giochi di corse automobilistiche in 3D (specialmente in giochi come Outrun 2 / Motoracer).

Nei giochi di corse automobilistiche classiche con un ambiente complesso (mondo aperto), immagino che ciò avvenga con una scatola base (per l'auto) per far collidere la collisione (per pista, edifici e altre cose). Il tutto verrebbe ottimizzato usando alcune scatole di delimitazione (questo è il modo in cui la collisione è fatta in molti giochi).

In un gioco come Outrun 2 / Motoracer, il gameplay è così semplice che gli sviluppatori potrebbero non averne bisogno e tutto avrebbe potuto essere semplificato molto. Per coloro che non lo suonano mai, ecco cosa è così specifico:

• L'auto / bici è sempre incollata sulla strada.
• La strada ha sempre le stesse dimensioni e ha una forma molto semplice.
• L'unica possibilità è quella di seguire quella strada, non è possibile lasciare la strada o entrare in collisione con qualcos'altro (eccetto altre macchine / biciclette, ma a noi non importa).
• Quando ti scontri con la strada, viene eseguita una collisione arcade di base (l'auto viene semplicemente allontanata da essa)

Ecco come penso che la collisione (potrebbe) sia stata fatta:

L'intera traccia potrebbe essere considerata gigante una curva più bezier 3d. Da quella curva, i poligoni stradali potrebbero essere generati (usando i vettori anteriore, sinistro e su generati dalla curva). Altri elementi (come case, alberi, ...) potrebbero anche essere posizionati e allineati usando questo metodo.

Quindi, per gestire le collisioni (e disegnare la macchina):

1) Trova la posizione più vicina sulla curva 3d dalla posizione 3d attuale dell'auto. In altre parole, trasforma la posizione della macchina 3d in una posizione della curva più bezier. Ogni posizione 3d sulla strada potrebbe essere considerata come uno spostamento lungo la curva 3d ( t) + spostamento laterale ( d). Controlla l'immagine qui sotto se non è chiara (questo è un esempio 2d ma questo si applica facilmente a 3d).

quando l'auto t = 0 è all'inizio della sezione di pista, quando l'auto t = 1 è alla fine. quando d = -1 o 1 auto si trova al confine del binario, quando d = 0 auto è in mezzo alla strada

2) allineare la macchina alla strada utilizzando te d(molto semplice: per ogni te dvalori posso ottenere una posizione 3D + up / anteriori / vettori sinistra). l'auto è ora incollata sulla strada

3) controllare lo spostamento laterale ddella vettura. se il valore è troppo grande (d > 1)o l' (d < -1)auto bassa è fuori pista. basta agganciarlo per mettere l'auto nel posto giusto.

Questo rende anche l'abbattimento 3D molto semplice, basta tracciare la traccia dalla tposizione attuale dell'auto a t + some_big_enough_value_to_avoid_visible_clipping.

O forse mi sbaglio completamente: sarebbe stato molto più veloce e più semplice controllare la collisione della macchina (un riquadro di delimitazione) e un insieme molto semplificato di poligoni che rappresentano la pista (senza edifici e simili). Il mondo 3d (e il risultante modello di colisione) sarebbero stati semplicemente generati prima, usando alcuni strumenti di terze parti (niente più curva 3d durante l'esecuzione del gioco, solo un mucchio di poligoni).

Ho lavorato su alcuni giochi commerciali simili a quelli che descrivi.

In ognuno di questi giochi, in realtà avevamo poligoni che creavano un "muro" invisibile lungo i lati della pista e facevamo i tradizionali test di collisione contro quei muri. Ciò significava che potremmo avere alcuni ulteriori rischi collidibili sul lato della strada, all'interno delle pareti invisibili, e anche farci variare la larghezza della strada più velocemente di quanto tu possa fare normalmente con un approccio a spline.

Detto questo, abbiamo anche fatto ciò che elenchi nella sezione su come penso che la collisione funzionerebbe al fine di proteggersi dal tunnel / glitch di collisione, e questo sistema è stato anche ampiamente utilizzato per la corsa della logica AI. Lo abbiamo anche usato per determinare quali auto erano in testa, in modo da poter visualizzare un indicatore "1 ° / 2 ° / 3 ° / ecc" sull'HUD. A volte questi dati venivano utilizzati anche per rigenerare un'auto dopo un grave incidente.

Un pezzo che ti sei perso nel modo in cui penso che la collisione funzionerebbe è che quando lavori con le spline in questo modo, normalmente dai le nervature alle spline. Le nervature sono bit di dati che esprimono quanto la traccia si estende lateralmente in ciascuna direzione rispetto alla spline. Quindi per una spline lunga 100 metri, potresti avere 50 nervature, che danno la larghezza della carreggiata ogni due metri lungo la sua lunghezza. Ciò consente alla traccia di modificare le larghezze lungo l'estensione. Nei giochi a cui ho lavorato, queste nervature hanno anche distinto tra "superficie della pista" e "area di guida". Quindi avresti una serie di larghezze stradali che indicano quanto lontano dal centro della spline hai una bella pista, e poi un'altra larghezza che dice quanto lontano la sabbia / erba / qualunque cosa vada fuori da quella. Ciò ci consente di avere giocatori in grado di percorrere una ragionevole distanza dalla pista, ma avere comunque l'intelligenza artificiale dove si trovava la superficie stradale reale.

Molti giochi a cui ho lavorato hanno anche archiviato altri dati nelle costole; un gioco ha fornito informazioni di illuminazione della pista nelle nervature, per calcolare facilmente se un'area era in ombra (che è stata quindi utilizzata per il rendering dell'auto, decidendo se disegnare o meno un bagliore dell'obiettivo e altri effetti). Un altro ha fornito informazioni su quali posizionamenti di telecamere cinematografiche potrebbero vedere quella parte della spline, quindi non abbiamo dovuto fare calcoli della linea di vista durante i replay. Ancora un altro includeva informazioni su quante corsie si trovavano sulla spline, in quale direzione prendevano e lo spostamento orizzontale in cui si trovava ciascuna corsia. Questo ci ha permesso di includere le auto del traffico che potevano guidare correttamente all'interno delle corsie stradali. Le nervature sono fantastiche per l'archiviazione di qualsiasi tipo di dato variabile di cui potresti aver bisogno sul tuo manto stradale.

Le nervature sono in genere archiviate in un array associato alla spline. Per motivi di velocità, un'implementazione normale avrà costole equidistanti, quindi una volta che conosci la distanza di un oggetto lungo la spline, puoi calcolare l'indice delle costole più vicino nell'array dividendo la distanza lungo la spline per la distanza tra le costole. Altrimenti sei bloccato a fare ricerche binarie attraverso il tuo array di nervature per trovare i dati di larghezza della strada corretti.

La tua descrizione di abbattimento fornisce una buona descrizione di base di come può essere usato l'approccio spline, ma in realtà è un po 'più complicato di quanto suggerisci - se usi le spline per l'abbattimento in questo modo, spesso i lunghi tornanti spesso non disegneranno il lato opposto del turno, poiché quando misurato dalla distanza lungo il binario, il lato opposto del turno può essere molto lontano, anche se è solo a pochi metri quando viene misurato in linea d'aria. Inoltre, le distanze a cui è possibile vedere la geometria del mondo sono in genere diverse da quelle a cui è possibile vedere la mesh della traccia, quindi anche quelli non si adattano perfettamente a questo sistema. La mia esperienza è che, nella maggior parte dei casi, è meglio non fare affidamento sulla logica track track per determinare se un modello debba essere disegnato; è molto più affidabile e fa sì che meno glitch utilizzino il test standard di frustum della fotocamera per questo.

Nel mio pilota OpenGL, inizialmente ho iniziato usando due cerchi per definire i bordi della pista, ma mi è sembrato troppo seccante. Uso glReadPixel per leggere il colore dei pixel. Se l'auto dei giocatori si trova su un pixel verde (color erba), il movimento è ulteriormente limitato. Gli effetti sulle prestazioni sono scarsi.