3D Koordinaten auf dem Bildschirm

  • 3D Koordinaten auf dem Bildschirm

    Kennt jemand ne Funktion mit der sich im 3D Mode berechnen lässt welche x und y Koordinaten auf dem Bildschirm ein Punkt im Raum hat, der also x y und z Koordinaten besitzt. Diese x und y Koordinaten sollen natürlich abhängig von Position und Drehung der Kamera seien.

    Wenn nicht, könnte man ja selber Berechnungen anstellen.

    Danke schon mal!

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Bl@ckSp@rk ()

  • Also meinste sowas als würdes du jetzt in einem Stratigie Spiel jetzt in der Näh vom Mittelpunkt der Einheit klickst ist die dann ausgewählt. Nur diesen Punkt herauszufinden ist das Problem. Da gibt es keine Funktion. Und die nachzuproggen ist ein schwieriges Unternehmen.

  • Ich meinte das eigentlich mehr so allgemein. Bei einem Strategiespiel ist es ja genau umgekehrt: Du hast die x y Koordinaten auf dem Bildschirm (Also die Maus) und man will den Punkt auf der Karte.

    Mal ein Bsp. damit man das besser versteht:
    Nehmen wir an, das Sichtfenster hat die Größe 800x600 Pixel. Die Kamera befindet sich an der Position (0,0,0) und ist nach (1,0,0) gerichtet. Der Upvektor ist (0,0,1), also die Kamera ist genau gerade und nicht verdreht. Der Punkt im Raum ist (100,0,0).
    Mit diesen Daten soll die Funktion nun den Punkt auf dem Bildschirm berechnen. Also genau so, als wäre der Punkt im Raum ein Eckpunkt eines Polygons und man will die Stelle an der Das Polygon auf den Bildschirm gezeichnet wird.
    Die Funktion müsste in diesem Beispiel die Koordinaten (400,300) zurückgeben, also die Mitte des Bildschirms.

    Soweit verstanden? Wenn nicht, bitte fragen.

    Naja, ich werds mal probieren zu progen, falls das jemand auch probieren will, dann bitte mal melden.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Bl@ckSp@rk ()

  • ein skript mit dem namen "scr_VectorSet" und diesem inhalt erstellen:

    GML-Quellcode

    1. //arguments 0-10 (first 11 arguments): Same as first 11 arguments of d3d_set_projection_ext().
    2. // Get a vector which represents the direction the camera is pointing and normalise it
    3. dX = argument3-argument0;
    4. dY = argument4-argument1;
    5. dZ = argument5-argument2;
    6. mm = sqrt(dX*dX+dY*dY+dZ*dZ);
    7. dX /= mm;
    8. dY /= mm;
    9. dZ /= mm;
    10. // Get the up vector from the arguments and orthogonalize it with the camera direction
    11. // Orthogonalize is a fancy way of saying I'll make the vectors perpendicular
    12. uX = argument6;
    13. uY = argument7;
    14. uZ = argument8;
    15. mm = uX*dX+uY*dY+uZ*dZ;
    16. uX -= mm*dX;
    17. uY -= mm*dY;
    18. uZ -= mm*dZ;
    19. mm = sqrt(uX*uX+uY*uY+uZ*uZ);
    20. uX /= mm;
    21. uY /= mm;
    22. uZ /= mm;
    23. // Scale the vector up by the tangent of half the view angle
    24. tFOV = tan(argument9*pi/360);
    25. uX *= tFOV;
    26. uY *= tFOV;
    27. uZ *= tFOV;
    28. // We need one more vector which is perpendicular to both the previous vectors
    29. // So we use a cross product: v = u x d
    30. vX = uY*dZ-dY*uZ;
    31. vY = uZ*dX-dZ*uX;
    32. vZ = uX*dY-dX*uY;
    33. // This vector's magnitude is now the same as ||u||, so we scale it up by the aspect ratio
    34. // This vector represents the 2D x-axis on your screen in 3D space
    35. vX *= argument10;
    36. vY *= argument10;
    37. vZ *= argument10;
    Alles anzeigen


    in den create event:

    GML-Quellcode

    1. vector_x=0
    2. vector_y=0
    3. vector_z=0


    in den begin-step event der camera das hier:

    GML-Quellcode

    1. scr_VectorSet(x,y,z,x+vector_x,y-vector_y,z+vector_z,0,0,1,45,1.33333);


    in den step event das hier:

    GML-Quellcode

    1. width=2*mouse_x/view_wview[0]-1;
    2. height=1-2*mouse_y/view_hview[0];
    3. mX = dX+uX*height+vX*width;
    4. mY = dY+uY*height+vY*width;
    5. mZ = dZ+uZ*height+vZ*width;
    6. placex=ceil(x-z*mX/mZ);
    7. placey=ceil(y-z*mY/mZ);


    in den draw event:

    GML-Quellcode

    1. vector_x=cos(direction*pi/180);
    2. vector_y=sin(direction*pi/180);
    3. vector_z=tan(degtorad(pitch));
    5. d3d_set_projection(x,y,z, x+vector_x,y-vector_y,z+vector_z, 0,0,1);


    dann kannst du in der camera placex und placey wie mouse_x und mouse_y verwenden.

    Edit: noch was vergessen
    Battle Command - WeltraumEchtzeitStrategie | Meine GM Spiele auf Box.net
    GCM/FA/O d-(--)@>---xpu s-:- !a C++$@ U- P L+ E W++ N o K-- w++ O? M V PS PE-- Y PGP t 5 X R+++ tv+ b DI D G e+ h? r-- x

  • Original von Bl@ckSp@rk
    Wo hast du das her, oder selber geschrieben?

    teilweise

    EDIT: wenn es nicht klappt, kann ich dir auch ein beispiel geben
    Battle Command - WeltraumEchtzeitStrategie | Meine GM Spiele auf Box.net
    GCM/FA/O d-(--)@>---xpu s-:- !a C++$@ U- P L+ E W++ N o K-- w++ O? M V PS PE-- Y PGP t 5 X R+++ tv+ b DI D G e+ h? r-- x

  • @ WIN:
    das war doch genau das was BS nicht wollte.
    es sollte doh so sein das man 3d koordinaten in 2d umwandelt, und nicht andersrum.

    also:

    GML-Quellcode

    1. width=2*mouse_x/view_wview[0]-1;
    2. height=1-2*mouse_y/view_hview[0];
    3. mX = dX+uX*height+vX*width;
    4. mY = dY+uY*height+vY*width;
    5. mZ = dZ+uZ*height+vZ*width;
    6. placex=ceil(x-z*mX/mZ);
    7. placey=ceil(y-z*mY/mZ);
    diesen codeblock nach x,y,z auflösen. ich wollte das mal machen, allerdings hapert es bei mir and er z coordinate. weil placez ja = 0 ist. nur was müsste man dan schreiben?

    GML-Quellcode

    1. placez=cail(z-z*mX/mz); // ???
    klappt leider nicht so ganz. weil mX dan ja immer =0 sein müsste.
    :) Nobody is perfect (-:

    "Dummköpfe sind Denkerköpfen weit überlegen. Zahlenmäßig." Ernst Ferstl

  • Original von Nobody-86
    ...es sollte doh so sein das man 3d koordinaten in 2d umwandelt, und nicht andersrum.

    aber das macht das skript doch ?(
    Battle Command - WeltraumEchtzeitStrategie | Meine GM Spiele auf Box.net
    GCM/FA/O d-(--)@>---xpu s-:- !a C++$@ U- P L+ E W++ N o K-- w++ O? M V PS PE-- Y PGP t 5 X R+++ tv+ b DI D G e+ h? r-- x

  • öhö, nein.

    der script passt auf die 2d koordinaten auf, die auf dem bildschirm sind, also auf die die man seheh würde wen man den bildschirm fotorgafiert, und wandelt diese dan so um das die koordinaten im 3dimensionalen auf dem "boden" liegen würden. also so wie wen man den room ortogonal von oben sehen würde.
    :) Nobody is perfect (-:

    "Dummköpfe sind Denkerköpfen weit überlegen. Zahlenmäßig." Ernst Ferstl

  • Benutzer online 1

    1 Besucher