0022777: Visualization - Unsafe way to get attribute values from MeshVS_Drawer
[occt.git] / src / MeshVS / MeshVS_ElementalColorPrsBuilder.cxx
old mode 100755 (executable)
new mode 100644 (file)
index 32304c5..7ceb269
@@ -1,58 +1,57 @@
 // Created on: 2003-11-12
 // Created by: Alexander SOLOVYOV
-// Copyright (c) 2003-2012 OPEN CASCADE SAS
+// Copyright (c) 2003-2014 OPEN CASCADE SAS
 //
-// The content of this file is subject to the Open CASCADE Technology Public
-// License Version 6.5 (the "License"). You may not use the content of this file
-// except in compliance with the License. Please obtain a copy of the License
-// at http://www.opencascade.org and read it completely before using this file.
+// This file is part of Open CASCADE Technology software library.
 //
-// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
-// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
 //
-// The Original Code and all software distributed under the License is
-// distributed on an "AS IS" basis, without warranty of any kind, and the
-// Initial Developer hereby disclaims all such warranties, including without
-// limitation, any warranties of merchantability, fitness for a particular
-// purpose or non-infringement. Please see the License for the specific terms
-// and conditions governing the rights and limitations under the License.
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
 
 
-#include <MeshVS_ElementalColorPrsBuilder.ixx>
-
-#include <Graphic3d_AspectFillArea3d.hxx>
-#include <Graphic3d_AspectLine3d.hxx>
 #include <Graphic3d_ArrayOfPolygons.hxx>
 #include <Graphic3d_ArrayOfPolylines.hxx>
+#include <Graphic3d_ArrayOfSegments.hxx>
+#include <Graphic3d_ArrayOfTriangles.hxx>
+#include <Graphic3d_AspectFillArea3d.hxx>
+#include <Graphic3d_AspectLine3d.hxx>
 #include <Graphic3d_Group.hxx>
-
-#include <Prs3d_ShadingAspect.hxx>
-#include <Prs3d_Root.hxx>
-#include <Prs3d_LineAspect.hxx>
-
-#include <TColStd_MapOfInteger.hxx>
-#include <TColStd_PackedMapOfInteger.hxx>
-#include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
-#include <TColStd_ListIteratorOfListOfInteger.hxx>
-#include <TColStd_Array1OfReal.hxx>
-#include <TColStd_SequenceOfInteger.hxx>
-#include <TColStd_HArray1OfReal.hxx>
-#include <TColStd_HPackedMapOfInteger.hxx>
-
-#include <MeshVS_DisplayModeFlags.hxx>
-#include <MeshVS_DataSource.hxx>
-#include <MeshVS_Mesh.hxx>
+#include <MeshVS_Buffer.hxx>
+#include <MeshVS_DataMapIteratorOfDataMapOfColorMapOfInteger.hxx>
+#include <MeshVS_DataMapIteratorOfDataMapOfIntegerColor.hxx>
+#include <MeshVS_DataMapIteratorOfDataMapOfIntegerTwoColors.hxx>
+#include <MeshVS_DataMapIteratorOfDataMapOfTwoColorsMapOfInteger.hxx>
 #include <MeshVS_DataMapOfColorMapOfInteger.hxx>
 #include <MeshVS_DataMapOfTwoColorsMapOfInteger.hxx>
+#include <MeshVS_DataSource.hxx>
+#include <MeshVS_DisplayModeFlags.hxx>
 #include <MeshVS_Drawer.hxx>
 #include <MeshVS_DrawerAttribute.hxx>
-#include <MeshVS_DataMapIteratorOfDataMapOfIntegerTwoColors.hxx>
-#include <MeshVS_DataMapIteratorOfDataMapOfIntegerColor.hxx>
-#include <MeshVS_DataMapIteratorOfDataMapOfTwoColorsMapOfInteger.hxx>
-#include <MeshVS_DataMapIteratorOfDataMapOfColorMapOfInteger.hxx>
+#include <MeshVS_ElementalColorPrsBuilder.hxx>
+#include <MeshVS_HArray1OfSequenceOfInteger.hxx>
+#include <MeshVS_Mesh.hxx>
 #include <MeshVS_MeshPrsBuilder.hxx>
-#include <MeshVS_Buffer.hxx>
+#include <Prs3d_LineAspect.hxx>
+#include <Prs3d_Presentation.hxx>
+#include <Prs3d_Root.hxx>
+#include <Prs3d_ShadingAspect.hxx>
+#include <Quantity_Color.hxx>
+#include <Standard_Type.hxx>
+#include <TColStd_Array1OfReal.hxx>
+#include <TColStd_HArray1OfReal.hxx>
+#include <TColStd_HPackedMapOfInteger.hxx>
+#include <TColStd_ListIteratorOfListOfInteger.hxx>
+#include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
+#include <TColStd_MapOfInteger.hxx>
+#include <TColStd_PackedMapOfInteger.hxx>
+#include <TColStd_SequenceOfInteger.hxx>
 
+IMPLEMENT_STANDARD_RTTIEXT(MeshVS_ElementalColorPrsBuilder,MeshVS_PrsBuilder)
 
 //================================================================
 // Function : Constructor MeshVS_ElementalColorPrsBuilder
@@ -178,16 +177,14 @@ void MeshVS_ElementalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)&
   }
 
   //Now we are ready to draw faces with equal colors
-  Aspect_InteriorStyle aStyle;
-  Standard_Integer     aStyleInt;
   Aspect_TypeOfLine    anEdgeType = Aspect_TOL_SOLID;
   Aspect_TypeOfLine    aLineType = Aspect_TOL_SOLID;
-  Standard_Integer     anEdgeInt, aLineInt;
-  Standard_Real        anEdgeWidth, aLineWidth;
+  Standard_Real        anEdgeWidth = 1.0, aLineWidth = 1.0;
   Quantity_Color       anInteriorColor;
   Quantity_Color       anEdgeColor, aLineColor;
   Standard_Boolean     anEdgeOn = Standard_True, IsReflect = Standard_False,
                        IsMeshSmoothShading = Standard_False;
+  Standard_Boolean toSupressBackFaces = Standard_False;
 
   aDrawer->GetColor  ( MeshVS_DA_InteriorColor, anInteriorColor );
   aDrawer->GetColor  ( MeshVS_DA_EdgeColor, anEdgeColor );
@@ -197,13 +194,13 @@ void MeshVS_ElementalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)&
   aDrawer->GetBoolean( MeshVS_DA_ShowEdges, anEdgeOn );
   aDrawer->GetBoolean( MeshVS_DA_ColorReflection, IsReflect );
   aDrawer->GetBoolean( MeshVS_DA_SmoothShading, IsMeshSmoothShading );
+  aDrawer->GetBoolean (MeshVS_DA_SupressBackFaces, toSupressBackFaces);
 
-  if ( aDrawer->GetInteger ( MeshVS_DA_InteriorStyle, aStyleInt) )
-    aStyle = (Aspect_InteriorStyle) aStyleInt;
-
+  Standard_Integer anEdgeInt = Aspect_TOL_SOLID;
   if ( aDrawer->GetInteger ( MeshVS_DA_EdgeType, anEdgeInt) )
     anEdgeType = (Aspect_TypeOfLine) anEdgeInt;
 
+  Standard_Integer aLineInt = Aspect_TOL_SOLID;
   if ( aDrawer->GetInteger ( MeshVS_DA_BeamType, aLineInt) )
     aLineType = (Aspect_TypeOfLine) aLineInt;
 
@@ -219,14 +216,14 @@ void MeshVS_ElementalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)&
             PolygonVerticesFor3D, PolygonBoundsFor3D );
   }
 
-  Graphic3d_MaterialAspect aMaterial[2];
-  Standard_Integer i;
-  for ( i=0; i<2; i++ )
+  Graphic3d_MaterialAspect aMaterial[2] = { Graphic3d_NOM_PLASTIC, Graphic3d_NOM_PLASTIC };
+  for (Standard_Integer i = 0; i < 2; i++)
   {
     // OCC20644 "plastic" is most suitable here, as it is "non-physic"
     // so TelUpdateMaterial() from OpenGl_attri.c uses the interior
     // color from AspectFillArea3d to calculate all material colors
-    aMaterial[i] = Graphic3d_MaterialAspect ( Graphic3d_NOM_PLASTIC );
+    aMaterial[i].SetSpecularColor (Quantity_NOC_BLACK);
+    aMaterial[i].SetEmissiveColor (Quantity_NOC_BLACK);
 
     // OCC21720 For single-colored elements turning all material components off is a good idea,
     // as anyhow the normals are not computed and the lighting will be off,
@@ -234,10 +231,8 @@ void MeshVS_ElementalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)&
     // and there is no need to spend time on updating material properties 
     if ( !IsReflect )
     {
-      aMaterial[i].SetReflectionModeOff(Graphic3d_TOR_AMBIENT);
-      aMaterial[i].SetReflectionModeOff(Graphic3d_TOR_DIFFUSE);
-      aMaterial[i].SetReflectionModeOff(Graphic3d_TOR_SPECULAR);
-      aMaterial[i].SetReflectionModeOff(Graphic3d_TOR_EMISSION);
+      aMaterial[i].SetAmbientColor (Quantity_NOC_BLACK);
+      aMaterial[i].SetDiffuseColor (Quantity_NOC_BLACK);
     }
     else
     {
@@ -246,155 +241,252 @@ void MeshVS_ElementalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)&
       // those in the color scale most exactly (the sum of all reflection 
       // coefficients is equal to 1). See also MeshVS_NodalColorPrsBuilder
       // class for more explanations.
-      aMaterial[i].SetAmbient( .5 );
-      aMaterial[i].SetDiffuse( .5 );
-      aMaterial[i].SetSpecular( 0. );
-      aMaterial[i].SetEmissive( 0. );
+      aMaterial[i].SetAmbientColor (Quantity_Color (Graphic3d_Vec3 (0.5f)));
+      aMaterial[i].SetDiffuseColor (Quantity_Color (Graphic3d_Vec3 (0.5f)));
     }
   }
 
   // Draw elements with one color
-  for ( MeshVS_DataMapIteratorOfDataMapOfColorMapOfInteger aColIter ( aColorsOfElements ); aColIter.More();
-        aColIter.Next() )
+  Handle(Graphic3d_Group) aGGroup, aGroup2, aLGroup, aSGroup;
+  if (!aTwoColorsOfElements.IsEmpty())
+  {
+    aGroup2 = Prs3d_Root::NewGroup (Prs);
+  }
+  if (!aColorsOfElements.IsEmpty())
   {
-    Standard_Integer aSize = aColIter.Value().Extent();
-    if ( aSize<=0 )
+    Handle(Graphic3d_AspectFillArea3d) aGroupFillAspect = new Graphic3d_AspectFillArea3d (Aspect_IS_SOLID, anInteriorColor, anEdgeColor,
+                                                                                          anEdgeType, anEdgeWidth, aMaterial[0], aMaterial[1]);
+    aGGroup = Prs3d_Root::NewGroup (Prs);
+    aLGroup = Prs3d_Root::NewGroup (Prs);
+    aGGroup->SetClosed (toSupressBackFaces == Standard_True);
+    aGGroup->SetGroupPrimitivesAspect (aGroupFillAspect);
+  }
+
+  if (anEdgeOn)
+  {
+    Handle(Graphic3d_AspectLine3d) anEdgeAspect = new Graphic3d_AspectLine3d (anEdgeColor, anEdgeType, anEdgeWidth);
+    aSGroup = Prs3d_Root::NewGroup (Prs);
+    aSGroup->SetGroupPrimitivesAspect (anEdgeAspect);
+  }
+
+  for (MeshVS_DataMapIteratorOfDataMapOfColorMapOfInteger aColIter (aColorsOfElements);
+       aColIter.More(); aColIter.Next())
+  {
+    if (aColIter.Value().IsEmpty())
+    {
       continue;
+    }
 
     TColStd_PackedMapOfInteger aCustomElements;
 
-    Prs3d_Root::NewGroup ( Prs );
-    Handle ( Graphic3d_Group ) aGGroup = Prs3d_Root::CurrentGroup ( Prs );
-    Prs3d_Root::NewGroup ( Prs );
-    Handle ( Graphic3d_Group ) aLGroup = Prs3d_Root::CurrentGroup ( Prs );
+    Standard_Integer aNbFacePrimitives = 0;
+    Standard_Integer aNbVolmPrimitives = 0;
+    Standard_Integer aNbEdgePrimitives = 0;
+    Standard_Integer aNbLinkPrimitives = 0;
 
-    Handle (Graphic3d_ArrayOfPolygons) aPolyGArr = new Graphic3d_ArrayOfPolygons
-      ( aMaxFaceNodes*aSize + PolygonVerticesFor3D, aSize + PolygonBoundsFor3D, 0, IsReflect );
+    for (it.Reset(); it.More(); it.Next())
+    {
+      Standard_Integer aNbNodes = 0;
+
+      if (!aColIter.Value().Contains (it.Key()))
+        continue;
+
+      if (!aSource->GetGeom (it.Key(), Standard_True, aCoords, aNbNodes, aType))
+        continue;
+
+      if (aType == MeshVS_ET_Volume)
+      {
+        if (aSource->Get3DGeom (it.Key(), aNbNodes, aTopo))
+        {
+          for (Standard_Integer aFaceIdx = aTopo->Lower(); aFaceIdx <= aTopo->Upper(); ++aFaceIdx)
+          {
+            const TColStd_SequenceOfInteger& aFaceNodes = aTopo->Value (aFaceIdx);
+
+            if (anEdgeOn) // add edge segments
+            {
+              aNbEdgePrimitives += aFaceNodes.Length();
+            }
+
+            aNbVolmPrimitives += aFaceNodes.Length() - 2;
+          }
+        }
+      }
+      else if (aType == MeshVS_ET_Link)
+      {
+        if (anEdgeOn)
+        {
+          aNbLinkPrimitives += aNbNodes - 1; // add link segments
+        }
+      }
+      else if (aType == MeshVS_ET_Face)
+      {
+        if (anEdgeOn)
+        {
+          aNbEdgePrimitives += aNbNodes; // add edge segments
+        }
+          
+        aNbFacePrimitives += aNbNodes - 2; // add face triangles
+      }
+    }
+
+    // Here we do not use indices arrays because they are not effective for some mesh
+    // drawing modes: shrinking mode (displaces the vertices inside the polygon), 3D
+    // cell rendering (normal interpolation is not always applicable - flat shading),
+    // elemental coloring (color interpolation is impossible)
+
+    Handle (Graphic3d_ArrayOfTriangles) aFaceTriangles = new Graphic3d_ArrayOfTriangles (
+     (aNbFacePrimitives + aNbVolmPrimitives) * 3, 0, IsReflect );
     Standard_Boolean IsPolyG = Standard_False;
 
-    Handle (Graphic3d_ArrayOfPolylines) aPolyLArr = new Graphic3d_ArrayOfPolylines
-      ( 2*aSize, aSize );
+    Handle (Graphic3d_ArrayOfSegments) anEdgeSegments = new Graphic3d_ArrayOfSegments (aNbEdgePrimitives * 2);
+    Handle (Graphic3d_ArrayOfSegments) aLinkSegments = new Graphic3d_ArrayOfSegments (aNbLinkPrimitives * 2);
     Standard_Boolean IsPolyL = Standard_False;
 
     // OCC20644 NOTE: aColIter.Key() color is then scaled by TelUpdateMaterial() in OpenGl_attri.c
     // using the material reflection coefficients. This affects the visual result.
-    Handle(Graphic3d_AspectFillArea3d) anAsp =
+    Handle(Graphic3d_AspectFillArea3d) aFillAspect =
       new Graphic3d_AspectFillArea3d ( Aspect_IS_SOLID, aColIter.Key(), anEdgeColor,
                                        anEdgeType, anEdgeWidth, aMaterial[0], aMaterial[1] );
 
-    Handle(Graphic3d_AspectLine3d) anLAsp =
+    Handle(Graphic3d_AspectLine3d) aLinkAspect =
       new Graphic3d_AspectLine3d ( aColIter.Key(), aLineType, aLineWidth );
 
-    anAsp->SetDistinguishOff ();
-    anAsp->SetInteriorColor ( aColIter.Key() );
-    if (anEdgeOn)
-      anAsp->SetEdgeOn();
-    else
-      anAsp->SetEdgeOff();
+    aFillAspect->SetDistinguishOff ();
+    aFillAspect->SetInteriorColor ( aColIter.Key() );
+    aFillAspect->SetEdgeOff();
 
-    for( it.Reset(); it.More(); it.Next() )
+    for (it.Reset(); it.More(); it.Next())
     {
       Standard_Integer aKey = it.Key();
-      if( aColIter.Value().Contains( aKey ) )
+      
+      if (aColIter.Value().Contains (aKey))
       {
-        if ( !aSource->GetGeom  ( aKey, Standard_True, aCoords, NbNodes, aType ) )
+        if (!aSource->GetGeom (aKey, Standard_True, aCoords, NbNodes, aType))
           continue;
-
-        if( aType == MeshVS_ET_Face )
+        
+        if (aType != MeshVS_ET_Face && aType != MeshVS_ET_Link && aType != MeshVS_ET_Volume)
         {
-          aPolyGArr->AddBound ( NbNodes );
-          if( IsExcludingOn() )
-            IDsToExclude.Add( aKey );
-        }
-        else if( aType == MeshVS_ET_Link )
-        {
-          aPolyLArr->AddBound ( NbNodes );
-          if( IsExcludingOn() )
-            IDsToExclude.Add( aKey );
+          aCustomElements.Add (aKey);
+          continue;
         }
-        else if( aType == MeshVS_ET_Volume )
+        
+        if (IsExcludingOn())
+          IDsToExclude.Add (aKey);
+          
+        if (aType == MeshVS_ET_Volume)
         {
-          if( IsExcludingOn() )
-            IDsToExclude.Add( aKey );
-          if( aSource->Get3DGeom( aKey, NbNodes, aTopo ) )
+          if (!aSource->Get3DGeom (aKey, NbNodes, aTopo))
           {
-            MeshVS_MeshPrsBuilder::AddVolumePrs( aTopo, aCoords, NbNodes, aPolyGArr, IsReflect, Standard_False, Standard_False, 1.0 );
-            IsPolyG = Standard_True;
-          }
-          else
             continue;
+          }
+          
+          MeshVS_MeshPrsBuilder::AddVolumePrs (aTopo, aCoords,
+            NbNodes, aFaceTriangles, IsReflect, Standard_False, Standard_False, 1.0);
+
+          if (anEdgeOn)
+          {
+            MeshVS_MeshPrsBuilder::AddVolumePrs (aTopo, aCoords,
+              NbNodes, anEdgeSegments, IsReflect, Standard_False, Standard_False, 1.0);
+          }
+
+          IsPolyG = Standard_True;
         }
-        else
+        else if (aType == MeshVS_ET_Face)
         {
-          aCustomElements.Add( aKey );
-          continue;
-        }
+          // Preparing normals
+          Handle(TColStd_HArray1OfReal) aNormals;
+          Standard_Boolean aHasNormals = IsReflect && aSource->GetNormalsByElement (aKey, IsMeshSmoothShading, aMaxFaceNodes, aNormals);
 
-        // Preparing normal(s) to show reflections if requested
-        Handle(TColStd_HArray1OfReal) aNormals;
-        Standard_Boolean hasNormals = IsReflect && aSource->GetNormalsByElement( aKey, IsMeshSmoothShading, aMaxFaceNodes, aNormals );
+          for (Standard_Integer aNodeIdx = 0; aNodeIdx < NbNodes - 2; ++aNodeIdx)
+          {
+            for (Standard_Integer anIdx = 0; anIdx < 3; ++anIdx)
+            {
+              if (IsReflect)
+              {
+                aFaceTriangles->AddVertex (aCoords (3 * (anIdx == 0 ? 0 : (aNodeIdx + anIdx)) + 1),
+                                           aCoords (3 * (anIdx == 0 ? 0 : (aNodeIdx + anIdx)) + 2),
+                                           aCoords (3 * (anIdx == 0 ? 0 : (aNodeIdx + anIdx)) + 3),
+                                           aHasNormals ? aNormals->Value (3 * (anIdx == 0 ? 0 : (aNodeIdx + anIdx)) + 1) : 0.0,
+                                           aHasNormals ? aNormals->Value (3 * (anIdx == 0 ? 0 : (aNodeIdx + anIdx)) + 2) : 0.0,
+                                           aHasNormals ? aNormals->Value (3 * (anIdx == 0 ? 0 : (aNodeIdx + anIdx)) + 3) : 1.0);
+              }
+              else
+              {
+                aFaceTriangles->AddVertex (aCoords (3 * (anIdx == 0 ? 0 : (aNodeIdx + anIdx)) + 1),
+                                           aCoords (3 * (anIdx == 0 ? 0 : (aNodeIdx + anIdx)) + 2),
+                                           aCoords (3 * (anIdx == 0 ? 0 : (aNodeIdx + anIdx)) + 3));
+              }
+            }
+          }
 
-        // Adding vertices (with normals if necessary)
-        for ( i=1; i<=NbNodes; i++ )
-          if ( aType == MeshVS_ET_Face )
+          if (anEdgeOn)
           {
-            if ( IsReflect )
+            for (Standard_Integer aNodeIdx = 0; aNodeIdx < NbNodes; ++aNodeIdx)
             {
-              hasNormals ? aPolyGArr->AddVertex ( aCoords(3 * i - 2), 
-                                                  aCoords(3 * i - 1), 
-                                                  aCoords(3 * i    ),
-                                                  aNormals->Value(3 * i - 2), 
-                                                  aNormals->Value(3 * i - 1), 
-                                                  aNormals->Value(3 * i    ) ) :
-                           aPolyGArr->AddVertex ( aCoords(3 * i - 2), 
-                                                  aCoords(3 * i - 1), 
-                                                  aCoords(3 * i    ),
-                                                  0., 
-                                                  0., 
-                                                  1. );
+              const Standard_Integer aNextIdx = (aNodeIdx + 1) % NbNodes;
+
+              anEdgeSegments->AddVertex (aCoords (3 * aNodeIdx + 1),
+                                         aCoords (3 * aNodeIdx + 2),
+                                         aCoords (3 * aNodeIdx + 3));
+              
+              anEdgeSegments->AddVertex (aCoords (3 * aNextIdx + 1),
+                                         aCoords (3 * aNextIdx + 2),
+                                         aCoords (3 * aNextIdx + 3));
             }
-            else
-              aPolyGArr->AddVertex ( aCoords(3 * i - 2), 
-                                     aCoords(3 * i - 1), 
-                                     aCoords(3 * i    ) );
-            IsPolyG = Standard_True;
           }
-          else if ( aType == MeshVS_ET_Link )
+
+          IsPolyG = Standard_True;
+        }
+        else if (aType == MeshVS_ET_Link)
+        {
+          for (Standard_Integer aNodeIdx = 0; aNodeIdx < NbNodes - 1; ++aNodeIdx)
           {
-            aPolyLArr->AddVertex ( aCoords(3*i-2), aCoords(3*i-1), aCoords(3*i) );
+            const Standard_Integer aNextIdx = aNodeIdx + 1;
+
+            aLinkSegments->AddVertex (aCoords (3 * aNodeIdx + 1),
+                                      aCoords (3 * aNodeIdx + 2),
+                                      aCoords (3 * aNodeIdx + 3));
+
+            aLinkSegments->AddVertex (aCoords (3 * aNextIdx + 1),
+                                      aCoords (3 * aNextIdx + 2),
+                                      aCoords (3 * aNextIdx + 3));
+
             IsPolyL = Standard_True;
           }
+        }
       }
     }
 
-    if ( IsPolyG )
+    if (IsPolyG)
     {
-      aGGroup->SetPrimitivesAspect ( anAsp );
-      aGGroup->AddPrimitiveArray ( aPolyGArr );
+      aGGroup->SetPrimitivesAspect (aFillAspect);
+      aGGroup->AddPrimitiveArray (aFaceTriangles);
+      aGGroup->SetClosed (toSupressBackFaces == Standard_True);
+      
+      if (anEdgeOn)
+      {
+        aSGroup->AddPrimitiveArray (anEdgeSegments);
+      }
     }
-    if ( IsPolyL )
+    if (IsPolyL)
     {
-      anAsp->SetEdgeOff();
-      aLGroup->SetPrimitivesAspect ( anAsp );
-      aLGroup->SetPrimitivesAspect ( anLAsp );
-      aLGroup->AddPrimitiveArray ( aPolyLArr );
-      if (anEdgeOn)
-        anAsp->SetEdgeOn();
-      else
-        anAsp->SetEdgeOff();
+      aLGroup->SetPrimitivesAspect (aFillAspect);
+      aLGroup->SetPrimitivesAspect (aLinkAspect);
+      aLGroup->AddPrimitiveArray (aLinkSegments);
     }
 
-    if( !aCustomElements.IsEmpty() )
-      CustomBuild( Prs, aCustomElements, IDsToExclude, DisplayMode );
+    if (!aCustomElements.IsEmpty())
+      CustomBuild(Prs, aCustomElements, IDsToExclude, DisplayMode);
   }
 
-  Graphic3d_MaterialAspect aMaterial2[2];
-  for ( i=0; i<2; i++ )
+  Graphic3d_MaterialAspect aMaterial2[2] = { Graphic3d_NOM_PLASTIC, Graphic3d_NOM_PLASTIC };
+  for (Standard_Integer i = 0; i < 2; i++)
   {
     // OCC20644 "plastic" is most suitable here, as it is "non-physic"
     // so TelUpdateMaterial() from OpenGl_attri.c uses the interior
     // color from AspectFillArea3d to calculate all material colors
-    aMaterial2[i] = Graphic3d_MaterialAspect ( Graphic3d_NOM_PLASTIC );
+    aMaterial2[i].SetSpecularColor (Quantity_NOC_BLACK);
+    aMaterial2[i].SetEmissiveColor (Quantity_NOC_BLACK);
 
     if ( !IsReflect )
     {
@@ -403,14 +495,8 @@ void MeshVS_ElementalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)&
       // to have different materials for front and back sides!
       // Instead, trying to make material color "nondirectional" with 
       // only ambient component on.
-      aMaterial2[i].SetReflectionModeOn ( Graphic3d_TOR_AMBIENT );
-      aMaterial2[i].SetReflectionModeOff( Graphic3d_TOR_DIFFUSE );
-      aMaterial2[i].SetReflectionModeOff( Graphic3d_TOR_SPECULAR );
-      aMaterial2[i].SetReflectionModeOff( Graphic3d_TOR_EMISSION );
-      aMaterial2[i].SetAmbient ( 1. );
-      aMaterial2[i].SetDiffuse ( 0. );
-      aMaterial2[i].SetSpecular( 0. );
-      aMaterial2[i].SetEmissive( 0. );
+      aMaterial2[i].SetAmbientColor (Quantity_Color (Graphic3d_Vec3 (1.0f)));
+      aMaterial2[i].SetDiffuseColor (Quantity_NOC_BLACK);
     }
     else
     {
@@ -419,26 +505,56 @@ void MeshVS_ElementalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)&
       // those in the color scale most exactly (the sum of all reflection 
       // coefficients is equal to 1). See also MeshVS_NodalColorPrsBuilder
       // class for more explanations.
-      aMaterial2[i].SetAmbient( .5 );
-      aMaterial2[i].SetDiffuse( .5 );
-      aMaterial2[i].SetSpecular( 0. );
-      aMaterial2[i].SetEmissive( 0. );
+      aMaterial2[i].SetAmbientColor (Quantity_Color (Graphic3d_Vec3 (0.5f)));
+      aMaterial2[i].SetDiffuseColor (Quantity_Color (Graphic3d_Vec3 (0.5f)));
     }
   }
 
   // Draw faces with two color
+  if (!aTwoColorsOfElements.IsEmpty())
+  {
+    Handle(Graphic3d_AspectFillArea3d) aGroupFillAspect2 = new Graphic3d_AspectFillArea3d (Aspect_IS_SOLID, anInteriorColor, anEdgeColor,
+                                                                                          anEdgeType, anEdgeWidth, aMaterial2[0], aMaterial2[1]);
+    aGroup2->SetClosed (Standard_False); // ignore toSupressBackFaces
+    aGroup2->SetGroupPrimitivesAspect (aGroupFillAspect2);
+  }
   for ( MeshVS_DataMapIteratorOfDataMapOfTwoColorsMapOfInteger aColIter2 ( aTwoColorsOfElements );
         aColIter2.More(); aColIter2.Next() )
   {
-    Prs3d_Root::NewGroup ( Prs );
-    Handle ( Graphic3d_Group ) aGroup2 = Prs3d_Root::CurrentGroup ( Prs );
-
-    Standard_Integer aSize = aColIter2.Value().Extent();
-    if ( aSize<=0 )
+    if (aColIter2.Value().IsEmpty())
+    {
       continue;
+    }
+
+    Standard_Integer aNbFacePrimitives = 0;
+    Standard_Integer aNbEdgePrimitives = 0;
+    
+    for (it.Reset(); it.More(); it.Next())
+    {
+      Standard_Integer aNbNodes = 0;
+
+      if (!aColIter2.Value().Contains (it.Key()))
+        continue;
 
-    Handle (Graphic3d_ArrayOfPolygons) aPolyArr = new Graphic3d_ArrayOfPolygons
-      ( aMaxFaceNodes*aSize, aSize, 0, IsReflect );
+      if (!aSource->GetGeom (it.Key(), Standard_True, aCoords, aNbNodes, aType))
+        continue;
+
+      if ( aType == MeshVS_ET_Face && aNbNodes > 0 )
+      {
+        if (anEdgeOn)
+        {
+          aNbEdgePrimitives += aNbNodes; // add edge segments
+        }
+
+        aNbFacePrimitives += aNbNodes - 2; // add face triangles
+      }
+    }
+
+    Handle (Graphic3d_ArrayOfTriangles) aFaceTriangles = new Graphic3d_ArrayOfTriangles
+      (aNbFacePrimitives * 3, 0, IsReflect);
+
+    Handle (Graphic3d_ArrayOfSegments) anEdgeSegments = new Graphic3d_ArrayOfSegments
+      (aNbEdgePrimitives * 2);
 
     MeshVS_TwoColors aTC = aColIter2.Key();
     Quantity_Color aMyIntColor, aMyBackColor;
@@ -452,12 +568,11 @@ void MeshVS_ElementalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)&
     anAsp->SetDistinguishOn ();
     anAsp->SetInteriorColor ( aMyIntColor );
     anAsp->SetBackInteriorColor ( aMyBackColor );
-    if (anEdgeOn)
+    /*if (anEdgeOn)
       anAsp->SetEdgeOn();
     else
-      anAsp->SetEdgeOff();
-
-    aGroup2->SetPrimitivesAspect ( anAsp );
+      anAsp->SetEdgeOff();*/
+    aGroup2->SetPrimitivesAspect (anAsp);
 
     for( it.Reset(); it.More(); it.Next() )
     {
@@ -470,43 +585,58 @@ void MeshVS_ElementalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)&
         if( IsExcludingOn() )
           IDsToExclude.Add( aKey );
 
-        if ( aType == MeshVS_ET_Face && NbNodes > 0 )
+        if (aType == MeshVS_ET_Face && NbNodes > 0)
         {
           // Preparing normal(s) to show reflections if requested
           Handle(TColStd_HArray1OfReal) aNormals;
           // OCC21720 Always passing normals to OpenGL to make materials work
           // For OpenGL: "No normals" -> "No lighting" -> "no materials taken into account"
-          Standard_Boolean hasNormals = /*IsReflect &&*/
-            aSource->GetNormalsByElement( aKey, IsMeshSmoothShading, aMaxFaceNodes, aNormals );
+          Standard_Boolean aHasNormals = /*IsReflect &&*/
+            aSource->GetNormalsByElement (aKey, IsMeshSmoothShading, aMaxFaceNodes, aNormals);
 
-          aPolyArr->AddBound ( NbNodes );
+          for (Standard_Integer aNodeIdx = 0; aNodeIdx < NbNodes - 2; ++aNodeIdx)
+          {
+            for (Standard_Integer anIdx = 0; anIdx < 3; ++anIdx)
+            {
+              if (IsReflect)
+              {
+                aFaceTriangles->AddVertex (aCoords (3 * (anIdx == 0 ? 0 : aNodeIdx + anIdx) + 1),
+                                           aCoords (3 * (anIdx == 0 ? 0 : aNodeIdx + anIdx) + 2),
+                                           aCoords (3 * (anIdx == 0 ? 0 : aNodeIdx + anIdx) + 3),
+                                           aHasNormals ? aNormals->Value (3 * (anIdx == 0 ? 0 : aNodeIdx + anIdx) + 1) : 0.0,
+                                           aHasNormals ? aNormals->Value (3 * (anIdx == 0 ? 0 : aNodeIdx + anIdx) + 2) : 0.0,
+                                           aHasNormals ? aNormals->Value (3 * (anIdx == 0 ? 0 : aNodeIdx + anIdx) + 3) : 1.0);
+              }
+              else
+              {
+                aFaceTriangles->AddVertex (aCoords (3 * (anIdx == 0 ? 0 : aNodeIdx + anIdx) + 1),
+                                           aCoords (3 * (anIdx == 0 ? 0 : aNodeIdx + anIdx) + 2),
+                                           aCoords (3 * (anIdx == 0 ? 0 : aNodeIdx + anIdx) + 3));
+              }
+            }
+          }
 
-          for ( i=1; i<=NbNodes; i++ )
+          if (anEdgeOn)
           {
-            if ( IsReflect )
+            for (Standard_Integer aNodeIdx = 0; aNodeIdx < NbNodes; ++aNodeIdx)
             {
-              hasNormals ? aPolyArr->AddVertex ( aCoords(3 * i - 2), 
-                                                 aCoords(3 * i - 1), 
-                                                 aCoords(3 * i    ),
-                                                 aNormals->Value(3 * i - 2), 
-                                                 aNormals->Value(3 * i - 1), 
-                                                 aNormals->Value(3 * i    ) ) :
-                           aPolyArr->AddVertex ( aCoords(3 * i - 2), 
-                                                 aCoords(3 * i - 1), 
-                                                 aCoords(3 * i    ),
-                                                 0., 
-                                                 0., 
-                                                 1. );
+              const Standard_Integer aNextIdx = (aNodeIdx + 1) % NbNodes;
+
+              anEdgeSegments->AddVertex (aCoords (3 * aNodeIdx + 1),
+                                         aCoords (3 * aNodeIdx + 2),
+                                         aCoords (3 * aNodeIdx + 3));
+
+              anEdgeSegments->AddVertex (aCoords (3 * aNextIdx + 1),
+                                         aCoords (3 * aNextIdx + 2),
+                                         aCoords (3 * aNextIdx + 3));
             }
-            else
-              aPolyArr->AddVertex ( aCoords(3*i-2), 
-                                    aCoords(3*i-1), 
-                                    aCoords(3*i  ) );
           }
         }
       }
     }
-    aGroup2->AddPrimitiveArray ( aPolyArr );
+
+    aGroup2->AddPrimitiveArray (aFaceTriangles);
+    aSGroup->AddPrimitiveArray (anEdgeSegments);
   }
 }