Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » OpenGL » OpenGL: Einlesen von mehreren Textdateien

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
03.07.2009, 01:59 Uhr
Mr



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...hab es komplett kopiert damit ihr es vllt. auch testen könnt.

Dieser Post wurde am 03.07.2009 um 02:07 Uhr von Mr editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
03.07.2009, 02:06 Uhr
Mr



Hier der Code:

gridroom.cpp:


C++:

#include <math.h>
#include <stdio.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include "camera.h"
#include "MobilityController.h"


CCamera Camera;

MobilityController* ptrMC;


int i=0;


//int parser( list <Point3f*> & , const char* );
Point3f* Start ;
Point3f* End;

/*
list <Point3f*> *punktliste;
list <Point3f*>::iterator it;
list <Point3f*>::iterator it2; */


/*
//static Point3f Start = {-5.0f, 1.0f, -6.0f};       //Startpunkt
static Point3f Startpkt = {0.0f, 0.0f, 0.0f};
static Point3f Endpkt = {5.0f, 0.0f, 0.0f};          //EndPunkt
//static Point3f End = {5.0f, 3.0f, 1.0f};
static Point3f End2pkt = {5.0f, 5.0f, 0.0f};
static Point3f End3pkt = {5.0f, 1.0f, 6.0f};
*/



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;

  /* it = punktliste.begin();
   punktliste.insert(it,&End3pkt);
   //it++;
   it = punktliste.begin();
   punktliste.insert(it,&End2pkt);
   //it++;
   it = punktliste.begin();
   punktliste.insert(it,&Endpkt);
   //it++;
   it = punktliste.begin();
   punktliste.insert(it,&Startpkt);
*/


/*
punktliste = new list <Point3f*>;
   parser( punktliste, "test.txt");

   cout << "geparst, starte nun liste "<<endl;

   it = punktliste->begin();
   it2 = punktliste->begin();
   it2++;


   while(it!=punktliste->end())
       {
       Start = *it;
       cout << "Start: "<<Start->X<<" "<<Start->Y<<" "<<Start->Z<<endl;
       it++;
       }
   it = punktliste->begin();
   Start = *it;
      End = *it2;
*/


}


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();
                 /*
                 Punkte_objekt->weiter();
                 Start = Punkte_objekt->getStart();
                 End =Punkte_objekt->getEnd();
                */

                     /* if(it==punktliste->end())
                             it = punktliste->begin();
                      else it++;
                      if(it2==punktliste->end())
                             it2 = punktliste->begin();
                      else it2++;
                      //i += 1;
                      Start = *it;
                      End = *it2;  */


                 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;

            //     Dir.X = (End->X - Start->X);
            //     Dir.Y = (End->Y - Start->Y);
            //     Dir.Z = (End->Z - Start->Z);

                     SpherePos = *Start;



                 // }
                        //Falls sie bereits zum zweiten mal ankommt, bewege sie nicht mehr
                   //     else
                    //    {
                            //Setze die Position auf End
                   //         SpherePos = * End;

                            //Setze die Richtungen auf 0.0f damit sie sich nicht mehr bewegt
                   //         Dir.X = Dir.Y = Dir.Z = 0.0f;
                   //     }
                    }

                    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();
}

/*
void keyboard(unsigned char key,int x, int y){
      switch(key){

      case '+':
            sx += 0.5;
            sy += 0.5;
            sz += 0.5;
            break;
      case '-':
            if(sx >0.5 && sy >0.5 && sz>0.5){
                  sx -= 0.1;
                  sy -= 0.1;
                  sz -= 0.1;
            }
            break;
      default:
            break;
      }
}
*/

/// \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();
}

/**********************************************************************
ESC: exit

CAMERA movement:
w : forwards
s : backwards
a : turn left
d : turn right
x : turn up
y : turn down
v : strafe right
c : strafe left
r : move up
f : move down

***********************************************************************/



void KeyDown(unsigned char key, int x, int y)
{
    switch (key)
    {
    case 'a':
        Camera.RotateY(5.0);
        zeichenfunktion();
        break;
    case 'd':
        Camera.RotateY(-5.0);
        zeichenfunktion();
        break;
    case 'w':
        Camera.MoveForwards( -0.1 ) ;
        zeichenfunktion();
        break;
    case 's':
        Camera.MoveForwards( 0.1 ) ;
        zeichenfunktion();
        break;
    case 'x':
        Camera.RotateX(5.0);
        zeichenfunktion();
        break;
    case 'y':
        Camera.RotateX(-5.0);
        zeichenfunktion();
        break;
    case 'c':
        Camera.StrafeRight(-0.1);
        zeichenfunktion();
        break;
    case 'v':
        Camera.StrafeRight(0.1);
        zeichenfunktion();
        break;
    case 'f':
        Camera.Move(F3dVector(0.0,-0.3,0.0));
        zeichenfunktion();
        break;
    case 'r':
        Camera.Move(F3dVector(0.0,0.3,0.0));
        zeichenfunktion();
        break;

    }
}

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);
   Camera.Move( F3dVector(0.0, 0.0, 3.0 ));
   Camera.MoveForwards( 1.0 );

       glutKeyboardFunc(KeyDown);

   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;
}



 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
03.07.2009, 02:06 Uhr
Mr



Und der Rest:


MobilityController.cpp und MobilityController.h:


C++:

#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;
}






C++:

#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_ */



 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ OpenGL ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: