TranslatorContext.h

#pragma once
#include "AL/usdmaya/Common.h"
#include "maya/MPxData.h"
#include "maya/MGlobal.h"
#include "maya/MObject.h"
#include "maya/MObjectHandle.h"
#include "maya/MObjectArray.h"
#include "maya/MDGModifier.h"
#include "pxr/base/tf/refPtr.h"
#include "pxr/usd/usd/prim.h"

#include <map>
#include <unordered_map>
#include <string>

namespace AL {
namespace usdmaya {
namespace fileio {
namespace translators {

typedef std::vector<MObjectHandle> MObjectHandleArray;

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
struct TranslatorContext
  : public TfRefBase
{
public:
  typedef TranslatorContext This; 
  typedef TfRefPtr<This> RefPtr; 

  static RefPtr create(nodes::ProxyShape* proxyShape)
    { return TfCreateRefPtr(new This(proxyShape)); }

  const nodes::ProxyShape* getProxyShape() const
    { return m_proxyShape; }

  UsdStageRefPtr getUsdStage() const;

  bool getTransform(const UsdPrim& prim, MObjectHandle& object)
    { return getTransform(prim.GetPath(), object); }

  bool getTransform(const SdfPath& path, MObjectHandle& object);

  bool getMObject(const UsdPrim& prim, MObjectHandle& object, MTypeId type)
    { return getMObject(prim.GetPath(), object, type); }

  bool getMObject(const SdfPath& path, MObjectHandle& object, MTypeId type);

  bool getMObject(const UsdPrim& prim, MObjectHandle& object, MFn::Type type)
    { return getMObject(prim.GetPath(), object, type); }

  bool getMObject(const SdfPath& path, MObjectHandle& object, MFn::Type type);

  bool getMObjects(const UsdPrim& prim, MObjectHandleArray& returned)
    { return getMObjects(prim.GetPath(), returned); }

  bool getMObjects(const SdfPath& path, MObjectHandleArray& returned);

  void insertItem(const UsdPrim& prim, MObjectHandle object);

  void removeItems(const UsdPrim& prim)
    { removeItems(prim.GetPath()); }

  void removeItems(const SdfPath& path);

  ~TranslatorContext();
   
  TfToken getTypeForPath(SdfPath path) const
  {
    const auto it = m_primMapping.find(path.GetString());
    if(it != m_primMapping.end())
    {
      return it->second.m_type;
    }
    return TfToken();
  }

  void registerItem(const UsdPrim& prim, MObjectHandle object);
   
  MString serialise() const;

  void deserialise(const MString& string);

private:

  TranslatorContext(const nodes::ProxyShape* proxyShape)
    : m_proxyShape(proxyShape), m_primMapping()
    {}

  const nodes::ProxyShape* m_proxyShape;

  struct PrimLookup
  {
    TfToken m_type;
    MObjectHandle m_object;
    MObjectHandleArray m_createdNodes;
  };

  // map between a usd prim path and either a dag parent node or
  // a dependency node
  std::unordered_map<std::string, PrimLookup> m_primMapping;
};

typedef TfRefPtr<TranslatorContext> TranslatorContextPtr;

//----------------------------------------------------------------------------------------------------------------------
} // translators
} // fileio
} // usdmaya
} // AL
//----------------------------------------------------------------------------------------------------------------------