Introduce Property<T> to simplify preferences system
[xonotic/netradiant.git] / radiant / brushmanip.cpp
1 /*
2    Copyright (C) 1999-2006 Id Software, Inc. and contributors.
3    For a list of contributors, see the accompanying CONTRIBUTORS file.
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 "brushmanip.h"
23
24
25 #include "gtkutil/widget.h"
26 #include "gtkutil/menu.h"
27 #include "gtkmisc.h"
28 #include "brushnode.h"
29 #include "map.h"
30 #include "texwindow.h"
31 #include "gtkdlgs.h"
32 #include "commands.h"
33 #include "mainframe.h"
34 #include "dialog.h"
35 #include "xywindow.h"
36 #include "preferences.h"
37
38 #include <list>
39 #include <gdk/gdkkeysyms.h>
40
41 void Brush_ConstructCuboid( Brush& brush, const AABB& bounds, const char* shader, const TextureProjection& projection ){
42         const unsigned char box[3][2] = { { 0, 1 }, { 2, 0 }, { 1, 2 } };
43         Vector3 mins( vector3_subtracted( bounds.origin, bounds.extents ) );
44         Vector3 maxs( vector3_added( bounds.origin, bounds.extents ) );
45
46         brush.clear();
47         brush.reserve( 6 );
48
49         {
50                 for ( int i = 0; i < 3; ++i )
51                 {
52                         Vector3 planepts1( maxs );
53                         Vector3 planepts2( maxs );
54                         planepts2[box[i][0]] = mins[box[i][0]];
55                         planepts1[box[i][1]] = mins[box[i][1]];
56
57                         brush.addPlane( maxs, planepts1, planepts2, shader, projection );
58                 }
59         }
60         {
61                 for ( int i = 0; i < 3; ++i )
62                 {
63                         Vector3 planepts1( mins );
64                         Vector3 planepts2( mins );
65                         planepts1[box[i][0]] = maxs[box[i][0]];
66                         planepts2[box[i][1]] = maxs[box[i][1]];
67
68                         brush.addPlane( mins, planepts1, planepts2, shader, projection );
69                 }
70         }
71 }
72
73 inline float max_extent( const Vector3& extents ){
74         return std::max( std::max( extents[0], extents[1] ), extents[2] );
75 }
76
77 inline float max_extent_2d( const Vector3& extents, int axis ){
78         switch ( axis )
79         {
80         case 0:
81                 return std::max( extents[1], extents[2] );
82         case 1:
83                 return std::max( extents[0], extents[2] );
84         default:
85                 return std::max( extents[0], extents[1] );
86         }
87 }
88
89 const std::size_t c_brushPrism_minSides = 3;
90 const std::size_t c_brushPrism_maxSides = c_brush_maxFaces - 2;
91 const char* const c_brushPrism_name = "brushPrism";
92
93 void Brush_ConstructPrism( Brush& brush, const AABB& bounds, std::size_t sides, int axis, const char* shader, const TextureProjection& projection ){
94         if ( sides < c_brushPrism_minSides ) {
95                 globalErrorStream() << c_brushPrism_name << ": sides " << Unsigned( sides ) << ": too few sides, minimum is " << Unsigned( c_brushPrism_minSides ) << "\n";
96                 return;
97         }
98         if ( sides > c_brushPrism_maxSides ) {
99                 globalErrorStream() << c_brushPrism_name << ": sides " << Unsigned( sides ) << ": too many sides, maximum is " << Unsigned( c_brushPrism_maxSides ) << "\n";
100                 return;
101         }
102
103         brush.clear();
104         brush.reserve( sides + 2 );
105
106         Vector3 mins( vector3_subtracted( bounds.origin, bounds.extents ) );
107         Vector3 maxs( vector3_added( bounds.origin, bounds.extents ) );
108
109         float radius = max_extent_2d( bounds.extents, axis );
110         const Vector3& mid = bounds.origin;
111         Vector3 planepts[3];
112
113         planepts[2][( axis + 1 ) % 3] = mins[( axis + 1 ) % 3];
114         planepts[2][( axis + 2 ) % 3] = mins[( axis + 2 ) % 3];
115         planepts[2][axis] = maxs[axis];
116         planepts[1][( axis + 1 ) % 3] = maxs[( axis + 1 ) % 3];
117         planepts[1][( axis + 2 ) % 3] = mins[( axis + 2 ) % 3];
118         planepts[1][axis] = maxs[axis];
119         planepts[0][( axis + 1 ) % 3] = maxs[( axis + 1 ) % 3];
120         planepts[0][( axis + 2 ) % 3] = maxs[( axis + 2 ) % 3];
121         planepts[0][axis] = maxs[axis];
122
123         brush.addPlane( planepts[0], planepts[1], planepts[2], shader, projection );
124
125         planepts[0][( axis + 1 ) % 3] = mins[( axis + 1 ) % 3];
126         planepts[0][( axis + 2 ) % 3] = mins[( axis + 2 ) % 3];
127         planepts[0][axis] = mins[axis];
128         planepts[1][( axis + 1 ) % 3] = maxs[( axis + 1 ) % 3];
129         planepts[1][( axis + 2 ) % 3] = mins[( axis + 2 ) % 3];
130         planepts[1][axis] = mins[axis];
131         planepts[2][( axis + 1 ) % 3] = maxs[( axis + 1 ) % 3];
132         planepts[2][( axis + 2 ) % 3] = maxs[( axis + 2 ) % 3];
133         planepts[2][axis] = mins[axis];
134
135         brush.addPlane( planepts[0], planepts[1], planepts[2], shader, projection );
136
137         for ( std::size_t i = 0 ; i < sides ; ++i )
138         {
139                 double sv = sin( i * 3.14159265 * 2 / sides );
140                 double cv = cos( i * 3.14159265 * 2 / sides );
141
142                 planepts[0][( axis + 1 ) % 3] = static_cast<float>( floor( mid[( axis + 1 ) % 3] + radius * cv + 0.5 ) );
143                 planepts[0][( axis + 2 ) % 3] = static_cast<float>( floor( mid[( axis + 2 ) % 3] + radius * sv + 0.5 ) );
144                 planepts[0][axis] = mins[axis];
145
146                 planepts[1][( axis + 1 ) % 3] = planepts[0][( axis + 1 ) % 3];
147                 planepts[1][( axis + 2 ) % 3] = planepts[0][( axis + 2 ) % 3];
148                 planepts[1][axis] = maxs[axis];
149
150                 planepts[2][( axis + 1 ) % 3] = static_cast<float>( floor( planepts[0][( axis + 1 ) % 3] - radius * sv + 0.5 ) );
151                 planepts[2][( axis + 2 ) % 3] = static_cast<float>( floor( planepts[0][( axis + 2 ) % 3] + radius * cv + 0.5 ) );
152                 planepts[2][axis] = maxs[axis];
153
154                 brush.addPlane( planepts[0], planepts[1], planepts[2], shader, projection );
155         }
156 }
157
158 const std::size_t c_brushCone_minSides = 3;
159 const std::size_t c_brushCone_maxSides = 32;
160 const char* const c_brushCone_name = "brushCone";
161
162 void Brush_ConstructCone( Brush& brush, const AABB& bounds, std::size_t sides, const char* shader, const TextureProjection& projection ){
163         if ( sides < c_brushCone_minSides ) {
164                 globalErrorStream() << c_brushCone_name << ": sides " << Unsigned( sides ) << ": too few sides, minimum is " << Unsigned( c_brushCone_minSides ) << "\n";
165                 return;
166         }
167         if ( sides > c_brushCone_maxSides ) {
168                 globalErrorStream() << c_brushCone_name << ": sides " << Unsigned( sides ) << ": too many sides, maximum is " << Unsigned( c_brushCone_maxSides ) << "\n";
169                 return;
170         }
171
172         brush.clear();
173         brush.reserve( sides + 1 );
174
175         Vector3 mins( vector3_subtracted( bounds.origin, bounds.extents ) );
176         Vector3 maxs( vector3_added( bounds.origin, bounds.extents ) );
177
178         float radius = max_extent( bounds.extents );
179         const Vector3& mid = bounds.origin;
180         Vector3 planepts[3];
181
182         planepts[0][0] = mins[0]; planepts[0][1] = mins[1]; planepts[0][2] = mins[2];
183         planepts[1][0] = maxs[0]; planepts[1][1] = mins[1]; planepts[1][2] = mins[2];
184         planepts[2][0] = maxs[0]; planepts[2][1] = maxs[1]; planepts[2][2] = mins[2];
185
186         brush.addPlane( planepts[0], planepts[1], planepts[2], shader, projection );
187
188         for ( std::size_t i = 0 ; i < sides ; ++i )
189         {
190                 double sv = sin( i * 3.14159265 * 2 / sides );
191                 double cv = cos( i * 3.14159265 * 2 / sides );
192
193                 planepts[0][0] = static_cast<float>( floor( mid[0] + radius * cv + 0.5 ) );
194                 planepts[0][1] = static_cast<float>( floor( mid[1] + radius * sv + 0.5 ) );
195                 planepts[0][2] = mins[2];
196
197                 planepts[1][0] = mid[0];
198                 planepts[1][1] = mid[1];
199                 planepts[1][2] = maxs[2];
200
201                 planepts[2][0] = static_cast<float>( floor( planepts[0][0] - radius * sv + 0.5 ) );
202                 planepts[2][1] = static_cast<float>( floor( planepts[0][1] + radius * cv + 0.5 ) );
203                 planepts[2][2] = maxs[2];
204
205                 brush.addPlane( planepts[0], planepts[1], planepts[2], shader, projection );
206         }
207 }
208
209 const std::size_t c_brushSphere_minSides = 3;
210 const std::size_t c_brushSphere_maxSides = 31;
211 const char* const c_brushSphere_name = "brushSphere";
212
213 void Brush_ConstructSphere( Brush& brush, const AABB& bounds, std::size_t sides, const char* shader, const TextureProjection& projection ){
214         if ( sides < c_brushSphere_minSides ) {
215                 globalErrorStream() << c_brushSphere_name << ": sides " << Unsigned( sides ) << ": too few sides, minimum is " << Unsigned( c_brushSphere_minSides ) << "\n";
216                 return;
217         }
218         if ( sides > c_brushSphere_maxSides ) {
219                 globalErrorStream() << c_brushSphere_name << ": sides " << Unsigned( sides ) << ": too many sides, maximum is " << Unsigned( c_brushSphere_maxSides ) << "\n";
220                 return;
221         }
222
223         brush.clear();
224         brush.reserve( sides * sides );
225
226         float radius = max_extent( bounds.extents );
227         const Vector3& mid = bounds.origin;
228         Vector3 planepts[3];
229
230         double dt = 2 * c_pi / sides;
231         double dp = c_pi / sides;
232         for ( std::size_t i = 0; i < sides; i++ )
233         {
234                 for ( std::size_t j = 0; j < sides - 1; j++ )
235                 {
236                         double t = i * dt;
237                         double p = float(j * dp - c_pi / 2);
238
239                         planepts[0] = vector3_added( mid, vector3_scaled( vector3_for_spherical( t, p ), radius ) );
240                         planepts[1] = vector3_added( mid, vector3_scaled( vector3_for_spherical( t, p + dp ), radius ) );
241                         planepts[2] = vector3_added( mid, vector3_scaled( vector3_for_spherical( t + dt, p + dp ), radius ) );
242
243                         brush.addPlane( planepts[0], planepts[1], planepts[2], shader, projection );
244                 }
245         }
246
247         {
248                 double p = ( sides - 1 ) * dp - c_pi / 2;
249                 for ( std::size_t i = 0; i < sides; i++ )
250                 {
251                         double t = i * dt;
252
253                         planepts[0] = vector3_added( mid, vector3_scaled( vector3_for_spherical( t, p ), radius ) );
254                         planepts[1] = vector3_added( mid, vector3_scaled( vector3_for_spherical( t + dt, p + dp ), radius ) );
255                         planepts[2] = vector3_added( mid, vector3_scaled( vector3_for_spherical( t + dt, p ), radius ) );
256
257                         brush.addPlane( planepts[0], planepts[1], planepts[2], shader, projection );
258                 }
259         }
260 }
261
262 const std::size_t c_brushRock_minSides = 10;
263 const std::size_t c_brushRock_maxSides = 1000;
264 const char* const c_brushRock_name = "brushRock";
265
266 void Brush_ConstructRock( Brush& brush, const AABB& bounds, std::size_t sides, const char* shader, const TextureProjection& projection ){
267         if ( sides < c_brushRock_minSides ) {
268                 globalErrorStream() << c_brushRock_name << ": sides " << Unsigned( sides ) << ": too few sides, minimum is " << Unsigned( c_brushRock_minSides ) << "\n";
269                 return;
270         }
271         if ( sides > c_brushRock_maxSides ) {
272                 globalErrorStream() << c_brushRock_name << ": sides " << Unsigned( sides ) << ": too many sides, maximum is " << Unsigned( c_brushRock_maxSides ) << "\n";
273                 return;
274         }
275
276         brush.clear();
277         brush.reserve( sides * sides );
278
279         float radius = max_extent( bounds.extents );
280         const Vector3& mid = bounds.origin;
281         Vector3 planepts[3];
282
283         for ( std::size_t j = 0; j < sides; j++ )
284         {
285                 planepts[0][0] = rand() - ( RAND_MAX / 2 );
286                 planepts[0][1] = rand() - ( RAND_MAX / 2 );
287                 planepts[0][2] = rand() - ( RAND_MAX / 2 );
288                 vector3_normalise( planepts[0] );
289
290                 // find two vectors that are perpendicular to planepts[0]
291                 ComputeAxisBase( planepts[0], planepts[1], planepts[2] );
292
293                 planepts[0] = vector3_added( mid, vector3_scaled( planepts[0], radius ) );
294                 planepts[1] = vector3_added( planepts[0], vector3_scaled( planepts[1], radius ) );
295                 planepts[2] = vector3_added( planepts[0], vector3_scaled( planepts[2], radius ) );
296
297 #if 0
298                 // make sure the orientation is right
299                 if ( vector3_dot( vector3_subtracted( planepts[0], mid ), vector3_cross( vector3_subtracted( planepts[1], mid ), vector3_subtracted( planepts[2], mid ) ) ) > 0 ) {
300                         Vector3 h;
301                         h = planepts[1];
302                         planepts[1] = planepts[2];
303                         planepts[2] = h;
304                         globalOutputStream() << "flip\n";
305                 }
306                 else{
307                         globalOutputStream() << "no flip\n";
308                 }
309 #endif
310
311                 brush.addPlane( planepts[0], planepts[1], planepts[2], shader, projection );
312         }
313 }
314
315 int GetViewAxis(){
316         switch ( GlobalXYWnd_getCurrentViewType() )
317         {
318         case XY:
319                 return 2;
320         case XZ:
321                 return 1;
322         case YZ:
323                 return 0;
324         }
325         return 2;
326 }
327
328 void Brush_ConstructPrefab( Brush& brush, EBrushPrefab type, const AABB& bounds, std::size_t sides, const char* shader, const TextureProjection& projection ){
329         switch ( type )
330         {
331         case eBrushCuboid:
332         {
333                 UndoableCommand undo( "brushCuboid" );
334
335                 Brush_ConstructCuboid( brush, bounds, shader, projection );
336         }
337         break;
338         case eBrushPrism:
339         {
340                 int axis = GetViewAxis();
341                 StringOutputStream command;
342                 command << c_brushPrism_name << " -sides " << Unsigned( sides ) << " -axis " << axis;
343                 UndoableCommand undo( command.c_str() );
344
345                 Brush_ConstructPrism( brush, bounds, sides, axis, shader, projection );
346         }
347         break;
348         case eBrushCone:
349         {
350                 StringOutputStream command;
351                 command << c_brushCone_name << " -sides " << Unsigned( sides );
352                 UndoableCommand undo( command.c_str() );
353
354                 Brush_ConstructCone( brush, bounds, sides, shader, projection );
355         }
356         break;
357         case eBrushSphere:
358         {
359                 StringOutputStream command;
360                 command << c_brushSphere_name << " -sides " << Unsigned( sides );
361                 UndoableCommand undo( command.c_str() );
362
363                 Brush_ConstructSphere( brush, bounds, sides, shader, projection );
364         }
365         break;
366         case eBrushRock:
367         {
368                 StringOutputStream command;
369                 command << c_brushRock_name << " -sides " << Unsigned( sides );
370                 UndoableCommand undo( command.c_str() );
371
372                 Brush_ConstructRock( brush, bounds, sides, shader, projection );
373         }
374         break;
375         }
376 }
377
378
379 void ConstructRegionBrushes( scene::Node* brushes[6], const Vector3& region_mins, const Vector3& region_maxs ){
380         {
381                 // set mins
382                 Vector3 mins( region_mins[0] - 32, region_mins[1] - 32, region_mins[2] - 32 );
383
384                 // vary maxs
385                 for ( std::size_t i = 0; i < 3; i++ )
386                 {
387                         Vector3 maxs( region_maxs[0] + 32, region_maxs[1] + 32, region_maxs[2] + 32 );
388                         maxs[i] = region_mins[i];
389                         Brush_ConstructCuboid( *Node_getBrush( *brushes[i] ), aabb_for_minmax( mins, maxs ), texdef_name_default(), TextureProjection() );
390                 }
391         }
392
393         {
394                 // set maxs
395                 Vector3 maxs( region_maxs[0] + 32, region_maxs[1] + 32, region_maxs[2] + 32 );
396
397                 // vary mins
398                 for ( std::size_t i = 0; i < 3; i++ )
399                 {
400                         Vector3 mins( region_mins[0] - 32, region_mins[1] - 32, region_mins[2] - 32 );
401                         mins[i] = region_maxs[i];
402                         Brush_ConstructCuboid( *Node_getBrush( *brushes[i + 3] ), aabb_for_minmax( mins, maxs ), texdef_name_default(), TextureProjection() );
403                 }
404         }
405 }
406
407
408 void Scene_BrushSetTexdef_Selected( scene::Graph& graph, const TextureProjection& projection ){
409         Scene_ForEachSelectedBrush_ForEachFace(graph, [&](Face &face) {
410                 face.SetTexdef(projection);
411         });
412         SceneChangeNotify();
413 }
414
415 void Scene_BrushSetTexdef_Component_Selected( scene::Graph& graph, const TextureProjection& projection ){
416         Scene_ForEachSelectedBrushFace(graph, [&](Face &face) {
417                 face.SetTexdef(projection);
418         });
419         SceneChangeNotify();
420 }
421
422
423 void Scene_BrushSetFlags_Selected( scene::Graph& graph, const ContentsFlagsValue& flags ){
424         Scene_ForEachSelectedBrush_ForEachFace(graph, [&](Face &face) {
425                 face.SetFlags(flags);
426         });
427         SceneChangeNotify();
428 }
429
430 void Scene_BrushSetFlags_Component_Selected( scene::Graph& graph, const ContentsFlagsValue& flags ){
431         Scene_ForEachSelectedBrushFace(graph, [&](Face &face) {
432                 face.SetFlags(flags);
433         });
434         SceneChangeNotify();
435 }
436
437 void Scene_BrushShiftTexdef_Selected( scene::Graph& graph, float s, float t ){
438         Scene_ForEachSelectedBrush_ForEachFace(graph, [&](Face &face) {
439                 face.ShiftTexdef(s, t);
440         });
441         SceneChangeNotify();
442 }
443
444 void Scene_BrushShiftTexdef_Component_Selected( scene::Graph& graph, float s, float t ){
445         Scene_ForEachSelectedBrushFace(graph, [&](Face &face) {
446                 face.ShiftTexdef(s, t);
447         });
448         SceneChangeNotify();
449 }
450
451 void Scene_BrushScaleTexdef_Selected( scene::Graph& graph, float s, float t ){
452         Scene_ForEachSelectedBrush_ForEachFace(graph, [&](Face &face) {
453                 face.ScaleTexdef(s, t);
454         });
455         SceneChangeNotify();
456 }
457
458 void Scene_BrushScaleTexdef_Component_Selected( scene::Graph& graph, float s, float t ){
459         Scene_ForEachSelectedBrushFace(graph, [&](Face &face) {
460                 face.ScaleTexdef(s, t);
461         });
462         SceneChangeNotify();
463 }
464
465 void Scene_BrushRotateTexdef_Selected( scene::Graph& graph, float angle ){
466         Scene_ForEachSelectedBrush_ForEachFace(graph, [&](Face &face) {
467                 face.RotateTexdef(angle);
468         });
469         SceneChangeNotify();
470 }
471
472 void Scene_BrushRotateTexdef_Component_Selected( scene::Graph& graph, float angle ){
473         Scene_ForEachSelectedBrushFace(graph, [&](Face &face) {
474                 face.RotateTexdef(angle);
475         });
476         SceneChangeNotify();
477 }
478
479
480 void Scene_BrushSetShader_Selected( scene::Graph& graph, const char* name ){
481         Scene_ForEachSelectedBrush_ForEachFace(graph, [&](Face &face) {
482                 face.SetShader(name);
483         });
484         SceneChangeNotify();
485 }
486
487 void Scene_BrushSetShader_Component_Selected( scene::Graph& graph, const char* name ){
488         Scene_ForEachSelectedBrushFace(graph, [&](Face &face) {
489                 face.SetShader(name);
490         });
491         SceneChangeNotify();
492 }
493
494 void Scene_BrushSetDetail_Selected( scene::Graph& graph, bool detail ){
495         Scene_ForEachSelectedBrush_ForEachFace(graph, [&](Face &face) {
496                 face.setDetail(detail);
497         });
498         SceneChangeNotify();
499 }
500
501 bool Face_FindReplaceShader( Face& face, const char* find, const char* replace ){
502         if ( shader_equal( face.GetShader(), find ) ) {
503                 face.SetShader( replace );
504                 return true;
505         }
506         return false;
507 }
508
509 bool DoingSearch( const char *repl ){
510         return ( repl == NULL || ( strcmp( "textures/", repl ) == 0 ) );
511 }
512
513 void Scene_BrushFindReplaceShader( scene::Graph& graph, const char* find, const char* replace ){
514         if ( DoingSearch( replace ) ) {
515                 Scene_ForEachBrush_ForEachFaceInstance(graph, [&](FaceInstance &faceinst) {
516                         if (shader_equal(faceinst.getFace().GetShader(), find)) {
517                                 faceinst.setSelected(SelectionSystem::eFace, true);
518                         }
519                 });
520         }
521         else
522         {
523                 Scene_ForEachBrush_ForEachFace(graph, [&](Face &face) { Face_FindReplaceShader(face, find, replace); });
524         }
525 }
526
527 void Scene_BrushFindReplaceShader_Selected( scene::Graph& graph, const char* find, const char* replace ){
528         if ( DoingSearch( replace ) ) {
529                 Scene_ForEachSelectedBrush_ForEachFaceInstance(graph, [&](FaceInstance &faceinst) {
530                         if (shader_equal(faceinst.getFace().GetShader(), find)) {
531                                 faceinst.setSelected(SelectionSystem::eFace, true);
532                         }
533                 });
534         }
535         else
536         {
537                 Scene_ForEachSelectedBrush_ForEachFace(graph, [&](Face &face) {
538                         Face_FindReplaceShader(face, find, replace);
539                 });
540         }
541 }
542
543 // TODO: find for components
544 // d1223m: dont even know what they are...
545 void Scene_BrushFindReplaceShader_Component_Selected( scene::Graph& graph, const char* find, const char* replace ){
546         if ( DoingSearch( replace ) ) {
547
548         }
549         else
550         {
551                 Scene_ForEachSelectedBrushFace(graph, [&](Face &face) {
552                         Face_FindReplaceShader(face, find, replace);
553                 });
554         }
555 }
556
557
558 void Scene_BrushFitTexture_Selected( scene::Graph& graph, float s_repeat, float t_repeat ){
559         Scene_ForEachSelectedBrush_ForEachFace(graph, [&](Face &face) {
560                 face.FitTexture(s_repeat, t_repeat);
561         });
562         SceneChangeNotify();
563 }
564
565 void Scene_BrushFitTexture_Component_Selected( scene::Graph& graph, float s_repeat, float t_repeat ){
566         Scene_ForEachSelectedBrushFace(graph, [&](Face &face) {
567                 face.FitTexture(s_repeat, t_repeat);
568         });
569         SceneChangeNotify();
570 }
571
572 TextureProjection g_defaultTextureProjection;
573 const TextureProjection& TextureTransform_getDefault(){
574         TexDef_Construct_Default( g_defaultTextureProjection );
575         return g_defaultTextureProjection;
576 }
577
578 void Scene_BrushConstructPrefab( scene::Graph& graph, EBrushPrefab type, std::size_t sides, const char* shader ){
579         if ( GlobalSelectionSystem().countSelected() != 0 ) {
580                 const scene::Path& path = GlobalSelectionSystem().ultimateSelected().path();
581
582                 Brush* brush = Node_getBrush( path.top() );
583                 if ( brush != 0 ) {
584                         AABB bounds = brush->localAABB(); // copy bounds because the brush will be modified
585                         Brush_ConstructPrefab( *brush, type, bounds, sides, shader, TextureTransform_getDefault() );
586                         SceneChangeNotify();
587                 }
588         }
589 }
590
591 void Scene_BrushResize_Selected( scene::Graph& graph, const AABB& bounds, const char* shader ){
592         if ( GlobalSelectionSystem().countSelected() != 0 ) {
593                 const scene::Path& path = GlobalSelectionSystem().ultimateSelected().path();
594
595                 Brush* brush = Node_getBrush( path.top() );
596                 if ( brush != 0 ) {
597                         Brush_ConstructCuboid( *brush, bounds, shader, TextureTransform_getDefault() );
598                         SceneChangeNotify();
599                 }
600         }
601 }
602
603 bool Brush_hasShader( const Brush& brush, const char* name ){
604         for ( Brush::const_iterator i = brush.begin(); i != brush.end(); ++i )
605         {
606                 if ( shader_equal( ( *i )->GetShader(), name ) ) {
607                         return true;
608                 }
609         }
610         return false;
611 }
612
613 class BrushSelectByShaderWalker : public scene::Graph::Walker
614 {
615 const char* m_name;
616 public:
617 BrushSelectByShaderWalker( const char* name )
618         : m_name( name ){
619 }
620 bool pre( const scene::Path& path, scene::Instance& instance ) const {
621         if ( path.top().get().visible() ) {
622                 Brush* brush = Node_getBrush( path.top() );
623                 if ( brush != 0 && Brush_hasShader( *brush, m_name ) ) {
624                         Instance_getSelectable( instance )->setSelected( true );
625                 }
626         }
627         return true;
628 }
629 };
630
631 void Scene_BrushSelectByShader( scene::Graph& graph, const char* name ){
632         graph.traverse( BrushSelectByShaderWalker( name ) );
633 }
634
635 void Scene_BrushSelectByShader_Component( scene::Graph& graph, const char* name ){
636         Scene_ForEachSelectedBrush_ForEachFaceInstance(graph, [&](FaceInstance &face) {
637                 printf("checking %s = %s\n", face.getFace().GetShader(), name);
638                 if (shader_equal(face.getFace().GetShader(), name)) {
639                         face.setSelected(SelectionSystem::eFace, true);
640                 }
641         });
642 }
643
644 void Scene_BrushGetTexdef_Selected( scene::Graph& graph, TextureProjection& projection ){
645         bool done = false;
646         Scene_ForEachSelectedBrush_ForEachFace(graph, [&](Face &face) {
647                 if (!done) {
648                         done = true;
649                         face.GetTexdef(projection);
650                 }
651         });
652 }
653
654 void Scene_BrushGetTexdef_Component_Selected( scene::Graph& graph, TextureProjection& projection ){
655 #if 1
656         if ( !g_SelectedFaceInstances.empty() ) {
657                 FaceInstance& faceInstance = g_SelectedFaceInstances.last();
658                 faceInstance.getFace().GetTexdef( projection );
659         }
660 #else
661         FaceGetTexdef visitor( projection );
662         Scene_ForEachSelectedBrushFace( graph, visitor );
663 #endif
664 }
665
666 void Scene_BrushGetShaderSize_Component_Selected( scene::Graph& graph, size_t& width, size_t& height ){
667         if ( !g_SelectedFaceInstances.empty() ) {
668                 FaceInstance& faceInstance = g_SelectedFaceInstances.last();
669                 width = faceInstance.getFace().getShader().width();
670                 height = faceInstance.getFace().getShader().height();
671         }
672 }
673
674
675 void Scene_BrushGetFlags_Selected( scene::Graph& graph, ContentsFlagsValue& flags ){
676 #if 1
677         if ( GlobalSelectionSystem().countSelected() != 0 ) {
678                 BrushInstance* brush = Instance_getBrush( GlobalSelectionSystem().ultimateSelected() );
679                 if ( brush != 0 ) {
680                         bool done = false;
681                         Brush_forEachFace(*brush, [&](Face &face) {
682                                 if (!done) {
683                                         done = true;
684                                         face.GetFlags(flags);
685                                 }
686                         });
687                 }
688         }
689 #else
690         Scene_ForEachSelectedBrush_ForEachFace( graph, FaceGetFlags( flags ) );
691 #endif
692 }
693
694 void Scene_BrushGetFlags_Component_Selected( scene::Graph& graph, ContentsFlagsValue& flags ){
695 #if 1
696         if ( !g_SelectedFaceInstances.empty() ) {
697                 FaceInstance& faceInstance = g_SelectedFaceInstances.last();
698                 faceInstance.getFace().GetFlags( flags );
699         }
700 #else
701         Scene_ForEachSelectedBrushFace( graph, FaceGetFlags( flags ) );
702 #endif
703 }
704
705
706 void Scene_BrushGetShader_Selected( scene::Graph& graph, CopiedString& shader ){
707 #if 1
708         if ( GlobalSelectionSystem().countSelected() != 0 ) {
709                 BrushInstance* brush = Instance_getBrush( GlobalSelectionSystem().ultimateSelected() );
710                 if ( brush != 0 ) {
711                         bool done = false;
712                         Brush_forEachFace(*brush, [&](Face &face) {
713                                 if (!done) {
714                                         done = true;
715                                         shader = face.GetShader();
716                                 }
717                         });
718                 }
719         }
720 #else
721         Scene_ForEachSelectedBrush_ForEachFace( graph, FaceGetShader( shader ) );
722 #endif
723 }
724
725 void Scene_BrushGetShader_Component_Selected( scene::Graph& graph, CopiedString& shader ){
726 #if 1
727         if ( !g_SelectedFaceInstances.empty() ) {
728                 FaceInstance& faceInstance = g_SelectedFaceInstances.last();
729                 shader = faceInstance.getFace().GetShader();
730         }
731 #else
732         FaceGetShader visitor( shader );
733         Scene_ForEachSelectedBrushFace( graph, visitor );
734 #endif
735 }
736
737
738 class filter_face_shader : public FaceFilter
739 {
740 const char* m_shader;
741 public:
742 filter_face_shader( const char* shader ) : m_shader( shader ){
743 }
744 bool filter( const Face& face ) const {
745         return shader_equal( face.GetShader(), m_shader );
746 }
747 };
748
749 class filter_face_shader_prefix : public FaceFilter
750 {
751 const char* m_prefix;
752 public:
753 filter_face_shader_prefix( const char* prefix ) : m_prefix( prefix ){
754 }
755 bool filter( const Face& face ) const {
756         return shader_equal_n( face.GetShader(), m_prefix, strlen( m_prefix ) );
757 }
758 };
759
760 class filter_face_flags : public FaceFilter
761 {
762 int m_flags;
763 public:
764 filter_face_flags( int flags ) : m_flags( flags ){
765 }
766 bool filter( const Face& face ) const {
767         return ( face.getShader().shaderFlags() & m_flags ) != 0;
768 }
769 };
770
771 class filter_face_contents : public FaceFilter
772 {
773 int m_contents;
774 public:
775 filter_face_contents( int contents ) : m_contents( contents ){
776 }
777 bool filter( const Face& face ) const {
778         return ( face.getShader().m_flags.m_contentFlags & m_contents ) != 0;
779 }
780 };
781
782
783
784 class filter_brush_any_face : public BrushFilter
785 {
786 FaceFilter* m_filter;
787 public:
788 filter_brush_any_face( FaceFilter* filter ) : m_filter( filter ){
789 }
790 bool filter( const Brush& brush ) const {
791         bool filtered = false;
792         Brush_forEachFace(brush, [&](Face &face) {
793                 if (m_filter->filter(face)) {
794                         filtered = true;
795                 }
796         });
797         return filtered;
798 }
799 };
800
801 class filter_brush_all_faces : public BrushFilter
802 {
803 FaceFilter* m_filter;
804 public:
805 filter_brush_all_faces( FaceFilter* filter ) : m_filter( filter ){
806 }
807 bool filter( const Brush& brush ) const {
808         bool filtered = true;
809         Brush_forEachFace(brush, [&](Face &face) {
810                 if (!m_filter->filter(face)) {
811                         filtered = false;
812                 }
813         });
814         return filtered;
815 }
816 };
817
818
819 filter_face_flags g_filter_face_clip( QER_CLIP );
820 filter_brush_all_faces g_filter_brush_clip( &g_filter_face_clip );
821
822 filter_face_shader g_filter_face_clip_q2( "textures/clip" );
823 filter_brush_all_faces g_filter_brush_clip_q2( &g_filter_face_clip_q2 );
824
825 filter_face_shader g_filter_face_weapclip( "textures/common/weapclip" );
826 filter_brush_all_faces g_filter_brush_weapclip( &g_filter_face_weapclip );
827
828 filter_face_shader g_filter_face_commonclip( "textures/common/clip" );
829 filter_brush_all_faces g_filter_brush_commonclip( &g_filter_face_commonclip );
830
831 filter_face_shader g_filter_face_fullclip( "textures/common/fullclip" );
832 filter_brush_all_faces g_filter_brush_fullclip( &g_filter_face_fullclip );
833
834 filter_face_shader g_filter_face_botclip( "textures/common/botclip" );
835 filter_brush_all_faces g_filter_brush_botclip( &g_filter_face_botclip );
836
837 filter_face_shader_prefix g_filter_face_caulk( "textures/common/caulk" );
838 filter_brush_all_faces g_filter_brush_caulk( &g_filter_face_caulk );
839
840 filter_face_shader_prefix g_filter_face_caulk_ja( "textures/system/caulk" );
841 filter_brush_all_faces g_filter_brush_caulk_ja( &g_filter_face_caulk_ja );
842
843 filter_face_shader_prefix g_filter_face_liquids( "textures/liquids/" );
844 filter_brush_any_face g_filter_brush_liquids( &g_filter_face_liquids );
845
846 filter_face_shader g_filter_face_hint( "textures/common/hint" );
847 filter_brush_any_face g_filter_brush_hint( &g_filter_face_hint );
848
849 filter_face_shader g_filter_face_hint_q2( "textures/hint" );
850 filter_brush_any_face g_filter_brush_hint_q2( &g_filter_face_hint_q2 );
851
852 filter_face_shader g_filter_face_hint_ja( "textures/system/hint" );
853 filter_brush_any_face g_filter_brush_hint_ja( &g_filter_face_hint_ja );
854
855 filter_face_shader g_filter_face_areaportal( "textures/common/areaportal" );
856 filter_brush_all_faces g_filter_brush_areaportal( &g_filter_face_areaportal );
857
858 filter_face_shader g_filter_face_visportal( "textures/editor/visportal" );
859 filter_brush_any_face g_filter_brush_visportal( &g_filter_face_visportal );
860
861 filter_face_shader g_filter_face_clusterportal( "textures/common/clusterportal" );
862 filter_brush_all_faces g_filter_brush_clusterportal( &g_filter_face_clusterportal );
863
864 filter_face_shader g_filter_face_lightgrid( "textures/common/lightgrid" );
865 filter_brush_all_faces g_filter_brush_lightgrid( &g_filter_face_lightgrid );
866
867 filter_face_flags g_filter_face_translucent( QER_TRANS );
868 filter_brush_all_faces g_filter_brush_translucent( &g_filter_face_translucent );
869
870 filter_face_contents g_filter_face_detail( BRUSH_DETAIL_MASK );
871 filter_brush_all_faces g_filter_brush_detail( &g_filter_face_detail );
872
873 filter_face_shader_prefix g_filter_face_decals( "textures/decals/" );
874 filter_brush_any_face g_filter_brush_decals( &g_filter_face_decals );
875
876
877 void BrushFilters_construct(){
878         add_brush_filter( g_filter_brush_clip, EXCLUDE_CLIP );
879         add_brush_filter( g_filter_brush_clip_q2, EXCLUDE_CLIP );
880         add_brush_filter( g_filter_brush_weapclip, EXCLUDE_CLIP );
881         add_brush_filter( g_filter_brush_fullclip, EXCLUDE_CLIP );
882         add_brush_filter( g_filter_brush_commonclip, EXCLUDE_CLIP );
883         add_brush_filter( g_filter_brush_botclip, EXCLUDE_BOTCLIP );
884         add_brush_filter( g_filter_brush_caulk, EXCLUDE_CAULK );
885         add_brush_filter( g_filter_brush_caulk_ja, EXCLUDE_CAULK );
886         add_face_filter( g_filter_face_caulk, EXCLUDE_CAULK );
887         add_face_filter( g_filter_face_caulk_ja, EXCLUDE_CAULK );
888         add_brush_filter( g_filter_brush_liquids, EXCLUDE_LIQUIDS );
889         add_brush_filter( g_filter_brush_hint, EXCLUDE_HINTSSKIPS );
890         add_brush_filter( g_filter_brush_hint_q2, EXCLUDE_HINTSSKIPS );
891         add_brush_filter( g_filter_brush_hint_ja, EXCLUDE_HINTSSKIPS );
892         add_brush_filter( g_filter_brush_clusterportal, EXCLUDE_CLUSTERPORTALS );
893         add_brush_filter( g_filter_brush_visportal, EXCLUDE_VISPORTALS );
894         add_brush_filter( g_filter_brush_areaportal, EXCLUDE_AREAPORTALS );
895         add_brush_filter( g_filter_brush_translucent, EXCLUDE_TRANSLUCENT );
896         add_brush_filter( g_filter_brush_detail, EXCLUDE_DETAILS );
897         add_brush_filter( g_filter_brush_detail, EXCLUDE_STRUCTURAL, true );
898         add_brush_filter( g_filter_brush_lightgrid, EXCLUDE_LIGHTGRID );
899         add_brush_filter( g_filter_brush_decals, EXCLUDE_DECALS );
900 }
901
902 #if 0
903
904 void normalquantisation_draw(){
905         glPointSize( 1 );
906         glBegin( GL_POINTS );
907         for ( std::size_t i = 0; i <= c_quantise_normal; ++i )
908         {
909                 for ( std::size_t j = 0; j <= c_quantise_normal; ++j )
910                 {
911                         Normal3f vertex( normal3f_normalised( Normal3f(
912                                                                                                           static_cast<float>( c_quantise_normal - j - i ),
913                                                                                                           static_cast<float>( i ),
914                                                                                                           static_cast<float>( j )
915                                                                                                           ) ) );
916                         VectorScale( normal3f_to_array( vertex ), 64.f, normal3f_to_array( vertex ) );
917                         glVertex3fv( normal3f_to_array( vertex ) );
918                         vertex.x = -vertex.x;
919                         glVertex3fv( normal3f_to_array( vertex ) );
920                 }
921         }
922         glEnd();
923 }
924
925 class RenderableNormalQuantisation : public OpenGLRenderable
926 {
927 public:
928 void render( RenderStateFlags state ) const {
929         normalquantisation_draw();
930 }
931 };
932
933 const float g_test_quantise_normal = 1.f / static_cast<float>( 1 << 3 );
934
935 class TestNormalQuantisation
936 {
937 void check_normal( const Normal3f& normal, const Normal3f& other ){
938         spherical_t spherical = spherical_from_normal3f( normal );
939         double longditude = RAD2DEG( spherical.longditude );
940         double latitude = RAD2DEG( spherical.latitude );
941         double x = cos( spherical.longditude ) * sin( spherical.latitude );
942         double y = sin( spherical.longditude ) * sin( spherical.latitude );
943         double z = cos( spherical.latitude );
944
945         ASSERT_MESSAGE( normal3f_dot( normal, other ) > 0.99, "bleh" );
946 }
947
948 void test_normal( const Normal3f& normal ){
949         Normal3f test = normal3f_from_spherical( spherical_from_normal3f( normal ) );
950         check_normal( normal, test );
951
952         EOctant octant = normal3f_classify_octant( normal );
953         Normal3f folded = normal3f_fold_octant( normal, octant );
954         ESextant sextant = normal3f_classify_sextant( folded );
955         folded = normal3f_fold_sextant( folded, sextant );
956
957         double scale = static_cast<float>( c_quantise_normal ) / ( folded.x + folded.y + folded.z );
958
959         double zbits = folded.z * scale;
960         double ybits = folded.y * scale;
961
962         std::size_t zbits_q = static_cast<std::size_t>( zbits );
963         std::size_t ybits_q = static_cast<std::size_t>( ybits );
964
965         ASSERT_MESSAGE( zbits_q <= ( c_quantise_normal / 8 ) * 3, "bleh" );
966         ASSERT_MESSAGE( ybits_q <= ( c_quantise_normal / 2 ), "bleh" );
967         ASSERT_MESSAGE( zbits_q + ( ( c_quantise_normal / 2 ) - ybits_q ) <= ( c_quantise_normal / 2 ), "bleh" );
968
969         std::size_t y_t = ( zbits_q < ( c_quantise_normal / 4 ) ) ? ybits_q : ( c_quantise_normal / 2 ) - ybits_q;
970         std::size_t z_t = ( zbits_q < ( c_quantise_normal / 4 ) ) ? zbits_q : ( c_quantise_normal / 2 ) - zbits_q;
971         std::size_t index = ( c_quantise_normal / 4 ) * y_t + z_t;
972         ASSERT_MESSAGE( index <= ( c_quantise_normal / 4 ) * ( c_quantise_normal / 2 ), "bleh" );
973
974         Normal3f tmp( c_quantise_normal - zbits_q - ybits_q, ybits_q, zbits_q );
975         tmp = normal3f_normalised( tmp );
976
977         Normal3f unfolded = normal3f_unfold_octant( normal3f_unfold_sextant( tmp, sextant ), octant );
978
979         check_normal( normal, unfolded );
980
981         double dot = normal3f_dot( normal, unfolded );
982         float length = VectorLength( normal3f_to_array( unfolded ) );
983         float inv_length = 1 / length;
984
985         Normal3f quantised = normal3f_quantised( normal );
986         check_normal( normal, quantised );
987 }
988 void test2( const Normal3f& normal, const Normal3f& other ){
989         if ( normal3f_quantised( normal ) != normal3f_quantised( other ) ) {
990                 int bleh = 0;
991         }
992 }
993
994 static Normal3f normalise( float x, float y, float z ){
995         return normal3f_normalised( Normal3f( x, y, z ) );
996 }
997
998 float vec_rand(){
999         return static_cast<float>( rand() - ( RAND_MAX / 2 ) );
1000 }
1001
1002 Normal3f normal3f_rand(){
1003         return normalise( vec_rand(), vec_rand(), vec_rand() );
1004 }
1005
1006 public:
1007 TestNormalQuantisation(){
1008         for ( int i = 4096; i > 0; --i )
1009                 test_normal( normal3f_rand() );
1010
1011         test_normal( normalise( 1, 0, 0 ) );
1012         test_normal( normalise( 0, 1, 0 ) );
1013         test_normal( normalise( 0, 0, 1 ) );
1014         test_normal( normalise( 1, 1, 0 ) );
1015         test_normal( normalise( 1, 0, 1 ) );
1016         test_normal( normalise( 0, 1, 1 ) );
1017
1018         test_normal( normalise( 10000, 10000, 10000 ) );
1019         test_normal( normalise( 10000, 10000, 10001 ) );
1020         test_normal( normalise( 10000, 10000, 10002 ) );
1021         test_normal( normalise( 10000, 10000, 10010 ) );
1022         test_normal( normalise( 10000, 10000, 10020 ) );
1023         test_normal( normalise( 10000, 10000, 10030 ) );
1024         test_normal( normalise( 10000, 10000, 10100 ) );
1025         test_normal( normalise( 10000, 10000, 10101 ) );
1026         test_normal( normalise( 10000, 10000, 10102 ) );
1027         test_normal( normalise( 10000, 10000, 10200 ) );
1028         test_normal( normalise( 10000, 10000, 10201 ) );
1029         test_normal( normalise( 10000, 10000, 10202 ) );
1030         test_normal( normalise( 10000, 10000, 10203 ) );
1031         test_normal( normalise( 10000, 10000, 10300 ) );
1032
1033
1034         test2( normalise( 10000, 10000, 10000 ), normalise( 10000, 10000, 10001 ) );
1035         test2( normalise( 10000, 10000, 10001 ), normalise( 10000, 10001, 10000 ) );
1036 }
1037 };
1038
1039 TestNormalQuantisation g_testNormalQuantisation;
1040
1041
1042 #endif
1043
1044 #if 0
1045 class TestSelectableObserver : public observer_template<const Selectable&>
1046 {
1047 public:
1048 void notify( const Selectable& arguments ){
1049         bool bleh = arguments.isSelected();
1050 }
1051 };
1052
1053 inline void test_bleh(){
1054         TestSelectableObserver test;
1055         ObservableSelectableInstance< SingleObservable< SelectionChangeCallback > > bleh;
1056         bleh.attach( test );
1057         bleh.setSelected( true );
1058         bleh.detach( test );
1059 }
1060
1061 class TestBleh
1062 {
1063 public:
1064 TestBleh(){
1065         test_bleh();
1066 }
1067 };
1068
1069 const TestBleh testbleh;
1070 #endif
1071
1072
1073 #if 0
1074 class TestRefcountedString
1075 {
1076 public:
1077 TestRefcountedString(){
1078         {
1079                 // copy construct
1080                 SmartString string1( "string1" );
1081                 SmartString string2( string1 );
1082                 SmartString string3( string2 );
1083         }
1084         {
1085                 // refcounted assignment
1086                 SmartString string1( "string1" );
1087                 SmartString string2( "string2" );
1088                 string1 = string2;
1089         }
1090         {
1091                 // copy assignment
1092                 SmartString string1( "string1" );
1093                 SmartString string2( "string2" );
1094                 string1 = string2.c_str();
1095         }
1096         {
1097                 // self-assignment
1098                 SmartString string1( "string1" );
1099                 string1 = string1;
1100         }
1101         {
1102                 // self-assignment via another reference
1103                 SmartString string1( "string1" );
1104                 SmartString string2( string1 );
1105                 string1 = string2;
1106         }
1107 }
1108 };
1109
1110 const TestRefcountedString g_testRefcountedString;
1111
1112 #endif
1113
1114 void Select_MakeDetail(){
1115         UndoableCommand undo( "brushSetDetail" );
1116         Scene_BrushSetDetail_Selected( GlobalSceneGraph(), true );
1117 }
1118
1119 void Select_MakeStructural(){
1120         UndoableCommand undo( "brushClearDetail" );
1121         Scene_BrushSetDetail_Selected( GlobalSceneGraph(), false );
1122 }
1123
1124 class BrushMakeSided
1125 {
1126 std::size_t m_count;
1127 public:
1128 BrushMakeSided( std::size_t count )
1129         : m_count( count ){
1130 }
1131 void set(){
1132         Scene_BrushConstructPrefab( GlobalSceneGraph(), eBrushPrism, m_count, TextureBrowser_GetSelectedShader( GlobalTextureBrowser() ) );
1133 }
1134 typedef MemberCaller<BrushMakeSided, void(), &BrushMakeSided::set> SetCaller;
1135 };
1136
1137
1138 BrushMakeSided g_brushmakesided3( 3 );
1139 BrushMakeSided g_brushmakesided4( 4 );
1140 BrushMakeSided g_brushmakesided5( 5 );
1141 BrushMakeSided g_brushmakesided6( 6 );
1142 BrushMakeSided g_brushmakesided7( 7 );
1143 BrushMakeSided g_brushmakesided8( 8 );
1144 BrushMakeSided g_brushmakesided9( 9 );
1145
1146 inline int axis_for_viewtype( int viewtype ){
1147         switch ( viewtype )
1148         {
1149         case XY:
1150                 return 2;
1151         case XZ:
1152                 return 1;
1153         case YZ:
1154                 return 0;
1155         }
1156         return 2;
1157 }
1158
1159 class BrushPrefab
1160 {
1161 EBrushPrefab m_type;
1162 public:
1163 BrushPrefab( EBrushPrefab type )
1164         : m_type( type ){
1165 }
1166 void set(){
1167         DoSides( m_type, axis_for_viewtype( GetViewAxis() ) );
1168 }
1169 typedef MemberCaller<BrushPrefab, void(), &BrushPrefab::set> SetCaller;
1170 };
1171
1172 BrushPrefab g_brushprism( eBrushPrism );
1173 BrushPrefab g_brushcone( eBrushCone );
1174 BrushPrefab g_brushsphere( eBrushSphere );
1175 BrushPrefab g_brushrock( eBrushRock );
1176
1177
1178 void FlipClip();
1179 void SplitClip();
1180 void Clip();
1181 void OnClipMode( bool enable );
1182 bool ClipMode();
1183
1184
1185 void ClipSelected(){
1186         if ( ClipMode() ) {
1187                 UndoableCommand undo( "clipperClip" );
1188                 Clip();
1189         }
1190 }
1191
1192 void SplitSelected(){
1193         if ( ClipMode() ) {
1194                 UndoableCommand undo( "clipperSplit" );
1195                 SplitClip();
1196         }
1197 }
1198
1199 void FlipClipper(){
1200         FlipClip();
1201 }
1202
1203
1204 Callback<void()> g_texture_lock_status_changed;
1205 ConstReferenceCaller<bool, void(const Callback<void(bool)> &), PropertyImpl<bool>::Export> g_texdef_movelock_caller( g_brush_texturelock_enabled );
1206 ToggleItem g_texdef_movelock_item( g_texdef_movelock_caller );
1207
1208 void Texdef_ToggleMoveLock(){
1209         g_brush_texturelock_enabled = !g_brush_texturelock_enabled;
1210         g_texdef_movelock_item.update();
1211         g_texture_lock_status_changed();
1212 }
1213
1214
1215
1216
1217
1218 void Brush_registerCommands(){
1219         GlobalToggles_insert( "TogTexLock", makeCallbackF(Texdef_ToggleMoveLock), ToggleItem::AddCallbackCaller( g_texdef_movelock_item ), Accelerator( 'T', (GdkModifierType)GDK_SHIFT_MASK ) );
1220
1221         GlobalCommands_insert( "BrushPrism", BrushPrefab::SetCaller( g_brushprism ) );
1222         GlobalCommands_insert( "BrushCone", BrushPrefab::SetCaller( g_brushcone ) );
1223         GlobalCommands_insert( "BrushSphere", BrushPrefab::SetCaller( g_brushsphere ) );
1224         GlobalCommands_insert( "BrushRock", BrushPrefab::SetCaller( g_brushrock ) );
1225
1226         GlobalCommands_insert( "Brush3Sided", BrushMakeSided::SetCaller( g_brushmakesided3 ), Accelerator( '3', (GdkModifierType)GDK_CONTROL_MASK ) );
1227         GlobalCommands_insert( "Brush4Sided", BrushMakeSided::SetCaller( g_brushmakesided4 ), Accelerator( '4', (GdkModifierType)GDK_CONTROL_MASK ) );
1228         GlobalCommands_insert( "Brush5Sided", BrushMakeSided::SetCaller( g_brushmakesided5 ), Accelerator( '5', (GdkModifierType)GDK_CONTROL_MASK ) );
1229         GlobalCommands_insert( "Brush6Sided", BrushMakeSided::SetCaller( g_brushmakesided6 ), Accelerator( '6', (GdkModifierType)GDK_CONTROL_MASK ) );
1230         GlobalCommands_insert( "Brush7Sided", BrushMakeSided::SetCaller( g_brushmakesided7 ), Accelerator( '7', (GdkModifierType)GDK_CONTROL_MASK ) );
1231         GlobalCommands_insert( "Brush8Sided", BrushMakeSided::SetCaller( g_brushmakesided8 ), Accelerator( '8', (GdkModifierType)GDK_CONTROL_MASK ) );
1232         GlobalCommands_insert( "Brush9Sided", BrushMakeSided::SetCaller( g_brushmakesided9 ), Accelerator( '9', (GdkModifierType)GDK_CONTROL_MASK ) );
1233
1234         GlobalCommands_insert( "ClipSelected", makeCallbackF(ClipSelected), Accelerator( GDK_KEY_Return ) );
1235         GlobalCommands_insert( "SplitSelected", makeCallbackF(SplitSelected), Accelerator( GDK_KEY_Return, (GdkModifierType)GDK_SHIFT_MASK ) );
1236         GlobalCommands_insert( "FlipClip", makeCallbackF(FlipClipper), Accelerator( GDK_KEY_Return, (GdkModifierType)GDK_CONTROL_MASK ) );
1237
1238         GlobalCommands_insert( "MakeDetail", makeCallbackF(Select_MakeDetail), Accelerator( 'M', (GdkModifierType)GDK_CONTROL_MASK ) );
1239         GlobalCommands_insert( "MakeStructural", makeCallbackF(Select_MakeStructural), Accelerator( 'S', (GdkModifierType)( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) ) );
1240 }
1241
1242 void Brush_constructMenu( ui::Menu menu ){
1243         create_menu_item_with_mnemonic( menu, "Prism...", "BrushPrism" );
1244         create_menu_item_with_mnemonic( menu, "Cone...", "BrushCone" );
1245         create_menu_item_with_mnemonic( menu, "Sphere...", "BrushSphere" );
1246         create_menu_item_with_mnemonic( menu, "Rock...", "BrushRock" );
1247         menu_separator( menu );
1248         {
1249                 auto menu_in_menu = create_sub_menu_with_mnemonic( menu, "CSG" );
1250                 if ( g_Layout_enableDetachableMenus.m_value ) {
1251                         menu_tearoff( menu_in_menu );
1252                 }
1253                 create_menu_item_with_mnemonic( menu_in_menu, "Make _Hollow", "CSGHollow" );
1254                 create_menu_item_with_mnemonic( menu_in_menu, "CSG _Subtract", "CSGSubtract" );
1255                 create_menu_item_with_mnemonic( menu_in_menu, "CSG _Merge", "CSGMerge" );
1256         }
1257         menu_separator( menu );
1258         {
1259                 auto menu_in_menu = create_sub_menu_with_mnemonic( menu, "Clipper" );
1260                 if ( g_Layout_enableDetachableMenus.m_value ) {
1261                         menu_tearoff( menu_in_menu );
1262                 }
1263
1264                 create_menu_item_with_mnemonic( menu_in_menu, "Clip selection", "ClipSelected" );
1265                 create_menu_item_with_mnemonic( menu_in_menu, "Split selection", "SplitSelected" );
1266                 create_menu_item_with_mnemonic( menu_in_menu, "Flip Clip orientation", "FlipClip" );
1267         }
1268         menu_separator( menu );
1269         create_menu_item_with_mnemonic( menu, "Make detail", "MakeDetail" );
1270         create_menu_item_with_mnemonic( menu, "Make structural", "MakeStructural" );
1271         create_menu_item_with_mnemonic( menu, "Snap selection to _grid", "SnapToGrid" );
1272
1273         create_check_menu_item_with_mnemonic( menu, "Texture Lock", "TogTexLock" );
1274         menu_separator( menu );
1275         create_menu_item_with_mnemonic( menu, "Copy Face Texture", "FaceCopyTexture" );
1276         create_menu_item_with_mnemonic( menu, "Paste Face Texture", "FacePasteTexture" );
1277
1278         command_connect_accelerator( "Brush3Sided" );
1279         command_connect_accelerator( "Brush4Sided" );
1280         command_connect_accelerator( "Brush5Sided" );
1281         command_connect_accelerator( "Brush6Sided" );
1282         command_connect_accelerator( "Brush7Sided" );
1283         command_connect_accelerator( "Brush8Sided" );
1284         command_connect_accelerator( "Brush9Sided" );
1285 }