#include "CLIPipeline.h"

#include "Manager.h"

#include "MeshImporterExporter.h"

#include "AnimationMerger.h"

#include "MeshValidator.h"

#include "MeshLodController.h"

#include "SelectionSet.h"

#include "SentryReporter.h"

#include "ScanConfig.h"

#include "ScanEngine.h"

#include "FBX/FBXExporter.h"

#include "MaterialPresetLibrary.h"

#include "TextureChannelPacker.h"

#include "TextureAtlasPacker.h"

#include "ApplyAtlas.h"

#include "NormalMapGenerator.h"

#include "MemoryEstimator.h"

#include "DrawCallAnalyzer.h"

#include "VertexCacheOptimizer.h"

#include "MeshDecimator.h"

#include "EditableMesh.h"

#include "TexturePaintBuffer.h"

#include "VertexColorBaker.h"

#include "VATBaker.h"

#include "MorphAnimationManager.h"

#include "NodeAnimationManager.h"

#include "PoseLibrary.h"

#include "QtMeshCloudClient.h"

#include <OgreMaterialSerializer.h>

#include <QApplication>

#include <QWidget>

#include <QDir>

#include <QFileInfo>

#include <QJsonDocument>

#include <QMap>

#include <QDebug>

#include <QTextStream>

#include <QLocale>

#include <QSysInfo>

#include <assimp/Importer.hpp>

#include <assimp/Exporter.hpp>

#include <assimp/postprocess.h>

#include <assimp/scene.h>

#include <OgreSubMesh.h>

#include <unordered_map>

#include <vector>

#include <memory>

#include <set>

#include <cstdio>

#ifndef Q_OS_WIN

#include <unistd.h>

#else

#include <io.h>

#endif

static int s_savedStdoutFd = -1;

static void cliWrite(const QString& text)

}

static aiMatrix4x4 ogreTransformToAi(const Ogre::Vector3& pos,

}

static aiScene* buildAnimOnlyAiSceneFromSkeleton(const Ogre::Skeleton* skel)

{

if (!skel)

return nullptr;

auto* scene = new aiScene();

// Root node

scene->mRootNode = new aiNode();

scene->mRootNode->mName = aiString("RootNode");

scene->mRootNode->mTransformation = aiMatrix4x4(); // identity

// Build bone node tree.

std::unordered_map<const Ogre::Bone*, aiNode*> boneToNode;

boneToNode.reserve(skel->getNumBones());

auto makeNodeForBone = [&](const Ogre::Bone* b) -> aiNode* {

auto it = boneToNode.find(b);

if (it != boneToNode.end())

return it->second;

auto* n = new aiNode();

n->mName = aiString(b->getName().c_str());

n->mTransformation = ogreTransformToAi(b->getPosition(), b->getOrientation(), b->getScale());

boneToNode[b] = n;

return n;

};

// Attach root bones under scene root; attach children under parents.

std::vector<aiNode*> rootBones;

rootBones.reserve(skel->getNumBones());

for (unsigned short i = 0; i < skel->getNumBones(); ++i) {

const Ogre::Bone* b = skel->getBone(i);

if (!b)

continue;

aiNode* node = makeNodeForBone(b);

const Ogre::Node* parent = b->getParent();

const Ogre::Bone* parentBone = dynamic_cast<const Ogre::Bone*>(parent);

if (!parentBone) {

rootBones.push_back(node);

continue;

}

aiNode* parentNode = makeNodeForBone(parentBone);

// Append as child

aiNode** newChildren = new aiNode*[parentNode->mNumChildren + 1];

for (unsigned int ci = 0; ci < parentNode->mNumChildren; ++ci)

newChildren[ci] = parentNode->mChildren[ci];

newChildren[parentNode->mNumChildren] = node;

delete[] parentNode->mChildren;

parentNode->mChildren = newChildren;

parentNode->mNumChildren += 1;

node->mParent = parentNode;

}

if (!rootBones.empty()) {

scene->mRootNode->mChildren = new aiNode*[rootBones.size()];

scene->mRootNode->mNumChildren = static_cast<unsigned int>(rootBones.size());

for (unsigned int i = 0; i < scene->mRootNode->mNumChildren; ++i) {

scene->mRootNode->mChildren[i] = rootBones[i];

rootBones[i]->mParent = scene->mRootNode;

}

}

// Animations

scene->mNumAnimations = skel->getNumAnimations();

scene->mAnimations = scene->mNumAnimations ? new aiAnimation*[scene->mNumAnimations] : nullptr;

for (unsigned short ai = 0; ai < skel->getNumAnimations(); ++ai) {

const Ogre::Animation* anim = skel->getAnimation(ai);

auto* a = new aiAnimation();

a->mName = aiString(anim->getName().c_str());

a->mDuration = anim->getLength();

a->mTicksPerSecond = 1.0; // key times are in seconds

// Collect bone tracks.

std::vector<const Ogre::NodeAnimationTrack*> tracks;

tracks.reserve(anim->getNumNodeTracks());

for (unsigned short ti = 0; ti < anim->getNumNodeTracks(); ++ti) {

const Ogre::NodeAnimationTrack* t = anim->getNodeTrack(ti);

if (t)

tracks.push_back(t);

}

a->mNumChannels = static_cast<unsigned int>(tracks.size());

a->mChannels = a->mNumChannels ? new aiNodeAnim*[a->mNumChannels] : nullptr;

for (unsigned int ci = 0; ci < a->mNumChannels; ++ci) {

const Ogre::NodeAnimationTrack* t = tracks[ci];

const Ogre::Node* target = t->getAssociatedNode();

const Ogre::Bone* bone = dynamic_cast<const Ogre::Bone*>(target);

auto* ch = new aiNodeAnim();

ch->mNodeName = aiString(bone ? bone->getName().c_str() : "Unknown");

const unsigned short kCount = t->getNumKeyFrames();

ch->mNumPositionKeys = kCount;

ch->mNumRotationKeys = kCount;

ch->mNumScalingKeys = kCount;

ch->mPositionKeys = kCount ? new aiVectorKey[kCount] : nullptr;

ch->mRotationKeys = kCount ? new aiQuatKey[kCount] : nullptr;

ch->mScalingKeys = kCount ? new aiVectorKey[kCount] : nullptr;

for (unsigned short ki = 0; ki < kCount; ++ki) {

const Ogre::TransformKeyFrame* kf = t->getNodeKeyFrame(ki);

const double time = kf->getTime();

const Ogre::Vector3 p = kf->getTranslate();

const Ogre::Quaternion r = kf->getRotation();

const Ogre::Vector3 s = kf->getScale();

ch->mPositionKeys[ki].mTime = time;

ch->mPositionKeys[ki].mValue = aiVector3D(p.x, p.y, p.z);

ch->mRotationKeys[ki].mTime = time;

ch->mRotationKeys[ki].mValue = aiQuaternion(r.w, r.x, r.y, r.z);

ch->mScalingKeys[ki].mTime = time;

ch->mScalingKeys[ki].mValue = aiVector3D(s.x, s.y, s.z);

}

a->mChannels[ci] = ch;

}

scene->mAnimations[ai] = a;

}

return scene;

}

static QString assimpExportFormatIdForAnimOnlyPath(const QString& outputPath)

}

static bool exportAnimOnlyViaAssimp(const Ogre::SkeletonPtr& skel, const QString& outputPath, QString* outError = nullptr)

}

static bool exportAnimOnly(const Ogre::SkeletonPtr& skel, const QString& outputPath, QString* outError = nullptr)

}

static bool cliSupportsColor()

}

static QString colorizeWord(const QString& text, const char* ansiColor, bool enabled)

}

static QString colorizeIconWhenPositive(const QString& icon, int value, const char* ansiColor, bool enabled)

}

static QString scanStatusLabel(bool hasError, bool hasWarning, bool colorize)

}

static QString findingSeverityTag(const Finding& f)

}

static QString formatScanAssetLine(const AssetInfo& asset, const QList<Finding>& findings, bool colorize)

}

static QString formatScanSummary(const ScanResult& result, bool colorize)

}

static QTextStream& err()

{

static QTextStream s(stderr);

return s;

}

static QString resolveIngestToken(const QString& flagToken)

}

#ifndef QTMESH_CLOUD_WEB_URL

#define QTMESH_CLOUD_WEB_URL "https://qtmesh.dev"

#endif

static void maybePrintCloudPromo(bool jsonOutput, const QString& flagToken = {})

}

static bool s_verbose = false;

static bool s_noTelemetry = false;

static void cliMessageHandler(QtMsgType type, const QMessageLogContext& ctx, const QString& msg)

}

static void redirectStdout()

}

void CLIPipeline::printVersion()

{

cliWrite(QString("qtmesh %1\n").arg(QTMESHEDITOR_VERSION));

}

void CLIPipeline::printUsage()

}

QString CLIPipeline::formatForExtension(const QString& path)

}

bool CLIPipeline::initOgreHeadless()

}

MeshInfo CLIPipeline::extractMeshInfo(const Ogre::Entity* entity, const QString& fileName)

}

QString CLIPipeline::formatMeshInfoText(const MeshInfo& info)

}

QString CLIPipeline::formatMeshInfoJson(const MeshInfo& info)

}

int CLIPipeline::run(int argc, char* argv[])