0029366: Visualization, OpenGl_Text - artifacts when using Aspect_TODT_SHADOW/Aspect_...
[occt.git] / src / OpenGl / OpenGl_Workspace.cxx
1 // Created on: 2011-09-20
2 // Created by: Sergey ZERCHANINOV
3 // Copyright (c) 2011-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <OpenGl_Workspace.hxx>
17
18 #include <OpenGl_ArbFBO.hxx>
19 #include <OpenGl_AspectLine.hxx>
20 #include <OpenGl_AspectFace.hxx>
21 #include <OpenGl_AspectMarker.hxx>
22 #include <OpenGl_AspectText.hxx>
23 #include <OpenGl_Context.hxx>
24 #include <OpenGl_Element.hxx>
25 #include <OpenGl_FrameBuffer.hxx>
26 #include <OpenGl_GlCore15.hxx>
27 #include <OpenGl_SceneGeometry.hxx>
28 #include <OpenGl_Structure.hxx>
29 #include <OpenGl_Sampler.hxx>
30 #include <OpenGl_ShaderManager.hxx>
31 #include <OpenGl_Texture.hxx>
32 #include <OpenGl_View.hxx>
33 #include <OpenGl_Window.hxx>
34
35 #include <Graphic3d_TextureParams.hxx>
36 #include <Graphic3d_TransformUtils.hxx>
37 #include <NCollection_AlignedAllocator.hxx>
38
39 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Workspace,Standard_Transient)
40 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_RaytraceFilter,OpenGl_RenderFilter)
41
42 #ifdef HAVE_GL2PS
43   #include <gl2ps.h>
44   /* OCC22216 NOTE: linker dependency can be switched off by undefining macro.
45      Pragma comment for gl2ps.lib is defined only here. */
46   #ifdef _MSC_VER
47   #pragma comment( lib, "gl2ps.lib" )
48   #endif
49 #endif
50
51 namespace
52 {
53   static const OpenGl_Vec4 THE_WHITE_COLOR (1.0f, 1.0f, 1.0f, 1.0f);
54   static const OpenGl_Vec4 THE_BLACK_COLOR (0.0f, 0.0f, 0.0f, 1.0f);
55
56   static const OpenGl_AspectLine myDefaultAspectLine;
57   static const OpenGl_AspectFace myDefaultAspectFace;
58   static const OpenGl_AspectMarker myDefaultAspectMarker;
59   static const OpenGl_AspectText myDefaultAspectText;
60
61   static const OpenGl_Matrix myDefaultMatrix =
62   {
63     {{ 1.0F, 0.0F, 0.0F, 0.0F },
64      { 0.0F, 1.0F, 0.0F, 0.0F },
65      { 0.0F, 0.0F, 1.0F, 0.0F },
66      { 0.0F, 0.0F, 0.0F, 1.0F }}
67   };
68
69 }
70
71 // =======================================================================
72 // function : Init
73 // purpose  :
74 // =======================================================================
75 void OpenGl_Material::Init (const Graphic3d_MaterialAspect& theMat,
76                             const Quantity_Color&           theInteriorColor)
77 {
78   const bool isPhysic = theMat.MaterialType (Graphic3d_MATERIAL_PHYSIC);
79   ChangeShine()        = 128.0f * theMat.Shininess();
80   ChangeTransparency() = theMat.Alpha();
81
82   // ambient component
83   if (theMat.ReflectionMode (Graphic3d_TOR_AMBIENT))
84   {
85     const OpenGl_Vec3& aSrcAmb = isPhysic ? theMat.AmbientColor() : theInteriorColor;
86     Ambient = OpenGl_Vec4 (aSrcAmb * theMat.Ambient(), 1.0f);
87   }
88   else
89   {
90     Ambient = THE_BLACK_COLOR;
91   }
92
93   // diffusion component
94   if (theMat.ReflectionMode (Graphic3d_TOR_DIFFUSE))
95   {
96     const OpenGl_Vec3& aSrcDif = isPhysic ? theMat.DiffuseColor() : theInteriorColor;
97     Diffuse = OpenGl_Vec4 (aSrcDif * theMat.Diffuse(), 1.0f);
98   }
99   else
100   {
101     Diffuse = THE_BLACK_COLOR;
102   }
103
104   // specular component
105   if (theMat.ReflectionMode (Graphic3d_TOR_SPECULAR))
106   {
107     const OpenGl_Vec3& aSrcSpe = isPhysic ? (const OpenGl_Vec3& )theMat.SpecularColor() : THE_WHITE_COLOR.rgb();
108     Specular = OpenGl_Vec4 (aSrcSpe * theMat.Specular(), 1.0f);
109   }
110   else
111   {
112     Specular = THE_BLACK_COLOR;
113   }
114
115   // emission component
116   if (theMat.ReflectionMode (Graphic3d_TOR_EMISSION))
117   {
118     const OpenGl_Vec3& aSrcEms = isPhysic ? theMat.EmissiveColor() : theInteriorColor;
119     Emission = OpenGl_Vec4 (aSrcEms * theMat.Emissive(), 1.0f);
120   }
121   else
122   {
123     Emission = THE_BLACK_COLOR;
124   }
125 }
126
127 // =======================================================================
128 // function : OpenGl_Workspace
129 // purpose  :
130 // =======================================================================
131 OpenGl_Workspace::OpenGl_Workspace (OpenGl_View* theView, const Handle(OpenGl_Window)& theWindow)
132 : myView (theView),
133   myWindow (theWindow),
134   myGlContext (!theWindow.IsNull() ? theWindow->GetGlContext() : NULL),
135   myUseZBuffer    (Standard_True),
136   myUseDepthWrite (Standard_True),
137   //
138   myAspectLineSet (&myDefaultAspectLine),
139   myAspectFaceSet (&myDefaultAspectFace),
140   myAspectMarkerSet (&myDefaultAspectMarker),
141   myAspectTextSet (&myDefaultAspectText),
142   //
143   ViewMatrix_applied (&myDefaultMatrix),
144   StructureMatrix_applied (&myDefaultMatrix),
145   myToAllowFaceCulling (false),
146   myModelViewMatrix (myDefaultMatrix)
147 {
148   if (!myGlContext.IsNull() && myGlContext->MakeCurrent())
149   {
150     myGlContext->core11fwd->glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
151
152     // General initialization of the context
153   #if !defined(GL_ES_VERSION_2_0)
154     if (myGlContext->core11 != NULL)
155     {
156       // enable two-side lighting by default
157       glLightModeli ((GLenum )GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
158       glHint (GL_POINT_SMOOTH_HINT, GL_FASTEST);
159       if (myGlContext->caps->ffpEnable)
160       {
161         glHint (GL_FOG_HINT, GL_FASTEST);
162       }
163     }
164
165     glHint (GL_LINE_SMOOTH_HINT,    GL_FASTEST);
166     glHint (GL_POLYGON_SMOOTH_HINT, GL_FASTEST);
167   #endif
168   }
169
170   myDefaultCappingAlgoFilter = new OpenGl_CappingAlgoFilter();
171
172   myNoneCulling .Aspect()->SetSuppressBackFaces (false);
173   myNoneCulling .Aspect()->SetDrawEdges (false);
174   myFrontCulling.Aspect()->SetSuppressBackFaces (true);
175   myFrontCulling.Aspect()->SetDrawEdges (false);
176 }
177
178 // =======================================================================
179 // function : Activate
180 // purpose  :
181 // =======================================================================
182 Standard_Boolean OpenGl_Workspace::Activate()
183 {
184   if (myWindow.IsNull() || !myWindow->Activate())
185   {
186     return Standard_False;
187   }
188
189   ViewMatrix_applied      = &myDefaultMatrix;
190   StructureMatrix_applied = &myDefaultMatrix;
191
192   ResetAppliedAspect();
193
194   // reset state for safety
195   myGlContext->BindProgram (Handle(OpenGl_ShaderProgram)());
196   if (myGlContext->core20fwd != NULL)
197   {
198     myGlContext->core20fwd->glUseProgram (OpenGl_ShaderProgram::NO_PROGRAM);
199   }
200   if (myGlContext->caps->ffpEnable)
201   {
202     myGlContext->ShaderManager()->PushState (Handle(OpenGl_ShaderProgram)());
203   }
204   return Standard_True;
205 }
206
207 //=======================================================================
208 //function : ResetAppliedAspect
209 //purpose  : Sets default values of GL parameters in accordance with default aspects
210 //=======================================================================
211 void OpenGl_Workspace::ResetAppliedAspect()
212 {
213   myGlContext->BindDefaultVao();
214
215   myHighlightStyle.Nullify();
216   myToAllowFaceCulling  = false;
217   myAspectLineSet       = &myDefaultAspectLine;
218   myAspectFaceSet       = &myDefaultAspectFace;
219   myAspectFaceApplied.Nullify();
220   myAspectMarkerSet     = &myDefaultAspectMarker;
221   myAspectMarkerApplied.Nullify();
222   myAspectTextSet       = &myDefaultAspectText;
223   myGlContext->SetPolygonOffset (Graphic3d_PolygonOffset());
224
225   ApplyAspectLine();
226   ApplyAspectFace();
227   ApplyAspectMarker();
228   ApplyAspectText();
229
230   myGlContext->SetTypeOfLine (myDefaultAspectLine.Aspect()->Type());
231   myGlContext->SetLineWidth  (myDefaultAspectLine.Aspect()->Width());
232 }
233
234 // =======================================================================
235 // function : SetAspectLine
236 // purpose  :
237 // =======================================================================
238 const OpenGl_AspectLine* OpenGl_Workspace::SetAspectLine (const OpenGl_AspectLine* theAspect)
239 {
240   const OpenGl_AspectLine* aPrevAspectLine = myAspectLineSet;
241   myAspectLineSet = theAspect;
242   return aPrevAspectLine;
243 }
244
245 // =======================================================================
246 // function : SetAspectFace
247 // purpose  :
248 // =======================================================================
249 const OpenGl_AspectFace * OpenGl_Workspace::SetAspectFace (const OpenGl_AspectFace* theAspect)
250 {
251   const OpenGl_AspectFace* aPrevAspectFace = myAspectFaceSet;
252   myAspectFaceSet = theAspect;
253   return aPrevAspectFace;
254 }
255
256 // =======================================================================
257 // function : SetAspectMarker
258 // purpose  :
259 // =======================================================================
260 const OpenGl_AspectMarker* OpenGl_Workspace::SetAspectMarker (const OpenGl_AspectMarker* theAspect)
261 {
262   const OpenGl_AspectMarker* aPrevAspectMarker = myAspectMarkerSet;
263   myAspectMarkerSet = theAspect;
264   return aPrevAspectMarker;
265 }
266
267 // =======================================================================
268 // function : SetAspectText
269 // purpose  :
270 // =======================================================================
271 const OpenGl_AspectText * OpenGl_Workspace::SetAspectText (const OpenGl_AspectText* theAspect)
272 {
273   const OpenGl_AspectText* aPrevAspectText = myAspectTextSet;
274   myAspectTextSet = theAspect;
275   return aPrevAspectText;
276 }
277
278 // =======================================================================
279 // function : ApplyAspectFace
280 // purpose  :
281 // =======================================================================
282 const OpenGl_AspectFace* OpenGl_Workspace::ApplyAspectFace()
283 {
284   if (myView->BackfacingModel() == Graphic3d_TOBM_AUTOMATIC)
285   {
286     // manage back face culling mode, disable culling when clipping is enabled
287     bool toSuppressBackFaces = myToAllowFaceCulling
288                             && myAspectFaceSet->Aspect()->ToSuppressBackFaces();
289     if (toSuppressBackFaces)
290     {
291       if (myGlContext->Clipping().IsClippingOrCappingOn()
292        || myAspectFaceSet->Aspect()->InteriorStyle() == Aspect_IS_HATCH)
293       {
294         toSuppressBackFaces = false;
295       }
296     }
297     if (toSuppressBackFaces)
298     {
299       if ((float )myAspectFaceSet->Aspect()->FrontMaterial().Transparency() != 0.0f)
300       {
301         // disable culling in case of translucent shading aspect
302         toSuppressBackFaces = false;
303       }
304     }
305     myGlContext->SetCullBackFaces (toSuppressBackFaces);
306   }
307
308   if (myAspectFaceSet->Aspect() == myAspectFaceApplied
309    && myHighlightStyle == myAspectFaceAppliedWithHL)
310   {
311     return myAspectFaceSet;
312   }
313   myAspectFaceAppliedWithHL = myHighlightStyle;
314
315 #if !defined(GL_ES_VERSION_2_0)
316   const Aspect_InteriorStyle anIntstyle = myAspectFaceSet->Aspect()->InteriorStyle();
317   if (myAspectFaceApplied.IsNull()
318    || myAspectFaceApplied->InteriorStyle() != anIntstyle)
319   {
320     switch (anIntstyle)
321     {
322       case Aspect_IS_EMPTY:
323       case Aspect_IS_HOLLOW:
324       {
325         myGlContext->SetPolygonMode (GL_LINE);
326         break;
327       }
328       case Aspect_IS_HATCH:
329       {
330         myGlContext->SetPolygonMode (GL_FILL);
331         myGlContext->SetPolygonHatchEnabled (true);
332         break;
333       }
334       case Aspect_IS_SOLID:
335       case Aspect_IS_HIDDENLINE:
336       {
337         myGlContext->SetPolygonMode (GL_FILL);
338         myGlContext->SetPolygonHatchEnabled (false);
339         break;
340       }
341       case Aspect_IS_POINT:
342       {
343         myGlContext->SetPolygonMode (GL_POINT);
344         break;
345       }
346     }
347   }
348
349   if (anIntstyle == Aspect_IS_HATCH)
350   {
351     myGlContext->SetPolygonHatchStyle (myAspectFaceSet->Aspect()->HatchStyle());
352   }
353 #endif
354
355   // Aspect_POM_None means: do not change current settings
356   if ((myAspectFaceSet->Aspect()->PolygonOffset().Mode & Aspect_POM_None) != Aspect_POM_None)
357   {
358     myGlContext->SetPolygonOffset (myAspectFaceSet->Aspect()->PolygonOffset());
359   }
360
361   // Case of hidden line
362   if (myAspectFaceSet->Aspect()->InteriorStyle() == Aspect_IS_HIDDENLINE)
363   {
364     // copy all values including line edge aspect
365     *myAspectFaceHl.Aspect().operator->() = *myAspectFaceSet->Aspect();
366     myAspectFaceHl.SetAspectEdge (myAspectFaceSet->AspectEdge());
367     myAspectFaceHl.Aspect()->SetInteriorColor (myView->BackgroundColor().GetRGB());
368     myAspectFaceHl.SetNoLighting (true);
369     myAspectFaceSet = &myAspectFaceHl;
370   }
371   else
372   {
373     myGlContext->SetShadingMaterial (myAspectFaceSet, myHighlightStyle);
374   }
375
376   if (myAspectFaceSet->Aspect()->ToMapTexture())
377   {
378     myGlContext->BindTextures (myAspectFaceSet->TextureSet (myGlContext));
379   }
380   else
381   {
382     myGlContext->BindTextures (myEnvironmentTexture);
383   }
384
385   myAspectFaceApplied = myAspectFaceSet->Aspect();
386   return myAspectFaceSet;
387 }
388
389 // =======================================================================
390 // function : ApplyAspectMarker
391 // purpose  :
392 // =======================================================================
393 const OpenGl_AspectMarker* OpenGl_Workspace::ApplyAspectMarker()
394 {
395   if (myAspectMarkerSet->Aspect() != myAspectMarkerApplied)
396   {
397     if (myAspectMarkerApplied.IsNull()
398     || (myAspectMarkerSet->Aspect()->Scale() != myAspectMarkerApplied->Scale()))
399     {
400     #if !defined(GL_ES_VERSION_2_0)
401       glPointSize (myAspectMarkerSet->Aspect()->Scale());
402     #ifdef HAVE_GL2PS
403       gl2psPointSize (myAspectMarkerSet->Aspect()->Scale());
404     #endif
405     #endif
406     }
407     myAspectMarkerApplied = myAspectMarkerSet->Aspect();
408   }
409   return myAspectMarkerSet;
410 }
411
412 // =======================================================================
413 // function : Width
414 // purpose  :
415 // =======================================================================
416 Standard_Integer OpenGl_Workspace::Width()  const
417 {
418   return !myView->GlWindow().IsNull() ? myView->GlWindow()->Width() : 0;
419 }
420
421 // =======================================================================
422 // function : Height
423 // purpose  :
424 // =======================================================================
425 Standard_Integer OpenGl_Workspace::Height() const
426 {
427   return !myView->GlWindow().IsNull() ? myView->GlWindow()->Height() : 0;
428 }
429
430 // =======================================================================
431 // function : IsCullingEnabled
432 // purpose  :
433 // =======================================================================
434 Standard_Boolean OpenGl_Workspace::IsCullingEnabled() const
435 {
436   return myView->IsCullingEnabled();
437 }
438
439 // =======================================================================
440 // function : FBOCreate
441 // purpose  :
442 // =======================================================================
443 Handle(OpenGl_FrameBuffer) OpenGl_Workspace::FBOCreate (const Standard_Integer theWidth,
444                                                         const Standard_Integer theHeight)
445 {
446   // activate OpenGL context
447   if (!Activate())
448     return Handle(OpenGl_FrameBuffer)();
449
450   // create the FBO
451   const Handle(OpenGl_Context)& aCtx = GetGlContext();
452   aCtx->BindTextures (Handle(OpenGl_TextureSet)());
453   Handle(OpenGl_FrameBuffer) aFrameBuffer = new OpenGl_FrameBuffer();
454   if (!aFrameBuffer->Init (aCtx, theWidth, theHeight, GL_RGBA8, GL_DEPTH24_STENCIL8, 0))
455   {
456     aFrameBuffer->Release (aCtx.operator->());
457     return Handle(OpenGl_FrameBuffer)();
458   }
459   return aFrameBuffer;
460 }
461
462 // =======================================================================
463 // function : FBORelease
464 // purpose  :
465 // =======================================================================
466 void OpenGl_Workspace::FBORelease (Handle(OpenGl_FrameBuffer)& theFbo)
467 {
468   // activate OpenGL context
469   if (!Activate()
470    || theFbo.IsNull())
471   {
472     return;
473   }
474
475   theFbo->Release (GetGlContext().operator->());
476   theFbo.Nullify();
477 }
478
479 // =======================================================================
480 // function : BufferDump
481 // purpose  :
482 // =======================================================================
483 Standard_Boolean OpenGl_Workspace::BufferDump (const Handle(OpenGl_FrameBuffer)& theFbo,
484                                                Image_PixMap&                     theImage,
485                                                const Graphic3d_BufferType&       theBufferType)
486 {
487   return !theImage.IsEmpty()
488       && Activate()
489       && OpenGl_FrameBuffer::BufferDump (GetGlContext(), theFbo, theImage, theBufferType);
490 }
491
492 // =======================================================================
493 // function : ShouldRender
494 // purpose  :
495 // =======================================================================
496 Standard_Boolean OpenGl_RaytraceFilter::ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
497                                                       const OpenGl_Element*           theElement)
498 {
499   Standard_Boolean aPrevFilterResult = Standard_True;
500   if (!myPrevRenderFilter.IsNull())
501   {
502     aPrevFilterResult = myPrevRenderFilter->ShouldRender (theWorkspace, theElement);
503   }
504   return aPrevFilterResult &&
505     !OpenGl_Raytrace::IsRaytracedElement (theElement);
506 }