MODIFICA / AGGIORNAMENTO: La mia più grande domanda in questo momento è se l'equazione "t = ..." del passaggio 3 è una buona idea o esiste un modo migliore per farlo. La maggior parte degli altri problemi è stata affrontata parzialmente o completamente, ma nessun commento o risposta ha toccato davvero questo problema. Ancora una volta, è probabilmente necessaria una soluzione analitica, le velocità e le distanze sono troppo grandi e gli oggetti sono troppo piccoli, per qualsiasi soluzione iterativa / ricorsiva (alcune sono suggerite di seguito nei commenti) a cui posso pensare (anche se se c'è una soluzione iterativa / ricorsiva speciale che gestirà bene questo tipo di situazioni, quindi sono decisamente aperto ad essa). Grazie mille per il tuo aiuto finora, siete tutti fantastici e apprezzo molto i vostri pensieri e il vostro aiuto!
Sto cercando di rilevare le collisioni tra piccoli oggetti ad alta velocità. Questa è una situazione in cui il tunneling può avvenire molto facilmente, anche a velocità relativamente basse.
Il lancio del raggio non funzionerà, poiché sta rilevando una collisione tra due oggetti ad alta velocità, non tra un oggetto e una parete fissa. (A meno che non abbia frainteso il ray casting?) Le prestazioni sono MOLTO MOLTO una considerazione; se possibile, voglio evitare un grande successo in termini di prestazioni. Ho già implementato un quadtree funzionale e molto efficace ( http://en.wikipedia.org/wiki/Quadtree ), quindi lo modificherò e lo userò come descritto di seguito.
Modifica: la riduzione dell'intervallo di tempo non funzionerà. Le velocità sono troppo elevate per questa soluzione, il che significa che i risultati delle prestazioni sarebbero troppo elevati, pur continuando a perdere la stragrande maggioranza delle collisioni tra tunnel . (Ad esempio, potrei avere un oggetto con una dimensione di circa 1 unità a una velocità misurata in milioni di unità per intervallo di tempo ...)
LA SOLUZIONE PROPOSTA:
Passo 1:
Crea una casella attorno al movimento di ciascun oggetto, quindi inserisci quelle caselle nel quadrifoglio per generare un elenco iniziale di possibili collisioni. Vedi l'immagine seguente (questa immagine mostra un oggetto circolare che si sposta da una posizione all'altra e il movimento che genera un rettangolo, che verrà inserito nel quadrifoglio):
Passaggio 2: (potresti voler saltare questo passaggio?)
Scorri l'elenco delle possibili collisioni generate dal quadrifoglio. Vedi se i rettangoli si intersecano in ogni possibile collisione. In tal caso, procedere al passaggio 3.
MODIFICA: Sotto, Sean Middleditch ha suggerito di usare i volumi spazzati / l'intersezione delle capsule (se gli oggetti sono cerchi). Ciò lascia tre opzioni: 1) saltare completamente il passaggio 2. 2) Eseguire il passaggio 2 a modo mio. 3) Fallo alla maniera di Sean. Il modo in cui Sean sarà più computazionalmente costoso della mia idea di scatola, tuttavia eliminerà più falsi positivi del mio modo, impedendo loro di arrivare al passo finale.
Qualcuno può parlare per esperienza su quale di queste 3 scelte sia la migliore? (Intendo utilizzare questo motore fisico per alcune cose diverse, quindi sto cercando la soluzione "generalmente migliore" che funziona più velocemente nella più ampia varietà di situazioni, non solo un caso di test specifico in cui posso facilmente misurare quale soluzione è il più veloce).
Passaggio 3:
Utilizzare l'equazione t = di seguito, se il discriminante (ovvero la parte sotto la radice quadrata) è negativo o 0, nessuna collisione, se positivo, quindi utilizzare il valore t come tempo di collisione (dopo di che è facile regolare le posizioni di conseguenza. ..se entrambi gli oggetti continuano a esistere dopo la collisione). Equazione:
t = (-1/2 sqrt ((2 a w-2 a x + 2 b y-2 b z-2 c w + 2 c x-2 d y + 2 dz) ^ 2-4 (w ^ 2- 2 w x + x ^ 2 + y ^ 2-2 y z + z ^ 2) (a ^ 2-2 a c + b ^ 2-2 b d + c ^ 2 + d ^ 2-r ^ 2-2 r ss ^ 2)) - a w + a xb y + b z + c wc x + d yd z) / (w ^ 2-2 w x + x ^ 2 + y ^ 2-2 y z + z ^ 2 ) .
Dove (1 e 2 vengono utilizzati per indicare gli oggetti 1 e 2):
t è un valore temporale negativo compreso tra 0 e -1, dove 0 è il fotogramma corrente e -1 è il fotogramma precedente;
a = x posizione 1;
b = y posizione 1;
c = x posizione 2;
d = y posizione 2;
w = x velocità 1;
x = x velocità 2;
y = y velocità 1;
z = y velocità 2;
r = raggio 1;
s = raggio 2;
Derivazione: (^ 2 significa quadrato)
Prendi le equazioni parametriche (ad esempio, newxpos1 = a + t w) per i movimenti degli oggetti e inseriscili nella formula della distanza (quadratura di entrambi i lati): formula della distanza al quadrato = (a + t w - (c + t x)) ^ 2 + (b + t y - (d + t * z)) ^ 2. Ricorda, t sarà negativo. Per trovare il tempo di collisione per due oggetti circolari impostiamo il lato sinistro uguale a (r + s) ^ 2. Risolvendo per t usando l'equazione quadratica (e una grande quantità di algebra molto noiosa), otteniamo l'equazione "t = ..." sopra.
Le mie domande:
1) È un buon modo per farlo? Funzionerà affatto? Incontrerò problemi imprevisti? (So che avrò problemi quando più di 2 oggetti alla volta si scontrano, ma non mi interessa poiché l'unico caso a cui mi oppongo davvero è quando hanno basse velocità relative (se le velocità relative sono alte allora la soluzione "sciocca" fornita dall'algoritmo sarà "abbastanza buona", e sarà impossibile per un essere umano vedere l'errore), e se più di 2 si scontrano con basse velocità relative nello stesso intervallo di tempo, la maggior parte delle soluzioni essere comunque abbastanza vicino, dal momento che non ho intenzione di avere un sacco di collisioni anelastiche)
2) La mia performance soffrirà molto? Non penso che lo farà, ma se lo farà, c'è un modo migliore per farlo?
3) Devo saltare il passaggio 2 e andare direttamente dal passaggio 1 al 3? Ovviamente il passaggio 2 non è vitale, ma potrebbe aiutare le prestazioni (OPPURE potrebbe costare più tempo della CPU di quanto risparmi).
Tutti gli altri commenti, suggerimenti o critiche sono i benvenuti. Grazie per l'aiuto!