react-native-reanimated 4.0.3 → 4.1.0-jsx-fix

package/Common/cpp/reanimated/AnimatedSensor/AnimatedSensorModule.cpp

@@ -26,7 +26,7 @@ jsi::Value AnimatedSensorModule::registerSensor(
     const jsi::Value &sensorDataHandler) {
   SensorType sensorType = static_cast<SensorType>(sensorTypeValue.asNumber());
 
-  auto shareableHandler = extractShareableOrThrow<ShareableWorklet>(
+  auto serializableHandler = extractSerializableOrThrow<SerializableWorklet>(
       rt,
       sensorDataHandler,
       "[Reanimated] Sensor event handler must be a worklet.");
@@ -36,7 +36,7 @@ jsi::Value AnimatedSensorModule::registerSensor(
       interval.asNumber(),
       iosReferenceFrame.asNumber(),
       [sensorType,
-       shareableHandler,
+       serializableHandler,
        weakUiWorkletRuntime = std::weak_ptr<WorkletRuntime>(uiWorkletRuntime)](
           double newValues[], int orientationDegrees) {
         auto uiWorkletRuntime = weakUiWorkletRuntime.lock();
@@ -65,7 +65,7 @@ jsi::Value AnimatedSensorModule::registerSensor(
         value.setProperty(
             uiRuntime, "interfaceOrientation", orientationDegrees);
 
-        uiWorkletRuntime->runGuarded(shareableHandler, value);
+        uiWorkletRuntime->runGuarded(serializableHandler, value);
       });
   if (sensorId != -1) {
     sensorsIds_.insert(sensorId);

package/Common/cpp/reanimated/AnimatedSensor/AnimatedSensorModule.h

@@ -2,7 +2,7 @@
 
 #include <reanimated/Tools/PlatformDepMethodsHolder.h>
 
-#include <worklets/SharedItems/Shareables.h>
+#include <worklets/SharedItems/Serializable.h>
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 
 #include <jsi/jsi.h>

package/Common/cpp/reanimated/CSS/common/definitions.h

@@ -20,7 +20,5 @@ using TransitionProperties = std::optional<PropertyNames>;
 
 using EasingFunction = std::function<double(double)>;
 using ColorChannels = std::array<uint8_t, 4>;
-using Vec16Array = std::array<double, 16>;
-using Matrix4x4 = std::array<std::array<double, 4>, 4>;
 
 } // namespace reanimated::css

package/Common/cpp/reanimated/CSS/common/{Quaternion.cpp → transforms/Quaternion.cpp}

@@ -1,4 +1,4 @@
-#include <reanimated/CSS/common/Quaternion.h>
+#include <reanimated/CSS/common/transforms/Quaternion.h>
 
 namespace reanimated::css {
 

package/Common/cpp/reanimated/CSS/common/transforms/TransformMatrix.h

@@ -0,0 +1,148 @@
+#pragma once
+
+#include <reanimated/CSS/common/definitions.h>
+
+#include <folly/dynamic.h>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace reanimated::css {
+
+class TransformMatrix {
+ public:
+  virtual ~TransformMatrix() = default;
+
+  virtual double determinant() const = 0;
+
+  virtual double &operator[](size_t index) = 0;
+  virtual const double &operator[](size_t index) const = 0;
+
+  virtual size_t getDimension() const = 0;
+
+  virtual std::string toString() const = 0;
+  virtual folly::dynamic toDynamic() const = 0;
+};
+
+template <typename TDerived, size_t TDimension>
+class TransformMatrixBase : public TransformMatrix {
+ public:
+  static constexpr size_t SIZE = TDimension * TDimension;
+  using MatrixArray = std::array<double, SIZE>;
+
+  explicit TransformMatrixBase(MatrixArray matrix)
+      : matrix_(std::move(matrix)) {}
+
+  explicit TransformMatrixBase(jsi::Runtime &rt, const jsi::Value &value) {
+    const auto array = value.asObject(rt).asArray(rt);
+    if (array.size(rt) != SIZE) {
+      throw std::invalid_argument(
+          "[Reanimated] Matrix array should have " + std::to_string(SIZE) +
+          " elements");
+    }
+
+    for (size_t i = 0; i < SIZE; ++i) {
+      matrix_[i] = array.getValueAtIndex(rt, i).asNumber();
+    }
+  }
+
+  explicit TransformMatrixBase(const folly::dynamic &array) {
+    if (!array.isArray() || array.size() != SIZE) {
+      throw std::invalid_argument(
+          "[Reanimated] Matrix array should have " + std::to_string(SIZE) +
+          " elements");
+    }
+
+    for (size_t i = 0; i < SIZE; ++i) {
+      matrix_[i] = array[i].asDouble();
+    }
+  }
+
+  virtual bool operator==(const TDerived &other) const = 0;
+
+  double &operator[](size_t index) override {
+    return matrix_[index];
+  }
+
+  const double &operator[](size_t index) const override {
+    return matrix_[index];
+  }
+
+  TDerived operator*(const TDerived &rhs) const {
+    return TDerived(multiply(rhs));
+  }
+
+  TDerived &operator*=(const TDerived &rhs) {
+    matrix_ = multiply(rhs);
+    return static_cast<TDerived &>(*this);
+  }
+
+  std::string toString() const override {
+    std::string result = "[";
+    for (size_t i = 0; i < SIZE; ++i) {
+      result += std::to_string(matrix_[i]);
+      if (i < SIZE - 1) {
+        result += ", ";
+      }
+    }
+    result += "]";
+    return result;
+  }
+
+  folly::dynamic toDynamic() const override {
+    folly::dynamic result = folly::dynamic::array;
+    for (size_t i = 0; i < SIZE; ++i) {
+      result.push_back(matrix_[i]);
+    }
+    return result;
+  }
+
+  size_t getDimension() const override {
+    return TDimension;
+  }
+
+  bool isSingular() const {
+    return determinant() == 0;
+  }
+
+  bool normalize() {
+    const auto last = matrix_[SIZE - 1];
+    if (last == 0) {
+      return false;
+    }
+    if (last == 1) {
+      return true;
+    }
+
+    for (size_t i = 0; i < SIZE; ++i) {
+      matrix_[i] /= last;
+    }
+    return true;
+  }
+
+  void transpose() {
+    for (size_t i = 0; i < TDimension; ++i) {
+      for (size_t j = i + 1; j < TDimension; ++j) {
+        std::swap(matrix_[i * TDimension + j], matrix_[j * TDimension + i]);
+      }
+    }
+  }
+
+ protected:
+  std::array<double, SIZE> matrix_;
+
+  MatrixArray multiply(const TDerived &rhs) const {
+    std::array<double, SIZE> result{};
+    for (size_t i = 0; i < TDimension; ++i) {
+      for (size_t j = 0; j < TDimension; ++j) {
+        for (size_t k = 0; k < TDimension; ++k) {
+          result[i * TDimension + j] +=
+              matrix_[i * TDimension + k] * rhs[k * TDimension + j];
+        }
+      }
+    }
+    return result;
+  }
+};
+
+} // namespace reanimated::css

package/Common/cpp/reanimated/CSS/common/transforms/TransformMatrix2D.cpp

@@ -0,0 +1,259 @@
+#include <reanimated/CSS/common/transforms/TransformMatrix2D.h>
+
+namespace reanimated::css {
+
+TransformMatrix2D::Decomposed TransformMatrix2D::Decomposed::interpolate(
+    const double progress,
+    const TransformMatrix2D::Decomposed &other) const {
+  return {
+      .scale = scale.interpolate(progress, other.scale),
+      .skew = skew + (other.skew - skew) * progress,
+      .rotation = rotation + (other.rotation - rotation) * progress,
+      .translation = translation.interpolate(progress, other.translation)};
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(
+    std::ostream &os,
+    const TransformMatrix2D::Decomposed &decomposed) {
+  os << "TransformMatrix2D::Decomposed(scale=" << decomposed.scale
+     << ", skew=" << decomposed.skew << ", rotation=" << decomposed.rotation
+     << ", translation=" << decomposed.translation << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+TransformMatrix2D TransformMatrix2D::Identity() {
+  // clang-format off
+  return TransformMatrix2D({
+    1, 0, 0,
+    0, 1, 0,
+    0, 0, 1
+  });
+  // clang-format on
+}
+
+template <>
+TransformMatrix2D TransformMatrix2D::create<TransformOp::Rotate>(double v) {
+  const auto cosVal = std::cos(v);
+  const auto sinVal = std::sin(v);
+  // clang-format off
+  return TransformMatrix2D({
+    cosVal, -sinVal, 0,
+    sinVal,  cosVal, 0,
+        0,        0, 1
+  });
+  // clang-format on
+}
+
+template <>
+TransformMatrix2D TransformMatrix2D::create<TransformOp::Scale>(double v) {
+  // clang-format off
+  return TransformMatrix2D({
+    v, 0, 0,
+    0, v, 0,
+    0, 0, 1
+  });
+  // clang-format on
+}
+
+template <>
+TransformMatrix2D TransformMatrix2D::create<TransformOp::ScaleX>(double v) {
+  // clang-format off
+  return TransformMatrix2D({
+    v, 0, 0,
+    0, 1, 0,
+    0, 0, 1
+  });
+  // clang-format on
+}
+
+template <>
+TransformMatrix2D TransformMatrix2D::create<TransformOp::ScaleY>(double v) {
+  // clang-format off
+  return TransformMatrix2D({
+    1, 0, 0,
+    0, v, 0,
+    0, 0, 1
+  });
+  // clang-format on
+}
+
+template <>
+TransformMatrix2D TransformMatrix2D::create<TransformOp::TranslateX>(double v) {
+  // clang-format off
+  return TransformMatrix2D({
+    1, 0, 0,
+    0, 1, 0,
+    v, 0, 1
+  });
+  // clang-format on
+}
+
+template <>
+TransformMatrix2D TransformMatrix2D::create<TransformOp::TranslateY>(double v) {
+  // clang-format off
+  return TransformMatrix2D({
+    1, 0, 0,
+    0, 1, 0,
+    0, v, 1
+  });
+  // clang-format on
+}
+
+template <>
+TransformMatrix2D TransformMatrix2D::create<TransformOp::SkewX>(double v) {
+  const auto tanVal = std::tan(v);
+  // clang-format off
+  return TransformMatrix2D({
+        1, 0, 0,
+   tanVal, 1, 0,
+        0, 0, 1
+  });
+  // clang-format on
+}
+
+template <>
+TransformMatrix2D TransformMatrix2D::create<TransformOp::SkewY>(double v) {
+  const auto tanVal = std::tan(v);
+  // clang-format off
+  return TransformMatrix2D({
+    1, tanVal, 0,
+    0,      1, 0,
+    0,      0, 1
+  });
+  // clang-format on
+}
+
+template <TransformOp TOperation>
+TransformMatrix2D TransformMatrix2D::create(double value) {
+  throw std::invalid_argument(
+      "[Reanimated] Cannot create TransformMatrix2D from: " +
+      getOperationNameFromType(TOperation));
+}
+
+bool TransformMatrix2D::operator==(const TransformMatrix2D &other) const {
+  return matrix_ == other.matrix_;
+}
+
+double TransformMatrix2D::determinant() const {
+  return (matrix_[0] * matrix_[4] * matrix_[8]) +
+      (matrix_[1] * matrix_[5] * matrix_[6]) +
+      (matrix_[2] * matrix_[3] * matrix_[7]) -
+      (matrix_[2] * matrix_[4] * matrix_[6]) -
+      (matrix_[1] * matrix_[3] * matrix_[8]) -
+      (matrix_[0] * matrix_[5] * matrix_[7]);
+}
+
+void TransformMatrix2D::translate2d(const Vector2D &translation) {
+  for (size_t i = 0; i < 3; ++i) {
+    matrix_[6 + i] +=
+        translation[0] * matrix_[i] + translation[1] * matrix_[3 + i];
+  }
+}
+
+void TransformMatrix2D::scale2d(const Vector2D &scale) {
+  for (size_t i = 0; i < 3; ++i) {
+    matrix_[i] *= scale[0];
+    matrix_[3 + i] *= scale[1];
+  }
+}
+
+std::optional<TransformMatrix2D::Decomposed> TransformMatrix2D::decompose()
+    const {
+  auto matrixCp = *this;
+
+  if (!matrixCp.normalize()) {
+    return std::nullopt;
+  }
+
+  const auto translation = matrixCp.getTranslation();
+
+  // Take the 2×2 linear part into two column vectors (col-major)
+  std::array<Vector2D, 2> rows;
+  for (size_t i = 0; i < 2; ++i) {
+    rows[i] = Vector2D(matrixCp[i * 3], matrixCp[i * 3 + 1]);
+  }
+
+  auto [scale, skew] = computeScaleAndSkew(rows);
+
+  // At this point, the matrix (in rows) is orthonormal.
+  // Check for a coordinate system flip. If the determinant
+  // is negative, then negate the matrix and the scaling factors.
+  if (rows[0].cross(rows[1]) < 0) {
+    scale *= -1;
+    for (auto &row : rows) {
+      row *= -1;
+    }
+  }
+
+  const auto rotation = computeRotation(rows);
+
+  return TransformMatrix2D::Decomposed{
+      .scale = scale,
+      .skew = skew,
+      .rotation = rotation,
+      .translation = translation};
+}
+
+TransformMatrix2D TransformMatrix2D::recompose(
+    const TransformMatrix2D::Decomposed &decomposed) {
+  auto result = TransformMatrix2D::Identity();
+
+  // Apply Translation
+  result.translate2d(decomposed.translation);
+
+  // Apply Rotation
+  const auto rotationMatrix =
+      TransformMatrix2D::create<TransformOp::Rotate>(decomposed.rotation);
+  result = rotationMatrix * result;
+
+  // Apply XY shear
+  if (decomposed.skew != 0) {
+    auto tmp = TransformMatrix2D::Identity();
+    tmp[3] = decomposed.skew;
+    result = tmp * result;
+  }
+
+  // Apply Scale
+  result.scale2d(decomposed.scale);
+
+  return result;
+}
+
+Vector2D TransformMatrix2D::getTranslation() const {
+  return Vector2D(matrix_[6], matrix_[7]);
+}
+
+std::pair<Vector2D, double> TransformMatrix2D::computeScaleAndSkew(
+    std::array<Vector2D, 2> &rows) {
+  Vector2D scale;
+
+  // Compute X scale and normalize first row
+  scale[0] = rows[0].length();
+  rows[0].normalize();
+
+  // Compute XY shear and orthogonalize second row against first
+  double skew = rows[0].dot(rows[1]);
+  rows[1] = rows[1].addScaled(rows[0], -skew);
+
+  // Now, compute Y scale and normalize second row
+  scale[1] = rows[1].length();
+  rows[1].normalize();
+
+  // Next, Normalize shear by Y scale
+  skew /= scale[1];
+
+  return {scale, skew};
+}
+
+double TransformMatrix2D::computeRotation(std::array<Vector2D, 2> &rows) {
+  // For 2D, we can compute rotation directly from the orthonormal matrix
+  // The rotation angle is atan2(m10, m00) where m10 is rows[1][0] and m00 is
+  // rows[0][0]
+  return std::atan2(rows[1][0], rows[0][0]);
+}
+
+} // namespace reanimated::css

package/Common/cpp/reanimated/CSS/common/transforms/TransformMatrix2D.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <reanimated/CSS/common/transforms/TransformMatrix.h>
+#include <reanimated/CSS/common/transforms/TransformOp.h>
+#include <reanimated/CSS/common/transforms/vectors.h>
+
+#include <folly/dynamic.h>
+#include <memory>
+#include <utility>
+
+namespace reanimated::css {
+
+namespace {
+static constexpr size_t MATRIX_2D_DIMENSION = 3; // 3x3 matrix
+}
+
+class TransformMatrix2D
+    : public TransformMatrixBase<TransformMatrix2D, MATRIX_2D_DIMENSION> {
+ public:
+  struct Decomposed {
+    Vector2D scale;
+    double skew;
+    double rotation;
+    Vector2D translation;
+
+#ifndef NDEBUG
+    friend std::ostream &operator<<(
+        std::ostream &os,
+        const Decomposed &decomposed);
+#endif // NDEBUG
+
+    Decomposed interpolate(double progress, const Decomposed &other) const;
+  };
+
+  using TransformMatrixBase<TransformMatrix2D, MATRIX_2D_DIMENSION>::
+      TransformMatrixBase;
+
+  static TransformMatrix2D Identity();
+
+  template <TransformOp TOperation>
+  static TransformMatrix2D create(double value);
+
+  bool operator==(const TransformMatrix2D &other) const override;
+
+  double determinant() const override;
+  void translate2d(const Vector2D &translation);
+  void scale2d(const Vector2D &scale);
+
+  std::optional<Decomposed> decompose() const;
+  static TransformMatrix2D recompose(const Decomposed &decomposed);
+
+ private:
+  Vector2D getTranslation() const;
+  static std::pair<Vector2D, double> computeScaleAndSkew(
+      std::array<Vector2D, 2> &rows);
+  static double computeRotation(std::array<Vector2D, 2> &rows);
+};
+
+} // namespace reanimated::css