| genericstate_p.h |
|
2138 |
- |
| qalphacoverage.cpp |
!
\class Qt3DRender::QAlphaCoverage
\since 5.7
\ingroup renderstates
\inmodule Qt3DRender
\brief Enable alpha-to-coverage multisampling mode.
A Qt3DRender::QAlphaCoverage class enables alpha-to-coverage multisampling mode.
When enabled, the fragment alpha value is used as a coverage for the sample
and combined with fragment coverage value. Qt3DRender::QAlphaCoverage does
nothing if multisampling is disabled. Alpha-to-coverage is most useful when
order independent blending is required, for example when rendering leaves,
grass and other rich vegetation.
It can be added to a QRenderPass by calling QRenderPass::addRenderState():
\code
QRenderPass *renderPass = new QRenderPass();
// Create a alpha coverage render state
QAlphaCoverage *alphaCoverage = new QAlphaCoverage();
QMultiSampleAntiAliasing *multiSampleAntialiasing = new QMultiSampleAntiAliasing();
// Add the render states to the render pass
renderPass->addRenderState(alphaCoverage);
renderPass->addRenderState(multiSampleAntialiasing);
\endcode
Or to a QRenderStateSet by calling QRenderStateSet::addRenderState():
\code
QRenderStateSet *renderStateSet = new QRenderStateSet();
// Create a alpha coverage render state
QAlphaCoverage *alphaCoverage = new QAlphaCoverage();
QMultiSampleAntiAliasing *multiSampleAntialiasing = new QMultiSampleAntiAliasing();
// Add the render states to the render state set
renderStateSet->addRenderState(alphaCoverage);
renderStateSet->addRenderState(multiSampleAntialiasing);
\endcode
\sa Qt3DRender::QMultiSampleAntiAliasing
|
3681 |
- |
| qalphacoverage.h |
|
729 |
- |
| qalphatest.cpp |
!
\class Qt3DRender::QAlphaTest
\brief The QAlphaTest class specify alpha reference test.
\since 5.7
\inmodule Qt3DRender
\ingroup renderstates
As the OpenGL documentation explains; The alpha test discards a fragment
conditional on the outcome of a comparison between the incoming fragment's
alpha value and a constant reference value.
|
3696 |
- |
| qalphatest.h |
|
1535 |
- |
| qalphatest_p.h |
|
1132 |
- |
| qblendequation.cpp |
!
\class Qt3DRender::QBlendEquation
\inheaderfile Qt3DRender/QBlendEquation
\brief The QBlendEquation class specifies the equation used for both the RGB
blend equation and the Alpha blend equation.
\inmodule Qt3DRender
\since 5.7
\ingroup renderstates
The blend equation is used to determine how a new pixel is combined with a pixel
already in the framebuffer.
|
2389 |
- |
| qblendequation.h |
|
1238 |
- |
| qblendequation_p.h |
|
1172 |
- |
| qblendequationarguments.cpp |
!
\class Qt3DRender::QBlendEquationArguments
\inmodule Qt3DRender
\since 5.5
\brief Encapsulates blending information: specifies how the incoming values (what's going to be drawn)
are going to affect the existing values (what is already drawn).
OpenGL pre-3.0: Set the same blend state for all draw buffers
(one QBlendEquationArguments)
OpenGL 3.0-pre4.0: Set the same blend state for all draw buffers,
but can disable blending for particular buffers
(one QBlendEquationArguments for setting glBlendFunc, n QBlendEquationArgumentss
for enabling/disabling Draw Buffers)
OpenGL 4.0+: Can set blend state individually for each draw buffer.
|
7667 |
- |
| qblendequationarguments.h |
|
3219 |
- |
| qblendequationarguments_p.h |
|
1592 |
- |
| qclipplane.cpp |
!
\class Qt3DRender::QClipPlane
\inmodule Qt3DRender
\since 5.5
\brief Enables an additional OpenGL clipping plane that can be in shaders
using gl_ClipDistance.
By default, OpenGL supports up to 8 additional clipping planes.
Qt3DCore::QClipPlane allows to enable one of these additional planes. These
planes can then be manipulated in the shaders using gl_ClipDistance[i]
where i varies between 0 and 7. The underlying implementation may support more
than 8 clip planes, but it is not guaranteed.
|
3103 |
- |
| qclipplane.h |
|
1249 |
- |
| qclipplane_p.h |
|
1068 |
- |
| qcolormask.cpp |
!
\class Qt3DRender::QColorMask
\inmodule Qt3DRender
\since 5.7
\brief Allows specifying which color components should be written to the
currently bound frame buffer.
By default, the property for each color component (red, green, blue, alpha)
is set to \c true which means they will be written to the frame buffer.
Setting any of the color component to \c false will prevent it from being
written into the frame buffer.
|
3835 |
- |
| qcolormask.h |
|
1515 |
- |
| qcolormask_p.h |
|
1136 |
- |
| qcullface.cpp |
!
\class Qt3DRender::QCullFace
\brief The QCullFace class specifies whether front or back face culling
is enabled.
\since 5.7
\inmodule Qt3DRender
\ingroup renderstates
QCullFace sets whether the front or back facets are culled.
Facets include triangles, quadrilaterals, polygons and rectangles.
It can be added by calling the addRenderState() method on a QRenderPass:
\code
// using namespace Qt3DRender;
QRenderPass *renderPass = new QRenderPass();
// Create a front face culling render state
QCullFace *cullFront = new QCullFace();
cullFront->setMode(QCullFace::Front);
// Add the render state to the render pass
renderPass->addRenderState(cullFront);
\endcode
Or by calling the addRenderState() method on a QRenderStateSet:
\code
// using namespace Qt3DRender;
QRenderStateSet *renderStateSet = new QRenderStateSet();
// Create a front face culling render state
QCullFace *cullFront = new QCullFace();
cullFront->setMode(QCullFace::Front);
// Add the render state to the render pass
renderStateSet->addRenderState(cullFront);
\endcode
\sa QFrontFace
|
3939 |
- |
| qcullface.h |
|
1083 |
- |
| qcullface_p.h |
|
1030 |
- |
| qdepthrange.cpp |
!
\class Qt3DRender::QDepthRange
\inmodule Qt3DRender
\since 5.14
\ingroup renderstates
\brief Enables remapping depth values written into the depth buffer.
By default, OpenGL writes scene depth information into the depth buffer in
the range [0.0, 1.0] with 0.0 corresponding to the near clip plane and 1.0 to
the far clip plane. QDepthRange allows mapping these values into a different
range so parts of the scene are always rendered in front of or behind other
parts. Valid values for near and far are between 0 and 1.
|
3034 |
- |
| qdepthrange.h |
|
1092 |
- |
| qdepthrange_p.h |
|
1034 |
- |
| qdepthtest.cpp |
!
\class Qt3DRender::QDepthTest
\brief The QDepthTest class tests the fragment shader's depth value against
the depth of a sample being written to.
\since 5.7
\inmodule Qt3DRender
\ingroup renderstates
A QDepthTest class is used to enable depth testing with a given depth test function.
The depth test enables writing fragment color values when the depth test passes, and
reject fragments which fail the test. The depth test uses the depth function to
test the fragments depth value to the value against z-buffer. If the underlying surface
does not have z-buffer, then QDepthTest does nothing.
\sa QAlphaTest, QStencilTest
|
3697 |
- |
| qdepthtest.h |
|
1287 |
- |
| qdepthtest_p.h |
|
1062 |
- |
| qdithering.cpp |
!
\class Qt3DRender::QDithering
\since 5.7
\inmodule Qt3DRender
\brief Enable dithering.
A Qt3DRender::QDithering class enables dithering. Dithering adds noise to the
color values to randomize quantization error in order to prevent large scale
patterns in the final image, such as banding. Dithering is most useful when
rendering to a surface with low color bit depth, such as RGB565 or RGBA4444.
|
1791 |
- |
| qdithering.h |
|
697 |
- |
| qfrontface.cpp |
!
\class Qt3DRender::QFrontFace
\brief The QFrontFace class defines front and back facing polygons.
\since 5.7
\ingroup renderstates
\inmodule Qt3DRender
A Qt3DRender::QFrontFace sets the winding direction of the front facing polygons.
\sa QCullFace
|
2148 |
- |
| qfrontface.h |
|
1124 |
- |
| qfrontface_p.h |
|
1060 |
- |
| qlinewidth.cpp |
!
\class Qt3DRender::QLineWidth
\inmodule Qt3DRender
\since 5.10
\brief Specifies the width of rasterized lines.
|
1669 |
- |
| qlinewidth.h |
|
996 |
- |
| qlinewidth_p.h |
|
976 |
- |
| qmultisampleantialiasing.cpp |
!
\class Qt3DRender::QMultiSampleAntiAliasing
\brief Enable multisample antialiasing.
\since 5.7
\ingroup renderstates
\inmodule Qt3DRender
A Qt3DRender::QMultiSampleAntiAliasing class enables multisample antialiasing.
It can be added to a QRenderPass by calling QRenderPass::addRenderState():
\code
QRenderPass *renderPass = new QRenderPass();
QMultiSampleAntiAliasing *msaa = new QMultiSampleAntiAliasing();
renderPass->addRenderState(msaa);
\endcode
Or a QRenderStateSet by calling QRenderStateSet::addRenderState():
\code
QRenderStateSet *renderStateSet = new QRenderStateSet();
QMultiSampleAntiAliasing *msaa = new QMultiSampleAntiAliasing();
renderStateSet->addRenderState(msaa);
\endcode
For multisampling to take effect, the render target must have been allocated
with multisampling enabled:
\code
QTexture2DMultisample *colorTex = new QTexture2DMultisample;
colorTex->setFormat(QAbstractTexture::RGBA8_UNorm);
colorTex->setWidth(1024);
colorTex->setHeight(1024);
QRenderTargetOutput *color = new QRenderTargetOutput;
color->setAttachmentPoint(QRenderTargetOutput::Color0);
color->setTexture(colorTex);
QTexture2DMultisample *depthStencilTex = new QTexture2DMultisample;
depthStencilTex->setFormat(QAbstractTexture::RGBA8_UNorm);
depthStencilTex->setWidth(1024);
depthStencilTex->setHeight(1024);
QRenderTargetOutput *depthStencil = new QRenderTargetOutput;
depthStencil->setAttachmentPoint(QRenderTargetOutput::DepthStencil);
depthStencil->setTexture(depthStencilTex);
Qt3DRender::QRenderTarget *renderTarget = new Qt3DRender::QRenderTarget;
renderTarget->addOutput(color);
renderTarget->addOutput(depthStencil);
\endcode
\include code/src_render_renderstates_qmultisampleantialiasing.qdocinc
\note When using OpenGL as the graphics API, glEnable(GL_MULTISAMPLE) will be called if
QMultiSampleAntiAliasing has been added to the render states.
|
4810 |
- |
| qmultisampleantialiasing.h |
|
740 |
- |
| qnodepthmask.cpp |
!
\class Qt3DRender::QNoDepthMask
\brief Disable depth write.
\since 5.7
\ingroup renderstates
\inmodule Qt3DRender
A Qt3DRender::QNoDepthMask class disables fragment depth write to depth buffer.
\sa Qt3DRender::QDepthTest
|
1469 |
- |
| qnodepthmask.h |
|
714 |
- |
| qpointsize.cpp |
!
\class Qt3DRender::QPointSize
\inmodule Qt3DRender
\since 5.7
\brief Specifies the size of rasterized points. May either be set statically
or by shader programs.
When the sizeMode property is set to SizeMode::Fixed, the value is set
using glPointSize(), if available. When using SizeMode::Programmable,
gl_PointSize must be set within shader programs, the value provided to this
RenderState is ignored in that case.
|
2568 |
- |
| qpointsize.h |
|
1141 |
- |
| qpointsize_p.h |
|
1114 |
- |
| qpolygonoffset.cpp |
!
\class Qt3DRender::QPolygonOffset
\brief The QPolygonOffset class sets the scale and steps to calculate depth
values for polygon offsets.
\since 5.7
\inmodule Qt3DRender
\ingroup renderstates
A QPolygonOffset class adds an offset to the fragment depth value prior to
depth test and depth write. The offset can be used to avoid z-fighting when
rendering polygons with very close depth values such as decals.
|
2843 |
- |
| qpolygonoffset.h |
|
1123 |
- |
| qpolygonoffset_p.h |
|
1104 |
- |
| qrastermode.cpp |
!
\class Qt3DRender::QRasterMode
\brief The QRasterMode render state allows to control the type of
rasterization to be performed.
\since 5.14
\inmodule Qt3DRender
\ingroup renderstates
The QRasterMode class is used to control the rasterization step of the
primitives at render time. This can be used to choose whether we only
want to show points, edges or fill a primitive.
\note This is not supported when rendering on OpenGL ES 2.0 platforms.
\sa QAlphaTest, QStencilTest
|
3667 |
- |
| qrastermode.h |
|
1395 |
- |
| qrastermode_p.h |
|
1143 |
- |
| qrenderstate.cpp |
!
\class Qt3DRender::QRenderState
\brief An abstract base class for all render states.
\since 5.7
\ingroup renderstates
\inmodule Qt3DRender
A Qt3DRender::QRenderState class is abstract base class for all render states.
One can not instantiate QRenderState directly, but through its subclasses.
|
1712 |
- |
| qrenderstate.h |
|
786 |
- |
| qrenderstate_p.h |
|
1225 |
- |
| qscissortest.cpp |
!
\class Qt3DRender::QScissorTest
\brief The QScissorTest class discards fragments that fall outside of a
certain rectangular portion of the screen.
\since 5.7
\ingroup renderstates
\inmodule Qt3DRender
A QScissorTest class enables scissor test, which discards fragments outside
the rectangular area of the screen specified by the left, bottom, width and
height properties.
|
3369 |
- |
| qscissortest.h |
|
1390 |
- |
| qscissortest_p.h |
|
1135 |
- |
| qseamlesscubemap.cpp |
!
\class Qt3DRender::QSeamlessCubemap
\brief Enables seamless cubemap texture filtering.
\since 5.7
\inmodule Qt3DRender
When present in a state set, enables the seamless cubemap texture filtering
as provided by the GL_ARB_seamless_cubemap extension (if available).
|
1543 |
- |
| qseamlesscubemap.h |
|
676 |
- |
| qstencilmask.cpp |
!
\class Qt3DRender::QStencilMask
\brief The QStencilMask class controls the front and back writing of
individual bits in the stencil planes.
\since 5.7
\ingroup renderstates
\inmodule Qt3DRender
A Qt3DRender::QStencilMask class specifies a write mask for the stencil values
after the stencil test. Mask can be specified separately for the front-facing
and back-facing polygons. The fragment stencil value is and'd with the mask
before it is written to the stencil buffer.
\sa Qt3DRender::QStencilTest
|
2912 |
- |
| qstencilmask.h |
|
1145 |
- |
| qstencilmask_p.h |
|
1062 |
- |
| qstenciloperation.cpp |
!
\class Qt3DRender::QStencilOperation
\brief The QStencilOperation class specifies stencil operation.
\since 5.7
\ingroup renderstates
\inmodule Qt3DRender
A Qt3DRender::QStencilOperation class specifies the stencil operations
for the front- and back-facing polygons. The stencil operation control
what is done to fragment when the stencil and depth test pass or fail.
\sa Qt3DRender::QStencilTest
|
4030 |
- |
| qstenciloperation.h |
|
991 |
- |
| qstenciloperation_p.h |
|
1604 |
- |
| qstenciloperationarguments.cpp |
!
\class Qt3DRender::QStencilOperationArguments
\brief The QStencilOperationArguments class sets the actions to be taken
when stencil and depth tests fail.
\since 5.7
\ingroup renderstates
\inmodule Qt3DRender
The Qt3DRender::QStencilOperationArguments class specifies the arguments for
the stencil operations.
\sa Qt3DRender::QStencilOperation
|
6712 |
- |
| qstenciloperationarguments.h |
|
2463 |
- |
| qstenciloperationarguments_p.h |
|
1864 |
- |
| qstenciltest.cpp |
!
\class Qt3DRender::QStencilTest
\since 5.7
\ingroup renderstates
\inmodule Qt3DRender
\brief The QStencilTest class specifies arguments for the stecil test.
A Qt3DRender::QStencilTest class specifies argument for the stencil test.
The stencil test comprises of three arguments: stencil test function,
stencil test mask and stencil reference value. QStencilTest allows these
arguments to be set for both front- and back-facing polygons separately.
\sa Qt3DRender::QStencilMask, Qt3DRender::QStencilOperation
|
3871 |
- |
| qstenciltest.h |
|
996 |
- |
| qstenciltest_p.h |
|
1509 |
- |
| qstenciltestarguments.cpp |
!
\class Qt3DRender::QStencilTestArguments
\brief The QStencilTestArguments class specifies arguments for stencil test.
\since 5.7
\ingroup renderstates
\inmodule Qt3DRender
The Qt3DRender::QStencilTestArguments class specifies the arguments for
the stencil test.
|
5511 |
- |
| qstenciltestarguments.h |
|
2236 |
- |
| qstenciltestarguments_p.h |
|
1548 |
- |
| renderstatenode.cpp |
|
8894 |
- |
| renderstatenode_p.h |
|
1206 |
- |
| renderstates.cpp |
|
6523 |
- |
| renderstates_p.h |
|
4917 |
- |
| renderstateset.cpp |
|
2803 |
- |
| renderstateset_p.h |
@brief changeCost - metric of cost to change to this state-set from
a candidate previous state-set. This is used to find an optimal
ordering of state-sets when sending draw commands.
@param previousState
@return
|
2264 |
- |
| statemask_p.h |
|
1592 |
- |
| statevariant.cpp |
|
2128 |
- |
| statevariant_p.h |
|
2967 |
- |