ProxyShape.h

#pragma once
#include "AL/usdmaya/Common.h"
#include "AL/maya/NodeHelper.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/VariantDB.h"

#include "maya/MPxSurfaceShape.h"
#include "maya/MEventMessage.h"
#include "maya/MNodeMessage.h"
#include "maya/MPxDrawOverride.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>

class UsdImagingGLHdEngine;

namespace AL {
namespace usdmaya {
namespace nodes {

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class ProxyShape
  : public MPxSurfaceShape,
    public maya::NodeHelper,
    public TfWeakBase
{
public:

  ProxyShape();

  ~ProxyShape();

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

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

  Layer* findLayer(SdfLayerHandle handle);

  MString findLayerMayaName(SdfLayerHandle handle);

  Layer* getLayer();

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

  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);

  // TODO reset if the usd file path is updated via the ui
  AL_DECL_ATTRIBUTE(serializedSessionLayer);


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

  AL_DECL_ATTRIBUTE(serializedTrCtx);

  AL_DECL_ATTRIBUTE(unloaded);

  AL_DECL_ATTRIBUTE(drivenPrimPaths);

  AL_DECL_ATTRIBUTE(drivenVisibility);

  AL_DECL_ATTRIBUTE(drivenTranslate);

  AL_DECL_ATTRIBUTE(drivenScale);

  AL_DECL_ATTRIBUTE(drivenRotate);

  AL_DECL_ATTRIBUTE(drivenRotateOrder);

  AL_DECL_ATTRIBUTE(ambient);

  AL_DECL_ATTRIBUTE(diffuse);

  AL_DECL_ATTRIBUTE(specular);

  AL_DECL_ATTRIBUTE(emission);

  AL_DECL_ATTRIBUTE(shininess);

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

  AL_DECL_ATTRIBUTE(outTime);

  AL_DECL_ATTRIBUTE(outStageData);

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

  UsdStageRefPtr getUsdStage() const;

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

  MBoundingBox boundingBox() const override;

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

  enum TransformReason
  {
    kSelection = 1 << 0,  
    kRequested = 1 << 1,  
    kRequired = 1 << 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.m_node;
      }
      return MObject::kNullObj;
    }

  std::vector<UsdPrim> huntForNativeNodesUnderPrim(
      const MDagPath& proxyTransformPath,
      SdfPath startPath);

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

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

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

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

  void printRefCounts() const;

  void createSelectionChangedCallback();

  void destroySelectionChangedCallback();

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

  void unloadMayaReferences();

  nodes::SchemaNodeRefDB& schemaDB()
    { return m_schemaNodeDB; }

  void serialiseTranslatorContext();

  void deserialiseTranslatorContext();

  void constructGLImagingEngine();

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

  SdfPathVector& selectedPaths()
    { return m_selectedPaths; }

  void findExcludedGeometry();

  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();
    }

private:

  void constructExcludedPrims();
  bool getInternalValueInContext(const MPlug& plug, MDataHandle& dataHandle, MDGContext& ctx) override;
  bool setInternalValueInContext(const MPlug& plug, const MDataHandle& dataHandle, MDGContext& ctx) override;

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

  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);
    MObject m_node;
    Transform* m_transform;

    // ref counting values
    struct
    {
      uint32_t m_required:1;
      uint32_t m_selected:1;
      uint32_t m_refCount:30;
    };

    bool decRef(const TransformReason reason);
    void incRef(const TransformReason reason);
  };

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

  // insert a new path into the requiredPaths map
  void makeTransformReference(const SdfPath& path, const MObject& node, TransformReason reason);

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

  void postConstructor() override;
  MStatus compute(const MPlug& plug, MDataBlock& dataBlock) override;
  MStatus setDependentsDirty(const MPlug& plugBeingDirtied, MPlugArray& plugs) override;
  bool isBounded() const 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);

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

  UsdPrim getUsdPrim(MDataBlock& dataBlock) const;
  SdfPathVector getExcludePrimPaths() const;
  bool isStageValid() const;
  bool primHasExcludedParent(UsdPrim prim);
  bool initPrim(const uint32_t index, MDGContext& ctx);

  void reloadStage(MPlug& plug);
  void onObjectsChanged(UsdNotice::ObjectsChanged const&, UsdStageWeakPtr const& sender);
  void variantSelectionListener(SdfNotice::LayersDidChange const& notice, UsdStageWeakPtr const& sender);
  void onEditTargetChanged(UsdNotice::StageEditTargetChanged const& notice, UsdStageWeakPtr const& sender);
  static void onSelectionChanged(void* ptr);
  static void onAttributeChanged(MNodeMessage::AttributeMessage, MPlug&, MPlug&, void*);
  void validateTransforms();

private:
  SdfPathVector m_selectedPaths;
  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;
  MCallbackId m_onSelectChanged;
  MCallbackId m_beforeSaveSceneId;
  MCallbackId m_attributeChanged;
  SdfPathVector m_excludedGeometry;
  SdfPathVector m_excludedTaggedGeometry;
  UsdStageRefPtr m_stage;
  SdfPath m_path;
  SchemaNodeRefDB m_schemaNodeDB;
  SdfPath m_variantChangePath;
  SdfPathVector m_variantSwitchedPrims;
  UsdImagingGLHdEngine* m_engine = 0;
  uint32_t m_engineRefCount = 0;
  bool m_variantHasChanged = false;
};

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