00001 #ifdef WIN32
00002
00003 #include <windows.h>
00004 #endif
00005
00006 #include <string.h>
00007 #include <math.h>
00008 #include <iostream.h>
00009 #include <GL/gl.h>
00010
00011 #include "vuCamera.h"
00012
00013 #include "vuParallelCamera.h"
00014
00015
00016 vuParallelCamera::vuParallelCamera() :
00017 m_Near(0), m_Far(1000)
00018 {
00019 m_Position = vuVector(0,0,0);
00020 m_LookAtVector = vuVector(0,0,-1);
00021 m_UpVector = vuVector(0,1,0);
00022 setXRange(320);
00023 setYRange(240);
00024
00025 fp = NULL;
00026 m_IsRecording = 0;
00027 line_number = 0;
00028
00029 m_IsChanged = true;
00030 }
00031
00032
00033 vuParallelCamera::vuParallelCamera(const vuParallelCamera& c)
00034 {
00035 m_Position = c.m_Position;
00036 m_LookAtVector = c.m_LookAtVector;
00037 m_UpVector = c.m_UpVector;
00038 m_Width = c.m_Width;
00039 m_Height = c.m_Height;
00040 m_XRange = c.m_XRange;
00041 m_YRange = c.m_YRange;
00042 m_XScale = c.m_XScale;
00043 m_YScale = c.m_YScale;
00044 m_XStep = c.m_XStep;
00045 m_YStep = c.m_YStep;
00046
00047 fp = NULL;
00048 m_IsRecording = 0;
00049 line_number = 0;
00050
00051 m_IsChanged = true;
00052 }
00053
00054
00055 vuParallelCamera::~vuParallelCamera()
00056 {
00057 clear_lines ();
00058 }
00059
00060 float vuParallelCamera::getXRange(void)
00061 {
00062 return m_XRange;
00063 }
00064
00065 void vuParallelCamera::setXRange(float xrng)
00066 {
00067 if(xrng == 0.0)
00068 throw "Camera has zero x-range!\n";
00069 m_XRange = xrng;
00070 m_XScale = m_Width/m_XRange;
00071
00072 m_IsChanged = true;
00073 }
00074
00075
00076 float vuParallelCamera::getYRange(void)
00077 {
00078 return m_YRange;
00079 }
00080
00081 void vuParallelCamera::setYRange(float yrng)
00082 {
00083 if(yrng == 0.0)
00084 throw "Camera has zero y-range!\n";
00085 m_YRange = yrng;
00086 m_YScale = m_Height/m_YRange;
00087
00088 m_IsChanged = true;
00089 }
00090
00091 void vuParallelCamera::setNear (float near)
00092
00093 {
00094 m_Near = double (near);
00095
00096
00097
00098 m_IsChanged = true;
00099 }
00100
00101 float vuParallelCamera::getNear ()
00102
00103 {
00104 return m_Near;
00105 }
00106
00107 void vuParallelCamera::setFar (float far)
00108
00109 {
00110 m_Far = double (far);
00111
00112
00113
00114 m_IsChanged = true;
00115 }
00116
00117 float vuParallelCamera::getFar ()
00118
00119 {
00120 return m_Far;
00121 }
00122
00123
00124
00125
00126 void vuParallelCamera::init(void)
00127 {
00128 if (m_Width<0)
00129 throw "CAMERA: width of view plane must be 0 or more pixels.";
00130 if (m_Height<0)
00131 throw "CAMERA: height of view plane must be 0 or more pixels.";
00132
00133
00134
00135
00136 vuVector right = m_RightVector;
00137 vuVector lookAt = m_LookAtVector;
00138 vuVector up = lookAt.cross(right);
00139
00140 right.makeUnit();
00141 up.makeUnit();
00142 lookAt.makeUnit();
00143
00144 m_XStep = right * (m_XRange / m_Width);
00145 m_YStep = up * (m_YRange / m_Height);
00146
00147 m_IsChanged = true;
00148 }
00149
00150
00151 vuRay vuParallelCamera::getRay(float xpixel, float ypixel)
00152 {
00153 xpixel -= m_Width/2;
00154 ypixel -= m_Height/2;
00155
00156 vuVector pos = m_Position + xpixel * m_XStep + ypixel * m_YStep;
00157 vuRay r;
00158
00159 r.m_Position = pos;
00160 r.m_Direction = m_LookAtVector;
00161
00162 return r;
00163 }
00164
00165
00166 vuParallelCamera& vuParallelCamera::operator=(const vuParallelCamera& rhs)
00167 {
00168 if (this == &rhs)
00169 return *this;
00170 m_Position = rhs.m_Position;
00171 m_LookAtVector = rhs.m_LookAtVector;
00172 m_UpVector = rhs.m_UpVector;
00173
00174 m_Width = rhs.m_Width;
00175 m_Height = rhs.m_Height;
00176 m_XStep = rhs.m_XStep;
00177 m_YStep = rhs.m_YStep;
00178
00179 m_IsChanged = true;
00180
00181 return *this;
00182 }
00183
00184 void vuParallelCamera::glInit()
00185
00186 {
00187
00188 ::glOrtho(-m_XRange/2,m_XRange/2,-m_YRange/2,m_YRange/2,m_Near,m_Far);
00189
00190 }
00191
00192 float vuParallelCamera::getDistance(const vuVector& point) const
00193 {
00194 return (point-m_Position).dot(m_LookAtVector);
00195 }
00196
00197 vuVector& vuParallelCamera::project(vuVector& point) const
00198 {
00199 vuVector a,r,u;
00200 u = m_RightVector.cross(m_LookAtVector);
00201 point -= m_Position;
00202 float dist = point.dot(m_LookAtVector);
00203 float px = point.dot(m_RightVector)*m_XScale;
00204 float py = point.dot(u)*m_YScale;
00205 float *v = point.getData();
00206 v[0]=px; v[1]=py; v[2]=dist;
00207 return point;
00208 }
00209
00210 void vuParallelCamera::TakeSnapShot (char* Shot)
00211
00212 {
00213 TakeSnapShotBasic (Shot);
00214 char temp [512];
00215
00216 TakeSnapShotOrtho (temp);
00217 strcat (Shot, ", ");
00218 strcat (Shot, temp);
00219 }
00220
00221 void vuParallelCamera::TakeSnapShot ()
00222
00223 {
00224 if (m_IsRecording)
00225
00226 {
00227 char Shot [1024];
00228
00229 TakeSnapShot (Shot);
00230
00231 fputs (Shot, fp);
00232 }
00233 }
00234
00235 void vuParallelCamera::TakeSnapShotOrtho (char* Shot)
00236
00237 {
00238 char temp [128];
00239
00240 gcvt (m_Width, 14, Shot);
00241 strcat (Shot, ", ");
00242
00243 gcvt (m_Height, 14, temp);
00244 strcat (Shot, temp);
00245 strcat (Shot, ", ");
00246
00247 gcvt (m_XRange, 14, temp);
00248 strcat (Shot, temp);
00249 strcat (Shot, ", ");
00250
00251 gcvt (m_YRange, 14, temp);
00252 strcat (Shot, temp);
00253 strcat (Shot, ", ");
00254
00255 strcat (Shot, ", ");
00256 gcvt (m_XScale, 14, temp);
00257 strcat (Shot, temp);
00258 strcat (Shot, ", ");
00259
00260 gcvt (m_YScale, 14, temp);
00261 strcat (Shot, temp);
00262 strcat (Shot, ", ");
00263
00264 gcvt (m_Near, 14, temp);
00265 strcat (Shot, temp);
00266 strcat (Shot, ", ");
00267
00268 gcvt (m_Far, 14, temp);
00269 strcat (Shot, temp);
00270
00271 strcat (Shot, "), (\0");
00272 m_XStep.save (temp);
00273 strcat (Shot, temp);
00274 strcat (Shot, "), (\0");
00275
00276 m_YStep.save (temp);
00277 strcat (Shot, temp);
00278 strcat (Shot, ")\n\0");
00279 }
00280
00281 int vuParallelCamera::RestoreShot (char* Shot)
00282
00283 {
00284 int position = RestoreShotBasic (Shot);
00285
00286 position += get_next_comma (&(Shot [position])) + 1;
00287 position += clear_blanks (&(Shot [position]));
00288
00289 return position + RestoreShotOrtho (&(Shot [position]));
00290 }
00291
00292 int vuParallelCamera::RestoreShotOrtho (char* Shot)
00293
00294 {
00295 int position;
00296
00297 m_Width = int (atof (Shot));
00298 position = get_next_comma (Shot) + 1;
00299 position += clear_blanks (&(Shot [position]));
00300
00301 m_Height = int (atof (&(Shot [position])));
00302 position += get_next_comma (Shot) + 1;
00303 position += clear_blanks (&(Shot [position]));
00304
00305 m_XRange = atof (&(Shot [position]));
00306 position += get_next_comma (Shot) + 1;
00307 position += clear_blanks (&(Shot [position]));
00308
00309 m_YRange = atof (&(Shot [position]));
00310 position += get_next_comma (Shot) + 1;
00311 position += clear_blanks (&(Shot [position]));
00312
00313 m_XScale = atof (&(Shot [position]));
00314 position += get_next_comma (Shot) + 1;
00315 position += clear_blanks (&(Shot [position]));
00316
00317 m_YScale = atof (&(Shot [position]));
00318 position += get_next_comma (Shot) + 1;
00319 position += clear_blanks (&(Shot [position]));
00320
00321 m_Near = atof (&(Shot [position]));
00322 position += get_next_comma (Shot) + 1;
00323 position += clear_blanks (&(Shot [position]));
00324
00325 m_Far = atof (&(Shot [position]));
00326 position += get_next_comma (Shot) + 1;
00327 position += clear_blanks (&(Shot [position]));
00328
00329 position += get_next_open (&(Shot [position])) + 1;
00330 m_XStep.load (&(Shot [position]));
00331 position += get_next_close (&(Shot [position])) + 1;
00332
00333 position += get_next_open (&(Shot [position])) + 1;
00334 m_YStep.load (&(Shot [position]));
00335 position += get_next_close (&(Shot [position])) + 1;
00336
00337 return position;
00338 }
00339
00340 int vuParallelCamera::RestoreNextShot ()
00341
00342 {
00343
00344 if (IsNextAvailable ())
00345 return RestoreShot (lines [++line_number]);
00346
00347 return -1;
00348 }
00349
00350 int vuParallelCamera::RestorePreviousShot ()
00351
00352 {
00353
00354 if (IsNextAvailable ())
00355 return RestoreShot (lines [--line_number]);
00356
00357 return -1;
00358 }
00359
00360
00361
00362 char id_string_cgs_xq3 [] = "vuParallelCameraD1.00__";
00363
00364 char* vuParallelCamera::get_id ()
00365
00366 {
00367 return id_string_cgs_xq3;
00368 }
00369
00370 bool vuParallelCamera::verify_id (char* id)
00371
00372 {
00373 return (strncmp (get_id (), id, strlen (get_id ())));
00374 }
00375
00376 ostream& operator<<(ostream& out, vuParallelCamera &cam)
00377
00378 {
00379 char Shot [1024];
00380
00381 cam.TakeSnapShot (Shot);
00382
00383 out << Shot;
00384
00385 return out;
00386 }
00387
00388 istream& operator>>(istream& in, vuParallelCamera &cam)
00389
00390 {
00391 char Shot [1024];
00392
00393 in >> Shot;
00394
00395 cam.RestoreShot (Shot);
00396
00397 cam.m_IsChanged = true;
00398
00399 return in;
00400 }
00401
00402 vuCamera* vuParallelCamera::create_new ()
00403
00404 {
00405 vuParallelCamera* ptr = new vuParallelCamera [1];
00406
00407 return (vuCamera *) (ptr);
00408 }
00409
00410 vuParallelCamera temp_cam_vpac_cgs__;
00411
00412 vuCamera* vuParallelCamera::operator* (float t)
00413
00414 {
00415 vuParallelCamera* temp_cam_vpac_cgs__ = (vuParallelCamera *) (create_new ());
00416
00417
00418
00419 temp_cam_vpac_cgs__->setPosition (m_Position * t);
00420 temp_cam_vpac_cgs__->setUpVector (m_UpVector * t);
00421 temp_cam_vpac_cgs__->setLookAtVector (m_LookAtVector * t);
00422
00423
00424 temp_cam_vpac_cgs__->setWidth((int)(m_Width*t));
00425 temp_cam_vpac_cgs__->setHeight((int)(m_Height*t));
00426
00427 temp_cam_vpac_cgs__->setXRange (m_XRange * t);
00428 temp_cam_vpac_cgs__->setYRange (m_YRange * t);
00429
00430
00431
00432
00433
00434 temp_cam_vpac_cgs__->setNear (m_Near * t);
00435 temp_cam_vpac_cgs__->setFar (m_Far * t);
00436
00437 m_IsChanged = true;
00438
00439 return temp_cam_vpac_cgs__;
00440 }
00441
00442 vuCamera* vuParallelCamera::operator*= (float t)
00443
00444 {
00445
00446
00447 setPosition (m_Position *= t);
00448 setUpVector (m_UpVector *= t);
00449 setLookAtVector (m_LookAtVector *= t);
00450
00451
00452 m_Width = (int)(m_Width * t);
00453 m_Height = (int)(m_Height * t);
00454
00455 setWidth(m_Width);
00456 setHeight(m_Height);
00457
00458 setXRange (m_XRange *= t);
00459 setYRange (m_YRange *= t);
00460
00461
00462
00463
00464
00465 setNear (m_Near *= t);
00466 setFar (m_Far *= t);
00467
00468 m_IsChanged = true;
00469
00470 return (vuCamera *) (this);
00471 }
00472
00473 vuCamera* operator* (float t, vuParallelCamera &cam)
00474
00475 {
00476 vuParallelCamera* temp_cam_vpac_cgs__ = (vuParallelCamera *) (cam.create_new ());
00477
00478
00479
00480 temp_cam_vpac_cgs__->setPosition (cam.m_Position * t);
00481 temp_cam_vpac_cgs__->setUpVector (cam.m_UpVector * t);
00482 temp_cam_vpac_cgs__->setLookAtVector (cam.m_LookAtVector * t);
00483
00484
00485 temp_cam_vpac_cgs__->setWidth ((int)(cam.m_Width * t));
00486 temp_cam_vpac_cgs__->setHeight ((int)(cam.m_Height * t));
00487
00488 temp_cam_vpac_cgs__->setXRange (cam.m_XRange * t);
00489 temp_cam_vpac_cgs__->setYRange (cam.m_YRange * t);
00490
00491
00492
00493
00494
00495 temp_cam_vpac_cgs__->setNear (cam.m_Near * t);
00496 temp_cam_vpac_cgs__->setFar (cam.m_Far * t);
00497
00498 return (vuCamera *) (temp_cam_vpac_cgs__);
00499 }
00500
00501
00502 vuCamera* vuParallelCamera::operator+ (vuParallelCamera &rhs)
00503
00504 {
00505 vuParallelCamera* temp_cam_vpac_cgs__ = (vuParallelCamera *) (create_new ());
00506
00507
00508
00509 temp_cam_vpac_cgs__->setPosition (m_Position + rhs.getPosition ());
00510 temp_cam_vpac_cgs__->setUpVector (m_UpVector + rhs.getUpVector ());
00511 temp_cam_vpac_cgs__->setLookAtVector (m_LookAtVector + rhs.getLookAtVector ());
00512
00513
00514 temp_cam_vpac_cgs__->setWidth (m_Width + rhs.getWidth ());
00515 temp_cam_vpac_cgs__->setHeight (m_Height + rhs.getHeight ());
00516
00517 temp_cam_vpac_cgs__->setXRange (m_XRange + rhs.getXRange ());
00518 temp_cam_vpac_cgs__->setYRange (m_YRange + rhs.getYRange ());
00519
00520
00521
00522
00523
00524 temp_cam_vpac_cgs__->setNear (m_Near + rhs.getNear ());
00525 temp_cam_vpac_cgs__->setFar (m_Far + rhs.getFar ());
00526
00527 m_IsChanged = true;
00528
00529 return (vuCamera* ) (temp_cam_vpac_cgs__);
00530 }
00531
00532 vuCamera* vuParallelCamera::operator+= (vuParallelCamera &rhs)
00533
00534 {
00535
00536
00537 setPosition (m_Position += rhs.getPosition ());
00538 setUpVector (m_UpVector += rhs.getUpVector ());
00539 setLookAtVector (m_LookAtVector += rhs.getLookAtVector ());
00540
00541
00542 setWidth (m_Width += rhs.getWidth ());
00543 setHeight (m_Height += rhs.getHeight ());
00544
00545 setXRange (m_XRange += rhs.getXRange ());
00546 setYRange (m_YRange + rhs.getYRange ());
00547
00548
00549
00550
00551
00552 setNear (m_Near += rhs.getNear ());
00553 setFar (m_Far += rhs.getFar ());
00554
00555 m_IsChanged = true;
00556
00557 return (vuCamera *) (this);
00558 }
00559
00560 vuCamera* vuParallelCamera::operator+ (vuParallelCamera *rhs)
00561
00562 {
00563 vuParallelCamera* temp_cam_vpac_cgs__ = (vuParallelCamera *) (create_new ());
00564
00565
00566
00567 temp_cam_vpac_cgs__->setPosition (m_Position + rhs->getPosition ());
00568 temp_cam_vpac_cgs__->setUpVector (m_UpVector + rhs->getUpVector ());
00569 temp_cam_vpac_cgs__->setLookAtVector (m_LookAtVector + rhs->getLookAtVector ());
00570
00571
00572 temp_cam_vpac_cgs__->setWidth (m_Width + rhs->getWidth ());
00573 temp_cam_vpac_cgs__->setHeight (m_Height + rhs->getHeight ());
00574
00575 temp_cam_vpac_cgs__->setXRange (m_XRange + rhs->getXRange ());
00576 temp_cam_vpac_cgs__->setYRange (m_YRange + rhs->getYRange ());
00577
00578
00579
00580
00581
00582 temp_cam_vpac_cgs__->setNear (m_Near + rhs->getNear ());
00583 temp_cam_vpac_cgs__->setFar (m_Far + rhs->getFar ());
00584
00585 m_IsChanged = true;
00586
00587 return (vuCamera *) (temp_cam_vpac_cgs__);
00588 }
00589
00590 vuCamera* vuParallelCamera::operator+= (vuParallelCamera *rhs)
00591
00592 {
00593
00594
00595 setPosition (m_Position += rhs->getPosition ());
00596 setUpVector (m_UpVector += rhs->getUpVector ());
00597 setLookAtVector (m_LookAtVector += rhs->getLookAtVector ());
00598
00599
00600 setWidth (m_Width += rhs->getWidth ());
00601 setHeight (m_Height += rhs->getHeight ());
00602
00603 setXRange (m_XRange += rhs->getXRange ());
00604 setYRange (m_YRange += rhs->getYRange ());
00605
00606
00607
00608
00609
00610 setNear (m_Near += rhs->getNear ());
00611 setFar (m_Far += rhs->getFar ());
00612
00613 m_IsChanged = true;
00614
00615 return (vuCamera *) (this);
00616 }
00617
00618 vuCamera* vuParallelCamera::set_equal_to_interp (vuCamera* cam1, vuCamera* cam2, float t1, float t2)
00619
00620 {
00621 vuParallelCamera *pcam1 = (vuParallelCamera *) (cam1);
00622 vuParallelCamera *pcam2 = (vuParallelCamera *) (cam2);
00623
00624 m_Position = pcam1->getPosition () * t1;
00625 m_UpVector = pcam1->getUpVector () * t1;
00626 m_LookAtVector = pcam1->getLookAtVector () * t1;
00627 m_RightVector = pcam1->getRightVector () * t1;
00628
00629 m_Width = (int)(pcam1->m_Width *t1 + pcam2->m_Width*t2);
00630 m_Height = (int)(pcam1->m_Height*t1 + pcam2->m_Height*t2);
00631
00632 m_XStep = pcam1->m_XStep * t1;
00633 m_YStep = pcam1->m_YStep * t1;
00634
00635 m_XRange = pcam1->getXRange () * t1;
00636 m_YRange = pcam1->getYRange () * t1;
00637 m_Near = pcam1->getNear () * t1;
00638 m_Far = pcam1->getFar () * t1;
00639
00640 m_Position += pcam2->getPosition () * t2;
00641 m_UpVector += pcam2->getUpVector () * t2;
00642 m_LookAtVector += pcam2->getLookAtVector () * t2;
00643 m_RightVector += pcam2->getRightVector () * t2;
00644
00645 m_XRange += pcam2->getXRange () * t2;
00646 m_YRange += pcam2->getYRange () * t2;
00647 m_Near += pcam2->getNear () * t2;
00648 m_Far += pcam2->getFar () * t2;
00649
00650 m_XStep += pcam1->m_XStep * t2;
00651 m_YStep += pcam1->m_YStep * t2;
00652
00653 return (vuCamera *) (this);
00654 }
00655
00656 vuParallelCamera* vuParallelCamera::operator= (vuParallelCamera *rhs)
00657
00658 {
00659 m_Position = rhs->getPosition ();
00660 m_UpVector = rhs->getUpVector ();
00661 m_LookAtVector = rhs->getLookAtVector ();
00662 m_RightVector = rhs->getRightVector ();
00663
00664 m_Width = rhs->getWidth ();
00665 m_Height = rhs->getHeight ();
00666 m_XRange = rhs->getXRange ();
00667 m_YRange = rhs->getYRange ();
00668 m_Near = rhs->getNear ();
00669 m_Far = rhs->getFar ();
00670 m_XStep = rhs->m_XStep;
00671 m_YStep = rhs->m_YStep;
00672
00673 m_IsChanged = true;
00674
00675 return this;
00676 }
00677
00678
00679
00680
00681
00682
00683
00684