anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Vectorize and reformat

Browse Source
master
Christophe Riccio ago%!(EXTRA string=14 years)
parent bc15b98730
commit 86be6440e3
13 changed files with 2285 additions and 3369 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 738
      glm/gtx/bit.inl
  2. 17
      glm/gtx/closest_point.inl
  3. 579
      glm/gtx/color_cast.inl
  4. 51
      glm/gtx/color_space.inl
  5. 53
      glm/gtx/color_space_YCoCg.inl
  6. 125
      glm/gtx/compatibility.inl
  7. 35
      glm/gtx/component_wise.inl
  8. 771
      glm/gtx/constants.inl
  9. 193
      glm/gtx/epsilon.inl
  10. 161
      glm/gtx/euler_angles.inl
  11. 53
      glm/gtx/extend.inl
  12. 16
      glm/gtx/fast_exponential.hpp
  13. 266
      glm/gtx/fast_exponential.inl

738
glm/gtx/bit.inl
View File

File diff suppressed because it is too large Load Diff

17
glm/gtx/closest_point.inl
Unescape View File

@ -10,16 +10,16 @@
#ifndef glm_gtx_closest_point
#define glm_gtx_closest_point
namespace glm{
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> closestPointOnLine
(
namespace glm
{
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> closestPointOnLine
(
detail::tvec3<valType> const & point,
detail::tvec3<valType> const & a,
detail::tvec3<valType> const & b
)
{
)
{
valType LineLength = distance(a, b);
detail::tvec3<valType> Vector = point - a;
detail::tvec3<valType> LineDirection = (b - a) / LineLength;
@ -30,8 +30,7 @@ GLM_FUNC_QUALIFIER detail::tvec3<valType> closestPointOnLine
if(Distance <= valType(0)) return a;
if(Distance >= LineLength) return b;
return a + LineDirection * Distance;
}
}
}//namespace glm
#endif//glm_gtx_closest_point

579
glm/gtx/color_cast.inl
View File

File diff suppressed because it is too large Load Diff

51
glm/gtx/color_space.inl
Unescape View File

@ -7,11 +7,11 @@
// File : glm/gtx/color_space.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> rgbColor(const detail::tvec3<T>& hsvColor)
namespace glm
{
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> rgbColor(const detail::tvec3<T>& hsvColor)
{
detail::tvec3<T> hsv = hsvColor;
detail::tvec3<T> rgbColor;
@ -64,11 +64,11 @@ GLM_FUNC_QUALIFIER detail::tvec3<T> rgbColor(const detail::tvec3<T>& hsvColor)
}
return rgbColor;
}
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> hsvColor(const detail::tvec3<T>& rgbColor)
{
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> hsvColor(const detail::tvec3<T>& rgbColor)
{
detail::tvec3<T> hsv = rgbColor;
float Min = min(min(rgbColor.r, rgbColor.g), rgbColor.b);
float Max = max(max(rgbColor.r, rgbColor.g), rgbColor.b);
@ -104,11 +104,11 @@ GLM_FUNC_QUALIFIER detail::tvec3<T> hsvColor(const detail::tvec3<T>& rgbColor)
}
return hsv;
}
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> saturation(const T s)
{
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> saturation(const T s)
{
detail::tvec3<T> rgbw = detail::tvec3<T>(T(0.2126), T(0.7152), T(0.0722));
T col0 = (T(1) - s) * rgbw.r;
@ -126,25 +126,24 @@ GLM_FUNC_QUALIFIER detail::tmat4x4<T> saturation(const T s)
result[2][1] = col2;
result[2][2] = col2 + s;
return result;
}
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> saturation(const T s, const detail::tvec3<T>& color)
{
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> saturation(const T s, const detail::tvec3<T>& color)
{
return detail::tvec3<T>(saturation(s) * detail::tvec4<T>(color, T(0)));
}
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> saturation(const T s, const detail::tvec4<T>& color)
{
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> saturation(const T s, const detail::tvec4<T>& color)
{
return saturation(s) * color;
}
}
template <typename T>
GLM_FUNC_QUALIFIER T luminosity(const detail::tvec3<T>& color)
{
template <typename T>
GLM_FUNC_QUALIFIER T luminosity(const detail::tvec3<T>& color)
{
const detail::tvec3<T> tmp = detail::tvec3<T>(0.33, 0.59, 0.11);
return dot(color, tmp);
}
}
}//namespace glm

53
glm/gtx/color_space_YCoCg.inl
Unescape View File

@ -7,59 +7,58 @@
// File : glm/gtx/color_space_YCoCg.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> rgb2YCoCg
(
detail::tvec3<valType> const & rgbColor
)
namespace glm
{
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> rgb2YCoCg
(
detail::tvec3<valType> const & rgbColor
)
{
detail::tvec3<valType> result;
result.x/*Y */ = rgbColor.r / valType(4) + rgbColor.g / valType(2) + rgbColor.b / valType(4);
result.y/*Co*/ = rgbColor.r / valType(2) + rgbColor.g * valType(0) - rgbColor.b / valType(2);
result.z/*Cg*/ = - rgbColor.r / valType(4) + rgbColor.g / valType(2) - rgbColor.b / valType(4);
return result;
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> rgb2YCoCgR
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> rgb2YCoCgR
(
detail::tvec3<valType> const & rgbColor
)
{
)
{
detail::tvec3<valType> result;
result.x/*Y */ = rgbColor.g / valType(2) + (rgbColor.r + rgbColor.b) / valType(4);
result.y/*Co*/ = rgbColor.r - rgbColor.b;
result.z/*Cg*/ = rgbColor.g - (rgbColor.r + rgbColor.b) / valType(2);
return result;
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> YCoCg2rgb
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> YCoCg2rgb
(
detail::tvec3<valType> const & YCoCgColor
)
{
)
{
detail::tvec3<valType> result;
result.r = YCoCgColor.x + YCoCgColor.y - YCoCgColor.z;
result.g = YCoCgColor.x + YCoCgColor.z;
result.b = YCoCgColor.x - YCoCgColor.y - YCoCgColor.z;
return result;
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> YCoCgR2rgb
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> YCoCgR2rgb
(
detail::tvec3<valType> const & YCoCgRColor
)
{
)
{
detail::tvec3<valType> result;
valType tmp = YCoCgRColor.x - (YCoCgRColor.z / valType(2));
result.g = YCoCgRColor.z + tmp;
result.b = tmp - (YCoCgRColor.y / valType(2));
result.r = result.b + YCoCgRColor.y;
return result;
}
}
}//namespace glm

125
glm/gtx/compatibility.inl
Unescape View File

@ -7,131 +7,130 @@
// File : glm/gtx/compatibility.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
// isfinite
template <typename genType>
GLM_FUNC_QUALIFIER bool isfinite(
genType const & x)
namespace glm
{
#if(GLM_COMPILER & GLM_COMPILER_VC)
// isfinite
template <typename genType>
GLM_FUNC_QUALIFIER bool isfinite(
genType const & x)
{
#if(GLM_COMPILER & GLM_COMPILER_VC)
return _finite(x);
#else//(GLM_COMPILER & GLM_COMPILER_GCC)
#else//(GLM_COMPILER & GLM_COMPILER_GCC)
return std::isfinite(x) != 0;
#endif
}
#endif
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> isfinite(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> isfinite(
detail::tvec2<valType> const & x)
{
{
return detail::tvec2<bool>(
isfinite(x.x),
isfinite(x.y));
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> isfinite(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> isfinite(
detail::tvec3<valType> const & x)
{
{
return detail::tvec3<bool>(
isfinite(x.x),
isfinite(x.y),
isfinite(x.z));
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> isfinite(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> isfinite(
detail::tvec4<valType> const & x)
{
{
return detail::tvec4<bool>(
isfinite(x.x),
isfinite(x.y),
isfinite(x.z),
isfinite(x.w));
}
}
// isinf
template <typename genType>
GLM_FUNC_QUALIFIER bool isinf(
// isinf
template <typename genType>
GLM_FUNC_QUALIFIER bool isinf(
genType const & x)
{
#if(GLM_COMPILER & GLM_COMPILER_VC)
{
#if(GLM_COMPILER & GLM_COMPILER_VC)
return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF;
#else
#else
return std::isinf(x) != 0;
#endif
}
#endif
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> isinf(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> isinf(
detail::tvec2<valType> const & x)
{
{
return detail::tvec2<bool>(
isinf(x.x),
isinf(x.y));
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> isinf(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> isinf(
detail::tvec3<valType> const & x)
{
{
return detail::tvec3<bool>(
isinf(x.x),
isinf(x.y),
isinf(x.z));
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> isinf(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> isinf(
detail::tvec4<valType> const & x)
{
{
return detail::tvec4<bool>(
isinf(x.x),
isinf(x.y),
isinf(x.z),
isinf(x.w));
}
}
// isnan
template <typename genType>
GLM_FUNC_QUALIFIER bool isnan(genType const & x)
{
#if(GLM_COMPILER & GLM_COMPILER_VC)
// isnan
template <typename genType>
GLM_FUNC_QUALIFIER bool isnan(genType const & x)
{
#if(GLM_COMPILER & GLM_COMPILER_VC)
return _isnan(x);
#else
#else
return std::isnan(x) != 0;
#endif
}
#endif
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> isnan(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> isnan(
detail::tvec2<valType> const & x)
{
{
return detail::tvec2<bool>(
isnan(x.x),
isnan(x.y));
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> isnan(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> isnan(
detail::tvec3<valType> const & x)
{
{
return detail::tvec3<bool>(
isnan(x.x),
isnan(x.y),
isnan(x.z));
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> isnan(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> isnan(
detail::tvec4<valType> const & x)
{
{
return detail::tvec4<bool>(
isnan(x.x),
isnan(x.y),
isnan(x.z),
isnan(x.w));
}
}
}//namespace glm

35
glm/gtx/component_wise.inl
Unescape View File

@ -7,42 +7,41 @@
// File : gtx_component_wise.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
template <typename genType>
GLM_FUNC_QUALIFIER typename genType::value_type compAdd(genType const & v)
namespace glm
{
template <typename genType>
GLM_FUNC_QUALIFIER typename genType::value_type compAdd(genType const & v)
{
typename genType::size_type result = typename genType::value_type(0);
for(typename genType::size_type i = 0; i < genType::value_size(); ++i)
result += v[i];
return result;
}
}
template <typename genType>
GLM_FUNC_QUALIFIER typename genType::value_type compMul(genType const & v)
{
template <typename genType>
GLM_FUNC_QUALIFIER typename genType::value_type compMul(genType const & v)
{
typename genType::value_type result = typename genType::value_type(1);
for(typename genType::size_type i = 0; i < genType::value_size(); ++i)
result *= v[i];
return result;
}
}
template <typename genType>
GLM_FUNC_QUALIFIER typename genType::value_type compMin(genType const & v)
{
template <typename genType>
GLM_FUNC_QUALIFIER typename genType::value_type compMin(genType const & v)
{
typename genType::value_type result = typename genType::value_type(v[0]);
for(typename genType::size_type i = 1; i < genType::value_size(); ++i)
result = min(result, v[i]);
return result;
}
}
template <typename genType>
GLM_FUNC_QUALIFIER typename genType::value_type compMax(genType const & v)
{
template <typename genType>
GLM_FUNC_QUALIFIER typename genType::value_type compMax(genType const & v)
{
typename genType::value_type result = typename genType::value_type(v[0]);
for(typename genType::size_type i = 1; i < genType::value_size(); ++i)
result = max(result, v[i]);
return result;
}
}
}//namespace glm

771
glm/gtx/constants.inl
Unescape View File

@ -20,773 +20,8 @@
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
/// @ref gtc_half_float
/// @file glm/gtc/half_float.inl
/// @date 2009-04-29 / 2011-06-05
/// @ref gtx_constants
/// @file glm/gtx/constants.inl
/// @date 2011-10-14 / 2011-10-14
/// @author Christophe Riccio
///////////////////////////////////////////////////////////////////////////////////
#include "../core/_detail.hpp"
namespace glm{
template <typename genIType>
GLM_FUNC_QUALIFIER genIType mask
(
genIType const & count
)
{
return ((genIType(1) << (count)) - genIType(1));
}
template <typename valIType>
GLM_FUNC_QUALIFIER detail::tvec2<valIType> mask
(
detail::tvec2<valIType> const & count
)
{
return detail::tvec2<valIType>(
mask(count[0]),
mask(count[1]));
}
template <typename valIType>
GLM_FUNC_QUALIFIER detail::tvec3<valIType> mask
(
detail::tvec3<valIType> const & count
)
{
return detail::tvec3<valIType>(
mask(count[0]),
mask(count[1]),
mask(count[2]));
}
template <typename valIType>
GLM_FUNC_QUALIFIER detail::tvec4<valIType> mask
(
detail::tvec4<valIType> const & count
)
{
return detail::tvec4<valIType>(
mask(count[0]),
mask(count[1]),
mask(count[2]),
mask(count[3]));
}
// extractField
template <typename genIType>
GLM_FUNC_QUALIFIER genIType extractField
(
half const & value,
genIType const & first,
genIType const & count
)
{
assert(first + count < sizeof(half));
return (value._data() << first) >> ((sizeof(half) << 3) - count);
}
template <typename genIType>
GLM_FUNC_QUALIFIER genIType extractField
(
float const & value,
genIType const & first,
genIType const & count
)
{
assert(first + count < sizeof(float));
return (detail::uif32(value).i << first) >> ((sizeof(float) << 3) - count);
}
template <typename genIType>
GLM_FUNC_QUALIFIER genIType extractField
(
double const & value,
genIType const & first,
genIType const & count
)
{
assert(first + count < sizeof(double));
return (detail::uif64(value).i << first) >> ((sizeof(double) << genIType(3)) - count);
}
template <typename genIUType, typename sizeType>
GLM_FUNC_QUALIFIER genIUType extractField
(
genIUType const & Value,
sizeType const & First,
sizeType const & Count
)
{
sizeType GenSize = sizeof(genIUType) << 3;
assert(First + Count <= GenSize);
genIUType ShiftLeft = Count ? Value << (GenSize - (Count + First)) : 0;
genIUType ShiftBack = ShiftLeft >> genIUType(GenSize - Count);
return ShiftBack;
}
template <typename genIUType, typename sizeType>
GLM_FUNC_QUALIFIER detail::tvec2<genIUType> extractField
(
detail::tvec2<genIUType> const & value,
sizeType const & first,
sizeType const & count
)
{
return detail::tvec2<genIUType>(
extractField(value[0], first, count),
extractField(value[1], first, count));
}
template <typename genIUType, typename sizeType>
GLM_FUNC_QUALIFIER detail::tvec3<genIUType> extractField
(
detail::tvec3<genIUType> const & value,
sizeType const & first,
sizeType const & count
)
{
return detail::tvec3<genIUType>(
extractField(value[0], first, count),
extractField(value[1], first, count),
extractField(value[2], first, count));
}
template <typename genIUType, typename sizeType>
GLM_FUNC_QUALIFIER detail::tvec4<genIUType> extractField
(
detail::tvec4<genIUType> const & value,
sizeType const & first,
sizeType const & count
)
{
return detail::tvec4<genIUType>(
extractField(value[0], first, count),
extractField(value[1], first, count),
extractField(value[2], first, count),
extractField(value[3], first, count));
}
template <typename genIUType, typename sizeType>
GLM_FUNC_QUALIFIER detail::tvec2<genIUType> extractField
(
detail::tvec2<genIUType> const & value,
detail::tvec2<sizeType> const & first,
detail::tvec2<sizeType> const & count
)
{
return detail::tvec2<genIUType>(
extractField(value[0], first[0], count[0]),
extractField(value[1], first[1], count[1]));
}
template <typename genIUType, typename sizeType>
GLM_FUNC_QUALIFIER detail::tvec3<genIUType> extractField
(
detail::tvec3<genIUType> const & value,
detail::tvec3<sizeType> const & first,
detail::tvec3<sizeType> const & count
)
{
return detail::tvec3<genIUType>(
extractField(value[0], first[0], count[0]),
extractField(value[1], first[1], count[1]),
extractField(value[2], first[2], count[2]));
}
template <typename genIUType, typename sizeType>
GLM_FUNC_QUALIFIER detail::tvec4<genIUType> extractField
(
detail::tvec4<genIUType> const & value,
detail::tvec4<sizeType> const & first,
detail::tvec4<sizeType> const & count
)
{
return detail::tvec4<genIUType>(
extractField(value[0], first[0], count[0]),
extractField(value[1], first[1], count[1]),
extractField(value[2], first[2], count[2]),
extractField(value[3], first[3], count[3]));
}
template <typename genIUType, typename sizeType>
GLM_FUNC_QUALIFIER detail::tvec2<genIUType> extractField
(
genIUType const & value,
detail::tvec2<sizeType> const & first,
detail::tvec2<sizeType> const & count
)
{
return detail::tvec2<genIUType>(
extractField(value, first[0], count[0]),
extractField(value, first[1], count[1]));
}
template <typename genIUType, typename sizeType>
GLM_FUNC_QUALIFIER detail::tvec3<genIUType> extractField
(
genIUType const & value,
detail::tvec3<sizeType> const & first,
detail::tvec3<sizeType> const & count
)
{
return detail::tvec3<genIUType>(
extractField(value, first[0], count[0]),
extractField(value, first[1], count[1]),
extractField(value, first[2], count[2]));
}
template <typename genIUType, typename sizeType>
GLM_FUNC_QUALIFIER detail::tvec4<genIUType> extractField
(
genIUType const & value,
detail::tvec4<sizeType> const & first,
detail::tvec4<sizeType> const & count
)
{
return detail::tvec4<genIUType>(
extractField(value, first[0], count[0]),
extractField(value, first[1], count[1]),
extractField(value, first[2], count[2]),
extractField(value, first[3], count[3]));
}
// lowestBit
template <typename genType>
GLM_FUNC_QUALIFIER int lowestBit
(
genType const & Value
)
{
assert(Value != genType(0)); // not valid call
genType Bit;
for(Bit = genType(0); !(Value & (1 << Bit)); ++Bit){}
return Bit;
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<int> lowestBit
(
detail::tvec2<valType> const & value
)
{
return detail::tvec2<int>(
lowestBit(value[0]),
lowestBit(value[1]));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<int> lowestBit
(
detail::tvec3<valType> const & value
)
{
return detail::tvec3<int>(
lowestBit(value[0]),
lowestBit(value[1]),
lowestBit(value[2]));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<int> lowestBit
(
detail::tvec4<valType> const & value
)
{
return detail::tvec4<int>(
lowestBit(value[0]),
lowestBit(value[1]),
lowestBit(value[2]),
lowestBit(value[3]));
}
// highestBit
template <typename genType>
GLM_FUNC_QUALIFIER int highestBit
(
genType const & value
)
{
assert(value != genType(0)); // not valid call
genType bit = genType(-1);
for(genType tmp = value; tmp; tmp >>= 1, ++bit){}
return bit;
}
//template <>
//GLM_FUNC_QUALIFIER int highestBit<int>
//(
// int value
//)
//{
// int bit = -1;
// for(int tmp = value; tmp; tmp >>= 1, ++bit);
// return bit;
//}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<int> highestBit
(
detail::tvec2<valType> const & value
)
{
return detail::tvec2<int>(
highestBit(value[0]),
highestBit(value[1]));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<int> highestBit
(
detail::tvec3<valType> const & value
)
{
return detail::tvec3<int>(
highestBit(value[0]),
highestBit(value[1]),
highestBit(value[2]));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<int> highestBit
(
detail::tvec4<valType> const & value
)
{
return detail::tvec4<int>(
highestBit(value[0]),
highestBit(value[1]),
highestBit(value[2]),
highestBit(value[3]));
}
// highestBitValue
template <typename genType>
GLM_FUNC_QUALIFIER genType highestBitValue
(
genType const & value
)
{
genType tmp = value;
genType result = genType(0);
while(tmp)
{
result = (tmp & (~tmp + 1)); // grab lowest bit
tmp &= ~result; // clear lowest bit
}
return result;
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<int> highestBitValue
(
detail::tvec2<valType> const & value
)
{
return detail::tvec2<int>(
highestBitValue(value[0]),
highestBitValue(value[1]));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<int> highestBitValue
(
detail::tvec3<valType> const & value
)
{
return detail::tvec3<int>(
highestBitValue(value[0]),
highestBitValue(value[1]),
highestBitValue(value[2]));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<int> highestBitValue
(
detail::tvec4<valType> const & value
)
{
return detail::tvec4<int>(
highestBitValue(value[0]),
highestBitValue(value[1]),
highestBitValue(value[2]),
highestBitValue(value[3]));
}
// isPowerOfTwo
template <typename genType>
GLM_FUNC_QUALIFIER bool isPowerOfTwo(genType const & Value)
{
//detail::If<std::numeric_limits<genType>::is_signed>::apply(abs, Value);
//return !(Value & (Value - 1));
// For old complier?
genType Result = Value;
if(std::numeric_limits<genType>::is_signed)
Result = abs(Result);
return !(Result & (Result - 1));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> isPowerOfTwo
(
detail::tvec2<valType> const & value
)
{
return detail::tvec2<bool>(
isPowerOfTwo(value[0]),
isPowerOfTwo(value[1]));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> isPowerOfTwo
(
detail::tvec3<valType> const & value
)
{
return detail::tvec3<bool>(
isPowerOfTwo(value[0]),
isPowerOfTwo(value[1]),
isPowerOfTwo(value[2]));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> isPowerOfTwo
(
detail::tvec4<valType> const & value
)
{
return detail::tvec4<bool>(
isPowerOfTwo(value[0]),
isPowerOfTwo(value[1]),
isPowerOfTwo(value[2]),
isPowerOfTwo(value[3]));
}
// powerOfTwoAbove
template <typename genType>
GLM_FUNC_QUALIFIER genType powerOfTwoAbove(genType const & value)
{
return isPowerOfTwo(value) ? value : highestBitValue(value) << 1;
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<valType> powerOfTwoAbove
(
detail::tvec2<valType> const & value
)
{
return detail::tvec2<valType>(
powerOfTwoAbove(value[0]),
powerOfTwoAbove(value[1]));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> powerOfTwoAbove
(
detail::tvec3<valType> const & value
)
{
return detail::tvec3<valType>(
powerOfTwoAbove(value[0]),
powerOfTwoAbove(value[1]),
powerOfTwoAbove(value[2]));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<valType> powerOfTwoAbove
(
detail::tvec4<valType> const & value
)
{
return detail::tvec4<valType>(
powerOfTwoAbove(value[0]),
powerOfTwoAbove(value[1]),
powerOfTwoAbove(value[2]),
powerOfTwoAbove(value[3]));
}
// powerOfTwoBelow
template <typename genType>
GLM_FUNC_QUALIFIER genType powerOfTwoBelow
(
genType const & value
)
{
return isPowerOfTwo(value) ? value : highestBitValue(value);
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<valType> powerOfTwoBelow
(
detail::tvec2<valType> const & value
)
{
return detail::tvec2<valType>(
powerOfTwoBelow(value[0]),
powerOfTwoBelow(value[1]));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> powerOfTwoBelow
(
detail::tvec3<valType> const & value
)
{
return detail::tvec3<valType>(
powerOfTwoBelow(value[0]),
powerOfTwoBelow(value[1]),
powerOfTwoBelow(value[2]));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<valType> powerOfTwoBelow
(
detail::tvec4<valType> const & value
)
{
return detail::tvec4<valType>(
powerOfTwoBelow(value[0]),
powerOfTwoBelow(value[1]),
powerOfTwoBelow(value[2]),
powerOfTwoBelow(value[3]));
}
// powerOfTwoNearest
template <typename genType>
GLM_FUNC_QUALIFIER genType powerOfTwoNearest
(
genType const & value
)
{
if(isPowerOfTwo(value))
return value;
genType prev = highestBitValue(value);
genType next = prev << 1;
return (next - value) < (value - prev) ? next : prev;
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<valType> powerOfTwoNearest
(
detail::tvec2<valType> const & value
)
{
return detail::tvec2<valType>(
powerOfTwoNearest(value[0]),
powerOfTwoNearest(value[1]));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> powerOfTwoNearest
(
detail::tvec3<valType> const & value
)
{
return detail::tvec3<valType>(
powerOfTwoNearest(value[0]),
powerOfTwoNearest(value[1]),
powerOfTwoNearest(value[2]));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<valType> powerOfTwoNearest
(
detail::tvec4<valType> const & value
)
{
return detail::tvec4<valType>(
powerOfTwoNearest(value[0]),
powerOfTwoNearest(value[1]),
powerOfTwoNearest(value[2]),
powerOfTwoNearest(value[3]));
}
template <typename genType>
GLM_FUNC_QUALIFIER genType bitRevert(genType const & In)
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRevert' only accept integer values");
genType Out = 0;
std::size_t BitSize = sizeof(genType) * 8;
for(std::size_t i = 0; i < BitSize; ++i)
if(In & (genType(1) << i))
Out |= genType(1) << (BitSize - 1 - i);
return Out;
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<valType> bitRevert
(
detail::tvec2<valType> const & Value
)
{
return detail::tvec2<valType>(
bitRevert(Value[0]),
bitRevert(Value[1]));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> bitRevert
(
detail::tvec3<valType> const & Value
)
{
return detail::tvec3<valType>(
bitRevert(Value[0]),
bitRevert(Value[1]),
bitRevert(Value[2]));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<valType> bitRevert
(
detail::tvec4<valType> const & Value
)
{
return detail::tvec4<valType>(
bitRevert(Value[0]),
bitRevert(Value[1]),
bitRevert(Value[2]),
bitRevert(Value[3]));
}
template <typename genType>
GLM_FUNC_QUALIFIER genType bitRotateRight(genType const & In, std::size_t Shift)
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRotateRight' only accept integer values");
std::size_t BitSize = sizeof(genType) * 8;
return (In << Shift) | (In >> (BitSize - Shift));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<valType> bitRotateRight
(
detail::tvec2<valType> const & Value,
std::size_t Shift
)
{
return detail::tvec2<valType>(
bitRotateRight(Value[0], Shift),
bitRotateRight(Value[1], Shift));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> bitRotateRight
(
detail::tvec3<valType> const & Value,
std::size_t Shift
)
{
return detail::tvec3<valType>(
bitRotateRight(Value[0], Shift),
bitRotateRight(Value[1], Shift),
bitRotateRight(Value[2], Shift));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<valType> bitRotateRight
(
detail::tvec4<valType> const & Value,
std::size_t Shift
)
{
return detail::tvec4<valType>(
bitRotateRight(Value[0], Shift),
bitRotateRight(Value[1], Shift),
bitRotateRight(Value[2], Shift),
bitRotateRight(Value[3], Shift));
}
template <typename genType>
GLM_FUNC_QUALIFIER genType bitRotateLeft(genType const & In, std::size_t Shift)
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRotateLeft' only accept integer values");
std::size_t BitSize = sizeof(genType) * 8;
return (In >> Shift) | (In << (BitSize - Shift));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<valType> bitRotateLeft
(
detail::tvec2<valType> const & Value,
std::size_t Shift
)
{
return detail::tvec2<valType>(
bitRotateLeft(Value[0], Shift),
bitRotateLeft(Value[1], Shift));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> bitRotateLeft
(
detail::tvec3<valType> const & Value,
std::size_t Shift
)
{
return detail::tvec3<valType>(
bitRotateLeft(Value[0], Shift),
bitRotateLeft(Value[1], Shift),
bitRotateLeft(Value[2], Shift));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<valType> bitRotateLeft
(
detail::tvec4<valType> const & Value,
std::size_t Shift
)
{
return detail::tvec4<valType>(
bitRotateLeft(Value[0], Shift),
bitRotateLeft(Value[1], Shift),
bitRotateLeft(Value[2], Shift),
bitRotateLeft(Value[3], Shift));
}
template <typename genIUType>
GLM_FUNC_QUALIFIER genIUType fillBitfieldWithOne
(
genIUType const & Value,
int const & FromBit,
int const & ToBit
)
{
assert(FromBit <= ToBit);
assert(ToBit <= sizeof(genIUType) * std::size_t(8));
genIUType Result = Value;
for(std::size_t i = 0; i <= ToBit; ++i)
Result |= (1 << i);
return Result;
}
template <typename genIUType>
GLM_FUNC_QUALIFIER genIUType fillBitfieldWithZero
(
genIUType const & Value,
int const & FromBit,
int const & ToBit
)
{
assert(FromBit <= ToBit);
assert(ToBit <= sizeof(genIUType) * std::size_t(8));
genIUType Result = Value;
for(std::size_t i = 0; i <= ToBit; ++i)
Result &= ~(1 << i);
return Result;
}
}//namespace glm

193
glm/gtx/epsilon.inl
Unescape View File

@ -7,224 +7,223 @@
// File : glm/gtx/epsilon.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
template <typename genType>
GLM_FUNC_QUALIFIER bool equalEpsilon
(
namespace glm
{
template <typename genType>
GLM_FUNC_QUALIFIER bool equalEpsilon
(
genType const & x,
genType const & y,
genType const & epsilon
)
{
)
{
return abs(x - y) < epsilon;
}
}
template <typename genType>
GLM_FUNC_QUALIFIER bool notEqualEpsilon
(
template <typename genType>
GLM_FUNC_QUALIFIER bool notEqualEpsilon
(
genType const & x,
genType const & y,
genType const & epsilon
)
{
)
{
return abs(x - y) >= epsilon;
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> equalEpsilon
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> equalEpsilon
(
detail::tvec2<valType> const & x,
detail::tvec2<valType> const & y,
valType const & epsilon)
{
{
return detail::tvec2<bool>(
abs(x.x - y.x) < epsilon,
abs(x.y - y.y) < epsilon);
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> equalEpsilon
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> equalEpsilon
(
detail::tvec3<valType> const & x,
detail::tvec3<valType> const & y,
valType const & epsilon)
{
{
return detail::tvec3<bool>(
abs(x.x - y.x) < epsilon,
abs(x.y - y.y) < epsilon,
abs(x.z - y.z) < epsilon);
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> equalEpsilon
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> equalEpsilon
(
detail::tvec4<valType> const & x,
detail::tvec4<valType> const & y,
valType const & epsilon
)
{
)
{
return detail::tvec4<bool>(
abs(x.x - y.x) < epsilon,
abs(x.y - y.y) < epsilon,
abs(x.z - y.z) < epsilon,
abs(x.w - y.w) < epsilon);
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> notEqualEpsilon
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> notEqualEpsilon
(
detail::tvec2<valType> const & x,
detail::tvec2<valType> const & y,
valType const & epsilon
)
{
)
{
return detail::tvec2<bool>(
abs(x.x - y.x) >= epsilon,
abs(x.y - y.y) >= epsilon);
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> notEqualEpsilon
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> notEqualEpsilon
(
detail::tvec3<valType> const & x,
detail::tvec3<valType> const & y,
valType const & epsilon
)
{
)
{
return detail::tvec3<bool>(
abs(x.x - y.x) >= epsilon,
abs(x.y - y.y) >= epsilon,
abs(x.z - y.z) >= epsilon);
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> notEqualEpsilon
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> notEqualEpsilon
(
detail::tvec4<valType> const & x,
detail::tvec4<valType> const & y,
valType const & epsilon
)
{
)
{
return detail::tvec4<bool>(
abs(x.x - y.x) >= epsilon,
abs(x.y - y.y) >= epsilon,
abs(x.z - y.z) >= epsilon,
abs(x.w - y.w) >= epsilon);
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> equalEpsilon
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> equalEpsilon
(
detail::tvec2<valType> const & x,
detail::tvec2<valType> const & y,
detail::tvec2<valType> const & epsilon
)
{
)
{
return detail::tvec2<bool>(
abs(x.x - y.x) < epsilon.x,
abs(x.y - y.y) < epsilon.y);
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> equalEpsilon
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> equalEpsilon
(
detail::tvec3<valType> const & x,
detail::tvec3<valType> const & y,
detail::tvec3<valType> const & epsilon
)
{
)
{
return detail::tvec3<bool>(
abs(x.x - y.x) < epsilon.x,
abs(x.y - y.y) < epsilon.y,
abs(x.z - y.z) < epsilon.z);
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> equalEpsilon
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> equalEpsilon
(
detail::tvec4<valType> const & x,
detail::tvec4<valType> const & y,
detail::tvec4<valType> const & epsilon
)
{
)
{
return detail::tvec4<bool>(
abs(x.x - y.x) < epsilon.x,
abs(x.y - y.y) < epsilon.y,
abs(x.z - y.z) < epsilon.z,
abs(x.w - y.w) < epsilon.w);
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> equalEpsilon
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> equalEpsilon
(
detail::tquat<valType> const & x,
detail::tquat<valType> const & y,
detail::tquat<valType> const & epsilon
)
{
)
{
return detail::tvec4<bool>(
abs(x.x - y.x) < epsilon.x,
abs(x.y - y.y) < epsilon.y,
abs(x.z - y.z) < epsilon.z,
abs(x.w - y.w) < epsilon.w);
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> notEqualEpsilon
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> notEqualEpsilon
(
detail::tvec2<valType> const & x,
detail::tvec2<valType> const & y,
detail::tvec2<valType> const & epsilon
)
{
)
{
return detail::tvec2<bool>(
abs(x.x - y.x) >= epsilon.x,
abs(x.y - y.y) >= epsilon.y);
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> notEqualEpsilon
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> notEqualEpsilon
(
detail::tvec3<valType> const & x,
detail::tvec3<valType> const & y,
detail::tvec3<valType> const & epsilon
)
{
)
{
return detail::tvec3<bool>(
abs(x.x - y.x) >= epsilon.x,
abs(x.y - y.y) >= epsilon.y,
abs(x.z - y.z) >= epsilon.z);
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> notEqualEpsilon
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> notEqualEpsilon
(
detail::tvec4<valType> const & x,
detail::tvec4<valType> const & y,
detail::tvec4<valType> const & epsilon
)
{
)
{
return detail::tvec4<bool>(
abs(x.x - y.x) >= epsilon.x,
abs(x.y - y.y) >= epsilon.y,
abs(x.z - y.z) >= epsilon.z,
abs(x.w - y.w) >= epsilon.w);
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> notEqualEpsilon
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> notEqualEpsilon
(
detail::tquat<valType> const & x,
detail::tquat<valType> const & y,
detail::tquat<valType> const & epsilon
)
{
)
{
return detail::tvec4<bool>(
abs(x.x - y.x) >= epsilon.x,
abs(x.y - y.y) >= epsilon.y,
abs(x.z - y.z) >= epsilon.z,
abs(x.w - y.w) >= epsilon.w);
}
}
}//namespace glm

161
glm/gtx/euler_angles.inl
Unescape View File

@ -7,14 +7,14 @@
// File : glm/gtx/euler_angles.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleX
(
valType const & angleX
)
namespace glm
{
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleX
(
valType const & angleX
)
{
valType cosX = glm::cos(angleX);
valType sinX = glm::sin(angleX);
@ -23,14 +23,14 @@ GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleX
valType(0), cosX, sinX, valType(0),
valType(0),-sinX, cosX, valType(0),
valType(0), valType(0), valType(0), valType(1));
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleY
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleY
(
valType const & angleY
)
{
)
{
valType cosY = glm::cos(angleY);
valType sinY = glm::sin(angleY);
@ -39,14 +39,14 @@ GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleY
valType(0), valType(1), valType(0), valType(0),
-sinY, valType(0), cosY, valType(0),
valType(0), valType(0), valType(0), valType(1));
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleZ
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleZ
(
valType const & angleZ
)
{
)
{
valType cosZ = glm::cos(angleZ);
valType sinZ = glm::sin(angleZ);
@ -55,15 +55,15 @@ GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleZ
-sinZ, cosZ, valType(0), valType(0),
valType(0), valType(0), valType(1), valType(0),
valType(0), valType(0), valType(0), valType(1));
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleXY
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleXY
(
valType const & angleX,
valType const & angleY
)
{
)
{
valType cosX = glm::cos(angleX);
valType sinX = glm::sin(angleX);
valType cosY = glm::cos(angleY);
@ -74,15 +74,15 @@ GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleXY
valType(0), cosX, sinX, valType(0),
-sinY , -sinX * cosY, cosX * cosY, valType(0),
valType(0), valType(0), valType(0), valType(1));
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleYX
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleYX
(
valType const & angleY,
valType const & angleX
)
{
)
{
valType cosX = glm::cos(angleX);
valType sinX = glm::sin(angleX);
valType cosY = glm::cos(angleY);
@ -93,36 +93,36 @@ GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleYX
-sinX * sinY, cosX, sinX * cosY, valType(0),
-cosX * sinY, -sinX, cosX * cosY, valType(0),
valType(0), valType(0), valType(0), valType(1));
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleXZ
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleXZ
(
valType const & angleX,
valType const & angleZ
)
{
)
{
return eulerAngleX(angleX) * eulerAngleZ(angleZ);
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleZX
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleZX
(
valType const & angleZ,
valType const & angleX
)
{
)
{
return eulerAngleZ(angleZ) * eulerAngleX(angleX);
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleYXZ
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleYXZ
(
valType const & yaw,
valType const & pitch,
valType const & roll
)
{
)
{
valType tmp_ch = glm::cos(yaw);
valType tmp_sh = glm::sin(yaw);
valType tmp_cp = glm::cos(pitch);
@ -148,16 +148,16 @@ GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleYXZ
Result[3][2] = valType(0);
Result[3][3] = valType(1);
return Result;
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> yawPitchRoll
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> yawPitchRoll
(
valType const & yaw,
valType const & pitch,
valType const & roll
)
{
)
{
valType tmp_ch = glm::cos(yaw);
valType tmp_sh = glm::sin(yaw);
valType tmp_cp = glm::cos(pitch);
@ -183,14 +183,14 @@ GLM_FUNC_QUALIFIER detail::tmat4x4<valType> yawPitchRoll
Result[3][2] = valType(0);
Result[3][3] = valType(1);
return Result;
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat2x2<valType> orientate2
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat2x2<valType> orientate2
(
valType const & angle
)
{
)
{
valType c = glm::cos(angle);
valType s = glm::sin(angle);
@ -200,14 +200,14 @@ GLM_FUNC_QUALIFIER detail::tmat2x2<valType> orientate2
Result[1][0] = -s;
Result[1][1] = c;
return Result;
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat3x3<valType> orientate3
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat3x3<valType> orientate3
(
valType const & angle
)
{
)
{
valType c = glm::cos(angle);
valType s = glm::sin(angle);
@ -222,24 +222,23 @@ GLM_FUNC_QUALIFIER detail::tmat3x3<valType> orientate3
Result[2][1] = 0.0f;
Result[2][2] = 1.0f;
return Result;
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat3x3<valType> orientate3
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat3x3<valType> orientate3
(
detail::tvec3<valType> const & angles
)
{
)
{
return detail::tmat3x3<valType>(yawPitchRoll(angles.x, angles.y, angles.z));
}
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> orientate4
(
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> orientate4
(
detail::tvec3<valType> const & angles
)
{
)
{
return yawPitchRoll(angles.z, angles.x, angles.y);
}
}
}//namespace glm

53
glm/gtx/extend.inl
Unescape View File

@ -7,50 +7,49 @@
// File : glm/gtx/extend.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
template <typename genType>
genType extend
(
namespace glm
{
template <typename genType>
genType extend
(
genType const & Origin,
genType const & Source,
genType const & Distance
)
{
)
{
return Origin + (Source - Origin) * Distance;
}
}
template <typename valType>
detail::tvec2<valType> extend
(
template <typename valType>
detail::tvec2<valType> extend
(
detail::tvec2<valType> const & Origin,
detail::tvec2<valType> const & Source,
valType const & Distance
)
{
)
{
return Origin + (Source - Origin) * Distance;
}
}
template <typename valType>
detail::tvec3<valType> extend
(
template <typename valType>
detail::tvec3<valType> extend
(
detail::tvec3<valType> const & Origin,
detail::tvec3<valType> const & Source,
valType const & Distance
)
{
)
{
return Origin + (Source - Origin) * Distance;
}
}
template <typename valType>
detail::tvec4<valType> extend
(
template <typename valType>
detail::tvec4<valType> extend
(
detail::tvec4<valType> const & Origin,
detail::tvec4<valType> const & Source,
valType const & Distance
)
{
)
{
return Origin + (Source - Origin) * Distance;
}
}
}//namespace glm

16
glm/gtx/fast_exponential.hpp
Unescape View File

@ -54,17 +54,17 @@ namespace glm
//! Faster than the common pow function but less accurate.
//! From GLM_GTX_fast_exponential extension.
template <typename valType>
valType fastPow(
valType const & x,
valType const & y);
template <typename genType>
genType fastPow(
genType const & x,
genType const & y);
//! Faster than the common pow function but less accurate.
//! From GLM_GTX_fast_exponential extension.
template <typename T, typename U>
T fastPow(
const T& x,
const U& y);
template <typename genTypeT, typename genTypeU>
genType fastPow(
genTypeT const & x,
genTypeU const & y);
//! Faster than the common exp function but less accurate.
//! From GLM_GTX_fast_exponential extension.

266
glm/gtx/fast_exponential.inl
Unescape View File

@ -7,95 +7,66 @@
// File : glm/gtx/fast_exponential.inl
///////////////////////////////////////////////////////////////////////////////////////////////////
namespace glm{
#include "../core/_vectorize.hpp"
// fastPow:
template <typename T>
GLM_FUNC_QUALIFIER T fastPow(const T x, const T y)
namespace glm
{
// fastPow:
template <typename genType>
GLM_FUNC_QUALIFIER genType fastPow(genType const & x, genType const & y)
{
return exp(y * log(x));
}
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> fastPow(
const detail::tvec2<T>& x,
const detail::tvec2<T>& y)
{
return detail::tvec2<T>(
fastPow(x.x, y.x),
fastPow(x.y, y.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> fastPow(
const detail::tvec3<T>& x,
const detail::tvec3<T>& y)
{
return detail::tvec3<T>(
fastPow(x.x, y.x),
fastPow(x.y, y.y),
fastPow(x.z, y.z));
}
VECTORIZE_VEC_VEC(fastPow)
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> fastPow(
const detail::tvec4<T>& x,
const detail::tvec4<T>& y)
{
return detail::tvec4<T>(
fastPow(x.x, y.x),
fastPow(x.y, y.y),
fastPow(x.z, y.z),
fastPow(x.w, y.w));
}
template <typename T>
GLM_FUNC_QUALIFIER T fastPow(const T x, int y)
{
template <typename T>
GLM_FUNC_QUALIFIER T fastPow(const T x, int y)
{
T f = T(1);
for(int i = 0; i < y; ++i)
f *= x;
return f;
}
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> fastPow(
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> fastPow(
const detail::tvec2<T>& x,
const detail::tvec2<int>& y)
{
{
return detail::tvec2<T>(
fastPow(x.x, y.x),
fastPow(x.y, y.y));
}
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> fastPow(
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> fastPow(
const detail::tvec3<T>& x,
const detail::tvec3<int>& y)
{
{
return detail::tvec3<T>(
fastPow(x.x, y.x),
fastPow(x.y, y.y),
fastPow(x.z, y.z));
}
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> fastPow(
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> fastPow(
const detail::tvec4<T>& x,
const detail::tvec4<int>& y)
{
{
return detail::tvec4<T>(
fastPow(x.x, y.x),
fastPow(x.y, y.y),
fastPow(x.z, y.z),
fastPow(x.w, y.w));
}
}
// fastExp
// Note: This function provides accurate results only for value between -1 and 1, else avoid it.
template <typename T>
GLM_FUNC_QUALIFIER T fastExp(const T x)
{
// fastExp
// Note: This function provides accurate results only for value between -1 and 1, else avoid it.
template <typename T>
GLM_FUNC_QUALIFIER T fastExp(const T x)
{
// This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower.
// return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f))));
T x2 = x * x;
@ -103,10 +74,10 @@ GLM_FUNC_QUALIFIER T fastExp(const T x)
T x4 = x3 * x;
T x5 = x4 * x;
return T(1) + x + (x2 * T(0.5)) + (x3 * T(0.1666666667)) + (x4 * T(0.041666667)) + (x5 * T(0.008333333333));
}
/* // Try to handle all values of float... but often shower than std::exp, glm::floor and the loop kill the performance
GLM_FUNC_QUALIFIER float fastExp(float x)
{
}
/* // Try to handle all values of float... but often shower than std::exp, glm::floor and the loop kill the performance
GLM_FUNC_QUALIFIER float fastExp(float x)
{
const float e = 2.718281828f;
const float IntegerPart = floor(x);
const float FloatPart = x - IntegerPart;
@ -120,11 +91,11 @@ GLM_FUNC_QUALIFIER float fastExp(float x)
const float x4 = x3 * FloatPart;
const float x5 = x4 * FloatPart;
return z * (1.0f + FloatPart + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f));
}
}
// Increase accuracy on number bigger that 1 and smaller than -1 but it's not enough for high and negative numbers
GLM_FUNC_QUALIFIER float fastExp(float x)
{
// Increase accuracy on number bigger that 1 and smaller than -1 but it's not enough for high and negative numbers
GLM_FUNC_QUALIFIER float fastExp(float x)
{
// This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower.
// return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f))));
float x2 = x * x;
@ -135,156 +106,45 @@ GLM_FUNC_QUALIFIER float fastExp(float x)
float x7 = x6 * x;
float x8 = x7 * x;
return 1.0f + x + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f)+ (x6 * 0.00138888888888f) + (x7 * 0.000198412698f) + (x8 * 0.0000248015873f);;
}
*/
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> fastExp(
const detail::tvec2<T>& x)
{
return detail::tvec2<T>(
fastExp(x.x),
fastExp(x.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> fastExp(
const detail::tvec3<T>& x)
{
return detail::tvec3<T>(
fastExp(x.x),
fastExp(x.y),
fastExp(x.z));
}
}
*/
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> fastExp(
const detail::tvec4<T>& x)
{
return detail::tvec4<T>(
fastExp(x.x),
fastExp(x.y),
fastExp(x.z),
fastExp(x.w));
}
VECTORIZE_VEC(fastExp)
// fastLog
template <typename T>
GLM_FUNC_QUALIFIER T fastLog(const T x)
{
// fastLog
template <typename genType>
GLM_FUNC_QUALIFIER genType fastLog(genType const & x)
{
return std::log(x);
}
}
/* Slower than the VC7.1 function...
GLM_FUNC_QUALIFIER float fastLog(float x)
{
/* Slower than the VC7.1 function...
GLM_FUNC_QUALIFIER float fastLog(float x)
{
float y1 = (x - 1.0f) / (x + 1.0f);
float y2 = y1 * y1;
return 2.0f * y1 * (1.0f + y2 * (0.3333333333f + y2 * (0.2f + y2 * 0.1428571429f)));
}
*/
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> fastLog(
const detail::tvec2<T>& x)
{
return detail::tvec2<T>(
fastLog(x.x),
fastLog(x.y));
}
}
*/
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> fastLog(
const detail::tvec3<T>& x)
{
return detail::tvec3<T>(
fastLog(x.x),
fastLog(x.y),
fastLog(x.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> fastLog(
const detail::tvec4<T>& x)
{
return detail::tvec4<T>(
fastLog(x.x),
fastLog(x.y),
fastLog(x.z),
fastLog(x.w));
}
VECTORIZE_VEC(fastLog)
//fastExp2, ln2 = 0.69314718055994530941723212145818f
template <typename T>
GLM_FUNC_QUALIFIER T fastExp2(const T x)
{
//fastExp2, ln2 = 0.69314718055994530941723212145818f
template <typename genType>
GLM_FUNC_QUALIFIER genType fastExp2(genType const & x)
{
return fastExp(0.69314718055994530941723212145818f * x);
}
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> fastExp2(
const detail::tvec2<T>& x)
{
return detail::tvec2<T>(
fastExp2(x.x),
fastExp2(x.y));
}
VECTORIZE_VEC(fastExp2)
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> fastExp2(
const detail::tvec3<T>& x)
{
return detail::tvec3<T>(
fastExp2(x.x),
fastExp2(x.y),
fastExp2(x.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> fastExp2(
const detail::tvec4<T>& x)
{
return detail::tvec4<T>(
fastExp2(x.x),
fastExp2(x.y),
fastExp2(x.z),
fastExp2(x.w));
}
// fastLog2, ln2 = 0.69314718055994530941723212145818f
template <typename T>
GLM_FUNC_QUALIFIER T fastLog2(const T x)
{
// fastLog2, ln2 = 0.69314718055994530941723212145818f
template <typename genType>
GLM_FUNC_QUALIFIER genType fastLog2(genType const & x)
{
return fastLog(x) / 0.69314718055994530941723212145818f;
}
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> fastLog2(
const detail::tvec2<T>& x)
{
return detail::tvec2<T>(
fastLog2(x.x),
fastLog2(x.y));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> fastLog2(
const detail::tvec3<T>& x)
{
return detail::tvec3<T>(
fastLog2(x.x),
fastLog2(x.y),
fastLog2(x.z));
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> fastLog2(
const detail::tvec4<T>& x)
{
return detail::tvec4<T>(
fastLog2(x.x),
fastLog2(x.y),
fastLog2(x.z),
fastLog2(x.w));
}
VECTORIZE_VEC(fastLog2)
}//namespace glm

Write Preview
Loading…
Cancel
Save