Dogcows Code - chaz/yoink/blob - src/Moof/cml/mathlib/vector_transform.h

   1 /* -*- C++ -*- ------------------------------------------------------------
   2
   3 Copyright (c) 2007 Jesse Anders and Demian Nave http://cmldev.net/
   4
   5 The Configurable Math Library (CML) is distributed under the terms of the
   6 Boost Software License, v1.0 (see cml/LICENSE for details).
   7
   8  *-----------------------------------------------------------------------*/
   9 /** @file
  10  *  @brief
  11  */
  12
  13 #ifndef vector_transform_h
  14 #define vector_transform_h
  15
  16 #include <cml/mathlib/checking.h>
  17
  18 /* Functions for transforming a vector, representing a geometric point or
  19  * or vector, by an affine transfom.
  20  *
  21  * Note: This functionality may be provisional, depending on what architecture
  22  * we settle on for the higher-level math functions. If we do keep these
  23  * functions, then this code may ending up being a placeholder for expression
  24  * template code.
  25  */
  26
  27 namespace cml {
  28
  29 /** A fixed-size temporary 4D vector */
  30 #define TEMP_VEC4 vector<          \
  31     typename et::ScalarPromote<    \
  32         typename MatT::value_type, \
  33         typename VecT::value_type  \
  34     >::type,                       \
  35     fixed<4>                       \
  36 >
  37
  38 /** A fixed-size temporary 3D vector */
  39 #define TEMP_VEC3 vector<          \
  40     typename et::ScalarPromote<    \
  41         typename MatT::value_type, \
  42         typename VecT::value_type  \
  43     >::type,                       \
  44     fixed<3>                       \
  45 >
  46
  47 /** A fixed-size temporary 2D vector */
  48 #define TEMP_VEC2 vector<          \
  49     typename et::ScalarPromote<    \
  50         typename MatT::value_type, \
  51         typename VecT::value_type  \
  52     >::type,                       \
  53     fixed<2>                       \
  54 >
  55
  56 namespace detail {
  57
  58 template < class MatT, class VecT > TEMP_VEC4
  59 transform_vector_4D(const MatT& m, const VecT& v, row_basis) {
  60     return v*m;
  61 }
  62
  63 template < class MatT, class VecT > TEMP_VEC4
  64 transform_vector_4D(const MatT& m, const VecT& v, col_basis) {
  65     return m*v;
  66 }
  67
  68 } // namespace detail
  69
  70 /** Apply a 4x4 homogeneous transform matrix to a 4D vector */
  71 template < class MatT, class VecT > TEMP_VEC4
  72 transform_vector_4D(const MatT& m, const VecT& v) {
  73     return detail::transform_vector_4D(m,v,typename MatT::basis_orient());
  74 }
  75
  76 /** Apply a 3D affine transform to a 3D point */
  77 template < class MatT, class VecT > TEMP_VEC3
  78 transform_point(const MatT& m, const VecT& v)
  79 {
  80     typedef TEMP_VEC3 vector_type;
  81
  82     /* Checking */
  83     detail::CheckMatAffine3D(m);
  84     detail::CheckVec3(v);
  85
  86     return vector_type(
  87         m.basis_element(0,0)*v[0]+m.basis_element(1,0)*v[1]+
  88             m.basis_element(2,0)*v[2]+m.basis_element(3,0),
  89         m.basis_element(0,1)*v[0]+m.basis_element(1,1)*v[1]+
  90             m.basis_element(2,1)*v[2]+m.basis_element(3,1),
  91         m.basis_element(0,2)*v[0]+m.basis_element(1,2)*v[1]+
  92             m.basis_element(2,2)*v[2]+m.basis_element(3,2)
  93     );
  94 }
  95
  96 /** Apply a 3D affine transform to a 3D vector */
  97 template < class MatT, class VecT > TEMP_VEC3
  98 transform_vector(const MatT& m, const VecT& v)
  99 {
 100     typedef TEMP_VEC3 vector_type;
 101
 102     /* Checking */
 103     detail::CheckMatLinear3D(m);
 104     detail::CheckVec3(v);
 105
 106     return vector_type(
 107         m.basis_element(0,0)*v[0]+m.basis_element(1,0)*v[1]+
 108             m.basis_element(2,0)*v[2],
 109         m.basis_element(0,1)*v[0]+m.basis_element(1,1)*v[1]+
 110             m.basis_element(2,1)*v[2],
 111         m.basis_element(0,2)*v[0]+m.basis_element(1,2)*v[1]+
 112             m.basis_element(2,2)*v[2]
 113     );
 114 }
 115
 116 /** Apply a 2D affine transform to a 2D point */
 117 template < class MatT, class VecT > TEMP_VEC2
 118 transform_point_2D(const MatT& m, const VecT& v)
 119 {
 120     typedef TEMP_VEC2 vector_type;
 121
 122     /* Checking */
 123     detail::CheckMatAffine2D(m);
 124     detail::CheckVec2(v);
 125
 126     return vector_type(
 127         m.basis_element(0,0)*v[0]+m.basis_element(1,0)*v[1]+
 128             m.basis_element(2,0),
 129         m.basis_element(0,1)*v[0]+m.basis_element(1,1)*v[1]+
 130             m.basis_element(2,1)
 131     );
 132 }
 133
 134 /** Apply a 2D affine transform to a 2D vector */
 135 template < class MatT, class VecT > TEMP_VEC2
 136 transform_vector_2D(const MatT& m, const VecT& v)
 137 {
 138     typedef TEMP_VEC2 vector_type;
 139
 140     /* Checking */
 141     detail::CheckMatLinear2D(m);
 142     detail::CheckVec2(v);
 143
 144     return vector_type(
 145         m.basis_element(0,0)*v[0] + m.basis_element(1,0)*v[1],
 146         m.basis_element(0,1)*v[0] + m.basis_element(1,1)*v[1]
 147     );
 148 }
 149
 150 #undef TEMP_VEC4
 151 #undef TEMP_VEC3
 152 #undef TEMP_VEC2
 153
 154 } // namespace cml
 155
 156 #endif