gfx: detect dropped shaders properly, and pair their two stages

Three things were wrong at once.

The drop handlers stored score::FilePath::relative, so a shader under the
document folder or the library arrived as "<PROJECT>:Shaders/x.fs" and every
model opened it with a bare QFile. It only ever worked in an unsaved
document, where relativize hands back an absolute path. The models resolve
through locateShaderPath now, as Gfx::Video::Model already did.

One handler could claim an extension: m_perFileExtension assigned rather than
appended, so of the four families sharing .fs exactly one survived, chosen by
hash order. The list asks every handler registered for the extension, and
each sniffs its own MODE marker and stays silent otherwise -- which also lets
raw raster have a drop handler at all, from the other plugin, without either
plugin having to name the other's process.

Vertex pairing used QString::replace, rewriting every occurrence in the path
(a directory named x.fs broke it), and RenderPipeline used baseName(), which
truncates at the first dot, so my.shader.fs looked for my.vs. Both go through
one sibling helper built on completeBaseName. Dropping a .fs and its .vs now
yields one process: the .vs half is refused by VSA when a fragment sibling
exists.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01H4N6KsxzvT1o9qoPvBThyz

Author: jcelerier

src/plugins/score-lib-process/Process/Drop/ProcessDropHandler.cpp

@@ -199,22 +199,26 @@ std::vector<ProcessDropHandler::ProcessDrop> ProcessDropHandlerList::getDrop(
       if(auto it = m_perFileExtension.find(ext.toStdString());
          it != m_perFileExtension.end())
       {
-        auto& handler = *it->second;
-
-        // First check if a custom drop is in order, which handles everything.
-        if(handleCustomDrop(handler))
-        {
-          // qDebug() << "handled through getCustomDrops";
-          return res;
-        }
-
-        // Then fall back to the normal mime data drop
-        score::FilePath p{
+        const score::FilePath p{
             .absolute = path,
             .relative = score::relativizeFilePath(path, ctx),
             .filename = f.fileName(),
             .basename = f.baseName()};
-        handler.getFileDrops(res, mime, p, ctx);
+
+        for(auto* h : it->second)
+        {
+          auto& handler = *h;
+
+          // First check if a custom drop is in order, which handles everything.
+          if(handleCustomDrop(handler))
+          {
+            // qDebug() << "handled through getCustomDrops";
+            return res;
+          }
+
+          // Then fall back to the normal mime data drop
+          handler.getFileDrops(res, mime, p, ctx);
+        }
       }
     }
   }
@@ -262,7 +266,7 @@ void ProcessDropHandlerList::initCaches() const
     {
       for(const auto& ext : handler.fileExtensions())
       {
-        m_perFileExtension[ext.toLower().toStdString()] = &handler;
+        m_perFileExtension[ext.toLower().toStdString()].push_back(&handler);
       }
 
       for(const auto& ext : handler.mimeTypes())

src/plugins/score-lib-process/Process/Drop/ProcessDropHandler.hpp

@@ -16,6 +16,7 @@
 #include <score_lib_process_export.h>
 
 #include <string>
+#include <vector>
 
 namespace Process
 {
@@ -85,7 +86,11 @@ class SCORE_LIB_PROCESS_EXPORT ProcessDropHandlerList final
 private:
   void initCaches() const;
   mutable ossia::hash_map<std::string, ProcessDropHandler*> m_perMimeTypes{};
-  mutable ossia::hash_map<std::string, ProcessDropHandler*> m_perFileExtension{};
+  // Several handlers legitimately claim one extension -- four shader families
+  // share ".fs" and tell each other apart by reading the file header -- so each
+  // of them gets its turn and the ones the file does not belong to say nothing.
+  mutable ossia::hash_map<std::string, std::vector<ProcessDropHandler*>>
+      m_perFileExtension{};
   mutable std::size_t m_lastCacheSize{};
 };
 }

src/plugins/score-plugin-gfx/Gfx/CSF/Library.cpp

@@ -1,6 +1,7 @@
 #include <Gfx/CSF/Library.hpp>
 #include <Gfx/CSF/Process.hpp>
 #include <Gfx/Filter/PreviewWidget.hpp>
+#include <Gfx/ShaderProgram.hpp>
 #include <Library/LibrarySettings.hpp>
 #include <Library/ProcessesItemModel.hpp>
 
@@ -60,6 +61,18 @@ void DropHandler::dropPath(
     std::vector<ProcessDrop>& vec, const score::FilePath& filename,
     const score::DocumentContext& ctx) const noexcept
 {
+  // A compute extension is not shared with any other family, so a file that
+  // declares no MODE at all is still taken -- but one that claims to be
+  // something else is left to its own handler.
+  switch(Gfx::shaderFileFamily(filename.absolute))
+  {
+    case Gfx::ShaderFamily::Compute:
+    case Gfx::ShaderFamily::Unknown:
+      break;
+    default:
+      return;
+  }
+
   Process::ProcessDropHandler::ProcessDrop p;
   p.creation.key = Metadata<ConcreteKey_k, Gfx::CSF::Model>::get();
   p.creation.prettyName = filename.basename;

src/plugins/score-plugin-gfx/Gfx/CSF/Process.cpp

@@ -79,10 +79,10 @@ Model::Model(
 {
   metadata().setInstanceName(*this);
 
-  QFile f{init};
-  if(f.open(QIODevice::ReadOnly))
+  const QString path = locateShaderPath(init, *this);
+  if(QFile f{path}; f.open(QIODevice::ReadOnly))
   {
-    m_scriptPath = init;
+    m_scriptPath = path;
     (void)setCompute(f.readAll());
   }
 }

src/plugins/score-plugin-gfx/Gfx/Filter/Library.cpp

@@ -2,7 +2,7 @@
 #include <Gfx/Filter/Library.hpp>
 #include <Gfx/Filter/PreviewWidget.hpp>
 #include <Gfx/Filter/Process.hpp>
-#include <Gfx/GeometryFilter/Process.hpp>
+#include <Gfx/ShaderProgram.hpp>
 #include <Gfx/GfxDevice.hpp>
 #include <Library/LibrarySettings.hpp>
 #include <Library/ProcessesItemModel.hpp>
@@ -154,13 +154,13 @@ void DropHandler::dropPath(
     std::vector<ProcessDrop>& vec, const score::FilePath& filename,
     const score::DocumentContext& ctx) const noexcept
 {
-  // See Gfx::GeometryFilter::DropHandler::dropPath: "glsl" resolves to one of
-  // the two handlers and either has to produce the right process.
-  QFile f{filename.absolute};
+  // ISF is the family without a MODE of its own: anything that declares one
+  // belongs to the handler of that family, which gets its own turn at the file.
+  if(Gfx::shaderFileFamily(filename.absolute) != Gfx::ShaderFamily::Unknown)
+    return;
+
   Process::ProcessDropHandler::ProcessDrop p;
-  p.creation.key = score::fileContains(f, "\"GEOMETRY_FILTER\"")
-                       ? Metadata<ConcreteKey_k, Gfx::GeometryFilter::Model>::get()
-                       : Metadata<ConcreteKey_k, Gfx::Filter::Model>::get();
+  p.creation.key = Metadata<ConcreteKey_k, Gfx::Filter::Model>::get();
   p.creation.prettyName = filename.basename;
   p.creation.customData = filename.relative;
 

src/plugins/score-plugin-gfx/Gfx/Filter/Process.cpp

@@ -71,15 +71,16 @@ Model::Model(
   metadata().setInstanceName(*this);
   m_outlets.push_back(new TextureOutlet{"Texture Out", Id<Process::Port>(1), this});
 
-  if(init.endsWith("fs") || init.endsWith("frag"))
+  const QString path = locateShaderPath(init, *this);
+  if(path.endsWith("fs") || path.endsWith("frag"))
   {
-    m_scriptPath = init;
-    (void)setProgram(programFromISFFragmentShaderPath(init, {}));
+    m_scriptPath = path;
+    (void)setProgram(programFromISFFragmentShaderPath(path, {}));
   }
-  else if(init.endsWith("vs") || init.endsWith("vert"))
+  else if(path.endsWith("vs") || path.endsWith("vert"))
   {
-    m_scriptPath = init;
-    (void)setProgram(programFromVSAVertexShaderPath(init, {}));
+    m_scriptPath = path;
+    (void)setProgram(programFromVSAVertexShaderPath(path, {}));
   }
 }
 

src/plugins/score-plugin-gfx/Gfx/GeometryFilter/Library.cpp

@@ -1,7 +1,7 @@
-#include <Gfx/Filter/Process.hpp>
 #include <Gfx/GeometryFilter/Library.hpp>
 #include <Gfx/GeometryFilter/PreviewWidget.hpp>
 #include <Gfx/GeometryFilter/Process.hpp>
+#include <Gfx/ShaderProgram.hpp>
 #include <Library/LibrarySettings.hpp>
 #include <Library/ProcessesItemModel.hpp>
 
@@ -53,14 +53,11 @@ void DropHandler::dropPath(
     std::vector<ProcessDrop>& vec, const score::FilePath& filename,
     const score::DocumentContext& ctx) const noexcept
 {
-  // Both this handler and Gfx::Filter's claim "glsl", and only one of them is
-  // in ProcessDropHandlerList's per-extension map, so both have to sort the two
-  // shader kinds out the way the library handlers do.
-  QFile f{filename.absolute};
+  if(Gfx::shaderFileFamily(filename.absolute) != Gfx::ShaderFamily::GeometryFilter)
+    return;
+
   Process::ProcessDropHandler::ProcessDrop p;
-  p.creation.key = score::fileContains(f, "\"GEOMETRY_FILTER\"")
-                       ? Metadata<ConcreteKey_k, Gfx::GeometryFilter::Model>::get()
-                       : Metadata<ConcreteKey_k, Gfx::Filter::Model>::get();
+  p.creation.key = Metadata<ConcreteKey_k, Gfx::GeometryFilter::Model>::get();
   p.creation.prettyName = filename.basename;
   p.creation.customData = filename.relative;
 

src/plugins/score-plugin-gfx/Gfx/GeometryFilter/Process.cpp

@@ -38,8 +38,7 @@ Model::Model(
   m_inlets.push_back(new GeometryInlet{"Geometry In", Id<Process::Port>(0), this});
   m_outlets.push_back(new GeometryOutlet{"Geometry Out", Id<Process::Port>(1), this});
 
-  QFile f{init};
-  if(f.open(QIODevice::ReadOnly))
+  if(QFile f{locateShaderPath(init, *this)}; f.open(QIODevice::ReadOnly))
     (void)setScript(f.readAll());
 }
 

src/plugins/score-plugin-gfx/Gfx/ShaderProgram.cpp

@@ -5,6 +5,10 @@
 #include <Library/LibrarySettings.hpp>
 
 #include <score/application/ApplicationContext.hpp>
+#include <score/tools/File.hpp>
+#include <score/tools/FilePath.hpp>
+
+#include <core/document/Document.hpp>
 
 #include <ossia/detail/flat_map.hpp>
 #include <ossia/detail/hash_map.hpp>
@@ -597,36 +601,82 @@ ProgramCache::get(const ShaderSource& program, const QString& originPath) noexce
   return {std::nullopt, "Unknown error"};
 }
 
+static QString shaderSibling(const QString& path, std::initializer_list<QLatin1String> exts)
+{
+  const QFileInfo fi{path};
+  // completeBaseName, not baseName: `my.shader.fs` pairs with `my.shader.vs`,
+  // and path surgery on the string as a whole would also rewrite a folder
+  // called `fs-shaders`.
+  const QString base = fi.path() + '/' + fi.completeBaseName() + '.';
+  for(const QLatin1String& ext : exts)
+  {
+    if(fi.suffix() == ext)
+      continue;
+    if(const QString candidate = base + ext; QFileInfo::exists(candidate))
+      return candidate;
+  }
+  return {};
+}
+
+QString vertexShaderSibling(const QString& fsPath) noexcept
+{
+  return shaderSibling(fsPath, {QLatin1String{"vert"}, QLatin1String{"vs"}});
+}
+
+QString fragmentShaderSibling(const QString& vsPath) noexcept
+{
+  return shaderSibling(vsPath, {QLatin1String{"frag"}, QLatin1String{"fs"}});
+}
+
+ShaderFamily shaderFileFamily(const QString& path) noexcept
+{
+  struct
+  {
+    std::string_view marker;
+    ShaderFamily family;
+  } static constexpr markers[]{
+      {"\"RAW_RASTER_PIPELINE\"", ShaderFamily::RawRaster},
+      {"\"GEOMETRY_FILTER\"", ShaderFamily::GeometryFilter},
+      {"\"COMPUTE_SHADER\"", ShaderFamily::Compute},
+      {"\"VERTEX_SHADER_ART\"", ShaderFamily::VertexShaderArt},
+  };
+
+  for(const auto& [marker, family] : markers)
+  {
+    // A fresh QFile per marker: fileContains reads from wherever the device
+    // currently is.
+    QFile f{path};
+    if(score::fileContains(f, marker))
+      return family;
+  }
+  return ShaderFamily::Unknown;
+}
+
+QString locateShaderPath(const QString& path, const QObject& process) noexcept
+{
+  if(path.isEmpty())
+    return path;
+
+  // Walked here rather than through score::IDocument::documentFromObject,
+  // which THROWS for an object that is not in a document -- a process being
+  // built for a preview or a preset is not, and this is noexcept.
+  for(const QObject* obj = &process; obj; obj = obj->parent())
+    if(auto* doc = qobject_cast<const score::Document*>(obj))
+      return score::locateFilePath(path, doc->context());
+
+  return path;
+}
+
 ShaderSource
 programFromISFFragmentShaderPath(
     const QString& fsFilename, QByteArray fsData, ShaderSource::ProgramType type)
 {
-  // ISF works by storing a vertex shader next to the fragment shader.
-  // Score recognises both the long (.frag/.vert) and short (.fs/.vs)
-  // extension conventions; pairings are tried independently of the FS
-  // file's own naming so a `foo.frag` next to `foo.vs` (or `foo.fs` next
-  // to `foo.vert`) also resolves. Without this, the .vs sibling is
-  // silently ignored and the descriptor falls back to the ISF default
-  // vertex shader — which doesn't know about user-declared
-  // VERTEX_INPUTS, so the consumer renders nothing.
-  const QString candidates[] = {
-      QString(fsFilename).replace(".frag", ".vert").replace(".fs", ".vs"),
-      QString(fsFilename).replace(".frag", ".vs"),
-      QString(fsFilename).replace(".fs", ".vert"),
-  };
-
   // If empty: will be using the ISF's default
   QByteArray vertexData;
-  for(const QString& vertexName : candidates)
+  if(const QString vertexName = vertexShaderSibling(fsFilename); !vertexName.isEmpty())
   {
-    if(vertexName == fsFilename)
-      continue;
-    if(QFile vertexFile{vertexName};
-       vertexFile.exists() && vertexFile.open(QIODevice::ReadOnly))
-    {
+    if(QFile vertexFile{vertexName}; vertexFile.open(QIODevice::ReadOnly))
       vertexData = vertexFile.readAll();
-      break;
-    }
   }
 
   if(fsData.isEmpty())

src/plugins/score-plugin-gfx/Gfx/ShaderProgram.hpp

@@ -121,6 +121,36 @@ struct SCORE_PLUGIN_GFX_EXPORT ShaderSource
   }
 };
 
+//! Which of the shader families a file on disk belongs to, read from the
+//! "MODE" key of its ISF header. `Unknown` is a shader with no such key: an
+//! ISF without MODE, a bare GLSL snippet, a hand-written companion vertex
+//! shader. Deciding this is what lets several drop handlers share an
+//! extension: each one claims its own family and leaves the rest alone.
+enum class ShaderFamily
+{
+  Unknown,
+  RawRaster,
+  GeometryFilter,
+  Compute,
+  VertexShaderArt
+};
+
+SCORE_PLUGIN_GFX_EXPORT ShaderFamily shaderFileFamily(const QString& path) noexcept;
+
+//! Path of the vertex shader that goes with @p fsPath -- `foo.vert` or
+//! `foo.vs` next to `foo.fs` / `foo.frag` -- or an empty string.
+SCORE_PLUGIN_GFX_EXPORT QString vertexShaderSibling(const QString& fsPath) noexcept;
+
+//! Path of the fragment shader @p vsPath is the companion of, or an empty
+//! string. A vertex shader that has one is not a standalone process.
+SCORE_PLUGIN_GFX_EXPORT QString fragmentShaderSibling(const QString& vsPath) noexcept;
+
+//! Absolute path of the shader a process was created with. Construction data
+//! travels as a <PROJECT>: / <LIBRARY>: path so that it survives a project
+//! being moved; the model needs the resolved one, like the load path does.
+SCORE_PLUGIN_GFX_EXPORT
+QString locateShaderPath(const QString& path, const QObject& process) noexcept;
+
 SCORE_PLUGIN_GFX_EXPORT ShaderSource
 programFromISFFragmentShaderPath(
     const QString& fsFilename, QByteArray fsData,