@react-native-ohos/react-native-reanimated 4.0.0-rc.1 → 4.0.2-beta.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/transforms/operations/matrix.cpp

@@ -1,208 +1,208 @@
-#include <reanimated/CSS/interpolation/transforms/TransformOperationInterpolator.h>
-#include <reanimated/CSS/interpolation/transforms/operations/matrix.h>
-
-#include <deque>
-#include <memory>
-#include <utility>
-
-namespace reanimated::css {
-
-TransformMatrix3D matrixFromOperations3D(TransformOperations &operations) {
-  TransformMatrix3D result;
-  for (int i = static_cast<int>(operations.size()) - 1; i >= 0; i--) {
-    result *= static_cast<const TransformMatrix3D &>(*operations[i]->toMatrix(true));
-  }
-  return result;
-}
-
-TransformMatrix2D matrixFromOperations2D(TransformOperations &operations) {
-  TransformMatrix2D result;
-  for (int i = static_cast<int>(operations.size()) - 1; i >= 0; i--) {
-    result *= static_cast<const TransformMatrix2D &>(*operations[i]->toMatrix(false));
-  }
-  return result;
-}
-
-std::pair<TransformOperations, bool> flattenOperations(const TransformOperations &operations) {
-  std::deque<std::shared_ptr<TransformOperation>> unprocessedQueue(operations.begin(), operations.end());
-  TransformOperations result;
-  bool is3D = false;
-
-  while (!unprocessedQueue.empty()) {
-    const auto operation = unprocessedQueue.front();
-    unprocessedQueue.pop_front();
-
-    if (operation->type == static_cast<uint8_t>(TransformOp::Matrix)) {
-      const auto matrixOperation = std::static_pointer_cast<MatrixOperation>(operation);
-      if (std::holds_alternative<TransformOperations>(matrixOperation->value)) {
-        // If the current operation is a matrix created from other operations,
-        // add all of these operations at the beginning of the queue
-        const auto &nestedOps = std::get<TransformOperations>(matrixOperation->value);
-        unprocessedQueue.insert(unprocessedQueue.begin(), nestedOps.begin(), nestedOps.end());
-        continue;
-      }
-    }
-
-    if (operation->is3D()) {
-      is3D = true;
-    }
-
-    result.emplace_back(operation);
-  }
-
-  return {std::move(result), is3D};
-}
-
-/**
- * Simplifies the vector of operations by converting to matrices and multiplying
- * transformations that can be converted. This reduces the number of operations
- * in the resulting operations vector or returns a single matrix if all
- * operations can be converted to a matrix.
- */
-std::pair<MatrixOperationValue, bool> simplifyOperations(const TransformOperations &operations) {
-  const auto [flattenedOperations, is3D] = flattenOperations(operations);
-
-  TransformOperations result;
-  TransformOperations toSimplify;
-  result.reserve(operations.size());
-  toSimplify.reserve(operations.size());
-
-//  const auto simplify = [&]() {
-//    return is3D ? std::make_shared<MatrixOperation>(matrixFromOperations3D(toSimplify))
-//                : std::make_shared<MatrixOperation>(matrixFromOperations2D(toSimplify));
-//  };
-   //TODO
-  const auto simplify = [](TransformOperations &toSimplify,bool is3DValue) {
-    return is3DValue ? std::make_shared<MatrixOperation>(matrixFromOperations3D(toSimplify))
-                : std::make_shared<MatrixOperation>(matrixFromOperations2D(toSimplify));
-  };
-  for (const auto &operation : flattenedOperations) {
-    if (operation->shouldResolve()) {
-      if (toSimplify.size() > 0) {
-        result.emplace_back(simplify(toSimplify,is3D));
-        toSimplify.clear();
-      }
-
-      // Keep operations that need to be resolved unchanged in the transform
-      // operations vector
-      result.emplace_back(operation);
-    } else {
-      toSimplify.emplace_back(operation);
-    }
-  }
-
-  // Result is empty only if there was not a single operation that needed to be
-  // resolved (all operations were added to the toSimplify vector)
-  if (result.empty()) {
-    return {simplify(toSimplify,is3D)->toMatrix(is3D), is3D};
-  }
-
-  result.emplace_back(simplify(toSimplify,is3D));
-
-  return {std::move(result), is3D};
-}
-
-MatrixOperation::MatrixOperation(MatrixOperationValue value)
-    : TransformOperation(TransformOp::Matrix), value(std::move(value)) {
-  // Initialize is3D_ based on the variant content
-  if (std::holds_alternative<TransformMatrix::Shared>(this->value)) {
-    const auto &matrix = std::get<TransformMatrix::Shared>(this->value);
-    is3D_ = matrix->getDimension() == MATRIX_3D_DIMENSION;
-  } else {
-    // If it contains TransformOperations, check if any operation is 3D
-    const auto &operations = std::get<TransformOperations>(this->value);
-    is3D_ = false;
-    for (const auto &operation : operations) {
-      if (operation->is3D()) {
-        is3D_ = true;
-        break;
-      }
-    }
-  }
-}
-
-MatrixOperation::MatrixOperation(jsi::Runtime &rt, const jsi::Value &value)
-    : MatrixOperation([&]() -> TransformMatrix::Shared {
-        // Try 2D first, then 3D (will throw if neither works)
-        if (TransformMatrix2D::canConstruct(rt, value)) {
-          is3D_ = false;
-          return std::make_shared<const TransformMatrix2D>(rt, value);
-        }
-        is3D_ = true;
-        return std::make_shared<const TransformMatrix3D>(rt, value);
-      }()) {}
-
-MatrixOperation::MatrixOperation(const folly::dynamic &value)
-    : MatrixOperation([&]() -> TransformMatrix::Shared {
-        // Try 2D first, then 3D (will throw if neither works)
-        if (TransformMatrix2D::canConstruct(value)) {
-          is3D_ = false;
-          return std::make_shared<const TransformMatrix2D>(value);
-        }
-        is3D_ = true;
-        return std::make_shared<const TransformMatrix3D>(value);
-      }()) {}
-
-MatrixOperation::MatrixOperation(TransformMatrix2D matrix)
-    : TransformOperation(TransformOp::Matrix),
-      value(std::make_shared<const TransformMatrix2D>(std::move(matrix))),
-      is3D_(false) {}
-
-MatrixOperation::MatrixOperation(TransformMatrix3D matrix)
-    : TransformOperation(TransformOp::Matrix),
-      value(std::make_shared<const TransformMatrix3D>(std::move(matrix))),
-      is3D_(true) {}
-
-MatrixOperation::MatrixOperation(TransformOperations operations)
-    // Simplify operations to reduce the number of matrix
-    // multiplications during matrix keyframe interpolation
-    : TransformOperation(TransformOp::Matrix), value([&]() {
-        const auto &[value, is3D] = simplifyOperations(operations);
-        is3D_ = is3D;
-        return value;
-      }()) {}
-
-bool MatrixOperation::is3D() const {
-  return is3D_;
-}
-
-folly::dynamic MatrixOperation::valueToDynamic() const {
-  return getMatrixFromVariant()->toDynamic();
-}
-
-TransformMatrix::Shared MatrixOperation::toMatrix(const bool force3D) const {
-  const auto &storedMatrix = getMatrixFromVariant();
-
-  if (force3D && storedMatrix->getDimension() == MATRIX_2D_DIMENSION) {
-    return std::make_shared<const TransformMatrix3D>(
-        TransformMatrix3D::from2D(static_cast<const TransformMatrix2D &>(*storedMatrix)));
-  }
-
-  return storedMatrix;
-}
-
-const TransformMatrix::Shared &MatrixOperation::getMatrixFromVariant() const {
-  if (!std::holds_alternative<TransformMatrix::Shared>(value)) {
-    throw std::runtime_error("[Reanimated] Cannot convert unprocessed transform operations to the matrix.");
-  }
-  return std::get<TransformMatrix::Shared>(value);
-}
-
-bool MatrixOperation::areValuesEqual(const StyleOperation &other) const {
-  const auto &otherOperation = static_cast<const MatrixOperation &>(other);
-
-  // Quick check: if variants have different types, they're not equal
-  if (value.index() != otherOperation.value.index()) {
-    return false;
-  }
-
-  // Both hold TransformOperations
-  if (std::holds_alternative<TransformOperations>(value)) {
-    return std::get<TransformOperations>(value) == std::get<TransformOperations>(otherOperation.value);
-  }
-
-  // Both hold matrices
-  return *std::get<TransformMatrix::Shared>(value) == *std::get<TransformMatrix::Shared>(otherOperation.value);
-}
-
-} // namespace reanimated::css
+#include <reanimated/CSS/interpolation/transforms/TransformOperationInterpolator.h>
+#include <reanimated/CSS/interpolation/transforms/operations/matrix.h>
+
+#include <deque>
+#include <memory>
+#include <utility>
+
+namespace reanimated::css {
+
+TransformMatrix3D matrixFromOperations3D(TransformOperations &operations) {
+  TransformMatrix3D result;
+  for (int i = static_cast<int>(operations.size()) - 1; i >= 0; i--) {
+    result *= static_cast<const TransformMatrix3D &>(*operations[i]->toMatrix(true));
+  }
+  return result;
+}
+
+TransformMatrix2D matrixFromOperations2D(TransformOperations &operations) {
+  TransformMatrix2D result;
+  for (int i = static_cast<int>(operations.size()) - 1; i >= 0; i--) {
+    result *= static_cast<const TransformMatrix2D &>(*operations[i]->toMatrix(false));
+  }
+  return result;
+}
+
+std::pair<TransformOperations, bool> flattenOperations(const TransformOperations &operations) {
+  std::deque<std::shared_ptr<TransformOperation>> unprocessedQueue(operations.begin(), operations.end());
+  TransformOperations result;
+  bool is3D = false;
+
+  while (!unprocessedQueue.empty()) {
+    const auto operation = unprocessedQueue.front();
+    unprocessedQueue.pop_front();
+
+    if (operation->type == static_cast<uint8_t>(TransformOp::Matrix)) {
+      const auto matrixOperation = std::static_pointer_cast<MatrixOperation>(operation);
+      if (std::holds_alternative<TransformOperations>(matrixOperation->value)) {
+        // If the current operation is a matrix created from other operations,
+        // add all of these operations at the beginning of the queue
+        const auto &nestedOps = std::get<TransformOperations>(matrixOperation->value);
+        unprocessedQueue.insert(unprocessedQueue.begin(), nestedOps.begin(), nestedOps.end());
+        continue;
+      }
+    }
+
+    if (operation->is3D()) {
+      is3D = true;
+    }
+
+    result.emplace_back(operation);
+  }
+
+  return {std::move(result), is3D};
+}
+
+/**
+ * Simplifies the vector of operations by converting to matrices and multiplying
+ * transformations that can be converted. This reduces the number of operations
+ * in the resulting operations vector or returns a single matrix if all
+ * operations can be converted to a matrix.
+ */
+std::pair<MatrixOperationValue, bool> simplifyOperations(const TransformOperations &operations) {
+  const auto [flattenedOperations, is3D] = flattenOperations(operations);
+
+  TransformOperations result;
+  TransformOperations toSimplify;
+  result.reserve(operations.size());
+  toSimplify.reserve(operations.size());
+
+//  const auto simplify = [&]() {
+//    return is3D ? std::make_shared<MatrixOperation>(matrixFromOperations3D(toSimplify))
+//                : std::make_shared<MatrixOperation>(matrixFromOperations2D(toSimplify));
+//  };
+   //TODO
+  const auto simplify = [](TransformOperations &toSimplify,bool is3DValue) {
+    return is3DValue ? std::make_shared<MatrixOperation>(matrixFromOperations3D(toSimplify))
+                : std::make_shared<MatrixOperation>(matrixFromOperations2D(toSimplify));
+  };
+  for (const auto &operation : flattenedOperations) {
+    if (operation->shouldResolve()) {
+      if (toSimplify.size() > 0) {
+        result.emplace_back(simplify(toSimplify,is3D));
+        toSimplify.clear();
+      }
+
+      // Keep operations that need to be resolved unchanged in the transform
+      // operations vector
+      result.emplace_back(operation);
+    } else {
+      toSimplify.emplace_back(operation);
+    }
+  }
+
+  // Result is empty only if there was not a single operation that needed to be
+  // resolved (all operations were added to the toSimplify vector)
+  if (result.empty()) {
+    return {simplify(toSimplify,is3D)->toMatrix(is3D), is3D};
+  }
+
+  result.emplace_back(simplify(toSimplify,is3D));
+
+  return {std::move(result), is3D};
+}
+
+MatrixOperation::MatrixOperation(MatrixOperationValue value)
+    : TransformOperation(TransformOp::Matrix), value(std::move(value)) {
+  // Initialize is3D_ based on the variant content
+  if (std::holds_alternative<TransformMatrix::Shared>(this->value)) {
+    const auto &matrix = std::get<TransformMatrix::Shared>(this->value);
+    is3D_ = matrix->getDimension() == MATRIX_3D_DIMENSION;
+  } else {
+    // If it contains TransformOperations, check if any operation is 3D
+    const auto &operations = std::get<TransformOperations>(this->value);
+    is3D_ = false;
+    for (const auto &operation : operations) {
+      if (operation->is3D()) {
+        is3D_ = true;
+        break;
+      }
+    }
+  }
+}
+
+MatrixOperation::MatrixOperation(jsi::Runtime &rt, const jsi::Value &value)
+    : MatrixOperation([&]() -> TransformMatrix::Shared {
+        // Try 2D first, then 3D (will throw if neither works)
+        if (TransformMatrix2D::canConstruct(rt, value)) {
+          is3D_ = false;
+          return std::make_shared<const TransformMatrix2D>(rt, value);
+        }
+        is3D_ = true;
+        return std::make_shared<const TransformMatrix3D>(rt, value);
+      }()) {}
+
+MatrixOperation::MatrixOperation(const folly::dynamic &value)
+    : MatrixOperation([&]() -> TransformMatrix::Shared {
+        // Try 2D first, then 3D (will throw if neither works)
+        if (TransformMatrix2D::canConstruct(value)) {
+          is3D_ = false;
+          return std::make_shared<const TransformMatrix2D>(value);
+        }
+        is3D_ = true;
+        return std::make_shared<const TransformMatrix3D>(value);
+      }()) {}
+
+MatrixOperation::MatrixOperation(TransformMatrix2D matrix)
+    : TransformOperation(TransformOp::Matrix),
+      value(std::make_shared<const TransformMatrix2D>(std::move(matrix))),
+      is3D_(false) {}
+
+MatrixOperation::MatrixOperation(TransformMatrix3D matrix)
+    : TransformOperation(TransformOp::Matrix),
+      value(std::make_shared<const TransformMatrix3D>(std::move(matrix))),
+      is3D_(true) {}
+
+MatrixOperation::MatrixOperation(TransformOperations operations)
+    // Simplify operations to reduce the number of matrix
+    // multiplications during matrix keyframe interpolation
+    : TransformOperation(TransformOp::Matrix), value([&]() {
+        const auto &[value, is3D] = simplifyOperations(operations);
+        is3D_ = is3D;
+        return value;
+      }()) {}
+
+bool MatrixOperation::is3D() const {
+  return is3D_;
+}
+
+folly::dynamic MatrixOperation::valueToDynamic() const {
+  return getMatrixFromVariant()->toDynamic();
+}
+
+TransformMatrix::Shared MatrixOperation::toMatrix(const bool force3D) const {
+  const auto &storedMatrix = getMatrixFromVariant();
+
+  if (force3D && storedMatrix->getDimension() == MATRIX_2D_DIMENSION) {
+    return std::make_shared<const TransformMatrix3D>(
+        TransformMatrix3D::from2D(static_cast<const TransformMatrix2D &>(*storedMatrix)));
+  }
+
+  return storedMatrix;
+}
+
+const TransformMatrix::Shared &MatrixOperation::getMatrixFromVariant() const {
+  if (!std::holds_alternative<TransformMatrix::Shared>(value)) {
+    throw std::runtime_error("[Reanimated] Cannot convert unprocessed transform operations to the matrix.");
+  }
+  return std::get<TransformMatrix::Shared>(value);
+}
+
+bool MatrixOperation::areValuesEqual(const StyleOperation &other) const {
+  const auto &otherOperation = static_cast<const MatrixOperation &>(other);
+
+  // Quick check: if variants have different types, they're not equal
+  if (value.index() != otherOperation.value.index()) {
+    return false;
+  }
+
+  // Both hold TransformOperations
+  if (std::holds_alternative<TransformOperations>(value)) {
+    return std::get<TransformOperations>(value) == std::get<TransformOperations>(otherOperation.value);
+  }
+
+  // Both hold matrices
+  return *std::get<TransformMatrix::Shared>(value) == *std::get<TransformMatrix::Shared>(otherOperation.value);
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/transforms/operations/matrix.h

@@ -1,56 +1,56 @@
-#pragma once
-
-#include <reanimated/CSS/common/transforms/TransformMatrix2D.h>
-#include <reanimated/CSS/common/transforms/TransformMatrix3D.h>
-#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
-
-#include <utility>
-#include <variant>
-
-namespace reanimated::css {
-
-// MatrixOperationValue type for matrix operations
-using MatrixOperationValue = std::variant<TransformMatrix::Shared, TransformOperations>;
-
-/**
- * Multiplies all operations in the vector to a single 3D matrix
- * @param operations - the vector of operations that can be represented in 3D
- */
-TransformMatrix3D matrixFromOperations3D(TransformOperations &operations);
-
-/**
- * Multiplies all operations in the vector to a single 2D matrix
- * @param operations - the vector of operations that can be represented in 2D
- */
-TransformMatrix2D matrixFromOperations2D(TransformOperations &operations);
-
-/**
- * MatrixOperation does not inherit from TransformOperationBase because its value type
- * is different from the other transform operations which use a CSSValue-derived type.
- * Instead, it uses a variant of TransformMatrix::Shared and TransformOperations that
- * doesn't have a value field.
- */
-struct MatrixOperation final : public TransformOperation {
-  const MatrixOperationValue value;
-
-  explicit MatrixOperation(MatrixOperationValue value);
-  explicit MatrixOperation(jsi::Runtime &rt, const jsi::Value &value);
-  explicit MatrixOperation(const folly::dynamic &value);
-  explicit MatrixOperation(TransformMatrix2D matrix);
-  explicit MatrixOperation(TransformMatrix3D matrix);
-  explicit MatrixOperation(TransformOperations operations);
-
-  bool is3D() const override;
-  folly::dynamic valueToDynamic() const override;
-  TransformMatrix::Shared toMatrix(bool force3D) const override;
-
- protected:
-  bool areValuesEqual(const StyleOperation &other) const override;
-
- private:
-  bool is3D_;
-
-  const TransformMatrix::Shared &getMatrixFromVariant() const;
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/transforms/TransformMatrix2D.h>
+#include <reanimated/CSS/common/transforms/TransformMatrix3D.h>
+#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
+
+#include <utility>
+#include <variant>
+
+namespace reanimated::css {
+
+// MatrixOperationValue type for matrix operations
+using MatrixOperationValue = std::variant<TransformMatrix::Shared, TransformOperations>;
+
+/**
+ * Multiplies all operations in the vector to a single 3D matrix
+ * @param operations - the vector of operations that can be represented in 3D
+ */
+TransformMatrix3D matrixFromOperations3D(TransformOperations &operations);
+
+/**
+ * Multiplies all operations in the vector to a single 2D matrix
+ * @param operations - the vector of operations that can be represented in 2D
+ */
+TransformMatrix2D matrixFromOperations2D(TransformOperations &operations);
+
+/**
+ * MatrixOperation does not inherit from TransformOperationBase because its value type
+ * is different from the other transform operations which use a CSSValue-derived type.
+ * Instead, it uses a variant of TransformMatrix::Shared and TransformOperations that
+ * doesn't have a value field.
+ */
+struct MatrixOperation final : public TransformOperation {
+  const MatrixOperationValue value;
+
+  explicit MatrixOperation(MatrixOperationValue value);
+  explicit MatrixOperation(jsi::Runtime &rt, const jsi::Value &value);
+  explicit MatrixOperation(const folly::dynamic &value);
+  explicit MatrixOperation(TransformMatrix2D matrix);
+  explicit MatrixOperation(TransformMatrix3D matrix);
+  explicit MatrixOperation(TransformOperations operations);
+
+  bool is3D() const override;
+  folly::dynamic valueToDynamic() const override;
+  TransformMatrix::Shared toMatrix(bool force3D) const override;
+
+ protected:
+  bool areValuesEqual(const StyleOperation &other) const override;
+
+ private:
+  bool is3D_;
+
+  const TransformMatrix::Shared &getMatrixFromVariant() const;
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/transforms/operations/perspective.cpp

@@ -1,42 +1,42 @@
-#include <reanimated/CSS/common/transforms/TransformMatrix3D.h>
-#include <reanimated/CSS/interpolation/transforms/operations/perspective.h>
-
-#include <algorithm>
-#include <cmath>
-#include <memory>
-
-namespace reanimated::css {
-
-double sanitizePerspectiveValue(double value) {
-  if (value < 0) {
-    // Round value between -1 and 0 to -1
-    return std::min(value, -1.0);
-  }
-  // Round value between 0 and 1 to 1
-  return std::max(value, 1.0);
-}
-
-PerspectiveOperation::PerspectiveOperation(const double value)
-    : TransformOperationBase<TransformOp::Perspective, CSSDouble>(CSSDouble(sanitizePerspectiveValue(value))) {}
-
-bool PerspectiveOperation::is3D() const {
-  return true;
-}
-
-folly::dynamic PerspectiveOperation::valueToDynamic() const {
-  if (std::isinf(value.value)) {
-    return folly::dynamic();
-  }
-  return value.toDynamic();
-}
-
-TransformMatrix::Shared PerspectiveOperation::toMatrix(bool /* force3D */) const {
-  if (!cachedMatrix_) {
-    // Perspective is a 3D operation
-    cachedMatrix_ =
-        std::make_shared<const TransformMatrix3D>(TransformMatrix3D::create<TransformOp::Perspective>(value.value));
-  }
-  return cachedMatrix_;
-}
-
-} // namespace reanimated::css
+#include <reanimated/CSS/common/transforms/TransformMatrix3D.h>
+#include <reanimated/CSS/interpolation/transforms/operations/perspective.h>
+
+#include <algorithm>
+#include <cmath>
+#include <memory>
+
+namespace reanimated::css {
+
+double sanitizePerspectiveValue(double value) {
+  if (value < 0) {
+    // Round value between -1 and 0 to -1
+    return std::min(value, -1.0);
+  }
+  // Round value between 0 and 1 to 1
+  return std::max(value, 1.0);
+}
+
+PerspectiveOperation::PerspectiveOperation(const double value)
+    : TransformOperationBase<TransformOp::Perspective, CSSDouble>(CSSDouble(sanitizePerspectiveValue(value))) {}
+
+bool PerspectiveOperation::is3D() const {
+  return true;
+}
+
+folly::dynamic PerspectiveOperation::valueToDynamic() const {
+  if (std::isinf(value.value)) {
+    return folly::dynamic();
+  }
+  return value.toDynamic();
+}
+
+TransformMatrix::Shared PerspectiveOperation::toMatrix(bool /* force3D */) const {
+  if (!cachedMatrix_) {
+    // Perspective is a 3D operation
+    cachedMatrix_ =
+        std::make_shared<const TransformMatrix3D>(TransformMatrix3D::create<TransformOp::Perspective>(value.value));
+  }
+  return cachedMatrix_;
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/transforms/operations/perspective.h

@@ -1,20 +1,20 @@
-#pragma once
-
-#include <reanimated/CSS/common/values/CSSNumber.h>
-#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
-
-#include <memory>
-
-namespace reanimated::css {
-
-struct PerspectiveOperation final : public TransformOperationBase<TransformOp::Perspective, CSSDouble> {
-  using TransformOperationBase<TransformOp::Perspective, CSSDouble>::TransformOperationBase;
-
-  explicit PerspectiveOperation(double value);
-
-  bool is3D() const override;
-  folly::dynamic valueToDynamic() const override;
-  TransformMatrix::Shared toMatrix(bool /* force3D */) const override;
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSNumber.h>
+#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
+
+#include <memory>
+
+namespace reanimated::css {
+
+struct PerspectiveOperation final : public TransformOperationBase<TransformOp::Perspective, CSSDouble> {
+  using TransformOperationBase<TransformOp::Perspective, CSSDouble>::TransformOperationBase;
+
+  explicit PerspectiveOperation(double value);
+
+  bool is3D() const override;
+  folly::dynamic valueToDynamic() const override;
+  TransformMatrix::Shared toMatrix(bool /* force3D */) const override;
+};
+
+} // namespace reanimated::css