Opengl Horizontale Drehung der Ego-Perspektive



  • Hi Leute,
    nachdem ich die letzten Tage alles im Internet durchsucht und viele mögliche Code-Beispiele ohne Erfolg ausprobiert habe, wende ich mich nun mit meiner Frage an das Forum.
    Es geht darum, die Ego-Perspektive z.B. nach links zu drehen, wenn ich die 'Links'-Taste drücke. Jetzt rotiert es irgendwie um einen anderen Punkt. Komme einfach nicht darauf, welche Zahlen man in z.B. Zeile 71-72 eintragen soll und welche Informationen man benötigt und ob der Ansatz überhaupt stimmt. Gibt es da Hilfe mit möglichst wenig Code und ohne externe Bibliotheken? Es ist bestimmt nur irgendeine Formel, die man eintragen muss.

    #include <SFML/Graphics.hpp>
    #include <iostream>
    #define _USE_MATH_DEFINES
    #include <math.h>
    #include <SFML/OpenGL.hpp>
    
    const short height = 800;
    const short width = 600;
    
    void myGluPerspective(double fovy, double aspect, double zNear, double zFar)
    {
        double f = 1.0 / tan(fovy * M_PI / 360);  // convert degrees to radians and divide by 2
        double xform[16] =
        {
            f / aspect, 0, 0, 0,
            0,          f, 0, 0,
            0,          0, (zFar + zNear)/(zFar - zNear), -1,
            0,          0, 2*zFar*zNear/(zFar - zNear), 0
        };
        glMultMatrixd(xform);
    }
    
    int main()
    {
        sf::RenderWindow window(sf::VideoMode(height,width), "Map", sf::Style::Close);
    	window.setFramerateLimit(40);
    
    	glMatrixMode(GL_MODELVIEW);
    	glLoadIdentity();
    
    	//glPushMatrix();
    	myGluPerspective(39.6,height/width,0,200);
    
    	glTranslatef(0,0,-5);
    	//glPopMatrix();
    
        while (window.isOpen())
        {
            sf::Event event;
    
    		while (window.pollEvent(event))
    		{
    			switch (event.type)
    			{
    			case sf::Event::Closed:
    				window.close();
    				break;
    			case sf::Event::KeyPressed:
    				if(sf::Keyboard::isKeyPressed(sf::Keyboard::Up))
    				{
    					glTranslatef(0, 0, 1);
    					break;
    				}
    				if(sf::Keyboard::isKeyPressed(sf::Keyboard::Down))
    				{
    					glTranslatef(0, 0, -1);
    					break;
    				}
    				if(sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
    				{
    					//glRotatef(-10.0f, 0.0f, 1.0f, 0.0f);					// Wie Ego-Perspektive horizontal drehen?
    
    					GLfloat matrixf[16];
    					glGetFloatv(GL_MODELVIEW_MATRIX, matrixf);
    
    					//glTranslatef(matrixf[12], 0, matrixf[14]);			// Geht nicht!
    					//glRotatef(-10, 0, 1, 0);
    					//glTranslatef(-matrixf[12], -0, -matrixf[14]);
    
    					//glTranslatef(0, 0, 0);
    					glRotatef(-10.0f, 0, 1.0f, 0);								// Geht nicht!
    
    					std::cout << "camxpos " << matrixf[12] << std::endl;
    					std::cout << "camypos " << matrixf[13] << std::endl;
    					std::cout << "camzpos " << matrixf[14] << std::endl;
    					break;
    				}
    				if(sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
    				{
    					glRotatef(10.0f, 0.0f, 1.0f, 0.0f);
    					break;
    				}
    			}
    
    		}
    
    		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    		glBegin(GL_QUADS);
    
    		glVertex3f(-1,-1,-1);
    		glVertex3f(1,-1,-1);
    		glVertex3f(1,1,-1);
    		glVertex3f(-1,1,-1);
    
    		glEnd();
    
            window.display();
        }
    
        return 0;
    }
    


  • glBegin(GL_QUADS);
     
    glVertex3f(-1,-1,-1);
    glVertex3f(1,-1,-1);
    glVertex3f(1,1,-1);
    glVertex3f(-1,1,-1);
     
    glEnd();
    

    Sag mal wo zur Hölle lernt man 2017 sowas noch? Bitte lerne richtiges OpenGL. Danke 🙂



  • Genau ... die arme(n) Grafikarte(n), das haben die doch nicht verdient.

    Ähnlich ists bei den Matrix Op's.
    Dir den Matrix-Stack zu erklären, ist wie jemanden der Lesen und schreiben lernen will, mit Keilschrift zu kommen.

    Bau und Verwalte die MVP Matrix selber.
    Das ist nicht so schwer, einmal begriffen ist Modelbewegung und eigen(viewport)Bewegung nen Klacks ... und bei modernen OpenGL brauchst es sowieso ...

    GLfloat matrixf[16];

    und nutze Biblios !
    http://glm.g-truc.net/0.9.8/index.html ist für sowas ganz gut, muss nicht gleich eigen oder ublas sein.

    Gibt gute Tuts im Internet ...
    [url]http://duriansoftware.com/joe/An-intro-to-modern-OpenGL.-Chapter-1:-The-Graphics-Pipeline.html
    [/url]
    z.b fürn Überblick ... (fixed Pipeline war 2010 schon lange out of date)

    http://www.codinglabs.net/article_world_view_projection_matrix.aspx
    Für die Projektionen

    Ich glaub nicht das du ne Umgebung hasst, wo du auf Opengl 1.x festgenagelt bist.

    Und noch was .... Tastaturereignisse kommen oft sehr unregelmaessig. je nach Auslastung vom rechner.
    Errechne dir den Winkel um den du drehen musst auf Basis der Zeitstamps vom letzen durchlauf ...
    Das macht die eigentliche Bewegung Lag resistenter und man kann (später) Beschleunigung mit hinzurechnen für etwas "smoothere" Abläufe.

    Ciao ...



  • Ist mir schon klar, dass man normal keine Quads mehr verwendet, sondern alles über VertexArrays läuft und die Grafikkarte mit Dreiecken arbeitet, aber das war nur zur Veranschaulichung.
    Hab jetzt in Zeile 32 einen etwas anderen Wert eingetragen und es sieht besser aus:
    myGluPerspective(60,height/width,0,180);

    Jetzt muss ich nur noch die richtige glRotate und glTranlate Kombination beim Drehen finden, dann wird sich die Kamera nicht mehr um den Nullpunkt drehen, sondern um einen von mir festegelten Punkt, der am besten mit der "Kamera" mitwandert.



  • Ich lasse das hier mal fuer dich stehen.


  • Mod

    wasd-camera tutorial
    koennte dein google keyword sein, um viele antworten zu finden. Cardiacs link solltest du dir aber auch anschauen und verinnerlichen ⚠



  • Ist mir schon klar, dass man normal keine Quads mehr verwendet, sondern alles über VertexArrays läuft und die Grafikkarte mit Dreiecken arbeitet

    VertexArrays und Drei/Vierekce haben nix miteinander zu tun 🙂
    Auch mit VBO's und VAO's kann man GL_QUADS rendern lassen.
    Man sollte es nur nicht tun (GL_TRIANGLES / TRIANGLEFAN und co ist je nach HW mindestens genau so schnell, ab und an schneller)

    Modernes OpenGL heisst Puffer basiertes rendern ....
    glBegin und glEnd ist der "Teufel", nicht GL_QUADS ^^
    genau so glPushMatrix und co 🙂

    Denk in Koordinatensystemen, das ist auf Dauer einfacher
    http://www.codinglabs.net/article_world_view_projection_matrix.aspx

    Damit wird auch dein Orbit Wunsch recht "easy"

    und nutz Bibos für Matrix operationen ...
    da gibts fertige funktionen z.b. um die Projektionsmatrix zu bekommen -> glm::perspective,
    selber machen ist fehleranfällig !


Log in to reply