entity/rotation.h

   1 /*
   2 Copyright (C) 2001-2006, William Joseph.
   3 All Rights Reserved.
   4
   5 This file is part of GtkRadiant.
   6
   7 GtkRadiant is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 GtkRadiant is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GtkRadiant; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20 */
  21
  22 #if !defined(INCLUDED_ROTATION_H)
  23 #define INCLUDED_ROTATION_H
  24
  25 #include "ientity.h"
  26
  27 #include "stream/stringstream.h"
  28 #include "math/quaternion.h"
  29 #include "generic/callback.h"
  30 #include "stringio.h"
  31
  32 #include "angle.h"
  33
  34 typedef float Float9[9];
  35
  36 inline void default_rotation(Float9 rotation)
  37 {
  38   rotation[0] = 1;
  39   rotation[1] = 0;
  40   rotation[2] = 0;
  41   rotation[3] = 0;
  42   rotation[4] = 1;
  43   rotation[5] = 0;
  44   rotation[6] = 0;
  45   rotation[7] = 0;
  46   rotation[8] = 1;
  47 }
  48 inline void write_rotation(const Float9 rotation, Entity* entity, const char* key = "rotation")
  49 {
  50   if(rotation[0] == 1
  51     && rotation[1] == 0
  52     && rotation[2] == 0
  53     && rotation[3] == 0
  54     && rotation[4] == 1
  55     && rotation[5] == 0
  56     && rotation[6] == 0
  57     && rotation[7] == 0
  58     && rotation[8] == 1)
  59   {
  60     entity->setKeyValue(key, "");
  61   }
  62   else
  63   {
  64     StringOutputStream value(256);
  65     value << rotation[0] << ' '
  66       << rotation[1] << ' '
  67       << rotation[2] << ' '
  68       << rotation[3] << ' '
  69       << rotation[4] << ' '
  70       << rotation[5] << ' '
  71       << rotation[6] << ' '
  72       << rotation[7] << ' '
  73       << rotation[8];
  74     entity->setKeyValue(key, value.c_str());
  75   }
  76 }
  77 inline void read_rotation(Float9 rotation, const char* value)
  78 {
  79   if(!string_parse_vector(value, rotation, rotation + 9))
  80   {
  81     default_rotation(rotation);
  82   }
  83 }
  84
  85 inline Matrix4 rotation_toMatrix(const Float9 rotation)
  86 {
  87   return Matrix4(
  88     rotation[0],
  89     rotation[1],
  90     rotation[2],
  91     0,
  92     rotation[3],
  93     rotation[4],
  94     rotation[5],
  95     0,
  96     rotation[6],
  97     rotation[7],
  98     rotation[8],
  99     0,
 100     0,
 101     0,
 102     0,
 103     1
 104   );
 105 }
 106
 107 inline void rotation_fromMatrix(Float9 rotation, const Matrix4& matrix)
 108 {
 109   rotation[0] = matrix.xx();
 110   rotation[1] = matrix.xy();
 111   rotation[2] = matrix.xz();
 112   rotation[3] = matrix.yx();
 113   rotation[4] = matrix.yy();
 114   rotation[5] = matrix.yz();
 115   rotation[6] = matrix.zx();
 116   rotation[7] = matrix.zy();
 117   rotation[8] = matrix.zz();
 118 }
 119
 120 inline void rotation_assign(Float9 rotation, const Float9 other)
 121 {
 122   rotation[0] = other[0];
 123   rotation[1] = other[1];
 124   rotation[2] = other[2];
 125   rotation[3] = other[3];
 126   rotation[4] = other[4];
 127   rotation[5] = other[5];
 128   rotation[6] = other[6];
 129   rotation[7] = other[7];
 130   rotation[8] = other[8];
 131 }
 132
 133 inline void rotation_rotate(Float9 rotation, const Quaternion& rotate)
 134 {
 135   rotation_fromMatrix(rotation,
 136     matrix4_multiplied_by_matrix4(
 137       rotation_toMatrix(rotation),
 138       matrix4_rotation_for_quaternion_quantised(rotate)
 139     )
 140   );
 141 }
 142
 143 inline void read_angle(Float9 rotation, const char* value)
 144 {
 145   float angle;
 146   if(!string_parse_float(value, angle))
 147   {
 148     default_rotation(rotation);
 149   }
 150   else
 151   {
 152     rotation_fromMatrix(rotation,  matrix4_rotation_for_z_degrees(angle));
 153   }
 154 }
 155
 156 class RotationKey
 157 {
 158   Callback m_rotationChanged;
 159 public:
 160   Float9 m_rotation;
 161
 162
 163   RotationKey(const Callback& rotationChanged)
 164     : m_rotationChanged(rotationChanged)
 165   {
 166     default_rotation(m_rotation);
 167   }
 168
 169   void angleChanged(const char* value)
 170   {
 171     read_angle(m_rotation, value);
 172     m_rotationChanged();
 173   }
 174   typedef MemberCaller1<RotationKey, const char*, &RotationKey::angleChanged> AngleChangedCaller;
 175
 176   void rotationChanged(const char* value)
 177   {
 178     read_rotation(m_rotation, value);
 179     m_rotationChanged();
 180   }
 181   typedef MemberCaller1<RotationKey, const char*, &RotationKey::rotationChanged> RotationChangedCaller;
 182
 183   void write(Entity* entity) const
 184   {
 185     Vector3 euler = matrix4_get_rotation_euler_xyz_degrees(rotation_toMatrix(m_rotation));
 186     if(euler[0] == 0 && euler[1] == 0)
 187     {
 188       entity->setKeyValue("rotation", "");
 189       write_angle(euler[2], entity);
 190     }
 191     else
 192     {
 193       entity->setKeyValue("angle", "");
 194       write_rotation(m_rotation, entity);
 195     }
 196   }
 197 };
 198
 199 #endif