0022819: Redesign of OpenGl driver
[occt.git] / src / OpenGl / OpenGl_subrs.cxx
1 /***********************************************************************
2
3 FONCTION :
4 ----------
5 File OpenGl_subrs :
6
7
8 REMARQUES:
9 ---------- 
10
11
12 HISTORIQUE DES MODIFICATIONS   :
13 --------------------------------
14 xx-xx-xx : xxx ; Creation.
15 11-03-96 : FMN ; Correction warning compilation
16 01-04-96 : CAL ; Integration MINSK portage WNT
17 26-04-96 : FMN ; Correction warning compilation
18 10-06-96 : CAL ; Transparence dans call_subr_set_refl_props
19 17-07-96 : CAL ; Suppression de CALL_PHIGS_ELEM_HLHSR_ID
20 07-10-96 : FMN ; Suppression code inutile
21 21-08-97 : PCT ; ajout deuxieme passe pour les textures
22 23-12-97 : FMN ; Suppression TelBackInteriorStyle, TelBackInteriorStyleIndex
23 29-12-97 : FMN ; Ajout cas 4 pour call_subr_polygon_indices()
24 30-12-97 : FMN ; CTS18312: Correction back material
25 08-04-98 : FGU ; Ajout emission
26 30-11-98 : FMN ; S3819 : Textes toujours visibles
27 16-06-2000 : ATS,GG : G005 : Group of functions: call_subr_parray
28
29 ************************************************************************/
30
31 #define IMP190602       /* GG Avoid memory leaks after creating a polyline
32 //                      with vertex colors primitive.
33 //                      Thanks to Ivan Fontaine (SAMTECH) for this improvment
34 */
35
36 /*----------------------------------------------------------------------*/
37 /*
38 * Includes
39 */ 
40
41
42 #include <OpenGl_tgl_all.hxx>
43
44 #include <stdio.h>
45 #include <stddef.h>
46 #include <stdlib.h>
47
48 #include <InterfaceGraphic_Graphic3d.hxx>
49
50 #include <OpenGl_cmn_varargs.hxx>
51 #include <OpenGl_tsm.hxx>
52 #include <OpenGl_tsm_ws.hxx>
53 #include <OpenGl_telem.hxx>
54 #include <OpenGl_tgl_funcs.hxx>
55 #include <OpenGl_tgl_subrs.hxx>
56 #include <OpenGl_telem_inquire.hxx>
57 #include <OpenGl_telem_view.hxx>
58 #include <OpenGl_tgl_elems.hxx>
59 #include <OpenGl_Memory.hxx>
60
61 void
62 call_subr_set_line_colr( Tfloat  r, Tfloat  g, Tfloat  b )
63 {
64   CMN_KEY  key;
65   TEL_COLOUR  col;
66
67   col.rgb[0] = r,
68   col.rgb[1] = g,
69   col.rgb[2] = b;
70   key.data.pdata = &col;
71   TsmAddToStructure( TelPolylineColour, 1, &key );
72
73   return;
74 }
75
76
77 void
78 call_subr_polyline( CALL_DEF_LISTPOINTS * alpoints )
79 {
80   CMN_KEY  key[4];
81   cmn_key  kp[4];
82
83   kp[0] = &key[0], kp[1] = &key[1], kp[2] = &key[2], kp[3] = &key[3];
84   key[0].id = NUM_LINES_ID;
85   key[0].data.ldata = 1;
86   key[1].id = VERTICES_ID;
87   key[1].data.pdata = alpoints->UPoints.Points;
88   key[2].id = BOUNDS_DATA_ID;
89   key[2].data.pdata = &alpoints->NbPoints;
90   key[3].id = NUM_VERTICES_ID;
91   key[3].data.ldata = alpoints->NbPoints;
92   TsmAddToStructure( TelPolyline, -4, kp );
93
94   return;
95 }
96
97
98 void
99 call_subr_polyline_data( CALL_DEF_LISTPOINTS * alpoints )
100 {
101   CMN_KEY  key[5];
102   cmn_key  kp[5];
103   tel_point points;
104   tel_colour col;
105   register   Tint  i;
106
107   if( alpoints->TypePoints != 3 )
108     return;  /* Coordinates and Vertex Colour not Specified */
109
110   points = new TEL_POINT[alpoints->NbPoints];
111   if( !points )
112     return;
113
114   col = new TEL_COLOUR[alpoints->NbPoints];
115   if( !col )
116   {
117     delete[] points;
118     return;
119   }
120
121   for( i = 0; i < alpoints->NbPoints; i++ )
122   {
123     points[i].xyz[0] = alpoints->UPoints.PointsC[i].Point.x;
124     points[i].xyz[1] = alpoints->UPoints.PointsC[i].Point.y;
125     points[i].xyz[2] = alpoints->UPoints.PointsC[i].Point.z;
126     col[i].rgb[0] = alpoints->UPoints.PointsC[i].Color.r;
127     col[i].rgb[1] = alpoints->UPoints.PointsC[i].Color.g;
128     col[i].rgb[2] = alpoints->UPoints.PointsC[i].Color.b;
129   }
130
131   key[0].id = NUM_LINES_ID;
132   key[0].data.ldata = 1;
133   key[1].id = VERTEX_COLOUR_VALS_ID;
134   key[1].data.pdata = col;
135   key[2].id = VERTICES_ID;
136   key[2].data.pdata = points;
137   key[3].id = BOUNDS_DATA_ID;
138   key[3].data.pdata = &alpoints->NbPoints;
139   key[4].id = NUM_VERTICES_ID;
140   key[4].data.ldata = alpoints->NbPoints;
141
142   for( i = 0; i < 5; i++ )
143     kp[i] = &key[i];
144
145   TsmAddToStructure( TelPolyline, -5, kp );
146
147 #ifdef IMP190602
148   delete[] points;
149   delete col;
150 #endif
151
152   return;
153 }
154
155
156
157 void
158 call_subr_remnameset( Tint num, Tint  *ns )
159 {
160   CMN_KEY  key;
161
162   key.id = num;
163   key.data.pdata = ns;
164   TsmAddToStructure( TelRemoveNameset, 1, &key );
165
166   return;
167 }
168
169
170 void
171 call_subr_addnameset( Tint num, Tint  *ns )
172 {
173   CMN_KEY  key;
174
175   key.id = num;
176   key.data.pdata = ns;
177   TsmAddToStructure( TelAddNameset, 1, &key );
178
179   return;
180 }
181
182 void
183 call_subr_set_back_int_colr( Tfloat r, Tfloat g, Tfloat b, Tfloat a )
184 {
185   CMN_KEY  key;
186   TEL_COLOUR  col;
187
188   col.rgb[0] = r,
189     col.rgb[1] = g,
190     col.rgb[2] = b;
191   key.data.pdata = &col;
192   TsmAddToStructure( TelBackInteriorColour, 1, &key );
193
194   return;
195 }
196
197
198
199 void
200 call_subr_set_int_colr( Tfloat r, Tfloat g, Tfloat b, Tfloat a )
201 {
202   CMN_KEY  key;
203   TEL_COLOUR  col;
204
205   col.rgb[0] = r,
206     col.rgb[1] = g,
207     col.rgb[2] = b;
208   key.data.pdata = &col;
209   TsmAddToStructure( TelInteriorColour, 1, &key );
210
211   return;
212 }
213
214 void
215 call_subr_set_edge_colr( Tfloat r, Tfloat g, Tfloat b )
216 {
217   CMN_KEY  key;
218   TEL_COLOUR  col;
219
220   col.rgb[0] = r,
221     col.rgb[1] = g,
222     col.rgb[2] = b;
223   key.data.pdata = &col;
224   TsmAddToStructure( TelEdgeColour, 1, &key );
225
226   return;
227 }
228
229
230 void
231 call_subr_set_refl_props( CALL_DEF_MATERIAL * material, Tint tag )
232 {
233   CMN_KEY  key;
234   TEL_SURF_PROP  surface;
235
236   /* Par defaut tout a 0 */
237   surface.amb  = ( float )0.0;
238   surface.diff = ( float )0.0;
239   surface.spec = ( float )0.0;
240   surface.emsv = ( float )0.0;
241   surface.isamb    = (int)0;
242   surface.isdiff   = (int)0;
243   surface.isspec   = (int)0;
244   surface.isemsv   = (int)0;
245   surface.isphysic = (int)0;
246
247   /* Cas par cas pour l evaluation */
248   if( material->IsAmbient )
249   {
250     surface.amb  = material->Ambient;
251     surface.isamb = 1;
252   }
253   if( material->IsDiffuse )
254   {
255     surface.diff = material->Diffuse;
256     surface.isdiff = 1;
257   }
258   if( material->IsSpecular )
259   {
260     surface.spec = material->Specular;
261     surface.isspec = 1;
262   }
263   if( material->IsEmission )
264   {
265     surface.emsv = material->Emission;
266     surface.isemsv = 1;
267   }
268
269   /* type de materiel */
270   if( material->IsPhysic )
271     surface.isphysic = 1;
272
273   /* Couleur du materiel */
274
275   /* Couleur eclairage ambient */
276   surface.ambcol.rgb[0] = material->ColorAmb.r;
277   surface.ambcol.rgb[1] = material->ColorAmb.g;
278   surface.ambcol.rgb[2] = material->ColorAmb.b;
279
280   /* Couleur eclairage diffus */
281   surface.difcol.rgb[0] = material->ColorDif.r;
282   surface.difcol.rgb[1] = material->ColorDif.g;
283   surface.difcol.rgb[2] = material->ColorDif.b;
284
285   /* Couleur eclairage speculaire */
286   surface.speccol.rgb[0] = material->ColorSpec.r;
287   surface.speccol.rgb[1] = material->ColorSpec.g;
288   surface.speccol.rgb[2] = material->ColorSpec.b;
289
290   /* Couleur d emission */
291   surface.emscol.rgb[0] = material->ColorEms.r;
292   surface.emscol.rgb[1] = material->ColorEms.g;
293   surface.emscol.rgb[2] = material->ColorEms.b;
294
295   surface.shine = ( float )128 * material->Shininess;
296   surface.env_reflexion = material->EnvReflexion;
297
298   /* Dans la couche C++ :
299   * prop->trans = 0. => opaque
300   * prop->trans = 1. => transparent
301   * en OpenGl c'est le contraire.
302   */
303   surface.trans = 1.0F - material->Transparency;
304
305   key.data.pdata = &surface;
306   TsmAddToStructure( tag ? TelBackSurfaceAreaProperties :
307   TelSurfaceAreaProperties, 1, &key );
308   return;
309 }
310
311 void
312 call_subr_set_marker_colr( Tfloat r, Tfloat g, Tfloat b )
313 {
314   CMN_KEY  key;
315   TEL_COLOUR  col;
316
317   col.rgb[0] = r,
318     col.rgb[1] = g,
319     col.rgb[2] = b;
320   key.data.pdata = &col;
321   TsmAddToStructure( TelPolymarkerColour, 1, &key );
322
323   return;
324 }
325
326
327 TStatus
328 call_subr_get_exec_struct( Tint afather, Tint ason, Tint  *ind )
329 {
330   tsm_node    node;
331   Tint        i, num;
332
333   if( TsmGetStructure( afather, &num, &node ) == TSuccess )
334   {
335     for( i = 0; i < num; i++, node = node->next )
336     {
337       if( node->elem.el == TelExecuteStructure )
338         if( node->elem.data.ldata == ason )
339         {
340           *ind = (i+1);
341           return TSuccess;
342         }
343     }
344   }
345   return TFailure;
346 }
347
348
349 void
350 call_subr_marker( CALL_DEF_MARKER * amarker )
351 {
352   CMN_KEY  key;
353   TEL_POINT  pt;
354
355   key.id = 1;
356   pt.xyz[0] = amarker->x,
357     pt.xyz[1] = amarker->y,
358     pt.xyz[2] = amarker->z;
359   key.data.pdata = &pt;
360   TsmAddToStructure( TelMarkerSet, 1, &key );
361
362   return;
363 }
364
365
366 void
367 call_subr_marker_set( CALL_DEF_LISTMARKERS * almarkers )
368 {
369   CMN_KEY  key;
370
371   key.id = almarkers->NbMarkers;
372   key.data.pdata = almarkers->Markers;
373   TsmAddToStructure( TelMarkerSet, 1, &key );
374
375   return;
376 }
377
378
379 void
380 call_subr_polygon( CALL_DEF_FACET * afacet )
381 {
382   CMN_KEY      k[3];
383
384   k[0].id = NUM_VERTICES_ID;
385   k[0].data.ldata = afacet->NbPoints;
386
387   k[1].id = SHAPE_FLAG_ID;
388   k[1].data.ldata = TEL_SHAPE_UNKNOWN;
389
390   switch (afacet->TypeFacet) {
391         case 0 : /* TOP_UNKNOWN */
392           k[1].data.ldata = TEL_SHAPE_UNKNOWN;
393           break;
394         case 1 : /* TOP_COMPLEX */
395           k[1].data.ldata = TEL_SHAPE_COMPLEX;
396           break;
397         case 2 : /* TOP_CONCAVE */
398           k[1].data.ldata = TEL_SHAPE_CONCAVE;
399           break;
400         case 3 : /* TOP_CONVEX */
401           k[1].data.ldata = TEL_SHAPE_CONVEX;
402           break;
403   }
404
405 #if defined(__sgi) || defined(IRIX)
406   /* Pb avec le tesselator sgi */
407   k[1].data.ldata = TEL_SHAPE_CONVEX;
408 #endif
409
410   k[2].id = VERTICES_ID;
411   k[2].data.pdata = afacet->UPoints.Points;
412
413   TsmAddToStructure( TelPolygon, 3, &k[0], &k[1], &k[2] );
414
415   return;
416 }
417
418
419 void
420 call_subr_polygon_data( CALL_DEF_FACET * afacet )
421 {
422   CMN_KEY      k[10];
423   cmn_key      kp[10];
424   Tint         nk = 0, i;
425   TEL_COLOUR   col;
426   void        *npt;
427   TEL_POINT   *pts=0, *ptn=0;
428   TEL_TEXTURE_COORD *ptt=0;
429
430   k[nk].id = NUM_VERTICES_ID;
431   k[nk].data.ldata = afacet->NbPoints;
432   nk++;
433
434   if( afacet->ColorIsDefined )
435   {
436     col.rgb[0] = afacet->Color.r;
437     col.rgb[1] = afacet->Color.g;
438     col.rgb[2] = afacet->Color.b;
439
440     k[nk].id = FACET_COLOUR_VALS_ID;
441     k[nk].data.pdata = &col;
442     nk++;
443   }
444
445   if( afacet->NormalIsDefined )
446   {
447     npt = &afacet->Normal;
448     k[nk].id = FNORMALS_ID;
449     k[nk].data.pdata = npt;
450     nk++;
451   }
452
453   switch (afacet->TypePoints)
454   {
455   case 1:
456     {
457       k[nk].id = SHAPE_FLAG_ID;
458       k[nk].data.ldata = TEL_SHAPE_UNKNOWN;
459       switch (afacet->TypeFacet) {
460   case 0 : /* TOP_UNKNOWN */
461     k[nk].data.ldata = TEL_SHAPE_UNKNOWN;
462     break;
463   case 1 : /* TOP_COMPLEX */
464     k[nk].data.ldata = TEL_SHAPE_COMPLEX;
465     break;
466   case 2 : /* TOP_CONCAVE */
467     k[nk].data.ldata = TEL_SHAPE_CONCAVE;
468     break;
469   case 3 : /* TOP_CONVEX */
470     k[nk].data.ldata = TEL_SHAPE_CONVEX;
471     break;
472       }
473 #if defined(__sgi) || defined(IRIX)
474       /* Pb avec le tesselator sgi */
475       k[nk].data.ldata = TEL_SHAPE_CONVEX;
476 #endif
477       nk++;
478       k[nk].id = VERTICES_ID;
479       k[nk].data.pdata = afacet->UPoints.Points;
480       nk++;
481       break;
482     }
483   case 2:
484     {
485       Tint i;
486
487       k[nk].id = SHAPE_FLAG_ID;
488       k[nk].data.ldata = TEL_SHAPE_UNKNOWN;
489       switch (afacet->TypeFacet) {
490   case 0 : /* TOP_UNKNOWN */
491     k[nk].data.ldata = TEL_SHAPE_UNKNOWN;
492     break;
493   case 1 : /* TOP_COMPLEX */
494     k[nk].data.ldata = TEL_SHAPE_COMPLEX;
495     break;
496   case 2 : /* TOP_CONCAVE */
497     k[nk].data.ldata = TEL_SHAPE_CONCAVE;
498     break;
499   case 3 : /* TOP_CONVEX */
500     k[nk].data.ldata = TEL_SHAPE_CONVEX;
501     break;
502       }
503 #if defined(__sgi) || defined(IRIX)
504       /* Pb avec le tesselator sgi */
505       k[nk].data.ldata = TEL_SHAPE_CONVEX;
506 #endif
507       nk++;
508       //cmn_memreserve( pts, afacet->NbPoints, 0 );
509       pts = new TEL_POINT[afacet->NbPoints];
510       k[nk].id = VERTICES_ID;
511       k[nk].data.pdata = pts;
512       nk++;
513       //cmn_memreserve( ptn, afacet->NbPoints, 0 );
514       ptn = new TEL_POINT[afacet->NbPoints];
515       k[nk].id = VNORMALS_ID;
516       k[nk].data.pdata = ptn;
517       nk++;
518       for( i = 0; i < afacet->NbPoints; i++ )
519       {
520         pts[i].xyz[0] = afacet->UPoints.PointsN[i].Point.x;
521         pts[i].xyz[1] = afacet->UPoints.PointsN[i].Point.y;
522         pts[i].xyz[2] = afacet->UPoints.PointsN[i].Point.z;
523
524         ptn[i].xyz[0] = afacet->UPoints.PointsN[i].Normal.dx;
525         ptn[i].xyz[1] = afacet->UPoints.PointsN[i].Normal.dy;
526         ptn[i].xyz[2] = afacet->UPoints.PointsN[i].Normal.dz;
527       }
528       break;
529     }
530   case 5:
531     {
532       Tint i;
533
534       k[nk].id = SHAPE_FLAG_ID;
535       k[nk].data.ldata = TEL_SHAPE_UNKNOWN;
536       switch (afacet->TypeFacet) {
537   case 0 : /* TOP_UNKNOWN */
538     k[nk].data.ldata = TEL_SHAPE_UNKNOWN;
539     break;
540   case 1 : /* TOP_COMPLEX */
541     k[nk].data.ldata = TEL_SHAPE_COMPLEX;
542     break;
543   case 2 : /* TOP_CONCAVE */
544     k[nk].data.ldata = TEL_SHAPE_CONCAVE;
545     break;
546   case 3 : /* TOP_CONVEX */
547     k[nk].data.ldata = TEL_SHAPE_CONVEX;
548     break;
549       }
550 #if defined(__sgi) || defined(IRIX)
551       /* Pb avec le tesselator sgi */
552       k[nk].data.ldata = TEL_SHAPE_CONVEX;
553 #endif
554       nk++;
555       //cmn_memreserve( pts, afacet->NbPoints, 0 );
556       pts = new TEL_POINT[afacet->NbPoints];
557       k[nk].id = VERTICES_ID;
558       k[nk].data.pdata = pts;
559       nk++;
560       //cmn_memreserve( ptn, afacet->NbPoints, 0 );
561       ptn = new TEL_POINT[afacet->NbPoints];
562       k[nk].id = VNORMALS_ID;
563       k[nk].data.pdata = ptn;
564       nk++;
565       //cmn_memreserve( ptt, afacet->NbPoints, 0 );
566       ptt = new TEL_TEXTURE_COORD[afacet->NbPoints];
567       k[nk].id = VTEXTURECOORD_ID;
568       k[nk].data.pdata = ptt;
569       nk++;
570       for( i = 0; i < afacet->NbPoints; i++ )
571       {
572         pts[i].xyz[0] = afacet->UPoints.PointsNT[i].Point.x;
573         pts[i].xyz[1] = afacet->UPoints.PointsNT[i].Point.y;
574         pts[i].xyz[2] = afacet->UPoints.PointsNT[i].Point.z;
575
576         ptn[i].xyz[0] = afacet->UPoints.PointsNT[i].Normal.dx;
577         ptn[i].xyz[1] = afacet->UPoints.PointsNT[i].Normal.dy;
578         ptn[i].xyz[2] = afacet->UPoints.PointsNT[i].Normal.dz;
579
580         ptt[i].xy[0] = afacet->UPoints.PointsNT[i].TextureCoord.tx;
581         ptt[i].xy[1] = afacet->UPoints.PointsNT[i].TextureCoord.ty;
582       }
583       break;
584     }
585   }
586
587   for( i = 0; i < nk; i++ )
588     kp[i] = &k[i];
589
590   TsmAddToStructure( TelPolygon, -nk, kp );
591
592   if( pts )
593   {
594     //cmn_freemem( pts );
595     delete[] pts;
596     //cmn_freemem( ptn );
597     delete[] ptn;
598     //cmn_freemem( ptt );
599     delete[] ptt;
600   }
601
602   return;
603 }
604
605
606 void
607 call_subr_polygon_indices( CALL_DEF_LISTPOINTS * alpoints,
608                           CALL_DEF_LISTEDGES * aledges,
609                           CALL_DEF_LISTINTEGERS * albounds )
610 {
611   CMN_KEY      k[10];
612   cmn_key      kp[10];
613   Tint         nk = 0, i;
614   tel_point    varr=0;
615   tel_point    narr=0;
616   tel_colour   carr=0;
617   tel_texture_coord tarr=0;
618   Tint        *edgvis=NULL, *bounds, *indices;
619   Tint         num_indices;
620
621   k[nk].id = NUM_VERTICES_ID;
622   k[nk].data.ldata = alpoints->NbPoints;
623   nk++;
624
625   k[nk].id = NUM_FACETS_ID;
626   k[nk].data.ldata = albounds->NbIntegers;
627   nk++;
628
629   k[nk].id = SHAPE_FLAG_ID;
630   k[nk].data.ldata = TEL_SHAPE_UNKNOWN;
631   nk++;
632
633   if( aledges->NbEdges )
634   {
635     //cmn_memreserve( edgvis, aledges->NbEdges, 0 );
636     edgvis = new Tint[aledges->NbEdges];
637     if( !edgvis )
638       return;
639     for( i = 0; i < aledges->NbEdges; i++ )
640       edgvis[i] = aledges->Edges[i].Type ? CALL_PHIGS_EDGE_OFF :
641     CALL_PHIGS_EDGE_ON;
642     k[nk].id = EDGE_DATA_ID;
643     k[nk].data.pdata = edgvis;
644     nk++;
645   }
646
647   bounds = new Tint[albounds->NbIntegers];
648   if( !bounds )
649   {
650     delete[] edgvis;
651     return;
652   }
653   for( i = 0, num_indices = 0; i < albounds->NbIntegers; i++ )
654   {
655     bounds[i] = albounds->Integers[i];
656     num_indices += bounds[i];
657   }
658   k[nk].id = BOUNDS_DATA_ID;
659   k[nk].data.pdata = bounds;
660   nk++;
661
662   indices = new Tint[num_indices];
663   if( !indices )
664   {
665     delete[] edgvis;
666     delete[] bounds;
667     return;
668   }
669   for( i = 0; i < num_indices; i++ )
670     indices[i] = aledges->Edges[i].Index1;
671   k[nk].id = CONNECTIVITY_ID;
672   k[nk].data.pdata = indices;
673   nk++;
674
675   switch( alpoints->TypePoints )
676   {
677   case 1 : /* Vertex Coordinates Specified */
678     varr = new TEL_POINT[alpoints->NbPoints];
679     if( !varr )
680     {
681       delete[] edgvis;
682       delete[] bounds;
683       delete[] indices;
684       return;
685     }
686     for( i = 0; i < alpoints->NbPoints; i++ )
687       varr[i].xyz[0] = alpoints->UPoints.Points[i].x,
688       varr[i].xyz[1] = alpoints->UPoints.Points[i].y,
689       varr[i].xyz[2] = alpoints->UPoints.Points[i].z;
690     k[nk].id = VERTICES_ID;
691     k[nk].data.pdata = varr;
692     nk++;
693     break;
694
695   case 2 : /* Coordinates and Vertex Normal Specified */
696     varr = new TEL_POINT[alpoints->NbPoints];
697     if( !varr )
698     {
699       delete[] edgvis;
700       delete[] bounds;
701       delete[] indices;
702       return;
703     }
704     narr = new TEL_POINT[alpoints->NbPoints];
705     if( !narr )
706     {
707       delete[] edgvis;
708       delete[] bounds;
709       delete[] indices;
710       delete[] varr;
711       return;
712     }
713     for( i = 0; i < alpoints->NbPoints; i++ )
714     {
715       varr[i].xyz[0] = alpoints->UPoints.PointsN[i].Point.x,
716         varr[i].xyz[1] = alpoints->UPoints.PointsN[i].Point.y,
717         varr[i].xyz[2] = alpoints->UPoints.PointsN[i].Point.z;
718
719       narr[i].xyz[0] = alpoints->UPoints.PointsN[i].Normal.dx,
720         narr[i].xyz[1] = alpoints->UPoints.PointsN[i].Normal.dy,
721         narr[i].xyz[2] = alpoints->UPoints.PointsN[i].Normal.dz;
722     }
723     k[nk].id = VERTICES_ID;
724     k[nk].data.pdata = varr;
725     nk++;
726     k[nk].id = VNORMALS_ID;
727     k[nk].data.pdata = narr;
728     nk++;
729     break;
730
731   case 3 : /* Coordinates and Vertex Colour Specified */
732     varr = new TEL_POINT[alpoints->NbPoints];
733     if( !varr )
734     {
735       delete[] edgvis;
736       delete[] bounds;
737       delete[] indices;
738       return;
739     }
740     carr = new TEL_COLOUR[alpoints->NbPoints];
741     if( !carr )
742     {
743       delete[] edgvis;
744       delete[] bounds;
745       delete[] indices;
746       delete[] varr;
747       return;
748     }
749     for( i = 0; i < alpoints->NbPoints; i++ )
750     {
751       varr[i].xyz[0] = alpoints->UPoints.PointsC[i].Point.x,
752         varr[i].xyz[1] = alpoints->UPoints.PointsC[i].Point.y,
753         varr[i].xyz[2] = alpoints->UPoints.PointsC[i].Point.z;
754
755       carr[i].rgb[0] = alpoints->UPoints.PointsC[i].Color.r,
756         carr[i].rgb[1] = alpoints->UPoints.PointsC[i].Color.g,
757         carr[i].rgb[2] = alpoints->UPoints.PointsC[i].Color.b;
758     }
759     k[nk].id = VERTICES_ID;
760     k[nk].data.pdata = varr;
761     nk++;
762     k[nk].id = VERTEX_COLOUR_VALS_ID;
763     k[nk].data.pdata = carr;
764     nk++;
765     break;
766
767   case 4 : /* Coordinates and Vertex Colour and Vertex Normal Specified */
768     varr = new TEL_POINT[alpoints->NbPoints];
769     if( !varr )
770     {
771       delete[] edgvis;
772       delete[] bounds;
773       delete[] indices;
774       return;
775     }
776     carr = new TEL_COLOUR[alpoints->NbPoints];
777     if( !carr )
778     {
779       delete[] edgvis;
780       delete[] bounds;
781       delete[] indices;
782       delete[] varr;
783       return;
784     }
785     narr = new TEL_POINT[alpoints->NbPoints];
786     if( !narr )
787     {
788       delete[] edgvis;
789       delete[] bounds;
790       delete[] indices;
791       delete[] varr;
792       delete[] carr;
793       return;
794     }
795     for( i = 0; i < alpoints->NbPoints; i++ )
796     {
797       varr[i].xyz[0] = alpoints->UPoints.PointsNC[i].Point.x,
798         varr[i].xyz[1] = alpoints->UPoints.PointsNC[i].Point.y,
799         varr[i].xyz[2] = alpoints->UPoints.PointsNC[i].Point.z;
800
801       carr[i].rgb[0] = alpoints->UPoints.PointsNC[i].Color.r,
802         carr[i].rgb[1] = alpoints->UPoints.PointsNC[i].Color.g,
803         carr[i].rgb[2] = alpoints->UPoints.PointsNC[i].Color.b;
804
805       narr[i].xyz[0] = alpoints->UPoints.PointsNC[i].Normal.dx,
806         narr[i].xyz[1] = alpoints->UPoints.PointsNC[i].Normal.dy,
807         narr[i].xyz[2] = alpoints->UPoints.PointsNC[i].Normal.dz;
808     }
809     k[nk].id = VERTICES_ID;
810     k[nk].data.pdata = varr;
811     nk++;
812     k[nk].id = VERTEX_COLOUR_VALS_ID;
813     k[nk].data.pdata = carr;
814     nk++;
815     k[nk].id = VNORMALS_ID;
816     k[nk].data.pdata = narr;
817     nk++;
818     break;
819
820   case 5 : /* Coordinates and Vertex Normal and Texture Coordinates specified */
821     varr = new TEL_POINT[alpoints->NbPoints];
822     if( !varr )
823     {
824       delete[] edgvis;
825       delete[] bounds;
826       delete[] indices;
827       return;
828     }
829     narr = new TEL_POINT[alpoints->NbPoints];
830     if( !narr )
831     {
832       delete[] edgvis;
833       delete[] bounds;
834       delete[] indices;
835       delete[] varr;
836       return;
837     }
838     tarr = new TEL_TEXTURE_COORD[alpoints->NbPoints];
839
840     if( !tarr )
841     {
842       delete[] edgvis;
843       delete[] bounds;
844       delete[] indices;
845       delete[] varr;
846       delete[] narr;
847       return;
848     }
849     for( i = 0; i < alpoints->NbPoints; i++ )
850     {
851       varr[i].xyz[0] = alpoints->UPoints.PointsNT[i].Point.x,
852         varr[i].xyz[1] = alpoints->UPoints.PointsNT[i].Point.y,
853         varr[i].xyz[2] = alpoints->UPoints.PointsNT[i].Point.z;
854
855       narr[i].xyz[0] = alpoints->UPoints.PointsNT[i].Normal.dx,
856         narr[i].xyz[1] = alpoints->UPoints.PointsNT[i].Normal.dy,
857         narr[i].xyz[2] = alpoints->UPoints.PointsNT[i].Normal.dz;
858
859       tarr[i].xy[0]  = alpoints->UPoints.PointsNT[i].TextureCoord.tx,
860         tarr[i].xy[1]  = alpoints->UPoints.PointsNT[i].TextureCoord.ty;
861     }
862     k[nk].id = VERTICES_ID;
863     k[nk].data.pdata = varr;
864     nk++;
865     k[nk].id = VNORMALS_ID;
866     k[nk].data.pdata = narr;
867     nk++;
868     k[nk].id = VTEXTURECOORD_ID;
869     k[nk].data.pdata = tarr;
870     nk++;
871     break;
872   }
873
874   for( i = 0; i < nk; i++ )
875     kp[i] = &k[i];
876
877
878   TsmAddToStructure( TelPolygonIndices, -nk, kp );
879
880   delete[] edgvis;
881   delete[] bounds;
882   delete[] indices;
883   delete[] varr;
884   if( tarr )
885     delete[] tarr;
886   if( narr )
887     delete[] narr;
888   if( carr )
889     delete[] carr;
890
891   return;
892 }
893
894
895 void
896 call_subr_polygon_set( CALL_DEF_LISTFACETS * alfacets )
897 {
898   CMN_KEY   key[3];
899   register  Tint  i, j, k;
900
901   Tint  num_bounds, *bounds;
902   tel_point          points;
903
904   num_bounds = alfacets->NbFacets;
905   bounds = new  Tint[num_bounds];
906   if( !bounds )
907     return;
908
909   for( i = 0, j = 0; i < num_bounds; i++ )
910     j += alfacets->LFacets[i].NbPoints;
911
912   points = new TEL_POINT[j];
913   if( !points )
914   {
915     delete[] bounds;
916     return;
917   }
918
919   for( i = 0, k = 0; i < num_bounds; i++ )
920     for( j = 0; j < alfacets->LFacets[i].NbPoints; j++ )
921     {
922       points[k].xyz[0] = alfacets->LFacets[i].UPoints.Points[j].x;
923       points[k].xyz[1] = alfacets->LFacets[i].UPoints.Points[j].y;
924       points[k].xyz[2] = alfacets->LFacets[i].UPoints.Points[j].z;
925       k++;
926     }
927
928     key[0].id = NUM_FACETS_ID;
929     key[0].data.ldata = num_bounds;
930     key[1].id = BOUNDS_DATA_ID;
931     key[1].data.pdata = bounds;
932     key[2].id = VERTICES_ID;
933     key[2].data.pdata = points;
934     TsmAddToStructure( TelPolygonSet, 3, &key[0], &key[1], &key[2] );
935
936     delete[] bounds;
937     delete[] points;
938
939     return;
940 }
941
942
943 void
944 call_subr_quadrangle( CALL_DEF_QUAD * aquad )
945 {
946   CMN_KEY       key[15];
947   cmn_key       kp[15];
948   Tint          nk = 0, i;
949   tel_point     vertices, vnormals=0;
950   tel_texture_coord vtexturecoord=0;
951
952   /* key[nk].id = NUM_ROWS_ID; */
953   key[nk].id = NUM_COLUMNS_ID;
954   key[nk].data.ldata = aquad->SizeRow - 1;
955   nk++;
956   /* key[nk].id = NUM_COLUMNS_ID; */
957   key[nk].id = NUM_ROWS_ID;
958   key[nk].data.ldata = aquad->SizeCol - 1;
959   nk++;
960
961   //cmn_memreserve( vertices, aquad->NbPoints, 0 );
962   vertices = new TEL_POINT[aquad->NbPoints];
963   if( !vertices )
964     return;
965
966   switch( aquad->TypePoints )
967   {
968   case  1: /* Vertex Coordinates Specified */
969     for( i = 0; i < aquad->NbPoints; i++ )
970     {
971       vertices[i].xyz[0] = aquad->UPoints.Points[i].x;
972       vertices[i].xyz[1] = aquad->UPoints.Points[i].y;
973       vertices[i].xyz[2] = aquad->UPoints.Points[i].z;
974     }
975     break;
976
977   case  2: /* Coordinates and Vertex Normal Specified */
978     //cmn_memreserve( vnormals, aquad->NbPoints, 0 );
979     vnormals = new TEL_POINT[aquad->NbPoints];
980     if( !vnormals )
981     {
982       //cmn_freemem( vertices );
983       delete[] vertices;
984       return;
985     }
986     for( i = 0; i < aquad->NbPoints; i++ )
987     {
988       vertices[i].xyz[0] = aquad->UPoints.PointsN[i].Point.x;
989       vertices[i].xyz[1] = aquad->UPoints.PointsN[i].Point.y;
990       vertices[i].xyz[2] = aquad->UPoints.PointsN[i].Point.z;
991       vnormals[i].xyz[0] = aquad->UPoints.PointsN[i].Normal.dx;
992       vnormals[i].xyz[1] = aquad->UPoints.PointsN[i].Normal.dy;
993       vnormals[i].xyz[2] = aquad->UPoints.PointsN[i].Normal.dz;
994     }
995     key[nk].id = VNORMALS_ID;
996     key[nk].data.pdata = vnormals;
997     nk++;
998     break;
999
1000   case  5: /* Coordinates and Vertex Normal and Texture Coordinate Specified */
1001     vnormals = new TEL_POINT[aquad->NbPoints];
1002     if( !vnormals )
1003     {
1004       delete[] vertices;
1005       return;
1006     }
1007     vtexturecoord = new TEL_TEXTURE_COORD[aquad->NbPoints];
1008     if (!vtexturecoord)
1009     {
1010       delete[] vnormals;
1011       delete[] vertices;
1012     }
1013     for( i = 0; i < aquad->NbPoints; i++ )
1014     {
1015       vertices[i].xyz[0] = aquad->UPoints.PointsNT[i].Point.x;
1016       vertices[i].xyz[1] = aquad->UPoints.PointsNT[i].Point.y;
1017       vertices[i].xyz[2] = aquad->UPoints.PointsNT[i].Point.z;
1018       vnormals[i].xyz[0] = aquad->UPoints.PointsNT[i].Normal.dx;
1019       vnormals[i].xyz[1] = aquad->UPoints.PointsNT[i].Normal.dy;
1020       vnormals[i].xyz[2] = aquad->UPoints.PointsNT[i].Normal.dz;
1021       vtexturecoord[i].xy[0] = aquad->UPoints.PointsNT[i].TextureCoord.tx;
1022       vtexturecoord[i].xy[1] = aquad->UPoints.PointsNT[i].TextureCoord.ty;
1023     }
1024     key[nk].id = VNORMALS_ID;
1025     key[nk].data.pdata = vnormals;
1026     nk++;
1027     key[nk].id = VTEXTURECOORD_ID;
1028     key[nk].data.pdata = vtexturecoord;
1029     nk++;
1030     break;
1031   }
1032
1033   key[nk].id = VERTICES_ID;
1034   key[nk].data.pdata = vertices;
1035   nk++;
1036
1037   for( i = 0; i < nk; i++ )
1038     kp[i] = &key[i];
1039
1040   TsmAddToStructure( TelQuadrangle, -nk, kp );
1041
1042   delete[] vertices;
1043   if (vtexturecoord)
1044     delete[] vtexturecoord;
1045   if( vnormals )
1046     delete[] vnormals;
1047
1048   return;
1049 }
1050
1051 void
1052 call_subr_set_text_colr( Tfloat  r, Tfloat  g, Tfloat  b )
1053 {
1054   CMN_KEY  key;
1055   TEL_COLOUR  col;
1056
1057   col.rgb[0] = r,
1058     col.rgb[1] = g,
1059     col.rgb[2] = b;
1060   key.data.pdata = &col;
1061   TsmAddToStructure( TelTextColour, 1, &key );
1062
1063   return;
1064 }
1065
1066 void
1067 call_subr_set_text_colr_subtitle( Tfloat  r, Tfloat  g, Tfloat  b )
1068 {
1069   CMN_KEY  key;
1070   TEL_COLOUR  col;
1071
1072   col.rgb[0] = r,
1073     col.rgb[1] = g,
1074     col.rgb[2] = b;
1075   key.data.pdata = &col;
1076   TsmAddToStructure( TelTextColourSubTitle, 1, &key );
1077
1078   return;
1079 }
1080
1081
1082 void
1083 call_subr_triangle( CALL_DEF_TRIKE * atrike )
1084 {
1085   Tint    i;
1086   tel_point  vertices, vnormals=0;
1087   tel_texture_coord vtexturecoord=0;
1088   CMN_KEY    key[15];
1089   cmn_key    kp[15];
1090   Tint       nk = 0;
1091
1092   vertices = new TEL_POINT[atrike->NbPoints];
1093   if( !vertices )
1094     return;
1095
1096   switch( atrike->TypePoints )
1097   {
1098   case  1: /* Vertex Coordinates Specified */
1099     for( i = 0; i < atrike->NbPoints; i++ )
1100     {
1101       vertices[i].xyz[0] = atrike->UPoints.Points[i].x;
1102       vertices[i].xyz[1] = atrike->UPoints.Points[i].y;
1103       vertices[i].xyz[2] = atrike->UPoints.Points[i].z;
1104     }
1105     break;
1106
1107   case  2: /* Coordinates and Vertex Normal Specified */
1108     vnormals = new TEL_POINT[atrike->NbPoints];
1109     if( !vnormals )
1110     {
1111       delete[] vertices; 
1112       return;
1113     }
1114     for( i = 0; i < atrike->NbPoints; i++ )
1115     {
1116       vertices[i].xyz[0] = atrike->UPoints.PointsN[i].Point.x;
1117       vertices[i].xyz[1] = atrike->UPoints.PointsN[i].Point.y;
1118       vertices[i].xyz[2] = atrike->UPoints.PointsN[i].Point.z;
1119       vnormals[i].xyz[0] = atrike->UPoints.PointsN[i].Normal.dx;
1120       vnormals[i].xyz[1] = atrike->UPoints.PointsN[i].Normal.dy;
1121       vnormals[i].xyz[2] = atrike->UPoints.PointsN[i].Normal.dz;
1122     }
1123     key[nk].id = VNORMALS_ID;
1124     key[nk].data.pdata = vnormals;
1125     nk++;
1126     break;
1127   case  5: /* Coordinates and Vertex Normal and Texture Coordinates Specified */
1128     vnormals = new TEL_POINT[atrike->NbPoints];
1129     if( !vnormals )
1130     {
1131       delete[] vertices;
1132       return;
1133     }
1134     vtexturecoord = new TEL_TEXTURE_COORD[atrike->NbPoints];
1135     if (!vtexturecoord)
1136     {
1137       delete[] vnormals;
1138       delete[] vertices;
1139     }
1140     for( i = 0; i < atrike->NbPoints; i++ )
1141     {
1142       vertices[i].xyz[0] = atrike->UPoints.PointsNT[i].Point.x;
1143       vertices[i].xyz[1] = atrike->UPoints.PointsNT[i].Point.y;
1144       vertices[i].xyz[2] = atrike->UPoints.PointsNT[i].Point.z;
1145       vnormals[i].xyz[0] = atrike->UPoints.PointsNT[i].Normal.dx;
1146       vnormals[i].xyz[1] = atrike->UPoints.PointsNT[i].Normal.dy;
1147       vnormals[i].xyz[2] = atrike->UPoints.PointsNT[i].Normal.dz;
1148       vtexturecoord[i].xy[0] = atrike->UPoints.PointsNT[i].TextureCoord.tx;
1149       vtexturecoord[i].xy[1] = atrike->UPoints.PointsNT[i].TextureCoord.ty;
1150     }
1151     key[nk].id = VNORMALS_ID;
1152     key[nk].data.pdata = vnormals;
1153     nk++;
1154     key[nk].id = VTEXTURECOORD_ID;
1155     key[nk].data.pdata = vtexturecoord;
1156     nk++;
1157     break;
1158   }
1159
1160   key[nk].id = NUM_FACETS_ID;
1161   key[nk].data.ldata = atrike->NbPoints-2;
1162   nk++;
1163
1164   key[nk].id = VERTICES_ID;
1165   key[nk].data.pdata = vertices;
1166   nk++;
1167
1168   for( i = 0; i < nk; i++ )
1169     kp[i] = &key[i];
1170
1171   TsmAddToStructure( TelTriangleMesh, -nk, kp );
1172
1173   delete[] vertices;
1174   if( vnormals )
1175     delete[] vnormals;
1176
1177   return;
1178 }
1179
1180
1181 void
1182 call_subr_set_highl_rep( Tint ind )
1183 {
1184   CMN_KEY  key;
1185
1186   key.data.ldata = ind;
1187   TsmAddToStructure( TelHighlightIndex, 1, &key );
1188
1189   return;
1190 }
1191
1192
1193 #define CALL_ 128
1194
1195 void
1196 call_subr_structure_exploration( Tint             Id,
1197                                 Tint             LabelBegin,
1198                                 Tint             LabelEnd,
1199                                 Tint             elem_num,
1200                                 Tint            *elem_type,
1201                                 CALL_DEF_POINT  *pt,
1202                                 CALL_DEF_NORMAL *npt,
1203                                 CALL_DEF_COLOR  *cpt,
1204                                 CALL_DEF_NORMAL *nfa )
1205 {
1206 #define CALL_MAX_ELEMS_PRINT 1000000
1207   Tfloat  r=0,  g=0,  b=0;
1208   Tfloat  x=0,  y=0,  z=0;
1209   Tfloat nx=0, ny=0, nz=0;
1210   Tfloat dx=0, dy=0, dz=0;
1211
1212   static Tint Initialisation = 1;
1213
1214   Tchar  *buffer=NULL;
1215   Tint    actual_size; /* OUT content size */
1216   Tint    err=0;       /* OUT error indicator */
1217   TelType type;        /* OUT element type */
1218   Tint    size;        /* OUT element size */
1219   Tint    ws;          /* OUT workstation */
1220
1221   Tint      index;        /* element pointer value */
1222   Tint      cur_index;    /* OUT element pointer value */
1223   Teldata   data;         /* OUT data record */
1224
1225   register int i, j;
1226   Tint     MAXPOINTS;
1227   Tint     MAXAREAS;
1228
1229   static Tint idata, jdata, kdata;
1230
1231   Tint printall;      /* print all structure elements or not */
1232   Tint dump;          /* print or not */
1233
1234   static Tint IdCur;  /* current structure id
1235                       (for exploration step by step) */
1236   static Tint ElCur;  /* current structure element number
1237                       (for exploration step by step) */
1238   static Tint IndCur; /* current index point in the structure element
1239                       (for exploration step by step) */
1240   static Tint JndCur; /* current index element in the structure element
1241                       (for exploration step by step) */
1242   static Tint EndExplo;/* flag when the exploration of the current
1243                        element is done.
1244                        (for exploration step by step) */
1245
1246   if( Initialisation )
1247   {
1248     Initialisation =  0;
1249     IdCur          = -1;
1250     ElCur          = -1;
1251     IndCur         = -1;
1252     JndCur         =  0;
1253   }
1254
1255   dump      = 0;
1256   printall  = 1;
1257   MAXPOINTS = CALL_MAX_ELEMS_PRINT;
1258   MAXAREAS  = CALL_MAX_ELEMS_PRINT;
1259
1260   if( (LabelBegin == 0) && (LabelEnd == 0) )
1261   {
1262     dump     = 1;
1263     printall = 0;
1264   }
1265
1266   if( elem_num )
1267   {
1268     index    = elem_num;
1269     dump     = 1;
1270     printall = 1;
1271
1272     npt->dx = npt->dy = npt->dz = nx = ny = nz = ( float )0.0;
1273     nfa->dx = nfa->dy = nfa->dz = dx = dy = dz = ( float )0.0;
1274     pt->x = pt->y = pt->z = x = y = z = ( float )0.0;
1275     cpt->r = cpt->g = cpt->b = r = g = b = ( float )0.0;
1276
1277     if ( (Id != IdCur) || (ElCur != elem_num) || EndExplo )
1278     {
1279       IdCur  = Id;
1280       ElCur  = elem_num;
1281       IndCur = -1;
1282       JndCur = 0;
1283     }
1284     else
1285     {
1286       IndCur ++;
1287     }
1288   }
1289   else
1290   {
1291     index  = 1;
1292     IdCur  = -1;
1293     ElCur  = -1;
1294     IndCur = -1;
1295     JndCur = 0;
1296   }
1297
1298   call_func_open_struct (Id);
1299
1300   while( index )
1301   {
1302     call_func_set_elem_ptr( index );
1303     if( call_func_inq_elem_ptr( &cur_index ) == TFailure )
1304       err = 1;
1305     else
1306       err = 0;
1307
1308     /* it's the end */
1309     if( ( index != cur_index ) || err )
1310     {
1311       index = 0;
1312       break;
1313     }
1314     if( TelInqCurElemTypeSize( &type, &size ) == TFailure )
1315       err = 1;
1316     else
1317       err = 0;
1318
1319     if( err || (type == CALL_PHIGS_ELEM_NIL) )
1320     {
1321       index = 0;
1322       break;
1323     }
1324
1325     if( elem_num )
1326     {
1327       EndExplo   = 0;
1328       *elem_type = type;
1329     }
1330
1331     if( type == CALL_PHIGS_ELEM_LABEL )
1332     {
1333       buffer = (Tchar *)malloc( CALL_ );
1334       TelInqCurElemContent( CALL_, buffer, &actual_size, &data );
1335
1336       if( data.idata == LabelBegin )
1337         dump = 1;
1338       if( ( LabelBegin == 0 ) && ( LabelEnd == 0 ) )
1339         dump = 1;
1340       if( dump )
1341       {
1342         if( elem_num )
1343         {
1344           if( IndCur >= 1 )
1345           {
1346             EndExplo = 1;
1347           }
1348           else
1349           {
1350             x = ( float )data.idata;
1351             y = ( float )0.0;
1352             z = ( float )0.0;
1353           }
1354         }
1355         else
1356         {
1357           printf( "\tELEM_LABEL\n" );
1358           printf( "\t\tLABEL %d\n", data.idata );
1359         }
1360       }
1361
1362       if( data.idata == LabelEnd )
1363         dump = 0;
1364
1365       free( buffer );
1366     }
1367
1368     if( dump )
1369     {
1370       switch (type)
1371       {
1372       case CALL_PHIGS_ELEM_NIL :
1373         {
1374           if( elem_num )
1375           {
1376             if (IndCur >= 0)
1377             {
1378               EndExplo = 1;
1379             }
1380             else
1381             {
1382               x = y = z = ( float )0.0;
1383             }
1384           }
1385           else
1386           {
1387             printf("\tELEM_NIL\n");
1388             printf("\t\tNo data involved\n");
1389           }
1390           break;
1391         }
1392       case CALL_PHIGS_ELEM_POLYMARKER3 :
1393         {
1394           i = size;
1395           buffer = new Tchar[i];
1396           TelInqCurElemContent( i, buffer, &actual_size, &data );
1397           idata = size/sizeof( TEL_POINT );
1398           if( elem_num )
1399           {
1400             if( (IndCur > -1) && (IndCur < idata) )
1401             {
1402               i = IndCur;
1403               x = data.pts3[i].xyz[0];
1404               y = data.pts3[i].xyz[1];
1405               z = data.pts3[i].xyz[2];
1406             }
1407             if (IndCur >= idata)
1408               EndExplo = 1;
1409           }
1410           else
1411           {
1412             printf("\tELEM_POLYMARKER3\n");
1413             printf("\t\tPOLYMARKER 3 nb pts %d\n", idata);
1414             if (printall)
1415             {
1416               for (i=0; i<idata && i<MAXPOINTS; i++)
1417                 printf( "\t\tpoint %d : %f %f %f\n", i,
1418                 data.pts3[i].xyz[0],
1419                 data.pts3[i].xyz[1],
1420                 data.pts3[i].xyz[2] );
1421             }
1422             else
1423             {
1424               i = 0;
1425               printf( "\t\tfirst point %d : %f %f %f\n", i,
1426                 data.pts3[i].xyz[0],
1427                 data.pts3[i].xyz[1],
1428                 data.pts3[i].xyz[2] );
1429               i = idata - 1;
1430               printf("\t\tlast point %d : %f %f %f\n", i,
1431                 data.pts3[i].xyz[0],
1432                 data.pts3[i].xyz[1],
1433                 data.pts3[i].xyz[2]);
1434             }
1435           }
1436           delete[] buffer;
1437           break;
1438         }
1439       case CALL_PHIGS_ELEM_FILL_AREA_SET3 :
1440         {
1441           i = size;
1442           buffer = new Tchar[i];
1443           TelInqCurElemContent( i, buffer, &actual_size, &data );
1444           jdata = data.fillareaset3data.num_bounds;
1445           if( elem_num )
1446           {
1447             if ((IndCur == 0) && (JndCur == 0))
1448               kdata = 0;
1449             if (JndCur >= jdata)
1450               EndExplo = 1;
1451             else
1452             {
1453               if (IndCur == 0)
1454               {
1455                 idata = data.fillareaset3data.bounds[JndCur];
1456               }
1457               else
1458               {
1459                 if ((IndCur > -1) && (IndCur < idata))
1460                 {
1461                   x =
1462                     data.fillareaset3data.points[kdata+IndCur].xyz[0];
1463                   y =
1464                     data.fillareaset3data.points[kdata+IndCur].xyz[1];
1465                   z =
1466                     data.fillareaset3data.points[kdata+IndCur].xyz[2];
1467
1468                   if(data.fillareaset3data.vrtflag ==
1469                     CALL_PHIGS_VERT_COORD_NORMAL)
1470                   {
1471                     nx = data.fillareaset3data.vnormals[IndCur].xyz[0];
1472                     ny = data.fillareaset3data.vnormals[IndCur].xyz[1];
1473                     nz = data.fillareaset3data.vnormals[IndCur].xyz[2];
1474                   }
1475                   if(data.fillareaset3data.vrtflag ==
1476                     CALL_PHIGS_VERT_COORD_COLOUR)
1477                   {
1478                     r =
1479                       data.fillareaset3data.colours[kdata+IndCur].rgb[0];
1480                     g =
1481                       data.fillareaset3data.colours[kdata+IndCur].rgb[1];
1482                     b =
1483                       data.fillareaset3data.colours[kdata+IndCur].rgb[2];
1484                   }
1485                   if (data.fillareaset3data.vrtflag ==
1486                     CALL_PHIGS_VERT_COORD_COLOUR_NORMAL)
1487                   {
1488                     nx = data.fillareaset3data.vnormals[IndCur].xyz[0];
1489                     ny = data.fillareaset3data.vnormals[IndCur].xyz[1];
1490                     nz = data.fillareaset3data.vnormals[IndCur].xyz[2];
1491                     r =
1492                       data.fillareaset3data.colours[kdata+IndCur].rgb[0];
1493                     g =
1494                       data.fillareaset3data.colours[kdata+IndCur].rgb[1];
1495                     b =
1496                       data.fillareaset3data.colours[kdata+IndCur].rgb[2];
1497                   }
1498                 }
1499               }
1500               if (IndCur >= idata)
1501               {
1502                 kdata += data.fillareaset3data.bounds[JndCur];
1503                 JndCur ++;
1504                 IndCur  = 0;
1505               }
1506             }
1507           }
1508           else
1509           {
1510             printf("\tELEM_FILL_AREA_SET3_DATA\n");
1511             printf("\t\tSET OF FILL AREA SET 3 WITH DATA\n");
1512             kdata = 0;
1513             printf("\t\tnb of faces %d\n", jdata);
1514             printf("\t\tfflag %d eflag %d vflag %d colr model RGB\n",
1515               data.fillareaset3data.faflag,
1516               data.fillareaset3data.edgflag,
1517               data.fillareaset3data.vrtflag );
1518             kdata = 0;
1519             for (j=0; j<jdata && j<MAXAREAS; j++)
1520             {
1521               idata = data.fillareaset3data.bounds[j];
1522               printf("\t\tface %d : %d vertices\n", j, idata);
1523               if (data.fillareaset3data.faflag ==
1524                 CALL_PHIGS_FACET_NORMAL)
1525                 printf("\t\t\tface normal %f %f %f\n",
1526                 data.fillareaset3data.gnormal[j].xyz[0],
1527                 data.fillareaset3data.gnormal[j].xyz[1],
1528                 data.fillareaset3data.gnormal[j].xyz[2]);
1529               if (data.fillareaset3data.faflag ==
1530                 CALL_PHIGS_FACET_COLOUR_NORMAL)
1531                 printf("\t\t\tnormal %f %f %f\n",
1532                 data.fillareaset3data.gnormal[j].xyz[0],
1533                 data.fillareaset3data.gnormal[j].xyz[1],
1534                 data.fillareaset3data.gnormal[j].xyz[2]);
1535               if (printall)
1536                 for (i=0; i<idata && i<MAXPOINTS; i++)
1537                   printf("\t\t\tvertex %d : %f %f %f\n", i,
1538                   data.fillareaset3data.points[kdata+i].xyz[0],
1539                   data.fillareaset3data.points[kdata+i].xyz[1],
1540                   data.fillareaset3data.points[kdata+i].xyz[2]);
1541               else
1542               {
1543                 i = 0;
1544                 printf("\t\tfirst vertex %d : %f %f %f\n", i,
1545                   data.fillareaset3data.points[kdata+i].xyz[0],
1546                   data.fillareaset3data.points[kdata+i].xyz[1],
1547                   data.fillareaset3data.points[kdata+i].xyz[2]);
1548
1549                 i = idata - 1;
1550                 printf("\t\tlast vertex %d : %f %f %f\n", i,
1551                   data.fillareaset3data.points[kdata+i].xyz[0],
1552                   data.fillareaset3data.points[kdata+i].xyz[1],
1553                   data.fillareaset3data.points[kdata+i].xyz[2]);
1554               }
1555               kdata += data.fillareaset3data.bounds[j];
1556             }
1557             delete[] buffer;
1558             break;
1559           }
1560         }
1561       case CALL_PHIGS_ELEM_FILL_AREA3 :
1562         {
1563           i = size;
1564           buffer = new Tchar[i];
1565           TelInqCurElemContent( i, buffer, &actual_size, &data );
1566           idata = data.fillarea3data.num_points;
1567
1568           if( elem_num )
1569           {
1570             if( (IndCur > -1) && (IndCur < idata) )
1571             {
1572               i = IndCur;
1573               x = data.fillarea3data.points[i].xyz[0];
1574               y = data.fillarea3data.points[i].xyz[1];
1575               z = data.fillarea3data.points[i].xyz[2];
1576             }
1577             if( IndCur >= idata )
1578               EndExplo = 1;
1579           }
1580           else
1581           {
1582             printf( "\tELEM_FILL_AREA3\n" );
1583             printf( "\t\tFILL AREA 3 nb pts %d\n", idata );
1584             if( printall )
1585             {
1586               for( i=0; i<idata && i<MAXPOINTS; i++ )
1587                 printf( "\t\tpoint %d : %f %f %f\n", i,
1588                 data.fillarea3data.points[i].xyz[0],
1589                 data.fillarea3data.points[i].xyz[1],
1590                 data.fillarea3data.points[i].xyz[2] );
1591             }
1592             else
1593             {
1594               i = 0;
1595               printf("\t\tfirst point %d : %f %f %f\n", i,
1596                 data.fillarea3data.points[i].xyz[0],
1597                 data.fillarea3data.points[i].xyz[1],
1598                 data.fillarea3data.points[i].xyz[2] );
1599               i = idata - 1;
1600               printf("\t\tlast point %d : %f %f %f\n", i,
1601                 data.fillarea3data.points[i].xyz[0],
1602                 data.fillarea3data.points[i].xyz[1],
1603                 data.fillarea3data.points[i].xyz[2] );
1604             }
1605           }
1606           delete[] buffer;
1607           break;
1608         }
1609       case CALL_PHIGS_ELEM_ANNO_TEXT_REL3 :
1610         {
1611           buffer = new Tchar[size];
1612           TelInqCurElemContent( size, buffer, &actual_size, &data );
1613
1614           if( elem_num )
1615           {
1616             if (IndCur == 0)
1617             {
1618               x = data.atext3.ref_pt.xyz[0];
1619               y = data.atext3.ref_pt.xyz[1];
1620               z = data.atext3.ref_pt.xyz[2];
1621             }
1622             if (IndCur == 1)
1623             {
1624               x = data.atext3.anno.xyz[0];
1625               y = data.atext3.anno.xyz[1];
1626               z = data.atext3.anno.xyz[2];
1627             }
1628             if( IndCur >= 2 )
1629               EndExplo = 1;
1630           }
1631           else
1632           {
1633             printf( "\tELEM_ANNO_TEXT_REL3\n" );
1634             printf( "\t\tANNOTATION TEXT RELATIVE 3 %S\n",
1635               data.atext3.string );
1636             printf( "\t\treference point %f %f %f\n",
1637               data.atext3.ref_pt.xyz[0],
1638               data.atext3.ref_pt.xyz[1],
1639               data.atext3.ref_pt.xyz[2] );
1640             printf( "\t\toffset %f %f %f\n",
1641               data.atext3.anno.xyz[0],
1642               data.atext3.anno.xyz[1],
1643               data.atext3.anno.xyz[2] );
1644           }
1645           delete[] buffer;
1646           break;
1647         }
1648       case CALL_PHIGS_ELEM_LINETYPE :
1649         {
1650           TelInqCurElemContent( 0, buffer, &actual_size, &data );
1651           if( elem_num )
1652           {
1653             if (IndCur >= 1)
1654               EndExplo = 1;
1655             else
1656             {
1657               x = ( float )data.idata;
1658               y = ( float )0.0;
1659               z = ( float )0.0;
1660             }
1661           }
1662           else {
1663             printf("\tELEM_LINETYPE\n");
1664             printf("\t\tLINETYPE %d\n", data.idata);
1665           }
1666           break;
1667         }
1668       case CALL_PHIGS_ELEM_LINEWIDTH :
1669         {
1670           TelInqCurElemContent( 0, buffer, &actual_size, &data );
1671           if( elem_num )
1672           {
1673             if (IndCur >= 1)
1674               EndExplo = 1;
1675             else
1676             {
1677               x = data.fdata;
1678               y = ( float )0.0;
1679               z = ( float )0.0;
1680             }
1681           }
1682           else
1683           {
1684             printf( "\tELEM_LINEWIDTH\n" );
1685             printf( "\t\tLINEWIDTH SCALE FACTOR %f\n", data.fdata);
1686           }
1687           break;
1688         }
1689       case CALL_PHIGS_ELEM_MARKER_TYPE :
1690         {
1691           TelInqCurElemContent( 0, buffer, &actual_size, &data );
1692           if( elem_num )
1693           {
1694             if( IndCur >= 1 )
1695               EndExplo = 1;
1696             else
1697             {
1698               x = ( float )data.idata;
1699               y = ( float )0.0;
1700               z = ( float )0.0;
1701             }
1702           }
1703           else
1704           {
1705             printf("\tELEM_MARKER_TYPE\n");
1706             printf("\t\tMARKER TYPE %d\n", data.idata);
1707           }
1708           break;
1709         }
1710       case CALL_PHIGS_ELEM_MARKER_SIZE :
1711         {
1712           TelInqCurElemContent( 0, buffer, &actual_size, &data );
1713           if( elem_num )
1714           {
1715             if (IndCur >= 1)
1716               EndExplo = 1;
1717             else
1718             {
1719               x = data.fdata;
1720               y = ( float )0.0;
1721               z = ( float )0.0;
1722             }
1723           }
1724           else
1725           {
1726             printf("\tELEM_MARKER_SIZE\n");
1727             printf("\t\tMARKER SIZE SCALE FACTOR %f\n", data.fdata);
1728           }
1729           break;
1730         }
1731 #if 0
1732       case CALL_PHIGS_ELEM_TEXT_FONT : /* DECPHIGS */
1733         buffer = new Tchar[CALL_];
1734         TelInqCurElemContent (CALL_, buffer, &actual_size, &data);
1735         if( elem_num )
1736           if (IndCur >= 1)
1737             EndExplo        = 1;
1738           else {
1739             x        = data.idata;
1740             y        = 0.0;
1741             z        = 0.0;
1742           }
1743         else {
1744           printf("\tELEM_TEXT_FONT\n");
1745           printf("\t\tTEXT FONT %d\n", data.idata);
1746         }
1747         delete[] buffer;
1748         break;
1749 #endif
1750       case CALL_PHIGS_ELEM_CHAR_EXPAN :
1751         {
1752           TelInqCurElemContent( 0, buffer, &actual_size, &data );
1753           if( elem_num )
1754           {
1755             if (IndCur >= 1)
1756               EndExplo = 1;
1757             else
1758             {
1759               x = data.fdata;
1760               y = ( float )0.0;
1761               z = ( float )0.0;
1762             }
1763           }
1764           else
1765           {
1766             printf("\tELEM_CHAR_EXPAN\n");
1767             printf("\t\tCHARACTER EXPANSION FACTOR %f\n",data.fdata);
1768           }
1769           break;
1770         }
1771       case CALL_PHIGS_ELEM_CHAR_SPACE :
1772         {
1773           TelInqCurElemContent( 0, buffer, &actual_size, &data );
1774           if( elem_num )
1775           {
1776             if (IndCur >= 1)
1777               EndExplo = 1;
1778             else
1779             {
1780               x = data.fdata;
1781               y = ( float )0.0;
1782               z = ( float )0.0;
1783             }
1784           }
1785           else
1786           {
1787             printf("\tELEM_CHAR_SPACE\n");
1788             printf("\t\tCHARACTER SPACING %f\n", data.fdata);
1789           }
1790           break;
1791         }
1792       case CALL_PHIGS_ELEM_ANNO_CHAR_HT :
1793         {
1794           TelInqCurElemContent( 0, buffer, &actual_size, &data );
1795           if( elem_num )
1796           {
1797             if (IndCur >= 1)
1798               EndExplo = 1;
1799             else
1800             {
1801               x = data.fdata;
1802               y = ( float )0.0;
1803               z = ( float )0.0;
1804             }
1805           }
1806           else
1807           {
1808             printf("\tELEM_ANNO_CHAR_HT\n");
1809             printf("\t\tANNOTATION TEXT CHARACTER HEIGHT %f\n",
1810               data.fdata);
1811           }
1812           break;
1813         }
1814       case CALL_PHIGS_ELEM_INT_STYLE :
1815         {
1816           TelInqCurElemContent( 0, buffer, &actual_size, &data );
1817           if( elem_num )
1818           {
1819             if (IndCur >= 1)
1820               EndExplo = 1;
1821             else
1822             {
1823               x = ( float )data.interior_style;
1824               y = ( float )0.0;
1825               z = ( float )0.0;
1826             }
1827           }
1828           else
1829           {
1830             printf("\tELEM_INT_STYLE\n");
1831             printf("\t\tINTERIOR STYLE %d\n", data.interior_style);
1832           }
1833           break;
1834         }
1835       case CALL_PHIGS_ELEM_INT_STYLE_IND :
1836         {
1837           TelInqCurElemContent( 0, buffer, &actual_size, &data );
1838           if( elem_num )
1839           {
1840             if (IndCur >= 1)
1841               EndExplo = 1;
1842             else
1843             {
1844               x = ( float )data.idata;
1845               y = ( float )0.0;
1846               z = ( float )0.0;
1847             }
1848           }
1849           else
1850           {
1851             printf("\tELEM_INT_STYLE_IND\n");
1852             printf("\t\tINTERIOR STYLE INDEX %d\n", data.idata);
1853           }
1854           break;
1855         }
1856       case CALL_PHIGS_ELEM_EDGE_FLAG :
1857         {
1858           TelInqCurElemContent( 0, buffer, &actual_size, &data );
1859           if( elem_num )
1860           {
1861             if (IndCur >= 1)
1862               EndExplo = 1;
1863             else
1864             {
1865               x = ( float )data.edge_flag;
1866               y = ( float )0.0;
1867               z = ( float )0.0;
1868             }
1869           }
1870           else
1871           {
1872             printf("\tELEM_EDGE_FLAG\n");
1873             printf("\t\tEDGE FLAG %d\n", data.edge_flag);
1874           }
1875           break;
1876         }
1877       case CALL_PHIGS_ELEM_EDGETYPE :
1878         {
1879           TelInqCurElemContent( 0, buffer, &actual_size, &data );
1880           if( elem_num )
1881           {
1882             if (IndCur >= 1)
1883               EndExplo = 1;
1884             else
1885             {
1886               x = ( float )data.idata;
1887               y = ( float )0.0;
1888               z = ( float )0.0;
1889             }
1890           }
1891           else
1892           {
1893             printf("\tELEM_EDGETYPE\n");
1894             printf("\t\tEDGETYPE %d\n", data.idata);
1895           }
1896           break;
1897         }
1898       case CALL_PHIGS_ELEM_EDGEWIDTH :
1899         {
1900           TelInqCurElemContent( 0, buffer, &actual_size, &data );
1901           if( elem_num )
1902           {
1903             if (IndCur >= 1)
1904               EndExplo = 1;
1905             else
1906             {
1907               x = data.fdata;
1908               y = ( float )0.0;
1909               z = ( float )0.0;
1910             }
1911           }
1912           else
1913           {
1914             printf("\tELEM_EDGEWIDTH\n");
1915             printf("\t\tEDGEWIDTH SCALE FACTOR %f\n", data.fdata);
1916           }
1917           break;
1918         }
1919       case CALL_PHIGS_ELEM_ADD_NAMES_SET :
1920         {
1921           buffer = new Tchar[size];
1922           TelInqCurElemContent( size, buffer, &actual_size, &data );
1923           idata = data.name_set.number;
1924           if( elem_num )
1925           {
1926             if( (IndCur > -1) && (IndCur < idata) )
1927             {
1928               i = IndCur;
1929               x = ( float )data.name_set.integers[i];
1930               y = ( float )0.0;
1931               z = ( float )0.0;
1932             }
1933             if( IndCur >= idata )
1934               EndExplo = 1;
1935           }
1936           else
1937           {
1938             printf("\tELEM_ADD_NAMES_SET\n");
1939             printf("\t\tADD NAMES TO SET\n");
1940             for( i=0; i<idata; i++ )
1941               printf("\t\tnames %d : %d\n",
1942               i, data.name_set.integers[i]);
1943           }
1944           delete[] buffer;
1945           break;
1946         }
1947       case CALL_PHIGS_ELEM_REMOVE_NAMES_SET :
1948         {
1949           buffer = new Tchar[size];
1950           TelInqCurElemContent( size, buffer, &actual_size, &data );
1951           idata = data.name_set.number;
1952           if( elem_num )
1953           {
1954             if( (IndCur > -1) && (IndCur < idata) )
1955             {
1956               i = IndCur;
1957               x = ( float )data.name_set.integers[i];
1958               y = ( float )0.0;
1959               z = ( float )0.0;
1960             }
1961             if (IndCur >= idata)
1962               EndExplo = 1;
1963           }
1964           else
1965           {
1966             printf("\tELEM_REMOVE_NAMES_SET\n");
1967             printf("\t\tREMOVE NAMES FROM SET\n");
1968             for( i=0; i<idata; i++ )
1969               printf("\t\tnames %d : %d\n",
1970               i, data.name_set.integers[i]);
1971           }
1972           delete[] buffer;
1973           break;
1974         }
1975       case CALL_PHIGS_ELEM_LOCAL_MODEL_TRAN3 :
1976         {
1977           TelInqCurElemContent( 0, buffer, &actual_size, &data );
1978           if( elem_num )
1979           {
1980             if (IndCur >= 0)
1981               EndExplo = 1;
1982             else
1983             {
1984               x = y = z = ( float )0.0;
1985             }
1986           }
1987           else
1988           {
1989             printf("\tELEM_LOCAL_MODEL_TRAN3\n");
1990             printf("\t\tLOCAL MODELLING TRANSFORMATION 3 comp %d\n",
1991               data.local_xform_3.compose_type);
1992             for( i=0; i<4; i++ )
1993             {
1994               printf("\t\t\t");
1995               for( j=0; j<4; j++ )
1996                 printf(" %f", data.local_xform_3.mat3[i][j]);
1997               printf("\n");
1998             }
1999           }
2000           break;
2001         }
2002       case CALL_PHIGS_ELEM_VIEW_IND :
2003         {
2004           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2005           if( elem_num )
2006           {
2007             if (IndCur >= 1)
2008               EndExplo = 1;
2009             else
2010             {
2011               x = ( float )data.idata;
2012               y = ( float )0.0;
2013               z = ( float )0.0;
2014             }
2015           }
2016           else
2017           {
2018             printf("\tELEM_VIEW_IND\n");
2019             printf("\t\tVIEW INDEX %d\n", data.idata);
2020
2021             if(! call_subr_inquirews (Id, &ws))
2022               printf("\t\tERROR : no view definition\n");
2023             else
2024             {
2025               printf("\t\tview structure in %d workstation\n", ws);
2026               printf("\t\t**********************\n");
2027               printf("\t\tdefinition in the ws %d\n", ws);
2028               printf("\t\t**********************\n");
2029               TelPrintViewRepresentation( ws, Id );
2030             }
2031           }
2032           break;
2033         }
2034       case CALL_PHIGS_ELEM_EXEC_STRUCT :
2035         {
2036           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2037           if( elem_num )
2038           {
2039             if (IndCur >= 1)
2040               EndExplo = 1;
2041             else
2042             {
2043               x = ( float )data.idata;
2044               y = ( float )0.0;
2045               z = ( float )0.0;
2046             }
2047           }
2048           else
2049           {
2050             printf("\tELEM_EXEC_STRUCT\n");
2051             printf("\t\tEXECUTE STRUCTURE %d\n", data.idata);
2052           }
2053           break;
2054         }
2055       case CALL_PHIGS_ELEM_APPL_DATA :
2056         {
2057           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2058           if( elem_num )
2059           {
2060             if (IndCur >= 0)
2061               EndExplo = 1;
2062             else
2063             {
2064               x = y = z = ( float )0.0;
2065             }
2066           }
2067           else
2068           {
2069             printf("\tELEM_APPL_DATA\n");
2070             printf("\t\tcontent not exploited\n");
2071           }
2072           break;
2073         }
2074       case CALL_PHIGS_ELEM_PICK_ID :
2075         {
2076           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2077           if( elem_num )
2078           {
2079             if (IndCur >= 1)
2080               EndExplo = 1;
2081             else
2082             {
2083               x = ( float )data.idata;
2084               y = ( float )0.0;
2085               z = ( float )0.0;
2086             }
2087           }
2088           else
2089           {
2090             printf("\tELEM_PICK_ID\n");
2091             printf("\t\tPICK ID %d\n", data.idata);
2092           }
2093           break;
2094         }
2095       case CALL_PHIGS_ELEM_POLYLINE_SET3_DATA : /* DECPHIGS */
2096         {
2097           buffer = new Tchar[size];
2098           TelInqCurElemContent( size, buffer, &actual_size, &data);
2099           jdata = data.lineset3data.num_bounds;
2100
2101           if( elem_num )
2102           {
2103             if( ( IndCur == -1 ) && ( JndCur == 0 ) )
2104               kdata = 0;
2105
2106             if( JndCur >= jdata )
2107               EndExplo = 1;
2108             else
2109             {
2110               if (IndCur == 0)
2111               {
2112                 idata = data.lineset3data.bounds[JndCur];
2113               }
2114               else
2115               {
2116                 if ( ( IndCur > -1 ) && ( IndCur < idata ) )
2117                 {
2118                   x = data.lineset3data.points[kdata+IndCur].xyz[0];
2119                   y = data.lineset3data.points[kdata+IndCur].xyz[1];
2120                   z = data.lineset3data.points[kdata+IndCur].xyz[2];
2121
2122                   if( data.lineset3data.colours )
2123                   {
2124                     r =
2125                       data.lineset3data.colours[kdata+IndCur].rgb[0];
2126                     g =
2127                       data.lineset3data.colours[kdata+IndCur].rgb[1];
2128                     b =
2129                       data.lineset3data.colours[kdata+IndCur].rgb[2];
2130                   }
2131                 }
2132
2133                 if( IndCur >= idata )
2134                 {
2135                   kdata += data.lineset3data.bounds[JndCur];
2136                   JndCur ++;
2137                   IndCur = 0;
2138                 }
2139               }
2140             }
2141           }
2142           else
2143           {
2144             printf( "\tELEM_POLYLINE_SET3_DATA\n" );
2145             kdata = 0;
2146             printf( "\t\tPOLYLINE SET 3 WITH DATA\n" );
2147             printf( "\t\tnb of lines %d\n", jdata );
2148             printf( "\t\tvflag %d colr model RGB\n",
2149               data.lineset3data.vrtflag );
2150             for( j = 0; j < jdata && j < MAXAREAS; j++ )
2151             {
2152               idata = data.lineset3data.bounds[j];
2153               printf( "\t\tface %d : %d vertices\n", j, idata );
2154               if( printall )
2155               {
2156                 for( i = 0; i < idata && i < MAXPOINTS; i++ )
2157                   printf( "\t\t\tvertex %d : %f %f %f\n", i,
2158                   data.lineset3data.points[kdata+i].xyz[0],
2159                   data.lineset3data.points[kdata+i].xyz[1],
2160                   data.lineset3data.points[kdata+i].xyz[2] );
2161               }
2162               else
2163               {
2164                 i = 0;
2165                 printf( "\t\tfirst vertex %d : %f %f %f\n", i,
2166                   data.lineset3data.points[kdata+i].xyz[0],
2167                   data.lineset3data.points[kdata+i].xyz[1],
2168                   data.lineset3data.points[kdata+i].xyz[2] );
2169
2170                 i = idata - 1;
2171                 printf( "\t\tlast vertex %d : %f %f %f\n", i,
2172                   data.lineset3data.points[kdata+i].xyz[0],
2173                   data.lineset3data.points[kdata+i].xyz[1],
2174                   data.lineset3data.points[kdata+i].xyz[2] );
2175               }
2176               kdata += data.lineset3data.bounds[j];
2177             }
2178           }
2179           delete[] buffer;
2180           break;
2181         }
2182       case CALL_PHIGS_ELEM_TRI_STRIP3_DATA :
2183         {
2184           buffer = new Tchar[size];
2185           TelInqCurElemContent( size, buffer, &actual_size, &data );
2186           idata = data.trianglestrip3data.num_facets + 2;
2187
2188           if( elem_num )
2189           {
2190             if (IndCur >= idata)
2191               EndExplo = 1;
2192             else
2193             {
2194               x = data.trianglestrip3data.points[IndCur].xyz[0];
2195               y = data.trianglestrip3data.points[IndCur].xyz[1];
2196               z = data.trianglestrip3data.points[IndCur].xyz[2];
2197
2198               if( data.trianglestrip3data.vrtflag ==
2199                 CALL_PHIGS_VERT_COORD_COLOUR )
2200               {
2201                 r = data.trianglestrip3data.colours[IndCur].rgb[0];
2202                 g = data.trianglestrip3data.colours[IndCur].rgb[1];
2203                 b = data.trianglestrip3data.colours[IndCur].rgb[2];
2204               }
2205               else if( data.trianglestrip3data.vrtflag ==
2206                 CALL_PHIGS_VERT_COORD_NORMAL )
2207               {
2208                 nx =
2209                   data.trianglestrip3data.vnormals[IndCur].xyz[0];
2210                 ny =
2211                   data.trianglestrip3data.vnormals[IndCur].xyz[1];
2212                 nz =
2213                   data.trianglestrip3data.vnormals[IndCur].xyz[2];
2214               }
2215               else if( data.trianglestrip3data.vrtflag ==
2216                 CALL_PHIGS_VERT_COORD_COLOUR_NORMAL )
2217               {
2218                 nx =
2219                   data.trianglestrip3data.vnormals[IndCur].xyz[0];
2220                 ny =
2221                   data.trianglestrip3data.vnormals[IndCur].xyz[1];
2222                 nz =
2223                   data.trianglestrip3data.vnormals[IndCur].xyz[2];
2224                 r = data.trianglestrip3data.colours[IndCur].rgb[0];
2225                 g = data.trianglestrip3data.colours[IndCur].rgb[1];
2226                 b = data.trianglestrip3data.colours[IndCur].rgb[2];
2227               }
2228             }
2229           }
2230           else
2231           {
2232             printf("\tELEM_TRI_STRIP3_DATA\n");
2233             printf("\t\tTRIANGLE STRIP 3 WITH DATA\n");
2234             printf("\t\tnb of vertices %d\n", idata);
2235             printf("\t\tfflag %d vflag %d colr model RGB\n",
2236               data.trianglestrip3data.fctflag,
2237               data.trianglestrip3data.vrtflag);
2238             if( printall )
2239               for( i=0; i<idata && i<MAXPOINTS; i++ )
2240                 printf("\t\t\tvertex %d : %f %f %f\n", i,
2241                 data.trianglestrip3data.points[i].xyz[0],
2242                 data.trianglestrip3data.points[i].xyz[1],
2243                 data.trianglestrip3data.points[i].xyz[2] );
2244             else
2245             {
2246               i = 0;
2247               printf("\t\tfirst vertex %d : %f %f %f\n", i,
2248                 data.trianglestrip3data.points[i].xyz[0],
2249                 data.trianglestrip3data.points[i].xyz[1],
2250                 data.trianglestrip3data.points[i].xyz[2]);
2251
2252               i = idata - 1;
2253               printf("\t\tlast vertex %d : %f %f %f\n", i,
2254                 data.trianglestrip3data.points[i].xyz[0],
2255                 data.trianglestrip3data.points[i].xyz[1],
2256                 data.trianglestrip3data.points[i].xyz[2]);
2257             }
2258           }
2259           delete buffer;
2260           break;
2261         }
2262       case CALL_PHIGS_ELEM_QUAD_MESH3_DATA :
2263         {
2264           buffer = new Tchar[size];
2265           TelInqCurElemContent( size, buffer, &actual_size, &data);
2266           idata = (data.quadmesh3data.dim.x_dim+1) *
2267             (data.quadmesh3data.dim.y_dim+1);
2268
2269           if( elem_num )
2270           {
2271             if (IndCur >= idata)
2272               EndExplo = 1;
2273             else
2274             {
2275               x = data.quadmesh3data.points[IndCur].xyz[0];
2276               y = data.quadmesh3data.points[IndCur].xyz[1];
2277               z = data.quadmesh3data.points[IndCur].xyz[2];
2278
2279               if( data.quadmesh3data.vrtflag ==
2280                 CALL_PHIGS_VERT_COORD_COLOUR )
2281               {
2282                 r = data.quadmesh3data.colours[IndCur].rgb[0];
2283                 g = data.quadmesh3data.colours[IndCur].rgb[1];
2284                 b = data.quadmesh3data.colours[IndCur].rgb[2];
2285               }
2286               else if( data.quadmesh3data.vrtflag ==
2287                 CALL_PHIGS_VERT_COORD_NORMAL )
2288               {
2289                 nx = data.quadmesh3data.vnormals[IndCur].xyz[0];
2290                 ny = data.quadmesh3data.vnormals[IndCur].xyz[1];
2291                 nz = data.quadmesh3data.vnormals[IndCur].xyz[2];
2292               }
2293               else if( data.quadmesh3data.vrtflag ==
2294                 CALL_PHIGS_VERT_COORD_COLOUR_NORMAL )
2295               {
2296                 nx = data.quadmesh3data.vnormals[IndCur].xyz[0];
2297                 ny = data.quadmesh3data.vnormals[IndCur].xyz[1];
2298                 nz = data.quadmesh3data.vnormals[IndCur].xyz[2];
2299                 r = data.quadmesh3data.colours[IndCur].rgb[0];
2300                 g = data.quadmesh3data.colours[IndCur].rgb[1];
2301                 b = data.quadmesh3data.colours[IndCur].rgb[2];
2302               }
2303             }
2304           }
2305           else
2306           {
2307             printf("\tELEM_QUAD_MESH3_DATA\n");
2308             printf("\t\tQUADRILATERAL MESH 3 WITH DATA\n");
2309             printf("\t\tdimensions %d %d\n",
2310               data.quadmesh3data.dim.x_dim,
2311               data.quadmesh3data.dim.y_dim);
2312             printf("\t\tnb of vertices %d\n", idata);
2313             printf("\t\tfflag %d vflag %d colr model RGB\n",
2314               data.quadmesh3data.fctflag,
2315               data.quadmesh3data.vrtflag);
2316             if( printall )
2317             {
2318               for( i=0; i<idata && i<MAXPOINTS; i++ )
2319                 printf("\t\t\tvertex %d : %f %f %f\n", i,
2320                 data.quadmesh3data.points[i].xyz[0],
2321                 data.quadmesh3data.points[i].xyz[1],
2322                 data.quadmesh3data.points[i].xyz[2]);
2323             }
2324             else
2325             {
2326               i = 0;
2327               printf("\t\tfirst vertex %d : %f %f %f\n", i,
2328                 data.quadmesh3data.points[i].xyz[0],
2329                 data.quadmesh3data.points[i].xyz[1],
2330                 data.quadmesh3data.points[i].xyz[2]);
2331
2332               i = idata - 1;
2333               printf("\t\tlast vertex %d : %f %f %f\n", i,
2334                 data.quadmesh3data.points[i].xyz[0],
2335                 data.quadmesh3data.points[i].xyz[1],
2336                 data.quadmesh3data.points[i].xyz[2]);
2337             }
2338           }
2339           delete[] buffer;
2340           break;
2341         }
2342       case CALL_PHIGS_ELEM_TEXT_COLR :
2343         {
2344           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2345           if( elem_num )
2346           {
2347             if (IndCur >= 1)
2348               EndExplo = 1;
2349             else
2350             {
2351               x = data.gnl_colour.rgb[0];
2352               y = data.gnl_colour.rgb[1];
2353               z = data.gnl_colour.rgb[2];
2354             }
2355           }
2356           else
2357           {
2358             printf("\tELEM_TEXT_COLR\n");
2359             printf("\t\tTEXT COLOUR r %f g %f b %f\n",
2360               data.gnl_colour.rgb[0],
2361               data.gnl_colour.rgb[1],
2362               data.gnl_colour.rgb[2] );
2363           }
2364           break;
2365         }
2366       case CALL_PHIGS_ELEM_MARKER_COLR :
2367         {
2368           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2369           if( elem_num )
2370           {
2371             if (IndCur >= 1)
2372               EndExplo = 1;
2373             else
2374             {
2375               x = data.gnl_colour.rgb[0];
2376               y = data.gnl_colour.rgb[1];
2377               z = data.gnl_colour.rgb[2];
2378             }
2379           }
2380           else
2381           {
2382             printf("\tELEM_MARKER_COLR\n");
2383             printf("\t\tPOLYMARKER COLOUR r %f g %f b %f\n",
2384               data.gnl_colour.rgb[0],
2385               data.gnl_colour.rgb[1],
2386               data.gnl_colour.rgb[2] );
2387           }
2388           break;
2389         }
2390       case CALL_PHIGS_ELEM_EDGE_COLR :
2391         {
2392           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2393           if( elem_num )
2394           {
2395             if (IndCur >= 1)
2396               EndExplo = 1;
2397             else
2398             {
2399               x = data.gnl_colour.rgb[0];
2400               y = data.gnl_colour.rgb[1];
2401               z = data.gnl_colour.rgb[2];
2402             }
2403           }
2404           else
2405           {
2406             printf("\tELEM_EDGE_COLR\n");
2407             printf("\t\tEDGE COLOUR r %f g %f b %f\n",
2408               data.gnl_colour.rgb[0],
2409               data.gnl_colour.rgb[1],
2410               data.gnl_colour.rgb[2]);
2411           }
2412           break;
2413         }
2414       case CALL_PHIGS_ELEM_LINE_COLR :
2415         {
2416           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2417           if( elem_num )
2418           {
2419             if (IndCur >= 1)
2420               EndExplo = 1;
2421             else
2422             {
2423               x = data.gnl_colour.rgb[0];
2424               y = data.gnl_colour.rgb[1];
2425               z = data.gnl_colour.rgb[2];
2426             }
2427           }
2428           else
2429           {
2430             printf("\tELEM_LINE_COLR\n");
2431             printf("\t\tPOLYLINE COLOUR r %f g %f b %f\n",
2432               data.gnl_colour.rgb[0],
2433               data.gnl_colour.rgb[1],
2434               data.gnl_colour.rgb[2]);
2435           }
2436           break;
2437         }
2438       case CALL_PHIGS_ELEM_INT_COLR :
2439         {
2440           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2441           if( elem_num )
2442           {
2443             if (IndCur >= 1)
2444               EndExplo = 1;
2445             else
2446             {
2447               x = data.gnl_colour.rgb[0];
2448               y = data.gnl_colour.rgb[1];
2449               z = data.gnl_colour.rgb[2];
2450             }
2451           }
2452           else
2453           {
2454             printf("\tELEM_INT_COLR\n");
2455             printf("\t\tINTERIOR COLOUR r %f g %f b %f\n",
2456               data.gnl_colour.rgb[0],
2457               data.gnl_colour.rgb[1],
2458               data.gnl_colour.rgb[2]);
2459           }
2460           break;
2461         }
2462       case CALL_PHIGS_ELEM_BACK_INT_COLR :
2463         {
2464           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2465           if( elem_num )
2466           {
2467             if (IndCur >= 1)
2468               EndExplo = 1;
2469             else
2470             {
2471               x = data.gnl_colour.rgb[0];
2472               y = data.gnl_colour.rgb[1];
2473               z = data.gnl_colour.rgb[2];
2474             }
2475           }
2476           else
2477           {
2478             printf("\tELEM_BACK_INT_COLR\n");
2479             printf("\t\tBACK INTERIOR COLOUR r %f g %f b %f\n",
2480               data.gnl_colour.rgb[0],
2481               data.gnl_colour.rgb[1],
2482               data.gnl_colour.rgb[2]);
2483           }
2484           break;
2485         }
2486       case CALL_PHIGS_ELEM_REFL_PROPS :
2487         {
2488           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2489           if( elem_num )
2490           {
2491             if (IndCur == 0)
2492             {
2493               x = data.surf_prop.amb;
2494               y = data.surf_prop.diff;
2495               z = data.surf_prop.trans;
2496             }
2497             if (IndCur == 1)
2498             {
2499               x = data.surf_prop.speccol.rgb[0];
2500               y = data.surf_prop.speccol.rgb[1];
2501               z = data.surf_prop.speccol.rgb[2];
2502             }
2503             if (IndCur == 2)
2504             {
2505               x = data.surf_prop.spec;
2506               y = data.surf_prop.shine;
2507               z = ( float )0.0;
2508             }
2509             if (IndCur >= 3)
2510               EndExplo = 1;
2511           }
2512           else
2513           {
2514             printf("\tELEM_REFL_PROPS\n");
2515             printf("\t\tREFLECTANCE PROPERTIES\n");
2516             printf("\t\tamb coef %f diff coef %f trans coef %f\n",
2517               data.surf_prop.amb,
2518               data.surf_prop.diff,
2519               data.surf_prop.trans);
2520             printf("\t\tspecular color r %f g %f b %f\n",
2521               data.surf_prop.speccol.rgb[0],
2522               data.surf_prop.speccol.rgb[1],
2523               data.surf_prop.speccol.rgb[2]);
2524             printf("\t\tspecular coef %f exp %f\n",
2525               data.surf_prop.spec,
2526               data.surf_prop.shine);
2527           }
2528           break;
2529         }
2530       case CALL_PHIGS_ELEM_BACK_REFL_PROPS :
2531         {
2532           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2533           if( elem_num )
2534           {
2535             if (IndCur == 0) {
2536               x = data.surf_prop.amb;
2537               y = data.surf_prop.diff;
2538               z = data.surf_prop.trans;
2539             }
2540             if (IndCur == 1) {
2541               x = data.surf_prop.speccol.rgb[0];
2542               y = data.surf_prop.speccol.rgb[1];
2543               z = data.surf_prop.speccol.rgb[2];
2544             }
2545             if (IndCur == 2) {
2546               x = data.surf_prop.spec;
2547               y = data.surf_prop.shine;
2548               z = ( float )0.0;
2549             }
2550             if (IndCur >= 3)
2551               EndExplo = 1;
2552           }
2553           else
2554           {
2555             printf("\tELEM_BACK_REFL_PROPS\n");
2556             printf("\t\tBACK REFLECTANCE PROPERTIES\n");
2557             printf("\t\tamb coef %f diff coef %f trans coef %f\n",
2558               data.surf_prop.amb,
2559               data.surf_prop.diff,
2560               data.surf_prop.trans);
2561             printf("\t\tspecular color r %f g %f b %f\n",
2562               data.surf_prop.speccol.rgb[0],
2563               data.surf_prop.speccol.rgb[1],
2564               data.surf_prop.speccol.rgb[2]);
2565             printf("\t\tspecular coef %f exp %f\n",
2566               data.surf_prop.spec,
2567               data.surf_prop.shine);
2568           }
2569           break;
2570         }
2571       case CALL_PHIGS_ELEM_INT_SHAD_METH :
2572         {
2573           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2574           if( elem_num )
2575           {
2576             if (IndCur >= 1)
2577               EndExplo = 1;
2578             else
2579             {
2580               x = ( float )data.idata;
2581               y = ( float )0.0;
2582               z = ( float )0.0;
2583             }
2584           }
2585           else
2586           {
2587             printf("\tELEM_INT_SHAD_METH\n");
2588             printf("\t\tINTERIOR SHADING METHOD %d\n", data.idata);
2589           }
2590           break;
2591         }
2592       case CALL_PHIGS_ELEM_INT_REFL_EQN :
2593         {
2594           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2595           if( elem_num )
2596           {
2597             if (IndCur >= 1)
2598               EndExplo = 1;
2599             else
2600             {
2601               x = ( float )data.idata;
2602               y = ( float )0.0;
2603               z = ( float )0.0;
2604             }
2605           }
2606           else
2607           {
2608             printf("\tELEM_INT_REFL_EQN\n");
2609             printf("\t\tREFLECTANCE EQUATION %d\n", data.idata);
2610           }
2611           break;
2612         }
2613       case CALL_PHIGS_ELEM_BACK_INT_REFL_EQN :
2614         {
2615           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2616           if( elem_num )
2617           {
2618             if (IndCur >= 1)
2619               EndExplo = 1;
2620             else
2621             {
2622               x = ( float )data.idata;
2623               y = ( float )0.0;
2624               z = ( float )0.0;
2625             }
2626           }
2627           else
2628           {
2629             printf("\tELEM_BACK_INT_REFL_EQN\n");
2630             printf("\t\tBACK INTERIOR REFLECTANCE EQUATION %d\n",
2631               data.idata);
2632           }
2633           break;
2634         }
2635       case CALL_PHIGS_ELEM_FACE_DISTING_MODE :
2636         {
2637           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2638           if( elem_num )
2639           {
2640             if (IndCur >= 1)
2641               EndExplo = 1;
2642             else
2643             {
2644               x = ( float )data.idata;
2645               y = ( float )0.0;
2646               z = ( float )0.0;
2647             }
2648           }
2649           else
2650           {
2651             printf("\tELEM_FACE_DISTING_MODE\n");
2652             printf("\t\tFACE DISTINGUISHING MODE %d\n", data.idata);
2653           }
2654           break;
2655         }
2656       case CALL_PHIGS_ELEM_FACE_CULL_MODE :
2657         {
2658           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2659           if( elem_num )
2660           {
2661             if (IndCur >= 1)
2662               EndExplo = 1;
2663             else
2664             {
2665               x = ( float )data.idata;
2666               y = ( float )0.0;
2667               z = ( float )0.0;
2668             }
2669           }
2670           else
2671           {
2672             printf("\tELEM_FACE_CULL_MODE\n");
2673             printf("\t\tFACE CULLING MODE %d\n", data.idata);
2674           }
2675           break;
2676         }
2677       case CALL_PHIGS_ELEM_LIGHT_SRC_STATE :
2678         {
2679           buffer = new Tchar[size];
2680           TelInqCurElemContent( size, buffer, &actual_size, &data );
2681           idata        = data.light_source_state.on.number;
2682           jdata        = data.light_source_state.off.number;
2683           if( elem_num )
2684           {
2685             if ( (IndCur >= idata) && (IndCur >= jdata) )
2686               EndExplo = 1;
2687             else
2688             {
2689               if (IndCur < idata)
2690                 x = ( float )data.light_source_state.on.integers[IndCur];
2691               if (IndCur < jdata)
2692                 nx = ( float )data.light_source_state.off.integers[IndCur];
2693             }
2694           }
2695           else
2696           {
2697             printf("\tELEM_LIGHT_SRC_STATE\n");
2698             for (i=0; i<idata; i++)
2699               printf("\t\tactive light %d\n",
2700               data.light_source_state.on.integers[i]);
2701             for (j=0; j<jdata; j++)
2702               printf("\t\tinactive light %d\n",
2703               data.light_source_state.off.integers[j]);
2704           }
2705           delete[] buffer;
2706           break;
2707         }
2708       case CALL_PHIGS_ELEM_DCUE_IND :
2709         {
2710           TelInqCurElemContent( 0, buffer, &actual_size, &data );
2711           if( elem_num )
2712           {
2713             if (IndCur >= 1)
2714               EndExplo = 1;
2715             else
2716             {
2717               x = ( float )data.idata;
2718               y = ( float )0.0;
2719               z = ( float )0.0;
2720             }
2721           }
2722           else
2723           {
2724             printf("\tELEM_DCUE_IND\n");
2725             printf("\t\tDEPTH CUE INDEX %d\n", data.idata);
2726           }
2727           break;
2728         }
2729       default:
2730         break;
2731       }
2732     }
2733
2734     if( elem_num )
2735     {
2736       index   = 0;
2737       pt->x   = x;
2738       pt->y   = y;
2739       pt->z   = z;
2740       npt->dx = nx;
2741       npt->dy = ny;
2742       npt->dz = nz;
2743       cpt->r  = r;
2744       cpt->g  = g;
2745       cpt->b  = b;
2746       nfa->dx = dx;
2747       nfa->dy = dy;
2748       nfa->dz = dz;
2749
2750       if( EndExplo )
2751         *elem_type = 0;
2752     }
2753     else
2754       index ++;
2755   }        /* while (index) */
2756
2757   call_func_close_struct ();
2758 }
2759
2760 Tint
2761 call_subr_inquirews( Tint struct_id, Tint *ws_id )
2762 {
2763   Tint act_size;
2764
2765   TsmGetWSPosted( struct_id, 1, ws_id, &act_size );
2766
2767   if( act_size )
2768     return 1;
2769   else
2770     return 0;
2771 }
2772
2773
2774 void
2775 call_subr_polygon_holes( CALL_DEF_LISTFACETS * alfacets )
2776 {
2777   register int i, j, k;
2778   int go;
2779   CMN_KEY k1, k2, k3;
2780
2781   Tint      *bounds;
2782   TEL_POINT *points;
2783
2784   bounds = new Tint[alfacets->NbFacets];
2785
2786   j = 0;
2787   for( i=0; i<alfacets->NbFacets; i++ )
2788     j += alfacets->LFacets[i].NbPoints;
2789
2790   points = new TEL_POINT[j];
2791
2792   for( i = 0; i < alfacets->NbFacets; i++ )
2793     bounds[i] = alfacets->LFacets[i].NbPoints;
2794
2795   k = 0;
2796   for (i=0; i<alfacets->NbFacets; i++)
2797   {
2798     for (j=0; j<alfacets->LFacets[i].NbPoints; j++)
2799     {
2800       points[k].xyz[0] = alfacets->LFacets[i].UPoints.Points[j].x;
2801       points[k].xyz[1] = alfacets->LFacets[i].UPoints.Points[j].y;
2802       points[k].xyz[2] = alfacets->LFacets[i].UPoints.Points[j].z;
2803       k++;
2804     }
2805   }
2806
2807   go = 1;
2808   if( bounds == 0 )
2809     go = 0;
2810   if( points == 0 )
2811     go = 0;
2812
2813   if( go )
2814   {
2815     k1.id = NUM_FACETS_ID;
2816     k1.data.ldata = alfacets->NbFacets;
2817     k2.id = BOUNDS_DATA_ID;
2818     k2.data.pdata = bounds;
2819     k3.id = VERTICES_ID;
2820     k3.data.pdata = points;
2821
2822     TsmAddToStructure( TelPolygonHoles, 3, &k1, &k2, &k3 );
2823   }
2824
2825   if( bounds != 0 )
2826     delete[] bounds;
2827   if( points != 0 )
2828     delete[] points;
2829 }
2830
2831 void
2832 call_subr_polygon_holes_data( CALL_DEF_LISTFACETS * alfacets )
2833 {
2834   register Tint i, j, k, count=0;
2835   CMN_KEY key[10];
2836   cmn_key kk[10];
2837   int go;
2838   Tint num_vertices;
2839   Tint num_bounds, *bounds = 0;
2840   TEL_POINT *vertices = 0;
2841   TEL_POINT *vnormals = 0;
2842
2843   for( i = 0; i < 10; i++ )
2844     kk[i] = &key[i];
2845
2846   key[count].id = SHAPE_FLAG_ID;
2847   key[count].data.ldata = TEL_SHAPE_UNKNOWN;
2848   count++;
2849
2850   key[count].id = NUM_FACETS_ID;
2851   key[count].data.ldata = alfacets->NbFacets;
2852   count++;
2853
2854   num_bounds = alfacets->NbFacets;
2855   bounds = new Tint[num_bounds];
2856
2857   key[count].id = BOUNDS_DATA_ID;
2858   key[count].data.pdata = bounds;
2859   count++;
2860
2861   num_vertices = 0;
2862   for( i=0; i<num_bounds; i++ )
2863     num_vertices += alfacets->LFacets[i].NbPoints;
2864
2865   k = 0;
2866   for( i=0; i<num_bounds; i++ )
2867   {
2868     bounds[i] = alfacets->LFacets[i].NbPoints;
2869
2870     switch( alfacets->LFacets[i].TypePoints )
2871     {
2872     case 1 : /* Coordinates Specified */
2873       {
2874         if( vertices == 0 )
2875         {
2876           vertices = new TEL_POINT[num_vertices];
2877
2878           key[count].id = VERTICES_ID;
2879           key[count].data.pdata = vertices;
2880           count++;
2881         }
2882
2883         for( j=0; j<alfacets->LFacets[i].NbPoints; j++ )
2884         {
2885           vertices[k].xyz[0] = alfacets->LFacets[i].UPoints.Points[j].x;
2886           vertices[k].xyz[1] = alfacets->LFacets[i].UPoints.Points[j].y;
2887           vertices[k].xyz[2] = alfacets->LFacets[i].UPoints.Points[j].z;
2888           k++;
2889         }
2890
2891         break;
2892       }
2893
2894     case 2 : /* Coordinates and Vertex Normal Specified */
2895       {
2896         if( vertices == 0 )
2897         {
2898           vertices = new TEL_POINT[num_vertices];
2899
2900           key[count].id = VERTICES_ID;
2901           key[count].data.pdata = vertices;
2902           count++;
2903
2904           vnormals = new TEL_POINT[num_vertices];
2905           key[count].id = VNORMALS_ID;
2906           key[count].data.pdata = vnormals;
2907           count++;
2908         }
2909
2910         for( j=0; j<alfacets->LFacets[i].NbPoints; j++ )
2911         {
2912           vertices[k].xyz[0] =
2913             alfacets->LFacets[i].UPoints.PointsN[j].Point.x;
2914           vertices[k].xyz[1] =
2915             alfacets->LFacets[i].UPoints.PointsN[j].Point.y;
2916           vertices[k].xyz[2] =
2917             alfacets->LFacets[i].UPoints.PointsN[j].Point.z;
2918           vnormals[k].xyz[0] =
2919             alfacets->LFacets[i].UPoints.PointsN[j].Normal.dx;
2920           vnormals[k].xyz[1] =
2921             alfacets->LFacets[i].UPoints.PointsN[j].Normal.dy;
2922           vnormals[k].xyz[2] =
2923             alfacets->LFacets[i].UPoints.PointsN[j].Normal.dz;
2924           k++;
2925         }
2926
2927         break;
2928       }
2929     }
2930   }
2931
2932   go = 1;
2933   if(bounds == 0)
2934     go = 0;
2935   if(vertices == 0)
2936     go = 0;
2937   if(vnormals == 0)
2938     go = 0;
2939
2940   if(go)
2941   {
2942     TsmAddToStructure( TelPolygonHoles, -count, kk );
2943   }
2944
2945   if(bounds)
2946     delete[] bounds;
2947   if(vertices)
2948     delete[] vertices;
2949   if(vnormals)
2950     delete[] vnormals;
2951 }
2952
2953
2954 void
2955 call_subr_curve( CALL_DEF_LISTPOINTS * alpoints )
2956 {
2957   CMN_KEY  key[3];
2958   cmn_key  kp[3];
2959
2960   kp[0] = &key[0], kp[1] = &key[1], kp[2] = &key[2];
2961
2962   key[0].id = CURVE_TYPE_ID;
2963   key[0].data.ldata = TelBezierCurve;
2964
2965   key[1].id = CURVE_NUM_POINTS_ID;
2966   key[1].data.ldata = 20;
2967
2968   key[2].id = CURVE_VERTICES_ID;
2969   key[2].data.pdata = alpoints->UPoints.Points;
2970
2971   TsmAddToStructure( TelCurve, -3, kp );
2972
2973   return;
2974 }
2975
2976 /* *** PARRAY functions *** */
2977
2978 void call_subr_parray( CALL_DEF_PARRAY *parray )
2979 {
2980   CMN_KEY      key;
2981   key.id = PARRAY_ID;
2982   key.data.pdata = (void *) parray;
2983
2984   TsmAddToStructure( TelParray, 1, &key );
2985 }
2986
2987 void call_subr_userdraw( CALL_DEF_USERDRAW *anobject )
2988 {
2989   CMN_KEY  key;
2990
2991   key.id = 1;
2992   key.data.pdata = anobject;
2993
2994   TsmAddToStructure( TelUserdraw, 1, &key );
2995 }