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