qt-everywhere-src-5.15.1/qtquick3d/tools/meshdebug/main.cpp - orbit - Git at Google

 /****************************************************************************
 **
 ** Copyright (C) 2019 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of Qt Quick 3D.
 **
 ** $QT_BEGIN_LICENSE:GPL$
 ** 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 General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU
 ** General Public License version 3 or (at your option) 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.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-3.0.html.
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include <QtCore/QCoreApplication>
 #include <QtCore/QCommandLineParser>
 #include <QtCore/QDebug>

 #include <QtQuick3DAssetImport/private/qssgmeshutilities_p.h>

 #include <QtGui/QMatrix4x4>

 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
 // QTextStream functions are moved to a namespace in Qt6
 using Qt::hex;
 #endif

 using namespace QSSGMeshUtilities;

 class MeshOffsetTracker
 {
 public:
     MeshOffsetTracker(qint64 startOffset)
         : m_startOffset(startOffset)
     {
     }

     bool needsAlignment() { return getAlignmentAmount() > 0; }
     quint32 getAlignmentAmount() { return 4 - (m_byteCounter % 4); }
     void align()
     {
         if (needsAlignment())
             m_byteCounter += getAlignmentAmount();
     }

     void advance(qint64 offset, bool forceAlign = true) {
         m_byteCounter += offset;
         if (forceAlign)
             align();
     }

     template <typename TDataType>
     void advance(OffsetDataRef<TDataType> &data, bool forceAlign = true)
     {
         data.m_offset = m_byteCounter;
         m_byteCounter += data.size() * sizeof(TDataType);
         if (forceAlign)
             align();
     }

     qint64 startOffset() const
     {
         return m_startOffset;
     }

     qint64 offset() const
     {
         return m_startOffset + m_byteCounter;
     }

 private:
     qint64 m_startOffset = 0;
     qint64 m_byteCounter = 0;
 };


 int main(int argc, char *argv[])
 {
     QCoreApplication app(argc, argv);

     // Setup command line arguments
     QCommandLineParser cmdLineParser;
     cmdLineParser.process(app);
     QStringList meshFileNames = cmdLineParser.positionalArguments();

     // if there is nothing to do return early
     if (meshFileNames.isEmpty())
         return -1;

     // Process Mesh files
     for (const auto &meshFileName : meshFileNames) {
         QFile meshFile(meshFileName);
         if (!meshFile.open(QIODevice::ReadOnly)) {
             qWarning() << "could not open " << meshFileName;
             continue;
         }

         if (Mesh::isMulti(meshFile)) {
             MeshMultiHeader* multiHeader = Mesh::loadMultiHeader(meshFile);
             if (!multiHeader) {
                 qWarning() << "could not read MeshMultiHeader in " << meshFileName;
                 continue;
             }

             // Print Multiheader information
             qDebug() << " -- Multiheader -- ";
             qDebug() << "fileId: " << multiHeader->m_fileId;
             qDebug() << "version: " << multiHeader->m_version;
             qDebug() << "mesh entries: " << multiHeader->m_entries.m_size;

             quint8 *theHeaderBaseAddr = reinterpret_cast<quint8 *>(multiHeader);
             bool foundMesh = false;
             for (quint32 idx = 0, end = multiHeader->m_entries.size(); idx < end && !foundMesh; ++idx) {
                 const MeshMultiEntry &entry(multiHeader->m_entries.index(theHeaderBaseAddr, idx));
                 qDebug() << "\t -- mesh entry" << idx << " -- ";
                 qDebug() << "\tid: " << entry.m_meshId;
                 qDebug() << "\toffset: " << Qt::hex << entry.m_meshOffset;
                 qDebug() << "\tpadding: " << entry.m_padding;

                 meshFile.seek(entry.m_meshOffset);

                 // Read mesh header
                 MeshDataHeader header;
                 meshFile.read(reinterpret_cast<char *>(&header), sizeof(MeshDataHeader));
                 qDebug() << "\t -- MeshDataHeader -- ";
                 qDebug() << "\tfileId: " << header.m_fileId;
                 qDebug() << "\tfileVersion: " << header.m_fileVersion;
                 qDebug() << "\tflags: " << header.m_headerFlags;
                 qDebug() << "\tsize(in bytes): " << header.m_sizeInBytes;

                 QByteArray meshMetadataData = meshFile.read(sizeof(Mesh));
                 Mesh *mesh = reinterpret_cast<Mesh *>(meshMetadataData.data());
                 MeshOffsetTracker offsetTracker(entry.m_meshOffset + sizeof(MeshDataHeader));
                 offsetTracker.advance(sizeof(Mesh), false);

                 // Vertex Buffer
                 qDebug() << "\t\t -- Vertex Buffer --";
                 meshFile.seek(offsetTracker.offset());
                 offsetTracker.advance(mesh->m_vertexBuffer.m_entries);
                 qDebug() << "\t\tentries offset: " << Qt::hex << mesh->m_vertexBuffer.m_entries.m_offset;
                 qDebug() << "\t\tentries size: " << mesh->m_vertexBuffer.m_entries.m_size * sizeof(MeshVertexBufferEntry);
                 QByteArray vertexBufferEntriesData = meshFile.read(mesh->m_vertexBuffer.m_entries.m_size * sizeof(MeshVertexBufferEntry));
                 for (quint32 idx = 0, end = mesh->m_vertexBuffer.m_entries.size(); idx < end; ++idx) {
                     // get name length
                     meshFile.seek(offsetTracker.offset());
                     QByteArray lenghtBuffer = meshFile.read(sizeof (quint32));
                     const quint32 &nameLenght = *reinterpret_cast<const quint32 *>(lenghtBuffer.constData());
                     offsetTracker.advance(sizeof(quint32), false);
                     QByteArray nameBuffer = meshFile.read(nameLenght);
                     offsetTracker.advance(nameLenght);
                     qDebug() << "\t\t\t -- Vertex Buffer Entry " << idx << "-- ";
                     const MeshVertexBufferEntry &entry = reinterpret_cast<const MeshVertexBufferEntry *>(vertexBufferEntriesData.constData())[idx];
                     qDebug() << "\t\t\tname: " << nameBuffer.constData();
                     qDebug() << "\t\t\ttype: " << toString(entry.m_componentType);
                     qDebug() << "\t\t\tnumComponents: " << entry.m_numComponents;
                     qDebug() << "\t\t\tfirstItemOffset: " << entry.m_firstItemOffset;
                 }
                 offsetTracker.advance(mesh->m_vertexBuffer.m_data);
                 qDebug() << "\t\tstride: " << mesh->m_vertexBuffer.m_stride;
                 qDebug() << "\t\tdata Offset: " << Qt::hex << mesh->m_vertexBuffer.m_data.m_offset;
                 qDebug() << "\t\tdata Size: " << mesh->m_vertexBuffer.m_data.m_size * sizeof(quint8);

                 // Index Buffer
                 qDebug() << "\t\t -- Index Buffer -- ";
                 offsetTracker.advance(mesh->m_indexBuffer.m_data);
                 qDebug() << "\t\tcomponentType: " << toString(mesh->m_indexBuffer.m_componentType);
                 qDebug() << "\t\tdata Offset: " << Qt::hex << mesh->m_indexBuffer.m_data.m_offset;
                 qDebug() << "\t\tdata Size: " << mesh->m_indexBuffer.m_data.m_size * sizeof(quint8);

                 // Subsets
                 qDebug() << "\t\t -- Subsets -- ";
                 meshFile.seek(offsetTracker.offset());
                 offsetTracker.advance(mesh->m_subsets);
                 qDebug() << "\t\toffset: " << Qt::hex << mesh->m_subsets.m_offset;
                 qDebug() << "\t\tsize: " << mesh->m_subsets.m_size * sizeof(MeshSubset);
                 QByteArray subsetEntriesData = meshFile.read(mesh->m_subsets.m_size * sizeof(MeshSubset));
                 for (quint32 idx = 0, end = mesh->m_subsets.size(); idx < end; ++idx) {
                     qDebug() << "\t\t -- Subset " << idx << "-- ";
                     MeshSubset &subset = reinterpret_cast<MeshSubset *>(subsetEntriesData.data())[idx];
                     qDebug() << "\t\thasCount: " << subset.hasCount();
                     qDebug() << "\t\tcount: " << subset.m_count;
                     qDebug() << "\t\toffset(size): " << subset.m_offset;
                     qDebug() << "\t\tbounds: (" << subset.m_bounds.minimum.x() << "," <<
                                 subset.m_bounds.minimum.y() << "," <<
                                 subset.m_bounds.minimum.z() << ") (" <<
                                 subset.m_bounds.maximum.x() << "," <<
                                 subset.m_bounds.maximum.y() << "," <<
                                 subset.m_bounds.maximum.z() << ")";
                     meshFile.seek(offsetTracker.offset());
                     offsetTracker.advance(subset.m_name);
                     qDebug() << "\t\tname offset: " << Qt::hex << subset.m_name.m_offset;
                     qDebug() << "\t\tname size: " << subset.m_name.m_size * sizeof(char16_t);
                     QByteArray subsetNameBuffer = meshFile.read(subset.m_name.m_size * sizeof(char16_t));
                     const char16_t* name = reinterpret_cast<const char16_t*>(subsetNameBuffer.constData());
                     qDebug() << "\t\tname: " << QString::fromUtf16(name);
                 }

                 // Joints
                 qDebug() << "\t\t -- Joints -- ";
                 meshFile.seek(offsetTracker.offset());
                 offsetTracker.advance(mesh->m_joints);
                 qDebug() << "\t\toffset: " << Qt::hex << mesh->m_joints.m_offset;
                 qDebug() << "\t\tsize: " << mesh->m_joints.m_size * sizeof(Joint);
                 QByteArray jointsData = meshFile.read(mesh->m_joints.m_size * sizeof(Joint));
                 for (quint32 idx = 0, end = mesh->m_joints.size(); idx < end; ++idx) {
                     qDebug() << "\t\t -- Joint " << idx << "-- ";
                     const Joint &joint = reinterpret_cast<const Joint *>(jointsData.constData())[idx];
                     qDebug() << "\t\tid: " << joint.m_jointID;
                     qDebug() << "\t\tparentId: " << joint.m_parentID;
                     qDebug() << "\t\tinvBindPose: " << QMatrix4x4(joint.m_invBindPose);
                     qDebug() << "\t\tlocalToGlobalBoneSpace: " << QMatrix4x4(joint.m_localToGlobalBoneSpace);
                 }

                 // Draw Mode
                 qDebug() << "\t\tdraw Mode: " << static_cast<int>(mesh->m_drawMode);

                 // Winding
                 qDebug() << "\t\twinding: " << toString(mesh->m_winding);

             }

         }

         meshFile.close();
         qDebug() << "closed meshFile";
     }

     return 0;
 }
	/****************************************************************************
	**
	** Copyright (C) 2019 The Qt Company Ltd.
	** Contact: https://www.qt.io/licensing/
	**
	** This file is part of Qt Quick 3D.
	**
	** $QT_BEGIN_LICENSE:GPL$
	** 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 General Public License Usage
	** Alternatively, this file may be used under the terms of the GNU
	** General Public License version 3 or (at your option) 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.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-3.0.html.
	**
	** $QT_END_LICENSE$
	**
	****************************************************************************/

	#include <QtCore/QCoreApplication>
	#include <QtCore/QCommandLineParser>
	#include <QtCore/QDebug>

	#include <QtQuick3DAssetImport/private/qssgmeshutilities_p.h>

	#include <QtGui/QMatrix4x4>

	#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
	// QTextStream functions are moved to a namespace in Qt6
	using Qt::hex;
	#endif

	using namespace QSSGMeshUtilities;

	class MeshOffsetTracker
	{
	public:
	MeshOffsetTracker(qint64 startOffset)
	: m_startOffset(startOffset)
	{
	}

	bool needsAlignment() { return getAlignmentAmount() > 0; }
	quint32 getAlignmentAmount() { return 4 - (m_byteCounter % 4); }
	void align()
	{
	if (needsAlignment())
	m_byteCounter += getAlignmentAmount();
	}

	void advance(qint64 offset, bool forceAlign = true) {
	m_byteCounter += offset;
	if (forceAlign)
	align();
	}

	template <typename TDataType>
	void advance(OffsetDataRef<TDataType> &data, bool forceAlign = true)
	{
	data.m_offset = m_byteCounter;
	m_byteCounter += data.size() * sizeof(TDataType);
	if (forceAlign)
	align();
	}

	qint64 startOffset() const
	{
	return m_startOffset;
	}

	qint64 offset() const
	{
	return m_startOffset + m_byteCounter;
	}

	private:
	qint64 m_startOffset = 0;
	qint64 m_byteCounter = 0;
	};


	int main(int argc, char *argv[])
	{
	QCoreApplication app(argc, argv);

	// Setup command line arguments
	QCommandLineParser cmdLineParser;
	cmdLineParser.process(app);
	QStringList meshFileNames = cmdLineParser.positionalArguments();

	// if there is nothing to do return early
	if (meshFileNames.isEmpty())
	return -1;

	// Process Mesh files
	for (const auto &meshFileName : meshFileNames) {
	QFile meshFile(meshFileName);
	if (!meshFile.open(QIODevice::ReadOnly)) {
	qWarning() << "could not open " << meshFileName;
	continue;
	}

	if (Mesh::isMulti(meshFile)) {
	MeshMultiHeader* multiHeader = Mesh::loadMultiHeader(meshFile);
	if (!multiHeader) {
	qWarning() << "could not read MeshMultiHeader in " << meshFileName;
	continue;
	}

	// Print Multiheader information
	qDebug() << " -- Multiheader -- ";
	qDebug() << "fileId: " << multiHeader->m_fileId;
	qDebug() << "version: " << multiHeader->m_version;
	qDebug() << "mesh entries: " << multiHeader->m_entries.m_size;

	quint8 theHeaderBaseAddr = reinterpret_cast<quint8 >(multiHeader);
	bool foundMesh = false;
	for (quint32 idx = 0, end = multiHeader->m_entries.size(); idx < end && !foundMesh; ++idx) {
	const MeshMultiEntry &entry(multiHeader->m_entries.index(theHeaderBaseAddr, idx));
	qDebug() << "\t -- mesh entry" << idx << " -- ";
	qDebug() << "\tid: " << entry.m_meshId;
	qDebug() << "\toffset: " << Qt::hex << entry.m_meshOffset;
	qDebug() << "\tpadding: " << entry.m_padding;

	meshFile.seek(entry.m_meshOffset);

	// Read mesh header
	MeshDataHeader header;
	meshFile.read(reinterpret_cast<char *>(&header), sizeof(MeshDataHeader));
	qDebug() << "\t -- MeshDataHeader -- ";
	qDebug() << "\tfileId: " << header.m_fileId;
	qDebug() << "\tfileVersion: " << header.m_fileVersion;
	qDebug() << "\tflags: " << header.m_headerFlags;
	qDebug() << "\tsize(in bytes): " << header.m_sizeInBytes;

	QByteArray meshMetadataData = meshFile.read(sizeof(Mesh));
	Mesh mesh = reinterpret_cast<Mesh >(meshMetadataData.data());
	MeshOffsetTracker offsetTracker(entry.m_meshOffset + sizeof(MeshDataHeader));
	offsetTracker.advance(sizeof(Mesh), false);

	// Vertex Buffer
	qDebug() << "\t\t -- Vertex Buffer --";
	meshFile.seek(offsetTracker.offset());
	offsetTracker.advance(mesh->m_vertexBuffer.m_entries);
	qDebug() << "\t\tentries offset: " << Qt::hex << mesh->m_vertexBuffer.m_entries.m_offset;
	qDebug() << "\t\tentries size: " << mesh->m_vertexBuffer.m_entries.m_size * sizeof(MeshVertexBufferEntry);
	QByteArray vertexBufferEntriesData = meshFile.read(mesh->m_vertexBuffer.m_entries.m_size * sizeof(MeshVertexBufferEntry));
	for (quint32 idx = 0, end = mesh->m_vertexBuffer.m_entries.size(); idx < end; ++idx) {
	// get name length
	meshFile.seek(offsetTracker.offset());
	QByteArray lenghtBuffer = meshFile.read(sizeof (quint32));
	const quint32 &nameLenght = reinterpret_cast<const quint32 >(lenghtBuffer.constData());
	offsetTracker.advance(sizeof(quint32), false);
	QByteArray nameBuffer = meshFile.read(nameLenght);
	offsetTracker.advance(nameLenght);
	qDebug() << "\t\t\t -- Vertex Buffer Entry " << idx << "-- ";
	const MeshVertexBufferEntry &entry = reinterpret_cast<const MeshVertexBufferEntry *>(vertexBufferEntriesData.constData())[idx];
	qDebug() << "\t\t\tname: " << nameBuffer.constData();
	qDebug() << "\t\t\ttype: " << toString(entry.m_componentType);
	qDebug() << "\t\t\tnumComponents: " << entry.m_numComponents;
	qDebug() << "\t\t\tfirstItemOffset: " << entry.m_firstItemOffset;
	}
	offsetTracker.advance(mesh->m_vertexBuffer.m_data);
	qDebug() << "\t\tstride: " << mesh->m_vertexBuffer.m_stride;
	qDebug() << "\t\tdata Offset: " << Qt::hex << mesh->m_vertexBuffer.m_data.m_offset;
	qDebug() << "\t\tdata Size: " << mesh->m_vertexBuffer.m_data.m_size * sizeof(quint8);

	// Index Buffer
	qDebug() << "\t\t -- Index Buffer -- ";
	offsetTracker.advance(mesh->m_indexBuffer.m_data);
	qDebug() << "\t\tcomponentType: " << toString(mesh->m_indexBuffer.m_componentType);
	qDebug() << "\t\tdata Offset: " << Qt::hex << mesh->m_indexBuffer.m_data.m_offset;
	qDebug() << "\t\tdata Size: " << mesh->m_indexBuffer.m_data.m_size * sizeof(quint8);

	// Subsets
	qDebug() << "\t\t -- Subsets -- ";
	meshFile.seek(offsetTracker.offset());
	offsetTracker.advance(mesh->m_subsets);
	qDebug() << "\t\toffset: " << Qt::hex << mesh->m_subsets.m_offset;
	qDebug() << "\t\tsize: " << mesh->m_subsets.m_size * sizeof(MeshSubset);
	QByteArray subsetEntriesData = meshFile.read(mesh->m_subsets.m_size * sizeof(MeshSubset));
	for (quint32 idx = 0, end = mesh->m_subsets.size(); idx < end; ++idx) {
	qDebug() << "\t\t -- Subset " << idx << "-- ";
	MeshSubset &subset = reinterpret_cast<MeshSubset *>(subsetEntriesData.data())[idx];
	qDebug() << "\t\thasCount: " << subset.hasCount();
	qDebug() << "\t\tcount: " << subset.m_count;
	qDebug() << "\t\toffset(size): " << subset.m_offset;
	qDebug() << "\t\tbounds: (" << subset.m_bounds.minimum.x() << "," <<
	subset.m_bounds.minimum.y() << "," <<
	subset.m_bounds.minimum.z() << ") (" <<
	subset.m_bounds.maximum.x() << "," <<
	subset.m_bounds.maximum.y() << "," <<
	subset.m_bounds.maximum.z() << ")";
	meshFile.seek(offsetTracker.offset());
	offsetTracker.advance(subset.m_name);
	qDebug() << "\t\tname offset: " << Qt::hex << subset.m_name.m_offset;
	qDebug() << "\t\tname size: " << subset.m_name.m_size * sizeof(char16_t);
	QByteArray subsetNameBuffer = meshFile.read(subset.m_name.m_size * sizeof(char16_t));
	const char16_t* name = reinterpret_cast<const char16_t*>(subsetNameBuffer.constData());
	qDebug() << "\t\tname: " << QString::fromUtf16(name);
	}

	// Joints
	qDebug() << "\t\t -- Joints -- ";
	meshFile.seek(offsetTracker.offset());
	offsetTracker.advance(mesh->m_joints);
	qDebug() << "\t\toffset: " << Qt::hex << mesh->m_joints.m_offset;
	qDebug() << "\t\tsize: " << mesh->m_joints.m_size * sizeof(Joint);
	QByteArray jointsData = meshFile.read(mesh->m_joints.m_size * sizeof(Joint));
	for (quint32 idx = 0, end = mesh->m_joints.size(); idx < end; ++idx) {
	qDebug() << "\t\t -- Joint " << idx << "-- ";
	const Joint &joint = reinterpret_cast<const Joint *>(jointsData.constData())[idx];
	qDebug() << "\t\tid: " << joint.m_jointID;
	qDebug() << "\t\tparentId: " << joint.m_parentID;
	qDebug() << "\t\tinvBindPose: " << QMatrix4x4(joint.m_invBindPose);
	qDebug() << "\t\tlocalToGlobalBoneSpace: " << QMatrix4x4(joint.m_localToGlobalBoneSpace);
	}

	// Draw Mode
	qDebug() << "\t\tdraw Mode: " << static_cast<int>(mesh->m_drawMode);

	// Winding
	qDebug() << "\t\twinding: " << toString(mesh->m_winding);

	}

	}

	meshFile.close();
	qDebug() << "closed meshFile";
	}

	return 0;
	}