Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

vuParallelCamera.cpp

Go to the documentation of this file.
00001 #ifdef WIN32
00002 //for proper inclusion of gl.h glu.h
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 //#include "vuMatrix.h"
00013 #include "vuParallelCamera.h"
00014 
00015 // Default constructor - set initial values
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 // Copy constructor
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 // Destructor
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); // this double recasting is something stupid.
00095                                 // without it, the code won't compile under windows,
00096                                 // but with it, it will, so that's why it's here.
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);   // this double recasting is something stupid.
00111                                 // without it, the code won't compile under windows,
00112                                 // but with it, it will, so that's why it's here.
00113 
00114         m_IsChanged = true;
00115 }
00116 
00117 float vuParallelCamera::getFar ()
00118 
00119 {
00120         return m_Far;
00121 }
00122 
00123 // Compute the following:
00124 //      m_XStep   - the distance between adjacent x pixels
00125 //      m_YStep   - the distance between adjacent y pixels
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   // Generate topleft, xstep, and ystep
00134   // m *vuVector(1,1,-1)
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 // Get the ray through pixel (xpixel, ypixel)
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 // Assignment operator
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 //#if defined (NVIDIA_EXT)
00188   ::glOrtho(-m_XRange/2,m_XRange/2,-m_YRange/2,m_YRange/2,m_Near,m_Far);
00189 //#endif
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);              // up
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 //      if (++line_number < int (lines.size ()))
00344         if (IsNextAvailable ())
00345                 return RestoreShot (lines [++line_number]);
00346 
00347         return -1;
00348 }
00349 
00350 int vuParallelCamera::RestorePreviousShot ()
00351 
00352 {
00353 //      if (++line_number < int (lines.size ()))
00354         if (IsNextAvailable ())
00355                 return RestoreShot (lines [--line_number]);
00356 
00357         return -1;
00358 }
00359 
00360 //the D1.00 is to signify that this is the first type that is written (in case the data changes, you don't want to
00361 // try to pass an old type through into a newer one.
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                 // These four are the basic things that
00418                 // are in vuCamera.
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 //      temp_cam.setRightVector (m_RightVector * t);
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                 // already done
00431 //      temp_cam.setXScale (m_XScale * t);
00432 //      temp_cam.setYScale (m_YScale * t);
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                 // These four are the basic things that
00446                 // are in vuCamera.
00447         setPosition (m_Position *= t);
00448         setUpVector (m_UpVector *= t);
00449         setLookAtVector (m_LookAtVector *= t);
00450 //emp_cam.setRightVector (m_RightVector *= t);
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                 // already done
00462 //      temp_cam.setXScale (m_XScale *= t);
00463 //      temp_cam.setYScale (m_YScale *= t);
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                 // These four are the basic things that
00479                 // are in vuCamera.
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 //      temp_cam.setRightVector (cam.m_RightVector * t);
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                 // already done
00492 //      temp_cam.setXScale (cam.m_XScale * t);
00493 //      temp_cam.setYScale (cam.m_YScale * t);
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                 // These four are the basic things that
00508                 // are in vuCamera.
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 //      temp_cam.setRightVector (m_RightVector * t);
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                 // already done
00521 //      temp_cam.setXScale (m_XScale * t);
00522 //      temp_cam.setYScale (m_YScale * t);
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                 // These four are the basic things that
00536                 // are in vuCamera.
00537         setPosition (m_Position += rhs.getPosition ());
00538         setUpVector (m_UpVector += rhs.getUpVector ());
00539         setLookAtVector (m_LookAtVector += rhs.getLookAtVector ());
00540 //      temp_cam.setRightVector (m_RightVector * t);
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                 // already done
00549 //      temp_cam.setXScale (m_XScale * t);
00550 //      temp_cam.setYScale (m_YScale * t);
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                 // These four are the basic things that
00566                 // are in vuCamera.
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 //      temp_cam.setRightVector (m_RightVector * t);
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                 // already done
00579 //      temp_cam.setXScale (m_XScale * t);
00580 //      temp_cam.setYScale (m_YScale * t);
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                 // These four are the basic things that
00594                 // are in vuCamera.
00595         setPosition (m_Position += rhs->getPosition ());
00596         setUpVector (m_UpVector += rhs->getUpVector ());
00597         setLookAtVector (m_LookAtVector += rhs->getLookAtVector ());
00598 //      temp_cam.setRightVector (m_RightVector * t);
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                 // already done
00607 //      temp_cam.setXScale (m_XScale * t);
00608 //      temp_cam.setYScale (m_YScale * t);
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 

Generated on Wed Dec 15 21:20:35 2004 for vuVolume by  doxygen 1.3.9.1