Update docs for render states

Change-Id: I40379d4b20baf79657926a1cef5b29e83579b46c
Reviewed-by: Tomi Korpipää <tomi.korpipaa@qt.io>
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

11 files changed, 436 insertions, 117 deletions

diff --git a/src/render/renderstates/qalphatest.cpp b/src/render/renderstates/qalphatest.cpp
index 2341c1039..81227d499 100644
--- a/src/render/renderstates/qalphatest.cpp
+++ b/src/render/renderstates/qalphatest.cpp
@@ -38,17 +38,6 @@
 **
 ****************************************************************************/
 
-/*!
- * \class QAlphaTest
- * \brief The QAlphaTest class is an OpenGL helper.
- * \since 5.7
- * \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 value.
- */
-
 #include "qalphatest.h"
 #include "qalphatest_p.h"
 #include <Qt3DRender/private/qrenderstatecreatedchange_p.h>
@@ -57,6 +46,80 @@ QT_BEGIN_NAMESPACE
 
 namespace Qt3DRender {
 
+/*!
+    \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.
+ */
+
+/*!
+    \qmltype AlphaTest
+    \brief The AlphaTest class specify alpha reference test
+    \since 5.7
+    \inqmlmodule Qt3D.Render
+    \inherits RenderState
+    \instantiates Qt3DRender::QAlphaTest
+    \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.
+ */
+
+/*!
+    \enum Qt3DRender::QAlphaTest::AlphaFunction
+
+    Enumeration for the alpha function values
+    \value Never Never pass alpha test
+    \value Always Always pass alpha test
+    \value Less Pass alpha test if fragment alpha is less than reference value
+    \value LessOrEqual Pass alpha test if fragment alpha is less than or equal to reference value
+    \value Equal Pass alpha test if fragment alpha is equal to reference value
+    \value GreaterOrEqual Pass alpha test if fragment alpha is greater than or equal to reference value
+    \value Greater Pass alpha test if fragment alpha is greater than reference value
+    \value NotEqual Pass alpha test if fragment alpha is not equal to reference value
+*/
+
+/*!
+    \qmlproperty enumeration AlphaTest::alphaFunction
+    Holds the alpha function used by the alpha test. Default is AlphaTest.Never.
+    \list
+    \li AlphaTest.Never
+    \li AlphaTest.Always
+    \li AlphaTest.Less
+    \li AlphaTest.LessOrEqual
+    \li AlphaTest.Equal
+    \li AlphaTest.GreaterOrEqual
+    \li AlphaTest.Greater
+    \li AlphaTest.NotEqual
+    \endlist
+    \sa Qt3DRender::QAlphaTest::AlphaFunction
+*/
+
+/*!
+    \qmlproperty real AlphaTest::referenceValue
+    Holds the reference value used by the alpha test. Default is 0.0.
+    When set, the value is clamped between 0 and 1.
+*/
+
+/*!
+    \property QAlphaTest::alphaFunction
+    Holds the alpha function used by the alpha test. Default is Never.
+*/
+
+/*!
+    \property QAlphaTest::referenceValue
+    Holds the reference value used by the alpha test. Default is 0.0.
+    When set, the value is clamped between 0 and 1.
+*/
+
+
 QAlphaTest::QAlphaTest(QNode *parent)
     : QRenderState(*new QAlphaTestPrivate, parent)
 {
@@ -67,19 +130,12 @@ QAlphaTest::~QAlphaTest()
 {
 }
 
-/*!
- * \return the current alpha test function.
- */
 QAlphaTest::AlphaFunction QAlphaTest::alphaFunction() const
 {
     Q_D(const QAlphaTest);
     return d->m_alphaFunction;
 }
 
-/*!
- * Sets the alpha test function to \a alphaFunction.
- * \param alphaFunction
- */
 void QAlphaTest::setAlphaFunction(QAlphaTest::AlphaFunction alphaFunction)
 {
     Q_D(QAlphaTest);
@@ -89,18 +145,12 @@ void QAlphaTest::setAlphaFunction(QAlphaTest::AlphaFunction alphaFunction)
     }
 }
 
-/*!
- * \return a float value between 0 and 1.
- */
 float QAlphaTest::referenceValue() const
 {
     Q_D(const QAlphaTest);
     return d->m_referenceValue;
 }
 
-/*!
- * Sets the reference value which is clamped between 0 and 1 to \a referenceValue.
- */
 void QAlphaTest::setReferenceValue(float referenceValue)
 {
     Q_D(QAlphaTest);
diff --git a/src/render/renderstates/qclipplane.cpp b/src/render/renderstates/qclipplane.cpp
index f117d040a..19053c147 100644
--- a/src/render/renderstates/qclipplane.cpp
+++ b/src/render/renderstates/qclipplane.cpp
@@ -55,7 +55,8 @@ namespace Qt3DRender {
     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 8.
+    where i varies between 0 and 7. The underlying implementation may support more
+    than 8 clip planes, but it is not guaranteed.
  */
 
 /*!
@@ -70,9 +71,44 @@ namespace Qt3DRender {
     By default, OpenGL supports up to 8 additional clipping planes. ClipPlane
     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 8.
+    0 and 7. The underlying implementation may support more than 8 clip planes,
+    but it is not guaranteed.
 */
 
+/*!
+    \qmlproperty int ClipPlane::planeIndex
+    Holds the index of the plane.
+    \note Usually between 0-7.
+*/
+
+/*!
+    \qmlproperty vector3d ClipPlane::normal
+    Holds the normal of the plane.
+*/
+
+/*!
+    \qmlproperty real ClipPlane::distance
+    Holds the distance of the plane from the world origin.
+*/
+
+
+/*!
+    \property QClipPlane::planeIndex
+    Holds the index of the plane.
+    \note Usually between 0-7.
+*/
+
+/*!
+    \property QClipPlane::normal
+    Holds the normal of the plane.
+*/
+
+/*!
+    \property QClipPlane::distance
+    Holds the distance of the plane from the world origin.
+*/
+
+
 QClipPlane::QClipPlane(QNode *parent)
     : QRenderState(*new QClipPlanePrivate(), parent)
 {
@@ -83,10 +119,6 @@ QClipPlane::~QClipPlane()
 {
 }
 
-/*!
- * Returns the index of the clip plane.
- * \note usually between 0-7
- */
 int QClipPlane::planeIndex() const
 {
     Q_D(const QClipPlane);
@@ -105,10 +137,6 @@ float QClipPlane::distance() const
     return d->m_distance;
 }
 
-/*!
- * Sets the index of the clip plane to \a plane.
- * \note above 7, support is not garanteed
- */
 void QClipPlane::setPlaneIndex(int planeIndex)
 {
     Q_D(QClipPlane);
diff --git a/src/render/renderstates/qcolormask.cpp b/src/render/renderstates/qcolormask.cpp
index 71819db94..fde09d7b0 100644
--- a/src/render/renderstates/qcolormask.cpp
+++ b/src/render/renderstates/qcolormask.cpp
@@ -48,7 +48,22 @@ namespace Qt3DRender {
 /*!
     \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.
+ */
+
+/*!
+    \qmltype ColorMask
+    \inqmlmodule Qt3D.Render
+    \since 5.7
+    \inherits RenderState
+    \instantiates Qt3DRender::QColorMask
     \brief Allows specifying which color components should be written to the
     currently bound frame buffer.
 
@@ -58,6 +73,26 @@ namespace Qt3DRender {
     written into the frame buffer.
  */
 
+/*!
+    \qmlproperty bool ColorMask::redMasked
+    Holds whether red color component should be written to the frame buffer.
+*/
+
+/*!
+    \qmlproperty bool ColorMask::greenMasked
+    Holds whether green color component should be written to the frame buffer.
+*/
+
+/*!
+    \qmlproperty bool ColorMask::blueMasked
+    Holds whether blue color component should be written to the frame buffer.
+*/
+
+/*!
+    \qmlproperty bool ColorMask::alphaMasked
+    Holds whether alpha component should be written to the frame buffer.
+*/
+
 
 /*!
     Constructs a new Qt3DCore::QColorMask instance with \a parent as parent.
@@ -97,7 +132,7 @@ bool QColorMask::isAlphaMasked() const
 }
 
 /*!
-    \property Qt3DRender::QColorMask::red
+    \property QColorMask::redMasked
     Holds whether the red color component should be written to the frame buffer.
  */
 void QColorMask::setRedMasked(bool redMasked)
@@ -110,7 +145,7 @@ void QColorMask::setRedMasked(bool redMasked)
 }
 
 /*!
-    \property Qt3DRender::QColorMask::green
+    \property QColorMask::greenMasked
     Holds whether the green color component should be written to the frame buffer.
  */
 void QColorMask::setGreenMasked(bool greenMasked)
@@ -123,7 +158,7 @@ void QColorMask::setGreenMasked(bool greenMasked)
 }
 
 /*!
-    \property Qt3DRender::QColorMask::blue
+    \property QColorMask::blueMasked
     Holds whether the blue color component should be written to the frame buffer.
  */
 void QColorMask::setBlueMasked(bool blueMasked)
@@ -136,7 +171,7 @@ void QColorMask::setBlueMasked(bool blueMasked)
 }
 
 /*!
-    \property Qt3DRender::QColorMask::alphaMasked
+    \property QColorMask::alphaMasked
     Holds whether the alphaMasked component should be written to the frame buffer.
  */
 void QColorMask::setAlphaMasked(bool alphaMasked)
diff --git a/src/render/renderstates/qcullface.cpp b/src/render/renderstates/qcullface.cpp
index 2b8a7f8e0..e96346287 100644
--- a/src/render/renderstates/qcullface.cpp
+++ b/src/render/renderstates/qcullface.cpp
@@ -38,18 +38,7 @@
 **
 ****************************************************************************/
 
-/*!
- * \class QCullFace
- * \brief The QCullFace class specifies whether front or back face culling
- * are enabled
- * \since 5.7
- * \ingroup renderstates
- *
- * QCullFace sets whether the front or back facets are culled.
- * Facets include triangles, quadrilaterals, polygons and rectangles.
- *
- * \sa QFrontFace
- */
+
 #include "qcullface.h"
 #include "qcullface_p.h"
 #include <Qt3DRender/private/qrenderstatecreatedchange_p.h>
@@ -59,7 +48,57 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DRender {
 
 /*!
- *  Constructs a new QCullFace::QCullFace instance with \a parent as parent.
+    \class Qt3DRender::QCullFace
+    \brief The QCullFace class specifies whether front or back face culling
+    are 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.
+
+    \sa QFrontFace
+ */
+
+/*!
+    \qmltype CullFace
+    \brief The CullFace type specifies whether front or back face culling
+    are enabled
+    \since 5.7
+    \inqmlmodule Qt3D.Render
+    \instantiates Qt3DRender::QCullFace
+    \inherits RenderState
+    \ingroup renderstates
+
+    CullFace sets whether the front or back facets are culled.
+    Facets include triangles, quadrilaterals, polygons and rectangles.
+
+    \sa FrontFace
+ */
+
+/*!
+    \enum Qt3DRender::QCullFace::CullingMode
+
+    This enumeration specifies values for the culling mode.
+    \value NoCulling culling is disabled
+    \value Front Culling is enabled for front facing polygons
+    \value Back Culling is enabled for back facing polygons
+    \value FrontAndBack Culling is enabled for all polygons, points and lines are drawn.
+*/
+
+/*!
+    \qmlproperty enumeration CullFace::mode
+    Holds the culling mode used by CullFace. Default is set to QCullFace.Back.
+*/
+
+/*!
+    \property QCullFace::mode
+    Holds the culling mode used by QCullFace. Default is set to QCullFace.Back.
+*/
+
+/*!
+     Constructs a new QCullFace::QCullFace instance with \a parent as parent.
  */
 QCullFace::QCullFace(QNode *parent)
     : QRenderState(*new QCullFacePrivate, parent)
@@ -71,19 +110,12 @@ QCullFace::~QCullFace()
 {
 }
 
-/*!
- * \return which culling mode is currently enabled.
- */
 QCullFace::CullingMode QCullFace::mode() const
 {
     Q_D(const QCullFace);
     return d->m_mode;
 }
 
-/*!
- * Sets which faces to cull to \a mode. Default is set to back.
- * \param mode
- */
 void QCullFace::setMode(QCullFace::CullingMode mode)
 {
     Q_D(QCullFace);
diff --git a/src/render/renderstates/qdepthtest.cpp b/src/render/renderstates/qdepthtest.cpp
index c2299f810..7e67ba5ba 100644
--- a/src/render/renderstates/qdepthtest.cpp
+++ b/src/render/renderstates/qdepthtest.cpp
@@ -38,14 +38,6 @@
 **
 ****************************************************************************/
 
-/*!
- * \class QDepthTest
- * \brief The QDepthTest class tests the fragment shader's depth value against
- * the depth of a sample being written to.
- * \since 5.7
- * \ingroup renderstates
- *
- */
 #include "qdepthtest.h"
 #include "qdepthtest_p.h"
 #include <Qt3DRender/private/qrenderstatecreatedchange_p.h>
@@ -55,7 +47,79 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DRender {
 
 /*!
- * The constructor creates a new QDepthTest::QDepthTest instance with the specified \a parent.
+    \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
+ */
+
+/*!
+    \qmltype DepthTest
+    \brief The DepthTest type tests the fragment shader's depth value against
+    the depth of a sample being written to.
+    \since 5.7
+    \inqmlmodule Qt3D.Render
+    \inherits RenderState
+    \instantiates Qt3DRender::QDepthTest
+    \ingroup renderstates
+
+    A DepthTest type 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, the DepthTest does nothing.
+
+    \sa AlphaTest, StencilTest
+ */
+
+/*!
+    \enum Qt3DRender::QDepthTest::DepthFunction
+
+    Enumeration for the depth function values
+    \value Never Never pass depth test
+    \value Always Always pass depth test
+    \value Less Pass depth test if fragment depth is less than z-buffer value
+    \value LessOrEqual Pass depth test if fragment depth is less than or equal to z-buffer value
+    \value Equal Pass depth test if fragment depth is equal to z-buffer value
+    \value GreaterOrEqual Pass depth test if fragment depth is greater than or equal to z-buffer value
+    \value Greater Pass depth test if fragment depth is greater than z-buffer value
+    \value NotEqual Pass depth test if fragment depth is not equal to z-buffer value
+*/
+
+/*!
+    \qmlproperty enumeration DepthTest::depthFunction
+    Holds the current function used by depth test. The default is DepthTest.Never.
+    \list
+    \li DepthTest.Never
+    \li DepthTest.Always
+    \li DepthTest.Less
+    \li DepthTest.LessOrEqual
+    \li DepthTest.Equal
+    \li DepthTest.GreaterOrEqual
+    \li DepthTest.Greater
+    \li DepthTest.NotEqual
+    \endlist
+    \sa Qt3DRender::QDepthTest::DepthFunction
+*/
+
+/*!
+    \property QDepthTest::depthFunction
+    Holds the current function used by depth test. The default is Never.
+*/
+
+
+/*!
+    The constructor creates a new QDepthTest::QDepthTest instance with the specified \a parent.
  */
 QDepthTest::QDepthTest(QNode *parent)
     : QRenderState(*new QDepthTestPrivate, parent)
@@ -67,19 +131,12 @@ QDepthTest::~QDepthTest()
 {
 }
 
-/*!
- * \return the current enabled depth function.
- */
 QDepthTest::DepthFunction QDepthTest::depthFunction() const
 {
     Q_D(const QDepthTest);
     return d->m_depthFunction;
 }
 
-/*!
- * Sets the depth function being enabled to \a depthFunction
- * \param depthFunction
- */
 void QDepthTest::setDepthFunction(QDepthTest::DepthFunction depthFunction)
 {
     Q_D(QDepthTest);
diff --git a/src/render/renderstates/qdithering.cpp b/src/render/renderstates/qdithering.cpp
index 7b98ed7ae..102cfa0ff 100644
--- a/src/render/renderstates/qdithering.cpp
+++ b/src/render/renderstates/qdithering.cpp
@@ -48,13 +48,31 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DRender {
 
 /*!
- * \class Qt3DRender::QDithering
- * \brief The QDithering class
- * \since 5.7
- * \ingroup
+    \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.
+ */
+
+/*!
+    \qmltype Dithering
+    \since 5.7
+    \inqmlmodule Qt3D.Render
+    \inherits RenderState
+    \instantiates Qt3DRender::QDithering
+    \brief Enable dithering
+
+    A Dithering type 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.
  */
 
-/*! \internal */
 class QDitheringPrivate : public QRenderStatePrivate
 {
 public:
@@ -66,8 +84,8 @@ public:
 };
 
 /*!
- * The constructor creates a new QDithering::QDithering instance with
- * the specified \a parent.
+    The constructor creates a new QDithering::QDithering instance with
+    the specified \a parent.
  */
 QDithering::QDithering(QNode *parent)
     : QRenderState(*new QDitheringPrivate, parent)
diff --git a/src/render/renderstates/qfrontface.cpp b/src/render/renderstates/qfrontface.cpp
index 016f27370..a814be82f 100644
--- a/src/render/renderstates/qfrontface.cpp
+++ b/src/render/renderstates/qfrontface.cpp
@@ -38,13 +38,6 @@
 **
 ****************************************************************************/
 
-/*!
- * \class QFrontFace
- * \brief The QFrontFace class defines front and back facing polygons.
- * \since 5.7
- * \ingroup renderstates
- *
- */
 #include "qfrontface.h"
 #include "qfrontface_p.h"
 #include <Qt3DRender/private/qrenderstatecreatedchange_p.h>
@@ -54,8 +47,52 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DRender {
 
 /*!
- * The constructor creates a new QFrontFace::QFrontFace instance with the
- * specified \a parent
+    \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
+ */
+
+/*!
+    \qmltype FrontFace
+    \brief The FrontFace type defines front and back facing polygons.
+    \since 5.7
+    \ingroup renderstates
+    \inqmlmodule Qt3D.Render
+    \inherits RenderState
+    \instantiates Qt3DRender::QFrontFace
+
+    A FrontFace sets the winding direction of the front facing polygons.
+
+    \sa CullFace
+ */
+
+/*!
+    \enum QFrontFace::WindingDirection
+
+    This enumeration specifies the winding direction values.
+    \value ClockWise Clockwise polygons are front facing.
+    \value CounterClockWise Counter clockwise polygons are front facing.
+*/
+
+/*!
+    \qmlproperty enumeration FrontFace::direction
+    Holds the winding direction of the front facing polygons. Default is FrontFace.Clockwise.
+*/
+
+/*!
+    \property QFrontFace::direction
+    Holds the winding direction of the front facing polygons. Default is Clockwise.
+*/
+
+/*!
+    The constructor creates a new QFrontFace::QFrontFace instance with the
+    specified \a parent
  */
 QFrontFace::QFrontFace(QNode *parent)
     : QRenderState(*new QFrontFacePrivate, parent)
@@ -67,19 +104,12 @@ QFrontFace::~QFrontFace()
 {
 }
 
-/*!
- * \return the current winding direction
- */
 QFrontFace::WindingDirection QFrontFace::direction() const
 {
     Q_D(const QFrontFace);
     return d->m_direction;
 }
 
-/*!
- * Sets the winding direction to \a direction
- * \param direction
- */
 void QFrontFace::setDirection(QFrontFace::WindingDirection direction)
 {
     Q_D(QFrontFace);
diff --git a/src/render/renderstates/qmultisampleantialiasing.cpp b/src/render/renderstates/qmultisampleantialiasing.cpp
index ae398cd0d..923fc435e 100644
--- a/src/render/renderstates/qmultisampleantialiasing.cpp
+++ b/src/render/renderstates/qmultisampleantialiasing.cpp
@@ -47,13 +47,29 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DRender {
 
 /*!
- * \class QMultiSampleAntiAliasing
- * \brief The QMultiSampleAntiAliasing class
- * \since 5.7
- * \ingroup renderstates
+    \class Qt3DRender::QMultiSampleAntiAliasing
+    \brief Enable multisample antialiasing
+    \since 5.7
+    \ingroup renderstates
+    \inmodule Qt3DRender
+
+    A Qt3DRender::QMultiSampleAntiAliasing class enables multisample antialiasing.
+    The render target must have been allocated with multisampling enabled.
+ */
+
+/*!
+    \qmltype MultiSampleAntiAliasing
+    \brief Enable multisample antialiasing
+    \since 5.7
+    \ingroup renderstates
+    \inqmlmodule Qt3D.Render
+    \inherits RenderState
+    \instantiates Qt3DRender::QMultiSampleAntiAliasing
+
+    A MultiSampleAntiAliasing type enables multisample antialiasing.
+    The render target must have been allocated with multisampling enabled.
  */
 
-/*! \internal */
 class QMultiSampleAntiAliasingPrivate : public QRenderStatePrivate
 {
 public:
@@ -66,8 +82,8 @@ public:
 };
 
 /*!
- * The constructor creates a new QMultiSampleAntiAliasing::QMultiSampleAntiAliasing
- * instance with the specified \a parent.
+    The constructor creates a new QMultiSampleAntiAliasing::QMultiSampleAntiAliasing
+    instance with the specified \a parent.
  */
 QMultiSampleAntiAliasing::QMultiSampleAntiAliasing(QNode *parent)
     : QRenderState(*new QMultiSampleAntiAliasingPrivate, parent)
diff --git a/src/render/renderstates/qnodepthmask.cpp b/src/render/renderstates/qnodepthmask.cpp
index b508f60b3..f0376cfb6 100644
--- a/src/render/renderstates/qnodepthmask.cpp
+++ b/src/render/renderstates/qnodepthmask.cpp
@@ -48,13 +48,31 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DRender {
 
 /*!
- * \class QNoDepthMask
- * \brief The QNoDepthMask class
- * \since 5.7
- * \ingroup renderstates
+    \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
+ */
+
+/*!
+    \qmltype NoDepthMask
+    \brief Disable depth write
+    \since 5.7
+    \ingroup renderstates
+    \inqmlmodule Qt3D.Render
+    \inherits RenderState
+    \instantiates Qt3DRender::QNoDepthMask
+
+    A NoDepthMask type disables fragment depth write to depth buffer.
+
+    \sa Qt3DRender::QDepthTest
  */
 
-/*! \internal */
 class QNoDepthMaskPrivate : public QRenderStatePrivate
 {
 public:
@@ -67,8 +85,8 @@ public:
 };
 
 /*!
- * the constructor creates a new QNoDepthMask::QNoDepthMask instance with
- * the specified \a parent.
+    The constructor creates a new QNoDepthMask::QNoDepthMask instance with
+    the specified \a parent.
  */
 QNoDepthMask::QNoDepthMask(QNode *parent)
     : QRenderState(*new QNoDepthMaskPrivate, parent)
diff --git a/src/render/renderstates/qpointsize.cpp b/src/render/renderstates/qpointsize.cpp
index 03c37bc4b..10687f8f2 100644
--- a/src/render/renderstates/qpointsize.cpp
+++ b/src/render/renderstates/qpointsize.cpp
@@ -48,6 +48,7 @@ namespace Qt3DRender {
 /*!
     \class Qt3DRender::QPointSize
     \inmodule Qt3DRender
+    \since 5.7
     \brief Specifies the size of rasterized points. May either be set statically
     or by shader programs.
 
@@ -59,6 +60,8 @@ namespace Qt3DRender {
 
 /*!
     \qmltype PointSize
+    \since 5.7
+    \inherits RenderState
     \instantiates Qt3DRender::QPointSize
     \inqmlmodule Qt3D.Render
 
@@ -72,12 +75,29 @@ namespace Qt3DRender {
  */
 
 /*!
-    \qmlproperty float Qt3D.Render::QPointSize::value
+    \enum Qt3DRender::QPointSize::SizeMode
+
+    This enumeration specifies values for the size mode.
+    \value Fixed The point size is by the QPointSize::value.
+    \value Programmable The point size value must be set in shader
+*/
+/*!
+    \qmlproperty real PointSize::value
+    Specifies the point size value to be used.
+*/
+
+/*!
+    \qmlproperty enumeration PointSize::sizeMode
+    Specifies the sizeMode to be used.
+*/
+
+/*!
+    \property  QPointSize::value
     Specifies the point size value to be used.
 */
 
 /*!
-    \qmlproperty QPointSize::SizeMode Qt3D.Render::QPointSize::sizeMode
+    \property QPointSize::sizeMode
     Specifies the sizeMode to be used.
 */
 
diff --git a/src/render/renderstates/qrenderstate.cpp b/src/render/renderstates/qrenderstate.cpp
index 974d8f602..fcdfd0eba 100644
--- a/src/render/renderstates/qrenderstate.cpp
+++ b/src/render/renderstates/qrenderstate.cpp
@@ -47,10 +47,25 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DRender {
 
 /*!
- * \class QRenderState
- * \brief The QRenderState class
- * \since 5.7
- * \ingroup renderstates
+    \class Qt3DRender::QRenderState
+    \brief An abstract base class for all render states
+    \since 5.7
+    \ingroup renderstates
+
+    A Qt3DRender::QRenderState class is abstract base class for all render states.
+    One can not instantiate QRenderState directly, but through its subclasses.
+ */
+
+/*!
+    \qmltype RenderState
+    \brief An abstract base type for all render states
+    \since 5.7
+    \inherits Node
+    \instantiates Qt3DRender::QRenderState
+    \ingroup renderstates
+
+    A RenderState type is abstract base class for all render states.
+    One can not instantiate RenderState directly, but through its subclasses.
  */
 
 /*! \internal */