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 filter_face_shader_prefix g_filter_face_decals("textures/decals/");
1132 filter_brush_any_face g_filter_brush_decals(&g_filter_face_decals);
1133
1134
1135 void BrushFilters_construct()
1136 {
1137   add_brush_filter(g_filter_brush_clip, EXCLUDE_CLIP);
1138   add_brush_filter(g_filter_brush_clip_q2, EXCLUDE_CLIP);
1139   add_brush_filter(g_filter_brush_weapclip, EXCLUDE_CLIP);
1140   add_brush_filter(g_filter_brush_fullclip, EXCLUDE_CLIP);
1141   add_brush_filter(g_filter_brush_commonclip, EXCLUDE_CLIP);
1142   add_brush_filter(g_filter_brush_botclip, EXCLUDE_BOTCLIP);
1143   add_brush_filter(g_filter_brush_caulk, EXCLUDE_CAULK);
1144   add_brush_filter(g_filter_brush_caulk_ja, EXCLUDE_CAULK);
1145   add_face_filter(g_filter_face_caulk, EXCLUDE_CAULK);
1146   add_face_filter(g_filter_face_caulk_ja, EXCLUDE_CAULK);
1147   add_brush_filter(g_filter_brush_liquids, EXCLUDE_LIQUIDS);
1148   add_brush_filter(g_filter_brush_hint, EXCLUDE_HINTSSKIPS);
1149   add_brush_filter(g_filter_brush_hint_q2, EXCLUDE_HINTSSKIPS);
1150   add_brush_filter(g_filter_brush_hint_ja, EXCLUDE_HINTSSKIPS);
1151   add_brush_filter(g_filter_brush_clusterportal, EXCLUDE_CLUSTERPORTALS);
1152   add_brush_filter(g_filter_brush_visportal, EXCLUDE_VISPORTALS);
1153   add_brush_filter(g_filter_brush_areaportal, EXCLUDE_AREAPORTALS);
1154   add_brush_filter(g_filter_brush_translucent, EXCLUDE_TRANSLUCENT);
1155   add_brush_filter(g_filter_brush_detail, EXCLUDE_DETAILS);
1156   add_brush_filter(g_filter_brush_detail, EXCLUDE_STRUCTURAL, true);
1157   add_brush_filter(g_filter_brush_lightgrid, EXCLUDE_LIGHTGRID);
1158   add_brush_filter(g_filter_brush_decals, EXCLUDE_DECALS);
1159 }
1160
1161 #if 0
1162
1163 void normalquantisation_draw()
1164 {
1165   glPointSize(1);
1166   glBegin(GL_POINTS);
1167   for(std::size_t i = 0; i <= c_quantise_normal; ++i)
1168   {
1169     for(std::size_t j = 0; j <= c_quantise_normal; ++j)
1170     {
1171       Normal3f vertex(normal3f_normalised(Normal3f(
1172         static_cast<float>(c_quantise_normal - j - i),
1173         static_cast<float>(i),
1174         static_cast<float>(j)
1175         )));
1176       VectorScale(normal3f_to_array(vertex), 64.f, normal3f_to_array(vertex));
1177       glVertex3fv(normal3f_to_array(vertex));
1178       vertex.x = -vertex.x;
1179       glVertex3fv(normal3f_to_array(vertex));
1180     }
1181   }
1182   glEnd();
1183 }
1184
1185 class RenderableNormalQuantisation : public OpenGLRenderable
1186 {
1187 public:
1188   void render(RenderStateFlags state) const
1189   {
1190     normalquantisation_draw();
1191   }
1192 };
1193
1194 const float g_test_quantise_normal = 1.f / static_cast<float>(1 << 3);
1195
1196 class TestNormalQuantisation
1197 {
1198   void check_normal(const Normal3f& normal, const Normal3f& other)
1199   {
1200     spherical_t spherical = spherical_from_normal3f(normal);
1201     double longditude = RAD2DEG(spherical.longditude);
1202     double latitude = RAD2DEG(spherical.latitude);
1203     double x = cos(spherical.longditude) * sin(spherical.latitude);
1204     double y = sin(spherical.longditude) * sin(spherical.latitude);
1205     double z = cos(spherical.latitude);
1206
1207     ASSERT_MESSAGE(normal3f_dot(normal, other) > 0.99, "bleh");
1208   }
1209
1210   void test_normal(const Normal3f& normal)
1211   {
1212     Normal3f test = normal3f_from_spherical(spherical_from_normal3f(normal));
1213     check_normal(normal, test);
1214
1215     EOctant octant = normal3f_classify_octant(normal);
1216     Normal3f folded = normal3f_fold_octant(normal, octant);
1217     ESextant sextant = normal3f_classify_sextant(folded);
1218     folded = normal3f_fold_sextant(folded, sextant);
1219
1220     double scale = static_cast<float>(c_quantise_normal) / (folded.x + folded.y + folded.z);
1221
1222     double zbits = folded.z * scale;
1223     double ybits = folded.y * scale;
1224
1225     std::size_t zbits_q = static_cast<std::size_t>(zbits);
1226     std::size_t ybits_q = static_cast<std::size_t>(ybits);
1227
1228     ASSERT_MESSAGE(zbits_q <= (c_quantise_normal / 8) * 3, "bleh");
1229     ASSERT_MESSAGE(ybits_q <= (c_quantise_normal / 2), "bleh");
1230     ASSERT_MESSAGE(zbits_q + ((c_quantise_normal / 2) - ybits_q) <= (c_quantise_normal / 2), "bleh");
1231
1232     std::size_t y_t = (zbits_q < (c_quantise_normal / 4)) ? ybits_q : (c_quantise_normal / 2) - ybits_q;
1233     std::size_t z_t = (zbits_q < (c_quantise_normal / 4)) ? zbits_q : (c_quantise_normal / 2) - zbits_q;
1234     std::size_t index = (c_quantise_normal / 4) * y_t + z_t;
1235     ASSERT_MESSAGE(index <= (c_quantise_normal / 4)*(c_quantise_normal / 2), "bleh");
1236
1237     Normal3f tmp(c_quantise_normal - zbits_q - ybits_q, ybits_q, zbits_q);
1238     tmp = normal3f_normalised(tmp);
1239
1240     Normal3f unfolded = normal3f_unfold_octant(normal3f_unfold_sextant(tmp, sextant), octant);
1241
1242     check_normal(normal, unfolded);
1243
1244     double dot = normal3f_dot(normal, unfolded);
1245     float length = VectorLength(normal3f_to_array(unfolded));
1246     float inv_length = 1 / length;
1247
1248     Normal3f quantised = normal3f_quantised(normal);
1249     check_normal(normal, quantised);
1250   }
1251   void test2(const Normal3f& normal, const Normal3f& other)
1252   {
1253     if(normal3f_quantised(normal) != normal3f_quantised(other))
1254     {
1255       int bleh = 0;
1256     }
1257   }
1258
1259   static Normal3f normalise(float x, float y, float z)
1260   {
1261     return normal3f_normalised(Normal3f(x, y, z));
1262   }
1263
1264   float vec_rand()
1265   {
1266     return static_cast<float>(rand() - (RAND_MAX/2));
1267   }
1268
1269   Normal3f normal3f_rand()
1270   {
1271     return normalise(vec_rand(), vec_rand(), vec_rand());
1272   }
1273
1274 public:
1275   TestNormalQuantisation()
1276   {
1277     for(int i = 4096; i > 0; --i)
1278       test_normal(normal3f_rand());
1279
1280     test_normal(normalise(1, 0, 0));
1281     test_normal(normalise(0, 1, 0));
1282     test_normal(normalise(0, 0, 1));
1283     test_normal(normalise(1, 1, 0));
1284     test_normal(normalise(1, 0, 1));
1285     test_normal(normalise(0, 1, 1));
1286
1287     test_normal(normalise(10000, 10000, 10000));
1288     test_normal(normalise(10000, 10000, 10001));
1289     test_normal(normalise(10000, 10000, 10002));
1290     test_normal(normalise(10000, 10000, 10010));
1291     test_normal(normalise(10000, 10000, 10020));
1292     test_normal(normalise(10000, 10000, 10030));
1293     test_normal(normalise(10000, 10000, 10100));
1294     test_normal(normalise(10000, 10000, 10101));
1295     test_normal(normalise(10000, 10000, 10102));
1296     test_normal(normalise(10000, 10000, 10200));
1297     test_normal(normalise(10000, 10000, 10201));
1298     test_normal(normalise(10000, 10000, 10202));
1299     test_normal(normalise(10000, 10000, 10203));
1300     test_normal(normalise(10000, 10000, 10300));
1301
1302
1303     test2(normalise(10000, 10000, 10000), normalise(10000, 10000, 10001));
1304     test2(normalise(10000, 10000, 10001), normalise(10000, 10001, 10000));
1305   }
1306 };
1307
1308 TestNormalQuantisation g_testNormalQuantisation;
1309
1310
1311 #endif
1312
1313 #if 0
1314 class TestSelectableObserver : public observer_template<const Selectable&>
1315 {
1316 public:
1317   void notify(const Selectable& arguments)
1318   {
1319     bool bleh = arguments.isSelected();
1320   }
1321 };
1322
1323 inline void test_bleh()
1324 {
1325   TestSelectableObserver test;
1326   ObservableSelectableInstance< SingleObservable< SelectionChangeCallback > > bleh;
1327   bleh.attach(test);
1328   bleh.setSelected(true);
1329   bleh.detach(test);
1330 }
1331
1332 class TestBleh
1333 {
1334 public:
1335   TestBleh()
1336   {
1337     test_bleh();
1338   }
1339 };
1340
1341 const TestBleh testbleh;
1342 #endif
1343
1344
1345 #if 0
1346 class TestRefcountedString
1347 {
1348 public:
1349   TestRefcountedString()
1350   {
1351     {
1352       // copy construct
1353       SmartString string1("string1");
1354       SmartString string2(string1);
1355       SmartString string3(string2);
1356     }
1357     {
1358       // refcounted assignment
1359       SmartString string1("string1");
1360       SmartString string2("string2");
1361       string1 = string2;
1362     }
1363     {
1364       // copy assignment
1365       SmartString string1("string1");
1366       SmartString string2("string2");
1367       string1 = string2.c_str();
1368     }
1369     {
1370       // self-assignment
1371       SmartString string1("string1");
1372       string1 = string1;
1373     }
1374     {
1375       // self-assignment via another reference
1376       SmartString string1("string1");
1377       SmartString string2(string1);
1378       string1 = string2;
1379     }
1380   }
1381 };
1382
1383 const TestRefcountedString g_testRefcountedString;
1384
1385 #endif
1386
1387 void Select_MakeDetail()
1388 {
1389   UndoableCommand undo("brushSetDetail");
1390   Scene_BrushSetDetail_Selected(GlobalSceneGraph(), true);
1391 }
1392
1393 void Select_MakeStructural()
1394 {
1395   UndoableCommand undo("brushClearDetail");
1396   Scene_BrushSetDetail_Selected(GlobalSceneGraph(), false);
1397 }
1398
1399 class BrushMakeSided
1400 {
1401   std::size_t m_count;
1402 public:
1403   BrushMakeSided(std::size_t count)
1404     : m_count(count)
1405   {
1406   }
1407   void set()
1408   {
1409     Scene_BrushConstructPrefab(GlobalSceneGraph(), eBrushPrism, m_count, TextureBrowser_GetSelectedShader(GlobalTextureBrowser()));
1410   }
1411   typedef MemberCaller<BrushMakeSided, &BrushMakeSided::set> SetCaller;
1412 };
1413
1414
1415 BrushMakeSided g_brushmakesided3(3);
1416 BrushMakeSided g_brushmakesided4(4);
1417 BrushMakeSided g_brushmakesided5(5);
1418 BrushMakeSided g_brushmakesided6(6);
1419 BrushMakeSided g_brushmakesided7(7);
1420 BrushMakeSided g_brushmakesided8(8);
1421 BrushMakeSided g_brushmakesided9(9);
1422
1423 inline int axis_for_viewtype(int viewtype)
1424 {
1425   switch(viewtype)
1426   {
1427     case XY:
1428       return 2;
1429     case XZ:
1430       return 1;
1431     case YZ:
1432       return 0;
1433   }
1434   return 2;
1435 }
1436
1437 class BrushPrefab
1438 {
1439   EBrushPrefab m_type;
1440 public:
1441   BrushPrefab(EBrushPrefab type)
1442     : m_type(type)
1443   {
1444   }
1445   void set()
1446   {
1447     DoSides(m_type, axis_for_viewtype(GetViewAxis()));
1448   }
1449   typedef MemberCaller<BrushPrefab, &BrushPrefab::set> SetCaller;
1450 };
1451
1452 BrushPrefab g_brushprism(eBrushPrism);
1453 BrushPrefab g_brushcone(eBrushCone);
1454 BrushPrefab g_brushsphere(eBrushSphere);
1455 BrushPrefab g_brushrock(eBrushRock);
1456
1457
1458 void FlipClip();
1459 void SplitClip();
1460 void Clip();
1461 void OnClipMode(bool enable);
1462 bool ClipMode();
1463
1464
1465 void ClipSelected()
1466 {
1467   if(ClipMode())
1468   {
1469     UndoableCommand undo("clipperClip");
1470     Clip();
1471   }
1472 }
1473
1474 void SplitSelected()
1475 {
1476   if(ClipMode())
1477   {
1478     UndoableCommand undo("clipperSplit");
1479     SplitClip();
1480   }
1481 }
1482
1483 void FlipClipper()
1484 {
1485   FlipClip();
1486 }
1487
1488
1489 Callback g_texture_lock_status_changed;
1490 BoolExportCaller g_texdef_movelock_caller(g_brush_texturelock_enabled);
1491 ToggleItem g_texdef_movelock_item(g_texdef_movelock_caller);
1492
1493 void Texdef_ToggleMoveLock()
1494 {
1495   g_brush_texturelock_enabled = !g_brush_texturelock_enabled;
1496   g_texdef_movelock_item.update();
1497   g_texture_lock_status_changed();
1498 }
1499
1500
1501
1502
1503
1504 void Brush_registerCommands()
1505 {
1506   GlobalToggles_insert("TogTexLock", FreeCaller<Texdef_ToggleMoveLock>(), ToggleItem::AddCallbackCaller(g_texdef_movelock_item), Accelerator('T', (GdkModifierType)GDK_SHIFT_MASK));
1507
1508   GlobalCommands_insert("BrushPrism", BrushPrefab::SetCaller(g_brushprism));
1509   GlobalCommands_insert("BrushCone", BrushPrefab::SetCaller(g_brushcone));
1510   GlobalCommands_insert("BrushSphere", BrushPrefab::SetCaller(g_brushsphere));
1511   GlobalCommands_insert("BrushRock", BrushPrefab::SetCaller(g_brushrock));
1512
1513   GlobalCommands_insert("Brush3Sided", BrushMakeSided::SetCaller(g_brushmakesided3), Accelerator('3', (GdkModifierType)GDK_CONTROL_MASK));
1514   GlobalCommands_insert("Brush4Sided", BrushMakeSided::SetCaller(g_brushmakesided4), Accelerator('4', (GdkModifierType)GDK_CONTROL_MASK));
1515   GlobalCommands_insert("Brush5Sided", BrushMakeSided::SetCaller(g_brushmakesided5), Accelerator('5', (GdkModifierType)GDK_CONTROL_MASK));
1516   GlobalCommands_insert("Brush6Sided", BrushMakeSided::SetCaller(g_brushmakesided6), Accelerator('6', (GdkModifierType)GDK_CONTROL_MASK));
1517   GlobalCommands_insert("Brush7Sided", BrushMakeSided::SetCaller(g_brushmakesided7), Accelerator('7', (GdkModifierType)GDK_CONTROL_MASK));
1518   GlobalCommands_insert("Brush8Sided", BrushMakeSided::SetCaller(g_brushmakesided8), Accelerator('8', (GdkModifierType)GDK_CONTROL_MASK));
1519   GlobalCommands_insert("Brush9Sided", BrushMakeSided::SetCaller(g_brushmakesided9), Accelerator('9', (GdkModifierType)GDK_CONTROL_MASK));
1520
1521   GlobalCommands_insert("ClipSelected", FreeCaller<ClipSelected>(), Accelerator(GDK_Return));
1522   GlobalCommands_insert("SplitSelected", FreeCaller<SplitSelected>(), Accelerator(GDK_Return, (GdkModifierType)GDK_SHIFT_MASK));
1523   GlobalCommands_insert("FlipClip", FreeCaller<FlipClipper>(), Accelerator(GDK_Return, (GdkModifierType)GDK_CONTROL_MASK));
1524
1525   GlobalCommands_insert("MakeDetail", FreeCaller<Select_MakeDetail>(), Accelerator('M', (GdkModifierType)GDK_CONTROL_MASK));
1526   GlobalCommands_insert("MakeStructural", FreeCaller<Select_MakeStructural>(), Accelerator('S', (GdkModifierType)(GDK_SHIFT_MASK|GDK_CONTROL_MASK)));
1527 }
1528
1529 void Brush_constructMenu(GtkMenu* menu)
1530 {
1531   create_menu_item_with_mnemonic(menu, "Prism...", "BrushPrism");
1532   create_menu_item_with_mnemonic(menu, "Cone...", "BrushCone");
1533   create_menu_item_with_mnemonic(menu, "Sphere...", "BrushSphere");
1534   create_menu_item_with_mnemonic(menu, "Rock...", "BrushRock");
1535   menu_separator (menu);
1536   {
1537     GtkMenu* menu_in_menu = create_sub_menu_with_mnemonic (menu, "CSG");
1538     if (g_Layout_enableDetachableMenus.m_value)
1539       menu_tearoff (menu_in_menu);
1540     create_menu_item_with_mnemonic(menu_in_menu, "Make _Hollow", "CSGHollow");
1541     create_menu_item_with_mnemonic(menu_in_menu, "CSG _Subtract", "CSGSubtract");
1542     create_menu_item_with_mnemonic(menu_in_menu, "CSG _Merge", "CSGMerge");
1543   }
1544   menu_separator(menu);
1545   {
1546     GtkMenu* menu_in_menu = create_sub_menu_with_mnemonic (menu, "Clipper");
1547     if (g_Layout_enableDetachableMenus.m_value)
1548       menu_tearoff (menu_in_menu);
1549
1550     create_menu_item_with_mnemonic(menu_in_menu, "Clip selection", "ClipSelected");
1551     create_menu_item_with_mnemonic(menu_in_menu, "Split selection", "SplitSelected");
1552     create_menu_item_with_mnemonic(menu_in_menu, "Flip Clip orientation", "FlipClip");
1553   }
1554   menu_separator(menu);
1555   create_menu_item_with_mnemonic(menu, "Make detail", "MakeDetail");
1556   create_menu_item_with_mnemonic(menu, "Make structural", "MakeStructural");
1557   create_menu_item_with_mnemonic(menu, "Snap selection to _grid", "SnapToGrid");
1558
1559   create_check_menu_item_with_mnemonic(menu, "Texture Lock", "TogTexLock");
1560   menu_separator(menu);
1561   create_menu_item_with_mnemonic(menu, "Copy Face Texture", "FaceCopyTexture");
1562   create_menu_item_with_mnemonic(menu, "Paste Face Texture", "FacePasteTexture");
1563
1564   command_connect_accelerator("Brush3Sided");
1565   command_connect_accelerator("Brush4Sided");
1566   command_connect_accelerator("Brush5Sided");
1567   command_connect_accelerator("Brush6Sided");
1568   command_connect_accelerator("Brush7Sided");
1569   command_connect_accelerator("Brush8Sided");
1570   command_connect_accelerator("Brush9Sided");
1571 }