source/animation/transform.cpp

   1 #include "transform.h"
   2
   3 namespace Msp {
   4 namespace GL {
   5
   6 Transform::Transform():
   7         position(0.0f, 0.0f, 0.0f),
   8         euler(Angle::zero(), Angle::zero(), Angle::zero()),
   9         scale(1.0f, 1.0f, 1.0f),
  10         mask(NONE)
  11 { }
  12
  13 Transform Transform::from_matrix(const Matrix &matrix)
  14 {
  15         Transform trn;
  16         trn.position = matrix.column(3).slice<3>(0);
  17
  18         trn.euler.z = Geometry::atan2<float>(matrix(1, 0), matrix(0, 0));
  19         Matrix m = Matrix::rotation(-trn.euler.z, Vector3(0.0f, 0.0f, 1.0f))*matrix;
  20         trn.euler.y = Geometry::atan2<float>(-m(2, 0), m(0, 0));
  21         m = Matrix::rotation(-trn.euler.y, Vector3(0.0f, 1.0f, 0.0f))*m;
  22         trn.euler.x = Geometry::atan2<float>(m(2, 1), m(1, 1));
  23         m = Matrix::rotation(-trn.euler.x, Vector3(1.0f, 0.0f, 0.0f))*m;
  24
  25         trn.scale = Vector3(m(0, 0), m(1, 1), m(2, 2));
  26
  27         trn.mask = POSITION|EULER|SCALE;
  28         return trn;
  29 }
  30
  31 void Transform::set_position(const Vector3 &p)
  32 {
  33         position = p;
  34         mask = mask|POSITION;
  35 }
  36
  37 void Transform::set_euler(const AngleVector3 &e)
  38 {
  39         euler = e;
  40         mask = mask|EULER;
  41 }
  42
  43 void Transform::set_rotation(const Angle &angle, const Vector3 &axis)
  44 {
  45         euler = from_matrix(Matrix::rotation(angle, axis)).euler;
  46         mask = mask|EULER;
  47 }
  48
  49 void Transform::set_scale(float s)
  50 {
  51         set_scale(Vector3(s, s, s));
  52 }
  53
  54 void Transform::set_scale(const Vector3 &s)
  55 {
  56         scale = s;
  57         mask = mask|SCALE;
  58 }
  59
  60 Matrix Transform::to_matrix() const
  61 {
  62         Matrix result;
  63         result.translate(position);
  64         result.rotate(euler.z, Vector3(0.0f, 0.0f, 1.0f));
  65         result.rotate(euler.y, Vector3(0.0f, 1.0f, 0.0f));
  66         result.rotate(euler.x, Vector3(1.0f, 0.0f, 0.0f));
  67         result.scale(scale);
  68         return result;
  69 }
  70
  71
  72 Transform::Loader::Loader(Transform &t):
  73         DataFile::ObjectLoader<Transform>(t)
  74 {
  75         add("position_x", &Loader::position_x);
  76         add("position_y", &Loader::position_y);
  77         add("position_z", &Loader::position_z);
  78         add("position", &Loader::position);
  79         add("euler_x", &Loader::euler_x);
  80         add("euler_y", &Loader::euler_y);
  81         add("euler_z", &Loader::euler_z);
  82         add("euler", &Loader::euler);
  83         add("rotation", &Loader::rotation);
  84         add("scale_x", &Loader::scale_x);
  85         add("scale_y", &Loader::scale_y);
  86         add("scale_z", &Loader::scale_z);
  87         add("scale", &Loader::scale_uniform);
  88         add("scale", &Loader::scale);
  89 }
  90
  91 void Transform::Loader::position_x(float x)
  92 {
  93         obj.position.x = x;
  94         obj.mask = obj.mask|POSITION_X;
  95 }
  96
  97 void Transform::Loader::position_y(float y)
  98 {
  99         obj.position.y = y;
 100         obj.mask = obj.mask|POSITION_Y;
 101 }
 102
 103 void Transform::Loader::position_z(float z)
 104 {
 105         obj.position.z = z;
 106         obj.mask = obj.mask|POSITION_Z;
 107 }
 108
 109 void Transform::Loader::position(float x, float y, float z)
 110 {
 111         obj.set_position(Vector3(x, y, z));
 112 }
 113
 114 void Transform::Loader::euler_x(float x)
 115 {
 116         obj.euler.x = Angle::from_degrees(x);
 117         obj.mask = obj.mask|EULER_X;
 118 }
 119
 120 void Transform::Loader::euler_y(float y)
 121 {
 122         obj.euler.y = Angle::from_degrees(y);
 123         obj.mask = obj.mask|EULER_Y;
 124 }
 125
 126 void Transform::Loader::euler_z(float z)
 127 {
 128         obj.euler.z = Angle::from_degrees(z);
 129         obj.mask = obj.mask|EULER_Z;
 130 }
 131
 132 void Transform::Loader::euler(float x, float y, float z)
 133 {
 134         obj.set_euler(AngleVector3(Angle::from_degrees(x), Angle::from_degrees(y), Angle::from_degrees(z)));
 135 }
 136
 137 void Transform::Loader::rotation(float a, float x, float y, float z)
 138 {
 139         obj.set_rotation(Angle::from_degrees(a), Vector3(x, y, z));
 140 }
 141
 142 void Transform::Loader::scale_x(float x)
 143 {
 144         obj.scale.x = x;
 145         obj.mask = obj.mask|SCALE_X;
 146 }
 147
 148 void Transform::Loader::scale_y(float y)
 149 {
 150         obj.scale.y = y;
 151         obj.mask = obj.mask|SCALE_Y;
 152 }
 153
 154 void Transform::Loader::scale_z(float z)
 155 {
 156         obj.scale.z = z;
 157         obj.mask = obj.mask|SCALE_Z;
 158 }
 159
 160 void Transform::Loader::scale_uniform(float s)
 161 {
 162         obj.set_scale(s);
 163 }
 164
 165 void Transform::Loader::scale(float x, float y, float z)
 166 {
 167         obj.set_scale(Vector3(x, y, z));
 168 }
 169
 170 } // namespace GL
 171 } // namespace Msp