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