AnimationTranslator.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/usdmaya/fileio/translators/DgNodeTranslator.h"
#include "AL/usdmaya/fileio/translators/TranslatorBase.h"

#include "maya/MPlug.h"
#include "maya/MString.h"
#include "maya/MDagPath.h"
#include "maya/MObjectHandle.h"

#include <vector>
#include <array>
#include <map>

#include <utility>

#include "pxr/pxr.h"
#include "pxr/usd/usd/stage.h"

PXR_NAMESPACE_USING_DIRECTIVE

struct compare_MPlug
{
  bool operator () (const MPlug& a, const MPlug& b) const
  {
    return strcmp(a.name().asChar(), b.name().asChar()) < 0;;
  }
};

struct compare_MDagPath
{
  bool operator () (const MDagPath& a, const MDagPath& b) const
  {
    return strcmp(a.fullPathName().asChar(), b.fullPathName().asChar()) < 0;;
  }
};

namespace AL {
namespace usdmaya {
namespace fileio {

struct ScaledPair
{
  UsdAttribute attr; 
  float scale; 
};

typedef std::map<MPlug, UsdAttribute, compare_MPlug> PlugAttrVector;
typedef std::map<MDagPath, UsdAttribute, compare_MDagPath> MeshAttrVector;
typedef std::map<MPlug, ScaledPair, compare_MPlug> PlugAttrScaledVector;

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class AnimationTranslator
{
public:

  static bool isAnimated(const MObject& node, const MObject& attr, const bool assumeExpressionIsAnimated = true)
    { return isAnimated(MPlug(node, attr), assumeExpressionIsAnimated); }

  AL_USDMAYA_PUBLIC
  static bool isAnimated(MPlug attr, bool assumeExpressionIsAnimated = true);

  AL_USDMAYA_PUBLIC
  static bool isAnimatedMesh(const MDagPath& mesh);

  AL_USDMAYA_PUBLIC
  static bool isAnimatedTransform(const MObject& transformNode);

  inline void addPlug(const MPlug& plug, const UsdAttribute& attribute, const bool assumeExpressionIsAnimated)
  {
    if(m_animatedPlugs.find(plug) != m_animatedPlugs.end())
      return;
    if(isAnimated(plug, assumeExpressionIsAnimated))
      m_animatedPlugs.emplace(plug, attribute);
  }

  inline void addPlug(const MPlug& plug, const UsdAttribute& attribute, const float scale, const bool assumeExpressionIsAnimated)
  {
    if(m_scaledAnimatedPlugs.find(plug) != m_scaledAnimatedPlugs.end())
      return;
    if(isAnimated(plug, assumeExpressionIsAnimated))
      m_scaledAnimatedPlugs.emplace(plug, ScaledPair{attribute, scale});
  }

  inline void addTransformPlug(const MPlug& plug, const UsdAttribute& attribute, const bool assumeExpressionIsAnimated)
  {
    if(m_animatedTransformPlugs.find(plug) != m_animatedTransformPlugs.end())
      return;
    if (isAnimated(plug, assumeExpressionIsAnimated))
      m_animatedTransformPlugs.emplace(plug, attribute);
  }

  inline void forceAddTransformPlug(const MPlug& plug, const UsdAttribute& attribute)
  {
    if(m_animatedTransformPlugs.find(plug) == m_animatedTransformPlugs.end())
      m_animatedTransformPlugs.emplace(plug, attribute);
  }

  inline void forceAddPlug(const MPlug& plug, const UsdAttribute& attribute, const float scale)
  {
    if(m_scaledAnimatedPlugs.find(plug) == m_scaledAnimatedPlugs.end())
      m_scaledAnimatedPlugs.emplace(plug, ScaledPair{ attribute, scale });
  }

  inline void forceAddPlug(const MPlug& plug, const UsdAttribute& attribute)
  {
    if(m_animatedPlugs.find(plug) == m_animatedPlugs.end())
      m_animatedPlugs.emplace(plug, attribute);
  }

  inline void addMesh(const MDagPath& path, const UsdAttribute& attribute)
  {
    if(m_animatedMeshes.find(path) == m_animatedMeshes.end())
      m_animatedMeshes.emplace(path, attribute);
  }

  AL_USDMAYA_PUBLIC
  void exportAnimation(const ExporterParams& params);

  inline void addCustomAnimNode(translators::TranslatorBase* translator, MDagPath dagPath, UsdPrim usdPrim)
    { m_animatedNodes.push_back({translator, dagPath, usdPrim}); }

private:
  static bool considerToBeAnimation(const MFn::Type nodeType);
  static bool inheritTransform(const MDagPath &path);
  static bool areTransformAttributesConnected(const MDagPath &path);
private:
  struct NodeExportInfo
  {
    translators::TranslatorBase* m_translator;
    MDagPath m_path;
    UsdPrim m_prim;
  };
  std::vector<NodeExportInfo> m_animatedNodes;
  PlugAttrVector m_animatedPlugs;
  PlugAttrScaledVector m_scaledAnimatedPlugs;
  PlugAttrVector m_animatedTransformPlugs;
  MeshAttrVector m_animatedMeshes;
};


//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class AnimationCheckTransformAttributes
{
private:
  constexpr static int transformAttributesCount {13};
public:
  AL_USDMAYA_PUBLIC
  AnimationCheckTransformAttributes();
  inline std::array<MObject, transformAttributesCount>::const_iterator begin() const {return m_commonTransformAttributes.cbegin();}
  inline std::array<MObject, transformAttributesCount>::const_iterator end() const {return m_commonTransformAttributes.cend();}
  inline MObject inheritTransformAttribute()const {return m_inheritTransformAttribute;}

private:
  MStatus initialise();
  std::array<MObject, transformAttributesCount> m_commonTransformAttributes;
  MObject m_inheritTransformAttribute;
};

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