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