Skip to content

Commit 9b6e009

Browse files
MatiPl01MatiPl01
authored
chore: Move transforms and matrix implementations from headers to cpp files (#8262)
## Summary This PR moves implementation of transform operations and template transform matrix class from header files to cpp files.
1 parent 5b054f5 commit 9b6e009

File tree

18 files changed

+612
-333
lines changed

18 files changed

+612
-333
lines changed

‎packages/react-native-reanimated/Common/cpp/reanimated/CSS/common/transforms/TransformMatrix.cpp‎

Lines changed: 176 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,176 @@
1+
#include <reanimated/CSS/common/transforms/TransformMatrix.h>
2+
3+
#include <reanimated/CSS/common/transforms/TransformMatrix2D.h>
4+
#include <reanimated/CSS/common/transforms/TransformMatrix3D.h>
5+
6+
#include <algorithm>
7+
8+
namespace reanimated::css {
9+
10+
// TransformMatrixBase template implementations
11+
template <typename TDerived, size_t TDimension>
12+
TransformMatrixBase<TDerived, TDimension>::TransformMatrixBase()
13+
: TransformMatrix(), matrix_{} {
14+
// Create an identity matrix
15+
for (size_t i = 0; i < TDimension; ++i) {
16+
matrix_[i * (TDimension + 1)] = 1;
17+
}
18+
}
19+
20+
template <typename TDerived, size_t TDimension>
21+
TransformMatrixBase<TDerived, TDimension>::TransformMatrixBase(
22+
MatrixArray matrix)
23+
: TransformMatrix(), matrix_(std::move(matrix)) {}
24+
25+
template <typename TDerived, size_t TDimension>
26+
TransformMatrixBase<TDerived, TDimension>::TransformMatrixBase(
27+
const TransformMatrixBase &other)
28+
: TransformMatrix(), matrix_(other.matrix_) {}
29+
30+
template <typename TDerived, size_t TDimension>
31+
TransformMatrixBase<TDerived, TDimension>::TransformMatrixBase(
32+
TransformMatrixBase &&other) noexcept
33+
: TransformMatrix(), matrix_(std::move(other.matrix_)) {}
34+
35+
template <typename TDerived, size_t TDimension>
36+
bool TransformMatrixBase<TDerived, TDimension>::operator==(
37+
const TDerived &other) const {
38+
return matrix_ == other.matrix_;
39+
}
40+
41+
template <typename TDerived, size_t TDimension>
42+
bool TransformMatrixBase<TDerived, TDimension>::operator==(
43+
const TransformMatrix &other) const {
44+
return TDimension == other.getDimension() &&
45+
matrix_ == static_cast<const TDerived &>(other).matrix_;
46+
}
47+
48+
template <typename TDerived, size_t TDimension>
49+
double &TransformMatrixBase<TDerived, TDimension>::operator[](size_t index) {
50+
return matrix_[index];
51+
}
52+
53+
template <typename TDerived, size_t TDimension>
54+
const double &TransformMatrixBase<TDerived, TDimension>::operator[](
55+
size_t index) const {
56+
return matrix_[index];
57+
}
58+
59+
template <typename TDerived, size_t TDimension>
60+
size_t TransformMatrixBase<TDerived, TDimension>::getDimension() const {
61+
return TDimension;
62+
}
63+
64+
template <typename TDerived, size_t TDimension>
65+
size_t TransformMatrixBase<TDerived, TDimension>::getSize() const {
66+
return SIZE;
67+
}
68+
69+
template <typename TDerived, size_t TDimension>
70+
bool TransformMatrixBase<TDerived, TDimension>::isSingular() const {
71+
return determinant() == 0;
72+
}
73+
74+
template <typename TDerived, size_t TDimension>
75+
bool TransformMatrixBase<TDerived, TDimension>::normalize() {
76+
const auto last = matrix_[SIZE - 1];
77+
if (last == 0) {
78+
return false;
79+
}
80+
if (last == 1) {
81+
return true;
82+
}
83+
84+
for (size_t i = 0; i < SIZE; ++i) {
85+
matrix_[i] /= last;
86+
}
87+
return true;
88+
}
89+
90+
template <typename TDerived, size_t TDimension>
91+
void TransformMatrixBase<TDerived, TDimension>::transpose() {
92+
for (size_t i = 0; i < TDimension; ++i) {
93+
for (size_t j = i + 1; j < TDimension; ++j) {
94+
std::swap(matrix_[i * TDimension + j], matrix_[j * TDimension + i]);
95+
}
96+
}
97+
}
98+
99+
template <typename TDerived, size_t TDimension>
100+
std::string TransformMatrixBase<TDerived, TDimension>::toString() const {
101+
std::string result = "[";
102+
for (size_t i = 0; i < SIZE; ++i) {
103+
result += std::to_string(matrix_[i]);
104+
if (i < SIZE - 1) {
105+
result += ", ";
106+
}
107+
}
108+
result += "]";
109+
return result;
110+
}
111+
112+
template <typename TDerived, size_t TDimension>
113+
folly::dynamic TransformMatrixBase<TDerived, TDimension>::toDynamic() const {
114+
folly::dynamic result = folly::dynamic::array;
115+
for (size_t i = 0; i < SIZE; ++i) {
116+
result.push_back(matrix_[i]);
117+
}
118+
return result;
119+
}
120+
121+
template <typename TDerived, size_t TDimension>
122+
TDerived TransformMatrixBase<TDerived, TDimension>::operator*(
123+
const TDerived &rhs) const {
124+
return TDerived(multiply(rhs));
125+
}
126+
127+
template <typename TDerived, size_t TDimension>
128+
TDerived &TransformMatrixBase<TDerived, TDimension>::operator*=(
129+
const TDerived &rhs) {
130+
matrix_ = multiply(rhs);
131+
return static_cast<TDerived &>(*this);
132+
}
133+
134+
template <typename TDerived, size_t TDimension>
135+
TransformMatrixBase<TDerived, TDimension> &
136+
TransformMatrixBase<TDerived, TDimension>::operator=(
137+
const TransformMatrixBase &other) {
138+
if (this != &other) {
139+
// Note: dimension_ is const, so we can't reassign it
140+
// But since all instances have the same dimension, this is fine
141+
matrix_ = other.matrix_;
142+
}
143+
return *this;
144+
}
145+
146+
template <typename TDerived, size_t TDimension>
147+
TransformMatrixBase<TDerived, TDimension> &
148+
TransformMatrixBase<TDerived, TDimension>::operator=(
149+
TransformMatrixBase &&other) noexcept {
150+
if (this != &other) {
151+
matrix_ = std::move(other.matrix_);
152+
}
153+
return *this;
154+
}
155+
156+
template <typename TDerived, size_t TDimension>
157+
typename TransformMatrixBase<TDerived, TDimension>::MatrixArray
158+
TransformMatrixBase<TDerived, TDimension>::multiply(const TDerived &rhs) const {
159+
MatrixArray result{};
160+
161+
for (size_t i = 0; i < TDimension; ++i) {
162+
for (size_t k = 0; k < TDimension; ++k) {
163+
double temp = matrix_[i * TDimension + k];
164+
for (size_t j = 0; j < TDimension; ++j) {
165+
result[i * TDimension + j] += temp * rhs[k * TDimension + j];
166+
}
167+
}
168+
}
169+
170+
return result;
171+
}
172+
173+
template class TransformMatrixBase<TransformMatrix2D, MATRIX_2D_DIMENSION>;
174+
template class TransformMatrixBase<TransformMatrix3D, MATRIX_3D_DIMENSION>;
175+
176+
} // namespace reanimated::css

‎packages/react-native-reanimated/Common/cpp/reanimated/CSS/common/transforms/TransformMatrix.h‎

Lines changed: 24 additions & 126 deletions
Original file line numberDiff line numberDiff line change
@@ -38,136 +38,34 @@ class TransformMatrixBase : public TransformMatrix {
3838
static constexpr size_t SIZE = TDimension * TDimension;
3939
using MatrixArray = std::array<double, SIZE>;
4040

41-
TransformMatrixBase() : TransformMatrix(), matrix_{} {
42-
// Create an identity matrix
43-
for (size_t i = 0; i < TDimension; ++i) {
44-
matrix_[i * (TDimension + 1)] = 1;
45-
}
46-
}
47-
48-
explicit TransformMatrixBase(MatrixArray matrix)
49-
: TransformMatrix(), matrix_(std::move(matrix)) {}
50-
51-
TransformMatrixBase(const TransformMatrixBase &other)
52-
: TransformMatrix(), matrix_(other.matrix_) {}
53-
54-
TransformMatrixBase(TransformMatrixBase &&other) noexcept
55-
: TransformMatrix(), matrix_(std::move(other.matrix_)) {}
56-
57-
inline bool operator==(const TDerived &other) const {
58-
return matrix_ == other.matrix_;
59-
}
60-
61-
inline bool operator==(const TransformMatrix &other) const override {
62-
return TDimension == other.getDimension() &&
63-
matrix_ == static_cast<const TDerived &>(other).matrix_;
64-
}
65-
66-
inline double &operator[](size_t index) override {
67-
return matrix_[index];
68-
}
69-
70-
inline const double &operator[](size_t index) const override {
71-
return matrix_[index];
72-
}
73-
74-
size_t getDimension() const override {
75-
return TDimension;
76-
}
77-
78-
size_t getSize() const override {
79-
return SIZE;
80-
}
81-
82-
bool isSingular() const override {
83-
return determinant() == 0;
84-
}
85-
86-
bool normalize() override {
87-
const auto last = matrix_[SIZE - 1];
88-
if (last == 0) {
89-
return false;
90-
}
91-
if (last == 1) {
92-
return true;
93-
}
94-
95-
for (size_t i = 0; i < SIZE; ++i) {
96-
matrix_[i] /= last;
97-
}
98-
return true;
99-
}
100-
101-
void transpose() override {
102-
for (size_t i = 0; i < TDimension; ++i) {
103-
for (size_t j = i + 1; j < TDimension; ++j) {
104-
std::swap(matrix_[i * TDimension + j], matrix_[j * TDimension + i]);
105-
}
106-
}
107-
}
108-
109-
std::string toString() const override {
110-
std::string result = "[";
111-
for (size_t i = 0; i < SIZE; ++i) {
112-
result += std::to_string(matrix_[i]);
113-
if (i < SIZE - 1) {
114-
result += ", ";
115-
}
116-
}
117-
result += "]";
118-
return result;
119-
}
120-
121-
folly::dynamic toDynamic() const override {
122-
folly::dynamic result = folly::dynamic::array;
123-
for (size_t i = 0; i < SIZE; ++i) {
124-
result.push_back(matrix_[i]);
125-
}
126-
return result;
127-
}
128-
129-
inline TDerived operator*(const TDerived &rhs) const {
130-
return TDerived(multiply(rhs));
131-
}
132-
133-
inline TDerived &operator*=(const TDerived &rhs) {
134-
matrix_ = multiply(rhs);
135-
return static_cast<TDerived &>(*this);
136-
}
137-
138-
TransformMatrixBase &operator=(const TransformMatrixBase &other) {
139-
if (this != &other) {
140-
// Note: dimension_ is const, so we can't reassign it
141-
// But since all instances have the same dimension, this is fine
142-
matrix_ = other.matrix_;
143-
}
144-
return *this;
145-
}
146-
147-
TransformMatrixBase &operator=(TransformMatrixBase &&other) noexcept {
148-
if (this != &other) {
149-
matrix_ = std::move(other.matrix_);
150-
}
151-
return *this;
152-
}
41+
TransformMatrixBase();
42+
explicit TransformMatrixBase(MatrixArray matrix);
43+
TransformMatrixBase(const TransformMatrixBase &other);
44+
TransformMatrixBase(TransformMatrixBase &&other) noexcept;
45+
46+
bool operator==(const TDerived &other) const;
47+
bool operator==(const TransformMatrix &other) const override;
48+
double &operator[](size_t index) override;
49+
const double &operator[](size_t index) const override;
50+
51+
size_t getDimension() const override;
52+
size_t getSize() const override;
53+
bool isSingular() const override;
54+
bool normalize() override;
55+
void transpose() override;
56+
std::string toString() const override;
57+
folly::dynamic toDynamic() const override;
58+
59+
TDerived operator*(const TDerived &rhs) const;
60+
TDerived &operator*=(const TDerived &rhs);
61+
62+
TransformMatrixBase &operator=(const TransformMatrixBase &other);
63+
TransformMatrixBase &operator=(TransformMatrixBase &&other) noexcept;
15364

15465
protected:
15566
std::array<double, SIZE> matrix_;
15667

157-
MatrixArray multiply(const TDerived &rhs) const {
158-
MatrixArray result{};
159-
160-
for (size_t i = 0; i < TDimension; ++i) {
161-
for (size_t k = 0; k < TDimension; ++k) {
162-
double temp = matrix_[i * TDimension + k];
163-
for (size_t j = 0; j < TDimension; ++j) {
164-
result[i * TDimension + j] += temp * rhs[k * TDimension + j];
165-
}
166-
}
167-
}
168-
169-
return result;
170-
}
68+
MatrixArray multiply(const TDerived &rhs) const;
17169
};
17270

17371
} // namespace reanimated::css

0 commit comments

Comments
 (0)