Weighted, Blended Order-Independent Transparency algorithm has been added rasterization pipeline.
In contrast to classical blending transparency it makes transparent objects look independent
from point of view. It also gives better depth occlusion when being used together with a weight factor
based on value of a GL depth buffer. The feature supports desktop OpenGL, OpenGL ES 3.0, ANGLE
and can be used together with MSAA on desktop GL.
To be used it require availability of:
1) Shaders pipeline.
2) Floating point color format for framebuffer (GL_ARB_color_buffer_float).
3) Multiple render targets (GL_ARB_draw_buffers).
Patch does not modify API and does not require application porting.
It adds new rendering options to Graphic3d_RenderingParams structure:
a) Transparency method from enumeration.
b) Scalar factor [0-1] controlling influence of a fragment's depth to its visibility.
Patch also simplifies processing of transparent objects for standard method:
rendering priority of transparent graphical structures is managed automatically,
therefore there is no need to care about it at application's side.
}
const Handle(Prs3d_Presentation)& aPrs = aPrsModed.Presentation()->Presentation();
- aPrs->SetDisplayPriority (10); // force highest priority for translucent objects
for (Graphic3d_SequenceOfGroup::Iterator aGroupIt (aPrs->Groups()); aGroupIt.More(); aGroupIt.Next())
{
const Handle(Graphic3d_Group)& aGroup = aGroupIt.Value();
aGroup->SetGroupPrimitivesAspect (anAreaAsp);
}
}
- aPrs->ResetDisplayPriority();
}
myRecomputeEveryPrs = Standard_False; // no mode to recalculate :only viewer update
const Handle(Prs3d_Presentation)& aPrs = aPrsModed.Presentation()->Presentation();
- if (IsTransparent())
- {
- aPrs->SetDisplayPriority (10); // force highest priority for translucent objects
- }
-
for (Graphic3d_SequenceOfGroup::Iterator aGroupIt (aPrs->Groups()); aGroupIt.More(); aGroupIt.Next())
{
const Handle(Graphic3d_Group)& aGroup = aGroupIt.Value();
aGroup->SetGroupPrimitivesAspect (anAreaAsp);
}
}
-
- if (!IsTransparent())
- {
- aPrs->ResetDisplayPriority();
- }
}
myRecomputeEveryPrs = Standard_False; // no mode to recalculate - only viewer update
return Standard_False;
}
- myColorTexture->Release (theCtx.operator->());
- myColorTexture->Create (theCtx);
+ myColorTextures (0)->Release (theCtx.operator->());
+ myColorTextures (0)->Create (theCtx);
myGlD3dSurf = aFuncs->wglDXRegisterObjectNV (myGlD3dDevice,
myD3dSurf,
- myColorTexture->TextureId(),
+ myColorTextures (0)->TextureId(),
GL_TEXTURE_2D,
WGL_ACCESS_WRITE_DISCARD_NV);
OpenGl_FrameBuffer::BindBuffer (theCtx);
theCtx->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
- GL_TEXTURE_2D, myColorTexture->TextureId(), 0);
+ GL_TEXTURE_2D, myColorTextures (0)->TextureId(), 0);
theCtx->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
GL_TEXTURE_2D, myDepthStencilTexture->TextureId(), 0);
if (theCtx->arbFBO->glCheckFramebufferStatus (GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
Graphic3d_PriorityDefinitionError.hxx
Graphic3d_RenderingMode.hxx
Graphic3d_RenderingParams.hxx
+Graphic3d_RenderTransparentMethod.hxx
Graphic3d_SequenceOfGroup.hxx
Graphic3d_SequenceOfHClipPlane.hxx
Graphic3d_SequenceOfStructure.hxx
--- /dev/null
+// Created on: 2017-04-25
+// Created by: Anton POLETAEV
+// Copyright (c) 2017 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _Graphic3d_RenderTransparentMethod_HeaderFile
+#define _Graphic3d_RenderTransparentMethod_HeaderFile
+
+//! Enumerates transparency rendering methods supported by rasterization mode.
+enum Graphic3d_RenderTransparentMethod
+{
+ Graphic3d_RTM_BLEND_UNORDERED, //!< Basic blend transparency with non-commuting blend operator without sorting
+ Graphic3d_RTM_BLEND_OIT //!< Weighted Blended Order-Independent Transparency with depth weight factor
+};
+
+#endif // _Graphic3d_RenderTransparentMethod_HeaderFile
#ifndef _Graphic3d_RenderingParams_HeaderFile
#define _Graphic3d_RenderingParams_HeaderFile
+#include <Graphic3d_Mat4.hxx>
+#include <Graphic3d_RenderTransparentMethod.hxx>
#include <Graphic3d_RenderingMode.hxx>
#include <Graphic3d_StereoMode.hxx>
-#include <Graphic3d_Mat4.hxx>
#include <Graphic3d_Vec4.hxx>
//! Helper class to store rendering parameters.
//! Creates default rendering parameters.
Graphic3d_RenderingParams()
: Method (Graphic3d_RM_RASTERIZATION),
+ TransparencyMethod (Graphic3d_RTM_BLEND_UNORDERED),
+ OitDepthFactor (0.0f),
NbMsaaSamples (0),
RenderResolutionScale (1.0f),
// ray tracing parameters
public:
- Graphic3d_RenderingMode Method; //!< specifies rendering mode, Graphic3d_RM_RASTERIZATION by default
- Standard_Integer NbMsaaSamples; //!< number of MSAA samples (should be within 0..GL_MAX_SAMPLES, power-of-two number), 0 by default
- Standard_ShortReal RenderResolutionScale; //!< rendering resolution scale factor, 1 by default;
- //! incompatible with MSAA (e.g. NbMsaaSamples should be set to 0)
-
- Standard_Boolean IsGlobalIlluminationEnabled; //!< enables/disables global illumination effects (path tracing)
- Standard_Integer SamplesPerPixel; //!< number of samples per pixel (SPP)
- Standard_Integer RaytracingDepth; //!< maximum ray-tracing depth, 3 by default
- Standard_Boolean IsShadowEnabled; //!< enables/disables shadows rendering, True by default
- Standard_Boolean IsReflectionEnabled; //!< enables/disables specular reflections, False by default
- Standard_Boolean IsAntialiasingEnabled; //!< enables/disables adaptive anti-aliasing, False by default
- Standard_Boolean IsTransparentShadowEnabled; //!< enables/disables light propagation through transparent media, False by default
- Standard_Boolean UseEnvironmentMapBackground; //!< enables/disables environment map background
- Standard_Boolean CoherentPathTracingMode; //!< enables/disables 'coherent' tracing mode (single RNG seed within 16x16 image blocks)
- Standard_Boolean AdaptiveScreenSampling; //!< enables/disables adaptive screen sampling mode for path tracing, FALSE by default
- Standard_Boolean ShowSamplingTiles; //!< enables/disables debug mode for adaptive screen sampling, FALSE by default
- Standard_Boolean TwoSidedBsdfModels; //!< forces path tracing to use two-sided versions of original one-sided scattering models
- Standard_ShortReal RadianceClampingValue; //!< maximum radiance value used for clamping radiance estimation.
- Standard_Boolean RebuildRayTracingShaders; //!< forces rebuilding ray tracing shaders at the next frame
- Standard_Integer NbRayTracingTiles; //!< total number of screen tiles used in adaptive sampling mode (PT only)
-
- Graphic3d_StereoMode StereoMode; //!< stereoscopic output mode, Graphic3d_StereoMode_QuadBuffer by default
- Anaglyph AnaglyphFilter; //!< filter for anaglyph output, Anaglyph_RedCyan_Optimized by default
- Graphic3d_Mat4 AnaglyphLeft; //!< left anaglyph filter (in normalized colorspace), Color = AnaglyphRight * theColorRight + AnaglyphLeft * theColorLeft;
- Graphic3d_Mat4 AnaglyphRight; //!< right anaglyph filter (in normalized colorspace), Color = AnaglyphRight * theColorRight + AnaglyphLeft * theColorLeft;
- Standard_Boolean ToReverseStereo; //!< flag to reverse stereo pair, FALSE by default
-
- unsigned int Resolution; //!< Pixels density (PPI), defines scaling factor for parameters like text size
- //! (when defined in screen-space units rather than in 3D) to be properly displayed
- //! on device (screen / printer). 72 is default value.
- //! Note that using difference resolution in different Views in same Viewer
- //! will lead to performance regression (for example, text will be recreated every time).
-
+ Graphic3d_RenderingMode Method; //!< specifies rendering mode, Graphic3d_RM_RASTERIZATION by default
+ Graphic3d_RenderTransparentMethod TransparencyMethod; //!< specifies rendering method for transparent graphics
+ Standard_ShortReal OitDepthFactor; //!< scalar factor [0-1] controlling influence of depth of a fragment to its final coverage
+ Standard_Integer NbMsaaSamples; //!< number of MSAA samples (should be within 0..GL_MAX_SAMPLES, power-of-two number), 0 by default
+ Standard_ShortReal RenderResolutionScale; //!< rendering resolution scale factor, 1 by default;
+ //! incompatible with MSAA (e.g. NbMsaaSamples should be set to 0)
+
+ Standard_Boolean IsGlobalIlluminationEnabled; //!< enables/disables global illumination effects (path tracing)
+ Standard_Integer SamplesPerPixel; //!< number of samples per pixel (SPP)
+ Standard_Integer RaytracingDepth; //!< maximum ray-tracing depth, 3 by default
+ Standard_Boolean IsShadowEnabled; //!< enables/disables shadows rendering, True by default
+ Standard_Boolean IsReflectionEnabled; //!< enables/disables specular reflections, False by default
+ Standard_Boolean IsAntialiasingEnabled; //!< enables/disables adaptive anti-aliasing, False by default
+ Standard_Boolean IsTransparentShadowEnabled; //!< enables/disables light propagation through transparent media, False by default
+ Standard_Boolean UseEnvironmentMapBackground; //!< enables/disables environment map background
+ Standard_Boolean CoherentPathTracingMode; //!< enables/disables 'coherent' tracing mode (single RNG seed within 16x16 image blocks)
+ Standard_Boolean AdaptiveScreenSampling; //!< enables/disables adaptive screen sampling mode for path tracing, FALSE by default
+ Standard_Boolean ShowSamplingTiles; //!< enables/disables debug mode for adaptive screen sampling, FALSE by default
+ Standard_Boolean TwoSidedBsdfModels; //!< forces path tracing to use two-sided versions of original one-sided scattering models
+ Standard_ShortReal RadianceClampingValue; //!< maximum radiance value used for clamping radiance estimation.
+ Standard_Boolean RebuildRayTracingShaders; //!< forces rebuilding ray tracing shaders at the next frame
+ Standard_Integer NbRayTracingTiles; //!< total number of screen tiles used in adaptive sampling mode (PT only)
+
+ Graphic3d_StereoMode StereoMode; //!< stereoscopic output mode, Graphic3d_StereoMode_QuadBuffer by default
+ Anaglyph AnaglyphFilter; //!< filter for anaglyph output, Anaglyph_RedCyan_Optimized by default
+ Graphic3d_Mat4 AnaglyphLeft; //!< left anaglyph filter (in normalized colorspace), Color = AnaglyphRight * theColorRight + AnaglyphLeft * theColorLeft;
+ Graphic3d_Mat4 AnaglyphRight; //!< right anaglyph filter (in normalized colorspace), Color = AnaglyphRight * theColorRight + AnaglyphLeft * theColorLeft;
+ Standard_Boolean ToReverseStereo; //!< flag to reverse stereo pair, FALSE by default
+
+ unsigned int Resolution; //!< Pixels density (PPI), defines scaling factor for parameters like text size
+ //! (when defined in screen-space units rather than in 3D) to be properly displayed
+ //! on device (screen / printer). 72 is default value.
+ //! Note that using difference resolution in different Views in same Viewer
+ //! will lead to performance regression (for example, text will be recreated every time).
};
#endif // _Graphic3d_RenderingParams_HeaderFile
Graphic3d_TypeOfLimit_HasRayTracing, //!< indicates whether ray tracing is supported
Graphic3d_TypeOfLimit_HasRayTracingTextures, //!< indicates whether ray tracing textures are supported
Graphic3d_TypeOfLimit_HasRayTracingAdaptiveSampling, //!< indicates whether adaptive screen sampling is supported
+ Graphic3d_TypeOfLimit_HasBlendedOit, //!< indicates whether necessary GL extensions for Weighted, Blended OIT available (without MSAA).
+ Graphic3d_TypeOfLimit_HasBlendedOitMsaa, //!< indicates whether necessary GL extensions for Weighted, Blended OIT available (with MSAA).
Graphic3d_TypeOfLimit_NB //!< number of elements in this enumeration
};
namespace
{
-#if !defined(GL_ES_VERSION_2_0)
- static const GLint THE_FILLPRIM_FROM = GL_TRIANGLES;
- static const GLint THE_FILLPRIM_TO = GL_POLYGON;
-#else
- static const GLint THE_FILLPRIM_FROM = GL_TRIANGLES;
- static const GLint THE_FILLPRIM_TO = GL_TRIANGLE_FAN;
-#endif
-
//! Render infinite capping plane.
//! @param theWorkspace [in] the GL workspace, context state.
//! @param thePlane [in] the graphical plane, for which the capping surface is rendered.
theWorkspace->ApplyAspectFace();
// evaluate number of pair faces
- glDisable (GL_DEPTH_TEST);
- glDepthMask (GL_FALSE);
+ if (theWorkspace->UseZBuffer())
+ {
+ glDisable (GL_DEPTH_TEST);
+ }
+ if (theWorkspace->UseDepthWrite())
+ {
+ glDepthMask (GL_FALSE);
+ }
glStencilFunc (GL_ALWAYS, 1, 0x01);
glStencilOp (GL_KEEP, GL_INVERT, GL_INVERT);
// render capping plane using the generated stencil mask
glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
- glDepthMask (GL_TRUE);
+ if (theWorkspace->UseDepthWrite())
+ {
+ glDepthMask (GL_TRUE);
+ }
glStencilFunc (GL_EQUAL, 1, 0x01);
glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP);
- glEnable (GL_DEPTH_TEST);
+ if (theWorkspace->UseZBuffer())
+ {
+ glEnable (GL_DEPTH_TEST);
+ }
renderPlane (theWorkspace, thePlane, aRenderPlane->ToUseObjectProperties()
? aGroupIter.Value()->AspectFace()
// replace primitive groups rendering filter
Handle(OpenGl_RenderFilter) aRenderFilter = theWorkspace->GetRenderFilter();
- theWorkspace->SetRenderFilter (theWorkspace->DefaultCappingAlgoFilter());
+ Handle(OpenGl_CappingAlgoFilter) aCappingFilter = theWorkspace->DefaultCappingAlgoFilter();
+ aCappingFilter->SetPreviousFilter (aRenderFilter);
+ theWorkspace->SetRenderFilter (aCappingFilter);
// prepare for rendering the clip planes
glEnable (GL_STENCIL_TEST);
// function : CanRender
// purpose :
// =======================================================================
-Standard_Boolean OpenGl_CappingAlgoFilter::CanRender (const OpenGl_Element* theElement)
+Standard_Boolean OpenGl_CappingAlgoFilter::ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_Element* theGlElement)
{
- const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theElement);
+ if (!myFilter.IsNull() && !myFilter->ShouldRender (theWorkspace, theGlElement))
+ {
+ return Standard_False;
+ }
+
+ const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theGlElement);
return aPArray != NULL
- && aPArray->DrawMode() >= THE_FILLPRIM_FROM
- && aPArray->DrawMode() <= THE_FILLPRIM_TO;
+ && aPArray->DrawMode() >= OpenGl_PrimitiveArray::THE_FILLPRIM_FROM
+ && aPArray->DrawMode() <= OpenGl_PrimitiveArray::THE_FILLPRIM_TO;
}
};
//! Graphical capping rendering algorithm filter.
-//! Filters out everything excepth shaded primitives.
+//! Filters out everything except shaded primitives.
class OpenGl_CappingAlgoFilter : public OpenGl_RenderFilter
{
public:
//! Default constructor.
OpenGl_CappingAlgoFilter() {}
+ //! Sets the current active filter in workspace.
+ //! @param thePrevFilter [in] the previously active filter that should have additive effect.
+ void SetPreviousFilter (const Handle(OpenGl_RenderFilter)& thePrevFitler) { myFilter = thePrevFitler; }
+
//! Checks whether the element can be rendered or not.
//! @param theElement [in] the element to check.
//! @return True if element can be rendered.
- virtual Standard_Boolean CanRender (const OpenGl_Element* theElement) Standard_OVERRIDE;
+ virtual Standard_Boolean ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_Element* theGlElement) Standard_OVERRIDE;
+
+private:
+
+ Handle(OpenGl_RenderFilter) myFilter; //!< Previous active filter that should be combined.
public:
hasUintIndex(Standard_True),
hasTexRGBA8(Standard_True),
#endif
+ hasDrawBuffers (OpenGl_FeatureNotAvailable),
+ hasFloatBuffer (OpenGl_FeatureNotAvailable),
+ hasHalfFloatBuffer (OpenGl_FeatureNotAvailable),
+ hasSampleVariables (OpenGl_FeatureNotAvailable),
+ arbDrawBuffers (Standard_False),
arbNPTW (Standard_False),
arbTexRG (Standard_False),
arbTexFloat (Standard_False),
arbDbg (NULL),
arbFBO (NULL),
arbFBOBlit (NULL),
+ arbSampleShading (Standard_False),
extFragDepth (Standard_False),
+ extDrawBuffers (Standard_False),
extGS (NULL),
extBgra(Standard_False),
extAnis(Standard_False),
extPDS (Standard_False),
atiMem (Standard_False),
nvxMem (Standard_False),
+ oesSampleVariables (Standard_False),
mySharedResources (new OpenGl_ResourcesMap()),
myDelayed (new OpenGl_DelayReleaseMap()),
myUnusedResources (new OpenGl_ResourcesStack()),
myMaxTexDim (1024),
myMaxClipPlanes (6),
myMaxMsaaSamples(0),
+ myMaxDrawBuffers (1),
+ myMaxColorAttachments (1),
myGlVerMajor (0),
myGlVerMinor (0),
myIsInitialized (Standard_False),
#endif
myToCullBackFaces (false),
myReadBuffer (0),
- myDrawBuffer (0),
+ myDrawBuffers (1),
myDefaultVao (0),
myIsGlDebugCtx (Standard_False),
myResolution (Graphic3d_RenderingParams::THE_DEFAULT_RESOLUTION),
void OpenGl_Context::SetDrawBuffer (const Standard_Integer theDrawBuffer)
{
#if !defined(GL_ES_VERSION_2_0)
- myDrawBuffer = !myIsStereoBuffers ? stereoToMonoBuffer (theDrawBuffer) : theDrawBuffer;
- if (myDrawBuffer < GL_COLOR_ATTACHMENT0
+ const Standard_Integer aDrawBuffer = !myIsStereoBuffers ? stereoToMonoBuffer (theDrawBuffer) : theDrawBuffer;
+ if (aDrawBuffer < GL_COLOR_ATTACHMENT0
&& arbFBO != NULL)
{
arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, OpenGl_FrameBuffer::NO_FRAMEBUFFER);
}
- ::glDrawBuffer (myDrawBuffer);
+ ::glDrawBuffer (aDrawBuffer);
+
+ myDrawBuffers.Clear();
+
+ if (aDrawBuffer != GL_NONE)
+ {
+ myDrawBuffers.SetValue (0, aDrawBuffer);
+ }
#else
(void )theDrawBuffer;
#endif
}
+// =======================================================================
+// function : SetDrawBuffers
+// purpose :
+// =======================================================================
+void OpenGl_Context::SetDrawBuffers (const Standard_Integer theNb, const Standard_Integer* theDrawBuffers)
+{
+ Standard_ASSERT_RETURN (hasDrawBuffers, "Multiple draw buffers feature is not supported by the context", Standard_ASSERT_DO_NOTHING());
+
+ myDrawBuffers.Clear();
+
+ Standard_Boolean useDefaultFbo = Standard_False;
+ for (Standard_Integer anI = 0; anI < theNb; ++anI)
+ {
+#if !defined(GL_ES_VERSION_2_0)
+ const Standard_Integer aDrawBuffer = !myIsStereoBuffers ? stereoToMonoBuffer (theDrawBuffers[anI]) : theDrawBuffers[anI];
+#else
+ const Standard_Integer aDrawBuffer = theDrawBuffers[anI];
+#endif
+ if (aDrawBuffer < GL_COLOR_ATTACHMENT0 && aDrawBuffer != GL_NONE)
+ {
+ useDefaultFbo = Standard_True;
+ }
+ else if (aDrawBuffer != GL_NONE)
+ {
+ myDrawBuffers.SetValue (anI, aDrawBuffer);
+ }
+ }
+ if (arbFBO != NULL && useDefaultFbo)
+ {
+ arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, OpenGl_FrameBuffer::NO_FRAMEBUFFER);
+ }
+
+ myFuncs->glDrawBuffers (theNb, (const GLenum*)theDrawBuffers);
+}
+
// =======================================================================
// function : SetCullBackFaces
// purpose :
::glGetIntegerv (GL_RENDER_MODE, &myRenderMode);
}
- // cache buffers state
+ // cache read buffers state
::glGetIntegerv (GL_READ_BUFFER, &myReadBuffer);
- ::glGetIntegerv (GL_DRAW_BUFFER, &myDrawBuffer);
+
+ // cache draw buffers state
+ myDrawBuffers.Clear();
+
+ if (myMaxDrawBuffers == 1)
+ {
+ Standard_Integer aDrawBuffer;
+
+ ::glGetIntegerv (GL_DRAW_BUFFER, &aDrawBuffer);
+
+ if (aDrawBuffer != GL_NONE)
+ {
+ myDrawBuffers.SetValue (0, aDrawBuffer);
+ }
+ }
+ else
+ {
+ Standard_Integer aDrawBuffer;
+
+ for (Standard_Integer anI = 0; anI < myMaxDrawBuffers; ++anI)
+ {
+ ::glGetIntegerv (GL_DRAW_BUFFER0 + anI, &aDrawBuffer);
+
+ if (aDrawBuffer != GL_NONE)
+ {
+ myDrawBuffers.SetValue (anI, aDrawBuffer);
+ }
+ }
+ }
#endif
}
myGlVerMajor = 0;
myGlVerMinor = 0;
myMaxMsaaSamples = 0;
+ myMaxDrawBuffers = 1;
+ myMaxColorAttachments = 1;
ReadGlVersion (myGlVerMajor, myGlVerMinor);
myVendor = (const char* )::glGetString (GL_VENDOR);
if (!caps->ffpEnable
}
}
+ extDrawBuffers = CheckExtension ("GL_EXT_draw_buffers") && FindProc ("glDrawBuffersEXT", myFuncs->glDrawBuffers);
+ arbDrawBuffers = CheckExtension ("GL_ARB_draw_buffers") && FindProc ("glDrawBuffersARB", myFuncs->glDrawBuffers);
+
+ if (IsGlGreaterEqual (3, 0) && FindProc ("glDrawBuffers", myFuncs->glDrawBuffers))
+ {
+ hasDrawBuffers = OpenGl_FeatureInCore;
+ }
+ else if (extDrawBuffers || arbDrawBuffers)
+ {
+ hasDrawBuffers = OpenGl_FeatureInExtensions;
+ }
+
+ hasFloatBuffer = IsGlGreaterEqual (3, 2) ? OpenGl_FeatureInCore :
+ CheckExtension ("GL_EXT_color_buffer_float") ? OpenGl_FeatureInExtensions
+ : OpenGl_FeatureNotAvailable;
+ hasHalfFloatBuffer = IsGlGreaterEqual (3, 2) ? OpenGl_FeatureInCore :
+ CheckExtension ("GL_EXT_color_buffer_half_float") ? OpenGl_FeatureInExtensions
+ : OpenGl_FeatureNotAvailable;
+
+ oesSampleVariables = CheckExtension ("GL_OES_sample_variables");
+ hasSampleVariables = IsGlGreaterEqual (3, 2) ? OpenGl_FeatureInCore :
+ oesSampleVariables ? OpenGl_FeatureInExtensions
+ : OpenGl_FeatureNotAvailable;
#else
myTexClamp = IsGlGreaterEqual (1, 2) ? GL_CLAMP_TO_EDGE : GL_CLAMP;
hasTexRGBA8 = Standard_True;
- arbNPTW = CheckExtension ("GL_ARB_texture_non_power_of_two");
- arbTexFloat = IsGlGreaterEqual (3, 0)
- || CheckExtension ("GL_ARB_texture_float");
- extBgra = CheckExtension ("GL_EXT_bgra");
- extAnis = CheckExtension ("GL_EXT_texture_filter_anisotropic");
- extPDS = CheckExtension ("GL_EXT_packed_depth_stencil");
- atiMem = CheckExtension ("GL_ATI_meminfo");
- nvxMem = CheckExtension ("GL_NVX_gpu_memory_info");
+ arbDrawBuffers = CheckExtension ("GL_ARB_draw_buffers");
+ arbNPTW = CheckExtension ("GL_ARB_texture_non_power_of_two");
+ arbTexFloat = IsGlGreaterEqual (3, 0)
+ || CheckExtension ("GL_ARB_texture_float");
+ arbSampleShading = CheckExtension ("GL_ARB_sample_shading");
+ extBgra = CheckExtension ("GL_EXT_bgra");
+ extAnis = CheckExtension ("GL_EXT_texture_filter_anisotropic");
+ extPDS = CheckExtension ("GL_EXT_packed_depth_stencil");
+ atiMem = CheckExtension ("GL_ATI_meminfo");
+ nvxMem = CheckExtension ("GL_NVX_gpu_memory_info");
+
+ hasDrawBuffers = IsGlGreaterEqual (2, 0) ? OpenGl_FeatureInCore :
+ arbDrawBuffers ? OpenGl_FeatureInExtensions
+ : OpenGl_FeatureNotAvailable;
+
+ hasFloatBuffer = hasHalfFloatBuffer = IsGlGreaterEqual (3, 0) ? OpenGl_FeatureInCore :
+ CheckExtension ("GL_ARB_color_buffer_float") ? OpenGl_FeatureInExtensions
+ : OpenGl_FeatureNotAvailable;
+
+ hasSampleVariables = IsGlGreaterEqual (4, 0) ? OpenGl_FeatureInCore :
+ arbSampleShading ? OpenGl_FeatureInExtensions
+ : OpenGl_FeatureNotAvailable;
GLint aStereo = GL_FALSE;
glGetIntegerv (GL_STEREO, &aStereo);
glGetIntegerv (GL_MAX_CLIP_PLANES, &myMaxClipPlanes);
#endif
+ if (hasDrawBuffers)
+ {
+ glGetIntegerv (GL_MAX_DRAW_BUFFERS, &myMaxDrawBuffers);
+ glGetIntegerv (GL_MAX_COLOR_ATTACHMENTS, &myMaxColorAttachments);
+ }
+
glGetIntegerv (GL_MAX_TEXTURE_SIZE, &myMaxTexDim);
if (extAnis)
// purpose :
// =======================================================================
void OpenGl_Context::SetShadingMaterial (const OpenGl_AspectFace* theAspect,
- const Handle(Graphic3d_PresentationAttributes)& theHighlight,
- const Standard_Boolean theUseDepthWrite)
+ const Handle(Graphic3d_PresentationAttributes)& theHighlight)
{
const Handle(Graphic3d_AspectFillArea3d)& anAspect = (!theHighlight.IsNull() && !theHighlight->BasicFillAreaAspect().IsNull())
? theHighlight->BasicFillAreaAspect()
myMatBack = myMatFront;
}
- // handling transparency
- float aTranspFront = aMatFrontSrc.Transparency();
- float aTranspBack = aMatBackSrc .Transparency();
if (!theHighlight.IsNull()
&& theHighlight->BasicFillAreaAspect().IsNull())
{
myMatFront.SetColor (theHighlight->ColorRGBA());
myMatBack .SetColor (theHighlight->ColorRGBA());
- aTranspFront = theHighlight->Transparency();
- aTranspBack = theHighlight->Transparency();
}
+
+ Standard_ShortReal aTranspFront = 0.f;
+ Standard_ShortReal aTranspBack = 0.f;
+ if (CheckIsTransparent (theAspect, theHighlight, aTranspFront, aTranspBack))
{
- GLboolean aDepthMask = GL_TRUE;
- if (aTranspFront != 0.0f
- || aTranspBack != 0.0f)
- {
- // render transparent
- myMatFront.Diffuse.a() = 1.0f - aTranspFront;
- myMatBack .Diffuse.a() = 1.0f - aTranspBack;
- glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- glEnable (GL_BLEND);
- aDepthMask = GL_FALSE;
- }
- else
- {
- // render opaque
- glBlendFunc (GL_ONE, GL_ZERO);
- glDisable (GL_BLEND);
- }
- if (theUseDepthWrite)
- {
- glDepthMask (aDepthMask);
- }
+ myMatFront.Diffuse.a() = 1.0f - aTranspFront;
+ myMatBack .Diffuse.a() = 1.0f - aTranspBack;
}
// do not update material properties in case of zero reflection mode,
myShaderManager->UpdateMaterialStateTo (myMatFront, myMatBack, toDistinguish, toMapTexture);
}
+// =======================================================================
+// function : CheckIsTransparent
+// purpose :
+// =======================================================================
+Standard_Boolean OpenGl_Context::CheckIsTransparent (const OpenGl_AspectFace* theAspect,
+ const Handle(Graphic3d_PresentationAttributes)& theHighlight,
+ Standard_ShortReal& theTranspFront,
+ Standard_ShortReal& theTranspBack)
+{
+ const Handle(Graphic3d_AspectFillArea3d)& anAspect = (!theHighlight.IsNull() && !theHighlight->BasicFillAreaAspect().IsNull())
+ ? theHighlight->BasicFillAreaAspect()
+ : theAspect->Aspect();
+
+ const bool toDistinguish = anAspect->Distinguish();
+ const Graphic3d_MaterialAspect& aMatFrontSrc = anAspect->FrontMaterial();
+ const Graphic3d_MaterialAspect& aMatBackSrc = toDistinguish
+ ? anAspect->BackMaterial()
+ : aMatFrontSrc;
+
+ // handling transparency
+ theTranspFront = aMatFrontSrc.Transparency();
+ theTranspBack = aMatBackSrc .Transparency();
+ if (!theHighlight.IsNull()
+ && theHighlight->BasicFillAreaAspect().IsNull())
+ {
+ theTranspFront = theHighlight->Transparency();
+ theTranspBack = theHighlight->Transparency();
+ }
+
+ return theTranspFront != 0.f
+ || theTranspBack != 0.f;
+}
+
// =======================================================================
// function : SetColor4fv
// purpose :
#include <NCollection_Map.hxx>
#include <NCollection_Handle.hxx>
#include <NCollection_List.hxx>
+#include <NCollection_SparseArray.hxx>
#include <Message.hxx>
#include <OpenGl_Caps.hxx>
#include <OpenGl_LineAttributes.hxx>
class OpenGl_AspectFace;
class Graphic3d_PresentationAttributes;
+enum OpenGl_FeatureFlag
+{
+ OpenGl_FeatureNotAvailable = 0, //!< Feature is not supported by OpenGl implementation.
+ OpenGl_FeatureInExtensions = 1, //!< Feature is supported as extension.
+ OpenGl_FeatureInCore = 2 //!< Feature is supported as part of core profile.
+};
+
DEFINE_STANDARD_HANDLE(OpenGl_Context, Standard_Transient)
//! This class generalize access to the GL context and available extensions.
//! @return value for GL_MAX_SAMPLES
Standard_Integer MaxMsaaSamples() const { return myMaxMsaaSamples; }
+ //! @return value for GL_MAX_DRAW_BUFFERS
+ Standard_Integer MaxDrawBuffers() const { return myMaxDrawBuffers; }
+
+ //! @return value for GL_MAX_COLOR_ATTACHMENTS
+ Standard_Integer MaxColorAttachments() const { return myMaxColorAttachments; }
+
//! Get maximum number of clip planes supported by OpenGl.
//! This value is implementation dependent. At least 6
//! planes should be supported by OpenGl (see specs).
//! Switch read buffer, wrapper for ::glReadBuffer().
Standard_EXPORT void SetReadBuffer (const Standard_Integer theReadBuffer);
- //! Return active draw buffer.
- Standard_Integer DrawBuffer() { return myDrawBuffer; }
+ //! Return active draw buffer attached to a render target referred by index (layout location).
+ Standard_Integer DrawBuffer (const Standard_Integer theIndex = 0)
+ {
+ return myDrawBuffers.IsBound (theIndex) ? myDrawBuffers.Value (theIndex) : GL_NONE;
+ }
//! Switch draw buffer, wrapper for ::glDrawBuffer().
Standard_EXPORT void SetDrawBuffer (const Standard_Integer theDrawBuffer);
+ //! Switch draw buffer, wrapper for ::glDrawBuffers (GLsizei, const GLenum*).
+ Standard_EXPORT void SetDrawBuffers (const Standard_Integer theNb, const Standard_Integer* theDrawBuffers);
+
//! Switch read/draw buffers.
void SetReadDrawBuffer (const Standard_Integer theBuffer)
{
//! Setup current shading material.
Standard_EXPORT void SetShadingMaterial (const OpenGl_AspectFace* theAspect,
- const Handle(Graphic3d_PresentationAttributes)& theHighlight,
- const Standard_Boolean theUseDepthWrite);
+ const Handle(Graphic3d_PresentationAttributes)& theHighlight);
+
+ //! Checks if transparency is required for the given aspect and highlight style.
+ Standard_EXPORT static Standard_Boolean CheckIsTransparent (const OpenGl_AspectFace* theAspect,
+ const Handle(Graphic3d_PresentationAttributes)& theHighlight,
+ Standard_ShortReal& theTranspFront,
+ Standard_ShortReal& theTranspBack);
//! Setup current color.
Standard_EXPORT void SetColor4fv (const OpenGl_Vec4& theColor);
public: //! @name extensions
- Standard_Boolean hasHighp; //!< highp in GLSL ES fragment shader is supported
- Standard_Boolean hasUintIndex; //!< GLuint for index buffer is supported (always available on desktop; on OpenGL ES - since 3.0 or as extension GL_OES_element_index_uint)
- Standard_Boolean hasTexRGBA8; //!< always available on desktop; on OpenGL ES - since 3.0 or as extension GL_OES_rgb8_rgba8
- Standard_Boolean arbNPTW; //!< GL_ARB_texture_non_power_of_two
- Standard_Boolean arbTexRG; //!< GL_ARB_texture_rg
- Standard_Boolean arbTexFloat; //!< GL_ARB_texture_float (on desktop OpenGL - since 3.0 or as extension GL_ARB_texture_float; on OpenGL ES - since 3.0)
- OpenGl_ArbTexBindless* arbTexBindless; //!< GL_ARB_bindless_texture
- OpenGl_ArbTBO* arbTBO; //!< GL_ARB_texture_buffer_object
- Standard_Boolean arbTboRGB32; //!< GL_ARB_texture_buffer_object_rgb32 (3-component TBO), in core since 4.0
- OpenGl_ArbIns* arbIns; //!< GL_ARB_draw_instanced
- OpenGl_ArbDbg* arbDbg; //!< GL_ARB_debug_output
- OpenGl_ArbFBO* arbFBO; //!< GL_ARB_framebuffer_object
- OpenGl_ArbFBOBlit* arbFBOBlit; //!< glBlitFramebuffer function, moved out from OpenGl_ArbFBO structure for compatibility with OpenGL ES 2.0
- Standard_Boolean extFragDepth; //!< GL_EXT_frag_depth on OpenGL ES 2.0 (gl_FragDepthEXT built-in variable, before OpenGL ES 3.0)
- OpenGl_ExtGS* extGS; //!< GL_EXT_geometry_shader4
- Standard_Boolean extBgra; //!< GL_EXT_bgra or GL_EXT_texture_format_BGRA8888 on OpenGL ES
- Standard_Boolean extAnis; //!< GL_EXT_texture_filter_anisotropic
- Standard_Boolean extPDS; //!< GL_EXT_packed_depth_stencil
- Standard_Boolean atiMem; //!< GL_ATI_meminfo
- Standard_Boolean nvxMem; //!< GL_NVX_gpu_memory_info
+ Standard_Boolean hasHighp; //!< highp in GLSL ES fragment shader is supported
+ Standard_Boolean hasUintIndex; //!< GLuint for index buffer is supported (always available on desktop; on OpenGL ES - since 3.0 or as extension GL_OES_element_index_uint)
+ Standard_Boolean hasTexRGBA8; //!< always available on desktop; on OpenGL ES - since 3.0 or as extension GL_OES_rgb8_rgba8
+ OpenGl_FeatureFlag hasDrawBuffers; //!< Complex flag indicating support of multiple draw buffers (desktop OpenGL 2.0, OpenGL ES 3.0, GL_ARB_draw_buffers, GL_EXT_draw_buffers)
+ OpenGl_FeatureFlag hasFloatBuffer; //!< Complex flag indicating support of float color buffer format (desktop OpenGL 3.0, GL_ARB_color_buffer_float, GL_EXT_color_buffer_float)
+ OpenGl_FeatureFlag hasHalfFloatBuffer; //!< Complex flag indicating support of half-float color buffer format (desktop OpenGL 3.0, GL_ARB_color_buffer_float, GL_EXT_color_buffer_half_float)
+ OpenGl_FeatureFlag hasSampleVariables; //!< Complex flag indicating support of MSAA variables in GLSL shader (desktop OpenGL 4.0, GL_ARB_sample_shading)
+ Standard_Boolean arbDrawBuffers; //!< GL_ARB_draw_buffers
+ Standard_Boolean arbNPTW; //!< GL_ARB_texture_non_power_of_two
+ Standard_Boolean arbTexRG; //!< GL_ARB_texture_rg
+ Standard_Boolean arbTexFloat; //!< GL_ARB_texture_float (on desktop OpenGL - since 3.0 or as extension GL_ARB_texture_float; on OpenGL ES - since 3.0)
+ OpenGl_ArbTexBindless* arbTexBindless; //!< GL_ARB_bindless_texture
+ OpenGl_ArbTBO* arbTBO; //!< GL_ARB_texture_buffer_object
+ Standard_Boolean arbTboRGB32; //!< GL_ARB_texture_buffer_object_rgb32 (3-component TBO), in core since 4.0
+ OpenGl_ArbIns* arbIns; //!< GL_ARB_draw_instanced
+ OpenGl_ArbDbg* arbDbg; //!< GL_ARB_debug_output
+ OpenGl_ArbFBO* arbFBO; //!< GL_ARB_framebuffer_object
+ OpenGl_ArbFBOBlit* arbFBOBlit; //!< glBlitFramebuffer function, moved out from OpenGl_ArbFBO structure for compatibility with OpenGL ES 2.0
+ Standard_Boolean arbSampleShading; //!< GL_ARB_sample_shading
+ Standard_Boolean extFragDepth; //!< GL_EXT_frag_depth on OpenGL ES 2.0 (gl_FragDepthEXT built-in variable, before OpenGL ES 3.0)
+ Standard_Boolean extDrawBuffers; //!< GL_EXT_draw_buffers
+ OpenGl_ExtGS* extGS; //!< GL_EXT_geometry_shader4
+ Standard_Boolean extBgra; //!< GL_EXT_bgra or GL_EXT_texture_format_BGRA8888 on OpenGL ES
+ Standard_Boolean extAnis; //!< GL_EXT_texture_filter_anisotropic
+ Standard_Boolean extPDS; //!< GL_EXT_packed_depth_stencil
+ Standard_Boolean atiMem; //!< GL_ATI_meminfo
+ Standard_Boolean nvxMem; //!< GL_NVX_gpu_memory_info
+ Standard_Boolean oesSampleVariables; //!< GL_OES_sample_variables
public: //! @name public properties tracking current state
typedef NCollection_Shared< NCollection_DataMap<TCollection_AsciiString, Standard_Integer> > OpenGl_DelayReleaseMap;
typedef NCollection_Shared< NCollection_DataMap<TCollection_AsciiString, Handle(OpenGl_Resource)> > OpenGl_ResourcesMap;
typedef NCollection_Shared< NCollection_List<Handle(OpenGl_Resource)> > OpenGl_ResourcesStack;
+ typedef NCollection_SparseArray<Standard_Integer> OpenGl_DrawBuffers;
Handle(OpenGl_ResourcesMap) mySharedResources; //!< shared resources with unique identification key
Handle(OpenGl_DelayReleaseMap) myDelayed; //!< shared resources for delayed release
Standard_Integer myMaxTexDim; //!< value for GL_MAX_TEXTURE_SIZE
Standard_Integer myMaxClipPlanes; //!< value for GL_MAX_CLIP_PLANES
Standard_Integer myMaxMsaaSamples; //!< value for GL_MAX_SAMPLES
+ Standard_Integer myMaxDrawBuffers; //!< value for GL_MAX_DRAW_BUFFERS
+ Standard_Integer myMaxColorAttachments; //!< value for GL_MAX_COLOR_ATTACHMENTS
Standard_Integer myGlVerMajor; //!< cached GL version major number
Standard_Integer myGlVerMinor; //!< cached GL version minor number
Standard_Boolean myIsInitialized; //!< flag indicates initialization state
Standard_Integer myPolygonMode; //!< currently used polygon rasterization mode (glPolygonMode)
bool myToCullBackFaces; //!< back face culling mode enabled state (glIsEnabled (GL_CULL_FACE))
Standard_Integer myReadBuffer; //!< current read buffer
- Standard_Integer myDrawBuffer; //!< current draw buffer
+ OpenGl_DrawBuffers myDrawBuffers; //!< current draw buffers
unsigned int myDefaultVao; //!< default Vertex Array Object
Standard_Boolean myIsGlDebugCtx; //!< debug context initialization state
TCollection_AsciiString myVendor; //!< Graphics Driver's vendor
//! @param theWorkspace [in] the rendering workspace.
//! @param theFilter [in] the rendering filter to check whether the element
//! should be rendered or not.
- //! @return True if element passes the filering check and is rendered.
+ //! @return True if element passes the check and renders,
inline Standard_Boolean
RenderFiltered (const Handle(OpenGl_Workspace)& theWorkspace,
const Handle(OpenGl_RenderFilter)& theFilter) const
{
- if (!theFilter.IsNull() && !theFilter->CanRender (this))
+ if (!theFilter.IsNull() && !theFilter->ShouldRender (theWorkspace, this))
{
return Standard_False;
}
return false;
}
+ //! Determine data type from texture sized format.
+ static bool getColorDataFormat (GLint theTextFormat,
+ GLenum& thePixelFormat,
+ GLenum& theDataType)
+ {
+ switch (theTextFormat)
+ {
+ case GL_RGBA32F:
+ {
+ thePixelFormat = GL_RGBA;
+ theDataType = GL_FLOAT;
+ return true;
+ }
+ case GL_R32F:
+ {
+ thePixelFormat = GL_RED;
+ theDataType = GL_FLOAT;
+ return true;
+ }
+ case GL_RGBA16F:
+ {
+ thePixelFormat = GL_RGBA;
+ theDataType = GL_HALF_FLOAT;
+ return true;
+ }
+ case GL_R16F:
+ {
+ thePixelFormat = GL_RED;
+ theDataType = GL_HALF_FLOAT;
+ return true;
+ }
+ case GL_RGBA8:
+ {
+ thePixelFormat = GL_RGBA;
+ theDataType = GL_UNSIGNED_INT;
+ return true;
+ }
+ case GL_RGBA:
+ {
+ thePixelFormat = GL_RGBA;
+ theDataType = GL_UNSIGNED_BYTE;
+ return true;
+ }
+ }
+ return false;
+ }
+
+ //! Checks whether two format arrays are equal or not.
+ static bool operator== (const OpenGl_ColorFormats& theFmt1,
+ const OpenGl_ColorFormats& theFmt2)
+ {
+ if (theFmt1.Length() != theFmt2.Length())
+ return false;
+ OpenGl_ColorFormats::Iterator anIt1 (theFmt1);
+ OpenGl_ColorFormats::Iterator anIt2 (theFmt1);
+ for (; anIt1.More(); anIt1.Next(), anIt2.Next())
+ {
+ if (anIt1.Value() != anIt2.Value())
+ return false;
+ }
+ return true;
+ }
}
// =======================================================================
: myVPSizeX (0),
myVPSizeY (0),
myNbSamples (0),
- myColorFormat (GL_RGBA8),
myDepthFormat (GL_DEPTH24_STENCIL8),
myGlFBufferId (NO_FRAMEBUFFER),
myGlColorRBufferId (NO_RENDERBUFFER),
myGlDepthRBufferId (NO_RENDERBUFFER),
myIsOwnBuffer (false),
- myColorTexture (new OpenGl_Texture()),
myDepthStencilTexture (new OpenGl_Texture())
{
- //
+ myColorFormats.Append (GL_RGBA8);
+ myColorTextures.Append (new OpenGl_Texture());
}
// =======================================================================
// purpose :
// =======================================================================
Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlContext,
- const GLsizei theSizeX,
- const GLsizei theSizeY,
- const GLint theColorFormat,
- const GLint theDepthFormat,
- const GLsizei theNbSamples)
+ const GLsizei theSizeX,
+ const GLsizei theSizeY,
+ const GLint theColorFormat,
+ const GLint theDepthFormat,
+ const GLsizei theNbSamples)
{
- myColorFormat = theColorFormat;
+ OpenGl_ColorFormats aColorFormats;
+
+ aColorFormats.Append (theColorFormat);
+
+ return Init (theGlContext, theSizeX, theSizeY, aColorFormats, theDepthFormat, theNbSamples);
+}
+
+// =======================================================================
+// function : Init
+// purpose :
+// =======================================================================
+Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlContext,
+ const GLsizei theSizeX,
+ const GLsizei theSizeY,
+ const OpenGl_ColorFormats& theColorFormats,
+ const Handle(OpenGl_Texture)& theDepthStencilTexture,
+ const GLsizei theNbSamples)
+{
+ myColorFormats = theColorFormats;
+
+ OpenGl_TextureArray aTextures (myColorTextures);
+ if (!myColorTextures.IsEmpty())
+ {
+ for (OpenGl_TextureArray::Iterator aTextureIt (myColorTextures); aTextureIt.More(); aTextureIt.Next())
+ {
+ aTextureIt.Value()->Release (theGlContext.operator->());
+ }
+ myColorTextures.Clear();
+ }
+ for (Standard_Integer aLength = 0; aLength < myColorFormats.Length(); ++aLength)
+ {
+ myColorTextures.Append (aLength < aTextures.Length() ? aTextures.Value (aLength) : new OpenGl_Texture());
+ }
+
+ myDepthFormat = theDepthStencilTexture->GetFormat();
+ myNbSamples = theNbSamples;
+ if (theGlContext->arbFBO == NULL)
+ {
+ return Standard_False;
+ }
+
+ // clean up previous state
+ Release (theGlContext.operator->());
+ if (myColorFormats.IsEmpty()
+ && myDepthFormat == 0)
+ {
+ return Standard_False;
+ }
+
+ myDepthStencilTexture = theDepthStencilTexture;
+ myIsOwnDepth = false;
+ myIsOwnBuffer = true;
+
+ // setup viewport sizes as is
+ myVPSizeX = theSizeX;
+ myVPSizeY = theSizeY;
+ const Standard_Integer aSizeX = theSizeX > 0 ? theSizeX : 2;
+ const Standard_Integer aSizeY = theSizeY > 0 ? theSizeY : 2;
+
+ // Create the textures (will be used as color buffer and depth-stencil buffer)
+ if (theNbSamples != 0)
+ {
+ for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
+ {
+ const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
+ const GLint aColorFormat = myColorFormats (aColorBufferIdx);
+ if (aColorFormat != 0
+ && !aColorTexture->Init2DMultisample (theGlContext, theNbSamples,
+ aColorFormat, aSizeX, aSizeY))
+ {
+ Release (theGlContext.operator->());
+ return Standard_False;
+ }
+ }
+ }
+ else
+ {
+ for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
+ {
+ GLenum aPixelFormat = 0;
+ GLenum aDataType = 0;
+ const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
+ const GLint aColorFormat = myColorFormats (aColorBufferIdx);
+ if (aColorFormat != 0
+ && getColorDataFormat (aColorFormat, aPixelFormat, aDataType)
+ && !aColorTexture->Init (theGlContext, aColorFormat,
+ aPixelFormat, aDataType,
+ aSizeX, aSizeY, Graphic3d_TOT_2D))
+ {
+ Release (theGlContext.operator->());
+ return Standard_False;
+ }
+ }
+ }
+
+ // Build FBO and setup it as texture
+ theGlContext->arbFBO->glGenFramebuffers (1, &myGlFBufferId);
+ theGlContext->arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, myGlFBufferId);
+
+ for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
+ {
+ const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
+ if (aColorTexture->IsValid())
+ {
+ theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + aColorBufferIdx,
+ aColorTexture->GetTarget(), aColorTexture->TextureId(), 0);
+ }
+ }
+ if (myDepthStencilTexture->IsValid())
+ {
+ #ifdef GL_DEPTH_STENCIL_ATTACHMENT
+ theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
+ myDepthStencilTexture->GetTarget(), myDepthStencilTexture->TextureId(), 0);
+ #else
+ theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+ myDepthStencilTexture->GetTarget(), myDepthStencilTexture->TextureId(), 0);
+ theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
+ myDepthStencilTexture->GetTarget(), myDepthStencilTexture->TextureId(), 0);
+ #endif
+ }
+ if (theGlContext->arbFBO->glCheckFramebufferStatus (GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
+ {
+ Release (theGlContext.operator->());
+ return Standard_False;
+ }
+
+ UnbindBuffer (theGlContext);
+ return Standard_True;
+}
+
+// =======================================================================
+// function : Init
+// purpose :
+// =======================================================================
+Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlContext,
+ const GLsizei theSizeX,
+ const GLsizei theSizeY,
+ const OpenGl_ColorFormats& theColorFormats,
+ const GLint theDepthFormat,
+ const GLsizei theNbSamples)
+{
+ myColorFormats = theColorFormats;
+
+ OpenGl_TextureArray aTextures (myColorTextures);
+ if (!myColorTextures.IsEmpty())
+ {
+ for (OpenGl_TextureArray::Iterator aTextureIt (myColorTextures); aTextureIt.More(); aTextureIt.Next())
+ {
+ aTextureIt.Value()->Release (theGlContext.operator->());
+ }
+ myColorTextures.Clear();
+ }
+ for (Standard_Integer aLength = 0; aLength < myColorFormats.Length(); ++aLength)
+ {
+ myColorTextures.Append (aLength < aTextures.Length() ? aTextures.Value (aLength) : new OpenGl_Texture());
+ }
+
myDepthFormat = theDepthFormat;
myNbSamples = theNbSamples;
if (theGlContext->arbFBO == NULL)
// clean up previous state
Release (theGlContext.operator->());
- if (myColorFormat == 0
+ if (myColorFormats.IsEmpty()
&& myDepthFormat == 0)
{
return Standard_False;
}
myIsOwnBuffer = true;
+ myIsOwnDepth = true;
// setup viewport sizes as is
myVPSizeX = theSizeX;
// Create the textures (will be used as color buffer and depth-stencil buffer)
if (theNbSamples != 0)
{
- if (myColorFormat != 0
- && !myColorTexture ->Init2DMultisample (theGlContext, theNbSamples, myColorFormat, aSizeX, aSizeY))
+ for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
{
- Release (theGlContext.operator->());
- return Standard_False;
+ const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
+ const GLint aColorFormat = myColorFormats (aColorBufferIdx);
+ if (aColorFormat != 0
+ && !aColorTexture->Init2DMultisample (theGlContext, theNbSamples, aColorFormat, aSizeX, aSizeY))
+ {
+ Release (theGlContext.operator->());
+ return Standard_False;
+ }
}
if (myDepthFormat != 0
&& !myDepthStencilTexture->Init2DMultisample (theGlContext, theNbSamples, myDepthFormat, aSizeX, aSizeY))
}
else
{
- if (myColorFormat != 0
- && !myColorTexture->Init (theGlContext, myColorFormat,
- GL_RGBA, GL_UNSIGNED_BYTE,
- aSizeX, aSizeY, Graphic3d_TOT_2D))
+ GLenum aPixelFormat = 0;
+ GLenum aDataType = 0;
+
+ for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
{
- Release (theGlContext.operator->());
- return Standard_False;
+ const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
+ const GLint aColorFormat = myColorFormats (aColorBufferIdx);
+ if (aColorFormat != 0
+ && getColorDataFormat (aColorFormat, aPixelFormat, aDataType)
+ && !aColorTexture->Init (theGlContext, aColorFormat,
+ aPixelFormat, aDataType,
+ aSizeX, aSizeY, Graphic3d_TOT_2D))
+ {
+ Release (theGlContext.operator->());
+ return Standard_False;
+ }
}
// extensions (GL_OES_packed_depth_stencil, GL_OES_depth_texture) + GL version might be used to determine supported formats
// instead of just trying to create such texture
- GLenum aPixelFormat = 0;
- GLenum aDataType = 0;
if (myDepthFormat != 0
&& getDepthDataFormat (myDepthFormat, aPixelFormat, aDataType)
&& !myDepthStencilTexture->Init (theGlContext, myDepthFormat,
// Build FBO and setup it as texture
theGlContext->arbFBO->glGenFramebuffers (1, &myGlFBufferId);
theGlContext->arbFBO->glBindFramebuffer (GL_FRAMEBUFFER, myGlFBufferId);
- if (myColorTexture->IsValid())
+ for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
{
- theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
- myColorTexture->GetTarget(), myColorTexture->TextureId(), 0);
+ const Handle(OpenGl_Texture)& aColorTexture = myColorTextures (aColorBufferIdx);
+ if (aColorTexture->IsValid())
+ {
+ theGlContext->arbFBO->glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + aColorBufferIdx,
+ aColorTexture->GetTarget(), aColorTexture->TextureId(), 0);
+ }
}
if (myDepthStencilTexture->IsValid())
{
}
// =======================================================================
-// function : Init
+// function : InitLazy
// purpose :
// =======================================================================
Standard_Boolean OpenGl_FrameBuffer::InitLazy (const Handle(OpenGl_Context)& theGlContext,
const GLint theDepthFormat,
const GLsizei theNbSamples)
{
- if (myVPSizeX == theViewportSizeX
- && myVPSizeY == theViewportSizeY
- && myColorFormat == theColorFormat
- && myDepthFormat == theDepthFormat
- && myNbSamples == theNbSamples)
+ OpenGl_ColorFormats aColorFormats;
+
+ aColorFormats.Append (theColorFormat);
+
+ return InitLazy (theGlContext, theViewportSizeX, theViewportSizeY, aColorFormats, theDepthFormat, theNbSamples);
+}
+
+// =======================================================================
+// function : InitLazy
+// purpose :
+// =======================================================================
+Standard_Boolean OpenGl_FrameBuffer::InitLazy (const Handle(OpenGl_Context)& theGlContext,
+ const GLsizei theViewportSizeX,
+ const GLsizei theViewportSizeY,
+ const OpenGl_ColorFormats& theColorFormats,
+ const GLint theDepthFormat,
+ const GLsizei theNbSamples)
+{
+ if (myVPSizeX == theViewportSizeX
+ && myVPSizeY == theViewportSizeY
+ && myColorFormats == theColorFormats
+ && myDepthFormat == theDepthFormat
+ && myNbSamples == theNbSamples)
{
return IsValid();
}
- return Init (theGlContext, theViewportSizeX, theViewportSizeY, theColorFormat, theDepthFormat, theNbSamples);
+ return Init (theGlContext, theViewportSizeX, theViewportSizeY, theColorFormats, theDepthFormat, theNbSamples);
}
// =======================================================================
const GLint theDepthFormat,
const GLuint theColorRBufferFromWindow)
{
- myColorFormat = theColorFormat;
+ myColorFormats.Clear();
+ myColorFormats.Append (theColorFormat);
+ if (!myColorTextures.IsEmpty())
+ {
+ Handle(OpenGl_Texture) aTexutre = myColorTextures.First();
+ for (OpenGl_TextureArray::Iterator aTextureIt (myColorTextures); aTextureIt.More(); aTextureIt.Next())
+ {
+ aTextureIt.Value()->Release (theGlCtx.operator->());
+ }
+ myColorTextures.Clear();
+ myColorTextures.Append (aTexutre);
+ }
+
myDepthFormat = theDepthFormat;
myNbSamples = 0;
if (theGlCtx->arbFBO == NULL)
Release (theGlCtx.operator->());
myIsOwnBuffer = true;
+ myIsOwnDepth = true;
// setup viewport sizes as is
myVPSizeX = theSizeX;
{
myGlColorRBufferId = theColorRBufferFromWindow;
}
- else if (myColorFormat != 0)
+ else if (theColorFormat != 0)
{
theGlCtx->arbFBO->glGenRenderbuffers (1, &myGlColorRBufferId);
theGlCtx->arbFBO->glBindRenderbuffer (GL_RENDERBUFFER, myGlColorRBufferId);
- theGlCtx->arbFBO->glRenderbufferStorage (GL_RENDERBUFFER, myColorFormat, aSizeX, aSizeY);
+ theGlCtx->arbFBO->glRenderbufferStorage (GL_RENDERBUFFER, theColorFormat, aSizeX, aSizeY);
}
bool hasStencilRB = false;
myGlFBufferId = GLuint(anFbo);
myIsOwnBuffer = false;
+ myIsOwnDepth = false;
if (aColorType == GL_RENDERBUFFER)
{
theGlCtx->arbFBO->glGetFramebufferAttachmentParameteriv (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &aColorId);
myIsOwnBuffer = false;
}
- myColorTexture->Release (theGlCtx);
- myDepthStencilTexture->Release (theGlCtx);
+ for (Standard_Integer aColorBufferIdx = 0; aColorBufferIdx < myColorTextures.Length(); ++aColorBufferIdx)
+ {
+ myColorTextures (aColorBufferIdx)->Release (theGlCtx);
+ }
+
+ if (myIsOwnDepth)
+ {
+ myDepthStencilTexture->Release (theGlCtx);
+ myIsOwnDepth = false;
+ }
myVPSizeX = 0;
myVPSizeY = 0;
#include <OpenGl_Resource.hxx>
#include <OpenGl_Texture.hxx>
+#include <NCollection_Vector.hxx>
+
class OpenGl_FrameBuffer;
DEFINE_STANDARD_HANDLE(OpenGl_FrameBuffer, OpenGl_Resource)
+//! Short declaration of useful collection types.
+typedef NCollection_Vector<GLint> OpenGl_ColorFormats;
+
//! Class implements FrameBuffer Object (FBO) resource
//! intended for off-screen rendering.
class OpenGl_FrameBuffer : public OpenGl_Resource
return myNbSamples;
}
+ //! Number of color buffers.
+ GLsizei NbColorBuffers() const
+ {
+ return myColorTextures.Length();
+ }
+
//! Return true if FBO has been created with color attachment.
bool HasColor() const
{
- return myColorFormat != 0;
+ return !myColorFormats.IsEmpty();
}
//! Return true if FBO has been created with depth attachment.
//! Textures width.
GLsizei GetSizeX() const
{
- return myColorTexture->SizeX();
+ return myColorTextures (0)->SizeX();
}
//! Textures height.
GLsizei GetSizeY() const
{
- return myColorTexture->SizeY();
+ return myColorTextures (0)->SizeY();
}
//! Viewport width.
return isValidFrameBuffer();
}
+ //! Initialize FBO for rendering into single/multiple color buffer and depth textures.
+ //! @param theGlCtx currently bound OpenGL context
+ //! @param theSizeX texture width
+ //! @param theSizeY texture height
+ //! @param theColorFormats list of color texture sized format (0 means no color attachment), e.g. GL_RGBA8
+ //! @param theDepthStencilTexture depth-stencil texture
+ //! @param theNbSamples MSAA number of samples (0 means normal texture)
+ //! @return true on success
+ Standard_EXPORT Standard_Boolean Init (const Handle(OpenGl_Context)& theGlCtx,
+ const GLsizei theSizeX,
+ const GLsizei theSizeY,
+ const OpenGl_ColorFormats& theColorFormats,
+ const Handle(OpenGl_Texture)& theDepthStencilTexture,
+ const GLsizei theNbSamples = 0);
+
//! Initialize FBO for rendering into textures.
//! @param theGlCtx currently bound OpenGL context
//! @param theSizeX texture width
const GLint theDepthFormat,
const GLsizei theNbSamples = 0);
+ //! Initialize FBO for rendering into single/multiple color buffer and depth textures.
+ //! @param theGlCtx currently bound OpenGL context
+ //! @param theSizeX texture width
+ //! @param theSizeY texture height
+ //! @param theColorFormats list of color texture sized format (0 means no color attachment), e.g. GL_RGBA8
+ //! @param theDepthFormat depth-stencil texture sized format (0 means no depth attachment), e.g. GL_DEPTH24_STENCIL8
+ //! @param theNbSamples MSAA number of samples (0 means normal texture)
+ //! @return true on success
+ Standard_EXPORT Standard_Boolean Init (const Handle(OpenGl_Context)& theGlCtx,
+ const GLsizei theSizeX,
+ const GLsizei theSizeY,
+ const OpenGl_ColorFormats& theColorFormats,
+ const GLint theDepthFormat,
+ const GLsizei theNbSamples = 0);
+
//! (Re-)initialize FBO with specified dimensions.
Standard_EXPORT Standard_Boolean InitLazy (const Handle(OpenGl_Context)& theGlCtx,
const GLsizei theViewportSizeX,
const GLint theDepthFormat,
const GLsizei theNbSamples = 0);
+ //! (Re-)initialize FBO with specified dimensions.
+ Standard_EXPORT Standard_Boolean InitLazy (const Handle(OpenGl_Context)& theGlCtx,
+ const GLsizei theViewportSizeX,
+ const GLsizei theViewportSizeY,
+ const OpenGl_ColorFormats& theColorFormats,
+ const GLint theDepthFormat,
+ const GLsizei theNbSamples = 0);
+
//! (Re-)initialize FBO with properties taken from another FBO.
Standard_Boolean InitLazy (const Handle(OpenGl_Context)& theGlCtx,
const OpenGl_FrameBuffer& theFbo)
{
- return InitLazy (theGlCtx, theFbo.myVPSizeX, theFbo.myVPSizeY, theFbo.myColorFormat, theFbo.myDepthFormat, theFbo.myNbSamples);
+ return InitLazy (theGlCtx, theFbo.myVPSizeX, theFbo.myVPSizeY, theFbo.myColorFormats, theFbo.myDepthFormat, theFbo.myNbSamples);
}
//! (Re-)initialize FBO with specified dimensions.
//! Unbind frame buffer.
Standard_EXPORT virtual void UnbindBuffer (const Handle(OpenGl_Context)& theGlCtx);
- //! Returns the color texture.
- inline const Handle(OpenGl_Texture)& ColorTexture() const
+ //! Returns the color texture for the given color buffer index.
+ inline const Handle(OpenGl_Texture)& ColorTexture (const GLint theColorBufferIndex = 0) const
{
- return myColorTexture;
+ return myColorTextures (theColorBufferIndex);
}
//! Returns the depth-stencil texture.
return myGlFBufferId != NO_FRAMEBUFFER;
}
+protected:
+
+ typedef NCollection_Vector<Handle(OpenGl_Texture)> OpenGl_TextureArray;
+
protected:
GLsizei myVPSizeX; //!< viewport width (should be <= texture width)
GLsizei myVPSizeY; //!< viewport height (should be <= texture height)
GLsizei myNbSamples; //!< number of MSAA samples
- GLint myColorFormat; //!< sized format for color texture, GL_RGBA8 by default
+ OpenGl_ColorFormats myColorFormats; //!< sized format for color texture, GL_RGBA8 by default
GLint myDepthFormat; //!< sized format for depth-stencil texture, GL_DEPTH24_STENCIL8 by default
GLuint myGlFBufferId; //!< FBO object ID
GLuint myGlColorRBufferId; //!< color Render Buffer object (alternative to myColorTexture)
GLuint myGlDepthRBufferId; //!< depth-stencil Render Buffer object (alternative to myDepthStencilTexture)
bool myIsOwnBuffer; //!< flag indicating that FBO should be deallocated by this class
- Handle(OpenGl_Texture) myColorTexture; //!< color texture object
+ bool myIsOwnDepth; //!< flag indicating that FBO should be deallocated by this class
+ OpenGl_TextureArray myColorTextures; //!< color texture objects
Handle(OpenGl_Texture) myDepthStencilTexture; //!< depth-stencil texture object
public:
#define GL_DEBUG_SEVERITY_HIGH 0x9146
#define GL_DEBUG_SEVERITY_MEDIUM 0x9147
#define GL_DEBUG_SEVERITY_LOW 0x9148
+
+ // GL_ARB_draw_buffers (GL_EXT_draw_buffers) extension
+ #define GL_MAX_COLOR_ATTACHMENTS 0x8CDF
+ #define GL_MAX_DRAW_BUFFERS 0x8824
+
+ // OES_texture_half_float
+ #define GL_HALF_FLOAT 0x8D61
#endif
#if !defined(HAVE_EGL) && (defined(__ANDROID__) || defined(__QNX__) || defined(HAVE_GLES2) || defined(OCCT_UWP))
typedef void (*glTexImage3D_t)(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* data);
glTexImage3D_t glTexImage3D;
+ typedef void (*glDrawBuffers_t)(GLsizei n, const GLenum* bufs);
+ glDrawBuffers_t glDrawBuffers;
+
public: //! @name OpenGL ES 3.1
typedef void (*glTexStorage2DMultisample_t)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
return (!aCtx.IsNull() && aCtx->HasRayTracingTextures()) ? 1 : 0;
case Graphic3d_TypeOfLimit_HasRayTracingAdaptiveSampling:
return (!aCtx.IsNull() && aCtx->HasRayTracingAdaptiveSampling()) ? 1 : 0;
+ case Graphic3d_TypeOfLimit_HasBlendedOit:
+ return (!aCtx.IsNull() && aCtx->hasDrawBuffers && (aCtx->hasFloatBuffer || aCtx->hasHalfFloatBuffer)) ? 1 : 0;
+ case Graphic3d_TypeOfLimit_HasBlendedOitMsaa:
+ return (!aCtx.IsNull() && aCtx->hasSampleVariables && (InquireLimit (Graphic3d_TypeOfLimit_HasBlendedOit) == 1)) ? 1 : 0;
case Graphic3d_TypeOfLimit_NB:
return 0;
}
theWorkspace->SetPolygonOffset (myLayerSettings.PolygonOffset());
// handle depth write
- theWorkspace->UseDepthWrite() = myLayerSettings.ToEnableDepthWrite();
+ theWorkspace->UseDepthWrite() = myLayerSettings.ToEnableDepthWrite() && theDefaultSettings.DepthMask == GL_TRUE;
glDepthMask (theWorkspace->UseDepthWrite() ? GL_TRUE : GL_FALSE);
const Standard_Boolean hasLocalCS = !myLayerSettings.OriginTransformation().IsNull();
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-#include <OpenGl_GlCore11.hxx>
+#include <OpenGl_GlCore15.hxx>
+#include <OpenGl_FrameBuffer.hxx>
#include <OpenGl_LayerList.hxx>
+#include <OpenGl_ShaderManager.hxx>
#include <OpenGl_Structure.hxx>
+#include <OpenGl_VertexBuffer.hxx>
+#include <OpenGl_View.hxx>
#include <OpenGl_Workspace.hxx>
#include <Graphic3d_GraphicDriver.hxx>
myNbPriorities (theNbPriorities),
myNbStructures (0),
myImmediateNbStructures (0),
- myModifStateOfRaytraceable (0)
+ myModifStateOfRaytraceable (0),
+ myRenderOpaqueFilter (new OpenGl_OpaqueFilter()),
+ myRenderTranspFilter (new OpenGl_TransparentFilter())
{
// insert default priority layers
myLayers.Append (OpenGl_Layer (myNbPriorities));
myLayerIds.Bind (Graphic3d_ZLayerId_TopOSD, myLayers.Upper());
myDefaultLayerIndex = myLayerIds.Find (Graphic3d_ZLayerId_Default);
+
+ myTransparentToProcess.Allocate (myLayers.Length());
}
//=======================================================================
// add the new layer
myLayers.Append (OpenGl_Layer (myNbPriorities));
myLayerIds.Bind (theLayerId, myLayers.Length());
+
+ myTransparentToProcess.Allocate (myLayers.Length());
}
//=======================================================================
}
myDefaultLayerIndex = myLayerIds.Find (Graphic3d_ZLayerId_Default);
+
+ myTransparentToProcess.Allocate (myLayers.Length());
}
//=======================================================================
//=======================================================================
void OpenGl_LayerList::Render (const Handle(OpenGl_Workspace)& theWorkspace,
const Standard_Boolean theToDrawImmediate,
- const OpenGl_LayerFilter theLayersToProcess) const
+ const OpenGl_LayerFilter theLayersToProcess,
+ OpenGl_FrameBuffer* theReadDrawFbo,
+ OpenGl_FrameBuffer* theOitAccumFbo) const
{
+ // Remember global settings for glDepth function and write mask.
OpenGl_GlobalLayerSettings aDefaultSettings;
const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
aCtx->core11fwd->glGetIntegerv (GL_DEPTH_FUNC, &aDefaultSettings.DepthFunc);
aCtx->core11fwd->glGetBooleanv (GL_DEPTH_WRITEMASK, &aDefaultSettings.DepthMask);
+ // Two render filters are used to support transparency draw. Opaque filter accepts
+ // only non-transparent OpenGl elements of a layer and counts number of skipped
+ // transparent ones. If the counter has positive value the layer is added into
+ // transparency post-processing stack. At the end of drawing or once the depth
+ // buffer is to be cleared the layers in the stack should be drawn using
+ // blending and depth mask settings and another transparency filter which accepts
+ // only transparent OpenGl elements of a layer. The stack <myTransparentToProcess>
+ // was preallocated before going into this method and has enough space to keep
+ // maximum number of references to layers, therefore it will not increase memory
+ // fragmentation during regular rendering.
+ const Handle(OpenGl_RenderFilter) aPrevFilter = theWorkspace->GetRenderFilter();
+ myRenderOpaqueFilter->SetPreviousFilter (aPrevFilter);
+ myRenderTranspFilter->SetPreviousFilter (aPrevFilter);
+ theWorkspace->SetRenderFilter (myRenderOpaqueFilter);
+
+ myTransparentToProcess.Clear();
+
+ OpenGl_LayerStack::iterator aStackIter (myTransparentToProcess.Origin());
Standard_Integer aSeqId = myLayers.Lower();
bool toClearDepth = false;
- for (OpenGl_SequenceOfLayers::Iterator anIts (myLayers); anIts.More(); anIts.Next(), ++aSeqId)
+ for (OpenGl_SequenceOfLayers::Iterator aLayerIter (myLayers); aLayerIter.More(); aLayerIter.Next(), ++aSeqId)
{
if (theLayersToProcess == OpenGl_LF_Bottom)
{
if (aSeqId != myDefaultLayerIndex) continue;
}
- const OpenGl_Layer& aLayer = anIts.Value();
+ const OpenGl_Layer& aLayer = aLayerIter.Value();
if (aLayer.IsImmediate() != theToDrawImmediate)
{
continue;
}
else if (aLayer.NbStructures() < 1)
{
- // make sure to clear depth of previous layers even if layer has no structures
+ // Make sure to clear depth of previous layers even if layer has no structures.
toClearDepth = toClearDepth || aLayer.LayerSettings().ToClearDepth();
continue;
}
- // depth buffers
+ // At this point the depth buffer may be set to clear by
+ // previous configuration of layers or configuration of the
+ // current layer. Additional rendering pass to handle transparent
+ // elements of recently drawn layers require use of current depth
+ // buffer so we put remaining layers for processing as one bunch before
+ // erasing the depth buffer.
if (toClearDepth
|| aLayer.LayerSettings().ToClearDepth())
{
+ if (!myTransparentToProcess.IsEmpty())
+ {
+ renderTransparent (theWorkspace, aStackIter, aDefaultSettings, theReadDrawFbo, theOitAccumFbo);
+ }
+
toClearDepth = false;
glDepthMask (GL_TRUE);
glClear (GL_DEPTH_BUFFER_BIT);
}
+ // Render opaque OpenGl elements of a layer and count the number of skipped.
+ // If a layer has skipped (e.g. transparent) elements it should be added into
+ // the transparency post-processing stack.
+ myRenderOpaqueFilter->SetSkippedCounter (0);
+
aLayer.Render (theWorkspace, aDefaultSettings);
+
+ if (myRenderOpaqueFilter->NbSkipped() > 0)
+ {
+ myTransparentToProcess.Push (&aLayer);
+ }
+ }
+
+ // Before finishing process the remaining collected layers with transparency.
+ if (!myTransparentToProcess.IsEmpty())
+ {
+ renderTransparent (theWorkspace, aStackIter, aDefaultSettings, theReadDrawFbo, theOitAccumFbo);
}
if (toClearDepth)
aCtx->core11fwd->glDepthMask (aDefaultSettings.DepthMask);
aCtx->core11fwd->glDepthFunc (aDefaultSettings.DepthFunc);
+
+ theWorkspace->SetRenderFilter (aPrevFilter);
+}
+
+//=======================================================================
+//function : renderTransparent
+//purpose : Render transparent objects using blending operator.
+//=======================================================================
+void OpenGl_LayerList::renderTransparent (const Handle(OpenGl_Workspace)& theWorkspace,
+ OpenGl_LayerStack::iterator& theLayerIter,
+ const OpenGl_GlobalLayerSettings& theGlobalSettings,
+ OpenGl_FrameBuffer* theReadDrawFbo,
+ OpenGl_FrameBuffer* theOitAccumFbo) const
+{
+ // Blended order-independent transparency algorithm require several preconditions
+ // to be enabled. It should be requested by user, at least two outputs from
+ // fragment shader should be supported by GPU, so is the given framebuffer
+ // should contain two additional color buffers to handle accumulated color channels,
+ // blended alpha channel and weight factors - these accumulation buffers are required
+ // to implement commuting blend operator (at least OpenGl 2.0 should be available).
+ const bool isEnabledOit = theOitAccumFbo != NULL
+ && theOitAccumFbo->NbColorBuffers() >= 2
+ && theOitAccumFbo->ColorTexture (0)->IsValid()
+ && theOitAccumFbo->ColorTexture (1)->IsValid();
+
+ // Check if current iterator has already reached the end of the stack.
+ // This should happen if no additional layers has been added to
+ // the processing stack after last transparency pass.
+ if (theLayerIter == myTransparentToProcess.Back())
+ {
+ return;
+ }
+
+ const Handle(OpenGl_Context) aCtx = theWorkspace->GetGlContext();
+ const Handle(OpenGl_ShaderManager)& aManager = aCtx->ShaderManager();
+ OpenGl_View* aView = theWorkspace->View();
+ const float aDepthFactor = aView != NULL ? aView->RenderingParams().OitDepthFactor : 0.0f;
+
+ theWorkspace->SetRenderFilter (myRenderTranspFilter);
+
+ aCtx->core11fwd->glEnable (GL_BLEND);
+
+ if (isEnabledOit)
+ {
+ aManager->SetOitState (true, aDepthFactor);
+
+ theOitAccumFbo->BindBuffer (aCtx);
+
+ static const Standard_Integer aDrawBuffers[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT0 + 1 };
+ aCtx->SetDrawBuffers (2, aDrawBuffers);
+ aCtx->core11fwd->glClearColor (0.0f, 0.0f, 0.0f, 1.0f);
+ aCtx->core11fwd->glClear (GL_COLOR_BUFFER_BIT);
+ aCtx->core15fwd->glBlendFuncSeparate (GL_ONE, GL_ONE, GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
+ }
+ else
+ {
+ aCtx->core11fwd->glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ }
+
+ // During blended order-independent transparency pass the depth test
+ // should be enabled to discard fragments covered by opaque geometry
+ // and depth writing should be disabled, because transparent fragments
+ // overal each other with non unitary coverage factor.
+ OpenGl_GlobalLayerSettings aGlobalSettings = theGlobalSettings;
+ aGlobalSettings.DepthMask = GL_FALSE;
+ aCtx->core11fwd->glDepthMask (GL_FALSE);
+
+ for (; theLayerIter != myTransparentToProcess.Back(); ++theLayerIter)
+ {
+ (*theLayerIter)->Render (theWorkspace, aGlobalSettings);
+ }
+
+ // Revert state of rendering.
+ if (isEnabledOit)
+ {
+ aManager->SetOitState (false, aDepthFactor);
+ theOitAccumFbo->UnbindBuffer (aCtx);
+ if (theReadDrawFbo)
+ {
+ theReadDrawFbo->BindBuffer (aCtx);
+ }
+
+ static const Standard_Integer aDrawBuffers[] = { GL_COLOR_ATTACHMENT0 };
+ aCtx->SetDrawBuffers (1, aDrawBuffers);
+ }
+
+ theWorkspace->SetRenderFilter (myRenderOpaqueFilter);
+ if (isEnabledOit)
+ {
+ const Standard_Boolean isMSAA = theReadDrawFbo && theReadDrawFbo->NbSamples() > 0;
+ OpenGl_VertexBuffer* aVerts = theWorkspace->View()->initBlitQuad (Standard_False);
+ if (aVerts->IsValid() && aManager->BindOitCompositingProgram (isMSAA))
+ {
+ aCtx->core11fwd->glDepthFunc (GL_ALWAYS);
+ aCtx->core11fwd->glDepthMask (GL_FALSE);
+
+ // Bind full screen quad buffer and framebuffer resources.
+ aVerts->BindVertexAttrib (aCtx, Graphic3d_TOA_POS);
+
+ const Handle(OpenGl_Texture) aTextureBack = theWorkspace->DisableTexture();
+
+ theOitAccumFbo->ColorTexture (0)->Bind (aCtx, GL_TEXTURE0 + 0);
+ theOitAccumFbo->ColorTexture (1)->Bind (aCtx, GL_TEXTURE0 + 1);
+
+ // Draw full screen quad with special shader to compose the buffers.
+ aCtx->core11fwd->glBlendFunc (GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA);
+ aCtx->core11fwd->glDrawArrays (GL_TRIANGLE_STRIP, 0, 4);
+
+ // Unbind OpenGL texture objects and shader program.
+ aVerts->UnbindVertexAttrib (aCtx, Graphic3d_TOA_POS);
+ theOitAccumFbo->ColorTexture (0)->Unbind (aCtx, GL_TEXTURE0 + 0);
+ theOitAccumFbo->ColorTexture (1)->Unbind (aCtx, GL_TEXTURE0 + 1);
+ aCtx->BindProgram (NULL);
+
+ if (!aTextureBack.IsNull())
+ {
+ theWorkspace->EnableTexture (aTextureBack);
+ }
+ }
+ else
+ {
+ aCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
+ "Initialization of OIT compositing pass has failed.\n"
+ " Blended order-independent transparency will not be available.\n");
+ if (aView != NULL)
+ {
+ Standard_Boolean& aOITFlag = isMSAA ? aView->myToDisableOITMSAA : aView->myToDisableOIT;
+ aOITFlag = Standard_True;
+ }
+ }
+ }
+
+ aCtx->core11fwd->glDisable (GL_BLEND);
+ aCtx->core11fwd->glBlendFunc (GL_ONE, GL_ZERO);
+ aCtx->core11fwd->glDepthMask (theGlobalSettings.DepthMask);
+ aCtx->core11fwd->glDepthFunc (theGlobalSettings.DepthFunc);
+}
+
+//=======================================================================
+//class : OpenGl_OpaqueFilter
+//function : ShouldRender
+//purpose : Checks whether the element should be rendered or skipped.
+//=======================================================================
+Standard_Boolean OpenGl_LayerList::OpenGl_OpaqueFilter::ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_Element* theGlElement)
+{
+ if (!myFilter.IsNull()
+ && !myFilter->ShouldRender (theWorkspace, theGlElement))
+ {
+ return Standard_False;
+ }
+
+ const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theGlElement);
+ if (aPArray == NULL
+ || aPArray->DrawMode() < OpenGl_PrimitiveArray::THE_FILLPRIM_FROM
+ || aPArray->DrawMode() > OpenGl_PrimitiveArray::THE_FILLPRIM_TO)
+ {
+ return Standard_True;
+ }
+
+ Standard_ShortReal aFront = 0.f;
+ Standard_ShortReal aBack = 0.f;
+
+ if (OpenGl_Context::CheckIsTransparent (theWorkspace->AspectFace(),
+ theWorkspace->HighlightStyle(),
+ aFront, aBack))
+ {
+ ++mySkippedCounter;
+ return Standard_False;
+ }
+
+ return Standard_True;
+}
+
+//=======================================================================
+//class : OpenGl_TransparentFilter
+//function : ShouldRender
+//purpose : Checks whether the element should be rendered or skipped.
+//=======================================================================
+Standard_Boolean OpenGl_LayerList::OpenGl_TransparentFilter::ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_Element* theGlElement)
+{
+ if (!myFilter.IsNull()
+ && !myFilter->ShouldRender (theWorkspace, theGlElement))
+ {
+ return Standard_False;
+ }
+
+ const OpenGl_PrimitiveArray* aPArray = dynamic_cast<const OpenGl_PrimitiveArray*> (theGlElement);
+ if (aPArray == NULL
+ || aPArray->DrawMode() < OpenGl_PrimitiveArray::THE_FILLPRIM_FROM
+ || aPArray->DrawMode() > OpenGl_PrimitiveArray::THE_FILLPRIM_TO)
+ {
+ return dynamic_cast<const OpenGl_AspectFace*> (theGlElement) != NULL;
+ }
+
+ Standard_ShortReal aFront = 0.f;
+ Standard_ShortReal aBack = 0.f;
+
+ return OpenGl_Context::CheckIsTransparent (theWorkspace->AspectFace(),
+ theWorkspace->HighlightStyle(),
+ aFront, aBack);
}
#include <OpenGl_Layer.hxx>
#include <OpenGl_LayerFilter.hxx>
+#include <NCollection_Array1.hxx>
+#include <NCollection_Handle.hxx>
#include <NCollection_Sequence.hxx>
#include <NCollection_DataMap.hxx>
//! Render this element
void Render (const Handle(OpenGl_Workspace)& theWorkspace,
const Standard_Boolean theToDrawImmediate,
- const OpenGl_LayerFilter theLayersToProcess) const;
+ const OpenGl_LayerFilter theLayersToProcess,
+ OpenGl_FrameBuffer* theReadDrawFbo,
+ OpenGl_FrameBuffer* theOitAccumFbo) const;
//! Returns the set of OpenGL Z-layers.
const OpenGl_SequenceOfLayers& Layers() const { return myLayers; }
//! Returns structure modification state (for ray-tracing).
Standard_Size ModificationStateOfRaytracable() const { return myModifStateOfRaytraceable; }
+protected:
+
+ //! Filter of TKOpenGl elements for processing only shading geometry and
+ //! for collecting number of skipped elements to an external counter.
+ class OpenGl_OpaqueFilter : public OpenGl_RenderFilter
+ {
+ public:
+
+ //! Constructor.
+ //! @param thePrevFilter [in] the previously active filter that should have additive effect.
+ OpenGl_OpaqueFilter() : mySkippedCounter (0) {}
+
+ //! Sets the current active filter in workspace.
+ //! @param thePrevFilter [in] the previously active filter that should have additive effect.
+ void SetPreviousFilter (const Handle(OpenGl_RenderFilter)& thePrevFitler) { myFilter = thePrevFitler; }
+
+ //! Sets the value of the skipped elements counter.
+ void SetSkippedCounter (const Standard_Size theCounter) { mySkippedCounter = theCounter; }
+
+ //! Returns number of skipped elements.
+ Standard_Size NbSkipped() const { return mySkippedCounter; }
+
+ //! Checks whether the element should be rendered or skipped.
+ //! @param theWorkspace [in] the currently used workspace for rendering.
+ //! @param theGlElement [in] the TKOpenGl rendering queue element that should be checked before streaming to GPU.
+ Standard_EXPORT virtual Standard_Boolean ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_Element* theGlElement) Standard_OVERRIDE;
+
+ DEFINE_STANDARD_RTTI_INLINE (OpenGl_OpaqueFilter, OpenGl_RenderFilter)
+
+ private:
+
+ Standard_Size mySkippedCounter; //!< Counter of skipped elements.
+ Handle(OpenGl_RenderFilter) myFilter; //!< Previous active filter that should be combined.
+ };
+
+ //! Filter of TKOpenGl elements for keeping only shading geometry with transparency.
+ class OpenGl_TransparentFilter : public OpenGl_RenderFilter
+ {
+ public:
+
+ //! Constructor.
+ OpenGl_TransparentFilter() {}
+
+ //! Sets the current active filter in workspace.
+ //! @param thePrevFilter [in] the previously active filter that should have additive effect.
+ void SetPreviousFilter (const Handle(OpenGl_RenderFilter)& thePrevFitler) { myFilter = thePrevFitler; }
+
+ //! Checks whether the element should be rendered or skipped.
+ //! @param theWorkspace [in] the currently used workspace for rendering.
+ //! @param theGlElement [in] the TKOpenGl rendering queue element that should be checked before streaming to GPU.
+ Standard_EXPORT virtual Standard_Boolean ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_Element* theGlElement) Standard_OVERRIDE;
+
+ DEFINE_STANDARD_RTTI_INLINE (OpenGl_TransparentFilter, OpenGl_RenderFilter)
+
+ private:
+
+ Handle(OpenGl_RenderFilter) myFilter; //!< Previous active filter that should be combined.
+ };
+
+ //! Stack of references to existing layers of predefined maximum size.
+ class OpenGl_LayerStack
+ {
+ public:
+ typedef NCollection_Array1<const OpenGl_Layer*>::iterator iterator;
+
+ //! Reallocate internal buffer of the stack.
+ void Allocate (Standard_Integer theSize)
+ {
+ if (theSize > 0)
+ {
+ myStackSpace = new NCollection_Array1<const OpenGl_Layer*> (1, theSize);
+ myStackSpace->Init (NULL);
+ myBackPtr = myStackSpace->begin();
+ }
+ else
+ {
+ myStackSpace.Nullify();
+ myBackPtr = iterator();
+ }
+ }
+
+ //! Clear stack.
+ void Clear()
+ {
+ if (!myStackSpace.IsNull())
+ {
+ myStackSpace->Init (NULL);
+ myBackPtr = myStackSpace->begin();
+ }
+ }
+
+ //! Push a new layer reference to the stack.
+ void Push (const OpenGl_Layer* theLayer) { (*myBackPtr++) = theLayer; }
+
+ //! Returns iterator to the origin of the stack.
+ iterator Origin() const { return myStackSpace.IsNull() ? iterator() : myStackSpace->begin(); }
+
+ //! Returns iterator to the back of the stack (after last item added).
+ iterator Back() const { return myBackPtr; }
+
+ //! Returns true if nothing has been pushed into the stack.
+ Standard_Boolean IsEmpty() const { return Back() == Origin(); }
+
+ private:
+
+ NCollection_Handle<NCollection_Array1<const OpenGl_Layer*> > myStackSpace;
+ iterator myBackPtr;
+ };
+
+ //! Render transparent objects using blending operator.
+ //! Additional accumulation framebuffer is used for blended order-independent
+ //! transparency algorithm. It should support floating-point color components
+ //! and share depth with main reading/drawing framebuffer.
+ //! @param theWorkspace [in] the currently used workspace for rendering.
+ //! @param theLayerIter [in/out] the current iterator of transparent layers to process.
+ //! @param theGlobalSettings [in] the set of global settings used for rendering.
+ //! @param theReadDrawFbo [in] the framebuffer for reading depth and writing final color.
+ //! @param theOitAccumFbo [in] the framebuffer for accumulating color and coverage for OIT process.
+ void renderTransparent (const Handle(OpenGl_Workspace)& theWorkspace,
+ OpenGl_LayerStack::iterator& theLayerIter,
+ const OpenGl_GlobalLayerSettings& theGlobalSettings,
+ OpenGl_FrameBuffer* theReadDrawFbo,
+ OpenGl_FrameBuffer* theOitAccumFbo) const;
+
protected:
// number of structures temporary put to default layer
mutable Standard_Size myModifStateOfRaytraceable;
+ //! Collection of references to layers with transparency gathered during rendering pass.
+ mutable OpenGl_LayerStack myTransparentToProcess;
+
+ Handle(OpenGl_OpaqueFilter) myRenderOpaqueFilter; //!< rendering filter for opaque drawing pass (blended OIT).
+ Handle(OpenGl_TransparentFilter) myRenderTranspFilter; //!< rendering filter for transparency drawing pass (blended OIT).
+
public:
DEFINE_STANDARD_ALLOC
DRAW_MODE_NONE = -1
};
+#if !defined(GL_ES_VERSION_2_0)
+ static const GLint THE_FILLPRIM_FROM = GL_TRIANGLES;
+ static const GLint THE_FILLPRIM_TO = GL_POLYGON;
+#else
+ static const GLint THE_FILLPRIM_FROM = GL_TRIANGLES;
+ static const GLint THE_FILLPRIM_TO = GL_TRIANGLE_FAN;
+#endif
+
//! Empty constructor
Standard_EXPORT OpenGl_PrimitiveArray (const OpenGl_GraphicDriver* theDriver);
DEFINE_STANDARD_HANDLE (OpenGl_RenderFilter, Standard_Transient)
class OpenGl_Element;
+class OpenGl_Workspace;
//! Base class for defining element rendering filters.
//! This class can be used in pair with advance rendering passes, and for
public:
//! Checks whether the element can be rendered or not.
+ //! @param theWorkspace [in] the current workspace.
//! @param theElement [in] the element to check.
//! @return True if element can be rendered.
- virtual Standard_Boolean CanRender (const OpenGl_Element* theElement) = 0;
+ virtual Standard_Boolean ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace, const OpenGl_Element* theElement) = 0;
public:
- DEFINE_STANDARD_RTTIEXT(OpenGl_RenderFilter,Standard_Transient)
+ DEFINE_STANDARD_RTTIEXT(OpenGl_RenderFilter, Standard_Transient)
};
#endif
OpenGl_PO_ClipPlanes1 = 0x040, //!< handle 1 clipping plane
OpenGl_PO_ClipPlanes2 = 0x080, //!< handle 2 clipping planes
OpenGl_PO_ClipPlanesN = 0x100, //!< handle N clipping planes
- OpenGl_PO_NB = 0x200 //!< overall number of combinations
+ OpenGl_PO_WriteOit = 0x200, //!< write coverage buffer for Blended Order-Independent Transparency
+ OpenGl_PO_NB = 0x400 //!< overall number of combinations
};
//! Alias to programs array of predefined length
EOL" discard;"
EOL" }";
+//! Output color and coverage for accumulation by OIT algorithm.
+const char THE_FRAG_write_oit_buffers[] =
+ EOL" float aWeight = occFragColor.a * clamp (1e+2 * pow (1.0 - gl_FragCoord.z * occOitDepthFactor, 3.0), 1e-2, 1e+2);"
+ EOL" occFragCoverage.r = occFragColor.a * aWeight;"
+ EOL" occFragColor = vec4 (occFragColor.rgb * occFragColor.a * aWeight, occFragColor.a);";
+
#if !defined(GL_ES_VERSION_2_0)
static const GLfloat THE_DEFAULT_AMBIENT[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
}
}
+// =======================================================================
+// function : PushOitState
+// purpose : Pushes state of OIT uniforms to the specified program
+// =======================================================================
+void OpenGl_ShaderManager::PushOitState (const Handle(OpenGl_ShaderProgram)& theProgram) const
+{
+ if (!theProgram->IsValid())
+ {
+ return;
+ }
+
+ if (myOitState.Index() == theProgram->ActiveState (OpenGL_OIT_STATE))
+ {
+ return;
+ }
+
+ const GLint aLocOutput = theProgram->GetStateLocation (OpenGl_OCCT_OIT_OUTPUT);
+ if (aLocOutput != OpenGl_ShaderProgram::INVALID_LOCATION)
+ {
+ theProgram->SetUniform (myContext, aLocOutput, myOitState.ToEnableWrite());
+ }
+
+ const GLint aLocDepthFactor = theProgram->GetStateLocation (OpenGl_OCCT_OIT_DEPTH_FACTOR);
+ if (aLocDepthFactor != OpenGl_ShaderProgram::INVALID_LOCATION)
+ {
+ theProgram->SetUniform (myContext, aLocDepthFactor, myOitState.DepthFactor());
+ }
+}
+
// =======================================================================
// function : PushState
// purpose : Pushes state of OCCT graphics parameters to the program
PushProjectionState (aProgram);
PushLightSourceState (aProgram);
PushMaterialState (aProgram);
+ PushOitState (aProgram);
}
// =======================================================================
{
aProgramSrc->SetHeader ("#version 150");
}
+#else
+ if (myContext->IsGlGreaterEqual (3, 0))
+ {
+ aProgramSrc->SetHeader ("#version 300 es");
+ }
#endif
aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
return Standard_True;
}
+// =======================================================================
+// function : prepareStdProgramOitCompositing
+// purpose :
+// =======================================================================
+Standard_Boolean OpenGl_ShaderManager::prepareStdProgramOitCompositing (const Standard_Boolean theMsaa)
+{
+ Handle(OpenGl_ShaderProgram)& aProgram = myOitCompositingProgram[theMsaa ? 1 : 0];
+ Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
+ TCollection_AsciiString aSrcVert, aSrcFrag;
+
+ aSrcVert =
+ EOL"THE_SHADER_OUT vec2 TexCoord;"
+ EOL"void main()"
+ EOL"{"
+ EOL" TexCoord = occVertex.zw;"
+ EOL" gl_Position = vec4 (occVertex.x, occVertex.y, 0.0, 1.0);"
+ EOL"}";
+
+ if (!theMsaa)
+ {
+ aSrcFrag =
+ EOL"uniform sampler2D uAccumTexture;"
+ EOL"uniform sampler2D uWeightTexture;"
+ EOL
+ EOL"THE_SHADER_IN vec2 TexCoord;"
+ EOL
+ EOL"void main()"
+ EOL"{"
+ EOL" vec4 aAccum = occTexture2D (uAccumTexture, TexCoord);"
+ EOL" float aWeight = occTexture2D (uWeightTexture, TexCoord).r;"
+ EOL" occFragColor = vec4 (aAccum.rgb / max (aWeight, 0.00001), aAccum.a);"
+ EOL"}";
+ #if !defined(GL_ES_VERSION_2_0)
+ if (myContext->IsGlGreaterEqual (3, 2))
+ {
+ aProgramSrc->SetHeader ("#version 150");
+ }
+ #else
+ if (myContext->IsGlGreaterEqual (3, 0))
+ {
+ aProgramSrc->SetHeader ("#version 300 es");
+ }
+ #endif
+ }
+ else
+ {
+ aSrcFrag =
+ EOL"uniform sampler2DMS uAccumTexture;"
+ EOL"uniform sampler2DMS uWeightTexture;"
+ EOL
+ EOL"THE_SHADER_IN vec2 TexCoord;"
+ EOL
+ EOL"void main()"
+ EOL"{"
+ EOL" ivec2 aTexel = ivec2 (textureSize (uAccumTexture) * TexCoord);"
+ EOL" vec4 aAccum = texelFetch (uAccumTexture, aTexel, gl_SampleID);"
+ EOL" float aWeight = texelFetch (uWeightTexture, aTexel, gl_SampleID).r;"
+ EOL" occFragColor = vec4 (aAccum.rgb / max (aWeight, 0.00001), aAccum.a);"
+ EOL"}";
+ #if !defined(GL_ES_VERSION_2_0)
+ if (myContext->IsGlGreaterEqual (4, 0))
+ {
+ aProgramSrc->SetHeader ("#version 400");
+ }
+ #else
+ if (myContext->IsGlGreaterEqual (3, 0))
+ {
+ aProgramSrc->SetHeader ("#version 300 es");
+ }
+ #endif
+ }
+
+ aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
+ aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
+ TCollection_AsciiString aKey;
+ if (!Create (aProgramSrc, aKey, aProgram))
+ {
+ aProgram = new OpenGl_ShaderProgram(); // just mark as invalid
+ return Standard_False;
+ }
+
+ myContext->BindProgram (aProgram);
+ aProgram->SetSampler (myContext, "uAccumTexture", 0);
+ aProgram->SetSampler (myContext, "uWeightTexture", 1);
+ myContext->BindProgram (Handle(OpenGl_ShaderProgram)());
+ return Standard_True;
+}
+
// =======================================================================
// function : pointSpriteAlphaSrc
// purpose :
const Standard_Integer theBits)
{
Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
- TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain, aSrcVertExtraFunc, aSrcGetAlpha, aSrcFrag, aSrcFragExtraOut, aSrcFragExtraMain;
+ TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain, aSrcVertExtraFunc, aSrcGetAlpha;
+ TCollection_AsciiString aSrcFrag, aSrcFragExtraOut, aSrcFragExtraMain, aSrcFragWriteOit;
TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return occColor; }";
TCollection_AsciiString aSrcFragMainGetColor = EOL" occFragColor = getColor();";
if ((theBits & OpenGl_PO_Point) != 0)
aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_N;
}
}
+ if ((theBits & OpenGl_PO_WriteOit) != 0)
+ {
+ aSrcFragWriteOit += THE_FRAG_write_oit_buffers;
+ }
TCollection_AsciiString aSrcVertEndMain;
if ((theBits & OpenGl_PO_StippleLine) != 0)
#if defined(GL_ES_VERSION_2_0)
if (myContext->IsGlGreaterEqual (3, 0))
{
- aProgramSrc->SetHeader ("#version 300 es");
hasGlslBitOps = true;
}
#else
EOL"{"
+ aSrcFragExtraMain
+ aSrcFragMainGetColor
+ + aSrcFragWriteOit
+ EOL"}";
#if !defined(GL_ES_VERSION_2_0)
{
aProgramSrc->SetHeader ("#version 150");
}
+#else
+ if (myContext->IsGlGreaterEqual (3, 0))
+ {
+ aProgramSrc->SetHeader ("#version 300 es");
+ }
#endif
aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
const Standard_Integer theBits)
{
Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
- TCollection_AsciiString aSrcVert, aSrcVertColor, aSrcVertExtraOut, aSrcVertExtraMain, aSrcFrag, aSrcFragExtraOut, aSrcFragExtraMain;
+ TCollection_AsciiString aSrcVert, aSrcVertColor, aSrcVertExtraOut, aSrcVertExtraMain;
+ TCollection_AsciiString aSrcFrag, aSrcFragExtraOut, aSrcFragExtraMain, aSrcFragWriteOit;
TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return gl_FrontFacing ? FrontColor : BackColor; }";
if ((theBits & OpenGl_PO_Point) != 0)
{
aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_N;
}
}
+ if ((theBits & OpenGl_PO_WriteOit) != 0)
+ {
+ aSrcFragWriteOit += THE_FRAG_write_oit_buffers;
+ }
const TCollection_AsciiString aLights = stdComputeLighting ((theBits & OpenGl_PO_VertColor) != 0);
aSrcVert = TCollection_AsciiString()
EOL"{"
+ aSrcFragExtraMain
+ EOL" occFragColor = getColor();"
- EOL"}";
+ + aSrcFragWriteOit
+ + EOL"}";
#if !defined(GL_ES_VERSION_2_0)
if (myContext->core32 != NULL)
{
aProgramSrc->SetHeader ("#version 150");
}
+#else
+ if (myContext->IsGlGreaterEqual (3, 0))
+ {
+ aProgramSrc->SetHeader ("#version 300 es");
+ }
#endif
aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
#define thePhongCompLight "computeLighting (normalize (Normal), normalize (View), Position, gl_FrontFacing)"
Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
- TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain, aSrcFrag, aSrcFragExtraOut, aSrcFragGetVertColor, aSrcFragExtraMain;
+ TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain;
+ TCollection_AsciiString aSrcFrag, aSrcFragExtraOut, aSrcFragGetVertColor, aSrcFragExtraMain, aSrcFragWriteOit;
TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return " thePhongCompLight "; }";
if ((theBits & OpenGl_PO_Point) != 0)
{
aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_N;
}
}
+ if ((theBits & OpenGl_PO_WriteOit) != 0)
+ {
+ aSrcFragWriteOit += THE_FRAG_write_oit_buffers;
+ }
aSrcVert = TCollection_AsciiString()
+ THE_FUNC_transformNormal
EOL"{"
+ aSrcFragExtraMain
+ EOL" occFragColor = getColor();"
- EOL"}";
+ + aSrcFragWriteOit
+ + EOL"}";
#if !defined(GL_ES_VERSION_2_0)
if (myContext->core32 != NULL)
{
aProgramSrc->SetHeader ("#version 150");
}
+#else
+ if (myContext->IsGlGreaterEqual (3, 0))
+ {
+ aProgramSrc->SetHeader ("#version 300 es");
+ }
#endif
aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
{
aProgramSrc->SetHeader ("#version 150");
}
+#else
+ if (myContext->IsGlGreaterEqual (3, 0))
+ {
+ aProgramSrc->SetHeader ("#version 300 es");
+ }
#endif
aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX, aSrcVert));
&& myContext->BindProgram (myBlitProgram);
}
+ //! Bind program for blended order-independent transparency buffers compositing.
+ Standard_Boolean BindOitCompositingProgram (const Standard_Boolean theIsMSAAEnabled)
+ {
+ const Standard_Integer aProgramIdx = theIsMSAAEnabled ? 1 : 0;
+ if (myOitCompositingProgram[aProgramIdx].IsNull())
+ {
+ prepareStdProgramOitCompositing (theIsMSAAEnabled);
+ }
+
+ const Handle(OpenGl_ShaderProgram)& aProgram = myOitCompositingProgram [aProgramIdx];
+ return !aProgram.IsNull() && myContext->BindProgram (aProgram);
+ }
+
//! Bind program for rendering stereoscopic image.
Standard_Boolean BindStereoProgram (const Graphic3d_StereoMode theStereoMode)
{
//! Pushes current state of material to specified program.
void PushMaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
+public:
+
+ //! Set the state of OIT rendering pass.
+ //! @param theToEnableOitWrite [in] flag indicating whether the special output should be written for OIT algorithm.
+ //! @param theDepthFactor [in] the scalar factor of depth influence to the fragment's coverage.
+ void SetOitState (const bool theToEnableOitWrite, const float theDepthFactor)
+ {
+ myOitState.Set (theToEnableOitWrite, theDepthFactor);
+ myOitState.Update();
+ }
+
+ //! Pushes state of OIT uniforms to the specified program.
+ Standard_EXPORT void PushOitState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
+
public:
//! Pushes current state of OCCT graphics parameters to specified program.
{
aBits |= OpenGl_PO_VertColor;
}
+
+ if (myOitState.ToEnableWrite())
+ {
+ aBits |= OpenGl_PO_WriteOit;
+ }
return aBits;
}
//! Prepare standard GLSL program for FBO blit operation.
Standard_EXPORT Standard_Boolean prepareStdProgramFboBlit();
+ //! Prepare standard GLSL programs for OIT compositing operation.
+ Standard_EXPORT Standard_Boolean prepareStdProgramOitCompositing (const Standard_Boolean theMsaa);
+
//! Prepare standard GLSL program without lighting.
Standard_EXPORT Standard_Boolean prepareStdProgramFlat (Handle(OpenGl_ShaderProgram)& theProgram,
const Standard_Integer theBits);
OpenGl_SetOfShaderPrograms myFlatPrograms; //!< programs matrix without lighting
Handle(OpenGl_ShaderProgram) myFontProgram; //!< standard program for textured text
Handle(OpenGl_ShaderProgram) myBlitProgram; //!< standard program for FBO blit emulation
+ Handle(OpenGl_ShaderProgram) myOitCompositingProgram[2]; //!< standard program for OIT compositing (default and MSAA).
OpenGl_MapOfShaderPrograms myMapOfLightPrograms; //!< map of lighting programs depending on shading model and lights configuration
Handle(OpenGl_ShaderProgram) myStereoPrograms[Graphic3d_StereoMode_NB]; //!< standard stereo programs
OpenGl_ClippingState myClippingState; //!< State of OCCT clipping planes
OpenGl_LightSourceState myLightSourceState; //!< State of OCCT light sources
OpenGl_MaterialState myMaterialState; //!< State of Front and Back materials
+ OpenGl_OitState myOitState; //!< State of OIT uniforms
gp_XYZ myLocalOrigin; //!< local camera transformation
Standard_Boolean myHasLocalOrigin; //!< flag indicating that local camera transformation has been set
"occBackMaterial", // OpenGl_OCCT_BACK_MATERIAL
"occColor", // OpenGl_OCCT_COLOR
+ "occOitOutput", // OpenGl_OCCT_OIT_OUTPUT
+ "occOitDepthFactor", // OpenGl_OCCT_OIT_DEPTH_FACTOR
+
"occTexTrsf2d", // OpenGl_OCCT_TEXTURE_TRSF2D
"occPointSize" // OpenGl_OCCT_POINT_SIZE
-
};
// =======================================================================
}
TCollection_AsciiString aSource = aDeclarations + anIter.Value()->Source();
+ TCollection_AsciiString anExtensions = "// This section enables extensions used in OCCT GLSL programs\n";
+ if (theCtx->hasDrawBuffers)
+ {
+ anExtensions += "#define OCC_ENABLE_draw_buffers\n";
+ }
+ if (theCtx->hasDrawBuffers == OpenGl_FeatureInExtensions)
+ {
+ if (theCtx->arbDrawBuffers)
+ {
+ anExtensions += "#extension GL_ARB_draw_buffers : enable\n";
+ }
+ else if (theCtx->extDrawBuffers)
+ {
+ anExtensions += "#extension GL_EXT_draw_buffers : enable\n";
+ }
+ }
+
+ if (theCtx->hasSampleVariables == OpenGl_FeatureInExtensions)
+ {
+#if defined(GL_ES_VERSION_2_0)
+ if (theCtx->oesSampleVariables)
+ {
+ anExtensions += "#extension GL_OES_sample_variables : enable\n";
+ }
+#else
+ if (theCtx->arbSampleShading)
+ {
+ anExtensions += "#extension GL_ARB_sample_shading : enable\n";
+ }
+#endif
+ }
+
switch (anIter.Value()->Type())
{
case Graphic3d_TOS_VERTEX:
{
- aSource = aHeader + TCollection_AsciiString ("#define VERTEX_SHADER\n") + aSource;
+ aSource = aHeader + TCollection_AsciiString ("#define VERTEX_SHADER\n") + anExtensions + aSource;
break;
}
case Graphic3d_TOS_FRAGMENT:
"precision highp int;\n"
: "precision mediump float;\n"
"precision mediump int;\n");
- aSource = aHeader + aPrefix + aSource;
+ aSource = aHeader + aPrefix + anExtensions + aSource;
#else
- aSource = aHeader + aSource;
+ aSource = aHeader + anExtensions + aSource;
#endif
break;
}
if (!aShader->LoadSource (theCtx, aSource))
{
+ theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH, aSource);
const TCollection_ExtendedString aMsg = "Error! Failed to set shader source";
theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
GL_DEBUG_TYPE_ERROR,
if (!aShader->Compile (theCtx))
{
+ theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH, aSource);
TCollection_AsciiString aLog;
aShader->FetchInfoLog (theCtx, aLog);
if (aLog.IsEmpty())
OpenGl_OCCT_BACK_MATERIAL,
OpenGl_OCCT_COLOR,
+ // Weighted, Blended Order-Independent Transparency rendering state
+ OpenGl_OCCT_OIT_OUTPUT,
+ OpenGl_OCCT_OIT_DEPTH_FACTOR,
+
+ // Context-dependent state
OpenGl_OCCT_TEXTURE_TRSF2D,
OpenGl_OCCT_POINT_SIZE,
OpenGl_PROJECTION_STATE,
OpenGl_MATERIAL_STATE,
OpenGl_SURF_DETAIL_STATE,
+ OpenGL_OIT_STATE,
OpenGl_UniformStateType_NB
};
};
+//! Defines generic state of order-independent transparency rendering properties.
+class OpenGl_OitState : public OpenGl_StateInterface
+{
+public:
+
+ //! Creates new uniform state.
+ OpenGl_OitState() : myToEnableWrite (false), myDepthFactor (0.5f) {}
+
+ //! Sets the uniform values.
+ //! @param theToEnableWrite [in] flag indicating whether color and coverage
+ //! values for OIT processing should be written by shader program.
+ //! @param theDepthFactor [in] scalar factor [0-1] defining influence of depth
+ //! component of a fragment to its final coverage coefficient.
+ void Set (const bool theToEnableWrite,
+ const float theDepthFactor)
+ {
+ myToEnableWrite = theToEnableWrite;
+ myDepthFactor = static_cast<float> (Max (0.f, Min (1.f, theDepthFactor)));
+ }
+
+ //! Returns flag indicating whether writing of output for OIT processing
+ //! should be enabled/disabled.
+ bool ToEnableWrite() const { return myToEnableWrite; }
+
+ //! Returns factor defining influence of depth component of a fragment
+ //! to its final coverage coefficient.
+ float DepthFactor() const { return myDepthFactor; }
+
+private:
+
+ bool myToEnableWrite; //!< writing color and coverage.
+ float myDepthFactor; //!< factor of depth influence to coverage.
+};
+
#endif // _OpenGl_State_HeaderFile
}
else
{
+ #if !defined(GL_ES_VERSION_2_0)
theTextFormat = GL_LUMINANCE8;
+ #else
+ theTextFormat = GL_LUMINANCE;
+ #endif
thePixelFormat = GL_LUMINANCE;
}
theDataType = GL_FLOAT;
}
else
{
+ #if !defined(GL_ES_VERSION_2_0)
theTextFormat = GL_ALPHA8;
+ #else
+ theTextFormat = GL_ALPHA;
+ #endif
thePixelFormat = GL_ALPHA;
}
theDataType = GL_FLOAT;
}
else
{
+ #if !defined(GL_ES_VERSION_2_0)
theTextFormat = GL_LUMINANCE8;
+ #else
+ theTextFormat = GL_LUMINANCE;
+ #endif
thePixelFormat = GL_LUMINANCE;
}
theDataType = GL_UNSIGNED_BYTE;
}
else
{
+ #if !defined(GL_ES_VERSION_2_0)
theTextFormat = GL_ALPHA8;
+ #else
+ theTextFormat = GL_ALPHA;
+ #endif
thePixelFormat = GL_ALPHA;
}
theDataType = GL_UNSIGNED_BYTE;
#if !defined(GL_ES_VERSION_2_0)
const GLint anIntFormat = theTextFormat;
#else
- // ES does not support sized formats and format conversions - them detected from data type
- const GLint anIntFormat = thePixelFormat;
- (void) theTextFormat;
+ // ES 2.0 does not support sized formats and format conversions - them detected from data type
+ const GLint anIntFormat = theCtx->IsGlGreaterEqual (3, 0) ? theTextFormat : thePixelFormat;
#endif
const GLsizei aMaxSize = theCtx->MaxTextureSize();
myToShowGradTrihedron (false),
myStateCounter (theCounter),
myLastLightSourceState (0, 0),
+#if !defined(GL_ES_VERSION_2_0)
myFboColorFormat (GL_RGBA8),
+#else
+ myFboColorFormat (GL_RGBA),
+#endif
myFboDepthFormat (GL_DEPTH24_STENCIL8),
myToFlipOutput (Standard_False),
myFrameCounter (0),
myHasFboBlit (Standard_True),
+ myToDisableOIT (Standard_False),
+ myToDisableOITMSAA (Standard_False),
myToDisableMSAA (Standard_False),
myTransientDrawToFront (Standard_True),
myBackBufferRestored (Standard_False),
aLight.Color.b() = 1.;
myNoShadingLight.Append (aLight);
- myCurrLightSourceState = myStateCounter->Increment();
- myMainSceneFbos[0] = new OpenGl_FrameBuffer();
- myMainSceneFbos[1] = new OpenGl_FrameBuffer();
- myImmediateSceneFbos[0] = new OpenGl_FrameBuffer();
- myImmediateSceneFbos[1] = new OpenGl_FrameBuffer();
- myOpenGlFBO = new OpenGl_FrameBuffer();
- myOpenGlFBO2 = new OpenGl_FrameBuffer();
- myRaytraceFBO1[0] = new OpenGl_FrameBuffer();
- myRaytraceFBO1[1] = new OpenGl_FrameBuffer();
- myRaytraceFBO2[0] = new OpenGl_FrameBuffer();
- myRaytraceFBO2[1] = new OpenGl_FrameBuffer();
+ myCurrLightSourceState = myStateCounter->Increment();
+ myMainSceneFbos[0] = new OpenGl_FrameBuffer();
+ myMainSceneFbos[1] = new OpenGl_FrameBuffer();
+ myMainSceneFbosOit[0] = new OpenGl_FrameBuffer();
+ myMainSceneFbosOit[1] = new OpenGl_FrameBuffer();
+ myImmediateSceneFbos[0] = new OpenGl_FrameBuffer();
+ myImmediateSceneFbos[1] = new OpenGl_FrameBuffer();
+ myImmediateSceneFbosOit[0] = new OpenGl_FrameBuffer();
+ myImmediateSceneFbosOit[1] = new OpenGl_FrameBuffer();
+ myOpenGlFBO = new OpenGl_FrameBuffer();
+ myOpenGlFBO2 = new OpenGl_FrameBuffer();
+ myRaytraceFBO1[0] = new OpenGl_FrameBuffer();
+ myRaytraceFBO1[1] = new OpenGl_FrameBuffer();
+ myRaytraceFBO2[0] = new OpenGl_FrameBuffer();
+ myRaytraceFBO2[1] = new OpenGl_FrameBuffer();
}
// =======================================================================
myBgTextureArray->Release (theCtx.operator->());
}
- myMainSceneFbos[0] ->Release (theCtx.operator->());
- myMainSceneFbos[1] ->Release (theCtx.operator->());
- myImmediateSceneFbos[0]->Release (theCtx.operator->());
- myImmediateSceneFbos[1]->Release (theCtx.operator->());
- myOpenGlFBO ->Release (theCtx.operator->());
- myOpenGlFBO2 ->Release (theCtx.operator->());
- myFullScreenQuad .Release (theCtx.operator->());
- myFullScreenQuadFlip .Release (theCtx.operator->());
+ myMainSceneFbos[0] ->Release (theCtx.operator->());
+ myMainSceneFbos[1] ->Release (theCtx.operator->());
+ myMainSceneFbosOit[0] ->Release (theCtx.operator->());
+ myMainSceneFbosOit[1] ->Release (theCtx.operator->());
+ myImmediateSceneFbos[0] ->Release (theCtx.operator->());
+ myImmediateSceneFbos[1] ->Release (theCtx.operator->());
+ myImmediateSceneFbosOit[0]->Release (theCtx.operator->());
+ myImmediateSceneFbosOit[1]->Release (theCtx.operator->());
+ myOpenGlFBO ->Release (theCtx.operator->());
+ myOpenGlFBO2 ->Release (theCtx.operator->());
+ myFullScreenQuad .Release (theCtx.operator->());
+ myFullScreenQuadFlip .Release (theCtx.operator->());
releaseRaytraceResources (theCtx);
}
//! Redraws view for the given monographic camera projection, or left/right eye.
Standard_EXPORT virtual void redraw (const Graphic3d_Camera::Projection theProjection,
- OpenGl_FrameBuffer* theReadDrawFbo);
+ OpenGl_FrameBuffer* theReadDrawFbo,
+ OpenGl_FrameBuffer* theOitAccumFbo);
//! Redraws view for the given monographic camera projection, or left/right eye.
//!
Standard_EXPORT virtual bool redrawImmediate (const Graphic3d_Camera::Projection theProjection,
OpenGl_FrameBuffer* theReadFbo,
OpenGl_FrameBuffer* theDrawFbo,
+ OpenGl_FrameBuffer* theOitAccumFbo,
const Standard_Boolean theIsPartialUpdate = Standard_False);
//! Blit image from/to specified buffers.
//! Renders the graphical contents of the view into the preprepared window or framebuffer.
//! @param theProjection [in] the projection that should be used for rendering.
//! @param theReadDrawFbo [in] the framebuffer for rendering graphics.
+ //! @param theOitAccumFbo [in] the framebuffer for accumulating color and coverage for OIT process.
//! @param theToDrawImmediate [in] the flag indicates whether the rendering performs in immediate mode.
Standard_EXPORT virtual void render (Graphic3d_Camera::Projection theProjection,
OpenGl_FrameBuffer* theReadDrawFbo,
+ OpenGl_FrameBuffer* theOitAccumFbo,
const Standard_Boolean theToDrawImmediate);
//! Renders the graphical scene.
//! @param theProjection [in] the projection that is used for rendering.
//! @param theReadDrawFbo [in] the framebuffer for rendering graphics.
+ //! @param theOitAccumFbo [in] the framebuffer for accumulating color and coverage for OIT process.
//! @param theToDrawImmediate [in] the flag indicates whether the rendering performs in immediate mode.
Standard_EXPORT virtual void renderScene (Graphic3d_Camera::Projection theProjection,
OpenGl_FrameBuffer* theReadDrawFbo,
+ OpenGl_FrameBuffer* theOitAccumFbo,
const Standard_Boolean theToDrawImmediate);
//! Draw background (gradient / image)
//! Render set of structures presented in the view.
//! @param theProjection [in] the projection that is used for rendering.
//! @param theReadDrawFbo [in] the framebuffer for rendering graphics.
+ //! @param theOitAccumFbo [in] the framebuffer for accumulating color and coverage for OIT process.
//! @param theToDrawImmediate [in] the flag indicates whether the rendering performs in immediate mode.
Standard_EXPORT virtual void renderStructs (Graphic3d_Camera::Projection theProjection,
OpenGl_FrameBuffer* theReadDrawFbo,
+ OpenGl_FrameBuffer* theOitAccumFbo,
const Standard_Boolean theToDrawImmediate);
//! Renders trihedron.
//! Blend together views pair into stereo image.
void drawStereoPair (OpenGl_FrameBuffer* theDrawFbo);
+ //! Check and update OIT compatibility with current OpenGL context's state.
+ bool checkOitCompatibility (const Handle(OpenGl_Context)& theGlContext,
+ const Standard_Boolean theMSAA);
+
+ //! Chooses compatible internal color format for OIT frame buffer.
+ bool chooseOitColorConfiguration (const Handle(OpenGl_Context)& theGlContext,
+ const Standard_Integer theConfigIndex,
+ OpenGl_ColorFormats& theFormats);
+
protected:
OpenGl_GraphicDriver* myDriver;
//! of the view (without presentation of immediate layers).
GLint myFboColorFormat; //!< sized format for color attachments
GLint myFboDepthFormat; //!< sized format for depth-stencil attachments
+ OpenGl_ColorFormats myFboOitColorConfig; //!< selected color format configuration for OIT color attachments
Handle(OpenGl_FrameBuffer) myMainSceneFbos[2];
- Handle(OpenGl_FrameBuffer) myImmediateSceneFbos[2]; //!< Additional buffers for immediate layer in stereo mode.
+ Handle(OpenGl_FrameBuffer) myMainSceneFbosOit[2]; //!< Additional buffers for transparent draw of main layer.
+ Handle(OpenGl_FrameBuffer) myImmediateSceneFbos[2]; //!< Additional buffers for immediate layer in stereo mode.
+ Handle(OpenGl_FrameBuffer) myImmediateSceneFbosOit[2]; //!< Additional buffers for transparency draw of immediate layer.
OpenGl_VertexBuffer myFullScreenQuad; //!< Vertices for full-screen quad rendering.
OpenGl_VertexBuffer myFullScreenQuadFlip;
Standard_Boolean myToFlipOutput; //!< Flag to draw result image upside-down
unsigned int myFrameCounter; //!< redraw counter, for debugging
Standard_Boolean myHasFboBlit; //!< disable FBOs on failure
+ Standard_Boolean myToDisableOIT; //!< disable OIT on failure
+ Standard_Boolean myToDisableOITMSAA; //!< disable OIT with MSAA on failure
Standard_Boolean myToDisableMSAA; //!< disable MSAA after failure
Standard_Boolean myTransientDrawToFront; //!< optimization flag for immediate mode (to render directly to the front buffer)
Standard_Boolean myBackBufferRestored;
friend class OpenGl_GraphicDriver;
friend class OpenGl_Workspace;
+ friend class OpenGl_LayerList;
};
#endif // _OpenGl_View_Header
aNbSamples = OpenGl_Context::GetPowerOfTwo (aNbSamples, aCtx->MaxMsaaSamples());
}
+ bool toUseOit = myRenderParams.TransparencyMethod == Graphic3d_RTM_BLEND_OIT
+ && checkOitCompatibility (aCtx, aNbSamples > 0);
+
+ const bool toInitImmediateFbo = myTransientDrawToFront
+ && (!aCtx->caps->useSystemBuffer || (toUseOit && HasImmediateStructures()));
+
if ( aFrameBuffer == NULL
&& !aCtx->DefaultFrameBuffer().IsNull()
&& aCtx->DefaultFrameBuffer()->IsValid())
&& (myTransientDrawToFront
|| aProjectType == Graphic3d_Camera::Projection_Stereo
|| aNbSamples != 0
+ || toUseOit
|| aSizeX != aRendSizeX))
{
if (myMainSceneFbos[0]->GetVPSizeX() != aRendSizeX
{
myMainSceneFbos[0]->Init (aCtx, aRendSizeX, aRendSizeY, myFboColorFormat, myFboDepthFormat, aNbSamples);
}
- if (myTransientDrawToFront
- && !aCtx->caps->useSystemBuffer
- && myMainSceneFbos[0]->IsValid())
- {
- myImmediateSceneFbos[0]->InitLazy (aCtx, *myMainSceneFbos[0]);
- }
+ }
+ if (myMainSceneFbos[0]->IsValid() && (toInitImmediateFbo || myImmediateSceneFbos[0]->IsValid()))
+ {
+ myImmediateSceneFbos[0]->InitLazy (aCtx, *myMainSceneFbos[0]);
}
}
else
}
}
+ // create color and coverage accumulation buffers required for OIT algorithm
+ if (toUseOit)
+ {
+ Standard_Integer anFboIt = 0;
+ for (; anFboIt < 2; ++anFboIt)
+ {
+ Handle(OpenGl_FrameBuffer)& aMainSceneFbo = myMainSceneFbos [anFboIt];
+ Handle(OpenGl_FrameBuffer)& aMainSceneFboOit = myMainSceneFbosOit [anFboIt];
+ Handle(OpenGl_FrameBuffer)& anImmediateSceneFbo = myImmediateSceneFbos [anFboIt];
+ Handle(OpenGl_FrameBuffer)& anImmediateSceneFboOit = myImmediateSceneFbosOit[anFboIt];
+ if (aMainSceneFbo->IsValid()
+ && (aMainSceneFboOit->GetVPSizeX() != aRendSizeX
+ || aMainSceneFboOit->GetVPSizeY() != aRendSizeY
+ || aMainSceneFboOit->NbSamples() != aNbSamples))
+ {
+ Standard_Integer aColorConfig = 0;
+ for (;;) // seemly responding to driver limitation (GL_FRAMEBUFFER_UNSUPPORTED)
+ {
+ if (myFboOitColorConfig.IsEmpty())
+ {
+ if (!chooseOitColorConfiguration (aCtx, aColorConfig++, myFboOitColorConfig))
+ {
+ break;
+ }
+ }
+ if (aMainSceneFboOit->Init (aCtx, aRendSizeX, aRendSizeY, myFboOitColorConfig, aMainSceneFbo->DepthStencilTexture(), aNbSamples))
+ {
+ break;
+ }
+ myFboOitColorConfig.Clear();
+ }
+ if (!aMainSceneFboOit->IsValid())
+ {
+ break;
+ }
+ }
+ else if (!aMainSceneFbo->IsValid())
+ {
+ aMainSceneFboOit->Release (aCtx.operator->());
+ aMainSceneFboOit->ChangeViewport (0, 0);
+ }
+
+ if (anImmediateSceneFbo->IsValid()
+ && (anImmediateSceneFboOit->GetVPSizeX() != aRendSizeX
+ || anImmediateSceneFboOit->GetVPSizeY() != aRendSizeY
+ || anImmediateSceneFboOit->NbSamples() != aNbSamples))
+ {
+ if (!anImmediateSceneFboOit->Init (aCtx, aRendSizeX, aRendSizeY, myFboOitColorConfig,
+ anImmediateSceneFbo->DepthStencilTexture(), aNbSamples))
+ {
+ break;
+ }
+ }
+ else if (!anImmediateSceneFbo->IsValid())
+ {
+ anImmediateSceneFboOit->Release (aCtx.operator->());
+ anImmediateSceneFboOit->ChangeViewport (0, 0);
+ }
+ }
+ if (anFboIt == 0) // only the first OIT framebuffer is mandatory
+ {
+ aCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
+ "Initialization of float texture framebuffer for use with\n"
+ " blended order-independent transparency rendering algorithm has failed.\n"
+ " Blended order-independent transparency will not be available.\n");
+ if (aNbSamples > 0)
+ {
+ myToDisableOITMSAA = Standard_True;
+ }
+ else
+ {
+ myToDisableOIT = Standard_True;
+ }
+ toUseOit = false;
+ }
+ }
+ if (!toUseOit && myMainSceneFbosOit[0]->IsValid())
+ {
+ myMainSceneFbosOit [0]->Release (aCtx.operator->());
+ myMainSceneFbosOit [1]->Release (aCtx.operator->());
+ myImmediateSceneFbosOit[0]->Release (aCtx.operator->());
+ myImmediateSceneFbosOit[1]->Release (aCtx.operator->());
+ myMainSceneFbosOit [0]->ChangeViewport (0, 0);
+ myMainSceneFbosOit [1]->ChangeViewport (0, 0);
+ myImmediateSceneFbosOit[0]->ChangeViewport (0, 0);
+ myImmediateSceneFbosOit[1]->ChangeViewport (0, 0);
+ }
+
if (aProjectType == Graphic3d_Camera::Projection_Stereo)
{
OpenGl_FrameBuffer* aMainFbos[2] =
myMainSceneFbos[0]->IsValid() ? myMainSceneFbos[0].operator->() : NULL,
myMainSceneFbos[1]->IsValid() ? myMainSceneFbos[1].operator->() : NULL
};
+ OpenGl_FrameBuffer* aMainFbosOit[2] =
+ {
+ myMainSceneFbosOit[0]->IsValid() ? myMainSceneFbosOit[0].operator->() : NULL,
+ myMainSceneFbosOit[1]->IsValid() ? myMainSceneFbosOit[1].operator->() :
+ myMainSceneFbosOit[0]->IsValid() ? myMainSceneFbosOit[0].operator->() : NULL
+ };
+
OpenGl_FrameBuffer* anImmFbos[2] =
{
myImmediateSceneFbos[0]->IsValid() ? myImmediateSceneFbos[0].operator->() : NULL,
myImmediateSceneFbos[1]->IsValid() ? myImmediateSceneFbos[1].operator->() : NULL
};
+ OpenGl_FrameBuffer* anImmFbosOit[2] =
+ {
+ myImmediateSceneFbosOit[0]->IsValid() ? myImmediateSceneFbosOit[0].operator->() : NULL,
+ myImmediateSceneFbosOit[1]->IsValid() ? myImmediateSceneFbosOit[1].operator->() :
+ myImmediateSceneFbosOit[0]->IsValid() ? myImmediateSceneFbosOit[0].operator->() : NULL
+ };
if (!myTransientDrawToFront)
{
- anImmFbos[0] = aMainFbos[0];
- anImmFbos[1] = aMainFbos[1];
+ anImmFbos [0] = aMainFbos [0];
+ anImmFbos [1] = aMainFbos [1];
+ anImmFbosOit[0] = aMainFbosOit[0];
+ anImmFbosOit[1] = aMainFbosOit[1];
}
else if (aStereoMode == Graphic3d_StereoMode_SoftPageFlip
|| aStereoMode == Graphic3d_StereoMode_QuadBuffer)
{
- anImmFbos[0] = NULL;
- anImmFbos[1] = NULL;
+ anImmFbos [0] = NULL;
+ anImmFbos [1] = NULL;
+ anImmFbosOit[0] = NULL;
+ anImmFbosOit[1] = NULL;
}
#if !defined(GL_ES_VERSION_2_0)
aCtx->SetResolution (myRenderParams.Resolution, myRenderParams.ResolutionRatio(),
aMainFbos[0] != NULL ? myRenderParams.RenderResolutionScale : 1.0f);
- redraw (Graphic3d_Camera::Projection_MonoLeftEye, aMainFbos[0]);
+ redraw (Graphic3d_Camera::Projection_MonoLeftEye, aMainFbos[0], aMainFbosOit[0]);
myBackBufferRestored = Standard_True;
myIsImmediateDrawn = Standard_False;
#if !defined(GL_ES_VERSION_2_0)
#endif
aCtx->SetResolution (myRenderParams.Resolution, myRenderParams.ResolutionRatio(),
anImmFbos[0] != NULL ? myRenderParams.RenderResolutionScale : 1.0f);
- if (!redrawImmediate (Graphic3d_Camera::Projection_MonoLeftEye, aMainFbos[0], anImmFbos[0]))
+ if (!redrawImmediate (Graphic3d_Camera::Projection_MonoLeftEye, aMainFbos[0], anImmFbos[0], anImmFbosOit[0]))
{
toSwap = false;
}
aCtx->SetResolution (myRenderParams.Resolution, myRenderParams.ResolutionRatio(),
aMainFbos[1] != NULL ? myRenderParams.RenderResolutionScale : 1.0f);
- redraw (Graphic3d_Camera::Projection_MonoRightEye, aMainFbos[1]);
+ redraw (Graphic3d_Camera::Projection_MonoRightEye, aMainFbos[1], aMainFbosOit[1]);
myBackBufferRestored = Standard_True;
myIsImmediateDrawn = Standard_False;
aCtx->SetResolution (myRenderParams.Resolution, myRenderParams.ResolutionRatio(),
anImmFbos[1] != NULL ? myRenderParams.RenderResolutionScale : 1.0f);
- if (!redrawImmediate (Graphic3d_Camera::Projection_MonoRightEye, aMainFbos[1], anImmFbos[1]))
+ if (!redrawImmediate (Graphic3d_Camera::Projection_MonoRightEye, aMainFbos[1], anImmFbos[1], anImmFbosOit[1]))
{
toSwap = false;
}
}
else
{
- OpenGl_FrameBuffer* aMainFbo = myMainSceneFbos[0]->IsValid() ? myMainSceneFbos[0].operator->() : aFrameBuffer;
- OpenGl_FrameBuffer* anImmFbo = aFrameBuffer;
- if (!aCtx->caps->useSystemBuffer && myImmediateSceneFbos[0]->IsValid())
+ OpenGl_FrameBuffer* aMainFbo = myMainSceneFbos[0]->IsValid() ? myMainSceneFbos[0].operator->() : aFrameBuffer;
+ OpenGl_FrameBuffer* aMainFboOit = myMainSceneFbosOit[0]->IsValid() ? myMainSceneFbosOit[0].operator->() : NULL;
+ OpenGl_FrameBuffer* anImmFbo = aFrameBuffer;
+ OpenGl_FrameBuffer* anImmFboOit = NULL;
+ if (!myTransientDrawToFront)
{
- anImmFbo = myImmediateSceneFbos[0].operator->();
+ anImmFbo = aMainFbo;
+ anImmFboOit = aMainFboOit;
}
- if (!myTransientDrawToFront)
+ else if (myImmediateSceneFbos[0]->IsValid())
{
- anImmFbo = aMainFbo;
+ anImmFbo = myImmediateSceneFbos[0].operator->();
+ anImmFboOit = myImmediateSceneFbosOit[0]->IsValid() ? myImmediateSceneFbosOit[0].operator->() : NULL;
}
#if !defined(GL_ES_VERSION_2_0)
#endif
aCtx->SetResolution (myRenderParams.Resolution, myRenderParams.ResolutionRatio(),
aMainFbo != aFrameBuffer ? myRenderParams.RenderResolutionScale : 1.0f);
- redraw (aProjectType, aMainFbo);
+
+ redraw (aProjectType, aMainFbo, aMainFboOit);
myBackBufferRestored = Standard_True;
myIsImmediateDrawn = Standard_False;
aCtx->SetResolution (myRenderParams.Resolution, myRenderParams.ResolutionRatio(),
anImmFbo != aFrameBuffer ? myRenderParams.RenderResolutionScale : 1.0f);
- if (!redrawImmediate (aProjectType, aMainFbo, anImmFbo))
+ if (!redrawImmediate (aProjectType, aMainFbo, anImmFbo, anImmFboOit))
{
toSwap = false;
}
myImmediateSceneFbos[0]->IsValid() ? myImmediateSceneFbos[0].operator->() : NULL,
myImmediateSceneFbos[1]->IsValid() ? myImmediateSceneFbos[1].operator->() : NULL
};
+ OpenGl_FrameBuffer* anImmFbosOit[2] =
+ {
+ myImmediateSceneFbosOit[0]->IsValid() ? myImmediateSceneFbosOit[0].operator->() : NULL,
+ myImmediateSceneFbosOit[1]->IsValid() ? myImmediateSceneFbosOit[1].operator->() :
+ myImmediateSceneFbosOit[0]->IsValid() ? myImmediateSceneFbosOit[0].operator->() : NULL
+ };
if (aStereoMode == Graphic3d_StereoMode_SoftPageFlip
|| aStereoMode == Graphic3d_StereoMode_QuadBuffer)
{
- anImmFbos[0] = NULL;
- anImmFbos[1] = NULL;
+ anImmFbos[0] = NULL;
+ anImmFbos[1] = NULL;
+ anImmFbosOit[0] = NULL;
+ anImmFbosOit[1] = NULL;
}
if (aCtx->arbFBO != NULL)
toSwap = redrawImmediate (Graphic3d_Camera::Projection_MonoLeftEye,
aMainFbos[0],
anImmFbos[0],
+ anImmFbosOit[0],
Standard_True) || toSwap;
if (aStereoMode == Graphic3d_StereoMode_SoftPageFlip
&& toSwap
toSwap = redrawImmediate (Graphic3d_Camera::Projection_MonoRightEye,
aMainFbos[1],
anImmFbos[1],
+ anImmFbosOit[1],
Standard_True) || toSwap;
if (anImmFbos[0] != NULL)
{
{
OpenGl_FrameBuffer* aMainFbo = myMainSceneFbos[0]->IsValid() ? myMainSceneFbos[0].operator->() : NULL;
OpenGl_FrameBuffer* anImmFbo = aFrameBuffer;
- if (!aCtx->caps->useSystemBuffer && myImmediateSceneFbos[0]->IsValid())
+ OpenGl_FrameBuffer* anImmFboOit = NULL;
+ if (myImmediateSceneFbos[0]->IsValid())
{
- anImmFbo = myImmediateSceneFbos[0].operator->();
+ anImmFbo = myImmediateSceneFbos[0].operator->();
+ anImmFboOit = myImmediateSceneFbosOit[0]->IsValid() ? myImmediateSceneFbosOit[0].operator->() : NULL;
}
#if !defined(GL_ES_VERSION_2_0)
if (aMainFbo == NULL)
toSwap = redrawImmediate (aProjectType,
aMainFbo,
anImmFbo,
+ anImmFboOit,
Standard_True) || toSwap;
if (anImmFbo != NULL
&& anImmFbo != aFrameBuffer)
// function : redraw
// purpose :
// =======================================================================
-void OpenGl_View::redraw (const Graphic3d_Camera::Projection theProjection, OpenGl_FrameBuffer* theReadDrawFbo)
+void OpenGl_View::redraw (const Graphic3d_Camera::Projection theProjection,
+ OpenGl_FrameBuffer* theReadDrawFbo,
+ OpenGl_FrameBuffer* theOitAccumFbo)
{
Handle(OpenGl_Context) aCtx = myWorkspace->GetGlContext();
if (theReadDrawFbo != NULL)
glClear (toClear);
- render (theProjection, theReadDrawFbo, Standard_False);
+ render (theProjection, theReadDrawFbo, theOitAccumFbo, Standard_False);
}
// =======================================================================
// purpose :
// =======================================================================
bool OpenGl_View::redrawImmediate (const Graphic3d_Camera::Projection theProjection,
- OpenGl_FrameBuffer* theReadFbo,
- OpenGl_FrameBuffer* theDrawFbo,
- const Standard_Boolean theIsPartialUpdate)
+ OpenGl_FrameBuffer* theReadFbo,
+ OpenGl_FrameBuffer* theDrawFbo,
+ OpenGl_FrameBuffer* theOitAccumFbo,
+ const Standard_Boolean theIsPartialUpdate)
{
Handle(OpenGl_Context) aCtx = myWorkspace->GetGlContext();
GLboolean toCopyBackToFront = GL_FALSE;
glClearDepthf (1.0f);
#endif
- render (theProjection, theDrawFbo, Standard_True);
+ render (theProjection, theDrawFbo, theOitAccumFbo, Standard_True);
return !toCopyBackToFront;
}
//=======================================================================
void OpenGl_View::render (Graphic3d_Camera::Projection theProjection,
OpenGl_FrameBuffer* theOutputFBO,
+ OpenGl_FrameBuffer* theOitAccumFbo,
const Standard_Boolean theToDrawImmediate)
{
// ==================================
myWorkspace->SetEnvironmentTexture (myTextureEnv);
- renderScene (theProjection, theOutputFBO, theToDrawImmediate);
+ renderScene (theProjection, theOutputFBO, theOitAccumFbo, theToDrawImmediate);
myWorkspace->SetEnvironmentTexture (Handle(OpenGl_Texture)());
//=======================================================================
void OpenGl_View::renderStructs (Graphic3d_Camera::Projection theProjection,
OpenGl_FrameBuffer* theReadDrawFbo,
+ OpenGl_FrameBuffer* theOitAccumFbo,
const Standard_Boolean theToDrawImmediate)
{
if ( myZLayers.NbStructures() <= 0 )
if (aCtx->arbFBOBlit != NULL)
{
// Render bottom OSD layer
- myZLayers.Render (myWorkspace, theToDrawImmediate, OpenGl_LF_Bottom);
+ myZLayers.Render (myWorkspace, theToDrawImmediate, OpenGl_LF_Bottom, theReadDrawFbo, theOitAccumFbo);
myWorkspace->SetRenderFilter (myRaytraceFilter);
{
}
// Render non-polygonal elements in default layer
- myZLayers.Render (myWorkspace, theToDrawImmediate, OpenGl_LF_Default);
+ myZLayers.Render (myWorkspace, theToDrawImmediate, OpenGl_LF_Default, theReadDrawFbo, theOitAccumFbo);
}
myWorkspace->SetRenderFilter (myRaytraceFilter->PrevRenderFilter());
}
raytrace (aSizeX, aSizeY, theProjection, theReadDrawFbo, aCtx);
// Render upper (top and topmost) OpenGL layers
- myZLayers.Render (myWorkspace, theToDrawImmediate, OpenGl_LF_Upper);
+ myZLayers.Render (myWorkspace, theToDrawImmediate, OpenGl_LF_Upper, theReadDrawFbo, theOitAccumFbo);
}
}
// mode or in case of ray-tracing failure
if (toRenderGL)
{
- myZLayers.Render (myWorkspace, theToDrawImmediate, OpenGl_LF_All);
+ myZLayers.Render (myWorkspace, theToDrawImmediate, OpenGl_LF_All, theReadDrawFbo, theOitAccumFbo);
// Set flag that scene was redrawn by standard pipeline
myWasRedrawnGL = Standard_True;
//=======================================================================
void OpenGl_View::renderScene (Graphic3d_Camera::Projection theProjection,
OpenGl_FrameBuffer* theReadDrawFbo,
+ OpenGl_FrameBuffer* theOitAccumFbo,
const Standard_Boolean theToDrawImmediate)
{
const Handle(OpenGl_Context)& aContext = myWorkspace->GetGlContext();
aContext->ShaderManager()->UpdateClippingState();
}
- renderStructs (theProjection, theReadDrawFbo, theToDrawImmediate);
+ renderStructs (theProjection, theReadDrawFbo, theOitAccumFbo, theToDrawImmediate);
myWorkspace->DisableTexture();
// Apply restored view matrix.
#endif
myIsImmediateDrawn = Standard_False;
}
+
+// =======================================================================
+// function : checkOitCompatibility
+// purpose :
+// =======================================================================
+Standard_Boolean OpenGl_View::checkOitCompatibility (const Handle(OpenGl_Context)& theGlContext,
+ const Standard_Boolean theMSAA)
+{
+ // determine if OIT is supported by current OpenGl context
+ Standard_Boolean& aToDisableOIT = theMSAA ? myToDisableMSAA : myToDisableOIT;
+ if (aToDisableOIT)
+ {
+ return Standard_False;
+ }
+
+ TCollection_ExtendedString aCompatibilityMsg;
+ if (!theGlContext->hasFloatBuffer
+ && !theGlContext->hasHalfFloatBuffer)
+ {
+ aCompatibilityMsg += "OpenGL context does not support floating-point RGBA color buffer format.\n";
+ }
+ if (theMSAA && !theGlContext->hasSampleVariables)
+ {
+ aCompatibilityMsg += "Current version of GLSL does not support built-in sample variables.\n";
+ }
+ if (!theGlContext->hasDrawBuffers)
+ {
+ aCompatibilityMsg += "OpenGL context does not support multiple draw buffers.\n";
+ }
+ if (aCompatibilityMsg.IsEmpty())
+ {
+ return Standard_True;
+ }
+
+ aCompatibilityMsg += " Blended order-independent transparency will not be available.\n";
+ theGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
+ GL_DEBUG_TYPE_ERROR,
+ 0,
+ GL_DEBUG_SEVERITY_HIGH,
+ aCompatibilityMsg);
+
+ aToDisableOIT = Standard_True;
+ return Standard_False;
+}
+
+// =======================================================================
+// function : chooseOitColorConfiguration
+// purpose :
+// =======================================================================
+bool OpenGl_View::chooseOitColorConfiguration (const Handle(OpenGl_Context)& theGlContext,
+ const Standard_Integer theConfigIndex,
+ OpenGl_ColorFormats& theFormats)
+{
+ theFormats.Clear();
+ switch (theConfigIndex)
+ {
+ case 0: // choose best applicable color format combination
+ {
+ theFormats.Append (theGlContext->hasHalfFloatBuffer ? GL_RGBA16F : GL_RGBA32F);
+ theFormats.Append (theGlContext->hasHalfFloatBuffer ? GL_R16F : GL_R32F);
+ return true;
+ }
+ case 1: // choose non-optimal applicable color format combination
+ {
+ theFormats.Append (theGlContext->hasHalfFloatBuffer ? GL_RGBA16F : GL_RGBA32F);
+ theFormats.Append (theGlContext->hasHalfFloatBuffer ? GL_RGBA16F : GL_RGBA32F);
+ return true;
+ }
+ }
+ return false; // color combination does not exist
+}
}
else
{
- myGlContext->SetShadingMaterial (myAspectFaceSet, myHighlightStyle, myUseDepthWrite);
+ myGlContext->SetShadingMaterial (myAspectFaceSet, myHighlightStyle);
}
if (myAspectFaceSet->Aspect()->ToMapTexture())
}
// =======================================================================
-// function : CanRender
+// function : ShouldRender
// purpose :
// =======================================================================
-Standard_Boolean OpenGl_RaytraceFilter::CanRender (const OpenGl_Element* theElement)
+Standard_Boolean OpenGl_RaytraceFilter::ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_Element* theElement)
{
Standard_Boolean aPrevFilterResult = Standard_True;
if (!myPrevRenderFilter.IsNull())
{
- aPrevFilterResult = myPrevRenderFilter->CanRender (theElement);
+ aPrevFilterResult = myPrevRenderFilter->ShouldRender (theWorkspace, theElement);
}
return aPrevFilterResult &&
!OpenGl_Raytrace::IsRaytracedElement (theElement);
//! Checks whether the element can be rendered or not.
//! @param theElement [in] the element to check.
//! @return True if element can be rendered.
- virtual Standard_Boolean CanRender (const OpenGl_Element* theElement) Standard_OVERRIDE;
+ virtual Standard_Boolean ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
+ const OpenGl_Element* theElement) Standard_OVERRIDE;
private:
THE_ATTRIBUTE vec4 occVertColor;
#elif (__VERSION__ >= 130)
out vec4 occFragColor;
+ #ifdef OCC_ENABLE_draw_buffers
+ out vec4 occFragCoverage;
+ #endif
#else
- #define occFragColor gl_FragColor
+ #ifdef OCC_ENABLE_draw_buffers
+ #define occFragColor gl_FragData[0]
+ #define occFragCoverage gl_FragData[1]
+ #else
+ #define occFragColor gl_FragColor
+ #endif
#endif
// Matrix state
uniform vec4 occTexTrsf2d[2]; //!< 2D texture transformation parameters
uniform float occPointSize; //!< point size
+//! Parameters of blended order-independent transparency rendering algorithm
+uniform int occOitOutput; //!< Enable bit for writing output color buffers for OIT (occFragColor, occFragCoverage)
+uniform float occOitDepthFactor; //!< Influence of the depth component to the coverage of the accumulated fragment
+
//! Parameters of clipping planes
uniform vec4 occClipPlaneEquations[THE_MAX_CLIP_PLANES];
uniform THE_PREC_ENUM int occClipPlaneCount; //!< Total number of clip planes
vec4 aMaterialDiffuse = gl_FrontFacing ? occFrontMaterial_Diffuse() : occBackMaterial_Diffuse();
vec4 aMaterialSpecular = gl_FrontFacing ? occFrontMaterial_Specular() : occBackMaterial_Specular();
vec4 aMaterialEmission = gl_FrontFacing ? occFrontMaterial_Emission() : occBackMaterial_Emission();
- return vec4 (Ambient, 1.0) * aMaterialAmbient
- + vec4 (Diffuse, 1.0) * aMaterialDiffuse
- + vec4 (Specular, 1.0) * aMaterialSpecular
- + aMaterialEmission;
+ vec3 aColor = Ambient * aMaterialAmbient.rgb
+ + Diffuse * aMaterialDiffuse.rgb
+ + Specular * aMaterialSpecular.rgb
+ + aMaterialEmission.rgb;
+ return vec4 (aColor, aMaterialDiffuse.a);
}
//! Entry point to the Fragment Shader
}
}
- gl_FragColor = computeLighting (normalize (Normal),
+ occFragColor = computeLighting (normalize (Normal),
normalize (View),
Position);
+
+ if (occOitOutput != 0)
+ {
+ float aWeight = occFragColor.a * clamp (1e+2 * pow (1.0 - gl_FragCoord.z * occOitDepthFactor, 3.0), 1e-2, 1e+2);
+ occFragCoverage.r = occFragColor.a * aWeight;
+ occFragColor = vec4 (occFragColor.rgb * occFragColor.a * aWeight, occFragColor.a);
+ }
}
" THE_ATTRIBUTE vec4 occVertColor;\n"
"#elif (__VERSION__ >= 130)\n"
" out vec4 occFragColor;\n"
+ " #ifdef OCC_ENABLE_draw_buffers\n"
+ " out vec4 occFragCoverage;\n"
+ " #endif\n"
"#else\n"
- " #define occFragColor gl_FragColor\n"
+ " #ifdef OCC_ENABLE_draw_buffers\n"
+ " #define occFragColor gl_FragData[0]\n"
+ " #define occFragCoverage gl_FragData[1]\n"
+ " #else\n"
+ " #define occFragColor gl_FragColor\n"
+ " #endif\n"
"#endif\n"
"\n"
"// Matrix state\n"
"uniform vec4 occTexTrsf2d[2]; //!< 2D texture transformation parameters\n"
"uniform float occPointSize; //!< point size\n"
"\n"
+ "//! Parameters of blended order-independent transparency rendering algorithm\n"
+ "uniform int occOitOutput; //!< Enable bit for writing output color buffers for OIT (occFragColor, occFragCoverage)\n"
+ "uniform float occOitDepthFactor; //!< Influence of the depth component to the coverage of the accumulated fragment\n"
+ "\n"
"//! Parameters of clipping planes\n"
"uniform vec4 occClipPlaneEquations[THE_MAX_CLIP_PLANES];\n"
"uniform THE_PREC_ENUM int occClipPlaneCount; //!< Total number of clip planes\n";
case Graphic3d_RM_RAYTRACING: theDI << "raytrace "; break;
}
theDI << "\n";
+ theDI << "transparency: ";
+ switch (aParams.TransparencyMethod)
+ {
+ case Graphic3d_RTM_BLEND_UNORDERED: theDI << "Basic blended transparency with non-commuting operator "; break;
+ case Graphic3d_RTM_BLEND_OIT: theDI << "Weighted Blended Order-Independent Transparency, depth weight factor: "
+ << TCollection_AsciiString (aParams.OitDepthFactor); break;
+ }
+ theDI << "\n";
theDI << "msaa: " << aParams.NbMsaaSamples << "\n";
theDI << "rendScale: " << aParams.RenderResolutionScale << "\n";
theDI << "rayDepth: " << aParams.RaytracingDepth << "\n";
aParams.NbMsaaSamples = aNbSamples;
}
}
+ else if (aFlag == "-oit")
+ {
+ if (toPrint)
+ {
+ if (aParams.TransparencyMethod == Graphic3d_RTM_BLEND_OIT)
+ {
+ theDI << "on, depth weight factor: " << TCollection_AsciiString (aParams.OitDepthFactor) << " ";
+ }
+ else
+ {
+ theDI << "off" << " ";
+ }
+ continue;
+ }
+ else if (++anArgIter >= theArgNb)
+ {
+ std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ return 1;
+ }
+
+ TCollection_AsciiString aParam = theArgVec[anArgIter];
+ aParam.LowerCase();
+ if (aParam.IsRealValue())
+ {
+ const Standard_ShortReal aWeight = (Standard_ShortReal) Draw::Atof (theArgVec[anArgIter]);
+ if (aWeight < 0.f || aWeight > 1.f)
+ {
+ std::cerr << "Error: invalid value of Weighted Order-Independent Transparency depth weight factor " << aWeight << ". Should be within range [0.0; 1.0]\n";
+ return 1;
+ }
+
+ aParams.TransparencyMethod = Graphic3d_RTM_BLEND_OIT;
+ aParams.OitDepthFactor = aWeight;
+ }
+ else if (aParam == "off")
+ {
+ aParams.TransparencyMethod = Graphic3d_RTM_BLEND_UNORDERED;
+ }
+ else
+ {
+ std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+ return 1;
+ }
+ }
else if (aFlag == "-rendscale"
|| aFlag == "-renderscale"
|| aFlag == "-renderresolutionscale")
__FILE__, VRenderParams, group);
theCommands.Add("vrenderparams",
"\n Manages rendering parameters: "
- "\n '-raster' Disables GPU ray-tracing"
- "\n '-msaa 0..4' Specifies number of samples for MSAA"
- "\n '-rendScale value Rendering resolution scale factor"
- "\n '-rayTrace' Enables GPU ray-tracing"
- "\n '-rayDepth 0..10' Defines maximum ray-tracing depth"
- "\n '-shadows on|off' Enables/disables shadows rendering"
- "\n '-reflections on|off' Enables/disables specular reflections"
- "\n '-fsaa on|off' Enables/disables adaptive anti-aliasing"
- "\n '-gleam on|off' Enables/disables transparency shadow effects"
- "\n '-gi on|off' Enables/disables global illumination effects"
- "\n '-brng on|off' Enables/disables blocked RNG (fast coherent PT)"
- "\n '-env on|off' Enables/disables environment map background"
- "\n '-twoside on|off' Enables/disables two-sided BSDF models (PT mode)"
- "\n '-iss on|off' Enables/disables adaptive screen sampling (PT mode)"
- "\n '-issd on|off' Shows screen sampling distribution in ISS mode"
- "\n '-maxrad > 0.0' Value used for clamping radiance estimation (PT mode)"
- "\n '-nbtiles 64..1024' Specifies number of screen tiles in ISS mode"
- "\n '-rebuildGlsl on|off' Rebuild Ray-Tracing GLSL programs (for debugging)"
- "\n '-shadingModel model' Controls shading model from enumeration"
- "\n color, flat, gouraud, phong"
- "\n '-resolution value' Sets a new pixels density (PPI), defines scaling factor for parameters like text size"
+ "\n '-raster' Disables GPU ray-tracing"
+ "\n '-msaa 0..4' Specifies number of samples for MSAA"
+ "\n '-oit off|0.0-1.0' Enables/disables OIT and sets depth weight factor"
+ "\n '-rendScale value Rendering resolution scale factor"
+ "\n '-rayTrace' Enables GPU ray-tracing"
+ "\n '-rayDepth 0..10' Defines maximum ray-tracing depth"
+ "\n '-shadows on|off' Enables/disables shadows rendering"
+ "\n '-reflections on|off' Enables/disables specular reflections"
+ "\n '-fsaa on|off' Enables/disables adaptive anti-aliasing"
+ "\n '-gleam on|off' Enables/disables transparency shadow effects"
+ "\n '-gi on|off' Enables/disables global illumination effects"
+ "\n '-brng on|off' Enables/disables blocked RNG (fast coherent PT)"
+ "\n '-env on|off' Enables/disables environment map background"
+ "\n '-twoside on|off' Enables/disables two-sided BSDF models (PT mode)"
+ "\n '-iss on|off' Enables/disables adaptive screen sampling (PT mode)"
+ "\n '-issd on|off' Shows screen sampling distribution in ISS mode"
+ "\n '-maxrad > 0.0' Value used for clamping radiance estimation (PT mode)"
+ "\n '-nbtiles 64..1024' Specifies number of screen tiles in ISS mode"
+ "\n '-rebuildGlsl on|off' Rebuild Ray-Tracing GLSL programs (for debugging)"
+ "\n '-shadingModel model' Controls shading model from enumeration"
+ "\n color, flat, gouraud, phong"
+ "\n '-resolution value' Sets a new pixels density (PPI), defines scaling factor for parameters like text size"
"\n Unlike vcaps, these parameters dramatically change visual properties."
"\n Command is intended to control presentation quality depending on"
"\n hardware capabilities and performance.",
019 manipulator
020 anim
021 dimensions
+022 transparency
--- /dev/null
+set subgroup "transparency"
+vinit View1
\ No newline at end of file
--- /dev/null
+puts "========"
+puts "Transparency - check different blend operators"
+puts "========"
+
+# custom shapes
+set aShape1 [locate_data_file occ/Top.brep]
+set aShape2 [locate_data_file occ/Bottom.brep]
+
+vinit View1
+vsetdispmode 1
+vsetgradientbg 180 180 180 255 255 255 2
+restore $aShape1 s1
+restore $aShape2 s2
+vdisplay s1
+vdisplay s2
+vsettransparency s1 0.5
+vsettransparency s2 0.5
+
+# check blending artifacts
+vviewparams -scale 4.519 -at 93.051 -88.513 17.789 -eye -156.923 -151.929 6.147 -up -0.246 0.969 0.002
+
+vrenderparams -oit off
+vdump $imagedir/${casename}_blend_artifacts_unordered.png
+
+vrenderparams -oit 1.0
+vdump $imagedir/${casename}_blend_artifacts_oit.png
+
+# check depth occlusion
+vsetcolor s1 red
+vsetcolor s2 black
+
+vviewparams -scale 5.807 -at -59.913 -276.799 -4.312 -eye -69.465 -20.350 23.739 -up 0.999 0.038 -0.009
+
+vrenderparams -oit off
+vdump $imagedir/${casename}_occlusion_unordered.png
+
+vrenderparams -oit 0.0
+vdump $imagedir/${casename}_occlusion_oit_nodepth.png
+
+vrenderparams -oit 1.0
+vdump $imagedir/${casename}_occlusion_oit.png
--- /dev/null
+puts "========"
+puts "Transparency - shading highlight"
+puts "========"
+
+psphere s 1
+vinit View1
+vdisplay -dispMode 1 s
+vfit
+vsettransparency s 0.5
+vrenderparams -oit 0
+vselprops dynHighlight -dispMode -1
+vmoveto 250 250
+checkcolor 250 250 0 1 1
+if { $stat != 1 } {
+ puts "Error : Highlighting is broken."
+}
projects / occt.git / commitdiff