Tools: AssimpConverter - stop linking against Codec_Assimp

PlugIns/Assimp/include/OgreAssimpLoader.h

@@ -65,7 +65,7 @@ namespace Ogre
 * %Codec for loading geometry using the [Open-Asset-Importer](https://github.com/assimp/assimp)
 * @{
 */
-class _OgreAssimpExport AssimpLoader
+class AssimpLoader
 {
 public:
     enum LoaderParams

PlugIns/Assimp/src/AssimpLoader.cpp

@@ -32,6 +32,8 @@ THE SOFTWARE.
 -----------------------------------------------------------------------------
 */
 #include "OgreAssimpLoader.h"
+#include "OgreString.h"
+#include "OgreStringConverter.h"
 
 #include <assimp/version.h>
 #include <assimp/scene.h>
@@ -360,15 +362,39 @@ bool AssimpLoader::load(const String& source, Mesh* mesh, SkeletonPtr& skeletonP
 bool AssimpLoader::_load(const char* name, Assimp::Importer& importer, Mesh* mesh, SkeletonPtr& skeletonPtr,
                          const Options& options)
 {
+    mAnimationSpeedModifier = options.animationSpeedModifier;
+    mLoaderParams = options.params;
+    mCustomAnimationName = options.customAnimationName;
+
+    float maxEdgeAngle = options.maxEdgeAngle;
+    int postProcessSteps = options.postProcessSteps;
+    auto optsAny = mesh->getUserObjectBindings().getUserAny("_AssimpLoaderOptions");
+    if(optsAny.has_value())
+    {
+        auto strOpts = any_cast<BinaryOptionList>(optsAny);
+        if(strOpts.find("quiet") != strOpts.end())
+            mLoaderParams |= LP_QUIET_MODE;
+        if(strOpts.find("customAnimationName") != strOpts.end())
+            mCustomAnimationName = strOpts["customAnimationName"];
+        if(strOpts.find("animationSpeedModifier") != strOpts.end())
+            StringConverter::parse(strOpts["animationSpeedModifier"], mAnimationSpeedModifier);
+        if(strOpts.find("maxEdgeAngle") != strOpts.end())
+            StringConverter::parse(strOpts["maxEdgeAngle"], maxEdgeAngle);
+        if(strOpts.find("postProcessSteps") != strOpts.end())
+            StringConverter::parse(strOpts["postProcessSteps"], postProcessSteps);
+        if(strOpts.find("cutAnimation") != strOpts.end())
+            mLoaderParams |= LP_CUT_ANIMATION_WHERE_NO_FURTHER_CHANGE;
+    }
+
     uint32 flags = aiProcessPreset_TargetRealtime_Fast | aiProcess_TransformUVCoords | aiProcess_FlipUVs;
     flags &= ~(aiProcess_JoinIdenticalVertices | aiProcess_CalcTangentSpace); // optimize for fast loading
 
-    flags |= options.postProcessSteps;
+    flags |= postProcessSteps;
 
     if((flags & (aiProcess_GenSmoothNormals | aiProcess_GenNormals)) != aiProcess_GenNormals)
         flags &= ~aiProcess_GenNormals; // prefer smooth normals
 
-    importer.SetPropertyFloat("PP_GSN_MAX_SMOOTHING_ANGLE", options.maxEdgeAngle);
+    importer.SetPropertyFloat("PP_GSN_MAX_SMOOTHING_ANGLE", maxEdgeAngle);
     const aiScene* scene = importer.ReadFile(name, flags);
 
     // If the import failed, report it
@@ -378,10 +404,7 @@ bool AssimpLoader::_load(const char* name, Assimp::Importer& importer, Mesh* mes
         return false;
     }
 
-    mAnimationSpeedModifier = options.animationSpeedModifier;
-    mLoaderParams = options.params;
     mQuietMode = mLoaderParams & LP_QUIET_MODE;
-    mCustomAnimationName = options.customAnimationName;
     mNodeDerivedTransformByName.clear();
 
     String basename, extension;

Tools/AssimpConverter/CMakeLists.txt

@@ -8,7 +8,8 @@
 #-------------------------------------------------------------------
 
 add_executable(OgreAssimpConverter main.cpp)
-target_link_libraries(OgreAssimpConverter OgreMain Codec_Assimp)
+target_link_libraries(OgreAssimpConverter OgreMain OgreRTShaderSystem)
+target_include_directories(OgreAssimpConverter PRIVATE $<TARGET_PROPERTY:fix::assimp,INTERFACE_INCLUDE_DIRECTORIES>)
 if (OGRE_PROJECT_FOLDERS)
 	set_property(TARGET OgreAssimpConverter PROPERTY FOLDER Tools)
 endif ()

Tools/AssimpConverter/main.cpp

@@ -36,9 +36,9 @@ THE SOFTWARE.
 #include <iostream>
 
 #include "Ogre.h"
+#include "OgreCodec.h"
 #include "OgreDefaultHardwareBufferManager.h"
 
-#include "OgreAssimpLoader.h"
 #include <assimp/postprocess.h>
 
 #ifdef OGRE_BUILD_COMPONENT_RTSHADERSYSTEM
@@ -78,7 +78,7 @@ struct AssOptions
     String dest;
     String logFile;
 
-    AssimpLoader::Options options;
+    BinaryOptionList options;
 
     AssOptions() { logFile = "OgreAssimp.log"; };
 };
@@ -106,18 +106,18 @@ AssOptions parseArgs(int numArgs, char** args)
 
     if (unOpt["-q"])
     {
-        opts.options.params |= AssimpLoader::LP_QUIET_MODE;
+        opts.options["quiet"] = "true";
     }
     if (unOpt["-3ds_ani_fix"])
     {
-        opts.options.params |= AssimpLoader::LP_CUT_ANIMATION_WHERE_NO_FURTHER_CHANGE;
+        opts.options["cutAnimation"] = "true";
     }
 
-    opts.options.postProcessSteps = aiProcessPreset_TargetRealtime_Quality;
+    opts.options["postProcessSteps"] = std::to_string(aiProcessPreset_TargetRealtime_Quality);
     opts.logFile = binOpt["-log"];
-    StringConverter::parse(binOpt["-aniSpeedMod"], opts.options.animationSpeedModifier);
-    opts.options.customAnimationName = binOpt["-aniName"];
-    StringConverter::parse(binOpt["-max_edge_angle"], opts.options.maxEdgeAngle);
+    opts.options["animationSpeedModifier"] = binOpt["-aniSpeedMod"];
+    opts.options["customAnimationName"] = binOpt["-aniName"];
+    opts.options["maxEdgeAngle"] = binOpt["-max_edge_angle"];
 
     // Source / dest
     if (numArgs > startIndex)
@@ -151,7 +151,7 @@ AssOptions parseArgs(int numArgs, char** args)
 
         std::cout << "source file               = " << opts.source << std::endl;
         std::cout << "destination               = " << opts.dest << std::endl;
-        std::cout << "animation speed modifier  = " << opts.options.animationSpeedModifier << std::endl;
+        std::cout << "animation speed modifier  = " << opts.options["animationSpeedModifier"] << std::endl;
         std::cout << "log file                  = " << opts.logFile << std::endl;
 
         std::cout << "-- END OPTIONS --" << std::endl;
@@ -180,31 +180,41 @@ int main(int numargs, char** args)
 
     try
     {
+        FileSystemLayer fsLayer("Ogre3D");
+        ConfigFile pluginsCfg;
+        pluginsCfg.load(fsLayer.getConfigFilePath("plugins.cfg"));
+
+        auto pluginDir = pluginsCfg.getSetting("PluginFolder")+"/";
+
         logMgr.setDefaultLog(NULL); // swallow startup messages
+
+        DefaultHardwareBufferManager bufferManager; // needed because we don't have a rendersystem
+
         Root root("", "", "");
         // get rid of the temporary log as we use the new log now
         logMgr.destroyLog("Temporary log");
 
         // use the log specified by the cmdline params
         logMgr.setDefaultLog(logMgr.createLog(opts.logFile, false, true));
 
+        root.loadPlugin(pluginDir + "/Codec_Assimp");
+
         MaterialManager::getSingleton().initialise();
 
 #ifdef OGRE_BUILD_COMPONENT_RTSHADERSYSTEM
         RTShader::ShaderGenerator::initialize();
 #endif
 
-        DefaultHardwareBufferManager bufferManager; // needed because we don't have a rendersystem
         DefaultTextureManager texMgr;
 
         String basename, ext, path;
         StringUtil::splitFullFilename(opts.source, basename, ext, path);
 
-        MeshPtr mesh = MeshManager::getSingleton().createManual(basename + "." + ext, RGN_DEFAULT);
-        SkeletonPtr skeleton;
+        auto codec = Codec::getCodec(ext);
 
-        AssimpLoader loader;
-        loader.load(opts.source, mesh.get(), skeleton, opts.options);
+        MeshPtr mesh = MeshManager::getSingleton().createManual(basename + "." + ext, RGN_DEFAULT);
+        mesh->getUserObjectBindings().setUserAny("_AssimpLoaderOptions", opts.options);
+        codec->decode(Root::openFileStream(opts.source), mesh.get());
 
         if (!opts.dest.empty())
         {
@@ -214,7 +224,7 @@ int main(int numargs, char** args)
         MeshSerializer meshSer;
         meshSer.exportMesh(mesh, path + basename + ".mesh");
 
-        if (skeleton)
+        if (auto skeleton = mesh->getSkeleton())
         {
             SkeletonSerializer binSer;
             binSer.exportSkeleton(skeleton.get(), path + skeleton->getName());