f7a89cc7f9cccd9032efca77c7a4d355a27c1ec6
[occt.git] / src / OpenGl / OpenGl_Structure.cxx
1 // Created on: 2011-08-01
2 // Created by: Sergey ZERCHANINOV
3 // Copyright (c) 2011-2012 OPEN CASCADE SAS
4 //
5 // The content of this file is subject to the Open CASCADE Technology Public
6 // License Version 6.5 (the "License"). You may not use the content of this file
7 // except in compliance with the License. Please obtain a copy of the License
8 // at http://www.opencascade.org and read it completely before using this file.
9 //
10 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
11 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12 //
13 // The Original Code and all software distributed under the License is
14 // distributed on an "AS IS" basis, without warranty of any kind, and the
15 // Initial Developer hereby disclaims all such warranties, including without
16 // limitation, any warranties of merchantability, fitness for a particular
17 // purpose or non-infringement. Please see the License for the specific terms
18 // and conditions governing the rights and limitations under the License.
19
20 #ifdef HAVE_CONFIG_H
21   #include <config.h>
22 #endif
23
24
25 #include <OpenGl_CappingAlgo.hxx>
26 #include <OpenGl_Context.hxx>
27 #include <OpenGl_GlCore11.hxx>
28 #include <OpenGl_ShaderManager.hxx>
29 #include <OpenGl_ShaderProgram.hxx>
30 #include <OpenGl_Structure.hxx>
31 #include <OpenGl_telem_util.hxx>
32 #include <OpenGl_Vec.hxx>
33 #include <OpenGl_View.hxx>
34 #include <OpenGl_Workspace.hxx>
35
36 #include <Graphic3d_SetOfHClipPlane_Handle.hxx>
37
38 //! Auxiliary class for bounding box presentation
39 class OpenGl_BndBoxPrs : public OpenGl_Element
40 {
41
42 public:
43
44   //! Main constructor
45   OpenGl_BndBoxPrs (const CALL_DEF_BOUNDBOX& theBndBox)
46   {
47     const float Xm = theBndBox.Pmin.x;
48     const float Ym = theBndBox.Pmin.y;
49     const float Zm = theBndBox.Pmin.z;
50     const float XM = theBndBox.Pmax.x;
51     const float YM = theBndBox.Pmax.y;
52     const float ZM = theBndBox.Pmax.z;
53     myVerts[0]  = OpenGl_Vec3 (Xm, Ym, Zm);
54     myVerts[1]  = OpenGl_Vec3 (Xm, Ym, ZM);
55     myVerts[2]  = OpenGl_Vec3 (Xm, YM, ZM);
56     myVerts[3]  = OpenGl_Vec3 (Xm, YM, Zm);
57     myVerts[4]  = OpenGl_Vec3 (Xm, Ym, Zm);
58     myVerts[5]  = OpenGl_Vec3 (XM, Ym, Zm);
59     myVerts[6]  = OpenGl_Vec3 (XM, Ym, ZM);
60     myVerts[7]  = OpenGl_Vec3 (XM, YM, ZM);
61     myVerts[8]  = OpenGl_Vec3 (XM, YM, Zm);
62     myVerts[9]  = OpenGl_Vec3 (XM, Ym, Zm);
63     myVerts[10] = OpenGl_Vec3 (XM, YM, Zm);
64     myVerts[11] = OpenGl_Vec3 (Xm, YM, Zm);
65     myVerts[12] = OpenGl_Vec3 (Xm, YM, ZM);
66     myVerts[13] = OpenGl_Vec3 (XM, YM, ZM);
67     myVerts[14] = OpenGl_Vec3 (XM, Ym, ZM);
68     myVerts[15] = OpenGl_Vec3 (Xm, Ym, ZM);
69   }
70
71   //! Render presentation
72   virtual void Render  (const Handle(OpenGl_Workspace)& theWorkspace) const
73   {
74     // Apply line aspect
75     const OpenGl_AspectLine*     anAspectLine = theWorkspace->AspectLine (Standard_True);
76     const Handle(OpenGl_Texture) aPrevTexture = theWorkspace->DisableTexture();
77
78     glDisable (GL_LIGHTING);
79     if ((theWorkspace->NamedStatus & (OPENGL_NS_ADD | OPENGL_NS_IMMEDIATE)) != 0)
80     {
81       glDepthMask (GL_FALSE);
82     }
83
84     // Use highlight colors
85     glColor3fv ((theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT) ? theWorkspace->HighlightColor->rgb : anAspectLine->Color().rgb);
86
87     glEnableClientState (GL_VERTEX_ARRAY);
88     glVertexPointer (3, GL_FLOAT, 0, (GLfloat* )&myVerts);
89     glDrawArrays (GL_LINE_STRIP, 0, 16);
90     glDisableClientState (GL_VERTEX_ARRAY);
91
92     // restore aspects
93     if (!aPrevTexture.IsNull())
94     {
95       theWorkspace->EnableTexture (aPrevTexture);
96     }
97   }
98
99   //! Release graphical resources
100   virtual void Release (const Handle(OpenGl_Context)& )
101   {
102     //
103   }
104
105 protected:
106
107   //! Protected destructor
108   virtual ~OpenGl_BndBoxPrs() {}
109
110 private:
111
112   OpenGl_Vec3 myVerts[16]; //!< vertices array
113
114 public:
115
116   DEFINE_STANDARD_ALLOC
117
118 };
119
120 /*----------------------------------------------------------------------*/
121
122 // =======================================================================
123 // function : call_util_transpose_mat
124 // purpose  :
125 // =======================================================================
126 static void call_util_transpose_mat (float tmat[16], float mat[4][4])
127 {
128   int i, j;
129
130   for (i=0; i<4; i++)
131     for (j=0; j<4; j++)
132       tmat[j*4+i] = mat[i][j];
133 }
134
135 // =======================================================================
136 // function : OpenGl_Structure
137 // purpose  :
138 // =======================================================================
139 OpenGl_Structure::OpenGl_Structure ()
140 : myTransformation(NULL),
141   myTransPers(NULL),
142   myAspectLine(NULL),
143   myAspectFace(NULL),
144   myAspectMarker(NULL),
145   myAspectText(NULL),
146   myHighlightBox(NULL),
147   myHighlightColor(NULL),
148   myNamedStatus(0),
149   myZLayer(0)
150 {
151 #if HAVE_OPENCL
152   myIsRaytracable = Standard_False;
153   myModificationState = 0;
154 #endif
155 }
156
157 // =======================================================================
158 // function : ~OpenGl_Structure
159 // purpose  :
160 // =======================================================================
161 OpenGl_Structure::~OpenGl_Structure()
162 {
163   Release (Handle(OpenGl_Context)());
164   delete myTransformation;  myTransformation  = NULL;
165   delete myTransPers;       myTransPers       = NULL;
166 }
167
168 // =======================================================================
169 // function : SetTransformation
170 // purpose  :
171 // =======================================================================
172 void OpenGl_Structure::SetTransformation (const float *theMatrix)
173 {
174   if (!myTransformation)
175   {
176     myTransformation = new OpenGl_Matrix();
177   }
178
179   matcpy (myTransformation->mat, theMatrix);
180
181 #ifdef HAVE_OPENCL
182   if (myIsRaytracable)
183   {
184     UpdateStateWithAncestorStructures();
185   }
186 #endif
187 }
188
189 // =======================================================================
190 // function : SetTransformPersistence
191 // purpose  :
192 // =======================================================================
193 void OpenGl_Structure::SetTransformPersistence(const CALL_DEF_TRANSFORM_PERSISTENCE &ATransPers)
194 {
195   if (!myTransPers)
196     myTransPers = new TEL_TRANSFORM_PERSISTENCE;
197
198   myTransPers->mode = ATransPers.Flag;
199   myTransPers->pointX = ATransPers.Point.x;
200   myTransPers->pointY = ATransPers.Point.y;
201   myTransPers->pointZ = ATransPers.Point.z;
202 }
203
204 // =======================================================================
205 // function : SetAspectLine
206 // purpose  :
207 // =======================================================================
208 void OpenGl_Structure::SetAspectLine (const CALL_DEF_CONTEXTLINE &theAspect)
209 {
210   if (!myAspectLine)
211   {
212     myAspectLine = new OpenGl_AspectLine();
213   }
214   myAspectLine->SetAspect (theAspect);
215 }
216
217 // =======================================================================
218 // function : SetAspectFace
219 // purpose  :
220 // =======================================================================
221 void OpenGl_Structure::SetAspectFace (const CALL_DEF_CONTEXTFILLAREA& theAspect)
222 {
223   if (!myAspectFace)
224   {
225     myAspectFace = new OpenGl_AspectFace();
226   }
227   myAspectFace->SetAspect (theAspect);
228
229 #ifdef HAVE_OPENCL
230   if (myIsRaytracable)
231   {
232     UpdateStateWithAncestorStructures();
233   }
234 #endif
235 }
236
237 // =======================================================================
238 // function : SetAspectMarker
239 // purpose  :
240 // =======================================================================
241 void OpenGl_Structure::SetAspectMarker (const CALL_DEF_CONTEXTMARKER& theAspect)
242 {
243   if (!myAspectMarker)
244   {
245     myAspectMarker = new OpenGl_AspectMarker();
246   }
247   myAspectMarker->SetAspect (theAspect);
248 }
249
250 // =======================================================================
251 // function : SetAspectText
252 // purpose  :
253 // =======================================================================
254 void OpenGl_Structure::SetAspectText (const CALL_DEF_CONTEXTTEXT &theAspect)
255 {
256   if (!myAspectText)
257   {
258     myAspectText = new OpenGl_AspectText();
259   }
260   myAspectText->SetAspect (theAspect);
261 }
262
263 // =======================================================================
264 // function : SetHighlightBox
265 // purpose  :
266 // =======================================================================
267 void OpenGl_Structure::SetHighlightBox (const Handle(OpenGl_Context)& theGlCtx,
268                                         const CALL_DEF_BOUNDBOX&      theBoundBox)
269 {
270   if (myHighlightBox != NULL)
271   {
272     myHighlightBox->Release (theGlCtx);
273   }
274   else
275   {
276 #ifndef HAVE_OPENCL
277     myHighlightBox = new OpenGl_Group();
278 #else
279     myHighlightBox = new OpenGl_Group (this);
280 #endif
281   }
282
283   CALL_DEF_CONTEXTLINE aContextLine;
284   aContextLine.Color    = theBoundBox.Color;
285   aContextLine.LineType = Aspect_TOL_SOLID;
286   aContextLine.Width    = 1.0f;
287   myHighlightBox->SetAspectLine (aContextLine);
288
289   OpenGl_BndBoxPrs* aBndBoxPrs = new OpenGl_BndBoxPrs (theBoundBox);
290   myHighlightBox->AddElement (TelParray, aBndBoxPrs);
291 }
292
293 // =======================================================================
294 // function : ClearHighlightBox
295 // purpose  :
296 // =======================================================================
297 void OpenGl_Structure::ClearHighlightBox (const Handle(OpenGl_Context)& theGlCtx)
298 {
299   if (myHighlightBox != NULL)
300   {
301     OpenGl_Element::Destroy (theGlCtx, myHighlightBox);
302   }
303 }
304
305 // =======================================================================
306 // function : SetHighlightColor
307 // purpose  :
308 // =======================================================================
309 void OpenGl_Structure::SetHighlightColor (const Handle(OpenGl_Context)& theGlCtx,
310                                           const Standard_ShortReal R,
311                                           const Standard_ShortReal G,
312                                           const Standard_ShortReal B)
313 {
314   ClearHighlightBox (theGlCtx);
315   if (myHighlightColor == NULL)
316   {
317     myHighlightColor = new TEL_COLOUR();
318   }
319
320   myHighlightColor->rgb[0] = R;
321   myHighlightColor->rgb[1] = G;
322   myHighlightColor->rgb[2] = B;
323   myHighlightColor->rgb[3] = 1.F;
324 }
325
326 // =======================================================================
327 // function : ClearHighlightColor
328 // purpose  :
329 // =======================================================================
330 void OpenGl_Structure::ClearHighlightColor (const Handle(OpenGl_Context)& theGlCtx)
331 {
332   ClearHighlightBox(theGlCtx);
333   delete myHighlightColor;
334   myHighlightColor = NULL;
335 }
336
337 // =======================================================================
338 // function : SetNamedStatus
339 // purpose  :
340 // =======================================================================
341 void OpenGl_Structure::SetNamedStatus (const Standard_Integer aStatus)
342 {
343   myNamedStatus = aStatus;
344
345 #ifdef HAVE_OPENCL
346   if (myIsRaytracable)
347   {
348     UpdateStateWithAncestorStructures();
349   }
350 #endif
351 }
352
353 #ifdef HAVE_OPENCL
354
355 // =======================================================================
356 // function : RegisterAncestorStructure
357 // purpose  :
358 // =======================================================================
359 void OpenGl_Structure::RegisterAncestorStructure (const OpenGl_Structure* theStructure) const
360 {
361   for (OpenGl_ListOfStructure::Iterator anIt (myAncestorStructures); anIt.More(); anIt.Next())
362   {
363     if (anIt.Value() == theStructure)
364     {
365       return;
366     }    
367   }
368
369   myAncestorStructures.Append (theStructure);
370 }
371
372 // =======================================================================
373 // function : UnregisterAncestorStructure
374 // purpose  :
375 // =======================================================================
376 void OpenGl_Structure::UnregisterAncestorStructure (const OpenGl_Structure* theStructure) const
377 {
378   for (OpenGl_ListOfStructure::Iterator anIt (myAncestorStructures); anIt.More(); anIt.Next())
379   {
380     if (anIt.Value() == theStructure)
381     {
382       myAncestorStructures.Remove (anIt);
383       return;
384     }    
385   }
386 }
387
388 // =======================================================================
389 // function : UnregisterFromAncestorStructure
390 // purpose  :
391 // =======================================================================
392 void OpenGl_Structure::UnregisterFromAncestorStructure() const
393 {
394   for (OpenGl_ListOfStructure::Iterator anIta (myAncestorStructures); anIta.More(); anIta.Next())
395   {
396     OpenGl_Structure* anAncestor = const_cast<OpenGl_Structure*> (anIta.ChangeValue());
397
398     for (OpenGl_ListOfStructure::Iterator anIts (anAncestor->myConnected); anIts.More(); anIts.Next())
399     {
400       if (anIts.Value() == this)
401       {
402         anAncestor->myConnected.Remove (anIts);
403         return;
404       }      
405     }
406   }
407 }
408
409 // =======================================================================
410 // function : UpdateStateWithAncestorStructures
411 // purpose  :
412 // =======================================================================
413 void OpenGl_Structure::UpdateStateWithAncestorStructures() const
414 {
415   myModificationState++;
416
417   for (OpenGl_ListOfStructure::Iterator anIt (myAncestorStructures); anIt.More(); anIt.Next())
418   {
419     anIt.Value()->UpdateStateWithAncestorStructures();
420   }
421 }
422
423 // =======================================================================
424 // function : UpdateRaytracableWithAncestorStructures
425 // purpose  :
426 // =======================================================================
427 void OpenGl_Structure::UpdateRaytracableWithAncestorStructures() const
428 {
429   myIsRaytracable = OpenGl_Raytrace::IsRaytracedStructure (this);
430
431   if (!myIsRaytracable)
432   {
433     for (OpenGl_ListOfStructure::Iterator anIt (myAncestorStructures); anIt.More(); anIt.Next())
434     {
435       anIt.Value()->UpdateRaytracableWithAncestorStructures();
436     }
437   }
438 }
439
440 // =======================================================================
441 // function : SetRaytracableWithAncestorStructures
442 // purpose  :
443 // =======================================================================
444 void OpenGl_Structure::SetRaytracableWithAncestorStructures() const
445 {
446   myIsRaytracable = Standard_True;
447
448   for (OpenGl_ListOfStructure::Iterator anIt (myAncestorStructures); anIt.More(); anIt.Next())
449   {
450     if (!anIt.Value()->IsRaytracable())
451     {
452       anIt.Value()->SetRaytracableWithAncestorStructures();
453     }
454   }
455 }
456
457 #endif
458
459 // =======================================================================
460 // function : Connect
461 // purpose  :
462 // =======================================================================
463 void OpenGl_Structure::Connect (const OpenGl_Structure *theStructure)
464 {
465   Disconnect (theStructure);
466   myConnected.Append (theStructure);
467
468 #ifdef HAVE_OPENCL
469   if (theStructure->IsRaytracable())
470   {
471     UpdateStateWithAncestorStructures();
472     SetRaytracableWithAncestorStructures();
473   }
474
475   theStructure->RegisterAncestorStructure (this);
476 #endif
477 }
478
479 // =======================================================================
480 // function : Disconnect
481 // purpose  :
482 // =======================================================================
483 void OpenGl_Structure::Disconnect (const OpenGl_Structure *theStructure)
484 {
485   OpenGl_ListOfStructure::Iterator its (myConnected);
486   while (its.More())
487   {
488     // Check for the given structure
489     if (its.Value() == theStructure)
490     {
491       myConnected.Remove (its);
492
493 #ifdef HAVE_OPENCL
494       if (theStructure->IsRaytracable())
495       {
496         UpdateStateWithAncestorStructures();
497         UpdateRaytracableWithAncestorStructures();
498       }
499
500       theStructure->UnregisterAncestorStructure (this);
501 #endif
502
503       return;
504     }
505     its.Next();
506   }
507 }
508
509 // =======================================================================
510 // function : AddGroup
511 // purpose  :
512 // =======================================================================
513 OpenGl_Group * OpenGl_Structure::AddGroup()
514 {
515   // Create new group
516 #ifndef HAVE_OPENCL
517   OpenGl_Group *g = new OpenGl_Group();
518 #else
519   OpenGl_Group *g = new OpenGl_Group (this);
520 #endif
521
522   myGroups.Append(g);
523   return g;
524 }
525
526 // =======================================================================
527 // function : RemoveGroup
528 // purpose  :
529 // =======================================================================
530 void OpenGl_Structure::RemoveGroup (const Handle(OpenGl_Context)& theGlCtx,
531                                     const OpenGl_Group*           theGroup)
532 {
533   for (OpenGl_ListOfGroup::Iterator anIter (myGroups); anIter.More(); anIter.Next())
534   {
535     // Check for the given group
536     if (anIter.Value() == theGroup)
537     {
538       myGroups.Remove (anIter);
539
540 #ifdef HAVE_OPENCL
541       if (theGroup->IsRaytracable())
542       {
543         UpdateStateWithAncestorStructures();
544         UpdateRaytracableWithAncestorStructures();
545       }
546 #endif
547
548       // Delete object
549       OpenGl_Element::Destroy (theGlCtx, const_cast<OpenGl_Group*& > (theGroup));
550       return;
551     }
552   }
553 }
554
555 // =======================================================================
556 // function : Clear
557 // purpose  :
558 // =======================================================================
559 void OpenGl_Structure::Clear (const Handle(OpenGl_Context)& theGlCtx)
560 {
561 #ifdef HAVE_OPENCL
562   Standard_Boolean aRaytracableGroupDeleted (Standard_False);
563 #endif
564
565   // Release groups
566   for (OpenGl_ListOfGroup::Iterator anIter (myGroups); anIter.More(); anIter.Next())
567   {
568 #ifdef HAVE_OPENCL
569     aRaytracableGroupDeleted |= anIter.Value()->IsRaytracable();
570 #endif
571     
572     // Delete objects
573     OpenGl_Element::Destroy (theGlCtx, const_cast<OpenGl_Group*& > (anIter.ChangeValue()));
574   }
575   myGroups.Clear();
576
577 #ifdef HAVE_OPENCL
578   if (aRaytracableGroupDeleted)
579   {
580     UpdateStateWithAncestorStructures();
581     UpdateRaytracableWithAncestorStructures();
582   }
583 #endif
584 }
585
586 // =======================================================================
587 // function : Render
588 // purpose  :
589 // =======================================================================
590 void OpenGl_Structure::Render (const Handle(OpenGl_Workspace) &AWorkspace) const
591 {
592   // Process the structure only if visible
593   if ( myNamedStatus & OPENGL_NS_HIDE )
594     return;
595
596   // Render named status
597   const Standard_Integer named_status = AWorkspace->NamedStatus;
598   AWorkspace->NamedStatus |= myNamedStatus;
599
600   // Is rendering in ADD or IMMEDIATE mode?
601   const Standard_Boolean isImmediate = (AWorkspace->NamedStatus & (OPENGL_NS_ADD | OPENGL_NS_IMMEDIATE)) != 0;
602
603   const Handle(OpenGl_Context)& aCtx = AWorkspace->GetGlContext();
604
605   // Apply local transformation
606   GLint matrix_mode = 0;
607   const OpenGl_Matrix *local_trsf = NULL;
608   if (myTransformation)
609   {
610     if (isImmediate)
611     {
612       Tmatrix3 aModelWorld;
613       call_util_transpose_mat (*aModelWorld, myTransformation->mat);
614       glGetIntegerv (GL_MATRIX_MODE, &matrix_mode);
615
616       if (!aCtx->ShaderManager()->IsEmpty())
617       {
618         Tmatrix3 aWorldView;
619         glGetFloatv (GL_MODELVIEW_MATRIX, *aWorldView);
620
621         Tmatrix3 aProjection;
622         glGetFloatv (GL_PROJECTION_MATRIX, *aProjection);
623
624         aCtx->ShaderManager()->UpdateModelWorldStateTo (aModelWorld);
625         aCtx->ShaderManager()->UpdateWorldViewStateTo (aWorldView);
626         aCtx->ShaderManager()->UpdateProjectionStateTo (aProjection);
627       }
628
629       glMatrixMode (GL_MODELVIEW);
630       glPushMatrix ();
631       glScalef (1.F, 1.F, 1.F);
632       glMultMatrixf (*aModelWorld);
633     }
634     else
635     {
636       glMatrixMode (GL_MODELVIEW);
637       glPushMatrix();
638
639       local_trsf = AWorkspace->SetStructureMatrix (myTransformation);
640     }
641   }
642
643   // Apply transform persistence
644   const TEL_TRANSFORM_PERSISTENCE *trans_pers = NULL;
645   if ( myTransPers && myTransPers->mode != 0 )
646   {
647     trans_pers = AWorkspace->ActiveView()->BeginTransformPersistence (aCtx, myTransPers);
648   }
649
650   // Apply aspects
651   const OpenGl_AspectLine *aspect_line = AWorkspace->AspectLine(Standard_False);
652   const OpenGl_AspectFace *aspect_face = AWorkspace->AspectFace(Standard_False);
653   const OpenGl_AspectMarker *aspect_marker = AWorkspace->AspectMarker(Standard_False);
654   const OpenGl_AspectText *aspect_text = AWorkspace->AspectText(Standard_False);
655   if (myAspectLine)
656     AWorkspace->SetAspectLine(myAspectLine);
657   if (myAspectFace)
658     AWorkspace->SetAspectFace(myAspectFace);
659   if (myAspectMarker)
660     AWorkspace->SetAspectMarker(myAspectMarker);
661   if (myAspectText)
662     AWorkspace->SetAspectText(myAspectText);
663
664   // Apply highlight box
665   if (myHighlightBox)
666     myHighlightBox->Render( AWorkspace );
667
668   // Apply highlight color
669   const TEL_COLOUR *highlight_color = AWorkspace->HighlightColor;
670   if (myHighlightColor)
671     AWorkspace->HighlightColor = myHighlightColor;
672
673   // Render connected structures
674   OpenGl_ListOfStructure::Iterator its(myConnected);
675   while (its.More())
676   {
677     its.Value()->Render(AWorkspace);
678     its.Next();
679   }
680
681   // Set up plane equations for non-structure transformed global model-view matrix
682   const Handle(OpenGl_Context)& aContext = AWorkspace->GetGlContext();
683
684   // List of planes to be applied to context state
685   Handle(Graphic3d_SetOfHClipPlane) aUserPlanes;
686
687   // Collect clipping planes of structure scope
688   if (!myClipPlanes.IsEmpty())
689   {
690     Graphic3d_SetOfHClipPlane::Iterator aClippingIt (myClipPlanes);
691     for (; aClippingIt.More(); aClippingIt.Next())
692     {
693       const Handle(Graphic3d_ClipPlane)& aClipPlane = aClippingIt.Value();
694       if (!aClipPlane->IsOn())
695       {
696         continue;
697       }
698
699       if (aUserPlanes.IsNull())
700       {
701         aUserPlanes = new Graphic3d_SetOfHClipPlane();
702       }
703
704       aUserPlanes->Add (aClipPlane);
705     }
706   }
707
708   if (!aUserPlanes.IsNull() && !aUserPlanes->IsEmpty())
709   {
710     // add planes at loaded view matrix state
711     aContext->ChangeClipping().AddWorld (*aUserPlanes, AWorkspace);
712
713     // Set OCCT state uniform variables
714     if (!aContext->ShaderManager()->IsEmpty())
715     {
716       aContext->ShaderManager()->UpdateClippingState();
717     }
718   }
719
720   // Render groups
721   OpenGl_ListOfGroup::Iterator itg(myGroups);
722   while (itg.More())
723   {
724     itg.Value()->Render(AWorkspace);
725     itg.Next();
726   }
727
728   // Render capping for structure groups
729   if (!aContext->Clipping().Planes().IsEmpty())
730   {
731     OpenGl_CappingAlgo::RenderCapping (AWorkspace, myGroups);
732   }
733
734   // Revert structure clippings
735   if (!aUserPlanes.IsNull() && !aUserPlanes->IsEmpty())
736   {
737     aContext->ChangeClipping().Remove (*aUserPlanes);
738
739     // Set OCCT state uniform variables
740     if (!aContext->ShaderManager()->IsEmpty())
741     {
742       aContext->ShaderManager()->RevertClippingState();
743     }
744   }
745
746   // Restore highlight color
747   AWorkspace->HighlightColor = highlight_color;
748
749   // Restore aspects
750   AWorkspace->SetAspectLine(aspect_line);
751   AWorkspace->SetAspectFace(aspect_face);
752   AWorkspace->SetAspectMarker(aspect_marker);
753   AWorkspace->SetAspectText(aspect_text);
754
755   // Restore transform persistence
756   if ( myTransPers && myTransPers->mode != 0 )
757   {
758     AWorkspace->ActiveView()->BeginTransformPersistence (aContext, trans_pers);
759   }
760
761   // Restore local transformation
762   if (myTransformation)
763   {
764     if (isImmediate)
765     {
766       glPopMatrix ();
767       glMatrixMode (matrix_mode);
768
769       Tmatrix3 aModelWorldState = { { 1.f, 0.f, 0.f, 0.f },
770                                     { 0.f, 1.f, 0.f, 0.f },
771                                     { 0.f, 0.f, 1.f, 0.f },
772                                     { 0.f, 0.f, 0.f, 1.f } };
773
774       aContext->ShaderManager()->RevertModelWorldStateTo (aModelWorldState);
775     }
776     else
777     {
778       AWorkspace->SetStructureMatrix (local_trsf, true);
779
780       glMatrixMode (GL_MODELVIEW);
781       glPopMatrix();
782     }
783   }
784
785   // Restore named status
786   AWorkspace->NamedStatus = named_status;
787 }
788
789 // =======================================================================
790 // function : Release
791 // purpose  :
792 // =======================================================================
793 void OpenGl_Structure::Release (const Handle(OpenGl_Context)& theGlCtx)
794 {
795   // Release groups
796   Clear (theGlCtx);
797   OpenGl_Element::Destroy (theGlCtx, myAspectLine);
798   OpenGl_Element::Destroy (theGlCtx, myAspectFace);
799   OpenGl_Element::Destroy (theGlCtx, myAspectMarker);
800   OpenGl_Element::Destroy (theGlCtx, myAspectText);
801   ClearHighlightColor (theGlCtx);
802
803 #ifdef HAVE_OPENCL
804   // Remove from connected list of ancestor
805   UnregisterFromAncestorStructure();
806 #endif
807 }
808
809 // =======================================================================
810 // function : ReleaseGlResources
811 // purpose  :
812 // =======================================================================
813 void OpenGl_Structure::ReleaseGlResources (const Handle(OpenGl_Context)& theGlCtx)
814 {
815   for (OpenGl_ListOfGroup::Iterator anIter (myGroups); anIter.More(); anIter.Next())
816   {
817     OpenGl_Group* aGroup = const_cast<OpenGl_Group*& > (anIter.ChangeValue());
818     if (aGroup != NULL)
819     {
820       aGroup->Release (theGlCtx);
821     }
822   }
823   if (myAspectLine != NULL)
824   {
825     myAspectLine->Release (theGlCtx);
826   }
827   if (myAspectFace != NULL)
828   {
829     myAspectFace->Release (theGlCtx);
830   }
831   if (myAspectMarker != NULL)
832   {
833     myAspectMarker->Release (theGlCtx);
834   }
835   if (myAspectText != NULL)
836   {
837     myAspectText->Release (theGlCtx);
838   }
839   if (myHighlightBox != NULL)
840   {
841     myHighlightBox->Release (theGlCtx);
842   }
843 }
844
845 //=======================================================================
846 //function : SetZLayer
847 //purpose  :
848 //=======================================================================
849 void OpenGl_Structure::SetZLayer (const Standard_Integer theLayerIndex)
850 {
851   myZLayer = theLayerIndex;
852 }
853
854 //=======================================================================
855 //function : GetZLayer
856 //purpose  :
857 //=======================================================================
858 Standard_Integer OpenGl_Structure::GetZLayer () const
859 {
860   return myZLayer;
861 }