@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/common/transforms/TransformMatrix3D.h

@@ -1,67 +1,67 @@
-#pragma once
-
-#include <reanimated/CSS/common/transforms/Quaternion.h>
-#include <reanimated/CSS/common/transforms/TransformMatrix2D.h>
-#include <reanimated/CSS/common/transforms/TransformOp.h>
-#include <reanimated/CSS/common/transforms/vectors.h>
-
-#include <folly/dynamic.h>
-#include <utility>
-
-namespace reanimated::css {
-
-static constexpr size_t MATRIX_3D_DIMENSION = 4; // 4x4 matrix
-
-class TransformMatrix3D : public TransformMatrixBase<TransformMatrix3D, MATRIX_3D_DIMENSION> {
- public:
-  struct Decomposed {
-    Vector3D scale;
-    Vector3D skew;
-    Quaternion quaternion;
-    Vector3D translation;
-    Vector4D perspective;
-
-#ifndef NDEBUG
-    friend std::ostream &operator<<(std::ostream &os, const Decomposed &decomposed);
-#endif // NDEBUG
-
-    Decomposed interpolate(double progress, const Decomposed &to) const;
-  };
-
-  using TransformMatrixBase<TransformMatrix3D, MATRIX_3D_DIMENSION>::TransformMatrixBase;
-
-  explicit TransformMatrix3D(jsi::Runtime &rt, const jsi::Value &value);
-  explicit TransformMatrix3D(const folly::dynamic &array);
-
-  template <TransformOp TOperation>
-  static TransformMatrix3D create(double value);
-  static TransformMatrix3D from2D(const TransformMatrix2D &matrix);
-
-#ifndef NDEBUG
-  friend std::ostream &operator<<(std::ostream &os, const TransformMatrix3D &matrix);
-#endif // NDEBUG
-
-  double determinant() const override;
-  void adjugate();
-  bool invert();
-  void translate3d(const Vector3D &translation);
-  void scale3d(const Vector3D &scale);
-
-  std::optional<Decomposed> decompose() const;
-  static TransformMatrix3D recompose(const Decomposed &decomposed);
-  static TransformMatrix3D fromQuaternion(const Quaternion &q);
-
- private:
-  std::optional<Vector4D> computePerspective() const;
-
-  Vector3D getTranslation() const;
-  static std::pair<Vector3D, Vector3D> computeScaleAndSkew(std::array<Vector3D, 3> &rows);
-  static Quaternion computeQuaternion(std::array<Vector3D, 3> &columns);
-
-  inline static double
-  determinant3x3(double a, double b, double c, double d, double e, double f, double g, double h, double i);
-};
-
-Vector4D operator*(const Vector4D &v, const TransformMatrix3D &m);
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/transforms/Quaternion.h>
+#include <reanimated/CSS/common/transforms/TransformMatrix2D.h>
+#include <reanimated/CSS/common/transforms/TransformOp.h>
+#include <reanimated/CSS/common/transforms/vectors.h>
+
+#include <folly/dynamic.h>
+#include <utility>
+
+namespace reanimated::css {
+
+static constexpr size_t MATRIX_3D_DIMENSION = 4; // 4x4 matrix
+
+class TransformMatrix3D : public TransformMatrixBase<TransformMatrix3D, MATRIX_3D_DIMENSION> {
+ public:
+  struct Decomposed {
+    Vector3D scale;
+    Vector3D skew;
+    Quaternion quaternion;
+    Vector3D translation;
+    Vector4D perspective;
+
+#ifndef NDEBUG
+    friend std::ostream &operator<<(std::ostream &os, const Decomposed &decomposed);
+#endif // NDEBUG
+
+    Decomposed interpolate(double progress, const Decomposed &to) const;
+  };
+
+  using TransformMatrixBase<TransformMatrix3D, MATRIX_3D_DIMENSION>::TransformMatrixBase;
+
+  explicit TransformMatrix3D(jsi::Runtime &rt, const jsi::Value &value);
+  explicit TransformMatrix3D(const folly::dynamic &array);
+
+  template <TransformOp TOperation>
+  static TransformMatrix3D create(double value);
+  static TransformMatrix3D from2D(const TransformMatrix2D &matrix);
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const TransformMatrix3D &matrix);
+#endif // NDEBUG
+
+  double determinant() const override;
+  void adjugate();
+  bool invert();
+  void translate3d(const Vector3D &translation);
+  void scale3d(const Vector3D &scale);
+
+  std::optional<Decomposed> decompose() const;
+  static TransformMatrix3D recompose(const Decomposed &decomposed);
+  static TransformMatrix3D fromQuaternion(const Quaternion &q);
+
+ private:
+  std::optional<Vector4D> computePerspective() const;
+
+  Vector3D getTranslation() const;
+  static std::pair<Vector3D, Vector3D> computeScaleAndSkew(std::array<Vector3D, 3> &rows);
+  static Quaternion computeQuaternion(std::array<Vector3D, 3> &columns);
+
+  inline static double
+  determinant3x3(double a, double b, double c, double d, double e, double f, double g, double h, double i);
+};
+
+Vector4D operator*(const Vector4D &v, const TransformMatrix3D &m);
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/common/transforms/TransformOp.cpp

@@ -1,52 +1,52 @@
-#include <reanimated/CSS/common/transforms/TransformOp.h>
-
-#include <array>
-#include <string>
-#include <unordered_map>
-
-namespace reanimated::css {
-
-constexpr std::array<const char *, 13> transformOperationStrings = {
-    "perspective",
-    "rotate",
-    "rotateX",
-    "rotateY",
-    "rotateZ",
-    "scale",
-    "scaleX",
-    "scaleY",
-    "translateX",
-    "translateY",
-    "skewX",
-    "skewY",
-    "matrix"};
-
-TransformOp getTransformOperationType(const std::string &property) {
-  static const std::unordered_map<std::string, TransformOp> stringToEnumMap = {
-      {"perspective", TransformOp::Perspective},
-      {"rotate", TransformOp::Rotate},
-      {"rotateX", TransformOp::RotateX},
-      {"rotateY", TransformOp::RotateY},
-      {"rotateZ", TransformOp::RotateZ},
-      {"scale", TransformOp::Scale},
-      {"scaleX", TransformOp::ScaleX},
-      {"scaleY", TransformOp::ScaleY},
-      {"translateX", TransformOp::TranslateX},
-      {"translateY", TransformOp::TranslateY},
-      {"skewX", TransformOp::SkewX},
-      {"skewY", TransformOp::SkewY},
-      {"matrix", TransformOp::Matrix}};
-
-  auto it = stringToEnumMap.find(property);
-  if (it != stringToEnumMap.end()) {
-    return it->second;
-  } else {
-    throw std::invalid_argument("[Reanimated] Unknown transform operation: " + property);
-  }
-}
-
-std::string getTransformOperationName(const TransformOp type) {
-  return transformOperationStrings[static_cast<uint8_t>(type)];
-}
-
-} // namespace reanimated::css
+#include <reanimated/CSS/common/transforms/TransformOp.h>
+
+#include <array>
+#include <string>
+#include <unordered_map>
+
+namespace reanimated::css {
+
+constexpr std::array<const char *, 13> transformOperationStrings = {
+    "perspective",
+    "rotate",
+    "rotateX",
+    "rotateY",
+    "rotateZ",
+    "scale",
+    "scaleX",
+    "scaleY",
+    "translateX",
+    "translateY",
+    "skewX",
+    "skewY",
+    "matrix"};
+
+TransformOp getTransformOperationType(const std::string &property) {
+  static const std::unordered_map<std::string, TransformOp> stringToEnumMap = {
+      {"perspective", TransformOp::Perspective},
+      {"rotate", TransformOp::Rotate},
+      {"rotateX", TransformOp::RotateX},
+      {"rotateY", TransformOp::RotateY},
+      {"rotateZ", TransformOp::RotateZ},
+      {"scale", TransformOp::Scale},
+      {"scaleX", TransformOp::ScaleX},
+      {"scaleY", TransformOp::ScaleY},
+      {"translateX", TransformOp::TranslateX},
+      {"translateY", TransformOp::TranslateY},
+      {"skewX", TransformOp::SkewX},
+      {"skewY", TransformOp::SkewY},
+      {"matrix", TransformOp::Matrix}};
+
+  auto it = stringToEnumMap.find(property);
+  if (it != stringToEnumMap.end()) {
+    return it->second;
+  } else {
+    throw std::invalid_argument("[Reanimated] Unknown transform operation: " + property);
+  }
+}
+
+std::string getTransformOperationName(const TransformOp type) {
+  return transformOperationStrings[static_cast<uint8_t>(type)];
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/common/transforms/TransformOp.h

@@ -1,26 +1,26 @@
-#pragma once
-
-#include <string>
-
-namespace reanimated::css {
-
-enum class TransformOp : uint8_t {
-  Perspective,
-  Rotate,
-  RotateX,
-  RotateY,
-  RotateZ,
-  Scale,
-  ScaleX,
-  ScaleY,
-  TranslateX,
-  TranslateY,
-  SkewX,
-  SkewY,
-  Matrix,
-};
-
-TransformOp getTransformOperationType(const std::string &property);
-std::string getTransformOperationName(const TransformOp type);
-
-} // namespace reanimated::css
+#pragma once
+
+#include <string>
+
+namespace reanimated::css {
+
+enum class TransformOp : uint8_t {
+  Perspective,
+  Rotate,
+  RotateX,
+  RotateY,
+  RotateZ,
+  Scale,
+  ScaleX,
+  ScaleY,
+  TranslateX,
+  TranslateY,
+  SkewX,
+  SkewY,
+  Matrix,
+};
+
+TransformOp getTransformOperationType(const std::string &property);
+std::string getTransformOperationName(const TransformOp type);
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/common/transforms/vectors.cpp

@@ -1,156 +1,156 @@
-#include <reanimated/CSS/common/transforms/vectors.h>
-
-namespace reanimated::css {
-
-// Vector2D
-
-double &Vector2D::operator[](const size_t idx) {
-  return vec[idx];
-}
-
-const double &Vector2D::operator[](const size_t idx) const {
-  return vec[idx];
-}
-
-Vector2D &Vector2D::operator*=(const double scalar) {
-  vec[0] *= scalar;
-  vec[1] *= scalar;
-  return *this;
-}
-
-#ifndef NDEBUG
-
-std::ostream &operator<<(std::ostream &os, const Vector2D &vector) {
-  os << "Vector2D(" << vector.vec[0] << ", " << vector.vec[1] << ")";
-  return os;
-}
-
-#endif // NDEBUG
-
-double Vector2D::length() const {
-  return std::hypot(vec[0], vec[1]);
-}
-
-void Vector2D::scaleToLength(double targetLength) {
-  double currentLength = length();
-  if (currentLength != 0) {
-    double factor = targetLength / currentLength;
-    vec[0] *= factor;
-    vec[1] *= factor;
-  }
-}
-
-void Vector2D::normalize() {
-  scaleToLength(1);
-}
-
-double Vector2D::dot(const Vector2D &other) const {
-  return vec[0] * other.vec[0] + vec[1] * other.vec[1];
-}
-
-double Vector2D::cross(const Vector2D &other) const {
-  return vec[0] * other.vec[1] - vec[1] * other.vec[0];
-}
-
-Vector2D Vector2D::addScaled(const Vector2D &other, const double scale) const {
-  return Vector2D{vec[0] + scale * other.vec[0], vec[1] + scale * other.vec[1]};
-}
-
-Vector2D Vector2D::interpolate(const double progress, const Vector2D &other) const {
-  return Vector2D{vec[0] + progress * (other.vec[0] - vec[0]), vec[1] + progress * (other.vec[1] - vec[1])};
-}
-
-// Vector3D
-
-double &Vector3D::operator[](const size_t idx) {
-  return vec[idx];
-}
-
-const double &Vector3D::operator[](const size_t idx) const {
-  return vec[idx];
-}
-
-Vector3D &Vector3D::operator*=(const double scalar) {
-  vec[0] *= scalar;
-  vec[1] *= scalar;
-  vec[2] *= scalar;
-  return *this;
-}
-
-#ifndef NDEBUG
-
-std::ostream &operator<<(std::ostream &os, const Vector3D &vector) {
-  os << "Vector3D(" << vector.vec[0] << ", " << vector.vec[1] << ", " << vector.vec[2] << ")";
-  return os;
-}
-
-#endif // NDEBUG
-
-double Vector3D::length() const {
-  return std::hypot(vec[0], vec[1], vec[2]);
-}
-
-void Vector3D::scaleToLength(double targetLength) {
-  double currentLength = length();
-  if (currentLength != 0) {
-    double factor = targetLength / currentLength;
-    vec[0] *= factor;
-    vec[1] *= factor;
-    vec[2] *= factor;
-  }
-}
-
-void Vector3D::normalize() {
-  scaleToLength(1);
-}
-
-double Vector3D::dot(const Vector3D &other) const {
-  return vec[0] * other.vec[0] + vec[1] * other.vec[1] + vec[2] * other.vec[2];
-}
-
-Vector3D Vector3D::cross(const Vector3D &other) const {
-  return Vector3D{
-      vec[1] * other.vec[2] - vec[2] * other.vec[1],
-      vec[2] * other.vec[0] - vec[0] * other.vec[2],
-      vec[0] * other.vec[1] - vec[1] * other.vec[0]};
-}
-
-Vector3D Vector3D::addScaled(const Vector3D &other, const double scale) const {
-  return Vector3D{vec[0] + scale * other.vec[0], vec[1] + scale * other.vec[1], vec[2] + scale * other.vec[2]};
-}
-
-Vector3D Vector3D::interpolate(const double progress, const Vector3D &other) const {
-  return Vector3D{
-      vec[0] + progress * (other.vec[0] - vec[0]),
-      vec[1] + progress * (other.vec[1] - vec[1]),
-      vec[2] + progress * (other.vec[2] - vec[2])};
-}
-
-// Vector4D
-
-double &Vector4D::operator[](const size_t idx) {
-  return vec[idx];
-}
-
-const double &Vector4D::operator[](const size_t idx) const {
-  return vec[idx];
-}
-
-Vector4D Vector4D::interpolate(const double progress, const Vector4D &other) const {
-  return Vector4D{
-      vec[0] + progress * (other.vec[0] - vec[0]),
-      vec[1] + progress * (other.vec[1] - vec[1]),
-      vec[2] + progress * (other.vec[2] - vec[2]),
-      vec[3] + progress * (other.vec[3] - vec[3])};
-}
-
-#ifndef NDEBUG
-
-std::ostream &operator<<(std::ostream &os, const Vector4D &vector) {
-  os << "Vector4D(" << vector.vec[0] << ", " << vector.vec[1] << ", " << vector.vec[2] << ", " << vector.vec[3] << ")";
-  return os;
-}
-
-#endif // NDEBUG
-
-} // namespace reanimated::css
+#include <reanimated/CSS/common/transforms/vectors.h>
+
+namespace reanimated::css {
+
+// Vector2D
+
+double &Vector2D::operator[](const size_t idx) {
+  return vec[idx];
+}
+
+const double &Vector2D::operator[](const size_t idx) const {
+  return vec[idx];
+}
+
+Vector2D &Vector2D::operator*=(const double scalar) {
+  vec[0] *= scalar;
+  vec[1] *= scalar;
+  return *this;
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const Vector2D &vector) {
+  os << "Vector2D(" << vector.vec[0] << ", " << vector.vec[1] << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+double Vector2D::length() const {
+  return std::hypot(vec[0], vec[1]);
+}
+
+void Vector2D::scaleToLength(double targetLength) {
+  double currentLength = length();
+  if (currentLength != 0) {
+    double factor = targetLength / currentLength;
+    vec[0] *= factor;
+    vec[1] *= factor;
+  }
+}
+
+void Vector2D::normalize() {
+  scaleToLength(1);
+}
+
+double Vector2D::dot(const Vector2D &other) const {
+  return vec[0] * other.vec[0] + vec[1] * other.vec[1];
+}
+
+double Vector2D::cross(const Vector2D &other) const {
+  return vec[0] * other.vec[1] - vec[1] * other.vec[0];
+}
+
+Vector2D Vector2D::addScaled(const Vector2D &other, const double scale) const {
+  return Vector2D{vec[0] + scale * other.vec[0], vec[1] + scale * other.vec[1]};
+}
+
+Vector2D Vector2D::interpolate(const double progress, const Vector2D &other) const {
+  return Vector2D{vec[0] + progress * (other.vec[0] - vec[0]), vec[1] + progress * (other.vec[1] - vec[1])};
+}
+
+// Vector3D
+
+double &Vector3D::operator[](const size_t idx) {
+  return vec[idx];
+}
+
+const double &Vector3D::operator[](const size_t idx) const {
+  return vec[idx];
+}
+
+Vector3D &Vector3D::operator*=(const double scalar) {
+  vec[0] *= scalar;
+  vec[1] *= scalar;
+  vec[2] *= scalar;
+  return *this;
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const Vector3D &vector) {
+  os << "Vector3D(" << vector.vec[0] << ", " << vector.vec[1] << ", " << vector.vec[2] << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+double Vector3D::length() const {
+  return std::hypot(vec[0], vec[1], vec[2]);
+}
+
+void Vector3D::scaleToLength(double targetLength) {
+  double currentLength = length();
+  if (currentLength != 0) {
+    double factor = targetLength / currentLength;
+    vec[0] *= factor;
+    vec[1] *= factor;
+    vec[2] *= factor;
+  }
+}
+
+void Vector3D::normalize() {
+  scaleToLength(1);
+}
+
+double Vector3D::dot(const Vector3D &other) const {
+  return vec[0] * other.vec[0] + vec[1] * other.vec[1] + vec[2] * other.vec[2];
+}
+
+Vector3D Vector3D::cross(const Vector3D &other) const {
+  return Vector3D{
+      vec[1] * other.vec[2] - vec[2] * other.vec[1],
+      vec[2] * other.vec[0] - vec[0] * other.vec[2],
+      vec[0] * other.vec[1] - vec[1] * other.vec[0]};
+}
+
+Vector3D Vector3D::addScaled(const Vector3D &other, const double scale) const {
+  return Vector3D{vec[0] + scale * other.vec[0], vec[1] + scale * other.vec[1], vec[2] + scale * other.vec[2]};
+}
+
+Vector3D Vector3D::interpolate(const double progress, const Vector3D &other) const {
+  return Vector3D{
+      vec[0] + progress * (other.vec[0] - vec[0]),
+      vec[1] + progress * (other.vec[1] - vec[1]),
+      vec[2] + progress * (other.vec[2] - vec[2])};
+}
+
+// Vector4D
+
+double &Vector4D::operator[](const size_t idx) {
+  return vec[idx];
+}
+
+const double &Vector4D::operator[](const size_t idx) const {
+  return vec[idx];
+}
+
+Vector4D Vector4D::interpolate(const double progress, const Vector4D &other) const {
+  return Vector4D{
+      vec[0] + progress * (other.vec[0] - vec[0]),
+      vec[1] + progress * (other.vec[1] - vec[1]),
+      vec[2] + progress * (other.vec[2] - vec[2]),
+      vec[3] + progress * (other.vec[3] - vec[3])};
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const Vector4D &vector) {
+  os << "Vector4D(" << vector.vec[0] << ", " << vector.vec[1] << ", " << vector.vec[2] << ", " << vector.vec[3] << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+} // namespace reanimated::css