src/OpenGl/OpenGl_togl_begin_immediat_mode.cxx

   1 /***********************************************************************
   2
   3 FONCTION :
   4 ----------
   5 file OpenGl_togl_begin_immediat_mode.c :
   6
   7
   8 REMARQUES:
   9 ----------
  10
  11
  12 HISTORIQUE DES MODIFICATIONS   :
  13 --------------------------------
  14 xx-xx-xx : CAL ; Creation.
  15 08-03-96 : FMN ; - Ajout include manquant
  16 01-04-96 : CAL ; Integration MINSK portage WNT
  17 15-04-96 : CAL ; Integration travail PIXMAP de Jim ROTH
  18 07-05-96 : CAL ; Gestion du minmax calcule en C++
  19 voir call_togl_set_minmax
  20 Debug temporaire pour ROB, TelRobSetRGB ()
  21 12-06-96 : CAL ; Recuperation des attributs lors d'un draw_structure
  22 22-07-96 :  GG ; Faire fonctionner correctement le highlight
  23 des polygones en mode immediat
  24 11-09-96 : FMN ; Ajout appel a TxglWinset dans call_togl_begin_immediat_mode
  25 04-11-96 : CAL : Retrait du mode simule, ajout du higlight
  26 dans togl_draw_structure
  27 06-11-96 : CAL : Retrait du test sur doublebuffer PRO5949
  28 16-12-96 : CAL : Ajout d'un glFinish () dans end_immediat_mode
  29 21-01-97 : CAL : Gestion du flag <partial> differente pour
  30 eviter les comparaisons avec shortrealfirst ou last
  31 22-04-97 : FMN ; Correction faute i a la place de j dans util_transform_pt
  32 22-04-97 : FMN ; Correction appel util_transform_pt dans togl_set_minmax
  33 24-04-97 : FMN ; (PRO4063) Ajout displaylist pour le mode transient
  34 25-07-97 : CAL ; Portage WNT (Bool, False, True)
  35 30-07-97 : FMN ; Meilleure gestion de la desactivation des lights
  36 10-09-97 : FMN ; Meilleure gestion de la desactivation des lights
  37 07-10-97 : FMN ; Simplification WNT
  38 Ajout glFlush dans call_togl_clear_immediat_mode()
  39 26-11-97 : FMN ; Ajout mode Ajout et xor
  40 Meilleure gestion display list pour le RetainMode
  41 19-12-97 : FMN ; Oublie return dans le call_togl_begin_ajout_mode()
  42 22-12-97 : FMN ; Suppression DEBUG_TEMPO_FOR_ROB
  43 Correction PRO10217
  44 Ajout affichage cadre TelCopyBuffer
  45 Ajout LightOff sur le redraw.
  46 02-02-98 : CAL ; Correction du bug sur les transformations de structure
  47 tracees en mode transient. (PRO10217) (PRO12283)
  48 05-02-98 : CAL ; Perfs : mise en place d'un flag identity pour savoir
  49 si la matrice de transformation est l'identite.
  50 08-04-98 : FMN ; Mailleur traitement du reaffichage d'une vue. Remplacement
  51 de TsmDisplayStructure() par call_func_redraw_all_structs().
  52 08-07-98 : FMN ; PRO14399: Desactivation animationFlag quand on debute
  53 le mode immediat (Transient et Ajout).
  54 30-09-98 : CAL ; Optimisation pour eviter de charger inutilement
  55 les matrices de la vue.
  56 27-11-98 : CAL ; S4062. Ajout des layers.
  57 02.14.100 : JR : Warnings on WNT truncations from double to float
  58
  59 IMP190100 : GG
  60 //                      -> Preserve current attributes because
  61 //                      attributes can be changed between
  62 //                      begin_immediate_mode() end end_immediate_mode()
  63 //                      -> Optimize transformations computation.
  64 //          -> Optimize REDRAW in immediat mode.
  65 //  19/09/00  -> Avoid to raise in set_linetype() & set_linewith()
  66 //        due to a bad call to TsmPutAttri() function.
  67
  68 BUC60726  GG_040900 Clear the last temporary detected in any case
  69
  70 BUC60900  GG_180501 Unhilight entity more earlier
  71 when clear() is call instead at the next begin().
  72
  73 ************************************************************************/
  74
  75
  76 #define BUC60863  /*GG_100401 After any view update, made identical
  77 //      the front and back buffer to avoid ghost drawing.
  78 //      Minimize flicking.
  79 */
  80
  81 #define IMP150501       /*GG_150501 CADPAK_V2 Enable/Disable Zbuffer
  82 NOTE that the previous and unused "double-buffer"
  83 arg is changed to "zbuffer" and enable/disable
  84 to use the OpenGl zbuffer capabilities during immediat
  85 drawing
  86 */
  87
  88 #define IMP260601 /*GG Enable correct backing store between 2 different views.
  89 */
  90
  91 #define IMP051001 /*GG Activates the polygon offset for polygon
  92 //      selection fill mode.
  93 */
  94
  95 /*----------------------------------------------------------------------*/
  96
  97 #define RIC120302       /* GG Enable to use the application display
  98 //                      callback at end of traversal
  99 */
 100
 101 /*
 102 * Includes
 103 */
 104
 105 #include <OpenGl_tgl_all.hxx>
 106 #ifdef IMP051001
 107 #include <OpenGl_Extension.hxx>
 108 #endif
 109 #include <math.h>
 110 #include <GL/gl.h>
 111 #include <stdio.h>
 112
 113 #include <InterfaceGraphic_Labels.hxx>
 114 #include <InterfaceGraphic_Graphic3d.hxx>
 115 #include <InterfaceGraphic_Visual3d.hxx>
 116
 117 #include <OpenGl_tsm_ws.hxx>
 118 #include <OpenGl_txgl.hxx>
 119 #include <OpenGl_tgl_tox.hxx>
 120 #include <OpenGl_tgl_funcs.hxx>
 121 #include <OpenGl_telem_filters.hxx>
 122 #include <OpenGl_telem.hxx>
 123 #include <OpenGl_telem_util.hxx>
 124 #include <OpenGl_telem_view.hxx>
 125 #include <OpenGl_LightBox.hxx>
 126 #include <OpenGl_animation.hxx>
 127 #include <OpenGl_telem_attri.hxx>
 128 #include <OpenGl_tgl.hxx>
 129 #include <OpenGl_tgl_subrvis.hxx>
 130
 131 int call_util_osd_getenv( char * , char * , int ) ;
 132
 133 /*----------------------------------------------------------------------*/
 134 /*
 135 * Constantes
 136 */
 137
 138 #define xCOPY
 139 #define xTRACE 0
 140
 141 #if TRACE > 0
 142 #include <OpenGl_traces.h>
 143 #endif
 144
 145
 146 /*----------------------------------------------------------------------*/
 147 /*
 148 * Variables externes
 149 */
 150
 151 /*----------------------------------------------------------------------*/
 152 /*
 153 * Prototypes fonctions
 154 */
 155
 156 /*----------------------------------------------------------------------*/
 157 /*
 158 * Prototypes Private functions
 159 */
 160
 161 static void call_util_transform_pt (float *x, float *y, float *z);
 162 static int call_util_is_identity ();
 163 static void call_util_transpose_mat (float tmat[16], float mat[4][4]);
 164
 165 /*----------------------------------------------------------------------*/
 166 /*
 167 * Variables statiques
 168 */
 169
 170 static int openglNumberOfPoints = 0;
 171 static GLint openglViewId = 0;
 172 static GLint openglWsId = 0;
 173
 174 static int identity = 1;
 175
 176 static int partial = -1;  /* -1 init, 0 complete, 1 partielle */
 177
 178 static float xm, ym, zm, XM, YM, ZM;
 179
 180 static float openglMat[4][4] = {
 181   {1., 0., 0., 0.},
 182   {0., 1., 0., 0.},
 183   {0., 0., 1., 0.},
 184   {0., 0., 0., 1.},
 185 };
 186
 187 static GLboolean transientOpen = GL_FALSE;
 188
 189 /*----------------------------------------------------------------------*/
 190 /*  Mode Ajout              */
 191 /*----------------------------------------------------------------------*/
 192
 193 int EXPORT call_togl_begin_ajout_mode (
 194                                        CALL_DEF_VIEW *aview
 195                                        )
 196 {
 197   CMN_KEY_DATA data;
 198
 199   TsmGetWSAttri (aview->WsId, WSWindow, &data);
 200 #ifdef IMP260601
 201   if (TxglWinset (call_thedisplay, (WINDOW) data.ldata) != TSuccess) return (0);
 202 #else
 203   if (TxglWinset (call_thedisplay, (WINDOW) data.ldata) == TSuccess)
 204 #endif
 205
 206     if (aview->ViewId == -1) return (0);
 207
 208   openglWsId = aview->WsId;
 209   openglViewId = aview->ViewId;
 210
 211   /* mise en place des matrices de projection et de mapping */
 212   /* TelSetViewIndex (aview->WsId, aview->ViewId); */
 213
 214 #ifdef TRACE
 215   printf ("call_togl_begin_ajout_mode %d %d\n", openglViewId, openglWsId);
 216 #endif
 217
 218   TelMakeFrontAndBackBufCurrent (aview->WsId);
 219
 220   TsmPushAttri();
 221
 222   return (1);
 223 }
 224
 225 /*----------------------------------------------------------------------*/
 226 void EXPORT call_togl_end_ajout_mode ()
 227 {
 228
 229 #ifdef TRACE
 230   printf ("call_togl_end_ajout_mode %d %d\n", openglViewId, openglWsId);
 231 #endif
 232
 233   if (openglViewId != 0) {
 234     TelMakeBackBufCurrent (openglWsId);
 235   }
 236
 237   openglViewId = 0;
 238   openglWsId = 0;
 239
 240   identity = 1;
 241
 242   /* FMN necessaire pour l'affichage sur WNT */
 243   glFlush();
 244
 245   TsmPopAttri();
 246
 247 }
 248
 249
 250 /*----------------------------------------------------------------------*/
 251 /*  Mode Transient              */
 252 /*----------------------------------------------------------------------*/
 253
 254 void EXPORT call_togl_clear_immediat_mode (
 255   CALL_DEF_VIEW *aview, Tint aFlush
 256   )
 257 {
 258   CMN_KEY_DATA   data;
 259   GLuint listIndex = 0;
 260   GLuint retainmode = 0;
 261
 262   if( transientOpen ) {
 263     call_togl_end_immediat_mode(0);
 264   }
 265
 266 #ifdef IMP260601
 267   TsmGetWSAttri (aview->WsId, WSWindow, &data);
 268   if (TxglWinset (call_thedisplay, (WINDOW) data.ldata) != TSuccess) return;
 269 #endif
 270   TsmGetWSAttri( aview->WsId, WSRetainMode, &data );
 271   retainmode = data.ldata;
 272
 273 #ifdef TRACE
 274   printf("call_togl_clear_immediat_mode. xm %f, ym %f, zm %f, XM %f, YM %f, ZM %f, partial %d retainmode %d\n",xm, ym, zm, XM, YM, ZM, partial, retainmode);
 275 #endif
 276
 277   if (  TelBackBufferRestored () == TOff ) {
 278     call_togl_erase_animation_mode();
 279     call_func_redraw_all_structs_begin (aview->WsId);
 280     if( aview->ptrUnderLayer)
 281       call_togl_redraw_layer2d (aview, (CALL_DEF_LAYER *)aview->ptrUnderLayer);
 282     call_func_redraw_all_structs_proc (aview->WsId);
 283     if( aview->ptrOverLayer)
 284       call_togl_redraw_layer2d (aview, (CALL_DEF_LAYER *)aview->ptrOverLayer);
 285 #ifdef RIC120302
 286     call_subr_displayCB(aview,OCC_REDRAW_WINDOW);
 287 #endif
 288     call_func_redraw_all_structs_end (aview->WsId, aFlush);
 289     /*
 290     After a redraw,
 291     Made the back identical to the front buffer
 292     */
 293     if( retainmode && (partial >= 0) )
 294       TelCopyBuffers (aview->WsId, GL_FRONT, GL_BACK,
 295       xm, ym, zm, XM, YM, ZM, partial);
 296 #ifdef TRACE
 297     printf(" $$$ REDRAW\n");
 298 #endif
 299     TelSetBackBufferRestored (TOn);
 300   } else if( partial >= 0 ) {
 301     /*
 302     Restore pixels from the back buffer.
 303     */
 304     TelCopyBuffers (aview->WsId, GL_BACK, GL_FRONT,
 305       xm, ym, zm, XM, YM, ZM, partial);
 306   }
 307
 308   TsmGetWSAttri (aview->WsId, WSTransient, &data);
 309   listIndex = (GLuint) data.ldata;
 310   if( listIndex != 0 ) {  /* Clear current list contents */
 311     glNewList( listIndex, GL_COMPILE_AND_EXECUTE);
 312     glEndList();
 313   }
 314   partial = -1;
 315   XM = YM = ZM = (float ) shortrealfirst ();
 316   xm = ym = zm = (float ) shortreallast ();
 317 }
 318
 319 /*----------------------------------------------------------------------*/
 320
 321 void call_togl_redraw_immediat_mode(
 322                                     CALL_DEF_VIEW * aview
 323                                     )
 324 {
 325   CMN_KEY_DATA   data;
 326   GLuint listIndex = 0;
 327   int retainmode = 0;
 328 #ifndef IMP150501
 329   GLboolean flag_zbuffer = GL_FALSE;
 330 #endif
 331
 332   TsmGetWSAttri( aview->WsId, WSRetainMode, &data );
 333   retainmode = data.ldata;
 334
 335   TsmGetWSAttri (aview->WsId, WSTransient, &data);
 336   listIndex = (GLuint) data.ldata;
 337
 338   if (retainmode != 0) {
 339     if (listIndex != 0) {
 340       TelMakeFrontBufCurrent (aview->WsId);
 341
 342       LightOff();
 343       /* mise en place des matrices de projection et de mapping */
 344       /* TelSetViewIndex (aview->WsId, aview->ViewId);  */
 345
 346 #ifdef TRACE
 347       printf("call_togl_redraw_immediat_mode::call displaylist(%d) \n",
 348         listIndex);
 349 #endif
 350 #ifdef IMP150501
 351       glCallList(listIndex);
 352 #else
 353       flag_zbuffer = glIsEnabled(GL_DEPTH_TEST);
 354       if (flag_zbuffer) glDisable(GL_DEPTH_TEST);
 355       glCallList(listIndex);
 356       if (flag_zbuffer) glEnable(GL_DEPTH_TEST);
 357 #endif
 358       /* FMN necessaire pour l'affichage sur WNT */
 359       glFlush();
 360
 361       TelMakeBackBufCurrent (aview->WsId);
 362     }
 363   }
 364 }
 365
 366
 367 /*----------------------------------------------------------------------*/
 368
 369 int EXPORT
 370 call_togl_begin_immediat_mode
 371 (
 372  CALL_DEF_VIEW * aview,
 373  CALL_DEF_LAYER * anunderlayer,
 374  CALL_DEF_LAYER * anoverlayer,
 375 #ifdef IMP150501
 376  int zbuffer,
 377 #else
 378  int doublebuffer,
 379 #endif
 380  int retainmode
 381  )
 382 {
 383   CMN_KEY_DATA data;
 384   GLuint listIndex = 0;
 385
 386   if (aview->ViewId == -1) return (0);
 387
 388   TsmGetWSAttri (aview->WsId, WSWindow, &data);
 389 #ifdef IMP260601
 390   if (TxglWinset (call_thedisplay, (WINDOW) data.ldata) != TSuccess) return (0);
 391 #else
 392   if (TxglWinset (call_thedisplay, (WINDOW) data.ldata) == TSuccess)
 393 #endif
 394
 395     openglWsId = aview->WsId;
 396   openglViewId = aview->ViewId;
 397
 398   data.ldata = retainmode;
 399   TsmSetWSAttri( aview->WsId, WSRetainMode, &data );
 400
 401 #ifdef TRACE
 402   printf ("call_togl_begin_immediat_mode %d %d RetainMode %d zbuffer %d partial %d\n", openglViewId, openglWsId, retainmode, zbuffer, partial);
 403 #endif
 404
 405   call_togl_clear_immediat_mode(aview,1);
 406
 407   TelMakeFrontBufCurrent (aview->WsId);
 408
 409   TsmPushAttri();
 410
 411 #ifdef COPY
 412   if (partial == 1) {
 413     glColor3f (1., 0., 0.);
 414     glBegin(GL_LINE_LOOP);
 415     glVertex3f (xm, ym, zm);
 416     glVertex3f (XM, ym, zm);
 417     glVertex3f (XM, YM, zm);
 418     glVertex3f (xm, YM, zm);
 419     glEnd();
 420   }
 421 #endif
 422
 423   /*
 424   * RetainMode
 425   */
 426   if( retainmode ) {
 427     TsmGetWSAttri (aview->WsId, WSTransient, &data);
 428     listIndex = (GLuint) data.ldata;
 429
 430     if (listIndex == 0) {
 431       listIndex = glGenLists(1);
 432 #ifdef TRACE
 433       printf("call_togl_begin_immediat_mode::init displaylist() %d \n", listIndex);
 434 #endif
 435       data.ldata = listIndex;
 436       TsmSetWSAttri( aview->WsId, WSTransient, &data );
 437     }
 438     if (listIndex == 0) return(0);
 439 #ifdef TRACE
 440     printf("call_togl_begin_immediat_mode::glNewList() %d \n", listIndex);
 441 #endif
 442     glNewList(listIndex, GL_COMPILE_AND_EXECUTE);
 443     transientOpen = GL_TRUE;
 444   }
 445
 446 #ifdef IMP150501
 447   if( zbuffer ) {
 448     glEnable(GL_DEPTH_TEST);
 449   } else glDisable(GL_DEPTH_TEST);
 450 #endif
 451
 452   return (1);
 453 }
 454
 455
 456 /*----------------------------------------------------------------------*/
 457 /*
 458 call_togl_end_immediat_mode (synchronize)
 459 GLboolean synchronize
 460
 461 End of immediate graphic primitives in the view.
 462 */
 463
 464 void EXPORT
 465 call_togl_end_immediat_mode
 466 (
 467  int synchronize
 468  )
 469 {
 470
 471 #ifdef TRACE
 472   printf ("call_togl_end_immediat_mode %d %d %d\n",
 473     synchronize, openglViewId, openglWsId);
 474 #endif
 475
 476 #ifndef BUC60863  /* Don't modify the current minmax !!*/
 477   /* Mise ajout MinMax */
 478   if ((xm > shortreallast ()) ||
 479     (ym > shortreallast ()) ||
 480     (zm > shortreallast ()) ||
 481     (XM > shortreallast ()) ||
 482     (YM > shortreallast ()) ||
 483     (ZM > shortreallast ()) ||
 484     (xm < shortrealfirst ()) ||
 485     (ym < shortrealfirst ()) ||
 486     (zm < shortrealfirst ()) ||
 487     (XM < shortrealfirst ()) ||
 488     (YM < shortrealfirst ()) ||
 489     (ZM < shortrealfirst ())) {
 490       XM = YM = ZM = (float ) shortreallast ();
 491       xm = ym = zm = (float ) shortrealfirst ();
 492       partial = 0;
 493     }
 494   else {
 495     if (partial != 0) partial = 1;
 496   }
 497 #endif  /*BUC60863*/
 498
 499   if (openglViewId != 0) {
 500 #ifdef COPY
 501     if (partial == 1) {
 502       glColor3f (0., 1., 0.);
 503       glBegin(GL_LINE_LOOP);
 504       glVertex3f (xm, ym, zm);
 505       glVertex3f (XM, ym, zm);
 506       glVertex3f (XM, YM, zm);
 507       glVertex3f (xm, YM, zm);
 508       glEnd();
 509     }
 510 #endif
 511
 512     if (transientOpen) {
 513       glEndList();
 514 #ifdef TRACE
 515       printf("--->glEndList() \n");
 516 #endif
 517       transientOpen = GL_FALSE;
 518     }
 519
 520     TelMakeBackBufCurrent (openglWsId);
 521   }
 522
 523   /*
 524   * Ajout CAL : pour voir quelque chose
 525   * avant le prochain begin_immediat_mode
 526   */
 527   glFinish ();
 528
 529   openglViewId = 0;
 530   openglWsId = 0;
 531
 532   identity = 1;
 533
 534   TsmPopAttri();
 535
 536 }
 537
 538 /*----------------------------------------------------------------------*/
 539 /*
 540 call_togl_transform (amatrix, mode)
 541 float amatrix[4][4]
 542 GLboolean mode
 543
 544 Set the local transformation for All primitives
 545 REPLACE the existante if mode is True or POSTCONCATENATE if GL_FALSE
 546 */
 547 void EXPORT
 548 call_togl_transform ( float amatrix[4][4], int mode )
 549 {
 550   int i, j;
 551   if (mode || identity) {
 552     for (i=0; i<4; i++)
 553       for (j=0; j<4; j++)
 554         openglMat[i][j] = amatrix[i][j];
 555   } else
 556     TelMultiplymat3 (openglMat, openglMat, amatrix);
 557
 558   identity = call_util_is_identity ();
 559 }
 560
 561
 562 /*
 563 call_togl_begin_polyline ()
 564
 565 Sets the graphic library ready to receive a polyline.
 566 */
 567
 568 void EXPORT
 569 call_togl_begin_polyline ()
 570 {
 571   openglNumberOfPoints  = 0;
 572   LightOff();
 573   glBegin (GL_LINE_STRIP);
 574 }
 575
 576
 577 /*----------------------------------------------------------------------*/
 578 /*
 579 call_togl_end_polyline ()
 580
 581 End of the polyline.
 582 */
 583
 584 void EXPORT
 585 call_togl_end_polyline ()
 586 {
 587
 588 #ifdef TRACE
 589   printf ("call_togl_end_polyline %d %d\n", openglViewId, openglWsId);
 590 #endif
 591
 592   if (openglViewId != 0) glEnd ();
 593 }
 594
 595
 596 /*----------------------------------------------------------------------*/
 597 /*
 598 call_togl_draw (x, y, z)
 599 float x;
 600 float y;
 601 float z;
 602
 603 Defines a new point in the current primitive.
 604 */
 605
 606 void EXPORT
 607 call_togl_draw
 608 (
 609  float x,
 610  float y,
 611  float z
 612  )
 613 {
 614
 615 #ifdef TRACE
 616   printf ("call_togl_draw %d %d\n", openglViewId, openglWsId);
 617 #endif
 618
 619   if (openglViewId != 0) {
 620     openglNumberOfPoints ++;
 621     call_util_transform_pt (&x, &y, &z);
 622     if (x > XM) XM = x;
 623     if (y > YM) YM = y;
 624     if (z > ZM) ZM = z;
 625     if (x < xm) xm = x;
 626     if (y < ym) ym = y;
 627     if (z < zm) zm = z;
 628     glVertex3f (x, y, z);
 629     partial = 1;
 630   }
 631 }
 632
 633
 634 /*----------------------------------------------------------------------*/
 635 /*
 636 call_togl_move (x, y, z)
 637 float x;
 638 float y;
 639 float z;
 640
 641 Defines a new point in the current primitive.
 642 */
 643
 644 void EXPORT
 645 call_togl_move
 646 (
 647  float x,
 648  float y,
 649  float z
 650  )
 651 {
 652
 653 #ifdef TRACE
 654   printf ("call_togl_move %d %d\n", openglViewId, openglWsId);
 655 #endif
 656
 657   if (openglViewId != 0) {
 658     if (openglNumberOfPoints != 0) {
 659       call_togl_end_polyline ();
 660       call_togl_begin_polyline ();
 661     }
 662
 663     openglNumberOfPoints ++;
 664     call_util_transform_pt (&x, &y, &z);
 665     if (x > XM) XM = x;
 666     if (y > YM) YM = y;
 667     if (z > ZM) ZM = z;
 668     if (x < xm) xm = x;
 669     if (y < ym) ym = y;
 670     if (z < zm) zm = z;
 671     glVertex3f (x, y, z);
 672     partial = 1;
 673   }
 674 }
 675
 676
 677 /*----------------------------------------------------------------------*/
 678 /*
 679 call_togl_set_linecolor (r, g, b)
 680 float r;
 681 float g;
 682 float b;
 683
 684 Sets a new color in the current primitive.
 685 */
 686
 687 void EXPORT
 688 call_togl_set_linecolor
 689 (
 690  float r,
 691  float g,
 692  float b
 693  )
 694 {
 695
 696 #ifdef TRACE
 697   printf ("call_togl_set_linecolor %d %d\n", openglViewId, openglWsId);
 698 #endif
 699
 700   if (openglViewId != 0) {
 701     TEL_COLOUR color;
 702     CMN_KEY key;
 703     key.id = TelPolylineColour;
 704     color.rgb[0] = r; color.rgb[1] = g; color.rgb[2] = b;
 705     key.data.pdata = &color;
 706     TsmSetAttri( 1, &key );
 707   }
 708 }
 709
 710
 711 /*----------------------------------------------------------------------*/
 712 /*
 713 call_togl_set_linetype (type)
 714 long type;
 715
 716 Sets a new line type in the current primitive.
 717 */
 718
 719 void EXPORT
 720 call_togl_set_linetype
 721 (
 722  long type
 723  )
 724 {
 725 #ifdef TRACE
 726   printf ("call_togl_set_linetype %d %d\n", openglViewId, openglWsId);
 727 #endif
 728
 729   if (openglViewId != 0) {
 730     CMN_KEY key;
 731     key.id = TelPolylineType;
 732     key.data.ldata = type;
 733     TsmSetAttri( 1, &key);
 734   }
 735 }
 736
 737
 738 /*----------------------------------------------------------------------*/
 739 /*
 740 call_togl_set_linewidth (width)
 741 float width;
 742
 743 Sets a new line width in the current primitive.
 744 */
 745
 746 void EXPORT
 747 call_togl_set_linewidth
 748 (
 749  float width
 750  )
 751 {
 752
 753 #ifdef TRACE
 754   printf ("call_togl_set_linewidth %d %d\n", openglViewId, openglWsId);
 755 #endif
 756
 757   if (openglViewId != 0) {
 758     CMN_KEY key;
 759     key.id = TelPolylineWidth;
 760     key.data.fdata = width;
 761     TsmSetAttri( 1, &key);
 762   }
 763 }
 764
 765
 766 /*----------------------------------------------------------------------*/
 767 /*
 768 call_togl_draw_structure (aStructureId)
 769 int aStructureId
 770
 771 Draw a structure in the transient view space
 772 */
 773
 774 void EXPORT
 775 call_togl_draw_structure
 776 (
 777  int aStructureId
 778  )
 779 {
 780   Tint    i, num;
 781   tsm_node node;
 782   register Tint istrsfed = 0;
 783   register Tint display = 1;
 784   register Tint highl = TOff;
 785   register TelType  telem;
 786   CMN_KEY   key;
 787
 788   float mat16[16];
 789   GLint mode1;
 790   GLint mode2;
 791
 792 #ifdef TRACE
 793   printf ("call_togl_draw_structure %d %d %d\n", openglViewId, openglWsId);
 794 #endif
 795
 796   if (openglViewId == 0) return;
 797
 798   if (TsmGetStructure (aStructureId, &num, &node) == TFailure || !num) return;
 799
 800   /*transform_persistence_end();*/
 801
 802   TsmPushAttriLight ();
 803   TsmPushAttri();
 804   TglNamesetPush();
 805
 806   /* mise en place de la matrice de transformation du trace transient */
 807   if (! identity) {
 808     call_util_transpose_mat (mat16, openglMat);
 809     glGetIntegerv (GL_MATRIX_MODE, &mode1);
 810     glMatrixMode (GL_MODELVIEW);
 811     glPushMatrix ();
 812     glScalef (1., 1., 1.);
 813     glMultMatrixf (mat16);
 814   }
 815
 816   for (i = 0; i < num; i++, node = node->next) {
 817     telem = node->elem.el;
 818 #if TRACE > 0
 819     TelTrace(telem,node->elem.data.ldata);
 820 #endif
 821     switch (telem) {
 822       case TelAddNameset:
 823       case TelRemoveNameset: {
 824         TsmSendMessage (telem, DisplayTraverse, node->elem.data, 0);
 825
 826         if( TglFilterNameset( openglWsId, InvisFilter ) == TSuccess )
 827           display = 0;
 828
 829         if( TglFilterNameset( openglWsId, HighlFilter ) == TSuccess )
 830           highl = TOn;
 831
 832         break;
 833                              }
 834
 835       case TelCurve:
 836       case TelMarker:
 837       case TelMarkerSet:
 838       case TelPolyline:
 839       case TelText: {
 840         /* do not send Display message to */
 841         /* primitives if they are invisible */
 842         if (display)
 843         {
 844           LightOff();
 845 #ifdef IMP150501
 846           glDepthMask(GL_FALSE);
 847 #endif
 848           key.id = highl;
 849           TsmSendMessage (telem, DisplayTraverse, node->elem.data, 1, &key);
 850         }
 851                     }
 852                     break;
 853
 854       case TelPolygon:
 855       case TelPolygonSet:
 856       case TelPolygonHoles:
 857       case TelPolygonIndices:
 858       case TelQuadrangle:
 859       case TelParray:
 860       case TelTriangleMesh: {
 861         /* do not send Display message to */
 862         /* primitives if they are invisible */
 863         if (display)
 864         {
 865           /* LightOn(); */
 866 #ifdef IMP150501
 867           glDepthMask(GL_FALSE);
 868 #endif
 869 #ifdef IMP051001
 870           if( highl ) {
 871             call_subr_disable_polygon_offset();
 872           }
 873 #endif
 874           key.id = highl;
 875           TsmSendMessage (telem, DisplayTraverse, node->elem.data, 1, &key);
 876 #ifdef IMP051001
 877           if( highl ) {
 878             call_subr_enable_polygon_offset();
 879           }
 880 #endif
 881         }
 882                             }
 883                             break;
 884
 885       case TelLocalTran3: {
 886         tel_matrix3_data  d = ((tel_matrix3_data)(node->elem.data.pdata));
 887         istrsfed = 1;
 888         call_util_transpose_mat (mat16, d->mat);
 889         glGetIntegerv (GL_MATRIX_MODE, &mode2);
 890         glMatrixMode (GL_MODELVIEW);
 891         glPushMatrix ();
 892         glScalef (1., 1., 1.);
 893         glMultMatrixf (mat16);
 894                           }
 895                           break;
 896                           /* ABD 29/10/04  Transform Persistence of Presentation( pan, zoom, rotate ) */
 897       case TelTransformPersistence:
 898         {
 899           key.id = openglWsId;
 900           TsmSendMessage (telem, DisplayTraverse, node->elem.data, 1, &key);
 901           break;
 902         }
 903         /*ABD 29/10/04  Transform Persistence of Presentation( pan, zoom, rotate ) */
 904       default: {
 905         key.id = openglWsId;
 906         TsmSendMessage (telem, DisplayTraverse, node->elem.data, 0, &key);
 907                }
 908     }
 909   }
 910
 911   TglNamesetPop();
 912   TsmPopAttri();
 913   TsmPopAttriLight ();
 914
 915   if (istrsfed) {
 916     glPopMatrix ();
 917     glMatrixMode (mode2);
 918   }
 919   if (! identity) {
 920     glPopMatrix ();
 921     glMatrixMode (mode1);
 922   }
 923
 924   return;
 925 }
 926
 927 /*----------------------------------------------------------------------*/
 928 /*
 929 call_togl_set_minmax (x1, y1, z1, x2, y2, z2)
 930 float x1;
 931 float y1;
 932 float z1;
 933 float x2;
 934 float y2;
 935 float z2;
 936
 937 Give the boundary box of the transient graphic
 938 */
 939
 940 void EXPORT
 941 call_togl_set_minmax (
 942                       float x1,
 943                       float y1,
 944                       float z1,
 945                       float x2,
 946                       float y2,
 947                       float z2
 948                       )
 949 {
 950 #ifdef TRACE
 951   printf("call_togl_set_minmax. x1 %f, y1 %f, z1 %f, x2 %f, y2 %f, z2 %f\n",x1, y1, z1, x2, y2, z2);
 952 #endif
 953   if ((x1 > shortreallast ()) ||
 954     (y1 > shortreallast ()) ||
 955     (z1 > shortreallast ()) ||
 956     (x2 > shortreallast ()) ||
 957     (y2 > shortreallast ()) ||
 958     (z2 > shortreallast ()) ||
 959     (x1 < shortrealfirst ()) ||
 960     (y1 < shortrealfirst ()) ||
 961     (z1 < shortrealfirst ()) ||
 962     (x2 < shortrealfirst ()) ||
 963     (y2 < shortrealfirst ()) ||
 964     (z2 < shortrealfirst ())) {
 965       XM = YM = ZM = (float ) shortreallast ();
 966       xm = ym = zm = (float ) shortrealfirst ();
 967       partial = 0;
 968     }
 969   else {
 970     call_util_transform_pt (&x1, &y1, &z1);
 971     call_util_transform_pt (&x2, &y2, &z2);
 972     if (x1 > XM) XM = x1;
 973     if (x1 < xm) xm = x1;
 974     if (y1 > YM) YM = y1;
 975     if (y1 < ym) ym = y1;
 976     if (z1 > ZM) ZM = z1;
 977     if (z1 < zm) zm = z1;
 978
 979     if (x2 > XM) XM = x2;
 980     if (x2 < xm) xm = x2;
 981     if (y2 > YM) YM = y2;
 982     if (y2 < ym) ym = y2;
 983     if (z2 > ZM) ZM = z2;
 984     if (z2 < zm) zm = z2;
 985     if (partial != 0) partial = 1;
 986   }
 987 }
 988
 989 /*----------------------------------------------------------------------*/
 990 /*
 991 * Private functions
 992 */
 993
 994 /*----------------------------------------------------------------------*/
 995 /*
 996 call_util_transform_pt (x, y, z)
 997 float *x;
 998 float *y;
 999 float *z;
1000
1001 Transform the point pt
1002 */
1003
1004 static void call_util_transform_pt
1005 (
1006  float *x,
1007  float *y,
1008  float *z
1009  )
1010 {
1011   int i, j;
1012   float sum = 0.;
1013   float tpt[4], pt[4];
1014
1015   if (! identity) {
1016     pt[0] = *x, pt[1] = *y, pt[2] = *z, pt[3] = 1.0;
1017
1018     for (i = 0; i < 4; i++) {
1019       for (j = 0, sum = 0.0; j < 4; j++)
1020         sum += openglMat[i][j] * pt[j];
1021       tpt[i] = sum;
1022     }
1023
1024     *x = tpt[0], *y = tpt[1], *z = tpt[2];
1025   }
1026 }
1027
1028
1029 /*----------------------------------------------------------------------*/
1030 /*
1031 int call_util_is_identity ()
1032
1033 Returns 1 if openglMat is the identity
1034 */
1035
1036 static int call_util_is_identity
1037 (
1038  )
1039 {
1040   int i, j;
1041   int res = 1;
1042
1043   for (i = 0; res && i < 4; i++)
1044     for (j = 0; res && j < 4; j++)
1045       if (i == j) res = (openglMat[i][j] == 1.);
1046       else        res = (openglMat[i][j] == 0.);
1047
1048 #ifdef TRACE
1049       printf ("La matrice suivante :\n");
1050       for (i = 0; i < 4; i++) {
1051         printf ("\t");
1052         for (j = 0; j < 4; j++)
1053           printf ("%f ", openglMat[i][j]);
1054         printf ("\n");
1055       }
1056       if (res)
1057         printf ("est la matrice identite\n");
1058       else
1059         printf ("n'est pas la matrice identite\n");
1060 #endif
1061
1062       return (res);
1063 }
1064
1065
1066 /*----------------------------------------------------------------------*/
1067 /*
1068 void call_util_transpose_mat (tmat, mat)
1069 float tmat[16];
1070 float mat[4][4];
1071
1072 Transpose mat and returns tmat.
1073 */
1074
1075 static void call_util_transpose_mat (float tmat[16], float mat[4][4]) {
1076   int i, j;
1077
1078   for (i=0; i<4; i++)
1079     for (j=0; j<4; j++)
1080       tmat[j*4+i] = mat[i][j];
1081
1082 #ifdef TRACE
1083   printf ("Transposee :\n");
1084   for (i = 0; i < 4; i++) {
1085     printf ("\t");
1086     for (j = 0; j < 4; j++)
1087       printf ("%f ", tmat[i*4+j]);
1088     printf ("\n");
1089   }
1090 #endif
1091 }