ProxyShape.h

//
// Copyright 2017 Animal Logic
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.//
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#pragma once

#include "../Api.h"

#include <AL/usdmaya/ForwardDeclares.h>
#include "AL/maya/utils/Api.h"
#include "AL/maya/utils/MayaHelperMacros.h"
#include "AL/maya/utils/NodeHelper.h"
#include "AL/event/EventHandler.h"
#include "AL/maya/event/MayaEventManager.h"
#include <AL/usdmaya/SelectabilityDB.h>
#include "AL/usdmaya/DrivenTransformsData.h"
#include "AL/usdmaya/fileio/translators/TranslatorBase.h"
#include "AL/usdmaya/fileio/translators/TranslatorContext.h"
#include "AL/usdmaya/fileio/translators/TransformTranslator.h"
#include "AL/usdmaya/nodes/proxy/PrimFilter.h"
#include "maya/MPxSurfaceShape.h"
#include "maya/MEventMessage.h"
#include "maya/MNodeMessage.h"
#include "maya/MPxDrawOverride.h"
#include "maya/MEvaluationNode.h"
#include "maya/MDagModifier.h"
#include "maya/MObjectArray.h"
#include "maya/MSelectionList.h"
#include "pxr/pxr.h"
#include "pxr/usd/usd/prim.h"
#include "pxr/usd/usd/timeCode.h"
#include "pxr/usd/sdf/path.h"
#include "pxr/base/tf/weakBase.h"
#include "pxr/usd/usd/notice.h"
#include "pxr/usd/sdf/notice.h"
#include <stack>
#include <functional>
#include "AL/usd/utils/ForwardDeclares.h"

PXR_NAMESPACE_USING_DIRECTIVE

PXR_NAMESPACE_OPEN_SCOPE

class UsdImagingGLHdEngine;

// Note: you MUST forward declare LayerManager, and not include LayerManager.h;
// The reason is that LayerManager.h includes MPxLocatorNode.h, which on Linux,
// ends up bringing in Xlib.h, which has this unfortunate macro:
//
//    #define Bool int
//
// This, in turn, will cause problems if you try to use SdfValueTypeNames->Bool,
// as in test_usdmaya_AttributeType.cpp
class LayerManager;

PXR_NAMESPACE_CLOSE_SCOPE;

namespace AL {
namespace usdmaya {
namespace nodes {

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
struct SelectionUndoHelper
{
  typedef TfHashSet<SdfPath, SdfPath::Hash> SdfPathHashSet;

  SelectionUndoHelper(nodes::ProxyShape* proxy, const SdfPathHashSet& paths, MGlobal::ListAdjustment mode, bool internal = false);

  void doIt();

  void undoIt();

private:
  friend class ProxyShape;
  nodes::ProxyShape* m_proxy;
  SdfPathHashSet m_paths;
  SdfPathHashSet m_previousPaths;
  MGlobal::ListAdjustment m_mode;
  MDagModifier m_modifier1;
  MDagModifier m_modifier2;
  MSelectionList m_previousSelection;
  MSelectionList m_newSelection;
  std::vector<std::pair<SdfPath, MObject>> m_insertedRefs;
  std::vector<std::pair<SdfPath, MObject>> m_removedRefs;
  bool m_internal;
};

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class SelectionList
{
public:
  typedef TfHashSet<SdfPath, SdfPath::Hash> SdfPathHashSet;

  SelectionList() = default;

  SelectionList(const SelectionList& sl) = default;

  ~SelectionList() = default;

  inline void clear()
    { m_selected.clear(); }

  inline void add(SdfPath path)
    {
      m_selected.insert(path);
    }

  inline void remove(SdfPath path)
    {
      auto it = m_selected.find(path);
      if(it != m_selected.end())
      {
        m_selected.erase(it);
      }
    }

  inline void toggle(SdfPath path)
    {
      auto insertResult = m_selected.insert(path);
      if (!insertResult.second)
      {
        m_selected.erase(insertResult.first);
      }
    }

  inline bool isSelected(const SdfPath& path) const
    { return m_selected.count(path) > 0; }

  inline const SdfPathHashSet& paths() const
    { return m_selected; }

  inline size_t size() const
    { return m_selected.size(); }

private:
  SdfPathHashSet m_selected;
};

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
struct  HierarchyIterationLogic
{
  HierarchyIterationLogic():
      preIteration(nullptr),
      iteration(nullptr),
      postIteration(nullptr)
  {}

  std::function<void()> preIteration;

  std::function<void(const fileio::TransformIterator& transformIterator,const UsdPrim& prim)> iteration;

  std::function<void()> postIteration;
};

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
struct FindUnselectablePrimsLogic
  : public HierarchyIterationLogic
{
  SdfPathVector newUnselectables; 
  SdfPathVector removeUnselectables; 
};

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
struct FindLockedPrimsLogic
  : public HierarchyIterationLogic
{
};

typedef const HierarchyIterationLogic*  HierarchyIterationLogics[3];
typedef std::unordered_map<SdfPath, MString, SdfPath::Hash > PrimPathToDagPath;

extern AL::event::EventId kPreClearStageCache;
extern AL::event::EventId kPostClearStageCache;
//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class ProxyShape
  : public MPxSurfaceShape,
    public AL::maya::utils::NodeHelper,
    public proxy::PrimFilterInterface,
    public AL::event::NodeEvents,
    public TfWeakBase
{
  friend struct SelectionUndoHelper;
  friend class ProxyShapeUI;
  friend class StageReloadGuard;
  friend class ProxyDrawOverride;
public:

  // returns the shape's parent transform
  MDagPath parentTransform();

  AL_USDMAYA_PUBLIC
  void registerEvents();

  typedef TfHashSet<SdfPath, SdfPath::Hash> SdfPathHashSet;

  typedef std::vector<std::pair<MObject, UsdPrim> > MObjectToPrim;
  AL_USDMAYA_PUBLIC
  static const char* s_selectionMaskName;

  AL_USDMAYA_PUBLIC
  ProxyShape();

  AL_USDMAYA_PUBLIC
  ~ProxyShape();

  //--------------------------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------------------------
  AL_MAYA_DECLARE_NODE();

  //--------------------------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------------------------

  AL_DECL_ATTRIBUTE(filePath);

  AL_DECL_ATTRIBUTE(primPath);

  AL_DECL_ATTRIBUTE(excludePrimPaths);

  AL_DECL_ATTRIBUTE(time);

  AL_DECL_ATTRIBUTE(timeOffset);

  AL_DECL_ATTRIBUTE(timeScalar);

  AL_DECL_ATTRIBUTE(complexity);

  AL_DECL_ATTRIBUTE(displayGuides);

  AL_DECL_ATTRIBUTE(displayRenderGuides);

  AL_DECL_ATTRIBUTE(layers);

  AL_DECL_ATTRIBUTE(serializedSessionLayer);

  AL_DECL_ATTRIBUTE(sessionLayerName);

  // @note currently not used
  AL_DECL_ATTRIBUTE(serializedArCtx);

  AL_DECL_ATTRIBUTE(serializedTrCtx);

  AL_DECL_ATTRIBUTE(unloaded);

  AL_DECL_ATTRIBUTE(inDrivenTransformsData);

  AL_DECL_ATTRIBUTE(ambient);

  AL_DECL_ATTRIBUTE(diffuse);

  AL_DECL_ATTRIBUTE(specular);

  AL_DECL_ATTRIBUTE(emission);

  AL_DECL_ATTRIBUTE(shininess);

  AL_DECL_ATTRIBUTE(serializedRefCounts);

  AL_DECL_ATTRIBUTE(populationMaskIncludePaths);

  AL_DECL_ATTRIBUTE(version);

  AL_DECL_ATTRIBUTE(stageDataDirty);

  AL_DECL_ATTRIBUTE(excludedTranslatedGeometry);

  AL_DECL_ATTRIBUTE(stageCacheId);

  AL_DECL_ATTRIBUTE(assetResolverConfig);

  //--------------------------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------------------------

  AL_DECL_ATTRIBUTE(outTime);

  AL_DECL_ATTRIBUTE(outStageData);


  //--------------------------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------------------------

  AL_USDMAYA_PUBLIC
  UsdStageRefPtr getUsdStage() const;

  UsdStageRefPtr usdStage() const
    { return m_stage; }

  bool getRenderAttris(void* attribs, const MHWRender::MFrameContext& frameContext, const MDagPath& dagPath);

  AL_USDMAYA_PUBLIC
  MBoundingBox boundingBox() const override;

  //--------------------------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------------------------

  enum TransformReason
  {
    kSelection = 1 << 0,  
    kRequested = 1 << 1,  
    kRequired = 1 << 2    
  };

  enum class PickMode : int
  {
    kPrims = 0,      
    kModels = 1,     
    kInstances = 2,  
  };

  inline bool isRequiredPath(const SdfPath& path) const
    { return m_requiredPaths.find(path) != m_requiredPaths.end(); }

  inline MObject findRequiredPath(const SdfPath& path) const
    {
      const auto it = m_requiredPaths.find(path);
      if(it != m_requiredPaths.end())
      {
        return it->second.node();
      }
      return MObject::kNullObj;
    }

  AL_USDMAYA_PUBLIC
  std::vector<UsdPrim> huntForNativeNodesUnderPrim(
      const MDagPath& proxyTransformPath,
      SdfPath startPath,
      fileio::translators::TranslatorManufacture& manufacture);

  AL_USDMAYA_PUBLIC
  MObject makeUsdTransformChain(
      const UsdPrim& usdPrim,
      MDagModifier& modifier,
      TransformReason reason,
      MDGModifier* modifier2 = 0,
      uint32_t* createCount = 0);

  AL_USDMAYA_PUBLIC
  MObject makeUsdTransforms(
      const UsdPrim& usdPrim,
      MDagModifier& modifier,
      TransformReason reason,
      MDGModifier* modifier2 = 0);

  AL_USDMAYA_PUBLIC
  void removeUsdTransformChain(
      const UsdPrim& usdPrim,
      MDagModifier& modifier,
      TransformReason reason);

  AL_USDMAYA_PUBLIC
  void removeUsdTransformChain(
      const SdfPath& path,
      MDagModifier& modifier,
      TransformReason reason);

  AL_USDMAYA_PUBLIC
  void removeUsdTransforms(
      const UsdPrim& usdPrim,
      MDagModifier& modifier,
      TransformReason reason);

  AL_USDMAYA_PUBLIC
  void printRefCounts() const;

  void destroyTransformReferences()
    { m_requiredPaths.clear(); }

  AL_USDMAYA_PUBLIC
  void filterPrims(
      const SdfPathVector& previousPrims,
      std::vector<UsdPrim>& newPrimSet,
      std::vector<UsdPrim>& transformsToCreate,
      std::vector<UsdPrim>& updatablePrimSet,
      SdfPathVector& removedPrimSet);

  AL_USDMAYA_PUBLIC
  void getCounts(SdfPath path, uint32_t& selected, uint32_t& required, uint32_t& refCount)
  {
    auto it = m_requiredPaths.find(path);
    if(it != m_requiredPaths.end())
    {
      selected = it->second.selected();
      required = it->second.required();
      refCount = it->second.refCount();
    }
  }

  AL_USDMAYA_PUBLIC
  bool isSelectedMObject(MObject obj, SdfPath& path)
  {
    for(auto it : m_requiredPaths)
    {
      if(obj == it.second.node())
      {
        path = it.first;
        if(m_selectedPaths.count(it.first) > 0)
        {
          return true;
        }
        break;
      }
    }
    return false;
  }

  //--------------------------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------------------------

  AL_USDMAYA_PUBLIC
  void serialiseTranslatorContext();

  AL_USDMAYA_PUBLIC
  void deserialiseTranslatorContext();

  AL_USDMAYA_PUBLIC
  MString recordUsdPrimToMayaPath(const UsdPrim &usdPrim,
                                  const MObject &mayaObject);

  AL_USDMAYA_PUBLIC
  MString getMayaPathFromUsdPrim(const UsdPrim& usdPrim);

  AL_USDMAYA_PUBLIC
  void findTaggedPrims();

  AL_USDMAYA_PUBLIC
  void findTaggedPrims(const HierarchyIterationLogics& iterationLogics);

  AL_USDMAYA_PUBLIC
  void findExcludedGeometry();

  AL_USDMAYA_PUBLIC
  void findSelectablePrims();

  AL_USDMAYA_PUBLIC
  void iteratePrimHierarchy();

  fileio::translators::TranslatorManufacture& translatorManufacture()
    { return m_translatorManufacture; }

  inline fileio::translators::TranslatorContextPtr& context()
    { return m_context; }

  //--------------------------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------------------------

  AL_USDMAYA_PUBLIC
  SdfPathHashSet& selectedPaths()
    { return m_selectedPaths; }

  //          they will get as the result of the command, ["|proxyRoot|foo|bar", "|proxyRoot|some|thing"], and be able
  //          to know what input SdfPath corresponds to what ouptut maya path
  AL_USDMAYA_PUBLIC
  bool doSelect(SelectionUndoHelper& helper, const SdfPathVector& orderedPaths);

  //--------------------------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------------------------

  AL_USDMAYA_PUBLIC
  void constructGLImagingEngine();

  inline UsdImagingGLHdEngine* engine() const
    { return m_engine; }

  //--------------------------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------------------------

  AL_USDMAYA_PUBLIC
  void unloadMayaReferences();

  UsdPrim getRootPrim()
    {
      if(m_stage)
      {
        if(!m_path.IsEmpty())
        {
          UsdPrim prim = m_stage->GetPrimAtPath(m_path);
          if(prim)
            return prim;
        }
        return m_stage->GetPseudoRoot();
      }
      return UsdPrim();
    }

  AL_USDMAYA_PUBLIC
  void serialiseTransformRefs();

  AL_USDMAYA_PUBLIC
  void deserialiseTransformRefs();

  AL_USDMAYA_PUBLIC
  void onPrePrimChanged(const SdfPath& path, SdfPathVector& outPathVector);

  AL_USDMAYA_PUBLIC
  void onPrimResync(SdfPath primPath, SdfPathVector& changedPaths);

  AL_USDMAYA_PUBLIC
  void resync(const SdfPath& primPath);


  // \brief Serialize information unique to this shape
  AL_USDMAYA_PUBLIC
  void serialize(UsdStageRefPtr stage, LayerManager* layerManager);

  // \brief Serialize all layers in proxyShapes to layerManager attributes; called before saving
  AL_USDMAYA_PUBLIC
  static void serializeAll();

  static inline std::vector<MObjectHandle>& GetUnloadedProxyShapes()
  {
    return m_unloadedProxyShapes;
  }

  inline void primChangedAtPath(const SdfPath& changePath)
  {
    UsdPrim p = m_stage->GetPrimAtPath(changePath);

    if(!p.IsValid())
    {
      MGlobal::displayInfo("ProxyShape: Could not change prim at path since there was no valid prim at the passed in path");
      return;
    }
    m_compositionHasChanged = true;
    m_changedPath = changePath;
    onPrePrimChanged(m_changedPath, m_variantSwitchedPrims);
  }

  inline void setHaveObjectsChangedAtPath(bool hasObjectsChanged)
    { m_compositionHasChanged = hasObjectsChanged; }

  SelectionList& selectionList()
    { return m_selectionList; }

  inline void setChangedSelectionState(bool v)
    { m_hasChangedSelection = v; }

  AL::usdmaya::SelectabilityDB& selectabilityDB()
    { return m_selectabilityDB; }

  const AL::usdmaya::SelectabilityDB& selectabilityDB() const
    { return const_cast<ProxyShape*>(this)->selectabilityDB(); }

  AL_USDMAYA_PUBLIC
  void loadStage();

  AL_USDMAYA_PUBLIC
  void addAttributeChangedCallback();

  AL_USDMAYA_PUBLIC
  void removeAttributeChangedCallback();

  AL_USDMAYA_PUBLIC
  void constructLockPrims();

  AL_USDMAYA_PUBLIC
  void translatePrimPathsIntoMaya(
      const SdfPathVector& importPaths,
      const SdfPathVector& teardownPaths,
      const fileio::translators::TranslatorParameters& param = fileio::translators::TranslatorParameters());

  AL_USDMAYA_PUBLIC
  void translatePrimsIntoMaya(
      const AL::usd::utils::UsdPrimVector& importPrims,
      const SdfPathVector& teardownPaths,
      const fileio::translators::TranslatorParameters& param = fileio::translators::TranslatorParameters());

  AL_USDMAYA_PUBLIC
  SdfPathVector getPrimPathsFromCommaJoinedString(const MString &paths) const;

  AL_USDMAYA_PUBLIC
  MSelectionMask getShapeSelectionMask() const override;

private:

  static void onSelectionChanged(void* ptr);
  bool removeAllSelectedNodes(SelectionUndoHelper& helper);
  void removeTransformRefs(const std::vector<std::pair<SdfPath, MObject>>& removedRefs, TransformReason reason);
  void insertTransformRefs(const std::vector<std::pair<SdfPath, MObject>>& removedRefs, TransformReason reason);

  void constructExcludedPrims();
  bool updateLockPrims(const SdfPathSet& lockTransformPrims, const SdfPathSet& lockInheritedPrims,
                       const SdfPathSet& unlockedPrims);
  bool lockTransformAttribute(const SdfPath& path, bool lock);

  MObject makeUsdTransformChain_internal(
      const UsdPrim& usdPrim,
      MDagModifier& modifier,
      TransformReason reason,
      MDGModifier* modifier2 = 0,
      uint32_t* createCount = 0,
      MString* newPath = 0);

  void removeUsdTransformChain_internal(
      const UsdPrim& usdPrim,
      MDagModifier& modifier,
      TransformReason reason);

  MObject makeUsdTransformChain(
      UsdPrim usdPrim,
      const MPlug& outStage,
      const MPlug& outTime,
      const MObject& parentXForm,
      MDagModifier& modifier,
      TransformReason reason,
      MDGModifier* modifier2,
      uint32_t* createCount,
      MString* newPath = 0);

  void makeUsdTransformsInternal(
      const UsdPrim& usdPrim,
      const MObject& parentXForm,
      MDagModifier& modifier,
      TransformReason reason,
      MDGModifier* modifier2);

  void removeUsdTransformsInternal(
      const UsdPrim& usdPrim,
      MDagModifier& modifier,
      TransformReason reason);

  struct TransformReference
  {
    TransformReference(const MObject& node, const TransformReason reason);
    TransformReference(MObject mayaNode, Transform* node, uint32_t r, uint32_t s, uint32_t rc);
    Transform* m_transform;
    MObject node() const { return m_node; }

    bool decRef(const TransformReason reason);
    void incRef(const TransformReason reason);
    void checkIncRef(const TransformReason reason);
    bool checkRef(const TransformReason reason);

    void printRefCounts() const
    {
      std::cout
                << m_required << ":"
                << m_selectedTemp << ":"
                << m_selected << ":"
                << int(m_refCount) << std::endl;
    }
    uint32_t selected() const { return m_selected; }
    uint32_t required() const { return m_required; }
    uint32_t refCount() const { return m_refCount; }
    void prepSelect()
      { m_selectedTemp = m_selected; }
  private:
    MObject m_node;
    // ref counting values
    struct
    {
      uint64_t m_required:16;
      uint64_t m_selectedTemp:16;
      uint64_t m_selected:16;
      uint64_t m_refCount:16;
    };
  };

  typedef std::map<SdfPath, TransformReference>  TransformReferenceMap;
  TransformReferenceMap m_requiredPaths;


  void cleanupTransformRefs();

  void makeTransformReference(const SdfPath& path, const MObject& node, TransformReason reason);

  void prepSelect();

  //--------------------------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------------------------

  void postConstructor() override;
  MStatus compute(const MPlug& plug, MDataBlock& dataBlock) override;
  MStatus setDependentsDirty(const MPlug& plugBeingDirtied, MPlugArray& plugs) override;
  bool isBounded() const override;
  #if MAYA_API_VERSION < 201700
  MPxNode::SchedulingType schedulingType() const override { return kSerialize; }
  #else
  MPxNode::SchedulingType schedulingType() const override { return kSerial; }
  #endif
  MStatus preEvaluation(const MDGContext & context, const MEvaluationNode& evaluationNode) override;

  //--------------------------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------------------------

  // split out compute methods.
  MStatus computeInStageDataCached(const MPlug& plug, MDataBlock& dataBlock);
  MStatus computeOutStageData(const MPlug& plug, MDataBlock& dataBlock);
  MStatus computeOutputTime(const MPlug& plug, MDataBlock& dataBlock, MTime&);
  MStatus computeDrivenAttributes(const MPlug& plug, MDataBlock& dataBlock, const MTime&);

  //--------------------------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------------------------

  UsdPrim getUsdPrim(MDataBlock& dataBlock) const;
  SdfPathVector getExcludePrimPaths() const;
  UsdStagePopulationMask constructStagePopulationMask(const MString &paths) const;

  bool isStageValid() const;
  bool primHasExcludedParent(UsdPrim prim);
  bool initPrim(const uint32_t index, MDGContext& ctx);

  void layerIdChanged(SdfNotice::LayerIdentifierDidChange const& notice, UsdStageWeakPtr const& sender);
  void onObjectsChanged(UsdNotice::ObjectsChanged const&, UsdStageWeakPtr const& sender);
  void variantSelectionListener(SdfNotice::LayersDidChange const& notice);
  void onEditTargetChanged(UsdNotice::StageEditTargetChanged const& notice, UsdStageWeakPtr const& sender);
  void trackEditTargetLayer(LayerManager* layerManager=nullptr);
  static void onAttributeChanged(MNodeMessage::AttributeMessage, MPlug&, MPlug&, void*);
  void validateTransforms();


  TfToken getTypeForPath(const SdfPath& path) override
    { return m_context->getTypeForPath(path); }

  bool getTypeInfo(TfToken type, bool& supportsUpdate, bool& requiresParent) override
    {
      auto translator = m_translatorManufacture.get(type);
      if(translator)
      {
        supportsUpdate = translator->supportsUpdate();
        requiresParent = translator->needsTransformParent();
      }
      return translator != 0;
    }

private:
  SdfPathVector m_pathsOrdered;
  static std::vector<MObjectHandle> m_unloadedProxyShapes;

  AL::usdmaya::SelectabilityDB m_selectabilityDB;
  HierarchyIterationLogics m_hierarchyIterationLogics;
  HierarchyIterationLogic m_findExcludedPrims;
  SelectionList m_selectionList;
  FindUnselectablePrimsLogic m_findUnselectablePrims;
  SdfPathHashSet m_selectedPaths;
  FindLockedPrimsLogic m_findLockedPrims;
  PrimPathToDagPath m_primPathToDagPath;
  std::vector<SdfPath> m_paths;
  std::vector<UsdPrim> m_prims;
  TfNotice::Key m_objectsChangedNoticeKey;
  TfNotice::Key m_variantChangedNoticeKey;
  TfNotice::Key m_editTargetChanged;

  mutable std::map<UsdTimeCode, MBoundingBox> m_boundingBoxCache;
  AL::event::CallbackId m_beforeSaveSceneId = -1;
  MCallbackId m_attributeChanged = 0;
  MCallbackId m_onSelectionChanged = 0;
  SdfPathVector m_excludedGeometry;
  SdfPathVector m_excludedTaggedGeometry;
  SdfPathSet m_lockTransformPrims;
  SdfPathSet m_lockInheritedPrims;
  SdfPathSet m_currentLockedPrims;
  static MObject m_transformTranslate;
  static MObject m_transformRotate;
  static MObject m_transformScale;
  UsdStageRefPtr m_stage;
  SdfPath m_path;
  fileio::translators::TranslatorContextPtr m_context;
  fileio::translators::TranslatorManufacture m_translatorManufacture;
  SdfPath m_changedPath;
  SdfPathVector m_variantSwitchedPrims;
  SdfLayerHandle m_prevEditTarget;
  UsdImagingGLHdEngine* m_engine = 0;

  uint32_t m_engineRefCount = 0;
  bool m_compositionHasChanged = false;
  bool m_drivenTransformsDirty = false;
  bool m_pleaseIgnoreSelection = false;
  bool m_hasChangedSelection = false;
};

//----------------------------------------------------------------------------------------------------------------------
} // nodes
} // usdmaya
} // AL
//----------------------------------------------------------------------------------------------------------------------