Integration of OCCT 6.5.0 from SVN
[occt.git] / src / MeshVS / MeshVS_ElementalColorPrsBuilder.cxx
CommitLineData
7fd59977 1// File: MeshVS_ElementalColorPrsBuilder.cxx
2// Created: Wed Nov 12 2003
3// Author: Alexander SOLOVYOV
4// Copyright: Open CASCADE 2003
5
6#define _POLYGONES_
7// if define _POLYGONES_ ColorPrsBuilder use ArrayOfPolygons for drawing faces
8
9#include <MeshVS_ElementalColorPrsBuilder.ixx>
10
11#include <Graphic3d_AspectFillArea3d.hxx>
12#include <Graphic3d_AspectLine3d.hxx>
13#include <Graphic3d_ArrayOfPolygons.hxx>
14#include <Graphic3d_ArrayOfPolylines.hxx>
15#include <Graphic3d_Vertex.hxx>
16#include <Graphic3d_Group.hxx>
17#include <Graphic3d_Array1OfVertex.hxx>
18
19#include <Prs3d_ShadingAspect.hxx>
20#include <Prs3d_Root.hxx>
21#include <Prs3d_LineAspect.hxx>
22
23#include <TColStd_MapOfInteger.hxx>
24#include <TColStd_PackedMapOfInteger.hxx>
25#include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
26#include <TColStd_ListIteratorOfListOfInteger.hxx>
27#include <TColStd_Array1OfReal.hxx>
28#include <TColStd_SequenceOfInteger.hxx>
29#include <TColStd_HArray1OfReal.hxx>
30#include <TColStd_HPackedMapOfInteger.hxx>
31
32#include <MeshVS_DisplayModeFlags.hxx>
33#include <MeshVS_DataSource.hxx>
34#include <MeshVS_Mesh.hxx>
35#include <MeshVS_DataMapOfColorMapOfInteger.hxx>
36#include <MeshVS_DataMapOfTwoColorsMapOfInteger.hxx>
37#include <MeshVS_Drawer.hxx>
38#include <MeshVS_DrawerAttribute.hxx>
39#include <MeshVS_DataMapIteratorOfDataMapOfIntegerTwoColors.hxx>
40#include <MeshVS_DataMapIteratorOfDataMapOfIntegerColor.hxx>
41#include <MeshVS_DataMapIteratorOfDataMapOfTwoColorsMapOfInteger.hxx>
42#include <MeshVS_DataMapIteratorOfDataMapOfColorMapOfInteger.hxx>
43#include <MeshVS_MeshPrsBuilder.hxx>
44#include <MeshVS_Buffer.hxx>
45
46
47//================================================================
48// Function : Constructor MeshVS_ElementalColorPrsBuilder
49// Purpose :
50//================================================================
51MeshVS_ElementalColorPrsBuilder::MeshVS_ElementalColorPrsBuilder
52 ( const Handle(MeshVS_Mesh)& Parent,
53 const MeshVS_DisplayModeFlags& Flags,
54 const Handle (MeshVS_DataSource)& DS,
55 const Standard_Integer Id,
56 const MeshVS_BuilderPriority& Priority )
57: MeshVS_PrsBuilder ( Parent, Flags, DS, Id, Priority )
58{
59 SetExcluding ( Standard_True );
60}
61
62//================================================================
63// Function : Build
64// Purpose :
65//================================================================
66void MeshVS_ElementalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
67 const TColStd_PackedMapOfInteger& IDs,
68 TColStd_PackedMapOfInteger& IDsToExclude,
69 const Standard_Boolean IsElement,
70 const Standard_Integer DisplayMode) const
71{
72 Handle (MeshVS_DataSource) aSource = GetDataSource();
73 Handle (MeshVS_Drawer) aDrawer = GetDrawer();
74
75 if ( aSource.IsNull() || aDrawer.IsNull() )
76 return;
77
78 Standard_Integer aMaxFaceNodes;
79 if ( !aDrawer->GetInteger ( MeshVS_DA_MaxFaceNodes, aMaxFaceNodes ) && aMaxFaceNodes<=0 )
80 return;
81
82 MeshVS_DataMapOfIntegerColor* anElemColorMap = (MeshVS_DataMapOfIntegerColor*) &myElemColorMap1;
83 MeshVS_DataMapOfIntegerTwoColors* anElemTwoColorsMap = (MeshVS_DataMapOfIntegerTwoColors*)&myElemColorMap2;
84
85 MeshVS_DataMapOfColorMapOfInteger aColorsOfElements;
86 MeshVS_DataMapOfTwoColorsMapOfInteger aTwoColorsOfElements;
87
88 MeshVS_Buffer aCoordsBuf (3*aMaxFaceNodes*sizeof(Standard_Real));
89 TColStd_Array1OfReal aCoords (aCoordsBuf, 1, 3*aMaxFaceNodes);
90 Standard_Integer NbNodes;
91 MeshVS_EntityType aType;
92
93 if ( !( DisplayMode & GetFlags() ) || !IsElement ||
94 ( myElemColorMap1.IsEmpty() && myElemColorMap2.IsEmpty() ) )
95 return;
96
97 // subtract the hidden elements and ids to exclude (to minimise allocated memory)
98 TColStd_PackedMapOfInteger anIDs;
99 anIDs.Assign( IDs );
100 Handle(TColStd_HPackedMapOfInteger) aHiddenElems = myParentMesh->GetHiddenElems();
101 if ( !aHiddenElems.IsNull() )
102 anIDs.Subtract( aHiddenElems->Map() );
103 anIDs.Subtract( IDsToExclude );
104
105 // STEP 0: We looking for two colored elements, who has equal two colors and move it
106 // to map of elements with one assigned color
107 TColStd_ListOfInteger aColorOne;
108 for ( MeshVS_DataMapIteratorOfDataMapOfIntegerTwoColors anIter ( *anElemTwoColorsMap ); anIter.More(); anIter.Next () )
109 {
110 Standard_Integer aKey = anIter.Key ();
111 MeshVS_TwoColors aValue = anIter.Value ();
112 Quantity_Color aCol1, aCol2;
113 ExtractColors ( aValue, aCol1, aCol2 );
114 if ( aCol1 == aCol2 )
115 {
116 aColorOne.Append ( aKey );
117 anElemColorMap->Bind ( aKey, aCol1 );
118 }
119 }
120
121 for ( TColStd_ListIteratorOfListOfInteger aLIter ( aColorOne ); aLIter.More(); aLIter.Next() )
122 anElemTwoColorsMap->UnBind ( aLIter.Value() );
123
124 // The map is to resort itself by colors.
125 // STEP 1: We start sorting elements with one assigned color
126 for ( MeshVS_DataMapIteratorOfDataMapOfIntegerColor anIterM ( *anElemColorMap ); anIterM.More(); anIterM.Next () )
127 {
128 Standard_Integer aMKey = anIterM.Key ();
129 // The ID of current element
130 Standard_Boolean IsExist = Standard_False;
131 for ( MeshVS_DataMapIteratorOfDataMapOfColorMapOfInteger anIterC ( aColorsOfElements );
132 anIterC.More() && !IsExist; anIterC.Next () )
133 if ( anIterC.Key()==anIterM.Value() )
134 {
135 TColStd_MapOfInteger& aChangeValue = (TColStd_MapOfInteger&) anIterC.Value();
136 aChangeValue.Add ( aMKey );
137 IsExist = Standard_True;
138 }
139
140 if ( !IsExist )
141 {
142 TColStd_MapOfInteger aNewMap; aNewMap.Add ( aMKey );
143 aColorsOfElements.Bind ( anIterM.Value(), aNewMap );
144 }
145 }
146
147 // STEP 2: We start sorting elements with two assigned colors
148 for ( MeshVS_DataMapIteratorOfDataMapOfIntegerTwoColors anIterM2 ( *anElemTwoColorsMap ); anIterM2.More();
149 anIterM2.Next () )
150 {
151 Standard_Integer aMKey = anIterM2.Key ();
152 // The ID of current element
153 Standard_Boolean IsExist = Standard_False;
154 for ( MeshVS_DataMapIteratorOfDataMapOfTwoColorsMapOfInteger anIterC2 ( aTwoColorsOfElements );
155 anIterC2.More() && !IsExist; anIterC2.Next () )
156 if ( IsEqual ( anIterC2.Key(), anIterM2.Value() ) )
157 {
158 TColStd_MapOfInteger& aChangeValue = (TColStd_MapOfInteger&) anIterC2.Value();
159 aChangeValue.Add ( aMKey );
160 IsExist = Standard_True;
161 }
162
163 if ( !IsExist )
164 {
165 TColStd_MapOfInteger aNewMap; aNewMap.Add ( aMKey );
166 aTwoColorsOfElements.Bind ( anIterM2.Value(), aNewMap );
167 }
168 }
169
170 //Now we are ready to draw faces with equal colors
171 Aspect_InteriorStyle aStyle;
172 Standard_Integer aStyleInt;
173 Aspect_TypeOfLine anEdgeType = Aspect_TOL_SOLID;
174 Aspect_TypeOfLine aLineType = Aspect_TOL_SOLID;
175 Standard_Integer anEdgeInt, aLineInt;
176 Standard_Real anEdgeWidth, aLineWidth;
177 Quantity_Color anInteriorColor;
178 Quantity_Color anEdgeColor, aLineColor;
179 Standard_Boolean anEdgeOn = Standard_True, IsReflect = Standard_False,
180 IsMeshSmoothShading = Standard_False;
181
182 aDrawer->GetColor ( MeshVS_DA_InteriorColor, anInteriorColor );
183 aDrawer->GetColor ( MeshVS_DA_EdgeColor, anEdgeColor );
184 aDrawer->GetColor ( MeshVS_DA_BeamColor, aLineColor );
185 aDrawer->GetDouble ( MeshVS_DA_EdgeWidth, anEdgeWidth );
186 aDrawer->GetDouble ( MeshVS_DA_BeamWidth, aLineWidth );
187 aDrawer->GetBoolean( MeshVS_DA_ShowEdges, anEdgeOn );
188 aDrawer->GetBoolean( MeshVS_DA_ColorReflection, IsReflect );
189 aDrawer->GetBoolean( MeshVS_DA_SmoothShading, IsMeshSmoothShading );
190
191 if ( aDrawer->GetInteger ( MeshVS_DA_InteriorStyle, aStyleInt) )
192 aStyle = (Aspect_InteriorStyle) aStyleInt;
193
194 if ( aDrawer->GetInteger ( MeshVS_DA_EdgeType, anEdgeInt) )
195 anEdgeType = (Aspect_TypeOfLine) anEdgeInt;
196
197 if ( aDrawer->GetInteger ( MeshVS_DA_BeamType, aLineInt) )
198 aLineType = (Aspect_TypeOfLine) aLineInt;
199
200 Handle( MeshVS_HArray1OfSequenceOfInteger ) aTopo;
201 Standard_Integer PolygonVerticesFor3D = 0, PolygonBoundsFor3D = 0;
202 TColStd_MapIteratorOfPackedMapOfInteger it (anIDs);
203 for( ; it.More(); it.Next() )
204 {
205 Standard_Integer aKey = it.Key();
206 if( aSource->Get3DGeom( aKey, NbNodes, aTopo ) )
207 MeshVS_MeshPrsBuilder::HowManyPrimitives
208 ( aTopo, Standard_True, Standard_False, NbNodes,
209 PolygonVerticesFor3D, PolygonBoundsFor3D );
210 }
211
212 Graphic3d_MaterialAspect aMaterial[2];
213 Standard_Integer i;
214 for ( i=0; i<2; i++ )
215 {
216 // OCC20644 "plastic" is most suitable here, as it is "non-physic"
217 // so TelUpdateMaterial() from OpenGl_attri.c uses the interior
218 // color from AspectFillArea3d to calculate all material colors
219 aMaterial[i] = Graphic3d_MaterialAspect ( Graphic3d_NOM_PLASTIC );
220
221 // OCC21720 For single-colored elements turning all material components off is a good idea,
222 // as anyhow the normals are not computed and the lighting will be off,
223 // the element color will be taken from Graphic3d_AspectFillArea3d's interior color,
224 // and there is no need to spend time on updating material properties
225 if ( !IsReflect )
226 {
227 aMaterial[i].SetReflectionModeOff(Graphic3d_TOR_AMBIENT);
228 aMaterial[i].SetReflectionModeOff(Graphic3d_TOR_DIFFUSE);
229 aMaterial[i].SetReflectionModeOff(Graphic3d_TOR_SPECULAR);
230 aMaterial[i].SetReflectionModeOff(Graphic3d_TOR_EMISSION);
231 }
232 else
233 {
234 // OCC20644 This stuff is important in order for elemental and nodal colors
235 // to produce similar visual impression and also to make colors match
236 // those in the color scale most exactly (the sum of all reflection
237 // coefficients is equal to 1). See also MeshVS_NodalColorPrsBuilder
238 // class for more explanations.
239 aMaterial[i].SetAmbient( .5 );
240 aMaterial[i].SetDiffuse( .5 );
241 aMaterial[i].SetSpecular( 0. );
242 aMaterial[i].SetEmissive( 0. );
243 }
244 }
245
246 // Draw elements with one color
247 for ( MeshVS_DataMapIteratorOfDataMapOfColorMapOfInteger aColIter ( aColorsOfElements ); aColIter.More();
248 aColIter.Next() )
249 {
250 Standard_Integer aSize = aColIter.Value().Extent();
251 if ( aSize<=0 )
252 continue;
253
254 TColStd_PackedMapOfInteger aCustomElements;
255
256 Prs3d_Root::NewGroup ( Prs );
257 Handle ( Graphic3d_Group ) aGGroup = Prs3d_Root::CurrentGroup ( Prs );
258 Prs3d_Root::NewGroup ( Prs );
259 Handle ( Graphic3d_Group ) aLGroup = Prs3d_Root::CurrentGroup ( Prs );
260
261 Handle (Graphic3d_ArrayOfPolygons) aPolyGArr = new Graphic3d_ArrayOfPolygons
262 ( aMaxFaceNodes*aSize + PolygonVerticesFor3D, aSize + PolygonBoundsFor3D, 0, IsReflect );
263 Standard_Boolean IsPolyG = Standard_False;
264
265 Handle (Graphic3d_ArrayOfPolylines) aPolyLArr = new Graphic3d_ArrayOfPolylines
266 ( 2*aSize, aSize );
267 Standard_Boolean IsPolyL = Standard_False;
268
269 // OCC20644 NOTE: aColIter.Key() color is then scaled by TelUpdateMaterial() in OpenGl_attri.c
270 // using the material reflection coefficients. This affects the visual result.
271 Handle(Graphic3d_AspectFillArea3d) anAsp =
272 new Graphic3d_AspectFillArea3d ( Aspect_IS_SOLID, aColIter.Key(), anEdgeColor,
273 anEdgeType, anEdgeWidth, aMaterial[0], aMaterial[1] );
274
275 Handle(Graphic3d_AspectLine3d) anLAsp =
276 new Graphic3d_AspectLine3d ( aColIter.Key(), aLineType, aLineWidth );
277
278 anAsp->SetDistinguishOff ();
279 anAsp->SetInteriorColor ( aColIter.Key() );
280 if (anEdgeOn)
281 anAsp->SetEdgeOn();
282 else
283 anAsp->SetEdgeOff();
284
285 for( it.Reset(); it.More(); it.Next() )
286 {
287 Standard_Integer aKey = it.Key();
288 if( aColIter.Value().Contains( aKey ) )
289 {
290 if ( !aSource->GetGeom ( aKey, Standard_True, aCoords, NbNodes, aType ) )
291 continue;
292
293 if( aType == MeshVS_ET_Face )
294 {
295 aPolyGArr->AddBound ( NbNodes );
296 if( IsExcludingOn() )
297 IDsToExclude.Add( aKey );
298 }
299 else if( aType == MeshVS_ET_Link )
300 {
301 aPolyLArr->AddBound ( NbNodes );
302 if( IsExcludingOn() )
303 IDsToExclude.Add( aKey );
304 }
305 else if( aType == MeshVS_ET_Volume )
306 {
307 if( IsExcludingOn() )
308 IDsToExclude.Add( aKey );
309 if( aSource->Get3DGeom( aKey, NbNodes, aTopo ) )
310 {
311 MeshVS_MeshPrsBuilder::AddVolumePrs( aTopo, aCoords, NbNodes, aPolyGArr, IsReflect, Standard_False, Standard_False, 1.0 );
312 IsPolyG = Standard_True;
313 }
314 else
315 continue;
316 }
317 else
318 {
319 aCustomElements.Add( aKey );
320 continue;
321 }
322
323 // Preparing normal(s) to show reflections if requested
324 Handle(TColStd_HArray1OfReal) aNormals;
325 Standard_Boolean hasNormals = IsReflect && aSource->GetNormalsByElement( aKey, IsMeshSmoothShading, aMaxFaceNodes, aNormals );
326
327 // Adding vertices (with normals if necessary)
328 for ( i=1; i<=NbNodes; i++ )
329 if ( aType == MeshVS_ET_Face )
330 {
331 if ( IsReflect )
332 {
333 hasNormals ? aPolyGArr->AddVertex ( aCoords(3 * i - 2),
334 aCoords(3 * i - 1),
335 aCoords(3 * i ),
336 aNormals->Value(3 * i - 2),
337 aNormals->Value(3 * i - 1),
338 aNormals->Value(3 * i ) ) :
339 aPolyGArr->AddVertex ( aCoords(3 * i - 2),
340 aCoords(3 * i - 1),
341 aCoords(3 * i ),
342 0.,
343 0.,
344 1. );
345 }
346 else
347 aPolyGArr->AddVertex ( aCoords(3 * i - 2),
348 aCoords(3 * i - 1),
349 aCoords(3 * i ) );
350 IsPolyG = Standard_True;
351 }
352 else if ( aType == MeshVS_ET_Link )
353 {
354 aPolyLArr->AddVertex ( aCoords(3*i-2), aCoords(3*i-1), aCoords(3*i) );
355 IsPolyL = Standard_True;
356 }
357 }
358 }
359
360 if ( IsPolyG )
361 {
362 aGGroup->SetPrimitivesAspect ( anAsp );
363 aGGroup->BeginPrimitives();
364 aGGroup->AddPrimitiveArray ( aPolyGArr );
365 aGGroup->EndPrimitives();
366 }
367 if ( IsPolyL )
368 {
369 anAsp->SetEdgeOff();
370 aLGroup->SetPrimitivesAspect ( anAsp );
371 aLGroup->SetPrimitivesAspect ( anLAsp );
372 aLGroup->BeginPrimitives();
373 aLGroup->AddPrimitiveArray ( aPolyLArr );
374 aLGroup->EndPrimitives();
375 if (anEdgeOn)
376 anAsp->SetEdgeOn();
377 else
378 anAsp->SetEdgeOff();
379 }
380
381 if( !aCustomElements.IsEmpty() )
382 CustomBuild( Prs, aCustomElements, IDsToExclude, DisplayMode );
383 }
384
385 Graphic3d_MaterialAspect aMaterial2[2];
386 for ( i=0; i<2; i++ )
387 {
388 // OCC20644 "plastic" is most suitable here, as it is "non-physic"
389 // so TelUpdateMaterial() from OpenGl_attri.c uses the interior
390 // color from AspectFillArea3d to calculate all material colors
391 aMaterial2[i] = Graphic3d_MaterialAspect ( Graphic3d_NOM_PLASTIC );
392
393 if ( !IsReflect )
394 {
395 // OCC21720 Cannot turn ALL material components off, as such a material
396 // would be ignored by TelUpdateMaterial(), but we need it in order
397 // to have different materials for front and back sides!
398 // Instead, trying to make material color "nondirectional" with
399 // only ambient component on.
400 aMaterial2[i].SetReflectionModeOn ( Graphic3d_TOR_AMBIENT );
401 aMaterial2[i].SetReflectionModeOff( Graphic3d_TOR_DIFFUSE );
402 aMaterial2[i].SetReflectionModeOff( Graphic3d_TOR_SPECULAR );
403 aMaterial2[i].SetReflectionModeOff( Graphic3d_TOR_EMISSION );
404 aMaterial2[i].SetAmbient ( 1. );
405 aMaterial2[i].SetDiffuse ( 0. );
406 aMaterial2[i].SetSpecular( 0. );
407 aMaterial2[i].SetEmissive( 0. );
408 }
409 else
410 {
411 // OCC20644 This stuff is important in order for elemental and nodal colors
412 // to produce similar visual impression and also to make colors match
413 // those in the color scale most exactly (the sum of all reflection
414 // coefficients is equal to 1). See also MeshVS_NodalColorPrsBuilder
415 // class for more explanations.
416 aMaterial2[i].SetAmbient( .5 );
417 aMaterial2[i].SetDiffuse( .5 );
418 aMaterial2[i].SetSpecular( 0. );
419 aMaterial2[i].SetEmissive( 0. );
420 }
421 }
422
423 // Draw faces with two color
424 for ( MeshVS_DataMapIteratorOfDataMapOfTwoColorsMapOfInteger aColIter2 ( aTwoColorsOfElements );
425 aColIter2.More(); aColIter2.Next() )
426 {
427 Prs3d_Root::NewGroup ( Prs );
428 Handle ( Graphic3d_Group ) aGroup2 = Prs3d_Root::CurrentGroup ( Prs );
429
430 Standard_Integer aSize = aColIter2.Value().Extent();
431 if ( aSize<=0 )
432 continue;
433
434#ifdef _POLYGONES_
435 Handle (Graphic3d_ArrayOfPolygons) aPolyArr = new Graphic3d_ArrayOfPolygons
436 ( aMaxFaceNodes*aSize, aSize, 0, IsReflect );
437#endif
438
439 MeshVS_TwoColors aTC = aColIter2.Key();
440 Quantity_Color aMyIntColor, aMyBackColor;
441 ExtractColors ( aTC, aMyIntColor, aMyBackColor );
442
443 // OCC20644 NOTE: aMyIntColor color is then scaled by TelUpdateMaterial() in OpenGl_attri.c
444 // using the material reflection coefficients. This affects the visual result.
445 Handle(Graphic3d_AspectFillArea3d) anAsp =
446 new Graphic3d_AspectFillArea3d ( Aspect_IS_SOLID, aMyIntColor, anEdgeColor,
447 anEdgeType, anEdgeWidth, aMaterial2[0], aMaterial2[1] );
448 anAsp->SetDistinguishOn ();
449 anAsp->SetInteriorColor ( aMyIntColor );
450 anAsp->SetBackInteriorColor ( aMyBackColor );
451 if (anEdgeOn)
452 anAsp->SetEdgeOn();
453 else
454 anAsp->SetEdgeOff();
455
456 aGroup2->SetPrimitivesAspect ( anAsp );
457 aGroup2->BeginPrimitives();
458
459 for( it.Reset(); it.More(); it.Next() )
460 {
461 Standard_Integer aKey = it.Key();
462 if( aColIter2.Value().Contains( aKey ) )
463 {
464 if ( !aSource->GetGeom ( aKey, Standard_True, aCoords, NbNodes, aType ) )
465 continue;
466
467 if( IsExcludingOn() )
468 IDsToExclude.Add( aKey );
469
470 if ( aType == MeshVS_ET_Face && NbNodes > 0 )
471 {
472 // Preparing normal(s) to show reflections if requested
473 Handle(TColStd_HArray1OfReal) aNormals;
474 // OCC21720 Always passing normals to OpenGL to make materials work
475 // For OpenGL: "No normals" -> "No lighting" -> "no materials taken into account"
476 Standard_Boolean hasNormals = /*IsReflect &&*/
477 aSource->GetNormalsByElement( aKey, IsMeshSmoothShading, aMaxFaceNodes, aNormals );
478
479#ifdef _POLYGONES_
480 aPolyArr->AddBound ( NbNodes );
481#else
482 Graphic3d_Array1OfVertex aVertArr ( 1, NbNodes );
483#endif
484
485 for ( i=1; i<=NbNodes; i++ )
486 {
487#ifdef _POLYGONES_
488 if ( IsReflect )
489 {
490 hasNormals ? aPolyArr->AddVertex ( aCoords(3 * i - 2),
491 aCoords(3 * i - 1),
492 aCoords(3 * i ),
493 aNormals->Value(3 * i - 2),
494 aNormals->Value(3 * i - 1),
495 aNormals->Value(3 * i ) ) :
496 aPolyArr->AddVertex ( aCoords(3 * i - 2),
497 aCoords(3 * i - 1),
498 aCoords(3 * i ),
499 0.,
500 0.,
501 1. );
502 }
503 else
504 aPolyArr->AddVertex ( aCoords(3*i-2),
505 aCoords(3*i-1),
506 aCoords(3*i ) );
507#else
508 if ( IsReflect )
509 {
510 aVertArr (i) = hasNormals ? Graphic3d_VertexN( aCoords(3 * i - 2),
511 aCoords(3 * i - 1),
512 aCoords(3 * i ),
513 aNormals->Value(3 * i - 2),
514 aNormals->Value(3 * i - 1),
515 aNormals->Value(3 * i ),
516 Standard_False ) :
517 Graphic3d_VertexN( aCoords(3 * i - 2),
518 aCoords(3 * i - 1),
519 aCoords(3 * i ),
520 0.,
521 0.,
522 1.,
523 Standard_False );
524
525 }
526 else
527 Graphic3d_Vertex ( aCoords(3 * i - 2),
528 aCoords(3 * i - 1),
529 aCoords(3 * i ) );
530#endif
531 }
532
533
534#ifndef _POLYGONES_
535 aGroup2->Polygon ( aVertArr );
536#endif
537 }
538 }
539 }
540#ifdef _POLYGONES_
541 aGroup2->AddPrimitiveArray ( aPolyArr );
542#endif
543 aGroup2->EndPrimitives();
544 }
545}
546
547//================================================================
548// Function : SetColors
549// Purpose :
550//================================================================
551void MeshVS_ElementalColorPrsBuilder::SetColors1 ( const MeshVS_DataMapOfIntegerColor& theColorMap )
552{
553 myElemColorMap1 = theColorMap;
554}
555
556//================================================================
557// Function : GetColors
558// Purpose :
559//================================================================
560const MeshVS_DataMapOfIntegerColor& MeshVS_ElementalColorPrsBuilder::GetColors1 () const
561{
562 return myElemColorMap1;
563}
564
565//================================================================
566// Function : HasColors1
567// Purpose :
568//================================================================
569Standard_Boolean MeshVS_ElementalColorPrsBuilder::HasColors1 () const
570{
571 return ( myElemColorMap1.Extent() >0 );
572}
573
574//================================================================
575// Function : GetColor1
576// Purpose :
577//================================================================
578Standard_Boolean MeshVS_ElementalColorPrsBuilder::GetColor1 ( const Standard_Integer ID,
579 Quantity_Color& theColor ) const
580{
581 Standard_Boolean aRes = myElemColorMap1.IsBound ( ID );
582 if ( aRes )
583 theColor = myElemColorMap1.Find ( ID );
584
585 return aRes;
586}
587
588//================================================================
589// Function : SetColor1
590// Purpose :
591//================================================================
592void MeshVS_ElementalColorPrsBuilder::SetColor1 ( const Standard_Integer theID,
593 const Quantity_Color& theCol )
594{
595 Standard_Boolean aRes = myElemColorMap1.IsBound ( theID );
596 if ( aRes )
597 myElemColorMap1.ChangeFind ( theID ) = theCol;
598 else
599 myElemColorMap1.Bind ( theID, theCol );
600}
601
602//================================================================
603// Function : SetColors2
604// Purpose :
605//================================================================
606void MeshVS_ElementalColorPrsBuilder::SetColors2 ( const MeshVS_DataMapOfIntegerTwoColors& theColorMap )
607{
608 myElemColorMap2 = theColorMap;
609}
610
611//================================================================
612// Function : GetColors2
613// Purpose :
614//================================================================
615const MeshVS_DataMapOfIntegerTwoColors& MeshVS_ElementalColorPrsBuilder::GetColors2 () const
616{
617 return myElemColorMap2;
618}
619
620//================================================================
621// Function : HasColors2
622// Purpose :
623//================================================================
624Standard_Boolean MeshVS_ElementalColorPrsBuilder::HasColors2 () const
625{
626 return (myElemColorMap2.Extent()>0);
627}
628
629//================================================================
630// Function : GetColor2
631// Purpose :
632//================================================================
633Standard_Boolean MeshVS_ElementalColorPrsBuilder::GetColor2 ( const Standard_Integer ID,
634 MeshVS_TwoColors& theColor ) const
635{
636 Standard_Boolean aRes = myElemColorMap2.IsBound ( ID );
637 if ( aRes )
638 theColor = myElemColorMap2.Find ( ID );
639
640 return aRes;
641}
642
643//================================================================
644// Function : GetColor2
645// Purpose :
646//================================================================
647Standard_Boolean MeshVS_ElementalColorPrsBuilder::GetColor2 ( const Standard_Integer ID,
648 Quantity_Color& theColor1,
649 Quantity_Color& theColor2 ) const
650{
651 MeshVS_TwoColors aTC;
652 Standard_Boolean aRes = GetColor2 ( ID, aTC );
653 if ( aRes)
654 ExtractColors ( aTC, theColor1, theColor2 );
655 return aRes;
656}
657
658//================================================================
659// Function : SetColor2
660// Purpose :
661//================================================================
662void MeshVS_ElementalColorPrsBuilder::SetColor2 ( const Standard_Integer theID,
663 const Quantity_Color& theCol1,
664 const Quantity_Color& theCol2 )
665{
666 SetColor2 ( theID, BindTwoColors ( theCol1, theCol2 ) );
667}
668
669//================================================================
670// Function : SetColor2
671// Purpose :
672//================================================================
673void MeshVS_ElementalColorPrsBuilder::SetColor2 ( const Standard_Integer theID,
674 const MeshVS_TwoColors& theCol )
675{
676 Standard_Boolean aRes = myElemColorMap2.IsBound ( theID );
677 if ( aRes )
678 myElemColorMap2.ChangeFind ( theID ) = theCol;
679 else
680 myElemColorMap2.Bind ( theID, theCol );
681}