MAYA-107516 USD Layer Editor

lib/mayaUsd/commands/CMakeLists.txt

@@ -8,14 +8,17 @@ target_sources(${PROJECT_NAME}
         baseListShadingModesCommand.cpp
         editTargetCommand.cpp
         layerEditorCommand.cpp
+        layerEditorWindowCommand.cpp
 )
 
 set(HEADERS
+        abstractLayerEditorWindow.h
         baseExportCommand.h
         baseImportCommand.h
         baseListShadingModesCommand.h
         editTargetCommand.h
         layerEditorCommand.h
+        layerEditorWindowCommand.h
 )
 
 # -----------------------------------------------------------------------------

lib/mayaUsd/commands/abstractLayerEditorWindow.h

@@ -0,0 +1,102 @@
+#ifndef ABSTRACTLAYEREDITORWINDOW_H
+#define ABSTRACTLAYEREDITORWINDOW_H
+
+#include <mayaUsd/base/api.h>
+
+#include <string>
+#include <vector>
+
+namespace MAYAUSD_NS_DEF {
+
+class AbstractLayerEditorWindow;
+
+/**
+ * @brief Abstract class used by layer editor window command to create and get
+ * the layer editor windows.
+ * This allows breaking the circular dependency between between maya usd lib
+ * and UI libraries.
+ *
+ */
+class MAYAUSD_CORE_PUBLIC AbstractLayerEditorCreator
+{
+public:
+    AbstractLayerEditorCreator();
+    virtual ~AbstractLayerEditorCreator();
+
+    typedef std::vector<std::string> PanelNamesList;
+
+    /*
+     * @brief returns a pointer to the registered  singleton
+     *
+     * @return AbstractLayerEditorCreator*
+     */
+    static AbstractLayerEditorCreator* instance();
+
+    /**
+     * @brief Create the maya panel with the given name
+     */
+    virtual AbstractLayerEditorWindow* createWindow(const char* panelName) = 0;
+
+    /**
+     * @brief returns the panel with a given name if it already exists
+     */
+    virtual AbstractLayerEditorWindow* getWindow(const char* panelName) const = 0;
+
+    /**
+     * @brief Gets an array of all the panels that exists
+     *
+     * @return std::vector<std::string>
+     */
+    virtual PanelNamesList getAllPanelNames() const = 0;
+
+private:
+    static AbstractLayerEditorCreator* _instance;
+};
+
+/**
+ * @brief Abstract class used to break dependency between core lib and maya UI,
+ * used to implement the layer editor commands
+ */
+class MAYAUSD_CORE_PUBLIC AbstractLayerEditorWindow
+{
+public:
+    /**
+     * @brief Constructor implemented by the maya usd layer editor
+     *
+     * @param panelName this is the name of the control in mel, not the title of the window
+     */
+    AbstractLayerEditorWindow(const char* panelName);
+
+    /**
+     * @brief Virtual Destructor
+     */
+    virtual ~AbstractLayerEditorWindow();
+
+    // queries about the current selection
+    virtual int  selectionLength() = 0;
+    virtual bool isInvalidLayer() = 0;
+    virtual bool isSessionLayer() = 0;
+    virtual bool isLayerDirty() = 0;
+    virtual bool isSubLayer() = 0;
+    virtual bool isAnonymousLayer() = 0;
+    virtual bool layerNeedsSaving() = 0;
+    virtual bool layerAppearsMuted() = 0;
+    virtual bool layerIsMuted() = 0;
+
+    virtual void removeSubLayer() = 0;
+    virtual void saveEdits() = 0;
+    virtual void discardEdits() = 0;
+    virtual void addAnonymousSublayer() = 0;
+    virtual void addParentLayer() = 0;
+    virtual void loadSubLayers() = 0;
+    virtual void muteLayer() = 0;
+    virtual void printLayer() = 0;
+    virtual void clearLayer() = 0;
+    virtual void selectPrimsWithSpec() = 0;
+
+    virtual void selectProxyShape(const char* shapePath) = 0;
+};
+
+} // namespace MAYAUSD_NS_DEF
+
+#endif // ABSTRACTLAYEREDITORWINDOW_H

lib/mayaUsd/commands/layerEditorCommand.cpp

@@ -43,6 +43,8 @@ const char kClearLayerFlag[] = "cl";
 const char kClearLayerFlagL[] = "clear";
 const char kAddAnonSublayerFlag[] = "aa";
 const char kAddAnonSublayerFlagL[] = "addAnonymous";
+const char kMuteLayerFlag[] = "mt";
+const char kMuteLayerFlagL[] = "muteLayer";
 
 } // namespace
 
@@ -57,7 +59,8 @@ enum class CmdId
     kReplace,
     kDiscardEdit,
     kClearLayer,
-    kAddAnonLayer
+    kAddAnonLayer,
+    kMuteLayer
 };
 
 class BaseCmd
@@ -320,6 +323,60 @@ class ClearLayer : public BackupLayerBase
     }
 };
 
+class MuteLayer : public BaseCmd
+{
+public:
+    MuteLayer()
+        : BaseCmd(CmdId::kMuteLayer)
+    {
+    }
+
+    bool doIt(SdfLayerHandle layer) override
+    {
+        auto stage = getStage();
+        if (!stage)
+            return false;
+        if (_muteIt) {
+            stage->MuteLayer(layer->GetIdentifier());
+        } else {
+            stage->UnmuteLayer(layer->GetIdentifier());
+        }
+
+        // we perfer not holding to pointers needlessly, but we need to hold on to the layer if we
+        // mute it otherwise usd will let go of it and its modifications, and any dirty children
+        // will also be lost
+        _mutedLayer = layer;
+        return true;
+    }
+
+    bool undoIt(SdfLayerHandle layer) override
+    {
+        auto stage = getStage();
+        if (!stage)
+            return false;
+        if (_muteIt) {
+            stage->UnmuteLayer(layer->GetIdentifier());
+        } else {
+            stage->MuteLayer(layer->GetIdentifier());
+        }
+        // we can release the pointer
+        _mutedLayer = nullptr;
+        return true;
+    }
+
+    std::string _proxyShapePath;
+    bool        _muteIt = true;
+
+protected:
+    UsdStageWeakPtr getStage()
+    {
+        auto prim = UsdMayaQuery::GetPrim(_proxyShapePath.c_str());
+        auto stage = prim.GetStage();
+        return stage;
+    }
+    PXR_NS::SdfLayerRefPtr _mutedLayer;
+};
+
 } // namespace Impl
 
 const char LayerEditorCommand::commandName[] = "mayaUsdLayerEditor";
@@ -346,8 +403,11 @@ MSyntax LayerEditorCommand::createSyntax()
     syntax.makeFlagMultiUse(kReplaceSubPathFlag);
     syntax.addFlag(kDiscardEditsFlag, kDiscardEditsFlagL);
     syntax.addFlag(kClearLayerFlag, kClearLayerFlagL);
+    // parameter: new layer name
     syntax.addFlag(kAddAnonSublayerFlag, kAddAnonSublayerFlagL, MSyntax::kString);
     syntax.makeFlagMultiUse(kAddAnonSublayerFlag);
+    // paramter: proxy shape name
+    syntax.addFlag(kMuteLayerFlag, kMuteLayerFlagL, MSyntax::kBoolean, MSyntax::kString);
 
     return syntax;
 }
@@ -434,6 +494,25 @@ MStatus LayerEditorCommand::parseArgs(const MArgList& argList)
                 _subCommands.push_back(std::move(cmd));
             }
         }
+        if (argParser.isFlagSet(kMuteLayerFlag)) {
+            bool muteIt = true;
+            argParser.getFlagArgument(kMuteLayerFlag, 0, muteIt);
+
+            MString proxyShapeName;
+            argParser.getFlagArgument(kMuteLayerFlag, 1, proxyShapeName);
+
+            auto prim = UsdMayaQuery::GetPrim(proxyShapeName.asChar());
+            if (prim == UsdPrim()) {
+                displayError(
+                    MString("Invalid proxy shape \"") + MString(proxyShapeName.asChar()) + "\"");
+                return MS::kInvalidParameter;
+            }
+
+            auto cmd = std::make_shared<Impl::MuteLayer>();
+            cmd->_muteIt = muteIt;
+            cmd->_proxyShapePath = proxyShapeName.asChar();
+            _subCommands.push_back(std::move(cmd));
+        }
     }
 
     return MS::kSuccess;