feat(ps1): TMD mesh + TIM texture import

qml/TexturePropertiesPanel.qml

@@ -84,9 +84,9 @@ GroupBox {
                     ThemedButton {
                         text: "Browse..."
                         onClicked: {
-                            var selectedFileName = MaterialEditorQML.openFileDialog()
-                            if (selectedFileName !== "") {
-                                MaterialEditorQML.setTextureName(selectedFileName)
+                            var selectedPath = MaterialEditorQML.openFileDialog()
+                            if (selectedPath !== "") {
+                                MaterialEditorQML.loadTextureFile(selectedPath)
                             }
                         }
                     }

src/AssetBrowserController.cpp

@@ -15,7 +15,7 @@ const QStringList AssetBrowserController::s_meshExtensions = {
     "fbx", "gltf", "glb", "gltf2", "vrm", "obj", "dae", "stl", "mesh", "3ds", "blend", "ply",
     "x", "x3d", "lwo", "lws", "ac", "ms3d", "cob", "scn", "bvh", "irrmesh", "irr",
     "mdl", "md2", "md3", "md5mesh", "smd", "ogex", "b3d", "q3d", "nff", "off",
-    "raw", "ter", "hmp", "assbin", "mesh.xml"
+    "raw", "ter", "hmp", "assbin", "mesh.xml", "tmd"
 };
 
 const QStringList AssetBrowserController::s_textureExtensions = {

src/AssetBrowserController_test.cpp

@@ -228,6 +228,8 @@ TEST_F(AssetBrowserControllerTests, FileTypeClassification) {
     EXPECT_EQ(abc->fileTypeForPath("/foo/bar.gltf"), "mesh");
     EXPECT_EQ(abc->fileTypeForPath("/foo/bar.vrm"), "mesh");
     EXPECT_EQ(abc->fileTypeForPath("/foo/bar.obj"), "mesh");
+    EXPECT_EQ(abc->fileTypeForPath("/foo/bar.tmd"), "mesh");
+    EXPECT_EQ(abc->fileTypeForPath("/foo/bar.TMD"), "mesh");
     EXPECT_EQ(abc->fileTypeForPath("/foo/bar.png"), "texture");
     EXPECT_EQ(abc->fileTypeForPath("/foo/bar.jpg"), "texture");
     EXPECT_EQ(abc->fileTypeForPath("/foo/bar.tga"), "texture");
@@ -252,6 +254,23 @@ TEST_F(AssetBrowserControllerTests, OpenFileMeshEmitsImportSignal) {
     EXPECT_EQ(paths.at(0), meshPath);
 }
 
+TEST_F(AssetBrowserControllerTests, OpenFileTmdEmitsImportSignal) {
+    QTemporaryDir tmpDir;
+    ASSERT_TRUE(tmpDir.isValid());
+
+    const QString meshPath = tmpDir.path() + "/car.tmd";
+    QFile(meshPath).open(QIODevice::WriteOnly);
+
+    auto* abc = AssetBrowserController::instance();
+    QSignalSpy spy(abc, &AssetBrowserController::importMeshRequested);
+
+    abc->openFile(meshPath);
+    EXPECT_EQ(spy.count(), 1);
+    const QStringList paths = spy.at(0).at(0).toStringList();
+    EXPECT_EQ(paths.size(), 1);
+    EXPECT_EQ(paths.at(0), meshPath);
+}
+
 TEST_F(AssetBrowserControllerTests, OpenFileNonexistentDoesNothing) {
     auto* abc = AssetBrowserController::instance();
     QSignalSpy spy(abc, &AssetBrowserController::importMeshRequested);

src/CLIPipeline.cpp

@@ -618,7 +618,8 @@ QString CLIPipeline::formatForExtension(const QString& path)
         {".x", "X (*.x)"},
         {".mesh.xml", "Ogre XML (*.mesh.xml)"},
         {".mesh", "Ogre Mesh (*.mesh)"},
-        {".assbin", "Assimp Binary (*.assbin)"}
+        {".assbin", "Assimp Binary (*.assbin)"},
+        {".tmd", "PlayStation TMD (*.tmd)"}
     };
 
     for (const ExtensionFormat& entry : extensionFormats) {

src/CLIPipeline_test.cpp

@@ -485,6 +485,12 @@ TEST(CLIPipelineFormatForExtension, Assbin)
     EXPECT_EQ(CLIPipeline::formatForExtension("model.assbin"), "Assimp Binary (*.assbin)");
 }
 
+TEST(CLIPipelineFormatForExtension, Tmd)
+{
+    EXPECT_EQ(CLIPipeline::formatForExtension("model.tmd"), "PlayStation TMD (*.tmd)");
+    EXPECT_EQ(CLIPipeline::formatForExtension("MODEL.TMD"), "PlayStation TMD (*.tmd)");
+}
+
 TEST(CLIPipelineFormatForExtension, UnknownDefaultsToMesh)
 {
     EXPECT_EQ(CLIPipeline::formatForExtension("model.xyz"), "Ogre Mesh (*.mesh)");

src/CMakeLists.txt

@@ -166,6 +166,7 @@ set(TEST_SOURCES "")
 ADD_SUBDIRECTORY("${CMAKE_CURRENT_SOURCE_DIR}/OgreXML")
 ADD_SUBDIRECTORY("${CMAKE_CURRENT_SOURCE_DIR}/Assimp")
 ADD_SUBDIRECTORY("${CMAKE_CURRENT_SOURCE_DIR}/FBX")
+ADD_SUBDIRECTORY("${CMAKE_CURRENT_SOURCE_DIR}/PS1")
 
 #file(GLOB UI_FILES ./ui_files/*.ui)
 # if we don't include this CMake will not include ui headers properly:
@@ -507,7 +508,8 @@ if(BUILD_TESTS)
     # UnitTests binary directory so that plugins.cfg (PluginFolder=../) can
     # find them.  The app bundle has these in Contents/MacOS/ via INSTALL
     # commands, but UnitTests is a plain executable — not a bundle.
-    gtest_discover_tests(UnitTests)
+    # Discover tests at ctest time (not build time) so CI can provide Xvfb/GL env.
+    gtest_discover_tests(UnitTests DISCOVERY_MODE PRE_TEST)
 
     # Copy RTSS shader resources to the UnitTests binary directory so that
     # RTSSResourcesTest can find them without requiring cmake --install.

src/MCPServer.cpp

@@ -3397,7 +3397,7 @@ QJsonArray MCPServer::buildToolsList()
             "'Ogre XML (*.mesh.xml)', 'Collada (*.dae)', 'X (*.x)', 'OBJ (*.obj)', "
             "'OBJ without MTL (*.objnomtl)', 'STL (*.stl)', 'PLY (*.ply)', '3DS (*.3ds)', "
             "'glTF 2.0 (*.gltf2)', 'glTF 2.0 Binary (*.glb2)', 'Assimp Binary (*.assbin)', "
-            "'FBX Binary (*.fbx)'. "
+            "'FBX Binary (*.fbx)', 'PlayStation TMD (*.tmd)'. "
             "Default: 'Ogre Mesh (*.mesh)'"}};
         inputSchema["properties"] = properties;
         inputSchema["required"] = QJsonArray{"path"};

src/Manager.cpp

@@ -80,7 +80,7 @@ Manager* Manager:: m_pSingleton = nullptr;
 
 QString Manager::mValidFileExtention = ".mesh .dae .blend .3ds .ase .obj .ifc .xgl .zgl .ply .dxf .lwo "\
         ".lws .lxo .stl .x .ac .ms3d .cob .scn .bvh .csm .xml .irrmesh .irr .mdl .md2 .md3 "\
-        ".pk3 .mdc .md5 .txt .smd .vta .m3 .3d .b3d .q3d .q3s .nff .nff .off .raw .ter .mdl .hmp .ndo .fbx .glb .gltf .vrm";
+        ".pk3 .mdc .md5 .txt .smd .vta .m3 .3d .b3d .q3d .q3s .nff .nff .off .raw .ter .mdl .hmp .ndo .fbx .glb .gltf .vrm .tmd";
 
 ////////////////////////////////////////
 /// Static Member to build & destroy

src/Manager_test.cpp

@@ -265,6 +265,10 @@ TEST_F(ManagerHeadlessTest, IsValidFileExtention)
     QString stlFile = "print.stl";
     EXPECT_TRUE(mgr->isValidFileExtention(stlFile));
 
+    QString tmdFile = "model.tmd";
+    EXPECT_TRUE(mgr->isValidFileExtention(tmdFile));
+    EXPECT_TRUE(mgr->isValidFileExtention(QStringLiteral("CAR.TMD")));
+
     // Invalid extensions
     QString docFile = "readme.doc";
     EXPECT_FALSE(mgr->isValidFileExtention(docFile));
@@ -284,6 +288,7 @@ TEST_F(ManagerHeadlessTest, IsValidFileExtention)
     EXPECT_TRUE(validExts.contains(".mesh"));
     EXPECT_TRUE(validExts.contains(".fbx"));
     EXPECT_TRUE(validExts.contains(".vrm"));
+    EXPECT_TRUE(validExts.contains(".tmd"));
 }
 
 TEST_F(ManagerHeadlessTest, CreateEmptyScene)

src/MaterialEditorQML.cpp

@@ -9,6 +9,7 @@
 #include "QMLMaterialHighlighter.h"
 #include "ModelDownloader.h"
 #include "RTShaderHelper.h"
+#include "PS1/PS1TIM.h"
 #include <OgreRTShaderSystem.h>
 #include <QDebug>
 #include <QFileDialog>
@@ -28,6 +29,7 @@
 #include <OgreLog.h>
 #include <OgreScriptCompiler.h>
 #include <OgreScriptTranslator.h>
+#include <OgreTextureUnitState.h>
 #include <QProcess>
 #include <QNetworkAccessManager>
 #include <QNetworkRequest>
@@ -857,7 +859,7 @@
     }
 }
 
 void MaterialEditorQML::setTextureName(const QString &name)
 {
     if (m_textureName != name) {
         m_textureName = name;
@@ -866,6 +868,20 @@
         if (textureUnit && !name.isEmpty() && name != "*Select a texture*") {
             // Only set non-empty, valid texture names to avoid OGRE crashes
             textureUnit->setTextureName(name.toStdString());
+
+            // If this is a per-import PS1 TMD material, default to unlit single-pass once an image is present.
+            if (m_ogreMaterial) {
+                const std::string matName = m_ogreMaterial->getName();
+                if (matName.rfind("TMD/", 0) == 0) {
+                    if (Ogre::Technique* tech = getCurrentTechnique()) {
+                        while (tech->getNumPasses() > 1)
+                            tech->removePass(1);
+                    }
+                    // PS1 .tim often uses color 0x0000 for transparent texels (see PS1TIM::loadTimToOgreImage).
+                    if (Ogre::Pass* pass = getCurrentPass())
+                        pass->setAlphaRejectSettings(Ogre::CMPF_GREATER_EQUAL, 1);
+                }
+            }
             updateMaterialText();
         }
 
@@ -966,7 +982,7 @@
         nullptr, 
         tr("Select a texture"),
         QStandardPaths::writableLocation(QStandardPaths::PicturesLocation),
-        tr("Image File (*.bmp *.jpg *.gif *.raw *.png *.tga *.dds)"));
+        tr("Texture File (*.bmp *.jpg *.jpeg *.gif *.raw *.png *.tga *.dds *.tim)"));
 
     if (filePath.isEmpty()) return;
 
@@ -981,23 +997,37 @@
         return;
     }
 
+    const bool isTim = file.suffix().compare(QStringLiteral("tim"), Qt::CaseInsensitive) == 0;
+    const QString ogreTexName = isTim ? (file.completeBaseName() + QStringLiteral(".tim")) : file.fileName();
+
     try {
         // Try to get existing texture
         Ogre::TextureManager::getSingleton().getByName(
-            file.fileName().toStdString(), file.path().toStdString());
+            ogreTexName.toStdString(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
     } catch (...) {
         // Load new texture
+        // Always register user-picked textures into the default group ("General") so materials can find them.
+        // Creating ad-hoc groups per directory makes TextureUnitState name resolution fail (yellow/black fallback).
         Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
-            file.path().toStdString(), "FileSystem", file.path().toStdString());
-        Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
+            file.path().toStdString(), "FileSystem", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
+        Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup(
+            Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
 
         Ogre::Image image;
-        image.load(file.fileName().toStdString(), file.path().toStdString());
+        if (isTim) {
+            QString err;
+            if (!PS1TIM::loadTimToOgreImage(filePath, image, &err)) {
+                emit errorOccurred(QString("Failed to load TIM: %1").arg(err));
+                return;
+            }
+        } else {
+            image.load(file.fileName().toStdString(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
+        }
         Ogre::TextureManager::getSingleton().loadImage(
-            file.fileName().toStdString(), file.path().toStdString(), image);
+            ogreTexName.toStdString(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, image);
     }
 
-    setTextureName(file.fileName());
+    setTextureName(ogreTexName);
 }
 // LCOV_EXCL_STOP
 
@@ -1643,7 +1673,27 @@
                 // Check origin (absolute path)
                 QString origin = QString::fromStdString(texPtr->getOrigin());
                 if (!origin.isEmpty() && QFileInfo::exists(origin)) {
-                    return QUrl::fromLocalFile(QFileInfo(origin).absoluteFilePath()).toString();
+                    // QML Image cannot display .tim; for those, generate a PNG preview.
+                    const QString ext = QFileInfo(origin).suffix().toLower();
+                    if (ext != "tim") {
+                        return QUrl::fromLocalFile(QFileInfo(origin).absoluteFilePath()).toString();
+                    }
+                }
+
+                // If we can't return a directly viewable file (e.g., .tim), generate a PNG preview from the GPU texture.
+                try {
+                    Ogre::Image img;
+                    texPtr->convertToImage(img, true);
+                    const QString dataPath = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
+                    const QString outDir = QDir(dataPath).filePath("texture_previews");
+                    QDir().mkpath(outDir);
+                    const QString outPath = QDir(outDir).filePath(texName + ".png");
+                    QFile::remove(outPath); // ensure stale previews don't linger
+                    img.save(outPath.toStdString());
+                    if (QFileInfo::exists(outPath)) {
+                        return QUrl::fromLocalFile(QFileInfo(outPath).absoluteFilePath()).toString();
+                    }
+                } catch (...) {
                 }
 
                 // The resource group name is often the directory the model was loaded from
@@ -2498,18 +2548,79 @@
         QApplication::activeWindow(),
         "Select Texture File",
         startDir,
-        "Image files (*.jpg *.jpeg *.png *.dds *.tga *.bmp);;All files (*)",
+        "Texture files (*.jpg *.jpeg *.png *.dds *.tga *.bmp *.tim);;All files (*)",
         nullptr,
         QFileDialog::DontUseNativeDialog | QFileDialog::DontUseCustomDirectoryIcons
     );
 
     if (!selectedFile.isEmpty()) {
-        return QFileInfo(selectedFile).fileName();
+        return selectedFile;
     } else {
         return QString();
     }
 }
 
+bool MaterialEditorQML::loadTextureFile(const QString &filePath)
+{
+    if (filePath.isEmpty())
+        return false;
+
+    Ogre::TextureUnitState* textureUnit = getCurrentTextureUnit();
+    if (!textureUnit) {
+        emit errorOccurred("No texture unit selected.");
+        return false;
+    }
+
+    QFileInfo file(filePath);
+    if (!file.exists()) {
+        emit errorOccurred("Texture file does not exist.");
+        return false;
+    }
+    if (file.fileName().isEmpty()) {
+        emit errorOccurred("Selected file has an empty name.");
+        return false;
+    }
+
+    const bool isTim = file.suffix().compare(QStringLiteral("tim"), Qt::CaseInsensitive) == 0;
+    const QString ogreTexName = isTim ? (file.completeBaseName() + QStringLiteral(".tim")) : file.fileName();
+    const std::string texNameStd = ogreTexName.toStdString();
+    const std::string group = Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME;
+
+    try {
+        if (Ogre::TextureManager::getSingleton().getByName(texNameStd, group)) {
+            setTextureName(ogreTexName);
+            return true;
+        }
+    } catch (...) {
+    }
+
+    try {
+        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
+            file.path().toStdString(), "FileSystem", group);
+        Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup(group);
+
+        Ogre::Image image;
+        if (isTim) {
+            QString err;
+            if (!PS1TIM::loadTimToOgreImage(filePath, image, &err)) {
+                emit errorOccurred(QString("Failed to load TIM: %1").arg(err));
+                return false;
+            }
+        } else {
+            image.load(file.fileName().toStdString(), group);
+        }
+        Ogre::TextureManager::getSingleton().loadImage(texNameStd, group, image);
+        setTextureName(ogreTexName);
+        return true;
+    } catch (const std::exception& e) {
+        emit errorOccurred(QString("Texture load failed: %1").arg(e.what()));
+        return false;
+    } catch (...) {
+        emit errorOccurred("Texture load failed.");
+        return false;
+    }
+}
+
 QString MaterialEditorQML::openMaterialImportDialog()
 {
     QString materialsPath = "./media/materials/scripts";
@@ -3264,7 +3375,7 @@
 
         engine->load(qmlUrl);
 
     } catch (const std::exception& e) {
         qDebug() << "Exception in Material Editor creation:" << e.what();
         emit errorOccurred(QString("Material Editor encountered an error: %1").arg(e.what()));
     } catch (...) {

src/MaterialEditorQML.h

@@ -377,6 +377,7 @@ public slots:
     Q_INVOKABLE QString getFileSizeString(const QString &path);
     Q_INVOKABLE bool pathExists(const QString &path);
     Q_INVOKABLE QString openFileDialog();
+    Q_INVOKABLE bool loadTextureFile(const QString &filePath);
     Q_INVOKABLE QString openMaterialImportDialog();
     Q_INVOKABLE QString openMaterialExportDialog(const QString &materialName = "");
     Q_INVOKABLE QString showNativeFileDialog(QObject *parentWindow);

src/MeshImporterExporter.cpp

@@ -52,6 +52,7 @@ THE SOFTWARE.
 #include "Assimp/BoneProcessor.h"
 #include "Assimp/AnimationProcessor.h"
 #include "CLIPipeline.h"
+#include "PS1/PS1TMD.h"
 #include "EditableMesh.h"
 #include "EditModeController.h"
 #include <OgreMaterialManager.h>
@@ -79,7 +80,8 @@ const QMap<QString, QString> MeshImporterExporter::exportFormats = {
     {"glTF 2.0 (*.gltf)", ".gltf"},
     {"glTF 2.0 Binary (*.glb)", ".glb"},
     {"Assimp Binary (*.assbin)", ".assbin"},
-    {"FBX Binary (*.fbx)", ".fbx"}
+    {"FBX Binary (*.fbx)", ".fbx"},
+    {"PlayStation TMD (*.tmd)", ".tmd"}
 };
 
 void MeshImporterExporter::configureCamera(const Ogre::Entity *en)
@@ -1203,6 +1205,27 @@ void MeshImporterExporter::importer(const QStringList &_uriList, unsigned int ad
                     AnimationMerger::registerSkeletonUpAxis(en->getMesh()->getSkeleton()->getName(), 1);
                 applyNormalMapsToEntity(en);
             }
+            else if (!file.suffix().compare(QStringLiteral("tmd"), Qt::CaseInsensitive))
+            {
+                const std::string meshName = (file.baseName() + QStringLiteral("_tmd")).toStdString();
+                Ogre::MeshPtr mesh = PS1TMD::importTmd(file.filePath(), meshName);
+                if (!mesh) {
+                    QMessageBox::warning(
+                        nullptr,
+                        QStringLiteral("PlayStation TMD"),
+                        QStringLiteral("Could not import %1 — invalid file or unsupported primitive types.")
+                            .arg(file.fileName()));
+                    continue;
+                }
+
+                SentryReporter::addBreadcrumb(
+                    QStringLiteral("file.import"),
+                    QStringLiteral("Imported PlayStation TMD: %1").arg(file.fileName()));
+
+                sn = Manager::getSingleton()->addSceneNode(file.baseName());
+                en = Manager::getSingleton()->createEntity(sn, mesh);
+                applyNormalMapsToEntity(en);
+            }
             else
             {
                 AssimpToOgreImporter importer;
@@ -1435,6 +1458,11 @@ int MeshImporterExporter::exporter(const Ogre::SceneNode *_sn, const QString &_u
         // .material and extracted image files next to the FBX.
         if (!ok)
             return -1;
+    } else if (_format == QStringLiteral("PlayStation TMD (*.tmd)")) {
+        if (!PS1TMD::exportEntity(e, _uri))
+            return -1;
+        SentryReporter::addBreadcrumb(QStringLiteral("file.export"),
+            QStringLiteral("Exported PlayStation TMD: %1").arg(_uri));
     } else {
         // Export using Assimp — build aiScene directly from Ogre mesh data
         try {