Ufe manipulation

lib/mayaUsd/ufe/CMakeLists.txt

@@ -33,13 +33,19 @@ if(CMAKE_UFE_V2_FEATURES_AVAILABLE)
     target_sources(${PROJECT_NAME}
         PRIVATE
             ProxyShapeContextOpsHandler.cpp
+            RotationUtils.cpp
             UsdAttribute.cpp
             UsdAttributes.cpp
             UsdAttributesHandler.cpp
             UsdContextOps.cpp
             UsdContextOpsHandler.cpp
             UsdObject3d.cpp
             UsdObject3dHandler.cpp
+            UsdTransform3dBase.cpp
+            UsdTransform3dCommonAPI.cpp
+            UsdTransform3dFallbackMayaXformStack.cpp
+            UsdTransform3dMatrixOp.cpp
+            UsdTransform3dMayaXformStack.cpp
             UsdUndoAddNewPrimCommand.cpp
             UsdUndoCreateGroupCommand.cpp
             UsdUndoInsertChildCommand.cpp
@@ -83,13 +89,19 @@ set(HEADERS
 if(CMAKE_UFE_V2_FEATURES_AVAILABLE)
     list(APPEND HEADERS
         ProxyShapeContextOpsHandler.h
+        RotationUtils.h
         UsdAttribute.h
         UsdAttributes.h
         UsdAttributesHandler.h
         UsdContextOps.h
         UsdContextOpsHandler.h
         UsdObject3d.h
         UsdObject3dHandler.h
+        UsdTransform3dBase.h
+        UsdTransform3dCommonAPI.h
+        UsdTransform3dFallbackMayaXformStack.h
+        UsdTransform3dMatrixOp.h
+        UsdTransform3dMayaXformStack.h
         UsdUIInfoHandler.h
         UsdUndoAddNewPrimCommand.h
         UsdUndoCreateGroupCommand.h

lib/mayaUsd/ufe/RotationUtils.cpp

@@ -0,0 +1,60 @@
+//
+// Copyright 2020 Autodesk
+//
+// 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.
+//
+
+#include "RotationUtils.h"
+
+namespace {
+
+inline double TO_DEG(double a) { return a * 180.0 / 3.141592654; }
+inline double TO_RAD(double a) { return a * 3.141592654 / 180.0; }
+
+}
+
+namespace MAYAUSD_NS_DEF {
+namespace ufe {
+
+template <MEulerRotation::RotationOrder SRC_ROT_ORDER> Ufe::Vector3d fromRot(const VtValue& value)
+{
+    auto v = value.Get<GfVec3f>();
+
+    MEulerRotation eulerRot(TO_RAD(v[0]), TO_RAD(v[1]), TO_RAD(v[2]), SRC_ROT_ORDER);
+    eulerRot.reorderIt(MEulerRotation::kXYZ);
+    return Ufe::Vector3d(TO_DEG(eulerRot.x), TO_DEG(eulerRot.y), TO_DEG(eulerRot.z));
+}
+
+template <MEulerRotation::RotationOrder DST_ROT_ORDER> VtValue toRot(double x, double y, double z)
+{
+    MEulerRotation eulerRot(TO_RAD(x), TO_RAD(y), TO_RAD(z), MEulerRotation::kXYZ);
+    eulerRot.reorderIt(DST_ROT_ORDER);
+    VtValue v;
+    v = GfVec3f(TO_DEG(eulerRot.x), TO_DEG(eulerRot.y), TO_DEG(eulerRot.z));
+    return v;
+}
+
+template Ufe::Vector3d fromRot<MEulerRotation::kXZY>(const VtValue&);
+template Ufe::Vector3d fromRot<MEulerRotation::kYXZ>(const VtValue&);
+template Ufe::Vector3d fromRot<MEulerRotation::kYZX>(const VtValue&);
+template Ufe::Vector3d fromRot<MEulerRotation::kZXY>(const VtValue&);
+template Ufe::Vector3d fromRot<MEulerRotation::kZYX>(const VtValue&);
+
+template VtValue toRot<MEulerRotation::kXZY>(double, double, double);
+template VtValue toRot<MEulerRotation::kYXZ>(double, double, double);
+template VtValue toRot<MEulerRotation::kYZX>(double, double, double);
+template VtValue toRot<MEulerRotation::kZXY>(double, double, double);
+template VtValue toRot<MEulerRotation::kZYX>(double, double, double);
+
+} // namespace ufe
+} // namespace MAYAUSD_NS_DEF

lib/mayaUsd/ufe/RotationUtils.h

@@ -0,0 +1,100 @@
+//
+// Copyright 2020 Autodesk
+//
+// 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 <mayaUsd/mayaUsd.h>
+
+#include <pxr/base/gf/vec3d.h>
+#include <pxr/base/vt/value.h>
+
+#include <maya/MEulerRotation.h>
+#include <ufe/types.h>
+
+PXR_NAMESPACE_USING_DIRECTIVE
+
+namespace MAYAUSD_NS_DEF {
+namespace ufe {
+
+//----------------------------------------------------------------------
+// Conversion functions from RotXYZ to all supported rotation attributes.
+//----------------------------------------------------------------------
+
+inline VtValue toXYZ(double x, double y, double z)
+{
+    // No rotation order conversion
+    VtValue v;
+    v = GfVec3f(x, y, z);
+    return v;
+}
+
+// Reorder argument RotXYZ rotation.
+template <MEulerRotation::RotationOrder DST_ROT_ORDER> VtValue toRot(double x, double y, double z);
+
+constexpr auto toXZY = toRot<MEulerRotation::kXZY>;
+constexpr auto toYXZ = toRot<MEulerRotation::kYXZ>;
+constexpr auto toYZX = toRot<MEulerRotation::kYZX>;
+constexpr auto toZXY = toRot<MEulerRotation::kZXY>;
+constexpr auto toZYX = toRot<MEulerRotation::kZYX>;
+
+// Scalar float is the proper type for single-axis rotations.
+inline VtValue toX(double x, double, double)
+{
+    VtValue v;
+    v = float(x);
+    return v;
+}
+
+inline VtValue toY(double, double y, double)
+{
+    VtValue v;
+    v = float(y);
+    return v;
+}
+
+inline VtValue toZ(double, double, double z)
+{
+    VtValue v;
+    v = float(z);
+    return v;
+}
+
+//----------------------------------------------------------------------
+// Conversion functions from all supported rotation attributes to RotXYZ.
+//----------------------------------------------------------------------
+
+inline Ufe::Vector3d fromXYZ(const VtValue& value)
+{
+    // No rotation order conversion
+    auto v = value.Get<GfVec3f>();
+    return Ufe::Vector3d(v[0], v[1], v[2]);
+}
+
+template <MEulerRotation::RotationOrder SRC_ROT_ORDER> Ufe::Vector3d fromRot(const VtValue& value);
+
+constexpr auto fromXZY = fromRot<MEulerRotation::kXZY>;
+constexpr auto fromYXZ = fromRot<MEulerRotation::kYXZ>;
+constexpr auto fromYZX = fromRot<MEulerRotation::kYZX>;
+constexpr auto fromZXY = fromRot<MEulerRotation::kZXY>;
+constexpr auto fromZYX = fromRot<MEulerRotation::kZYX>;
+
+inline Ufe::Vector3d fromX(const VtValue& value) { return Ufe::Vector3d(value.Get<float>(), 0, 0); }
+
+inline Ufe::Vector3d fromY(const VtValue& value) { return Ufe::Vector3d(0, value.Get<float>(), 0); }
+
+inline Ufe::Vector3d fromZ(const VtValue& value) { return Ufe::Vector3d(0, 0, value.Get<float>()); }
+
+} // namespace ufe
+} // namespace MAYAUSD_NS_DEF

lib/mayaUsd/ufe/StagesSubject.cpp

@@ -291,12 +291,12 @@ void StagesSubject::stageChanged(
         }
 #endif
 
-        // We need to determine if the change is a Transform3d change.
-        // We must at least pick up xformOp:translate, xformOp:rotateXYZ,
-        // and xformOp:scale.
-        const TfToken nameToken = changedPath.GetNameToken();
-        if (nameToken == UsdGeomTokens->xformOpOrder || UsdGeomXformOp::IsXformOp(nameToken)) {
-            Ufe::Transform3d::notify(ufePath);
+        if (!InTransform3dChange::inTransform3dChange()) {
+            // Is the change a Transform3d change?
+            const TfToken nameToken = changedPath.GetNameToken();
+            if (nameToken == UsdGeomTokens->xformOpOrder || UsdGeomXformOp::IsXformOp(nameToken)) {
+                Ufe::Transform3d::notify(ufePath);
+            }
         }
     }
 }

lib/mayaUsd/ufe/UsdRotateUndoableCommand.h

@@ -57,7 +57,7 @@ class MAYAUSD_CORE_PUBLIC UsdRotateUndoableCommand
          create(const UsdSceneItem::Ptr& item, double x, double y, double z);
 #endif
 
-    // Ufe::RotateUndoableCommand overrides.  rotate() sets the command's
+    // Ufe::RotateUndoableCommand overrides.  set() sets the command's
     // rotation value and executes the command.
     void undo() override;
     void redo() override;

lib/mayaUsd/ufe/UsdTransform3d.cpp

@@ -186,11 +186,7 @@ Ufe::ScaleUndoableCommand::Ptr UsdTransform3d::scaleCmd()
 #endif
 
 #ifdef UFE_V2_FEATURES_AVAILABLE
-#if UFE_PREVIEW_VERSION_NUM >= 2025
 Ufe::SetMatrix4dUndoableCommand::Ptr UsdTransform3d::setMatrixCmd(const Ufe::Matrix4d& m)
-#else
-Ufe::SetMatrixUndoableCommand::Ptr UsdTransform3d::setMatrixCmd(const Ufe::Matrix4d& m)
-#endif
 {
     // TODO: HS Aug25,2020 dummy code to pass the compiler errors
     return nullptr;
@@ -209,36 +205,35 @@ void UsdTransform3d::scale(double x, double y, double z)
     scaleOp(prim(), fItem->path(), x, y, z);
 }
 
-#if UFE_PREVIEW_VERSION_NUM >= 2025
-//#ifdef UFE_V2_FEATURES_AVAILABLE
-Ufe::TranslateUndoableCommand::Ptr UsdTransform3d::rotatePivotCmd(double, double, double)
+Ufe::TranslateUndoableCommand::Ptr
+#ifdef UFE_V2_FEATURES_AVAILABLE
+UsdTransform3d::rotatePivotCmd(double, double, double)
+#else
+UsdTransform3d::rotatePivotTranslateCmd()
+#endif
 {
     // As of 12-Oct-2020, setting rotate pivot on command creation
     // unsupported.  Use translate() method on returned command.
-    return UsdRotatePivotTranslateUndoableCommand::create(fItem->path());
-}
-
-void UsdTransform3d::rotatePivot(double x, double y, double z)
-{
-    rotatePivotTranslateOp(prim(), path(), x, y, z);
-}
-#else
-Ufe::TranslateUndoableCommand::Ptr UsdTransform3d::rotatePivotTranslateCmd()
-{
+    return UsdRotatePivotTranslateUndoableCommand::create(
 #ifdef UFE_V2_FEATURES_AVAILABLE
-    return UsdRotatePivotTranslateUndoableCommand::create(fItem->path());
+        fItem->path()
 #else
-    auto translateCmd
-        = UsdRotatePivotTranslateUndoableCommand::create(prim(), fItem->path(), fItem);
-    return translateCmd;
+        prim(), fItem->path(), fItem
 #endif
+    );
 }
 
-void UsdTransform3d::rotatePivotTranslate(double x, double y, double z)
+void
+#ifdef UFE_V2_FEATURES_AVAILABLE
+UsdTransform3d::rotatePivot(
+#else
+UsdTransform3d::rotatePivotTranslate(
+#endif
+    double x, double y, double z
+)
 {
     rotatePivotTranslateOp(prim(), path(), x, y, z);
 }
-#endif
 
 Ufe::Vector3d UsdTransform3d::rotatePivot() const
 {
@@ -256,27 +251,53 @@ Ufe::Vector3d UsdTransform3d::rotatePivot() const
     return Ufe::Vector3d(x, y, z);
 }
 
-#if UFE_PREVIEW_VERSION_NUM >= 2025
-//#ifdef UFE_V2_FEATURES_AVAILABLE
-Ufe::TranslateUndoableCommand::Ptr UsdTransform3d::scalePivotCmd(double, double, double)
+Ufe::TranslateUndoableCommand::Ptr
+#ifdef UFE_V2_FEATURES_AVAILABLE
+UsdTransform3d::scalePivotCmd(double, double, double)
+#else
+UsdTransform3d::scalePivotTranslateCmd()
+#endif
 {
     return nullptr;
 }
 
-void UsdTransform3d::scalePivot(double x, double y, double z) { return rotatePivot(x, y, z); }
+void
+#ifdef UFE_V2_FEATURES_AVAILABLE
+UsdTransform3d::scalePivot(
 #else
-Ufe::TranslateUndoableCommand::Ptr UsdTransform3d::scalePivotTranslateCmd()
+UsdTransform3d::scalePivotTranslate(
+#endif
+    double, double, double
+)
+{}
+
+Ufe::Vector3d UsdTransform3d::scalePivot() const { return rotatePivot(); }
+
+#ifdef UFE_V2_FEATURES_AVAILABLE
+Ufe::TranslateUndoableCommand::Ptr UsdTransform3d::translateRotatePivotCmd(double, double, double)
 {
-    throw std::runtime_error("UsdTransform3d::scalePivotTranslateCmd() not implemented");
+    // USD common transform API does not support rotate pivot correction.
+    return nullptr;
 }
 
-void UsdTransform3d::scalePivotTranslate(double x, double y, double z)
+Ufe::Vector3d UsdTransform3d::rotatePivotTranslation() const
 {
-    return rotatePivotTranslate(x, y, z);
+    // USD common transform API does not support rotate pivot correction.
+    return Ufe::Vector3d(0, 0, 0);
 }
-#endif
 
-Ufe::Vector3d UsdTransform3d::scalePivot() const { return rotatePivot(); }
+Ufe::TranslateUndoableCommand::Ptr UsdTransform3d::translateScalePivotCmd(double, double, double)
+{
+    // USD common transform API does not support scale pivot correction.
+    return nullptr;
+}
+
+Ufe::Vector3d UsdTransform3d::scalePivotTranslation() const
+{
+    // USD common transform API does not support scale pivot correction.
+    return Ufe::Vector3d(0, 0, 0);
+}
+#endif
 
 Ufe::Matrix4d UsdTransform3d::segmentInclusiveMatrix() const
 {