Niente, mi dà sempre lo stesso errore di prima. Posto il codice chiamante:
codice:
//1. Troviamo il n. della faccia sorvolata
//per questo ci servono gli array faces del modello
//ma non sappiamo se sono di tipo FaceH, FaceT o FaceHT
finfo = My.Planets[k].GetType().GetField("faces");
if (ThisType == My.NormalTType)
{
FaceT[] faces = (FaceT[])finfo.GetValue(My.Planets[k]);
//Vediamo se c'è una faccia sorvolata
int c = Close<FaceT>(faces, L, closed);
if (c != 999)//la Discovery sta sorvolando una faccia
{
//proiezione normale sulla faccia nel rif. assoluto (O)
Vector3 P = Pnormal<FaceT>(faces[c], L);
//rif. generalizzato di P al nodo principale (N)
Vector3 NP = P - L - faces[c].nodes[0];
//Controlla se la proiezione P è interna ai bordi della faccia sorvolata
if (IsP<FaceT>(NP, faces[c]))
{
//SI. --> P E' L'OMBRA DELLA DISCOVERY
//quota sul piano zero.
ThisQuote = Vector3.Dot(My.Discovery.Position - P, faces[c].Normal);
if (ThisQuote < 1f)// --> ATTERRATA!
{
//Calcola l'orientamento del piano zero della faccia di atterraggio
Vector3 V1 = faces[c].V1;
Vector3 n = faces[c].Normal;
//Imposta le relactions attuali
My.GMode = false;
My.TMode = false;
My.OMode = false;
//My.GMode = false;
Position = P + 1f * n;//vertice al suolo + 1
Speed = 0f;
To = Vector3.Normalize(V1);
Azi = azif(To);
Alt = altf(To);
Up = n;
//Aggiorna ThisQuote con la nuova posizione
ThisQuote = 1f;
Ground = true;
TPush = 4f * D * ES * My.Gfactor;
}
}
}
}
else if (ThisType == My.NormalHType)
{
FaceH[] faces = (FaceH[])finfo.GetValue(My.Planets[k]);
//Vediamo se c'è una faccia sorvolata
int c = Close<FaceH>(faces, L, closed);
if (c != 999)//la Discovery sta sorvolando una faccia
{
float Qzero = 999f; //inizializza altezza della Discovery dal piano di faccia
float DeltaQ = 0f; // e il dislivello superficiale rispetto a Qzero.
//proiezione normale sulla faccia nel rif. assoluto (O)
Vector3 P = Pnormal<FaceH>(faces[c], L);
//rif. generalizzato di P al nodo principale (N)
Vector3 NP = P - L - faces[c].nodes[0];
//Controlla se la proiezione P è interna ai bordi della faccia sorvolata
if (IsP<FaceH>(NP, faces[c]))
{
//SI. --> P E' L'OMBRA DELLA DISCOVERY
//quota sul piano zero.
Qzero = Vector3.Dot(My.Discovery.Position - P, faces[c].Normal);
//dislivello della superficie in altezza o profondità rispetto al piano zero
DeltaQ = Delta<FaceH>(P, faces[c], L);
ThisQuote = Qzero - DeltaQ;
if (ThisQuote < 1f)// --> ATTERRATA!
{
//Calcola l'orientamento del piano zero della faccia di atterraggio
Vector3 V1 = faces[c].V1;
Vector3 n = faces[c].Normal;
//Imposta le relactions attuali
My.GMode = false;
My.TMode = false;
My.OMode = false;
Position = P + (DeltaQ + 1) * n;//vertice al suolo + 1
Speed = 0f;
To = Vector3.Normalize(V1);
Azi = azif(To);
Alt = altf(To);
Up = n;
//Aggiorna Qzero e Quote con la nuova posizione
Qzero = DeltaQ + 1f;
ThisQuote = 1f;
Ground = true;
TPush = 4f * D * ES * My.Gfactor;
TPush *= 30f + 27 * (1f - D * ES) / 999999f;
}
}
}
}
else//NormalHTType
{
FaceHT[] faces = (FaceHT[])finfo.GetValue(My.Planets[k]);
//Vediamo se c'è una faccia sorvolata
int c = Close<FaceHT>(faces, L, closed);
if (c != 999)//la Discovery sta sorvolando una faccia
{
float Qzero = 999f; //inizializza altezza della Discovery dal piano di faccia
float DeltaQ = 0f; // e il dislivello superficiale rispetto a Qzero.
//proiezione normale sulla faccia nel rif. assoluto (O)
Vector3 P = Pnormal<FaceHT>(faces[c], L);
//rif. generalizzato di P al nodo principale (N)
Vector3 NP = P - L - faces[c].nodes[0];
//Controlla se la proiezione P è interna ai bordi della faccia sorvolata
if (IsP<FaceHT>(NP, faces[c]))
{
//SI. --> P E' L'OMBRA DELLA DISCOVERY
//quota sul piano zero.
Qzero = Vector3.Dot(My.Discovery.Position - P, faces[c].Normal);
//dislivello della superficie in altezza o profondità rispetto al piano zero
DeltaQ = Delta<FaceHT>(P, faces[c], L);
ThisQuote = Qzero - DeltaQ;
if (ThisQuote < 1f)// --> ATTERRATA!
{
//Calcola l'orientamento del piano zero della faccia di atterraggio
Vector3 V1 = faces[c].V1;
Vector3 n = faces[c].Normal;
//Imposta le relactions attuali
My.GMode = false;
My.TMode = false;
My.OMode = false;
Position = P + (DeltaQ + 1) * n;//vertice al suolo + 1
Speed = 0f;
To = Vector3.Normalize(V1);
Azi = azif(To);
Alt = altf(To);
Up = n;
//Aggiorna Qzero e Quote con la nuova posizione
Qzero = DeltaQ + 1f;
ThisQuote = 1f;
Ground = true;
TPush = 4f * D * ES * My.Gfactor;
TPush *= 30f + 27 * (1f - D * ES) / 999999f;
}
}
}
}
e queste sono le funzioni incriminate:
codice:
//Calcola, se esiste, il numero della faccia sorvolata dalla Discovery
public int Close<T>(IList<T> faces, Vector3 L, float closed)
{
int res = 999;
for (int i = 0; i < 6; i++)
{
T face = faces[i];
if (IsOn<T>(face, L, closed))//condizione di sorvolo
{
res = i;
break;
}
}
return res;
}
//verifica che la Discovery si trova nello spazio sovrastante
//(sta sorvolando) una faccia
public bool IsOn<T>(T face, Vector3 L, float closed)
{
bool res = false;
//Position nel riferimento al nodo principale N della faccia i-esima
Vector3 NP = My.Discovery.Position - L - face.nodes[0];
//versori dei vettori direttivi della faccia i-esima
Vector3 v1 = Vector3.Normalize(face.V1);
Vector3 v2 = Vector3.Normalize(face.V2);
if ((Vector3.Dot(NP, face.Normal) > My.Q2) & (Vector3.Dot(NP, face.Normal) < closed))
if ((Vector3.Dot(NP, v1) > 0) & (Vector3.Dot(NP, v1) < face.V1.Length()))
if ((Vector3.Dot(NP, v2) > 0) & (Vector3.Dot(NP, v2) < face.V2.Length()))
res = true;
return res;
}
//verifica che la proiezione di un punto P su un piano è interno
//alla faccia (ombra)
public bool IsP<T>(Vector3 P, T face)
{
bool res = false;
//versori dei vettori direttivi della faccia i-esima
Vector3 v1 = Vector3.Normalize(face.V1);
Vector3 v2 = Vector3.Normalize(face.V2);
//Verifica se P è interno al parallelogramma costruito con i due vettori direttivi V1 e V2
//calcolando le proiezioni del vettore P sui versori v1 e v2
if ((Vector3.Dot(P, v1) > 0) & (Vector3.Dot(P, v1) < face.V1.Length()))
if ((Vector3.Dot(P, v2) > 0) & (Vector3.Dot(P, v2) < face.V2.Length()))
res = true;
return res;
}
//calcola la proiezione normale P della Discovery sulla faccia i-esima
public Vector3 Pnormal<T>(T face, Vector3 L)
{
//Nodo principale e normale
Vector3 N = L + face.nodes[0];
Vector3 n = face.Normal;
return My.Discovery.Position + Vector3.Dot(N - My.Discovery.Position, n) * n;
}
//calcola il dislivello della forma superficiale di una faccia
//nel punto P sul piano zero
public float Delta<T>(Vector3 P, T face, Vector3 L)
{
Vector3 N = L + face.nodes[0];
Vector3 v1 = Vector3.Normalize(face.V1);
Vector3 v2 = Vector3.Normalize(face.V2);
int u = (int)Vector3.Dot(P - N, v1);
int w = (int)Vector3.Dot(P - N, v2);
//indice del vertice corrispondente
int index = (int)(u + w * (face.V1.Length() + 1));
//Delta (negativo se depresso)
return face.generalizeV[index].Position.Y;
}
Rispondi quotando
