0029570: Visualization, Graphic3d_Aspect - merge Graphic3d_Group aspects
[occt.git] / src / AIS / AIS_Triangulation.cxx
1 // Copyright (c) 1999-2014 OPEN CASCADE SAS
2 //
3 // This file is part of Open CASCADE Technology software library.
4 //
5 // This library is free software; you can redistribute it and/or modify it under
6 // the terms of the GNU Lesser General Public License version 2.1 as published
7 // by the Free Software Foundation, with special exception defined in the file
8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
9 // distribution for complete text of the license and disclaimer of any warranty.
10 //
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
13
14 #include <AIS_DisplayMode.hxx>
15 #include <AIS_Triangulation.hxx>
16 #include <AIS_InteractiveObject.hxx>
17 #include <Standard_Type.hxx>
18 #include <Poly_Array1OfTriangle.hxx>
19 #include <Poly_Triangulation.hxx>
20 #include <Prs3d_Drawer.hxx>
21 #include <Prs3d_Root.hxx>
22 #include <Prs3d_ShadingAspect.hxx>
23 #include <TShort_Array1OfShortReal.hxx>
24 #include <TColgp_Array1OfPnt.hxx>
25 #include <TColStd_HArray1OfInteger.hxx>
26 #include <TShort_HArray1OfShortReal.hxx>
27 #include <Graphic3d_Group.hxx>
28 #include <Graphic3d_AspectFillArea3d.hxx>
29 #include <Graphic3d_ArrayOfTriangles.hxx>
30
31
32 IMPLEMENT_STANDARD_RTTIEXT(AIS_Triangulation,AIS_InteractiveObject)
33
34 AIS_Triangulation::AIS_Triangulation(const Handle(Poly_Triangulation)& Triangulation)
35 {
36   myTriangulation = Triangulation;
37   myNbNodes       = Triangulation->NbNodes();
38   myNbTriangles   = Triangulation->NbTriangles();
39   myFlagColor     = 0;
40 }
41
42 //=======================================================================
43 //function : SetTransparency
44 //purpose  :
45 //=======================================================================
46 void AIS_Triangulation::SetTransparency (const Standard_Real theValue)
47 {
48   if (!myDrawer->HasOwnShadingAspect())
49   {
50     myDrawer->SetShadingAspect (new Prs3d_ShadingAspect());
51     if (myDrawer->HasLink())
52     {
53       *myDrawer->ShadingAspect()->Aspect() = *myDrawer->Link()->ShadingAspect()->Aspect();
54     }
55   }
56
57   // override transparency
58   myDrawer->ShadingAspect()->SetTransparency (theValue, myCurrentFacingModel);
59   myDrawer->SetTransparency ((Standard_ShortReal )theValue);
60
61   updatePresentation();
62 }
63
64 //=======================================================================
65 //function : UnsetTransparency
66 //purpose  :
67 //=======================================================================
68 void AIS_Triangulation::UnsetTransparency()
69 {
70   myDrawer->SetTransparency (0.0f);
71   if (!myDrawer->HasOwnShadingAspect())
72   {
73     return;
74   }
75   else if (HasColor() || HasMaterial())
76   {
77     myDrawer->ShadingAspect()->SetTransparency (0.0, myCurrentFacingModel);
78   }
79
80   updatePresentation();
81 }
82
83 //=======================================================================
84 //function : updatePresentation
85 //purpose  :
86 //=======================================================================
87 void AIS_Triangulation::updatePresentation()
88 {
89   if (HasVertexColors())
90   {
91     SetToUpdate (AIS_WireFrame);
92   }
93   else
94   {
95     // modify shading presentation without re-computation
96     const PrsMgr_Presentations&        aPrsList  = Presentations();
97     Handle(Graphic3d_AspectFillArea3d) anAreaAsp = myDrawer->ShadingAspect()->Aspect();
98     for (Standard_Integer aPrsIt = 1; aPrsIt <= aPrsList.Length(); ++aPrsIt)
99     {
100       const PrsMgr_ModedPresentation& aPrsModed = aPrsList.Value (aPrsIt);
101       if (aPrsModed.Mode() != AIS_WireFrame)
102       {
103         continue;
104       }
105
106       const Handle(Prs3d_Presentation)& aPrs = aPrsModed.Presentation()->Presentation();
107
108       for (Graphic3d_SequenceOfGroup::Iterator aGroupIt (aPrs->Groups()); aGroupIt.More(); aGroupIt.Next())
109       {
110         const Handle(Graphic3d_Group)& aGroup = aGroupIt.Value();
111         aGroup->SetGroupPrimitivesAspect (anAreaAsp);
112       }
113     }
114
115     myRecomputeEveryPrs = Standard_False; // no mode to recalculate - only viewer update
116     myToRecomputeModes.Clear();
117   }
118 }
119
120 //=======================================================================
121 //function : Compute
122 //purpose  :
123 //=======================================================================
124 void AIS_Triangulation::Compute(const Handle(PrsMgr_PresentationManager3d)& /*aPresentationManager*/,
125                                 const Handle(Prs3d_Presentation)& aPresentation,
126                                 const Standard_Integer aMode)
127 {
128   switch (aMode)
129   {
130     case 0:
131       const TColgp_Array1OfPnt& nodes = myTriangulation->Nodes();             //Nodes
132       const Poly_Array1OfTriangle& triangles = myTriangulation->Triangles();  //Triangle
133
134       Standard_Boolean hasVNormals = myTriangulation->HasNormals();
135       Standard_Boolean hasVColors  = HasVertexColors();
136
137       Handle(Graphic3d_ArrayOfTriangles) anArray = new Graphic3d_ArrayOfTriangles (myNbNodes, myNbTriangles * 3,
138                                                                                    hasVNormals, hasVColors, Standard_False);
139       Handle(Graphic3d_Group) TheGroup = Prs3d_Root::CurrentGroup(aPresentation);
140       Handle(Graphic3d_AspectFillArea3d) aspect = myDrawer->ShadingAspect()->Aspect();
141
142       Standard_Integer i;
143       Standard_Integer j;
144
145       Standard_Real ambient = aspect->FrontMaterial().Ambient();
146       if (hasVNormals)
147       {
148         const TShort_Array1OfShortReal& normals = myTriangulation->Normals();
149         if (hasVColors)
150         {
151           const TColStd_Array1OfInteger& colors = myColor->Array1();
152           for ( i = nodes.Lower(); i <= nodes.Upper(); i++ )
153           {
154             j = (i - nodes.Lower()) * 3;
155             anArray->AddVertex(nodes(i), attenuateColor(colors(i), ambient));
156             anArray->SetVertexNormal(i, normals(j+1), normals(j+2), normals(j+3));
157           }
158         }
159         else // !hasVColors
160         {
161           for ( i = nodes.Lower(); i <= nodes.Upper(); i++ )
162           {
163             j = (i - nodes.Lower()) * 3;
164             anArray->AddVertex(nodes(i));
165             anArray->SetVertexNormal(i, normals(j+1), normals(j+2), normals(j+3));
166           }
167         }
168       }
169       else // !hasVNormals
170       {
171         if (hasVColors)
172         {
173           const TColStd_Array1OfInteger& colors = myColor->Array1();
174           for ( i = nodes.Lower(); i <= nodes.Upper(); i++ )
175           {
176             anArray->AddVertex(nodes(i), attenuateColor(colors(i), ambient));
177           }
178         }
179         else // !hasVColors
180         {
181           for ( i = nodes.Lower(); i <= nodes.Upper(); i++ )
182           {
183             anArray->AddVertex(nodes(i));
184           }
185         }
186       }
187
188       Standard_Integer indexTriangle[3] = {0,0,0};
189       for ( i = triangles.Lower(); i<= triangles.Upper(); i++ ) {
190         triangles(i).Get(indexTriangle[0], indexTriangle[1], indexTriangle[2]);
191         anArray->AddEdge(indexTriangle[0]);
192         anArray->AddEdge(indexTriangle[1]);
193         anArray->AddEdge(indexTriangle[2]);
194       }
195       TheGroup->SetPrimitivesAspect(aspect);
196       TheGroup->AddPrimitiveArray(anArray);
197       break;
198   }
199 }
200
201 //=======================================================================
202 //function : ComputeSelection
203 //purpose  :
204 //=======================================================================
205 void AIS_Triangulation::ComputeSelection(const Handle(SelectMgr_Selection)& /*aSelection*/,
206                                          const Standard_Integer /*aMode*/)
207 {
208
209 }
210
211 //=======================================================================
212 //function : SetColor
213 //purpose  : Set the color for each node.
214 //           Each 32-bit color is Alpha << 24 + Blue << 16 + Green << 8 + Red
215 //           Order of color components is essential for further usage by OpenGL
216 //=======================================================================
217 void AIS_Triangulation::SetColors(const Handle(TColStd_HArray1OfInteger)& aColor)
218 {
219   myFlagColor = 1;
220   myColor = aColor;
221 }
222
223 //=======================================================================
224 //function : GetColor
225 //purpose  : Get the color for each node.
226 //           Each 32-bit color is Alpha << 24 + Blue << 16 + Green << 8 + Red
227 //           Order of color components is essential for further usage by OpenGL
228 //=======================================================================
229
230 Handle(TColStd_HArray1OfInteger) AIS_Triangulation::GetColors() const
231 {
232   return myColor;
233 }
234
235
236 //=======================================================================
237 //function : SetTriangulation
238 //purpose  :
239 //=======================================================================
240 void AIS_Triangulation::SetTriangulation(const Handle(Poly_Triangulation)& aTriangulation)
241 {
242   myTriangulation = aTriangulation;
243 }
244
245 //=======================================================================
246 //function : GetTriangulation
247 //purpose  :
248 //=======================================================================
249 Handle(Poly_Triangulation) AIS_Triangulation::GetTriangulation() const{
250   return myTriangulation;
251 }
252
253 //=======================================================================
254 //function : AttenuateColor
255 //purpose  :
256 //=======================================================================
257 Graphic3d_Vec4ub AIS_Triangulation::attenuateColor (const Standard_Integer theColor,
258                                                     const Standard_Real    theComposition)
259 {
260   const Standard_Byte* anRgbx = reinterpret_cast<const Standard_Byte*> (&theColor);
261
262   // If IsTranparent() is false alpha value will be ignored anyway.
263   Standard_Byte anAlpha = IsTransparent() ? static_cast<Standard_Byte> (255.0 - myDrawer->ShadingAspect()->Aspect()->FrontMaterial().Transparency() * 255.0)
264                                           : 255;
265
266   return Graphic3d_Vec4ub ((Standard_Byte)(theComposition * anRgbx[0]),
267                            (Standard_Byte)(theComposition * anRgbx[1]),
268                            (Standard_Byte)(theComposition * anRgbx[2]),
269                            anAlpha);
270 }