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

Reformatting

Browse Source
master
Christophe Riccio ago%!(EXTRA string=14 years)
parent 6f6d161afb
commit bc15b98730
7 changed files with 2447 additions and 2512 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1946
      glm/gtc/half_float.inl
  2. 88
      glm/gtc/matrix_access.inl
  3. 253
      glm/gtc/matrix_inverse.inl
  4. 765
      glm/gtc/matrix_transform.inl
  5. 1665
      glm/gtc/noise.inl
  6. 4
      glm/gtc/quaternion.inl
  7. 248
      glm/gtc/swizzle.inl

1946
glm/gtc/half_float.inl
View File

File diff suppressed because it is too large Load Diff

88
glm/gtc/matrix_access.inl
Unescape View File

@ -26,49 +26,55 @@
/// @author Christophe Riccio /// @author Christophe Riccio
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
namespace glm{ namespace glm
template <typename genType>
GLM_FUNC_QUALIFIER genType row(
genType const & m,
int index,
typename genType::row_type const & x)
{
genType Result = m;
for(typename genType::size_type i = 0; i < genType::row_size(); ++i)
Result[i][index] = x[i];
return Result;
}
template <typename genType>
GLM_FUNC_QUALIFIER typename genType::row_type row(
genType const & m,
int index)
{ {
typename genType::row_type Result; template <typename genType>
for(typename genType::size_type i = 0; i < genType::row_size(); ++i) GLM_FUNC_QUALIFIER genType row
Result[i] = m[i][index]; (
return Result; genType const & m,
} int index,
typename genType::row_type const & x
)
{
genType Result = m;
for(typename genType::size_type i = 0; i < genType::row_size(); ++i)
Result[i][index] = x[i];
return Result;
}
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER genType column( GLM_FUNC_QUALIFIER typename genType::row_type row
genType const & m, (
int index, genType const & m,
typename genType::col_type const & x) int index
{ )
genType Result = m; {
Result[index] = x; typename genType::row_type Result;
return Result; for(typename genType::size_type i = 0; i < genType::row_size(); ++i)
} Result[i] = m[i][index];
return Result;
}
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER typename genType::col_type column( GLM_FUNC_QUALIFIER genType column
genType const & m, (
int index) genType const & m,
{ int index,
return m[index]; typename genType::col_type const & x
} )
{
genType Result = m;
Result[index] = x;
return Result;
}
template <typename genType>
GLM_FUNC_QUALIFIER typename genType::col_type column
(
genType const & m,
int index
)
{
return m[index];
}
}//namespace glm }//namespace glm

253
glm/gtc/matrix_inverse.inl
Unescape View File

@ -26,129 +26,134 @@
/// @author Christophe Riccio /// @author Christophe Riccio
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
namespace glm{ namespace glm
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> affineInverse
(
detail::tmat3x3<T> const & m
)
{
detail::tmat3x3<T> Result(m);
Result[2] = detail::tvec3<T>(0, 0, 1);
Result = transpose(Result);
detail::tvec3<T> Translation = Result * detail::tvec3<T>(-detail::tvec2<T>(m[2]), m[2][2]);
Result[2] = Translation;
return Result;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> affineInverse
(
detail::tmat4x4<T> const & m
)
{
detail::tmat4x4<T> Result(m);
Result[3] = detail::tvec4<T>(0, 0, 0, 1);
Result = transpose(Result);
detail::tvec4<T> Translation = Result * detail::tvec4<T>(-detail::tvec3<T>(m[3]), m[3][3]);
Result[3] = Translation;
return Result;
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat2x2<valType> inverseTranspose(
detail::tmat2x2<valType> const & m)
{ {
valType Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1]; template <typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> affineInverse
detail::tmat2x2<valType> Inverse( (
+ m[1][1] / Determinant, detail::tmat3x3<T> const & m
- m[0][1] / Determinant, )
- m[1][0] / Determinant, {
+ m[0][0] / Determinant); detail::tmat3x3<T> Result(m);
Result[2] = detail::tvec3<T>(0, 0, 1);
return Inverse; Result = transpose(Result);
} detail::tvec3<T> Translation = Result * detail::tvec3<T>(-detail::tvec2<T>(m[2]), m[2][2]);
Result[2] = Translation;
template <typename valType> return Result;
GLM_FUNC_QUALIFIER detail::tmat3x3<valType> inverseTranspose( }
detail::tmat3x3<valType> const & m)
{ template <typename T>
valType Determinant = GLM_FUNC_QUALIFIER detail::tmat4x4<T> affineInverse
+ m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) (
- m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0]) detail::tmat4x4<T> const & m
+ m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]); )
{
detail::tmat3x3<valType> Inverse; detail::tmat4x4<T> Result(m);
Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]); Result[3] = detail::tvec4<T>(0, 0, 0, 1);
Inverse[0][1] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]); Result = transpose(Result);
Inverse[0][2] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]); detail::tvec4<T> Translation = Result * detail::tvec4<T>(-detail::tvec3<T>(m[3]), m[3][3]);
Inverse[1][0] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]); Result[3] = Translation;
Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]); return Result;
Inverse[1][2] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]); }
Inverse[2][0] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
Inverse[2][1] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]); template <typename valType>
Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]); GLM_FUNC_QUALIFIER detail::tmat2x2<valType> inverseTranspose
Inverse /= Determinant; (
detail::tmat2x2<valType> const & m
return Inverse; )
} {
valType Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
template <typename valType>
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> inverseTranspose( detail::tmat2x2<valType> Inverse(
detail::tmat4x4<valType> const & m) + m[1][1] / Determinant,
{ - m[0][1] / Determinant,
valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; - m[1][0] / Determinant,
valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; + m[0][0] / Determinant);
valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; return Inverse;
valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; }
valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3]; template <typename valType>
valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3]; GLM_FUNC_QUALIFIER detail::tmat3x3<valType> inverseTranspose
valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2]; (
valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3]; detail::tmat3x3<valType> const & m
valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2]; )
valType SubFactor11 = m[1][1] * m[3][3] - m[3][1] * m[1][3]; {
valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1]; valType Determinant =
valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3]; + m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1])
valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3]; - m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])
valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2]; + m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2]; detail::tmat3x3<valType> Inverse;
valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1]; Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]);
Inverse[0][1] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);
detail::tmat4x4<valType> Inverse; Inverse[0][2] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]);
Inverse[0][0] = + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02); Inverse[1][0] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]);
Inverse[0][1] = - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04); Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]);
Inverse[0][2] = + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05); Inverse[1][2] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]);
Inverse[0][3] = - (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05); Inverse[2][0] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
Inverse[2][1] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]);
Inverse[1][0] = - (m[0][1] * SubFactor00 - m[0][2] * SubFactor01 + m[0][3] * SubFactor02); Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]);
Inverse[1][1] = + (m[0][0] * SubFactor00 - m[0][2] * SubFactor03 + m[0][3] * SubFactor04); Inverse /= Determinant;
Inverse[1][2] = - (m[0][0] * SubFactor01 - m[0][1] * SubFactor03 + m[0][3] * SubFactor05);
Inverse[1][3] = + (m[0][0] * SubFactor02 - m[0][1] * SubFactor04 + m[0][2] * SubFactor05); return Inverse;
}
Inverse[2][0] = + (m[0][1] * SubFactor06 - m[0][2] * SubFactor07 + m[0][3] * SubFactor08);
Inverse[2][1] = - (m[0][0] * SubFactor06 - m[0][2] * SubFactor09 + m[0][3] * SubFactor10); template <typename valType>
Inverse[2][2] = + (m[0][0] * SubFactor11 - m[0][1] * SubFactor09 + m[0][3] * SubFactor12); GLM_FUNC_QUALIFIER detail::tmat4x4<valType> inverseTranspose
Inverse[2][3] = - (m[0][0] * SubFactor08 - m[0][1] * SubFactor10 + m[0][2] * SubFactor12); (
detail::tmat4x4<valType> const & m
Inverse[3][0] = - (m[0][1] * SubFactor13 - m[0][2] * SubFactor14 + m[0][3] * SubFactor15); )
Inverse[3][1] = + (m[0][0] * SubFactor13 - m[0][2] * SubFactor16 + m[0][3] * SubFactor17); {
Inverse[3][2] = - (m[0][0] * SubFactor14 - m[0][1] * SubFactor16 + m[0][3] * SubFactor18); valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
Inverse[3][3] = + (m[0][0] * SubFactor15 - m[0][1] * SubFactor17 + m[0][2] * SubFactor18); valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
valType Determinant = valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+ m[0][0] * Inverse[0][0] valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+ m[0][1] * Inverse[0][1] valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+ m[0][2] * Inverse[0][2] valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+ m[0][3] * Inverse[0][3]; valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
Inverse /= Determinant; valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
return Inverse; valType SubFactor11 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
} valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
detail::tmat4x4<valType> Inverse;
Inverse[0][0] = + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02);
Inverse[0][1] = - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04);
Inverse[0][2] = + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05);
Inverse[0][3] = - (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05);
Inverse[1][0] = - (m[0][1] * SubFactor00 - m[0][2] * SubFactor01 + m[0][3] * SubFactor02);
Inverse[1][1] = + (m[0][0] * SubFactor00 - m[0][2] * SubFactor03 + m[0][3] * SubFactor04);
Inverse[1][2] = - (m[0][0] * SubFactor01 - m[0][1] * SubFactor03 + m[0][3] * SubFactor05);
Inverse[1][3] = + (m[0][0] * SubFactor02 - m[0][1] * SubFactor04 + m[0][2] * SubFactor05);
Inverse[2][0] = + (m[0][1] * SubFactor06 - m[0][2] * SubFactor07 + m[0][3] * SubFactor08);
Inverse[2][1] = - (m[0][0] * SubFactor06 - m[0][2] * SubFactor09 + m[0][3] * SubFactor10);
Inverse[2][2] = + (m[0][0] * SubFactor11 - m[0][1] * SubFactor09 + m[0][3] * SubFactor12);
Inverse[2][3] = - (m[0][0] * SubFactor08 - m[0][1] * SubFactor10 + m[0][2] * SubFactor12);
Inverse[3][0] = - (m[0][1] * SubFactor13 - m[0][2] * SubFactor14 + m[0][3] * SubFactor15);
Inverse[3][1] = + (m[0][0] * SubFactor13 - m[0][2] * SubFactor16 + m[0][3] * SubFactor17);
Inverse[3][2] = - (m[0][0] * SubFactor14 - m[0][1] * SubFactor16 + m[0][3] * SubFactor18);
Inverse[3][3] = + (m[0][0] * SubFactor15 - m[0][1] * SubFactor17 + m[0][2] * SubFactor18);
valType Determinant =
+ m[0][0] * Inverse[0][0]
+ m[0][1] * Inverse[0][1]
+ m[0][2] * Inverse[0][2]
+ m[0][3] * Inverse[0][3];
Inverse /= Determinant;
return Inverse;
}
}//namespace glm }//namespace glm

765
glm/gtc/matrix_transform.inl
Unescape View File

@ -26,388 +26,387 @@
/// @author Christophe Riccio /// @author Christophe Riccio
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
namespace glm{ namespace glm
template <typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate
(
detail::tmat4x4<T> const & m,
detail::tvec3<T> const & v
)
{ {
detail::tmat4x4<T> Result(m); template <typename T>
Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3]; GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate
return Result; (
} detail::tmat4x4<T> const & m,
detail::tvec3<T> const & v
template <typename T> )
GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate {
( detail::tmat4x4<T> Result(m);
detail::tmat4x4<T> const & m, Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
T const & angle, return Result;
detail::tvec3<T> const & v }
)
{ template <typename T>
T a = radians(angle); GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate
T c = cos(a); (
T s = sin(a); detail::tmat4x4<T> const & m,
T const & angle,
detail::tvec3<T> axis = normalize(v); detail::tvec3<T> const & v
)
detail::tvec3<T> temp = (T(1) - c) * axis; {
T a = radians(angle);
detail::tmat4x4<T> Rotate(detail::tmat4x4<T>::null); T c = cos(a);
Rotate[0][0] = c + temp[0] * axis[0]; T s = sin(a);
Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1]; detail::tvec3<T> axis = normalize(v);
Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2]; detail::tvec3<T> temp = (T(1) - c) * axis;
Rotate[1][1] = c + temp[1] * axis[1];
Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0]; detail::tmat4x4<T> Rotate(detail::tmat4x4<T>::null);
Rotate[0][0] = c + temp[0] * axis[0];
Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1]; Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0]; Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
Rotate[2][2] = c + temp[2] * axis[2];
Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
detail::tmat4x4<T> Result(detail::tmat4x4<T>::null); Rotate[1][1] = c + temp[1] * axis[1];
Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2]; Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2]; Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
Result[3] = m[3]; Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
return Result; Rotate[2][2] = c + temp[2] * axis[2];
}
detail::tmat4x4<T> Result(detail::tmat4x4<T>::null);
template <typename T> Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
( Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
detail::tmat4x4<T> const & m, Result[3] = m[3];
detail::tvec3<T> const & v return Result;
) }
{
detail::tmat4x4<T> Result(detail::tmat4x4<T>::null); template <typename T>
Result[0] = m[0] * v[0]; GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale
Result[1] = m[1] * v[1]; (
Result[2] = m[2] * v[2]; detail::tmat4x4<T> const & m,
Result[3] = m[3]; detail::tvec3<T> const & v
return Result; )
} {
detail::tmat4x4<T> Result(detail::tmat4x4<T>::null);
template <typename T> Result[0] = m[0] * v[0];
GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate_slow Result[1] = m[1] * v[1];
( Result[2] = m[2] * v[2];
detail::tmat4x4<T> const & m, Result[3] = m[3];
detail::tvec3<T> const & v return Result;
) }
{
detail::tmat4x4<T> Result(T(1)); template <typename T>
Result[3] = detail::tvec4<T>(v, T(1)); GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate_slow
return m * Result; (
detail::tmat4x4<T> const & m,
//detail::tmat4x4<valType> Result(m); detail::tvec3<T> const & v
Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3]; )
//Result[3][0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0]; {
//Result[3][1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1]; detail::tmat4x4<T> Result(T(1));
//Result[3][2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2]; Result[3] = detail::tvec4<T>(v, T(1));
//Result[3][3] = m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3]; return m * Result;
//return Result;
} //detail::tmat4x4<valType> Result(m);
Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
template <typename T> //Result[3][0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0];
GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate_slow //Result[3][1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1];
( //Result[3][2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
detail::tmat4x4<T> const & m, //Result[3][3] = m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3];
T const & angle, //return Result;
detail::tvec3<T> const & v }
)
{ template <typename T>
T a = radians(angle); GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate_slow
T c = cos(a); (
T s = sin(a); detail::tmat4x4<T> const & m,
detail::tmat4x4<T> Result; T const & angle,
detail::tvec3<T> const & v
detail::tvec3<T> axis = normalize(v); )
{
Result[0][0] = c + (1 - c) * axis.x * axis.x; T a = radians(angle);
Result[0][1] = (1 - c) * axis.x * axis.y + s * axis.z; T c = cos(a);
Result[0][2] = (1 - c) * axis.x * axis.z - s * axis.y; T s = sin(a);
Result[0][3] = 0; detail::tmat4x4<T> Result;
Result[1][0] = (1 - c) * axis.y * axis.x - s * axis.z; detail::tvec3<T> axis = normalize(v);
Result[1][1] = c + (1 - c) * axis.y * axis.y;
Result[1][2] = (1 - c) * axis.y * axis.z + s * axis.x; Result[0][0] = c + (1 - c) * axis.x * axis.x;
Result[1][3] = 0; Result[0][1] = (1 - c) * axis.x * axis.y + s * axis.z;
Result[0][2] = (1 - c) * axis.x * axis.z - s * axis.y;
Result[2][0] = (1 - c) * axis.z * axis.x + s * axis.y; Result[0][3] = 0;
Result[2][1] = (1 - c) * axis.z * axis.y - s * axis.x;
Result[2][2] = c + (1 - c) * axis.z * axis.z; Result[1][0] = (1 - c) * axis.y * axis.x - s * axis.z;
Result[2][3] = 0; Result[1][1] = c + (1 - c) * axis.y * axis.y;
Result[1][2] = (1 - c) * axis.y * axis.z + s * axis.x;
Result[3] = detail::tvec4<T>(0, 0, 0, 1); Result[1][3] = 0;
return m * Result;
} Result[2][0] = (1 - c) * axis.z * axis.x + s * axis.y;
Result[2][1] = (1 - c) * axis.z * axis.y - s * axis.x;
template <typename T> Result[2][2] = c + (1 - c) * axis.z * axis.z;
GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale_slow Result[2][3] = 0;
(
detail::tmat4x4<T> const & m, Result[3] = detail::tvec4<T>(0, 0, 0, 1);
detail::tvec3<T> const & v return m * Result;
) }
{
detail::tmat4x4<T> Result(T(1)); template <typename T>
Result[0][0] = v.x; GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale_slow
Result[1][1] = v.y; (
Result[2][2] = v.z; detail::tmat4x4<T> const & m,
return m * Result; detail::tvec3<T> const & v
} )
{
template <typename valType> detail::tmat4x4<T> Result(T(1));
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> ortho Result[0][0] = v.x;
( Result[1][1] = v.y;
valType const & left, Result[2][2] = v.z;
valType const & right, return m * Result;
valType const & bottom, }
valType const & top,
valType const & zNear, template <typename valType>
valType const & zFar GLM_FUNC_QUALIFIER detail::tmat4x4<valType> ortho
) (
{ valType const & left,
detail::tmat4x4<valType> Result(1); valType const & right,
Result[0][0] = valType(2) / (right - left); valType const & bottom,
Result[1][1] = valType(2) / (top - bottom); valType const & top,
Result[2][2] = - valType(2) / (zFar - zNear); valType const & zNear,
Result[3][0] = - (right + left) / (right - left); valType const & zFar
Result[3][1] = - (top + bottom) / (top - bottom); )
Result[3][2] = - (zFar + zNear) / (zFar - zNear); {
return Result; detail::tmat4x4<valType> Result(1);
} Result[0][0] = valType(2) / (right - left);
Result[1][1] = valType(2) / (top - bottom);
template <typename valType> Result[2][2] = - valType(2) / (zFar - zNear);
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> ortho( Result[3][0] = - (right + left) / (right - left);
valType const & left, Result[3][1] = - (top + bottom) / (top - bottom);
valType const & right, Result[3][2] = - (zFar + zNear) / (zFar - zNear);
valType const & bottom, return Result;
valType const & top) }
{
detail::tmat4x4<valType> Result(1); template <typename valType>
Result[0][0] = valType(2) / (right - left); GLM_FUNC_QUALIFIER detail::tmat4x4<valType> ortho(
Result[1][1] = valType(2) / (top - bottom); valType const & left,
Result[2][2] = - valType(1); valType const & right,
Result[3][0] = - (right + left) / (right - left); valType const & bottom,
Result[3][1] = - (top + bottom) / (top - bottom); valType const & top)
return Result; {
} detail::tmat4x4<valType> Result(1);
Result[0][0] = valType(2) / (right - left);
template <typename valType> Result[1][1] = valType(2) / (top - bottom);
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> frustum Result[2][2] = - valType(1);
( Result[3][0] = - (right + left) / (right - left);
valType const & left, Result[3][1] = - (top + bottom) / (top - bottom);
valType const & right, return Result;
valType const & bottom, }
valType const & top,
valType const & nearVal, template <typename valType>
valType const & farVal GLM_FUNC_QUALIFIER detail::tmat4x4<valType> frustum
) (
{ valType const & left,
detail::tmat4x4<valType> Result(0); valType const & right,
Result[0][0] = (valType(2) * nearVal) / (right - left); valType const & bottom,
Result[1][1] = (valType(2) * nearVal) / (top - bottom); valType const & top,
Result[2][0] = (right + left) / (right - left); valType const & nearVal,
Result[2][1] = (top + bottom) / (top - bottom); valType const & farVal
Result[2][2] = -(farVal + nearVal) / (farVal - nearVal); )
Result[2][3] = valType(-1); {
Result[3][2] = -(valType(2) * farVal * nearVal) / (farVal - nearVal); detail::tmat4x4<valType> Result(0);
return Result; Result[0][0] = (valType(2) * nearVal) / (right - left);
} Result[1][1] = (valType(2) * nearVal) / (top - bottom);
Result[2][0] = (right + left) / (right - left);
template <typename valType> Result[2][1] = (top + bottom) / (top - bottom);
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> perspective Result[2][2] = -(farVal + nearVal) / (farVal - nearVal);
( Result[2][3] = valType(-1);
valType const & fovy, Result[3][2] = -(valType(2) * farVal * nearVal) / (farVal - nearVal);
valType const & aspect, return Result;
valType const & zNear, }
valType const & zFar
) template <typename valType>
{ GLM_FUNC_QUALIFIER detail::tmat4x4<valType> perspective
valType range = tan(radians(fovy / valType(2))) * zNear; (
valType left = -range * aspect; valType const & fovy,
valType right = range * aspect; valType const & aspect,
valType bottom = -range; valType const & zNear,
valType top = range; valType const & zFar
)
detail::tmat4x4<valType> Result(valType(0)); {
Result[0][0] = (valType(2) * zNear) / (right - left); valType range = tan(radians(fovy / valType(2))) * zNear;
Result[1][1] = (valType(2) * zNear) / (top - bottom); valType left = -range * aspect;
Result[2][2] = - (zFar + zNear) / (zFar - zNear); valType right = range * aspect;
Result[2][3] = - valType(1); valType bottom = -range;
Result[3][2] = - (valType(2) * zFar * zNear) / (zFar - zNear); valType top = range;
return Result;
} detail::tmat4x4<valType> Result(valType(0));
Result[0][0] = (valType(2) * zNear) / (right - left);
template <typename valType> Result[1][1] = (valType(2) * zNear) / (top - bottom);
GLM_FUNC_QUALIFIER detail::tmat4x4<valType> perspectiveFov Result[2][2] = - (zFar + zNear) / (zFar - zNear);
( Result[2][3] = - valType(1);
valType const & fov, Result[3][2] = - (valType(2) * zFar * zNear) / (zFar - zNear);
valType const & width, return Result;
valType const & height, }
valType const & zNear,
valType const & zFar template <typename valType>
) GLM_FUNC_QUALIFIER detail::tmat4x4<valType> perspectiveFov
{ (
valType rad = glm::radians(fov); valType const & fov,
valType h = glm::cos(valType(0.5) * rad) / glm::sin(valType(0.5) * rad); valType const & width,
valType w = h * height / width; valType const & height,
valType const & zNear,
detail::tmat4x4<valType> Result(valType(0)); valType const & zFar
Result[0][0] = w; )
Result[1][1] = h; {
Result[2][2] = (zFar + zNear) / (zFar - zNear); valType rad = glm::radians(fov);
Result[2][3] = valType(1); valType h = glm::cos(valType(0.5) * rad) / glm::sin(valType(0.5) * rad);
Result[3][2] = -(valType(2) * zFar * zNear) / (zFar - zNear); valType w = h * height / width;
return Result;
} detail::tmat4x4<valType> Result(valType(0));
Result[0][0] = w;
template <typename T> Result[1][1] = h;
GLM_FUNC_QUALIFIER detail::tmat4x4<T> infinitePerspective Result[2][2] = (zFar + zNear) / (zFar - zNear);
( Result[2][3] = valType(1);
T fovy, Result[3][2] = -(valType(2) * zFar * zNear) / (zFar - zNear);
T aspect, return Result;
T zNear }
)
{ template <typename T>
T range = tan(radians(fovy / T(2))) * zNear; GLM_FUNC_QUALIFIER detail::tmat4x4<T> infinitePerspective
T left = -range * aspect; (
T right = range * aspect; T fovy,
T bottom = -range; T aspect,
T top = range; T zNear
)
detail::tmat4x4<T> Result(T(0)); {
Result[0][0] = (T(2) * zNear) / (right - left); T range = tan(radians(fovy / T(2))) * zNear;
Result[1][1] = (T(2) * zNear) / (top - bottom); T left = -range * aspect;
Result[2][2] = - T(1); T right = range * aspect;
Result[2][3] = - T(1); T bottom = -range;
Result[3][2] = - T(2) * zNear; T top = range;
return Result;
} detail::tmat4x4<T> Result(T(0));
Result[0][0] = (T(2) * zNear) / (right - left);
template <typename T> Result[1][1] = (T(2) * zNear) / (top - bottom);
GLM_FUNC_QUALIFIER detail::tmat4x4<T> tweakedInfinitePerspective Result[2][2] = - T(1);
( Result[2][3] = - T(1);
T fovy, Result[3][2] = - T(2) * zNear;
T aspect, return Result;
T zNear }
)
{ template <typename T>
T range = tan(radians(fovy / T(2))) * zNear; GLM_FUNC_QUALIFIER detail::tmat4x4<T> tweakedInfinitePerspective
T left = -range * aspect; (
T right = range * aspect; T fovy,
T bottom = -range; T aspect,
T top = range; T zNear
)
detail::tmat4x4<T> Result(T(0)); {
Result[0][0] = (T(2) * zNear) / (right - left); T range = tan(radians(fovy / T(2))) * zNear;
Result[1][1] = (T(2) * zNear) / (top - bottom); T left = -range * aspect;
Result[2][2] = T(0.0001) - T(1); T right = range * aspect;
Result[2][3] = T(-1); T bottom = -range;
Result[3][2] = - (T(0.0001) - T(2)) * zNear; T top = range;
return Result;
} detail::tmat4x4<T> Result(T(0));
Result[0][0] = (T(2) * zNear) / (right - left);
template <typename T, typename U> Result[1][1] = (T(2) * zNear) / (top - bottom);
GLM_FUNC_QUALIFIER detail::tvec3<T> project Result[2][2] = T(0.0001) - T(1);
( Result[2][3] = T(-1);
detail::tvec3<T> const & obj, Result[3][2] = - (T(0.0001) - T(2)) * zNear;
detail::tmat4x4<T> const & model, return Result;
detail::tmat4x4<T> const & proj, }
detail::tvec4<U> const & viewport
) template <typename T, typename U>
{ GLM_FUNC_QUALIFIER detail::tvec3<T> project
detail::tvec4<T> tmp = detail::tvec4<T>(obj, T(1)); (
tmp = model * tmp; detail::tvec3<T> const & obj,
tmp = proj * tmp; detail::tmat4x4<T> const & model,
detail::tmat4x4<T> const & proj,
tmp /= tmp.w; detail::tvec4<U> const & viewport
tmp = tmp * T(0.5) + T(0.5); )
tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]); {
tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]); detail::tvec4<T> tmp = detail::tvec4<T>(obj, T(1));
tmp = model * tmp;
return detail::tvec3<T>(tmp); tmp = proj * tmp;
}
tmp /= tmp.w;
template <typename T, typename U> tmp = tmp * T(0.5) + T(0.5);
GLM_FUNC_QUALIFIER detail::tvec3<T> unProject tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]);
( tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]);
detail::tvec3<T> const & win,
detail::tmat4x4<T> const & model, return detail::tvec3<T>(tmp);
detail::tmat4x4<T> const & proj, }
detail::tvec4<U> const & viewport
) template <typename T, typename U>
{ GLM_FUNC_QUALIFIER detail::tvec3<T> unProject
detail::tmat4x4<T> inverse = glm::inverse(proj * model); (
detail::tvec3<T> const & win,
detail::tvec4<T> tmp = detail::tvec4<T>(win, T(1)); detail::tmat4x4<T> const & model,
tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]); detail::tmat4x4<T> const & proj,
tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]); detail::tvec4<U> const & viewport
tmp = tmp * T(2) - T(1); )
{
detail::tvec4<T> obj = inverse * tmp; detail::tmat4x4<T> inverse = glm::inverse(proj * model);
obj /= obj.w;
detail::tvec4<T> tmp = detail::tvec4<T>(win, T(1));
return detail::tvec3<T>(obj); tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]);
} tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]);
tmp = tmp * T(2) - T(1);
template <typename T, typename U>
detail::tmat4x4<T> pickMatrix detail::tvec4<T> obj = inverse * tmp;
( obj /= obj.w;
detail::tvec2<T> const & center,
detail::tvec2<T> const & delta, return detail::tvec3<T>(obj);
detail::tvec4<U> const & viewport }
)
{ template <typename T, typename U>
assert(delta.x > T(0) && delta.y > T(0)); detail::tmat4x4<T> pickMatrix
detail::tmat4x4<T> Result(1.0f); (
detail::tvec2<T> const & center,
if(!(delta.x > T(0) && delta.y > T(0))) detail::tvec2<T> const & delta,
return Result; // Error detail::tvec4<U> const & viewport
)
detail::tvec3<T> Temp( {
(T(viewport[2]) - T(2) * (center.x - T(viewport[0]))) / delta.x, assert(delta.x > T(0) && delta.y > T(0));
(T(viewport[3]) - T(2) * (center.y - T(viewport[1]))) / delta.y, detail::tmat4x4<T> Result(1.0f);
T(0));
if(!(delta.x > T(0) && delta.y > T(0)))
// Translate and scale the picked region to the entire window return Result; // Error
Result = translate(Result, Temp);
return scale(Result, detail::tvec3<T>(T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1))); detail::tvec3<T> Temp(
} (T(viewport[2]) - T(2) * (center.x - T(viewport[0]))) / delta.x,
(T(viewport[3]) - T(2) * (center.y - T(viewport[1]))) / delta.y,
template <typename T> T(0));
GLM_FUNC_QUALIFIER detail::tmat4x4<T> lookAt
( // Translate and scale the picked region to the entire window
detail::tvec3<T> const & eye, Result = translate(Result, Temp);
detail::tvec3<T> const & center, return scale(Result, detail::tvec3<T>(T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1)));
detail::tvec3<T> const & up }
)
{ template <typename T>
detail::tvec3<T> f = normalize(center - eye); GLM_FUNC_QUALIFIER detail::tmat4x4<T> lookAt
detail::tvec3<T> u = normalize(up); (
detail::tvec3<T> s = normalize(cross(f, u)); detail::tvec3<T> const & eye,
u = cross(s, f); detail::tvec3<T> const & center,
detail::tvec3<T> const & up
detail::tmat4x4<T> Result(1); )
Result[0][0] = s.x; {
Result[1][0] = s.y; detail::tvec3<T> f = normalize(center - eye);
Result[2][0] = s.z; detail::tvec3<T> u = normalize(up);
Result[0][1] = u.x; detail::tvec3<T> s = normalize(cross(f, u));
Result[1][1] = u.y; u = cross(s, f);
Result[2][1] = u.z;
Result[0][2] =-f.x; detail::tmat4x4<T> Result(1);
Result[1][2] =-f.y; Result[0][0] = s.x;
Result[2][2] =-f.z; Result[1][0] = s.y;
/* Test this instead of translate3D Result[2][0] = s.z;
Result[3][0] =-dot(s, eye); Result[0][1] = u.x;
Result[3][1] =-dot(y, eye); Result[1][1] = u.y;
Result[3][2] = dot(f, eye); Result[2][1] = u.z;
*/ Result[0][2] =-f.x;
return translate(Result, -eye); Result[1][2] =-f.y;
} Result[2][2] =-f.z;
/* Test this instead of translate3D
Result[3][0] =-dot(s, eye);
Result[3][1] =-dot(y, eye);
Result[3][2] = dot(f, eye);
*/
return translate(Result, -eye);
}
}//namespace glm }//namespace glm

1665
glm/gtc/noise.inl
View File

File diff suppressed because it is too large Load Diff

4
glm/gtc/quaternion.inl
Unescape View File

@ -29,8 +29,8 @@
#include <limits> #include <limits>
namespace glm{ namespace glm{
namespace detail{ namespace detail
{
template <typename T> template <typename T>
GLM_FUNC_QUALIFIER tquat<T>::tquat() : GLM_FUNC_QUALIFIER tquat<T>::tquat() :
x(0), x(0),

248
glm/gtc/swizzle.inl
Unescape View File

@ -26,165 +26,91 @@
/// @author Christophe Riccio /// @author Christophe Riccio
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
namespace glm{ namespace glm
{
template <typename T, template <typename> class vecType> template <typename T, template <typename> class vecType>
GLM_FUNC_QUALIFIER T swizzle GLM_FUNC_QUALIFIER T swizzle
( (
vecType<T> const & v, vecType<T> const & v,
comp x comp x
) )
{ {
assert(int(x) < int(vecType<T>::value_size)); assert(int(x) < int(vecType<T>::value_size));
return v[x]; return v[x];
} }
template <typename T, template <typename> class vecType> template <typename T, template <typename> class vecType>
GLM_FUNC_QUALIFIER detail::tvec2<T> swizzle GLM_FUNC_QUALIFIER detail::tvec2<T> swizzle
( (
vecType<T> const & v, vecType<T> const & v,
comp x, comp y comp x, comp y
) )
{ {
return detail::tvec2<T>( return detail::tvec2<T>(
v[x], v[x],
v[y]); v[y]);
} }
template <typename T, template <typename> class vecType> template <typename T, template <typename> class vecType>
GLM_FUNC_QUALIFIER detail::tvec3<T> swizzle GLM_FUNC_QUALIFIER detail::tvec3<T> swizzle
( (
vecType<T> const & v, vecType<T> const & v,
comp x, comp y, comp z comp x, comp y, comp z
) )
{ {
return detail::tvec3<T>( return detail::tvec3<T>(
v[x], v[x],
v[y], v[y],
v[z]); v[z]);
} }
template <typename T, template <typename> class vecType> template <typename T, template <typename> class vecType>
GLM_FUNC_QUALIFIER detail::tvec4<T> swizzle GLM_FUNC_QUALIFIER detail::tvec4<T> swizzle
( (
vecType<T> const & v, vecType<T> const & v,
comp x, comp y, comp z, comp w comp x, comp y, comp z, comp w
) )
{ {
return detail::tvec4<T>(v[x], v[y], v[z], v[w]); return detail::tvec4<T>(v[x], v[y], v[z], v[w]);
} }
template <typename T> template <typename T>
GLM_FUNC_QUALIFIER T& swizzle GLM_FUNC_QUALIFIER T& swizzle
( (
detail::tvec4<T> & v, detail::tvec4<T> & v,
comp x comp x
) )
{ {
return v[x]; return v[x];
} }
template <typename T> template <typename T>
GLM_FUNC_QUALIFIER detail::tref2<T> swizzle GLM_FUNC_QUALIFIER detail::tref2<T> swizzle
( (
detail::tvec4<T> & v, detail::tvec4<T> & v,
comp x, comp y comp x, comp y
) )
{ {
return detail::tref2<T>(v[x], v[y]); return detail::tref2<T>(v[x], v[y]);
} }
template <typename T> template <typename T>
GLM_FUNC_QUALIFIER detail::tref3<T> swizzle GLM_FUNC_QUALIFIER detail::tref3<T> swizzle
( (
detail::tvec4<T> & v, detail::tvec4<T> & v,
comp x, comp y, comp z comp x, comp y, comp z
) )
{ {
return detail::tref3<T>(v[x], v[y], v[z]); return detail::tref3<T>(v[x], v[y], v[z]);
} }
template <typename T> template <typename T>
GLM_FUNC_QUALIFIER detail::tref4<T> swizzle GLM_FUNC_QUALIFIER detail::tref4<T> swizzle
( (
detail::tvec4<T> & v, detail::tvec4<T> & v,
comp x, comp y, comp z, comp w comp x, comp y, comp z, comp w
) )
{ {
return detail::tref4<T>(v[x], v[y], v[z], v[w]); return detail::tref4<T>(v[x], v[y], v[z], v[w]);
} }
/*
template <comp x>
GLM_FUNC_QUALIFIER float& swizzle
(
detail::tvec4<float> & v
)
{
return v[x];
}
template <comp x>
GLM_FUNC_QUALIFIER int& swizzle
(
detail::tvec4<int> & v
)
{
return v[x];
}
template <comp x, comp y>
GLM_FUNC_QUALIFIER detail::tref2<float> swizzle
(
detail::tvec4<float> & v
)
{
return detail::tref2<float>(v[x], v[y]);
}
template <comp x, comp y>
GLM_FUNC_QUALIFIER detail::tref2<int> swizzle
(
detail::tvec4<int> & v
)
{
return detail::tref2<int>(v[x], v[y]);
}
template <comp x, comp y, comp z>
GLM_FUNC_QUALIFIER detail::tref3<float> swizzle
(
detail::tvec4<float> & v
)
{
return detail::tref3<float>(v[x], v[y], v[z]);
}
template <comp x, comp y, comp z>
GLM_FUNC_QUALIFIER detail::tref3<int> swizzle
(
detail::tvec4<int> & v
)
{
return detail::tref3<int>(v[x], v[y], v[z]);
}
template <comp x, comp y, comp z, comp w>
GLM_FUNC_QUALIFIER detail::tref4<float> swizzle
(
detail::tvec4<float> & v
)
{
return detail::tref4<float>(v[x], v[y], v[z], v[w]);
}
template <comp x, comp y, comp z, comp w>
GLM_FUNC_QUALIFIER detail::tref4<int> swizzle
(
detail::tvec4<int> & v
)
{
return detail::tref4<int>(v[x], v[y], v[z], v[w]);
}
*/
}//namespace glm }//namespace glm

Write Preview
Loading…
Cancel
Save