radiant/select.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 "select.h"
  23
  24 #include "debugging/debugging.h"
  25
  26 #include "ientity.h"
  27 #include "iselection.h"
  28 #include "iundo.h"
  29
  30 #include <vector>
  31
  32 #include "stream/stringstream.h"
  33 #include "signal/isignal.h"
  34 #include "shaderlib.h"
  35 #include "scenelib.h"
  36
  37 #include "gtkutil/idledraw.h"
  38 #include "gtkutil/dialog.h"
  39 #include "gtkutil/widget.h"
  40 #include "brushmanip.h"
  41 #include "brush.h"
  42 #include "patchmanip.h"
  43 #include "patchdialog.h"
  44 #include "selection.h"
  45 #include "texwindow.h"
  46 #include "gtkmisc.h"
  47 #include "mainframe.h"
  48 #include "grid.h"
  49 #include "map.h"
  50
  51
  52
  53 select_workzone_t g_select_workzone;
  54
  55
  56 /**
  57   Loops over all selected brushes and stores their
  58   world AABBs in the specified array.
  59 */
  60 class CollectSelectedBrushesBounds : public SelectionSystem::Visitor
  61 {
  62   AABB* m_bounds;   // array of AABBs
  63   Unsigned m_max;   // max AABB-elements in array
  64   Unsigned& m_count;// count of valid AABBs stored in array
  65
  66 public:
  67   CollectSelectedBrushesBounds(AABB* bounds, Unsigned max, Unsigned& count)
  68     : m_bounds(bounds),
  69       m_max(max),
  70       m_count(count)
  71   {
  72     m_count = 0;
  73   }
  74
  75   void visit(scene::Instance& instance) const
  76   {
  77     ASSERT_MESSAGE(m_count <= m_max, "Invalid m_count in CollectSelectedBrushesBounds");
  78
  79     // stop if the array is already full
  80     if(m_count == m_max)
  81       return;
  82
  83     Selectable* selectable = Instance_getSelectable(instance);
  84     if((selectable != 0)
  85       && instance.isSelected())
  86     {
  87       // brushes only
  88       if(Instance_getBrush(instance) != 0)
  89       {
  90         m_bounds[m_count] = instance.worldAABB();
  91         ++m_count;
  92       }
  93     }
  94   }
  95 };
  96
  97 /**
  98   Selects all objects that intersect one of the bounding AABBs.
  99   The exact intersection-method is specified through TSelectionPolicy
 100 */
 101 template<class TSelectionPolicy>
 102 class SelectByBounds : public scene::Graph::Walker
 103 {
 104   AABB* m_aabbs;           // selection aabbs
 105   Unsigned m_count;        // number of aabbs in m_aabbs
 106   TSelectionPolicy policy; // type that contains a custom intersection method aabb<->aabb
 107
 108 public:
 109   SelectByBounds(AABB* aabbs, Unsigned count)
 110       : m_aabbs(aabbs),
 111         m_count(count)
 112   {
 113   }
 114
 115   bool pre(const scene::Path& path, scene::Instance& instance) const
 116   {
 117     Selectable* selectable = Instance_getSelectable(instance);
 118
 119     // ignore worldspawn
 120     Entity* entity = Node_getEntity(path.top());
 121     if(entity)
 122     {
 123       if(string_equal(entity->getKeyValue("classname"), "worldspawn"))
 124         return true;
 125     }
 126
 127     if( (path.size() > 1) &&
 128         (!path.top().get().isRoot()) &&
 129         (selectable != 0)
 130        )
 131     {
 132       for(Unsigned i = 0; i < m_count; ++i)
 133       {
 134         if(policy.Evaluate(m_aabbs[i], instance))
 135         {
 136           selectable->setSelected(true);
 137         }
 138       }
 139     }
 140
 141     return true;
 142   }
 143
 144   /**
 145     Performs selection operation on the global scenegraph.
 146     If delete_bounds_src is true, then the objects which were
 147     used as source for the selection aabbs will be deleted.
 148 */
 149   static void DoSelection(bool delete_bounds_src = true)
 150   {
 151     if(GlobalSelectionSystem().Mode() == SelectionSystem::ePrimitive)
 152     {
 153       // we may not need all AABBs since not all selected objects have to be brushes
 154       const Unsigned max = (Unsigned)GlobalSelectionSystem().countSelected();
 155       AABB* aabbs = new AABB[max];
 156
 157       Unsigned count;
 158       CollectSelectedBrushesBounds collector(aabbs, max, count);
 159       GlobalSelectionSystem().foreachSelected(collector);
 160
 161       // nothing usable in selection
 162       if(!count)
 163       {
 164         delete[] aabbs;
 165         return;
 166       }
 167
 168       // delete selected objects
 169       if(delete_bounds_src)// see deleteSelection
 170       {
 171         UndoableCommand undo("deleteSelected");
 172         Select_Delete();
 173       }
 174
 175       // select objects with bounds
 176       GlobalSceneGraph().traverse(SelectByBounds<TSelectionPolicy>(aabbs, count));
 177
 178       SceneChangeNotify();
 179       delete[] aabbs;
 180     }
 181   }
 182 };
 183
 184 /**
 185   SelectionPolicy for SelectByBounds
 186   Returns true if box and the AABB of instance intersect
 187 */
 188 class SelectionPolicy_Touching
 189 {
 190 public:
 191   bool Evaluate(const AABB& box, scene::Instance& instance) const
 192   {
 193     const AABB& other(instance.worldAABB());
 194     for(Unsigned i = 0; i < 3; ++i)
 195     {
 196       if(fabsf(box.origin[i] - other.origin[i]) > (box.extents[i] + other.extents[i]))
 197         return false;
 198     }
 199     return true;
 200   }
 201 };
 202
 203 /**
 204   SelectionPolicy for SelectByBounds
 205   Returns true if the AABB of instance is inside box
 206 */
 207 class SelectionPolicy_Inside
 208 {
 209 public:
 210   bool Evaluate(const AABB& box, scene::Instance& instance) const
 211   {
 212     const AABB& other(instance.worldAABB());
 213     for(Unsigned i = 0; i < 3; ++i)
 214     {
 215       if(fabsf(box.origin[i] - other.origin[i]) > (box.extents[i] - other.extents[i]))
 216         return false;
 217     }
 218     return true;
 219   }
 220 };
 221
 222 class DeleteSelected : public scene::Graph::Walker
 223 {
 224   mutable bool m_remove;
 225   mutable bool m_removedChild;
 226 public:
 227   DeleteSelected()
 228     : m_remove(false), m_removedChild(false)
 229   {
 230   }
 231   bool pre(const scene::Path& path, scene::Instance& instance) const
 232   {
 233     m_removedChild = false;
 234
 235     Selectable* selectable = Instance_getSelectable(instance);
 236     if(selectable != 0
 237       && selectable->isSelected()
 238       && path.size() > 1
 239       && !path.top().get().isRoot())
 240     {
 241       m_remove = true;
 242
 243       return false;// dont traverse into child elements
 244     }
 245     return true;
 246   }
 247   void post(const scene::Path& path, scene::Instance& instance) const
 248   {
 249
 250     if(m_removedChild)
 251     {
 252       m_removedChild = false;
 253
 254       // delete empty entities
 255       Entity* entity = Node_getEntity(path.top());
 256       if(entity != 0
 257         && path.top().get_pointer() != Map_FindWorldspawn(g_map)
 258         && Node_getTraversable(path.top())->empty())
 259       {
 260         Path_deleteTop(path);
 261       }
 262     }
 263
 264         // node should be removed
 265     if(m_remove)
 266     {
 267       if(Node_isEntity(path.parent()) != 0)
 268       {
 269         m_removedChild = true;
 270       }
 271
 272       m_remove = false;
 273       Path_deleteTop(path);
 274     }
 275   }
 276 };
 277
 278 void Scene_DeleteSelected(scene::Graph& graph)
 279 {
 280   graph.traverse(DeleteSelected());
 281   SceneChangeNotify();
 282 }
 283
 284 void Select_Delete (void)
 285 {
 286   Scene_DeleteSelected(GlobalSceneGraph());
 287 }
 288
 289 class InvertSelectionWalker : public scene::Graph::Walker
 290 {
 291   SelectionSystem::EMode m_mode;
 292   mutable Selectable* m_selectable;
 293 public:
 294   InvertSelectionWalker(SelectionSystem::EMode mode)
 295     : m_mode(mode), m_selectable(0)
 296   {
 297   }
 298   bool pre(const scene::Path& path, scene::Instance& instance) const
 299   {
 300     Selectable* selectable = Instance_getSelectable(instance);
 301     if(selectable)
 302     {
 303       switch(m_mode)
 304       {
 305       case SelectionSystem::eEntity:
 306         if(Node_isEntity(path.top()) != 0)
 307         {
 308           m_selectable = path.top().get().visible() ? selectable : 0;
 309         }
 310         break;
 311       case SelectionSystem::ePrimitive:
 312         m_selectable = path.top().get().visible() ? selectable : 0;
 313         break;
 314       case SelectionSystem::eComponent:
 315         break;
 316       }
 317     }
 318     return true;
 319   }
 320   void post(const scene::Path& path, scene::Instance& instance) const
 321   {
 322     if(m_selectable != 0)
 323     {
 324       m_selectable->setSelected(!m_selectable->isSelected());
 325       m_selectable = 0;
 326     }
 327   }
 328 };
 329
 330 void Scene_Invert_Selection(scene::Graph& graph)
 331 {
 332   graph.traverse(InvertSelectionWalker(GlobalSelectionSystem().Mode()));
 333 }
 334
 335 void Select_Invert()
 336 {
 337   Scene_Invert_Selection(GlobalSceneGraph());
 338 }
 339
 340 class ExpandSelectionToEntitiesWalker : public scene::Graph::Walker
 341 {
 342   mutable std::size_t m_depth;
 343 public:
 344   ExpandSelectionToEntitiesWalker() : m_depth(0)
 345   {
 346   }
 347   bool pre(const scene::Path& path, scene::Instance& instance) const
 348   {
 349     ++m_depth;
 350
 351     // ignore worldspawn
 352     NodeSmartReference me(path.top().get());
 353     if(me == Map_FindOrInsertWorldspawn(g_map))
 354             return false;
 355
 356     if(m_depth == 2) // entity depth
 357     {
 358       // traverse and select children if any one is selected
 359           if(instance.childSelected())
 360                 Instance_setSelected(instance, true);
 361       return Node_getEntity(path.top())->isContainer() && instance.isSelected();
 362     }
 363     else if(m_depth == 3) // primitive depth
 364     {
 365       Instance_setSelected(instance, true);
 366       return false;
 367     }
 368     return true;
 369   }
 370   void post(const scene::Path& path, scene::Instance& instance) const
 371   {
 372     --m_depth;
 373   }
 374 };
 375
 376 void Scene_ExpandSelectionToEntities()
 377 {
 378   GlobalSceneGraph().traverse(ExpandSelectionToEntitiesWalker());
 379 }
 380
 381
 382 namespace
 383 {
 384   void Selection_UpdateWorkzone()
 385   {
 386     if(GlobalSelectionSystem().countSelected() != 0)
 387     {
 388       Select_GetBounds(g_select_workzone.d_work_min, g_select_workzone.d_work_max);
 389     }
 390   }
 391   typedef FreeCaller<Selection_UpdateWorkzone> SelectionUpdateWorkzoneCaller;
 392
 393   IdleDraw g_idleWorkzone = IdleDraw(SelectionUpdateWorkzoneCaller());
 394 }
 395
 396 const select_workzone_t& Select_getWorkZone()
 397 {
 398   g_idleWorkzone.flush();
 399   return g_select_workzone;
 400 }
 401
 402 void UpdateWorkzone_ForSelection()
 403 {
 404   g_idleWorkzone.queueDraw();
 405 }
 406
 407 // update the workzone to the current selection
 408 void UpdateWorkzone_ForSelectionChanged(const Selectable& selectable)
 409 {
 410   if(selectable.isSelected())
 411   {
 412     UpdateWorkzone_ForSelection();
 413   }
 414 }
 415
 416 void Select_SetShader(const char* shader)
 417 {
 418   if(GlobalSelectionSystem().Mode() != SelectionSystem::eComponent)
 419   {
 420     Scene_BrushSetShader_Selected(GlobalSceneGraph(), shader);
 421     Scene_PatchSetShader_Selected(GlobalSceneGraph(), shader);
 422   }
 423   Scene_BrushSetShader_Component_Selected(GlobalSceneGraph(), shader);
 424 }
 425
 426 void Select_SetTexdef(const TextureProjection& projection)
 427 {
 428   if(GlobalSelectionSystem().Mode() != SelectionSystem::eComponent)
 429   {
 430     Scene_BrushSetTexdef_Selected(GlobalSceneGraph(), projection);
 431   }
 432   Scene_BrushSetTexdef_Component_Selected(GlobalSceneGraph(), projection);
 433 }
 434
 435 void Select_SetFlags(const ContentsFlagsValue& flags)
 436 {
 437   if(GlobalSelectionSystem().Mode() != SelectionSystem::eComponent)
 438   {
 439     Scene_BrushSetFlags_Selected(GlobalSceneGraph(), flags);
 440   }
 441   Scene_BrushSetFlags_Component_Selected(GlobalSceneGraph(), flags);
 442 }
 443
 444 void Select_GetBounds (Vector3& mins, Vector3& maxs)
 445 {
 446   AABB bounds;
 447   Scene_BoundsSelected(GlobalSceneGraph(), bounds);
 448   maxs = vector3_added(bounds.origin, bounds.extents);
 449   mins = vector3_subtracted(bounds.origin, bounds.extents);
 450 }
 451
 452 void Select_GetMid (Vector3& mid)
 453 {
 454   AABB bounds;
 455   Scene_BoundsSelected(GlobalSceneGraph(), bounds);
 456   mid = vector3_snapped(bounds.origin);
 457 }
 458
 459
 460 void Select_FlipAxis (int axis)
 461 {
 462   Vector3 flip(1, 1, 1);
 463   flip[axis] = -1;
 464   GlobalSelectionSystem().scaleSelected(flip);
 465 }
 466
 467
 468 void Select_Scale(float x, float y, float z)
 469 {
 470   GlobalSelectionSystem().scaleSelected(Vector3(x, y, z));
 471 }
 472
 473 enum axis_t
 474 {
 475   eAxisX = 0,
 476   eAxisY = 1,
 477   eAxisZ = 2,
 478 };
 479
 480 enum sign_t
 481 {
 482   eSignPositive = 1,
 483   eSignNegative = -1,
 484 };
 485
 486 inline Matrix4 matrix4_rotation_for_axis90(axis_t axis, sign_t sign)
 487 {
 488   switch(axis)
 489   {
 490   case eAxisX:
 491     if(sign == eSignPositive)
 492     {
 493       return matrix4_rotation_for_sincos_x(1, 0);
 494     }
 495     else
 496     {
 497       return matrix4_rotation_for_sincos_x(-1, 0);
 498     }
 499   case eAxisY:
 500     if(sign == eSignPositive)
 501     {
 502       return matrix4_rotation_for_sincos_y(1, 0);
 503     }
 504     else
 505     {
 506       return matrix4_rotation_for_sincos_y(-1, 0);
 507     }
 508   default://case eAxisZ:
 509     if(sign == eSignPositive)
 510     {
 511       return matrix4_rotation_for_sincos_z(1, 0);
 512     }
 513     else
 514     {
 515       return matrix4_rotation_for_sincos_z(-1, 0);
 516     }
 517   }
 518 }
 519
 520 inline void matrix4_rotate_by_axis90(Matrix4& matrix, axis_t axis, sign_t sign)
 521 {
 522   matrix4_multiply_by_matrix4(matrix, matrix4_rotation_for_axis90(axis, sign));
 523 }
 524
 525 inline void matrix4_pivoted_rotate_by_axis90(Matrix4& matrix, axis_t axis, sign_t sign, const Vector3& pivotpoint)
 526 {
 527   matrix4_translate_by_vec3(matrix, pivotpoint);
 528   matrix4_rotate_by_axis90(matrix, axis, sign);
 529   matrix4_translate_by_vec3(matrix, vector3_negated(pivotpoint));
 530 }
 531
 532 inline Quaternion quaternion_for_axis90(axis_t axis, sign_t sign)
 533 {
 534 #if 1
 535   switch(axis)
 536   {
 537   case eAxisX:
 538     if(sign == eSignPositive)
 539     {
 540       return Quaternion(c_half_sqrt2f, 0, 0, c_half_sqrt2f);
 541     }
 542     else
 543     {
 544       return Quaternion(-c_half_sqrt2f, 0, 0, -c_half_sqrt2f);
 545     }
 546   case eAxisY:
 547     if(sign == eSignPositive)
 548     {
 549       return Quaternion(0, c_half_sqrt2f, 0, c_half_sqrt2f);
 550     }
 551     else
 552     {
 553       return Quaternion(0, -c_half_sqrt2f, 0, -c_half_sqrt2f);
 554     }
 555   default://case eAxisZ:
 556     if(sign == eSignPositive)
 557     {
 558       return Quaternion(0, 0, c_half_sqrt2f, c_half_sqrt2f);
 559     }
 560     else
 561     {
 562       return Quaternion(0, 0, -c_half_sqrt2f, -c_half_sqrt2f);
 563     }
 564   }
 565 #else
 566   quaternion_for_matrix4_rotation(matrix4_rotation_for_axis90((axis_t)axis, (deg > 0) ? eSignPositive : eSignNegative));
 567 #endif
 568 }
 569
 570 void Select_RotateAxis (int axis, float deg)
 571 {
 572   if(fabs(deg) == 90.f)
 573   {
 574     GlobalSelectionSystem().rotateSelected(quaternion_for_axis90((axis_t)axis, (deg > 0) ? eSignPositive : eSignNegative));
 575   }
 576   else
 577   {
 578     switch(axis)
 579     {
 580     case 0:
 581       GlobalSelectionSystem().rotateSelected(quaternion_for_matrix4_rotation(matrix4_rotation_for_x_degrees(deg)));
 582       break;
 583     case 1:
 584       GlobalSelectionSystem().rotateSelected(quaternion_for_matrix4_rotation(matrix4_rotation_for_y_degrees(deg)));
 585       break;
 586     case 2:
 587       GlobalSelectionSystem().rotateSelected(quaternion_for_matrix4_rotation(matrix4_rotation_for_z_degrees(deg)));
 588       break;
 589     }
 590   }
 591 }
 592
 593
 594 void Select_ShiftTexture(float x, float y)
 595 {
 596   if(GlobalSelectionSystem().Mode() != SelectionSystem::eComponent)
 597   {
 598     Scene_BrushShiftTexdef_Selected(GlobalSceneGraph(), x, y);
 599     Scene_PatchTranslateTexture_Selected(GlobalSceneGraph(), x, y);
 600   }
 601   //globalOutputStream() << "shift selected face textures: s=" << x << " t=" << y << '\n';
 602   Scene_BrushShiftTexdef_Component_Selected(GlobalSceneGraph(), x, y);
 603 }
 604
 605 void Select_ScaleTexture(float x, float y)
 606 {
 607   if(GlobalSelectionSystem().Mode() != SelectionSystem::eComponent)
 608   {
 609     Scene_BrushScaleTexdef_Selected(GlobalSceneGraph(), x, y);
 610     Scene_PatchScaleTexture_Selected(GlobalSceneGraph(), x, y);
 611   }
 612   Scene_BrushScaleTexdef_Component_Selected(GlobalSceneGraph(), x, y);
 613 }
 614
 615 void Select_RotateTexture(float amt)
 616 {
 617   if(GlobalSelectionSystem().Mode() != SelectionSystem::eComponent)
 618   {
 619     Scene_BrushRotateTexdef_Selected(GlobalSceneGraph(), amt);
 620     Scene_PatchRotateTexture_Selected(GlobalSceneGraph(), amt);
 621   }
 622   Scene_BrushRotateTexdef_Component_Selected(GlobalSceneGraph(), amt);
 623 }
 624
 625 // TTimo modified to handle shader architecture:
 626 // expects shader names at input, comparison relies on shader names .. texture names no longer relevant
 627 void FindReplaceTextures(const char* pFind, const char* pReplace, bool bSelected)
 628 {
 629   if(!texdef_name_valid(pFind))
 630   {
 631     globalErrorStream() << "FindReplaceTextures: invalid texture name: '" << pFind << "', aborted\n";
 632     return;
 633   }
 634   if(!texdef_name_valid(pReplace))
 635   {
 636     globalErrorStream() << "FindReplaceTextures: invalid texture name: '" << pReplace << "', aborted\n";
 637     return;
 638   }
 639
 640   StringOutputStream command;
 641   command << "textureFindReplace -find " << pFind << " -replace " << pReplace;
 642   UndoableCommand undo(command.c_str());
 643
 644   if(bSelected)
 645   {
 646     if(GlobalSelectionSystem().Mode() != SelectionSystem::eComponent)
 647     {
 648       Scene_BrushFindReplaceShader_Selected(GlobalSceneGraph(), pFind, pReplace);
 649       Scene_PatchFindReplaceShader_Selected(GlobalSceneGraph(), pFind, pReplace);
 650     }
 651     Scene_BrushFindReplaceShader_Component_Selected(GlobalSceneGraph(), pFind, pReplace);
 652   }
 653   else
 654   {
 655     Scene_BrushFindReplaceShader(GlobalSceneGraph(), pFind, pReplace);
 656     Scene_PatchFindReplaceShader(GlobalSceneGraph(), pFind, pReplace);
 657   }
 658 }
 659
 660 typedef std::vector<const char*> Classnames;
 661
 662 bool classnames_match_entity(const Classnames& classnames, Entity* entity)
 663 {
 664   for(Classnames::const_iterator i = classnames.begin(); i != classnames.end(); ++i)
 665   {
 666     if(string_equal(entity->getKeyValue("classname"), *i))
 667     {
 668       return true;
 669     }
 670   }
 671   return false;
 672 }
 673
 674 class EntityFindByClassnameWalker : public scene::Graph::Walker
 675 {
 676   const Classnames& m_classnames;
 677 public:
 678   EntityFindByClassnameWalker(const Classnames& classnames)
 679     : m_classnames(classnames)
 680   {
 681   }
 682   bool pre(const scene::Path& path, scene::Instance& instance) const
 683   {
 684     Entity* entity = Node_getEntity(path.top());
 685     if(entity != 0
 686       && classnames_match_entity(m_classnames, entity))
 687     {
 688       Instance_getSelectable(instance)->setSelected(true);
 689     }
 690     return true;
 691   }
 692 };
 693
 694 void Scene_EntitySelectByClassnames(scene::Graph& graph, const Classnames& classnames)
 695 {
 696   graph.traverse(EntityFindByClassnameWalker(classnames));
 697 }
 698
 699 class EntityGetSelectedClassnamesWalker : public scene::Graph::Walker
 700 {
 701   Classnames& m_classnames;
 702 public:
 703   EntityGetSelectedClassnamesWalker(Classnames& classnames)
 704     : m_classnames(classnames)
 705   {
 706   }
 707   bool pre(const scene::Path& path, scene::Instance& instance) const
 708   {
 709     Selectable* selectable = Instance_getSelectable(instance);
 710     if(selectable != 0
 711       && selectable->isSelected())
 712     {
 713       Entity* entity = Node_getEntity(path.top());
 714       if(entity != 0)
 715       {
 716         m_classnames.push_back(entity->getKeyValue("classname"));
 717       }
 718     }
 719     return true;
 720   }
 721 };
 722
 723 void Scene_EntityGetClassnames(scene::Graph& graph, Classnames& classnames)
 724 {
 725   graph.traverse(EntityGetSelectedClassnamesWalker(classnames));
 726 }
 727
 728 void Select_AllOfType()
 729 {
 730   if(GlobalSelectionSystem().Mode() == SelectionSystem::eComponent)
 731   {
 732     if(GlobalSelectionSystem().ComponentMode() == SelectionSystem::eFace)
 733     {
 734       GlobalSelectionSystem().setSelectedAllComponents(false);
 735       Scene_BrushSelectByShader_Component(GlobalSceneGraph(), TextureBrowser_GetSelectedShader(GlobalTextureBrowser()));
 736     }
 737   }
 738   else
 739   {
 740     Classnames classnames;
 741     Scene_EntityGetClassnames(GlobalSceneGraph(), classnames);
 742     GlobalSelectionSystem().setSelectedAll(false);
 743     if(!classnames.empty())
 744     {
 745       Scene_EntitySelectByClassnames(GlobalSceneGraph(), classnames);
 746     }
 747     else
 748     {
 749       Scene_BrushSelectByShader(GlobalSceneGraph(), TextureBrowser_GetSelectedShader(GlobalTextureBrowser()));
 750       Scene_PatchSelectByShader(GlobalSceneGraph(), TextureBrowser_GetSelectedShader(GlobalTextureBrowser()));
 751     }
 752   }
 753 }
 754
 755 void Select_Inside(void)
 756 {
 757         SelectByBounds<SelectionPolicy_Inside>::DoSelection();
 758 }
 759
 760 void Select_Touching(void)
 761 {
 762         SelectByBounds<SelectionPolicy_Touching>::DoSelection(false);
 763 }
 764
 765 void Select_FitTexture(float horizontal, float vertical)
 766 {
 767   if(GlobalSelectionSystem().Mode() != SelectionSystem::eComponent)
 768   {
 769     Scene_BrushFitTexture_Selected(GlobalSceneGraph(), horizontal, vertical);
 770   }
 771   Scene_BrushFitTexture_Component_Selected(GlobalSceneGraph(), horizontal, vertical);
 772
 773   SceneChangeNotify();
 774 }
 775
 776 inline void hide_node(scene::Node& node, bool hide)
 777 {
 778   hide
 779     ? node.enable(scene::Node::eHidden)
 780     : node.disable(scene::Node::eHidden);
 781 }
 782
 783 class HideSelectedWalker : public scene::Graph::Walker
 784 {
 785   bool m_hide;
 786 public:
 787   HideSelectedWalker(bool hide)
 788     : m_hide(hide)
 789   {
 790   }
 791   bool pre(const scene::Path& path, scene::Instance& instance) const
 792   {
 793     Selectable* selectable = Instance_getSelectable(instance);
 794     if(selectable != 0
 795       && selectable->isSelected())
 796     {
 797       hide_node(path.top(), m_hide);
 798     }
 799     return true;
 800   }
 801 };
 802
 803 void Scene_Hide_Selected(bool hide)
 804 {
 805   GlobalSceneGraph().traverse(HideSelectedWalker(hide));
 806 }
 807
 808 void Select_Hide()
 809 {
 810   Scene_Hide_Selected(true);
 811   SceneChangeNotify();
 812 }
 813
 814 void HideSelected()
 815 {
 816   Select_Hide();
 817   GlobalSelectionSystem().setSelectedAll(false);
 818 }
 819
 820
 821 class HideAllWalker : public scene::Graph::Walker
 822 {
 823   bool m_hide;
 824 public:
 825   HideAllWalker(bool hide)
 826     : m_hide(hide)
 827   {
 828   }
 829   bool pre(const scene::Path& path, scene::Instance& instance) const
 830   {
 831     hide_node(path.top(), m_hide);
 832     return true;
 833   }
 834 };
 835
 836 void Scene_Hide_All(bool hide)
 837 {
 838   GlobalSceneGraph().traverse(HideAllWalker(hide));
 839 }
 840
 841 void Select_ShowAllHidden()
 842 {
 843   Scene_Hide_All(false);
 844   SceneChangeNotify();
 845 }
 846
 847
 848
 849 void Selection_Flipx()
 850 {
 851   UndoableCommand undo("mirrorSelected -axis x");
 852   Select_FlipAxis(0);
 853 }
 854
 855 void Selection_Flipy()
 856 {
 857   UndoableCommand undo("mirrorSelected -axis y");
 858   Select_FlipAxis(1);
 859 }
 860
 861 void Selection_Flipz()
 862 {
 863   UndoableCommand undo("mirrorSelected -axis z");
 864   Select_FlipAxis(2);
 865 }
 866
 867 void Selection_Rotatex()
 868 {
 869   UndoableCommand undo("rotateSelected -axis x -angle -90");
 870   Select_RotateAxis(0,-90);
 871 }
 872
 873 void Selection_Rotatey()
 874 {
 875   UndoableCommand undo("rotateSelected -axis y -angle 90");
 876   Select_RotateAxis(1, 90);
 877 }
 878
 879 void Selection_Rotatez()
 880 {
 881   UndoableCommand undo("rotateSelected -axis z -angle -90");
 882   Select_RotateAxis(2,-90);
 883 }
 884
 885
 886
 887 void Nudge(int nDim, float fNudge)
 888 {
 889   Vector3 translate(0, 0, 0);
 890   translate[nDim] = fNudge;
 891
 892   GlobalSelectionSystem().translateSelected(translate);
 893 }
 894
 895 void Selection_NudgeZ(float amount)
 896 {
 897   StringOutputStream command;
 898   command << "nudgeSelected -axis z -amount " << amount;
 899   UndoableCommand undo(command.c_str());
 900
 901   Nudge(2, amount);
 902 }
 903
 904 void Selection_MoveDown()
 905 {
 906   Selection_NudgeZ(-GetGridSize());
 907 }
 908
 909 void Selection_MoveUp()
 910 {
 911   Selection_NudgeZ(GetGridSize());
 912 }
 913
 914 void SceneSelectionChange(const Selectable& selectable)
 915 {
 916   SceneChangeNotify();
 917 }
 918
 919 SignalHandlerId Selection_boundsChanged;
 920
 921 void Selection_construct()
 922 {
 923   typedef FreeCaller1<const Selectable&, SceneSelectionChange> SceneSelectionChangeCaller;
 924   GlobalSelectionSystem().addSelectionChangeCallback(SceneSelectionChangeCaller());
 925   typedef FreeCaller1<const Selectable&, UpdateWorkzone_ForSelectionChanged> UpdateWorkzoneForSelectionChangedCaller;
 926   GlobalSelectionSystem().addSelectionChangeCallback(UpdateWorkzoneForSelectionChangedCaller());
 927   typedef FreeCaller<UpdateWorkzone_ForSelection> UpdateWorkzoneForSelectionCaller;
 928   Selection_boundsChanged = GlobalSceneGraph().addBoundsChangedCallback(UpdateWorkzoneForSelectionCaller());
 929 }
 930
 931 void Selection_destroy()
 932 {
 933   GlobalSceneGraph().removeBoundsChangedCallback(Selection_boundsChanged);
 934 }
 935
 936
 937 #include "gtkdlgs.h"
 938 #include <gtk/gtkbox.h>
 939 #include <gtk/gtkspinbutton.h>
 940 #include <gtk/gtktable.h>
 941 #include <gtk/gtklabel.h>
 942 #include <gdk/gdkkeysyms.h>
 943
 944
 945 inline Quaternion quaternion_for_euler_xyz_degrees(const Vector3& eulerXYZ)
 946 {
 947 #if 0
 948   return quaternion_for_matrix4_rotation(matrix4_rotation_for_euler_xyz_degrees(eulerXYZ));
 949 #elif 0
 950   return quaternion_multiplied_by_quaternion(
 951     quaternion_multiplied_by_quaternion(
 952       quaternion_for_z(degrees_to_radians(eulerXYZ[2])),
 953       quaternion_for_y(degrees_to_radians(eulerXYZ[1]))
 954     ),
 955     quaternion_for_x(degrees_to_radians(eulerXYZ[0]))
 956   );
 957 #elif 1
 958   double cx = cos(degrees_to_radians(eulerXYZ[0] * 0.5));
 959   double sx = sin(degrees_to_radians(eulerXYZ[0] * 0.5));
 960   double cy = cos(degrees_to_radians(eulerXYZ[1] * 0.5));
 961   double sy = sin(degrees_to_radians(eulerXYZ[1] * 0.5));
 962   double cz = cos(degrees_to_radians(eulerXYZ[2] * 0.5));
 963   double sz = sin(degrees_to_radians(eulerXYZ[2] * 0.5));
 964
 965   return Quaternion(
 966     cz * cy * sx - sz * sy * cx,
 967     cz * sy * cx + sz * cy * sx,
 968     sz * cy * cx - cz * sy * sx,
 969     cz * cy * cx + sz * sy * sx
 970   );
 971 #endif
 972 }
 973
 974 struct RotateDialog
 975 {
 976   GtkSpinButton* x;
 977   GtkSpinButton* y;
 978   GtkSpinButton* z;
 979   GtkWindow *window;
 980 };
 981
 982 static gboolean rotatedlg_apply (GtkWidget *widget, RotateDialog* rotateDialog)
 983 {
 984   Vector3 eulerXYZ;
 985
 986   eulerXYZ[0] = static_cast<float>(gtk_spin_button_get_value(rotateDialog->x));
 987   eulerXYZ[1] = static_cast<float>(gtk_spin_button_get_value(rotateDialog->y));
 988   eulerXYZ[2] = static_cast<float>(gtk_spin_button_get_value(rotateDialog->z));
 989
 990   StringOutputStream command;
 991   command << "rotateSelectedEulerXYZ -x " << eulerXYZ[0] << " -y " << eulerXYZ[1] << " -z " << eulerXYZ[2];
 992   UndoableCommand undo(command.c_str());
 993
 994   GlobalSelectionSystem().rotateSelected(quaternion_for_euler_xyz_degrees(eulerXYZ));
 995   return TRUE;
 996 }
 997
 998 static gboolean rotatedlg_cancel (GtkWidget *widget, RotateDialog* rotateDialog)
 999 {
1000         gtk_widget_hide(GTK_WIDGET(rotateDialog->window));
1001
1002         gtk_spin_button_set_value(rotateDialog->x, 0.0f); // reset to 0 on close
1003         gtk_spin_button_set_value(rotateDialog->y, 0.0f);
1004         gtk_spin_button_set_value(rotateDialog->z, 0.0f);
1005
1006         return TRUE;
1007 }
1008
1009 static gboolean rotatedlg_ok (GtkWidget *widget, RotateDialog* rotateDialog)
1010 {
1011         rotatedlg_apply(widget, rotateDialog);
1012         rotatedlg_cancel(widget, rotateDialog);
1013         return TRUE;
1014 }
1015
1016 static gboolean rotatedlg_delete (GtkWidget *widget, GdkEventAny *event, RotateDialog* rotateDialog)
1017 {
1018         rotatedlg_cancel(widget, rotateDialog);
1019         return TRUE;
1020 }
1021
1022 RotateDialog g_rotate_dialog;
1023 void DoRotateDlg()
1024 {
1025   if(g_rotate_dialog.window == NULL)
1026   {
1027           g_rotate_dialog.window = create_dialog_window(MainFrame_getWindow(), "Arbitrary rotation", G_CALLBACK(rotatedlg_delete), &g_rotate_dialog);
1028
1029           GtkAccelGroup* accel = gtk_accel_group_new();
1030           gtk_window_add_accel_group(g_rotate_dialog.window, accel);
1031
1032           {
1033                   GtkHBox* hbox = create_dialog_hbox(4, 4);
1034                   gtk_container_add(GTK_CONTAINER(g_rotate_dialog.window), GTK_WIDGET(hbox));
1035                   {
1036                           GtkTable* table = create_dialog_table(3, 2, 4, 4);
1037                           gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(table), TRUE, TRUE, 0);
1038                           {
1039                                   GtkWidget* label = gtk_label_new ("  X  ");
1040                                   gtk_widget_show (label);
1041                                   gtk_table_attach(table, label, 0, 1, 0, 1,
1042                                                   (GtkAttachOptions) (0),
1043                                                   (GtkAttachOptions) (0), 0, 0);
1044                           }
1045                           {
1046                                   GtkWidget* label = gtk_label_new ("  Y  ");
1047                                   gtk_widget_show (label);
1048                                   gtk_table_attach(table, label, 0, 1, 1, 2,
1049                                                   (GtkAttachOptions) (0),
1050                                                   (GtkAttachOptions) (0), 0, 0);
1051                           }
1052                           {
1053                                   GtkWidget* label = gtk_label_new ("  Z  ");
1054                                   gtk_widget_show (label);
1055                                   gtk_table_attach(table, label, 0, 1, 2, 3,
1056                                                   (GtkAttachOptions) (0),
1057                                                   (GtkAttachOptions) (0), 0, 0);
1058                           }
1059                           {
1060                                   GtkAdjustment* adj = GTK_ADJUSTMENT(gtk_adjustment_new(0, -359, 359, 1, 10, 0));
1061                                   GtkSpinButton* spin = GTK_SPIN_BUTTON(gtk_spin_button_new(adj, 1, 0));
1062                                   gtk_widget_show(GTK_WIDGET(spin));
1063                                   gtk_table_attach(table, GTK_WIDGET(spin), 1, 2, 0, 1,
1064                                                   (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1065                                                   (GtkAttachOptions) (0), 0, 0);
1066                                   gtk_widget_set_size_request(GTK_WIDGET(spin), 64, -1);
1067                                   gtk_spin_button_set_wrap(spin, TRUE);
1068
1069                                   gtk_widget_grab_focus(GTK_WIDGET(spin));
1070
1071                                   g_rotate_dialog.x = spin;
1072                           }
1073                           {
1074                                   GtkAdjustment* adj = GTK_ADJUSTMENT(gtk_adjustment_new(0, -359, 359, 1, 10, 0));
1075                                   GtkSpinButton* spin = GTK_SPIN_BUTTON(gtk_spin_button_new(adj, 1, 0));
1076                                   gtk_widget_show(GTK_WIDGET(spin));
1077                                   gtk_table_attach(table, GTK_WIDGET(spin), 1, 2, 1, 2,
1078                                                   (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1079                                                   (GtkAttachOptions) (0), 0, 0);
1080                                   gtk_widget_set_size_request(GTK_WIDGET(spin), 64, -1);
1081                                   gtk_spin_button_set_wrap(spin, TRUE);
1082
1083                                   g_rotate_dialog.y = spin;
1084                           }
1085                           {
1086                                   GtkAdjustment* adj = GTK_ADJUSTMENT(gtk_adjustment_new(0, -359, 359, 1, 10, 0));
1087                                   GtkSpinButton* spin = GTK_SPIN_BUTTON(gtk_spin_button_new(adj, 1, 0));
1088                                   gtk_widget_show(GTK_WIDGET(spin));
1089                                   gtk_table_attach(table, GTK_WIDGET(spin), 1, 2, 2, 3,
1090                                                   (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1091                                                   (GtkAttachOptions) (0), 0, 0);
1092                                   gtk_widget_set_size_request(GTK_WIDGET(spin), 64, -1);
1093                                   gtk_spin_button_set_wrap(spin, TRUE);
1094
1095                                   g_rotate_dialog.z = spin;
1096                           }
1097                   }
1098                   {
1099                           GtkVBox* vbox = create_dialog_vbox(4);
1100                           gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox), TRUE, TRUE, 0);
1101                           {
1102                                   GtkButton* button = create_dialog_button("OK", G_CALLBACK(rotatedlg_ok), &g_rotate_dialog);
1103                                   gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0);
1104                                   widget_make_default(GTK_WIDGET(button));
1105                                   gtk_widget_add_accelerator(GTK_WIDGET(button), "clicked", accel, GDK_Return, (GdkModifierType)0, (GtkAccelFlags)0);
1106                           }
1107                           {
1108                                   GtkButton* button = create_dialog_button("Cancel", G_CALLBACK(rotatedlg_cancel), &g_rotate_dialog);
1109                                   gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0);
1110                                   gtk_widget_add_accelerator(GTK_WIDGET(button), "clicked", accel, GDK_Escape, (GdkModifierType)0, (GtkAccelFlags)0);
1111                           }
1112                           {
1113                                   GtkButton* button = create_dialog_button("Apply", G_CALLBACK(rotatedlg_apply), &g_rotate_dialog);
1114                                   gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0);
1115                           }
1116                   }
1117           }
1118   }
1119
1120   gtk_widget_show(GTK_WIDGET(g_rotate_dialog.window));
1121 }
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131 struct ScaleDialog
1132 {
1133   GtkWidget* x;
1134   GtkWidget* y;
1135   GtkWidget* z;
1136   GtkWindow *window;
1137 };
1138
1139 static gboolean scaledlg_apply (GtkWidget *widget, ScaleDialog* scaleDialog)
1140 {
1141   float sx, sy, sz;
1142
1143   sx = static_cast<float>(atof(gtk_entry_get_text (GTK_ENTRY (scaleDialog->x))));
1144   sy = static_cast<float>(atof(gtk_entry_get_text (GTK_ENTRY (scaleDialog->y))));
1145   sz = static_cast<float>(atof(gtk_entry_get_text (GTK_ENTRY (scaleDialog->z))));
1146
1147   StringOutputStream command;
1148   command << "scaleSelected -x " << sx << " -y " << sy << " -z " << sz;
1149   UndoableCommand undo(command.c_str());
1150
1151   Select_Scale(sx, sy, sz);
1152
1153   return TRUE;
1154 }
1155
1156 static gboolean scaledlg_cancel (GtkWidget *widget, ScaleDialog* scaleDialog)
1157 {
1158         gtk_widget_hide(GTK_WIDGET(scaleDialog->window));
1159
1160         gtk_entry_set_text (GTK_ENTRY(scaleDialog->x), "1.0");
1161         gtk_entry_set_text (GTK_ENTRY(scaleDialog->y), "1.0");
1162         gtk_entry_set_text (GTK_ENTRY(scaleDialog->z), "1.0");
1163
1164         return TRUE;
1165 }
1166
1167 static gboolean scaledlg_ok (GtkWidget *widget, ScaleDialog* scaleDialog)
1168 {
1169         scaledlg_apply(widget, scaleDialog);
1170         scaledlg_cancel(widget, scaleDialog);
1171         return TRUE;
1172 }
1173
1174 static gboolean scaledlg_delete (GtkWidget *widget, GdkEventAny *event, ScaleDialog* scaleDialog)
1175 {
1176         scaledlg_cancel(widget, scaleDialog);
1177         return TRUE;
1178 }
1179
1180 ScaleDialog g_scale_dialog;
1181
1182 void DoScaleDlg()
1183 {
1184   if(g_scale_dialog.window == NULL)
1185   {
1186           g_scale_dialog.window = create_dialog_window(MainFrame_getWindow(), "Arbitrary scale", G_CALLBACK(scaledlg_delete), &g_scale_dialog);
1187
1188           GtkAccelGroup* accel = gtk_accel_group_new();
1189           gtk_window_add_accel_group(g_scale_dialog.window, accel);
1190
1191           {
1192                   GtkHBox* hbox = create_dialog_hbox(4, 4);
1193                   gtk_container_add(GTK_CONTAINER(g_scale_dialog.window), GTK_WIDGET(hbox));
1194                   {
1195                           GtkTable* table = create_dialog_table(3, 2, 4, 4);
1196                           gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(table), TRUE, TRUE, 0);
1197                           {
1198                                   GtkWidget* label = gtk_label_new ("  X  ");
1199                                   gtk_widget_show (label);
1200                                   gtk_table_attach(table, label, 0, 1, 0, 1,
1201                                                   (GtkAttachOptions) (0),
1202                                                   (GtkAttachOptions) (0), 0, 0);
1203                           }
1204                           {
1205                                   GtkWidget* label = gtk_label_new ("  Y  ");
1206                                   gtk_widget_show (label);
1207                                   gtk_table_attach(table, label, 0, 1, 1, 2,
1208                                                   (GtkAttachOptions) (0),
1209                                                   (GtkAttachOptions) (0), 0, 0);
1210                           }
1211                           {
1212                                   GtkWidget* label = gtk_label_new ("  Z  ");
1213                                   gtk_widget_show (label);
1214                                   gtk_table_attach(table, label, 0, 1, 2, 3,
1215                                                   (GtkAttachOptions) (0),
1216                                                   (GtkAttachOptions) (0), 0, 0);
1217                           }
1218                           {
1219                                   GtkWidget* entry = gtk_entry_new();
1220                                   gtk_entry_set_text (GTK_ENTRY(entry), "1.0");
1221                                   gtk_widget_show (entry);
1222                                   gtk_table_attach(table, entry, 1, 2, 0, 1,
1223                                                   (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1224                                                   (GtkAttachOptions) (0), 0, 0);
1225
1226                                   g_scale_dialog.x = entry;
1227                           }
1228                           {
1229                                   GtkWidget* entry = gtk_entry_new();
1230                                   gtk_entry_set_text (GTK_ENTRY(entry), "1.0");
1231                                   gtk_widget_show (entry);
1232                                   gtk_table_attach(table, entry, 1, 2, 1, 2,
1233                                                   (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1234                                                   (GtkAttachOptions) (0), 0, 0);
1235
1236                                   g_scale_dialog.y = entry;
1237                           }
1238                           {
1239                                   GtkWidget* entry = gtk_entry_new();
1240                                   gtk_entry_set_text (GTK_ENTRY(entry), "1.0");
1241                                   gtk_widget_show (entry);
1242                                   gtk_table_attach(table, entry, 1, 2, 2, 3,
1243                                                   (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1244                                                   (GtkAttachOptions) (0), 0, 0);
1245
1246                                   g_scale_dialog.z = entry;
1247                           }
1248                   }
1249                   {
1250                           GtkVBox* vbox = create_dialog_vbox(4);
1251                           gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox), TRUE, TRUE, 0);
1252                           {
1253                                   GtkButton* button = create_dialog_button("OK", G_CALLBACK(scaledlg_ok), &g_scale_dialog);
1254                                   gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0);
1255                                   widget_make_default(GTK_WIDGET(button));
1256                                   gtk_widget_add_accelerator(GTK_WIDGET(button), "clicked", accel, GDK_Return, (GdkModifierType)0, (GtkAccelFlags)0);
1257                           }
1258                           {
1259                                   GtkButton* button = create_dialog_button("Cancel", G_CALLBACK(scaledlg_cancel), &g_scale_dialog);
1260                                   gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0);
1261                                   gtk_widget_add_accelerator(GTK_WIDGET(button), "clicked", accel, GDK_Escape, (GdkModifierType)0, (GtkAccelFlags)0);
1262                           }
1263                           {
1264                                   GtkButton* button = create_dialog_button("Apply", G_CALLBACK(scaledlg_apply), &g_scale_dialog);
1265                                   gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0);
1266                           }
1267                   }
1268           }
1269   }
1270
1271   gtk_widget_show(GTK_WIDGET(g_scale_dialog.window));
1272 }