0027860: Visualization - clean up Transformation Persistence API
[occt.git] / src / Graphic3d / Graphic3d_ArrayOfPrimitives.lxx
1 // Created on: 2000-06-16
2 // Copyright (c) 2000-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #include <Graphic3d_ArrayOfPrimitives.hxx>
16 #include <Standard_OutOfRange.hxx>
17
18 #include <gp_Dir.hxx>
19 #include <gp_Pnt.hxx>
20
21 inline const Handle(Graphic3d_IndexBuffer)& Graphic3d_ArrayOfPrimitives::Indices() const
22 {
23   return myIndices;
24 }
25
26 inline const Handle(Graphic3d_Buffer)& Graphic3d_ArrayOfPrimitives::Attributes() const
27 {
28   return myAttribs;
29 }
30
31 inline const Handle(Graphic3d_BoundBuffer)& Graphic3d_ArrayOfPrimitives::Bounds() const
32 {
33   return myBounds;
34 }
35
36 inline Graphic3d_TypeOfPrimitiveArray Graphic3d_ArrayOfPrimitives::Type() const
37 {
38   return myType;
39 }
40
41 inline Standard_Boolean Graphic3d_ArrayOfPrimitives::HasVertexNormals() const
42 {
43   return myVNor != 0;
44 }
45
46 inline Standard_Boolean Graphic3d_ArrayOfPrimitives::HasVertexColors() const
47 {
48   return myVCol != 0;
49 }
50
51 inline Standard_Boolean Graphic3d_ArrayOfPrimitives::HasVertexTexels() const
52 {
53   return myVTex != 0;
54 }
55
56 inline Standard_Integer Graphic3d_ArrayOfPrimitives::VertexNumber() const
57 {
58   return !myAttribs.IsNull() ? myAttribs->NbElements : -1;
59 }
60
61 inline Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex (const gp_Pnt& theVertex)
62 {
63   return AddVertex (theVertex.X(), theVertex.Y(), theVertex.Z());
64 }
65
66 inline Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex (const Graphic3d_Vec3& theVertex)
67 {
68   return AddVertex (theVertex.x(), theVertex.y(), theVertex.z());
69 }
70
71 inline Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex (const gp_Pnt&           theVertex,
72                                                                 const Graphic3d_Vec4ub& theColor)
73 {
74   const Standard_Integer anIndex = AddVertex (theVertex);
75   SetVertexColor (anIndex, theColor);
76   return anIndex;
77 }
78
79 inline Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex (const Standard_Real theX,
80                                                                 const Standard_Real theY,
81                                                                 const Standard_Real theZ)
82 {
83   return AddVertex (RealToShortReal (theX),
84                     RealToShortReal (theY),
85                     RealToShortReal (theZ));
86 }
87
88 inline Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex (const gp_Pnt& theVertex,
89                                                                 const gp_Dir& theNormal)
90 {
91   return AddVertex (theVertex.X(), theVertex.Y(), theVertex.Z(),
92                     theNormal.X(), theNormal.Y(), theNormal.Z());
93 }
94
95 inline Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex (const Standard_Real theX,  const Standard_Real theY,  const Standard_Real theZ,
96                                                                 const Standard_Real theNX, const Standard_Real theNY, const Standard_Real theNZ)
97 {
98   return AddVertex (RealToShortReal (theX),  RealToShortReal (theY),  RealToShortReal (theZ),
99                     Standard_ShortReal (theNX), Standard_ShortReal (theNY), Standard_ShortReal (theNZ));
100 }
101
102 inline Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex (const gp_Pnt&   theVertex,
103                                                                 const gp_Pnt2d& theTexel)
104 {
105   return AddVertex (theVertex.X(), theVertex.Y(), theVertex.Z(),
106                     theTexel.X(), theTexel.Y());
107 }
108
109 inline Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex (const Standard_Real theX,  const Standard_Real theY,  const Standard_Real theZ,
110                                                                 const Standard_Real theTX, const Standard_Real theTY)
111 {
112   return AddVertex (RealToShortReal (theX),  RealToShortReal (theY),  RealToShortReal (theZ),
113                     Standard_ShortReal (theTX), Standard_ShortReal (theTY));
114 }
115
116 inline Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex (const gp_Pnt&   theVertex,
117                                                                 const gp_Dir&   theNormal,
118                                                                 const gp_Pnt2d& theTexel)
119 {
120   return AddVertex (theVertex.X(), theVertex.Y(), theVertex.Z(),
121                     theNormal.X(), theNormal.Y(), theNormal.Z(),
122                     theTexel.X(),  theTexel.Y());
123 }
124
125 inline Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex (const Standard_Real theX,  const Standard_Real theY,  const Standard_Real theZ,
126                                                                 const Standard_Real theNX, const Standard_Real theNY, const Standard_Real theNZ,
127                                                                 const Standard_Real theTX, const Standard_Real theTY)
128 {
129   return AddVertex (RealToShortReal (theX),  RealToShortReal (theY),  RealToShortReal (theZ),
130                     Standard_ShortReal (theNX), Standard_ShortReal (theNY), Standard_ShortReal (theNZ),
131                     Standard_ShortReal (theTX), Standard_ShortReal (theTY));
132 }
133
134 inline void Graphic3d_ArrayOfPrimitives::SetVertice (const Standard_Integer   theIndex,
135                                                      const Standard_ShortReal theX,
136                                                      const Standard_ShortReal theY,
137                                                      const Standard_ShortReal theZ)
138 {
139   if (myAttribs.IsNull())
140   {
141     return;
142   }
143
144   if (theIndex < 1
145    || theIndex > myMaxVertexs)
146   {
147     Standard_OutOfRange::Raise ("BAD VERTEX index");
148   }
149
150   Graphic3d_Vec3& aVec = myAttribs->ChangeValue<Graphic3d_Vec3> (theIndex - 1);
151   aVec.x() = theX;
152   aVec.y() = theY;
153   aVec.z() = theZ;
154
155   myAttribs->NbElements = Max (theIndex, myAttribs->NbElements);
156 }
157
158 inline void Graphic3d_ArrayOfPrimitives::SetVertexColor (const Standard_Integer theIndex,
159                                                          const Standard_Real    theR,
160                                                          const Standard_Real    theG,
161                                                          const Standard_Real    theB)
162 {
163   if (myAttribs.IsNull())
164   {
165     return;
166   }
167
168   if (theIndex < 1
169    || theIndex > myMaxVertexs)
170   {
171     Standard_OutOfRange::Raise ("BAD VERTEX index");
172   }
173
174   if (myVCol != 0)
175   {
176     Graphic3d_Vec4ub aColor (Standard_Byte(theR * 255.0),
177                              Standard_Byte(theG * 255.0),
178                              Standard_Byte(theB * 255.0), 255);
179     SetVertexColor (theIndex, *reinterpret_cast<Standard_Integer*>(&aColor));
180   }
181   myAttribs->NbElements = Max (theIndex, myAttribs->NbElements);
182 }
183
184 inline void Graphic3d_ArrayOfPrimitives::SetVertexColor (const Standard_Integer  theIndex,
185                                                          const Graphic3d_Vec4ub& theColor)
186 {
187   SetVertexColor (theIndex, *reinterpret_cast<const Standard_Integer*> (&theColor));
188 }
189
190 inline void Graphic3d_ArrayOfPrimitives::SetVertexNormal (const Standard_Integer theIndex,
191                                                           const Standard_Real    theNX,
192                                                           const Standard_Real    theNY,
193                                                           const Standard_Real    theNZ)
194 {
195   if (myAttribs.IsNull())
196   {
197     return;
198   }
199
200   if (theIndex < 1
201    || theIndex > myMaxVertexs)
202   {
203     Standard_OutOfRange::Raise ("BAD VERTEX index");
204   }
205
206   if (myVNor != 0)
207   {
208     Graphic3d_Vec3& aVec = *reinterpret_cast<Graphic3d_Vec3* >(myAttribs->changeValue (theIndex - 1) + size_t(myVNor));
209     aVec.x() = Standard_ShortReal (theNX);
210     aVec.y() = Standard_ShortReal (theNY);
211     aVec.z() = Standard_ShortReal (theNZ);
212   }
213   myAttribs->NbElements = Max (theIndex, myAttribs->NbElements);
214 }
215
216 inline void Graphic3d_ArrayOfPrimitives::SetVertexTexel (const Standard_Integer theIndex,
217                                                          const Standard_Real    theTX,
218                                                          const Standard_Real    theTY)
219 {
220   if (myAttribs.IsNull())
221   {
222     return;
223   }
224
225   if (theIndex < 1
226    || theIndex > myMaxVertexs)
227   {
228     Standard_OutOfRange::Raise ("BAD VERTEX index");
229   }
230
231   if (myVTex != 0)
232   {
233     Graphic3d_Vec2& aVec = *reinterpret_cast<Graphic3d_Vec2* >(myAttribs->changeValue (theIndex - 1) + size_t(myVTex));
234     aVec.x() = Standard_ShortReal (theTX);
235     aVec.y() = Standard_ShortReal (theTY);
236   }
237   myAttribs->NbElements = Max (theIndex, myAttribs->NbElements);
238 }
239
240 inline void Graphic3d_ArrayOfPrimitives::SetBoundColor (const Standard_Integer theIndex,
241                                                         const Standard_Real    theR,
242                                                         const Standard_Real    theG,
243                                                         const Standard_Real    theB)
244 {
245   if (myBounds.IsNull())
246   {
247     return;
248   }
249
250   if (theIndex < 1
251    || theIndex > myMaxBounds)
252   {
253     Standard_OutOfRange::Raise ("BAD BOUND index");
254   }
255
256   Graphic3d_Vec4& aVec = myBounds->Colors[theIndex - 1];
257   aVec.r() = Standard_ShortReal (theR);
258   aVec.g() = Standard_ShortReal (theG);
259   aVec.b() = Standard_ShortReal (theB);
260   aVec.a() = 1.0f;
261   myBounds->NbBounds = Max (theIndex, myBounds->NbBounds);
262 }
263
264 inline void Graphic3d_ArrayOfPrimitives::Vertice (const Standard_Integer theIndex,
265                                                   Standard_Real&         theX,
266                                                   Standard_Real&         theY,
267                                                   Standard_Real&         theZ) const
268 {
269   theX = theY = theZ = 0.0;
270   if (myAttribs.IsNull())
271   {
272     return;
273   }
274
275   if (theIndex < 1
276    || theIndex > myAttribs->NbElements)
277   {
278     Standard_OutOfRange::Raise ("BAD VERTEX index");
279   }
280
281   const Graphic3d_Vec3& aVec = myAttribs->Value<Graphic3d_Vec3> (theIndex - 1);
282   theX = Standard_Real(aVec.x());
283   theY = Standard_Real(aVec.y());
284   theZ = Standard_Real(aVec.z());
285 }
286
287 inline void Graphic3d_ArrayOfPrimitives::VertexColor (const Standard_Integer theIndex,
288                                                       Standard_Real&         theR,
289                                                       Standard_Real&         theG,
290                                                       Standard_Real&         theB) const
291 {
292   theR = theG = theB = 0.0;
293   if (myAttribs.IsNull())
294   {
295     return;
296   }
297
298   if (theIndex < 1
299    || theIndex > myAttribs->NbElements)
300   {
301     Standard_OutOfRange::Raise ("BAD VERTEX index");
302   }
303   Standard_Integer aColorInt = 0;
304   VertexColor (theIndex, aColorInt);
305   const Graphic3d_Vec4ub& aColor = *reinterpret_cast<const Graphic3d_Vec4ub* >(&aColorInt);
306   theR = Standard_Real(aColor.r()) / 255.0;
307   theG = Standard_Real(aColor.g()) / 255.0;
308   theB = Standard_Real(aColor.b()) / 255.0;
309 }
310
311 inline void Graphic3d_ArrayOfPrimitives::VertexColor (const Standard_Integer theIndex,
312                                                       Standard_Integer&      theColor) const
313 {
314   if (myVCol != 0)
315   {
316     theColor = *reinterpret_cast<const Standard_Integer* >(myAttribs->value (theIndex - 1) + size_t(myVCol));
317   }
318 }
319
320 inline void Graphic3d_ArrayOfPrimitives::VertexNormal (const Standard_Integer theIndex,
321                                                        Standard_Real&         theNX,
322                                                        Standard_Real&         theNY,
323                                                        Standard_Real&         theNZ) const
324 {
325   theNX = theNY = theNZ = 0.0;
326   if (myAttribs.IsNull())
327   {
328     return;
329   }
330
331   if (theIndex < 1
332    || theIndex > myAttribs->NbElements)
333   {
334     Standard_OutOfRange::Raise ("BAD VERTEX index");
335   }
336
337   if (myVNor != 0)
338   {
339     const Graphic3d_Vec3& aVec = *reinterpret_cast<const Graphic3d_Vec3* >(myAttribs->value (theIndex - 1) + size_t(myVNor));
340     theNX = Standard_Real(aVec.x());
341     theNY = Standard_Real(aVec.y());
342     theNZ = Standard_Real(aVec.z());
343   }
344 }
345
346 inline void Graphic3d_ArrayOfPrimitives::VertexTexel (const Standard_Integer theIndex,
347                                                       Standard_Real&         theTX,
348                                                       Standard_Real&         theTY) const
349 {
350   theTX = theTY = 0.0;
351   if (myAttribs.IsNull())
352   {
353     return;
354   }
355
356   if (theIndex < 1
357    || theIndex > myAttribs->NbElements)
358   {
359     Standard_OutOfRange::Raise ("BAD VERTEX index");
360   }
361
362   if (myVTex != 0)
363   {
364     const Graphic3d_Vec2& aVec = *reinterpret_cast<const Graphic3d_Vec2* >(myAttribs->value (theIndex - 1) + size_t(myVTex));
365     theTX = Standard_Real(aVec.x());
366     theTY = Standard_Real(aVec.y());
367   }
368 }
369
370 inline Standard_Integer Graphic3d_ArrayOfPrimitives::EdgeNumber() const
371 {
372   return !myIndices.IsNull() ? myIndices->NbElements : -1;
373 }
374
375 inline Standard_Integer Graphic3d_ArrayOfPrimitives::Edge (const Standard_Integer theIndex) const
376 {
377   if (myIndices.IsNull()
378    || theIndex <= 0
379    || theIndex > myIndices->NbElements)
380   {
381     Standard_OutOfRange::Raise ("BAD EDGE index");
382   }
383   return Standard_Integer(myIndices->Index (theIndex - 1) + 1);
384 }
385
386 inline Standard_Boolean Graphic3d_ArrayOfPrimitives::HasBoundColors() const
387 {
388   return !myBounds.IsNull() && myBounds->Colors != NULL;
389 }
390
391 inline Standard_Integer Graphic3d_ArrayOfPrimitives::BoundNumber() const
392 {
393   return !myBounds.IsNull() ? myBounds->NbBounds : -1;
394 }
395
396 inline Standard_Integer Graphic3d_ArrayOfPrimitives::Bound (const Standard_Integer theIndex) const
397 {
398   if (myBounds.IsNull()
399    || theIndex <= 0
400    || theIndex > myBounds->NbBounds)
401   {
402     Standard_OutOfRange::Raise ("BAD BOUND index");
403   }
404   return myBounds->Bounds[theIndex - 1];
405 }
406
407 inline void Graphic3d_ArrayOfPrimitives::BoundColor (const Standard_Integer theIndex,
408                                                      Standard_Real&         theR,
409                                                      Standard_Real&         theG,
410                                                      Standard_Real&         theB) const
411 {
412   if (myBounds.IsNull()
413    || myBounds->Colors == NULL
414    || theIndex <= 0
415    || theIndex > myBounds->NbBounds)
416   {
417     Standard_OutOfRange::Raise(" BAD BOUND index");
418   }
419
420   const Graphic3d_Vec4& aVec = myBounds->Colors[theIndex - 1];
421   theR = Standard_Real(aVec.r());
422   theG = Standard_Real(aVec.g());
423   theB = Standard_Real(aVec.b());
424 }