lings- rechtsbewegen in openGL

Fachmann

ok thx ersma

aber ein punkt ist also doch nicht ein punkt sondern eine richtung von zentrum und dem punkt
un der up punkt ist also ein up vector vom zentrum zu den up punkt^^

also wie ist es eigentlich am sinnvollsten in einer 3D welt rumzulaufen?
1. modelview matrix rumverschieben
2. projections matrix rumverschieben
oder 3. mit gluLookAt arbeiten

wenn ich jetzt 3. nehm:

gluLookAt(pos.x, pos.y, pos.z, dir.x, dir.y, dir.z, 0,1,0);

wie muss ich dann die pos und dir elemtente manipulieren, wenn man W A S D drückt, sodass man realistisch rumlaufen kann

meine idee:

W:
pos.z += 1;
dir.z += 1;

S:
pos.z -= 1;
dir.z -=1;

dir.z = cos(90-drehwinkel);
dir.x = sin(90-drehwinkel);

A:
????

hellihjb

aber ein punkt ist also doch nicht ein punkt sondern eine richtung von zentrum und dem punkt

vom zentrum aus gesehen ist jeder punkt auch eine richtung

wie ist es eigentlich am sinnvollsten in einer 3D welt rumzulaufen?
1. modelview matrix rumverschieben
2. projections matrix rumverschieben
3. mit gluLookAt arbeiten

fuehrt am ende alles zum gleichen ergebnis.

gluLookAt(pos.x, pos.y, pos.z, dir.x, dir.y, dir.z, 0,1,0);
wie muss ich dann die pos und dir elemtente manipulieren, wenn man W A S D drückt, sodass man realistisch rumlaufen kann

da du dich so nur um die y-achse drehst, kannst du maxis vorschlag folgen:

'a': winkel+=irgendwas
'd': winkel-=irgendwas

// vektor nach vorne: (fuer winkel=0: 0,0,-1)
vorne.x= sin(winkel);
vorne.y= 0;
vorne.z= -cos(winkel);

// verschiebung vorne/hinten
'w': pos+=vorne // jeweils x,y,z
's': pos-=vorne

// absolutes "target"
dir= pos+vorne

Fachmann

ok wir kommen der sache schon näher.
ich hab jetz mal dein code passend umgeschrieben (so wie ichs verstanden hab) un im programm steht dann:

gldrawScene():

...
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    glLoadIdentity();
	glMatrixMode(GL_MODELVIEW_MATRIX);

	gluLookAt(pos.x, pos.y, pos.z, dir.x, dir.y, dir.z, 0,1,0);

	glBegin(GL_TRIANGLES); 
     glColor3f(0.0f,0.0f,1.0f);
     glVertex3f( 0.0f, 1.0f, 0.0f);
     glVertex3f(-1.0f,-1.0f, 0.0f);
     glVertex3f( 1.0f,-1.0f, 0.0f);
	glEnd();
...

...einfach ein 3-eck und gluLookAt

und dann in WinMain:

...
                                        if (keys['W'])
					{
						pos.x += dir.x;
						pos.y += dir.y;
						pos.z += dir.z;

					}
					if (keys['S'])
					{
						pos.x -= dir.x;
						pos.y -= dir.y;
						pos.z -= dir.z;
					}
					if (keys['A'])
					{
						rot += 1.0f;
						dir.x= sin(rot);
						dir.y= 0;
						dir.z= -cos(rot);
					}
					if(keys['D'])
					{
						rot -= 1.0f;
						dir.x= sin(rot);
						dir.y= 0;
						dir.z= -cos(rot);
					}
...

ok wenn ich starte seh ich ein 3eck.
drücke ich W dann komm ich immer näher ans 3-eck. wenn das 3-eck genau vor meiner nase ist "prallt" es ab und geht nach hinten bis es weg ist.
dann lass ich W los un starte neu. das 3-eck is wieder in der mitte
wenn ich A gedrückt halt geht es nach rechts, so umgefähr um 20grad dann geht es nach links, so umgefähr 20grad. also bewegt es sich im winkel von 40grad immer wieder hin und her.
das heisst ich hab dein code misverstanden und bitte um aufklärung
wäre nett

hellihjb

du scheinst ja wohl nichts von dem gelesen oder verstanden zu haben, was ich geschrieben habe...

wenn ich A gedrückt halt geht es nach rechts, so umgefähr um 20grad dann geht es nach links, so umgefähr 20grad
rot += 1.0f;
dir.x= sin(rot);

1.0 sind ~57.3 grad, denn:

sin() und cos() erwarten rad und nicht grad.

drücke ich W dann komm ich immer näher ans 3-eck. wenn das 3-eck genau vor meiner nase ist "prallt" es ab und geht nach hinten bis es weg ist.
dir.x= sin(rot);
dir.y= 0;
dir.z= -cos(rot); 
gluLookAt(pos.x, pos.y, pos.z, dir.x, dir.y, dir.z, 0,1,0);

nochmal: der parameter "dir" von gluLookAt ist eine absolute position auf die du schaust. du uebergibst aber eine richtung und darum schaust du immer auf einen punkt nahe (0,0,0) - nur rein zufaellig steht an dieser stelle dein dreieck. uebergib' statt "dir" einfach "pos+dir".

Fachmann

ok jetz hab ichs, ich sag mal danke für die ganze aufregung

wenn dir langweilig ist kannste mir auch noch sagen wie man seitlich läuft

eig ja dir.x += 1;
pos.x += 1;

dann schiebt man grad die position un den sichtpunkt zur seite. das geht aber logischerweise nur in der ausgangsposition. man muss den sichtvector um 90grad am zentrum drehen un dann auf diesem neuen vector das zentrum verschieben +/-.
wie gesagt, diese frage ist optimal^^

hellihjb

kannste mir auch noch sagen wie man seitlich läuft

mathematisch korrekt waere "seitlich" entlang des vektors der senkrecht auf "vorne" und "up" steht.
da in diesem fall "vorne" aber effektiv zweidimensional ist, brauchst du nur die beiden komponenten tauschen und eine negieren:

seite.x= -vorne.z;
seite.y= 0;
seite.z= vorne.x;

kann man sich auch leicht am einheitskreis (sin, cos) verdeutlichen.

wie gesagt, diese frage ist optimal^^

bitte was?

Fachmann

top! thx, funktioniert zwar noch nicht so gaaanz aber im prinzip stimmts thx

also "optimal" ...naja ist nicht notwendig (zu beantworten)

Fachmann

also teoräätisch geht es ja wenn mans aufn blatt papier malt. aber bei openGL net weil immer wenn ich mich dann seitlich beweg geht die kamera wieder in die ausgangsposition

pos.x = -dir.z
pos.z = dor.x

ich weiss nur net warum das minus zeichen da ist, es geht iwie auch ohne.

dann noch ne frage die vll damit zusammenhängt, weil das hier oben nicht geht:
mein mensch steht pos 0.0/0.0 un guckt auf 0.0/1.0 guckt. wenn ich W drück wird der pos vector mit dem direction vector addiert dh: neue vectoren:
pos = 0.0/1.0
direction = 0.0/1.0

wenn ich nochmal W drück dann:
pos = 0.0/2.0
direction = 0.0/1.0

dh mein mensch guckt nach hinten, macht er aber nicht. warum?

hellihjb

wenn ich mich dann seitlich beweg geht die kamera wieder in die ausgangsposition
pos.x = -dir.z
pos.z = dir.x

du setzt hier den richtungsvektor als position.
der richtungsvektor wird irgendwas nahe 0 sein.
darum befindest du dich am ursprung.

ich weiss nur net warum das minus zeichen da ist, es geht iwie auch ohne.

wenn du einen 2d-vektor (x,y) hast der beispielsweise nach vorne zeigt, zeigt der vektor (y,-x) zur seite - siehe einheitskreis.

wenn du solche zusammenhaenge nicht verstehen kannst, solltest du dich nicht mit 3d-programmierung beschaeftigen.

Fachmann

ja sry meine lehrnmethode ist "learning by doing". aber <3lichen dank jetz klappst.

ich hatte einen logischen denkfehler in meim brain

Fachmann

so ich hab jetz schon ganzviel dazugelernt in dem thema aber darf ich bitte bitte bitte noch eine frage stellen |=

rapso

Fachmann schrieb:

so ich hab jetz schon ganzviel dazugelernt in dem thema aber darf ich bitte bitte bitte noch eine frage stellen |=

ja, durftest du und das war jetzt eine sehr nutzlose frage aber du hast sie gestellt, dann darf ich nu den thread schliessen :p

Fachmann

mmh da muss ich jetz ma überlegen
wenn man fragt ob man eine frage stellen darf, ist die frage dann die frage ob man noch eine frage stellen darf?
oder ist die frage dann eine neue frei wählbare frage?

xindon

Alter frag einfach

Fachmann

ah mein plan ging auf.

nun gut es geht ums hochgucken.

wenn die direction gleich (0.0f/0.0f/-1.0f) ist dann kann man im prinzip die direction für hoch und runter gucken so berechnen:
dir.y = sin(rad);
dir.z = -cos(rad);

wenn allerdings der directionsvektor != 0.0f,0.0f,-1.0f ist dann kann man das wie ich erarbeitet hat nicht machen.
meiner arbeit nach geht nur
dir.y = sin(rad);

der dir.z ist irgentwie abhängig von dem winkel der guckrichtung (links-rechts) aber wie (wenn überhaupt) ?

hellihjb

beeinflusst die blickrichtung auch die bewegungsrichtung oder willst du dich nach wie vor nur in der ebene bewegen?

grundsaetzlich gilt: da dein richtungsvektor nicht mehr parallel zur grundflaeche steht (die deine rotationsachse definiert hat), ist diese nicht mehr explizit gegeben und muss zusaetzlich spezifiziert werden.
vereinfacht gesagt: du kannst einem richtungsvektor eines unbekannten koordinatensystems nicht ansehen wo oben und unten ist.
genau das macht aber gluLookAt (in verbindung mit dem up-vektor) - warum willst du diese funktion nicht nutzen?

rapso

Fachmann schrieb:

mmh da muss ich jetz ma überlegen
wenn man fragt ob man eine frage stellen darf, ist die frage dann die frage ob man noch eine frage stellen darf?
oder ist die frage dann eine neue frei wählbare frage?

Du hast glück dass ich zu lazy bin hier die neusten Treiber für MS-remote-Folter zu installieren

Aber nächstes mal, einfach fragen, du kannst bei neuen Fragen auch gerne einen neuen thread aufmachen, heir hat nicht jeder seinen eigenen thread der ihn sein lebenlang begleitet.

Fachmann

"MS-remote-Folter" ...was soll ich dazu noch sagen^^
naja ich hab mir gedacht die frage gehört ja in die selbe gruppe die hier angesprochen wird deswegen hab ichs nochma hier reingemacht
wenn das gelöst ist bin ich für monate bedient;)

@hellijib

dh wenn der richtungsvektor anfängt, sich in der 3. dimension zu bewegen, muss er expliziert spezifiziert werden?
deshalb soll man den upvektor manipulieren?

seite:
up
|
|
|_____direction

wenn der upvektor immer im winkel von 90grad zur direktion steht dann könnte man einen neuen winkel names UpDownAngle erstellen sowie ein vektor UpDownVector. letzterer wird beim auf und up bewegen wiefolg manipuliert:
(dieser vektor wird auch als parameter vom Upvector parameter bei glulookAt angegeben)

updown.y = sin(rad);
updown.z = -cos(rad);

also wenn man nach oben gucken will muss man nur den upvektor nach hinten drehen (center of mass) un somit wird auch die direction nach oben gekippt?
wie wenn die obige zeichnung ein festes stück ist un ich es um den beliebigen winkel nach links/rechts kipp (center of mass)?
(warscheinlich net )

soo und nochma editiert:
wenn ich das so umsetz dreht sich mein objekt (also die komplette weld) um die z achse wenn ich hoch oder runter guck(en will).

hellihjb

was du effektiv willst, ist ja 'ne rotationsmatrix.
die besteht aus 3 vektoren die, wie beim kartesischen koordinatensystem, alle senkrecht aufeinander stehen.
bei deinen bisherigen bemuehungen war das leicht zu realisieren:
dein richtungsvektor war zweidimensional in x und z und der up-vektor dadurch eindeutig definiert durch (0,1,0) (implizit durch glRotate).
den allgemeinen fall loest gluLookAt - den up-vektor muss man dabei nicht besonders genau nehmen:
die funktion berechnet zunaechst den vektor zur seite (steht senkrecht auf "vorne" und "up") und daraus wiederum den tatsaechlichen "up" als senkrecht auf "vorne" und "seite" - es muss also nur die grobe richtung passen.
wenn man davon ausgehen kann, dass man immer "auf dem boden" steht und lediglich nach oben und unten gucken koennen soll, bleibt der upvektor (0,1,0).
willst du beliebig im raum herumtrudeln, wuerde ich dir quaternionen nahelegen.
deren mathematische hintergruende sind fuer dich wahrscheinlich unmoeglich nachzuvollziehen, die anwendung jedoch relativ simpel.

Fachmann

Die Anwendung ist simpel aber für mich noch nicht wirklich einfach weil mir da warscheinlich noch ein bisschen Basiswissen fehlt^^
Ich werde mich auch ma durchgooglen was man unter einer Quaternion versteht, weil mir die "Kurzbeschreibung" da nicht weiter hilft. Was das genau ist werde ich die nächsten 5 Jahre nicht verstehen also bleibt mir nichts übrig als die Anwendung zu verstehen ohne zu wissen, was genau ein Quaterion ist. (ich freu mich schon drauf )
wie gesagt - ich versuchs mit der anwendung und meld mich bei problemen evtl. .
warscheinlich muss ich das mit updown-bewegen erstmal pausieren und nach meinem abitur (falls es soweit kommt) nochmal drauf eingehen. Aber ich bedanke mich erstmal recht herzlich!