X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketcherPrs%2FSketcherPrs_SymbolPrs.cpp;h=ad415c53a5d75abd2f790ef593180e8200620750;hb=60a74f80e93d09ce5dce729bfaaba7ec67af8753;hp=d5119b1b15b8245a8a1281bee8510306cb589e7c;hpb=0ab427528dcf2fe28ba3f54a5702cfc7ceb91efb;p=modules%2Fshaper.git

diff --git a/src/SketcherPrs/SketcherPrs_SymbolPrs.cpp b/src/SketcherPrs/SketcherPrs_SymbolPrs.cpp
index d5119b1b1..ad415c53a 100644
--- a/src/SketcherPrs/SketcherPrs_SymbolPrs.cpp
+++ b/src/SketcherPrs/SketcherPrs_SymbolPrs.cpp
@@ -18,7 +18,6 @@
 #include <Graphic3d_BndBox4f.hxx>
 
 #include <SelectMgr_Selection.hxx>
-#include <SelectMgr_SelectionManager.hxx>
 #include <Select3D_SensitivePoint.hxx>
 #include <TopLoc_Location.hxx>
 #include <AIS_InteractiveContext.hxx>
@@ -37,8 +36,6 @@
 #include <OpenGl_PointSprite.hxx>
 #include <OpenGl_VertexBuffer.hxx>
 #include <OpenGl_ShaderManager.hxx>
-#include <OpenGl_VertexBufferCompat.hxx>
-#include <OpenGl_GraphicDriver.hxx>
 
 #ifdef WIN32
 # define FSEP "\\"
@@ -85,6 +82,8 @@ class SketcherPrs_VertexBuffer : public OpenGl_VertexBuffer
 public:
 
   //! Create uninitialized VBO..
+  //! \param theAttribs attributes
+  //! \param theStride a flag
   SketcherPrs_VertexBuffer (const Graphic3d_Attribute* theAttribs,
                         const Standard_Integer     theStride)
   : Stride (theStride), NbAttributes(1)
@@ -100,6 +99,7 @@ public:
     memcpy (Attribs, theAttribs.AttributesArray(), sizeof(Graphic3d_Attribute) * NbAttributes);
   }
 
+  /// Returns True if color attribute is defined
   virtual bool HasColorAttribute() const
   {
     for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter) {
@@ -111,6 +111,7 @@ public:
     return false;
   }
 
+  /// Returns True if normal attribute is defined
   virtual bool HasNormalAttribute() const
   {
     for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter) {
@@ -122,6 +123,8 @@ public:
     return false;
   }
 
+  /// Bind position of the attribute
+  /// \param theGlCtx OpenGl context
   virtual void BindPositionAttribute (const Handle(OpenGl_Context)& theGlCtx) const
   {
     if (!OpenGl_VertexBuffer::IsValid()) {
@@ -145,6 +148,8 @@ public:
     }
   }
 
+  /// Bind all attributes
+  /// \param theGlCtx OpenGl context
   virtual void BindAllAttributes (const Handle(OpenGl_Context)& theGlCtx) const
   {
     if (!OpenGl_VertexBuffer::IsValid())
@@ -165,6 +170,8 @@ public:
     }
   }
 
+  /// Unbind all attributes
+  /// \param theGlCtx OpenGl context
   virtual void UnbindAllAttributes (const Handle(OpenGl_Context)& theGlCtx) const
   {
     if (!OpenGl_VertexBuffer::IsValid())
@@ -179,8 +186,13 @@ public:
 
 public:
 
+  /// Array of attributes
   Graphic3d_Attribute Attribs[1];
+
+  /// A flag
   Standard_Integer    Stride;
+
+  /// Number of attributes
   Standard_Integer NbAttributes;
 };
 
@@ -189,15 +201,21 @@ public:
 class SketcherPrs_Element: public OpenGl_Element
 {
 public:
+  /// Constructor
+  /// \param theObj a presentation
   SketcherPrs_Element(const Handle(SketcherPrs_SymbolPrs)& theObj) : 
   OpenGl_Element(), myObj(theObj) {}
 
+  /// Render the current presentation
+  /// \param theWorkspace OpenGL workspace
   virtual void Render (const Handle(OpenGl_Workspace)& theWorkspace) const
   {
     if (!myObj.IsNull())
       myObj->Render(theWorkspace);
   }
 
+  /// Releases OpenGL resources
+  /// \param theContext OpenGL context
   virtual void Release (OpenGl_Context* theContext) 
   {
     if (!myObj.IsNull())
@@ -231,53 +249,60 @@ std::map<const char*, Handle(Image_AlienPixMap)> SketcherPrs_SymbolPrs::myIconsM
 
 SketcherPrs_SymbolPrs::SketcherPrs_SymbolPrs(ModelAPI_Feature* theConstraint, 
                                              const std::shared_ptr<GeomAPI_Ax3>& thePlane)
- : AIS_InteractiveObject(), myConstraint(theConstraint), myPlane(thePlane)
+ : AIS_InteractiveObject(), myConstraint(theConstraint), myPlane(thePlane), myIsConflicting(false)
 {
   SetAutoHilight(Standard_False);
+  myPntArray = new Graphic3d_ArrayOfPoints(1);
+  myPntArray->AddVertex(0., 0., 0.);
 }
 
 SketcherPrs_SymbolPrs::~SketcherPrs_SymbolPrs()
 {
   SketcherPrs_PositionMgr* aMgr = SketcherPrs_PositionMgr::get();
+  // Empty memory in position manager
   aMgr->deleteConstraint(this);
 }
 
-
+#ifdef _WINDOWS
+#pragma warning( disable : 4996 )
+#endif
 
 Handle(Image_AlienPixMap) SketcherPrs_SymbolPrs::icon()
 {
   if (myIconsMap.count(iconName()) == 1) {
     return myIconsMap[iconName()];
   }
-  char* aEnv = getenv("NewGeomResources");
-  if (aEnv != NULL) {
-    TCollection_AsciiString aFile(aEnv);
-    aFile += FSEP;
-    aFile += iconName();
-    Handle(Image_AlienPixMap) aPixMap = new Image_AlienPixMap();
-    if (aPixMap->Load(aFile)) {
-      myIconsMap[iconName()] = aPixMap;
-      return aPixMap;
-    }
+  // Load icon for the presentation
+  std::string aFile;
+  char* anEnv = getenv("SHAPER_ROOT_DIR");
+  if (anEnv) {
+    aFile = std::string(anEnv);
   } else {
-    static const char aMsg[] = "Error! NewGeomResources environment variable is not defined: constraint images are not found";
-    cout<<aMsg<<endl;
-    Events_Error::send(aMsg);
-    myIconsMap[iconName()] = Handle(Image_AlienPixMap)();
+    anEnv = getenv("OPENPARTS_ROOT_DIR");
+    if (anEnv)
+      aFile = std::string(anEnv);
   }
-  return Handle(Image_AlienPixMap)();
-}
-
-void SketcherPrs_SymbolPrs::ClearSelected()
-{
-  Handle( Prs3d_Presentation ) aSelectionPrs = GetSelectPresentation( NULL );  
-  if( !aSelectionPrs.IsNull() ) {
-    aSelectionPrs->Clear(); 
+  aFile += FSEP;
+  aFile += "resources";
+
+  aFile += FSEP;
+  aFile += iconName();
+  Handle(Image_AlienPixMap) aPixMap = new Image_AlienPixMap();
+  if (aPixMap->Load(aFile.c_str())) {
+    myIconsMap[iconName()] = aPixMap;
+    return aPixMap;
   }
+  // The icon for constraint is not found
+  static const char aMsg[] = "Error! constraint images are not found";
+  cout<<aMsg<<endl;
+  Events_Error::send(aMsg);
+  myIconsMap[iconName()] = Handle(Image_AlienPixMap)();
+  return Handle(Image_AlienPixMap)();
 }
 
 void SketcherPrs_SymbolPrs::prepareAspect()
 {
+  // Create an aspect with the icon
   if (myAspect.IsNull()) {
     Handle(Image_AlienPixMap) aIcon = icon();
     if (aIcon.IsNull()) 
@@ -298,6 +323,7 @@ void SketcherPrs_SymbolPrs::addLine(const Handle(Graphic3d_Group)& theGroup, std
   std::shared_ptr<GeomAPI_Pnt> aPnt1 = aEdge->firstPoint();
   std::shared_ptr<GeomAPI_Pnt> aPnt2 = aEdge->lastPoint();
 
+  // Draw line by two points
   Handle(Graphic3d_ArrayOfSegments) aLines = new Graphic3d_ArrayOfSegments(2, 1);
   aLines->AddVertex(aPnt1->impl<gp_Pnt>());
   aLines->AddVertex(aPnt2->impl<gp_Pnt>());
@@ -318,7 +344,8 @@ void SketcherPrs_SymbolPrs::HilightSelected(const Handle(PrsMgr_PresentationMana
 }
 
 void SketcherPrs_SymbolPrs::HilightOwnerWithColor(const Handle(PrsMgr_PresentationManager3d)& thePM, 
-                                                 const Quantity_NameOfColor theColor, const Handle(SelectMgr_EntityOwner)& theOwner)
+                                                 const Quantity_NameOfColor theColor, 
+                                                 const Handle(SelectMgr_EntityOwner)& theOwner)
 {
   thePM->Color(this, theColor);
 
@@ -334,6 +361,7 @@ void SketcherPrs_SymbolPrs::Compute(const Handle(PrsMgr_PresentationManager3d)&
                                    const Handle(Prs3d_Presentation)& thePresentation, 
                                    const Standard_Integer theMode)
 {
+  // Create an icon
   prepareAspect();
 
   Handle(AIS_InteractiveContext) aCtx = GetContext();
@@ -343,23 +371,28 @@ void SketcherPrs_SymbolPrs::Compute(const Handle(PrsMgr_PresentationManager3d)&
     aDriver->UserDrawCallback() = SymbolPrsCallBack;
   }
 
-  if (!updatePoints(20))
-    return;
+  // Update points with default shift value
+  // it updates array of points if the presentation is ready to display, or the array of points
+  // contains the previous values
+  
+  bool aReadyToDisplay = updateIfReadyToDisplay(20);
 
   int aNbVertex = myPntArray->VertexNumber();
   if (myOwner.IsNull()) {
     myOwner = new SelectMgr_EntityOwner(this);
   }
 
+  // Create sensitive point for each symbol
   mySPoints.Clear();
   for (int i = 1; i <= aNbVertex; i++) {
-    Handle(SketcherPrs_SensitivePoint) aSP = new SketcherPrs_SensitivePoint(myOwner, myPntArray, i);
+    Handle(SketcherPrs_SensitivePoint) aSP = new SketcherPrs_SensitivePoint(myOwner, i);
     mySPoints.Append(aSP);
   }
 
   Handle(Graphic3d_Group) aGroup = Prs3d_Root::NewGroup(thePresentation);
   aGroup->SetPrimitivesAspect(myAspect);
 
+  // Recompute boundary box of the group
   Graphic3d_BndBox4f& aBnd = aGroup->ChangeBoundingBox();
   gp_Pnt aVert;
   aBnd.Clear();
@@ -368,14 +401,22 @@ void SketcherPrs_SymbolPrs::Compute(const Handle(PrsMgr_PresentationManager3d)&
     aBnd.Add (Graphic3d_Vec4((float)aVert.X(), (float)aVert.Y(), (float)aVert.Z(), 1.0f));
   }
 
+  // Pint the group with custom procedure (see Render)
   aGroup->UserDraw(this, true);
+
+  // Disable frustum culling for this object by marking it as mutable
+  aGroup->Structure()->SetMutable(true);
   //aGroup->AddPrimitiveArray(myPntArray);
+
+  if (!aReadyToDisplay)
+    SketcherPrs_Tools::sendEmptyPresentationError(myConstraint,
+                          "An empty AIS presentation: SketcherPrs_LengthDimension");
 }
 
 
 
 void SketcherPrs_SymbolPrs::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,
-                                            const Standard_Integer aMode)
+                                             const Standard_Integer aMode)
 {
   ClearSelected();
   if ((aMode == 0) || (aMode == SketcherPrs_Tools::Sel_Constraint)) {
@@ -384,16 +425,46 @@ void SketcherPrs_SymbolPrs::ComputeSelection(const Handle(SelectMgr_Selection)&
   }
 }
 
+void SketcherPrs_SymbolPrs::SetConflictingConstraint(const bool& theConflicting,
+                                                     const std::vector<int>& theColor)
+{
+  if (theConflicting)
+  {
+    if (!myAspect.IsNull())
+      myAspect->SetColor (Quantity_Color (theColor[0] / 255., theColor[1] / 255., theColor[2] / 255.,
+                          Quantity_TOC_RGB));
+    myIsConflicting = true;
+  }
+  else
+  {
+    if (!myAspect.IsNull())
+      myAspect->SetColor (Quantity_Color (1.0, 1.0, 0.0, Quantity_TOC_RGB));
+    myIsConflicting = false;
+  }
+}
 
 void SketcherPrs_SymbolPrs::Render(const Handle(OpenGl_Workspace)& theWorkspace) const
 {
+  // this method is a combination of OCCT OpenGL functions. The main purpose is to have
+  // equal distance from the source object to symbol indpendently of zoom.
+  // It is base on OCCT 6.9.1 and might need changes when using later OCCT versions.
+  // The specific SHAPER modifications are marked by ShaperModification:start/end, other is OCCT code
+
+  // do not update presentation for invalid or already removed objects: the presentation
+  // should be removed soon
+  if (!myConstraint->data().get() || !myConstraint->data()->isValid())
+    return;
+
   const OpenGl_AspectMarker* anAspectMarker = theWorkspace->AspectMarker(Standard_True);
   const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
   Handle(OpenGl_View) aView = theWorkspace->ActiveView();
   
+  // ShaperModification:start
   double aScale = aView->Camera()->Scale();
-  if (!updatePoints(MyDist * aScale))
-    return;
+  // Update points coordinate taking the viewer scale into account
+  updateIfReadyToDisplay(MyDist * aScale);
+
+  // ShaperModification:end
 
   Handle(Graphic3d_Buffer) aAttribs = myPntArray->Attributes();
 
@@ -401,6 +472,7 @@ void SketcherPrs_SymbolPrs::Render(const Handle(OpenGl_Workspace)& theWorkspace)
     myVboAttribs = new SketcherPrs_VertexBuffer(*aAttribs);
   }
 
+  // Update drawing attributes
   if (!myVboAttribs->init(aCtx, 0, aAttribs->NbElements, aAttribs->Data(), GL_NONE, aAttribs->Stride)) {
     myVboAttribs->Release (aCtx.operator->());
     myVboAttribs.Nullify();
@@ -412,7 +484,10 @@ void SketcherPrs_SymbolPrs::Render(const Handle(OpenGl_Workspace)& theWorkspace)
   const Handle(OpenGl_PointSprite)& aSpriteNorm = anAspectMarker->SpriteRes(aCtx);
       
   if (!aSpriteNorm.IsNull() && !aSpriteNorm->IsDisplayList()) {
-    const bool toHilight = (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT) != 0;
+    // ShaperModification:start : filling the presentation with color if there is a conflict
+    const bool toHilight = (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT) != 0 || myIsConflicting;
+    // ShaperModification:end
+
     const Handle(OpenGl_PointSprite)& aSprite = (toHilight && anAspectMarker->SpriteHighlightRes(aCtx)->IsValid())
                                               ? anAspectMarker->SpriteHighlightRes(aCtx)
                                               : aSpriteNorm;
@@ -422,6 +497,12 @@ void SketcherPrs_SymbolPrs::Render(const Handle(OpenGl_Workspace)& theWorkspace)
     if (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT)
       aLineColor = theWorkspace->HighlightColor;
 
+    // Set lighting of the symbol
+    if (toHilight)
+      aCtx->core11fwd->glDisable (GL_LIGHTING);
+    else
+      aCtx->core11fwd->glEnable (GL_LIGHTING);
+
     aCtx->SetColor4fv(*(const OpenGl_Vec4* )(aLineColor->rgb));
 
 
@@ -446,12 +527,16 @@ void SketcherPrs_SymbolPrs::Render(const Handle(OpenGl_Workspace)& theWorkspace)
   // Update selection position only if there is no selected object
   // because it can corrupt selection of other objects
   if ((GetContext()->NbCurrents() == 0) && (GetContext()->NbSelected() == 0))
-    GetContext()->RecomputeSelectionOnly(this);
+  {
+    GetContext()->MainSelector()->RebuildSensitivesTree (this);
+    GetContext()->MainSelector()->RebuildObjectsTree (false);
+  }
 }
 
 
 void SketcherPrs_SymbolPrs::Release (OpenGl_Context* theContext)
 {
+  // Release OpenGl resources
   if (!myVboAttribs.IsNull()) {
     if (theContext) {
       theContext->DelayedRelease (myVboAttribs);
@@ -464,16 +549,20 @@ void SketcherPrs_SymbolPrs::drawShape(const std::shared_ptr<GeomAPI_Shape>& theS
                                       const Handle(Prs3d_Presentation)& thePrs) const
 {
   if (theShape->isEdge()) {
+    // The shape is edge
     std::shared_ptr<GeomAPI_Curve> aCurve = 
       std::shared_ptr<GeomAPI_Curve>(new GeomAPI_Curve(theShape));
     if (aCurve->isLine()) {
+      // The shape is line
       GeomAdaptor_Curve aCurv(aCurve->impl<Handle(Geom_Curve)>(), aCurve->startParam(), aCurve->endParam());
       StdPrs_Curve::Add(thePrs, aCurv, myDrawer);
     } else {
+      // The shape is circle or arc
       GeomAdaptor_Curve aAdaptor(aCurve->impl<Handle(Geom_Curve)>(), aCurve->startParam(), aCurve->endParam());
       StdPrs_DeflectionCurve::Add(thePrs,aAdaptor,myDrawer);
     }
   } else if (theShape->isVertex()) {
+    // draw vertex
     std::shared_ptr<GeomAPI_Vertex> aVertex = 
       std::shared_ptr<GeomAPI_Vertex>(new GeomAPI_Vertex(theShape));
     std::shared_ptr<GeomAPI_Pnt> aPnt = aVertex->point();
@@ -498,3 +587,15 @@ void SketcherPrs_SymbolPrs::drawListOfShapes(const std::shared_ptr<ModelAPI_Attr
   }
 }
 
+void SketcherPrs_SymbolPrs::BoundingBox (Bnd_Box& theBndBox)
+{
+  Select3D_BndBox3d aTmpBox;
+  for (Select3D_EntitySequenceIter aPntIter (mySPoints); aPntIter.More(); aPntIter.Next()) {
+    const Handle(Select3D_SensitiveEntity)& anEnt = aPntIter.Value();
+    aTmpBox.Combine (anEnt->BoundingBox());
+  }
+
+  theBndBox.Update (aTmpBox.CornerMin().x(), aTmpBox.CornerMin().y(), aTmpBox.CornerMin().z(),
+                    aTmpBox.CornerMax().x(), aTmpBox.CornerMax().y(), aTmpBox.CornerMax().z());
+}
+