src/MeshVS/MeshVS_NodalColorPrsBuilder.cxx

   1 // Created on: 2003-11-12
   2 // Created by: Alexander SOLOVYOV
   3 // Copyright (c) 2003-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 #define _POLYGONES_
  22 // if define _POLYGONES_ ColorPrsBuilder use ArrayOfPolygons for drawing faces
  23
  24 #include <MeshVS_NodalColorPrsBuilder.ixx>
  25
  26 #include <Graphic3d_AspectFillArea3d.hxx>
  27 #include <Graphic3d_AspectLine3d.hxx>
  28 #include <Graphic3d_ArrayOfPolygons.hxx>
  29 #include <Graphic3d_ArrayOfPolylines.hxx>
  30 #include <Graphic3d_Group.hxx>
  31 #include <Graphic3d_TextureParams.hxx>
  32
  33 #include <Prs3d_ShadingAspect.hxx>
  34 #include <Prs3d_Root.hxx>
  35 #include <Prs3d_LineAspect.hxx>
  36
  37 #include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
  38 #include <TColStd_ListIteratorOfListOfInteger.hxx>
  39 #include <TColStd_Array1OfReal.hxx>
  40 #include <TColStd_HArray1OfReal.hxx>
  41 #include <TColStd_Array1OfInteger.hxx>
  42 #include <TColStd_SequenceOfInteger.hxx>
  43 #include <TColStd_HPackedMapOfInteger.hxx>
  44
  45 #include <MeshVS_DisplayModeFlags.hxx>
  46 #include <MeshVS_DrawerAttribute.hxx>
  47 #include <MeshVS_DataSource.hxx>
  48 #include <MeshVS_Drawer.hxx>
  49 #include <MeshVS_Mesh.hxx>
  50 #include <MeshVS_MeshPrsBuilder.hxx>
  51 #include <MeshVS_HArray1OfSequenceOfInteger.hxx>
  52 #include <MeshVS_Buffer.hxx>
  53
  54 #include <gp_Pnt.hxx>
  55 #include <Image_PixMap.hxx>
  56 #include <Graphic3d_Texture2D.hxx>
  57 #include <Graphic3d_TypeOfTextureMode.hxx>
  58 #include <Standard_DefineHandle.hxx>
  59 #include <PrsMgr_PresentationManager3d.hxx>
  60 #include <AIS_Drawer.hxx>
  61 #include <Quantity_Array1OfColor.hxx>
  62 #include <Aspect_SequenceOfColor.hxx>
  63
  64 /*
  65   Class       : MeshVS_ImageTexture2D
  66   Description : Texture for nodal presentation
  67 */
  68 class MeshVS_ImageTexture2D : public Graphic3d_Texture2D
  69 {
  70
  71 public:
  72
  73   MeshVS_ImageTexture2D (const Handle(Image_PixMap)& theImg)
  74   : Graphic3d_Texture2D ("", Graphic3d_TOT_2D),
  75     myImage (theImg)
  76   {
  77     myParams->SetModulate (Standard_True);
  78     myParams->SetFilter   (Graphic3d_TOTF_BILINEAR);
  79   }
  80
  81   virtual ~MeshVS_ImageTexture2D()
  82   {
  83     //
  84   }
  85
  86   virtual Standard_Boolean IsDone() const
  87   {
  88     return !myImage.IsNull() && !myImage->IsEmpty();
  89   }
  90
  91   virtual Handle(Image_PixMap) GetImage() const
  92   {
  93     return myImage;
  94   }
  95
  96 private:
  97
  98   Handle(Image_PixMap) myImage;
  99
 100 public:
 101
 102   DEFINE_STANDARD_RTTI(MeshVS_ImageTexture2D)
 103
 104 };
 105
 106 DEFINE_STANDARD_HANDLE    (MeshVS_ImageTexture2D, Graphic3d_Texture2D)
 107 IMPLEMENT_STANDARD_HANDLE (MeshVS_ImageTexture2D, Graphic3d_Texture2D)
 108 IMPLEMENT_STANDARD_RTTIEXT(MeshVS_ImageTexture2D, Graphic3d_Texture2D)
 109
 110 //================================================================
 111 // Function : getNearestPow2
 112 // Purpose  : Returns the nearest power of two greater than the
 113 //            argument value
 114 //================================================================
 115 static inline Standard_Integer getNearestPow2( Standard_Integer theValue )
 116 {
 117   // Precaution against overflow
 118   Standard_Integer aHalfMax = IntegerLast() >> 1, aRes = 1;
 119   if ( theValue > aHalfMax ) theValue = aHalfMax;
 120   while ( aRes < theValue ) aRes <<= 1;
 121   return aRes;
 122 }
 123
 124 /*
 125   Class       : MeshVS_NodalColorPrsBuilder
 126   Description : This class provides methods to create presentation of
 127                 nodes with assigned color (See hxx for more description )
 128 */
 129
 130 //================================================================
 131 // Function : Constructor MeshVS_NodalColorPrsBuilder
 132 // Purpose  :
 133 //================================================================
 134 MeshVS_NodalColorPrsBuilder::MeshVS_NodalColorPrsBuilder ( const Handle(MeshVS_Mesh)& Parent,
 135                                                            const MeshVS_DisplayModeFlags& Flags,
 136                                                            const Handle (MeshVS_DataSource)& DS,
 137                                                            const Standard_Integer Id,
 138                                                            const MeshVS_BuilderPriority& Priority )
 139 : MeshVS_PrsBuilder ( Parent, Flags, DS, Id, Priority ),
 140   myUseTexture( Standard_False ),
 141   myInvalidColor( Quantity_NOC_GRAY )
 142 {
 143   SetExcluding ( Standard_True );
 144 }
 145
 146 //================================================================
 147 // Function : Build
 148 // Purpose  :
 149 //================================================================
 150 void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
 151                                           const TColStd_PackedMapOfInteger& IDs,
 152                                           TColStd_PackedMapOfInteger& IDsToExclude,
 153                                           const Standard_Boolean IsElement,
 154                                           const Standard_Integer DisplayMode) const
 155 {
 156   Handle (MeshVS_DataSource) aSource = GetDataSource();
 157   Handle (MeshVS_Drawer)     aDrawer = GetDrawer();
 158   if ( aSource.IsNull() || aDrawer.IsNull() )
 159     return;
 160
 161   Standard_Integer aMaxFaceNodes;
 162   if ( !aDrawer->GetInteger ( MeshVS_DA_MaxFaceNodes, aMaxFaceNodes ) || aMaxFaceNodes <= 0 )
 163     return;
 164
 165   MeshVS_Buffer aCoordsBuf (3*aMaxFaceNodes*sizeof(Standard_Real));
 166   TColStd_Array1OfReal aCoords ( aCoordsBuf, 1, 3 * aMaxFaceNodes );
 167   Standard_Integer NbNodes;
 168   MeshVS_EntityType aType;
 169
 170   if ( !( DisplayMode & GetFlags() ) || !IsElement )
 171     return;
 172
 173   if ( myUseTexture && ( !myTextureCoords.Extent() || !myTextureColorMap.Length() ) ||
 174        !myUseTexture && !myNodeColorMap.Extent() )
 175     return;
 176
 177   // subtract the hidden elements and ids to exclude (to minimise allocated memory)
 178   TColStd_PackedMapOfInteger anIDs;
 179   anIDs.Assign( IDs );
 180   Handle(TColStd_HPackedMapOfInteger) aHiddenElems = myParentMesh->GetHiddenElems();
 181   if ( !aHiddenElems.IsNull() )
 182     anIDs.Subtract( aHiddenElems->Map() );
 183   anIDs.Subtract( IDsToExclude );
 184
 185   Standard_Boolean IsReflect = Standard_False, IsMeshSmoothShading = Standard_False;
 186   aDrawer->GetBoolean( MeshVS_DA_ColorReflection, IsReflect );
 187   aDrawer->GetBoolean( MeshVS_DA_SmoothShading,   IsMeshSmoothShading );
 188
 189   // Following parameter are used for texture presentation only
 190   int nbColors = 0; // Number of colors from color map
 191   int nbTextureColors = 0; // Number of colors in texture (it will be pow of 2)
 192   if ( myUseTexture )
 193   {
 194     nbColors = myTextureColorMap.Length();
 195     nbTextureColors = getNearestPow2( nbColors );
 196   }
 197
 198   Standard_Integer aSize = anIDs.Extent();
 199
 200   // Calculate maximum possible number of vertices and bounds
 201   Handle( MeshVS_HArray1OfSequenceOfInteger ) aTopo;
 202   Standard_Integer PolygonVerticesFor3D = 0, PolygonBoundsFor3D = 0;
 203   TColStd_MapIteratorOfPackedMapOfInteger it (anIDs);
 204   for( ; it.More(); it.Next() )
 205   {
 206     Standard_Integer aKey = it.Key();
 207     if ( aSource->Get3DGeom( aKey, NbNodes, aTopo ) )
 208       MeshVS_MeshPrsBuilder::HowManyPrimitives
 209       ( aTopo, Standard_True, Standard_False, NbNodes,
 210       PolygonVerticesFor3D, PolygonBoundsFor3D );
 211   }
 212
 213   // Draw faces with nodal color
 214   // OCC20644 Use "plastic" material as it is "non-physic" and so it is easier
 215   // to get the required colors (see TelUpdateMaterial() function in OpenGl_attri.c)
 216   Graphic3d_MaterialAspect aMaterial[ 2 ];
 217   aMaterial[ 0 ] = Graphic3d_MaterialAspect( Graphic3d_NOM_PLASTIC );
 218   aMaterial[ 1 ] = Graphic3d_MaterialAspect( Graphic3d_NOM_PLASTIC );
 219   Standard_Integer i;
 220   for ( i = 0; i < 2; i++ )
 221   {
 222     if ( !IsReflect )
 223     {
 224       aMaterial[ i ].SetReflectionModeOff( Graphic3d_TOR_SPECULAR );
 225       aMaterial[ i ].SetReflectionModeOff( Graphic3d_TOR_AMBIENT );
 226       aMaterial[ i ].SetReflectionModeOff( Graphic3d_TOR_DIFFUSE );
 227       aMaterial[ i ].SetReflectionModeOff( Graphic3d_TOR_EMISSION );
 228     }
 229     else{
 230       // OCC20644 Using the material with reflection properties same as in
 231       // ElementalColorPrsBuilder, to get the same colors.
 232       // Additionally, ambient and diffuse coefficients are used below to scale incoming colors,
 233       // to simulate TelUpdateMaterial() function from OpenGl_attri.c.
 234       // This is mandatory, as these "scaled" colors are then passed directly to OpenGL
 235       // as ambient and diffuse colors of the current material using glColorMaterial().
 236       // In ElementalColorPrsBuilder we do not need to do scale the colors, as this
 237       // is done by TelUpdateMaterial().
 238       // 0.5 is used to have the colors in 3D maximally similar to those in the color scale.
 239       // This is possible when the sum of all coefficient is equal to 1.
 240       aMaterial[i].SetAmbient( .5 );
 241       aMaterial[i].SetDiffuse( .5 );
 242       aMaterial[i].SetSpecular( 0. );
 243       aMaterial[i].SetEmissive( 0. );
 244     }
 245
 246  }
 247
 248
 249   // Create array of polygons for interior presentation of faces and volumes
 250   Handle(Graphic3d_ArrayOfPolygons) aCPolyArr = new Graphic3d_ArrayOfPolygons
 251     ( aMaxFaceNodes * aSize + PolygonVerticesFor3D, aSize + PolygonBoundsFor3D,
 252     0, myUseTexture || IsReflect, !myUseTexture, Standard_False, myUseTexture );
 253
 254   // Create array of polylines for presentation of edges
 255   // (used for optimization insted of SetEdgeOn method call)
 256   Handle(Graphic3d_ArrayOfPolylines) aPolyL = new Graphic3d_ArrayOfPolylines
 257     ( ( aMaxFaceNodes + 1 ) * aSize + PolygonVerticesFor3D, aSize + PolygonBoundsFor3D );
 258
 259   gp_Pnt P, Start;
 260   Standard_Real aMin = gp::Resolution() * gp::Resolution();
 261   gp_Dir aDefNorm( 0., 0., 1. );
 262
 263   // Prepare for scaling the incoming colors
 264   Standard_Real anColorRatio = aMaterial[0].Ambient();
 265
 266   for( it.Reset(); it.More(); it.Next() )
 267   {
 268     Standard_Integer aKey = it.Key();
 269     if ( aSource->GetGeom  ( aKey, Standard_True, aCoords, NbNodes, aType ) )
 270     {
 271       MeshVS_Buffer aNodesBuf (NbNodes*sizeof(Standard_Integer));
 272       TColStd_Array1OfInteger aNodes(aNodesBuf, 1, NbNodes);
 273       if ( !aSource->GetNodesByElement ( aKey, aNodes, NbNodes ) )
 274         continue;
 275
 276       Quantity_Color aNColor;
 277
 278       Standard_Boolean isValid = Standard_True;
 279       Standard_Integer i;
 280       if ( myUseTexture )
 281       {
 282         for ( i = 1; i <= NbNodes && isValid; i++ )
 283           isValid = myTextureCoords.IsBound( aNodes( i ) );
 284       }
 285       else
 286       {
 287         for ( i = 1; i <= NbNodes && isValid; i++ )
 288           isValid = GetColor ( aNodes( i ), aNColor );
 289       }
 290
 291       if ( !isValid )
 292         continue;
 293
 294       // Preparing normal(s) to show reflections if requested
 295       Handle(TColStd_HArray1OfReal) aNormals;
 296       Standard_Boolean hasNormals =
 297         ( IsReflect && aSource->GetNormalsByElement( aKey, IsMeshSmoothShading, aMaxFaceNodes, aNormals ) );
 298
 299       if ( aType == MeshVS_ET_Face )
 300       {
 301         aCPolyArr->AddBound ( NbNodes );
 302         aPolyL->AddBound ( NbNodes + 1 );
 303
 304         for ( i = 1; i <= NbNodes; i++)
 305         {
 306           P = gp_Pnt( aCoords( 3 * i - 2 ), aCoords( 3 * i - 1 ), aCoords( 3 * i ) );
 307           if ( myUseTexture )
 308           {
 309             int anId = aNodes( i );
 310             double aTexCoord = myTextureCoords( anId );
 311
 312             // transform texture coordinate in accordance with number of colors specified
 313             // by upper level and real size of Gl texture
 314             // The Gl texture has border colors interpolated with the colors from the color map,
 315             // thats why we need to shrink texture coordinates around the middle point to
 316             // exclude areas where the map colors are interpolated with the borders color
 317             double aWrapCoord = 1.0 / (2.0 * nbTextureColors) + aTexCoord * (nbColors - 1.0) / nbTextureColors;
 318
 319             if ( hasNormals )
 320             {
 321               gp_Vec aNorm(aNormals->Value( 3 * i - 2 ),
 322                            aNormals->Value( 3 * i - 1 ),
 323                            aNormals->Value( 3 * i     ));
 324               // There are two "rows" of colors: user's invalid color at the top
 325               // of texture and line of map colors at the bottom of the texture.
 326               // Since the texture has borders, which are interpolated with the "rows" of colors
 327               // we should specify the 0.25 offset to get the correct texture color
 328               aNorm.SquareMagnitude() > aMin ?
 329                 aCPolyArr->AddVertex(P, gp_Dir( aNorm ),
 330                   gp_Pnt2d( aWrapCoord, aTexCoord >= 0 && aTexCoord <= 1 ? 0.75 : 0.25 ) ) :
 331                 aCPolyArr->AddVertex(P, aDefNorm,
 332                   gp_Pnt2d( aWrapCoord, aTexCoord >= 0 && aTexCoord <= 1 ? 0.75 : 0.25 ) );
 333             }
 334             else
 335               aCPolyArr->AddVertex( P, aDefNorm,
 336                 gp_Pnt2d( aWrapCoord, aTexCoord >= 0 && aTexCoord <= 1 ? 0.75 : 0.25 ) );
 337           }
 338           else
 339           {
 340             GetColor ( aNodes( i ), aNColor );
 341
 342             if ( IsReflect )
 343             {
 344               // Simulating TelUpdateMaterial() from OpenGl_attri.c
 345               // to get the same colors in elemental and nodal color prs builders
 346               aNColor.SetValues(anColorRatio * aNColor.Red(),
 347                                 anColorRatio * aNColor.Green(),
 348                                 anColorRatio * aNColor.Blue(),
 349                                 Quantity_TOC_RGB);
 350
 351               if ( hasNormals )
 352               {
 353                 gp_Vec aNorm(aNormals->Value( 3 * i - 2 ),
 354                   aNormals->Value( 3 * i - 1 ),
 355                   aNormals->Value( 3 * i     ));
 356                 aNorm.SquareMagnitude() > aMin ?
 357                   aCPolyArr->AddVertex(P, gp_Dir( aNorm ), aNColor ) :
 358                 aCPolyArr->AddVertex(P, aDefNorm       , aNColor );
 359               }
 360               else
 361                 aCPolyArr->AddVertex(P, aDefNorm, aNColor );
 362             }
 363             else
 364               aCPolyArr->AddVertex( P, aNColor );
 365           }
 366           aPolyL->AddVertex ( P );
 367           if ( i == 1 )
 368             Start = P;
 369         }
 370         aPolyL->AddVertex ( Start );
 371
 372         // if IsExcludingOn then presentation must not be built by other builders
 373         if ( IsExcludingOn() )
 374           IDsToExclude.Add( aKey );
 375       }
 376       else if ( aType == MeshVS_ET_Volume )
 377       {
 378         if ( !aSource->Get3DGeom( aKey, NbNodes, aTopo ) )
 379           continue;
 380
 381         // iterate through faces of volume
 382         for ( Standard_Integer k = aTopo->Lower(), last = aTopo->Upper(), normIndex = 1; k <= last; k++, normIndex++ )
 383         {
 384           const TColStd_SequenceOfInteger& aSeq = aTopo->Value( k );
 385           Standard_Integer m = aSeq.Length(), ind;
 386
 387           // build polygon & polylines for current face
 388           aCPolyArr->AddBound( m );
 389           aPolyL->AddBound( m + 1 );
 390           for ( Standard_Integer j = 1; j <= m; j++ )
 391           {
 392             ind = aSeq.Value( j );
 393             P = gp_Pnt( aCoords( 3 * ind + 1 ),
 394                         aCoords( 3 * ind + 2 ),
 395                         aCoords( 3 * ind + 3 ) );
 396             if ( myUseTexture )
 397             {
 398               Standard_Integer anId = aNodes( ind + 1 );
 399               Standard_Real aTexCoord = myTextureCoords( anId );
 400
 401               // transform texture coordinate in accordance with number of colors specified
 402               // by upper level and real size of Gl texture
 403               // The Gl texture has border colors interpolated with the colors from the color map,
 404               // thats why we need to shrink texture coordinates around the middle point to
 405               // exclude areas where the map colors are interpolated with the borders color
 406               double aWrapCoord = 1.0 / (2.0 * nbTextureColors) + aTexCoord * (nbColors - 1.0) / nbTextureColors;
 407
 408               if ( hasNormals )
 409               {
 410                 gp_Vec aNorm(aNormals->Value( 3 * i - 2 ),
 411                              aNormals->Value( 3 * i - 1 ),
 412                              aNormals->Value( 3 * i     ));
 413                 // There are two "rows" of colors: user's invalid color at the top
 414                 // of texture and line of map colors at the bottom of the texture.
 415                 // Since the texture has borders, which are interpolated with the "rows" of colors
 416                 // we should specify the 0.25 offset to get the correct texture color
 417                 aNorm.SquareMagnitude() > aMin ?
 418                   aCPolyArr->AddVertex(P, gp_Dir( aNorm ),
 419                     gp_Pnt2d( aWrapCoord, aTexCoord >= 0 && aTexCoord <= 1 ? 0.75 : 0.25 ) ) :
 420                   aCPolyArr->AddVertex(P, aDefNorm,
 421                     gp_Pnt2d( aWrapCoord, aTexCoord >= 0 && aTexCoord <= 1 ? 0.75 : 0.25 ) );
 422               }
 423               else
 424                 aCPolyArr->AddVertex( P, aDefNorm,
 425                   gp_Pnt2d( aWrapCoord, aTexCoord >= 0 && aTexCoord <= 1 ? 0.75 : 0.25 ) );
 426             }
 427             else
 428             {
 429               GetColor( aNodes( ind + 1 ), aNColor );
 430               if  ( IsReflect )
 431               {
 432                 // Simulating TelUpdateMaterial() from OpenGl_attri.c
 433                 // to get the same colors in elemental and nodal color prs builders
 434                 aNColor.SetValues(anColorRatio * aNColor.Red(),
 435                                   anColorRatio * aNColor.Green(),
 436                                   anColorRatio * aNColor.Blue(),
 437                                   Quantity_TOC_RGB);
 438
 439                 if ( hasNormals )
 440                 {
 441                   gp_Vec aNorm(aNormals->Value( 3 * normIndex - 2 ),
 442                     aNormals->Value( 3 * normIndex - 1 ),
 443                     aNormals->Value( 3 * normIndex ));
 444                   aNorm.SquareMagnitude() > aMin ?
 445                     aCPolyArr->AddVertex( P, gp_Dir( aNorm ), aNColor ) :
 446                   aCPolyArr->AddVertex( P, aDefNorm       , aNColor );
 447                 }
 448                 else
 449                   aCPolyArr->AddVertex( P, aDefNorm, aNColor );
 450               }
 451               else
 452                 aCPolyArr->AddVertex( P, aNColor );
 453             }
 454             aPolyL->AddVertex ( P );
 455             if ( j == 1 )
 456               Start = P;
 457           }
 458           aPolyL->AddVertex ( Start );
 459         }
 460
 461         // if IsExcludingOn then presentation must not be built by other builders
 462         if ( IsExcludingOn() )
 463           IDsToExclude.Add( aKey );
 464       }
 465     }
 466   } // for ( ...
 467
 468   Handle(Graphic3d_AspectFillArea3d) anAsp;
 469
 470 //  Aspect_InteriorStyle  aStyle;
 471 //  Standard_Integer      aStyleInt;
 472   Aspect_TypeOfLine     anEdgeType = Aspect_TOL_SOLID;
 473   Standard_Integer      anEdgeInt;
 474   Standard_Real         anEdgeWidth;
 475   Quantity_Color        anInteriorColor;
 476   Quantity_Color        anEdgeColor, aLineColor;
 477   Standard_Boolean      aShowEdges = Standard_True;
 478
 479   aDrawer->GetColor  ( MeshVS_DA_InteriorColor, anInteriorColor );
 480   aDrawer->GetColor  ( MeshVS_DA_EdgeColor, anEdgeColor );
 481   aDrawer->GetColor  ( MeshVS_DA_BeamColor, aLineColor );
 482   aDrawer->GetDouble ( MeshVS_DA_EdgeWidth, anEdgeWidth );
 483   aDrawer->GetBoolean( MeshVS_DA_ShowEdges, aShowEdges );
 484
 485   if ( aDrawer->GetInteger ( MeshVS_DA_EdgeType, anEdgeInt ) )
 486     anEdgeType = (Aspect_TypeOfLine) anEdgeInt;
 487
 488   if ( myUseTexture )
 489   {
 490     Handle(AIS_Drawer) anAISDrawer =  myParentMesh->Attributes();
 491     if ( anAISDrawer.IsNull() )
 492       return;
 493
 494     anAISDrawer->SetShadingAspect( new Prs3d_ShadingAspect() );
 495     anAsp = anAISDrawer->ShadingAspect()->Aspect();
 496     if ( anAsp.IsNull() )
 497       return;
 498
 499     anAsp->SetFrontMaterial( aMaterial[ 0 ] );
 500     anAsp->SetBackMaterial( aMaterial[ 1 ] );
 501
 502
 503     Handle(Graphic3d_Texture2D) aTexture = CreateTexture();
 504     if ( aTexture.IsNull() )
 505       return;
 506
 507     anAsp->SetTextureMapOn();
 508     anAsp->SetTextureMap( aTexture );
 509     anAsp->SetInteriorColor( Quantity_NOC_WHITE );
 510   }
 511   else
 512   {
 513 //    if ( aDrawer->GetInteger ( MeshVS_DA_InteriorStyle, aStyleInt ) )
 514 //      aStyle = (Aspect_InteriorStyle)aStyleInt;
 515
 516     anAsp = new Graphic3d_AspectFillArea3d (
 517       Aspect_IS_SOLID, Quantity_NOC_GRAY, anEdgeColor,
 518       anEdgeType, anEdgeWidth, aMaterial[ 0 ], aMaterial[ 1 ] );
 519   }
 520
 521   anAsp->SetDistinguishOff();
 522   anAsp->SetEdgeOff();
 523
 524   Handle(Graphic3d_AspectLine3d) anLAsp =
 525     new Graphic3d_AspectLine3d( anEdgeColor, anEdgeType, anEdgeWidth );
 526
 527   Prs3d_Root::NewGroup ( Prs );
 528   Handle(Graphic3d_Group) aGroup1 = Prs3d_Root::CurrentGroup ( Prs );
 529
 530   aGroup1->SetPrimitivesAspect( anAsp );
 531   aGroup1->AddPrimitiveArray( aCPolyArr );
 532
 533   if (aShowEdges)
 534   {
 535     Prs3d_Root::NewGroup ( Prs );
 536     Handle(Graphic3d_Group) aGroup2 = Prs3d_Root::CurrentGroup ( Prs );
 537
 538     anAsp->SetEdgeOff();
 539     anAsp->SetTextureMapOff();
 540     aGroup2->SetPrimitivesAspect( anAsp );
 541     aGroup2->SetPrimitivesAspect( anLAsp );
 542     aGroup2->AddPrimitiveArray( aPolyL );
 543     anAsp->SetEdgeOn();
 544   }
 545 }
 546
 547 //================================================================
 548 // Function : SetColors
 549 // Purpose  :
 550 //================================================================
 551 void MeshVS_NodalColorPrsBuilder::SetColors (
 552   const MeshVS_DataMapOfIntegerColor& theColorMap )
 553 {
 554   myNodeColorMap = theColorMap;
 555 }
 556
 557 //================================================================
 558 // Function : GetColors
 559 // Purpose  :
 560 //================================================================
 561 const MeshVS_DataMapOfIntegerColor& MeshVS_NodalColorPrsBuilder::GetColors() const
 562 {
 563   return myNodeColorMap;
 564 }
 565
 566 //================================================================
 567 // Function : HasColors
 568 // Purpose  :
 569 //================================================================
 570 Standard_Boolean MeshVS_NodalColorPrsBuilder::HasColors () const
 571 {
 572   return ( myNodeColorMap.Extent() >0 );
 573 }
 574
 575 //================================================================
 576 // Function : GetColor
 577 // Purpose  :
 578 //================================================================
 579 Standard_Boolean MeshVS_NodalColorPrsBuilder::GetColor ( const Standard_Integer ID,
 580                                                          Quantity_Color& theColor ) const
 581 {
 582   Standard_Boolean aRes = myNodeColorMap.IsBound ( ID );
 583   if ( aRes )
 584     theColor = myNodeColorMap.Find ( ID );
 585   return aRes;
 586 }
 587
 588 //================================================================
 589 // Function : SetColor
 590 // Purpose  :
 591 //================================================================
 592 void MeshVS_NodalColorPrsBuilder::SetColor ( const Standard_Integer theID,
 593                                              const Quantity_Color& theCol )
 594 {
 595   Standard_Boolean aRes = myNodeColorMap.IsBound ( theID );
 596   if ( aRes )
 597     myNodeColorMap.ChangeFind ( theID ) = theCol;
 598   else
 599     myNodeColorMap.Bind ( theID, theCol );
 600 }
 601
 602 //================================================================
 603 // Function : UseTexture
 604 // Purpose  : Specify whether texture must be used to build presentation
 605 //================================================================
 606 void MeshVS_NodalColorPrsBuilder::UseTexture( const Standard_Boolean theToUse )
 607 {
 608   myUseTexture = theToUse;
 609   if ( myUseTexture )
 610     myNodeColorMap.Clear();
 611   else
 612     myTextureColorMap.Clear();
 613 }
 614
 615 //================================================================
 616 // Function : IsUseTexture
 617 // Purpose  : Verify whether texture is used to build presentation
 618 //================================================================
 619 Standard_Boolean MeshVS_NodalColorPrsBuilder::IsUseTexture() const
 620 {
 621   return myUseTexture;
 622 }
 623
 624 //================================================================
 625 // Function : SetColorMap
 626 // Purpose  : Set colors to be used for texrture presentation.
 627 //            Generate texture in accordance with given parameters
 628 //================================================================
 629 void MeshVS_NodalColorPrsBuilder::SetColorMap( const Aspect_SequenceOfColor& theColors )
 630 {
 631   myTextureColorMap = theColors;
 632 }
 633
 634 //================================================================
 635 // Function : GetColorMap
 636 // Purpose  : Return colors used for texrture presentation
 637 //================================================================
 638 const Aspect_SequenceOfColor& MeshVS_NodalColorPrsBuilder::GetColorMap() const
 639 {
 640   return myTextureColorMap;
 641 }
 642
 643 //================================================================
 644 // Function : SetInvalidColor
 645 // Purpose  : Set color representing invalid texture coordinate
 646 //            (laying outside range [0, 1])
 647 //================================================================
 648 void MeshVS_NodalColorPrsBuilder::SetInvalidColor(
 649   const Quantity_Color& theInvalidColor )
 650 {
 651   myInvalidColor = theInvalidColor;
 652 }
 653
 654 //================================================================
 655 // Function : GetInvalidColor
 656 // Purpose  : Return color representing invalid texture coordinate
 657 //            (laying outside range [0, 1])
 658 //================================================================
 659 Quantity_Color MeshVS_NodalColorPrsBuilder::GetInvalidColor() const
 660 {
 661   return myInvalidColor;
 662 }
 663
 664 //================================================================
 665 // Function : SetTextureCoords
 666 // Purpose  : Specify correspondence between node IDs and texture
 667 //            coordinates (range [0, 1])
 668 //================================================================
 669 void MeshVS_NodalColorPrsBuilder::SetTextureCoords (
 670   const TColStd_DataMapOfIntegerReal& theMap )
 671 {
 672   myTextureCoords = theMap;
 673 }
 674
 675 //================================================================
 676 // Function : GetTextureCoords
 677 // Purpose  : Get correspondence between node IDs and texture
 678 //            coordinates (range [0, 1])
 679 //================================================================
 680 const TColStd_DataMapOfIntegerReal& MeshVS_NodalColorPrsBuilder::GetTextureCoords() const
 681 {
 682   return myTextureCoords;
 683 }
 684
 685 //================================================================
 686 // Function : SetTextureCoord
 687 // Purpose  : Specify correspondence between node ID and texture
 688 //            coordinate (range [0, 1])
 689 //================================================================
 690 void MeshVS_NodalColorPrsBuilder::SetTextureCoord( const Standard_Integer theID,
 691                                                    const Standard_Real theCoord )
 692 {
 693   myTextureCoords.Bind( theID, theCoord );
 694 }
 695
 696 //================================================================
 697 // Function : GetTextureCoord
 698 // Purpose  : Return correspondence between node IDs and texture
 699 //            coordinate (range [0, 1])
 700 //================================================================
 701 Standard_Real MeshVS_NodalColorPrsBuilder::GetTextureCoord( const Standard_Integer theID )
 702 {
 703   return myTextureCoords.IsBound( theID ) ? myTextureCoords( theID ) : -1;
 704 }
 705
 706 //================================================================
 707 // Function : CreateTexture
 708 // Purpose  : Create texture in accordance with myTextureColorMap
 709 //================================================================
 710 Handle(Graphic3d_Texture2D) MeshVS_NodalColorPrsBuilder::CreateTexture() const
 711 {
 712   const Standard_Integer aColorsNb = myTextureColorMap.Length();
 713   if (aColorsNb == 0)
 714   {
 715     return NULL;
 716   }
 717
 718   // create and fill image with colors
 719   Handle(Image_PixMap) anImage = new Image_PixMap();
 720   if (!anImage->InitTrash (Image_PixMap::ImgRGBA, Standard_Size(getNearestPow2 (aColorsNb)), 2))
 721   {
 722     return NULL;
 723   }
 724
 725   anImage->SetTopDown (false);
 726   Image_PixMapData<Image_ColorRGBA>& aData = anImage->EditData<Image_ColorRGBA>();
 727   for (Standard_Size aCol = 0; aCol < Standard_Size(aColorsNb); ++aCol)
 728   {
 729     const Quantity_Color& aSrcColor = myTextureColorMap.Value (Standard_Integer(aCol) + 1);
 730     Image_ColorRGBA& aColor = aData.ChangeValue (0, aCol);
 731     aColor.r() = Standard_Byte(255.0 * aSrcColor.Red());
 732     aColor.g() = Standard_Byte(255.0 * aSrcColor.Green());
 733     aColor.b() = Standard_Byte(255.0 * aSrcColor.Blue());
 734     aColor.a() = 0xFF;
 735   }
 736
 737   // fill padding bytes
 738   const Quantity_Color& aLastColorSrc = myTextureColorMap.Last();
 739   const Image_ColorRGBA aLastColor =
 740   {{
 741     Standard_Byte(255.0 * aLastColorSrc.Red()),
 742     Standard_Byte(255.0 * aLastColorSrc.Green()),
 743     Standard_Byte(255.0 * aLastColorSrc.Blue()),
 744     0xFF
 745   }};
 746
 747   // fill second row
 748   for (Standard_Size aCol = (Standard_Size )aColorsNb; aCol < anImage->SizeX(); ++aCol)
 749   {
 750     aData.ChangeValue (0, aCol) = aLastColor;
 751   }
 752
 753   const Image_ColorRGBA anInvalidColor =
 754   {{
 755     Standard_Byte(255.0 * myInvalidColor.Red()),
 756     Standard_Byte(255.0 * myInvalidColor.Green()),
 757     Standard_Byte(255.0 * myInvalidColor.Blue()),
 758     0xFF
 759   }};
 760   for (Standard_Size aCol = 0; aCol < anImage->SizeX(); ++aCol)
 761   {
 762     aData.ChangeValue (1, aCol) = anInvalidColor;
 763   }
 764
 765   // create texture
 766   return new MeshVS_ImageTexture2D (anImage);
 767 }