Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/orxonox/trunk/src/camera.cc @ 3554

Last change on this file since 3554 was 3551, checked in by patrick, 20 years ago

orxonox/trunk: renamed all timing functions to tick() - cleanede up world

File size: 6.4 KB
Line 
1
2
3/*
4   orxonox - the future of 3D-vertical-scrollers
5
6   Copyright (C) 2004 orx
7
8   This program is free software; you can redistribute it and/or modify
9   it under the terms of the GNU General Public License as published by
10   the Free Software Foundation; either version 2, or (at your option)
11   any later version.
12
13   ### File Specific:
14   main-programmer: Christian Meyer
15   co-programmer: ...
16*/
17
18#include "camera.h"
19#include "world.h"
20#include "world_entity.h"
21
22using namespace std;
23
24/**
25   \brief creates a Camera
26   
27   This standard constructor sets all parameters to zero
28*/
29Camera::Camera (World* world)
30{
31  this->world = world;
32  this->bound = NULL;
33  /* give it some physical live */
34  this->m = 10;
35  this->a = new Vector(0.0, 0.0, 0.0);
36  this->v = new Vector(0.0, 0.0, 0.0);
37  this->fs = new Vector(0.0, 0.0, 0.0);
38  this->cameraMode = NORMAL;
39  this->deltaTime = 3000.0;
40  this->cameraOffset = 1.0;
41  this->cameraOffsetZ = 10.0;
42  this->t = 0.0;
43
44
45  this->setDrawable (false);
46}
47
48/**
49   \brief default destructor
50*/
51Camera::~Camera ()
52{
53  this->bound = NULL;
54  this->world = NULL;
55
56}
57
58/**
59   \brief time based actualisation of camera parameters
60   \param deltaT: The amount of time that has passed in milliseconds
61   
62   This is called by the World in every time_slice, use it to do fancy time dependant effects (such
63   as smooth camera movement or swaying).
64*/
65void Camera::tick (Uint32 deltaT)
66{
67  if( this->t <= deltaTime)
68    {this->t += deltaT;}
69  //printf("time is: t=%f\n", t );
70  updateDesiredPlace();
71  //jump(NULL);
72}
73
74/**
75   \brief this calculates the location where the track wants the camera to be
76   
77   This refreshes the placement the camera should have according to the
78   bound entity's position on the track.
79*/
80void Camera::updateDesiredPlace ()
81{
82  switch(cameraMode)
83    {
84     
85    case ELLIPTICAL:
86      {
87        /*
88        //r = actual_place.r
89        Orxonox *orx = Orxonox::getInstance();
90        Location lookat; 
91        Placement plFocus;
92        if( bound != NULL)
93          {
94            bound->getLookat (&lookat);
95            orx->getWorld()->calcCameraPos (&lookat, &plFocus);
96            Quaternion *fr;
97            if(t < 20.0)
98              {
99                Vector *start = new Vector(0.0, 1.0, 0.0);
100                r = *(new Vector(0.0, 5.0, 0.0));
101
102                Vector up(0.0, 0.0, 1.0);
103               
104                Vector op(1.0, 0.0, 0.0);
105                float angle = angleDeg(op, *start);
106                printf("angle is: %f\n", angle);
107
108                //if in one plane
109                from = new Quaternion(angle, up);
110
111                //from = new Quaternion(*start, *up);
112                //&from = &plFocus.w;
113                //fr = &plFocus.w; real quaternion use
114               
115
116
117                Vector vDirection(1.0, 0.0, 0.0);
118                //vDirection = plFocus.w.apply(vDirection);
119                to = new Quaternion(vDirection, *start);
120                res = new Quaternion();
121              }
122            //printf("vector r = %f, %f, %f\n",r.x, r.y, r.z );
123            rAbs = r.len();
124            if(t < 30)
125              {
126                ka = rAbs / deltaTime*deltaTime;
127              }
128
129            res->quatSlerp(to, from, t/deltaTime, res);
130
131            Vector ursp(0.0, 0.0, 0.0);
132            desiredPlace.r =  ursp - res->apply(r);
133
134            printf("desired place is: %f, %f, %f\n", desiredPlace.r.x, desiredPlace.r.y, desiredPlace.r.z);
135            //plLastBPlace = *bound->get_placement();
136           
137          }
138      */
139      }
140      break;
141    case SMOTH_FOLLOW:
142      {
143        /*
144        Placement *plBound = bound->getPlacement();
145        Location lcBound;
146        if(bound != null)
147          {
148            bound->getLookat(&lcBound);
149            Vector vDirection(0.0, 0.0, 1.0);
150            vDirection = plBound->w.apply(vDirection);
151            desiredPlace.r = (vDirection * ((lcBound.dist-10.0))) + Vector(0,0,5.0);
152          }
153        */
154        break;
155      }
156      /* this is a camera mode that tries just to follow the entity. */
157    case STICKY:
158      {
159        /*
160        if(bound != null)
161          {
162            Placement *plBound = bound->getPlacement();
163            Vector vDirection(0.0, 0.0, 1.0);
164            Vector eclipticOffset(0.0, 0.0, 5.0);
165            vDirection = plBound->w.apply(vDirection);
166            desiredPlace.r = plBound->r - vDirection*10 + eclipticOffset;
167          }
168        */
169        break;
170      }
171      /* the camera is handled like an entity and rolls on the track */
172    case NORMAL:
173      if( bound != NULL && world != NULL )
174        {
175          //FIXME: camera should be made via relative coordinates
176          Vector* cameraOffset = new Vector (-10, 5, 0);
177          this->setRelCoor (cameraOffset);
178        } 
179      else
180        {
181          /*
182          desiredPlace.r = Vector (0,0,0);
183          desiredPlace.w = Quaternion ();
184          */
185        }
186      break;
187    }
188}
189
190/**
191   \brief initialize rendering perspective according to this camera
192   
193   This is called immediately before the rendering cycle starts, it sets all global
194   rendering options as well as the GL_PROJECTION matrix according to the camera.
195*/
196void Camera::apply ()
197{
198  glMatrixMode (GL_PROJECTION);
199  glLoadIdentity ();
200  // view
201  // TO DO: implement options for frustum generation
202  //glFrustum(-1.0, 1.0, -1.0, 1.0, 1.5, 250.0);
203  gluPerspective(60, 1.2f, 0.1, 250);
204 
205  //Vector up(0,0,1);
206  //Vector dir(1,0,0);
207  //Quaternion q(dir,up);
208  //float matrix[4][4];
209  //q.conjugate().matrix (matrix);
210  //glMultMatrixf ((float*)matrix);
211  //glTranslatef (10,0,-5);
212  //
213  //dir = Vector(-1,-1,0);
214  //q = Quaternion( dir, up);
215  //glMatrixMode (GL_MODELVIEW);
216  //glLoadIdentity ();
217  //q.matrix (matrix);
218  //glMultMatrixf ((float*)matrix);
219  //glTranslatef (2,2,0);
220  //
221  //glBegin(GL_TRIANGLES);
222  //glColor3f(1,0,0);
223  //glVertex3f(0,0,0.5);
224  //glColor3f(0,1,0);
225  //glVertex3f(-0.5,0,-1);
226  //glColor3f(0,0,1);
227  //glVertex3f(0.5,0,-1);
228  //glEnd();   
229
230  // ===== first camera control calculation option
231  // rotation
232  float matrix[4][4];
233  //this->absDirection.conjugate().matrix (matrix);
234  /* orientation and */
235  //glMultMatrixf ((float*)matrix);
236
237  /*  translation */
238  //glTranslatef (this->absCoordinate.x, this->absCoordinate.y, this->absCoordinate.z );
239
240
241  // ===== second camera control calculation option
242 
243  gluLookAt(this->absCoordinate.x, this->absCoordinate.y, this->absCoordinate.z, 
244            this->parent->getAbsCoor ().x, this->parent->getAbsCoor ().y, this->parent->getAbsCoor ().z,
245            0.0, 1.0, 0.0);
246 
247
248  glMatrixMode (GL_MODELVIEW);
249  glLoadIdentity ();
250}
251
252
253
254/**
255  \brief bind the camera to an entity
256  \param entity: The enitity to bind the camera to
257       
258  This sets the focus of the camera to the given entity. This means that it will use the given WorldEntity's
259  Location and get_lookat() to determine the viewpoint the camera will render from.
260  Note that you cannot bind a camera to a free entity.
261*/
262void Camera::bind (WorldEntity* entity)
263{
264  if( entity != NULL)
265    {
266      if( entity->isFree()) printf("Cannot bind camera to free entity");
267      else 
268        {
269          this->bound = entity;
270        }
271    } 
272}
273
274
275void Camera::setWorld(World* world)
276{
277  this->world = world;
278}
279
280
Note: See TracBrowser for help on using the repository browser.