ok
[xonotic/netradiant.git] / 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());