radiant/brushmodule.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 "brushmodule.h"
  23
  24 #include "qerplugin.h"
  25
  26 #include "brushnode.h"
  27 #include "brushmanip.h"
  28
  29 #include "preferencesystem.h"
  30 #include "stringio.h"
  31
  32 #include "map.h"
  33 #include "qe3.h"
  34 #include "mainframe.h"
  35 #include "preferences.h"
  36
  37 LatchedBool g_useAlternativeTextureProjection(false, "Use alternative texture-projection");
  38 bool g_showAlternativeTextureProjectionOption = false;
  39
  40 bool getTextureLockEnabled()
  41 {
  42   return g_brush_texturelock_enabled;
  43 }
  44
  45 void Face_importSnapPlanes(bool value)
  46 {
  47   Face::m_quantise = value ? quantiseInteger : quantiseFloating;
  48 }
  49 typedef FreeCaller1<bool, Face_importSnapPlanes> FaceImportSnapPlanesCaller;
  50
  51 void Face_exportSnapPlanes(const BoolImportCallback& importer)
  52 {
  53   importer(Face::m_quantise == quantiseInteger);
  54 }
  55 typedef FreeCaller1<const BoolImportCallback&, Face_exportSnapPlanes> FaceExportSnapPlanesCaller;
  56
  57 void Brush_constructPreferences(PreferencesPage& page)
  58 {
  59   page.appendCheckBox(
  60     "", "Snap planes to integer grid",
  61     FaceImportSnapPlanesCaller(),
  62     FaceExportSnapPlanesCaller()
  63   );
  64   page.appendEntry(
  65     "Default texture scale",
  66     g_texdef_default_scale
  67   );
  68   if(g_showAlternativeTextureProjectionOption)
  69   {
  70     page.appendCheckBox(
  71       "", "Use alternative texture-projection",
  72       LatchedBoolImportCaller(g_useAlternativeTextureProjection),
  73       BoolExportCaller(g_useAlternativeTextureProjection.m_latched)
  74     );
  75   }
  76 }
  77 void Brush_constructPage(PreferenceGroup& group)
  78 {
  79   PreferencesPage page(group.createPage("Brush", "Brush Settings"));
  80   Brush_constructPreferences(page);
  81 }
  82 void Brush_registerPreferencesPage()
  83 {
  84   PreferencesDialog_addSettingsPage(FreeCaller1<PreferenceGroup&, Brush_constructPage>());
  85 }
  86
  87
  88 void Brush_Construct(EBrushType type)
  89 {
  90   if(type == eBrushTypeQuake3)
  91   {
  92     g_showAlternativeTextureProjectionOption = true;
  93
  94     GlobalPreferenceSystem().registerPreference(
  95       "AlternativeTextureProjection",
  96       BoolImportStringCaller(g_useAlternativeTextureProjection.m_latched),
  97       BoolExportStringCaller(g_useAlternativeTextureProjection.m_latched)
  98     );
  99     g_useAlternativeTextureProjection.useLatched();
 100
 101     if(g_useAlternativeTextureProjection.m_value)
 102     {
 103       type = eBrushTypeQuake3BP;
 104     }
 105   }
 106
 107   Brush_registerCommands();
 108   Brush_registerPreferencesPage();
 109
 110   BrushFilters_construct();
 111
 112   BrushClipPlane::constructStatic();
 113   BrushInstance::constructStatic();
 114   Brush::constructStatic(type);
 115
 116   Brush::m_maxWorldCoord = g_MaxWorldCoord;
 117   BrushInstance::m_counter = &g_brushCount;
 118
 119   g_texdef_default_scale = 0.5f;
 120   const char* value = g_pGameDescription->getKeyValue("default_scale");
 121   if(!string_empty(value))
 122   {
 123     float scale = static_cast<float>(atof(value));
 124     if(scale != 0)
 125     {
 126       g_texdef_default_scale = scale;
 127     }
 128     else
 129     {
 130       globalErrorStream() << "error parsing \"default_scale\" attribute\n";
 131     }
 132   }
 133
 134   FaceTextureClipboard_setDefault();
 135
 136   GlobalPreferenceSystem().registerPreference("TextureLock", BoolImportStringCaller(g_brush_texturelock_enabled), BoolExportStringCaller(g_brush_texturelock_enabled));
 137   GlobalPreferenceSystem().registerPreference("BrushSnapPlanes", makeBoolStringImportCallback(FaceImportSnapPlanesCaller()), makeBoolStringExportCallback(FaceExportSnapPlanesCaller()));
 138   GlobalPreferenceSystem().registerPreference("TexdefDefaultScale", FloatImportStringCaller(g_texdef_default_scale), FloatExportStringCaller(g_texdef_default_scale));
 139
 140   GridStatus_getTextureLockEnabled = getTextureLockEnabled;
 141   g_texture_lock_status_changed = FreeCaller<GridStatus_onTextureLockEnabledChanged>();
 142 }
 143
 144 void Brush_Destroy()
 145 {
 146   Brush::m_maxWorldCoord = 0;
 147   BrushInstance::m_counter = 0;
 148
 149   Brush::destroyStatic();
 150   BrushInstance::destroyStatic();
 151   BrushClipPlane::destroyStatic();
 152 }
 153
 154 void Brush_clipperColourChanged()
 155 {
 156   BrushClipPlane::destroyStatic();
 157   BrushClipPlane::constructStatic();
 158 }
 159
 160
 161 class Quake3BrushCreator : public BrushCreator
 162 {
 163 public:
 164   scene::Node& createBrush()
 165   {
 166     return (new BrushNode)->node();
 167   }
 168   bool useAlternativeTextureProjection() const
 169   {
 170     return g_useAlternativeTextureProjection.m_value;
 171   }
 172 };
 173
 174 Quake3BrushCreator g_Quake3BrushCreator;
 175
 176 BrushCreator& GetBrushCreator()
 177 {
 178   return g_Quake3BrushCreator;
 179 }
 180
 181 #include "modulesystem/singletonmodule.h"
 182 #include "modulesystem/moduleregistry.h"
 183
 184
 185 class BrushDependencies :
 186   public GlobalRadiantModuleRef,
 187   public GlobalSceneGraphModuleRef,
 188   public GlobalShaderCacheModuleRef,
 189   public GlobalSelectionModuleRef,
 190   public GlobalOpenGLModuleRef,
 191   public GlobalUndoModuleRef,
 192   public GlobalFilterModuleRef
 193 {
 194 };
 195
 196 class BrushDoom3API : public TypeSystemRef
 197 {
 198   BrushCreator* m_brushdoom3;
 199 public:
 200   typedef BrushCreator Type;
 201   STRING_CONSTANT(Name, "doom3");
 202
 203   BrushDoom3API()
 204   {
 205     Brush_Construct(eBrushTypeDoom3);
 206
 207      m_brushdoom3 = &GetBrushCreator();
 208   }
 209   ~BrushDoom3API()
 210   {
 211     Brush_Destroy();
 212   }
 213   BrushCreator* getTable()
 214   {
 215     return m_brushdoom3;
 216   }
 217 };
 218
 219 typedef SingletonModule<BrushDoom3API, BrushDependencies> BrushDoom3Module;
 220 typedef Static<BrushDoom3Module> StaticBrushDoom3Module;
 221 StaticRegisterModule staticRegisterBrushDoom3(StaticBrushDoom3Module::instance());
 222
 223
 224 class BrushQuake4API : public TypeSystemRef
 225 {
 226   BrushCreator* m_brushquake4;
 227 public:
 228   typedef BrushCreator Type;
 229   STRING_CONSTANT(Name, "quake4");
 230
 231   BrushQuake4API()
 232   {
 233     Brush_Construct(eBrushTypeQuake4);
 234
 235      m_brushquake4 = &GetBrushCreator();
 236   }
 237   ~BrushQuake4API()
 238   {
 239     Brush_Destroy();
 240   }
 241   BrushCreator* getTable()
 242   {
 243     return m_brushquake4;
 244   }
 245 };
 246
 247 typedef SingletonModule<BrushQuake4API, BrushDependencies> BrushQuake4Module;
 248 typedef Static<BrushQuake4Module> StaticBrushQuake4Module;
 249 StaticRegisterModule staticRegisterBrushQuake4(StaticBrushQuake4Module::instance());
 250
 251
 252 class BrushQuake3API : public TypeSystemRef
 253 {
 254   BrushCreator* m_brushquake3;
 255 public:
 256   typedef BrushCreator Type;
 257   STRING_CONSTANT(Name, "quake3");
 258
 259   BrushQuake3API()
 260   {
 261     Brush_Construct(eBrushTypeQuake3);
 262
 263     m_brushquake3 = &GetBrushCreator();
 264   }
 265   ~BrushQuake3API()
 266   {
 267     Brush_Destroy();
 268   }
 269   BrushCreator* getTable()
 270   {
 271     return m_brushquake3;
 272   }
 273 };
 274
 275 typedef SingletonModule<BrushQuake3API, BrushDependencies> BrushQuake3Module;
 276 typedef Static<BrushQuake3Module> StaticBrushQuake3Module;
 277 StaticRegisterModule staticRegisterBrushQuake3(StaticBrushQuake3Module::instance());
 278
 279
 280 class BrushQuake2API : public TypeSystemRef
 281 {
 282   BrushCreator* m_brushquake2;
 283 public:
 284   typedef BrushCreator Type;
 285   STRING_CONSTANT(Name, "quake2");
 286
 287   BrushQuake2API()
 288   {
 289     Brush_Construct(eBrushTypeQuake2);
 290
 291     m_brushquake2 = &GetBrushCreator();
 292   }
 293   ~BrushQuake2API()
 294   {
 295     Brush_Destroy();
 296   }
 297   BrushCreator* getTable()
 298   {
 299     return m_brushquake2;
 300   }
 301 };
 302
 303 typedef SingletonModule<BrushQuake2API, BrushDependencies> BrushQuake2Module;
 304 typedef Static<BrushQuake2Module> StaticBrushQuake2Module;
 305 StaticRegisterModule staticRegisterBrushQuake2(StaticBrushQuake2Module::instance());
 306
 307
 308 class BrushQuake1API : public TypeSystemRef
 309 {
 310   BrushCreator* m_brushquake1;
 311 public:
 312   typedef BrushCreator Type;
 313   STRING_CONSTANT(Name, "quake");
 314
 315   BrushQuake1API()
 316   {
 317     Brush_Construct(eBrushTypeQuake);
 318
 319     m_brushquake1 = &GetBrushCreator();
 320   }
 321   ~BrushQuake1API()
 322   {
 323     Brush_Destroy();
 324   }
 325   BrushCreator* getTable()
 326   {
 327     return m_brushquake1;
 328   }
 329 };
 330
 331 typedef SingletonModule<BrushQuake1API, BrushDependencies> BrushQuake1Module;
 332 typedef Static<BrushQuake1Module> StaticBrushQuake1Module;
 333 StaticRegisterModule staticRegisterBrushQuake1(StaticBrushQuake1Module::instance());
 334
 335
 336 class BrushHalfLifeAPI : public TypeSystemRef
 337 {
 338   BrushCreator* m_brushhalflife;
 339 public:
 340   typedef BrushCreator Type;
 341   STRING_CONSTANT(Name, "halflife");
 342
 343   BrushHalfLifeAPI()
 344   {
 345     Brush_Construct(eBrushTypeHalfLife);
 346
 347     m_brushhalflife = &GetBrushCreator();
 348   }
 349   ~BrushHalfLifeAPI()
 350   {
 351     Brush_Destroy();
 352   }
 353   BrushCreator* getTable()
 354   {
 355     return m_brushhalflife;
 356   }
 357 };
 358
 359 typedef SingletonModule<BrushHalfLifeAPI, BrushDependencies> BrushHalfLifeModule;
 360 typedef Static<BrushHalfLifeModule> StaticBrushHalfLifeModule;
 361 StaticRegisterModule staticRegisterBrushHalfLife(StaticBrushHalfLifeModule::instance());