Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/branches/blink/src/util/track/track.cc

Last change on this file was 10454, checked in by patrick, 18 years ago

track now got constant speed

File size: 9.2 KB
Line 
1/*
2   orxonox - the future of 3D-vertical-scrollers
3
4   Copyright (C) 2006 orx
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11### File Specific:
12
13   This is anohter installment of the infamous track system. It serves for
14   temporary use only and is mainly a slimmed version of the old track.
15
16   The track is used to steer the spaceship. In this case the track will have
17   to control a PNode. The spaceship will be able to fly around this node.
18   The camera will always be focused on that point.
19
20   As we do this we have exactly the verticalscroller feeling we want.
21
22   main-programmer: Benjamin Knecht
23*/
24
25#include "util/loading/load_param.h"
26#include "track/track.h"
27
28#include "p_node.h"
29
30#include "stdincl.h"
31
32#include "debug.h"
33
34ObjectListDefinition(Track);
35// CREATE_FACTORY(Track);
36
37
38/**
39 *  standard constructor
40*/
41Track::Track()
42{
43  this->init();
44}
45
46
47/**
48 * this is a constructor for use with the xml loading file
49 * @param root xml root element for this object
50 */
51Track::Track(const TiXmlElement* root)
52{
53  this->init();
54
55  if (root != NULL)
56    this->loadParams(root);
57}
58
59
60/**
61 * initializes this class
62 */
63void Track::init()
64{
65  this->curveType = CURVE_BEZIER;
66//  this->startingTime = 0;
67  this->duration = 20;
68  this->endTime = 20;
69  this->width = 10;
70  this->curve = new BezierCurve();
71  this->trackNode = new PNode(PNode::getNullParent(), PNODE_ALL);
72  this->nodeCount = 0;
73  this->localTime = 0;
74}
75
76/**
77 *  standard destructor
78*/
79Track::~Track()
80{
81
82}
83
84
85void Track::loadParams(const TiXmlElement* root)
86{
87     LOAD_PARAM_START_CYCLE(root, element);
88     {
89           LoadParam_CYCLE(element, "addPoint", this, Track, addPoint)
90             .describe("Adds a new Point to the currently selected TrackElement");
91           LoadParam_CYCLE(element, "speed", this, Track, setSpeed)
92             .describe("Sets speed of traveling");
93           LoadParam_CYCLE(element, "mode", this, Track, setMode)
94             .describe("Sets mode of track behavior");
95     }
96     LOAD_PARAM_END_CYCLE(element);
97}
98
99
100
101/**
102 * This function adds a point with its coordinates to the track
103 * @param x
104 * @param y
105 * @param z
106 */
107void Track::addPoint(float x, float y, float z)
108{
109     this->addPointV(Vector (x,y,z));
110}
111
112
113/**
114 * This function adds a point to the track as a vector
115 * @param newPoint
116 */
117void Track::addPointV(Vector newPoint)
118{
119   this->curve->addNode(newPoint);
120   if( this->nodeCount == 0) this->trackNode->setAbsCoor(newPoint);
121   this->nodeCount++;
122   // PRINTF(0)("Point added to curve\n");
123}
124
125/**
126 * This function sets the speed of the trackNode by altering the duration
127 * of the time the trackNode travels on the whole track. This is bad because
128 * the speed depends on the length of the curve. (by getting the curve's length
129 * this function will make a lot more sense)
130 */
131void Track::setSpeed(float speed)
132{
133     this->duration = this->duration/speed;
134     this->speed = speed;
135}
136
137/**
138 * Sets the mode of the track. 0 means wait at the end. 1 means rerun track
139 */
140void Track::setMode(int newMode)
141{
142     this->mode = newMode;
143}
144
145/**
146 * We probably doesn't even need this
147 */
148//void Track::finalize()
149//{
150//   for (int i = 1; i<= trackElemCount ;i++)
151//     {
152//       TrackElement* tmpElem = this->firstTrackElem->findByID(i);
153//       if( tmpElem->childCount > 0)
154//         {
155//           tIterator<TrackElement>* iterator = tmpElem->children->getIterator();
156//           TrackElement* enumElem = iterator->firstElement();
157//           //TrackElement* enumElem = tmpElem->children->enumerate();
158//           while (enumElem)
159//             {
160//
161//               // c1-continuity
162//               enumElem->curve->addNode(enumElem->curve->getNode(0) +
163//                                                    ((enumElem->curve->getNode(0) -
164//                                                     tmpElem->curve->getNode(tmpElem->curve->getNodeCount()-1))
165//                                                     ),2);
166//               enumElem->nodeCount++;
167//               // c2-continuity
168//               enumElem->curve->addNode((tmpElem->curve->getNode(tmpElem->curve->getNodeCount())-
169//                                                     tmpElem->curve->getNode(tmpElem->curve->getNodeCount()-1)) * 4 +
170//                                                    tmpElem->curve->getNode(tmpElem->curve->getNodeCount()-2), 3);
171//               enumElem->nodeCount++;
172//               PRINTF(5)("accelerations: %d-in: count: %d, %f, %f, %f\n                  %d-out: count: %d %f, %f, %f\n",
173//                      tmpElem->ID, tmpElem->nodeCount,
174//                      tmpElem->curve->calcAcc(0.999).x, tmpElem->curve->calcAcc(0.999).y, tmpElem->curve->calcAcc(0.999).z,
175//                      enumElem->ID, enumElem->nodeCount,
176//                      enumElem->curve->calcAcc(0).x, enumElem->curve->calcAcc(0).y, enumElem->curve->calcAcc(0).z);
177//
178//               enumElem = iterator->nextElement();
179//             }
180//           delete iterator;
181//         }
182//     }
183
184
185
186  /*for (int i = 1; i <= trackElemCount;i++)
187    if (this->firstTrackElem->findByID(i)->endTime > this->maxTime)
188      this->maxTime = this->firstTrackElem->findByID(i)->endTime; // very bad implemented :/
189      */
190//}
191
192Vector Track::calcPos() const
193{
194  return this->curve->calcPos(this->localTime/this->duration);
195}
196
197Vector Track::calcDir() const
198{
199  return this->curve->calcDir(this->localTime/this->duration);
200}
201
202void Track::tick(float dt)
203{
204//   PRINTF(4)("CurrentTrackID: %d, LocalTime is: %f, timestep is: %f\n", this->currentTrackElem->ID, this->localTime, dt);
205//   if (this->localTime <= this->firstTrackElem->duration)
206//     this->jumpTo(this->localTime);
207//   if (this->localTime <= this->maxTime)
208
209
210//   if (this->localTime > this->currentTrackElem->endTime
211//       && this->currentTrackElem->children)
212//     {
213//       if (this->currentTrackElem->jumpTime != 0.0)
214//         this->jumpTo(this->localTime + this->currentTrackElem->jumpTime);
215//       // jump to the next TrackElement and also set the history of the new Element to the old one.
216//       TrackElement* tmpHistoryElem = this->currentTrackElem;
217//       this->currentTrackElem = this->currentTrackElem->getChild(this->choosePath(this->currentTrackElem));
218//       this->currentTrackElem->history = tmpHistoryElem;
219//       if (this->currentTrackElem->getName())
220//         {
221//           this->trackText->setText(this->currentTrackElem->getName());
222//           this->textAnimation->replay();
223//         }
224//     }
225   if (this->trackNode)
226     {
227       // tmp save
228        float oldTime = this->localTime;
229
230        if(this->mode == 0)
231        {
232              if(this->localTime < this->duration)
233                this->localTime += dt;
234        }
235        else
236        {
237            this->localTime += dt;
238            if(this->localTime >= this->duration)
239                this->localTime = 0;
240        }
241
242       Vector tmp = this->calcPos();
243
244
245       Vector dV = tmp - this->trackNode->getAbsCoor();
246       float dx = speed * dt;
247       float ratio = dx / dV.len();
248
249       if( dt > 0.0f)
250       {
251          float newDt = dt * ratio;
252          this->localTime = oldTime += newDt;
253       }
254       tmp = this->calcPos();
255
256       Vector v(0.0, 1.0, 0.0);
257       Quaternion quat = Quaternion(this->calcDir(), v);
258       Quaternion q(-PI/2, v);
259       quat = quat * q;
260
261       // move trackNode of the track
262       this->trackNode->shiftCoor(tmp - this->trackNode->getAbsCoor());
263       // set direction and roll angle of trackNode
264       this->trackNode->setAbsDir(quat);
265     }
266}
267
268/**
269 * @returns the main TrackNode
270*/
271PNode* Track::getTrackNode()
272{
273  return this->trackNode;
274}
275
276/**
277 *  Imports a model of the Graph into the OpenGL-environment.
278 * @param dt The Iterator used in seconds for Painting the Graph.
279
280   This is for testing facility only. Do this if you want to see the Path inside the Level.
281   eventually this will all be packed into a gl-list.
282*/
283void Track::drawGraph(float dt) const
284{
285    glMatrixMode(GL_MODELVIEW);
286    glPushMatrix();
287
288    glPushAttrib(GL_ENABLE_BIT);
289
290    glDisable(GL_LIGHTING);
291    glDisable(GL_TEXTURE_2D);
292    glDisable(GL_BLEND);
293    glLineWidth(2.0);
294
295
296
297    PNode* node = PNode::getNullParent();
298    glTranslatef (node->getAbsCoor ().x,
299                  node->getAbsCoor ().y,
300                  node->getAbsCoor ().z);
301    Vector tmpRot = node->getAbsDir().getSpacialAxis();
302    glRotatef (node->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
303
304
305      glBegin(GL_LINE_STRIP);
306        glColor3f(1.0, 1.0, 0.6);
307
308        Vector tmpVector;
309        for(float f = 0.0; f < 1.0; f+=dt)
310          {
311            //PRINTF(0)("drawing",this->calcPos().x, this->calcPos().y, this->calcPos().z);
312            tmpVector = this->curve->calcPos(f);
313            glVertex3f(tmpVector.x, tmpVector.y, tmpVector.z);
314          }
315      glEnd();
316
317      glPopAttrib();
318
319    glPopMatrix();
320}
Note: See TracBrowser for help on using the repository browser.