1 // File Graphic3d_ArrayOfPrimitives.cxx
2 // Created 16/06/2000 : ATS/GG : G005
6 #include <Graphic3d_ArrayOfPrimitives.ixx>
7 #include <Standard.hxx>
8 #include <TCollection_AsciiString.hxx>
9 #include <OSD_Environment.hxx>
14 static Standard_Integer enableArray = 1;
15 static Standard_Boolean interleavedArray = Standard_False;
17 Graphic3d_ArrayOfPrimitives :: Graphic3d_ArrayOfPrimitives (
18 const Graphic3d_TypeOfPrimitiveArray aType,
19 const Standard_Integer maxVertexs,
20 const Standard_Integer maxBounds,
21 const Standard_Integer maxEdges,
22 const Standard_Boolean hasVNormals,
23 const Standard_Boolean hasVColors,
24 const Standard_Boolean hasFColors,
25 const Standard_Boolean hasVTexels,
26 const Standard_Boolean hasEdgeInfos
27 ) : myMaxBounds(0),myMaxVertexs(0),myMaxEdges(0) {
28 Standard_Integer size = sizeof(CALL_DEF_PARRAY);
29 Standard_Integer format = MVERTICE;
30 if( hasVNormals ) format |= MVNORMAL;
31 if( hasVColors ) format |= MVCOLOR;
32 if( hasVTexels ) format |= MVTEXEL;
34 myPrimitiveArray = (Graphic3d_PrimitiveArray) Standard::Allocate(size);
35 memset ( myPrimitiveArray, 0, size );
38 myPrimitiveArray->vertices = (TEL_POINT*) Standard::Allocate(maxVertexs *sizeof(TEL_POINT));
39 memset ( myPrimitiveArray->vertices, 0, maxVertexs *sizeof(TEL_POINT));
43 myPrimitiveArray->vnormals = (TEL_POINT*) Standard::Allocate(sizeof(TEL_POINT) * maxVertexs);
44 memset ( myPrimitiveArray->vnormals, 0, sizeof(TEL_POINT) * maxVertexs);
48 myPrimitiveArray->vcolours = (Tint*) Standard::Allocate(maxVertexs *sizeof(Tint));
49 memset ( myPrimitiveArray->vcolours, 0, sizeof(Tint) * maxVertexs);
53 myPrimitiveArray->vtexels = (TEL_TEXTURE_COORD*) Standard::Allocate(maxVertexs *sizeof(TEL_TEXTURE_COORD));
54 memset ( myPrimitiveArray->vtexels, 0, sizeof(TEL_TEXTURE_COORD) * maxVertexs);
57 if( hasFColors && (maxBounds > 0) ){
58 myPrimitiveArray->fcolours = (TEL_COLOUR*) Standard::Allocate(maxBounds *sizeof(TEL_COLOUR));
59 memset ( myPrimitiveArray->fcolours, 0, sizeof(TEL_COLOUR) * maxBounds);
63 myPrimitiveArray->bounds = (Tint*) Standard::Allocate(maxBounds *sizeof(Tint));
64 memset ( myPrimitiveArray->bounds, 0, maxBounds *sizeof(Tint));
68 myPrimitiveArray->edges = (Tint*) Standard::Allocate(maxEdges *sizeof(Tint));
69 memset ( myPrimitiveArray->edges, 0, maxEdges *sizeof(Tint));
72 if( hasEdgeInfos && (maxEdges > 0) ){
73 myPrimitiveArray->edge_vis = (Tchar*)Standard::Allocate(maxEdges *sizeof(Tchar));
74 memset ( myPrimitiveArray->edge_vis, 0, maxEdges *sizeof(Tchar));
77 myPrimitiveArray->keys = NULL;
78 myMaxVertexs = maxVertexs;
79 myMaxBounds = maxBounds;
80 myMaxEdges = maxEdges;
81 myPrimitiveArray->type = (TelPrimitivesArrayType) aType;
82 myPrimitiveArray->format = format;
83 myPrimitiveArray->num_bounds = 0;
84 myPrimitiveArray->num_vertexs = 0;
85 myPrimitiveArray->num_edges = 0;
86 myPrimitiveArray->VBOEnabled = -1;
87 myPrimitiveArray->flagBufferVBO = -1;
88 myPrimitiveArray->contextId = 0;
90 for( int i =0 ; i < VBOMaxType ; i++){
91 myPrimitiveArray->bufferVBO[i] = 0;
96 void Graphic3d_ArrayOfPrimitives::Destroy ( ){
97 if( myPrimitiveArray ) {
98 if( myPrimitiveArray->vertices ){
99 Standard::Free( (Standard_Address&)myPrimitiveArray->vertices );
100 myPrimitiveArray->vertices = 0;
103 if( myPrimitiveArray->vnormals ){
104 Standard::Free( (Standard_Address&)myPrimitiveArray->vnormals );
105 myPrimitiveArray->vnormals = 0;
108 if( myPrimitiveArray->vcolours ){
109 Standard::Free( (Standard_Address&)myPrimitiveArray->vcolours );
110 myPrimitiveArray->vcolours = 0;
113 if( myPrimitiveArray->vtexels ){
114 Standard::Free( (Standard_Address&)myPrimitiveArray->vtexels );
115 myPrimitiveArray->vtexels = 0;
118 if( myPrimitiveArray->fcolours ){
119 Standard::Free( (Standard_Address&)myPrimitiveArray->fcolours );
120 myPrimitiveArray->fcolours = 0;
123 if( myPrimitiveArray->bounds ){
124 Standard::Free( (Standard_Address&)myPrimitiveArray->bounds );
125 myPrimitiveArray->bounds = 0;
128 if( myPrimitiveArray->edges ){
129 Standard::Free( (Standard_Address&)myPrimitiveArray->edges );
130 myPrimitiveArray->edges = 0;
133 if( myPrimitiveArray->edge_vis ){
134 Standard::Free( (Standard_Address&)myPrimitiveArray->edge_vis );
135 myPrimitiveArray->edge_vis = 0;
138 Standard::Free( (Standard_Address&)myPrimitiveArray );
140 cout << " Graphic3d_ArrayOfPrimitives::Destroy()" << endl;
145 void Graphic3d_ArrayOfPrimitives::Enable() {
149 void Graphic3d_ArrayOfPrimitives::Disable() {
153 Standard_Boolean Graphic3d_ArrayOfPrimitives::IsEnable() {
155 if( enableArray == 0 ) {
156 OSD_Environment csf(TCollection_AsciiString("CSF_USE_ARRAY_OF_PRIMITIVES"));
157 TCollection_AsciiString value = csf.Value();
159 if( value.Length() > 0 ) {
160 if( value.IsIntegerValue() ) {
161 enableArray = value.IntegerValue();
162 if( enableArray > 1 ) {
164 } else interleavedArray = Standard_False;
168 if( enableArray > 0 ) {
169 if( interleavedArray )
170 cout << " ! ENABLE to use Interleaved arrays of primitives" << endl;
172 cout << " ! ENABLE to use Single arrays of primitives" << endl;
174 cout << " ! DISABLE to use arrays of primitives" << endl;
177 if( enableArray > 0 ) return Standard_True;
179 return Standard_False;
182 Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex(
183 const gp_Pnt& aVertice) {
185 aVertice.Coord(x,y,z);
186 return AddVertex(x,y,z);
189 Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex(
190 const Standard_Real X, const Standard_Real Y, const Standard_Real Z) {
192 if( !myPrimitiveArray ) return 0;
194 Standard_Integer index = myPrimitiveArray->num_vertexs + 1;
195 if( index > myMaxVertexs ) {
196 Standard_OutOfRange::Raise(" TOO many VERTEX");
198 SetVertice(index,X,Y,Z);
202 Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex(
203 const gp_Pnt& aVertice,
204 const Quantity_Color& aColor) {
206 aVertice.Coord(x,y,z);
207 Standard_Integer index = AddVertex(x,y,z);
209 aColor.Values(r,g,b,Quantity_TOC_RGB);
210 SetVertexColor(index,r,g,b);
213 Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex(
214 const gp_Pnt& aVertice,
215 const Standard_Integer aColor) {
217 aVertice.Coord(x,y,z);
218 Standard_Integer index = AddVertex(x,y,z);
219 SetVertexColor(index,aColor);
224 Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex(
225 const gp_Pnt& aVertice,
226 const gp_Dir& aNormal) {
228 aVertice.Coord(x,y,z);
229 Standard_Real nx,ny,nz;
230 aNormal.Coord(nx,ny,nz);
231 return AddVertex(x,y,z,nx,ny,nz);
234 Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex(
235 const Standard_Real X, const Standard_Real Y, const Standard_Real Z,
236 const Standard_Real NX, const Standard_Real NY, const Standard_Real NZ) {
237 if( !myPrimitiveArray ) return 0;
239 Standard_Integer index = myPrimitiveArray->num_vertexs + 1;
240 if( index > myMaxVertexs ) {
241 Standard_OutOfRange::Raise(" TOO many VERTEX");
243 SetVertice(index,X,Y,Z);
244 SetVertexNormal(index,NX,NY,NZ);
249 Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex(
250 const gp_Pnt& aVertice,
251 const gp_Dir& aNormal,
252 const Quantity_Color& aColor) {
254 aVertice.Coord(x,y,z);
255 Standard_Real nx,ny,nz;
256 aNormal.Coord(nx,ny,nz);
257 Standard_Integer index = AddVertex(x,y,z,nx,ny,nz);
259 aColor.Values(r,g,b,Quantity_TOC_RGB);
260 SetVertexColor(index,r,g,b);
264 Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex(
265 const gp_Pnt& aVertice,
266 const gp_Dir& aNormal,
267 const Standard_Integer aColor) {
269 aVertice.Coord(x,y,z);
270 Standard_Real nx,ny,nz;
271 aNormal.Coord(nx,ny,nz);
272 Standard_Integer index = AddVertex(x,y,z,nx,ny,nz);
273 SetVertexColor(index,aColor);
277 Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex(
278 const gp_Pnt& aVertice,
279 const gp_Pnt2d& aTexel) {
281 aVertice.Coord(x,y,z);
284 return AddVertex(x,y,z,tx,ty);
287 Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex(
288 const Standard_Real X, const Standard_Real Y, const Standard_Real Z,
289 const Standard_Real TX, const Standard_Real TY) {
290 if( !myPrimitiveArray ) return 0;
292 Standard_Integer index = myPrimitiveArray->num_vertexs + 1;
293 if( index > myMaxVertexs ) {
294 Standard_OutOfRange::Raise(" TOO many VERTEX");
296 SetVertice(index,X,Y,Z);
297 SetVertexTexel(index,TX,TY);
301 Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex(
302 const gp_Pnt& aVertice,
303 const gp_Dir& aNormal,
304 const gp_Pnt2d& aTexel) {
306 aVertice.Coord(x,y,z);
307 Standard_Real nx,ny,nz;
308 aNormal.Coord(nx,ny,nz);
311 return AddVertex(x,y,z,nx,ny,nz,tx,ty);
314 Standard_Integer Graphic3d_ArrayOfPrimitives::AddVertex(
315 const Standard_Real X, const Standard_Real Y, const Standard_Real Z,
316 const Standard_Real NX, const Standard_Real NY, const Standard_Real NZ,
317 const Standard_Real TX, const Standard_Real TY) {
318 if( !myPrimitiveArray ) return 0;
320 Standard_Integer index = myPrimitiveArray->num_vertexs + 1;
321 if( index > myMaxVertexs ) {
322 Standard_OutOfRange::Raise(" TOO many VERTEX");
324 SetVertice(index,X,Y,Z);
325 SetVertexNormal(index,NX,NY,NZ);
326 SetVertexTexel(index,TX,TY);
330 Standard_Integer Graphic3d_ArrayOfPrimitives::AddBound( const Standard_Integer edgeNumber) {
331 Standard_Integer index = 0;
332 if( myPrimitiveArray && myPrimitiveArray->bounds ) {
333 index = myPrimitiveArray->num_bounds;
334 if( index < myMaxBounds ) {
335 myPrimitiveArray->bounds[index] = edgeNumber;
336 myPrimitiveArray->num_bounds = ++index;
338 Standard_OutOfRange::Raise(" TOO many BOUNDS");
345 Standard_Integer Graphic3d_ArrayOfPrimitives::AddBound(
346 const Standard_Integer edgeNumber,
347 const Quantity_Color& aFColor
350 aFColor.Values(r,g,b,Quantity_TOC_RGB);
351 return AddBound(edgeNumber,r,g,b);
354 Standard_Integer Graphic3d_ArrayOfPrimitives::AddBound(
355 const Standard_Integer edgeNumber,
356 const Standard_Real R,
357 const Standard_Real G,
358 const Standard_Real B) {
359 if( !myPrimitiveArray ) return 0;
361 Standard_Integer index = myPrimitiveArray->num_bounds;
362 if( index >= myMaxBounds ) {
363 Standard_OutOfRange::Raise(" TOO many BOUND");
365 myPrimitiveArray->bounds[index] = edgeNumber;
366 myPrimitiveArray->num_bounds = ++index;
367 SetBoundColor(index,R,G,B);
371 Standard_Integer Graphic3d_ArrayOfPrimitives::AddEdge(
372 const Standard_Integer vertexIndex,
373 const Standard_Boolean isVisible) {
374 if( !myPrimitiveArray ) return 0;
376 Standard_Integer index = myPrimitiveArray->num_edges;
377 if( index >= myMaxEdges ) {
378 Standard_OutOfRange::Raise(" TOO many EDGE");
380 Standard_Integer vindex = vertexIndex-1;
381 if( vertexIndex > 0 && vindex < myMaxVertexs ) {
382 myPrimitiveArray->edges[index] = vindex;
383 if( myPrimitiveArray->edge_vis ) {
384 myPrimitiveArray->edge_vis[index] = (Tchar) (isVisible ? 1 : 0);
386 myPrimitiveArray->num_edges = ++index;
388 Standard_OutOfRange::Raise(" BAD EDGE vertex index");
394 Standard_Boolean Graphic3d_ArrayOfPrimitives::Orientate(
395 const gp_Dir& aNormal) {
396 return Orientate(1,Max(VertexNumber(),EdgeNumber()),aNormal);
399 Standard_Boolean Graphic3d_ArrayOfPrimitives::Orientate(
400 const Standard_Integer aVertexIndex,
401 const Standard_Integer aVertexNumber,
402 const gp_Dir& aNormal) {
403 Standard_Boolean somethingHasChange = Standard_False;
404 if( myPrimitiveArray && (myPrimitiveArray->num_vertexs > 2) ) {
405 Standard_Integer i,j,k=aVertexNumber,n=aVertexIndex-1;
406 Standard_ShortReal x,y,z;
407 if( myPrimitiveArray->edges ) {
408 if( n >= 0 && (n+k) <= myPrimitiveArray->num_edges ) {
409 Standard_Integer i1 = myPrimitiveArray->edges[n];
410 Standard_Integer i2 = myPrimitiveArray->edges[n+1];
411 Standard_Integer i3 = myPrimitiveArray->edges[n+2];
412 gp_Pnt p1(myPrimitiveArray->vertices[i1].xyz[0],
413 myPrimitiveArray->vertices[i1].xyz[1],
414 myPrimitiveArray->vertices[i1].xyz[2]);
415 gp_Pnt p2(myPrimitiveArray->vertices[i2].xyz[0],
416 myPrimitiveArray->vertices[i2].xyz[1],
417 myPrimitiveArray->vertices[i2].xyz[2]);
418 gp_Pnt p3(myPrimitiveArray->vertices[i3].xyz[0],
419 myPrimitiveArray->vertices[i3].xyz[1],
420 myPrimitiveArray->vertices[i3].xyz[2]);
421 gp_Vec v21(p1,p2),v31(p1,p3),fn = v21.Crossed(v31);
422 if( aNormal.IsOpposite(fn,Standard_PI/4.) ) {
423 Standard_Integer e; char v;
424 for( i=0,j=k-1 ; i<k/2 ; i++,j-- ) {
425 e = myPrimitiveArray->edges[n+i];
426 myPrimitiveArray->edges[n+i] = myPrimitiveArray->edges[n+j];
427 myPrimitiveArray->edges[n+j] = e;
428 if( myPrimitiveArray->edge_vis ) {
429 v = myPrimitiveArray->edge_vis[n+i];
430 myPrimitiveArray->edge_vis[n+i] = myPrimitiveArray->edge_vis[n+j];
431 myPrimitiveArray->edge_vis[n+j] = v;
433 if( myPrimitiveArray->vnormals ) {
434 e = myPrimitiveArray->edges[n+i];
435 x = myPrimitiveArray->vnormals[e].xyz[0];
436 y = myPrimitiveArray->vnormals[e].xyz[1];
437 z = myPrimitiveArray->vnormals[e].xyz[2];
439 if( aNormal.IsOpposite(vn,Standard_PI/4.) ) {
440 myPrimitiveArray->vnormals[e].xyz[0] = -x;
441 myPrimitiveArray->vnormals[e].xyz[1] = -y;
442 myPrimitiveArray->vnormals[e].xyz[2] = -z;
446 somethingHasChange = Standard_True;
449 Standard_OutOfRange::Raise(" BAD EDGE index or number");
451 return somethingHasChange;
454 if( n >= 0 && (n+k) <= myPrimitiveArray->num_vertexs ) {
455 gp_Pnt p1(myPrimitiveArray->vertices[n].xyz[0],
456 myPrimitiveArray->vertices[n].xyz[1],
457 myPrimitiveArray->vertices[n].xyz[2]);
458 gp_Pnt p2(myPrimitiveArray->vertices[n+1].xyz[0],
459 myPrimitiveArray->vertices[n+1].xyz[1],
460 myPrimitiveArray->vertices[n+1].xyz[2]);
461 gp_Pnt p3(myPrimitiveArray->vertices[n+2].xyz[0],
462 myPrimitiveArray->vertices[n+2].xyz[1],
463 myPrimitiveArray->vertices[n+2].xyz[2]);
464 gp_Vec v21(p1,p2),v31(p1,p3),fn = v21.Crossed(v31);
465 if( aNormal.IsOpposite(fn,Standard_PI/4.) ) {
466 for( i=0,j=k-1 ; i<k/2 ; i++,j-- ) {
467 x = myPrimitiveArray->vertices[n+i].xyz[0];
468 y = myPrimitiveArray->vertices[n+i].xyz[1];
469 z = myPrimitiveArray->vertices[n+i].xyz[2];
470 myPrimitiveArray->vertices[n+i].xyz[0] = myPrimitiveArray->vertices[n+j].xyz[0];
471 myPrimitiveArray->vertices[n+i].xyz[1] = myPrimitiveArray->vertices[n+j].xyz[1];
472 myPrimitiveArray->vertices[n+i].xyz[2] = myPrimitiveArray->vertices[n+j].xyz[2];
473 myPrimitiveArray->vertices[n+j].xyz[0] = x;
474 myPrimitiveArray->vertices[n+j].xyz[1] = y;
475 myPrimitiveArray->vertices[n+j].xyz[2] = z;
476 if( myPrimitiveArray->vnormals ) {
477 x = myPrimitiveArray->vnormals[n+i].xyz[0];
478 y = myPrimitiveArray->vnormals[n+i].xyz[1];
479 z = myPrimitiveArray->vnormals[n+i].xyz[2];
480 myPrimitiveArray->vnormals[n+i].xyz[0] = myPrimitiveArray->vnormals[n+j].xyz[0];
481 myPrimitiveArray->vnormals[n+i].xyz[1] = myPrimitiveArray->vnormals[n+j].xyz[1];
482 myPrimitiveArray->vnormals[n+i].xyz[2] = myPrimitiveArray->vnormals[n+j].xyz[2];
483 myPrimitiveArray->vnormals[n+j].xyz[0] = x;
484 myPrimitiveArray->vnormals[n+j].xyz[1] = y;
485 myPrimitiveArray->vnormals[n+j].xyz[2] = z;
487 x = myPrimitiveArray->vnormals[n+i].xyz[0];
488 y = myPrimitiveArray->vnormals[n+i].xyz[1];
489 z = myPrimitiveArray->vnormals[n+i].xyz[2];
491 if( aNormal.IsOpposite(vn,Standard_PI/4.) ) {
492 myPrimitiveArray->vnormals[n+i].xyz[0] = -x;
493 myPrimitiveArray->vnormals[n+i].xyz[1] = -y;
494 myPrimitiveArray->vnormals[n+i].xyz[2] = -z;
497 if( myPrimitiveArray->vcolours ) {
498 x = (Standard_ShortReal)myPrimitiveArray->vcolours[n+i];
499 myPrimitiveArray->vcolours[n+i] = myPrimitiveArray->vcolours[n+j];
500 myPrimitiveArray->vcolours[n+j] = (Tint)x;
502 if( myPrimitiveArray->vtexels ) {
503 x = myPrimitiveArray->vtexels[n+i].xy[0];
504 y = myPrimitiveArray->vtexels[n+i].xy[1];
505 myPrimitiveArray->vtexels[n+i].xy[0] = myPrimitiveArray->vtexels[n+j].xy[0];
506 myPrimitiveArray->vtexels[n+i].xy[1] = myPrimitiveArray->vtexels[n+j].xy[1];
507 myPrimitiveArray->vtexels[n+j].xy[0] = x;
508 myPrimitiveArray->vtexels[n+j].xy[1] = y;
511 somethingHasChange = Standard_True;
515 return somethingHasChange;
518 Standard_Boolean Graphic3d_ArrayOfPrimitives::Orientate(
519 const Standard_Integer aBoundIndex,
520 const gp_Dir& aNormal) {
521 Standard_Boolean somethingHasChange = Standard_False;
522 if( myPrimitiveArray && myPrimitiveArray->vertices ) {
523 if( myPrimitiveArray->bounds &&
524 (aBoundIndex > 0) && (aBoundIndex <= myPrimitiveArray->num_bounds) ) {
525 Standard_Integer k,n;
526 for( k=n=1 ; k<aBoundIndex ; k++ )
527 n += myPrimitiveArray->bounds[k];
528 k = myPrimitiveArray->bounds[aBoundIndex-1];
529 somethingHasChange = Orientate(n,k,aNormal);
530 } else if( myPrimitiveArray->bounds ) {
531 Standard_OutOfRange::Raise(" BAD BOUND index");
532 } else if( (aBoundIndex > 0) && (aBoundIndex <= ItemNumber()) ) {
533 switch( myPrimitiveArray->type ) {
534 case TelPointsArrayType:
535 case TelPolylinesArrayType:
536 case TelSegmentsArrayType:
538 case TelPolygonsArrayType:
539 case TelTriangleStripsArrayType:
540 case TelTriangleFansArrayType:
541 case TelQuadrangleStripsArrayType:
542 somethingHasChange = Orientate(1,VertexNumber(),aNormal);
544 case TelTrianglesArrayType:
545 somethingHasChange = Orientate(aBoundIndex*3-2,3,aNormal);
547 case TelQuadranglesArrayType:
548 somethingHasChange = Orientate(aBoundIndex*4-3,4,aNormal);
554 Standard_OutOfRange::Raise(" BAD ITEM index");
557 return somethingHasChange;
560 void Graphic3d_ArrayOfPrimitives::SetVertice(
561 const Standard_Integer anIndex,
562 const gp_Pnt& aVertice) {
564 aVertice.Coord(x,y,z);
565 SetVertice(anIndex,x,y,z);
568 void Graphic3d_ArrayOfPrimitives::SetVertexColor(
569 const Standard_Integer anIndex,
570 const Quantity_Color& aColor) {
572 aColor.Values(r,g,b,Quantity_TOC_RGB);
573 SetVertexColor(anIndex,r,g,b);
576 void Graphic3d_ArrayOfPrimitives::SetVertexColor(
577 const Standard_Integer anIndex,
578 const Standard_Integer aColor) {
580 if( !myPrimitiveArray ) return;
581 if( anIndex < 1 || anIndex > myMaxVertexs ) {
582 Standard_OutOfRange::Raise(" BAD VERTEX index");
584 Standard_Integer index = anIndex - 1;
585 if( myPrimitiveArray->vcolours ) {
586 #if defined (sparc) || defined (__sparc__) || defined (__sparc)
588 Well known processor(x86) architectures that use the little-endian format.
589 Processors use big-endian format is SPARC. In this case use platform with
590 SPARC architecture(SUNOS). Byte order could have little-endian format.
592 const char* p_ch = (const char*)&aColor;
593 myPrimitiveArray->vcolours[index] += p_ch[0];
594 myPrimitiveArray->vcolours[index] += p_ch[1] << 8 ;
595 myPrimitiveArray->vcolours[index] += p_ch[2] << 16;
596 myPrimitiveArray->vcolours[index] += p_ch[3] << 24;
598 myPrimitiveArray->vcolours[index] = aColor;
603 void Graphic3d_ArrayOfPrimitives::SetVertexNormal(
604 const Standard_Integer anIndex,
605 const gp_Dir& aNormal) {
607 aNormal.Coord(x,y,z);
608 SetVertexNormal(anIndex,x,y,z);
611 void Graphic3d_ArrayOfPrimitives::SetVertexTexel(
612 const Standard_Integer anIndex,
613 const gp_Pnt2d& aTexel) {
616 SetVertexTexel(anIndex,x,y);
619 void Graphic3d_ArrayOfPrimitives::SetBoundColor(
620 const Standard_Integer anIndex,
621 const Quantity_Color& aColor) {
623 aColor.Values(r,g,b,Quantity_TOC_RGB);
624 SetBoundColor(anIndex,r,g,b);
627 Standard_CString Graphic3d_ArrayOfPrimitives::StringType() const {
628 TCollection_AsciiString name("UndefinedArray");
629 switch( myPrimitiveArray->type ) {
630 case TelPointsArrayType:
631 name = "ArrayOfPoints";
633 case TelPolylinesArrayType:
634 name = "ArrayOfPolylines";
636 case TelSegmentsArrayType:
637 name = "ArrayOfSegments";
639 case TelPolygonsArrayType:
640 name = "ArrayOfPolygons";
642 case TelTrianglesArrayType:
643 name = "ArrayOfTriangles";
645 case TelQuadranglesArrayType:
646 name = "ArrayOfQuadrangles";
648 case TelTriangleStripsArrayType:
649 name = "ArrayOfTriangleStrips";
651 case TelQuadrangleStripsArrayType:
652 name = "ArrayOfQuadrangleStrips";
654 case TelTriangleFansArrayType:
655 name = "ArrayOfTriangleFans";
661 return name.ToCString();
664 gp_Pnt Graphic3d_ArrayOfPrimitives::Vertice(const Standard_Integer aRank) const {
666 Vertice(aRank,x,y,z);
667 return gp_Pnt(x,y,z);
670 Quantity_Color Graphic3d_ArrayOfPrimitives::VertexColor(const Standard_Integer aRank) const {
672 VertexColor(aRank,r,g,b);
673 return Quantity_Color(r,g,b,Quantity_TOC_RGB);
676 gp_Dir Graphic3d_ArrayOfPrimitives::VertexNormal(const Standard_Integer aRank) const {
678 VertexNormal(aRank,x,y,z);
679 return gp_Dir(x,y,z);
682 gp_Pnt2d Graphic3d_ArrayOfPrimitives::VertexTexel(const Standard_Integer aRank) const {
684 VertexTexel(aRank,x,y);
685 return gp_Pnt2d(x,y);
688 Quantity_Color Graphic3d_ArrayOfPrimitives::BoundColor(const Standard_Integer aRank) const {
690 BoundColor(aRank,r,g,b);
691 return Quantity_Color(r,g,b,Quantity_TOC_RGB);
694 Standard_Integer Graphic3d_ArrayOfPrimitives::ItemNumber() const {
695 Standard_Integer number=-1;
696 if( myPrimitiveArray ) switch( myPrimitiveArray->type ) {
697 case TelPointsArrayType:
698 number = myPrimitiveArray->num_vertexs;
700 case TelPolylinesArrayType:
701 case TelPolygonsArrayType:
702 if( myPrimitiveArray->num_bounds > 0 )
703 number = myPrimitiveArray->num_bounds;
706 case TelSegmentsArrayType:
707 if( myPrimitiveArray->num_edges > 0 )
708 number = myPrimitiveArray->num_edges/2;
709 else number = myPrimitiveArray->num_vertexs/2;
711 case TelTrianglesArrayType:
712 if( myPrimitiveArray->num_edges > 0 )
713 number = myPrimitiveArray->num_edges/3;
714 else number = myPrimitiveArray->num_vertexs/3;
716 case TelQuadranglesArrayType:
717 if( myPrimitiveArray->num_edges > 0 )
718 number = myPrimitiveArray->num_edges/4;
719 else number = myPrimitiveArray->num_vertexs/4;
721 case TelTriangleStripsArrayType:
722 if( myPrimitiveArray->num_bounds > 0 )
723 number = myPrimitiveArray->num_vertexs-2*myPrimitiveArray->num_bounds;
724 else number = myPrimitiveArray->num_vertexs-2;
726 case TelQuadrangleStripsArrayType:
727 if( myPrimitiveArray->num_bounds > 0 )
728 number = myPrimitiveArray->num_vertexs/2-myPrimitiveArray->num_bounds;
729 else number = myPrimitiveArray->num_vertexs/2-1;
731 case TelTriangleFansArrayType:
732 if( myPrimitiveArray->num_bounds > 0 )
733 number = myPrimitiveArray->num_vertexs-2*myPrimitiveArray->num_bounds;
734 else number = myPrimitiveArray->num_vertexs-2;
743 void Graphic3d_ArrayOfPrimitives::ComputeVNormals(
744 const Standard_Integer from,
745 const Standard_Integer to) {
746 Standard_Integer next = from+1;
747 Standard_Integer last = to+1;
750 if( myMaxEdges > 0 ) {
751 p1 = Vertice(Edge(next++));
752 p2 = Vertice(Edge(next++));
754 p1 = Vertice(next++);
755 p2 = Vertice(next++);
760 while ( next <= last ) {
761 if( myMaxEdges > 0 ) {
762 p3 = Vertice(Edge(next));
769 if( vn.SquareMagnitude() > 0. ) break;
775 cout << " An item has a NULL computed facet normal" << endl;
781 if( myMaxEdges > 0 ) {
782 for( int i=from+1 ; i<=to+1 ; i++ ) {
783 SetVertexNormal(Edge(i),vn);
786 for( int i=from+1 ; i<=to+1 ; i++ ) {
787 SetVertexNormal(i,vn);
792 Standard_Boolean Graphic3d_ArrayOfPrimitives::IsValid() {
794 if( !myPrimitiveArray ) return Standard_False;
796 Standard_Integer nvertexs = myPrimitiveArray->num_vertexs;
797 Standard_Integer nbounds = myPrimitiveArray->num_bounds;
798 Standard_Integer nedges = myPrimitiveArray->num_edges;
799 Standard_Integer i,j,k,n;
802 Standard_CString name = StringType();
803 cout << " !!! An " << name << " has " << ItemNumber() << " items" << endl;
806 switch( myPrimitiveArray->type ) {
807 case TelPointsArrayType:
810 cout << " *** An " << name << " is unavailable with a too lower number of vertex " << nvertexs << endl;
812 return Standard_False;
815 case TelPolylinesArrayType:
816 if( nedges > 0 && nedges < 2 ) {
818 cout << " *** An " << name << " is unavailable with a too lower number of edges " << nedges << endl;
820 return Standard_False;
824 cout << " *** An " << name << " is unavailable with a too lower number of vertex " << nvertexs << endl;
826 return Standard_False;
829 case TelSegmentsArrayType:
832 cout << " *** An " << name << " is unavailable with a too lower number of vertex " << nvertexs << endl;
834 return Standard_False;
837 case TelPolygonsArrayType:
838 if( nedges > 0 && nedges < 3 ) {
840 cout << " *** An " << name << " is unavailable with a too lower number of edges " << nedges << endl;
842 return Standard_False;
846 cout << " *** An " << name << " is unavailable with a too lower number of vertex " << nvertexs << endl;
848 return Standard_False;
851 case TelTrianglesArrayType:
853 if( nedges < 3 || nedges % 3 != 0 ) {
855 cout << " *** An " << name << " is unavailable with a too lower number of edges " << nedges << endl;
857 if( nedges > 3 ) myPrimitiveArray->num_edges = 3 * (nedges / 3);
858 else return Standard_False;
860 } else if( nvertexs < 3 || nvertexs % 3 != 0 ) {
862 cout << " *** An " << name << " is unavailable with a too lower number of vertex " << nvertexs << endl;
864 if( nvertexs > 3 ) myPrimitiveArray->num_vertexs = 3 * (nvertexs / 3);
865 else return Standard_False;
868 case TelQuadranglesArrayType:
870 if( nedges < 4 || nedges % 4 != 0 ) {
872 cout << " *** An " << name << " is unavailable with a too lower number of edges " << nedges << endl;
874 if( nedges > 4 ) myPrimitiveArray->num_edges = 4 * (nedges / 4);
875 else return Standard_False;
877 } else if( nvertexs < 4 || nvertexs % 4 != 0 ) {
879 cout << " *** An " << name << " is unavailable with a too lower number of vertex " << nvertexs << endl;
881 if( nvertexs > 4 ) myPrimitiveArray->num_vertexs = 4 * (nvertexs / 4);
882 else return Standard_False;
885 case TelTriangleFansArrayType:
886 case TelTriangleStripsArrayType:
889 cout << " *** An " << name << " is unavailable with a too lower number of vertex " << nvertexs << endl;
891 return Standard_False;
894 case TelQuadrangleStripsArrayType:
897 cout << " *** An " << name << " is unavailable with a too lower number of vertex " << nvertexs << endl;
899 return Standard_False;
904 cout << " *** UNKNOWN Array of primitives type found" << endl;
906 return Standard_False;
910 for( i=n=0 ; i<nbounds ; i++ ) {
911 n += myPrimitiveArray->bounds[i];
913 if( nedges > 0 && n != nedges ) {
915 cout << " *** An " << name << " has an incoherent number of edges " << nedges << endl;
917 if( nedges > n ) myPrimitiveArray->num_edges = n;
918 else return Standard_False;
919 } else if( n != nvertexs ) {
921 cout << " *** An " << name << " has an incoherent number of vertexs " << nvertexs << endl;
923 if( nvertexs > n ) myPrimitiveArray->num_vertexs = n;
924 else return Standard_False;
929 for( i=0 ; i<nedges ; i++ ) {
930 if( myPrimitiveArray->edges[i] >= myPrimitiveArray->num_vertexs ) {
932 cout << " *** An " << name << " has a vertex index " << myPrimitiveArray->edges[i] << " greater than the number of defined vertexs " << myPrimitiveArray->num_vertexs << endl;
934 myPrimitiveArray->edges[i] = myPrimitiveArray->num_vertexs-1;
939 Standard_Integer format;
940 Standard_Boolean valid = Standard_True;
941 for( i=0 ; i<nvertexs ; i++ ) {
942 format = myPrimitiveArray->format;
943 if( format != myPrimitiveArray->format ) {
944 valid = Standard_False;
946 cout << " *** An " << name << " has an incoherent kind of vertexs "
947 << i+1 << " of type " << myPrimitiveArray->format << "/" << format << endl;
953 if( valid ) return Standard_True;
957 for( j=n=0 ; j<nbounds ; j++ )
959 k = myPrimitiveArray->bounds[j];
960 for( i=0 ; i<k ; i++ )
962 format = myPrimitiveArray->format;
963 if( format != myPrimitiveArray->format )
965 if( myPrimitiveArray->format & MVNORMAL ) switch( myPrimitiveArray->type )
967 case TelPolygonsArrayType:
968 if( i == 0 ) ComputeVNormals(n+i,n+k-1);
970 case TelTrianglesArrayType:
971 if( !(i % 3) ) ComputeVNormals(n+i,n+i+2);
973 case TelQuadranglesArrayType:
974 if( !(i % 4) ) ComputeVNormals(n+i,n+i+3);
976 case TelTriangleFansArrayType:
977 case TelTriangleStripsArrayType:
978 if( i < k-2 ) ComputeVNormals(n+i,n+i+2);
981 case TelQuadrangleStripsArrayType:
982 if( !(i %2) && (i < k-3) ) ComputeVNormals(n+i,n+i+3);
989 n += myPrimitiveArray->bounds[j];
991 } else if( nedges > 0 ) {
992 for( i=0 ; i<nedges ; i++ ) {
993 k = myPrimitiveArray->edges[i];
994 format = myPrimitiveArray->format;
995 if( format != myPrimitiveArray->format ) {
996 if( myPrimitiveArray->format & MVNORMAL ) switch( myPrimitiveArray->type ) {
997 case TelPolygonsArrayType:
998 if( i == 0 ) ComputeVNormals(i,nedges-1);
1000 case TelTrianglesArrayType:
1002 ComputeVNormals(k,k+2);
1004 case TelQuadranglesArrayType:
1006 ComputeVNormals(k,k+3);
1008 case TelTriangleFansArrayType:
1009 case TelTriangleStripsArrayType:
1010 if( i < nedges-2 ) ComputeVNormals(i,i+2);
1013 case TelQuadrangleStripsArrayType:
1014 if( !(i %2) && (i < nedges-3) ) ComputeVNormals(i,i+3);
1021 } else if( nvertexs > 0 ) {
1022 for( i=0 ; i<nvertexs ; i++ ) {
1023 format = myPrimitiveArray->format;
1024 if( format != myPrimitiveArray->format ) {
1025 if( myPrimitiveArray->format & MVNORMAL ) switch( myPrimitiveArray->type ) {
1026 case TelPolygonsArrayType:
1027 if( i == 0 ) ComputeVNormals(i,nvertexs-1);
1029 case TelTrianglesArrayType:
1030 if( !(i % 3) ) ComputeVNormals(i,i+2);
1032 case TelQuadranglesArrayType:
1033 if( !(i % 4) ) ComputeVNormals(i,i+3);
1035 case TelTriangleFansArrayType:
1036 case TelTriangleStripsArrayType:
1037 if( i < nvertexs-2 ) ComputeVNormals(i,i+2);
1040 case TelQuadrangleStripsArrayType:
1041 if( !(i %2) && (i < nvertexs-3) ) ComputeVNormals(i,i+3);
1050 return Standard_True;