path: root/src/render/materialsystem/qshaderimage.cpp

/****************************************************************************
**
** Copyright (C) 2019 Klaralvdalens Datakonsult AB (KDAB).
** Contact: https://www.qt.io/licensing/
**
** This file is part of the Qt3D module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qshaderimage.h"
#include "qshaderimage_p.h"
#include <Qt3DRender/qabstracttexture.h>

QT_BEGIN_NAMESPACE

namespace Qt3DRender {

QShaderImagePrivate::QShaderImagePrivate()
    : Qt3DCore::QNodePrivate()
    , m_texture(nullptr)
    , m_mipLevel(0)
    , m_layer(0)
    , m_access(QShaderImage::ReadWrite)
    , m_format(QShaderImage::Automatic)
    , m_layered(false)
{
}

QShaderImagePrivate::~QShaderImagePrivate()
{
}

/*!
    \qmltype ShaderImage
    \instantiates Qt3DRender::QShaderImage
    \inqmlmodule Qt3D.Render
    \since 5.14
    \brief Provides Image access to shader programs.

    To make the content of textures available for read and write operations in
    a shader, they need to exposed as ShaderImage. Textures can be composed of
    several mip levels, layers and faces. Additionally declaring a ShaderImage
    allows specifying which level, layer or face of the texture content we want
    to access.

    ShaderImage has to be assigned as a Parameter's value and reference a valid
    Qt3D.Render.AbstractTexture to work properly.

    If the referenced texture is a one-dimensional array, two-dimensional array,
    three-dimensional, cube map, cube map array, or two-dimensional multisample
    array texture, it is possible to bind either the entire texture level or a
    single layer or face of the texture level. This can be controlled with the
    \l layered property.

    Support for ShaderImage is only supported with OpenGL 4 and partially with
    OpenGL ES 3.1 and 3.2.

    OpenGL 4 supports the following image types:
    \table
    \header
       \li GLSL Type
       \li OpenGL Type Enum
       \li Texture Type
    \row
       \li image1D
       \li GL_IMAGE_1D
       \li Texture1D
    \row
       \li image2D
       \li GL_IMAGE_2D
       \li Texture2D
    \row
       \li image3D
       \li GL_IMAGE_3D
       \li Texture3D
    \row
       \li image2DRect
       \li GL_IMAGE_2D_RECT
       \li TextureRectangle
    \row
       \li imageCube
       \li GL_IMAGE_CUBE
       \li TextureCubeMap
    \row
       \li imageBuffer
       \li GL_IMAGE_BUFFER
       \li TextureBuffer
    \row
       \li image1DArray
       \li GL_IMAGE_1D_ARRAY
       \li Texture1DArray
    \row
       \li image2DArray
       \li GL_IMAGE_2D_ARRAY
       \li Texture2DArray
    \row
       \li imageCubeArray
       \li GL_IMAGE_CUBE_MAP_ARRAY
       \li TextureCubeMapArray
    \row
       \li image2DMS
       \li GL_IMAGE_2D_MULTISAMPLE
       \li Texture2DMultisample
    \row
       \li image2DMSArray
       \li GL_IMAGE_2D_MULTISAMPLE_ARRAY
       \li Texture2DMultisampleArray
    \row
       \li iimage1D
       \li GL_INT_IMAGE_1D
       \li Texture1D
    \row
       \li iimage2D
       \li GL_INT_IMAGE_2D
       \li Texture2D
    \row
       \li iimage3D
       \li GL_INT_IMAGE_3D
       \li Texture3D
    \row
       \li iimage2DRect
       \li GL_INT_IMAGE_2D_RECT
       \li TextureRectangle
    \row
       \li iimageCube
       \li GL_INT_IMAGE_CUBE
       \li TextureCubeMap
    \row
       \li iimageBuffer
       \li GL_INT_IMAGE_BUFFER
       \li TextureBuffer
    \row
       \li iimage1DArray
       \li GL_INT_IMAGE_1D_ARRAY
       \li Texture1DArray
    \row
       \li iimage2DArray
       \li GL_INT_IMAGE_2D_ARRAY
       \li Texture2DArray
    \row
       \li iimageCubeArray
       \li GL_INT_IMAGE_CUBE_MAP_ARRAY
       \li TextureCubeMapArray
    \row
       \li iimage2DMS
       \li GL_INT_IMAGE_2D_MULTISAMPLE
       \li Texture2DMultisample
    \row
       \li iimage2DMSArray
       \li GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY
       \li Texture2DMultisampleArray
    \row
       \li uimage1D
       \li GL_UNSIGNED_INT_IMAGE_1D
       \li Texture1D
    \row
       \li uimage2D
       \li GL_UNSIGNED_INT_IMAGE_2D
       \li Texture2D
    \row
       \li uimage3D
       \li GL_UNSIGNED_INT_IMAGE_3D
       \li Texture3D
    \row
       \li uimage2DRect
       \li GL_UNSIGNED_INT_IMAGE_2D_RECT
       \li TextureRectangle
    \row
       \li uimageCube
       \li GL_UNSIGNED_INT_IMAGE_CUBE
       \li TextureCubeMap
    \row
       \li uimageBuffer
       \li GL_UNSIGNED_INT_IMAGE_BUFFER
       \li TextureBuffer
    \row
       \li uimage1DArray
       \li GL_UNSIGNED_INT_IMAGE_1D_ARRAY
       \li Texture1DArray
    \row
       \li uimage2DArray
       \li GL_UNSIGNED_INT_IMAGE_2D_ARRAY
       \li Texture2DArray
    \row
       \li uimageCubeArray
       \li GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY
       \li TextureCubeMapArray
    \row
       \li uimage2DMS
       \li GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE
       \li Texture2DMultisample
    \row
       \li uimage2DMSArray
       \li GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY
       \li Texture2DMultisampleArray
    \endtable

    OpenGL ES 3.1 supports the following image types:
    \table
    \header
       \li GLSL Type
       \li OpenGL Type Enum
       \li Texture Type
    \row
       \li image2D
       \li GL_IMAGE_2D
       \li Texture2D
    \row
       \li image3D
       \li GL_IMAGE_3D
       \li Texture3D
    \row
       \li imageCube
       \li GL_IMAGE_CUBE
       \li TextureCubeMap
    \row
       \li image2DArray
       \li GL_IMAGE_2D_ARRAY
       \li Texture2DArray
    \row
       \li iimage2D
       \li GL_INT_IMAGE_2D
       \li Texture2D
    \row
       \li iimage3D
       \li GL_INT_IMAGE_3D
       \li Texture3D
    \row
       \li iimageCube
       \li GL_INT_IMAGE_CUBE
       \li TextureCubeMap
    \row
       \li iimage2DArray
       \li GL_INT_IMAGE_2D_ARRAY
       \li Texture2DArray
    \row
       \li uimage2D
       \li GL_UNSIGNED_INT_IMAGE_2D
       \li Texture2D
    \row
       \li uimage3D
       \li GL_UNSIGNED_INT_IMAGE_3D
       \li Texture3D
    \row
       \li uimageCube
       \li GL_UNSIGNED_INT_IMAGE_CUBE
       \li TextureCubeMap
    \row
       \li uimage2DArray
       \li GL_UNSIGNED_INT_IMAGE_2D_ARRAY
       \li Texture2DArray
    \endtable

    OpenGL ES 3.2 supports all of the OpenGL ES 3.1 image types as well as the
    following:
    \table
    \header
       \li GLSL Type
       \li OpenGL Type Enum
       \li Texture Type
    \row
       \li imageBuffer
       \li GL_IMAGE_BUFFER
       \li TextureBuffer
    \row
       \li imageCubeArray
       \li GL_IMAGE_CUBE_MAP_ARRAY
       \li TextureCubeMapArray
    \row
       \li iimageBuffer
       \li GL_IMAGE_BUFFER
       \li TextureBuffer
    \row
       \li iimageCubeArray
       \li GL_INT_IMAGE_CUBE_MAP_ARRAY
       \li TextureCubeMapArray
    \row
       \li uimageBuffer
       \li GL_UNSIGNED_INT_IMAGE_BUFFER
       \li TextureBuffer
    \row
       \li uimageCubeArray
       \li GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY
       \li TextureCubeMapArray
    \endtable

    Expected use would look like:

    \badcode

    import Qt3D.Render 2.14

    Entity {
    ...
        Texture2D {
            id: tex2D
            ...
        }

        Material {
            parameters: Parameter {
                name: "imageUniformName"
                value: ShaderImage {
                    texture: tex2D
                }
            }
            ...
        }
     ...
    }
    \endcode
 */

/*!
    \qmlproperty int Qt3D.Render::ShaderImage::mipLevel

    Holds which mipLevel out of the referenced texture should be used for the
    ShaderImage.

    The default value is 0.
 */

/*!
    \qmlproperty int Qt3D.Render::ShaderImage::layer

    Holds which layer out of the referenced texture should be used for the
    ShaderImage. This property does nothing if \a layered is set to true or if
    the reference texture's type isn't compatible with layers.

    \note When the referenced texture is of type cube map or cube map array and
    \a ĺayered is set to false, the face and layer are retrieved in the
    following manner:
    \badcode
    cubeMapLayer = layer / 6
    cubeMapFace = layer - (cubeMapLayer * 6)
    \endcode

    The default value is 0.
 */

/*!
 * \qmlproperty bool Qt3D.Render::ShaderImage::layered

    If set to true, if the referenced texture is a one-dimensional array,
    two-dimensional array, three-dimensional, cube map, cube map array, or
    two-dimensional multisample array texture, the entire level will be bound
    for all layers. If set to false, only the single layer specified by the \a
    layer property will be bound.

    The default value is \c false.
 */

/*!
    \qmlproperty enumeration Qt3D.Render::ShaderImage::access

    Specifies the type of access we want to allow from our shader instances to
    the image. If a shader tries to write or read from an image that has
    incompatible access, the behavior is undefined.

    \value ShaderImage.ReadOnly
           Read-only access.
    \value ShaderImage.WriteOnly
           Write-only access.
    \value ShaderImage.ReadWrite
           Read-write access.

    The default value is ShaderImage.ReadWrite.
 */

/*!
    \qmlproperty enumeration Qt3D.Render::ShaderImage::format

    Specifies the image format, which is essentially important when storing values
    in the ShaderImage from a shader.

    The format doesn't have to be the same as the referenced texture's format.
    It however has to be compatible (matching in size but not necessarily by
    class type). For instance a texture of format R32F (size 32bits, class
    1x32) could be used with an image of format RGBA8I (size 32bits, class
    4x8). Table 8.27 of the
    \l{https://www.khronos.org/registry/OpenGL/specs/gl/glspec45.core.pdf}{OpenGL specifications}
    shows the size and class for all supported image formats.

    By default Qt3D will try to set the image format to match that of the
    referenced texture.

    The default value is ShaderImage.Automatic.
 */

/*!
    \class Qt3DRender::QShaderImage
    \inmodule Qt3DRender
    \since 5.14
    \brief Provides Image access to shader programs.

    To make the content of textures available for read and write operations in
    a shader, they need to exposed as QShaderImage. Textures can be composed of
    several mip levels, layers and faces. Additionally declaring a QShaderImage
    allows specifying which level, layer or face of the texture content we want
    to access.

    QShaderImage has to be assigned as a QParameter's value and reference a valid
    Qt3DRender::QAbstractTexture to work properly.

    If the referenced texture is a one-dimensional array, two-dimensional array,
    three-dimensional, cube map, cube map array, or two-dimensional multisample
    array texture, it is possible to bind either the entire texture level or a
    single layer or face of the texture level. This can be controlled with the
    \l layered property.

    Support for QShaderImage is only supported with OpenGL 4 and partially with
    OpenGL ES 3.1 and 3.2.

    OpenGL 4 supports the following image types:
    \table
    \header
       \li GLSL Type
       \li OpenGL Type Enum
       \li Texture Type
    \row
       \li image1D
       \li GL_IMAGE_1D
       \li QTexture1D
    \row
       \li image2D
       \li GL_IMAGE_2D
       \li QTexture2D
    \row
       \li image3D
       \li GL_IMAGE_3D
       \li QTexture3D
    \row
       \li image2DRect
       \li GL_IMAGE_2D_RECT
       \li QTextureRectangle
    \row
       \li imageCube
       \li GL_IMAGE_CUBE
       \li QTextureCubeMap
    \row
       \li imageBuffer
       \li GL_IMAGE_BUFFER
       \li QTextureBuffer
    \row
       \li image1DArray
       \li GL_IMAGE_1D_ARRAY
       \li QTexture1DArray
    \row
       \li image2DArray
       \li GL_IMAGE_2D_ARRAY
       \li QTexture2DArray
    \row
       \li imageCubeArray
       \li GL_IMAGE_CUBE_MAP_ARRAY
       \li QTextureCubeMapArray
    \row
       \li image2DMS
       \li GL_IMAGE_2D_MULTISAMPLE
       \li QTexture2DMultisample
    \row
       \li image2DMSArray
       \li GL_IMAGE_2D_MULTISAMPLE_ARRAY
       \li QTexture2DMultisampleArray
    \row
       \li iimage1D
       \li GL_INT_IMAGE_1D
       \li QTexture1D
    \row
       \li iimage2D
       \li GL_INT_IMAGE_2D
       \li QTexture2D
    \row
       \li iimage3D
       \li GL_INT_IMAGE_3D
       \li QTexture3D
    \row
       \li iimage2DRect
       \li GL_INT_IMAGE_2D_RECT
       \li QTextureRectangle
    \row
       \li iimageCube
       \li GL_INT_IMAGE_CUBE
       \li QTextureCubeMap
    \row
       \li iimageBuffer
       \li GL_INT_IMAGE_BUFFER
       \li QTextureBuffer
    \row
       \li iimage1DArray
       \li GL_INT_IMAGE_1D_ARRAY
       \li QTexture1DArray
    \row
       \li iimage2DArray
       \li GL_INT_IMAGE_2D_ARRAY
       \li QTexture2DArray
    \row
       \li iimageCubeArray
       \li GL_INT_IMAGE_CUBE_MAP_ARRAY
       \li QTextureCubeMapArray
    \row
       \li iimage2DMS
       \li GL_INT_IMAGE_2D_MULTISAMPLE
       \li QTexture2DMultisample
    \row
       \li iimage2DMSArray
       \li GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY
       \li QTexture2DMultisampleArray
    \row
       \li uimage1D
       \li GL_UNSIGNED_INT_IMAGE_1D
       \li QTexture1D
    \row
       \li uimage2D
       \li GL_UNSIGNED_INT_IMAGE_2D
       \li QTexture2D
    \row
       \li uimage3D
       \li GL_UNSIGNED_INT_IMAGE_3D
       \li QTexture3D
    \row
       \li uimage2DRect
       \li GL_UNSIGNED_INT_IMAGE_2D_RECT
       \li QTextureRectangle
    \row
       \li uimageCube
       \li GL_UNSIGNED_INT_IMAGE_CUBE
       \li QTextureCubeMap
    \row
       \li uimageBuffer
       \li GL_UNSIGNED_INT_IMAGE_BUFFER
       \li QTextureBuffer
    \row
       \li uimage1DArray
       \li GL_UNSIGNED_INT_IMAGE_1D_ARRAY
       \li QTexture1DArray
    \row
       \li uimage2DArray
       \li GL_UNSIGNED_INT_IMAGE_2D_ARRAY
       \li QTexture2DArray
    \row
       \li uimageCubeArray
       \li GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY
       \li QTextureCubeMapArray
    \row
       \li uimage2DMS
       \li GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE
       \li QTexture2DMultisample
    \row
       \li uimage2DMSArray
       \li GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY
       \li QTexture2DMultisampleArray
    \endtable

    OpenGL ES 3.1 supports the following image types:
    \table
    \header
       \li GLSL Type
       \li OpenGL Type Enum
       \li Texture Type
    \row
       \li image2D
       \li GL_IMAGE_2D
       \li QTexture2D
    \row
       \li image3D
       \li GL_IMAGE_3D
       \li QTexture3D
    \row
       \li imageCube
       \li GL_IMAGE_CUBE
       \li QTextureCubeMap
    \row
       \li image2DArray
       \li GL_IMAGE_2D_ARRAY
       \li QTexture2DArray
    \row
       \li iimage2D
       \li GL_INT_IMAGE_2D
       \li QTexture2D
    \row
       \li iimage3D
       \li GL_INT_IMAGE_3D
       \li QTexture3D
    \row
       \li iimageCube
       \li GL_INT_IMAGE_CUBE
       \li QTextureCubeMap
    \row
       \li iimage2DArray
       \li GL_INT_IMAGE_2D_ARRAY
       \li QTexture2DArray
    \row
       \li uimage2D
       \li GL_UNSIGNED_INT_IMAGE_2D
       \li QTexture2D
    \row
       \li uimage3D
       \li GL_UNSIGNED_INT_IMAGE_3D
       \li QTexture3D
    \row
       \li uimageCube
       \li GL_UNSIGNED_INT_IMAGE_CUBE
       \li QTextureCubeMap
    \row
       \li uimage2DArray
       \li GL_UNSIGNED_INT_IMAGE_2D_ARRAY
       \li QTexture2DArray
    \endtable

    OpenGL ES 3.2 supports all of the OpenGL ES 3.1 image types as well as the
    following:
    \table
    \header
       \li GLSL Type
       \li OpenGL Type Enum
       \li Texture Type
    \row
       \li imageBuffer
       \li GL_IMAGE_BUFFER
       \li QTextureBuffer
    \row
       \li imageCubeArray
       \li GL_IMAGE_CUBE_MAP_ARRAY
       \li QTextureCubeMapArray
    \row
       \li iimageBuffer
       \li GL_IMAGE_BUFFER
       \li QTextureBuffer
    \row
       \li iimageCubeArray
       \li GL_INT_IMAGE_CUBE_MAP_ARRAY
       \li QTextureCubeMapArray
    \row
       \li uimageBuffer
       \li GL_UNSIGNED_INT_IMAGE_BUFFER
       \li QTextureBuffer
    \row
       \li uimageCubeArray
       \li GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY
       \li QTextureCubeMapArray
    \endtable

    Expected use would look like:

    \badcode
    Qt3DRender::QTexture2D *tex2D = new Qt3DRender::QTexture2D();
    ...
    Qt3DRender::QMaterial *material = new Qt3DRender::QMaterial();
    ...
    Qt3DRender::QParameter *imageParameter = new Qt3DRender::QParameter();
    Qt3DRender::QShaderImage *shaderImage = new Qt3DRender::QShaderImage();

    shaderImage->setTexture(tex2D);

    imageParameter->setName("imageUniformName");
    imageParameter->setValue(QVariant::fromValue(shaderImage));

    material->addParameter(imageParamenter);
    \endcode
 */

/*!
    \property Qt3DRender::QShaderImage::mipLevel

    Holds which mipLevel out of the referenced texture should be used for the
    QShaderImage.

    The default value is 0.
*/

/*!
    \property Qt3DRender::QShaderImage::layer

    Holds which layer out of the referenced texture should be used for the
    QShaderImage. This property does nothing if \a layered is set to true or if the
    reference texture's type isn't compatible with layers.

    \note When the referenced texture is of type cube map or cube map array and
    \a ĺayered is set to false, the face and layer are retrieved in the
    following manner:
    \badcode
    cubeMapLayer = layer / 6
    cubeMapFace = layer - (cubeMapLayer * 6)
    \endcode

    The default value is 0.
 */

/*!
 * \property Qt3DRender::QShaderImage::layered

    If set to true, if the referenced texture is a one-dimensional array,
    two-dimensional array, three-dimensional, cube map, cube map array, or
    two-dimensional multisample array texture, the entire level will be bound
    for all layers. If set to false, only the single layer specified by the \a
    layer property will be bound.

    The default value is \c false.
 */

/*!
    \property Qt3DRender::QShaderImage::access

    Specifies the type of access we want to allow from our shader instances to
    the image. If a shader tries to write or read from an image that has
    incompatible access, the behavior is undefined.

    The default value is QShaderImage::ReadWrite.
 */

/*!
    \property Qt3DRender::QShaderImage::format

    Specifies the image format, which is essentially important when storing values
    in the Image from a shader.

    The format doesn't have to be the same as the referenced texture's format.
    It however has to be compatible (matching in size but not necessarily by
    class type). For instance a texture of format R32F (size 32bits, class
    1x32) could be used with an image of format RGBA8I (size 32bits, class
    4x8). Table 8.27 of the
    \l{https://www.khronos.org/registry/OpenGL/specs/gl/glspec45.core.pdf}{OpenGL specifications}
    shows the size and class for all supported Image formats.

    By default Qt3D will try to set the image format to match that of the
    referenced texture.

    The default value is QShaderImage::Automatic.
 */

/*!
    \enum Qt3DRender::QShaderImage::Access

    \value ReadOnly
           Image will only be read from in shaders
    \value WriteOnly
           Image will only be written into from shaders
    \value ReadWrite
           Image will only be read and written into from shaders
*/

/*!
    \enum Qt3DRender::QShaderImage::ImageFormat

    This list describes all possible image formats

    \value NoFormat
          GL_NONE
    \value Automatic
          Qt 3D will try to determine the format automatically based on
          the referenced texture.
    \value R8_UNorm
          GL_R8 (GLSL type r8, supported by OpenGL 4.2+)
    \value RG8_UNorm
          GL_RG8 (GLSL type rg8, supported by OpenGL 4.2+)
    \value RGBA8_UNorm
          GL_RGBA8 (GLSL type rgba8, supported by OpenGL 4.2+, OpenGL ES 3.1+)
    \value R16_UNorm
          GL_R16 (GLSL type r16, supported by OpenGL 4.2+)
    \value RG16_UNorm
          GL_RG16 (GLSL type rg16, supported by OpenGL 4.2+)
    \value RGBA16_UNorm
          GL_RGBA16 (GLSL type rgba16, supported by OpenGL 4.2+)
    \value R8_SNorm
          GL_R8_SNORM (GLSL type r8_snorm, supported by OpenGL 4.2+)
    \value RG8_SNorm
          GL_RG8_SNORM (GLSL type rg8_snorm, supported by OpenGL 4.2+)
    \value RGBA8_SNorm
          GL_RGBA8_SNORM (GLSL type rgba8_snorm, supported by OpenGL 4.2+, OpenGL ES 3.1+)
    \value R16_SNorm
          GL_R16_SNORM (GLSL type r16_snorm, supported by OpenGL 4.2+)
    \value RG16_SNorm
          GL_RG16_SNORM (GLSL type rg16_snorm, supported by OpenGL 4.2+)
    \value RGBA16_SNorm
          GL_RGBA16_SNORM (GLSL type rgba16_snorm, supported by OpenGL 4.2+)
    \value R8U
          GL_R8UI (GLSL type r8ui, supported by OpenGL 4.2+)
    \value RG8U
          GL_RG8UI (GLSL type rg8ui, supported by OpenGL 4.2+)
    \value RGBA8U
          GL_RGBA8UI (GLSL type rgba8ui, supported by OpenGL 4.2+, OpenGL ES 3.1+)
    \value R16U
          GL_R16UI (GLSL type r16ui, supported by OpenGL 4.2+)
    \value RG16U
          GL_RG16UI (GLSL type rg16ui, supported by OpenGL 4.2+)
    \value RGBA16U
          GL_RGBA16UI (GLSL type rgba16ui, supported by OpenGL 4.2+, OpenGL ES 3.1+)
    \value R32U
          GL_R32UI (GLSL type r32ui, supported by OpenGL 4.2+, OpenGL ES 3.1)
    \value RG32U
          GL_RG32UI (GLSL type rg32ui, supported by OpenGL 4.2+)
    \value RGBA32U
          GL_RGBA32UI (GLSL type rgba32ui, supported by OpenGL 4.2+, OpenGL ES 3.1+)
    \value R8I
          GL_R8I (GLSL type r8i, supported by OpenGL 4.2+)
    \value RG8I
          GL_RG8I (GLSL type rg8i, supported by OpenGL 4.2+)
    \value RGBA8I
          GL_RGBA8I (GLSL type rgba8i, supported by OpenGL 4.2+, OpenGL ES 3.1+)
    \value R16I
          GL_R16I (GLSL type r16i, supported by OpenGL 4.2+)
    \value RG16I
          GL_RG16I (GLSL type rg16i, supported by OpenGL 4.2+)
    \value RGBA16I
          GL_RGBA16I (GLSL type rgba16i, supported by OpenGL 4.2+, OpenGL ES 3.1)
    \value R32I
          GL_R32I (GLSL type r32i, supported by OpenGL 4.2+, OpenGL ES 3.1+)
    \value RG32I
          GL_RG32I (GLSL type rg32i, supported by OpenGL 4.2+)
    \value RGBA32I
          GL_RGBA32I (GLSL type rgba32i, supported by OpenGL 4.2+, OpenGL ES 3.1+)
    \value R16F
          GL_R16F (GLSL type r16f, supported by OpenGL 4.2+)
    \value RG16F
          GL_RG16F (GLSL type rg16f, supported by OpenGL 4.2+)
    \value RGBA16F
          GL_RGBA16F (GLSL type rgba16f, supported by OpenGL 4.2+, OpenGL ES 3.1+)
    \value R32F
          GL_R32F (GLSL type r32f, supported by OpenGL 4.2+, OpenGL ES 3.1+)
    \value RG32F
          GL_RG32F (GLSL type rg32f, supported by OpenGL 4.2+)
    \value RGBA32F
          GL_RGBA32F (GLSL type rgba32f, supported by OpenGL 4.2+, OpenGL ES 3.1+)
    \value RG11B10F
          GL_R11F_G11F_B10F (GLSL type r11f_g11f_b10f, supported by OpenGL 4.2+)
    \value RGB10A2
          GL_RGB10_A2 (GLSL type rgb10_a2, supported by OpenGL 4.2+)
    \value RGB10A2U
          GL_RGB10_A2UI (GLSL type rgb10_a2ui, supported by OpenGL 4.2+)
*/


QShaderImage::QShaderImage(Qt3DCore::QNode *parent)
    : Qt3DCore::QNode(*new QShaderImagePrivate, parent)
{
}

QShaderImage::~QShaderImage()
{

}

QAbstractTexture *QShaderImage::texture() const
{
    Q_D(const QShaderImage);
    return d->m_texture;
}

bool QShaderImage::layered() const
{
    Q_D(const QShaderImage);
    return d->m_layered;
}

int QShaderImage::mipLevel() const
{
    Q_D(const QShaderImage);
    return d->m_mipLevel;
}

int QShaderImage::layer() const
{
    Q_D(const QShaderImage);
    return d->m_layer;
}

QShaderImage::Access QShaderImage::access() const
{
    Q_D(const QShaderImage);
    return d->m_access;
}

QShaderImage::ImageFormat QShaderImage::format() const
{
    Q_D(const QShaderImage);
    return d->m_format;
}

void QShaderImage::setTexture(QAbstractTexture *texture)
{
    Q_D(QShaderImage);
    if (texture == d->m_texture)
        return;

    if (d->m_texture)
        d->unregisterDestructionHelper(d->m_texture);

    if (texture && !texture->parent())
        texture->setParent(this);

    d->m_texture = texture;

    if (d->m_texture)
        d->registerDestructionHelper(d->m_texture, &QShaderImage::setTexture, d->m_texture);

    Q_EMIT textureChanged(texture);
}

void QShaderImage::setLayered(bool layered)
{
    Q_D(QShaderImage);
    if (layered == d->m_layered)
        return;
    d->m_layered = layered;
    Q_EMIT layeredChanged(layered);
}

void QShaderImage::setMipLevel(int mipLevel)
{
    Q_D(QShaderImage);
    if (mipLevel == d->m_mipLevel)
        return;
    d->m_mipLevel = mipLevel;
    Q_EMIT mipLevelChanged(mipLevel);
}

void QShaderImage::setLayer(int layer)
{
    Q_D(QShaderImage);
    if (layer == d->m_layer)
        return;
    d->m_layer = layer;
    Q_EMIT layerChanged(layer);
}

void QShaderImage::setAccess(QShaderImage::Access access)
{
    Q_D(QShaderImage);
    if (access == d->m_access)
        return;
    d->m_access = access;
    Q_EMIT accessChanged(access);
}

void QShaderImage::setFormat(QShaderImage::ImageFormat format)
{
    Q_D(QShaderImage);
    if (format == d->m_format)
        return;
    d->m_format = format;
    Q_EMIT formatChanged(format);
}

Qt3DCore::QNodeCreatedChangeBasePtr Qt3DRender::QShaderImage::createNodeCreationChange() const
{
    auto creationChange = Qt3DCore::QNodeCreatedChangePtr<QShaderImageData>::create(this);
    QShaderImageData &data = creationChange->data;
    Q_D(const QShaderImage);
    data.textureId = Qt3DCore::qIdForNode(d->m_texture);
    data.layer = d->m_layer;
    data.mipLevel = d->m_mipLevel;
    data.access = d->m_access;
    data.format = d->m_format;
    data.layered = d->m_layered;
    return creationChange;

}

} // namespace Qt3DRender

QT_END_NAMESPACE