TransformationMatrix.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/TransformOperation.h"

#include "maya/MPxTransformationMatrix.h"
#include "maya/MPxTransform.h"

#include "pxr/pxr.h"
#include "pxr/usd/usdGeom/xform.h"
#include "pxr/usd/usdGeom/xformCommonAPI.h"

PXR_NAMESPACE_USING_DIRECTIVE

namespace AL {
namespace usdmaya {
namespace nodes {

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class TransformationMatrix
  : public MPxTransformationMatrix
{
  UsdPrim m_prim;
  UsdGeomXform m_xform;
  UsdTimeCode m_time;
  std::vector<UsdGeomXformOp> m_xformops;
  std::vector<TransformOperation> m_orderedOps;
  MObject m_transformNode;

  // tweak values. These are applied on top of the USD transform values to produce the final result.
  MVector m_scaleTweak;
  MEulerRotation m_rotationTweak;
  MVector m_translationTweak;
  MVector m_shearTweak;
  MPoint m_scalePivotTweak;
  MVector m_scalePivotTranslationTweak;
  MPoint m_rotatePivotTweak;
  MVector m_rotatePivotTranslationTweak;
  MQuaternion m_rotateOrientationTweak;

  // values read in from USD
  MVector m_scaleFromUsd;
  MEulerRotation m_rotationFromUsd;
  MVector m_translationFromUsd;
  MVector m_shearFromUsd;
  MPoint m_scalePivotFromUsd;
  MVector m_scalePivotTranslationFromUsd;
  MPoint m_rotatePivotFromUsd;
  MVector m_rotatePivotTranslationFromUsd;
  MQuaternion m_rotateOrientationFromUsd;

  // post-transform translation value applied in object space after all other transformations
  MVector m_localTranslateOffset;

  // methods that will insert a transform op into the ordered queue of operations, if for some.
  void insertTranslateOp();
  void insertScaleOp();
  void insertShearOp();
  void insertScalePivotOp();
  void insertScalePivotTranslationOp();
  void insertRotateOp();
  void insertRotatePivotOp();
  void insertRotatePivotTranslationOp();
  void insertRotateAxesOp();

  enum Flags
  {
    // describe which components are animated
    kAnimatedScale = 1 << 0,
    kAnimatedRotation = 1 << 1,
    kAnimatedTranslation = 1 << 2,
    kAnimatedMatrix = 1 << 3,
    kAnimatedShear = 1 << 4,

    // are the transform ops coming from a matrix, the PXR schema, or from the maya schema (no flags set)
    kFromMatrix = 1 << 8,
    kFromMayaSchema = 1 << 9,

    // which transform components are present in the prim?
    kPrimHasScale = 1 << 16,
    kPrimHasRotation = 1 << 17,
    kPrimHasTranslation = 1 << 18,
    kPrimHasShear = 1 << 19,
    kPrimHasScalePivot = 1 << 20,
    kPrimHasScalePivotTranslate = 1 << 21,
    kPrimHasRotatePivot = 1 << 22,
    kPrimHasRotatePivotTranslate = 1 << 23,
    kPrimHasRotateAxes = 1 << 24,
    kPrimHasPivot = 1 << 25,
    kPrimHasTransform = 1 << 26,

    kPushToPrimEnabled = 1 << 28,
    kInheritsTransform = 1 << 29,

    kPushPrimToMatrix = 1 << 30,
    kReadAnimatedValues = 1 << 31,

    kAnimationMask = kAnimatedShear | kAnimatedScale | kAnimatedRotation | kAnimatedTranslation | kAnimatedMatrix,

    // Most of these flags are calculated based on reading the usd prim; however, a few are driven
    // "externally" (ie, from attributes on the controlling transform node), and should NOT be reset
    // when we're re-initializing (ie, in setPrim)
    kPreservationMask = kPushToPrimEnabled | kReadAnimatedValues
  };
  uint32_t m_flags = 0;

  bool internal_readVector(MVector& result, const UsdGeomXformOp& op) { return readVector(result, op, getTimeCode()); }
  bool internal_readShear(MVector& result, const UsdGeomXformOp& op) { return readShear(result, op, getTimeCode()); }
  bool internal_readPoint(MPoint& result, const UsdGeomXformOp& op) { return readPoint(result, op, getTimeCode()); }
  bool internal_readRotation(MEulerRotation& result, const UsdGeomXformOp& op) { return readRotation(result, op, getTimeCode()); }
  double internal_readDouble(const UsdGeomXformOp& op) { return readDouble(op, getTimeCode()); }
  bool internal_readMatrix(MMatrix& result, const UsdGeomXformOp& op) { return readMatrix(result, op, getTimeCode()); }

  bool internal_pushVector(const MVector& result, UsdGeomXformOp& op) { return pushVector(result, op, getTimeCode()); }
  bool internal_pushPoint(const MPoint& result, UsdGeomXformOp& op) { return pushPoint(result, op, getTimeCode()); }
  bool internal_pushRotation(const MEulerRotation& result, UsdGeomXformOp& op) { return pushRotation(result, op, getTimeCode()); }
  void internal_pushDouble(const double result, UsdGeomXformOp& op) { pushDouble(result, op, getTimeCode()); }
  bool internal_pushShear(const MVector& result, UsdGeomXformOp& op) { return pushShear(result, op, getTimeCode()); }
  bool internal_pushMatrix(const MMatrix& result, UsdGeomXformOp& op) { return pushMatrix(result, op, getTimeCode()); }

public:

  void setMObject(const MObject object)
    { m_transformNode = object; }

  bool isTranslateLocked()
    {
      MPlug plug(m_transformNode, MPxTransform::translate);
      return plug.isLocked() ||
             plug.child(0).isLocked() ||
             plug.child(1).isLocked() ||
             plug.child(2).isLocked();
    }

  bool isRotateLocked()
    {
      MPlug plug(m_transformNode, MPxTransform::rotate);
      return plug.isLocked() ||
             plug.child(0).isLocked() ||
             plug.child(1).isLocked() ||
             plug.child(2).isLocked();
    }

  bool isScaleLocked()
    {
      MPlug plug(m_transformNode, MPxTransform::scale);
      return plug.isLocked() ||
             plug.child(0).isLocked() ||
             plug.child(1).isLocked() ||
             plug.child(2).isLocked();
    }

  static bool readVector(MVector& result, const UsdGeomXformOp& op, UsdTimeCode timeCode = UsdTimeCode::EarliestTime());

  static bool readShear(MVector& result, const UsdGeomXformOp& op, UsdTimeCode timeCode = UsdTimeCode::EarliestTime());

  static bool readPoint(MPoint& result, const UsdGeomXformOp& op, UsdTimeCode timeCode = UsdTimeCode::EarliestTime());

  static bool readRotation(MEulerRotation& result, const UsdGeomXformOp& op, UsdTimeCode timeCode = UsdTimeCode::EarliestTime());

  static double readDouble(const UsdGeomXformOp& op, UsdTimeCode timeCode = UsdTimeCode::EarliestTime());

  static bool readMatrix(MMatrix& result, const UsdGeomXformOp& op, UsdTimeCode timeCode = UsdTimeCode::EarliestTime());

  static bool pushVector(const MVector& input, UsdGeomXformOp& op, UsdTimeCode timeCode = UsdTimeCode::Default());

  static bool pushPoint(const MPoint& input, UsdGeomXformOp& op, UsdTimeCode timeCode = UsdTimeCode::Default());

  static bool pushRotation(const MEulerRotation& input, UsdGeomXformOp& op, UsdTimeCode timeCode = UsdTimeCode::Default());

  static void pushDouble(const double input, UsdGeomXformOp& op, UsdTimeCode timeCode = UsdTimeCode::Default());

  static bool pushShear(const MVector& input, UsdGeomXformOp& op, UsdTimeCode timeCode = UsdTimeCode::Default());

  static bool pushMatrix(const MMatrix& input, UsdGeomXformOp& op, UsdTimeCode timeCode = UsdTimeCode::Default());

  AL_USDMAYA_PUBLIC
  static const MTypeId kTypeId;

  AL_USDMAYA_PUBLIC
  static MPxTransformationMatrix* creator();

  TransformationMatrix();

  TransformationMatrix(const UsdPrim& prim);

  void setPrim(const UsdPrim& prim, Transform* transformNode);

  void enablePushToPrim(bool enabled);

  void enableReadAnimatedValues(bool enabled);

  inline UsdTimeCode getTimeCode()
    { return readAnimatedValues() ? m_time : UsdTimeCode::Default(); }

  inline void setLocalTranslationOffset(const MVector& localTranslateOffset)
    { m_localTranslateOffset = localTranslateOffset; }

  inline const UsdPrim& prim() const
    { return m_prim; }

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

  inline bool hasAnimation() const
    { return (kAnimationMask & m_flags) != 0; }

  inline bool hasAnimatedScale() const
    { return (kAnimatedScale & m_flags) != 0; }

  inline bool hasAnimatedShear() const
    { return (kAnimatedShear & m_flags) != 0; }

  inline bool hasAnimatedTranslation() const
    { return (kAnimatedTranslation & m_flags) != 0; }

  inline bool hasAnimatedRotation() const
    { return (kAnimatedRotation & m_flags) != 0; }

  inline bool hasAnimatedMatrix() const
    { return (kAnimatedMatrix & m_flags) != 0; }

  inline bool primHasScale() const
    { return (kPrimHasScale & m_flags) != 0; }

  inline bool primHasRotation() const
    { return (kPrimHasRotation & m_flags) != 0; }

  inline bool primHasTranslation() const
    { return (kPrimHasTranslation & m_flags) != 0; }

  inline bool primHasShear() const
    { return (kPrimHasShear & m_flags) != 0; }

  inline bool primHasScalePivot() const
    { return (kPrimHasScalePivot & m_flags) != 0; }

  inline bool primHasScalePivotTranslate() const
    { return (kPrimHasScalePivotTranslate & m_flags) != 0; }

  inline bool primHasRotatePivot() const
    { return (kPrimHasRotatePivot & m_flags) != 0; }

  inline bool primHasRotatePivotTranslate() const
    { return (kPrimHasRotatePivotTranslate & m_flags) != 0; }

  inline bool primHasRotateAxes() const
    { return (kPrimHasRotateAxes & m_flags) != 0; }

  inline bool primHasPivot() const
    { return (kPrimHasPivot & m_flags) != 0; }

  inline bool primHasTransform() const
    { return (kPrimHasTransform & m_flags) != 0; }

  inline bool readAnimatedValues() const
    { return (kReadAnimatedValues & m_flags) != 0; }

  inline bool pushToPrimEnabled() const
    { return (kPushToPrimEnabled & m_flags) != 0; }

  inline bool pushPrimToMatrix() const
    { return (kPushPrimToMatrix & m_flags) != 0; }

  inline bool pushToPrimAvailable() const
    { return pushToPrimEnabled() && m_prim.IsValid(); }

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

  void initialiseToPrim(bool readFromPrim = true, Transform* node = 0);

  void updateToTime(const UsdTimeCode& time);

  void pushToPrim();

private:
  //  Translation methods:
  MStatus translateTo(const MVector &vector, MSpace::Space = MSpace::kTransform) override;

  //  Scale methods:
  MStatus scaleTo(const MVector &, MSpace::Space = MSpace::kTransform) override;

  //  Shear methods:
  MStatus shearTo(const MVector& shear, MSpace::Space = MSpace::kTransform) override;

  //  Scale pivot methods:
  MStatus setScalePivot(const MPoint &, MSpace::Space = MSpace::kTransform, bool balance = true) override;
  MStatus setScalePivotTranslation(const MVector &vector, MSpace::Space = MSpace::kTransform) override;

  //  Rotate pivot methods:
  MStatus setRotatePivot(const MPoint &, MSpace::Space = MSpace::kTransform, bool balance = true) override;
  MStatus setRotatePivotTranslation(const MVector &vector, MSpace::Space = MSpace::kTransform) override;

  //  Rotate order methods:
  MStatus setRotationOrder(MTransformationMatrix::RotationOrder, bool preserve = true) override;

  //  Rotation methods:
  MStatus rotateTo(const MQuaternion &q, MSpace::Space = MSpace::kTransform) override;
  MStatus rotateTo(const MEulerRotation &e, MSpace::Space = MSpace::kTransform) override;
  MStatus setRotateOrientation(const MQuaternion &q, MSpace::Space = MSpace::kTransform, bool balance = true) override;
  MStatus setRotateOrientation(const MEulerRotation &euler, MSpace::Space = MSpace::kTransform, bool balance = true) override;

  //  Compute matrix result
  MMatrix asMatrix() const override;
  MMatrix asMatrix(double percent) const override;
};

//----------------------------------------------------------------------------------------------------------------------
} // nodes
} // usdmaya
} // AL
//----------------------------------------------------------------------------------------------------------------------