0032289: Visualization - add NCollection_Mat3 for 3x3 matrix similar to NCollection_Mat4
[occt.git] / src / OpenGl / OpenGl_View.hxx
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 #ifndef _OpenGl_View_Header
17 #define _OpenGl_View_Header
18
19 #include <Standard_Transient.hxx>
20 #include <Standard_Type.hxx>
21
22 #include <TColStd_Array2OfReal.hxx>
23 #include <NCollection_List.hxx>
24 #include <math_BullardGenerator.hxx>
25
26 #include <Quantity_NameOfColor.hxx>
27 #include <Aspect_FillMethod.hxx>
28 #include <Aspect_GradientFillMethod.hxx>
29
30 #include <Graphic3d_CView.hxx>
31 #include <Graphic3d_CullingTool.hxx>
32 #include <Graphic3d_GraduatedTrihedron.hxx>
33 #include <Graphic3d_SequenceOfHClipPlane.hxx>
34 #include <Graphic3d_ToneMappingMethod.hxx>
35 #include <Graphic3d_TypeOfShadingModel.hxx>
36 #include <Graphic3d_WorldViewProjState.hxx>
37 #include <Graphic3d_ZLayerSettings.hxx>
38
39 #include <OpenGl_Aspects.hxx>
40 #include <OpenGl_BackgroundArray.hxx>
41 #include <OpenGl_Context.hxx>
42 #include <OpenGl_FrameBuffer.hxx>
43 #include <OpenGl_FrameStatsPrs.hxx>
44 #include <OpenGl_GraduatedTrihedron.hxx>
45 #include <OpenGl_LayerList.hxx>
46 #include <OpenGl_LineAttributes.hxx>
47 #include <OpenGl_SceneGeometry.hxx>
48 #include <OpenGl_Structure.hxx>
49 #include <OpenGl_Window.hxx>
50 #include <OpenGl_Workspace.hxx>
51 #include <OpenGl_TileSampler.hxx>
52
53 #include <map>
54 #include <set>
55
56 class Graphic3d_StructureManager;
57 class OpenGl_DepthPeeling;
58 class OpenGl_GraphicDriver;
59 class OpenGl_PBREnvironment;
60 class OpenGl_StateCounter;
61 class OpenGl_ShadowMap;
62 class OpenGl_ShadowMapArray;
63 class OpenGl_TriangleSet;
64 class OpenGl_Workspace;
65 class OpenGl_View;
66
67 DEFINE_STANDARD_HANDLE(OpenGl_View,Graphic3d_CView)
68
69 //! Implementation of OpenGl view.
70 class OpenGl_View : public Graphic3d_CView
71 {
72
73 public:
74
75   //! Constructor.
76   Standard_EXPORT OpenGl_View (const Handle(Graphic3d_StructureManager)& theMgr,
77                                const Handle(OpenGl_GraphicDriver)& theDriver,
78                                const Handle(OpenGl_Caps)& theCaps,
79                                OpenGl_StateCounter* theCounter);
80
81   //! Default destructor.
82   Standard_EXPORT virtual ~OpenGl_View();
83
84   //! Release OpenGL resources.
85   Standard_EXPORT virtual void ReleaseGlResources (const Handle(OpenGl_Context)& theCtx);
86
87   //! Deletes and erases the view.
88   Standard_EXPORT virtual void Remove() Standard_OVERRIDE;
89
90   //! @param theDrawToFrontBuffer Advanced option to modify rendering mode:
91   //! 1. TRUE.  Drawing immediate mode structures directly to the front buffer over the scene image.
92   //! Fast, so preferred for interactive work (used by default).
93   //! However these extra drawings will be missed in image dump since it is performed from back buffer.
94   //! Notice that since no pre-buffering used the V-Sync will be ignored and rendering could be seen
95   //! in run-time (in case of slow hardware) and/or tearing may appear.
96   //! So this is strongly recommended to draw only simple (fast) structures.
97   //! 2. FALSE. Drawing immediate mode structures to the back buffer.
98   //! The complete scene is redrawn first, so this mode is slower if scene contains complex data and/or V-Sync
99   //! is turned on. But it works in any case and is especially useful for view dump because the dump image is read
100   //! from the back buffer.
101   //! @return previous mode.
102   Standard_EXPORT Standard_Boolean SetImmediateModeDrawToFront (const Standard_Boolean theDrawToFrontBuffer) Standard_OVERRIDE;
103
104   //! Creates and maps rendering window to the view.
105   //! @param theWindow [in] the window.
106   //! @param theContext [in] the rendering context. If NULL the context will be created internally.
107   Standard_EXPORT virtual void SetWindow (const Handle(Aspect_Window)&  theWindow,
108                                           const Aspect_RenderingContext theContext) Standard_OVERRIDE;
109
110   //! Returns window associated with the view.
111   virtual Handle(Aspect_Window) Window() const Standard_OVERRIDE
112   { return myWindow->PlatformWindow(); }
113
114   //! Returns True if the window associated to the view is defined.
115   virtual Standard_Boolean IsDefined() const Standard_OVERRIDE
116   { return !myWindow.IsNull(); }
117
118   //! Handle changing size of the rendering window.
119   Standard_EXPORT virtual void Resized() Standard_OVERRIDE;
120
121   //! Redraw content of the view.
122   Standard_EXPORT virtual void Redraw() Standard_OVERRIDE;
123
124   //! Redraw immediate content of the view.
125   Standard_EXPORT virtual void RedrawImmediate() Standard_OVERRIDE;
126
127   //! Marks BVH tree for given priority list as dirty and marks primitive set for rebuild.
128   Standard_EXPORT virtual void Invalidate() Standard_OVERRIDE;
129
130   //! Return true if view content cache has been invalidated.
131   virtual Standard_Boolean IsInvalidated() Standard_OVERRIDE { return !myBackBufferRestored; }
132
133   //! Dump active rendering buffer into specified memory buffer.
134   //! In Ray-Tracing allow to get a raw HDR buffer using Graphic3d_BT_RGB_RayTraceHdrLeft buffer type,
135   //! only Left view will be dumped ignoring stereoscopic parameter.
136   Standard_EXPORT virtual Standard_Boolean BufferDump (Image_PixMap& theImage,
137                                                        const Graphic3d_BufferType& theBufferType) Standard_OVERRIDE;
138
139   //! Marks BVH tree and the set of BVH primitives of correspondent priority list with id theLayerId as outdated.
140   Standard_EXPORT virtual void InvalidateBVHData (const Graphic3d_ZLayerId theLayerId) Standard_OVERRIDE;
141
142   //! Add a layer to the view.
143   //! @param theNewLayerId [in] id of new layer, should be > 0 (negative values are reserved for default layers).
144   //! @param theSettings   [in] new layer settings
145   //! @param theLayerAfter [in] id of layer to append new layer before
146   Standard_EXPORT virtual void InsertLayerBefore (const Graphic3d_ZLayerId theLayerId,
147                                                   const Graphic3d_ZLayerSettings& theSettings,
148                                                   const Graphic3d_ZLayerId theLayerAfter) Standard_OVERRIDE;
149
150   //! Add a layer to the view.
151   //! @param theNewLayerId  [in] id of new layer, should be > 0 (negative values are reserved for default layers).
152   //! @param theSettings    [in] new layer settings
153   //! @param theLayerBefore [in] id of layer to append new layer after
154   Standard_EXPORT virtual void InsertLayerAfter (const Graphic3d_ZLayerId theNewLayerId,
155                                                  const Graphic3d_ZLayerSettings& theSettings,
156                                                  const Graphic3d_ZLayerId theLayerBefore) Standard_OVERRIDE;
157
158   //! Remove a z layer with the given ID.
159   Standard_EXPORT virtual void RemoveZLayer (const Graphic3d_ZLayerId theLayerId) Standard_OVERRIDE;
160
161   //! Sets the settings for a single Z layer of specified view.
162   Standard_EXPORT virtual void SetZLayerSettings (const Graphic3d_ZLayerId theLayerId,
163                                                   const Graphic3d_ZLayerSettings& theSettings) Standard_OVERRIDE;
164
165   //! Returns the maximum Z layer ID.
166   //! First layer ID is Graphic3d_ZLayerId_Default, last ID is ZLayerMax().
167   Standard_EXPORT virtual Standard_Integer ZLayerMax() const Standard_OVERRIDE;
168
169   //! Returns the list of layers.
170   Standard_EXPORT virtual const NCollection_List<Handle(Graphic3d_Layer)>& Layers() const Standard_OVERRIDE;
171
172   //! Returns layer with given ID or NULL if undefined.
173   Standard_EXPORT virtual Handle(Graphic3d_Layer) Layer (const Graphic3d_ZLayerId theLayerId) const Standard_OVERRIDE;
174
175   //! Returns the bounding box of all structures displayed in the view.
176   //! If theToIncludeAuxiliary is TRUE, then the boundary box also includes minimum and maximum limits
177   //! of graphical elements forming parts of infinite and other auxiliary structures.
178   //! @param theToIncludeAuxiliary consider also auxiliary presentations (with infinite flag or with trihedron transformation persistence)
179   //! @return computed bounding box
180   Standard_EXPORT virtual Bnd_Box MinMaxValues (const Standard_Boolean theToIncludeAuxiliary) const Standard_OVERRIDE;
181
182   //! Returns pointer to an assigned framebuffer object.
183   Standard_EXPORT virtual Handle(Standard_Transient) FBO() const Standard_OVERRIDE;
184
185   //! Sets framebuffer object for offscreen rendering.
186   Standard_EXPORT virtual void SetFBO (const Handle(Standard_Transient)& theFbo) Standard_OVERRIDE;
187
188   //! Generate offscreen FBO in the graphic library.
189   //! If not supported on hardware returns NULL.
190   Standard_EXPORT virtual Handle(Standard_Transient) FBOCreate (const Standard_Integer theWidth,
191                                                                 const Standard_Integer theHeight) Standard_OVERRIDE;
192
193   //! Remove offscreen FBO from the graphic library
194   Standard_EXPORT virtual void FBORelease (Handle(Standard_Transient)& theFbo) Standard_OVERRIDE;
195
196   //! Read offscreen FBO configuration.
197   Standard_EXPORT virtual void FBOGetDimensions (const Handle(Standard_Transient)& theFbo,
198                                                  Standard_Integer& theWidth,
199                                                  Standard_Integer& theHeight,
200                                                  Standard_Integer& theWidthMax,
201                                                  Standard_Integer& theHeightMax) Standard_OVERRIDE;
202
203   //! Change offscreen FBO viewport.
204   Standard_EXPORT virtual void FBOChangeViewport (const Handle(Standard_Transient)& theFbo,
205                                                   const Standard_Integer theWidth,
206                                                   const Standard_Integer theHeight) Standard_OVERRIDE;
207
208   //! Returns additional buffers for depth peeling OIT.
209   const Handle(OpenGl_DepthPeeling)& DepthPeelingFbos() const { return myDepthPeelingFbos; }
210
211 public:
212
213   //! Returns gradient background fill colors.
214   Standard_EXPORT virtual Aspect_GradientBackground GradientBackground() const Standard_OVERRIDE;
215
216   //! Sets gradient background fill colors.
217   Standard_EXPORT virtual void SetGradientBackground (const Aspect_GradientBackground& theBackground) Standard_OVERRIDE;
218
219   //! Returns background image texture map.
220   virtual Handle(Graphic3d_TextureMap) BackgroundImage() Standard_OVERRIDE { return myBackgroundImage; }
221
222   //! Sets image texture or environment cubemap as background.
223   //! @param theTextureMap [in] source to set a background;
224   //!                           should be either Graphic3d_Texture2D or Graphic3d_CubeMap
225   //! @param theToUpdatePBREnv [in] defines whether IBL maps will be generated or not
226   //!                               (see GeneratePBREnvironment())
227   Standard_EXPORT virtual void SetBackgroundImage (const Handle(Graphic3d_TextureMap)& theTextureMap,
228                                                    Standard_Boolean theToUpdatePBREnv = Standard_True) Standard_OVERRIDE;
229
230   //! Returns background image fill style.
231   Standard_EXPORT virtual Aspect_FillMethod BackgroundImageStyle() const Standard_OVERRIDE;
232
233   //! Sets background image fill style.
234   Standard_EXPORT virtual void SetBackgroundImageStyle (const Aspect_FillMethod theFillStyle) Standard_OVERRIDE;
235
236   //! Returns cubemap being set last time on background.
237   Standard_EXPORT Handle(Graphic3d_CubeMap) BackgroundCubeMap() const Standard_OVERRIDE;
238
239   //! Generates PBR specular probe and irradiance map
240   //! in order to provide environment indirect illumination in PBR shading model (Image Based Lighting).
241   //! The source of environment data is background cubemap.
242   //! If PBR is unavailable it does nothing.
243   //! If PBR is available but there is no cubemap being set to background it clears all IBL maps (see 'ClearPBREnvironment').
244   virtual void GeneratePBREnvironment() Standard_OVERRIDE { myPBREnvRequest = OpenGl_PBREnvRequest_BAKE; }
245
246   //! Fills PBR specular probe and irradiance map with white color.
247   //! So that environment indirect illumination will be constant
248   //! and will be fully controlled by ambient light sources.
249   //! If PBR is unavailable it does nothing.
250   virtual void ClearPBREnvironment() Standard_OVERRIDE { myPBREnvRequest = OpenGl_PBREnvRequest_CLEAR; }
251
252   //! Returns number of mipmap levels used in specular IBL map.
253   //! 0 if PBR environment is not created.
254   Standard_EXPORT unsigned int SpecIBLMapLevels() const;
255
256   //! Returns environment texture set for the view.
257   virtual Handle(Graphic3d_TextureEnv) TextureEnv() const Standard_OVERRIDE { return myTextureEnvData; }
258
259   //! Sets environment texture for the view.
260   Standard_EXPORT virtual void SetTextureEnv (const Handle(Graphic3d_TextureEnv)& theTextureEnv) Standard_OVERRIDE;
261
262   //! Returns local camera origin currently set for rendering, might be modified during rendering.
263   const gp_XYZ& LocalOrigin() const { return myLocalOrigin; }
264
265   //! Setup local camera origin currently set for rendering.
266   Standard_EXPORT void SetLocalOrigin (const gp_XYZ& theOrigin);
267
268   //! Returns list of lights of the view.
269   virtual const Handle(Graphic3d_LightSet)& Lights() const Standard_OVERRIDE { return myLights; }
270
271   //! Sets list of lights for the view.
272   virtual void SetLights (const Handle(Graphic3d_LightSet)& theLights) Standard_OVERRIDE
273   {
274     myLights = theLights;
275     myCurrLightSourceState = myStateCounter->Increment();
276   }
277
278   //! Returns list of clip planes set for the view.
279   virtual const Handle(Graphic3d_SequenceOfHClipPlane)& ClipPlanes() const Standard_OVERRIDE { return myClipPlanes; }
280
281   //! Sets list of clip planes for the view.
282   virtual void SetClipPlanes (const Handle(Graphic3d_SequenceOfHClipPlane)& thePlanes) Standard_OVERRIDE { myClipPlanes = thePlanes; }
283
284   //! Fill in the dictionary with diagnostic info.
285   //! Should be called within rendering thread.
286   //!
287   //! This API should be used only for user output or for creating automated reports.
288   //! The format of returned information (e.g. key-value layout)
289   //! is NOT part of this API and can be changed at any time.
290   //! Thus application should not parse returned information to weed out specific parameters.
291   Standard_EXPORT virtual void DiagnosticInformation (TColStd_IndexedDataMapOfStringString& theDict,
292                                                       Graphic3d_DiagnosticInfo theFlags) const Standard_OVERRIDE;
293
294   //! Returns string with statistic performance info.
295   Standard_EXPORT virtual TCollection_AsciiString StatisticInformation() const Standard_OVERRIDE;
296
297   //! Fills in the dictionary with statistic performance info.
298   Standard_EXPORT virtual void StatisticInformation (TColStd_IndexedDataMapOfStringString& theDict) const Standard_OVERRIDE;
299
300 public:
301
302   //! Returns background color.
303   const Quantity_ColorRGBA& BackgroundColor() const { return myBgColor; }
304
305   //! Change graduated trihedron.
306   OpenGl_GraduatedTrihedron& ChangeGraduatedTrihedron() { return myGraduatedTrihedron; }
307
308   void SetTextureEnv (const Handle(OpenGl_Context)&       theCtx,
309                       const Handle(Graphic3d_TextureEnv)& theTexture);
310
311   void SetBackgroundTextureStyle (const Aspect_FillMethod FillStyle);
312
313   void SetBackgroundGradient (const Quantity_Color& AColor1, const Quantity_Color& AColor2, const Aspect_GradientFillMethod AType);
314
315   void SetBackgroundGradientType (const Aspect_GradientFillMethod AType);
316
317   //! Returns list of OpenGL Z-layers.
318   const OpenGl_LayerList& LayerList() const { return myZLayers; }
319
320   //! Returns OpenGL window implementation.
321   const Handle(OpenGl_Window)& GlWindow() const { return myWindow; }
322
323   //! Returns OpenGL environment map.
324   const Handle(OpenGl_TextureSet)& GlTextureEnv() const { return myTextureEnv; }
325
326   //! Returns selector for BVH tree, providing a possibility to store information
327   //! about current view volume and to detect which objects are overlapping it.
328   const Graphic3d_CullingTool& BVHTreeSelector() const { return myBVHSelector; }
329
330   //! Returns true if there are immediate structures to display
331   bool HasImmediateStructures() const
332   {
333     return myZLayers.NbImmediateStructures() != 0;
334   }
335
336 public: //! @name obsolete Graduated Trihedron functionality
337
338   //! Displays Graduated Trihedron.
339   Standard_EXPORT virtual void GraduatedTrihedronDisplay (const Graphic3d_GraduatedTrihedron& theTrihedronData) Standard_OVERRIDE;
340
341   //! Erases Graduated Trihedron.
342   Standard_EXPORT virtual void GraduatedTrihedronErase() Standard_OVERRIDE;
343
344   //! Sets minimum and maximum points of scene bounding box for Graduated Trihedron stored in graphic view object.
345   //! @param theMin [in] the minimum point of scene.
346   //! @param theMax [in] the maximum point of scene.
347   Standard_EXPORT virtual void GraduatedTrihedronMinMaxValues (const Graphic3d_Vec3 theMin, const Graphic3d_Vec3 theMax) Standard_OVERRIDE;
348
349 protected: //! @name Internal methods for managing GL resources
350
351   //! Initializes OpenGl resource for environment texture.
352   void initTextureEnv (const Handle(OpenGl_Context)& theContext);
353
354 protected: //! @name low-level redrawing sub-routines
355
356   //! Prepare frame buffers for rendering.
357   Standard_EXPORT virtual bool prepareFrameBuffers (Graphic3d_Camera::Projection& theProj);
358
359   //! Redraws view for the given monographic camera projection, or left/right eye.
360   Standard_EXPORT virtual void redraw (const Graphic3d_Camera::Projection theProjection,
361                                        OpenGl_FrameBuffer*                theReadDrawFbo,
362                                        OpenGl_FrameBuffer*                theOitAccumFbo);
363
364   //! Redraws view for the given monographic camera projection, or left/right eye.
365   //!
366   //! Method will blit snapshot containing main scene (myMainSceneFbos or BackBuffer)
367   //! into presentation buffer (myMainSceneFbos -> offscreen FBO or
368   //! myMainSceneFbos -> BackBuffer or BackBuffer -> FrontBuffer),
369   //! and redraw immediate structures on top.
370   //!
371   //! When scene caching is disabled (myTransientDrawToFront, no double buffer in window, etc.),
372   //! the first step (blitting) will be skipped.
373   //!
374   //! @return false if immediate structures has been rendered directly into FrontBuffer
375   //! and Buffer Swap should not be called.
376   Standard_EXPORT virtual bool redrawImmediate (const Graphic3d_Camera::Projection theProjection,
377                                                 OpenGl_FrameBuffer* theReadFbo,
378                                                 OpenGl_FrameBuffer* theDrawFbo,
379                                                 OpenGl_FrameBuffer* theOitAccumFbo,
380                                                 const Standard_Boolean theIsPartialUpdate = Standard_False);
381
382   //! Blit image from/to specified buffers.
383   Standard_EXPORT bool blitBuffers (OpenGl_FrameBuffer*    theReadFbo,
384                                     OpenGl_FrameBuffer*    theDrawFbo,
385                                     const Standard_Boolean theToFlip = Standard_False);
386
387   //! Setup default FBO.
388   Standard_EXPORT void bindDefaultFbo (OpenGl_FrameBuffer* theCustomFbo = NULL);
389
390 protected: //! @name Rendering of GL graphics (with prepared drawing buffer).
391
392   //! Renders the graphical contents of the view into the preprepared shadowmap framebuffer.
393   //! @param theShadowMap [in] the framebuffer for rendering shadowmap.
394   Standard_EXPORT virtual void renderShadowMap (const Handle(OpenGl_ShadowMap)& theShadowMap);
395
396   //! Renders the graphical contents of the view into the preprepared window or framebuffer.
397   //! @param theProjection [in] the projection that should be used for rendering.
398   //! @param theReadDrawFbo [in] the framebuffer for rendering graphics.
399   //! @param theOitAccumFbo [in] the framebuffer for accumulating color and coverage for OIT process.
400   //! @param theToDrawImmediate [in] the flag indicates whether the rendering performs in immediate mode.
401   Standard_EXPORT virtual void render (Graphic3d_Camera::Projection theProjection,
402                                        OpenGl_FrameBuffer*          theReadDrawFbo,
403                                        OpenGl_FrameBuffer*          theOitAccumFbo,
404                                        const Standard_Boolean       theToDrawImmediate);
405
406   //! Renders the graphical scene.
407   //! @param theProjection [in] the projection that is used for rendering.
408   //! @param theReadDrawFbo [in] the framebuffer for rendering graphics.
409   //! @param theOitAccumFbo [in] the framebuffer for accumulating color and coverage for OIT process.
410   //! @param theToDrawImmediate [in] the flag indicates whether the rendering performs in immediate mode.
411   Standard_EXPORT virtual void renderScene (Graphic3d_Camera::Projection theProjection,
412                                             OpenGl_FrameBuffer*    theReadDrawFbo,
413                                             OpenGl_FrameBuffer*    theOitAccumFbo,
414                                             const Standard_Boolean theToDrawImmediate);
415
416   //! Draw background (gradient / image)
417   Standard_EXPORT virtual void drawBackground (const Handle(OpenGl_Workspace)& theWorkspace,
418                                                Graphic3d_Camera::Projection theProjection);
419
420   //! Render set of structures presented in the view.
421   //! @param theProjection [in] the projection that is used for rendering.
422   //! @param theReadDrawFbo [in] the framebuffer for rendering graphics.
423   //! @param theOitAccumFbo [in] the framebuffer for accumulating color and coverage for OIT process.
424   //! @param theToDrawImmediate [in] the flag indicates whether the rendering performs in immediate mode.
425   Standard_EXPORT virtual void renderStructs (Graphic3d_Camera::Projection theProjection,
426                                               OpenGl_FrameBuffer*    theReadDrawFbo,
427                                               OpenGl_FrameBuffer*    theOitAccumFbo,
428                                               const Standard_Boolean theToDrawImmediate);
429
430   //! Renders trihedron.
431   void renderTrihedron (const Handle(OpenGl_Workspace) &theWorkspace);
432
433   //! Renders frame statistics.
434   void renderFrameStats();
435
436 private:
437
438   //! Adds the structure to display lists of the view.
439   Standard_EXPORT virtual void displayStructure (const Handle(Graphic3d_CStructure)& theStructure,
440                                                  const Standard_Integer thePriority) Standard_OVERRIDE;
441
442   //! Erases the structure from display lists of the view.
443   Standard_EXPORT virtual void eraseStructure (const Handle(Graphic3d_CStructure)& theStructure) Standard_OVERRIDE;
444
445   //! Change Z layer of a structure already presented in view.
446   Standard_EXPORT virtual void changeZLayer (const Handle(Graphic3d_CStructure)& theCStructure,
447                                              const Graphic3d_ZLayerId theNewLayerId) Standard_OVERRIDE;
448
449   //! Changes the priority of a structure within its Z layer in the specified view.
450   Standard_EXPORT virtual void changePriority (const Handle(Graphic3d_CStructure)& theCStructure,
451                                                const Standard_Integer theNewPriority) Standard_OVERRIDE;
452
453 private:
454
455   //! Release sRGB resources (frame-buffers, textures, etc.).
456   void releaseSrgbResources (const Handle(OpenGl_Context)& theCtx);
457
458   //! Copy content of Back buffer to the Front buffer.
459   bool copyBackToFront();
460
461   //! Initialize blit quad.
462   OpenGl_VertexBuffer* initBlitQuad (const Standard_Boolean theToFlip);
463
464   //! Blend together views pair into stereo image.
465   void drawStereoPair (OpenGl_FrameBuffer* theDrawFbo);
466
467   //! Check and update OIT compatibility with current OpenGL context's state.
468   bool checkOitCompatibility (const Handle(OpenGl_Context)& theGlContext,
469                               const Standard_Boolean theMSAA);
470
471   //! Chooses compatible internal color format for OIT frame buffer.
472   bool chooseOitColorConfiguration (const Handle(OpenGl_Context)& theGlContext,
473                                     const Standard_Integer theConfigIndex,
474                                     OpenGl_ColorFormats& theFormats);
475
476 protected:
477
478   OpenGl_GraphicDriver*    myDriver;
479   Handle(OpenGl_Window)    myWindow;
480   Handle(OpenGl_Workspace) myWorkspace;
481   Handle(OpenGl_Caps)      myCaps;
482   Standard_Boolean         myWasRedrawnGL;
483
484   Handle(Graphic3d_SequenceOfHClipPlane) myClipPlanes;
485   gp_XYZ                          myLocalOrigin;
486   Handle(OpenGl_FrameBuffer)      myFBO;
487   Standard_Boolean                myToShowGradTrihedron;
488   Handle(Graphic3d_TextureMap)    myBackgroundImage;
489   Handle(Graphic3d_TextureEnv)    myTextureEnvData;
490   Graphic3d_GraduatedTrihedron    myGTrihedronData;
491
492   Handle(Graphic3d_LightSet)      myNoShadingLight;
493   Handle(Graphic3d_LightSet)      myLights;
494   OpenGl_LayerList                myZLayers; //!< main list of displayed structure, sorted by layers
495
496   Graphic3d_WorldViewProjState    myWorldViewProjState; //!< camera modification state
497   OpenGl_StateCounter*            myStateCounter;
498   Standard_Size                   myCurrLightSourceState;
499   Standard_Size                   myLightsRevision;
500
501   typedef std::pair<Standard_Size, Standard_Size> StateInfo;
502
503   StateInfo myLastOrientationState;
504   StateInfo myLastViewMappingState;
505   StateInfo myLastLightSourceState;
506
507   //! Is needed for selection of overlapping objects and storage of the current view volume
508   Graphic3d_CullingTool myBVHSelector;
509
510   OpenGl_GraduatedTrihedron myGraduatedTrihedron;
511   OpenGl_FrameStatsPrs      myFrameStatsPrs;
512
513   Handle(OpenGl_TextureSet) myTextureEnv;
514
515   //! Framebuffers for OpenGL output.
516   Handle(OpenGl_FrameBuffer) myOpenGlFBO;
517   Handle(OpenGl_FrameBuffer) myOpenGlFBO2;
518
519 protected: //! @name Rendering properties
520
521   //! Two framebuffers (left and right views) store cached main presentation
522   //! of the view (without presentation of immediate layers).
523   Standard_Integer           mySRgbState;             //!< track sRGB state
524   GLint                      myFboColorFormat;        //!< sized format for color attachments
525   GLint                      myFboDepthFormat;        //!< sized format for depth-stencil attachments
526   OpenGl_ColorFormats        myFboOitColorConfig;     //!< selected color format configuration for OIT color attachments
527   Handle(OpenGl_FrameBuffer) myMainSceneFbos[2];
528   Handle(OpenGl_FrameBuffer) myMainSceneFbosOit[2];      //!< Additional buffers for transparent draw of main layer.
529   Handle(OpenGl_FrameBuffer) myImmediateSceneFbos[2];    //!< Additional buffers for immediate layer in stereo mode.
530   Handle(OpenGl_FrameBuffer) myImmediateSceneFbosOit[2]; //!< Additional buffers for transparency draw of immediate layer.
531   Handle(OpenGl_FrameBuffer) myXrSceneFbo;               //!< additional FBO (without MSAA) for submitting to XR
532   Handle(OpenGl_DepthPeeling)   myDepthPeelingFbos;   //!< additional buffers for depth peeling
533   Handle(OpenGl_ShadowMapArray) myShadowMaps;         //!< additional FBOs for shadow map rendering
534   OpenGl_VertexBuffer        myFullScreenQuad;        //!< Vertices for full-screen quad rendering.
535   OpenGl_VertexBuffer        myFullScreenQuadFlip;
536   Standard_Boolean           myToFlipOutput;          //!< Flag to draw result image upside-down
537   unsigned int               myFrameCounter;          //!< redraw counter, for debugging
538   Standard_Boolean           myHasFboBlit;            //!< disable FBOs on failure
539   Standard_Boolean           myToDisableOIT;          //!< disable OIT on failure
540   Standard_Boolean           myToDisableOITMSAA;      //!< disable OIT with MSAA on failure
541   Standard_Boolean           myToDisableMSAA;         //!< disable MSAA after failure
542   Standard_Boolean           myTransientDrawToFront; //!< optimization flag for immediate mode (to render directly to the front buffer)
543   Standard_Boolean           myBackBufferRestored;
544   Standard_Boolean           myIsImmediateDrawn;     //!< flag indicates that immediate mode buffer contains some data
545
546 protected: //! @name Background parameters
547
548   OpenGl_Aspects*            myTextureParams;                     //!< Stores texture and its parameters for textured background
549   OpenGl_Aspects*            myCubeMapParams;                     //!< Stores cubemap and its parameters for cubemap background
550   Handle(Graphic3d_CubeMap)  myBackgroundCubeMap;                 //!< Cubemap has been set as background
551   Graphic3d_TypeOfBackground myBackgroundType;                    //!< Current type of background
552   OpenGl_BackgroundArray*    myBackgrounds[Graphic3d_TypeOfBackground_NB]; //!< Array of primitive arrays of different background types
553
554 protected: //! @name methods related to PBR
555
556   //! Checks whether PBR is available.
557   Standard_EXPORT Standard_Boolean checkPBRAvailability() const;
558
559   //! Generates IBL maps used in PBR pipeline.
560   //! If background cubemap is not set clears all IBL maps.
561   Standard_EXPORT void bakePBREnvironment (const Handle(OpenGl_Context)& theCtx);
562
563   //! Fills all IBL maps with white color.
564   //! So that environment lighting is considered to be constant and is completely controls by ambient light sources.
565   Standard_EXPORT void clearPBREnvironment (const Handle(OpenGl_Context)& theCtx);
566
567   //! Process requests to generate or to clear PBR environment.
568   Standard_EXPORT void processPBREnvRequest (const Handle(OpenGl_Context)& theCtx);
569
570 protected: //! @name fields and types related to PBR
571
572   //! State of PBR environment.
573   enum PBREnvironmentState
574   {
575     OpenGl_PBREnvState_NONEXISTENT,
576     OpenGl_PBREnvState_UNAVAILABLE, // indicates failed try to create PBR environment
577     OpenGl_PBREnvState_CREATED
578   };
579
580   //! Type of action which can be done with PBR environment.
581   enum PBREnvironmentRequest
582   {
583     OpenGl_PBREnvRequest_NONE,
584     OpenGl_PBREnvRequest_BAKE,
585     OpenGl_PBREnvRequest_CLEAR
586   };
587
588   Handle(OpenGl_PBREnvironment) myPBREnvironment; //!< manager of IBL maps used in PBR pipeline
589   PBREnvironmentState           myPBREnvState;    //!< state of PBR environment
590   PBREnvironmentRequest         myPBREnvRequest;  //!< type of action is requested to be done with PBR environment
591
592 protected: //! @name data types related to ray-tracing
593
594   //! Result of OpenGL shaders initialization.
595   enum RaytraceInitStatus
596   {
597     OpenGl_RT_NONE,
598     OpenGl_RT_INIT,
599     OpenGl_RT_FAIL
600   };
601
602   //! Describes update mode (state).
603   enum RaytraceUpdateMode
604   {
605     OpenGl_GUM_CHECK,   //!< check geometry state
606     OpenGl_GUM_PREPARE, //!< collect unchanged objects
607     OpenGl_GUM_REBUILD  //!< rebuild changed and new objects
608   };
609
610   //! Defines frequently used shader variables.
611   enum ShaderVariableIndex
612   {
613     OpenGl_RT_aPosition,
614
615     // camera position
616     OpenGl_RT_uOriginLT,
617     OpenGl_RT_uOriginLB,
618     OpenGl_RT_uOriginRT,
619     OpenGl_RT_uOriginRB,
620     OpenGl_RT_uDirectLT,
621     OpenGl_RT_uDirectLB,
622     OpenGl_RT_uDirectRT,
623     OpenGl_RT_uDirectRB,
624     OpenGl_RT_uViewPrMat,
625     OpenGl_RT_uUnviewMat,
626
627     // 3D scene params
628     OpenGl_RT_uSceneRad,
629     OpenGl_RT_uSceneEps,
630     OpenGl_RT_uLightAmbnt,
631     OpenGl_RT_uLightCount,
632
633     // background params
634     OpenGl_RT_uBackColorTop,
635     OpenGl_RT_uBackColorBot,
636
637     // ray-tracing params
638     OpenGl_RT_uShadowsEnabled,
639     OpenGl_RT_uReflectEnabled,
640     OpenGl_RT_uEnvMapEnabled,
641     OpenGl_RT_uEnvMapForBack,
642     OpenGl_RT_uTexSamplersArray,
643     OpenGl_RT_uBlockedRngEnabled,
644
645     // size of render window
646     OpenGl_RT_uWinSizeX,
647     OpenGl_RT_uWinSizeY,
648
649     // sampled frame params
650     OpenGl_RT_uAccumSamples,
651     OpenGl_RT_uFrameRndSeed,
652
653     // adaptive FSAA params
654     OpenGl_RT_uFsaaOffset,
655     OpenGl_RT_uSamples,
656
657     // images used by ISS mode
658     OpenGl_RT_uRenderImage,
659     OpenGl_RT_uTilesImage,
660     OpenGl_RT_uOffsetImage,
661     OpenGl_RT_uTileSize,
662     OpenGl_RT_uVarianceScaleFactor,
663
664     // maximum radiance value
665     OpenGl_RT_uMaxRadiance,
666
667     OpenGl_RT_NbVariables // special field
668   };
669
670   //! Defines OpenGL image samplers.
671   enum ShaderImageNames
672   {
673     OpenGl_RT_OutputImage = 0,
674     OpenGl_RT_VisualErrorImage = 1,
675     OpenGl_RT_TileOffsetsImage = 2,
676     OpenGl_RT_TileSamplesImage = 3
677   };
678
679   //! Tool class for management of shader sources.
680   class ShaderSource
681   {
682   public:
683
684     //! Default shader prefix - empty string.
685     static const TCollection_AsciiString EMPTY_PREFIX;
686
687     //! Creates new uninitialized shader source.
688     ShaderSource()
689     {
690       //
691     }
692
693   public:
694
695     //! Returns error description in case of load fail.
696     const TCollection_AsciiString& ErrorDescription() const
697     {
698       return myError;
699     }
700
701     //! Returns prefix to insert before the source.
702     const TCollection_AsciiString& Prefix() const
703     {
704       return myPrefix;
705     }
706
707     //! Sets prefix to insert before the source.
708     void SetPrefix (const TCollection_AsciiString& thePrefix)
709     {
710       myPrefix = thePrefix;
711     }
712
713     //! Returns shader source combined with prefix.
714     TCollection_AsciiString Source (const Handle(OpenGl_Context)& theCtx,
715                                     const GLenum theType) const;
716
717     //! Loads shader source from specified files.
718     Standard_Boolean LoadFromFiles (const TCollection_AsciiString* theFileNames, const TCollection_AsciiString& thePrefix = EMPTY_PREFIX);
719
720     //! Loads shader source from specified strings.
721     Standard_Boolean LoadFromStrings (const TCollection_AsciiString* theStrings, const TCollection_AsciiString& thePrefix = EMPTY_PREFIX);
722
723   private:
724
725     TCollection_AsciiString mySource; //!< Source string of the shader object
726     TCollection_AsciiString myPrefix; //!< Prefix to insert before the source
727     TCollection_AsciiString myError;  //!< error state
728
729   };
730
731   //! Default ray-tracing depth.
732   static const Standard_Integer THE_DEFAULT_NB_BOUNCES = 3;
733
734   //! Default size of traversal stack.
735   static const Standard_Integer THE_DEFAULT_STACK_SIZE = 10;
736
737   //! Compile-time ray-tracing parameters.
738   struct RaytracingParams
739   {
740     //! Actual size of traversal stack in shader program.
741     Standard_Integer StackSize;
742
743     //! Actual ray-tracing depth (number of ray bounces).
744     Standard_Integer NbBounces;
745
746     //! Define depth computation
747     Standard_Boolean IsZeroToOneDepth;
748
749     //! Enables/disables light propagation through transparent media.
750     Standard_Boolean TransparentShadows;
751
752     //! Enables/disables global illumination (GI) effects.
753     Standard_Boolean GlobalIllumination;
754
755     //! Enables/disables the use of OpenGL bindless textures.
756     Standard_Boolean UseBindlessTextures;
757
758     //! Enables/disables two-sided BSDF models instead of one-sided.
759     Standard_Boolean TwoSidedBsdfModels;
760
761     //! Enables/disables adaptive screen sampling for path tracing.
762     Standard_Boolean AdaptiveScreenSampling;
763
764     //! Enables/disables 1-pass atomic mode for AdaptiveScreenSampling.
765     Standard_Boolean AdaptiveScreenSamplingAtomic;
766
767     //! Enables/disables environment map for background.
768     Standard_Boolean UseEnvMapForBackground;
769
770     //! Enables/disables normal map ignoring during path tracing.
771     Standard_Boolean ToIgnoreNormalMap;
772
773     //! Maximum radiance value used for clamping radiance estimation.
774     Standard_ShortReal RadianceClampingValue;
775     
776     //! Enables/disables depth-of-field effect (path tracing, perspective camera).
777     Standard_Boolean DepthOfField;
778
779     //! Enables/disables cubemap backgraund.
780     Standard_Boolean CubemapForBack;
781
782     //! Tone mapping method for path tracing.
783     Graphic3d_ToneMappingMethod ToneMappingMethod;
784
785     //! Creates default compile-time ray-tracing parameters.
786     RaytracingParams()
787     : StackSize              (THE_DEFAULT_STACK_SIZE),
788       NbBounces              (THE_DEFAULT_NB_BOUNCES),
789       IsZeroToOneDepth       (Standard_False),
790       TransparentShadows     (Standard_False),
791       GlobalIllumination     (Standard_False),
792       UseBindlessTextures    (Standard_False),
793       TwoSidedBsdfModels     (Standard_False),
794       AdaptiveScreenSampling (Standard_False),
795       AdaptiveScreenSamplingAtomic (Standard_False),
796       UseEnvMapForBackground (Standard_False),
797       ToIgnoreNormalMap      (Standard_False),
798       RadianceClampingValue  (30.0),
799       DepthOfField           (Standard_False),
800       CubemapForBack         (Standard_False),
801       ToneMappingMethod      (Graphic3d_ToneMappingMethod_Disabled) { }
802   };
803
804   //! Describes state of OpenGL structure.
805   struct StructState
806   {
807     Standard_Size StructureState;
808     Standard_Size InstancedState;
809
810     //! Creates new structure state.
811     StructState (const Standard_Size theStructureState = 0,
812                  const Standard_Size theInstancedState = 0)
813     : StructureState (theStructureState),
814       InstancedState (theInstancedState)
815     {
816       //
817     }
818
819     //! Creates new structure state.
820     StructState (const OpenGl_Structure* theStructure)
821     {
822       StructureState = theStructure->ModificationState();
823
824       InstancedState = theStructure->InstancedStructure() != NULL ?
825         theStructure->InstancedStructure()->ModificationState() : 0;
826     }
827   };
828
829 protected: //! @name methods related to ray-tracing
830
831   //! Updates 3D scene geometry for ray-tracing.
832   Standard_Boolean updateRaytraceGeometry (const RaytraceUpdateMode      theMode,
833                                            const Standard_Integer        theViewId,
834                                            const Handle(OpenGl_Context)& theGlContext);
835
836   //! Updates 3D scene light sources for ray-tracing.
837   Standard_Boolean updateRaytraceLightSources (const OpenGl_Mat4& theInvModelView, const Handle(OpenGl_Context)& theGlContext);
838
839   //! Checks to see if the OpenGL structure is modified.
840   Standard_Boolean toUpdateStructure (const OpenGl_Structure* theStructure);
841
842   //! Adds OpenGL structure to ray-traced scene geometry.
843   Standard_Boolean addRaytraceStructure (const OpenGl_Structure*       theStructure,
844                                          const Handle(OpenGl_Context)& theGlContext);
845
846   //! Adds OpenGL groups to ray-traced scene geometry.
847   Standard_Boolean addRaytraceGroups (const OpenGl_Structure*        theStructure,
848                                       const OpenGl_RaytraceMaterial& theStructMat,
849                                       const Handle(TopLoc_Datum3D)&  theTrsf,
850                                       const Handle(OpenGl_Context)&  theGlContext);
851
852   //! Creates ray-tracing material properties.
853   OpenGl_RaytraceMaterial convertMaterial (const OpenGl_Aspects* theAspect,
854                                            const Handle(OpenGl_Context)& theGlContext);
855
856   //! Adds OpenGL primitive array to ray-traced scene geometry.
857   Handle(OpenGl_TriangleSet) addRaytracePrimitiveArray (const OpenGl_PrimitiveArray* theArray,
858                                                         const Standard_Integer       theMatID,
859                                                         const OpenGl_Mat4*           theTrans);
860
861   //! Adds vertex indices from OpenGL primitive array to ray-traced scene geometry.
862   Standard_Boolean addRaytraceVertexIndices (OpenGl_TriangleSet&                  theSet,
863                                              const Standard_Integer               theMatID,
864                                              const Standard_Integer               theCount,
865                                              const Standard_Integer               theOffset,
866                                              const OpenGl_PrimitiveArray&         theArray);
867
868   //! Adds OpenGL triangle array to ray-traced scene geometry.
869   Standard_Boolean addRaytraceTriangleArray (OpenGl_TriangleSet&                  theSet,
870                                              const Standard_Integer               theMatID,
871                                              const Standard_Integer               theCount,
872                                              const Standard_Integer               theOffset,
873                                              const Handle(Graphic3d_IndexBuffer)& theIndices);
874
875   //! Adds OpenGL triangle fan array to ray-traced scene geometry.
876   Standard_Boolean addRaytraceTriangleFanArray (OpenGl_TriangleSet&                  theSet,
877                                                 const Standard_Integer               theMatID,
878                                                 const Standard_Integer               theCount,
879                                                 const Standard_Integer               theOffset,
880                                                 const Handle(Graphic3d_IndexBuffer)& theIndices);
881
882   //! Adds OpenGL triangle strip array to ray-traced scene geometry.
883   Standard_Boolean addRaytraceTriangleStripArray (OpenGl_TriangleSet&                  theSet,
884                                                   const Standard_Integer               theMatID,
885                                                   const Standard_Integer               theCount,
886                                                   const Standard_Integer               theOffset,
887                                                   const Handle(Graphic3d_IndexBuffer)& theIndices);
888
889   //! Adds OpenGL quadrangle array to ray-traced scene geometry.
890   Standard_Boolean addRaytraceQuadrangleArray (OpenGl_TriangleSet&                  theSet,
891                                                const Standard_Integer               theMatID,
892                                                const Standard_Integer               theCount,
893                                                const Standard_Integer               theOffset,
894                                                const Handle(Graphic3d_IndexBuffer)& theIndices);
895
896   //! Adds OpenGL quadrangle strip array to ray-traced scene geometry.
897   Standard_Boolean addRaytraceQuadrangleStripArray (OpenGl_TriangleSet&                  theSet,
898                                                     const Standard_Integer               theMatID,
899                                                     const Standard_Integer               theCount,
900                                                     const Standard_Integer               theOffset,
901                                                     const Handle(Graphic3d_IndexBuffer)& theIndices);
902
903   //! Adds OpenGL polygon array to ray-traced scene geometry.
904   Standard_Boolean addRaytracePolygonArray (OpenGl_TriangleSet&                  theSet,
905                                             const Standard_Integer               theMatID,
906                                             const Standard_Integer               theCount,
907                                             const Standard_Integer               theOffset,
908                                             const Handle(Graphic3d_IndexBuffer)& theIndices);
909
910   //! Uploads ray-trace data to the GPU.
911   Standard_Boolean uploadRaytraceData (const Handle(OpenGl_Context)& theGlContext);
912
913   //! Generates shader prefix based on current ray-tracing options.
914   TCollection_AsciiString generateShaderPrefix (const Handle(OpenGl_Context)& theGlContext) const;
915
916   //! Performs safe exit when shaders initialization fails.
917   Standard_Boolean safeFailBack (const TCollection_ExtendedString& theMessage,
918                                  const Handle(OpenGl_Context)&     theGlContext);
919
920   //! Loads and compiles shader object from specified source.
921   Handle(OpenGl_ShaderObject) initShader (const GLenum                  theType,
922                                           const ShaderSource&           theSource,
923                                           const Handle(OpenGl_Context)& theGlContext);
924
925   //! Creates shader program from the given vertex and fragment shaders.
926   Handle(OpenGl_ShaderProgram) initProgram (const Handle(OpenGl_Context)&      theGlContext,
927                                             const Handle(OpenGl_ShaderObject)& theVertShader,
928                                             const Handle(OpenGl_ShaderObject)& theFragShader,
929                                             const TCollection_AsciiString& theName);
930
931   //! Initializes OpenGL/GLSL shader programs.
932   Standard_Boolean initRaytraceResources (const Standard_Integer theSizeX,
933                                           const Standard_Integer theSizeY,
934                                           const Handle(OpenGl_Context)& theGlContext);
935
936   //! Releases OpenGL/GLSL shader programs.
937   void releaseRaytraceResources (const Handle(OpenGl_Context)& theGlContext,
938                                  const Standard_Boolean        theToRebuild = Standard_False);
939
940   //! Updates auxiliary OpenGL frame buffers.
941   Standard_Boolean updateRaytraceBuffers (const Standard_Integer        theSizeX,
942                                           const Standard_Integer        theSizeY,
943                                           const Handle(OpenGl_Context)& theGlContext);
944
945   //! Generates viewing rays for corners of screen quad.
946   //! (ray tracing; path tracing for orthographic camera)
947   void updateCamera (const OpenGl_Mat4& theOrientation,
948                      const OpenGl_Mat4& theViewMapping,
949                      OpenGl_Vec3*       theOrigins,
950                      OpenGl_Vec3*       theDirects,
951                      OpenGl_Mat4&       theView,
952                      OpenGl_Mat4&       theUnView);
953
954   //! Generate viewing rays (path tracing, perspective camera).
955   void updatePerspCameraPT(const OpenGl_Mat4&           theOrientation,
956                            const OpenGl_Mat4&           theViewMapping,
957                            Graphic3d_Camera::Projection theProjection,
958                            OpenGl_Mat4&                 theViewPr,
959                            OpenGl_Mat4&                 theUnview,
960                            const int                    theWinSizeX,
961                            const int                    theWinSizeY);
962
963   //! Binds ray-trace textures to corresponding texture units.
964   void bindRaytraceTextures (const Handle(OpenGl_Context)& theGlContext,
965                              int theStereoView);
966
967   //! Unbinds ray-trace textures from corresponding texture unit.
968   void unbindRaytraceTextures (const Handle(OpenGl_Context)& theGlContext);
969
970   //! Sets uniform state for the given ray-tracing shader program.
971   Standard_Boolean setUniformState (const Standard_Integer        theProgramId,
972                                     const Standard_Integer        theSizeX,
973                                     const Standard_Integer        theSizeY,
974                                     Graphic3d_Camera::Projection  theProjection,
975                                     const Handle(OpenGl_Context)& theGlContext);
976
977   //! Runs ray-tracing shader programs.
978   Standard_Boolean runRaytraceShaders (const Standard_Integer        theSizeX,
979                                        const Standard_Integer        theSizeY,
980                                        Graphic3d_Camera::Projection  theProjection,
981                                        OpenGl_FrameBuffer*           theReadDrawFbo,
982                                        const Handle(OpenGl_Context)& theGlContext);
983
984   //! Runs classical (Whitted-style) ray-tracing kernel.
985   Standard_Boolean runRaytrace (const Standard_Integer        theSizeX,
986                                 const Standard_Integer        theSizeY,
987                                 Graphic3d_Camera::Projection  theProjection,
988                                 OpenGl_FrameBuffer*           theReadDrawFbo,
989                                 const Handle(OpenGl_Context)& theGlContext);
990
991   //! Runs path tracing (global illumination) kernel.
992   Standard_Boolean runPathtrace (const Standard_Integer        theSizeX,
993                                  const Standard_Integer        theSizeY,
994                                  Graphic3d_Camera::Projection  theProjection,
995                                  const Handle(OpenGl_Context)& theGlContext);
996
997   //! Runs path tracing (global illumination) kernel.
998   Standard_Boolean runPathtraceOut (Graphic3d_Camera::Projection  theProjection,
999                                     OpenGl_FrameBuffer*           theReadDrawFbo,
1000                                     const Handle(OpenGl_Context)& theGlContext);
1001
1002   //! Redraws the window using OpenGL/GLSL ray-tracing or path tracing.
1003   Standard_Boolean raytrace (const Standard_Integer        theSizeX,
1004                              const Standard_Integer        theSizeY,
1005                              Graphic3d_Camera::Projection  theProjection,
1006                              OpenGl_FrameBuffer*           theReadDrawFbo,
1007                              const Handle(OpenGl_Context)& theGlContext);
1008
1009 protected: //! @name fields related to ray-tracing
1010
1011   //! Result of RT/PT shaders initialization.
1012   RaytraceInitStatus myRaytraceInitStatus;
1013
1014   //! Is ray-tracing geometry data valid?
1015   Standard_Boolean myIsRaytraceDataValid;
1016
1017   //! True if warning about missing extension GL_ARB_bindless_texture has been displayed.
1018   Standard_Boolean myIsRaytraceWarnTextures;
1019
1020   //! 3D scene geometry data for ray-tracing.
1021   OpenGl_RaytraceGeometry myRaytraceGeometry;
1022
1023   //! Builder for triangle set.
1024   opencascade::handle<BVH_Builder<Standard_ShortReal, 3> > myRaytraceBVHBuilder;
1025
1026   //! Compile-time ray-tracing parameters.
1027   RaytracingParams myRaytraceParameters;
1028
1029   //! Radius of bounding sphere of the scene.
1030   Standard_ShortReal myRaytraceSceneRadius;
1031   //! Scene epsilon to prevent self-intersections.
1032   Standard_ShortReal myRaytraceSceneEpsilon;
1033
1034   //! OpenGL/GLSL source of ray-tracing fragment shader.
1035   ShaderSource myRaytraceShaderSource;
1036   //! OpenGL/GLSL source of adaptive-AA fragment shader.
1037   ShaderSource myPostFSAAShaderSource;
1038   //! OpenGL/GLSL source of RT/PT display fragment shader.
1039   ShaderSource myOutImageShaderSource;
1040
1041   //! OpenGL/GLSL ray-tracing fragment shader.
1042   Handle(OpenGl_ShaderObject) myRaytraceShader;
1043   //! OpenGL/GLSL adaptive-AA fragment shader.
1044   Handle(OpenGl_ShaderObject) myPostFSAAShader;
1045   //! OpenGL/GLSL ray-tracing display fragment shader.
1046   Handle(OpenGl_ShaderObject) myOutImageShader;
1047
1048   //! OpenGL/GLSL ray-tracing shader program.
1049   Handle(OpenGl_ShaderProgram) myRaytraceProgram;
1050   //! OpenGL/GLSL adaptive-AA shader program.
1051   Handle(OpenGl_ShaderProgram) myPostFSAAProgram;
1052   //! OpenGL/GLSL program for displaying texture.
1053   Handle(OpenGl_ShaderProgram) myOutImageProgram;
1054
1055   //! Texture buffer of data records of bottom-level BVH nodes.
1056   Handle(OpenGl_TextureBufferArb) mySceneNodeInfoTexture;
1057   //! Texture buffer of minimum points of bottom-level BVH nodes.
1058   Handle(OpenGl_TextureBufferArb) mySceneMinPointTexture;
1059   //! Texture buffer of maximum points of bottom-level BVH nodes.
1060   Handle(OpenGl_TextureBufferArb) mySceneMaxPointTexture;
1061   //! Texture buffer of transformations of high-level BVH nodes.
1062   Handle(OpenGl_TextureBufferArb) mySceneTransformTexture;
1063
1064   //! Texture buffer of vertex coords.
1065   Handle(OpenGl_TextureBufferArb) myGeometryVertexTexture;
1066   //! Texture buffer of vertex normals.
1067   Handle(OpenGl_TextureBufferArb) myGeometryNormalTexture;
1068   //! Texture buffer of vertex UV coords.
1069   Handle(OpenGl_TextureBufferArb) myGeometryTexCrdTexture;
1070   //! Texture buffer of triangle indices.
1071   Handle(OpenGl_TextureBufferArb) myGeometryTriangTexture;
1072
1073   //! Texture buffer of material properties.
1074   Handle(OpenGl_TextureBufferArb) myRaytraceMaterialTexture;
1075   //! Texture buffer of light source properties.
1076   Handle(OpenGl_TextureBufferArb) myRaytraceLightSrcTexture;
1077
1078   //! 1st framebuffer (FBO) to perform adaptive FSAA.
1079   //! Used in compatibility mode (no adaptive sampling).
1080   Handle(OpenGl_FrameBuffer) myRaytraceFBO1[2];
1081   //! 2nd framebuffer (FBO) to perform adaptive FSAA.
1082   //! Used in compatibility mode (no adaptive sampling).
1083   Handle(OpenGl_FrameBuffer) myRaytraceFBO2[2];
1084
1085   //! Output textures (2 textures are used in stereo mode).
1086   //! Used if adaptive screen sampling is activated.
1087   Handle(OpenGl_Texture) myRaytraceOutputTexture[2];
1088
1089   //! Texture containing per-tile visual error estimation (2 textures are used in stereo mode).
1090   //! Used if adaptive screen sampling is activated.
1091   Handle(OpenGl_Texture) myRaytraceVisualErrorTexture[2];
1092   //! Texture containing offsets of sampled screen tiles (2 textures are used in stereo mode).
1093   //! Used if adaptive screen sampling is activated.
1094   Handle(OpenGl_Texture) myRaytraceTileOffsetsTexture[2];
1095   //! Texture containing amount of extra per-tile samples (2 textures are used in stereo mode).
1096   //! Used if adaptive screen sampling is activated.
1097   Handle(OpenGl_Texture) myRaytraceTileSamplesTexture[2];
1098
1099   //! Vertex buffer (VBO) for drawing dummy quad.
1100   OpenGl_VertexBuffer myRaytraceScreenQuad;
1101
1102   //! Cached locations of frequently used uniform variables.
1103   Standard_Integer myUniformLocations[2][OpenGl_RT_NbVariables];
1104
1105   //! State of OpenGL structures reflected to ray-tracing.
1106   std::map<const OpenGl_Structure*, StructState> myStructureStates;
1107
1108   //! PrimitiveArray to TriangleSet map for scene partial update.
1109   std::map<Standard_Size, OpenGl_TriangleSet*> myArrayToTrianglesMap;
1110
1111   //! Set of IDs of non-raytracable elements (to detect updates).
1112   std::set<Standard_Integer> myNonRaytraceStructureIDs;
1113
1114   //! Marks if environment map should be updated.
1115   Standard_Boolean myToUpdateEnvironmentMap;
1116
1117   //! State of OpenGL layer list.
1118   Standard_Size myRaytraceLayerListState;
1119
1120   //! Number of accumulated frames (for progressive rendering).
1121   Standard_Integer myAccumFrames;
1122
1123   //! Stored ray origins used for detection of camera movements.
1124   OpenGl_Vec3 myPreviousOrigins[3];
1125
1126   //! Bullard RNG to produce random sequence.
1127   math_BullardGenerator myRNG;
1128
1129   //! Tool object for sampling screen tiles in PT mode.
1130   OpenGl_TileSampler myTileSampler;
1131
1132   //! Camera position used for projective mode
1133   OpenGl_Vec3 myEyeOrig;
1134
1135   //! Camera view direction used for projective mode
1136   OpenGl_Vec3 myEyeView;
1137
1138   //! Camera's screen vertical direction used for projective mode
1139   OpenGl_Vec3 myEyeVert;
1140
1141   //! Camera's screen horizontal direction used for projective mode
1142   OpenGl_Vec3 myEyeSide;
1143
1144   //! Camera's screen size used for projective mode
1145   OpenGl_Vec2 myEyeSize;
1146
1147   //! Aperture radius of camera on previous frame used for depth-of-field (path tracing)
1148   float myPrevCameraApertureRadius;
1149
1150   //! Focal distance of camera on previous frame used for depth-of-field (path tracing)
1151   float myPrevCameraFocalPlaneDist;
1152
1153 public:
1154
1155   DEFINE_STANDARD_ALLOC
1156   DEFINE_STANDARD_RTTIEXT(OpenGl_View,Graphic3d_CView) // Type definition
1157
1158   friend class OpenGl_GraphicDriver;
1159   friend class OpenGl_Workspace;
1160   friend class OpenGl_LayerList;
1161   friend class OpenGl_FrameStats;
1162 };
1163
1164 #endif // _OpenGl_View_Header