plugins/entity/angles.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_ANGLES_H )
  23 #define INCLUDED_ANGLES_H
  24
  25 #include "ientity.h"
  26
  27 #include "math/quaternion.h"
  28 #include "generic/callback.h"
  29 #include "stringio.h"
  30
  31 #include "angle.h"
  32
  33 const Vector3 ANGLESKEY_IDENTITY = Vector3(0, 0, 0);
  34
  35 inline void default_angles(Vector3 &angles)
  36 {
  37     angles = ANGLESKEY_IDENTITY;
  38 }
  39
  40 inline void normalise_angles(Vector3 &angles)
  41 {
  42     angles[0] = static_cast<float>( float_mod(angles[0], 360));
  43     angles[1] = static_cast<float>( float_mod(angles[1], 360));
  44     angles[2] = static_cast<float>( float_mod(angles[2], 360));
  45 }
  46
  47 inline void read_angle(Vector3 &angles, const char *value)
  48 {
  49     if (!string_parse_float(value, angles[2])) {
  50         default_angles(angles);
  51     } else {
  52         angles[0] = 0;
  53         angles[1] = 0;
  54         normalise_angles(angles);
  55     }
  56 }
  57
  58 inline void read_angles(Vector3 &angles, const char *value)
  59 {
  60     if (!string_parse_vector3(value, angles)) {
  61         default_angles(angles);
  62     } else {
  63         angles = Vector3(angles[2], angles[0], angles[1]);
  64         normalise_angles(angles);
  65     }
  66 }
  67
  68 inline void write_angles(const Vector3 &angles, Entity *entity)
  69 {
  70     if (angles[0] == 0
  71         && angles[1] == 0
  72         && angles[2] == 0) {
  73         entity->setKeyValue("angle", "");
  74         entity->setKeyValue("angles", "");
  75     } else {
  76         char value[64];
  77
  78         if (angles[0] == 0 && angles[1] == 0) {
  79             entity->setKeyValue("angles", "");
  80             write_angle(angles[2], entity);
  81         } else {
  82             sprintf(value, "%f %f %f", angles[1], angles[2], angles[0]);
  83             entity->setKeyValue("angle", "");
  84             entity->setKeyValue("angles", value);
  85         }
  86     }
  87 }
  88
  89 inline Vector3 angles_rotated(const Vector3 &angles, const Quaternion &rotation)
  90 {
  91     return matrix4_get_rotation_euler_xyz_degrees(
  92             matrix4_multiplied_by_matrix4(
  93                     matrix4_rotation_for_euler_xyz_degrees(angles),
  94                     matrix4_rotation_for_quaternion_quantised(rotation)
  95             )
  96     );
  97 }
  98
  99 class AnglesKey {
 100     Callback<void()> m_anglesChanged;
 101 public:
 102     Vector3 m_angles;
 103
 104
 105     AnglesKey(const Callback<void()> &anglesChanged)
 106             : m_anglesChanged(anglesChanged), m_angles(ANGLESKEY_IDENTITY)
 107     {
 108     }
 109
 110     void angleChanged(const char *value)
 111     {
 112         read_angle(m_angles, value);
 113         m_anglesChanged();
 114     }
 115
 116     typedef MemberCaller<AnglesKey, void(const char *), &AnglesKey::angleChanged> AngleChangedCaller;
 117
 118     void anglesChanged(const char *value)
 119     {
 120         read_angles(m_angles, value);
 121         m_anglesChanged();
 122     }
 123
 124     typedef MemberCaller<AnglesKey, void(const char *), &AnglesKey::anglesChanged> AnglesChangedCaller;
 125
 126     void write(Entity *entity) const
 127     {
 128         write_angles(m_angles, entity);
 129     }
 130 };
 131
 132
 133 #endif