Revision control
Copy as Markdown
// Copyright (C) 2008-2012 NVIDIA Corporation.
// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#ifndef QSSGRENDERBASETYPES_P_H
#define QSSGRENDERBASETYPES_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include <QtQuick3DUtils/qtquick3dutilsexports.h>
#include <QtCore/qvariant.h>
#include <QtGui/QVector2D>
#include <QtGui/QVector3D>
#include <QtGui/QVector4D>
#include <QtGui/QMatrix4x4>
#include <QtGui/QMatrix3x3>
#include <QFloat16>
#include <cmath>
QT_BEGIN_NAMESPACE
enum class QSSGRenderComponentType // stored in mesh files, the values must not change, must match Mesh::ComponentType
{
UnsignedInt8 = 1,
Int8,
UnsignedInt16,
Int16,
UnsignedInt32,
Int32,
UnsignedInt64,
Int64,
Float16,
Float32,
Float64
};
enum class QSSGRenderDrawMode // stored in mesh files, the values must not change, must match Mesh::DrawMode
{
Points = 1,
LineStrip,
LineLoop, // Not supported
Lines,
TriangleStrip,
TriangleFan,
Triangles
};
enum class QSSGRenderWinding // stored in mesh files, the values must not change, must match Mesh::Winding
{
Clockwise = 1,
CounterClockwise
};
enum class QSSGRenderSamplerType
{
Unknown,
Sampler2D,
Sampler2DArray,
Sampler3D,
SamplerCube,
SamplerCubeArray,
SamplerBuffer,
};
struct Q_QUICK3DUTILS_EXPORT QSSGRenderTextureFormat
{
static constexpr quint8 DepthTextureFlag = 1u << 6;
static constexpr quint8 CompressedTextureFlag = 1u << 7;
enum Format : quint8 {
// Non-compressed formats
Unknown = 0,
R8,
R16,
R16F,
R32I,
R32UI,
R32F,
RG8,
RGBA8,
RGB8,
SRGB8,
SRGB8A8,
RGB565,
RGBA5551,
Alpha8,
Luminance8,
Luminance16,
LuminanceAlpha8,
RGBA16F,
RG16F,
RG32F,
RGB32F,
RGBA32F,
R11G11B10,
RGB9E5,
RGB10_A2,
RGB16F,
RGBA32UI,
RGB32UI,
RGBA16UI,
RGB16UI,
RGBA8UI,
RGB8UI,
RGBA32I,
RGB32I,
RGBA16I,
RGB16I,
RGBA8I,
RGB8I,
RGBE8,
// Depth textures
Depth16 = DepthTextureFlag + 1,
Depth24,
Depth32,
Depth24Stencil8,
// Compressed formats
RGBA_DXT1 = CompressedTextureFlag + 1,
RGB_DXT1,
RGBA_DXT3,
RGBA_DXT5,
R11_EAC_UNorm,
R11_EAC_SNorm,
RG11_EAC_UNorm,
RG11_EAC_SNorm,
RGB8_ETC2,
SRGB8_ETC2,
RGB8_PunchThrough_Alpha1_ETC2,
SRGB8_PunchThrough_Alpha1_ETC2,
RGBA8_ETC2_EAC,
SRGB8_Alpha8_ETC2_EAC,
RGBA_ASTC_4x4,
RGBA_ASTC_5x4,
RGBA_ASTC_5x5,
RGBA_ASTC_6x5,
RGBA_ASTC_6x6,
RGBA_ASTC_8x5,
RGBA_ASTC_8x6,
RGBA_ASTC_8x8,
RGBA_ASTC_10x5,
RGBA_ASTC_10x6,
RGBA_ASTC_10x8,
RGBA_ASTC_10x10,
RGBA_ASTC_12x10,
RGBA_ASTC_12x12,
SRGB8_Alpha8_ASTC_4x4,
SRGB8_Alpha8_ASTC_5x4,
SRGB8_Alpha8_ASTC_5x5,
SRGB8_Alpha8_ASTC_6x5,
SRGB8_Alpha8_ASTC_6x6,
SRGB8_Alpha8_ASTC_8x5,
SRGB8_Alpha8_ASTC_8x6,
SRGB8_Alpha8_ASTC_8x8,
SRGB8_Alpha8_ASTC_10x5,
SRGB8_Alpha8_ASTC_10x6,
SRGB8_Alpha8_ASTC_10x8,
SRGB8_Alpha8_ASTC_10x10,
SRGB8_Alpha8_ASTC_12x10,
SRGB8_Alpha8_ASTC_12x12,
BC1,
BC2,
BC3,
BC4,
BC5,
BC6H,
BC7,
};
Format format;
constexpr QSSGRenderTextureFormat(Format f) : format(f) {}
[[nodiscard]] constexpr bool isCompressedTextureFormat() const noexcept
{
return (format & CompressedTextureFlag);
}
[[nodiscard]] constexpr bool isUncompressedTextureFormat() const noexcept
{
return !isCompressedTextureFormat();
}
[[nodiscard]] bool isDepthTextureFormat() const noexcept
{
return (format & DepthTextureFlag);
}
[[nodiscard]] const char *toString() const;
[[nodiscard]] qint32 getSizeofFormat() const noexcept;
[[nodiscard]] qint32 getNumberOfComponent() const noexcept;
void decodeToFloat(void *inPtr, qint32 byteOfs, float *outPtr) const;
void encodeToPixel(float *inPtr, void *outPtr, qint32 byteOfs) const;
bool operator==(const QSSGRenderTextureFormat &other) const { return format == other.format; }
bool operator!=(const QSSGRenderTextureFormat &other) const { return format != other.format; }
};
enum class QSSGRenderTextureFilterOp
{
None = 0,
Nearest,
Linear
};
enum class QSSGRenderTextureCoordOp : quint8
{
Unknown = 0,
ClampToEdge,
MirroredRepeat,
Repeat
};
enum class QSSGCullFaceMode
{
Unknown = 0,
Back,
Front,
Disabled,
FrontAndBack, // Not exposed in the front-end
};
enum class QSSGDepthDrawMode
{
OpaqueOnly,
Always,
Never,
OpaquePrePass
};
template<typename TDataType>
struct QSSGRenderGenericVec2
{
TDataType x;
TDataType y;
QSSGRenderGenericVec2(TDataType _x, TDataType _y) : x(_x), y(_y) {}
QSSGRenderGenericVec2() {}
bool operator==(const QSSGRenderGenericVec2 &inOther) const { return x == inOther.x && y == inOther.y; }
};
template<typename TDataType>
struct QSSGRenderGenericVec3
{
TDataType x;
TDataType y;
TDataType z;
QSSGRenderGenericVec3(TDataType _x, TDataType _y, TDataType _z) : x(_x), y(_y), z(_z) {}
QSSGRenderGenericVec3() {}
bool operator==(const QSSGRenderGenericVec3 &inOther) const
{
return x == inOther.x && y == inOther.y && z == inOther.z;
}
};
template<typename TDataType>
struct QSSGRenderGenericVec4
{
TDataType x;
TDataType y;
TDataType z;
TDataType w;
QSSGRenderGenericVec4(TDataType _x, TDataType _y, TDataType _z, TDataType _w) : x(_x), y(_y), z(_z), w(_w) {}
QSSGRenderGenericVec4() {}
bool operator==(const QSSGRenderGenericVec4 &inOther) const
{
return x == inOther.x && y == inOther.y && z == inOther.z && w == inOther.w;
}
};
namespace QSSGRenderShaderValue
{
enum Type : quint32
{
Unknown = 0,
Integer, // qint32,
IntegerVec2, // qint32_2,
IntegerVec3, // qint32_3,
IntegerVec4, // qint32_4,
Boolean, // bool
BooleanVec2, // bool_2,
BooleanVec3, // bool_3,
BooleanVec4, // bool_4,
Float, // float,
Vec2, // QVector2D,
Vec3, // QVector3D,
Vec4, // QVector4D,
UnsignedInteger, // quint32,
UnsignedIntegerVec2, // quint32_2,
UnsignedIntegerVec3, // quint32_3,
UnsignedIntegerVec4, // quint32_4,
Matrix3x3, // QMatrix3x3,
Matrix4x4, // QMatrix4x4,
Rgba, // QColor
Size, // QSize
SizeF, // QSizeF
Point, // QPoint
PointF, // QPointF
Rect, // QRect
RectF, // QRectF
Quaternion, // QQuaternion
Texture,
};
using vec2 = QVector2D;
using vec3 = QVector3D;
using vec4 = QVector4D;
using bvec2 = QSSGRenderGenericVec2<bool>;
using bvec3 = QSSGRenderGenericVec3<bool>;
using bvec4 = QSSGRenderGenericVec4<bool>;
using ivec2 = QSSGRenderGenericVec2<qint32>;
using ivec3 = QSSGRenderGenericVec3<qint32>;
using ivec4 = QSSGRenderGenericVec4<qint32>;
using uvec2 = QSSGRenderGenericVec2<quint32>;
using uvec3 = QSSGRenderGenericVec3<quint32>;
using uvec4 = QSSGRenderGenericVec4<quint32>;
}
enum class QSSGRenderTextureTypeValue
{
Unknown = 0,
Diffuse,
Specular,
Environment,
Bump,
Normal,
Emissive,
Anisotropy,
Translucent
};
enum class QSSGRenderTextureCubeFace : quint8
{
PosX,
NegX,
PosY,
NegY,
PosZ,
NegZ
};
using QSSGRenderTextureCubeFaceT = std::underlying_type_t<QSSGRenderTextureCubeFace>;
// Same order as expected by QRHI!
static constexpr QSSGRenderTextureCubeFace QSSGRenderTextureCubeFaces[] {
QSSGRenderTextureCubeFace::PosX, QSSGRenderTextureCubeFace::NegX,
QSSGRenderTextureCubeFace::PosY, QSSGRenderTextureCubeFace::NegY,
QSSGRenderTextureCubeFace::PosZ, QSSGRenderTextureCubeFace::NegZ
};
constexpr QSSGRenderTextureCubeFaceT QSSGRenderTextureCubeFaceMask { 0xf };
constexpr QSSGRenderTextureCubeFace QSSGRenderTextureCubeFaceNone { QSSGRenderTextureCubeFaceT(1 << 4) };
class Q_QUICK3DUTILS_EXPORT QSSGBaseTypeHelpers
{
QSSGBaseTypeHelpers() = default;
public:
// Enum as string
static const char *toString(QSSGRenderTextureCubeFace value);
static const char *toString(QSSGRenderTextureTypeValue value);
static const char *toString(QSSGDepthDrawMode value);
static const char *toString(QSSGRenderWinding value);
static const char *toString(QSSGCullFaceMode value);
static const char *toString(QSSGRenderComponentType value);
static const char *toString(QSSGRenderTextureFormat::Format value);
static const char *toString(QSSGRenderTextureCoordOp value);
static const char *toString(QSSGRenderTextureFilterOp value);
static QByteArray toString(QSSGRenderSamplerType value);
static const char *displayName(QSSGRenderTextureCubeFace face);
static size_t getSizeOfType(QSSGRenderComponentType type);
// Note: These will wrap around
static constexpr QSSGRenderTextureCubeFace next(QSSGRenderTextureCubeFace face)
{ return (face == QSSGRenderTextureCubeFaces[5]) ? QSSGRenderTextureCubeFaces[0] : QSSGRenderTextureCubeFace(quint8(face) + 1); }
static constexpr QSSGRenderTextureCubeFace prev(QSSGRenderTextureCubeFace face)
{ return (face == QSSGRenderTextureCubeFaces[0]) ? QSSGRenderTextureCubeFaces[5] : QSSGRenderTextureCubeFace(quint8(face) - 1); }
static constexpr QSSGRenderTextureCubeFaceT indexOfCubeFace(QSSGRenderTextureCubeFace face) noexcept { return QSSGRenderTextureCubeFaceT(face) & 0xf; }
};
class QSSGBaseTypeProperty
{
public:
QSSGBaseTypeProperty() = default;
QSSGBaseTypeProperty(const QByteArray &name, const QByteArray &typeName, const QVariant &value, QSSGRenderShaderValue::Type shaderDataType, int pid = -1)
: name(name), typeName(typeName), value(value), shaderDataType(shaderDataType), pid(pid)
{ }
QByteArray name;
QByteArray typeName;
mutable QVariant value;
QSSGRenderShaderValue::Type shaderDataType;
int pid;
};
QT_END_NAMESPACE
#endif // QSSGRENDERBASETYPES_P_H