src/OpenGl/OpenGl_View.cxx

   1 // Created on: 2011-09-20
   2 // Created by: Sergey ZERCHANINOV
   3 // Copyright (c) 2011-2012 OPEN CASCADE SAS
   4 //
   5 // The content of this file is subject to the Open CASCADE Technology Public
   6 // License Version 6.5 (the "License"). You may not use the content of this file
   7 // except in compliance with the License. Please obtain a copy of the License
   8 // at http://www.opencascade.org and read it completely before using this file.
   9 //
  10 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  11 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  12 //
  13 // The Original Code and all software distributed under the License is
  14 // distributed on an "AS IS" basis, without warranty of any kind, and the
  15 // Initial Developer hereby disclaims all such warranties, including without
  16 // limitation, any warranties of merchantability, fitness for a particular
  17 // purpose or non-infringement. Please see the License for the specific terms
  18 // and conditions governing the rights and limitations under the License.
  19
  20
  21 #ifdef HAVE_CONFIG_H
  22   #include <config.h>
  23 #endif
  24
  25 #include <NCollection_Mat4.hxx>
  26
  27 #include <OpenGl_Context.hxx>
  28 #include <OpenGl_Display.hxx>
  29 #include <OpenGl_GlCore11.hxx>
  30 #include <OpenGl_GraduatedTrihedron.hxx>
  31 #include <OpenGl_ShaderManager.hxx>
  32 #include <OpenGl_Texture.hxx>
  33 #include <OpenGl_Trihedron.hxx>
  34 #include <OpenGl_transform_persistence.hxx>
  35 #include <OpenGl_View.hxx>
  36 #include <OpenGl_Workspace.hxx>
  37
  38 #include <Graphic3d_TextureEnv.hxx>
  39
  40 IMPLEMENT_STANDARD_HANDLE(OpenGl_View,MMgt_TShared)
  41 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_View,MMgt_TShared)
  42
  43 /*----------------------------------------------------------------------*/
  44
  45 static const OPENGL_BG_TEXTURE myDefaultBgTexture = { 0, 0, 0, Aspect_FM_CENTERED };
  46 static const OPENGL_BG_GRADIENT myDefaultBgGradient = { {{ 0.F, 0.F, 0.F, 1.F }}, {{ 0.F, 0.F, 0.F, 1.F }}, Aspect_GFM_NONE };
  47 static const Tmatrix3 myDefaultMatrix = { { 1.F, 0.F, 0.F, 0.F }, { 0.F, 1.F, 0.F, 0.F }, { 0.F, 0.F, 1.F, 0.F }, { 0.F, 0.F, 0.F, 1.F } };
  48 static const OPENGL_ZCLIP myDefaultZClip = { { Standard_True, 0.F }, { Standard_True, 1.F } };
  49 static const OPENGL_EXTRA_REP myDefaultExtra =
  50 {
  51   //vrp
  52   { 0.F, 0.F, 0.F },
  53   //vpn
  54   { 0.F, 0.F, 1.F },
  55   //vup
  56   { 0.F, 1.F, 0.F },
  57   //map
  58   {
  59     //window
  60     { 0.F, 0.F, 1.F, 1.F },
  61     //viewport
  62     { 0.F, 0.F, 0.F, 1.F, 1.F, 1.F },
  63     //proj
  64     TelParallel,
  65     //prp
  66     { 0.F, 0.F, 0.F },
  67     //vpd
  68     0.F,
  69     //fpd
  70     0.F,
  71     //bpd
  72     -1.F
  73   },
  74   //scaleFactors
  75   { 1.F, 1.F, 1.F }
  76 };
  77
  78 static const OPENGL_FOG myDefaultFog = { Standard_False, 0.F, 1.F, { { 0.F, 0.F, 0.F, 1.F } } };
  79 static const TEL_TRANSFORM_PERSISTENCE myDefaultTransPers = { 0, 0.F, 0.F, 0.F };
  80 static const GLdouble THE_IDENTITY_MATRIX[4][4] =
  81 {
  82   {1.0, 0.0, 0.0, 0.0},
  83   {0.0, 1.0, 0.0, 0.0},
  84   {0.0, 0.0, 1.0, 0.0},
  85   {0.0, 0.0, 0.0, 1.0}
  86 };
  87
  88 /*----------------------------------------------------------------------*/
  89
  90 OpenGl_View::OpenGl_View (const CALL_DEF_VIEWCONTEXT &AContext)
  91 : mySurfaceDetail(Visual3d_TOD_NONE),
  92   myBackfacing(0),
  93   myBgTexture(myDefaultBgTexture),
  94   myBgGradient(myDefaultBgGradient),
  95   //myOrientationMatrix(myDefaultMatrix),
  96   //myMappingMatrix(myDefaultMatrix),
  97   //shield_indicator = TOn,
  98   //shield_colour = { { 0.F, 0.F, 0.F, 1.F } },
  99   //border_indicator = TOff,
 100   //border_colour = { { 0.F, 0.F, 0.F, 1.F } },
 101   //active_status = TOn,
 102   myZClip(myDefaultZClip),
 103   myExtra(myDefaultExtra),
 104   myFog(myDefaultFog),
 105   myTrihedron(NULL),
 106   myGraduatedTrihedron(NULL),
 107   myVisualization(AContext.Visualization),
 108   myIntShadingMethod(TEL_SM_GOURAUD),
 109   myAntiAliasing(Standard_False),
 110   myTransPers(&myDefaultTransPers),
 111   myIsTransPers(Standard_False),
 112   myOrientationChanged (Standard_True),
 113   myViewMappingChanged (Standard_True),
 114   myLightSourcesChanged (Standard_True)
 115 {
 116   // Initialize matrices
 117   memcpy(myOrientationMatrix,myDefaultMatrix,sizeof(Tmatrix3));
 118   memcpy(myMappingMatrix,myDefaultMatrix,sizeof(Tmatrix3));
 119
 120   // Shading method
 121   switch (AContext.Model)
 122   {
 123     case 1 : /* VISUAL3D_TOM_INTERP_COLOR */
 124     case 3 : /* VISUAL3D_TOM_VERTEX */
 125       myIntShadingMethod = TEL_SM_GOURAUD;
 126       break;
 127     default :
 128       myIntShadingMethod = TEL_SM_FLAT;
 129       break;
 130   }
 131
 132 #ifdef HAVE_OPENCL
 133   myModificationState = 1; // initial state
 134 #endif
 135 }
 136
 137 /*----------------------------------------------------------------------*/
 138
 139 OpenGl_View::~OpenGl_View ()
 140 {
 141   ReleaseGlResources (NULL); // ensure ReleaseGlResources() was called within valid context
 142 }
 143
 144 void OpenGl_View::ReleaseGlResources (const Handle(OpenGl_Context)& theCtx)
 145 {
 146   OpenGl_Element::Destroy (theCtx, myTrihedron);
 147   OpenGl_Element::Destroy (theCtx, myGraduatedTrihedron);
 148
 149   if (!myTextureEnv.IsNull())
 150   {
 151     theCtx->DelayedRelease (myTextureEnv);
 152     myTextureEnv.Nullify();
 153   }
 154   if (myBgTexture.TexId != 0)
 155   {
 156     glDeleteTextures (1, (GLuint*)&(myBgTexture.TexId));
 157     myBgTexture.TexId = 0;
 158   }
 159 }
 160
 161 void OpenGl_View::SetTextureEnv (const Handle(OpenGl_Context)&       theCtx,
 162                                  const Handle(Graphic3d_TextureEnv)& theTexture)
 163 {
 164   if (!myTextureEnv.IsNull())
 165   {
 166     theCtx->DelayedRelease (myTextureEnv);
 167     myTextureEnv.Nullify();
 168   }
 169
 170   if (theTexture.IsNull())
 171   {
 172     return;
 173   }
 174
 175   myTextureEnv = new OpenGl_Texture (theTexture->GetParams());
 176   Handle(Image_PixMap) anImage = theTexture->GetImage();
 177   if (!anImage.IsNull())
 178     myTextureEnv->Init (theCtx, *anImage.operator->(), theTexture->Type());
 179
 180 #ifdef HAVE_OPENCL
 181   myModificationState++;
 182 #endif
 183 }
 184
 185 void OpenGl_View::SetSurfaceDetail (const Visual3d_TypeOfSurfaceDetail theMode)
 186 {
 187   mySurfaceDetail = theMode;
 188
 189 #ifdef HAVE_OPENCL
 190   myModificationState++;
 191 #endif
 192 }
 193
 194 /*----------------------------------------------------------------------*/
 195
 196 void OpenGl_View::SetBackfacing (const Standard_Integer theMode)
 197 {
 198   myBackfacing = theMode;
 199 }
 200
 201 /*----------------------------------------------------------------------*/
 202
 203 //call_togl_setlight
 204 void OpenGl_View::SetLights (const CALL_DEF_VIEWCONTEXT &AContext)
 205 {
 206   myLights.Clear();
 207
 208   const int nb_lights = AContext.NbActiveLight;
 209
 210   int i = 0;
 211   const CALL_DEF_LIGHT *alight = &(AContext.ActiveLight[0]);
 212   for ( ; i < nb_lights; i++, alight++ )
 213   {
 214     OpenGl_Light rep;
 215     memset(&rep,0,sizeof(rep));
 216
 217         switch( alight->LightType )
 218     {
 219       case 0 : /* TOLS_AMBIENT */
 220         rep.type = TLightAmbient;
 221         rep.col.rgb[0] = alight->Color.r;
 222         rep.col.rgb[1] = alight->Color.g;
 223         rep.col.rgb[2] = alight->Color.b;
 224         break;
 225
 226       case 1 : /* TOLS_DIRECTIONAL */
 227         rep.type = TLightDirectional;
 228         rep.col.rgb[0] = alight->Color.r;
 229         rep.col.rgb[1] = alight->Color.g;
 230         rep.col.rgb[2] = alight->Color.b;
 231         rep.dir[0] = alight->Direction.x;
 232         rep.dir[1] = alight->Direction.y;
 233         rep.dir[2] = alight->Direction.z;
 234         break;
 235
 236       case 2 : /* TOLS_POSITIONAL */
 237         rep.type = TLightPositional;
 238         rep.col.rgb[0] = alight->Color.r;
 239         rep.col.rgb[1] = alight->Color.g;
 240         rep.col.rgb[2] = alight->Color.b;
 241         rep.pos[0] = alight->Position.x;
 242         rep.pos[1] = alight->Position.y;
 243         rep.pos[2] = alight->Position.z;
 244         rep.atten[0] = alight->Attenuation[0];
 245         rep.atten[1] = alight->Attenuation[1];
 246         break;
 247
 248       case 3 : /* TOLS_SPOT */
 249         rep.type = TLightSpot;
 250         rep.col.rgb[0] = alight->Color.r;
 251         rep.col.rgb[1] = alight->Color.g;
 252         rep.col.rgb[2] = alight->Color.b;
 253         rep.pos[0] = alight->Position.x;
 254         rep.pos[1] = alight->Position.y;
 255         rep.pos[2] = alight->Position.z;
 256         rep.dir[0] = alight->Direction.x;
 257         rep.dir[1] = alight->Direction.y;
 258         rep.dir[2] = alight->Direction.z;
 259         rep.shine = alight->Concentration;
 260         rep.atten[0] = alight->Attenuation[0];
 261         rep.atten[1] = alight->Attenuation[1];
 262         rep.angle = alight->Angle;
 263         break;
 264     }
 265
 266     rep.HeadLight = alight->Headlight;
 267
 268     myLights.Append(rep);
 269   }
 270
 271   myLightSourcesChanged = Standard_True;
 272 }
 273
 274 /*----------------------------------------------------------------------*/
 275
 276 //call_togl_setvisualisation
 277 void OpenGl_View::SetVisualisation (const CALL_DEF_VIEWCONTEXT &AContext)
 278 {
 279   myVisualization = AContext.Visualization;
 280   // Shading method
 281   switch (AContext.Model)
 282   {
 283     case 1 : /* VISUAL3D_TOM_INTERP_COLOR */
 284     case 3 : /* VISUAL3D_TOM_VERTEX */
 285       myIntShadingMethod = TEL_SM_GOURAUD;
 286       break;
 287     default :
 288       myIntShadingMethod = TEL_SM_FLAT;
 289       break;
 290   }
 291 }
 292
 293 /*----------------------------------------------------------------------*/
 294
 295 //call_togl_cliplimit
 296 void OpenGl_View::SetClipLimit (const Graphic3d_CView& theCView)
 297 {
 298   myZClip.Back.Limit =
 299     (theCView.Context.ZClipBackPlane     - theCView.Mapping.BackPlaneDistance) /
 300     (theCView.Mapping.FrontPlaneDistance - theCView.Mapping.BackPlaneDistance);
 301   myZClip.Front.Limit =
 302     (theCView.Context.ZClipFrontPlane    - theCView.Mapping.BackPlaneDistance) /
 303     (theCView.Mapping.FrontPlaneDistance - theCView.Mapping.BackPlaneDistance);
 304   if (myZClip.Back.Limit < 0.0f)
 305     myZClip.Back.Limit = 0.0f;
 306   if (myZClip.Front.Limit > 1.0f)
 307     myZClip.Front.Limit = 1.0f;
 308   if (myZClip.Back.Limit > myZClip.Front.Limit)
 309   {
 310     myZClip.Back.Limit  = 0.0f;
 311     myZClip.Front.Limit = 1.0f;
 312   }
 313
 314   myZClip.Back.IsOn  = (theCView.Context.BackZClipping  != 0);
 315   myZClip.Front.IsOn = (theCView.Context.FrontZClipping != 0);
 316 }
 317
 318 /*----------------------------------------------------------------------*/
 319
 320 //call_togl_viewmapping
 321 void OpenGl_View::SetMapping (const Handle(OpenGl_Display)& theGlDisplay,
 322                               const Graphic3d_CView&        theCView)
 323 {
 324   const float ratio   = theCView.DefWindow.dy / theCView.DefWindow.dx;
 325   const float r_ratio = theCView.DefWindow.dx / theCView.DefWindow.dy;
 326
 327   TEL_VIEW_MAPPING Map;
 328
 329   Map.window.xmin = theCView.Mapping.WindowLimit.um;
 330   Map.window.ymin = theCView.Mapping.WindowLimit.vm;
 331   Map.window.xmax = theCView.Mapping.WindowLimit.uM;
 332   Map.window.ymax = theCView.Mapping.WindowLimit.vM;
 333
 334   Map.viewport.xmin = 0.F;
 335   Map.viewport.xmax = ( 1.F < r_ratio ? 1.F : r_ratio );
 336   Map.viewport.ymin = 0.F;
 337   Map.viewport.ymax = ( 1.F < ratio ? 1.F : ratio );
 338   Map.viewport.zmin = 0.F;
 339   Map.viewport.zmax = 1.F;
 340
 341   // projection type
 342   switch (theCView.Mapping.Projection)
 343   {
 344     case 0 :
 345       Map.proj = TelPerspective;
 346       break;
 347     case 1 :
 348       Map.proj = TelParallel;
 349       break;
 350   }
 351
 352   // projection reference point
 353   Map.prp[0] = theCView.Mapping.ProjectionReferencePoint.x;
 354   Map.prp[1] = theCView.Mapping.ProjectionReferencePoint.y;
 355   Map.prp[2] = theCView.Mapping.ProjectionReferencePoint.z;
 356   if (!theGlDisplay.IsNull() && !theGlDisplay->Walkthrough())
 357     Map.prp[2] += theCView.Mapping.FrontPlaneDistance;
 358
 359   // view plane distance
 360   Map.vpd = theCView.Mapping.ViewPlaneDistance;
 361
 362   // back plane distance
 363   Map.bpd = theCView.Mapping.BackPlaneDistance;
 364
 365   // front plane distance
 366   Map.fpd = theCView.Mapping.FrontPlaneDistance;
 367
 368   Tint err_ind = 0;
 369
 370   // use user-defined matrix
 371   if (theCView.Mapping.IsCustomMatrix)
 372   {
 373     int i, j;
 374     for( i = 0; i < 4; i++ )
 375       for( j = 0; j < 4; j++ )
 376         myMappingMatrix[i][j] = theCView.Mapping.ProjectionMatrix[i][j];
 377   }
 378   else
 379     TelEvalViewMappingMatrix (theGlDisplay, &Map, &err_ind, myMappingMatrix);
 380
 381   if (!err_ind)
 382     myExtra.map = Map;
 383
 384   myViewMappingChanged = Standard_True;
 385 }
 386
 387 /*----------------------------------------------------------------------*/
 388
 389 //call_togl_vieworientation
 390 void OpenGl_View::SetOrientation (const Graphic3d_CView& theCView)
 391 {
 392   Tfloat Vrp[3];
 393   Tfloat Vpn[3];
 394   Tfloat Vup[3];
 395   Tfloat ScaleFactors[3];
 396
 397   Vrp[0] = theCView.Orientation.ViewReferencePoint.x;
 398   Vrp[1] = theCView.Orientation.ViewReferencePoint.y;
 399   Vrp[2] = theCView.Orientation.ViewReferencePoint.z;
 400
 401   Vpn[0] = theCView.Orientation.ViewReferencePlane.x;
 402   Vpn[1] = theCView.Orientation.ViewReferencePlane.y;
 403   Vpn[2] = theCView.Orientation.ViewReferencePlane.z;
 404
 405   Vup[0] = theCView.Orientation.ViewReferenceUp.x;
 406   Vup[1] = theCView.Orientation.ViewReferenceUp.y;
 407   Vup[2] = theCView.Orientation.ViewReferenceUp.z;
 408
 409   ScaleFactors[0] = theCView.Orientation.ViewScaleX;
 410   ScaleFactors[1] = theCView.Orientation.ViewScaleY;
 411   ScaleFactors[2] = theCView.Orientation.ViewScaleZ;
 412
 413   Tint err_ind = 0;
 414
 415   // use user-defined matrix
 416   if (theCView.Orientation.IsCustomMatrix)
 417   {
 418     int i, j;
 419     for( i = 0; i < 4; i++ )
 420       for( j = 0; j < 4; j++ )
 421         myOrientationMatrix[i][j] = theCView.Orientation.ModelViewMatrix[i][j];
 422   }
 423   else
 424   {
 425     TelEvalViewOrientationMatrix (Vrp, Vpn, Vup, ScaleFactors, &err_ind, myOrientationMatrix);
 426   }
 427
 428   if (!err_ind)
 429   {
 430     myExtra.vrp[0] = Vrp[0];
 431     myExtra.vrp[1] = Vrp[1];
 432     myExtra.vrp[2] = Vrp[2];
 433
 434     myExtra.vpn[0] = Vpn[0];
 435     myExtra.vpn[1] = Vpn[1];
 436     myExtra.vpn[2] = Vpn[2];
 437
 438     myExtra.vup[0] = Vup[0];
 439     myExtra.vup[1] = Vup[1];
 440     myExtra.vup[2] = Vup[2];
 441
 442     myExtra.scaleFactors[0] = ScaleFactors[0],
 443     myExtra.scaleFactors[1] = ScaleFactors[1],
 444     myExtra.scaleFactors[2] = ScaleFactors[2];
 445   }
 446
 447   myOrientationChanged = Standard_True;
 448 }
 449
 450 /*----------------------------------------------------------------------*/
 451
 452 void OpenGl_View::SetFog (const Graphic3d_CView& theCView,
 453                           const Standard_Boolean theFlag)
 454 {
 455   if (!theFlag)
 456   {
 457     myFog.IsOn = Standard_False;
 458   }
 459   else
 460   {
 461     myFog.IsOn = Standard_True;
 462
 463     myFog.Front =
 464       (theCView.Context.DepthFrontPlane    - theCView.Mapping.BackPlaneDistance) /
 465       (theCView.Mapping.FrontPlaneDistance - theCView.Mapping.BackPlaneDistance);
 466
 467     myFog.Back =
 468       (theCView.Context.DepthBackPlane     - theCView.Mapping.BackPlaneDistance) /
 469       (theCView.Mapping.FrontPlaneDistance - theCView.Mapping.BackPlaneDistance);
 470
 471     if (myFog.Front < 0.F)
 472       myFog.Front = 0.F;
 473     else if (myFog.Front > 1.F)
 474       myFog.Front = 1.F;
 475
 476     if (myFog.Back < 0.F)
 477       myFog.Back = 0.F;
 478     else if (myFog.Back > 1.F)
 479       myFog.Back = 1.F;
 480
 481     if (myFog.Back > myFog.Front)
 482     {
 483       myFog.Front = 1.F;
 484       myFog.Back = 0.F;
 485     }
 486
 487     myFog.Color.rgb[0] = theCView.DefWindow.Background.r;
 488     myFog.Color.rgb[1] = theCView.DefWindow.Background.g;
 489     myFog.Color.rgb[2] = theCView.DefWindow.Background.b;
 490     myFog.Color.rgb[3] = 1.0f;
 491   }
 492 }
 493
 494 /*----------------------------------------------------------------------*/
 495
 496 void OpenGl_View::TriedronDisplay (const Handle(OpenGl_Context)&       theCtx,
 497                                    const Aspect_TypeOfTriedronPosition thePosition,
 498                                    const Quantity_NameOfColor          theColor,
 499                                    const Standard_Real                 theScale,
 500                                    const Standard_Boolean              theAsWireframe)
 501 {
 502   OpenGl_Element::Destroy (theCtx, myTrihedron);
 503   myTrihedron = new OpenGl_Trihedron (thePosition, theColor, theScale, theAsWireframe);
 504 }
 505
 506 /*----------------------------------------------------------------------*/
 507
 508 void OpenGl_View::TriedronErase (const Handle(OpenGl_Context)& theCtx)
 509 {
 510   OpenGl_Element::Destroy (theCtx, myTrihedron);
 511 }
 512
 513 /*----------------------------------------------------------------------*/
 514
 515 void OpenGl_View::GraduatedTrihedronDisplay (const Handle(OpenGl_Context)&        theCtx,
 516                                              const Graphic3d_CGraduatedTrihedron& theData)
 517 {
 518   OpenGl_Element::Destroy (theCtx, myGraduatedTrihedron);
 519   myGraduatedTrihedron = new OpenGl_GraduatedTrihedron (theData);
 520 }
 521
 522 /*----------------------------------------------------------------------*/
 523
 524 void OpenGl_View::GraduatedTrihedronErase (const Handle(OpenGl_Context)& theCtx)
 525 {
 526   OpenGl_Element::Destroy (theCtx, myGraduatedTrihedron);
 527 }
 528
 529 /*----------------------------------------------------------------------*/
 530
 531 //transform_persistence_end
 532 void OpenGl_View::EndTransformPersistence(const Handle(OpenGl_Context)& theCtx)
 533 {
 534   if (myIsTransPers)
 535   {
 536     // restore matrix
 537     glMatrixMode (GL_PROJECTION);
 538     glPopMatrix();
 539     glMatrixMode (GL_MODELVIEW);
 540     glPopMatrix();
 541     myIsTransPers = Standard_False;
 542
 543     // Note: the approach of accessing OpenGl matrices is used now since the matrix
 544     // manipulation are made with help of OpenGl methods. This might be replaced by
 545     // direct computation of matrices by OCC subroutines.
 546     Tmatrix3 aResultWorldView;
 547     glGetFloatv (GL_MODELVIEW_MATRIX, *aResultWorldView);
 548
 549     Tmatrix3 aResultProjection;
 550     glGetFloatv (GL_PROJECTION_MATRIX, *aResultProjection);
 551
 552     // Set OCCT state uniform variables
 553     theCtx->ShaderManager()->RevertWorldViewStateTo (aResultWorldView);
 554     theCtx->ShaderManager()->RevertProjectionStateTo (aResultProjection);
 555   }
 556 }
 557
 558 /*----------------------------------------------------------------------*/
 559
 560 //transform_persistence_begin
 561 const TEL_TRANSFORM_PERSISTENCE* OpenGl_View::BeginTransformPersistence (const Handle(OpenGl_Context)& theCtx,
 562                                                                          const TEL_TRANSFORM_PERSISTENCE* theTransPers)
 563 {
 564   const TEL_TRANSFORM_PERSISTENCE* aTransPersPrev = myTransPers;
 565   myTransPers = theTransPers;
 566   if (theTransPers->mode == 0)
 567   {
 568     EndTransformPersistence (theCtx);
 569     return aTransPersPrev;
 570   }
 571
 572   GLint aViewport[4];
 573   GLdouble aModelMatrix[4][4];
 574   GLdouble aProjMatrix[4][4];
 575   glGetIntegerv (GL_VIEWPORT,          aViewport);
 576   glGetDoublev  (GL_MODELVIEW_MATRIX,  (GLdouble* )aModelMatrix);
 577   glGetDoublev  (GL_PROJECTION_MATRIX, (GLdouble *)aProjMatrix);
 578   const GLdouble aViewportW = (GLdouble )aViewport[2];
 579   const GLdouble aViewportH = (GLdouble )aViewport[3];
 580
 581   if (myIsTransPers)
 582   {
 583     // pop matrix stack - it will be overridden later
 584     glMatrixMode (GL_PROJECTION);
 585     glPopMatrix();
 586     glMatrixMode (GL_MODELVIEW);
 587     glPopMatrix();
 588   }
 589   else
 590   {
 591     myIsTransPers = Standard_True;
 592   }
 593
 594   // push matrices into stack and reset them
 595   glMatrixMode (GL_MODELVIEW);
 596   glPushMatrix();
 597   glLoadIdentity();
 598
 599   glMatrixMode (GL_PROJECTION);
 600   glPushMatrix();
 601   glLoadIdentity();
 602
 603   // get the window's (fixed) coordinates for theTransPers->point before matrixes modifications
 604   GLdouble aWinX = 0.0, aWinY = 0.0, aWinZ = 0.0;
 605   if ((theTransPers->mode & TPF_PAN) != TPF_PAN)
 606   {
 607     gluProject (theTransPers->pointX, theTransPers->pointY, theTransPers->pointZ,
 608                 (GLdouble* )aModelMatrix, (GLdouble* )aProjMatrix, aViewport,
 609                 &aWinX, &aWinY, &aWinZ);
 610   }
 611
 612   // prevent zooming
 613   if ((theTransPers->mode & TPF_ZOOM)
 614    || (theTransPers->mode == TPF_TRIEDRON))
 615   {
 616     // compute fixed-zoom multiplier
 617     // actually function works ugly with TelPerspective!
 618     const GLdouble aDet2 = 0.002 / (aViewportW > aViewportH ? aProjMatrix[1][1] : aProjMatrix[0][0]);
 619     aProjMatrix[0][0] *= aDet2;
 620     aProjMatrix[1][1] *= aDet2;
 621     aProjMatrix[2][2] *= aDet2;
 622   }
 623
 624   // prevent translation - annulate translate matrix
 625   if ((theTransPers->mode & TPF_PAN)
 626    || (theTransPers->mode == TPF_TRIEDRON))
 627   {
 628     aModelMatrix[3][0] = 0.0;
 629     aModelMatrix[3][1] = 0.0;
 630     aModelMatrix[3][2] = 0.0;
 631     aProjMatrix [3][0] = 0.0;
 632     aProjMatrix [3][1] = 0.0;
 633     aProjMatrix [3][2] = 0.0;
 634   }
 635
 636   // prevent scaling-on-axis
 637   if (theTransPers->mode & TPF_ZOOM)
 638   {
 639     const double aScaleX = myExtra.scaleFactors[0];
 640     const double aScaleY = myExtra.scaleFactors[1];
 641     const double aScaleZ = myExtra.scaleFactors[2];
 642     for (int i = 0; i < 3; ++i)
 643     {
 644       aModelMatrix[0][i] /= aScaleX;
 645       aModelMatrix[1][i] /= aScaleY;
 646       aModelMatrix[2][i] /= aScaleZ;
 647     }
 648   }
 649
 650   // prevent rotating - annulate rotate matrix
 651   if (theTransPers->mode & TPF_ROTATE)
 652   {
 653     aModelMatrix[0][0] = 1.0;
 654     aModelMatrix[1][1] = 1.0;
 655     aModelMatrix[2][2] = 1.0;
 656
 657     aModelMatrix[1][0] = 0.0;
 658     aModelMatrix[2][0] = 0.0;
 659     aModelMatrix[0][1] = 0.0;
 660     aModelMatrix[2][1] = 0.0;
 661     aModelMatrix[0][2] = 0.0;
 662     aModelMatrix[1][2] = 0.0;
 663   }
 664
 665   // load computed matrices
 666   glMatrixMode (GL_MODELVIEW);
 667   glMultMatrixd ((GLdouble* )aModelMatrix);
 668
 669   glMatrixMode (GL_PROJECTION);
 670   glMultMatrixd ((GLdouble* )aProjMatrix);
 671
 672   if (theTransPers->mode == TPF_TRIEDRON)
 673   {
 674     // move to the window corner
 675     if (theTransPers->pointX != 0.0
 676      && theTransPers->pointY != 0.0)
 677     {
 678       GLdouble aW1, aH1, aW2, aH2, aDummy;
 679       glMatrixMode (GL_PROJECTION);
 680       gluUnProject ( 0.5 * aViewportW,  0.5 * aViewportH, 0.0,
 681                     (GLdouble* )THE_IDENTITY_MATRIX, (GLdouble* )aProjMatrix, aViewport,
 682                     &aW1, &aH1, &aDummy);
 683       gluUnProject (-0.5 * aViewportW, -0.5 * aViewportH, 0.0,
 684                     (GLdouble* )THE_IDENTITY_MATRIX, (GLdouble* )aProjMatrix, aViewport,
 685                     &aW2, &aH2, &aDummy);
 686       GLdouble aMoveX = 0.5 * (aW1 - aW2 - theTransPers->pointZ);
 687       GLdouble aMoveY = 0.5 * (aH1 - aH2 - theTransPers->pointZ);
 688       aMoveX = (theTransPers->pointX > 0.0) ? aMoveX : -aMoveX;
 689       aMoveY = (theTransPers->pointY > 0.0) ? aMoveY : -aMoveY;
 690       glTranslated (aMoveX, aMoveY, 0.0);
 691     }
 692   }
 693   else if ((theTransPers->mode & TPF_PAN) != TPF_PAN)
 694   {
 695     // move to thePoint using saved win-coordinates ('marker-behaviour')
 696     GLdouble aMoveX, aMoveY, aMoveZ;
 697     glGetDoublev (GL_MODELVIEW_MATRIX,  (GLdouble* )aModelMatrix);
 698     glGetDoublev (GL_PROJECTION_MATRIX, (GLdouble* )aProjMatrix);
 699     gluUnProject (aWinX, aWinY, aWinZ,
 700                   (GLdouble* )aModelMatrix, (GLdouble* )aProjMatrix, aViewport,
 701                   &aMoveX, &aMoveY, &aMoveZ);
 702
 703     glMatrixMode (GL_MODELVIEW);
 704     glTranslated (aMoveX, aMoveY, aMoveZ);
 705   }
 706
 707   // Note: the approach of accessing OpenGl matrices is used now since the matrix
 708   // manipulation are made with help of OpenGl methods. This might be replaced by
 709   // direct computation of matrices by OCC subroutines.
 710   Tmatrix3 aResultWorldView;
 711   glGetFloatv (GL_MODELVIEW_MATRIX, *aResultWorldView);
 712
 713   Tmatrix3 aResultProjection;
 714   glGetFloatv (GL_PROJECTION_MATRIX, *aResultProjection);
 715
 716   // Set OCCT state uniform variables
 717   theCtx->ShaderManager()->UpdateWorldViewStateTo (aResultWorldView);
 718   theCtx->ShaderManager()->UpdateProjectionStateTo (aResultProjection);
 719
 720   return aTransPersPrev;
 721 }