0022819: Redesign of OpenGl driver
[occt.git] / src / OpenGl / OpenGl_Trihedron.cxx
1 // File:      OpenGl_Trihedron.cxx
2 // Created:   20 September 2011
3 // Author:    Sergey ZERCHANINOV
4 // Copyright: OPEN CASCADE 2011
5
6 #define QTOCC_PATCH   /* Active QtOPENCASCADE patches */
7
8 #include <OpenGl_tgl_all.hxx>
9
10 #include <stddef.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <math.h> /* pour M_PI */
14
15 #include <OpenGl_TextureBox.hxx>
16
17 #include <InterfaceGraphic_Graphic3d.hxx>  /* pour CALL_DEF_STRUCTURE */
18 #include <InterfaceGraphic_Aspect.hxx>  /* pour CALL_DEF_VIEW  */
19 #include <InterfaceGraphic_Visual3d.hxx>
20
21 #include <OpenGl_transform_persistence.hxx>
22
23 #ifdef HAVE_GL2PS
24 #include <gl2ps.h>
25 #endif
26
27 #ifdef HAVE_CONFIG_H
28 #include <config.h>
29 #endif
30 #ifdef HAVE_STRING_H
31 #include <string.h>
32 #endif
33
34 #include <OpenGl_Workspace.hxx>
35 #include <OpenGl_View.hxx>
36 #include <OpenGl_Trihedron.hxx>
37
38 IMPLEMENT_STANDARD_HANDLE(OpenGl_Trihedron,MMgt_TShared)
39 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Trihedron,MMgt_TShared)
40
41 /*----------------------------------------------------------------------*/
42 /*
43 * Constantes
44 */ 
45
46 #define NO_DEBUG
47 #define NO_PRINT
48 #define NO_PRINT_MATRIX
49
50 #ifndef M_PI
51 # define M_PI          3.14159265358979323846
52 #endif
53
54 static const CALL_DEF_CONTEXTLINE myDefaultContextLine =
55 {
56   1, //IsDef
57   1, //IsSet
58   { 1.F, 1.F, 1.F }, //Color
59   Aspect_TOL_SOLID, //LineType
60   1.F //Width
61 };
62
63 static const CALL_DEF_CONTEXTTEXT myDefaultContextText =
64 {
65   1, //IsDef
66   1, //IsSet
67   "Courier", //Font
68   0.3F, //Space
69   1.0F, //Expan
70   { 1.F, 1.F, 1.F }, //Color
71   Aspect_TOST_NORMAL, //Style
72   Aspect_TODT_NORMAL, //DisplayType
73   { 1.F, 1.F, 1.F }, //ColorSubTitle
74   0, //TextZoomable
75   0.F, //TextAngle
76   OSD_FA_Regular //TextFontAspect
77 };
78
79 /*----------------------------------------------------------------------*/
80 /*
81 * Variables statiques
82 */
83
84 /* Default parameters for ZBUFFER triheron */
85 static TEL_COLOUR theXColor = {{ 1.F, 0.F, 0.F, 0.6F }};
86 static TEL_COLOUR theYColor = {{ 0.F, 1.F, 0.F, 0.6F }};
87 static TEL_COLOUR theZColor = {{ 0.F, 0.F, 1.F, 0.6F }};
88 static float theRatio = 0.8f;
89 static float theDiameter = 0.05f;
90 static int   theNbFacettes = 12;
91
92 /*----------------------------------------------------------------------*/
93
94 /*
95 * affichage d'un triedre non zoomable a partir des index dans les tables
96 * des structures non zoomables.
97 *
98 * Triedre = Objet non Zoomable :
99 * on recalcule ses dimensions et son origine en fonction de la taille
100 * de la fenetre; on positionne selon le choix de l'init;
101 * et on inhibe seulement les translations.
102 *
103 */
104
105 //call_triedron_redraw
106 void OpenGl_Trihedron::Redraw (const Handle(OpenGl_Workspace) &AWorkspace) const
107 {
108   const Standard_Real U = AWorkspace->ActiveView()->Height();
109   const Standard_Real V = AWorkspace->ActiveView()->Width();
110
111   /* la taille des axes est 1 proportion (fixee a l'init du triedre) */
112   /* de la dimension la plus petite de la window.                    */ 
113   const GLdouble L = ( U < V ? U : V ) * myScale;
114
115   /*
116   * On inhibe les translations; on conserve les autres transformations.
117   */
118
119   /* on lit les matrices de transformation et de projection de la vue */
120   /* pour annuler les translations (dernieres colonnes des matrices). */
121   GLdouble modelMatrix[4][4];
122   glGetDoublev( GL_MODELVIEW_MATRIX,  (GLdouble *) modelMatrix );
123   GLdouble projMatrix[4][4];
124   glGetDoublev( GL_PROJECTION_MATRIX, (GLdouble *) projMatrix );
125
126   /* on annule la translation qui peut etre affectee a la vue */
127   modelMatrix[3][0] = 0.;
128   modelMatrix[3][1] = 0.;
129   modelMatrix[3][2] = 0.;
130   projMatrix[3][0] = 0.;
131   projMatrix[3][1] = 0.;
132   projMatrix[3][2] = 0.;
133
134   /* sauvegarde du contexte des matrices avant chargement */
135   glMatrixMode (GL_MODELVIEW);
136   glPushMatrix ();
137   glLoadMatrixd( (GLdouble *) modelMatrix );
138   glMatrixMode ( GL_PROJECTION );
139   glPushMatrix ();
140   glLoadMatrixd( (GLdouble *) projMatrix );
141
142   /*
143   * Positionnement de l'origine du triedre selon le choix de l'init
144   */
145
146   /* on fait uniquement une translation de l'origine du Triedre */
147
148   switch (myPos)
149   {
150     case Aspect_TOTP_LEFT_LOWER :
151       glTranslated( -0.5*U + L , -0.5*V + L , 0. );
152       break;
153
154     case Aspect_TOTP_LEFT_UPPER :
155       glTranslated( -0.5*U + L , +0.5*V - L -L/3., 0. );
156       break;
157
158     case Aspect_TOTP_RIGHT_LOWER :
159       glTranslated( 0.5*U - L -L/3. , -0.5*V + L , 0. );
160       break;
161
162     case Aspect_TOTP_RIGHT_UPPER :
163       glTranslated( 0.5*U - L -L/3. , +0.5*V - L -L/3. , 0. );
164       break;
165
166     //case Aspect_TOTP_CENTER :
167     default :
168       break;
169   }
170
171   /* 
172   * Creation du triedre 
173   */
174   const OpenGl_AspectLine *AspectLine = AWorkspace->AspectLine( Standard_True );
175
176 #ifdef QTOCC_PATCH /* Fotis Sioutis 2007-11-14 15:06 
177   I have also seen in previous posts that the view trihedron in V3d_WIREFRAME mode 
178   changes colors depending on the state of the view. This behaviour can be easily 
179   corrected by altering call_triedron_redraw function in OpenGl_triedron.c of TKOpengl.
180   The only change needed is to erase glDisable(GL_LIGHTING) that is called before the 
181   Axis name drawing and move this function call just before the initial axis drawing.
182   Below is the code portion with the modification.I don't know if this is considered to 
183   be a bug but anyway i believe it might help some of you out there.*/
184   glDisable(GL_LIGHTING);
185 #endif
186
187   /* Position de l'origine */
188   const GLdouble TriedronOrigin[3] = { 0.0, 0.0, 0.0 };
189
190   /* Position des Axes */
191   GLdouble TriedronAxeX[3] = { 1.0, 0.0, 0.0 };
192   GLdouble TriedronAxeY[3] = { 0.0, 1.0, 0.0 };
193   GLdouble TriedronAxeZ[3] = { 0.0, 0.0, 1.0 };
194   TriedronAxeX[0] = L ;
195   TriedronAxeY[1] = L ;
196   TriedronAxeZ[2] = L ;
197
198   /* dessin des axes */
199   glBegin(GL_LINES);
200   glVertex3dv( TriedronOrigin );
201   glVertex3dv( TriedronAxeX );
202
203   glVertex3dv( TriedronOrigin );
204   glVertex3dv( TriedronAxeY );
205
206   glVertex3dv( TriedronOrigin );
207   glVertex3dv( TriedronAxeZ );
208   glEnd();
209
210   /* fleches au bout des axes (= cones de la couleur demandee) */
211   const GLdouble l = 0.75*L; /* distance a l'origine */
212   const GLdouble rayon = L/30. ; /* rayon de la base du cone */
213   const int NbFacettes = 12; /* le cone sera compose de 12 facettes triangulaires */
214   const double Angle = 2. * M_PI/ NbFacettes;
215
216   int      ii;
217   GLdouble TriedronCoord[3] = { 1.0, 0.0, 0.0 };
218
219   /* solution FILAIRE des cones au bout des axes : une seule ligne */
220   glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
221   /* (la couleur est deja initialisee dans AspectLine) */
222   /* FIN de la solution FILAIRE CHOISIE pour les cones des axes */
223
224   /* fleche en X */
225   glBegin(GL_TRIANGLE_FAN);
226   glVertex3dv( TriedronAxeX );
227   TriedronCoord[0] = l;
228   ii = NbFacettes;
229   while (ii >= 0 ) {
230     TriedronCoord[1] = rayon * sin(ii * Angle);
231     TriedronCoord[2] = rayon * cos(ii * Angle);
232     glVertex3dv( TriedronCoord );
233     ii--;
234   }
235   glEnd();
236
237   /* fleche en Y */
238   glBegin(GL_TRIANGLE_FAN);
239   glVertex3dv( TriedronAxeY );
240   TriedronCoord[1] = l;
241   ii = NbFacettes;
242   while (ii >= 0 ) {
243     TriedronCoord[0] = rayon * cos(ii * Angle);
244     TriedronCoord[2] = rayon * sin(ii * Angle);
245     glVertex3dv( TriedronCoord );
246     ii--;
247   }
248   glEnd();
249
250   /* fleche en Z */
251   glBegin(GL_TRIANGLE_FAN);
252   glVertex3dv( TriedronAxeZ );
253   TriedronCoord[2] = l;
254   ii = NbFacettes;
255   while (ii >= 0 ) {
256     TriedronCoord[0] = rayon * sin(ii * Angle);
257     TriedronCoord[1] = rayon * cos(ii * Angle);
258     glVertex3dv( TriedronCoord );
259     ii--;
260   }
261   glEnd();
262
263   /* dessin de l'origine */
264   TriedronCoord[2] = 0.0 ;
265   ii = 24 ;
266   const double Angle1 = 2. * M_PI/ ii;
267   glBegin(GL_LINE_LOOP);
268   while (ii >= 0 ) {
269     TriedronCoord[0] = rayon * sin(ii * Angle1);
270     TriedronCoord[1] = rayon * cos(ii * Angle1);
271     glVertex3dv( TriedronCoord );
272     ii--;
273   }  
274   glEnd();
275
276   /* 
277   * Noms des axes et de l'origine
278   */
279   const OpenGl_AspectText *AspectText = AWorkspace->AspectText( Standard_True );
280   glColor3fv (AspectText->Color().rgb);
281
282   AWorkspace->RenderText (L"X", 0, float(L + rayon),    0.0f,                   float(-rayon));
283   AWorkspace->RenderText (L"Y", 0, float(rayon),        float(L + 3.0 * rayon), float(2.0 * rayon));
284   AWorkspace->RenderText (L"Z", 0, float(-2.0 * rayon), float(0.5 * rayon),     float(L + 3.0 * rayon));
285
286   /* 
287   * restauration du contexte des matrices
288   */
289   glMatrixMode (GL_PROJECTION);
290   glPopMatrix ();
291   glMatrixMode (GL_MODELVIEW);
292   glPopMatrix ();
293 }
294
295
296 /*******************************************************
297 *  Draws ZBUFFER trihedron mode
298 *******************************************************/
299 //call_zbuffer_triedron_redraw
300 void OpenGl_Trihedron::RedrawZBuffer (const Handle(OpenGl_Workspace) &AWorkspace) const
301 {
302   const Standard_Real U = AWorkspace->ActiveView()->Height();
303   const Standard_Real V = AWorkspace->ActiveView()->Width();
304
305   GLdouble modelMatrix[4][4];
306   glGetDoublev( GL_MODELVIEW_MATRIX,  (GLdouble *) modelMatrix );
307   GLdouble projMatrix[4][4];
308   glGetDoublev( GL_PROJECTION_MATRIX, (GLdouble *) projMatrix );
309
310   /* Check position in the ViewPort */
311 #ifdef QTOCC_PATCH /* PCD 29/09/2008 */
312   /* Simple code modification recommended by Fotis Sioutis and Peter Dolbey  */
313   /* to remove the irritating default behaviour of triedrons using V3d_ZBUFFER   */
314   /* which causes the glyph to jump around the screen when the origin moves offscreen. */
315   GLboolean isWithinView = GL_FALSE;
316 #else
317   /* Original code */
318   GLint   aViewPort[4];  /* to store view port coordinates */
319   glGetIntegerv(GL_VIEWPORT, aViewPort);
320   GLdouble aWinCoord[3];
321   /* Position de l'origine */
322   const GLdouble TriedronOrigin[3] = { 0.0, 0.0, 0.0 };
323   gluProject(TriedronOrigin[0], TriedronOrigin[1], TriedronOrigin[2],
324              (GLdouble *)modelMatrix, (GLdouble *)projMatrix, aViewPort,
325              &aWinCoord[0], &aWinCoord[1], &aWinCoord[2]);
326
327   GLboolean isWithinView = !((aWinCoord[0]<aViewPort[0]) || (aWinCoord[0]>aViewPort[2]) ||
328                              (aWinCoord[1]<aViewPort[1]) || (aWinCoord[1]>aViewPort[3]));
329 #endif
330
331   /* la taille des axes est 1 proportion (fixee a l'init du triedre) */
332   /* de la dimension la plus petite de la window.                    */ 
333   GLdouble L = ( U < V ? U : V ) * myScale;
334
335   if (!isWithinView)
336   {
337     /* Annulate translation matrix */
338     modelMatrix[3][0] = 0.;
339     modelMatrix[3][1] = 0.;
340     modelMatrix[3][2] = 0.;
341     projMatrix[3][0] = 0.;
342     projMatrix[3][1] = 0.;
343     projMatrix[3][2] = 0.;
344
345     /* save matrix */
346     glMatrixMode (GL_MODELVIEW);
347     glPushMatrix ();
348     //glLoadIdentity ();
349     glLoadMatrixd( (GLdouble *) modelMatrix);
350     glMatrixMode ( GL_PROJECTION );
351     glPushMatrix ();
352     //glLoadIdentity();
353     glLoadMatrixd( (GLdouble *) projMatrix);
354
355     /*
356     * Define position in the view
357     */
358     switch (myPos)
359     {
360       case Aspect_TOTP_LEFT_LOWER : 
361         glTranslated( -0.5*U + L , -0.5*V + L , 0. );
362         break;
363
364       case Aspect_TOTP_LEFT_UPPER :
365         glTranslated( -0.5*U + L , +0.5*V - L -L/3. , 0. );
366         break;
367
368       case Aspect_TOTP_RIGHT_LOWER :
369         glTranslated( 0.5*U - L -L/3. , -0.5*V + L , 0. );
370         break;
371
372       case Aspect_TOTP_RIGHT_UPPER :
373         glTranslated( 0.5*U - L -L/3. , +0.5*V - L -L/3. , 0. );
374         break;
375
376       //case Aspect_TOTP_CENTER :
377       default :
378         break;
379     }
380     L *= myRatio;
381   }
382
383   const OpenGl_AspectLine *AspectLine = AWorkspace->AspectLine( Standard_True );
384   const TEL_COLOUR &aLineColor = AspectLine->Color();
385
386   /* 
387   * Creation the trihedron
388   */
389 #define CYLINDER_LENGTH   0.75f
390
391   const GLuint startList = glGenLists(4);
392   GLUquadricObj* aQuadric = gluNewQuadric();
393
394   const GLboolean aIsDepthEnabled = glIsEnabled(GL_DEPTH_TEST);
395
396 #ifndef BUG
397
398   GLboolean aIsDepthMaskEnabled;
399 #ifdef QTOCC_PATCH  /*PCD 02/07/07   */
400   /* GL_DEPTH_WRITEMASK is not a valid argument to glIsEnabled, the  */
401   /* original code is shown to be broken when run under an OpenGL debugger  */
402   /* like GLIntercept. This is the correct way to retrieve the mask value.  */
403   glGetBooleanv(GL_DEPTH_WRITEMASK, &aIsDepthMaskEnabled); 
404 #else
405   aIsDepthMaskEnabled = glIsEnabled(GL_DEPTH_WRITEMASK);
406 #endif
407
408 #endif 
409
410   const GLdouble aCylinderLength = L * CYLINDER_LENGTH;
411   const GLdouble aCylinderDiametr = L * myDiameter;
412   const GLdouble aConeDiametr = aCylinderDiametr * 2.;
413   const GLdouble aConeLength = L * (1 - CYLINDER_LENGTH);
414   /* Correct for owerlapping */
415   /*    aCylinderLength += aConeLength - 1.2*aCylinderDiametr*aConeLength/aConeDiametr;*/
416
417   /* Create cylinder for axis */
418   gluQuadricDrawStyle(aQuadric, GLU_FILL); /* smooth shaded */
419   gluQuadricNormals(aQuadric, GLU_FLAT);
420   /* Axis */
421   glNewList(startList, GL_COMPILE);
422   gluCylinder(aQuadric, aCylinderDiametr, aCylinderDiametr, aCylinderLength, myNbFacettes, 1);
423   glEndList();
424   /* Cone */
425   glNewList(startList + 1, GL_COMPILE);
426   gluCylinder(aQuadric, aConeDiametr, 0., aConeLength, myNbFacettes, 1);
427   glEndList();
428   /* Central sphere */
429   glNewList(startList + 2, GL_COMPILE);
430   gluSphere(aQuadric, aCylinderDiametr * 2., myNbFacettes, myNbFacettes);
431   glEndList();
432   /* End disk */
433   gluQuadricOrientation(aQuadric,GLU_INSIDE); /*szv*/
434   glNewList(startList + 3, GL_COMPILE);
435   gluDisk(aQuadric, aCylinderDiametr, aConeDiametr, myNbFacettes, 1/*szv:2*/);
436   glEndList();
437
438   /* Store previous attributes */
439   glPushAttrib(GL_LIGHTING_BIT | GL_POLYGON_BIT);
440   glEnable(GL_LIGHTING);
441
442   glCullFace(GL_BACK);
443   glEnable(GL_CULL_FACE);
444
445 #ifdef QTOCC_PATCH /*Fotis Sioutis | 2008-01-21 10:55
446   In the function call_zbuffer_triedron_redraw of TKOpengl, 
447   the z buffered trihedron changes colors in case there 
448   is an object in the scene that has an explicit material 
449   attached to it.In the trihedron display loop, 
450   GL_COLOR_MATERIAL is enabled, but only the GL_DIFFUSE 
451   parameter is utilized in glColorMaterial(...).
452   This causes the last ambient,specular and emission values 
453   used, to stay at the stack and applied to the trihedron
454   (which causes the color change).
455   A fix is proposed , to change GL_DIFFUSE to 
456   GL_AMBIENT_AND_DIFFUSE in glColorMaterial call in 
457   line 946.The above of course will leave unchanged 
458   the SPECULAR and EMISSION values.
459   Another proposal which would fix 100% the problem 
460   is to use glMaterial instead of glColor on the trihedron 
461   drawing loop.               */
462   const GLfloat aNULLColor[] = { 0.f, 0.f, 0.f, 0.f }; /* FS 21/01/08 */
463   glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, aNULLColor);
464   glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, aNULLColor);
465   glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, aNULLColor);
466   glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.f);
467 #endif
468
469   glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
470   glEnable(GL_COLOR_MATERIAL);
471
472   if (!aIsDepthEnabled)  {
473     glEnable(GL_DEPTH_TEST);
474 #ifndef BUG
475     glClear(GL_DEPTH_BUFFER_BIT);
476 #endif
477   }
478 #ifdef BUG
479   if (!(aIsDepthEnabled && isWithinView))
480     glClear(GL_DEPTH_BUFFER_BIT);
481 #endif
482
483 #ifndef BUG
484   if (!aIsDepthMaskEnabled)  {
485     /* This is how the depthmask needs to be re-enabled...*/
486     glDepthMask(GL_TRUE);
487     /* ...and not this stuff below */
488   }
489 #endif
490
491   /* Position des Axes */
492   GLdouble TriedronAxeX[3] = { 1.0, 0.0, 0.0 };
493   GLdouble TriedronAxeY[3] = { 0.0, 1.0, 0.0 };
494   GLdouble TriedronAxeZ[3] = { 0.0, 0.0, 1.0 };
495   TriedronAxeX[0] = L;
496   TriedronAxeY[1] = L;
497   TriedronAxeZ[2] = L;
498
499   glMatrixMode(GL_MODELVIEW);
500
501 #ifdef QTOCC_PATCH /* PCD 17/06/07  */
502   GLint df;
503   glGetIntegerv (GL_DEPTH_FUNC, &df); 
504 #else
505   /*
506 #define COLOR_REDUCE      0.3f
507 #ifdef BUG
508 #define ALPHA_REDUCE      0.4f
509 #else
510 #define ALPHA_REDUCE      1.0f
511 #endif
512   //szv:if (isWithinView) {
513   glDepthFunc(GL_GREATER);
514   glPushMatrix();
515   glPushMatrix();
516   glPushMatrix();
517
518   glColor4f(aLineColor.rgb[0]*COLOR_REDUCE, 
519             aLineColor.rgb[1]*COLOR_REDUCE, 
520             aLineColor.rgb[2]*COLOR_REDUCE,
521             ALPHA_REDUCE);
522   glCallList(startList+2);
523
524   // Z axis
525   glColor4f(myZColor.rgb[0]*COLOR_REDUCE, 
526             myZColor.rgb[1]*COLOR_REDUCE, 
527             myZColor.rgb[2]*COLOR_REDUCE,
528             ALPHA_REDUCE);
529   glCallList(startList);
530   glTranslated(0, 0, L * CYLINDER_LENGTH);
531   glCallList(startList + 3);
532   glCallList(startList + 1);
533   glPopMatrix();    
534
535   // X axis
536   glRotated(90.0, TriedronAxeY[0], TriedronAxeY[1], TriedronAxeY[2]);
537   glColor4f(myXColor.rgb[0]*COLOR_REDUCE,
538             myXColor.rgb[1]*COLOR_REDUCE, 
539             myXColor.rgb[2]*COLOR_REDUCE,
540             ALPHA_REDUCE);
541   glCallList(startList);
542   glTranslated(0, 0, L * CYLINDER_LENGTH);
543   glCallList(startList + 3);
544   glCallList(startList + 1);
545   glPopMatrix();    
546
547   // Y axis
548   glRotated(-90.0, TriedronAxeX[0], TriedronAxeX[1], TriedronAxeX[2]);
549   glColor4f(myYColor.rgb[0]*COLOR_REDUCE, 
550             myYColor.rgb[1]*COLOR_REDUCE, 
551             myYColor.rgb[2]*COLOR_REDUCE,
552             ALPHA_REDUCE);
553   glCallList(startList);
554   glTranslated(0, 0, L * CYLINDER_LENGTH);
555   glCallList(startList + 3);
556   glCallList(startList + 1);
557   glPopMatrix();
558
559   glDepthFunc(GL_LESS);
560   //szv:}
561   */
562 #endif
563
564 #ifdef QTOCC_PATCH
565   int i;
566   for (i = 0; i < 2; i++) /* PCD 11/02/08 Two pass method */
567   {
568     if (i == 0) /*  First pass  */
569     {                          
570       glDepthFunc(GL_ALWAYS); 
571     }
572     else
573     {
574       glDepthFunc(GL_LEQUAL); 
575     }
576 #endif
577
578     glPushMatrix();
579     glPushMatrix();
580     glPushMatrix();
581
582     glColor3fv(aLineColor.rgb);
583     glCallList(startList+2);
584
585     // Z axis
586     glColor4fv(myZColor.rgb);
587     glCallList(startList);
588     glTranslated(0, 0, L * CYLINDER_LENGTH);
589     glCallList(startList + 3);
590     glCallList(startList + 1);
591     glPopMatrix();    
592
593     // X axis
594     glRotated(90.0, TriedronAxeY[0], TriedronAxeY[1], TriedronAxeY[2]);
595     glColor4fv(myXColor.rgb);
596     glCallList(startList);
597     glTranslated(0, 0, L * CYLINDER_LENGTH);
598     glCallList(startList + 3);
599     glCallList(startList + 1);
600     glPopMatrix();    
601
602     // Y axis
603     glRotated(-90.0, TriedronAxeX[0], TriedronAxeX[1], TriedronAxeX[2]);
604     glColor4fv(myYColor.rgb);
605     glCallList(startList);
606     glTranslated(0, 0, L * CYLINDER_LENGTH);
607     glCallList(startList + 3);
608     glCallList(startList + 1);
609     glPopMatrix();
610
611 #ifdef QTOCC_PATCH
612   }
613 #endif
614
615   if (!aIsDepthEnabled) 
616     glDisable(GL_DEPTH_TEST);
617 #ifndef BUG
618   if (!aIsDepthMaskEnabled)
619
620 #ifdef QTOCC_PATCH /*PCD 02/07/07   */
621     glDepthMask(GL_FALSE);
622 #else
623     glDisable(GL_DEPTH_WRITEMASK);
624 #endif
625
626 #endif
627   glDisable(GL_CULL_FACE);
628   glDisable(GL_COLOR_MATERIAL);
629
630   gluDeleteQuadric(aQuadric);
631   glColor3fv (aLineColor.rgb);
632
633 #ifdef QTOCC_PATCH /* PCD 11/02/08 */
634   /* Always write the text */
635   glDepthFunc(GL_ALWAYS); 
636 #endif
637
638   glPopAttrib();
639
640   /* fleches au bout des axes (= cones de la couleur demandee) */
641   //const GLdouble l = 0.75*L; /* distance a l'origine */
642   const GLdouble rayon = L/30. ; /* rayon de la base du cone */
643   //const double Angle = 2. * M_PI/ myNbFacettes;
644
645   glDeleteLists(startList, 4); 
646
647   glDisable(GL_LIGHTING);
648
649   /* 
650   * origine names
651   */
652   const OpenGl_AspectText *AspectText = AWorkspace->AspectText( Standard_True );
653   glColor3fv (AspectText->Color().rgb);
654
655   AWorkspace->RenderText (L"X", 0, float(L + rayon),    0.0f,                   float(-rayon));
656   AWorkspace->RenderText (L"Y", 0, float(rayon),        float(L + 3.0 * rayon), float(2.0 * rayon));
657   AWorkspace->RenderText (L"Z", 0, float(-2.0 * rayon), float(0.5 * rayon),     float(L + 3.0 * rayon));
658
659 #ifdef QTOCC_PATCH
660   /*PCD 17/06/07    */
661   glDepthFunc(df);
662 #endif
663
664   if (!isWithinView) { /* restore matrix */
665     glMatrixMode (GL_PROJECTION);
666     glPopMatrix ();
667     glMatrixMode (GL_MODELVIEW);
668     glPopMatrix ();
669   }
670 }
671
672
673 /*----------------------------------------------------------------------*/
674
675 /*----------------------------------------------------------------------*/
676 /*
677 * Fonctions publiques 
678 */
679
680
681 /*
682 * initialisation d'un triedre non zoomable dans une vue.
683 * ou modification des valeurs deja initialisees.
684 */
685
686 //call_triedron_init
687 OpenGl_Trihedron::OpenGl_Trihedron (const Aspect_TypeOfTriedronPosition APosition, const Quantity_NameOfColor AColor,
688                                   const Standard_Real AScale, const Standard_Boolean AsWireframe)
689 : myPos(APosition),
690   myScale(AScale),
691   myIsWireframe(AsWireframe)
692 {
693   Standard_Real R,G,B;
694   Quantity_Color Color(AColor);
695   Color.Values(R,G,B,Quantity_TOC_RGB);
696
697   CALL_DEF_CONTEXTLINE aContextLine = myDefaultContextLine;
698   aContextLine.Color.r = (float)R;
699   aContextLine.Color.g = (float)G;
700   aContextLine.Color.b = (float)B;
701   myAspectLine.SetContext(aContextLine);
702
703   CALL_DEF_CONTEXTTEXT aContextText = myDefaultContextText;
704   aContextText.Color.r = (float)R;
705   aContextText.Color.g = (float)G;
706   aContextText.Color.b = (float)B;
707   myAspectText.SetContext(aContextText);
708
709   myXColor = theXColor;
710   myYColor = theYColor;
711   myZColor = theZColor;
712
713   myRatio = theRatio;
714   myDiameter = theDiameter;
715   myNbFacettes = theNbFacettes;
716 }
717
718 /*----------------------------------------------------------------------*/
719
720 /*
721 * destruction du triedre non zoomable d'une vue.
722 */
723
724 //call_triedron_erase
725 OpenGl_Trihedron::~OpenGl_Trihedron ()
726 {
727 }
728
729 /*----------------------------------------------------------------------*/
730
731 /*
732 * affichage d'un triedre non zoomable dans la wks  awsid 
733 *
734 * Triedre = Objet non Zoomable;
735 * on cree cette fonction pour pouvoir travailler par les structures 
736 * utilisees par les fonctions Tsm* et TEL_VIEW_REP
737 *
738 */
739
740 //call_triedron_redraw_from_wsid
741 void OpenGl_Trihedron::Render (const Handle(OpenGl_Workspace) &AWorkspace) const
742 {
743   const OpenGl_AspectLine *oldAspectLine = AWorkspace->SetAspectLine(&myAspectLine);
744   const OpenGl_AspectText *oldAspectText = AWorkspace->SetAspectText(&myAspectText);
745
746   /* check if GL_LIGHTING should be disabled
747   no enabling 'cause it will be done (if necessary: kinda Polygon types ) 
748   during redrawing structures
749   */
750   if (!AWorkspace->UseGLLight())
751     glDisable( GL_LIGHTING );
752
753   /* sauvegarde du contexte (on reste dans le buffer courant) */
754   const GLboolean save_texture_state = IsTextureEnabled();
755   DisableTexture();
756
757   /* affichage du Triedre Non Zoomable */
758   AWorkspace->ActiveView()->EndTransformPersistence();
759
760   if (myIsWireframe)
761     Redraw (AWorkspace);
762   else
763     RedrawZBuffer (AWorkspace);
764
765   /* restauration du contexte */
766   if (save_texture_state) EnableTexture();
767
768   AWorkspace->SetAspectText(oldAspectText);
769   AWorkspace->SetAspectLine(oldAspectLine);
770 }
771
772 /*----------------------------------------------------------------------*/
773 //call_ztriedron_setup
774 void OpenGl_Trihedron::Setup (const Quantity_NameOfColor XColor, const Quantity_NameOfColor YColor, const Quantity_NameOfColor ZColor,
775                              const Standard_Real SizeRatio, const Standard_Real AxisDiametr, const Standard_Integer NbFacettes)
776 {
777   Standard_Real R,G,B;
778
779   Quantity_Color(XColor).Values(R, G, B, Quantity_TOC_RGB);
780   theXColor.rgb[0] = float (R);
781   theXColor.rgb[1] = float (G);
782   theXColor.rgb[2] = float (B);
783
784   Quantity_Color(YColor).Values(R, G, B, Quantity_TOC_RGB);
785   theYColor.rgb[0] = float (R);
786   theYColor.rgb[1] = float (G);
787   theYColor.rgb[2] = float (B);
788
789   Quantity_Color(ZColor).Values(R, G, B, Quantity_TOC_RGB);
790   theZColor.rgb[0] = float (R);
791   theZColor.rgb[1] = float (G);
792   theZColor.rgb[2] = float (B);
793
794   theRatio = float (SizeRatio);
795   theDiameter = float (AxisDiametr);
796   theNbFacettes = NbFacettes;
797 }