src/OpenGl/OpenGl_qstrip.cxx

   1 #define G003
   2 #define G004
   3 /***********************************************************************
   4
   5 FONCTION :
   6 ----------
   7 File OpenGl_qstrip :
   8
   9
  10 REMARQUES:
  11 ----------
  12
  13
  14 HISTORIQUE DES MODIFICATIONS   :
  15 --------------------------------
  16 xx-xx-xx : xxx ; Creation.
  17 11-03-96 : FMN ; Correction warning compilation
  18 01-04-96 : CAL ; Integration MINSK portage WNT
  19 22-04-96 : FMN ; Suppression prototype inutile.
  20 09-08-96 : FMN ; Suppression appel glMatrixMode() avant glGetFloatv()
  21 21-10-96 : FMN ; Suppression LMC_COLOR fait dans OpenGl_execstruct.c
  22 30-06-97 : FMN ; Suppression OpenGl_telem_light.h
  23 18-07-97 : FMN ; Ajout desactivation des lights suivant front_lighting_model
  24 21-07-97 : FMN ; Amelioration des performances OPTIMISATION_FMN
  25 - suppression calcul inutile sur les front faces
  26 27-08-97 : FMN ; Correction affichage des edges
  27 On n'affiche que les edges dans le mode IS_EMPTY
  28 10-09-97 : FMN ; Amelioration des perfs liees aux lights.
  29 15-09-97 : PCT ; Ajout coordonnees textures
  30 24-09-97 : FMN ; Suppression OPTIMISATION_FMN.
  31 08-12-97 : FMN ; Suppression appel TsmGetAttri inutile.
  32 31-12-97 : FMN ; Simplification pour le highlight
  33 15-01-98 : FMN ; Ajout Hidden line
  34 17-02-00 : EUG ; Degeneration support
  35 17-02-00 : EUG ; Bitmap drawing support
  36 08-03-01 : GG  ; BUC60823 Avoid crash in the normal computation method
  37 on confuse point.
  38
  39 ************************************************************************/
  40
  41 #define BUC60876        /* GG 5/4/2001 Disable local display list
  42 //                      when animation is not required
  43 */
  44
  45 /*----------------------------------------------------------------------*/
  46 /*
  47 * Includes
  48 */
  49
  50
  51 #include <OpenGl_tgl_all.hxx>
  52
  53 #include <stddef.h>
  54 #include <stdio.h>
  55
  56 #include <GL/gl.h>
  57 #include <GL/glu.h>
  58
  59 #include <OpenGl_cmn_varargs.hxx>
  60 #include <OpenGl_telem_attri.hxx>
  61 #include <OpenGl_tsm.hxx>
  62 #include <OpenGl_telem.hxx>
  63 #include <OpenGl_telem_util.hxx>
  64 #include <OpenGl_telem_highlight.hxx>
  65 #include <OpenGl_telem_inquire.hxx>
  66 #include <OpenGl_telem_view.hxx>
  67 #include <OpenGl_tgl_funcs.hxx>
  68 #include <OpenGl_LightBox.hxx>
  69 #include <OpenGl_TextureBox.hxx>
  70 #include <OpenGl_Memory.hxx>
  71
  72 /*----------------------------------------------------------------------*/
  73 /*
  74 * Constantes
  75 */
  76
  77 /*----------------------------------------------------------------------*/
  78 /*
  79 * Variables externes
  80 */
  81
  82 extern  Tint  ForbidSetTextureMapping; /* currently defined in tsm/tsm.c */
  83
  84 #ifdef G003
  85 # include <float.h>
  86 # define DEF_DS_INTERNAL
  87 # include <OpenGl_degeneration.hxx>
  88
  89 # ifdef G004
  90 extern GLboolean g_fBitmap;
  91 # endif /* G004 */
  92
  93 # define OPENGL_RAND() (  ( unsigned )( s_Rand = s_Rand * 214013L + 2531011L ))
  94
  95 extern int   g_nDegenerateModel;
  96 extern float g_fSkipRatio;
  97 extern GLboolean g_fAnimation;
  98
  99 #endif  /* G003 */
 100
 101 /*----------------------------------------------------------------------*/
 102
 103 struct TEL_QSTRIP_DATA
 104 {
 105   Tint       shape_flag;  /* TEL_SHAPE_UNKNOWN or TEL_SHAPE_COMPLEX or
 106                           TEL_SHAPE_CONVEX  or TEL_SHAPE_CONCAVE */
 107   Tint       facet_flag;  /* TEL_FA_NONE or TEL_FA_NORMAL */
 108   Tint       vertex_flag; /* TEL_VT_NONE or TEL_VT_NORMAL */
 109   Tint       num_rows,
 110     num_columns; /* Number of rows and columns */
 111   tel_point  fnormals;    /* Facet normals */
 112   tel_colour fcolours;    /* Facet colours */
 113   tel_point  vertices;    /* Vertices */
 114   tel_colour vcolours;    /* Vertex colour values */
 115   tel_point  vnormals;    /* Vertex normals */
 116   tel_texture_coord vtexturecoord; /* Texture coordinates */
 117 #ifdef G003
 118   DS_INTERNAL d;
 119 #endif  /* G003 */
 120   IMPLEMENT_MEMORY_OPERATORS
 121 };
 122 typedef TEL_QSTRIP_DATA* tel_qstrip_data;
 123
 124 static  TStatus  QuadrangleDisplay( TSM_ELEM_DATA, Tint, cmn_key* );
 125 static  TStatus  QuadrangleAdd( TSM_ELEM_DATA, Tint, cmn_key* );
 126 static  TStatus  QuadrangleDelete( TSM_ELEM_DATA, Tint, cmn_key* );
 127 static  TStatus  QuadranglePrint( TSM_ELEM_DATA, Tint, cmn_key* );
 128 static  TStatus  QuadrangleInquire( TSM_ELEM_DATA, Tint, cmn_key* );
 129
 130 static void
 131 draw_qstrip( tel_qstrip_data,
 132             Tint,          /* highlight flag */
 133             Tint,          /* front_lighting_model,  */
 134             Tint,          /* interior_style,  */
 135             tel_colour    /* edge_colour, */
 136             );
 137
 138 #ifdef G003
 139 static void draw_edges                 ( tel_qstrip_data, tel_colour, Tint, Tint );
 140 extern void draw_degenerates_as_points ( PDS_INTERNAL, tel_point, Tint           );
 141 extern void draw_degenerates_as_bboxs  ( PDS_INTERNAL, tel_point, Tint           );
 142 extern void set_drawable_items         ( GLboolean*, int                         );
 143 #else
 144 static void draw_edges ( tel_qstrip_data, tel_colour, Tint );
 145 #endif  /* G003 */
 146
 147 static void draw_line_strip ( tel_qstrip_data, tel_colour, Tint, Tint );
 148
 149 static TEL_QSTRIP_DATA qstrip_defaults = {
 150
 151   TEL_SHAPE_UNKNOWN, /* shape_flag */
 152   TEL_FA_NONE,       /* facet_flag */
 153   TEL_VT_NONE        /* vertex_flag */
 154
 155 };
 156
 157 static TStatus ( *MtdTbl[] ) ( TSM_ELEM_DATA, Tint, cmn_key* ) = {
 158
 159   QuadrangleDisplay, /* PickTraverse */
 160   QuadrangleDisplay,
 161   QuadrangleAdd,
 162   QuadrangleDelete,
 163   QuadranglePrint,
 164   QuadrangleInquire
 165
 166 };
 167
 168 /*----------------------------------------------------------------------*/
 169
 170 MtblPtr TelQuadrangleInitClass ( TelType* el ) {
 171
 172   *el = TelQuadrangle;
 173
 174   return MtdTbl;
 175
 176 }  /* end TelQuadrangleInitClass */
 177
 178 static  TStatus
 179 QuadrangleAdd( TSM_ELEM_DATA d, Tint n, cmn_key *k )
 180
 181 {
 182   Tint i, j;
 183   Tint nf, nv;
 184   tel_qstrip_data  data;
 185
 186   for( i = 0; i < n; i++ )
 187   {
 188     if( k[i]->id == NUM_ROWS_ID )
 189       break;
 190   }
 191   if( i == n )
 192     return TFailure;
 193
 194   if( !(k[i]->data.ldata) )
 195     return TFailure;
 196
 197   for( j = 0; j < n; j++ )
 198   {
 199     if( k[j]->id == NUM_COLUMNS_ID )
 200       break;
 201   }
 202   if( j == n )
 203     return TFailure;
 204
 205   if( !(k[j]->data.ldata) )
 206     return TFailure;
 207
 208   data = new TEL_QSTRIP_DATA();
 209   if( !data )
 210     return TFailure;
 211
 212   /* load defaults */
 213   *data = qstrip_defaults;
 214
 215   data->num_rows    = k[i]->data.ldata;
 216   data->num_columns = k[j]->data.ldata;
 217   nf = data->num_rows * data->num_columns;
 218   nv = ( data->num_rows+1 ) * ( data->num_columns+1 );
 219
 220   data->vtexturecoord = 0;
 221
 222   for( i = 0; i < n; i++ )
 223   {
 224     switch( k[i]->id )
 225     {
 226     case SHAPE_FLAG_ID:
 227       {
 228         data->shape_flag = k[i]->data.ldata;
 229         break;
 230       }
 231     case FNORMALS_ID:
 232       {
 233         data->facet_flag = TEL_FA_NORMAL;
 234         data->fnormals = new TEL_POINT[nf];
 235         memcpy( data->fnormals, k[i]->data.pdata, nf*sizeof(TEL_POINT) );
 236         for( j = 0; j < nf; j++ )
 237           vecnrm( data->fnormals[j].xyz );
 238         break;
 239       }
 240     case FACET_COLOUR_VALS_ID:
 241       {
 242         data->fcolours = new TEL_COLOUR[nf];
 243         memcpy( data->fcolours, k[i]->data.pdata, nf*sizeof(TEL_COLOUR) );
 244         break;
 245       }
 246     case VERTICES_ID:
 247       {
 248         data->vertices = new TEL_POINT[nv];
 249         memcpy( data->vertices, k[i]->data.pdata, nv*sizeof(TEL_POINT) );
 250         break;
 251       }
 252     case VERTEX_COLOUR_VALS_ID:
 253       {
 254         data->vcolours = new TEL_COLOUR[nv];
 255         memcpy( data->vcolours, k[i]->data.pdata, nv*sizeof(TEL_COLOUR) );
 256         break;
 257       }
 258     case VNORMALS_ID:
 259       {
 260         data->vertex_flag = TEL_VT_NORMAL;
 261         data->vnormals = new TEL_POINT[nv];
 262         memcpy( data->vnormals, k[i]->data.pdata, nv*sizeof(TEL_POINT) );
 263         for( j = 0; j < nv; j++ )
 264           vecnrm( data->vnormals[j].xyz );
 265         break;
 266       }
 267     case VTEXTURECOORD_ID:
 268       {
 269         data->vtexturecoord = new TEL_TEXTURE_COORD[nv];
 270         memcpy( data->vtexturecoord, k[i]->data.pdata, nv*sizeof(TEL_TEXTURE_COORD) );
 271         break;
 272       }
 273     default:
 274       {
 275         break;
 276       }
 277     }
 278   }
 279
 280   if( data->facet_flag != TEL_FA_NORMAL )
 281   {
 282     /* calculate the normals and store */
 283     data->fnormals = new TEL_POINT[nf];
 284     for( i = 0; i < nf; i++ )
 285     {
 286       TEL_POINT  p1, p2, p3, p4;
 287       Tint       r, c, id;
 288
 289       r = i/data->num_columns;
 290       c = i%data->num_columns;
 291
 292       id = r*(data->num_columns+1) + c;
 293       p1 = data->vertices[id];
 294       p2 = data->vertices[id+data->num_columns+1];
 295       p3 = data->vertices[id+data->num_columns+2];
 296       p4 = data->vertices[id+1];
 297
 298       p4.xyz[0] -= p2.xyz[0];
 299       p4.xyz[1] -= p2.xyz[1];
 300       p4.xyz[2] -= p2.xyz[2];
 301
 302       p4.xyz[0] += p1.xyz[0];
 303       p4.xyz[1] += p1.xyz[1];
 304       p4.xyz[2] += p1.xyz[2];
 305
 306       TelGetNormal( p4.xyz, p1.xyz, p3.xyz, data->fnormals[i].xyz );
 307     }
 308 #ifndef BUC60823
 309     for( j = 0; j < nf; j++ )
 310       vecnrm( data->fnormals[j].xyz );
 311 #endif
 312   }
 313   if( data->vertex_flag != TEL_VT_NORMAL )
 314   {
 315     Tint r, c, id;
 316     /* calculate the vertex normals */
 317     data->vnormals = new TEL_POINT[nv];
 318     for( i = 0; i < nv; i++ )
 319     {
 320       if( i == 0 )
 321         data->vnormals[i] = data->fnormals[i];
 322       else if( i == (nv-1) )
 323         data->vnormals[i] = data->fnormals[nf-1];
 324       else if( i == (nv-data->num_columns-1) )
 325         data->vnormals[i] = data->fnormals[nf-data->num_columns];
 326       else if( i == data->num_columns )
 327         data->vnormals[i] = data->fnormals[i-1];
 328       else if( i%(data->num_columns+1) == 0 )
 329       {
 330         r = i/(data->num_columns+1);
 331         data->vnormals[i].xyz[0] =
 332           ( data->fnormals[(r-1)*data->num_columns].xyz[0] +
 333           data->fnormals[r*data->num_columns].xyz[0] ) / ( float )2.0;
 334         data->vnormals[i].xyz[1] =
 335           ( data->fnormals[(r-1)*data->num_columns].xyz[1] +
 336           data->fnormals[r*data->num_columns].xyz[1] ) / ( float )2.0;
 337         data->vnormals[i].xyz[2] =
 338           ( data->fnormals[(r-1)*data->num_columns].xyz[2] +
 339           data->fnormals[r*data->num_columns].xyz[2] ) / ( float )2.0;
 340       }
 341       else if( i <= data->num_columns )
 342       {
 343         data->vnormals[i].xyz[0] = ( data->fnormals[i-1].xyz[0] +
 344           data->fnormals[i].xyz[0] ) / ( float )2.0;
 345         data->vnormals[i].xyz[1] = ( data->fnormals[i-1].xyz[1] +
 346           data->fnormals[i].xyz[1] ) / ( float )2.0;
 347         data->vnormals[i].xyz[2] = ( data->fnormals[i-1].xyz[2] +
 348           data->fnormals[i].xyz[2] ) / ( float )2.0;
 349       }
 350       else if( i >= (nv-data->num_columns-1 ) )
 351       {
 352         c = i%(data->num_columns+1);
 353         id = nf-data->num_columns+c;
 354
 355         data->vnormals[i].xyz[0] = ( data->fnormals[id-1].xyz[0] +
 356           data->fnormals[id].xyz[0] ) / ( float )2.0;
 357         data->vnormals[i].xyz[1] = ( data->fnormals[id-1].xyz[1] +
 358           data->fnormals[id].xyz[1] ) / ( float )2.0;
 359         data->vnormals[i].xyz[2] = ( data->fnormals[id-1].xyz[2] +
 360           data->fnormals[id].xyz[2] ) / ( float )2.0;
 361       }
 362       else if( (i+1)%(data->num_columns+1) == 0 )
 363       {
 364         r = (i+1)/(data->num_columns+1);
 365         data->vnormals[i].xyz[0] =
 366           ( data->fnormals[(r-1)*data->num_columns-1].xyz[0] +
 367           data->fnormals[r*data->num_columns-1].xyz[0] ) / ( float )2.0;
 368         data->vnormals[i].xyz[1] =
 369           ( data->fnormals[(r-1)*data->num_columns-1].xyz[1] +
 370           data->fnormals[r*data->num_columns-1].xyz[1] ) / ( float )2.0;
 371         data->vnormals[i].xyz[2] =
 372           ( data->fnormals[(r-1)*data->num_columns-1].xyz[2] +
 373           data->fnormals[r*data->num_columns-1].xyz[2] ) / ( float )2.0;
 374       }
 375       else
 376       {
 377         r = i/(data->num_columns+1);
 378         c = i%(data->num_columns+1);
 379
 380         id = r*data->num_columns+c;
 381
 382         data->vnormals[i].xyz[0] =
 383           ( data->fnormals[id].xyz[0] +
 384           data->fnormals[id-data->num_columns].xyz[0] +
 385           data->fnormals[id-1].xyz[0] +
 386           data->fnormals[id-data->num_columns-1].xyz[0] ) / ( float )4.0;
 387         data->vnormals[i].xyz[1] =
 388           ( data->fnormals[id].xyz[1] +
 389           data->fnormals[id-data->num_columns].xyz[1] +
 390           data->fnormals[id-1].xyz[1] +
 391           data->fnormals[id-data->num_columns-1].xyz[1] ) / ( float )4.0;
 392         data->vnormals[i].xyz[2] =
 393           ( data->fnormals[id].xyz[2] +
 394           data->fnormals[id-data->num_columns].xyz[2] +
 395           data->fnormals[id-1].xyz[2] +
 396           data->fnormals[id-data->num_columns-1].xyz[2] ) / ( float )4.0;
 397       }
 398     }
 399   }
 400 #ifdef G003
 401   data -> d.list      =  0;
 402   data -> d.dlist     =  0;
 403   data -> d.degMode   =  0;
 404   data -> d.model     = -1;
 405   data -> d.skipRatio =  0.0F;
 406   data->d.bDraw = new unsigned char[nv];
 407 #endif  /* G003 */
 408   ((tsm_elem_data)(d.pdata))->pdata = data;
 409
 410   return TSuccess;
 411 }
 412 /*----------------------------------------------------------------------*/
 413
 414 static  TStatus
 415 QuadrangleDisplay( TSM_ELEM_DATA data, Tint n, cmn_key *k )
 416 {
 417   CMN_KEY       k11, k12, k17, k111, k114;
 418
 419   Tint           front_lighting_model;
 420   Tint           interior_style;
 421   TEL_COLOUR     interior_colour;
 422   TEL_COLOUR     edge_colour;
 423
 424   tel_qstrip_data d;
 425
 426   k12.id          = TelInteriorReflectanceEquation;
 427   k17.id          = TelInteriorStyle;
 428   k111.id         = TelInteriorColour;
 429   k111.data.pdata = &interior_colour;
 430   k114.id         = TelEdgeColour;
 431   k114.data.pdata = &edge_colour;
 432
 433   TsmGetAttri( 4, &k12, &k17, &k111, &k114);
 434
 435   front_lighting_model     = k12.data.ldata;
 436   interior_style           = k17.data.ldata;
 437
 438 #ifdef PRINT
 439   printf("QuadrangleDisplay \n");
 440 #endif
 441
 442   /*
 443   *  Use highlight colours
 444   */
 445
 446   if( k[0]->id == TOn )
 447   {
 448     TEL_HIGHLIGHT  hrep;
 449
 450     k11.id = TelHighlightIndex;
 451     TsmGetAttri( 1, &k11 );
 452     if( TelGetHighlightRep( TglActiveWs, k11.data.ldata, &hrep )
 453       == TSuccess )
 454     {
 455       if( hrep.type == TelHLForcedColour )
 456       {
 457         edge_colour = interior_colour = hrep.col;
 458         front_lighting_model = CALL_PHIGS_REFL_NONE;
 459       }
 460       else if( hrep.type == TelHLColour )
 461       {
 462         edge_colour = hrep.col;
 463         k[0]->id = TOff;
 464       }
 465     }
 466     else
 467     {
 468       TelGetHighlightRep( TglActiveWs, 0, &hrep );
 469       if( hrep.type == TelHLForcedColour )
 470       {
 471         edge_colour = interior_colour = hrep.col;
 472         front_lighting_model = CALL_PHIGS_REFL_NONE;
 473       }
 474       else if( hrep.type == TelHLColour )
 475       {
 476         edge_colour = hrep.col;
 477         k[0]->id = TOff;
 478       }
 479     }
 480   }
 481
 482   d = (tel_qstrip_data)data.pdata;
 483
 484   glColor3fv( interior_colour.rgb );
 485
 486   draw_qstrip( d,
 487     k[0]->id,
 488     front_lighting_model,
 489     interior_style,
 490     &edge_colour );
 491
 492   return TSuccess;
 493 }
 494
 495 /*----------------------------------------------------------------------*/
 496
 497 static void draw_qstrip (
 498                          tel_qstrip_data                  p,
 499                          Tint                         hflag,
 500                          Tint          front_lighting_model,
 501                          Tint                interior_style,
 502                          tel_colour             edge_colour
 503                          )
 504 {
 505
 506   Tint              i, m, newList = 0;
 507   Tint              nf, nv, nr, nc;
 508   Tint              lighting_model;
 509   tel_point         pv, pfn, pvn;
 510   tel_colour        pfc, pvc;
 511   tel_texture_coord pvt;
 512
 513   pfn = p -> fnormals;
 514   pfc = p -> fcolours;
 515   pv  = p -> vertices;
 516   pvc = p -> vcolours;
 517   pvn = p -> vnormals;
 518   pvt = p -> vtexturecoord;
 519
 520   if ( hflag == TOn ) {
 521
 522     pvc = 0;
 523     pfc = 0;
 524
 525   }  /* end if */
 526
 527 #ifdef G003
 528   if ( g_nDegenerateModel < 2 && interior_style != TSM_EMPTY ) {
 529 #else
 530   if ( interior_style != TSM_EMPTY ) {
 531 #endif  /* G003 */
 532     if ( front_lighting_model == CALL_PHIGS_REFL_NONE )
 533
 534       LightOff ();
 535
 536     else LightOn ();
 537
 538     lighting_model = front_lighting_model;
 539     nr             = p -> num_rows;
 540     nc             = p -> num_columns;
 541     nf             = nr * nc;
 542     nv             = ( nr + 1 ) * ( nc + 1 );
 543 #ifdef G003
 544 #ifdef BUC60876
 545     if ( !g_fAnimation )
 546       goto doDraw; /* Disable object display list out of animation */
 547 #endif
 548 # ifdef G004
 549     if ( g_fBitmap )
 550       goto doDraw;  /* display lists are NOT shared between */
 551     /*  window's context and bitmap's one   */
 552 # endif  /* G004 */
 553     if ( p -> d.model != front_lighting_model || !p -> d.list ||
 554       p -> d.model == -1                                 ||
 555       ( g_nDegenerateModel && p -> d.skipRatio != g_fSkipRatio )
 556       ) {
 557
 558         p -> d.skipRatio = g_fSkipRatio;
 559         p -> d.model     = front_lighting_model;
 560         p -> d.degMode   = g_nDegenerateModel;
 561
 562         if ( g_fSkipRatio == 0.0 ) {
 563
 564           if ( !p -> d.list ) p -> d.list = glGenLists ( 1 );
 565
 566           glNewList ( p -> d.list, GL_COMPILE_AND_EXECUTE );
 567           newList = 1;
 568 #endif  /* G003 */
 569 #ifdef G004
 570 doDraw:
 571 #endif  /* G004 */
 572           if ( lighting_model == CALL_PHIGS_REFL_NONE ) {
 573
 574             if ( pvc ) {
 575
 576               for ( m = 0; m < nr; ++m ) {
 577
 578                 glBegin ( GL_QUAD_STRIP );
 579                 glColor3fv  ( pvc[         m * ( nc + 1 ) ].rgb );
 580                 glVertex3fv ( pv[          m * ( nc + 1 ) ].xyz );
 581                 glColor3fv  ( pvc[ ( m + 1 ) * ( nc + 1 ) ].rgb );
 582                 glVertex3fv ( pv[  ( m + 1 ) * ( nc + 1 ) ].xyz );
 583
 584                 for ( i = 1; i < nc + 1; ++i ) {
 585
 586                   glColor3fv  ( pvc[         i + m * ( nc + 1 ) ].rgb );
 587                   glVertex3fv ( pv[          i + m * ( nc + 1 ) ].xyz );
 588                   glColor3fv  ( pvc[ i + ( m + 1 ) * ( nc + 1 ) ].rgb );
 589                   glVertex3fv ( pv[  i + ( m + 1 ) * ( nc + 1 ) ].xyz );
 590
 591                 }  /* end for */
 592
 593                 glEnd ();
 594
 595               }  /* end for */
 596
 597             } else if ( pfc ) {
 598
 599               glColor3fv ( pfc[ 0 ].rgb );
 600
 601               for ( m = 0; m < nr; ++m ) {
 602
 603                 glBegin ( GL_QUAD_STRIP );
 604                 glColor3fv  ( pfc[                m * nc ].rgb );
 605                 glVertex3fv ( pv[         m * ( nc + 1 ) ].xyz );
 606                 glVertex3fv ( pv[ ( m + 1 ) * ( nc + 1 ) ].xyz );
 607
 608                 for ( i = 1; i < nc + 1; ++i ) {
 609
 610                   glVertex3fv ( pv[         i + m * ( nc + 1 ) ].xyz );
 611                   glColor3fv  ( pfc[            i - 1 + m * nc ].rgb );
 612                   glVertex3fv ( pv[ i + ( m + 1 ) * ( nc + 1 ) ].xyz );
 613
 614                 }  /* end for */
 615
 616                 glEnd ();
 617
 618               }  /* end for */
 619
 620             } else {
 621
 622               for ( m = 0; m < nr; ++m ) {
 623
 624                 glBegin ( GL_QUAD_STRIP );
 625                 glVertex3fv ( pv[         m * ( nc + 1 ) ].xyz );
 626                 glVertex3fv ( pv[ ( m + 1 ) * ( nc + 1 ) ].xyz );
 627
 628                 for ( i = 1; i < nc + 1; ++i ) {
 629
 630                   glVertex3fv( pv[         i + m * ( nc + 1 ) ].xyz );
 631                   glVertex3fv( pv[ i + ( m + 1 ) * ( nc + 1 ) ].xyz );
 632
 633                 }  /* end for */
 634
 635                 glEnd ();
 636
 637               }  /* end for */
 638
 639             }  /* end else */
 640
 641           } else {  /* lighting_model != TelLModelNone */
 642
 643             if ( pvt && !ForbidSetTextureMapping )
 644
 645               for ( m = 0; m < nr; ++m ) {
 646
 647                 glBegin ( GL_QUAD_STRIP );
 648                 glNormal3fv   ( pvn[         m * ( nc + 1 ) ].xyz );
 649                 glTexCoord2fv ( pvt[         m * ( nc + 1 ) ].xy  );
 650                 glVertex3fv   ( pv[          m * ( nc + 1 ) ].xyz );
 651                 glNormal3fv   ( pvn[ ( m + 1 ) * ( nc + 1 ) ].xyz );
 652                 glTexCoord2fv ( pvt[ ( m + 1 ) * ( nc + 1 ) ].xy  );
 653                 glVertex3fv   ( pv[  ( m + 1 ) * ( nc + 1 ) ].xyz );
 654
 655                 for ( i = 1; i < nc + 1; ++i ) {
 656
 657                   glNormal3fv   ( pvn[         i + m * ( nc + 1 ) ].xyz );
 658                   glTexCoord2fv ( pvt[         i + m * ( nc + 1 ) ].xy  );
 659                   glVertex3fv   ( pv[          i + m * ( nc + 1 ) ].xyz );
 660                   glNormal3fv   ( pvn[ i + ( m + 1 ) * ( nc + 1 ) ].xyz );
 661                   glTexCoord2fv ( pvt[ i + ( m + 1 ) * ( nc + 1 ) ].xy  );
 662                   glVertex3fv   ( pv[  i + ( m + 1 ) * ( nc + 1 ) ].xyz );
 663
 664                 }  /* end for */
 665
 666                 glEnd ();
 667
 668               }  /* end for */
 669
 670             else
 671
 672               for ( m = 0; m < nr; ++m ) {
 673
 674                 glBegin ( GL_QUAD_STRIP );
 675                 glNormal3fv ( pvn[         m * ( nc + 1 ) ].xyz );
 676                 glVertex3fv ( pv[          m * ( nc + 1 ) ].xyz );
 677                 glNormal3fv ( pvn[ ( m + 1 ) * ( nc + 1 ) ].xyz );
 678                 glVertex3fv ( pv[  ( m + 1 ) * ( nc + 1 ) ].xyz );
 679
 680                 for ( i = 1; i < nc + 1; ++i ) {
 681
 682                   glNormal3fv ( pvn[         i + m * ( nc + 1 ) ].xyz );
 683                   glVertex3fv ( pv[          i + m * ( nc + 1 ) ].xyz );
 684                   glNormal3fv ( pvn[ i + ( m + 1 ) * ( nc + 1 ) ].xyz );
 685                   glVertex3fv ( pv[  i + ( m + 1 ) * ( nc + 1 ) ].xyz );
 686
 687                 }  /* end for */
 688
 689                 glEnd ();
 690
 691               }  /* end for */
 692
 693           }  /* end else */
 694 #ifdef G003
 695         } else if ( g_fSkipRatio != 1.0 ) {
 696
 697           set_drawable_items ( p -> d.bDraw, nr );
 698
 699           if ( !p -> d.dlist ) p -> d.dlist = glGenLists ( 1 );
 700
 701           glNewList ( p -> d.dlist, GL_COMPILE_AND_EXECUTE );
 702           newList = 1;
 703
 704           if ( lighting_model == CALL_PHIGS_REFL_NONE ) {
 705
 706             if ( pvc ) {
 707
 708               for ( m = 0; m < nr; ++m )
 709
 710                 if ( p -> d.bDraw[ m ] ) {
 711
 712                   glBegin ( GL_QUAD_STRIP );
 713                   glColor3fv  ( pvc[         m * ( nc + 1 ) ].rgb );
 714                   glVertex3fv ( pv[          m * ( nc + 1 ) ].xyz );
 715                   glColor3fv  ( pvc[ ( m + 1 ) * ( nc + 1 ) ].rgb );
 716                   glVertex3fv ( pv[  ( m + 1 ) * ( nc + 1 ) ].xyz );
 717
 718                   for ( i = 1; i < nc + 1; ++i ) {
 719
 720                     glColor3fv  ( pvc[ i + ( m + 1 ) * ( nc + 1 ) ].rgb );
 721                     glVertex3fv ( pv[  i + ( m + 1 ) * ( nc + 1 ) ].xyz );
 722                     glColor3fv  ( pvc[         i + m * ( nc + 1 ) ].rgb );
 723                     glVertex3fv ( pv[          i + m * ( nc + 1 ) ].xyz );
 724
 725                   }  /* end for */
 726
 727                   glEnd ();
 728
 729                 }  /* end if */
 730
 731             } else if ( pfc ) {
 732
 733               glColor3fv ( pfc[ 0 ].rgb );
 734
 735               for ( m = 0; m < nr; ++m )
 736
 737                 if ( p -> d.bDraw[ m ] ) {
 738
 739                   glBegin ( GL_QUADS );
 740                   glColor3fv  ( pfc[                m * nc ].rgb );
 741                   glVertex3fv ( pv[         m * ( nc + 1 ) ].xyz );
 742                   glVertex3fv ( pv[ ( m + 1 ) * ( nc + 1 ) ].xyz );
 743
 744                   for ( i = 1; i < nc + 1; ++i ) {
 745
 746                     glColor3fv  ( pfc[            i - 1 + m * nc ].rgb );
 747                     glVertex3fv ( pv[ i + ( m + 1 ) * ( nc + 1 ) ].xyz );
 748                     glVertex3fv ( pv[         i + m * ( nc + 1 ) ].xyz );
 749
 750                   }  /* end for */
 751
 752                   glEnd ();
 753
 754                 }  /* end if */
 755
 756             } else {
 757
 758               for ( m = 0; m < nr; ++m )
 759
 760                 if ( p -> d.bDraw[ m ] ) {
 761
 762                   glBegin ( GL_QUADS );
 763                   glVertex3fv ( pv[         m * ( nc + 1 ) ].xyz );
 764                   glVertex3fv ( pv[ ( m + 1 ) * ( nc + 1 ) ].xyz );
 765
 766                   for ( i = 1; i < nc + 1; ++i ) {
 767
 768                     glVertex3fv( pv[ i + ( m + 1 ) * ( nc + 1 ) ].xyz );
 769                     glVertex3fv( pv[         i + m * ( nc + 1 ) ].xyz );
 770
 771                   }  /* end for */
 772
 773                   glEnd ();
 774
 775                 }  /* end if */
 776
 777             }  /* end else */
 778
 779           } else {  /* lighting_model != TelLModelNone */
 780
 781             if ( pvt && !ForbidSetTextureMapping ) {
 782
 783               for ( m = 0; m < nr; ++m )
 784
 785                 if ( p -> d.bDraw[ m ] ) {
 786
 787                   glBegin ( GL_QUADS );
 788                   glNormal3fv   ( pvn[         m * ( nc + 1 ) ].xyz );
 789                   glTexCoord2fv ( pvt[         m * ( nc + 1 ) ].xy  );
 790                   glVertex3fv   ( pv[          m * ( nc + 1 ) ].xyz );
 791                   glNormal3fv   ( pvn[ ( m + 1 ) * ( nc + 1 ) ].xyz );
 792                   glTexCoord2fv ( pvt[ ( m + 1 ) * ( nc + 1 ) ].xy  );
 793                   glVertex3fv   ( pv[  ( m + 1 ) * ( nc + 1 ) ].xyz );
 794
 795                   for ( i = 1; i < nc + 1; ++i ) {
 796
 797                     glNormal3fv   ( pvn[ i + ( m + 1 ) * ( nc + 1 ) ].xyz );
 798                     glTexCoord2fv ( pvt[ i + ( m + 1 ) * ( nc + 1 ) ].xy  );
 799                     glVertex3fv   ( pv[  i + ( m + 1 ) * ( nc + 1 ) ].xyz );
 800                     glNormal3fv   ( pvn[         i + m * ( nc + 1 ) ].xyz );
 801                     glTexCoord2fv ( pvt[         i + m * ( nc + 1 ) ].xy  );
 802                     glVertex3fv   ( pv[          i + m * ( nc + 1 ) ].xyz );
 803
 804                   }  /* end for */
 805
 806                   glEnd ();
 807
 808                 }  /* end if */
 809
 810             } else
 811
 812               for ( m = 0; m < nr; ++m )
 813
 814                 if ( p -> d.bDraw[ m ] ) {
 815
 816                   glBegin ( GL_QUADS );
 817                   glNormal3fv ( pvn[         m * ( nc + 1 ) ].xyz );
 818                   glVertex3fv ( pv[          m * ( nc + 1 ) ].xyz );
 819                   glNormal3fv ( pvn[ ( m + 1 ) * ( nc + 1 ) ].xyz );
 820                   glVertex3fv ( pv[  ( m + 1 ) * ( nc + 1 ) ].xyz );
 821
 822                   for ( i = 1; i < nc + 1; ++i ) {
 823
 824                     glNormal3fv ( pvn[ i + ( m + 1 ) * ( nc + 1 ) ].xyz );
 825                     glVertex3fv ( pv[  i + ( m + 1 ) * ( nc + 1 ) ].xyz );
 826                     glNormal3fv ( pvn[         i + m * ( nc + 1 ) ].xyz );
 827                     glVertex3fv ( pv[          i + m * ( nc + 1 ) ].xyz );
 828
 829                   }  /* end for */
 830
 831                   glEnd ();
 832
 833                 }  /* end if */
 834
 835           }  /* end else */
 836
 837         } else {
 838
 839           if ( !p -> d.dlist ) p -> d.dlist = glGenLists ( 1 );
 840
 841           glNewList ( p -> d.dlist, GL_COMPILE_AND_EXECUTE );
 842           newList = 1;
 843
 844         }  /* end else */
 845         if ( newList ) glEndList ();
 846
 847         if ( g_nDegenerateModel ) return;
 848
 849       } else {
 850
 851         glCallList ( g_fSkipRatio == 0.0 ? p -> d.list : p -> d.dlist );
 852
 853         if ( g_nDegenerateModel ) return;
 854
 855       }  /* end else */
 856 #endif  /* G003 */
 857   }  /* end if ( interior_style != TSM_EMPTY ) */
 858 #ifdef G003
 859   i = 0;
 860
 861   /* OCC11904 -- Temporarily disable environment mapping */
 862   glPushAttrib(GL_ENABLE_BIT);
 863   glDisable(GL_TEXTURE_1D);
 864   glDisable(GL_TEXTURE_2D);
 865
 866   switch ( g_nDegenerateModel ) {
 867
 868 default:
 869   break;
 870
 871 case 2:  /* XXX_TDM_WIREFRAME */
 872   i = 1;
 873   break;
 874
 875 case 3:  /* XXX_TDM_MARKER */
 876   draw_degenerates_as_points (
 877     &p -> d, p -> vertices, ( p -> num_rows + 1 ) * ( p -> num_columns + 1 )
 878     );
 879
 880   glPopAttrib();
 881
 882   return;
 883
 884 case 4:  /* XXX_TDM_BBOX */
 885   draw_degenerates_as_bboxs (
 886     &p -> d, p -> vertices, ( p -> num_rows + 1 ) * ( p -> num_columns + 1 )
 887     );
 888
 889   glPopAttrib();
 890
 891   return;
 892
 893   }  /* end switch */
 894
 895   draw_edges ( p, edge_colour, interior_style, i );
 896 #else
 897   draw_edges ( p, edge_colour, interior_style    );
 898 #endif  /* G003 */
 899
 900   glPopAttrib();
 901 }  /* end draw_qstrip */
 902 /*----------------------------------------------------------------------*/
 903 static  TStatus
 904 QuadrangleDelete( TSM_ELEM_DATA data, Tint n, cmn_key *k )
 905 {
 906   tel_qstrip_data p;
 907
 908   p = (tel_qstrip_data)data.pdata;
 909   if( p->fnormals ) //cmn_freemem( p->fnormals );
 910     delete[] p->fnormals;
 911   if( p->fcolours ) //cmn_freemem( p->fcolours );
 912     delete[] p->fcolours;
 913   if( p->vertices ) //cmn_freemem( p->vertices );
 914     delete[] p->vertices;
 915   if( p->vcolours ) //cmn_freemem( p->vcolours );
 916     delete[] p->vcolours;
 917   if( p->vnormals ) //cmn_freemem( p->vnormals );
 918     delete[] p->vnormals;
 919   if (p->vtexturecoord) //cmn_freemem(p->vtexturecoord);
 920     delete[] p->vtexturecoord;
 921
 922   if (data.pdata)
 923     delete data.pdata;
 924
 925   return TSuccess;
 926 }
 927
 928 /*----------------------------------------------------------------------*/
 929 static  TStatus
 930 QuadranglePrint( TSM_ELEM_DATA data, Tint n, cmn_key *k )
 931 {
 932   Tint           i;
 933   tel_qstrip_data p = (tel_qstrip_data)data.pdata;
 934
 935   fprintf(stdout, "TelQuadrangle. ");
 936   fprintf(stdout, "\n\tNumber of Rows : %d\n", p->num_rows);
 937   fprintf(stdout, "\n\tNumber of Columns : %d\n", p->num_columns);
 938   switch( p->shape_flag )
 939   {
 940   case TEL_SHAPE_UNKNOWN:
 941     fprintf( stdout, "\t\tShape Flag : UNKNOWN\n" );
 942     break;
 943
 944   case TEL_SHAPE_COMPLEX:
 945     fprintf( stdout, "\t\tShape Flag : COMPLEX\n" );
 946     break;
 947
 948   case TEL_SHAPE_CONCAVE:
 949     fprintf( stdout, "\t\tShape Flag : CONCAVE\n" );
 950     break;
 951
 952   case TEL_SHAPE_CONVEX:
 953     fprintf( stdout, "\t\tShape Flag : CONVEX\n" );
 954     break;
 955
 956   }
 957   switch( p->facet_flag )
 958   {
 959   case TEL_FA_NONE:
 960     if( p->fcolours )
 961       fprintf( stdout, "\t\tFacet Flag : COLOUR\n" );
 962     else
 963       fprintf( stdout, "\t\tFacet Flag : NONE\n" );
 964     break;
 965
 966   case TEL_FA_NORMAL:
 967     if( p->fcolours )
 968       fprintf( stdout, "\t\tFacet Flag : COLOURNORMAL\n" );
 969     else
 970       fprintf( stdout, "\t\tFacet Flag : NORMAL\n" );
 971     break;
 972   }
 973
 974   switch( p->vertex_flag )
 975   {
 976   case TEL_VT_NONE:
 977     if( p->vcolours )
 978       fprintf( stdout, "\t\tVertex Flag : COLOUR\n" );
 979     else
 980       fprintf( stdout, "\t\tVertex Flag : NONE\n" );
 981     break;
 982
 983   case TEL_VT_NORMAL:
 984     if( p->vcolours )
 985       fprintf( stdout, "\t\tVertex Flag : COLOURNORMAL\n" );
 986     else
 987       fprintf( stdout, "\t\tVertex Flag : NORMAL\n" );
 988     break;
 989   }
 990   if( p->fnormals )
 991   {
 992     fprintf( stdout, "\n\t\tFacet Normals : " );
 993     for( i = 0; i < (p->num_rows * p->num_columns); i++ )
 994       fprintf( stdout, "\n\t\t v[%d] = %g %g %g", i,
 995       p->fnormals[i].xyz[0],
 996       p->fnormals[i].xyz[1],
 997       p->fnormals[i].xyz[2] );
 998   }
 999   else
1000     fprintf( stdout, "\n\t\tFacet Normals not specified\n" );
1001
1002   if( p->fcolours )
1003   {
1004     fprintf( stdout, "\n\t\tFacet Colours : " );
1005     for( i = 0; i < (p->num_rows * p->num_columns+1); i++ )
1006       fprintf( stdout, "\n\t\t v[%d] = %g %g %g", i,
1007       p->fcolours[i].rgb[0],
1008       p->fcolours[i].rgb[1],
1009       p->fcolours[i].rgb[2] );    }
1010   else
1011     fprintf( stdout, "\n\t\tFacet Colours not specified\n" );
1012   if( p->vertices )
1013   {
1014     fprintf( stdout, "\n\t\tVertices : " );
1015     for( i = 0; i < (p->num_rows+1)*(p->num_columns+1); i++ )
1016       fprintf( stdout, "\n\t\t v[%d] = %g %g %g", i,
1017       p->vertices[i].xyz[0],
1018       p->vertices[i].xyz[1],
1019       p->vertices[i].xyz[2] );    }
1020
1021   fprintf( stdout, "\n" );
1022   if( p->vcolours )
1023   {
1024     fprintf( stdout, "\n\t\tVertex Colours : " );
1025     for( i = 0; i < (p->num_rows+1)*(p->num_columns+1); i++ )
1026       fprintf( stdout, "\n\t\t v[%d] = %g %g %g", i,
1027       p->vcolours[i].rgb[0],
1028       p->vcolours[i].rgb[1],
1029       p->vcolours[i].rgb[2] );    }
1030   else
1031     fprintf( stdout, "\n\t\tVertex Colours not specified\n" );
1032
1033   if( p->vnormals )
1034   {
1035     fprintf( stdout, "\n\t\tVertex Normals : " );
1036     for( i = 0; i < (p->num_rows+1)*(p->num_columns+1); i++ )
1037       fprintf( stdout, "\n\t\t v[%d] = %g %g %g", i,
1038       p->vnormals[i].xyz[0],
1039       p->vnormals[i].xyz[1],
1040       p->vnormals[i].xyz[2] );    }
1041   else
1042     fprintf( stdout, "\n\t\tVertex Normals not specified\n" );
1043
1044   if (p->vtexturecoord)
1045   {
1046     fprintf(stdout, "\n\t\tTexture Coordinates : ");
1047     for (i=0; i<(p->num_rows+1)*(p->num_columns+1); i++)
1048       fprintf(stdout, "\n\t\t v[%d] = %g %g", i,
1049       p->vtexturecoord[i].xy[0],
1050       p->vtexturecoord[i].xy[1]);
1051   }
1052   else
1053     fprintf( stdout, "\n\t\tTexture Coordinates not specified\n");
1054
1055   fprintf( stdout, "\n" );
1056
1057   return TSuccess;
1058 }
1059
1060 /*----------------------------------------------------------------------*/
1061 #ifdef G003
1062 static void draw_edges (
1063                         tel_qstrip_data              p,
1064                         tel_colour         edge_colour,
1065                         Tint            interior_style,
1066                         Tint                 forceDraw
1067                         )
1068 {
1069 #else
1070 static void draw_edges (
1071                         tel_qstrip_data              p,
1072                         tel_colour         edge_colour,
1073                         Tint            interior_style
1074                         )
1075 {
1076 #endif  /* G003 */
1077   CMN_KEY   k, k1, k2, k3, k4;
1078   Tint      nf, nc, newList = 0;
1079   Tint      edge_type, line_type_preserve;
1080   Tfloat    edge_width, line_width_preserve;
1081   GLboolean texture_on;
1082   tel_point pv;
1083 #ifdef G003
1084   if ( interior_style != TSM_HIDDENLINE && !forceDraw )
1085   {
1086 #else
1087   if ( interior_style != TSM_HIDDENLINE )
1088   {
1089 #endif  /* G003 */
1090     k.id = TelEdgeFlag;
1091     TsmGetAttri ( 1, &k );
1092
1093     if ( k.data.ldata == TOff ) return;
1094
1095   }  /* end if */
1096
1097   pv = p -> vertices;
1098
1099   LightOff ();
1100   texture_on = IsTextureEnabled ();
1101
1102   if ( texture_on ) DisableTexture ();
1103
1104   k1.id = TelPolylineWidth;
1105   k2.id = TelPolylineType;
1106   k3.id = TelEdgeType;
1107   k4.id = TelEdgeWidth;
1108   TsmGetAttri ( 4, &k1, &k2, &k3, &k4 );
1109
1110   line_width_preserve = k1.data.fdata;
1111   line_type_preserve  = k2.data.ldata;
1112   edge_type           = k3.data.ldata;
1113   edge_width          = k4.data.fdata;
1114
1115   nc = p -> num_columns;
1116   nf = p -> num_rows * p->num_columns;
1117
1118   if ( line_width_preserve != edge_width ) {
1119
1120     k.id         = TelPolylineWidth;
1121     k.data.fdata = edge_width;
1122     TsmSetAttri ( 1, &k );
1123
1124   }  /* end if */
1125
1126   if ( line_type_preserve != edge_type ) {
1127
1128     k.id         = TelPolylineType;
1129     k.data.ldata = edge_type;
1130     TsmSetAttri ( 1, &k );
1131
1132   }  /* end if */
1133 #ifdef G003
1134   if ( !forceDraw )
1135 #endif  /* G003 */
1136     draw_line_strip ( p, edge_colour, nf, nc );
1137 #ifdef G003
1138   else {
1139 #ifdef BUC60876
1140     if ( !g_fAnimation )
1141       goto doDraw; /* Disable object display list out of animation */
1142 #endif
1143 # ifdef G004
1144     if ( g_fBitmap )
1145       goto doDraw;
1146 # endif  /* G004 */
1147     if ( p -> d.degMode != 2 || p -> d.skipRatio != g_fSkipRatio || !p -> d.dlist ) {
1148
1149       if ( !p -> d.dlist ) p -> d.dlist = glGenLists ( 1 );
1150
1151       p -> d.degMode   = 2;
1152       p -> d.skipRatio = g_fSkipRatio;
1153       glNewList ( p -> d.dlist, GL_COMPILE_AND_EXECUTE );
1154       newList = 1;
1155 doDraw:
1156       glPushAttrib ( GL_DEPTH_BUFFER_BIT );
1157       glDisable ( GL_DEPTH_TEST );
1158
1159       if ( g_fSkipRatio == 0.0 )
1160
1161         draw_line_strip ( p, edge_colour, nf, nc );
1162
1163       else if ( g_fSkipRatio != 1.0 ) {
1164
1165         int i, m1, m2, n1, n2, n3, n4;
1166
1167         set_drawable_items ( p -> d.bDraw, nf );
1168
1169         glColor3fv ( edge_colour -> rgb );
1170
1171         for ( i = 0; i < nf; ++i )
1172
1173           if ( p -> d.bDraw[ i ] ) {
1174
1175             glBegin ( GL_LINE_STRIP );
1176             m1 = i / nc;
1177             m2 = i % nc;
1178             n1 = m1 * ( nc + 1 ) + m2;
1179             n2 = n1 + nc + 1;
1180             n3 = n2 + 1;
1181             n4 = n1 + 1;
1182
1183             glVertex3fv ( p -> vertices[ n1 ].xyz );
1184             glVertex3fv ( p -> vertices[ n2 ].xyz );
1185             glVertex3fv ( p -> vertices[ n3 ].xyz );
1186             glVertex3fv ( p -> vertices[ n4 ].xyz );
1187             glVertex3fv ( p -> vertices[ n1 ].xyz );
1188             glEnd();
1189
1190           }  /* end if */
1191
1192       }  /* end if */
1193
1194       glPopAttrib ();
1195       if ( newList ) glEndList ();
1196
1197     } else glCallList ( p -> d.dlist );
1198
1199   }  /* end else */
1200 #endif  /* G003 */
1201   if ( line_width_preserve != edge_width ) {
1202
1203     k.id         = TelPolylineWidth;
1204     k.data.fdata = line_width_preserve;
1205     TsmSetAttri ( 1, &k );
1206
1207   }  /* end if */
1208
1209   if ( line_type_preserve != edge_type ) {
1210
1211     k.id         = TelPolylineType;
1212     k.data.ldata = line_type_preserve;
1213     TsmSetAttri ( 1, &k );
1214
1215   }  /* end if */
1216
1217   if ( texture_on ) EnableTexture ();
1218
1219 }  /* end draw_edges */
1220
1221 static void draw_line_strip ( tel_qstrip_data p, tel_colour c, Tint nf, Tint nc ) {
1222
1223   int i, m1, m2, n1, n2, n3, n4;
1224
1225   glColor3fv ( c -> rgb );
1226
1227   for ( i = 0; i < nf; ++i ) {
1228
1229     glBegin ( GL_LINE_STRIP );
1230     m1 = i / nc;
1231     m2 = i % nc;
1232     n1 = m1 * ( nc + 1 ) + m2;
1233     n2 = n1 + nc + 1;
1234     n3 = n2 + 1;
1235     n4 = n1 + 1;
1236
1237     glVertex3fv ( p -> vertices[ n1 ].xyz );
1238     glVertex3fv ( p -> vertices[ n2 ].xyz );
1239     glVertex3fv ( p -> vertices[ n3 ].xyz );
1240     glVertex3fv ( p -> vertices[ n4 ].xyz );
1241     glVertex3fv ( p -> vertices[ n1 ].xyz );
1242     glEnd();
1243
1244   }  /* end for */
1245
1246 }  /* end draw_line_strip */
1247 /*----------------------------------------------------------------------*/
1248
1249 static TStatus
1250 QuadrangleInquire( TSM_ELEM_DATA data, Tint n, cmn_key *k )
1251 {
1252   Tint             i, j;
1253   tel_qstrip_data  d;
1254   Tint             size_reqd=0;
1255   TStatus          status = TSuccess;
1256   Tchar            *cur_ptr = 0;
1257   Tint             nf, nv;
1258
1259   d = (tel_qstrip_data)data.pdata;
1260   nf = d->num_rows * d->num_columns;
1261   nv = ( d->num_rows + 1 ) * ( d->num_columns + 1 );
1262
1263   if( d->fcolours )
1264     size_reqd += ( nf * sizeof( TEL_COLOUR ) );
1265
1266   if( d->facet_flag == TEL_FA_NORMAL )
1267     size_reqd += ( nf * sizeof( TEL_POINT ) );
1268
1269   size_reqd += ( nv * sizeof( TEL_POINT ) );
1270
1271   if( d->vcolours )
1272     size_reqd += ( nv * sizeof( TEL_COLOUR ) );
1273
1274   if( d->vertex_flag == TEL_VT_NORMAL )
1275     size_reqd += ( nv * sizeof( TEL_POINT ) );
1276
1277   for( i = 0; i < n; i++ )
1278   {
1279     switch( k[i]->id )
1280     {
1281     case INQ_GET_SIZE_ID:
1282       {
1283         k[i]->data.ldata = size_reqd;
1284         break;
1285       }
1286
1287     case INQ_GET_CONTENT_ID:
1288       {
1289         TEL_INQ_CONTENT *c;
1290         Teldata         *w;
1291
1292         c = (tel_inq_content)k[i]->data.pdata;
1293         c->act_size = size_reqd;
1294         w = c->data;
1295
1296         cur_ptr = c->buf;
1297         w->quadmesh3data.shpflag = d->shape_flag;
1298         w->quadmesh3data.dim.x_dim = d->num_rows;
1299         w->quadmesh3data.dim.y_dim = d->num_columns;
1300
1301         if( c->size >= size_reqd )
1302         {
1303           if( d->facet_flag == TEL_FA_NORMAL )
1304           {
1305             if( d->fcolours )
1306             {
1307               w->quadmesh3data.fctflag = TEL_FAFLAG_COLOURNORMAL;
1308               w->quadmesh3data.gnormals = (tel_point)(c->buf);
1309               for( j = 0; j < nf; j++ )
1310               {
1311                 w->quadmesh3data.gnormals[j] = d->fnormals[j];
1312               }
1313               cur_ptr += ( nf * sizeof( TEL_POINT ) );
1314
1315               w->quadmesh3data.facet_colour_vals =
1316                 (tel_colour)(cur_ptr);
1317               for( j = 0; j < nf; j++ )
1318               {
1319                 w->quadmesh3data.facet_colour_vals[j] =
1320                   d->fcolours[j];
1321               }
1322               cur_ptr += ( nf * sizeof( TEL_COLOUR ) );
1323             }
1324             else
1325             {
1326               w->quadmesh3data.fctflag = TEL_FAFLAG_NORMAL;
1327               w->quadmesh3data.facet_colour_vals = 0;
1328               w->quadmesh3data.gnormals = (tel_point)(c->buf);
1329               for( j = 0; j < nf; j++ )
1330               {
1331                 w->quadmesh3data.gnormals[j] = d->fnormals[j];
1332               }
1333               cur_ptr += ( nf * sizeof( TEL_POINT ) );
1334             }
1335           }
1336           else
1337           {
1338             w->quadmesh3data.gnormals = 0;
1339             if( d->fcolours )
1340             {
1341               w->quadmesh3data.fctflag = TEL_FAFLAG_COLOUR;
1342               w->quadmesh3data.facet_colour_vals =
1343                 (tel_colour)(c->buf );
1344               for( j = 0; j < nf; j++ )
1345               {
1346                 w->quadmesh3data.facet_colour_vals[j] =
1347                   d->fcolours[j];
1348               }
1349               cur_ptr += ( nf * sizeof( TEL_COLOUR ) );
1350             }
1351             else
1352             {
1353               w->quadmesh3data.fctflag = TEL_FAFLAG_NONE;
1354               w->quadmesh3data.facet_colour_vals = 0;
1355             }
1356           }
1357
1358           w->quadmesh3data.points = (tel_point)cur_ptr;
1359           for( j = 0; j < nv; j++ )
1360           {
1361             w->quadmesh3data.points[j] = d->vertices[j];
1362           }
1363           cur_ptr += ( nv * sizeof( TEL_POINT ) );
1364
1365           if( d->vertex_flag == TEL_VT_NORMAL )
1366           {
1367             if( d->vcolours )
1368             {
1369               w->quadmesh3data.vrtflag = TEL_VTFLAG_COLOURNORMAL;
1370               w->quadmesh3data.vnormals = (tel_point)(cur_ptr);
1371               for( j = 0; j < nv; j++ )
1372               {
1373                 w->quadmesh3data.vnormals[j] = d->vnormals[i];
1374               }
1375               cur_ptr += ( nv * sizeof( TEL_POINT ) );
1376
1377               w->quadmesh3data.colours = (tel_colour)(cur_ptr);
1378
1379               for( j = 0; j < nv; j++ )
1380               {
1381                 w->quadmesh3data.colours[j] = d->vcolours[i];
1382               }
1383             }
1384             else
1385             {
1386               w->quadmesh3data.vrtflag = TEL_VTFLAG_NORMAL;
1387               w->quadmesh3data.colours = 0;
1388               w->quadmesh3data.vnormals = (tel_point)(cur_ptr);
1389
1390               for( j = 0; j < nv; j++ )
1391               {
1392                 w->quadmesh3data.vnormals[j] = d->vnormals[i];
1393               }
1394             }
1395           }
1396           else
1397           {
1398             w->quadmesh3data.vnormals = 0;
1399             if( d->vcolours )
1400             {
1401               w->quadmesh3data.vrtflag = TEL_VTFLAG_COLOUR;
1402               w->quadmesh3data.colours = (tel_colour)(cur_ptr);
1403               for( j = 0; j < nv; j++ )
1404               {
1405                 w->quadmesh3data.colours[j] = d->vcolours[i];
1406               }
1407             }
1408             else
1409             {
1410               w->quadmesh3data.vrtflag = TEL_VTFLAG_NONE;
1411               w->quadmesh3data.colours = 0;
1412             }
1413           }
1414
1415           status = TSuccess;
1416         }
1417         else
1418           status = TFailure;
1419         break;
1420       }
1421     }
1422   }
1423   return status;
1424 }
1425
1426 /*----------------------------------------------------------------------*/