OpenGL: Einlesen von mehreren Textdateien



  • Hallo,

    mein Programm liest zur Zeit aus eine Textdatei x,y und z Koordinaten ein und ein 3D-Objekt (Kugel)fährt diese ab. Die Punkte die ich einlese verwalte ich in einer Liste. Nun möchte ich aber das ich 2 oder mehr Textdateien einlesen kann und für diese dann ein neues Objekt erzeugt wird...sprich eine 2. Kugel in der Darstellung. Ich weiß leider nihcht wie ich das mit meiner Liste machen kann. Hoffe ihr könnt mir da weiter helfen.

    Vielen Dank für eure Mühe!!!

    Der Code ist in den nächsten Posts, da es sonst irgendwie nicht angezeigt wird.
    Entschuldigt den langen Post, hab es komplett kopiert damit ihr es vllt. auch testen könnt.



  • Hier der Code:

    gridroom.cpp:

    #include <math.h>
    #include <stdio.h>
    #include <GL/gl.h>
    #include <GL/glu.h>
    #include <GL/glut.h>
    #include "MobilityController.h"
    
    MobilityController* ptrMC;
    
    int i=0;
    
    //int parser( list <Point3f*> & , const char* );
    Point3f* Start ;
    Point3f* End;
    
    void init(void)
    {
       //Hintergrund ist schwarz
       glClearColor (0.0, 0.0, 0.0, 0.0);
       glShadeModel (GL_SMOOTH);
       glEnable(GL_DEPTH_TEST);
    
       //es werde Licht
       GLfloat light0_pos[]={1.0, 5.0, 3.0, 1.0};       /*Position der Lichtquelle*/
       glLightfv(GL_LIGHT0, GL_POSITION, light0_pos);
       glEnable(GL_LIGHTING);
       glEnable(GL_LIGHT0);
    
       Start = ptrMC->getStart();
       End = ptrMC->getEnd();
    
       cout << "Startpunkt: " <<Start->X<<" "<<Start->Y<<" "<<Start->Z<<endl;
       cout << "Endpunkt: " <<End->X<<" "<<End->Y<<" "<<End->Z<<endl;
    
    }
    
    void grid(void){
    
        glDisable(GL_LIGHTING);
    
        //glPushMatrix();
        //glTranslatef(1,-1,-1);
        //glTranslatef(0,0,0);
    
        glRotatef(0,0,1,0);
    
        //glScalef(0.9,0.5,0.5);
    
    /********************************************
    * Einzeichen der Kordinaten Achsen in Farbe*
    * x:weiß, y:rot, z: blau                   *
    ********************************************/
    
             glBegin(GL_LINES);
             //glLineWidth (5.0);
    
                glColor3f (1.0, 1.0, 1.0); // Green for x axis
                glVertex3f(-3,0,0);
                glVertex3f(30,0,0);
                glColor3f(1.0,0.0,0.0); // Red for y axis
                glVertex3f(0,-3,0);
                glVertex3f(0,30,0);
                glColor3f(0.0,0.0,1.0); // Blue for z axis
                glVertex3f(0,0,-3);
                glVertex3f(0,0,30);
                glEnd();
    
    /****************************************
    * Zeichnet einen Grid Boden            *
    ****************************************/
        glBegin(GL_LINES);
        glColor3f(0, 0.66, 0);
            for(int i=-30;i<=30;++i) {
                //if(i!=0){                   //um im Ursprung nichts zu zeichen
                    glVertex3f(i,0,-30);
                glVertex3f(i,0,30);
    
                glVertex3f(30,0,i);
                glVertex3f(-30,0,i);
                //}
            }
    
        glEnd();
    
        glEnable(GL_LIGHTING);
        //glPopMatrix();
    }
    
    GLfloat angle=0.0;
    
    void spin(void) {
        angle+=1;
    
      glutPostRedisplay();
    }
    
    float xTrans = 0.0f;//keeps track of X translation
    int xDir = 1;//1-rechts,0-links
    float zTrans = 0.0f;
    
    void movesphere() {
    
            /*********************************************
            * Bewegung von einem Start zu einem End Punkt*
            **********************************************/
    
            static float Dis = sqrt(pow(Start->X - End->X, 2.0f)+pow(Start->Y - End->Y, 2.0f)+pow(Start->Z - End->Z, 2.0f)) * 10.0f;
            static Point3f Dir = {(End->X - Start->X) / Dis, (End->Y - Start->Y) / Dis, (End->Z - Start->Z) / Dis};
            //static Point3f Dir = {(End->X - Start->X), (End->Y - Start->Y), (End->Z - Start->Z)};
    
            static Point3f SpherePos= *Start;
    
                        //Überprüfen ob sie an einem EndPunkt angekommen ist.
                        //Da die Kugel gleichmäßig fliegt reicht es wenn nur eine Bedienung erfüllt ist
                 if(((SpherePos.X < Start->X && SpherePos.X < End->X) || (SpherePos.X > Start->X && SpherePos.X > End->X))
                    || ((SpherePos.Y < Start->Y && SpherePos.Y < End->Y) || (SpherePos.Y > Start->Y && SpherePos.Y > End->Y))
                    || ((SpherePos.Z < Start->Z && SpherePos.Z < End->Z) || (SpherePos.Z > Start->Z && SpherePos.Z > End->Z)))
                   {
    
                            //Falls sie zum ersten mal an einem EndPunkt ankommt, vertausche sie
                   //  if(i == 0)
                   //   {
    
                     ptrMC->setNextPoints();
                     Start = ptrMC->getStart();
                     End = ptrMC->getEnd();
    
                     Dis = sqrt(pow(Start->X - End->X, 2.0f)+pow(Start->Y - End->Y, 2.0f)+pow(Start->Z - End->Z, 2.0f)) * 10.0f;
    
                       Dir.X = (End->X - Start->X) / Dis;
                         Dir.Y = (End->Y - Start->Y) / Dis;
                         Dir.Z = (End->Z - Start->Z) / Dis;
    
                         SpherePos = *Start;
    
                        }
    
                        SpherePos.X += Dir.X;
                        SpherePos.Y += Dir.Y;
                        SpherePos.Z += Dir.Z;
    
                        glTranslatef(SpherePos.X, SpherePos.Y, SpherePos.Z);
    
    }
    
    //zeichnet die Kugel in die Szene
    void sphere(void){
    
        movesphere();
        glColor3f(0, 0.66, 0);
        glutWireSphere(0.8, 30, 3000);
    
    }
    
    //scale factors
    static float sx = 1.0, sy = 1.0 , sz = 1.0;
    
    void zeichenfunktion(void)
    {
    
       glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
       Camera.Render();
       //glLoadIdentity(); // Reset The matrix
    
       /* gluLookAt:
       * We make our position a bit high and back to view the whole scene
       * Position View Up Vector
       */
       //gluLookAt(0, 5,10, 0, 0, 1, 0, 1, 0);
       gluLookAt(15,30,60, 0, 0, 0, 0, 1, 0); // This determines where the camera's position and view is
       // LookAt Parms (Eye_X, Eye_Y, Eye_Z, View_X, View_Y, View_Z, Up_X, Up_Y, UpZ)
    
       glScalef(sx, sy, sz);
    
       //und los geht es mit dem ZEICHNEN!
          grid();
          sphere();
    
        //das hier damit wir nochmal bei (0,0,0) anfangen können
       glLoadIdentity();
    
       glutSwapBuffers();
    }
    
    /// \brief    Called when the screen gets resized
    /// \param    w    -    the new width
    /// \param    h    -    the new height
    ///
    void reshape(int w, int h)
    {
        // prevent divide by 0 error when minimised
        if(w==0)
            h = 1;
    
        glViewport(0,0,w,h);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluPerspective(45,(float)w/h,0.1,100);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
    }
    
    int main(int argc, char** argv)
    {
    
        ptrMC = new MobilityController();
    
      //Hier werden die elementaren Dinge eingestellt
    
       glutInit(&argc, argv);
       glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB|GLUT_DEPTH);
    
       //wie z.B. das Fenster
       //hier die Größe
       glutInitWindowSize (640, 480);
    
       //der Ort wo das Fenster erscheinen soll
       glutInitWindowPosition (100, 100);
    
       //und der Titel des Fensters
       glutCreateWindow ("3Droom");
       //glutKeyboardFunc(keyboard);
    
       init ();
       //Hier wird angegeben welche Funktion die Befehlen fürs Zeichnen enthält
       //wir haben sie "zeichenfunktion" genannt
    
       glutDisplayFunc(zeichenfunktion);
       glutReshapeFunc(reshape);
       glutIdleFunc(spin);
    
       glutMainLoop();
    
       return 0;
    }
    


  • Und der Rest:

    MobilityController.cpp und MobilityController.h:

    #include "MobilityController.h"
    
    MobilityController::MobilityController(){
    
    cout<<"hier"<<endl;
        Parser("C:\\Test.txt");
        for(PLIt it = punktliste.begin();it!=punktliste.end();++it)
        {
            //cout << "test" << endl;
               Point3f* einPunkt = *it;
            cout << "einPunkt: "<<einPunkt->X<<" "<<einPunkt->Y<<" "<<einPunkt->Z<<endl;
        }
        Start = punktliste.begin();
        End = punktliste.begin();
        End++;
    
    };
    
    int MobilityController::Parser( const char* datei){
    
        // Zu lesende Datei öffnen
            ifstream input(datei);
            // Überprüfen ob Datei geöffnet wurde
            if(!input) {
                cerr << "Datei wurde nicht gefunden: " <<datei<< endl;
                return EXIT_FAILURE;
            }
    
            float wert_x, wert_y, wert_z;
            // Liest bei jedem Schleifendurchlauf 3 Werte ein
            char trennzeichen; //für das Komma
    
            for(int index=0;input >> wert_x >> trennzeichen >> wert_y >> trennzeichen >> wert_z; ++index) {
                Point3f* pkt = new Point3f();
                pkt->X = wert_x;
                pkt->Y = wert_y;
                pkt->Z = wert_z;
                cout << "[" << pkt->X << "," << pkt->Y << "," << pkt->Z <<"]" << endl;
                //it = punktliste.begin();
                //punktliste.insert(it,pkt);
                punktliste.push_back(pkt);
                cout << "Lese Wert "<<index<<endl;
                cout << "Länge der Liste: "<<punktliste.size()<<endl;
                 //it = punktliste.end();
                 //einPunkt = *it;
                 /*                   cout << "erstes: "<<einPunkt->X<<" "<<einPunkt->Y<<" "<<einPunkt->Z<<endl;
                it = punktliste.end();
                einPunkt = *it;
                                   cout << "letztes: "<<einPunkt->X<<" "<<einPunkt->Y<<" "<<einPunkt->Z<<endl;
                 */
    
            }
    return EXIT_SUCCESS;
    }
    
    int MobilityController::setNextPoints(){
    
        Start++;
        if(Start==punktliste.end())
             Start = punktliste.begin();
    
        End++;
        if(End==punktliste.end())
            End = punktliste.begin();
    
    //      while(it!=punktliste->end())
    //             {
    //             Start = *it;
    //             cout << "Start: "<<Start->X<<" "<<Start->Y<<" "<<Start->Z<<endl;
    //             it++;
    //             }
    //         it = punktliste->begin();
    //         Start = *it;
    //            End = *it2;
    
    return 0;
    }
    
    Point3f* MobilityController::getStart()
    {
        return *Start;
    }
    Point3f* MobilityController::getEnd()
    {
    
        return *End;
    }
    
    #ifndef MOBILITYCONTROLLER_H_
    #define MOBILITYCONTROLLER_H_
    
    #include<iostream>
    #include<fstream>
    #include<string>
    #include <list>
    using namespace std;
    
    struct Point3f //Struktur die die Punkte für uns hält
        {
            float X, Y, Z;
        };
    
    class MobilityController {
    public:
        MobilityController();
        //virtual ~MobilityController();
        int setNextPoints();
    
        Point3f* getStart();
        Point3f* getEnd();
    private:
    
        list <Point3f*> punktliste;
        typedef list <Point3f*>::iterator PLIt;
        PLIt Start, End;
    
        int Parser( const char* datei);
    
    };
    
    #endif /* MOBILITYCONTROLLER_H_ */
    


  • Mach dir doch einfach ein Feld von Listen, die du abarbeitest

    vector<list<Foo>> usw.


Anmelden zum Antworten