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   GlobalPreferenceSystem().registerPreference("TextureLock", BoolImportStringCaller(g_brush_texturelock_enabled), BoolExportStringCaller(g_brush_texturelock_enabled));
 135   GlobalPreferenceSystem().registerPreference("BrushSnapPlanes", makeBoolStringImportCallback(FaceImportSnapPlanesCaller()), makeBoolStringExportCallback(FaceExportSnapPlanesCaller()));
 136   GlobalPreferenceSystem().registerPreference("TexdefDefaultScale", FloatImportStringCaller(g_texdef_default_scale), FloatExportStringCaller(g_texdef_default_scale));
 137
 138   GridStatus_getTextureLockEnabled = getTextureLockEnabled;
 139   g_texture_lock_status_changed = FreeCaller<GridStatus_onTextureLockEnabledChanged>();
 140 }
 141
 142 void Brush_Destroy()
 143 {
 144   Brush::m_maxWorldCoord = 0;
 145   BrushInstance::m_counter = 0;
 146
 147   Brush::destroyStatic();
 148   BrushInstance::destroyStatic();
 149   BrushClipPlane::destroyStatic();
 150 }
 151
 152 void Brush_clipperColourChanged()
 153 {
 154   BrushClipPlane::destroyStatic();
 155   BrushClipPlane::constructStatic();
 156 }
 157
 158 void BrushFaceData_fromFace(const BrushFaceDataCallback& callback, Face& face)
 159 {
 160   _QERFaceData faceData;
 161   faceData.m_p0 = face.getPlane().planePoints()[0];
 162   faceData.m_p1 = face.getPlane().planePoints()[1];
 163   faceData.m_p2 = face.getPlane().planePoints()[2];
 164   faceData.m_shader = face.GetShader();
 165   faceData.m_texdef = face.getTexdef().m_projection.m_texdef;
 166   faceData.contents = face.getShader().m_flags.m_contentFlags;
 167   faceData.flags = face.getShader().m_flags.m_surfaceFlags;
 168   faceData.value = face.getShader().m_flags.m_value;
 169   callback(faceData);
 170 }
 171 typedef ConstReferenceCaller1<BrushFaceDataCallback, Face&, BrushFaceData_fromFace> BrushFaceDataFromFaceCaller;
 172 typedef Callback1<Face&> FaceCallback;
 173
 174 class Quake3BrushCreator : public BrushCreator
 175 {
 176 public:
 177   scene::Node& createBrush()
 178   {
 179     return (new BrushNode)->node();
 180   }
 181   bool useAlternativeTextureProjection() const
 182   {
 183     return g_useAlternativeTextureProjection.m_value;
 184   }
 185   void Brush_forEachFace(scene::Node& brush, const BrushFaceDataCallback& callback)
 186   {
 187     ::Brush_forEachFace(*Node_getBrush(brush), FaceCallback(BrushFaceDataFromFaceCaller(callback)));
 188   }
 189   bool Brush_addFace(scene::Node& brush, const _QERFaceData& faceData)
 190   {
 191     Node_getBrush(brush)->undoSave();
 192     return Node_getBrush(brush)->addPlane(faceData.m_p0, faceData.m_p1, faceData.m_p2, faceData.m_shader, TextureProjection(faceData.m_texdef, brushprimit_texdef_t(), Vector3(0, 0, 0), Vector3(0, 0, 0))) != 0;
 193   }
 194 };
 195
 196 Quake3BrushCreator g_Quake3BrushCreator;
 197
 198 BrushCreator& GetBrushCreator()
 199 {
 200   return g_Quake3BrushCreator;
 201 }
 202
 203 #include "modulesystem/singletonmodule.h"
 204 #include "modulesystem/moduleregistry.h"
 205
 206
 207 class BrushDependencies :
 208   public GlobalRadiantModuleRef,
 209   public GlobalSceneGraphModuleRef,
 210   public GlobalShaderCacheModuleRef,
 211   public GlobalSelectionModuleRef,
 212   public GlobalOpenGLModuleRef,
 213   public GlobalUndoModuleRef,
 214   public GlobalFilterModuleRef
 215 {
 216 };
 217
 218 class BrushDoom3API : public TypeSystemRef
 219 {
 220   BrushCreator* m_brushdoom3;
 221 public:
 222   typedef BrushCreator Type;
 223   STRING_CONSTANT(Name, "doom3");
 224
 225   BrushDoom3API()
 226   {
 227     Brush_Construct(eBrushTypeDoom3);
 228
 229      m_brushdoom3 = &GetBrushCreator();
 230   }
 231   ~BrushDoom3API()
 232   {
 233     Brush_Destroy();
 234   }
 235   BrushCreator* getTable()
 236   {
 237     return m_brushdoom3;
 238   }
 239 };
 240
 241 typedef SingletonModule<BrushDoom3API, BrushDependencies> BrushDoom3Module;
 242 typedef Static<BrushDoom3Module> StaticBrushDoom3Module;
 243 StaticRegisterModule staticRegisterBrushDoom3(StaticBrushDoom3Module::instance());
 244
 245
 246 class BrushQuake4API : public TypeSystemRef
 247 {
 248   BrushCreator* m_brushquake4;
 249 public:
 250   typedef BrushCreator Type;
 251   STRING_CONSTANT(Name, "quake4");
 252
 253   BrushQuake4API()
 254   {
 255     Brush_Construct(eBrushTypeQuake4);
 256
 257      m_brushquake4 = &GetBrushCreator();
 258   }
 259   ~BrushQuake4API()
 260   {
 261     Brush_Destroy();
 262   }
 263   BrushCreator* getTable()
 264   {
 265     return m_brushquake4;
 266   }
 267 };
 268
 269 typedef SingletonModule<BrushQuake4API, BrushDependencies> BrushQuake4Module;
 270 typedef Static<BrushQuake4Module> StaticBrushQuake4Module;
 271 StaticRegisterModule staticRegisterBrushQuake4(StaticBrushQuake4Module::instance());
 272
 273
 274 class BrushQuake3API : public TypeSystemRef
 275 {
 276   BrushCreator* m_brushquake3;
 277 public:
 278   typedef BrushCreator Type;
 279   STRING_CONSTANT(Name, "quake3");
 280
 281   BrushQuake3API()
 282   {
 283     Brush_Construct(eBrushTypeQuake3);
 284
 285     m_brushquake3 = &GetBrushCreator();
 286   }
 287   ~BrushQuake3API()
 288   {
 289     Brush_Destroy();
 290   }
 291   BrushCreator* getTable()
 292   {
 293     return m_brushquake3;
 294   }
 295 };
 296
 297 typedef SingletonModule<BrushQuake3API, BrushDependencies> BrushQuake3Module;
 298 typedef Static<BrushQuake3Module> StaticBrushQuake3Module;
 299 StaticRegisterModule staticRegisterBrushQuake3(StaticBrushQuake3Module::instance());
 300
 301
 302 class BrushQuake2API : public TypeSystemRef
 303 {
 304   BrushCreator* m_brushquake2;
 305 public:
 306   typedef BrushCreator Type;
 307   STRING_CONSTANT(Name, "quake2");
 308
 309   BrushQuake2API()
 310   {
 311     Brush_Construct(eBrushTypeQuake2);
 312
 313     m_brushquake2 = &GetBrushCreator();
 314   }
 315   ~BrushQuake2API()
 316   {
 317     Brush_Destroy();
 318   }
 319   BrushCreator* getTable()
 320   {
 321     return m_brushquake2;
 322   }
 323 };
 324
 325 typedef SingletonModule<BrushQuake2API, BrushDependencies> BrushQuake2Module;
 326 typedef Static<BrushQuake2Module> StaticBrushQuake2Module;
 327 StaticRegisterModule staticRegisterBrushQuake2(StaticBrushQuake2Module::instance());
 328
 329
 330 class BrushQuake1API : public TypeSystemRef
 331 {
 332   BrushCreator* m_brushquake1;
 333 public:
 334   typedef BrushCreator Type;
 335   STRING_CONSTANT(Name, "quake");
 336
 337   BrushQuake1API()
 338   {
 339     Brush_Construct(eBrushTypeQuake);
 340
 341     m_brushquake1 = &GetBrushCreator();
 342   }
 343   ~BrushQuake1API()
 344   {
 345     Brush_Destroy();
 346   }
 347   BrushCreator* getTable()
 348   {
 349     return m_brushquake1;
 350   }
 351 };
 352
 353 typedef SingletonModule<BrushQuake1API, BrushDependencies> BrushQuake1Module;
 354 typedef Static<BrushQuake1Module> StaticBrushQuake1Module;
 355 StaticRegisterModule staticRegisterBrushQuake1(StaticBrushQuake1Module::instance());
 356
 357
 358 class BrushHalfLifeAPI : public TypeSystemRef
 359 {
 360   BrushCreator* m_brushhalflife;
 361 public:
 362   typedef BrushCreator Type;
 363   STRING_CONSTANT(Name, "halflife");
 364
 365   BrushHalfLifeAPI()
 366   {
 367     Brush_Construct(eBrushTypeHalfLife);
 368
 369     m_brushhalflife = &GetBrushCreator();
 370   }
 371   ~BrushHalfLifeAPI()
 372   {
 373     Brush_Destroy();
 374   }
 375   BrushCreator* getTable()
 376   {
 377     return m_brushhalflife;
 378   }
 379 };
 380
 381 typedef SingletonModule<BrushHalfLifeAPI, BrushDependencies> BrushHalfLifeModule;
 382 typedef Static<BrushHalfLifeModule> StaticBrushHalfLifeModule;
 383 StaticRegisterModule staticRegisterBrushHalfLife(StaticBrushHalfLifeModule::instance());