mirror of
https://github.com/dragonpilot/dragonpilot.git
synced 2026-03-02 20:43:53 +08:00
openpilot v0.6 release
This commit is contained in:
Vehicle Researcher
381
phonelibs/android_frameworks_native/include/ui/TVecHelpers.h
Normal file
381
phonelibs/android_frameworks_native/include/ui/TVecHelpers.h
Normal file
@@ -0,0 +1,381 @@
|
||||
/*
|
||||
* 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 */
|
||||
Reference in New Issue
Block a user