plugins/entity/scale.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_SCALE_H )
  23 #define INCLUDED_SCALE_H
  24
  25 #include "ientity.h"
  26
  27 #include "math/matrix.h"
  28 #include "generic/callback.h"
  29 #include "stringio.h"
  30
  31 const Vector3 SCALEKEY_IDENTITY = Vector3(1, 1, 1);
  32
  33 inline void default_scale(Vector3 &scale)
  34 {
  35     scale = SCALEKEY_IDENTITY;
  36 }
  37
  38 inline void read_scale(Vector3 &scalevec, const char *value)
  39 {
  40     float scale;
  41     if (!string_parse_float(value, scale)
  42         || scale == 0) {
  43         default_scale(scalevec);
  44     } else {
  45         scalevec = Vector3(scale, scale, scale);
  46     }
  47 }
  48
  49 inline void read_scalevec(Vector3 &scale, const char *value)
  50 {
  51     if (!string_parse_vector3(value, scale)
  52         || scale[0] == 0
  53         || scale[1] == 0
  54         || scale[2] == 0) {
  55         default_scale(scale);
  56     }
  57 }
  58
  59 inline void write_scale(const Vector3 &scale, Entity *entity)
  60 {
  61     if (scale[0] == 1 && scale[1] == 1 && scale[2] == 1) {
  62         entity->setKeyValue("modelscale", "");
  63         entity->setKeyValue("modelscale_vec", "");
  64     } else {
  65         char value[64];
  66
  67         if (scale[0] == scale[1] && scale[0] == scale[2]) {
  68             sprintf(value, "%f", scale[0]);
  69             entity->setKeyValue("modelscale_vec", "");
  70             entity->setKeyValue("modelscale", value);
  71         } else {
  72             sprintf(value, "%f %f %f", scale[0], scale[1], scale[2]);
  73             entity->setKeyValue("modelscale", "");
  74             entity->setKeyValue("modelscale_vec", value);
  75         }
  76     }
  77 }
  78
  79 inline Vector3 scale_scaled(const Vector3 &scale, const Vector3 &scaling)
  80 {
  81     return matrix4_get_scale_vec3(
  82             matrix4_multiplied_by_matrix4(
  83                     matrix4_scale_for_vec3(scale),
  84                     matrix4_scale_for_vec3(scaling)
  85             )
  86     );
  87 }
  88
  89
  90 class ScaleKey {
  91     Callback<void()> m_scaleChanged;
  92 public:
  93     Vector3 m_scale;
  94
  95
  96     ScaleKey(const Callback<void()> &scaleChanged)
  97             : m_scaleChanged(scaleChanged), m_scale(SCALEKEY_IDENTITY)
  98     {
  99     }
 100
 101     void uniformScaleChanged(const char *value)
 102     {
 103         read_scale(m_scale, value);
 104         m_scaleChanged();
 105     }
 106
 107     typedef MemberCaller<ScaleKey, void(const char *), &ScaleKey::uniformScaleChanged> UniformScaleChangedCaller;
 108
 109     void scaleChanged(const char *value)
 110     {
 111         read_scalevec(m_scale, value);
 112         m_scaleChanged();
 113     }
 114
 115     typedef MemberCaller<ScaleKey, void(const char *), &ScaleKey::scaleChanged> ScaleChangedCaller;
 116
 117     void write(Entity *entity) const
 118     {
 119         write_scale(m_scale, entity);
 120     }
 121 };
 122
 123
 124 #endif