TranslatorBase.h

#pragma once

#include "maya/MDagPath.h"

#include "pxr/base/tf/refBase.h"
#include "pxr/base/tf/type.h"
#include "pxr/base/tf/weakBase.h"
#include "pxr/base/tf/registryManager.h"
#include "pxr/usd/usd/prim.h"

#include <iostream>
#include <unordered_map>
#include "AL/usdmaya/fileio/translators/TranslatorContext.h"

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

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class TranslatorAbstract
  : public TfRefBase, public TfWeakBase
{
public:
  typedef TranslatorAbstract This; 
  typedef TfRefPtr<This> RefPtr; 
  typedef TfWeakPtr<This> Ptr; 

  virtual ~TranslatorAbstract() {}

  virtual TfType getTranslatedType() const = 0;

  virtual bool needsTransformParent() const
    { return true; }

  virtual MStatus initialize()
    { return MS::kSuccess; }

  virtual MStatus import(const UsdPrim& prim, MObject& parent)
    { return MS::kSuccess; }

  virtual MStatus postImport(const UsdPrim& prim)
    { return MS::kSuccess; }

  virtual MStatus preTearDown(UsdPrim& prim)
    { return MS::kSuccess; }

  virtual MStatus tearDown(const SdfPath& path)
    { return MStatus::kNotImplemented; }

  virtual bool supportsUpdate() const
    { return false; }

  virtual MStatus update(const UsdPrim& prim)
    { return MStatus::kNotImplemented; }

};

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class TranslatorBase
  : public TranslatorAbstract
{
public:
  typedef TranslatorBase This;
  typedef TfRefPtr<This> RefPtr;

  virtual ~TranslatorBase()
    {}

  virtual TfType getTranslatedType() const override
    { return m_translatedType; }

  virtual TranslatorContextPtr context() const
    { return m_context; }

  static RefPtr manufacture(const std::string& primType, TranslatorContextPtr context) = delete;

  UsdStageRefPtr getUsdStage() const
    { return context()->getUsdStage(); }

protected:

  virtual void setTranslatedType(const TfType& translatedType)
    { m_translatedType = translatedType; }

  virtual void setContext(const TranslatorContextPtr context)
    { m_context = context; }

private:

  TfType m_translatedType;
  TranslatorContextPtr m_context;
};

typedef TfRefPtr<TranslatorBase> TranslatorRefPtr;

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class TranslatorManufacture
{
public:
  typedef TfRefPtr<TranslatorBase> RefPtr; 

  RefPtr get(const TfToken type_name, TranslatorContextPtr context);

private:
  std::unordered_map<std::string, TranslatorRefPtr> m_translatorsMap;
};

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class TranslatorFactoryBase
  : public TfType::FactoryBase
{
public:
  virtual TfRefPtr<TranslatorBase> create(TranslatorContextPtr ctx) const = 0;
};

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
template <typename T>
class TranslatorFactory : public TranslatorFactoryBase
{
public:
  virtual TfRefPtr<TranslatorBase> create(TranslatorContextPtr ctx) const
    { return T::create(ctx); }
};

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
#define AL_USDMAYA_DECLARE_TRANSLATOR(PlugClass)                                \
typedef PlugClass This;                                                         \
typedef TfRefPtr<This> RefPtr;                                                  \
typedef TfWeakPtr<This> Ptr;                                                    \
static RefPtr create(TranslatorContextPtr context);

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
#define AL_USDMAYA_DEFINE_TRANSLATOR(PlugClass, TranslatedType)                 \
TfRefPtr<PlugClass>                                                             \
PlugClass::create(TranslatorContextPtr context) {                               \
  TfType const &type = TfType::Find<TranslatedType>();                          \
  if(not type.IsUnknown()) {                                                    \
    TfRefPtr<PlugClass> plugin = TfCreateRefPtr(new This());                    \
    plugin->setTranslatedType(type);                                            \
    plugin->setContext(context);                                                \
    plugin->initialize();                                                       \
    return plugin;                                                              \
  }                                                                             \
  else {                                                                        \
    TF_CODING_ERROR(                                                            \
      "Failed to get %s usd type, maybe the needed plugin is not loaded",       \
      typeid(TranslatedType).name());                                           \
    return TfNullPtr;                                                           \
  }                                                                             \
}                                                                               \
                                                                                \
TF_REGISTRY_FUNCTION(TfType)                                                    \
{                                                                               \
    TfType::Define<PlugClass, TfType::Bases<TranslatorBase>>()                  \
        .SetFactory<TranslatorFactory<PlugClass>>();                            \
}

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