plugins/entity/entity.cpp

   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 #include "entity.h"
  23
  24 #include "ifilter.h"
  25 #include "selectable.h"
  26 #include "namespace.h"
  27
  28 #include "scenelib.h"
  29 #include "entitylib.h"
  30 #include "eclasslib.h"
  31 #include "pivot.h"
  32
  33 #include "targetable.h"
  34 #include "uniquenames.h"
  35 #include "namekeys.h"
  36 #include "stream/stringstream.h"
  37 #include "filters.h"
  38
  39
  40 #include "miscmodel.h"
  41 #include "light.h"
  42 #include "group.h"
  43 #include "eclassmodel.h"
  44 #include "generic.h"
  45 #include "doom3group.h"
  46
  47
  48
  49 EGameType g_gameType;
  50
  51 inline scene::Node& entity_for_eclass(EntityClass* eclass)
  52 {
  53   if((string_compare_nocase_n(eclass->name(), "misc_", 5) == 0 && string_equal_nocase(eclass->name() + string_length(eclass->name()) - 5, "model")) // misc_*model (also misc_model) // TODO make classname_* wrapper functions for this
  54   || classname_equal(eclass->name(), "model_static"))
  55   {
  56     return New_MiscModel(eclass);
  57   }
  58   else if(classname_equal(eclass->name(), "light")
  59     || classname_equal(eclass->name(), "lightJunior"))
  60   {
  61     return New_Light(eclass);
  62   }
  63   if(!eclass->fixedsize)
  64   {
  65     if(g_gameType == eGameTypeDoom3)
  66     {
  67       return New_Doom3Group(eclass);
  68     }
  69     else
  70     {
  71       return New_Group(eclass);
  72     }
  73   }
  74   else if(!string_empty(eclass->modelpath()))
  75   {
  76     return New_EclassModel(eclass);
  77   }
  78   else
  79   {
  80     return New_GenericEntity(eclass);
  81   }
  82 }
  83
  84 void Entity_setName(Entity& entity, const char* name)
  85 {
  86   entity.setKeyValue("name", name);
  87 }
  88 typedef ReferenceCaller1<Entity, const char*, Entity_setName> EntitySetNameCaller;
  89
  90 inline Namespaced* Node_getNamespaced(scene::Node& node)
  91 {
  92   return NodeTypeCast<Namespaced>::cast(node);
  93 }
  94
  95 inline scene::Node& node_for_eclass(EntityClass* eclass)
  96 {
  97   scene::Node& node = entity_for_eclass(eclass);
  98   Node_getEntity(node)->setKeyValue("classname", eclass->name());
  99
 100   if(g_gameType == eGameTypeDoom3
 101     && string_not_empty(eclass->name())
 102     && !string_equal(eclass->name(), "worldspawn")
 103     && !string_equal(eclass->name(), "UNKNOWN_CLASS"))
 104   {
 105     char buffer[1024];
 106     strcpy(buffer, eclass->name());
 107     strcat(buffer, "_1");
 108     GlobalNamespace().makeUnique(buffer, EntitySetNameCaller(*Node_getEntity(node)));
 109   }
 110
 111   Namespaced* namespaced = Node_getNamespaced(node);
 112   if(namespaced != 0)
 113   {
 114     namespaced->setNamespace(GlobalNamespace());
 115   }
 116
 117   return node;
 118 }
 119
 120 EntityCreator::KeyValueChangedFunc EntityKeyValues::m_entityKeyValueChanged = 0;
 121 EntityCreator::KeyValueChangedFunc KeyValue::m_entityKeyValueChanged = 0;
 122 Counter* EntityKeyValues::m_counter = 0;
 123
 124 bool g_showNames = true;
 125 bool g_showAngles = true;
 126 bool g_newLightDraw = true;
 127 bool g_lightRadii = false;
 128
 129 class ConnectEntities
 130 {
 131 public:
 132   Entity* m_e1;
 133   Entity* m_e2;
 134   int m_index;
 135   ConnectEntities(Entity* e1, Entity* e2, int index) : m_e1(e1), m_e2(e2), m_index(index)
 136   {
 137   }
 138   const char *keyname()
 139   {
 140     StringOutputStream key(16);
 141     if(m_index <= 0)
 142       return "target";
 143     if(m_index == 1)
 144       return "killtarget";
 145     key << "target" << m_index;
 146     return key.c_str();
 147   }
 148   void connect(const char* name)
 149   {
 150           m_e1->setKeyValue(keyname(), name);
 151           m_e2->setKeyValue("targetname", name);
 152   }
 153   typedef MemberCaller1<ConnectEntities, const char*, &ConnectEntities::connect> ConnectCaller;
 154 };
 155
 156 inline Entity* ScenePath_getEntity(const scene::Path& path)
 157 {
 158   Entity* entity = Node_getEntity(path.top());
 159   if(entity == 0)
 160   {
 161     entity = Node_getEntity(path.parent());
 162   }
 163   return entity;
 164 }
 165
 166 class Quake3EntityCreator : public EntityCreator
 167 {
 168 public:
 169   scene::Node& createEntity(EntityClass* eclass)
 170   {
 171     return node_for_eclass(eclass);
 172   }
 173   void setKeyValueChangedFunc(KeyValueChangedFunc func)
 174   {
 175     EntityKeyValues::setKeyValueChangedFunc(func);
 176   }
 177   void setCounter(Counter* counter)
 178   {
 179     EntityKeyValues::setCounter(counter);
 180   }
 181   void connectEntities(const scene::Path& path, const scene::Path& targetPath, int index)
 182   {
 183     Entity* e1 = ScenePath_getEntity(path);
 184     Entity* e2 = ScenePath_getEntity(targetPath);
 185
 186     if(e1 == 0 || e2 == 0)
 187     {
 188       globalErrorStream() << "entityConnectSelected: both of the selected instances must be an entity\n";
 189       return;
 190     }
 191
 192     if(e1 == e2)
 193     {
 194       globalErrorStream() << "entityConnectSelected: the selected instances must not both be from the same entity\n";
 195       return;
 196     }
 197
 198
 199     UndoableCommand undo("entityConnectSelected");
 200
 201     if(g_gameType == eGameTypeDoom3)
 202     {
 203       StringOutputStream key(16);
 204       if(index >= 0)
 205       {
 206           key << "target";
 207           if(index != 0)
 208           {
 209             key << index;
 210           }
 211           e1->setKeyValue(key.c_str(), e2->getKeyValue("name"));
 212           key.clear();
 213       }
 214       else
 215       {
 216         for(unsigned int i = 0; ; ++i)
 217         {
 218           key << "target";
 219           if(i != 0)
 220           {
 221             key << i;
 222           }
 223           const char* value = e1->getKeyValue(key.c_str());
 224           if(string_empty(value))
 225           {
 226             e1->setKeyValue(key.c_str(), e2->getKeyValue("name"));
 227             break;
 228           }
 229           key.clear();
 230         }
 231       }
 232     }
 233     else
 234     {
 235       ConnectEntities connector(e1, e2, index);
 236       const char* value = e2->getKeyValue("targetname");
 237       if(!string_empty(value))
 238       {
 239         connector.connect(value);
 240       }
 241       else
 242       {
 243         const char* type = e2->getKeyValue("classname");
 244         if(string_empty(type))
 245         {
 246           type = "t";
 247         }
 248         StringOutputStream key(64);
 249         key << type << "1";
 250         GlobalNamespace().makeUnique(key.c_str(), ConnectEntities::ConnectCaller(connector));
 251       }
 252     }
 253
 254     SceneChangeNotify();
 255   }
 256   void setLightRadii(bool lightRadii)
 257   {
 258     g_lightRadii = lightRadii;
 259   }
 260   bool getLightRadii()
 261   {
 262     return g_lightRadii;
 263   }
 264   void setShowNames(bool showNames)
 265   {
 266     g_showNames = showNames;
 267   }
 268   bool getShowNames()
 269   {
 270     return g_showNames;
 271   }
 272   void setShowAngles(bool showAngles)
 273   {
 274     g_showAngles = showAngles;
 275   }
 276   bool getShowAngles()
 277   {
 278     return g_showAngles;
 279   }
 280
 281   void printStatistics() const
 282   {
 283     StringPool_analyse(EntityKeyValues::getPool());
 284   }
 285 };
 286
 287 Quake3EntityCreator g_Quake3EntityCreator;
 288
 289 EntityCreator& GetEntityCreator()
 290 {
 291   return g_Quake3EntityCreator;
 292 }
 293
 294
 295
 296 class filter_entity_classname : public EntityFilter
 297 {
 298   const char* m_classname;
 299 public:
 300   filter_entity_classname(const char* classname) : m_classname(classname)
 301   {
 302   }
 303   bool filter(const Entity& entity) const
 304   {
 305     return string_equal(entity.getKeyValue("classname"), m_classname);
 306   }
 307 };
 308
 309 class filter_entity_classgroup : public EntityFilter
 310 {
 311   const char* m_classgroup;
 312   std::size_t m_length;
 313 public:
 314   filter_entity_classgroup(const char* classgroup) : m_classgroup(classgroup), m_length(string_length(m_classgroup))
 315   {
 316   }
 317   bool filter(const Entity& entity) const
 318   {
 319     return string_equal_n(entity.getKeyValue("classname"), m_classgroup, m_length);
 320   }
 321 };
 322
 323 filter_entity_classname g_filter_entity_world("worldspawn");
 324 filter_entity_classname g_filter_entity_func_group("func_group");
 325 filter_entity_classname g_filter_entity_light("light");
 326 filter_entity_classname g_filter_entity_misc_model("misc_model");
 327 filter_entity_classname g_filter_entity_misc_gamemodel("misc_gamemodel");
 328 filter_entity_classgroup g_filter_entity_trigger("trigger_");
 329 filter_entity_classgroup g_filter_entity_path("path_");
 330
 331 class filter_entity_doom3model : public EntityFilter
 332 {
 333 public:
 334   bool filter(const Entity& entity) const
 335   {
 336     return string_equal(entity.getKeyValue("classname"), "func_static")
 337       && !string_equal(entity.getKeyValue("model"), entity.getKeyValue("name"));
 338   }
 339 };
 340
 341 filter_entity_doom3model g_filter_entity_doom3model;
 342
 343
 344 void Entity_InitFilters()
 345 {
 346         add_entity_filter(g_filter_entity_world, EXCLUDE_WORLD);
 347         add_entity_filter(g_filter_entity_func_group, EXCLUDE_WORLD);
 348         add_entity_filter(g_filter_entity_world, EXCLUDE_ENT, true);
 349     add_entity_filter(g_filter_entity_trigger, EXCLUDE_TRIGGERS);
 350         add_entity_filter(g_filter_entity_misc_model, EXCLUDE_MODELS);
 351     add_entity_filter(g_filter_entity_misc_gamemodel, EXCLUDE_MODELS);
 352         add_entity_filter(g_filter_entity_doom3model, EXCLUDE_MODELS);
 353         add_entity_filter(g_filter_entity_light, EXCLUDE_LIGHTS);
 354         add_entity_filter(g_filter_entity_path, EXCLUDE_PATHS);
 355 }
 356
 357
 358 #include "preferencesystem.h"
 359
 360 void Entity_Construct(EGameType gameType)
 361 {
 362   g_gameType = gameType;
 363   if(g_gameType == eGameTypeDoom3)
 364   {
 365     g_targetable_nameKey = "name";
 366
 367     Static<KeyIsName>::instance().m_keyIsName = keyIsNameDoom3;
 368     Static<KeyIsName>::instance().m_nameKey = "name";
 369   }
 370   else
 371   {
 372     Static<KeyIsName>::instance().m_keyIsName = keyIsNameQuake3;
 373     Static<KeyIsName>::instance().m_nameKey = "targetname";
 374   }
 375
 376   GlobalPreferenceSystem().registerPreference("SI_ShowNames", BoolImportStringCaller(g_showNames), BoolExportStringCaller(g_showNames));
 377   GlobalPreferenceSystem().registerPreference("SI_ShowAngles", BoolImportStringCaller(g_showAngles), BoolExportStringCaller(g_showAngles));
 378   GlobalPreferenceSystem().registerPreference("NewLightStyle", BoolImportStringCaller(g_newLightDraw), BoolExportStringCaller(g_newLightDraw));
 379   GlobalPreferenceSystem().registerPreference("LightRadiuses", BoolImportStringCaller(g_lightRadii), BoolExportStringCaller(g_lightRadii));
 380
 381   Entity_InitFilters();
 382   LightType lightType = LIGHTTYPE_DEFAULT;
 383   if(g_gameType == eGameTypeRTCW)
 384   {
 385     lightType = LIGHTTYPE_RTCW;
 386   }
 387   else if(g_gameType == eGameTypeDoom3)
 388   {
 389     lightType = LIGHTTYPE_DOOM3;
 390   }
 391   Light_Construct(lightType);
 392   MiscModel_construct();
 393   Doom3Group_construct();
 394
 395   RenderablePivot::StaticShader::instance() = GlobalShaderCache().capture("$PIVOT");
 396
 397   GlobalShaderCache().attachRenderable(StaticRenderableConnectionLines::instance());
 398 }
 399
 400 void Entity_Destroy()
 401 {
 402   GlobalShaderCache().detachRenderable(StaticRenderableConnectionLines::instance());
 403
 404   GlobalShaderCache().release("$PIVOT");
 405
 406   Doom3Group_destroy();
 407   MiscModel_destroy();
 408   Light_Destroy();
 409 }