src/Graphic3d/Graphic3d_Camera.cxx

   1 // Created on: 2013-05-29
   2 // Created by: Anton POLETAEV
   3 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   4 //
   5 // This file is part of Open CASCADE Technology software library.
   6 //
   7 // This library is free software; you can redistribute it and/or modify it under
   8 // the terms of the GNU Lesser General Public License version 2.1 as published
   9 // by the Free Software Foundation, with special exception defined in the file
  10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  11 // distribution for complete text of the license and disclaimer of any warranty.
  12 //
  13 // Alternatively, this file may be used under the terms of Open CASCADE
  14 // commercial license or contractual agreement.
  15
  16 #include <Graphic3d_Camera.hxx>
  17
  18 #include <gp_Pln.hxx>
  19 #include <gp_QuaternionNLerp.hxx>
  20 #include <gp_QuaternionSLerp.hxx>
  21 #include <Graphic3d_Vec4.hxx>
  22 #include <Graphic3d_WorldViewProjState.hxx>
  23 #include <NCollection_Sequence.hxx>
  24 #include <Standard_ShortReal.hxx>
  25 #include <Standard_Atomic.hxx>
  26 #include <Standard_Assert.hxx>
  27
  28 IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_Camera,Standard_Transient)
  29
  30 namespace
  31 {
  32   // (degrees -> radians) * 0.5
  33   static const Standard_Real DTR_HALF = 0.5 * 0.0174532925;
  34
  35   // default property values
  36   static const Standard_Real DEFAULT_ZNEAR = 0.001;
  37   static const Standard_Real DEFAULT_ZFAR  = 3000.0;
  38
  39   // atomic state counter
  40   static volatile Standard_Integer THE_STATE_COUNTER = 0;
  41
  42   // z-range tolerance compatible with for floating point.
  43   static Standard_Real zEpsilon()
  44   {
  45     return FLT_EPSILON;
  46   }
  47
  48   // relative z-range tolerance compatible with for floating point.
  49   static Standard_Real zEpsilon (const Standard_Real theValue)
  50   {
  51     Standard_Real anAbsValue = Abs (theValue);
  52     if (anAbsValue <= (double)FLT_MIN)
  53     {
  54       return FLT_MIN;
  55     }
  56     Standard_Real aLogRadix = Log10 (anAbsValue) / Log10 (FLT_RADIX);
  57     Standard_Real aExp = Floor (aLogRadix);
  58     return FLT_EPSILON * Pow (FLT_RADIX, aExp);
  59   }
  60
  61   //! Convert camera definition to Ax3
  62   gp_Ax3 cameraToAx3 (const Graphic3d_Camera& theCamera)
  63   {
  64     const gp_Dir aBackDir = -theCamera.Direction();
  65     const gp_Dir anXAxis (theCamera.Up().Crossed (aBackDir));
  66     const gp_Dir anYAxis (aBackDir      .Crossed (anXAxis));
  67     const gp_Dir aZAxis  (anXAxis       .Crossed (anYAxis));
  68     return gp_Ax3 (gp_Pnt (0.0, 0.0, 0.0), aZAxis, anXAxis);
  69   }
  70 }
  71
  72 // =======================================================================
  73 // function : Graphic3d_Camera
  74 // purpose  :
  75 // =======================================================================
  76 Graphic3d_Camera::Graphic3d_Camera()
  77 : myUp (0.0, 1.0, 0.0),
  78   myDirection (0.0, 0.0, 1.0),
  79   myEye (0.0, 0.0, -1500.0),
  80   myDistance (1500.0),
  81   myAxialScale (1.0, 1.0, 1.0),
  82   myProjType (Projection_Orthographic),
  83   myFOVy (45.0),
  84   myFOVx (45.0),
  85   myFOV2d (180.0),
  86   myFOVyTan (Tan (DTR_HALF * 45.0)),
  87   myZNear (DEFAULT_ZNEAR),
  88   myZFar (DEFAULT_ZFAR),
  89   myAspect (1.0),
  90   myScale (1000.0),
  91   myZFocus (1.0),
  92   myZFocusType (FocusType_Relative),
  93   myIOD (0.05),
  94   myIODType (IODType_Relative),
  95   myIsCustomProjMatM (false),
  96   myIsCustomProjMatLR(false),
  97   myIsCustomFrustomLR(false)
  98 {
  99   myWorldViewProjState.Initialize ((Standard_Size)Standard_Atomic_Increment (&THE_STATE_COUNTER),
 100                                    (Standard_Size)Standard_Atomic_Increment (&THE_STATE_COUNTER),
 101                                    this);
 102 }
 103
 104 // =======================================================================
 105 // function : Graphic3d_Camera
 106 // purpose  :
 107 // =======================================================================
 108 Graphic3d_Camera::Graphic3d_Camera (const Handle(Graphic3d_Camera)& theOther)
 109 : myUp (0.0, 1.0, 0.0),
 110   myDirection (0.0, 0.0, 1.0),
 111   myEye (0.0, 0.0, -1500.0),
 112   myDistance (1500.0),
 113   myAxialScale (1.0, 1.0, 1.0),
 114   myProjType (Projection_Orthographic),
 115   myFOVy (45.0),
 116   myFOVx (45.0),
 117   myFOV2d (180.0),
 118   myFOVyTan (Tan (DTR_HALF * 45.0)),
 119   myZNear (DEFAULT_ZNEAR),
 120   myZFar (DEFAULT_ZFAR),
 121   myAspect (1.0),
 122   myScale (1000.0),
 123   myZFocus (1.0),
 124   myZFocusType (FocusType_Relative),
 125   myIOD (0.05),
 126   myIODType (IODType_Relative),
 127   myIsCustomProjMatM (false),
 128   myIsCustomProjMatLR(false),
 129   myIsCustomFrustomLR(false)
 130 {
 131   myWorldViewProjState.Initialize (this);
 132
 133   Copy (theOther);
 134 }
 135
 136 // =======================================================================
 137 // function : CopyMappingData
 138 // purpose  :
 139 // =======================================================================
 140 void Graphic3d_Camera::CopyMappingData (const Handle(Graphic3d_Camera)& theOtherCamera)
 141 {
 142   SetProjectionType (theOtherCamera->ProjectionType());
 143   SetFOVy           (theOtherCamera->FOVy());
 144   SetFOV2d          (theOtherCamera->FOV2d());
 145   SetZRange         (theOtherCamera->ZNear(), theOtherCamera->ZFar());
 146   SetAspect         (theOtherCamera->Aspect());
 147   SetScale          (theOtherCamera->Scale());
 148   SetZFocus         (theOtherCamera->ZFocusType(), theOtherCamera->ZFocus());
 149   SetIOD            (theOtherCamera->GetIODType(), theOtherCamera->IOD());
 150   SetTile           (theOtherCamera->myTile);
 151
 152   ResetCustomProjection();
 153   if (theOtherCamera->IsCustomStereoProjection())
 154   {
 155     SetCustomStereoProjection (theOtherCamera->myCustomProjMatL,
 156                                theOtherCamera->myCustomHeadToEyeMatL,
 157                                theOtherCamera->myCustomProjMatR,
 158                                theOtherCamera->myCustomHeadToEyeMatR);
 159   }
 160   else if (theOtherCamera->IsCustomStereoFrustum())
 161   {
 162     SetCustomStereoFrustums (theOtherCamera->myCustomFrustumL, theOtherCamera->myCustomFrustumR);
 163   }
 164   if (theOtherCamera->IsCustomMonoProjection())
 165   {
 166     SetCustomMonoProjection (theOtherCamera->myCustomProjMatM);
 167   }
 168 }
 169
 170 // =======================================================================
 171 // function : CopyOrientationData
 172 // purpose  :
 173 // =======================================================================
 174 void Graphic3d_Camera::CopyOrientationData (const Handle(Graphic3d_Camera)& theOtherCamera)
 175 {
 176   if (!myEye.IsEqual (theOtherCamera->Eye(), 0.0)
 177    || !myUp.IsEqual (theOtherCamera->Up(), 0.0)
 178    || !myDirection.IsEqual (theOtherCamera->Direction(), 0.0)
 179    ||  myDistance != theOtherCamera->Distance())
 180   {
 181     myEye = theOtherCamera->Eye();
 182     myUp  = theOtherCamera->Up();
 183     myDirection = theOtherCamera->Direction();
 184     myDistance = theOtherCamera->Distance();
 185     InvalidateOrientation();
 186   }
 187   SetAxialScale (theOtherCamera->AxialScale());
 188 }
 189
 190 // =======================================================================
 191 // function : Copy
 192 // purpose  :
 193 // =======================================================================
 194 void Graphic3d_Camera::Copy (const Handle(Graphic3d_Camera)& theOther)
 195 {
 196   CopyMappingData (theOther);
 197   CopyOrientationData (theOther);
 198 }
 199
 200 // =======================================================================
 201 // function : MoveEyeTo
 202 // purpose  :
 203 // =======================================================================
 204 void Graphic3d_Camera::MoveEyeTo (const gp_Pnt& theEye)
 205 {
 206   if (myEye.IsEqual (theEye, 0.0))
 207   {
 208     return;
 209   }
 210
 211   myEye = theEye;
 212   InvalidateOrientation();
 213 }
 214
 215 // =======================================================================
 216 // function : SetEyeAndCenter
 217 // purpose  :
 218 // =======================================================================
 219 void Graphic3d_Camera::SetEyeAndCenter (const gp_Pnt& theEye,
 220                                         const gp_Pnt& theCenter)
 221 {
 222   if (Eye()   .IsEqual (theEye,    0.0)
 223    && Center().IsEqual (theCenter, 0.0))
 224   {
 225     return;
 226   }
 227
 228   myEye = theEye;
 229   myDistance = theEye.Distance (theCenter);
 230   if (myDistance > gp::Resolution())
 231   {
 232     myDirection = gp_Dir (theCenter.XYZ() - theEye.XYZ());
 233   }
 234   InvalidateOrientation();
 235 }
 236
 237 // =======================================================================
 238 // function : SetEye
 239 // purpose  :
 240 // =======================================================================
 241 void Graphic3d_Camera::SetEye (const gp_Pnt& theEye)
 242 {
 243   if (Eye().IsEqual (theEye, 0.0))
 244   {
 245     return;
 246   }
 247
 248   const gp_Pnt aCenter = Center();
 249   myEye = theEye;
 250   myDistance = myEye.Distance (aCenter);
 251   if (myDistance > gp::Resolution())
 252   {
 253     myDirection = gp_Dir (aCenter.XYZ() - myEye.XYZ());
 254   }
 255   InvalidateOrientation();
 256 }
 257
 258 // =======================================================================
 259 // function : SetCenter
 260 // purpose  :
 261 // =======================================================================
 262 void Graphic3d_Camera::SetCenter (const gp_Pnt& theCenter)
 263 {
 264   const Standard_Real aDistance = myEye.Distance (theCenter);
 265   if (myDistance == aDistance)
 266   {
 267     return;
 268   }
 269
 270   myDistance = aDistance;
 271   if (myDistance > gp::Resolution())
 272   {
 273     myDirection = gp_Dir (theCenter.XYZ() - myEye.XYZ());
 274   }
 275   InvalidateOrientation();
 276 }
 277
 278 // =======================================================================
 279 // function : SetUp
 280 // purpose  :
 281 // =======================================================================
 282 void Graphic3d_Camera::SetUp (const gp_Dir& theUp)
 283 {
 284   if (Up().IsEqual (theUp, 0.0))
 285   {
 286     return;
 287   }
 288
 289   myUp = theUp;
 290   InvalidateOrientation();
 291 }
 292
 293 // =======================================================================
 294 // function : SetAxialScale
 295 // purpose  :
 296 // =======================================================================
 297 void Graphic3d_Camera::SetAxialScale (const gp_XYZ& theAxialScale)
 298 {
 299   if (AxialScale().IsEqual (theAxialScale, 0.0))
 300   {
 301     return;
 302   }
 303
 304   myAxialScale = theAxialScale;
 305   InvalidateOrientation();
 306 }
 307
 308 // =======================================================================
 309 // function : SetDistance
 310 // purpose  :
 311 // =======================================================================
 312 void Graphic3d_Camera::SetDistance (const Standard_Real theDistance)
 313 {
 314   if (myDistance == theDistance)
 315   {
 316     return;
 317   }
 318
 319   const gp_Pnt aCenter = Center();
 320   myDistance = theDistance;
 321   myEye = aCenter.XYZ() - myDirection.XYZ() * myDistance;
 322   InvalidateOrientation();
 323 }
 324
 325 // =======================================================================
 326 // function : SetDirectionFromEye
 327 // purpose  :
 328 // =======================================================================
 329 void Graphic3d_Camera::SetDirectionFromEye (const gp_Dir& theDir)
 330 {
 331   if (myDirection.IsEqual (theDir, 0.0))
 332   {
 333     return;
 334   }
 335
 336   myDirection = theDir;
 337   InvalidateOrientation();
 338 }
 339
 340 // =======================================================================
 341 // function : SetDirection
 342 // purpose  :
 343 // =======================================================================
 344 void Graphic3d_Camera::SetDirection (const gp_Dir& theDir)
 345 {
 346   if (myDirection.IsEqual (theDir, 0.0))
 347   {
 348     return;
 349   }
 350
 351   const gp_Pnt aCenter = Center();
 352   myDirection = theDir;
 353   myEye = aCenter.XYZ() - theDir.XYZ() * myDistance;
 354   InvalidateOrientation();
 355 }
 356
 357 // =======================================================================
 358 // function : SetScale
 359 // purpose  :
 360 // =======================================================================
 361 void Graphic3d_Camera::SetScale (const Standard_Real theScale)
 362 {
 363   if (Scale() == theScale)
 364   {
 365     return;
 366   }
 367
 368   myScale = theScale;
 369
 370   switch (myProjType)
 371   {
 372     case Projection_Perspective  :
 373     case Projection_Stereo       :
 374     case Projection_MonoLeftEye  :
 375     case Projection_MonoRightEye :
 376     {
 377       Standard_Real aDistance = theScale * 0.5 / myFOVyTan;
 378       SetDistance (aDistance);
 379     }
 380
 381     default :
 382       break;
 383   }
 384
 385   InvalidateProjection();
 386 }
 387
 388 // =======================================================================
 389 // function : Scale
 390 // purpose  :
 391 // =======================================================================
 392 Standard_Real Graphic3d_Camera::Scale() const
 393 {
 394   switch (myProjType)
 395   {
 396     case Projection_Orthographic :
 397       return myScale;
 398
 399     // case Projection_Perspective  :
 400     // case Projection_Stereo       :
 401     // case Projection_MonoLeftEye  :
 402     // case Projection_MonoRightEye :
 403     default :
 404       return Distance() * 2.0 * myFOVyTan;
 405   }
 406 }
 407
 408 // =======================================================================
 409 // function : SetProjectionType
 410 // purpose  :
 411 // =======================================================================
 412 void Graphic3d_Camera::SetProjectionType (const Projection theProjectionType)
 413 {
 414   Projection anOldType = ProjectionType();
 415
 416   if (anOldType == theProjectionType)
 417   {
 418     return;
 419   }
 420
 421   if (anOldType == Projection_Orthographic)
 422   {
 423     if (myZNear <= RealEpsilon())
 424     {
 425       myZNear = DEFAULT_ZNEAR;
 426     }
 427     if (myZFar <= RealEpsilon())
 428     {
 429       myZFar = DEFAULT_ZFAR;
 430     }
 431   }
 432
 433   myProjType = theProjectionType;
 434
 435   InvalidateProjection();
 436 }
 437
 438 // =======================================================================
 439 // function : SetFOVy
 440 // purpose  :
 441 // =======================================================================
 442 void Graphic3d_Camera::SetFOVy (const Standard_Real theFOVy)
 443 {
 444   if (FOVy() == theFOVy)
 445   {
 446     return;
 447   }
 448
 449   myFOVy = theFOVy;
 450   myFOVx = theFOVy * myAspect;
 451   myFOVyTan = Tan(DTR_HALF * myFOVy);
 452
 453   InvalidateProjection();
 454 }
 455
 456 // =======================================================================
 457 // function : SetFOV2d
 458 // purpose  :
 459 // =======================================================================
 460 void Graphic3d_Camera::SetFOV2d (const Standard_Real theFOV)
 461 {
 462   if (FOV2d() == theFOV)
 463   {
 464     return;
 465   }
 466
 467   myFOV2d = theFOV;
 468   InvalidateProjection();
 469 }
 470
 471 // =======================================================================
 472 // function : SetZRange
 473 // purpose  :
 474 // =======================================================================
 475 void Graphic3d_Camera::SetZRange (const Standard_Real theZNear,
 476                                   const Standard_Real theZFar)
 477 {
 478   Standard_ASSERT_RAISE (theZFar > theZNear, "ZFar should be greater than ZNear");
 479   if (!IsOrthographic())
 480   {
 481     Standard_ASSERT_RAISE (theZNear > 0.0, "Only positive Z-Near is allowed for perspective camera");
 482     Standard_ASSERT_RAISE (theZFar  > 0.0, "Only positive Z-Far is allowed for perspective camera");
 483   }
 484
 485   if (ZNear() == theZNear
 486    && ZFar () == theZFar)
 487   {
 488     return;
 489   }
 490
 491   myZNear = theZNear;
 492   myZFar  = theZFar;
 493
 494   InvalidateProjection();
 495 }
 496
 497 // =======================================================================
 498 // function : SetAspect
 499 // purpose  :
 500 // =======================================================================
 501 void Graphic3d_Camera::SetAspect (const Standard_Real theAspect)
 502 {
 503   if (Aspect() == theAspect)
 504   {
 505     return;
 506   }
 507
 508   myAspect = theAspect;
 509   myFOVx = myFOVy * theAspect;
 510
 511   InvalidateProjection();
 512 }
 513
 514 // =======================================================================
 515 // function : SetZFocus
 516 // purpose  :
 517 // =======================================================================
 518 void Graphic3d_Camera::SetZFocus(const FocusType theType, const Standard_Real theZFocus)
 519 {
 520   if (ZFocusType() == theType
 521    && ZFocus    () == theZFocus)
 522   {
 523     return;
 524   }
 525
 526   myZFocusType = theType;
 527   myZFocus     = theZFocus;
 528
 529   InvalidateProjection();
 530 }
 531
 532 // =======================================================================
 533 // function : SetIOD
 534 // purpose  :
 535 // =======================================================================
 536 void Graphic3d_Camera::SetIOD (const IODType theType, const Standard_Real theIOD)
 537 {
 538   if (GetIODType() == theType
 539    && IOD       () == theIOD)
 540   {
 541     return;
 542   }
 543
 544   myIODType = theType;
 545   myIOD     = theIOD;
 546
 547   InvalidateProjection();
 548 }
 549
 550 // =======================================================================
 551 // function : SetTile
 552 // purpose  :
 553 // =======================================================================
 554 void Graphic3d_Camera::SetTile (const Graphic3d_CameraTile& theTile)
 555 {
 556   if (myTile == theTile)
 557   {
 558     return;
 559   }
 560
 561   myTile = theTile;
 562   InvalidateProjection();
 563 }
 564
 565 // =======================================================================
 566 // function : OrthogonalizeUp
 567 // purpose  :
 568 // =======================================================================
 569 void Graphic3d_Camera::OrthogonalizeUp()
 570 {
 571   SetUp (OrthogonalizedUp());
 572 }
 573
 574 // =======================================================================
 575 // function : OrthogonalizedUp
 576 // purpose  :
 577 // =======================================================================
 578 gp_Dir Graphic3d_Camera::OrthogonalizedUp() const
 579 {
 580   gp_Dir aDir  = Direction();
 581   gp_Dir aLeft = aDir.Crossed (Up());
 582
 583   // recompute up as: up = left x direction
 584   return aLeft.Crossed (aDir);
 585 }
 586
 587 // =======================================================================
 588 // function : Transform
 589 // purpose  :
 590 // =======================================================================
 591 void Graphic3d_Camera::Transform (const gp_Trsf& theTrsf)
 592 {
 593   if (theTrsf.Form() == gp_Identity)
 594   {
 595     return;
 596   }
 597
 598   myUp .Transform (theTrsf);
 599   myDirection.Transform (theTrsf);
 600   myEye.Transform (theTrsf);
 601   InvalidateOrientation();
 602 }
 603
 604 // =======================================================================
 605 // function : safePointCast
 606 // purpose  :
 607 // =======================================================================
 608 static Graphic3d_Vec4d safePointCast (const gp_Pnt& thePnt)
 609 {
 610   Standard_Real aLim = 1e15f;
 611
 612   // have to deal with values greater then max float
 613   gp_Pnt aSafePoint = thePnt;
 614   const Standard_Real aBigFloat = aLim * 0.1f;
 615   if (Abs (aSafePoint.X()) > aLim)
 616     aSafePoint.SetX (aSafePoint.X() >= 0 ? aBigFloat : -aBigFloat);
 617   if (Abs (aSafePoint.Y()) > aLim)
 618     aSafePoint.SetY (aSafePoint.Y() >= 0 ? aBigFloat : -aBigFloat);
 619   if (Abs (aSafePoint.Z()) > aLim)
 620     aSafePoint.SetZ (aSafePoint.Z() >= 0 ? aBigFloat : -aBigFloat);
 621
 622   // convert point
 623   Graphic3d_Vec4d aPnt (aSafePoint.X(), aSafePoint.Y(), aSafePoint.Z(), 1.0);
 624
 625   return aPnt;
 626 }
 627
 628 // =======================================================================
 629 // function : Project
 630 // purpose  :
 631 // =======================================================================
 632 gp_Pnt Graphic3d_Camera::Project (const gp_Pnt& thePnt) const
 633 {
 634   const Graphic3d_Mat4d& aViewMx = OrientationMatrix();
 635   const Graphic3d_Mat4d& aProjMx = ProjectionMatrix();
 636
 637   // use compatible type of point
 638   Graphic3d_Vec4d aPnt = safePointCast (thePnt);
 639
 640   aPnt = aViewMx * aPnt; // convert to view coordinate space
 641   aPnt = aProjMx * aPnt; // convert to projection coordinate space
 642
 643   const Standard_Real aInvW = 1.0 / Standard_Real (aPnt.w());
 644
 645   return gp_Pnt (aPnt.x() * aInvW, aPnt.y() * aInvW, aPnt.z() * aInvW);
 646 }
 647
 648 // =======================================================================
 649 // function : UnProject
 650 // purpose  :
 651 // =======================================================================
 652 gp_Pnt Graphic3d_Camera::UnProject (const gp_Pnt& thePnt) const
 653 {
 654   const Graphic3d_Mat4d& aViewMx = OrientationMatrix();
 655   const Graphic3d_Mat4d& aProjMx = ProjectionMatrix();
 656
 657   Graphic3d_Mat4d aInvView;
 658   Graphic3d_Mat4d aInvProj;
 659
 660   // this case should never happen
 661   if (!aViewMx.Inverted (aInvView) || !aProjMx.Inverted (aInvProj))
 662   {
 663     return gp_Pnt (0.0, 0.0, 0.0);
 664   }
 665
 666   // use compatible type of point
 667   Graphic3d_Vec4d aPnt = safePointCast (thePnt);
 668
 669   aPnt = aInvProj * aPnt; // convert to view coordinate space
 670   aPnt = aInvView * aPnt; // convert to world coordinate space
 671
 672   const Standard_Real aInvW = 1.0 / Standard_Real (aPnt.w());
 673
 674   return gp_Pnt (aPnt.x() * aInvW, aPnt.y() * aInvW, aPnt.z() * aInvW);
 675 }
 676
 677 // =======================================================================
 678 // function : ConvertView2Proj
 679 // purpose  :
 680 // =======================================================================
 681 gp_Pnt Graphic3d_Camera::ConvertView2Proj (const gp_Pnt& thePnt) const
 682 {
 683   const Graphic3d_Mat4d& aProjMx = ProjectionMatrix();
 684
 685   // use compatible type of point
 686   Graphic3d_Vec4d aPnt = safePointCast (thePnt);
 687
 688   aPnt = aProjMx * aPnt; // convert to projection coordinate space
 689
 690   const Standard_Real aInvW = 1.0 / Standard_Real (aPnt.w());
 691
 692   return gp_Pnt (aPnt.x() * aInvW, aPnt.y() * aInvW, aPnt.z() * aInvW);
 693 }
 694
 695 // =======================================================================
 696 // function : ConvertProj2View
 697 // purpose  :
 698 // =======================================================================
 699 gp_Pnt Graphic3d_Camera::ConvertProj2View (const gp_Pnt& thePnt) const
 700 {
 701   const Graphic3d_Mat4d& aProjMx = ProjectionMatrix();
 702
 703   Graphic3d_Mat4d aInvProj;
 704
 705   // this case should never happen, but...
 706   if (!aProjMx.Inverted (aInvProj))
 707   {
 708     return gp_Pnt (0, 0, 0);
 709   }
 710
 711   // use compatible type of point
 712   Graphic3d_Vec4d aPnt = safePointCast (thePnt);
 713
 714   aPnt = aInvProj * aPnt; // convert to view coordinate space
 715
 716   const Standard_Real aInvW = 1.0 / Standard_Real (aPnt.w());
 717
 718   return gp_Pnt (aPnt.x() * aInvW, aPnt.y() * aInvW, aPnt.z() * aInvW);
 719 }
 720
 721 // =======================================================================
 722 // function : ConvertWorld2View
 723 // purpose  :
 724 // =======================================================================
 725 gp_Pnt Graphic3d_Camera::ConvertWorld2View (const gp_Pnt& thePnt) const
 726 {
 727   const Graphic3d_Mat4d& aViewMx = OrientationMatrix();
 728
 729   // use compatible type of point
 730   Graphic3d_Vec4d aPnt = safePointCast (thePnt);
 731
 732   aPnt = aViewMx * aPnt; // convert to view coordinate space
 733
 734   const Standard_Real aInvW = 1.0 / Standard_Real (aPnt.w());
 735
 736   return gp_Pnt (aPnt.x() * aInvW, aPnt.y() * aInvW, aPnt.z() * aInvW);
 737 }
 738
 739 // =======================================================================
 740 // function : ConvertView2World
 741 // purpose  :
 742 // =======================================================================
 743 gp_Pnt Graphic3d_Camera::ConvertView2World (const gp_Pnt& thePnt) const
 744 {
 745   const Graphic3d_Mat4d& aViewMx = OrientationMatrix();
 746
 747   Graphic3d_Mat4d aInvView;
 748
 749   if (!aViewMx.Inverted (aInvView))
 750   {
 751     return gp_Pnt(0, 0, 0);
 752   }
 753
 754   // use compatible type of point
 755   Graphic3d_Vec4d aPnt = safePointCast (thePnt);
 756
 757   aPnt = aInvView * aPnt; // convert to world coordinate space
 758
 759   const Standard_Real aInvW = 1.0 / Standard_Real (aPnt.w());
 760
 761   return gp_Pnt (aPnt.x() * aInvW, aPnt.y() * aInvW, aPnt.z() * aInvW);
 762 }
 763
 764 // =======================================================================
 765 // function : ViewDimensions
 766 // purpose  :
 767 // =======================================================================
 768 gp_XYZ Graphic3d_Camera::ViewDimensions (const Standard_Real theZValue) const
 769 {
 770   // view plane dimensions
 771   Standard_Real aSize = IsOrthographic() ? myScale : (2.0 * theZValue * myFOVyTan);
 772   Standard_Real aSizeX, aSizeY;
 773   if (myAspect > 1.0)
 774   {
 775     aSizeX = aSize * myAspect;
 776     aSizeY = aSize;
 777   }
 778   else
 779   {
 780     aSizeX = aSize;
 781     aSizeY = aSize / myAspect;
 782   }
 783
 784   // and frustum depth
 785   return gp_XYZ (aSizeX, aSizeY, myZFar - myZNear);
 786 }
 787
 788 // =======================================================================
 789 // function : Frustum
 790 // purpose  :
 791 // =======================================================================
 792 void Graphic3d_Camera::Frustum (gp_Pln& theLeft,
 793                                 gp_Pln& theRight,
 794                                 gp_Pln& theBottom,
 795                                 gp_Pln& theTop,
 796                                 gp_Pln& theNear,
 797                                 gp_Pln& theFar) const
 798 {
 799   gp_Vec aProjection = gp_Vec (Direction());
 800   gp_Vec anUp        = OrthogonalizedUp();
 801   gp_Vec aSide       = aProjection ^ anUp;
 802
 803   Standard_ASSERT_RAISE (
 804     !aProjection.IsParallel (anUp, Precision::Angular()),
 805      "Can not derive SIDE = PROJ x UP - directions are parallel");
 806
 807   theNear = gp_Pln (Eye().Translated (aProjection * ZNear()), aProjection);
 808   theFar  = gp_Pln (Eye().Translated (aProjection * ZFar()), -aProjection);
 809
 810   Standard_Real aHScaleHor = 0.0, aHScaleVer = 0.0;
 811   if (Aspect() >= 1.0)
 812   {
 813     aHScaleHor = Scale() * 0.5 * Aspect();
 814     aHScaleVer = Scale() * 0.5;
 815   }
 816   else
 817   {
 818     aHScaleHor = Scale() * 0.5;
 819     aHScaleVer = Scale() * 0.5 / Aspect();
 820   }
 821
 822   gp_Pnt aPntLeft   = Center().Translated (aHScaleHor * -aSide);
 823   gp_Pnt aPntRight  = Center().Translated (aHScaleHor *  aSide);
 824   gp_Pnt aPntBottom = Center().Translated (aHScaleVer * -anUp);
 825   gp_Pnt aPntTop    = Center().Translated (aHScaleVer *  anUp);
 826
 827   gp_Vec aDirLeft   =  aSide;
 828   gp_Vec aDirRight  = -aSide;
 829   gp_Vec aDirBottom =  anUp;
 830   gp_Vec aDirTop    = -anUp;
 831   if (!IsOrthographic())
 832   {
 833     Standard_Real aHFOVHor = ATan (Tan (DTR_HALF * FOVy()) * Aspect());
 834     Standard_Real aHFOVVer = DTR_HALF * FOVy();
 835     aDirLeft.Rotate   (gp_Ax1 (gp::Origin(), anUp),   aHFOVHor);
 836     aDirRight.Rotate  (gp_Ax1 (gp::Origin(), anUp),  -aHFOVHor);
 837     aDirBottom.Rotate (gp_Ax1 (gp::Origin(), aSide), -aHFOVVer);
 838     aDirTop.Rotate    (gp_Ax1 (gp::Origin(), aSide),  aHFOVVer);
 839   }
 840
 841   theLeft   = gp_Pln (aPntLeft,   aDirLeft);
 842   theRight  = gp_Pln (aPntRight,  aDirRight);
 843   theBottom = gp_Pln (aPntBottom, aDirBottom);
 844   theTop    = gp_Pln (aPntTop,    aDirTop);
 845 }
 846
 847 // =======================================================================
 848 // function : OrientationMatrix
 849 // purpose  :
 850 // =======================================================================
 851 const Graphic3d_Mat4d& Graphic3d_Camera::OrientationMatrix() const
 852 {
 853   return UpdateOrientation (myMatricesD).Orientation;
 854 }
 855
 856 // =======================================================================
 857 // function : OrientationMatrixF
 858 // purpose  :
 859 // =======================================================================
 860 const Graphic3d_Mat4& Graphic3d_Camera::OrientationMatrixF() const
 861 {
 862   return UpdateOrientation (myMatricesF).Orientation;
 863 }
 864
 865 // =======================================================================
 866 // function : ProjectionMatrix
 867 // purpose  :
 868 // =======================================================================
 869 const Graphic3d_Mat4d& Graphic3d_Camera::ProjectionMatrix() const
 870 {
 871   return UpdateProjection (myMatricesD).MProjection;
 872 }
 873
 874 // =======================================================================
 875 // function : ProjectionMatrixF
 876 // purpose  :
 877 // =======================================================================
 878 const Graphic3d_Mat4& Graphic3d_Camera::ProjectionMatrixF() const
 879 {
 880   return UpdateProjection (myMatricesF).MProjection;
 881 }
 882
 883 // =======================================================================
 884 // function : ProjectionStereoLeft
 885 // purpose  :
 886 // =======================================================================
 887 const Graphic3d_Mat4d& Graphic3d_Camera::ProjectionStereoLeft() const
 888 {
 889   return UpdateProjection (myMatricesD).LProjection;
 890 }
 891
 892 // =======================================================================
 893 // function : ProjectionStereoLeftF
 894 // purpose  :
 895 // =======================================================================
 896 const Graphic3d_Mat4& Graphic3d_Camera::ProjectionStereoLeftF() const
 897 {
 898   return UpdateProjection (myMatricesF).LProjection;
 899 }
 900
 901 // =======================================================================
 902 // function : ProjectionStereoRight
 903 // purpose  :
 904 // =======================================================================
 905 const Graphic3d_Mat4d& Graphic3d_Camera::ProjectionStereoRight() const
 906 {
 907   return UpdateProjection (myMatricesD).RProjection;
 908 }
 909
 910 // =======================================================================
 911 // function : ProjectionStereoRightF
 912 // purpose  :
 913 // =======================================================================
 914 const Graphic3d_Mat4& Graphic3d_Camera::ProjectionStereoRightF() const
 915 {
 916   return UpdateProjection (myMatricesF).RProjection;
 917 }
 918
 919 // =======================================================================
 920 // function : ResetCustomProjection
 921 // purpose  :
 922 // =======================================================================
 923 void Graphic3d_Camera::ResetCustomProjection()
 924 {
 925   if (myIsCustomFrustomLR
 926    || myIsCustomProjMatLR
 927    || myIsCustomProjMatM)
 928   {
 929     myIsCustomFrustomLR = false;
 930     myIsCustomProjMatLR = false;
 931     myIsCustomProjMatM  = false;
 932     InvalidateProjection();
 933   }
 934 }
 935
 936 // =======================================================================
 937 // function : StereoProjection
 938 // purpose  :
 939 // =======================================================================
 940 void Graphic3d_Camera::StereoProjection (Graphic3d_Mat4d& theProjL,
 941                                          Graphic3d_Mat4d& theHeadToEyeL,
 942                                          Graphic3d_Mat4d& theProjR,
 943                                          Graphic3d_Mat4d& theHeadToEyeR) const
 944 {
 945   stereoProjection (theProjL, theHeadToEyeL, theProjR, theHeadToEyeR);
 946 }
 947
 948 // =======================================================================
 949 // function : StereoProjectionF
 950 // purpose  :
 951 // =======================================================================
 952 void Graphic3d_Camera::StereoProjectionF (Graphic3d_Mat4& theProjL,
 953                                           Graphic3d_Mat4& theHeadToEyeL,
 954                                           Graphic3d_Mat4& theProjR,
 955                                           Graphic3d_Mat4& theHeadToEyeR) const
 956 {
 957   stereoProjection (theProjL, theHeadToEyeL, theProjR, theHeadToEyeR);
 958 }
 959
 960 // =======================================================================
 961 // function : stereoProjection
 962 // purpose  :
 963 // =======================================================================
 964 template <typename Elem_t>
 965 void Graphic3d_Camera::stereoProjection (NCollection_Mat4<Elem_t>& theProjL,
 966                                          NCollection_Mat4<Elem_t>& theHeadToEyeL,
 967                                          NCollection_Mat4<Elem_t>& theProjR,
 968                                          NCollection_Mat4<Elem_t>& theHeadToEyeR) const
 969 {
 970   if (myIsCustomProjMatLR)
 971   {
 972     theProjL     .ConvertFrom (myCustomProjMatL);
 973     theHeadToEyeL.ConvertFrom (myCustomHeadToEyeMatL);
 974     theProjR     .ConvertFrom (myCustomProjMatR);
 975     theHeadToEyeR.ConvertFrom (myCustomHeadToEyeMatR);
 976     return;
 977   }
 978
 979   NCollection_Mat4<Elem_t> aDummy;
 980   computeProjection (aDummy, theProjL, theProjR, false);
 981
 982   const Standard_Real aIOD = myIODType == IODType_Relative
 983                            ? myIOD * Distance()
 984                            : myIOD;
 985   if (aIOD != 0.0)
 986   {
 987     // X translation to cancel parallax
 988     theHeadToEyeL.InitIdentity();
 989     theHeadToEyeL.SetColumn (3, NCollection_Vec3<Elem_t> (Elem_t ( 0.5 * aIOD), Elem_t (0.0), Elem_t (0.0)));
 990     theHeadToEyeR.InitIdentity();
 991     theHeadToEyeR.SetColumn (3, NCollection_Vec3<Elem_t> (Elem_t (-0.5 * aIOD), Elem_t (0.0), Elem_t (0.0)));
 992   }
 993 }
 994
 995 // =======================================================================
 996 // function : SetCustomStereoFrustums
 997 // purpose  :
 998 // =======================================================================
 999 void Graphic3d_Camera::SetCustomStereoFrustums (const Aspect_FrustumLRBT<Standard_Real>& theFrustumL,
1000                                                 const Aspect_FrustumLRBT<Standard_Real>& theFrustumR)
1001 {
1002   myCustomFrustumL = theFrustumL;
1003   myCustomFrustumR = theFrustumR;
1004   myIsCustomFrustomLR = true;
1005   myIsCustomProjMatLR = false;
1006   InvalidateProjection();
1007 }
1008
1009 // =======================================================================
1010 // function : SetCustomStereoProjection
1011 // purpose  :
1012 // =======================================================================
1013 void Graphic3d_Camera::SetCustomStereoProjection (const Graphic3d_Mat4d& theProjL,
1014                                                   const Graphic3d_Mat4d& theHeadToEyeL,
1015                                                   const Graphic3d_Mat4d& theProjR,
1016                                                   const Graphic3d_Mat4d& theHeadToEyeR)
1017 {
1018   myCustomProjMatL = theProjL;
1019   myCustomProjMatR = theProjR;
1020   myCustomHeadToEyeMatL = theHeadToEyeL;
1021   myCustomHeadToEyeMatR = theHeadToEyeR;
1022   myIsCustomProjMatLR = true;
1023   myIsCustomFrustomLR = false;
1024   InvalidateProjection();
1025 }
1026
1027 // =======================================================================
1028 // function : SetCustomMonoProjection
1029 // purpose  :
1030 // =======================================================================
1031 void Graphic3d_Camera::SetCustomMonoProjection (const Graphic3d_Mat4d& theProj)
1032 {
1033   myCustomProjMatM = theProj;
1034   myIsCustomProjMatM = true;
1035   InvalidateProjection();
1036 }
1037
1038 // =======================================================================
1039 // function : computeProjection
1040 // purpose  :
1041 // =======================================================================
1042 template <typename Elem_t>
1043 void Graphic3d_Camera::computeProjection (NCollection_Mat4<Elem_t>& theProjM,
1044                                           NCollection_Mat4<Elem_t>& theProjL,
1045                                           NCollection_Mat4<Elem_t>& theProjR,
1046                                           bool theToAddHeadToEye) const
1047 {
1048   theProjM.InitIdentity();
1049   theProjL.InitIdentity();
1050   theProjR.InitIdentity();
1051
1052   // sets top of frustum based on FOVy and near clipping plane
1053   Elem_t aScale   = static_cast<Elem_t> (myScale);
1054   Elem_t aZNear   = static_cast<Elem_t> (myZNear);
1055   Elem_t aZFar    = static_cast<Elem_t> (myZFar);
1056   Elem_t anAspect = static_cast<Elem_t> (myAspect);
1057   Elem_t aDXHalf = 0.0, aDYHalf = 0.0;
1058   if (IsOrthographic())
1059   {
1060     aDXHalf = aDYHalf = aScale * Elem_t (0.5);
1061   }
1062   else
1063   {
1064     aDXHalf = aDYHalf = aZNear * Elem_t (myFOVyTan);
1065   }
1066
1067   if (anAspect > 1.0)
1068   {
1069     aDXHalf *= anAspect;
1070   }
1071   else
1072   {
1073     aDYHalf /= anAspect;
1074   }
1075
1076   // sets right of frustum based on aspect ratio
1077   Aspect_FrustumLRBT<Elem_t> anLRBT;
1078   anLRBT.Left   = -aDXHalf;
1079   anLRBT.Right  =  aDXHalf;
1080   anLRBT.Bottom = -aDYHalf;
1081   anLRBT.Top    =  aDYHalf;
1082
1083   Elem_t aIOD  = myIODType == IODType_Relative
1084     ? static_cast<Elem_t> (myIOD * Distance())
1085     : static_cast<Elem_t> (myIOD);
1086
1087   Elem_t aFocus = myZFocusType == FocusType_Relative
1088     ? static_cast<Elem_t> (myZFocus * Distance())
1089     : static_cast<Elem_t> (myZFocus);
1090
1091   if (myTile.IsValid())
1092   {
1093     const Elem_t aDXFull = Elem_t(2) * aDXHalf;
1094     const Elem_t aDYFull = Elem_t(2) * aDYHalf;
1095     const Graphic3d_Vec2i anOffset = myTile.OffsetLowerLeft();
1096     anLRBT.Left   = -aDXHalf + aDXFull * static_cast<Elem_t> (anOffset.x())                       / static_cast<Elem_t> (myTile.TotalSize.x());
1097     anLRBT.Right  = -aDXHalf + aDXFull * static_cast<Elem_t> (anOffset.x() + myTile.TileSize.x()) / static_cast<Elem_t> (myTile.TotalSize.x());
1098     anLRBT.Bottom = -aDYHalf + aDYFull * static_cast<Elem_t> (anOffset.y())                       / static_cast<Elem_t> (myTile.TotalSize.y());
1099     anLRBT.Top    = -aDYHalf + aDYFull * static_cast<Elem_t> (anOffset.y() + myTile.TileSize.y()) / static_cast<Elem_t> (myTile.TotalSize.y());
1100   }
1101
1102   if (myIsCustomProjMatM)
1103   {
1104     theProjM.ConvertFrom (myCustomProjMatM);
1105   }
1106   switch (myProjType)
1107   {
1108     case Projection_Orthographic:
1109     {
1110       if (!myIsCustomProjMatM)
1111       {
1112         orthoProj (theProjM, anLRBT, aZNear, aZFar);
1113       }
1114       break;
1115     }
1116     case Projection_Perspective:
1117     {
1118       if (!myIsCustomProjMatM)
1119       {
1120         perspectiveProj (theProjM, anLRBT, aZNear, aZFar);
1121       }
1122       break;
1123     }
1124     case Projection_MonoLeftEye:
1125     case Projection_MonoRightEye:
1126     case Projection_Stereo:
1127     {
1128       if (!myIsCustomProjMatM)
1129       {
1130         perspectiveProj (theProjM, anLRBT, aZNear, aZFar);
1131       }
1132       if (myIsCustomProjMatLR)
1133       {
1134         if (theToAddHeadToEye)
1135         {
1136           theProjL.ConvertFrom (myCustomProjMatL * myCustomHeadToEyeMatL);
1137           theProjR.ConvertFrom (myCustomProjMatR * myCustomHeadToEyeMatR);
1138         }
1139         else
1140         {
1141           theProjL.ConvertFrom (myCustomProjMatL);
1142           theProjR.ConvertFrom (myCustomProjMatR);
1143         }
1144       }
1145       else if (myIsCustomFrustomLR)
1146       {
1147         anLRBT = Aspect_FrustumLRBT<Elem_t> (myCustomFrustumL).Multiplied (aZNear);
1148         perspectiveProj (theProjL, anLRBT, aZNear, aZFar);
1149
1150         anLRBT = Aspect_FrustumLRBT<Elem_t> (myCustomFrustumR).Multiplied (aZNear);
1151         perspectiveProj (theProjR, anLRBT, aZNear, aZFar);
1152       }
1153       else
1154       {
1155         stereoEyeProj (theProjL,
1156                        anLRBT, aZNear, aZFar, aIOD, aFocus,
1157                        Aspect_Eye_Left);
1158         stereoEyeProj (theProjR,
1159                        anLRBT, aZNear, aZFar, aIOD, aFocus,
1160                        Aspect_Eye_Right);
1161       }
1162
1163       if (theToAddHeadToEye
1164       && !myIsCustomProjMatLR
1165       &&  aIOD != Elem_t (0.0))
1166       {
1167         // X translation to cancel parallax
1168         theProjL.Translate (NCollection_Vec3<Elem_t> (Elem_t ( 0.5) * aIOD, Elem_t (0.0), Elem_t (0.0)));
1169         theProjR.Translate (NCollection_Vec3<Elem_t> (Elem_t (-0.5) * aIOD, Elem_t (0.0), Elem_t (0.0)));
1170       }
1171       break;
1172     }
1173   }
1174   if (myProjType == Projection_MonoLeftEye)
1175   {
1176     theProjM = theProjL;
1177   }
1178   else if (myProjType == Projection_MonoRightEye)
1179   {
1180     theProjM = theProjR;
1181   }
1182 }
1183
1184 // =======================================================================
1185 // function : UpdateOrientation
1186 // purpose  :
1187 // =======================================================================
1188 template <typename Elem_t>
1189 Graphic3d_Camera::TransformMatrices<Elem_t>&
1190   Graphic3d_Camera::UpdateOrientation (TransformMatrices<Elem_t>& theMatrices) const
1191 {
1192   if (theMatrices.IsOrientationValid())
1193   {
1194     return theMatrices; // for inline accessors
1195   }
1196
1197   theMatrices.InitOrientation();
1198
1199   NCollection_Vec3<Elem_t> anEye (static_cast<Elem_t> (myEye.X()),
1200                                   static_cast<Elem_t> (myEye.Y()),
1201                                   static_cast<Elem_t> (myEye.Z()));
1202
1203   NCollection_Vec3<Elem_t> aViewDir (static_cast<Elem_t> (myDirection.X()),
1204                                      static_cast<Elem_t> (myDirection.Y()),
1205                                      static_cast<Elem_t> (myDirection.Z()));
1206
1207   NCollection_Vec3<Elem_t> anUp (static_cast<Elem_t> (myUp.X()),
1208                                  static_cast<Elem_t> (myUp.Y()),
1209                                  static_cast<Elem_t> (myUp.Z()));
1210
1211   NCollection_Vec3<Elem_t> anAxialScale (static_cast<Elem_t> (myAxialScale.X()),
1212                                          static_cast<Elem_t> (myAxialScale.Y()),
1213                                          static_cast<Elem_t> (myAxialScale.Z()));
1214
1215   LookOrientation (anEye, aViewDir, anUp, anAxialScale, theMatrices.Orientation);
1216
1217   return theMatrices; // for inline accessors
1218 }
1219
1220 // =======================================================================
1221 // function : InvalidateProjection
1222 // purpose  :
1223 // =======================================================================
1224 void Graphic3d_Camera::InvalidateProjection()
1225 {
1226   myMatricesD.ResetProjection();
1227   myMatricesF.ResetProjection();
1228   myWorldViewProjState.ProjectionState() = (Standard_Size)Standard_Atomic_Increment (&THE_STATE_COUNTER);
1229 }
1230
1231 // =======================================================================
1232 // function : InvalidateOrientation
1233 // purpose  :
1234 // =======================================================================
1235 void Graphic3d_Camera::InvalidateOrientation()
1236 {
1237   myMatricesD.ResetOrientation();
1238   myMatricesF.ResetOrientation();
1239   myWorldViewProjState.WorldViewState() = (Standard_Size)Standard_Atomic_Increment (&THE_STATE_COUNTER);
1240 }
1241
1242 // =======================================================================
1243 // function : orthoProj
1244 // purpose  :
1245 // =======================================================================
1246 template <typename Elem_t>
1247 void Graphic3d_Camera::orthoProj (NCollection_Mat4<Elem_t>& theOutMx,
1248                                   const Aspect_FrustumLRBT<Elem_t>& theLRBT,
1249                                   const Elem_t theNear,
1250                                   const Elem_t theFar)
1251 {
1252   // row 0
1253   theOutMx.ChangeValue (0, 0) = Elem_t (2.0) / (theLRBT.Right - theLRBT.Left);
1254   theOutMx.ChangeValue (0, 1) = Elem_t (0.0);
1255   theOutMx.ChangeValue (0, 2) = Elem_t (0.0);
1256   theOutMx.ChangeValue (0, 3) = - (theLRBT.Right + theLRBT.Left) / (theLRBT.Right - theLRBT.Left);
1257
1258   // row 1
1259   theOutMx.ChangeValue (1, 0) = Elem_t (0.0);
1260   theOutMx.ChangeValue (1, 1) = Elem_t (2.0) / (theLRBT.Top - theLRBT.Bottom);
1261   theOutMx.ChangeValue (1, 2) = Elem_t (0.0);
1262   theOutMx.ChangeValue (1, 3) = - (theLRBT.Top + theLRBT.Bottom) / (theLRBT.Top - theLRBT.Bottom);
1263
1264   // row 2
1265   theOutMx.ChangeValue (2, 0) = Elem_t (0.0);
1266   theOutMx.ChangeValue (2, 1) = Elem_t (0.0);
1267   theOutMx.ChangeValue (2, 2) = Elem_t (-2.0) / (theFar - theNear);
1268   theOutMx.ChangeValue (2, 3) = - (theFar + theNear) / (theFar - theNear);
1269
1270   // row 3
1271   theOutMx.ChangeValue (3, 0) = Elem_t (0.0);
1272   theOutMx.ChangeValue (3, 1) = Elem_t (0.0);
1273   theOutMx.ChangeValue (3, 2) = Elem_t (0.0);
1274   theOutMx.ChangeValue (3, 3) = Elem_t (1.0);
1275 }
1276
1277 // =======================================================================
1278 // function : PerspectiveProj
1279 // purpose  :
1280 // =======================================================================
1281 template <typename Elem_t>
1282 void Graphic3d_Camera::perspectiveProj (NCollection_Mat4<Elem_t>& theOutMx,
1283                                         const Aspect_FrustumLRBT<Elem_t>& theLRBT,
1284                                         const Elem_t theNear,
1285                                         const Elem_t theFar)
1286 {
1287   // column 0
1288   theOutMx.ChangeValue (0, 0) = (Elem_t (2.0) * theNear) / (theLRBT.Right - theLRBT.Left);
1289   theOutMx.ChangeValue (1, 0) = Elem_t (0.0);
1290   theOutMx.ChangeValue (2, 0) = Elem_t (0.0);
1291   theOutMx.ChangeValue (3, 0) = Elem_t (0.0);
1292
1293   // column 1
1294   theOutMx.ChangeValue (0, 1) = Elem_t (0.0);
1295   theOutMx.ChangeValue (1, 1) = (Elem_t (2.0) * theNear) / (theLRBT.Top - theLRBT.Bottom);
1296   theOutMx.ChangeValue (2, 1) = Elem_t (0.0);
1297   theOutMx.ChangeValue (3, 1) = Elem_t (0.0);
1298
1299   // column 2
1300   theOutMx.ChangeValue (0, 2) = (theLRBT.Right + theLRBT.Left) / (theLRBT.Right - theLRBT.Left);
1301   theOutMx.ChangeValue (1, 2) = (theLRBT.Top + theLRBT.Bottom) / (theLRBT.Top - theLRBT.Bottom);
1302   theOutMx.ChangeValue (2, 2) = -(theFar + theNear) / (theFar - theNear);
1303   theOutMx.ChangeValue (3, 2) = Elem_t (-1.0);
1304
1305   // column 3
1306   theOutMx.ChangeValue (0, 3) = Elem_t (0.0);
1307   theOutMx.ChangeValue (1, 3) = Elem_t (0.0);
1308   theOutMx.ChangeValue (2, 3) = -(Elem_t (2.0) * theFar * theNear) / (theFar - theNear);
1309   theOutMx.ChangeValue (3, 3) = Elem_t (0.0);
1310 }
1311
1312 // =======================================================================
1313 // function : StereoEyeProj
1314 // purpose  :
1315 // =======================================================================
1316 template <typename Elem_t>
1317 void Graphic3d_Camera::stereoEyeProj (NCollection_Mat4<Elem_t>& theOutMx,
1318                                       const Aspect_FrustumLRBT<Elem_t>& theLRBT,
1319                                       const Elem_t theNear,
1320                                       const Elem_t theFar,
1321                                       const Elem_t theIOD,
1322                                       const Elem_t theZFocus,
1323                                       const Aspect_Eye theEyeIndex)
1324 {
1325   Elem_t aDx = theEyeIndex == Aspect_Eye_Left ? Elem_t (0.5) * theIOD : Elem_t (-0.5) * theIOD;
1326   Elem_t aDXStereoShift = aDx * theNear / theZFocus;
1327
1328   // construct eye projection matrix
1329   Aspect_FrustumLRBT<Elem_t> aLRBT = theLRBT;
1330   aLRBT.Left  = theLRBT.Left  + aDXStereoShift;
1331   aLRBT.Right = theLRBT.Right + aDXStereoShift;
1332   perspectiveProj (theOutMx, aLRBT, theNear, theFar);
1333 }
1334
1335 // =======================================================================
1336 // function : LookOrientation
1337 // purpose  :
1338 // =======================================================================
1339 template <typename Elem_t>
1340 void Graphic3d_Camera::LookOrientation (const NCollection_Vec3<Elem_t>& theEye,
1341                                         const NCollection_Vec3<Elem_t>& theFwdDir,
1342                                         const NCollection_Vec3<Elem_t>& theUpDir,
1343                                         const NCollection_Vec3<Elem_t>& theAxialScale,
1344                                         NCollection_Mat4<Elem_t>& theOutMx)
1345 {
1346   NCollection_Vec3<Elem_t> aForward = theFwdDir;
1347   aForward.Normalize();
1348
1349   // side = forward x up
1350   NCollection_Vec3<Elem_t> aSide = NCollection_Vec3<Elem_t>::Cross (aForward, theUpDir);
1351   aSide.Normalize();
1352
1353   // recompute up as: up = side x forward
1354   NCollection_Vec3<Elem_t> anUp = NCollection_Vec3<Elem_t>::Cross (aSide, aForward);
1355
1356   NCollection_Mat4<Elem_t> aLookMx;
1357   aLookMx.SetRow (0, aSide);
1358   aLookMx.SetRow (1, anUp);
1359   aLookMx.SetRow (2, -aForward);
1360
1361   theOutMx.InitIdentity();
1362   theOutMx.Multiply (aLookMx);
1363   theOutMx.Translate (-theEye);
1364
1365   NCollection_Mat4<Elem_t> anAxialScaleMx;
1366   anAxialScaleMx.ChangeValue (0, 0) = theAxialScale.x();
1367   anAxialScaleMx.ChangeValue (1, 1) = theAxialScale.y();
1368   anAxialScaleMx.ChangeValue (2, 2) = theAxialScale.z();
1369
1370   theOutMx.Multiply (anAxialScaleMx);
1371 }
1372
1373 //=============================================================================
1374 //function : ZFitAll
1375 //purpose  :
1376 //=============================================================================
1377 bool Graphic3d_Camera::ZFitAll (const Standard_Real theScaleFactor,
1378                                 const Bnd_Box&      theMinMax,
1379                                 const Bnd_Box&      theGraphicBB,
1380                                 Standard_Real&      theZNear,
1381                                 Standard_Real&      theZFar) const
1382 {
1383   Standard_ASSERT_RAISE (theScaleFactor > 0.0, "Zero or negative scale factor is not allowed.");
1384
1385   // Method changes zNear and zFar parameters of camera so as to fit graphical structures
1386   // by their graphical boundaries. It precisely fits min max boundaries of primary application
1387   // objects (second argument), while it can sacrifice the real graphical boundaries of the
1388   // scene with infinite or helper objects (third argument) for the sake of perspective projection.
1389   if (theGraphicBB.IsVoid())
1390   {
1391     theZNear = DEFAULT_ZNEAR;
1392     theZFar  = DEFAULT_ZFAR;
1393     return false;
1394   }
1395
1396   // Measure depth of boundary points from camera eye.
1397   NCollection_Sequence<gp_Pnt> aPntsToMeasure;
1398
1399   Standard_Real aGraphicBB[6];
1400   theGraphicBB.Get (aGraphicBB[0], aGraphicBB[1], aGraphicBB[2], aGraphicBB[3], aGraphicBB[4], aGraphicBB[5]);
1401
1402   aPntsToMeasure.Append (gp_Pnt (aGraphicBB[0], aGraphicBB[1], aGraphicBB[2]));
1403   aPntsToMeasure.Append (gp_Pnt (aGraphicBB[0], aGraphicBB[1], aGraphicBB[5]));
1404   aPntsToMeasure.Append (gp_Pnt (aGraphicBB[0], aGraphicBB[4], aGraphicBB[2]));
1405   aPntsToMeasure.Append (gp_Pnt (aGraphicBB[0], aGraphicBB[4], aGraphicBB[5]));
1406   aPntsToMeasure.Append (gp_Pnt (aGraphicBB[3], aGraphicBB[1], aGraphicBB[2]));
1407   aPntsToMeasure.Append (gp_Pnt (aGraphicBB[3], aGraphicBB[1], aGraphicBB[5]));
1408   aPntsToMeasure.Append (gp_Pnt (aGraphicBB[3], aGraphicBB[4], aGraphicBB[2]));
1409   aPntsToMeasure.Append (gp_Pnt (aGraphicBB[3], aGraphicBB[4], aGraphicBB[5]));
1410
1411   Standard_Boolean isFiniteMinMax = !theMinMax.IsVoid() && !theMinMax.IsWhole();
1412
1413   if (isFiniteMinMax)
1414   {
1415     Standard_Real aMinMax[6];
1416     theMinMax.Get (aMinMax[0], aMinMax[1], aMinMax[2], aMinMax[3], aMinMax[4], aMinMax[5]);
1417
1418     aPntsToMeasure.Append (gp_Pnt (aMinMax[0], aMinMax[1], aMinMax[2]));
1419     aPntsToMeasure.Append (gp_Pnt (aMinMax[0], aMinMax[1], aMinMax[5]));
1420     aPntsToMeasure.Append (gp_Pnt (aMinMax[0], aMinMax[4], aMinMax[2]));
1421     aPntsToMeasure.Append (gp_Pnt (aMinMax[0], aMinMax[4], aMinMax[5]));
1422     aPntsToMeasure.Append (gp_Pnt (aMinMax[3], aMinMax[1], aMinMax[2]));
1423     aPntsToMeasure.Append (gp_Pnt (aMinMax[3], aMinMax[1], aMinMax[5]));
1424     aPntsToMeasure.Append (gp_Pnt (aMinMax[3], aMinMax[4], aMinMax[2]));
1425     aPntsToMeasure.Append (gp_Pnt (aMinMax[3], aMinMax[4], aMinMax[5]));
1426   }
1427
1428   // Camera eye plane.
1429   gp_Dir aCamDir = Direction();
1430   gp_Pnt aCamEye = myEye;
1431   gp_Pln aCamPln (aCamEye, aCamDir);
1432
1433   Standard_Real aModelMinDist = RealLast();
1434   Standard_Real aModelMaxDist = RealFirst();
1435   Standard_Real aGraphMinDist = RealLast();
1436   Standard_Real aGraphMaxDist = RealFirst();
1437
1438   const gp_XYZ& anAxialScale = myAxialScale;
1439
1440   // Get minimum and maximum distances to the eye plane.
1441   Standard_Integer aCounter = 0;
1442   NCollection_Sequence<gp_Pnt>::Iterator aPntIt(aPntsToMeasure);
1443   for (; aPntIt.More(); aPntIt.Next())
1444   {
1445     gp_Pnt aMeasurePnt = aPntIt.Value();
1446
1447     aMeasurePnt = gp_Pnt (aMeasurePnt.X() * anAxialScale.X(),
1448                           aMeasurePnt.Y() * anAxialScale.Y(),
1449                           aMeasurePnt.Z() * anAxialScale.Z());
1450
1451     Standard_Real aDistance = aCamPln.Distance (aMeasurePnt);
1452
1453     // Check if the camera is intruded into the scene.
1454     gp_Vec aVecToMeasurePnt (aCamEye, aMeasurePnt);
1455     if (aVecToMeasurePnt.Magnitude() > gp::Resolution()
1456      && aCamDir.IsOpposite (aVecToMeasurePnt, M_PI * 0.5))
1457     {
1458       aDistance *= -1;
1459     }
1460
1461     // The first eight points are from theGraphicBB, the last eight points are from theMinMax (can be absent).
1462     Standard_Real& aChangeMinDist = aCounter >= 8 ? aModelMinDist : aGraphMinDist;
1463     Standard_Real& aChangeMaxDist = aCounter >= 8 ? aModelMaxDist : aGraphMaxDist;
1464     aChangeMinDist = Min (aDistance, aChangeMinDist);
1465     aChangeMaxDist = Max (aDistance, aChangeMaxDist);
1466     aCounter++;
1467   }
1468
1469   // Compute depth of bounding box center.
1470   Standard_Real aMidDepth  = (aGraphMinDist + aGraphMaxDist) * 0.5;
1471   Standard_Real aHalfDepth = (aGraphMaxDist - aGraphMinDist) * 0.5;
1472
1473   // Compute enlarged or shrank near and far z ranges.
1474   Standard_Real aZNear  = aMidDepth - aHalfDepth * theScaleFactor;
1475   Standard_Real aZFar   = aMidDepth + aHalfDepth * theScaleFactor;
1476
1477   if (!IsOrthographic())
1478   {
1479     // Everything is behind the perspective camera.
1480     if (aZFar < zEpsilon())
1481     {
1482       theZNear = DEFAULT_ZNEAR;
1483       theZFar  = DEFAULT_ZFAR;
1484       return false;
1485     }
1486   }
1487
1488   //
1489   // Consider clipping errors due to double to single precision floating-point conversion.
1490   //
1491
1492   // Model to view transformation performs translation of points against eye position
1493   // in three dimensions. Both point coordinate and eye position values are converted from
1494   // double to single precision floating point numbers producing conversion errors.
1495   // Epsilon (Mod) * 3.0 should safely compensate precision error for z coordinate after
1496   // translation assuming that the:
1497   // Epsilon (Eye.Mod()) * 3.0 > Epsilon (Eye.X()) + Epsilon (Eye.Y()) + Epsilon (Eye.Z()).
1498   Standard_Real aEyeConf = 3.0 * zEpsilon (myEye.XYZ().Modulus());
1499
1500   // Model to view transformation performs rotation of points according to view direction.
1501   // New z coordinate is computed as a multiplication of point's x, y, z coordinates by the
1502   // "forward" direction vector's x, y, z coordinates. Both point's and "z" direction vector's
1503   // values are converted from double to single precision floating point numbers producing
1504   // conversion errors.
1505   // Epsilon (Mod) * 6.0 should safely compensate the precision errors for the multiplication
1506   // of point coordinates by direction vector.
1507   gp_Pnt aGraphicMin = theGraphicBB.CornerMin();
1508   gp_Pnt aGraphicMax = theGraphicBB.CornerMax();
1509
1510   Standard_Real aModelConf = 6.0 * zEpsilon (aGraphicMin.XYZ().Modulus()) +
1511                              6.0 * zEpsilon (aGraphicMax.XYZ().Modulus());
1512
1513   // Compensate floating point conversion errors by increasing zNear, zFar to avoid clipping.
1514   aZNear -= zEpsilon (aZNear) + aEyeConf + aModelConf;
1515   aZFar  += zEpsilon (aZFar)  + aEyeConf + aModelConf;
1516
1517   if (!IsOrthographic())
1518   {
1519     // For perspective projection, the value of z in normalized device coordinates is non-linear
1520     // function of eye z coordinate. For fixed-point depth representation resolution of z in
1521     // model-view space will grow towards zFar plane and its scale depends mostly on how far is zNear
1522     // against camera's eye. The purpose of the code below is to select most appropriate zNear distance
1523     // to balance between clipping (less zNear, more chances to observe closely small models without clipping)
1524     // and resolution of depth. A well applicable criteria to this is a ratio between resolution of z at center
1525     // of model boundaries and the distance to that center point. The ratio is chosen empirically and validated
1526     // by tests database. It is considered to be ~0.001 (0.1%) for 24 bit depth buffer, for less depth bitness
1527     // the zNear will be placed similarly giving lower resolution.
1528     // Approximation of the formula for respectively large z range is:
1529     // zNear = [z * (1 + k) / (k * c)],
1530     // where:
1531     // z - distance to center of model boundaries;
1532     // k - chosen ratio, c - capacity of depth buffer;
1533     // k = 0.001, k * c = 1677.216, (1 + k) / (k * c) ~ 5.97E-4
1534     //
1535     // The function uses center of model boundaries computed from "theMinMax" boundaries (instead of using real
1536     // graphical boundaries of all displayed objects). That means that it can sacrifice resolution of presentation
1537     // of non primary ("infinite") application graphical objects in favor of better perspective projection of the
1538     // small applicative objects measured with "theMinMax" values.
1539     Standard_Real aZRange   = isFiniteMinMax ? aModelMaxDist - aModelMinDist : aGraphMaxDist - aGraphMinDist;
1540     Standard_Real aZMin     = isFiniteMinMax ? aModelMinDist : aGraphMinDist;
1541     Standard_Real aZ        = aZMin < 0 ? aZRange / 2.0 : aZRange / 2.0 + aZMin;
1542     Standard_Real aZNearMin = aZ * 5.97E-4;
1543     if (aZNear < aZNearMin)
1544     {
1545       // Clip zNear according to the minimum value matching the quality.
1546       aZNear = aZNearMin;
1547       if (aZFar < aZNear)
1548       {
1549         aZFar = aZNear;
1550       }
1551     }
1552     else
1553     {
1554       // Compensate zNear conversion errors for perspective projection.
1555       aZNear -= aZFar * zEpsilon (aZNear) / (aZFar - zEpsilon (aZNear));
1556     }
1557
1558     // Compensate zFar conversion errors for perspective projection.
1559     aZFar += zEpsilon (aZFar);
1560
1561     // Ensure that after all the zNear is not a negative value.
1562     if (aZNear < zEpsilon())
1563     {
1564       aZNear = zEpsilon();
1565     }
1566     Standard_ASSERT_RAISE (aZFar > aZNear, "ZFar should be greater than ZNear");
1567   }
1568
1569   theZNear = aZNear;
1570   theZFar  = aZFar;
1571   Standard_ASSERT_RAISE (aZFar > aZNear, "ZFar should be greater than ZNear");
1572   return true;
1573 }
1574
1575 //=============================================================================
1576 //function : Interpolate
1577 //purpose  :
1578 //=============================================================================
1579 void Graphic3d_Camera::Interpolate (const Handle(Graphic3d_Camera)& theStart,
1580                                     const Handle(Graphic3d_Camera)& theEnd,
1581                                     const double theT,
1582                                     Handle(Graphic3d_Camera)& theCamera)
1583 {
1584   if (Abs (theT - 1.0) < Precision::Confusion())
1585   {
1586     // just copy end-point transformation
1587     theCamera->Copy (theEnd);
1588     return;
1589   }
1590
1591   theCamera->Copy (theStart);
1592   if (Abs (theT - 0.0) < Precision::Confusion())
1593   {
1594     return;
1595   }
1596
1597   // apply rotation
1598   {
1599     gp_Ax3 aCamStart = cameraToAx3 (*theStart);
1600     gp_Ax3 aCamEnd   = cameraToAx3 (*theEnd);
1601     gp_Trsf aTrsfStart, aTrsfEnd;
1602     aTrsfStart.SetTransformation (aCamStart, gp::XOY());
1603     aTrsfEnd  .SetTransformation (aCamEnd,   gp::XOY());
1604
1605     gp_Quaternion aRotStart = aTrsfStart.GetRotation();
1606     gp_Quaternion aRotEnd   = aTrsfEnd  .GetRotation();
1607     gp_Quaternion aRotDelta = aRotEnd * aRotStart.Inverted();
1608     gp_Quaternion aRot = gp_QuaternionNLerp::Interpolate (gp_Quaternion(), aRotDelta, theT);
1609     gp_Trsf aTrsfRot;
1610     aTrsfRot.SetRotation (aRot);
1611     theCamera->Transform (aTrsfRot);
1612   }
1613
1614   // apply translation
1615   {
1616     gp_XYZ aCenter  = NCollection_Lerp<gp_XYZ>::Interpolate (theStart->Center().XYZ(), theEnd->Center().XYZ(), theT);
1617     gp_XYZ anEye    = NCollection_Lerp<gp_XYZ>::Interpolate (theStart->Eye().XYZ(),    theEnd->Eye().XYZ(),    theT);
1618     gp_XYZ anAnchor = aCenter;
1619     Standard_Real aKc = 0.0;
1620
1621     const Standard_Real aDeltaCenter = theStart->Center().Distance (theEnd->Center());
1622     const Standard_Real aDeltaEye    = theStart->Eye()   .Distance (theEnd->Eye());
1623     if (aDeltaEye <= gp::Resolution())
1624     {
1625       anAnchor = anEye;
1626       aKc = 1.0;
1627     }
1628     else if (aDeltaCenter > gp::Resolution())
1629     {
1630       aKc = aDeltaCenter / (aDeltaCenter + aDeltaEye);
1631
1632       const gp_XYZ anAnchorStart = NCollection_Lerp<gp_XYZ>::Interpolate (theStart->Center().XYZ(), theStart->Eye().XYZ(), aKc);
1633       const gp_XYZ anAnchorEnd   = NCollection_Lerp<gp_XYZ>::Interpolate (theEnd  ->Center().XYZ(), theEnd  ->Eye().XYZ(), aKc);
1634       anAnchor = NCollection_Lerp<gp_XYZ>::Interpolate (anAnchorStart, anAnchorEnd, theT);
1635     }
1636
1637     const gp_Vec        aDirEyeToCenter     = theCamera->Direction();
1638     const Standard_Real aDistEyeCenterStart = theStart->Eye().Distance (theStart->Center());
1639     const Standard_Real aDistEyeCenterEnd   = theEnd  ->Eye().Distance (theEnd  ->Center());
1640     const Standard_Real aDistEyeCenter      = NCollection_Lerp<Standard_Real>::Interpolate (aDistEyeCenterStart, aDistEyeCenterEnd, theT);
1641     aCenter = anAnchor + aDirEyeToCenter.XYZ() * aDistEyeCenter * aKc;
1642     anEye   = anAnchor - aDirEyeToCenter.XYZ() * aDistEyeCenter * (1.0 - aKc);
1643
1644     theCamera->SetEyeAndCenter (anEye, aCenter);
1645   }
1646
1647   // apply scaling
1648   if (Abs(theStart->Scale() - theEnd->Scale()) > Precision::Confusion()
1649    && theStart->IsOrthographic())
1650   {
1651     const Standard_Real aScale = NCollection_Lerp<Standard_Real>::Interpolate (theStart->Scale(), theEnd->Scale(), theT);
1652     theCamera->SetScale (aScale);
1653   }
1654 }
1655
1656 //=======================================================================
1657 //function : FrustumPoints
1658 //purpose  :
1659 //=======================================================================
1660 void Graphic3d_Camera::FrustumPoints (NCollection_Array1<Graphic3d_Vec3d>& thePoints,
1661                                       const Graphic3d_Mat4d& theModelWorld) const
1662 {
1663   if (thePoints.Length() != FrustumVerticesNB)
1664   {
1665     thePoints.Resize (0, FrustumVerticesNB, Standard_False);
1666   }
1667
1668   const Graphic3d_Mat4d& aProjectionMat = ProjectionMatrix();
1669   const Graphic3d_Mat4d aWorldViewMat = OrientationMatrix() * theModelWorld;
1670
1671   Standard_Real nLeft = 0.0, nRight = 0.0, nTop = 0.0, nBottom = 0.0;
1672   Standard_Real fLeft = 0.0, fRight = 0.0, fTop = 0.0, fBottom = 0.0;
1673   Standard_Real aNear = 0.0, aFar = 0.0;
1674   if (!IsOrthographic())
1675   {
1676     // handle perspective projection
1677     aNear = aProjectionMat.GetValue (2, 3) / (-1.0 + aProjectionMat.GetValue (2, 2));
1678     aFar  = aProjectionMat.GetValue (2, 3) / ( 1.0 + aProjectionMat.GetValue (2, 2));
1679     // Near plane
1680     nLeft   = aNear * (aProjectionMat.GetValue (0, 2) - 1.0) / aProjectionMat.GetValue (0, 0);
1681     nRight  = aNear * (aProjectionMat.GetValue (0, 2) + 1.0) / aProjectionMat.GetValue (0, 0);
1682     nTop    = aNear * (aProjectionMat.GetValue (1, 2) + 1.0) / aProjectionMat.GetValue (1, 1);
1683     nBottom = aNear * (aProjectionMat.GetValue (1, 2) - 1.0) / aProjectionMat.GetValue (1, 1);
1684     // Far plane
1685     fLeft   = aFar  * (aProjectionMat.GetValue (0, 2) - 1.0) / aProjectionMat.GetValue (0, 0);
1686     fRight  = aFar  * (aProjectionMat.GetValue (0, 2) + 1.0) / aProjectionMat.GetValue (0, 0);
1687     fTop    = aFar  * (aProjectionMat.GetValue (1, 2) + 1.0) / aProjectionMat.GetValue (1, 1);
1688     fBottom = aFar  * (aProjectionMat.GetValue (1, 2) - 1.0) / aProjectionMat.GetValue (1, 1);
1689   }
1690   else
1691   {
1692     // handle orthographic projection
1693     aNear = (1.0 / aProjectionMat.GetValue (2, 2)) * (aProjectionMat.GetValue (2, 3) + 1.0);
1694     aFar  = (1.0 / aProjectionMat.GetValue (2, 2)) * (aProjectionMat.GetValue (2, 3) - 1.0);
1695     // Near plane
1696     nLeft   = ( 1.0 + aProjectionMat.GetValue (0, 3)) / (-aProjectionMat.GetValue (0, 0));
1697     fLeft   = nLeft;
1698     nRight  = ( 1.0 - aProjectionMat.GetValue (0, 3)) /   aProjectionMat.GetValue (0, 0);
1699     fRight  = nRight;
1700     nTop    = ( 1.0 - aProjectionMat.GetValue (1, 3)) /   aProjectionMat.GetValue (1, 1);
1701     fTop    = nTop;
1702     nBottom = (-1.0 - aProjectionMat.GetValue (1, 3)) /   aProjectionMat.GetValue (1, 1);
1703     fBottom = nBottom;
1704   }
1705
1706   Graphic3d_Vec4d aLeftTopNear     (nLeft,  nTop,    -aNear, 1.0), aRightBottomFar (fRight, fBottom, -aFar, 1.0);
1707   Graphic3d_Vec4d aLeftBottomNear  (nLeft,  nBottom, -aNear, 1.0), aRightTopFar    (fRight, fTop,    -aFar, 1.0);
1708   Graphic3d_Vec4d aRightBottomNear (nRight, nBottom, -aNear, 1.0), aLeftTopFar     (fLeft,  fTop,    -aFar, 1.0);
1709   Graphic3d_Vec4d aRightTopNear    (nRight, nTop,    -aNear, 1.0), aLeftBottomFar  (fLeft,  fBottom, -aFar, 1.0);
1710
1711   Graphic3d_Mat4d anInvWorldView;
1712   aWorldViewMat.Inverted (anInvWorldView);
1713
1714   Graphic3d_Vec4d aTmpPnt;
1715   aTmpPnt = anInvWorldView * aLeftTopNear;
1716   thePoints.SetValue (FrustumVert_LeftTopNear,     aTmpPnt.xyz() / aTmpPnt.w());
1717   aTmpPnt = anInvWorldView * aRightBottomFar;
1718   thePoints.SetValue (FrustumVert_RightBottomFar,  aTmpPnt.xyz() / aTmpPnt.w());
1719   aTmpPnt = anInvWorldView * aLeftBottomNear;
1720   thePoints.SetValue (FrustumVert_LeftBottomNear,  aTmpPnt.xyz() / aTmpPnt.w());
1721   aTmpPnt = anInvWorldView * aRightTopFar;
1722   thePoints.SetValue (FrustumVert_RightTopFar,     aTmpPnt.xyz() / aTmpPnt.w());
1723   aTmpPnt = anInvWorldView * aRightBottomNear;
1724   thePoints.SetValue (FrustumVert_RightBottomNear, aTmpPnt.xyz() / aTmpPnt.w());
1725   aTmpPnt = anInvWorldView * aLeftTopFar;
1726   thePoints.SetValue (FrustumVert_LeftTopFar,      aTmpPnt.xyz() / aTmpPnt.w());
1727   aTmpPnt = anInvWorldView * aRightTopNear;
1728   thePoints.SetValue (FrustumVert_RightTopNear,    aTmpPnt.xyz() / aTmpPnt.w());
1729   aTmpPnt = anInvWorldView * aLeftBottomFar;
1730   thePoints.SetValue (FrustumVert_LeftBottomFar,   aTmpPnt.xyz() / aTmpPnt.w());
1731 }
1732
1733 //=======================================================================
1734 //function : DumpJson
1735 //purpose  :
1736 //=======================================================================
1737 void Graphic3d_Camera::DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth) const
1738 {
1739   OCCT_DUMP_TRANSIENT_CLASS_BEGIN (theOStream)
1740
1741   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myUp)
1742   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myDirection)
1743   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myEye)
1744
1745   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myDistance)
1746
1747   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myAxialScale)
1748   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myProjType)
1749   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myFOVy)
1750   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myZNear)
1751   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myZFar)
1752   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myAspect)
1753
1754   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myScale)
1755   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myZFocus)
1756   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myZFocusType)
1757
1758   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myIOD)
1759   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myIODType)
1760
1761   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myTile)
1762   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myMatricesD)
1763   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myMatricesF)
1764   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myWorldViewProjState)
1765 }