Vektor-gympa.

Hej

 

Nu tänkte jag lyfta fram ett bra exempel på när man behöver krångla till det lite för att få ut en riktig ned-vektor/normal när man bara har en riktningsvektor varav resterande vektorer är fel och måste räknas ut på nytt.

 

Vad jag menar med fel är att dessa inte längre är 90 grader till förhållande av riktningen, vi behöver räkna om sid-vektorn för att kunna använda den tillsammans med riktningen så att vi kan få fram den nya ned-vektorn/normalen.

 

Se bilden..

 

Nu har jag inte lagt in sid-vektorn i bilden men det man ser här är 2 stycken skepp, där skepp 1 är mitt skepp och skepp 2 är fiendens. När mitt skepp kommer fram till skepp 2 så vill jag att mitt skepp ska riktas mot skepp 2 när det påbörjar sin skjutning.

Problemet är att de vektorer jag har är riktningen V1 och Ned N1 varav den sistnämnda får jag genom att räkna ut vektorn från mitt skepp 1 till mitten utav planeten, och då ser vi att denna ned-vektor N1 inte blir 90 grader i förhållande till V1 utan helt olika beroende på vilket håll mitt skepp vrider sig för att riktas mot skepp 2.

Jag behöver alltså räkna ut N2 som är den riktiga 90 gradiga ned-vektorn till V1 men vi har ingen känd punkt för detta.

 

Vi räkna ut en ny (N2) vilket vi gör genom att först ta korsprodukten av Riktningen X N1, så vi får den nya sid-vektorn (X är tecknet för Korsprodukt).

Därefter tar vi Riktningen X Nya Sid-vektorn, korsar dem och får den nya riktiga 90 graders ned-vektorn. Dessa vektorer normaliserar vi sedan, så att de får en matematisk betydelse.

 

Jag räknar ut upp-vektorn i min kod istället för ned-vektorn eftersom det är den JPCT vill ha för att orientera 3D objekten, det är bara ni vänder på korsproduktuträkningen så får du ned-vektorn istället om det är just den du behöver. Valde att berätta om ned-vektorn här för att det blev tydligare att förstå på bildexemplet.

 

Här är koden för detta i Java..

 

float directionX = skepp2PosX - skepp1PosX;
float directionY = skepp2PosY - skepp1PosY;
float directionZ = skepp2PosZ - skepp1PosZ;

// Korsa felande "ned"-vektor med riktningen, för ny sid-vektor.
float sideX = directionY * skepp1PosZ - directionZ * skepp1PosY;
float sideY = directionZ * skepp1PosX - directionX * skepp1PosZ;
float sideZ = directionX * skepp1PosY - directionY * skepp1PosX;

// Korsa igen för att få den nya 90 graders uppvektorn.
float upX = directionY * sideZ - directionZ * sideY;
float upY = directionZ * sideX - directionX * sideZ;
float upZ = directionX * sideY - directionY * sideX;

float l = (float) Math.sqrt((double) (upX * upX + upY * upY + upZ * upZ));

float upNX = 0;
float upNY = 0;
float upNZ = 0;

// Normalisera den nya uppvektorn..
if (l != 0.0F)
{
    float lDn = 1.0F / l;
    upNX = upX * lDn;
    upNY = upY * lDn;
    upNZ = upZ * lDn;
}

Det är en grovskriven funktion i Java, så det finns plats för att fina till den.

 

Om man inte har en äkta riktning och upp-vektor så blir hela objektet förvrängt eller till och med inte visas på skärmen, och det vill vi ju inte.

 

Hörs nästa gång.