src/OpenGl/OpenGl_Structure.cxx

   1 // Created on: 2011-08-01
   2 // Created by: Sergey ZERCHANINOV
   3 // Copyright (c) 2011-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 <OpenGl_CappingAlgo.hxx>
  17 #include <OpenGl_Context.hxx>
  18 #include <OpenGl_GlCore11.hxx>
  19 #include <OpenGl_GraphicDriver.hxx>
  20 #include <OpenGl_ShaderManager.hxx>
  21 #include <OpenGl_ShaderProgram.hxx>
  22 #include <OpenGl_StructureShadow.hxx>
  23 #include <OpenGl_Vec.hxx>
  24 #include <OpenGl_View.hxx>
  25 #include <OpenGl_Workspace.hxx>
  26
  27 #include <Graphic3d_SequenceOfHClipPlane.hxx>
  28
  29
  30 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Structure,Graphic3d_CStructure)
  31
  32 //! Auxiliary class for bounding box presentation
  33 class OpenGl_BndBoxPrs : public OpenGl_Element
  34 {
  35
  36 public:
  37
  38   //! Main constructor
  39   OpenGl_BndBoxPrs (const Graphic3d_BndBox4f& theBndBox)
  40   {
  41     const float Xm = theBndBox.CornerMin().x();
  42     const float Ym = theBndBox.CornerMin().y();
  43     const float Zm = theBndBox.CornerMin().z();
  44     const float XM = theBndBox.CornerMax().x();
  45     const float YM = theBndBox.CornerMax().y();
  46     const float ZM = theBndBox.CornerMax().z();
  47
  48     myVerts[0]  = OpenGl_Vec3 (Xm, Ym, Zm);
  49     myVerts[1]  = OpenGl_Vec3 (Xm, Ym, ZM);
  50     myVerts[2]  = OpenGl_Vec3 (Xm, YM, ZM);
  51     myVerts[3]  = OpenGl_Vec3 (Xm, YM, Zm);
  52     myVerts[4]  = OpenGl_Vec3 (Xm, Ym, Zm);
  53     myVerts[5]  = OpenGl_Vec3 (XM, Ym, Zm);
  54     myVerts[6]  = OpenGl_Vec3 (XM, Ym, ZM);
  55     myVerts[7]  = OpenGl_Vec3 (XM, YM, ZM);
  56     myVerts[8]  = OpenGl_Vec3 (XM, YM, Zm);
  57     myVerts[9]  = OpenGl_Vec3 (XM, Ym, Zm);
  58     myVerts[10] = OpenGl_Vec3 (XM, YM, Zm);
  59     myVerts[11] = OpenGl_Vec3 (Xm, YM, Zm);
  60     myVerts[12] = OpenGl_Vec3 (Xm, YM, ZM);
  61     myVerts[13] = OpenGl_Vec3 (XM, YM, ZM);
  62     myVerts[14] = OpenGl_Vec3 (XM, Ym, ZM);
  63     myVerts[15] = OpenGl_Vec3 (Xm, Ym, ZM);
  64   }
  65
  66   //! Render presentation
  67   virtual void Render  (const Handle(OpenGl_Workspace)& theWorkspace) const
  68   {
  69   #if !defined(GL_ES_VERSION_2_0)
  70     // Apply line aspect
  71     const Handle(OpenGl_Texture) aPrevTexture = theWorkspace->DisableTexture();
  72
  73     glDisable (GL_LIGHTING);
  74
  75     // Use highlight colors
  76     theWorkspace->GetGlContext()->core11->glColor3fv (theWorkspace->LineColor().GetData());
  77
  78     glEnableClientState (GL_VERTEX_ARRAY);
  79     glVertexPointer (3, GL_FLOAT, 0, (GLfloat* )&myVerts);
  80     glDrawArrays (GL_LINE_STRIP, 0, 16);
  81     glDisableClientState (GL_VERTEX_ARRAY);
  82
  83     // restore aspects
  84     if (!aPrevTexture.IsNull())
  85     {
  86       theWorkspace->EnableTexture (aPrevTexture);
  87     }
  88   #else
  89     (void )theWorkspace;
  90   #endif
  91   }
  92
  93   //! Release graphical resources
  94   virtual void Release (OpenGl_Context*)
  95   {
  96     //
  97   }
  98
  99 protected:
 100
 101   //! Protected destructor
 102   virtual ~OpenGl_BndBoxPrs() {}
 103
 104 private:
 105
 106   OpenGl_Vec3 myVerts[16]; //!< vertices array
 107
 108 public:
 109
 110   DEFINE_STANDARD_ALLOC
 111
 112 };
 113
 114 /*----------------------------------------------------------------------*/
 115
 116 // =======================================================================
 117 // function : OpenGl_Structure
 118 // purpose  :
 119 // =======================================================================
 120 OpenGl_Structure::OpenGl_Structure (const Handle(Graphic3d_StructureManager)& theManager)
 121 : Graphic3d_CStructure (theManager),
 122   myHighlightColor     (NULL),
 123   myInstancedStructure (NULL),
 124   myIsRaytracable      (Standard_False),
 125   myModificationState  (0),
 126   myIsCulled           (Standard_True),
 127   myIsMirrored         (Standard_False)
 128 {
 129   //
 130 }
 131
 132 // =======================================================================
 133 // function : ~OpenGl_Structure
 134 // purpose  :
 135 // =======================================================================
 136 OpenGl_Structure::~OpenGl_Structure()
 137 {
 138   Release (Handle(OpenGl_Context)());
 139 }
 140
 141 // =======================================================================
 142 // function : UpdateTransformation
 143 // purpose  :
 144 // =======================================================================
 145 void OpenGl_Structure::UpdateTransformation()
 146 {
 147   const OpenGl_Mat4& aMat = Graphic3d_CStructure::Transformation;
 148   Standard_ShortReal aDet =
 149     aMat.GetValue(0, 0) * (aMat.GetValue(1, 1) * aMat.GetValue(2, 2) - aMat.GetValue(2, 1) * aMat.GetValue(1, 2)) -
 150     aMat.GetValue(0, 1) * (aMat.GetValue(1, 0) * aMat.GetValue(2, 2) - aMat.GetValue(2, 0) * aMat.GetValue(1, 2)) +
 151     aMat.GetValue(0, 2) * (aMat.GetValue(1, 0) * aMat.GetValue(2, 1) - aMat.GetValue(2, 0) * aMat.GetValue(1, 1));
 152
 153   // Determinant of transform matrix less then 0 means that mirror transform applied.
 154   myIsMirrored = aDet < 0.0f;
 155
 156   if (IsRaytracable())
 157   {
 158     ++myModificationState;
 159   }
 160 }
 161
 162 // =======================================================================
 163 // function : clearHighlightBox
 164 // purpose  :
 165 // =======================================================================
 166 void OpenGl_Structure::clearHighlightBox (const Handle(OpenGl_Context)& theGlCtx)
 167 {
 168   if (!myHighlightBox.IsNull())
 169   {
 170     myHighlightBox->Release (theGlCtx);
 171     myHighlightBox.Nullify();
 172   }
 173 }
 174
 175 // =======================================================================
 176 // function : HighlightWithColor
 177 // purpose  :
 178 // =======================================================================
 179 void OpenGl_Structure::HighlightWithColor (const Graphic3d_Vec3&  theColor,
 180                                            const Standard_Boolean theToCreate)
 181 {
 182   const Handle(OpenGl_Context)& aContext = GlDriver()->GetSharedContext();
 183   if (theToCreate)
 184     setHighlightColor   (aContext, theColor);
 185   else
 186     clearHighlightColor (aContext);
 187 }
 188
 189 // =======================================================================
 190 // function : HighlightWithBndBox
 191 // purpose  :
 192 // =======================================================================
 193 void OpenGl_Structure::HighlightWithBndBox (const Handle(Graphic3d_Structure)& theStruct,
 194                                             const Standard_Boolean             theToCreate)
 195 {
 196   const Handle(OpenGl_Context)& aContext = GlDriver()->GetSharedContext();
 197   if (!theToCreate)
 198   {
 199     clearHighlightBox (aContext);
 200     return;
 201   }
 202
 203   if (!myHighlightBox.IsNull())
 204   {
 205     myHighlightBox->Release (aContext);
 206   }
 207   else
 208   {
 209     myHighlightBox = new OpenGl_Group (theStruct);
 210   }
 211
 212   myHighlightBox->SetGroupPrimitivesAspect (new Graphic3d_AspectLine3d (HighlightColor, Aspect_TOL_SOLID, 1.0));
 213
 214   OpenGl_BndBoxPrs* aBndBoxPrs = new OpenGl_BndBoxPrs (myBndBox);
 215   myHighlightBox->AddElement (aBndBoxPrs);
 216 }
 217
 218 // =======================================================================
 219 // function : setHighlightColor
 220 // purpose  :
 221 // =======================================================================
 222 void OpenGl_Structure::setHighlightColor (const Handle(OpenGl_Context)& theGlCtx,
 223                                           const Graphic3d_Vec3&         theColor)
 224 {
 225   clearHighlightBox (theGlCtx);
 226   if (myHighlightColor == NULL)
 227   {
 228     myHighlightColor = new OpenGl_Vec4 (theColor, 1.0f);
 229   }
 230   else
 231   {
 232     myHighlightColor->xyz() = theColor;
 233   }
 234 }
 235
 236 // =======================================================================
 237 // function : clearHighlightColor
 238 // purpose  :
 239 // =======================================================================
 240 void OpenGl_Structure::clearHighlightColor (const Handle(OpenGl_Context)& theGlCtx)
 241 {
 242   clearHighlightBox(theGlCtx);
 243   delete myHighlightColor;
 244   myHighlightColor = NULL;
 245 }
 246
 247 // =======================================================================
 248 // function : OnVisibilityChanged
 249 // purpose  :
 250 // =======================================================================
 251 void OpenGl_Structure::OnVisibilityChanged()
 252 {
 253   if (IsRaytracable())
 254   {
 255     ++myModificationState;
 256   }
 257 }
 258
 259 // =======================================================================
 260 // function : IsRaytracable
 261 // purpose  :
 262 // =======================================================================
 263 Standard_Boolean OpenGl_Structure::IsRaytracable() const
 264 {
 265   if (!myGroups.IsEmpty()
 266     && myIsRaytracable)
 267   {
 268     return Standard_True;
 269   }
 270
 271   return myInstancedStructure != NULL
 272      &&  myInstancedStructure->IsRaytracable();
 273 }
 274
 275 // =======================================================================
 276 // function : UpdateRaytracableState
 277 // purpose  :
 278 // =======================================================================
 279 void OpenGl_Structure::UpdateStateIfRaytracable (const Standard_Boolean toCheck) const
 280 {
 281   myIsRaytracable = !toCheck;
 282   if (!myIsRaytracable)
 283   {
 284     for (OpenGl_Structure::GroupIterator anIter (myGroups); anIter.More(); anIter.Next())
 285     {
 286       if (anIter.Value()->IsRaytracable())
 287       {
 288         myIsRaytracable = Standard_True;
 289         break;
 290       }
 291     }
 292   }
 293
 294   if (IsRaytracable())
 295   {
 296     ++myModificationState;
 297   }
 298 }
 299
 300 // =======================================================================
 301 // function : Connect
 302 // purpose  :
 303 // =======================================================================
 304 void OpenGl_Structure::Connect (Graphic3d_CStructure& theStructure)
 305 {
 306   OpenGl_Structure* aStruct = static_cast<OpenGl_Structure*> (&theStructure);
 307
 308   Standard_ASSERT_RAISE (myInstancedStructure == NULL || myInstancedStructure == aStruct,
 309     "Error! Instanced structure is already defined");
 310
 311   myInstancedStructure = aStruct;
 312
 313   if (aStruct->IsRaytracable())
 314   {
 315     UpdateStateIfRaytracable (Standard_False);
 316   }
 317 }
 318
 319 // =======================================================================
 320 // function : Disconnect
 321 // purpose  :
 322 // =======================================================================
 323 void OpenGl_Structure::Disconnect (Graphic3d_CStructure& theStructure)
 324 {
 325   OpenGl_Structure* aStruct = static_cast<OpenGl_Structure*> (&theStructure);
 326
 327   if (myInstancedStructure == aStruct)
 328   {
 329     myInstancedStructure = NULL;
 330
 331     if (aStruct->IsRaytracable())
 332     {
 333       UpdateStateIfRaytracable();
 334     }
 335   }
 336 }
 337
 338 // =======================================================================
 339 // function : NewGroup
 340 // purpose  :
 341 // =======================================================================
 342 Handle(Graphic3d_Group) OpenGl_Structure::NewGroup (const Handle(Graphic3d_Structure)& theStruct)
 343 {
 344   Handle(OpenGl_Group) aGroup = new OpenGl_Group (theStruct);
 345   myGroups.Append (aGroup);
 346   return aGroup;
 347 }
 348
 349 // =======================================================================
 350 // function : RemoveGroup
 351 // purpose  :
 352 // =======================================================================
 353 void OpenGl_Structure::RemoveGroup (const Handle(Graphic3d_Group)& theGroup)
 354 {
 355   if (theGroup.IsNull())
 356   {
 357     return;
 358   }
 359
 360   for (Graphic3d_SequenceOfGroup::Iterator aGroupIter (myGroups); aGroupIter.More(); aGroupIter.Next())
 361   {
 362     // Check for the given group
 363     if (aGroupIter.Value() == theGroup)
 364     {
 365       const Standard_Boolean wasRaytracable =
 366         static_cast<const OpenGl_Group&> (*theGroup).IsRaytracable();
 367
 368       theGroup->Clear (Standard_False);
 369
 370       if (wasRaytracable)
 371       {
 372         UpdateStateIfRaytracable();
 373       }
 374
 375       myGroups.Remove (aGroupIter);
 376       return;
 377     }
 378   }
 379 }
 380
 381 // =======================================================================
 382 // function : Clear
 383 // purpose  :
 384 // =======================================================================
 385 void OpenGl_Structure::Clear()
 386 {
 387   Clear (GlDriver()->GetSharedContext());
 388 }
 389
 390 // =======================================================================
 391 // function : Clear
 392 // purpose  :
 393 // =======================================================================
 394 void OpenGl_Structure::Clear (const Handle(OpenGl_Context)& theGlCtx)
 395 {
 396   Standard_Boolean aRaytracableGroupDeleted (Standard_False);
 397
 398   // Release groups
 399   for (OpenGl_Structure::GroupIterator aGroupIter (myGroups); aGroupIter.More(); aGroupIter.Next())
 400   {
 401     aRaytracableGroupDeleted |= aGroupIter.Value()->IsRaytracable();
 402
 403     // Delete objects
 404     aGroupIter.ChangeValue()->Release (theGlCtx);
 405   }
 406   myGroups.Clear();
 407
 408   if (aRaytracableGroupDeleted)
 409   {
 410     myIsRaytracable = Standard_False;
 411   }
 412
 413   Is2dText       = Standard_False;
 414   IsForHighlight = Standard_False;
 415 }
 416
 417 // =======================================================================
 418 // function : renderGeometry
 419 // purpose  :
 420 // =======================================================================
 421 void OpenGl_Structure::renderGeometry (const Handle(OpenGl_Workspace)& theWorkspace,
 422                                        bool&                           theHasClosed) const
 423 {
 424   if (myInstancedStructure != NULL)
 425   {
 426     myInstancedStructure->renderGeometry (theWorkspace, theHasClosed);
 427   }
 428
 429   for (OpenGl_Structure::GroupIterator aGroupIter (myGroups); aGroupIter.More(); aGroupIter.Next())
 430   {
 431     theHasClosed = theHasClosed || aGroupIter.Value()->IsClosed();
 432     aGroupIter.Value()->Render (theWorkspace);
 433   }
 434 }
 435
 436 // =======================================================================
 437 // function : Render
 438 // purpose  :
 439 // =======================================================================
 440 void OpenGl_Structure::Render (const Handle(OpenGl_Workspace) &theWorkspace) const
 441 {
 442   // Process the structure only if visible
 443   if (!visible)
 444   {
 445     return;
 446   }
 447
 448   const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
 449
 450   // Render named status
 451   if (highlight)
 452   {
 453     theWorkspace->SetHighlight (true);
 454   }
 455
 456   // Apply local transformation
 457   aCtx->ModelWorldState.Push();
 458   aCtx->ModelWorldState.SetCurrent (Transformation);
 459
 460   const Standard_Boolean anOldGlNormalize = aCtx->IsGlNormalizeEnabled();
 461
 462 #if !defined(GL_ES_VERSION_2_0)
 463   // detect scale transform
 464   if (aCtx->core11 != NULL)
 465   {
 466     const Standard_ShortReal aScaleX = Transformation.GetRow (0).xyz().SquareModulus();
 467     if (Abs (aScaleX - 1.f) > Precision::Confusion())
 468     {
 469       aCtx->SetGlNormalizeEnabled (Standard_True);
 470     }
 471   }
 472 #endif
 473
 474   if (TransformPersistence.Flags)
 475   {
 476     OpenGl_Mat4 aProjection = aCtx->ProjectionState.Current();
 477     OpenGl_Mat4 aWorldView  = aCtx->WorldViewState.Current();
 478     TransformPersistence.Apply (aProjection, aWorldView, theWorkspace->Width(), theWorkspace->Height());
 479
 480     aCtx->ProjectionState.Push();
 481     aCtx->WorldViewState.Push();
 482     aCtx->ProjectionState.SetCurrent (aProjection);
 483     aCtx->WorldViewState.SetCurrent (aWorldView);
 484     aCtx->ApplyProjectionMatrix();
 485
 486   #if !defined(GL_ES_VERSION_2_0)
 487     if (!aCtx->IsGlNormalizeEnabled()
 488       && aCtx->core11 != NULL)
 489     {
 490       const Standard_Real aScale = Graphic3d_TransformUtils::ScaleFactor<Standard_ShortReal> (aWorldView);
 491       if (Abs (aScale - 1.0f) > Precision::Confusion())
 492       {
 493         aCtx->SetGlNormalizeEnabled (Standard_True);
 494       }
 495     }
 496   #endif
 497   }
 498
 499   // Take into account transform persistence
 500   aCtx->ApplyModelViewMatrix();
 501
 502   // remember aspects
 503   const OpenGl_AspectLine*   aPrevAspectLine   = theWorkspace->AspectLine();
 504   const OpenGl_AspectFace*   aPrevAspectFace   = theWorkspace->AspectFace();
 505   const OpenGl_AspectMarker* aPrevAspectMarker = theWorkspace->AspectMarker();
 506   const OpenGl_AspectText*   aPrevAspectText   = theWorkspace->AspectText();
 507
 508   // Apply correction for mirror transform
 509   if (myIsMirrored)
 510   {
 511     aCtx->core11fwd->glFrontFace (GL_CW);
 512   }
 513
 514   // Apply highlight color
 515   const OpenGl_Vec4* aHighlightColor = theWorkspace->HighlightColor;
 516   if (myHighlightColor)
 517     theWorkspace->HighlightColor = myHighlightColor;
 518
 519   // Set up plane equations for non-structure transformed global model-view matrix
 520   // List of planes to be applied to context state
 521   NCollection_Handle<Graphic3d_SequenceOfHClipPlane> aUserPlanes;
 522
 523   // Collect clipping planes of structure scope
 524   if (!myClipPlanes.IsEmpty())
 525   {
 526     Graphic3d_SequenceOfHClipPlane::Iterator aClippingIter (myClipPlanes);
 527     for (; aClippingIter.More(); aClippingIter.Next())
 528     {
 529       const Handle(Graphic3d_ClipPlane)& aClipPlane = aClippingIter.Value();
 530       if (!aClipPlane->IsOn())
 531       {
 532         continue;
 533       }
 534
 535       if (aUserPlanes.IsNull())
 536       {
 537         aUserPlanes = new Graphic3d_SequenceOfHClipPlane();
 538       }
 539
 540       aUserPlanes->Append (aClipPlane);
 541     }
 542   }
 543
 544   if (!aUserPlanes.IsNull() && !aUserPlanes->IsEmpty())
 545   {
 546     // add planes at loaded view matrix state
 547     aCtx->ChangeClipping().AddWorld (aCtx, *aUserPlanes);
 548
 549     // Set OCCT state uniform variables
 550     aCtx->ShaderManager()->UpdateClippingState();
 551   }
 552
 553   // Render groups
 554   bool hasClosedPrims = false;
 555   renderGeometry (theWorkspace, hasClosedPrims);
 556
 557   // Reset correction for mirror transform
 558   if (myIsMirrored)
 559   {
 560     aCtx->core11fwd->glFrontFace (GL_CCW);
 561   }
 562
 563   // Render capping for structure groups
 564   if (hasClosedPrims
 565   && !aCtx->Clipping().Planes().IsEmpty())
 566   {
 567     OpenGl_CappingAlgo::RenderCapping (theWorkspace, *this);
 568   }
 569
 570   // Revert structure clippings
 571   if (!aUserPlanes.IsNull() && !aUserPlanes->IsEmpty())
 572   {
 573     aCtx->ChangeClipping().Remove (aCtx, *aUserPlanes);
 574
 575     // Set OCCT state uniform variables
 576     aCtx->ShaderManager()->RevertClippingState();
 577   }
 578
 579   // Restore local transformation
 580   aCtx->ModelWorldState.Pop();
 581   aCtx->SetGlNormalizeEnabled (anOldGlNormalize);
 582   if (TransformPersistence.Flags)
 583   {
 584     aCtx->ProjectionState.Pop();
 585     aCtx->WorldViewState.Pop();
 586     aCtx->ApplyProjectionMatrix();
 587   }
 588
 589   // Restore highlight color
 590   theWorkspace->HighlightColor = aHighlightColor;
 591
 592   // Restore aspects
 593   theWorkspace->SetAspectLine   (aPrevAspectLine);
 594   theWorkspace->SetAspectFace   (aPrevAspectFace);
 595   theWorkspace->SetAspectMarker (aPrevAspectMarker);
 596   theWorkspace->SetAspectText   (aPrevAspectText);
 597
 598   // Apply highlight box
 599   if (!myHighlightBox.IsNull())
 600   {
 601     myHighlightBox->Render (theWorkspace);
 602   }
 603
 604   // Restore named status
 605   theWorkspace->SetHighlight (false);
 606 }
 607
 608 // =======================================================================
 609 // function : Release
 610 // purpose  :
 611 // =======================================================================
 612 void OpenGl_Structure::Release (const Handle(OpenGl_Context)& theGlCtx)
 613 {
 614   // Release groups
 615   Clear (theGlCtx);
 616   clearHighlightColor (theGlCtx);
 617 }
 618
 619 // =======================================================================
 620 // function : ReleaseGlResources
 621 // purpose  :
 622 // =======================================================================
 623 void OpenGl_Structure::ReleaseGlResources (const Handle(OpenGl_Context)& theGlCtx)
 624 {
 625   for (OpenGl_Structure::GroupIterator aGroupIter (myGroups); aGroupIter.More(); aGroupIter.Next())
 626   {
 627     aGroupIter.ChangeValue()->Release (theGlCtx);
 628   }
 629   if (!myHighlightBox.IsNull())
 630   {
 631     myHighlightBox->Release (theGlCtx.operator->());
 632   }
 633 }
 634
 635 //=======================================================================
 636 //function : ShadowLink
 637 //purpose  :
 638 //=======================================================================
 639 Handle(Graphic3d_CStructure) OpenGl_Structure::ShadowLink (const Handle(Graphic3d_StructureManager)& theManager) const
 640 {
 641   return new OpenGl_StructureShadow (theManager, this);
 642 }