replicant-frameworks_native/include/ui/TVecHelpers.h

382 lines
12 KiB
C
Raw Normal View History

/*
* Copyright 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef TVEC_IMPLEMENTATION
#error "Don't include TVecHelpers.h directly. use ui/vec*.h instead"
#else
#undef TVEC_IMPLEMENTATION
#endif
#ifndef UI_TVEC_HELPERS_H
#define UI_TVEC_HELPERS_H
#include <stdint.h>
#include <sys/types.h>
#define PURE __attribute__((pure))
namespace android {
// -------------------------------------------------------------------------------------
/*
* No user serviceable parts here.
*
* Don't use this file directly, instead include ui/vec{2|3|4}.h
*/
/*
* This class casts itself into anything and assign itself from anything!
* Use with caution!
*/
template <typename TYPE>
struct Impersonator {
Impersonator& operator = (const TYPE& rhs) {
reinterpret_cast<TYPE&>(*this) = rhs;
return *this;
}
operator TYPE& () {
return reinterpret_cast<TYPE&>(*this);
}
operator TYPE const& () const {
return reinterpret_cast<TYPE const&>(*this);
}
};
/*
* TVec{Add|Product}Operators implements basic arithmetic and basic compound assignments
* operators on a vector of type BASE<T>.
*
* BASE only needs to implement operator[] and size().
* By simply inheriting from TVec{Add|Product}Operators<BASE, T> BASE will automatically
* get all the functionality here.
*/
template <template<typename T> class BASE, typename T>
class TVecAddOperators {
public:
/* compound assignment from a another vector of the same size but different
* element type.
*/
template <typename OTHER>
BASE<T>& operator += (const BASE<OTHER>& v) {
BASE<T>& rhs = static_cast<BASE<T>&>(*this);
for (size_t i=0 ; i<BASE<T>::size() ; i++) {
rhs[i] += v[i];
}
return rhs;
}
template <typename OTHER>
BASE<T>& operator -= (const BASE<OTHER>& v) {
BASE<T>& rhs = static_cast<BASE<T>&>(*this);
for (size_t i=0 ; i<BASE<T>::size() ; i++) {
rhs[i] -= v[i];
}
return rhs;
}
/* compound assignment from a another vector of the same type.
* These operators can be used for implicit conversion and handle operations
* like "vector *= scalar" by letting the compiler implicitly convert a scalar
* to a vector (assuming the BASE<T> allows it).
*/
BASE<T>& operator += (const BASE<T>& v) {
BASE<T>& rhs = static_cast<BASE<T>&>(*this);
for (size_t i=0 ; i<BASE<T>::size() ; i++) {
rhs[i] += v[i];
}
return rhs;
}
BASE<T>& operator -= (const BASE<T>& v) {
BASE<T>& rhs = static_cast<BASE<T>&>(*this);
for (size_t i=0 ; i<BASE<T>::size() ; i++) {
rhs[i] -= v[i];
}
return rhs;
}
/*
* NOTE: the functions below ARE NOT member methods. They are friend functions
* with they definition inlined with their declaration. This makes these
* template functions available to the compiler when (and only when) this class
* is instantiated, at which point they're only templated on the 2nd parameter
* (the first one, BASE<T> being known).
*/
/* The operators below handle operation between vectors of the same side
* but of a different element type.
*/
template<typename RT>
friend inline
BASE<T> PURE operator +(const BASE<T>& lv, const BASE<RT>& rv) {
return BASE<T>(lv) += rv;
}
template<typename RT>
friend inline
BASE<T> PURE operator -(const BASE<T>& lv, const BASE<RT>& rv) {
return BASE<T>(lv) -= rv;
}
/* The operators below (which are not templates once this class is instanced,
* i.e.: BASE<T> is known) can be used for implicit conversion on both sides.
* These handle operations like "vector * scalar" and "scalar * vector" by
* letting the compiler implicitly convert a scalar to a vector (assuming
* the BASE<T> allows it).
*/
friend inline
BASE<T> PURE operator +(const BASE<T>& lv, const BASE<T>& rv) {
return BASE<T>(lv) += rv;
}
friend inline
BASE<T> PURE operator -(const BASE<T>& lv, const BASE<T>& rv) {
return BASE<T>(lv) -= rv;
}
};
template <template<typename T> class BASE, typename T>
class TVecProductOperators {
public:
/* compound assignment from a another vector of the same size but different
* element type.
*/
template <typename OTHER>
BASE<T>& operator *= (const BASE<OTHER>& v) {
BASE<T>& rhs = static_cast<BASE<T>&>(*this);
for (size_t i=0 ; i<BASE<T>::size() ; i++) {
rhs[i] *= v[i];
}
return rhs;
}
template <typename OTHER>
BASE<T>& operator /= (const BASE<OTHER>& v) {
BASE<T>& rhs = static_cast<BASE<T>&>(*this);
for (size_t i=0 ; i<BASE<T>::size() ; i++) {
rhs[i] /= v[i];
}
return rhs;
}
/* compound assignment from a another vector of the same type.
* These operators can be used for implicit conversion and handle operations
* like "vector *= scalar" by letting the compiler implicitly convert a scalar
* to a vector (assuming the BASE<T> allows it).
*/
BASE<T>& operator *= (const BASE<T>& v) {
BASE<T>& rhs = static_cast<BASE<T>&>(*this);
for (size_t i=0 ; i<BASE<T>::size() ; i++) {
rhs[i] *= v[i];
}
return rhs;
}
BASE<T>& operator /= (const BASE<T>& v) {
BASE<T>& rhs = static_cast<BASE<T>&>(*this);
for (size_t i=0 ; i<BASE<T>::size() ; i++) {
rhs[i] /= v[i];
}
return rhs;
}
/*
* NOTE: the functions below ARE NOT member methods. They are friend functions
* with they definition inlined with their declaration. This makes these
* template functions available to the compiler when (and only when) this class
* is instantiated, at which point they're only templated on the 2nd parameter
* (the first one, BASE<T> being known).
*/
/* The operators below handle operation between vectors of the same side
* but of a different element type.
*/
template<typename RT>
friend inline
BASE<T> PURE operator *(const BASE<T>& lv, const BASE<RT>& rv) {
return BASE<T>(lv) *= rv;
}
template<typename RT>
friend inline
BASE<T> PURE operator /(const BASE<T>& lv, const BASE<RT>& rv) {
return BASE<T>(lv) /= rv;
}
/* The operators below (which are not templates once this class is instanced,
* i.e.: BASE<T> is known) can be used for implicit conversion on both sides.
* These handle operations like "vector * scalar" and "scalar * vector" by
* letting the compiler implicitly convert a scalar to a vector (assuming
* the BASE<T> allows it).
*/
friend inline
BASE<T> PURE operator *(const BASE<T>& lv, const BASE<T>& rv) {
return BASE<T>(lv) *= rv;
}
friend inline
BASE<T> PURE operator /(const BASE<T>& lv, const BASE<T>& rv) {
return BASE<T>(lv) /= rv;
}
};
/*
* TVecUnaryOperators implements unary operators on a vector of type BASE<T>.
*
* BASE only needs to implement operator[] and size().
* By simply inheriting from TVecUnaryOperators<BASE, T> BASE will automatically
* get all the functionality here.
*
* These operators are implemented as friend functions of TVecUnaryOperators<BASE, T>
*/
template <template<typename T> class BASE, typename T>
class TVecUnaryOperators {
public:
BASE<T>& operator ++ () {
BASE<T>& rhs = static_cast<BASE<T>&>(*this);
for (size_t i=0 ; i<BASE<T>::size() ; i++) {
++rhs[i];
}
return rhs;
}
BASE<T>& operator -- () {
BASE<T>& rhs = static_cast<BASE<T>&>(*this);
for (size_t i=0 ; i<BASE<T>::size() ; i++) {
--rhs[i];
}
return rhs;
}
BASE<T> operator - () const {
BASE<T> r(BASE<T>::NO_INIT);
BASE<T> const& rv(static_cast<BASE<T> const&>(*this));
for (size_t i=0 ; i<BASE<T>::size() ; i++) {
r[i] = -rv[i];
}
return r;
}
};
/*
* TVecComparisonOperators implements relational/comparison operators
* on a vector of type BASE<T>.
*
* BASE only needs to implement operator[] and size().
* By simply inheriting from TVecComparisonOperators<BASE, T> BASE will automatically
* get all the functionality here.
*/
template <template<typename T> class BASE, typename T>
class TVecComparisonOperators {
public:
/*
* NOTE: the functions below ARE NOT member methods. They are friend functions
* with they definition inlined with their declaration. This makes these
* template functions available to the compiler when (and only when) this class
* is instantiated, at which point they're only templated on the 2nd parameter
* (the first one, BASE<T> being known).
*/
template<typename RT>
friend inline
bool PURE operator ==(const BASE<T>& lv, const BASE<RT>& rv) {
for (size_t i = 0; i < BASE<T>::size(); i++)
if (lv[i] != rv[i])
return false;
return true;
}
template<typename RT>
friend inline
bool PURE operator !=(const BASE<T>& lv, const BASE<RT>& rv) {
return !operator ==(lv, rv);
}
template<typename RT>
friend inline
bool PURE operator >(const BASE<T>& lv, const BASE<RT>& rv) {
for (size_t i = 0; i < BASE<T>::size(); i++)
if (lv[i] <= rv[i])
return false;
return true;
}
template<typename RT>
friend inline
bool PURE operator <=(const BASE<T>& lv, const BASE<RT>& rv) {
return !(lv > rv);
}
template<typename RT>
friend inline
bool PURE operator <(const BASE<T>& lv, const BASE<RT>& rv) {
for (size_t i = 0; i < BASE<T>::size(); i++)
if (lv[i] >= rv[i])
return false;
return true;
}
template<typename RT>
friend inline
bool PURE operator >=(const BASE<T>& lv, const BASE<RT>& rv) {
return !(lv < rv);
}
};
/*
* TVecFunctions implements functions on a vector of type BASE<T>.
*
* BASE only needs to implement operator[] and size().
* By simply inheriting from TVecFunctions<BASE, T> BASE will automatically
* get all the functionality here.
*/
template <template<typename T> class BASE, typename T>
class TVecFunctions {
public:
/*
* NOTE: the functions below ARE NOT member methods. They are friend functions
* with they definition inlined with their declaration. This makes these
* template functions available to the compiler when (and only when) this class
* is instantiated, at which point they're only templated on the 2nd parameter
* (the first one, BASE<T> being known).
*/
template<typename RT>
friend inline
T PURE dot(const BASE<T>& lv, const BASE<RT>& rv) {
T r(0);
for (size_t i = 0; i < BASE<T>::size(); i++)
r += lv[i]*rv[i];
return r;
}
friend inline
T PURE length(const BASE<T>& lv) {
return sqrt( dot(lv, lv) );
}
template<typename RT>
friend inline
T PURE distance(const BASE<T>& lv, const BASE<RT>& rv) {
return length(rv - lv);
}
friend inline
BASE<T> PURE normalize(const BASE<T>& lv) {
return lv * (1 / length(lv));
}
};
#undef PURE
// -------------------------------------------------------------------------------------
}; // namespace android
#endif /* UI_TVEC_HELPERS_H */