Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » OpenGL » OpenGL: Bewegung zwischen zwei Punkten

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 < [ 2 ]
000
26.02.2009, 02:04 Uhr
~Mr
Gast


Hallo,

ich möchte das sich ein 3D-Objekt von einem Punkt P1 zu einem Punkt P2 bewegt. Die Punkte P1 und P2 muss ich doch mit glTranslate setzten oder? Bisher habe ich es hinbekommen das er sich in einem Intervall hin und her bewegt:


C++:
void sphere(void){
glTranslatef(-1,1,-4);


         //überprüfen ob das Objekt sich nach rechts entlang der x.Achse bewegen kann
           if(xDir==1 && xTrans<5.0f)   //stellt ein wie viele einheiten entlang der x-Achse erlaubt
              {
               xTrans+=0.1f;//xTrans erhöhen
              }
           else//wenn das Objekt das rechte ende erreicht
              {
               xDir=0;//Richtung ändern
              }

           //überprüfen ob das Objekt sich nach links entlang der x.Achse bewegen kann
           if(xDir==0 && xTrans>-5.0f)
              {
                  xTrans-=0.1f;//xTrans verringern
              }
            else//wenn das Objekt das linke ende erreicht
              {
                  xDir=1;//Richtung ändern
              }

            //translate along the x-axis
            glTranslatef(xTrans,0.0f,0.0f);
            //glTranslatef(-1,1,-angle);

            //glRotatef(angle,1,0,0);
            //glRotatef(angle,0,1,0);
            //glRotatef(angle,0,0,1);

            // Set the current OpenGL color to red
       //glColor4f(1.0, 0.0, 0.0, 1.0);
       glColor3f(0, 0.66, 0);  //Grid farbe??
       // Draw a wire sphere
       glutWireSphere(0.3, 30, 3000);
}



Aber wie bekomme ich die Punkt zu Punkt bewegung hin?
Frage zu glTranslate: Wenn ich das benutze um die Kugel zu platzieren, bleibt doch das Koordinatensystem fest? Oder verschiebt sich damit das Koordinatensystem und die Kugel ist in Wirklichkeit im Ursprung?

Noch ne Frage: Ich setzte in meinem Code zu Beginn glTranslatef(-1,1,-4), und dann erfolgt die Überprüfung ob er sich noch im Intervall befindet. Diese Funktion Sphere wird doch immer wieder aufgerufen, also müsste sich doch die Kugel auch wieder auf die Position (-1,1,-4)begeben, und er müsste hin und her sprigen. Passiert aber nicht. Warum?

Hoffe ihr könnt mir weiterhelfen. Hier nochmal der Komplette Code, damit ihr es auch mal Testen könnt:


C++:
#include "gridroom.h"
#include <math.h>
#include <stdio.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>


void init(void)
{
   /***********************************/
   /* Hier werden ganz zu Anfang ein  */
   /* paar Sachen angeschaltet.       */
   /* Kümmert euch nicht :-)          */
   /***********************************/

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



/****************************************
* Zeichnet einen Grid Boden            *
****************************************/


void grid(void){

    glDisable(GL_LIGHTING);

    /*
     * glTranslate(a,b,c) verschiebt den Koordinatenursprung
     * des aktuellen Koordinatensystems
     * um a Einheiten in die Richtung der X-Achse, um b
     * Einheiten in die Richtung der Y-Achse und um c Einheiten in die Richtung der Z-Achse.
     */

    //glPushMatrix();
    //glTranslatef(1,-1,-1);
    //glTranslatef(0,0,0);



    /*
     * glRotate(w,x,y,z) rotiert das
     * Koordinatensystem um w Grad um die Rotationsachse
     * welche durch (0,0,0) und (x,y,z) verläuft. glRotate
     * richtet also die Achsen neu aus. (Die Richtung der Achsen
     * ist z.B. wichtig für glTranslate)
     */

    glRotatef(0,0,1,0);

    //glScalef(0.9,0.5,0.5);

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

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



    glEnable(GL_LIGHTING);
    //glPopMatrix();
}

//bool klein = true;
GLfloat angle=0.0;




void spin(void) {
    angle+=1;


    //klein = angle <= 10;

//    if(angle<=3){
//        angle+=0.5;
//       }
//    if((angle==2.5)&&(angle==3)){
//        angle= angle-1;
//    }

  glutPostRedisplay();
}

float xTrans = 0.0f;//keeps track of X translation
int xDir = 1;//1-rechts,0-links
float zTrans = 0.0f;
//zeichnet die Kugel in die Szene
void sphere(void){
/***************************************
* Lineare Bewegung entlang der x-Achse*
****************************************/


        //glTranslatef(-1,1,-2);
         glTranslatef(-1,1,-4);


         //überprüfen ob das Objekt sich nach rechts entlang der x.Achse bewegen kann
           if(xDir==1 && xTrans<5.0f)   //stellt ein wie viele einheiten entlang der x-Achse erlaubt
              {
               xTrans+=0.1f;//xTrans erhöhen
              }
           else//wenn das Objekt das rechte ende erreicht
              {
               xDir=0;//Richtung ändern
              }

           //überprüfen ob das Objekt sich nach links entlang der x.Achse bewegen kann
           if(xDir==0 && xTrans>-5.0f)
              {
                  xTrans-=0.1f;//xTrans verringern
              }
            else//wenn das Objekt das linke ende erreicht
              {
                  xDir=1;//Richtung ändern
              }

            //translate along the x-axis
            glTranslatef(xTrans,0.0f,0.0f);
            //glTranslatef(-1,1,-angle);

            //glRotatef(angle,1,0,0);
            //glRotatef(angle,0,1,0);
            //glRotatef(angle,0,0,1);

            // Set the current OpenGL color to red
       //glColor4f(1.0, 0.0, 0.0, 1.0);
       glColor3f(0, 0.66, 0);  //Grid farbe??
       // Draw a wire sphere
       glutWireSphere(0.3, 30, 3000);


/****************************************
* Orbitale Bewegung entlang der y-Achse*
****************************************/

/*

    //glPushMatrix(); // Push on a new matrix scope
    glRotatef(angle, 0, 1.0, 0); // Rotate the sphere around the origin (the sun)
    glTranslatef(-1,2,-3); //kleinerer Orbit; einstellbar durch den z wert
    //glTranslatef(-1,1,-5); //größerer Orbit einstellbar durch den z wert
    glRotatef(angle, 0, 1.0, 0); // Rotate the sphere to make it spin
    //gluSphere(pObj, 0.2f, 20, 20); // Draw the sphere with a radius of 0.2 so it's smaller than the sun
    glColor3f(0, 0.66, 0);  //Grid farbe??
    // Draw a wire sphere
    glutWireSphere(0.3, 30, 3000);
    //glPopMatrix();

*/

}


void zeichenfunktion(void)
{

   glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

   //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(12, 12,12, 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)


   //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)
{
   //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");

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




Der Post ist jetzt ziemlich lang geworden
Vielen Dank im Voraus.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
26.02.2009, 09:47 Uhr
TOSHMAX



Hallo,

ich würde das etwa so lösen:


C++:
struct Point3f //Struktur die die Punkte für uns hält
{
    float X, Y, Z;
};

void sphere(void)
{
    static Point3f Start = {-5.0f, 1.0f, -6.0f};         //Startpunkt
    static Point3f End   = {5.0f, 1.0f, 6.0f};           //EndPunkt

    //Um die Distanz zwischen beiden Punkten zu bestimmen
    //die 100 verlangsamt die Bewegung etwas
    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)) * 100.0f;

    //Hier wird für jede Achse eine Geschwindigkeit bestimmt damit die Kugel gleichmäßig fliegt
    static Point3f Dir = {(Start.X - End.X) / Dis, (Start.Y - End.Y) / Dis, (Start.Z - End.Z) / Dis};

    //Hier stehen die aktuellen Punkte, beginnend beim Start
    static Point3f SpherePos = Start;

    //Überprüfe ob sie die Grenzen überschreitet und drehe die Richtung ggf. um
    if(SpherePos.X < Start.X || SpherePos.X > End.X)
        Dir.X = -Dir.X;
    if(SpherePos.Y < Start.Y || SpherePos.Y > End.Y)
        Dir.Y = -Dir.Y;
    if(SpherePos.Z < Start.Z || SpherePos.Z > End.Z)
        Dir.Z = -Dir.Z;

    //Erhöhe/veringere aktuelle Positionen
    SpherePos.X += Dir.X;
    SpherePos.Y += Dir.Y;
    SpherePos.Z += Dir.Z;

    //Lass die Kugel dorthin bewegen
    glTranslatef(SpherePos.X, SpherePos.Y, SpherePos.Z);

    //Zeichne sie
    glColor3f(0, 0.66, 0);
    glutWireSphere(0.3, 30, 3000);
}



So würde es gehen. Das musst du natürlich für deine Vorhaben umschreiben.
Ich hoffe das hilft dir weiter.

Gruß
TOSHMAX

Dieser Post wurde am 26.02.2009 um 09:48 Uhr von TOSHMAX editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
27.02.2009, 00:19 Uhr
~Mr
Gast


Vielen Dank! Das wird mir auf jedenfall weiterhelfen.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
06.03.2009, 16:57 Uhr
Mr



Hallo,

hab den Code von TOSHMAX ausprobiert und es klappt allerdings nur wenn man wenn die y-Koordinate vom Startpunkt kleiner als der Endpunkt ist, Start = {5.0f, 1.0f, 6.0f}, End = {5.0f, 0.0f, 0.0f}.

Ich finde den Fehler irgendwie nicht. Ich habe, damit die Kugel wenn der Endpunkt erreicht ist stoppt, noch die Bedingung


C++:
if(SpherePos.X < End.X || SpherePos.Y < End.Y || SpherePos.Z < End.Z)
        {
            SpherePos.X += Dir.X;
            SpherePos.Y += Dir.Y;
            SpherePos.Z += Dir.Z;
        }

hinzugefügt. Aber daran liegt es auch nicht.

Ich habe dann den Codde versucht zu erweitern, weil die Kugel mehrere Punkte errecihen sollte und nicht nur zwei. Hab das versucht mal für drei Punkte zu realisieren:


C++:
        if(i==0){
            Start = End;
            End = End2;
            i+=1;  



Ich vertausche einfach Start und End. Ist das überhaupt eine gute Idee von. Es soll darauf hinauslaufen nach ich n-Punkte aus einer Text-Datei auslesen kann und die Kugel die nacheinander abfährt und am Ende stehen bleibt.

Hier nochmal die komplette Methode. Um es zu testen einfach in den Code vom ertsen Post von mir einfügen.


C++:
void sphere(void){



        //Um die Distanz zwischen beiden Punkten zu bestimmen
        //die 100 verlangsamt die Bewegung etwas
        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;
    


        //Hier wird für jede Achse eine Geschwindigkeit bestimmt damit die Kugel gleichmäßig fliegt
        static Point3f Dir = {(Start.X - End.X) / Dis, (Start.Y - End.Y) / Dis, (Start.Z - End.Z) / Dis};
      


        //Hier stehen die aktuellen Punkte, beginnend beim Start
        static Point3f SpherePos = Start;
        //std::cout <<"StartX:"<<Start.X << "StartY:"<<Start.Y << "StartZ:"<<Start.Z <<std::endl;
        //Überprüfe ob sie die Grenzen überschreitet und drehe die Richtung ggf. um
        if(SpherePos.X < Start.X || SpherePos.X > End.X)
            Dir.X = -Dir.X;
        if(SpherePos.Y < Start.Y || SpherePos.Y > End.Y)
            Dir.Y = -Dir.Y;
        if(SpherePos.Z < Start.Z || SpherePos.Z > End.Z)
            Dir.Z = -Dir.Z;



        //Erhöhe/veringere aktuelle Positionen
        if(SpherePos.X < End.X || SpherePos.Y < End.Y || SpherePos.Z < End.Z)
        {
            SpherePos.X += Dir.X;
            SpherePos.Y += Dir.Y;
            SpherePos.Z += Dir.Z;
        }
       else{
            

            if(i==0){
            Start = End;
            End = End2;
            
            i+=1;
            }

            
            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 = {(Start.X - End.X) / Dis, (Start.Y - End.Y) / Dis, (Start.Z - End.Z) / Dis};
            
            //Hier stehen die aktuellen Punkte, beginnend beim Start
            static Point3f  SpherePos = Start;

            if(SpherePos.X < Start.X || SpherePos.X > End.X)
                Dir.X = -Dir.X;
        
            if(SpherePos.Y < Start.Y || SpherePos.Y > End.Y)
                Dir.Y = -Dir.Y;
        
            if(SpherePos.Z < Start.Z || SpherePos.Z > End.Z)
                Dir.Z = -Dir.Z;
        

           //if(SpherePos.X < End.X || SpherePos.Y < End.Y || SpherePos.Z < End.Z)
                 // {
            SpherePos.X += Dir.X;
            SpherePos.Y += Dir.Y;
            SpherePos.Z += Dir.Z; // }
        

        }  


        //Lass die Kugel dorthin bewegen
        glTranslatef(SpherePos.X, SpherePos.Y, SpherePos.Z);
        std::cout <<"NEU4:SpherePosX: "<<SpherePos.X<<"SpherePosY: "<<SpherePos.Y<<"SpherePosZ: "<<SpherePos.Z<<std::endl;

        //Zeichne sie
        glColor3f(0, 0.66, 0);
        glutWireSphere(0.3, 30, 3000);



}


Und noch die Punkte die ich global definiert habe:

C++:

int i=0;
struct Point3f //Struktur die die Punkte für uns hält
{
    float X, Y, Z;
};
//static Point3f Start = {-5.0f, 1.0f, -6.0f};       //Startpunkt
//static Point3f Start = {0.0f, 0.0f, 0.0f};
static Point3f Start = {5.0f, 1.0f, 6.0f};          //EndPunkt
static Point3f End = {5.0f, 0.0f, 0.0f};
static Point3f End2 = {5.0f, 7.0f, 1.0f};  


Hoffe ihr könnt mir da helfen. Danke!

Dieser Post wurde am 06.03.2009 um 17:00 Uhr von Mr editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
07.03.2009, 10:14 Uhr
TOSHMAX



Hi,
sorry, das war ein ganz blöder Fehler von mir. Mit diesem Code bewegt sie sich in alle Richtungen:

C++:
        if((SpherePos.X < Start.X && SpherePos.X < End.X) || (SpherePos.X > Start.X && SpherePos.X > End.X))
            Dir.X = -Dir.X;
        if((SpherePos.Y < Start.Y && SpherePos.Y < End.Y) || (SpherePos.Y > Start.Y && SpherePos.Y > End.Y))
            Dir.Y = -Dir.Y;
        if((SpherePos.Z < Start.Z && SpherePos.Z < End.Z) || (SpherePos.Z > Start.Z && SpherePos.Z > End.Z))
            Dir.Z = -Dir.Z;



Und mit diesem Code in sphere(), kann sie zwei Punke abfliegen, und bleibt dann stehen.

C++:
        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)) * 100.0f;
        static Point3f Dir = {(End.X - Start.X) / Dis, (End.Y - Start.Y) / Dis, (End.Z - Start.Z) / Dis};
        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)
            {
                Start = End;
                End = End2;

                i += 1;

                Dis = sqrt(pow(Start.X - End.X, 2.0f)+pow(Start.Y - End.Y, 2.0f)+pow(Start.Z - End.Z, 2.0f)) * 100.0f;

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

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

        glColor3f(0, 0.66, 0);
        glutWireSphere(0.3, 30, 3000);



So, ich hoffe ich hab nicht wieder eine Fehler reingebaut, falls doch lass es mich wissen.

Gruß
TOSHMAX

Dieser Post wurde am 07.03.2009 um 10:16 Uhr von TOSHMAX editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
08.03.2009, 00:47 Uhr
Mr



Hi TOSHMAX,

vielen Dank für deine Mühe!!! Es klappt und bisher ist mir noch nichts aufgefallen. Hab aber noch ne Frage: Bis jetzt ist es ja für 3 Punkte eingestellt. Ich möchte es aber für beliebige Punkte haben. Wies sollte ich das am besten realisieren? Es muss ja dann immer wieder Start und End vertauscht werden. Also er müsste sich immer zwei Punkte anschauen oder?
Hast du da ne Idee?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
08.03.2009, 09:35 Uhr
TOSHMAX



Hallo,

das geht so ähnlich wie es jetzt schon ist.

Du liest alle Punkte z. B. aus einer Datei aus und speicherst sie in einem Array. Das Punkte-Vertauschen wird ja immer aufgerufen, wenn die Kugel über den bisherigen Endpunkt hinaus geht. Deshalb nimmst du eine Variable und erhöhst sie immer, wenn du die Punkte vertauscht.

Die Variable bestimmt dann immer den aktuellen Endpunkt und wenn sie die Maximale Anzahl an Punkten erreicht hat, lässt du die Kugel, wie oben, nicht mehr bewegen.

Gruß
TOSHMAX
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
11.03.2009, 00:43 Uhr
Mr



Hallo,

ich habe es jetzt geschafft, dass ich mehrere Punkte abfliegen kann. Hab das mit einer Liste gelöst. Hab aber das Problem, dass wenn er beginnt (also von p1 nach p2) er zurück zu p1 springt und dann fortfährt. Also p1->p2->Sprung zurück zu p1->p2->p3->p4.
Finde den Fehler aber nicht. Hier der Code:


Und noch was: Hat irgendjemand schon mal einen Parser programmiert. Möchte aus einer Textdatei Koordinaten x,y,z auslesen. Die Textdatei sollte so aufgebaut sein:
5, 5, 1
2, -1, 0


C++:

#include <math.h>
#include <stdio.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include<iostream>
#include<fstream>
#include<string>
#include <list>
using namespace std;


//bool change;
int i=0;
struct Point3f //Struktur die die Punkte für uns hält
{
    float X, Y, Z;
};

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};   //wenn z größer als 1 kugel fliegt in einer schleife
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);



   it = punktliste.end();
   punktliste.insert(it,&End3pkt);
   it++;
   punktliste.insert(it,&End2pkt);
   it++;
   punktliste.insert(it,&Endpkt);
   it++;
   punktliste.insert(it,&Startpkt);


   it = punktliste.begin();
   it2 = punktliste.begin();
   it2++;

   Start = *it;
   End = *it2;
}



/****************************************
* Zeichnet einen Grid Boden            *
****************************************/


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

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

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



    glEnable(GL_LIGHTING);
    //glPopMatrix();
}

//bool klein = true;
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;


//zeichnet die Kugel in die Szene
void sphere(void){

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

                  Start = *it;
                  End = *it2;

                  if(it==punktliste.end())
                         it = punktliste.begin();
                  else it++;
                  if(it2==punktliste.end())
                         it2 = punktliste.begin();
                  else 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;

                 SpherePos = *Start;
                }

                SpherePos.X += Dir.X;
                SpherePos.Y += Dir.Y;
                SpherePos.Z += Dir.Z;

                glTranslatef(SpherePos.X, SpherePos.Y, SpherePos.Z);

                glColor3f(0, 0.66, 0);
                glutWireSphere(0.3, 30, 3000);



}


void zeichenfunktion(void)
{

   glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

   //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(12, 12,12, 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)


   //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)
{



   //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");

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




Vielen Dank im Voraus.
Grüße
Mr

Dieser Post wurde am 11.03.2009 um 00:44 Uhr von Mr editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
11.03.2009, 17:45 Uhr
TOSHMAX



Hi,
das er zurückspringt liegt daran, dass du den StartPunkt neu setzt bevor du ihn erhöhst, dass heißt wenn er zum ersten Mal an einem Punkt ankommt bekommt er zuerst den gleichen Punkt zugewiesen und erst dann wird dieser Punkt erhöht.

Gruß
TOSHMAX
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
009
12.03.2009, 00:49 Uhr
Mr



Danke!!! Dumm von mir, habe es irgendwie übersehen.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 < [ 2 ]     [ 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: