1/*
2 * Copyright (C) 2011 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#ifndef ANDROID_VEC_H
18#define ANDROID_VEC_H
19
20#include <math.h>
21
22#include <stdint.h>
23#include <stddef.h>
24
25#include "traits.h"
26
27// -----------------------------------------------------------------------
28
29#define PURE __attribute__((pure))
30
31namespace android {
32
33// -----------------------------------------------------------------------
34// non-inline helpers
35
36template <typename TYPE, size_t SIZE>
37class vec;
38
39template <typename TYPE, size_t SIZE>
40struct vbase;
41
42namespace helpers {
43
44template <typename T> inline T min(T a, T b) { return a<b ? a : b; }
45template <typename T> inline T max(T a, T b) { return a>b ? a : b; }
46
47template < template<typename T, size_t S> class VEC,
48    typename TYPE, size_t SIZE, size_t S>
49vec<TYPE, SIZE>& doAssign(
50        vec<TYPE, SIZE>& lhs, const VEC<TYPE, S>& rhs) {
51    const size_t minSize = min(SIZE, S);
52    const size_t maxSize = max(SIZE, S);
53    for (size_t i=0 ; i<minSize ; i++)
54        lhs[i] = rhs[i];
55    for (size_t i=minSize ; i<maxSize ; i++)
56        lhs[i] = 0;
57    return lhs;
58}
59
60
61template <
62    template<typename T, size_t S> class VLHS,
63    template<typename T, size_t S> class VRHS,
64    typename TYPE,
65    size_t SIZE
66>
67VLHS<TYPE, SIZE> PURE doAdd(
68        const VLHS<TYPE, SIZE>& lhs,
69        const VRHS<TYPE, SIZE>& rhs) {
70    VLHS<TYPE, SIZE> r;
71    for (size_t i=0 ; i<SIZE ; i++)
72        r[i] = lhs[i] + rhs[i];
73    return r;
74}
75
76template <
77    template<typename T, size_t S> class VLHS,
78    template<typename T, size_t S> class VRHS,
79    typename TYPE,
80    size_t SIZE
81>
82VLHS<TYPE, SIZE> PURE doSub(
83        const VLHS<TYPE, SIZE>& lhs,
84        const VRHS<TYPE, SIZE>& rhs) {
85    VLHS<TYPE, SIZE> r;
86    for (size_t i=0 ; i<SIZE ; i++)
87        r[i] = lhs[i] - rhs[i];
88    return r;
89}
90
91template <
92    template<typename T, size_t S> class VEC,
93    typename TYPE,
94    size_t SIZE
95>
96VEC<TYPE, SIZE> PURE doMulScalar(
97        const VEC<TYPE, SIZE>& lhs,
98        typename TypeTraits<TYPE>::ParameterType rhs) {
99    VEC<TYPE, SIZE> r;
100    for (size_t i=0 ; i<SIZE ; i++)
101        r[i] = lhs[i] * rhs;
102    return r;
103}
104
105template <
106    template<typename T, size_t S> class VEC,
107    typename TYPE,
108    size_t SIZE
109>
110VEC<TYPE, SIZE> PURE doScalarMul(
111        typename TypeTraits<TYPE>::ParameterType lhs,
112        const VEC<TYPE, SIZE>& rhs) {
113    VEC<TYPE, SIZE> r;
114    for (size_t i=0 ; i<SIZE ; i++)
115        r[i] = lhs * rhs[i];
116    return r;
117}
118
119}; // namespace helpers
120
121// -----------------------------------------------------------------------
122// Below we define the mathematical operators for vectors.
123// We use template template arguments so we can generically
124// handle the case where the right-hand-size and left-hand-side are
125// different vector types (but with same value_type and size).
126// This is needed for performance when using ".xy{z}" element access
127// on vec<>. Without this, an extra conversion to vec<> would be needed.
128//
129// example:
130//      vec4_t a;
131//      vec3_t b;
132//      vec3_t c = a.xyz + b;
133//
134//  "a.xyz + b" is a mixed-operation between a vbase<> and a vec<>, requiring
135//  a conversion of vbase<> to vec<>. The template gunk below avoids this,
136// by allowing the addition on these different vector types directly
137//
138
139template <
140    template<typename T, size_t S> class VLHS,
141    template<typename T, size_t S> class VRHS,
142    typename TYPE,
143    size_t SIZE
144>
145inline VLHS<TYPE, SIZE> PURE operator + (
146        const VLHS<TYPE, SIZE>& lhs,
147        const VRHS<TYPE, SIZE>& rhs) {
148    return helpers::doAdd(lhs, rhs);
149}
150
151template <
152    template<typename T, size_t S> class VLHS,
153    template<typename T, size_t S> class VRHS,
154    typename TYPE,
155    size_t SIZE
156>
157inline VLHS<TYPE, SIZE> PURE operator - (
158        const VLHS<TYPE, SIZE>& lhs,
159        const VRHS<TYPE, SIZE>& rhs) {
160    return helpers::doSub(lhs, rhs);
161}
162
163template <
164    template<typename T, size_t S> class VEC,
165    typename TYPE,
166    size_t SIZE
167>
168inline VEC<TYPE, SIZE> PURE operator * (
169        const VEC<TYPE, SIZE>& lhs,
170        typename TypeTraits<TYPE>::ParameterType rhs) {
171    return helpers::doMulScalar(lhs, rhs);
172}
173
174template <
175    template<typename T, size_t S> class VEC,
176    typename TYPE,
177    size_t SIZE
178>
179inline VEC<TYPE, SIZE> PURE operator * (
180        typename TypeTraits<TYPE>::ParameterType lhs,
181        const VEC<TYPE, SIZE>& rhs) {
182    return helpers::doScalarMul(lhs, rhs);
183}
184
185
186template <
187    template<typename T, size_t S> class VLHS,
188    template<typename T, size_t S> class VRHS,
189    typename TYPE,
190    size_t SIZE
191>
192TYPE PURE dot_product(
193        const VLHS<TYPE, SIZE>& lhs,
194        const VRHS<TYPE, SIZE>& rhs) {
195    TYPE r(0);
196    for (size_t i=0 ; i<SIZE ; i++)
197        r += lhs[i] * rhs[i];
198    return r;
199}
200
201template <
202    template<typename T, size_t S> class V,
203    typename TYPE,
204    size_t SIZE
205>
206TYPE PURE length(const V<TYPE, SIZE>& v) {
207    return sqrt(dot_product(v, v));
208}
209
210template <
211    template<typename T, size_t S> class V,
212    typename TYPE,
213    size_t SIZE
214>
215TYPE PURE length_squared(const V<TYPE, SIZE>& v) {
216    return dot_product(v, v);
217}
218
219template <
220    template<typename T, size_t S> class V,
221    typename TYPE,
222    size_t SIZE
223>
224V<TYPE, SIZE> PURE normalize(const V<TYPE, SIZE>& v) {
225    return v * (1/length(v));
226}
227
228template <
229    template<typename T, size_t S> class VLHS,
230    template<typename T, size_t S> class VRHS,
231    typename TYPE
232>
233VLHS<TYPE, 3> PURE cross_product(
234        const VLHS<TYPE, 3>& u,
235        const VRHS<TYPE, 3>& v) {
236    VLHS<TYPE, 3> r;
237    r.x = u.y*v.z - u.z*v.y;
238    r.y = u.z*v.x - u.x*v.z;
239    r.z = u.x*v.y - u.y*v.x;
240    return r;
241}
242
243
244template <typename TYPE, size_t SIZE>
245vec<TYPE, SIZE> PURE operator - (const vec<TYPE, SIZE>& lhs) {
246    vec<TYPE, SIZE> r;
247    for (size_t i=0 ; i<SIZE ; i++)
248        r[i] = -lhs[i];
249    return r;
250}
251
252// -----------------------------------------------------------------------
253
254// This our basic vector type, it just implements the data storage
255// and accessors.
256
257template <typename TYPE, size_t SIZE>
258struct vbase {
259    TYPE v[SIZE];
260    inline const TYPE& operator[](size_t i) const { return v[i]; }
261    inline       TYPE& operator[](size_t i)       { return v[i]; }
262};
263template<> struct vbase<float, 2> {
264    union {
265        float v[2];
266        struct { float x, y; };
267        struct { float s, t; };
268    };
269    inline const float& operator[](size_t i) const { return v[i]; }
270    inline       float& operator[](size_t i)       { return v[i]; }
271};
272template<> struct vbase<float, 3> {
273    union {
274        float v[3];
275        struct { float x, y, z; };
276        struct { float s, t, r; };
277        vbase<float, 2> xy;
278        vbase<float, 2> st;
279    };
280    inline const float& operator[](size_t i) const { return v[i]; }
281    inline       float& operator[](size_t i)       { return v[i]; }
282};
283template<> struct vbase<float, 4> {
284    union {
285        float v[4];
286        struct { float x, y, z, w; };
287        struct { float s, t, r, q; };
288        vbase<float, 3> xyz;
289        vbase<float, 3> str;
290        vbase<float, 2> xy;
291        vbase<float, 2> st;
292    };
293    inline const float& operator[](size_t i) const { return v[i]; }
294    inline       float& operator[](size_t i)       { return v[i]; }
295};
296
297// -----------------------------------------------------------------------
298
299template <typename TYPE, size_t SIZE>
300class vec : public vbase<TYPE, SIZE>
301{
302    typedef typename TypeTraits<TYPE>::ParameterType pTYPE;
303    typedef vbase<TYPE, SIZE> base;
304
305public:
306    // STL-like interface.
307    typedef TYPE value_type;
308    typedef TYPE& reference;
309    typedef TYPE const& const_reference;
310    typedef size_t size_type;
311
312    typedef TYPE* iterator;
313    typedef TYPE const* const_iterator;
314    iterator begin() { return base::v; }
315    iterator end() { return base::v + SIZE; }
316    const_iterator begin() const { return base::v; }
317    const_iterator end() const { return base::v + SIZE; }
318    size_type size() const { return SIZE; }
319
320    // -----------------------------------------------------------------------
321    // default constructors
322
323    vec() { }
324    vec(const vec& rhs)  : base(rhs) { }
325    vec(const base& rhs) : base(rhs) { }  // NOLINT(implicit)
326
327    // -----------------------------------------------------------------------
328    // conversion constructors
329
330    vec(pTYPE rhs) {  // NOLINT(implicit)
331        for (size_t i=0 ; i<SIZE ; i++)
332            base::operator[](i) = rhs;
333    }
334
335    template < template<typename T, size_t S> class VEC, size_t S>
336    explicit vec(const VEC<TYPE, S>& rhs) {
337        helpers::doAssign(*this, rhs);
338    }
339
340    explicit vec(TYPE const* array) {
341        for (size_t i=0 ; i<SIZE ; i++)
342            base::operator[](i) = array[i];
343    }
344
345    // -----------------------------------------------------------------------
346    // Assignment
347
348    vec& operator = (const vec& rhs) {
349        base::operator=(rhs);
350        return *this;
351    }
352
353    vec& operator = (const base& rhs) {
354        base::operator=(rhs);
355        return *this;
356    }
357
358    vec& operator = (pTYPE rhs) {
359        for (size_t i=0 ; i<SIZE ; i++)
360            base::operator[](i) = rhs;
361        return *this;
362    }
363
364    template < template<typename T, size_t S> class VEC, size_t S>
365    vec& operator = (const VEC<TYPE, S>& rhs) {
366        return helpers::doAssign(*this, rhs);
367    }
368
369    // -----------------------------------------------------------------------
370    // operation-assignment
371
372    vec& operator += (const vec& rhs);
373    vec& operator -= (const vec& rhs);
374    vec& operator *= (pTYPE rhs);
375
376    // -----------------------------------------------------------------------
377    // non-member function declaration and definition
378    // NOTE: we declare the non-member function as friend inside the class
379    // so that they are known to the compiler when the class is instantiated.
380    // This helps the compiler doing template argument deduction when the
381    // passed types are not identical. Essentially this helps with
382    // type conversion so that you can multiply a vec<float> by an scalar int
383    // (for instance).
384
385    friend inline vec PURE operator + (const vec& lhs, const vec& rhs) {
386        return helpers::doAdd(lhs, rhs);
387    }
388    friend inline vec PURE operator - (const vec& lhs, const vec& rhs) {
389        return helpers::doSub(lhs, rhs);
390    }
391    friend inline vec PURE operator * (const vec& lhs, pTYPE v) {
392        return helpers::doMulScalar(lhs, v);
393    }
394    friend inline vec PURE operator * (pTYPE v, const vec& rhs) {
395        return helpers::doScalarMul(v, rhs);
396    }
397    friend inline TYPE PURE dot_product(const vec& lhs, const vec& rhs) {
398        return android::dot_product(lhs, rhs);
399    }
400};
401
402// -----------------------------------------------------------------------
403
404template <typename TYPE, size_t SIZE>
405vec<TYPE, SIZE>& vec<TYPE, SIZE>::operator += (const vec<TYPE, SIZE>& rhs) {
406    vec<TYPE, SIZE>& lhs(*this);
407    for (size_t i=0 ; i<SIZE ; i++)
408        lhs[i] += rhs[i];
409    return lhs;
410}
411
412template <typename TYPE, size_t SIZE>
413vec<TYPE, SIZE>& vec<TYPE, SIZE>::operator -= (const vec<TYPE, SIZE>& rhs) {
414    vec<TYPE, SIZE>& lhs(*this);
415    for (size_t i=0 ; i<SIZE ; i++)
416        lhs[i] -= rhs[i];
417    return lhs;
418}
419
420template <typename TYPE, size_t SIZE>
421vec<TYPE, SIZE>& vec<TYPE, SIZE>::operator *= (vec<TYPE, SIZE>::pTYPE rhs) {
422    vec<TYPE, SIZE>& lhs(*this);
423    for (size_t i=0 ; i<SIZE ; i++)
424        lhs[i] *= rhs;
425    return lhs;
426}
427
428// -----------------------------------------------------------------------
429
430typedef vec<float, 2> vec2_t;
431typedef vec<float, 3> vec3_t;
432typedef vec<float, 4> vec4_t;
433
434// -----------------------------------------------------------------------
435
436}; // namespace android
437
438#endif /* ANDROID_VEC_H */
439