fix(scan): stabilize scan --fix + better output + FSAA default

src/AnimationMerger.cpp

@@ -8,6 +8,8 @@
 #include <QRegularExpression>
 #include <cctype>
 #include <unordered_map>
+#include <vector>
+#include <cmath>
 
 // Registry: skeleton name → up-axis (1=Y-up, 2=Z-up).
 // Populated by AnimationMerger::registerSkeletonUpAxis() at import time.
@@ -586,6 +588,8 @@ int AnimationMerger::simplifyAnimation(Ogre::Skeleton* skel,
     newAnim->setRotationInterpolationMode(rotInterpMode);
 
     for (const auto& td : tracks) {
+        if (td.keys.empty())
+            continue;
         auto* newTrack = newAnim->createNodeTrack(td.handle);
         if (td.associatedNode)
             newTrack->setAssociatedNode(td.associatedNode);

src/Assimp/Importer.cpp

@@ -33,6 +33,7 @@
 #include "BoneProcessor.h"
 #include "MeshProcessor.h"
 #include <algorithm>
+#include <string_view>
 
 Ogre::MeshPtr AssimpToOgreImporter::loadModel(const std::string& path, bool convertToLeftHanded, unsigned int additionalFlags) {
     skeleton.reset();  // Clear any skeleton from a previous import
@@ -59,15 +60,54 @@
         flags |= aiProcess_ConvertToLeftHanded;
     flags |= additionalFlags;
 
+    auto pathEndsWithInsensitive = [](const std::string& p, std::string_view suf) -> bool {
+        const size_t n = suf.size();
+        if (p.size() < n)
+            return false;
+        for (size_t i = 0; i < n; ++i) {
+            char a = p[p.size() - n + i];
+            char b = suf[i];
+            if (a >= 'A' && a <= 'Z')
+                a = static_cast<char>(a - 'A' + 'a');
+            if (b >= 'A' && b <= 'Z')
+                b = static_cast<char>(b - 'A' + 'a');
+            if (a != b)
+                return false;
+        }
+        return true;
+    };
+
     const aiScene* scene = importer.ReadFile(path, flags);
     // Do this immediately after ReadFile while the scene is still valid.
     m_sceneUpAxis = 1; // default: Y-up
     if (scene && scene->mMetaData)
         scene->mMetaData->Get("UpAxis", m_sceneUpAxis);
 
+    // Some FBX animation takes fail the full post-process stack (null scene or no root)
+    // but load with a lighter flag set. Retry once before giving up.
+    if ((!scene || !scene->mRootNode) &&
+        (pathEndsWithInsensitive(path, ".fbx") || pathEndsWithInsensitive(path, ".fbxa"))) {
+        unsigned int lightFlags = aiProcess_Triangulate |
+                                  aiProcess_ValidateDataStructure |
+                                  aiProcess_LimitBoneWeights |
+                                  aiProcess_PopulateArmatureData |
+                                  aiProcess_GlobalScale;
+        if (convertToLeftHanded)
+            lightFlags |= aiProcess_ConvertToLeftHanded;
+        lightFlags |= additionalFlags;
+        importer.SetPropertyBool(AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS, false);
+        scene = importer.ReadFile(path, lightFlags);
+        m_sceneUpAxis = 1;
+        if (scene && scene->mMetaData)
+            scene->mMetaData->Get("UpAxis", m_sceneUpAxis);
+    }
+
     // A null scene or missing root node is always fatal.
     if(!scene || !scene->mRootNode) {
-        Ogre::LogManager::getSingleton().logError("ERROR::ASSIMP::" + std::string(importer.GetErrorString()));
+        const char* errStr = importer.GetErrorString();
+        const std::string errMsg = (errStr && *errStr) ? std::string(errStr)
+                                                       : std::string("ReadFile failed (no scene / no root node)");
+        Ogre::LogManager::getSingleton().logError("ERROR::ASSIMP::" + errMsg);
         return {};
     }
     // animationOnly: the scene has no geometry (e.g. Unreal Engine retarget FBX).

src/Assimp/MaterialProcessor.cpp

@@ -1,6 +1,25 @@
 #include "MaterialProcessor.h"
 #include "RTShaderHelper.h"
 
+namespace {
+static Ogre::Pass* ensureFirstPass(const Ogre::MaterialPtr& mat)
+{
+    if (!mat)
+        return nullptr;
+    Ogre::Technique* tech = nullptr;
+    if (mat->getNumTechniques() == 0)
+        tech = mat->createTechnique();
+    else
+        tech = mat->getTechnique(0);
+
+    if (!tech)
+        return nullptr;
+    if (tech->getNumPasses() == 0)
+        return tech->createPass();
+    return tech->getPass(0);
+}
+} // namespace
+
 void MaterialProcessor::loadScene(const aiScene* scene)
 {
     for(auto i = 0u; i < scene->mNumMaterials; i++) {
@@ -42,37 +61,43 @@
             }
             if(normalTexPtr) {
                 Ogre::LogManager::getSingleton().logMessage("MaterialProcessor: Applying RTSS normal map '" + normalFilename + "' to existing material '" + materialName + "'");
+                // Some materials can exist without any techniques/passes (e.g. partially loaded
+                // script materials). Ensure a valid pass exists before RTSS touches it.
+                (void)ensureFirstPass(existingMaterial);
                 applyRTSSNormalMap(existingMaterial, normalTexPtr->getName());
             }
         }
         return existingMaterial;
     }
 
     Ogre::MaterialPtr ogreMaterial = Ogre::MaterialManager::getSingleton().create(materialName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
+    Ogre::Pass* pass = ensureFirstPass(ogreMaterial);
+    if (!pass)
+        return ogreMaterial;
 
     aiColor3D color(0.f, 0.f, 0.f);
     if(AI_SUCCESS == material->Get(AI_MATKEY_COLOR_DIFFUSE, color)) {
-        ogreMaterial->getTechnique(0)->getPass(0)->setDiffuse(color.r, color.g, color.b, 1.0f);
+        pass->setDiffuse(color.r, color.g, color.b, 1.0f);
     }
 
     if(AI_SUCCESS == material->Get(AI_MATKEY_COLOR_AMBIENT, color)) {
         // PBR-workflow exporters often set ambient to (0,0,0) which kills ambient
         // lighting in Ogre's Phong model. Keep Ogre's default (white) in that case.
         if(color.r > 0.001f || color.g > 0.001f || color.b > 0.001f)
-            ogreMaterial->getTechnique(0)->getPass(0)->setAmbient(color.r, color.g, color.b);
+            pass->setAmbient(color.r, color.g, color.b);
     }
 
     if(AI_SUCCESS == material->Get(AI_MATKEY_COLOR_SPECULAR, color)) {
-        ogreMaterial->getTechnique(0)->getPass(0)->setSpecular(color.r, color.g, color.b, 1.0f);
+        pass->setSpecular(color.r, color.g, color.b, 1.0f);
     }
 
     if(AI_SUCCESS == material->Get(AI_MATKEY_COLOR_EMISSIVE, color)) {
-        ogreMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(color.r, color.g, color.b);
+        pass->setSelfIllumination(color.r, color.g, color.b);
     }
 
     float shininess = 0.0f;
     if(AI_SUCCESS == material->Get(AI_MATKEY_SHININESS, shininess)) {
-        ogreMaterial->getTechnique(0)->getPass(0)->setShininess(shininess);
+        pass->setShininess(shininess);
     }
 
     // Handle textures
@@ -85,7 +110,7 @@
         if(!texturePtr){
             texturePtr = loadTexture(textureFilename, path, scene);
         }
-        auto* tus = ogreMaterial->getTechnique(0)->getPass(0)->createTextureUnitState(texturePtr->getName());
+        auto* tus = pass->createTextureUnitState(texturePtr->getName());
         tus->setName("diffuse_map");
     }