qssgmesh_p.h - mozsearch

qt/qtquick3d/src/utils/qssgmesh_p.h (file symbol)

Enable keyboard shortcuts

Revision control

Copy as Markdown

// Copyright (C) 2019 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

// Qt-Security score:critical reason:data-parser

#ifndef QSSGMESHUTILITIES_P_H

#define QSSGMESHUTILITIES_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/private/qtquick3dutilsglobal_p.h>

#include <QtQuick3DUtils/private/qssgbounds3_p.h>

#include <QtQuick3DUtils/private/qssgrenderbasetypes_p.h>

#include <QtCore/qstring.h>

#include <QtCore/qbytearray.h>

#include <QtCore/qiodevice.h>

#include <QtCore/qlist.h>

#include <QtCore/qmap.h>

#include <QtGui/qvectornd.h>

QT_BEGIN_NAMESPACE

struct QSSGRenderVertexBufferEntry

    QByteArray m_name;

    /** Datatype of the this entry points to in the buffer */

    QSSGRenderComponentType m_componentType;

    /** Number of components of each data member. 1,2,3, or 4.  Don't be stupid.*/

    quint32 m_numComponents;

    /** Offset from the beginning of the buffer of the first item */

    quint32 m_firstItemOffset;

    QSSGRenderVertexBufferEntry(const QByteArray &nm,

                                QSSGRenderComponentType type,

                                quint32 numComponents,

                                quint32 firstItemOffset = 0)

        : m_name(nm), m_componentType(type), m_numComponents(numComponents), m_firstItemOffset(firstItemOffset)

    QSSGRenderVertexBufferEntry()

        : m_componentType(QSSGRenderComponentType::Float32), m_numComponents(0), m_firstItemOffset(0)

    QSSGRenderVertexBufferEntry(const QSSGRenderVertexBufferEntry &inOther)

        : m_name(inOther.m_name)

        , m_componentType(inOther.m_componentType)

        , m_numComponents(inOther.m_numComponents)

        , m_firstItemOffset(inOther.m_firstItemOffset)

    QSSGRenderVertexBufferEntry &operator=(const QSSGRenderVertexBufferEntry &inOther)

        if (this != &inOther) {

            m_name = inOther.m_name;

            m_componentType = inOther.m_componentType;

            m_numComponents = inOther.m_numComponents;

            m_firstItemOffset = inOther.m_firstItemOffset;

        return *this;

};

namespace QSSGMesh {

struct AssetVertexEntry;

struct AssetMeshSubset;

struct RuntimeMeshData;

struct AssetLodEntry;

class Q_QUICK3DUTILS_EXPORT Mesh

public:

    using DrawMode = QSSGRenderDrawMode;

    using Winding = QSSGRenderWinding;

    using ComponentType = QSSGRenderComponentType;

    struct VertexBufferEntry {

        ComponentType componentType = ComponentType::Float32;

        quint32 componentCount = 0;

        quint32 offset = 0;

        QByteArray name;

        QSSGRenderVertexBufferEntry toRenderVertexBufferEntry() const {

            return QSSGRenderVertexBufferEntry(name,

                                               QSSGRenderComponentType(componentType),

                                               componentCount,

                                               offset);

};

    struct VertexBuffer {

        quint32 stride = 0;

        QVector<VertexBufferEntry> entries;

        QByteArray data;

};

    struct IndexBuffer {

        ComponentType componentType = ComponentType::UnsignedInt32;

        QByteArray data;

};

    struct TargetBuffer {

        quint32 numTargets = 0;

        QVector<VertexBufferEntry> entries;

        QByteArray data;

};

    struct SubsetBounds {

        QVector3D min;

        QVector3D max;

};

    struct Lod {

        quint32 count = 0;

        quint32 offset = 0;

        float distance = 0.0f;

};

    struct Subset {

        QString name;

        SubsetBounds bounds;

        quint32 count = 0;

        quint32 offset = 0;

        QSize lightmapSizeHint;

        QVector<Lod> lods;

};

    // can just return by value (big data is all implicitly shared)

    VertexBuffer vertexBuffer() const { return m_vertexBuffer; }

    IndexBuffer indexBuffer() const { return m_indexBuffer; }

    TargetBuffer targetBuffer() const { return m_targetBuffer; }

    QVector<Subset> subsets() const { return m_subsets; }

    // id 0 == first, otherwise has to match

    static Mesh loadMesh(QIODevice *device, quint32 id = 0);

    static QMap<quint32, Mesh> loadAll(QIODevice *device);

    static Mesh fromAssetData(const QVector<AssetVertexEntry> &vbufEntries,

                              const QByteArray &indexBufferData,

                              ComponentType indexComponentType,

                              const QVector<AssetMeshSubset> &subsets,

                              quint32 numTargets = 0, quint32 numTargetComps = 0);

    static Mesh fromRuntimeData(const RuntimeMeshData &data,

                                QString *error);

    bool isValid() const { return !m_subsets.isEmpty(); }

    DrawMode drawMode() const { return m_drawMode; }

    Winding winding() const { return m_winding; }

    // id 0 == generate new id; otherwise uses it as-is, and must be an unused one

    quint32 save(QIODevice *device, quint32 id = 0) const;

    bool hasLightmapUVChannel() const;

    bool createLightmapUVChannel(float texelsPerUnit, const QMatrix4x4 &scale);

private:

    DrawMode m_drawMode = DrawMode::Triangles;

    Winding m_winding = Winding::CounterClockwise;

    VertexBuffer m_vertexBuffer;

    IndexBuffer m_indexBuffer;

    TargetBuffer m_targetBuffer;

    QVector<Subset> m_subsets;

    friend struct MeshInternal;

};

struct Q_QUICK3DUTILS_EXPORT AssetVertexEntry // for asset importer plugins (Assimp, FBX)

    QByteArray name;

    QByteArray data;

    Mesh::ComponentType componentType = Mesh::ComponentType::Float32;

    quint32 componentCount = 0;

    qint32 morphTargetId = -1; // -1 menas that this entry belongs to the original mesh.

};

struct Q_QUICK3DUTILS_EXPORT AssetMeshSubset // for asset importer plugins (Assimp, FBX)

    QString name;

    quint32 count = 0;

    quint32 offset = 0;

    quint32 boundsPositionEntryIndex = std::numeric_limits<quint32>::max();

    quint32 lightmapWidth = 0;

    quint32 lightmapHeight = 0;

    QVector<Mesh::Lod> lods;

};

struct Q_QUICK3DUTILS_EXPORT RuntimeMeshData // for custom geometry (QQuick3DGeometry, QSSGRenderGeometry)

    struct Attribute {

        enum Semantic {

            IndexSemantic = 0,

            PositionSemantic,                       // attr_pos

            NormalSemantic,                         // attr_norm

            TexCoordSemantic,                       // attr_uv0

            TangentSemantic,                        // attr_textan

            BinormalSemantic,                       // attr_binormal

            JointSemantic,                          // attr_joints

            WeightSemantic,                         // attr_weights

            ColorSemantic,                          // attr_color

            TexCoord1Semantic,                      // attr_uv1

            TexCoord0Semantic = TexCoordSemantic    // attr_uv0

};

        Semantic semantic = PositionSemantic;

        Mesh::ComponentType componentType = Mesh::ComponentType::Float32;

        int offset = 0;

        int componentCount() const {

            switch (semantic) {

            case IndexSemantic:             return 1;

            case PositionSemantic:          return 3;

            case NormalSemantic:            return 3;

            case TexCoord0Semantic:         return 2;

            case TexCoord1Semantic:         return 2;

            case TangentSemantic:           return 3;

            case BinormalSemantic:          return 3;

            case JointSemantic:             return 4;

            case WeightSemantic:            return 4;

            case ColorSemantic:             return 4;

            Q_UNREACHABLE_RETURN(0);

};

    struct TargetAttribute {

        Attribute attr;

        int targetId;

        int stride;

};

    static const int MAX_ATTRIBUTES = 16;

    static const int MAX_TARGET_ATTRIBUTES = 32;

    void clear()

        clearVertexAndIndex();

        clearTarget();

    void clearVertexAndIndex()

        m_vertexBuffer.clear();

        m_indexBuffer.clear();

        m_subsets.clear();

        m_attributeCount = 0;

        m_primitiveType = Mesh::DrawMode::Triangles;

    void clearTarget()

        m_targetBuffer.clear();

        m_targetAttributeCount = 0;

    QByteArray m_vertexBuffer;

    QByteArray m_indexBuffer;

    QByteArray m_targetBuffer;

    QVector<Mesh::Subset> m_subsets;

    Attribute m_attributes[MAX_ATTRIBUTES];

    int m_attributeCount = 0;

    TargetAttribute m_targetAttributes[MAX_TARGET_ATTRIBUTES];

    int m_targetAttributeCount = 0;

    Mesh::DrawMode m_primitiveType = Mesh::DrawMode::Triangles;

    int m_stride = 0;

};

struct Q_QUICK3DUTILS_EXPORT MeshInternal

    struct MultiMeshInfo {

        quint32 fileId = 0;

        quint32 fileVersion = 0;

        QMap<quint32, quint64> meshEntries;

        static const quint32 FILE_ID = 555777497;

        static const quint32 FILE_VERSION = 1;

        bool isValid() const {

            return fileId == FILE_ID && fileVersion == FILE_VERSION;

        static MultiMeshInfo withDefaults() {

            return { FILE_ID, FILE_VERSION, {} };

};

    struct MeshDataHeader {

        quint32 fileId = 0;

        quint16 fileVersion = 0;

        quint16 flags = 0;

        quint32 sizeInBytes = 0;

        static const quint32 FILE_ID = 3365961549;

        // Version 3 and 4 is only different in the "offset" values that are

        // all zeroes in version 4 because they are not used by the new mesh

        // reader. So to support both with the new loader, no branching is

        // needed at all, it just needs to accept both versions.

        static const quint32 LEGACY_MESH_FILE_VERSION = 3;

        // Version 5 differs from 4 with the added lightmapSizeHint per subset.

        // This needs branching in the deserializer.

        // Version 6 differs from 5 with additional lodCount per subset as well

        // as a list of Level of Detail data after the subset names.

        // Version 7 will split the morph target data

        static const quint32 FILE_VERSION = 7;

        static MeshDataHeader withDefaults() {

            return { FILE_ID, FILE_VERSION, 0, 0 };

        bool isValid() const {

            return fileId == FILE_ID

                    && fileVersion <= FILE_VERSION

                    && fileVersion >= LEGACY_MESH_FILE_VERSION;

        bool hasLightmapSizeHint() const {

            return fileVersion >= 5;

        bool hasLodDataHint() const {

            return fileVersion >= 6;

        bool hasSeparateTargetBuffer() const {

            return fileVersion >= 7;

};

    struct MeshOffsetTracker {

        quint32 startOffset = 0;

        quint32 byteCounter = 0;

        MeshOffsetTracker(int offset)

            : startOffset(offset) {}

        int offset() {

            return startOffset + byteCounter;

        quint32 alignedAdvance(int advanceAmount) {

            advance(advanceAmount);

            quint32 alignmentAmount = 4 - (byteCounter % 4);

            byteCounter += alignmentAmount;

            return alignmentAmount;

        void advance(int advanceAmount) {

            byteCounter += advanceAmount;

};

    struct Subset {

        QByteArray rawNameUtf16;

        quint32 nameLength = 0;

        Mesh::SubsetBounds bounds;

        quint32 offset = 0;

        quint32 count = 0;

        QSize lightmapSizeHint;

        quint32 lodCount = 0;

        Mesh::Subset toMeshSubset() const {

            Mesh::Subset subset;

            // Only as many units as were actually read, less the terminator.

            const qsizetype units = qMin(qsizetype(nameLength), rawNameUtf16.size() / 2);

            if (units > 0)

                subset.name = QString::fromUtf16(reinterpret_cast<const char16_t *>(rawNameUtf16.constData()), units - 1);

            subset.bounds.min = bounds.min;

            subset.bounds.max = bounds.max;

            subset.count = count;

            subset.offset = offset;

            subset.lightmapSizeHint = lightmapSizeHint;

            subset.lods.resize(lodCount);

            return subset;

};

    static MultiMeshInfo readFileHeader(QIODevice *device);

    static void writeFileHeader(QIODevice *device, const MultiMeshInfo &meshFileInfo);

    static quint64 readMeshData(QIODevice *device, quint64 offset, Mesh *mesh, MeshDataHeader *header);

    static void writeMeshHeader(QIODevice *device, const MeshDataHeader &header);

    static quint64 writeMeshData(QIODevice *device, const Mesh &mesh);

    static quint32 byteSizeForComponentType(Mesh::ComponentType componentType) { return quint32(QSSGBaseTypeHelpers::getSizeOfType(componentType)); }

    static const char *getPositionAttrName() { return "attr_pos"; }

    static const char *getNormalAttrName() { return "attr_norm"; }

    static const char *getUV0AttrName() { return "attr_uv0"; }

    static const char *getUV1AttrName() { return "attr_uv1"; }

    static const char *getLightmapUVAttrName() { return "attr_lightmapuv"; }

    static const char *getTexTanAttrName() { return "attr_textan"; }

    static const char *getTexBinormalAttrName() { return "attr_binormal"; }

    static const char *getColorAttrName() { return "attr_color"; }

    static const char *getJointAttrName() { return "attr_joints"; }

    static const char *getWeightAttrName() { return "attr_weights"; }

    static QSSGBounds3 calculateSubsetBounds(const Mesh::VertexBufferEntry &entry,

                                             const QByteArray &vertexBufferData,

                                             quint32 vertexBufferStride,

                                             const QByteArray &indexBufferData,

                                             Mesh::ComponentType indexComponentType,

                                             quint32 subsetCount,

                                             quint32 subsetOffset);

};

size_t Q_QUICK3DUTILS_EXPORT simplifyMesh(unsigned int* destination,

                                          const unsigned int* indices,

                                          size_t indexCount,

                                          const float* vertexPositions,

                                          size_t vertexCount,

                                          size_t vertexPositionsStride,

                                          size_t targetIndexCount,

                                          float targetError,

                                          unsigned int options,

                                          float* resultError);

float Q_QUICK3DUTILS_EXPORT simplifyScale(const float* vertexPositions,

                                          size_t vertexCount,

                                          size_t vertexPositionsStride);

void Q_QUICK3DUTILS_EXPORT optimizeVertexCache(unsigned int* destination,

                                               const unsigned int* indices,

                                               size_t indexCount,

                                               size_t vertexCount);

// A vertex attribute stream for welding; mirrors meshopt_Stream

struct MeshVertexStream

    const void *data;

    size_t elementSize;

    size_t stride;

};

// The largest number of attribute streams generateVertexRemap() accepts

constexpr size_t maxVertexStreams = 16;

// Builds a remap table that welds bitwise-identical vertices across all

// given attribute streams, returning the unique vertex count. streamCount

// must be between 1 and maxVertexStreams, and every stream's elementSize

// must be no larger than its stride.

size_t Q_QUICK3DUTILS_EXPORT generateVertexRemap(unsigned int *destination,

                                                 const unsigned int *indices,

                                                 size_t indexCount,

                                                 size_t vertexCount,

                                                 const MeshVertexStream *streams,

                                                 size_t streamCount);

void Q_QUICK3DUTILS_EXPORT remapVertexBuffer(void *destination,

                                             const void *vertices,

                                             size_t vertexCount,

                                             size_t vertexSize,

                                             const unsigned int *remap);

void Q_QUICK3DUTILS_EXPORT remapIndexBuffer(unsigned int *destination,

                                            const unsigned int *indices,

                                            size_t indexCount,

                                            const unsigned int *remap);

// destination takes indexCount * 4 floats: tangent xyz and bitangent sign

void Q_QUICK3DUTILS_EXPORT generateTangents(float *destination,

                                            const unsigned int *indices,

                                            size_t indexCount,

                                            const float *vertexPositions,

                                            size_t vertexCount,

                                            size_t vertexPositionsStride,

                                            const float *vertexNormals,

                                            size_t vertexNormalsStride,

                                            const float *vertexUvs,

                                            size_t vertexUvsStride);

struct MeshLevelOfDetail

    float distance = 0.0f;

    QVector<quint32> indexes;

};

struct MeshVertexSplit

    quint32 sourceIndex = 0;

    QVector3D normal;

};

// Generates simplified index buffers (levels of detail) for a triangle mesh,

// returned from smallest to largest index count. When normals are

// recalculated, vertices whose new normal deviates more than

// normalSplitAngle from the original are split: the returned LOD indexes

// reference new vertices starting at positions.size(), and the caller must

// append a copy of each reported source vertex with the given normal, in

// order. splitVertices is cleared on entry, so it always describes only the

// call that produced it.

//

// Passing 0.0 for both angles disables normal recalculation, which is also

// what happens when normals is empty. Otherwise normals must be the same

// length as positions. Note that preserving the normals this way also keeps

// vertices that only differ in their normal from being welded together, so a

// mesh with hard edges yields fewer levels, or none at all.

QVector<MeshLevelOfDetail> Q_QUICK3DUTILS_EXPORT generateMeshLevelsOfDetail(

        const QVector<QVector3D> &positions,

        const QVector<QVector3D> &normals,

        const QVector<quint32> &indexes,

        QVector<MeshVertexSplit> &splitVertices,

        float normalMergeAngle = 60.0f,

        float normalSplitAngle = 25.0f);

} // namespace QSSGMesh

QT_END_NAMESPACE

#endif // QSSGMESHUTILITIES_P_H