File error reporting

application/F3DOptionsTools.h

@@ -93,6 +93,7 @@ static inline const std::map<std::string_view, std::string_view> LibOptionsNames
   { "animation-indices", "scene.animation.indices" },
   { "animation-speed-factor", "scene.animation.speed_factor" },
   { "force-reader", "scene.force_reader" },
+  { "skip-content-check", "scene.skip_content_check" },
   { "font-file", "ui.font_file" },
   { "font-scale", "ui.scale" },
   { "font-color", "ui.font_color" },

application/F3DStarter.cxx

@@ -1667,11 +1667,12 @@ void F3DStarter::LoadFileGroupInternal(
 
         try
         {
+          f3d::file_availability availability = scene.supports(tmpPath);
           if (!fs::exists(tmpPath))
           {
             f3d::log::error(tmpPath.string(), " does not exist");
           }
-          else if (scene.supports(tmpPath))
+          else if (availability == f3d::file_availability::SUPPORTED)
           {
             // Check the size of the file before loading it
             static constexpr int BYTES_IN_MIB = 1048576;
@@ -1687,7 +1688,22 @@ void F3DStarter::LoadFileGroupInternal(
               localPaths.emplace_back(tmpPath);
             }
           }
-          else
+          else if (availability == f3d::file_availability::UNSUPPORTED_EXTENSION)
+          {
+            auto forceReader = this->Internals->LibOptions.scene.force_reader;
+            if (forceReader)
+            {
+              f3d::log::warn("Forced reader ", *forceReader, " doesn't exist");
+            }
+            else
+            {
+              f3d::log::warn(tmpPath.string(),
+                " is of an unknown format, use "
+                "--force-reader to select a specific reader");
+            }
+            unsupported = true;
+          }
+          else if (availability == f3d::file_availability::UNSUPPORTED_CONTENT)
           {
             auto forceReader = this->Internals->LibOptions.scene.force_reader;
             if (forceReader)
@@ -1697,7 +1713,7 @@ void F3DStarter::LoadFileGroupInternal(
             else
             {
               f3d::log::warn(tmpPath.string(),
-                " is of an unknown format or contains unsupported contents, use "
+                " contains unsupported contents, use "
                 "--force-reader to select a specific reader");
             }
             unsupported = true;
@@ -1822,7 +1838,7 @@ void F3DStarter::LoadFileGroupInternal(
 
     // Unwatch and erase paths that should not be watched anymore
     for (auto it = this->Internals->FolderWatchIds.begin();
-         it != this->Internals->FolderWatchIds.end();)
+      it != this->Internals->FolderWatchIds.end();)
     {
       const fs::path& path = it->first;
       const dmon_watch_id& dmonId = it->second;
@@ -2307,7 +2323,8 @@ void F3DStarter::AddCommands()
 
   interactor.addCommand(
     "load_next_file_group",
-    [this](const std::vector<std::string>& args) {
+    [this](const std::vector<std::string>& args)
+    {
       this->LoadRelativeFileGroup(
         +1, parse_optional_bool_flag(args, "load_next_file_group", false));
     },

c/scene_c_api.cxx

@@ -127,7 +127,8 @@ int f3d_scene_supports(f3d_scene_t* scene, const char* file_path)
   }
 
   f3d::scene* cpp_scene = reinterpret_cast<f3d::scene*>(scene);
-  return cpp_scene->supports(std::filesystem::path(file_path)) ? 1 : 0;
+  auto availability = cpp_scene->supports(std::filesystem::path(file_path));
+  return static_cast<int>(availability);
 }
 
 //----------------------------------------------------------------------------

cmake/f3dPlugin.cmake

@@ -343,7 +343,9 @@ macro(f3d_plugin_build)
   else()
     # In-source plugin path
     set(_f3d_has_application "${F3D_BUILD_APPLICATION}")
-    set(_f3d_include_path "${F3D_SOURCE_DIR}/library/plugin")
+    set(_f3d_include_path "${F3D_SOURCE_DIR}/library/plugin"
+        "${F3D_SOURCE_DIR}/library/public"
+        "${CMAKE_BINARY_DIR}/library/public")
     set(_f3d_config_dir ${f3d_config_dir})
     set(_f3d_plugins_install_dir ${F3D_PLUGINS_INSTALL_DIR})
   endif()

doc/libf3d/03-OPTIONS.md

@@ -65,6 +65,12 @@ Force a specific reader to be used, disregarding the file extension and file con
 
 CLI: `--force-reader`.
 
+### `scene.skip_content_check` (_bool_, default: `false`)
+
+Make attempt to read file without checking it's header.
+
+CLI: `--skip-content-check`.
+
 ### `scene.camera.orthographic` (_bool_, optional)
 
 Set to true to force orthographic projection. Model-specified by default, which is false if not specified.

doc/libf3d/06-MIGRATION.md

@@ -14,3 +14,9 @@ The callback takes an argument of type `f3d::interactor::interactor_state_t` all
 ## F3D_PLUGINS_PATH
 
 When running F3D, it was possible to specify the path for loading plugins using the environment variable `F3D_PLUGINS_PATH`. This variable has been removed in favor of the CLI option `--plugins-path` which is more secure.
+
+## scene.supports method
+`scene::supports()` method signature changed, it now returns `f3d::file_availability` enum instead of `bool`. Here is how you can check if a file is supported now:
+```cpp
+if (scene.supports("some.obj") == f3d::file_availability::SUPPORTED)
+```

doc/user/03-OPTIONS.md

@@ -33,6 +33,10 @@ List available _readers_ and exit. Ignore `--verbose`.
 
 Force a specific [reader](02-SUPPORTED_FORMATS.md) to be used, disregarding the file extension and file content.
 
+### `--skip-content-check` (_bool_, default: `false`)
+
+Make attempt to read file without checking it's header.
+
 ### `--list-bindings`
 
 List available _bindings_ and exit. Ignore `--verbose`.

java/F3DSceneBindings.cxx

@@ -376,9 +376,9 @@ extern "C"
     }
 
     const char* str = env->GetStringUTFChars(filePath, nullptr);
-    bool result = GetEngine(env, self)->getScene().supports(str);
+    f3d::file_availability result = GetEngine(env, self)->getScene().supports(str);
     env->ReleaseStringUTFChars(filePath, str);
-    return result;
+    return result != f3d::file_availability::SUPPORTED;
   }
 
   JNIEXPORT jobject JAVA_BIND(Scene, loadAnimationTime)(

library/options.json

@@ -33,6 +33,9 @@
     },
     "force_reader": {
       "type": "string"
+    },
+    "skip_content_check": {
+      "type": "bool"
     }
   },
   "render": {
@@ -396,7 +399,8 @@
       },
       "colormap": {
         "type": "colormap",
-        "default_value": "0.0, 0.0, 0.0, 0.0, 0.4, 0.9, 0.0, 0.0, 0.8, 0.9, 0.9, 0.0, 1.0, 1.0, 1.0, 1.0"
+        "default_value":
+          "0.0, 0.0, 0.0, 0.0, 0.4, 0.9, 0.0, 0.0, 0.8, 0.9, 0.9, 0.0, 1.0, 1.0, 1.0, 1.0"
       },
       "opacity_map": {
         "type": "double_vector",

library/plugin/reader.h

@@ -9,9 +9,12 @@
 #include <algorithm>
 #include <cctype>
 #include <map>
+#include <optional>
 #include <string>
 #include <vector>
 
+#include "scene.h"
+
 class vtkResourceStream;
 namespace f3d
 {
@@ -66,28 +69,39 @@ class reader
   /**
    * Check if this reader can read the given filename - according to its extension and file content
    */
-  virtual bool canRead(const std::string& fileName) const
-  {
-    std::string ext = fileName.substr(fileName.find_last_of(".") + 1);
-    std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
-
-    const std::vector<std::string>& extensions = this->getExtensions();
-
-    if (!std::any_of(
-          extensions.begin(), extensions.end(), [&](const std::string& s) { return s == ext; }))
-    {
-      return false;
-    }
-
-    vtkNew<vtkFileResourceStream> stream;
-    if (!stream->Open(fileName.c_str()))
+  virtual bool canRead(const std::string& fileName, const std::optional<bool> skipContentCheck,
+    f3d::file_availability& availability) const
     {
+      std::string ext = fileName.substr(fileName.find_last_of(".") + 1);
+      std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
+
+      const std::vector<std::string>& extensions = this->getExtensions();
+
+      if (std::any_of(
+            extensions.begin(), extensions.end(), [&](const std::string& s) { return s == ext; }))
+      {
+        vtkNew<vtkFileResourceStream> stream;
+        if (skipContentCheck.has_value() && skipContentCheck.value() == true)
+        {
+          availability = f3d::file_availability::SUPPORTED;
+          return true;
+        }
+        else if (stream->Open(fileName.c_str()))
+        {
+          if (this->canRead(stream))
+          {
+            availability = f3d::file_availability::SUPPORTED;
+            return true;
+          }
+          else
+          {
+            availability = f3d::file_availability::UNSUPPORTED_CONTENT;
+          }
+        }
+      }
       return false;
     }
 
-    return this->canRead(stream);
-  }
-
   /**
    * Should return true if this reader could be able to read provided stream,
    * false if it is sure it cannot.

library/private/factory.h

@@ -15,6 +15,7 @@
 
 #include "plugin.h"
 #include "reader.h"
+#include "scene.h"
 
 #include <map>
 #include <optional>
@@ -45,13 +46,14 @@ class factory
   /**
    * Get the reader that can read the given file, nullptr if none
    */
-  reader* getReader(const std::string& fileName, std::optional<std::string> forceReader);
+  reader* getReader(const std::string& fileName, std::optional<std::string> forceReader,
+    const std::optional<bool> skipContentCheck, file_availability& availability);
 
   /**
    * Get the reader that can read the given buffer, nullptr if none
    */
-  reader* getReader(
-    const std::byte* buffer, std::size_t size, std::optional<std::string> forceReader);
+  reader* getReader(const std::byte* buffer, std::size_t size,
+    std::optional<std::string> forceReader, const std::optional<bool> skipContentCheck);
 
   /**
    * Get the list of the registered plugins

library/private/scene_impl.h

@@ -44,7 +44,7 @@ class scene_impl : public scene
   scene& updateLight(int index, const light_state_t& lightState) override;
   scene& removeLight(int index) override;
   scene& removeAllLights() override;
-  bool supports(const std::filesystem::path& filePath) override;
+  file_availability supports(const std::filesystem::path& filePath) override;
   scene& loadAnimationTime(double timeValue) override;
   std::pair<double, double> animationTimeRange() override;
   std::vector<double> getAnimationKeyFrames() override;

library/public/scene.h

@@ -34,6 +34,14 @@ namespace f3d
  * \endcode
  *
  */
+
+enum class file_availability : int
+{
+  SUPPORTED = 1,
+  UNSUPPORTED_EXTENSION = 2,
+  UNSUPPORTED_CONTENT = 3,
+};
+
 class F3D_EXPORT scene
 {
 public:
@@ -156,7 +164,8 @@ class F3D_EXPORT scene
    * scene.force_reader is taken into account and plugin should be loaded for their readers to be
    * found.
    */
-  [[nodiscard]] virtual bool supports(const std::filesystem::path& filePath) = 0;
+  [[nodiscard]] virtual file_availability supports(
+    const std::filesystem::path& filePath) = 0;
 
   /**
    * Load added files at provided time value if they contain any animation

library/src/factory.cxx.in

@@ -14,8 +14,8 @@ namespace f3d
 namespace
 {
 template<typename F>
-reader* pickReader(
-  const std::vector<plugin*>& plugins, std::optional<std::string> forceReader, F&& isValid)
+reader* pickReader(const std::vector<plugin*>& plugins, std::optional<std::string> forceReader,
+  file_availability& availability, F&& isValid)
 {
   int bestScore = -1;
   reader* bestReader = nullptr;
@@ -28,6 +28,7 @@ reader* pickReader(
       {
         if (reader->getName() == *forceReader)
         {
+          availability = file_availability::SUPPORTED;
           return reader.get();
         }
       }
@@ -76,20 +77,22 @@ factory::plugin_initializer_t factory::getStaticInitializer(const std::string& p
 }
 
 //----------------------------------------------------------------------------
-reader* factory::getReader(const std::string& fileName, std::optional<std::string> forceReader)
+reader* factory::getReader(const std::string& fileName, std::optional<std::string> forceReader,
+  const std::optional<bool> skipContentCheck, file_availability& availability)
 {
-  return f3d::pickReader(
-    this->Plugins, forceReader, [&](const reader* reader) { return reader->canRead(fileName); });
+  return f3d::pickReader(this->Plugins, forceReader, availability, [&](const reader* reader)
+    { return reader->canRead(fileName, skipContentCheck, availability); });
 }
 
 //----------------------------------------------------------------------------
-reader* factory::getReader(
-  const std::byte* buffer, std::size_t size, std::optional<std::string> forceReader)
+reader* factory::getReader(const std::byte* buffer, std::size_t size,
+  std::optional<std::string> forceReader, const std::optional<bool> skipContentCheck)
 {
   vtkNew<vtkMemoryResourceStream> stream;
   stream->SetBuffer(buffer, size);
+  file_availability availability;
 
-  return f3d::pickReader(this->Plugins, forceReader,
+  return f3d::pickReader(this->Plugins, forceReader, availability,
     [&](const reader* reader) { return reader->supportsStream() && reader->canRead(stream); });
 }