TranslatorBase.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/maya/utils/Api.h"

#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 <functional>
#include "AL/usdmaya/fileio/translators/TranslatorContext.h"
#include "AL/usdmaya/fileio/ExportParams.h"

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

enum class ExportFlag
{
  kNotSupported,
  kFallbackSupport,
  kSupported
};


//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
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, MObject& createdObj)
    { return MS::kSuccess; }

  virtual UsdPrim exportObject(UsdStageRefPtr stage, MDagPath dagPath, const SdfPath& usdPath, const ExporterParams& params)
    { return UsdPrim(); }

  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 bool importableByDefault() const
    { return true; }

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

  virtual ExportFlag canExport(const MObject& obj)
    { return ExportFlag::kNotSupported; }

};

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

  virtual ~TranslatorBase()
    {}

  TfType getTranslatedType() const override
    { return m_translatedType; }

  TranslatorContextPtr context() const
    { return m_context; }

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

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

  virtual void exportCustomAnim(const MDagPath& path, UsdPrim& prim, const UsdTimeCode& timeCode)
    {
      (void)path;
      (void)prim;
      (void)timeCode;
    }

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;
typedef std::vector<TranslatorRefPtr> TranslatorRefPtrVector;

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

  AL_USDMAYA_PUBLIC
  TranslatorManufacture(TranslatorContextPtr context);

  AL_USDMAYA_PUBLIC
  RefPtr get(const TfToken type_name);

  AL_USDMAYA_PUBLIC
  RefPtr get(const MObject& mayaObject);

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

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

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

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
#define AL_USDMAYA_DECLARE_TRANSLATOR(PlugClass)                                \
typedef PlugClass This;                                                         \
typedef TfRefPtr<This> RefPtr;                                                  \
typedef TfWeakPtr<This> Ptr;                                                    \
AL_MAYA_MACROS_PUBLIC                                                           \
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(!type.IsUnknown()) {                                                       \
    TfRefPtr<PlugClass> plugin = TfCreateRefPtr(new This());                    \
    plugin->setTranslatedType(type);                                            \
    plugin->setContext(context);                                                \
    if(!plugin->initialize()) return TfRefPtr<PlugClass>();                     \
    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
//----------------------------------------------------------------------------------------------------------------------