1/*
2 * Copyright 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#pragma once
18
19#include <math/TMatHelpers.h>
20#include <math/vec2.h>
21#include <stdint.h>
22#include <sys/types.h>
23
24#define PURE __attribute__((pure))
25
26#if __cplusplus >= 201402L
27#define CONSTEXPR constexpr
28#else
29#define CONSTEXPR
30#endif
31
32namespace android {
33// -------------------------------------------------------------------------------------
34namespace details {
35
36/**
37 * A 2x2 column-major matrix class.
38 *
39 * Conceptually a 2x2 matrix is a an array of 2 column vec2:
40 *
41 * mat2 m =
42 *      \f$
43 *      \left(
44 *      \begin{array}{cc}
45 *      m[0] & m[1] \\
46 *      \end{array}
47 *      \right)
48 *      \f$
49 *      =
50 *      \f$
51 *      \left(
52 *      \begin{array}{cc}
53 *      m[0][0] & m[1][0] \\
54 *      m[0][1] & m[1][1] \\
55 *      \end{array}
56 *      \right)
57 *      \f$
58 *      =
59 *      \f$
60 *      \left(
61 *      \begin{array}{cc}
62 *      m(0,0) & m(0,1) \\
63 *      m(1,0) & m(1,1) \\
64 *      \end{array}
65 *      \right)
66 *      \f$
67 *
68 * m[n] is the \f$ n^{th} \f$ column of the matrix and is a vec2.
69 *
70 */
71template <typename T>
72class TMat22 :  public TVecUnaryOperators<TMat22, T>,
73                public TVecComparisonOperators<TMat22, T>,
74                public TVecAddOperators<TMat22, T>,
75                public TMatProductOperators<TMat22, T>,
76                public TMatSquareFunctions<TMat22, T>,
77                public TMatHelpers<TMat22, T>,
78                public TMatDebug<TMat22, T> {
79public:
80    enum no_init { NO_INIT };
81    typedef T value_type;
82    typedef T& reference;
83    typedef T const& const_reference;
84    typedef size_t size_type;
85    typedef TVec2<T> col_type;
86    typedef TVec2<T> row_type;
87
88    static constexpr size_t COL_SIZE = col_type::SIZE;  // size of a column (i.e.: number of rows)
89    static constexpr size_t ROW_SIZE = row_type::SIZE;  // size of a row (i.e.: number of columns)
90    static constexpr size_t NUM_ROWS = COL_SIZE;
91    static constexpr size_t NUM_COLS = ROW_SIZE;
92
93private:
94    /*
95     *  <--  N columns  -->
96     *
97     *  a[0][0] a[1][0] a[2][0] ... a[N][0]    ^
98     *  a[0][1] a[1][1] a[2][1] ... a[N][1]    |
99     *  a[0][2] a[1][2] a[2][2] ... a[N][2]  M rows
100     *  ...                                    |
101     *  a[0][M] a[1][M] a[2][M] ... a[N][M]    v
102     *
103     *  COL_SIZE = M
104     *  ROW_SIZE = N
105     *  m[0] = [ a[0][0] a[0][1] a[0][2] ... a[0][M] ]
106     */
107
108    col_type m_value[NUM_COLS];
109
110public:
111    // array access
112    inline constexpr col_type const& operator[](size_t column) const {
113#if __cplusplus >= 201402L
114        // only possible in C++0x14 with constexpr
115        assert(column < NUM_COLS);
116#endif
117        return m_value[column];
118    }
119
120    inline col_type& operator[](size_t column) {
121        assert(column < NUM_COLS);
122        return m_value[column];
123    }
124
125    // -----------------------------------------------------------------------
126    // we want the compiler generated versions for these...
127    TMat22(const TMat22&) = default;
128    ~TMat22() = default;
129    TMat22& operator = (const TMat22&) = default;
130
131    /**
132     *  constructors
133     */
134
135    /**
136     * leaves object uninitialized. use with caution.
137     */
138    explicit constexpr TMat22(no_init)
139            : m_value{ col_type(col_type::NO_INIT),
140                       col_type(col_type::NO_INIT) } {}
141
142
143    /**
144     * initialize to identity.
145     *
146     *      \f$
147     *      \left(
148     *      \begin{array}{cc}
149     *      1 & 0 \\
150     *      0 & 1 \\
151     *      \end{array}
152     *      \right)
153     *      \f$
154     */
155    CONSTEXPR TMat22();
156
157    /**
158     * initialize to Identity*scalar.
159     *
160     *      \f$
161     *      \left(
162     *      \begin{array}{cc}
163     *      v & 0 \\
164     *      0 & v \\
165     *      \end{array}
166     *      \right)
167     *      \f$
168     */
169    template<typename U>
170    explicit CONSTEXPR TMat22(U v);
171
172    /**
173     * sets the diagonal to a vector.
174     *
175     *      \f$
176     *      \left(
177     *      \begin{array}{cc}
178     *      v[0] & 0 \\
179     *      0 & v[1] \\
180     *      \end{array}
181     *      \right)
182     *      \f$
183     */
184    template <typename U>
185    explicit CONSTEXPR TMat22(const TVec2<U>& v);
186
187    /**
188     * construct from another matrix of the same size
189     */
190    template <typename U>
191    explicit CONSTEXPR TMat22(const TMat22<U>& rhs);
192
193    /**
194     * construct from 2 column vectors.
195     *
196     *      \f$
197     *      \left(
198     *      \begin{array}{cc}
199     *      v0 & v1 \\
200     *      \end{array}
201     *      \right)
202     *      \f$
203     */
204    template <typename A, typename B>
205    CONSTEXPR TMat22(const TVec2<A>& v0, const TVec2<B>& v1);
206
207    /** construct from 4 elements in column-major form.
208     *
209     *      \f$
210     *      \left(
211     *      \begin{array}{cc}
212     *      m[0][0] & m[1][0] \\
213     *      m[0][1] & m[1][1] \\
214     *      \end{array}
215     *      \right)
216     *      \f$
217     */
218    template <
219        typename A, typename B,
220        typename C, typename D>
221    CONSTEXPR TMat22(A m00, B m01, C m10, D m11);
222
223    /**
224     * construct from a C array in column major form.
225     */
226    template <typename U>
227    explicit CONSTEXPR TMat22(U const* rawArray);
228
229    /**
230     * Rotate by radians in the 2D plane
231     */
232    static CONSTEXPR TMat22<T> rotate(T radian) {
233        TMat22<T> r(TMat22<T>::NO_INIT);
234        T c = std::cos(radian);
235        T s = std::sin(radian);
236        r[0][0] = c;   r[1][1] = c;
237        r[0][1] = s;   r[1][0] = -s;
238        return r;
239    }
240};
241
242// ----------------------------------------------------------------------------------------
243// Constructors
244// ----------------------------------------------------------------------------------------
245
246// Since the matrix code could become pretty big quickly, we don't inline most
247// operations.
248
249template <typename T>
250CONSTEXPR TMat22<T>::TMat22() {
251    m_value[0] = col_type(1, 0);
252    m_value[1] = col_type(0, 1);
253}
254
255template <typename T>
256template <typename U>
257CONSTEXPR TMat22<T>::TMat22(U v) {
258    m_value[0] = col_type(v, 0);
259    m_value[1] = col_type(0, v);
260}
261
262template<typename T>
263template<typename U>
264CONSTEXPR TMat22<T>::TMat22(const TVec2<U>& v) {
265    m_value[0] = col_type(v.x, 0);
266    m_value[1] = col_type(0, v.y);
267}
268
269// construct from 4 scalars. Note that the arrangement
270// of values in the constructor is the transpose of the matrix
271// notation.
272template<typename T>
273template <
274    typename A, typename B,
275    typename C, typename D>
276CONSTEXPR TMat22<T>::TMat22( A m00, B m01, C m10, D m11) {
277    m_value[0] = col_type(m00, m01);
278    m_value[1] = col_type(m10, m11);
279}
280
281template <typename T>
282template <typename U>
283CONSTEXPR TMat22<T>::TMat22(const TMat22<U>& rhs) {
284    for (size_t col = 0; col < NUM_COLS; ++col) {
285        m_value[col] = col_type(rhs[col]);
286    }
287}
288
289// Construct from 2 column vectors.
290template <typename T>
291template <typename A, typename B>
292CONSTEXPR TMat22<T>::TMat22(const TVec2<A>& v0, const TVec2<B>& v1) {
293    m_value[0] = v0;
294    m_value[1] = v1;
295}
296
297// Construct from raw array, in column-major form.
298template <typename T>
299template <typename U>
300CONSTEXPR TMat22<T>::TMat22(U const* rawArray) {
301    for (size_t col = 0; col < NUM_COLS; ++col) {
302        for (size_t row = 0; row < NUM_ROWS; ++row) {
303            m_value[col][row] = *rawArray++;
304        }
305    }
306}
307
308// ----------------------------------------------------------------------------------------
309// Arithmetic operators outside of class
310// ----------------------------------------------------------------------------------------
311
312/* We use non-friend functions here to prevent the compiler from using
313 * implicit conversions, for instance of a scalar to a vector. The result would
314 * not be what the caller expects.
315 *
316 * Also note that the order of the arguments in the inner loop is important since
317 * it determines the output type (only relevant when T != U).
318 */
319
320// matrix * column-vector, result is a vector of the same type than the input vector
321template <typename T, typename U>
322CONSTEXPR typename TMat22<U>::col_type PURE operator *(const TMat22<T>& lhs, const TVec2<U>& rhs) {
323    // Result is initialized to zero.
324    typename TMat22<U>::col_type result;
325    for (size_t col = 0; col < TMat22<T>::NUM_COLS; ++col) {
326        result += lhs[col] * rhs[col];
327    }
328    return result;
329}
330
331// row-vector * matrix, result is a vector of the same type than the input vector
332template <typename T, typename U>
333CONSTEXPR typename TMat22<U>::row_type PURE operator *(const TVec2<U>& lhs, const TMat22<T>& rhs) {
334    typename TMat22<U>::row_type result(TMat22<U>::row_type::NO_INIT);
335    for (size_t col = 0; col < TMat22<T>::NUM_COLS; ++col) {
336        result[col] = dot(lhs, rhs[col]);
337    }
338    return result;
339}
340
341// matrix * scalar, result is a matrix of the same type than the input matrix
342template<typename T, typename U>
343constexpr typename std::enable_if<std::is_arithmetic<U>::value, TMat22<T>>::type PURE
344operator*(TMat22<T> lhs, U rhs) {
345    return lhs *= rhs;
346}
347
348// scalar * matrix, result is a matrix of the same type than the input matrix
349template<typename T, typename U>
350constexpr typename std::enable_if<std::is_arithmetic<U>::value, TMat22<T>>::type PURE
351operator*(U lhs, const TMat22<T>& rhs) {
352    return rhs * lhs;
353}
354
355// ----------------------------------------------------------------------------------------
356
357/* FIXME: this should go into TMatSquareFunctions<> but for some reason
358 * BASE<T>::col_type is not accessible from there (???)
359 */
360template<typename T>
361CONSTEXPR typename TMat22<T>::col_type PURE diag(const TMat22<T>& m) {
362    return matrix::diag(m);
363}
364
365}  // namespace details
366
367// ----------------------------------------------------------------------------------------
368
369typedef details::TMat22<double> mat2d;
370typedef details::TMat22<float> mat2;
371typedef details::TMat22<float> mat2f;
372
373// ----------------------------------------------------------------------------------------
374}  // namespace android
375
376#undef PURE
377#undef CONSTEXPR
378