ich habe vier punkte, die alle den selben abstand zueinander (in 2d) haben
diese punkte haben aber alle verschiedene höhen (also dann 3d)
ich möchte nun die höhen ausrechnen von einem punkt, der in diesem quadrat liegt (2d)

grafische darstellung:
http://people.freenet.de/Mathias-Kanzler/mathe.jpg

es handelst sich also um eine heightmap, die ich linear interpolieren will...

C++ ->
ich habe schon versucht eine funktion zu schreiben, jedoch funktioniert das bloss in x richtung mit der höhenerkennung...

ich habe wegen der übersichtlichkeit extra viele interne variablen benutzt

erklärung der globalen variablen:

STEP_SIZE ist der abstand der einzelnen vertices nach X und Y

MAP_SIZE ist die größe der heightmap und von STEP_SIZE unabhängig

byte pHeightMap[MAP_SIZE*MAP_SIZE] ist ein eindimensionales array, das ich 2dimensional gebrauche und die höheninformationen beinhaltet



Code:


float pHeight(BYTE *pHeightMap, GLfloat X, GLfloat Y) // sollte genaue höhe der x/y position zurückliefern
{
if(X>MAP_SIZE){X-=MAP_SIZE;}if(Y>MAP_SIZE){Y-=MAP_SIZE;} //karte soll sich wiederholen
GLfloat x2 =(int)((X/MAP_SIZE) * (MAP_SIZE/STEP_SIZE)) *STEP_SIZE ; // stufenweiser ungenauer x wert wird ermittelt( STEP_SIZE=Stufengröße)
GLfloat y2 =(int)((Y/MAP_SIZE) * (MAP_SIZE/STEP_SIZE)) *STEP_SIZE ; // das selbe für y




float hdx,hdy, hdx2;
float sx,sy;

GLfloat dx,dy;

hdx=pHeightMap[(int)x2 + ((int)y2 * MAP_SIZE)] - pHeightMap[(int)x2+STEP_SIZE + ((int)y2 * MAP_SIZE)]; //höhendifferenz für x
hdx2=pHeightMap[(int)x2 + (((int)y2+STEP_SIZE )* MAP_SIZE)] - pHeightMap[(int)x2+STEP_SIZE + (((int)y2 + STEP_SIZE) * MAP_SIZE)];//höhendifferenz für gegenüberliegendes x
hdy=pHeightMap[(int)x2 + ((int)y2 * MAP_SIZE)] - pHeightMap[(int)x2 + (((int)y2+STEP_SIZE) * MAP_SIZE)]; //höhendifferenz für y

dx=X-x2; //differenz von genau(X) und ungenau(x2) für x (strecke)
dy=Y-y2; //und für y


sx=hdx/STEP_SIZE; //steigungsfaktor für x
sx2=hdx2/STEP_SIZE;
sy=hdy/STEP_SIZE;


float hy= ( (dx* sx2 - dx*sx ) /STEP_SIZE ) *dy; //höhendifferenz geteilt STEP_SIZE (für steigungsfaktor) *strecke


return pHeightMap[(int)x2 + ((int)y2 * MAP_SIZE)] - dx *sx +hy;
}

irgendwo muss da ein fehler sein....

ein zusätzliches problem ist, dass eine ebene durch 3 punkte eindeutig gekennzeichnet ist, ich hab aber 4 -> zwei ebenen-> ich muss also erst rausfinden, auf welcher ebene der punkt ist. dafür hätte ich auch schon eine lösung:
STEP_SIZE*STEP_SIZE-> ganzes quadrat(2ebenen)
STEP_SIZE*STEP_SIZE/2-> halbes quad ->eine ebene

also->
if(x*y<STEP_SIZE*STEP_SIZE){Ebene=1;}

ich glaub, es wissen welche, können mathe aber nicht ausstehen! ^^

@Menlow STOP SPAM! STOP SPAM! STOP SPAM!

Du bist so ein elender Spammer, kannst nichts absolut rein gar nichts zum Thema beitragen musst aber trotzdem deine blöden Kommentare ablassen.

Dich sollte man mal ein paar Tage sperren damit du nachdenken kannst vor dem Posten!

@Menlow: Lass doch einfach mal Deine verdammt sinnlosen Beiträge!

@Coder: Sehe ich das richtig, dass Deine Polygone aus vier Punkten bestehen?

ja, die polys bestehen aus 4 punkten

Dann würde ich Dir aber ganz feste raten, Dein System auf 3-Punkt-Poligone umzustellen (wird so gut wie überall so gemacht). Dann hast Du auch die Möglichkeit mit der hessischen Normalenform den Abstand des Punktes zur Ebene zu bestimmen.

nein, so mein ich das nicht -> meine engine arbeitet mit TRIANGLE_STRIPS (also alle punkte hängen zusammen) wegen der performance
meine funktion arbeitet mit 4 punkten (quadrat)
diese könnte ich aber auch theoretisch auf 2 dreiecke aufteilen