src/OpenGl/OpenGl_GraphicDriver_711.cxx

   1 // File   OpenGl_GraphicDriver_711.cxx
   2 // Created  Mardi 28 janvier 1997
   3 // Author CAL
   4 //
   5 // Modified
   6 //              27/08/97 ; PCT : ajout coordonne texture
   7
   8 //-Copyright  MatraDatavision 1997
   9
  10 //-Version
  11
  12 //-Design Declaration des variables specifiques aux Drivers
  13
  14 //-Warning  Un driver encapsule les Pex et OpenGl drivers
  15
  16 //-References
  17
  18 //-Language C++ 2.0
  19
  20 //-Declarations
  21
  22 // for the class
  23 #include <OpenGl_GraphicDriver.jxx>
  24 #include <Aspect_DriverDefinitionError.hxx>
  25
  26
  27 #include <OSD_Timer.hxx>
  28
  29 #include <OpenGl_tgl_funcs.hxx>
  30
  31 //-Aliases
  32
  33 //-Global data definitions
  34
  35 //-Methods, in order
  36
  37 void OpenGl_GraphicDriver::TriangleMesh (const Graphic3d_CGroup& ACGroup,
  38                                          const Graphic3d_Array1OfVertex& ListVertex,
  39                                          const Standard_Boolean )
  40 {
  41
  42   Graphic3d_CGroup MyCGroup = ACGroup;
  43
  44   Standard_Integer Lower  = ListVertex.Lower ();
  45
  46   CALL_DEF_TRIKE atrike;
  47
  48   atrike.NbPoints   = int (ListVertex.Length ());
  49   atrike.TypePoints = 1;
  50   atrike.UPoints.Points = (CALL_DEF_POINT *) &ListVertex (Lower);
  51
  52   if (MyTraceLevel) {
  53     PrintFunction ("call_togl_triangle");
  54     PrintCGroup (MyCGroup, 1);
  55   }
  56   call_togl_triangle (&MyCGroup, &atrike);
  57
  58 }
  59
  60 void OpenGl_GraphicDriver::TriangleMesh (const Graphic3d_CGroup& ACGroup,
  61                                          const Graphic3d_Array1OfVertexN& ListVertex,
  62                                          const Standard_Boolean )
  63 {
  64
  65   Graphic3d_CGroup MyCGroup = ACGroup;
  66
  67   Standard_Real X, Y, Z;
  68   Standard_Real DX, DY, DZ;
  69
  70   Standard_Integer i, j;
  71   Standard_Integer Lower  = ListVertex.Lower ();
  72   Standard_Integer Upper  = ListVertex.Upper ();
  73
  74   CALL_DEF_TRIKE atrike;
  75   CALL_DEF_POINTN *points;
  76
  77   i = ListVertex.Length ();
  78
  79   // Allocation dynamique
  80   points  = new CALL_DEF_POINTN [i];
  81
  82   atrike.NbPoints   = int (i);
  83   atrike.TypePoints = 2;
  84   atrike.UPoints.PointsN  = points;
  85
  86   // Parcours des sommets
  87   for (j=0, i=Lower; i<=Upper; i++, j++) {
  88     ListVertex (i).Coord (X, Y, Z);
  89     points[j].Point.x = float (X);
  90     points[j].Point.y = float (Y);
  91     points[j].Point.z = float (Z);
  92     ListVertex (i).Normal (DX, DY, DZ);
  93     points[j].Normal.dx = float (DX);
  94     points[j].Normal.dy = float (DY);
  95     points[j].Normal.dz = float (DZ);
  96   }
  97
  98   if (MyTraceLevel) {
  99     PrintFunction ("call_togl_triangle");
 100     PrintCGroup (MyCGroup, 1);
 101   }
 102   call_togl_triangle (&MyCGroup, &atrike);
 103
 104   // Desallocation dynamique
 105   delete [] points;
 106
 107 }
 108
 109
 110 void OpenGl_GraphicDriver::TriangleMesh(const Graphic3d_CGroup& ACGroup,
 111                                         const Graphic3d_Array1OfVertexNT& ListVertex,
 112                                         const Standard_Boolean )
 113 {
 114
 115   Graphic3d_CGroup MyCGroup = ACGroup;
 116
 117   Standard_Real X, Y, Z;
 118   Standard_Real DX, DY, DZ;
 119
 120   Standard_Integer i, j;
 121   Standard_Integer Lower  = ListVertex.Lower ();
 122   Standard_Integer Upper  = ListVertex.Upper ();
 123
 124   CALL_DEF_TRIKE atrike;
 125   CALL_DEF_POINTNT *points;
 126
 127   i = ListVertex.Length ();
 128
 129   // Allocation dynamique
 130   points  = new CALL_DEF_POINTNT [i];
 131
 132   atrike.NbPoints   = int (i);
 133   atrike.TypePoints = 5;
 134   atrike.UPoints.PointsNT = points;
 135
 136   // Parcours des sommets
 137   for (j=0, i=Lower; i<=Upper; i++, j++) {
 138     ListVertex (i).Coord (X, Y, Z);
 139     points[j].Point.x = float (X);
 140     points[j].Point.y = float (Y);
 141     points[j].Point.z = float (Z);
 142     ListVertex (i).Normal (DX, DY, DZ);
 143     points[j].Normal.dx = float (DX);
 144     points[j].Normal.dy = float (DY);
 145     points[j].Normal.dz = float (DZ);
 146     ListVertex (i).TextureCoordinate(DX,DY);
 147     points[j].TextureCoord.tx = float(DX);
 148     points[j].TextureCoord.ty = float(DY);
 149   }
 150
 151   if (MyTraceLevel) {
 152     PrintFunction ("call_togl_triangle");
 153     PrintCGroup (MyCGroup, 1);
 154   }
 155   call_togl_triangle (&MyCGroup, &atrike);
 156
 157   // Desallocation dynamique
 158   delete [] points;
 159
 160 }
 161
 162 void OpenGl_GraphicDriver::TriangleSet (const Graphic3d_CGroup& ACGroup,
 163                                         const Graphic3d_Array1OfVertex& ListVertex,
 164                                         const Aspect_Array1OfEdge& ListEdge,
 165                                         const Standard_Boolean )
 166 {
 167
 168   Graphic3d_CGroup MyCGroup = ACGroup;
 169
 170   OSD_Timer theTimer;
 171   Standard_Real seconds, CPUtime;
 172   Standard_Integer minutes, hours;
 173
 174   Standard_Integer i, j, k;
 175   Standard_Integer Lower, Upper;
 176   Standard_Integer OffSet;
 177
 178   CALL_DEF_LISTPOINTS alpoints;
 179   CALL_DEF_LISTEDGES aledges;
 180   CALL_DEF_EDGE *edges;
 181
 182   // Permettra une generalisation plus facile a une methode du style
 183   // PolygonSet (ListVertex, ListEdge, Bounds).
 184   int *integers;
 185   CALL_DEF_LISTINTEGERS albounds;
 186
 187   theTimer.Reset();theTimer.Start();
 188
 189   i = ListVertex.Length ();
 190   j = ListEdge.Length ();
 191   k = int (j/3);
 192
 193   Lower = ListVertex.Lower ();
 194   Upper = ListVertex.Upper ();
 195   OffSet  = Lower;
 196
 197   // Allocation dynamique
 198   edges = new CALL_DEF_EDGE [j];
 199   integers= new int [k];
 200
 201 #ifdef a
 202   alpoints.NbPoints = int (i);
 203 #else
 204   alpoints.NbPoints = i;
 205 #endif
 206   alpoints.TypePoints = 1;
 207   alpoints.UPoints.Points = (CALL_DEF_POINT *) &ListVertex (Lower);
 208
 209 #ifdef a
 210   aledges.NbEdges   = int (j);
 211 #else
 212   aledges.NbEdges   = j;
 213 #endif
 214   aledges.Edges   = edges;
 215
 216 #ifdef a
 217   albounds.NbIntegers = int (k);
 218 #else
 219   albounds.NbIntegers = k;
 220 #endif
 221   albounds.Integers = integers;
 222
 223   Lower = ListEdge.Lower ();
 224   Upper = ListEdge.Upper ();
 225
 226   // Parcours des aretes
 227   for (j=0, i=Lower; i<=Upper; i++, j++) {
 228 #ifdef a
 229     edges[j].Index1 = int (ListEdge (i).FirstIndex ()-OffSet);
 230     edges[j].Index2 = int (ListEdge (i).LastIndex ()-OffSet);
 231     edges[j].Type = int (ListEdge (i).Type ());
 232 #else
 233     edges[j].Index1 = ListEdge (i).FirstIndex ()-OffSet;
 234     edges[j].Index2 = ListEdge (i).LastIndex ()-OffSet;
 235     edges[j].Type = ListEdge (i).Type ();
 236 #endif
 237   }
 238
 239   // Parcours des limites (ici toutes les limites sont egales a 3.
 240   for (j=0; j<albounds.NbIntegers; j++) integers[j] = 3;
 241
 242   if (MyTraceLevel) {
 243     PrintFunction ("call_togl_polygon_indices");
 244     PrintCGroup (MyCGroup, 1);
 245   }
 246
 247
 248   theTimer.Stop();
 249   theTimer.Show(seconds, minutes, hours, CPUtime);
 250 #ifdef TRACE
 251   cout<<"opengl_driver general stuff in : sec: "<<seconds<< "; min: " << minutes <<endl;
 252 #endif
 253
 254   theTimer.Reset();theTimer.Start();
 255   call_togl_polygon_indices (&MyCGroup, &alpoints, &aledges, &albounds);
 256   theTimer.Stop();
 257   theTimer.Show(seconds, minutes, hours, CPUtime);
 258 #ifdef TRACE
 259   cout<<"call_togl_polygon_indices in : sec: "<<seconds<< "; min: " << minutes <<endl;
 260 #endif
 261   // Desallocation dynamique
 262   delete [] edges;
 263   delete [] integers;
 264
 265 }
 266
 267 void OpenGl_GraphicDriver::TriangleSet (const Graphic3d_CGroup& ACGroup,
 268                                         const Graphic3d_Array1OfVertexN& ListVertex,
 269                                         const Aspect_Array1OfEdge& ListEdge,
 270                                         const Standard_Boolean )
 271 {
 272
 273   Graphic3d_CGroup MyCGroup = ACGroup;
 274
 275   Standard_Real X, Y, Z;
 276   Standard_Real DX, DY, DZ;
 277
 278   Standard_Integer i, j, k;
 279   Standard_Integer Lower, Upper;
 280   Standard_Integer OffSet;
 281
 282   CALL_DEF_LISTPOINTS alpoints;
 283   CALL_DEF_POINTN *points;
 284   CALL_DEF_LISTEDGES aledges;
 285   CALL_DEF_EDGE *edges;
 286
 287   // Permettra une generalisation plus facile a une methode du style
 288   // PolygonSet (ListVertex, ListEdge, Bounds).
 289   int *integers;
 290   CALL_DEF_LISTINTEGERS albounds;
 291
 292   i = ListVertex.Length ();
 293   j = ListEdge.Length ();
 294   k = int (j/3);
 295
 296   Lower = ListVertex.Lower ();
 297   Upper = ListVertex.Upper ();
 298   OffSet  = Lower;
 299
 300   // Allocation dynamique
 301   points  = new CALL_DEF_POINTN [i];
 302   edges = new CALL_DEF_EDGE [j];
 303   integers= new int [k];
 304
 305   alpoints.NbPoints = int (i);
 306   alpoints.TypePoints = 2;
 307   alpoints.UPoints.PointsN= points;
 308
 309   aledges.NbEdges   = int (j);
 310   aledges.Edges   = edges;
 311
 312   albounds.NbIntegers = int (k);
 313   albounds.Integers = integers;
 314
 315   // Parcours des sommets
 316   for (j=0, i=Lower; i<=Upper; i++, j++) {
 317     ListVertex (i).Coord (X, Y, Z);
 318     points[j].Point.x = float (X);
 319     points[j].Point.y = float (Y);
 320     points[j].Point.z = float (Z);
 321     ListVertex (i).Normal (DX, DY, DZ);
 322     points[j].Normal.dx = float (DX);
 323     points[j].Normal.dy = float (DY);
 324     points[j].Normal.dz = float (DZ);
 325   }
 326
 327   Lower = ListEdge.Lower ();
 328   Upper = ListEdge.Upper ();
 329
 330   // Parcours des aretes
 331   for (j=0, i=Lower; i<=Upper; i++, j++) {
 332     edges[j].Index1 = int (ListEdge (i).FirstIndex ()-OffSet);
 333     edges[j].Index2 = int (ListEdge (i).LastIndex ()-OffSet);
 334     edges[j].Type = int (ListEdge (i).Type ());
 335   }
 336
 337   // Parcours des limites (ici toutes les limites sont egales a 3.
 338   for (j=0; j<albounds.NbIntegers; j++) integers[j] = 3;
 339
 340   if (MyTraceLevel) {
 341     PrintFunction ("call_togl_polygon_indices");
 342     PrintCGroup (MyCGroup, 1);
 343   }
 344   call_togl_polygon_indices (&MyCGroup, &alpoints, &aledges, &albounds);
 345
 346   // Desallocation dynamique
 347   delete [] points;
 348   delete [] edges;
 349   delete [] integers;
 350
 351 }
 352
 353 void OpenGl_GraphicDriver::TriangleSet (const Graphic3d_CGroup& ACGroup,
 354                                         const Graphic3d_Array1OfVertexC& ListVertex,
 355                                         const Aspect_Array1OfEdge& ListEdge,
 356                                         const Standard_Boolean )
 357 {
 358
 359   Graphic3d_CGroup MyCGroup = ACGroup;
 360
 361   Standard_Real X, Y, Z;
 362   Standard_Real R, G, B;
 363
 364   Standard_Integer i, j, k;
 365   Standard_Integer Lower, Upper;
 366   Standard_Integer OffSet;
 367
 368   CALL_DEF_LISTPOINTS alpoints;
 369   CALL_DEF_POINTC *points;
 370   CALL_DEF_LISTEDGES aledges;
 371   CALL_DEF_EDGE *edges;
 372
 373   // Permettra une generalisation plus facile a une methode du style
 374   // PolygonSet (ListVertex, ListEdge, Bounds).
 375   int *integers;
 376   CALL_DEF_LISTINTEGERS albounds;
 377
 378   i = ListVertex.Length ();
 379   j = ListEdge.Length ();
 380   k = int (j/3);
 381
 382   Lower = ListVertex.Lower ();
 383   Upper = ListVertex.Upper ();
 384   OffSet  = Lower;
 385
 386   // Allocation dynamique
 387   points  = new CALL_DEF_POINTC [i];
 388   edges = new CALL_DEF_EDGE [j];
 389   integers= new int [k];
 390
 391   alpoints.NbPoints = int (i);
 392   alpoints.TypePoints = 3;
 393   alpoints.UPoints.PointsC= points;
 394
 395   aledges.NbEdges   = int (j);
 396   aledges.Edges   = edges;
 397
 398   albounds.NbIntegers = int (k);
 399   albounds.Integers = integers;
 400
 401   // Parcours des sommets
 402   for (j=0, i=Lower; i<=Upper; i++, j++) {
 403     ListVertex (i).Coord (X, Y, Z);
 404     points[j].Point.x = float (X);
 405     points[j].Point.y = float (Y);
 406     points[j].Point.z = float (Z);
 407     (ListVertex (i).Color ()).Values (R, G, B, Quantity_TOC_RGB);
 408     points[j].Color.r = float (R);
 409     points[j].Color.g = float (G);
 410     points[j].Color.b = float (B);
 411   }
 412
 413   Lower = ListEdge.Lower ();
 414   Upper = ListEdge.Upper ();
 415
 416   // Parcours des aretes
 417   for (j=0, i=Lower; i<=Upper; i++, j++) {
 418     edges[j].Index1 = int (ListEdge (i).FirstIndex ()-OffSet);
 419     edges[j].Index2 = int (ListEdge (i).LastIndex ()-OffSet);
 420     edges[j].Type = int (ListEdge (i).Type ());
 421   }
 422
 423   // Parcours des limites (ici toutes les limites sont egales a 3.
 424   for (j=0; j<albounds.NbIntegers; j++) integers[j] = 3;
 425
 426   if (MyTraceLevel) {
 427     PrintFunction ("call_togl_polygon_indices");
 428     PrintCGroup (MyCGroup, 1);
 429   }
 430   call_togl_polygon_indices (&MyCGroup, &alpoints, &aledges, &albounds);
 431
 432   // Desallocation dynamique
 433   delete [] points;
 434   delete [] edges;
 435   delete [] integers;
 436
 437 }
 438
 439 void OpenGl_GraphicDriver::TriangleSet (const Graphic3d_CGroup& ACGroup,
 440                                         const Graphic3d_Array1OfVertexNC& ListVertex,
 441                                         const Aspect_Array1OfEdge& ListEdge,
 442                                         const Standard_Boolean )
 443 {
 444   Graphic3d_CGroup MyCGroup = ACGroup;
 445
 446   Standard_Real X, Y, Z;
 447   Standard_Real R, G, B;
 448   Standard_Real DX, DY, DZ;
 449
 450   Standard_Integer i, j, k;
 451   Standard_Integer Lower, Upper;
 452   Standard_Integer OffSet;
 453
 454   CALL_DEF_LISTPOINTS alpoints;
 455   CALL_DEF_POINTNC *points;
 456   CALL_DEF_LISTEDGES aledges;
 457   CALL_DEF_EDGE *edges;
 458
 459   // Permettra une generalisation plus facile a une methode du style
 460   // PolygonSet (ListVertex, ListEdge, Bounds).
 461   int *integers;
 462   CALL_DEF_LISTINTEGERS albounds;
 463
 464   i = ListVertex.Length ();
 465   j = ListEdge.Length ();
 466   k = int (j/3);
 467
 468   Lower = ListVertex.Lower ();
 469   Upper = ListVertex.Upper ();
 470   OffSet  = Lower;
 471
 472   // Allocation dynamique
 473   points  = new CALL_DEF_POINTNC [i];
 474   edges = new CALL_DEF_EDGE [j];
 475   integers= new int [k];
 476
 477   alpoints.NbPoints = int (i);
 478   alpoints.TypePoints = 4;
 479   alpoints.UPoints.PointsNC= points;
 480
 481   aledges.NbEdges   = int (j);
 482   aledges.Edges   = edges;
 483
 484   albounds.NbIntegers = int (k);
 485   albounds.Integers = integers;
 486
 487   // Parcours des sommets
 488   for (j=0, i=Lower; i<=Upper; i++, j++) {
 489     ListVertex (i).Coord (X, Y, Z);
 490     points[j].Point.x = float (X);
 491     points[j].Point.y = float (Y);
 492     points[j].Point.z = float (Z);
 493     ListVertex (i).Normal (DX, DY, DZ);
 494     points[j].Normal.dx = float (DX);
 495     points[j].Normal.dy = float (DY);
 496     points[j].Normal.dz = float (DZ);
 497     (ListVertex (i).Color ()).Values (R, G, B, Quantity_TOC_RGB);
 498     points[j].Color.r = float (R);
 499     points[j].Color.g = float (G);
 500     points[j].Color.b = float (B);
 501   }
 502
 503   Lower = ListEdge.Lower ();
 504   Upper = ListEdge.Upper ();
 505
 506   // Parcours des aretes
 507   for (j=0, i=Lower; i<=Upper; i++, j++) {
 508     edges[j].Index1 = int (ListEdge (i).FirstIndex ()-OffSet);
 509     edges[j].Index2 = int (ListEdge (i).LastIndex ()-OffSet);
 510     edges[j].Type = int (ListEdge (i).Type ());
 511   }
 512
 513   // Parcours des limites (ici toutes les limites sont egales a 3.
 514   for (j=0; j<albounds.NbIntegers; j++) integers[j] = 3;
 515
 516   if (MyTraceLevel) {
 517     PrintFunction ("call_togl_polygon_indices");
 518     PrintCGroup (MyCGroup, 1);
 519   }
 520   call_togl_polygon_indices (&MyCGroup, &alpoints, &aledges, &albounds);
 521
 522   // Desallocation dynamique
 523   delete [] points;
 524   delete [] edges;
 525   delete [] integers;
 526
 527 }
 528
 529
 530
 531 void OpenGl_GraphicDriver::TriangleSet(const Graphic3d_CGroup& ACGroup,
 532                                        const Graphic3d_Array1OfVertexNT& ListVertex,
 533                                        const Aspect_Array1OfEdge& ListEdge,
 534                                        const Standard_Boolean )
 535 {
 536
 537   Graphic3d_CGroup MyCGroup = ACGroup;
 538   Standard_Real X, Y, Z;
 539   Standard_Real DX, DY, DZ;
 540
 541   Standard_Integer i, j, k;
 542   Standard_Integer Lower, Upper;
 543   Standard_Integer OffSet;
 544
 545   CALL_DEF_LISTPOINTS alpoints;
 546   CALL_DEF_POINTNT *points;
 547   CALL_DEF_LISTEDGES aledges;
 548   CALL_DEF_EDGE *edges;
 549
 550   // Permettra une generalisation plus facile a une methode du style
 551   // PolygonSet (ListVertex, ListEdge, Bounds).
 552   int *integers;
 553   CALL_DEF_LISTINTEGERS albounds;
 554
 555   i = ListVertex.Length ();
 556   j = ListEdge.Length ();
 557   k = int (j/3);
 558
 559   Lower = ListVertex.Lower ();
 560   Upper = ListVertex.Upper ();
 561   OffSet  = Lower;
 562
 563   // Allocation dynamique
 564   points  = new CALL_DEF_POINTNT [i];
 565   edges = new CALL_DEF_EDGE [j];
 566   integers= new int [k];
 567
 568   alpoints.NbPoints = int (i);
 569   alpoints.TypePoints = 5;
 570   alpoints.UPoints.PointsNT= points;
 571
 572   aledges.NbEdges   = int (j);
 573   aledges.Edges   = edges;
 574
 575   albounds.NbIntegers = int (k);
 576   albounds.Integers = integers;
 577
 578   // Parcours des sommets
 579   for (j=0, i=Lower; i<=Upper; i++, j++) {
 580     ListVertex (i).Coord (X, Y, Z);
 581     points[j].Point.x = float (X);
 582     points[j].Point.y = float (Y);
 583     points[j].Point.z = float (Z);
 584     ListVertex (i).Normal (DX, DY, DZ);
 585     points[j].Normal.dx = float (DX);
 586     points[j].Normal.dy = float (DY);
 587     points[j].Normal.dz = float (DZ);
 588     ListVertex (i).TextureCoordinate(DX,DY);
 589     points[j].TextureCoord.tx = float(DX);
 590     points[j].TextureCoord.ty = float(DY);
 591   }
 592
 593   Lower = ListEdge.Lower ();
 594   Upper = ListEdge.Upper ();
 595
 596   // Parcours des aretes
 597   for (j=0, i=Lower; i<=Upper; i++, j++) {
 598     edges[j].Index1 = int (ListEdge (i).FirstIndex ()-OffSet);
 599     edges[j].Index2 = int (ListEdge (i).LastIndex ()-OffSet);
 600     edges[j].Type = int (ListEdge (i).Type ());
 601   }
 602
 603   // Parcours des limites (ici toutes les limites sont egales a 3.
 604   for (j=0; j<albounds.NbIntegers; j++) integers[j] = 3;
 605
 606   if (MyTraceLevel) {
 607     PrintFunction ("call_togl_polygon_indices");
 608     PrintCGroup (MyCGroup, 1);
 609   }
 610   call_togl_polygon_indices (&MyCGroup, &alpoints, &aledges, &albounds);
 611
 612   // Desallocation dynamique
 613   delete [] points;
 614   delete [] edges;
 615   delete [] integers;
 616
 617 }