DgNodeTranslator.h

#pragma once
#include "AL/usdmaya/Common.h"
#include "AL/usdmaya/AttributeType.h"
#include "AL/maya/DgNodeHelper.h"

#include "maya/MPlug.h"
#include "maya/MAngle.h"
#include "maya/MDistance.h"
#include "maya/MTime.h"
#include "maya/MFnAnimCurve.h"

#include "maya/MGlobal.h"
#include "maya/MStatus.h"

#include "pxr/base/gf/half.h"
#include "pxr/usd/usd/attribute.h"
#include "pxr/usd/usdGeom/xformOp.h"

#include <string>
#include <vector>

namespace AL {
namespace usdmaya {
namespace fileio {
namespace translators {
//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class DgNodeTranslator
  : public maya::DgNodeHelper
{
public:

  static MStatus registerType();

  virtual MObject createNode(const UsdPrim& from, MObject parent, const char* nodeType, const ImporterParams& params);

  MStatus copyAttributes(const UsdPrim& from, MObject to, const ImporterParams& params);

  static MStatus copyAttributes(const MObject& from, UsdPrim& to, const ExporterParams& params);

  virtual bool attributeHandled(const UsdAttribute& usdAttr);

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

  template<typename T>
  static MStatus setVec3Anim(MObject node, MObject attr, const UsdGeomXformOp op, double conversionFactor = 1.0);

  MStatus setAngleAnim(MObject node, MObject attr, const UsdGeomXformOp op);

  MStatus setFloatAttrAnim(MObject node, MObject attr, UsdAttribute usdAttr, double conversionFactor = 1.0);

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

  static MStatus getUsdBoolArray(const MObject& node, const MObject& attr, VtArray<bool>& values);

  static MStatus getUsdInt8Array(const MObject& node, const MObject& attr, VtArray<int8_t>& values);

  static MStatus getUsdInt16Array(const MObject& node, const MObject& attr, VtArray<int16_t>& values);

  static MStatus getUsdInt32Array(const MObject& node, const MObject& attr, VtArray<int32_t>& values);

  static MStatus getUsdInt64Array(const MObject& node, const MObject& attr, VtArray<int64_t>& values);

  static MStatus getUsdHalfArray(const MObject& node, const MObject& attr, VtArray<half>& values);

  static MStatus getUsdFloatArray(const MObject& node, const MObject& attr, VtArray<float>& values);

  static MStatus getUsdDoubleArray(const MObject& node, const MObject& attr, VtArray<double>& values);

  static MStatus setUsdBoolArray(const MObject& node, const MObject& attr, const VtArray<bool>& values);

  static MStatus setUsdInt8Array(const MObject& node, const MObject& attr, const VtArray<int8_t>& values);

  static MStatus setUsdInt16Array(const MObject& node, const MObject& attr, const VtArray<int16_t>& values);

  static MStatus setUsdInt32Array(const MObject& node, const MObject& attr, const VtArray<int32_t>& values);

  static MStatus setUsdInt64Array(const MObject& node, const MObject& attr, const VtArray<int64_t>& values);

  static MStatus setUsdHalfArray(const MObject& node, const MObject& attr, const VtArray<half>& values);

  static MStatus setUsdFloatArray(const MObject& node, const MObject& attr, const VtArray<float>& values);

  static MStatus setUsdDoubleArray(const MObject& node, const MObject& attr, const VtArray<double>& values);

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

  static MStatus copyBool(MObject node, MObject attr, const UsdAttribute& value);

  static MStatus copyFloat(MObject node, MObject attr, const UsdAttribute& value);

  static MStatus copyDouble(MObject node, MObject attr, const UsdAttribute& value);

  static MStatus copyInt(MObject node, MObject attr, const UsdAttribute& value);

  static MStatus copyVec3(MObject node, MObject attr, const UsdAttribute& value);

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

  static MStatus setSingleMayaValue(MObject node, MObject attr, const UsdAttribute& usdAttr, const UsdDataType type);

  static MStatus setArrayMayaValue(MObject node, MObject attr, const UsdAttribute& usdAttr, const UsdDataType type);

  static MStatus setMayaValue(MObject node, MObject attr, const UsdAttribute& usdAttr);

  static MStatus addDynamicAttribute(MObject node, const UsdAttribute& usdAttr);

  static MStatus copyDynamicAttributes(MObject node, UsdPrim& prim);

  static void copyAttributeValue(const MPlug& attr, UsdAttribute& usdAttr, const UsdTimeCode& timeCode);

  static void copySimpleValue(const MPlug& plug, UsdAttribute& usdAttr, const UsdTimeCode& timeCode);

  static void copyAttributeValue(const MPlug& attr, UsdAttribute& usdAttr, float scale, const UsdTimeCode& timeCode);

  static void copySimpleValue(const MPlug& plug, UsdAttribute& usdAttr, float scale, const UsdTimeCode& timeCode);
};

//----------------------------------------------------------------------------------------------------------------------
template<typename T>
MStatus DgNodeTranslator::setVec3Anim(MObject node, MObject attr, const UsdGeomXformOp op, double conversionFactor)
{
  MPlug plug(node, attr);
  MStatus status;
  const char* const xformErrorCreate = "DgNodeTranslator:setVec3Anim error creating animation curve";

  MFnAnimCurve acFnSetX;
  acFnSetX.create(plug.child(0), NULL, &status);
  AL_MAYA_CHECK_ERROR(status, xformErrorCreate);

  MFnAnimCurve acFnSetY;
  acFnSetY.create(plug.child(1), NULL, &status);
  AL_MAYA_CHECK_ERROR(status, xformErrorCreate);

  MFnAnimCurve acFnSetZ;
  acFnSetZ.create(plug.child(2), NULL, &status);
  AL_MAYA_CHECK_ERROR(status, xformErrorCreate);

  std::vector<double> times;
  op.GetTimeSamples(&times);

  const char* const xformErrorKey = "DgNodeTranslator:setVec3Anim error setting key on animation curve";

  T value(0);
  for(auto const& timeValue: times)
  {
    const bool retValue = op.GetAs<T>(&value, timeValue);
    if (!retValue) continue;

    MTime tm(timeValue, MTime::kFilm);

    switch (acFnSetX.animCurveType())
    {
      case MFnAnimCurve::kAnimCurveTL: // time->distance: translation
      case MFnAnimCurve::kAnimCurveTA: // time->angle: rotation
      case MFnAnimCurve::kAnimCurveTU: // time->double: scale
      {
        acFnSetX.addKey(tm, value[0] * conversionFactor, MFnAnimCurve::kTangentGlobal, MFnAnimCurve::kTangentGlobal, NULL, &status);
        AL_MAYA_CHECK_ERROR(status, xformErrorKey);
        acFnSetY.addKey(tm, value[1] * conversionFactor, MFnAnimCurve::kTangentGlobal, MFnAnimCurve::kTangentGlobal, NULL, &status);
        AL_MAYA_CHECK_ERROR(status, xformErrorKey);
        acFnSetZ.addKey(tm, value[2] * conversionFactor, MFnAnimCurve::kTangentGlobal, MFnAnimCurve::kTangentGlobal, NULL, &status);
        AL_MAYA_CHECK_ERROR(status, xformErrorKey);
        break;
      }
      default:
      {
        break;
      }
    }
  }

  return MS::kSuccess;
}

//----------------------------------------------------------------------------------------------------------------------
inline MStatus DgNodeTranslator::getUsdInt8Array(const MObject& node, const MObject& attr, VtArray<int8_t>& values)
{
  MPlug plug(node, attr);
  if(!plug || !plug.isArray())
    return MS::kFailure;
  const uint32_t num = plug.numElements();
  values.resize(num);
  return getInt8Array(node, attr, values.data(), num);
}

//----------------------------------------------------------------------------------------------------------------------
inline MStatus DgNodeTranslator::getUsdInt16Array(const MObject& node, const MObject& attr, VtArray<int16_t>& values)
{
  MPlug plug(node, attr);
  if(!plug || !plug.isArray())
    return MS::kFailure;
  const uint32_t num = plug.numElements();
  values.resize(num);
  return getInt16Array(node, attr, values.data(), num);
}

//----------------------------------------------------------------------------------------------------------------------
inline MStatus DgNodeTranslator::getUsdInt32Array(const MObject& node, const MObject& attr, VtArray<int32_t>& values)
{
  MPlug plug(node, attr);
  if(!plug || !plug.isArray())
    return MS::kFailure;
  const uint32_t num = plug.numElements();
  values.resize(num);
  return getInt32Array(node, attr, values.data(), num);
}

//----------------------------------------------------------------------------------------------------------------------
inline MStatus DgNodeTranslator::getUsdInt64Array(const MObject& node, const MObject& attr, VtArray<int64_t>& values)
{
  MPlug plug(node, attr);
  if(!plug || !plug.isArray())
    return MS::kFailure;
  const uint32_t num = plug.numElements();
  values.resize(num);
  return getInt64Array(node, attr, values.data(), num);
}

//----------------------------------------------------------------------------------------------------------------------
inline MStatus DgNodeTranslator::getUsdHalfArray(const MObject& node, const MObject& attr, VtArray<half>& values)
{
  MPlug plug(node, attr);
  if(!plug || !plug.isArray())
    return MS::kFailure;
  const uint32_t num = plug.numElements();
  values.resize(num);
  return getHalfArray(node, attr, values.data(), num);
}

//----------------------------------------------------------------------------------------------------------------------
inline MStatus DgNodeTranslator::getUsdFloatArray(const MObject& node, const MObject& attr, VtArray<float>& values)
{
  MPlug plug(node, attr);
  if(!plug || !plug.isArray())
    return MS::kFailure;
  const uint32_t num = plug.numElements();
  values.resize(num);
  return getFloatArray(node, attr, values.data(), num);
}

//----------------------------------------------------------------------------------------------------------------------
inline MStatus DgNodeTranslator::getUsdDoubleArray(const MObject& node, const MObject& attr, VtArray<double>& values)
{
  MPlug plug(node, attr);
  if(!plug || !plug.isArray())
    return MS::kFailure;
  const uint32_t num = plug.numElements();
  values.resize(num);
  return getDoubleArray(node, attr, values.data(), num);
}

//----------------------------------------------------------------------------------------------------------------------
inline MStatus DgNodeTranslator::setUsdInt8Array(const MObject& node, const MObject& attr, const VtArray<int8_t>& values)
{
  return setInt8Array(node, attr, values.cdata(), values.size());
}

//----------------------------------------------------------------------------------------------------------------------
inline MStatus DgNodeTranslator::setUsdInt16Array(const MObject& node, const MObject& attr, const VtArray<int16_t>& values)
{
  return setInt16Array(node, attr, values.cdata(), values.size());
}

//----------------------------------------------------------------------------------------------------------------------
inline MStatus DgNodeTranslator::setUsdInt32Array(const MObject& node, const MObject& attr, const VtArray<int32_t>& values)
{
  return setInt32Array(node, attr, values.cdata(), values.size());
}

//----------------------------------------------------------------------------------------------------------------------
inline MStatus DgNodeTranslator::setUsdInt64Array(const MObject& node, const MObject& attr, const VtArray<int64_t>& values)
{
  return setInt64Array(node, attr, values.cdata(), values.size());
}

//----------------------------------------------------------------------------------------------------------------------
inline MStatus DgNodeTranslator::setUsdHalfArray(const MObject& node, const MObject& attr, const VtArray<half>& values)
{
  return setHalfArray(node, attr, values.cdata(), values.size());
}

//----------------------------------------------------------------------------------------------------------------------
inline MStatus DgNodeTranslator::setUsdFloatArray(const MObject& node, const MObject& attr, const VtArray<float>& values)
{
  return setFloatArray(node, attr, values.cdata(), values.size());
}

//----------------------------------------------------------------------------------------------------------------------
inline MStatus DgNodeTranslator::setUsdDoubleArray(const MObject& node, const MObject& attr, const VtArray<double>& values)
{
  return setDoubleArray(node, attr, values.cdata(), values.size());
}

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