radiant/brush.h

   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 #if !defined(INCLUDED_BRUSH_H)
  23 #define INCLUDED_BRUSH_H
  24
  25 /// \file
  26 /// \brief The brush primitive.
  27 ///
  28 /// A collection of planes that define a convex polyhedron.
  29 /// The Boundary-Representation of this primitive is a manifold polygonal mesh.
  30 /// Each face polygon is represented by a list of vertices in a \c Winding.
  31 /// Each vertex is associated with another face that is adjacent to the edge
  32 /// formed by itself and the next vertex in the winding. This information can
  33 /// be used to find edge-pairs and vertex-rings.
  34
  35
  36 #include "debugging/debugging.h"
  37
  38 #include "itexdef.h"
  39 #include "iundo.h"
  40 #include "iselection.h"
  41 #include "irender.h"
  42 #include "imap.h"
  43 #include "ibrush.h"
  44 #include "igl.h"
  45 #include "ifilter.h"
  46 #include "nameable.h"
  47 #include "moduleobserver.h"
  48
  49 #include <set>
  50
  51 #include "cullable.h"
  52 #include "renderable.h"
  53 #include "selectable.h"
  54 #include "editable.h"
  55 #include "mapfile.h"
  56
  57 #include "math/frustum.h"
  58 #include "selectionlib.h"
  59 #include "render.h"
  60 #include "texturelib.h"
  61 #include "container/container.h"
  62 #include "generic/bitfield.h"
  63
  64 #include "winding.h"
  65 #include "brush_primit.h"
  66
  67 #define CONTENTS_DETAIL 0x8000000
  68
  69
  70 enum EBrushType
  71 {
  72   eBrushTypeQuake,
  73   eBrushTypeQuake2,
  74   eBrushTypeQuake3,
  75   eBrushTypeQuake3BP,
  76   eBrushTypeDoom3,
  77   eBrushTypeQuake4,
  78   eBrushTypeHalfLife,
  79 };
  80
  81
  82 #define BRUSH_CONNECTIVITY_DEBUG 0
  83 #define BRUSH_DEGENERATE_DEBUG 0
  84
  85 template<typename TextOuputStreamType>
  86 inline TextOuputStreamType& ostream_write(TextOuputStreamType& ostream, const Matrix4& m)
  87 {
  88   return ostream << "(" << m[0] << " " << m[1] << " " << m[2] << " " << m[3] << ", "
  89     << m[4] << " " << m[5] << " " << m[6] << " " << m[7] << ", "
  90     << m[8] << " " << m[9] << " " << m[10] << " " << m[11] << ", "
  91     << m[12] << " " << m[13] << " " << m[14] << " " << m[15] << ")";
  92 }
  93
  94 inline void print_vector3(const Vector3& v)
  95 {
  96   globalOutputStream() << "( " << v.x() << " " << v.y() << " " << v.z() << " )\n";
  97 }
  98
  99 inline void print_3x3(const Matrix4& m)
 100 {
 101   globalOutputStream() << "( " << m.xx() << " " << m.xy() << " " << m.xz() << " ) "
 102     << "( " << m.yx() << " " << m.yy() << " " << m.yz() << " ) "
 103     << "( " << m.zx() << " " << m.zy() << " " << m.zz() << " )\n";
 104 }
 105
 106
 107
 108 inline bool texdef_sane(const texdef_t& texdef)
 109 {
 110   return fabs(texdef.shift[0]) < (1 << 16)
 111     && fabs(texdef.shift[1]) < (1 << 16);
 112 }
 113
 114 inline void Winding_DrawWireframe(const Winding& winding)
 115 {
 116   glVertexPointer(3, GL_FLOAT, sizeof(WindingVertex), &winding.points.data()->vertex);
 117   glDrawArrays(GL_LINE_LOOP, 0, GLsizei(winding.numpoints));
 118 }
 119
 120 inline void Winding_Draw(const Winding& winding, const Vector3& normal, RenderStateFlags state)
 121 {
 122   glVertexPointer(3, GL_FLOAT, sizeof(WindingVertex), &winding.points.data()->vertex);
 123
 124   if((state & RENDER_BUMP) != 0)
 125   {
 126     Vector3 normals[c_brush_maxFaces];
 127     typedef Vector3* Vector3Iter;
 128     for(Vector3Iter i = normals, end = normals + winding.numpoints; i != end; ++i)
 129     {
 130       *i = normal;
 131     }
 132     if(GlobalShaderCache().useShaderLanguage())
 133     {
 134       glNormalPointer(GL_FLOAT, sizeof(Vector3), normals);
 135       glVertexAttribPointerARB(c_attr_TexCoord0, 2, GL_FLOAT, 0, sizeof(WindingVertex), &winding.points.data()->texcoord);
 136       glVertexAttribPointerARB(c_attr_Tangent, 3, GL_FLOAT, 0, sizeof(WindingVertex), &winding.points.data()->tangent);
 137       glVertexAttribPointerARB(c_attr_Binormal, 3, GL_FLOAT, 0, sizeof(WindingVertex), &winding.points.data()->bitangent);
 138     }
 139     else
 140     {
 141       glVertexAttribPointerARB(11, 3, GL_FLOAT, 0, sizeof(Vector3), normals);
 142       glVertexAttribPointerARB(8, 2, GL_FLOAT, 0, sizeof(WindingVertex), &winding.points.data()->texcoord);
 143       glVertexAttribPointerARB(9, 3, GL_FLOAT, 0, sizeof(WindingVertex), &winding.points.data()->tangent);
 144       glVertexAttribPointerARB(10, 3, GL_FLOAT, 0, sizeof(WindingVertex), &winding.points.data()->bitangent);
 145     }
 146   }
 147   else
 148   {
 149     if (state & RENDER_LIGHTING)
 150     {
 151       Vector3 normals[c_brush_maxFaces];
 152       typedef Vector3* Vector3Iter;
 153       for(Vector3Iter i = normals, last = normals + winding.numpoints; i != last; ++i)
 154       {
 155         *i = normal;
 156       }
 157       glNormalPointer(GL_FLOAT, sizeof(Vector3), normals);
 158     }
 159
 160     if (state & RENDER_TEXTURE)
 161     {
 162       glTexCoordPointer(2, GL_FLOAT, sizeof(WindingVertex), &winding.points.data()->texcoord);
 163     }
 164   }
 165 #if 0
 166   if (state & RENDER_FILL)
 167   {
 168     glDrawArrays(GL_TRIANGLE_FAN, 0, GLsizei(winding.numpoints));
 169   }
 170   else
 171   {
 172     glDrawArrays(GL_LINE_LOOP, 0, GLsizei(winding.numpoints));
 173   }
 174 #else
 175   glDrawArrays(GL_POLYGON, 0, GLsizei(winding.numpoints));
 176 #endif
 177
 178 #if 0
 179   const Winding& winding = winding;
 180
 181   if(state & RENDER_FILL)
 182   {
 183     glBegin(GL_POLYGON);
 184   }
 185   else
 186   {
 187     glBegin(GL_LINE_LOOP);
 188   }
 189
 190   if (state & RENDER_LIGHTING)
 191     glNormal3fv(normal);
 192
 193   for(int i = 0; i < winding.numpoints; ++i)
 194   {
 195     if (state & RENDER_TEXTURE)
 196       glTexCoord2fv(&winding.points[i][3]);
 197     glVertex3fv(winding.points[i]);
 198   }
 199   glEnd();
 200 #endif
 201 }
 202
 203 const Colour4b colour_vertex(0, 255, 0, 255);
 204
 205
 206 #include "shaderlib.h"
 207
 208 typedef DoubleVector3 PlanePoints[3];
 209
 210 inline bool planepts_equal(const PlanePoints planepts, const PlanePoints other)
 211 {
 212   return planepts[0] == other[0] && planepts[1] == other[1] && planepts[2] == other[2];
 213 }
 214
 215 inline void planepts_assign(PlanePoints planepts, const PlanePoints other)
 216 {
 217   planepts[0] = other[0];
 218   planepts[1] = other[1];
 219   planepts[2] = other[2];
 220 }
 221
 222 inline void planepts_quantise(PlanePoints planepts, double snap)
 223 {
 224   vector3_snap(planepts[0], snap);
 225   vector3_snap(planepts[1], snap);
 226   vector3_snap(planepts[2], snap);
 227 }
 228
 229 inline float vector3_max_component(const Vector3& vec3)
 230 {
 231   return std::max(fabsf(vec3[0]), std::max(fabsf(vec3[1]), fabsf(vec3[2])));
 232 }
 233
 234 inline void edge_snap(Vector3& edge, double snap)
 235 {
 236   float scale = static_cast<float>(ceil(fabs(snap / vector3_max_component(edge))));
 237   if(scale > 0.0f)
 238   {
 239     vector3_scale(edge, scale);
 240   }
 241   vector3_snap(edge, snap);
 242 }
 243
 244 inline void planepts_snap(PlanePoints planepts, double snap)
 245 {
 246   Vector3 edge01(vector3_subtracted(planepts[1], planepts[0]));
 247   Vector3 edge12(vector3_subtracted(planepts[2], planepts[1]));
 248   Vector3 edge20(vector3_subtracted(planepts[0], planepts[2]));
 249
 250   double length_squared_01 = vector3_dot(edge01, edge01);
 251   double length_squared_12 = vector3_dot(edge12, edge12);
 252   double length_squared_20 = vector3_dot(edge20, edge20);
 253
 254   vector3_snap(planepts[0], snap);
 255
 256   if(length_squared_01 < length_squared_12)
 257   {
 258     if(length_squared_12 < length_squared_20)
 259     {
 260       edge_snap(edge01, snap);
 261       edge_snap(edge12, snap);
 262       planepts[1] = vector3_added(planepts[0], edge01);
 263       planepts[2] = vector3_added(planepts[1], edge12);
 264     }
 265     else
 266     {
 267       edge_snap(edge20, snap);
 268       edge_snap(edge01, snap);
 269       planepts[1] = vector3_added(planepts[0], edge20);
 270       planepts[2] = vector3_added(planepts[1], edge01);
 271     }
 272   }
 273   else
 274   {
 275     if(length_squared_01 < length_squared_20)
 276     {
 277       edge_snap(edge01, snap);
 278       edge_snap(edge12, snap);
 279       planepts[1] = vector3_added(planepts[0], edge01);
 280       planepts[2] = vector3_added(planepts[1], edge12);
 281     }
 282     else
 283     {
 284       edge_snap(edge12, snap);
 285       edge_snap(edge20, snap);
 286       planepts[1] = vector3_added(planepts[0], edge12);
 287       planepts[2] = vector3_added(planepts[1], edge20);
 288     }
 289   }
 290 }
 291
 292 inline PointVertex pointvertex_for_planept(const DoubleVector3& point, const Colour4b& colour)
 293 {
 294   return PointVertex(
 295     Vertex3f(
 296       static_cast<float>(point.x()),
 297       static_cast<float>(point.y()),
 298       static_cast<float>(point.z())
 299     ),
 300     colour
 301   );
 302 }
 303
 304 inline PointVertex pointvertex_for_windingpoint(const Vector3& point, const Colour4b& colour)
 305 {
 306   return PointVertex(
 307     vertex3f_for_vector3(point),
 308     colour
 309   );
 310 }
 311
 312 inline bool check_plane_is_integer(const PlanePoints& planePoints)
 313 {
 314   return !float_is_integer(planePoints[0][0])
 315     || !float_is_integer(planePoints[0][1])
 316     || !float_is_integer(planePoints[0][2])
 317     || !float_is_integer(planePoints[1][0])
 318     || !float_is_integer(planePoints[1][1])
 319     || !float_is_integer(planePoints[1][2])
 320     || !float_is_integer(planePoints[2][0])
 321     || !float_is_integer(planePoints[2][1])
 322     || !float_is_integer(planePoints[2][2]);
 323 }
 324
 325 inline void brush_check_shader(const char* name)
 326 {
 327   if(!shader_valid(name))
 328   {
 329     globalErrorStream() << "brush face has invalid texture name: '" << name << "'\n";
 330   }
 331 }
 332
 333 class FaceShaderObserver
 334 {
 335 public:
 336   virtual void realiseShader() = 0;
 337   virtual void unrealiseShader() = 0;
 338 };
 339
 340 class FaceShaderObserverRealise
 341 {
 342 public:
 343   void operator()(FaceShaderObserver& observer) const
 344   {
 345     observer.realiseShader();
 346   }
 347 };
 348
 349 class FaceShaderObserverUnrealise
 350 {
 351 public:
 352   void operator()(FaceShaderObserver& observer) const
 353   {
 354     observer.unrealiseShader();
 355   }
 356 };
 357
 358 typedef ReferencePair<FaceShaderObserver> FaceShaderObserverPair;
 359
 360
 361 class ContentsFlagsValue
 362 {
 363 public:
 364   ContentsFlagsValue()
 365   {
 366   }
 367   ContentsFlagsValue(int surfaceFlags, int contentFlags, int value, bool specified) :
 368     m_surfaceFlags(surfaceFlags),
 369     m_contentFlags(contentFlags),
 370     m_value(value),
 371     m_specified(specified)
 372   {
 373   }
 374   int m_surfaceFlags;
 375   int m_contentFlags;
 376   int m_value;
 377   bool m_specified;
 378 };
 379
 380 inline unsigned int ContentFlags_assignable(unsigned int contentFlags)
 381 {
 382   return contentFlags & ~CONTENTS_DETAIL;
 383 }
 384
 385 inline ContentsFlagsValue ContentsFlagsValue_maskDetail(const ContentsFlagsValue& other)
 386 {
 387   return ContentsFlagsValue(other.m_surfaceFlags, ContentFlags_assignable(other.m_contentFlags), other.m_value, other.m_specified);
 388 }
 389
 390
 391 class FaceShader : public ModuleObserver
 392 {
 393 public:
 394   class SavedState
 395   {
 396   public:
 397     CopiedString m_shader;
 398     ContentsFlagsValue m_flags;
 399
 400     SavedState(const FaceShader& faceShader)
 401     {
 402       m_shader = faceShader.getShader();
 403       m_flags = faceShader.m_flags;
 404     }
 405
 406     void exportState(FaceShader& faceShader) const
 407     {
 408       faceShader.setShader(m_shader.c_str());
 409       faceShader.setFlags(m_flags);
 410     }
 411   };
 412
 413   CopiedString m_shader;
 414   Shader* m_state;
 415   ContentsFlagsValue m_flags;
 416   FaceShaderObserverPair m_observers;
 417   bool m_instanced;
 418   bool m_realised;
 419
 420   FaceShader(const char* shader, const ContentsFlagsValue& flags = ContentsFlagsValue(0, 0, 0, false)) :
 421     m_shader(shader),
 422     m_state(0),
 423     m_flags(flags),
 424     m_instanced(false),
 425     m_realised(false)
 426   {
 427     captureShader();
 428   }
 429   ~FaceShader()
 430   {
 431     releaseShader();
 432   }
 433   // copy-construction not supported
 434   FaceShader(const FaceShader& other);
 435
 436   void instanceAttach()
 437   {
 438     m_instanced = true;
 439     m_state->incrementUsed();
 440   }
 441   void instanceDetach()
 442   {
 443     m_state->decrementUsed();
 444     m_instanced = false;
 445   }
 446
 447   void captureShader()
 448   {
 449     ASSERT_MESSAGE(m_state == 0, "shader cannot be captured");
 450     brush_check_shader(m_shader.c_str());
 451     m_state = GlobalShaderCache().capture(m_shader.c_str());
 452     m_state->attach(*this);
 453   }
 454   void releaseShader()
 455   {
 456     ASSERT_MESSAGE(m_state != 0, "shader cannot be released");
 457     m_state->detach(*this);
 458     GlobalShaderCache().release(m_shader.c_str());
 459     m_state = 0;
 460   }
 461
 462   void realise()
 463   {
 464     ASSERT_MESSAGE(!m_realised, "FaceTexdef::realise: already realised");
 465     m_realised = true;
 466     m_observers.forEach(FaceShaderObserverRealise());
 467   }
 468   void unrealise()
 469   {
 470     ASSERT_MESSAGE(m_realised, "FaceTexdef::unrealise: already unrealised");
 471     m_observers.forEach(FaceShaderObserverUnrealise());
 472     m_realised = false;
 473   }
 474
 475   void attach(FaceShaderObserver& observer)
 476   {
 477     m_observers.attach(observer);
 478     if(m_realised)
 479     {
 480       observer.realiseShader();
 481     }
 482   }
 483
 484   void detach(FaceShaderObserver& observer)
 485   {
 486     if(m_realised)
 487     {
 488       observer.unrealiseShader();
 489     }
 490     m_observers.detach(observer);
 491   }
 492
 493   const char* getShader() const
 494   {
 495     return m_shader.c_str();
 496   }
 497   void setShader(const char* name)
 498   {
 499     if(m_instanced)
 500     {
 501       m_state->decrementUsed();
 502     }
 503     releaseShader();
 504     m_shader = name;
 505     captureShader();
 506     if(m_instanced)
 507     {
 508       m_state->incrementUsed();
 509     }
 510   }
 511   ContentsFlagsValue getFlags() const
 512   {
 513     ASSERT_MESSAGE(m_realised, "FaceShader::getFlags: flags not valid when unrealised");
 514     if(!m_flags.m_specified)
 515     {
 516       return ContentsFlagsValue(
 517         m_state->getTexture().surfaceFlags,
 518         m_state->getTexture().contentFlags,
 519         m_state->getTexture().value,
 520         true
 521       );
 522     }
 523     return m_flags;
 524   }
 525   void setFlags(const ContentsFlagsValue& flags)
 526   {
 527     ASSERT_MESSAGE(m_realised, "FaceShader::setFlags: flags not valid when unrealised");
 528     m_flags = ContentsFlagsValue_maskDetail(flags);
 529   }
 530
 531   Shader* state() const
 532   {
 533     return m_state;
 534   }
 535
 536   std::size_t width() const
 537   {
 538     if(m_realised)
 539     {
 540       return m_state->getTexture().width;
 541     }
 542     return 1;
 543   }
 544   std::size_t height() const
 545   {
 546     if(m_realised)
 547     {
 548       return m_state->getTexture().height;
 549     }
 550     return 1;
 551   }
 552   unsigned int shaderFlags() const
 553   {
 554     if(m_realised)
 555     {
 556       return m_state->getFlags();
 557     }
 558     return 0;
 559   }
 560 };
 561
 562
 563 inline void FaceShader_getFlags(const FaceShader& faceShader, ContentsFlagsValue& flags)
 564 {
 565   flags = faceShader.getFlags();
 566 }
 567
 568
 569
 570
 571
 572 class FaceTexdef : public FaceShaderObserver
 573 {
 574   // not copyable
 575   FaceTexdef(const FaceTexdef& other);
 576   // not assignable
 577   FaceTexdef& operator=(const FaceTexdef& other);
 578 public:
 579   class SavedState
 580   {
 581   public:
 582     TextureProjection m_projection;
 583
 584     SavedState(const FaceTexdef& faceTexdef)
 585     {
 586       m_projection = faceTexdef.m_projection;
 587     }
 588
 589     void exportState(FaceTexdef& faceTexdef) const
 590     {
 591       Texdef_Assign(faceTexdef.m_projection, m_projection);
 592     }
 593   };
 594
 595   FaceShader& m_shader;
 596   TextureProjection m_projection;
 597   bool m_projectionInitialised;
 598   bool m_scaleApplied;
 599
 600   FaceTexdef(
 601     FaceShader& shader,
 602     const TextureProjection& projection,
 603     bool projectionInitialised = true
 604   ) :
 605     m_shader(shader),
 606     m_projection(projection),
 607     m_projectionInitialised(projectionInitialised),
 608     m_scaleApplied(false)
 609   {
 610     m_shader.attach(*this);
 611   }
 612   ~FaceTexdef()
 613   {
 614     m_shader.detach(*this);
 615   }
 616
 617   void addScale()
 618   {
 619     ASSERT_MESSAGE(!m_scaleApplied, "texture scale aready added");
 620     m_scaleApplied = true;
 621     m_projection.m_brushprimit_texdef.addScale(m_shader.width(), m_shader.height());
 622   }
 623   void removeScale()
 624   {
 625     ASSERT_MESSAGE(m_scaleApplied, "texture scale aready removed");
 626     m_scaleApplied = false;
 627     m_projection.m_brushprimit_texdef.removeScale(m_shader.width(), m_shader.height());
 628   }
 629
 630   void realiseShader()
 631   {
 632     if(m_projectionInitialised && !m_scaleApplied)
 633     {
 634       addScale();
 635     }
 636   }
 637   void unrealiseShader()
 638   {
 639     if(m_projectionInitialised && m_scaleApplied)
 640     {
 641       removeScale();
 642     }
 643   }
 644
 645   void setTexdef(const TextureProjection& projection)
 646   {
 647     removeScale();
 648     Texdef_Assign(m_projection, projection);
 649     addScale();
 650   }
 651
 652   void shift(float s, float t)
 653   {
 654     ASSERT_MESSAGE(texdef_sane(m_projection.m_texdef), "FaceTexdef::shift: bad texdef");
 655     removeScale();
 656     Texdef_Shift(m_projection, s, t);
 657     addScale();
 658   }
 659
 660   void scale(float s, float t)
 661   {
 662     removeScale();
 663     Texdef_Scale(m_projection, s, t);
 664     addScale();
 665   }
 666
 667   void rotate(float angle)
 668   {
 669     removeScale();
 670     Texdef_Rotate(m_projection, angle);
 671     addScale();
 672   }
 673
 674   void fit(const Vector3& normal, const Winding& winding, float s_repeat, float t_repeat)
 675   {
 676     Texdef_FitTexture(m_projection, m_shader.width(), m_shader.height(), normal, winding, s_repeat, t_repeat);
 677   }
 678
 679   void emitTextureCoordinates(Winding& winding, const Vector3& normal, const Matrix4& localToWorld)
 680   {
 681     Texdef_EmitTextureCoordinates(m_projection, m_shader.width(), m_shader.height(), winding, normal, localToWorld);
 682   }
 683
 684   void transform(const Plane3& plane, const Matrix4& matrix)
 685   {
 686     removeScale();
 687     Texdef_transformLocked(m_projection, m_shader.width(), m_shader.height(), plane, matrix);
 688     addScale();
 689   }
 690
 691   TextureProjection normalised() const
 692   {
 693     brushprimit_texdef_t tmp(m_projection.m_brushprimit_texdef);
 694     tmp.removeScale(m_shader.width(), m_shader.height());
 695     return TextureProjection(m_projection.m_texdef, tmp, m_projection.m_basis_s, m_projection.m_basis_t);
 696   }
 697   void setBasis(const Vector3& normal)
 698   {
 699     Matrix4 basis;
 700     Normal_GetTransform(normal, basis);
 701     m_projection.m_basis_s = Vector3(basis.xx(), basis.yx(), basis.zx());
 702     m_projection.m_basis_t = Vector3(-basis.xy(), -basis.yy(), -basis.zy());
 703   }
 704 };
 705
 706 inline void FaceTexdef_getTexdef(const FaceTexdef& faceTexdef, TextureProjection& projection)
 707 {
 708   projection = faceTexdef.normalised();
 709 }
 710
 711 inline void planepts_print(const PlanePoints& planePoints, TextOutputStream& ostream)
 712 {
 713   ostream << "( " << planePoints[0][0] << " " << planePoints[0][1] << " " << planePoints[0][2] << " ) "
 714     << "( " << planePoints[1][0] << " " << planePoints[1][1] << " " << planePoints[1][2] << " ) "
 715     << "( " << planePoints[2][0] << " " << planePoints[2][1] << " " << planePoints[2][2] << " )";
 716 }
 717
 718
 719 inline Plane3 Plane3_applyTranslation(const Plane3& plane, const Vector3& translation)
 720 {
 721   Plane3 tmp(plane3_translated(Plane3(plane.normal(), -plane.dist()), translation));
 722   return Plane3(tmp.normal(), -tmp.dist());
 723 }
 724
 725 inline Plane3 Plane3_applyTransform(const Plane3& plane, const Matrix4& matrix)
 726 {
 727   Plane3 tmp(plane3_transformed(Plane3(plane.normal(), -plane.dist()), matrix));
 728   return Plane3(tmp.normal(), -tmp.dist());
 729 }
 730
 731 class FacePlane
 732 {
 733   PlanePoints m_planepts;
 734   Plane3 m_planeCached;
 735   Plane3 m_plane;
 736 public:
 737   Vector3 m_funcStaticOrigin;
 738
 739   static EBrushType m_type;
 740
 741   static bool isDoom3Plane()
 742   {
 743     return FacePlane::m_type == eBrushTypeDoom3 || FacePlane::m_type == eBrushTypeQuake4;
 744   }
 745
 746   class SavedState
 747   {
 748   public:
 749     PlanePoints m_planepts;
 750     Plane3 m_plane;
 751
 752     SavedState(const FacePlane& facePlane)
 753     {
 754       if(facePlane.isDoom3Plane())
 755       {
 756         m_plane = facePlane.m_plane;
 757       }
 758       else
 759       {
 760         planepts_assign(m_planepts, facePlane.planePoints());
 761       }
 762     }
 763
 764     void exportState(FacePlane& facePlane) const
 765     {
 766       if(facePlane.isDoom3Plane())
 767       {
 768         facePlane.m_plane = m_plane;
 769         facePlane.updateTranslated();
 770       }
 771       else
 772       {
 773         planepts_assign(facePlane.planePoints(), m_planepts);
 774         facePlane.MakePlane();
 775       }
 776     }
 777   };
 778
 779   FacePlane() : m_funcStaticOrigin(0, 0, 0)
 780   {
 781   }
 782   FacePlane(const FacePlane& other) : m_funcStaticOrigin(0, 0, 0)
 783   {
 784     if(!isDoom3Plane())
 785     {
 786       planepts_assign(m_planepts, other.m_planepts);
 787       MakePlane();
 788     }
 789     else
 790     {
 791       m_plane = other.m_plane;
 792       updateTranslated();
 793     }
 794   }
 795
 796   void MakePlane()
 797   {
 798     if(!isDoom3Plane())
 799     {
 800 #if 0
 801       if(check_plane_is_integer(m_planepts))
 802       {
 803         globalErrorStream() << "non-integer planepts: ";
 804         planepts_print(m_planepts, globalErrorStream());
 805         globalErrorStream() << "\n";
 806       }
 807 #endif
 808       m_planeCached = plane3_for_points(m_planepts);
 809     }
 810   }
 811
 812   void reverse()
 813   {
 814     if(!isDoom3Plane())
 815     {
 816       vector3_swap(m_planepts[0], m_planepts[2]);
 817       MakePlane();
 818     }
 819     else
 820     {
 821       m_planeCached = plane3_flipped(m_plane);
 822       updateSource();
 823     }
 824   }
 825   void transform(const Matrix4& matrix, bool mirror)
 826   {
 827     if(!isDoom3Plane())
 828     {
 829
 830 #if 0
 831       bool off = check_plane_is_integer(planePoints());
 832 #endif
 833
 834       matrix4_transform_point(matrix, m_planepts[0]);
 835       matrix4_transform_point(matrix, m_planepts[1]);
 836       matrix4_transform_point(matrix, m_planepts[2]);
 837
 838       if(mirror)
 839       {
 840         reverse();
 841       }
 842
 843 #if 0
 844       if(check_plane_is_integer(planePoints()))
 845       {
 846         if(!off)
 847         {
 848           globalErrorStream() << "caused by transform\n";
 849         }
 850       }
 851 #endif
 852       MakePlane();
 853     }
 854     else
 855     {
 856       m_planeCached = Plane3_applyTransform(m_planeCached, matrix);
 857       updateSource();
 858     }
 859   }
 860   void offset(float offset)
 861   {
 862     if(!isDoom3Plane())
 863     {
 864       Vector3 move(vector3_scaled(m_planeCached.normal(), -offset));
 865
 866       vector3_subtract(m_planepts[0], move);
 867       vector3_subtract(m_planepts[1], move);
 868       vector3_subtract(m_planepts[2], move);
 869
 870       MakePlane();
 871     }
 872     else
 873     {
 874       m_planeCached.d += offset;
 875       updateSource();
 876     }
 877   }
 878
 879   void updateTranslated()
 880   {
 881     m_planeCached = Plane3_applyTranslation(m_plane, m_funcStaticOrigin);
 882   }
 883   void updateSource()
 884   {
 885     m_plane = Plane3_applyTranslation(m_planeCached, vector3_negated(m_funcStaticOrigin));
 886   }
 887
 888
 889   PlanePoints& planePoints()
 890   {
 891     return m_planepts;
 892   }
 893   const PlanePoints& planePoints() const
 894   {
 895     return m_planepts;
 896   }
 897   const Plane3& plane3() const
 898   {
 899     return m_planeCached;
 900   }
 901   void setDoom3Plane(const Plane3& plane)
 902   {
 903     m_plane = plane;
 904     updateTranslated();
 905   }
 906   const Plane3& getDoom3Plane() const
 907   {
 908     return m_plane;
 909   }
 910
 911   void copy(const FacePlane& other)
 912   {
 913     if(!isDoom3Plane())
 914     {
 915       planepts_assign(m_planepts, other.m_planepts);
 916       MakePlane();
 917     }
 918     else
 919     {
 920       m_planeCached = other.m_plane;
 921       updateSource();
 922     }
 923   }
 924   void copy(const Vector3& p0, const Vector3& p1, const Vector3& p2)
 925   {
 926     if(!isDoom3Plane())
 927     {
 928       m_planepts[0] = p0;
 929       m_planepts[1] = p1;
 930       m_planepts[2] = p2;
 931       MakePlane();
 932     }
 933     else
 934     {
 935       m_planeCached = plane3_for_points(p2, p1, p0);
 936       updateSource();
 937     }
 938   }
 939 };
 940
 941
 942 const double GRID_MIN = 0.125;
 943
 944 inline double quantiseInteger(double f)
 945 {
 946   return float_to_integer(f);
 947 }
 948
 949 inline double quantiseFloating(double f)
 950 {
 951   return float_snapped(f, 1.f / (1 << 16));
 952 }
 953
 954 typedef double (*QuantiseFunc)(double f);
 955
 956 class Face;
 957
 958 class FaceFilter
 959 {
 960 public:
 961   virtual bool filter(const Face& face) const = 0;
 962 };
 963
 964 bool face_filtered(Face& face);
 965
 966 void Brush_addTextureChangedCallback(const Callback& callback);
 967 void Brush_textureChanged();
 968
 969
 970 extern bool g_brush_texturelock_enabled;
 971
 972 class FaceObserver
 973 {
 974 public:
 975   virtual void planeChanged() = 0;
 976   virtual void connectivityChanged() = 0;
 977   virtual void shaderChanged() = 0;
 978   virtual void evaluateTransform() = 0;
 979 };
 980
 981 class Face :
 982 public OpenGLRenderable,
 983 public Filterable,
 984 public Undoable,
 985 public FaceShaderObserver
 986 {
 987   std::size_t m_refcount;
 988
 989   class SavedState : public UndoMemento
 990   {
 991   public:
 992     FacePlane::SavedState m_planeState;
 993     FaceTexdef::SavedState m_texdefState;
 994     FaceShader::SavedState m_shaderState;
 995
 996     SavedState(const Face& face) : m_planeState(face.getPlane()), m_texdefState(face.getTexdef()), m_shaderState(face.getShader())
 997     {
 998     }
 999
1000     void exportState(Face& face) const
1001     {
1002       m_planeState.exportState(face.getPlane());
1003       m_shaderState.exportState(face.getShader());
1004       m_texdefState.exportState(face.getTexdef());
1005     }
1006
1007     void release()
1008     {
1009       delete this;
1010     }
1011   };
1012
1013 public:
1014   static QuantiseFunc m_quantise;
1015   static EBrushType m_type;
1016
1017   PlanePoints m_move_planepts;
1018   PlanePoints m_move_planeptsTransformed;
1019 private:
1020   FacePlane m_plane;
1021   FacePlane m_planeTransformed;
1022   FaceShader m_shader;
1023   FaceTexdef m_texdef;
1024   TextureProjection m_texdefTransformed;
1025
1026   Winding m_winding;
1027   Vector3 m_centroid;
1028   bool m_filtered;
1029
1030   FaceObserver* m_observer;
1031   UndoObserver* m_undoable_observer;
1032   MapFile* m_map;
1033
1034   // assignment not supported
1035   Face& operator=(const Face& other);
1036   // copy-construction not supported
1037   Face(const Face& other);
1038
1039 public:
1040
1041   Face(FaceObserver* observer) :
1042     m_refcount(0),
1043     m_shader(texdef_name_default()),
1044     m_texdef(m_shader, TextureProjection(), false),
1045     m_filtered(false),
1046     m_observer(observer),
1047     m_undoable_observer(0),
1048     m_map(0)
1049   {
1050     m_shader.attach(*this);
1051     m_plane.copy(Vector3(0, 0, 0), Vector3(64, 0, 0), Vector3(0, 64, 0));
1052     m_texdef.setBasis(m_plane.plane3().normal());
1053     planeChanged();
1054   }
1055   Face(
1056     const Vector3& p0,
1057     const Vector3& p1,
1058     const Vector3& p2,
1059     const char* shader,
1060     const TextureProjection& projection,
1061     FaceObserver* observer
1062   ) :
1063     m_refcount(0),
1064     m_shader(shader),
1065     m_texdef(m_shader, projection),
1066     m_observer(observer),
1067     m_undoable_observer(0),
1068     m_map(0)
1069   {
1070     m_shader.attach(*this);
1071     m_plane.copy(p0, p1, p2);
1072     m_texdef.setBasis(m_plane.plane3().normal());
1073     planeChanged();
1074     updateFiltered();
1075   }
1076   Face(const Face& other, FaceObserver* observer) :
1077     m_refcount(0),
1078     m_shader(other.m_shader.getShader(), other.m_shader.m_flags),
1079     m_texdef(m_shader, other.getTexdef().normalised()),
1080     m_observer(observer),
1081     m_undoable_observer(0),
1082     m_map(0)
1083   {
1084     m_shader.attach(*this);
1085     m_plane.copy(other.m_plane);
1086     planepts_assign(m_move_planepts, other.m_move_planepts);
1087     m_texdef.setBasis(m_plane.plane3().normal());
1088     planeChanged();
1089     updateFiltered();
1090   }
1091   ~Face()
1092   {
1093     m_shader.detach(*this);
1094   }
1095
1096   void planeChanged()
1097   {
1098     revertTransform();
1099     m_observer->planeChanged();
1100   }
1101
1102   void realiseShader()
1103   {
1104     m_observer->shaderChanged();
1105   }
1106   void unrealiseShader()
1107   {
1108   }
1109
1110   void instanceAttach(MapFile* map)
1111   {
1112     m_shader.instanceAttach();
1113     m_map = map;
1114     m_undoable_observer = GlobalUndoSystem().observer(this);
1115     GlobalFilterSystem().registerFilterable(*this);
1116   }
1117   void instanceDetach(MapFile* map)
1118   {
1119     GlobalFilterSystem().unregisterFilterable(*this);
1120     m_undoable_observer = 0;
1121     GlobalUndoSystem().release(this);
1122     m_map = 0;
1123     m_shader.instanceDetach();
1124   }
1125
1126   void render(RenderStateFlags state) const
1127   {
1128     Winding_Draw(m_winding, m_planeTransformed.plane3().normal(), state);
1129   }
1130
1131   void updateFiltered()
1132   {
1133     m_filtered = face_filtered(*this);
1134   }
1135   bool isFiltered() const
1136   {
1137     return m_filtered;
1138   }
1139
1140   void undoSave()
1141   {
1142     if(m_map != 0)
1143     {
1144       m_map->changed();
1145     }
1146     if(m_undoable_observer != 0)
1147     {
1148       m_undoable_observer->save(this);
1149     }
1150   }
1151
1152   // undoable
1153   UndoMemento* exportState() const
1154   {
1155     return new SavedState(*this);
1156   }
1157   void importState(const UndoMemento* data)
1158   {
1159     undoSave();
1160
1161     static_cast<const SavedState*>(data)->exportState(*this);
1162
1163     planeChanged();
1164     m_observer->connectivityChanged();
1165     texdefChanged();
1166     m_observer->shaderChanged();
1167     updateFiltered();
1168   }
1169
1170   void IncRef()
1171   {
1172     ++m_refcount;
1173   }
1174   void DecRef()
1175   {
1176     if(--m_refcount == 0)
1177       delete this;
1178   }
1179
1180   void flipWinding()
1181   {
1182     m_plane.reverse();
1183     planeChanged();
1184   }
1185
1186   bool intersectVolume(const VolumeTest& volume, const Matrix4& localToWorld) const
1187   {
1188     return volume.TestPlane(Plane3(plane3().normal(), -plane3().dist()), localToWorld);
1189   }
1190
1191   void render(Renderer& renderer, const Matrix4& localToWorld) const
1192   {
1193     renderer.SetState(m_shader.state(), Renderer::eFullMaterials);
1194     renderer.addRenderable(*this, localToWorld);
1195   }
1196
1197   void transform(const Matrix4& matrix, bool mirror)
1198   {
1199     if(g_brush_texturelock_enabled)
1200     {
1201       Texdef_transformLocked(m_texdefTransformed, m_shader.width(), m_shader.height(), m_plane.plane3(), matrix);
1202     }
1203
1204     m_planeTransformed.transform(matrix, mirror);
1205
1206 #if 0
1207     ASSERT_MESSAGE(projectionaxis_for_normal(normal) == projectionaxis_for_normal(plane3().normal()), "bleh");
1208 #endif
1209     m_observer->planeChanged();
1210   }
1211
1212   void assign_planepts(const PlanePoints planepts)
1213   {
1214     m_planeTransformed.copy(planepts[0], planepts[1], planepts[2]);
1215     m_observer->planeChanged();
1216   }
1217
1218   /// \brief Reverts the transformable state of the brush to identity.
1219   void revertTransform()
1220   {
1221     m_planeTransformed = m_plane;
1222     planepts_assign(m_move_planeptsTransformed, m_move_planepts);
1223     m_texdefTransformed = m_texdef.m_projection;
1224   }
1225   void freezeTransform()
1226   {
1227     undoSave();
1228     m_plane = m_planeTransformed;
1229     planepts_assign(m_move_planepts, m_move_planeptsTransformed);
1230     m_texdef.m_projection = m_texdefTransformed;
1231   }
1232
1233   void update_move_planepts_vertex(std::size_t index, PlanePoints planePoints)
1234   {
1235     std::size_t numpoints = getWinding().numpoints;
1236     ASSERT_MESSAGE(index < numpoints, "update_move_planepts_vertex: invalid index");
1237
1238     std::size_t opposite = Winding_Opposite(getWinding(), index);
1239     std::size_t adjacent = Winding_wrap(getWinding(), opposite+numpoints-1);
1240     planePoints[0] = getWinding()[opposite].vertex;
1241     planePoints[1] = getWinding()[index].vertex;
1242     planePoints[2] = getWinding()[adjacent].vertex;
1243     // winding points are very inaccurate, so they must be quantised before using them to generate the face-plane
1244     planepts_quantise(planePoints, GRID_MIN);
1245   }
1246
1247   void snapto(float snap)
1248   {
1249     if(contributes())
1250     {
1251 #if 0
1252       ASSERT_MESSAGE(plane3_valid(m_plane.plane3()), "invalid plane before snap to grid");
1253       planepts_snap(m_plane.planePoints(), snap);
1254       ASSERT_MESSAGE(plane3_valid(m_plane.plane3()), "invalid plane after snap to grid");
1255 #else
1256       PlanePoints planePoints;
1257       update_move_planepts_vertex(0, planePoints);
1258       vector3_snap(planePoints[0], snap);
1259       vector3_snap(planePoints[1], snap);
1260       vector3_snap(planePoints[2], snap);
1261       assign_planepts(planePoints);
1262       freezeTransform();
1263 #endif
1264       SceneChangeNotify();
1265       if(!plane3_valid(m_plane.plane3()))
1266       {
1267         globalErrorStream() << "WARNING: invalid plane after snap to grid\n";
1268       }
1269     }
1270   }
1271
1272
1273   void testSelect(SelectionTest& test, SelectionIntersection& best)
1274   {
1275     test.TestPolygon(VertexPointer(reinterpret_cast<VertexPointer::pointer>(&m_winding.points.data()->vertex), sizeof(WindingVertex)), m_winding.numpoints, best);
1276   }
1277
1278   void testSelect_centroid(SelectionTest& test, SelectionIntersection& best)
1279   {
1280     test.TestPoint(m_centroid, best);
1281   }
1282
1283   void shaderChanged()
1284   {
1285     EmitTextureCoordinates();
1286     Brush_textureChanged();
1287     m_observer->shaderChanged();
1288     updateFiltered();
1289     SceneChangeNotify();
1290   }
1291
1292   const char* GetShader() const
1293   {
1294     return m_shader.getShader();
1295   }
1296   void SetShader(const char* name)
1297   {
1298     undoSave();
1299     m_shader.setShader(name);
1300     shaderChanged();
1301   }
1302
1303   void revertTexdef()
1304   {
1305     m_texdefTransformed = m_texdef.m_projection;
1306   }
1307   void texdefChanged()
1308   {
1309     revertTexdef();
1310     EmitTextureCoordinates();
1311     Brush_textureChanged();
1312   }
1313
1314   void SetTexdef(const TextureProjection& projection)
1315   {
1316     undoSave();
1317     m_texdef.setTexdef(projection);
1318     texdefChanged();
1319   }
1320
1321   void SetFlags(const ContentsFlagsValue& flags)
1322   {
1323     undoSave();
1324     m_shader.setFlags(flags);
1325     m_observer->shaderChanged();
1326     updateFiltered();
1327   }
1328
1329   void ShiftTexdef(float s, float t)
1330   {
1331     undoSave();
1332     m_texdef.shift(s, t);
1333     texdefChanged();
1334   }
1335
1336   void ScaleTexdef(float s, float t)
1337   {
1338     undoSave();
1339     m_texdef.scale(s, t);
1340     texdefChanged();
1341   }
1342
1343   void RotateTexdef(float angle)
1344   {
1345     undoSave();
1346     m_texdef.rotate(angle);
1347     texdefChanged();
1348   }
1349
1350   void FitTexture(float s_repeat, float t_repeat)
1351   {
1352     undoSave();
1353     m_texdef.fit(m_plane.plane3().normal(), m_winding, s_repeat, t_repeat);
1354     texdefChanged();
1355   }
1356
1357   void EmitTextureCoordinates()
1358   {
1359     Texdef_EmitTextureCoordinates(m_texdefTransformed, m_shader.width(), m_shader.height(), m_winding, plane3().normal(), g_matrix4_identity);
1360   }
1361
1362
1363   const Vector3& centroid() const
1364   {
1365     return m_centroid;
1366   }
1367
1368   void construct_centroid()
1369   {
1370     Winding_Centroid(m_winding, plane3(), m_centroid);
1371   }
1372
1373   const Winding& getWinding() const
1374   {
1375     return m_winding;
1376   }
1377   Winding& getWinding()
1378   {
1379     return m_winding;
1380   }
1381
1382   const Plane3& plane3() const
1383   {
1384     m_observer->evaluateTransform();
1385     return m_planeTransformed.plane3();
1386   }
1387   FacePlane& getPlane()
1388   {
1389     return m_plane;
1390   }
1391   const FacePlane& getPlane() const
1392   {
1393     return m_plane;
1394   }
1395   FaceTexdef& getTexdef()
1396   {
1397     return m_texdef;
1398   }
1399   const FaceTexdef& getTexdef() const
1400   {
1401     return m_texdef;
1402   }
1403   FaceShader& getShader()
1404   {
1405     return m_shader;
1406   }
1407   const FaceShader& getShader() const
1408   {
1409     return m_shader;
1410   }
1411
1412   bool isDetail() const
1413   {
1414     return (m_shader.m_flags.m_contentFlags & CONTENTS_DETAIL) != 0;
1415   }
1416   void setDetail(bool detail)
1417   {
1418     undoSave();
1419     if(detail && !isDetail())
1420     {
1421       m_shader.m_flags.m_contentFlags |= CONTENTS_DETAIL;
1422     }
1423     else if(!detail && isDetail())
1424     {
1425       m_shader.m_flags.m_contentFlags &= ~CONTENTS_DETAIL;
1426     }
1427     m_observer->shaderChanged();
1428   }
1429
1430   bool contributes() const
1431   {
1432     return m_winding.numpoints > 2;
1433   }
1434   bool is_bounded() const
1435   {
1436     for(Winding::const_iterator i = m_winding.begin(); i != m_winding.end(); ++i)
1437     {
1438       if((*i).adjacent == c_brush_maxFaces)
1439       {
1440         return false;
1441       }
1442     }
1443     return true;
1444   }
1445 };
1446
1447
1448 class FaceVertexId
1449 {
1450   std::size_t m_face;
1451   std::size_t m_vertex;
1452
1453 public:
1454   FaceVertexId(std::size_t face, std::size_t vertex)
1455     : m_face(face), m_vertex(vertex)
1456   {
1457   }
1458
1459   std::size_t getFace() const
1460   {
1461     return m_face;
1462   }
1463   std::size_t getVertex() const
1464   {
1465     return m_vertex;
1466   }
1467 };
1468
1469 typedef std::size_t faceIndex_t;
1470
1471 struct EdgeRenderIndices
1472 {
1473   RenderIndex first;
1474   RenderIndex second;
1475
1476   EdgeRenderIndices()
1477     : first(0), second(0)
1478   {
1479   }
1480   EdgeRenderIndices(const RenderIndex _first, const RenderIndex _second)
1481     : first(_first), second(_second)
1482   {
1483   }
1484 };
1485
1486 struct EdgeFaces
1487 {
1488   faceIndex_t first;
1489   faceIndex_t second;
1490
1491   EdgeFaces()
1492     : first(c_brush_maxFaces), second(c_brush_maxFaces)
1493   {
1494   }
1495   EdgeFaces(const faceIndex_t _first, const faceIndex_t _second)
1496     : first(_first), second(_second)
1497   {
1498   }
1499 };
1500
1501 class RenderableWireframe : public OpenGLRenderable
1502 {
1503 public:
1504   void render(RenderStateFlags state) const
1505   {
1506 #if 1
1507     glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_vertices->colour);
1508     glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_vertices->vertex);
1509     glDrawElements(GL_LINES, GLsizei(m_size<<1), RenderIndexTypeID, m_faceVertex.data());
1510 #else
1511     glBegin(GL_LINES);
1512     for(std::size_t i = 0; i < m_size; ++i)
1513     {
1514       glVertex3fv(&m_vertices[m_faceVertex[i].first].vertex.x);
1515       glVertex3fv(&m_vertices[m_faceVertex[i].second].vertex.x);
1516     }
1517     glEnd();
1518 #endif
1519   }
1520
1521   Array<EdgeRenderIndices> m_faceVertex;
1522   std::size_t m_size;
1523   const PointVertex* m_vertices;
1524 };
1525
1526 class Brush;
1527 typedef std::vector<Brush*> brush_vector_t;
1528
1529 class BrushFilter
1530 {
1531 public:
1532   virtual bool filter(const Brush& brush) const = 0;
1533 };
1534
1535 bool brush_filtered(Brush& brush);
1536 void add_brush_filter(BrushFilter& filter, int mask, bool invert = false);
1537
1538
1539 /// \brief Returns true if 'self' takes priority when building brush b-rep.
1540 inline bool plane3_inside(const Plane3& self, const Plane3& other)
1541 {
1542   if(vector3_equal_epsilon(self.normal(), other.normal(), 0.001))
1543   {
1544     return self.dist() < other.dist();
1545   }
1546   return true;
1547 }
1548
1549 typedef SmartPointer<Face> FaceSmartPointer;
1550 typedef std::vector<FaceSmartPointer> Faces;
1551
1552 /// \brief Returns the unique-id of the edge adjacent to \p faceVertex in the edge-pair for the set of \p faces.
1553 inline FaceVertexId next_edge(const Faces& faces, FaceVertexId faceVertex)
1554 {
1555   std::size_t adjacent_face = faces[faceVertex.getFace()]->getWinding()[faceVertex.getVertex()].adjacent;
1556   std::size_t adjacent_vertex = Winding_FindAdjacent(faces[adjacent_face]->getWinding(), faceVertex.getFace());
1557
1558   ASSERT_MESSAGE(adjacent_vertex != c_brush_maxFaces, "connectivity data invalid");
1559   if(adjacent_vertex == c_brush_maxFaces)
1560   {
1561     return faceVertex;
1562   }
1563
1564   return FaceVertexId(adjacent_face, adjacent_vertex);
1565 }
1566
1567 /// \brief Returns the unique-id of the vertex adjacent to \p faceVertex in the vertex-ring for the set of \p faces.
1568 inline FaceVertexId next_vertex(const Faces& faces, FaceVertexId faceVertex)
1569 {
1570   FaceVertexId nextEdge = next_edge(faces, faceVertex);
1571   return FaceVertexId(nextEdge.getFace(), Winding_next(faces[nextEdge.getFace()]->getWinding(), nextEdge.getVertex()));
1572 }
1573
1574 class SelectableEdge
1575 {
1576   Vector3 getEdge() const
1577   {
1578     const Winding& winding = getFace().getWinding();
1579     return vector3_mid(winding[m_faceVertex.getVertex()].vertex, winding[Winding_next(winding, m_faceVertex.getVertex())].vertex);
1580   }
1581
1582 public:
1583   Faces& m_faces;
1584   FaceVertexId m_faceVertex;
1585
1586   SelectableEdge(Faces& faces, FaceVertexId faceVertex)
1587     : m_faces(faces), m_faceVertex(faceVertex)
1588   {
1589   }
1590   SelectableEdge& operator=(const SelectableEdge& other)
1591   {
1592     m_faceVertex = other.m_faceVertex;
1593     return *this;
1594   }
1595
1596   Face& getFace() const
1597   {
1598     return *m_faces[m_faceVertex.getFace()];
1599   }
1600
1601   void testSelect(SelectionTest& test, SelectionIntersection& best)
1602   {
1603     test.TestPoint(getEdge(), best);
1604   }
1605 };
1606
1607 class SelectableVertex
1608 {
1609   Vector3 getVertex() const
1610   {
1611     return getFace().getWinding()[m_faceVertex.getVertex()].vertex;
1612   }
1613
1614 public:
1615   Faces& m_faces;
1616   FaceVertexId m_faceVertex;
1617
1618   SelectableVertex(Faces& faces, FaceVertexId faceVertex)
1619     : m_faces(faces), m_faceVertex(faceVertex)
1620   {
1621   }
1622   SelectableVertex& operator=(const SelectableVertex& other)
1623   {
1624     m_faceVertex = other.m_faceVertex;
1625     return *this;
1626   }
1627
1628   Face& getFace() const
1629   {
1630     return *m_faces[m_faceVertex.getFace()];
1631   }
1632
1633   void testSelect(SelectionTest& test, SelectionIntersection& best)
1634   {
1635     test.TestPoint(getVertex(), best);
1636   }
1637 };
1638
1639 class BrushObserver
1640 {
1641 public:
1642   virtual void reserve(std::size_t size) = 0;
1643   virtual void clear() = 0;
1644   virtual void push_back(Face& face) = 0;
1645   virtual void pop_back() = 0;
1646   virtual void erase(std::size_t index) = 0;
1647   virtual void connectivityChanged() = 0;
1648
1649   virtual void edge_clear() = 0;
1650   virtual void edge_push_back(SelectableEdge& edge) = 0;
1651
1652   virtual void vertex_clear() = 0;
1653   virtual void vertex_push_back(SelectableVertex& vertex) = 0;
1654
1655   virtual void DEBUG_verify() const = 0;
1656 };
1657
1658 class BrushVisitor
1659 {
1660 public:
1661   virtual void visit(Face& face) const = 0;
1662 };
1663
1664 class Brush :
1665   public TransformNode,
1666   public Bounded,
1667   public Cullable,
1668   public Snappable,
1669   public Undoable,
1670   public FaceObserver,
1671   public Filterable,
1672   public Nameable,
1673   public BrushDoom3
1674 {
1675 private:
1676   scene::Node* m_node;
1677   typedef UniqueSet<BrushObserver*> Observers;
1678   Observers m_observers;
1679   UndoObserver* m_undoable_observer;
1680   MapFile* m_map;
1681
1682   // state
1683   Faces m_faces;
1684   // ----
1685
1686   // cached data compiled from state
1687   Array<PointVertex> m_faceCentroidPoints;
1688   RenderablePointArray m_render_faces;
1689
1690   Array<PointVertex> m_uniqueVertexPoints;
1691   typedef std::vector<SelectableVertex> SelectableVertices;
1692   SelectableVertices m_select_vertices;
1693   RenderablePointArray m_render_vertices;
1694
1695   Array<PointVertex> m_uniqueEdgePoints;
1696   typedef std::vector<SelectableEdge> SelectableEdges;
1697   SelectableEdges m_select_edges;
1698   RenderablePointArray m_render_edges;
1699
1700   Array<EdgeRenderIndices> m_edge_indices;
1701   Array<EdgeFaces> m_edge_faces;
1702
1703   AABB m_aabb_local;
1704   // ----
1705
1706   Callback m_evaluateTransform;
1707   Callback m_boundsChanged;
1708
1709   mutable bool m_planeChanged; // b-rep evaluation required
1710   mutable bool m_transformChanged; // transform evaluation required
1711   // ----
1712
1713 public:
1714   STRING_CONSTANT(Name, "Brush");
1715
1716   Callback m_lightsChanged;
1717
1718   // static data
1719   static Shader* m_state_point;
1720   // ----
1721
1722   static EBrushType m_type;
1723   static double m_maxWorldCoord;
1724
1725   Brush(scene::Node& node, const Callback& evaluateTransform, const Callback& boundsChanged) :
1726     m_node(&node),
1727     m_undoable_observer(0),
1728     m_map(0),
1729     m_render_faces(m_faceCentroidPoints, GL_POINTS),
1730     m_render_vertices(m_uniqueVertexPoints, GL_POINTS),
1731     m_render_edges(m_uniqueEdgePoints, GL_POINTS),
1732     m_planeChanged(false),
1733     m_transformChanged(false),
1734     m_evaluateTransform(evaluateTransform),
1735     m_boundsChanged(boundsChanged)
1736   {
1737     planeChanged();
1738   }
1739   Brush(const Brush& other, scene::Node& node, const Callback& evaluateTransform, const Callback& boundsChanged) :
1740     m_node(&node),
1741     m_undoable_observer(0),
1742     m_map(0),
1743     m_render_faces(m_faceCentroidPoints, GL_POINTS),
1744     m_render_vertices(m_uniqueVertexPoints, GL_POINTS),
1745     m_render_edges(m_uniqueEdgePoints, GL_POINTS),
1746     m_planeChanged(false),
1747     m_transformChanged(false),
1748     m_evaluateTransform(evaluateTransform),
1749     m_boundsChanged(boundsChanged)
1750   {
1751     copy(other);
1752   }
1753   Brush(const Brush& other) :
1754     TransformNode(other),
1755     Bounded(other),
1756     Cullable(other),
1757     Undoable(other),
1758     FaceObserver(other),
1759     Filterable(other),
1760     Nameable(other),
1761     BrushDoom3(other),
1762     m_node(0),
1763     m_undoable_observer(0),
1764     m_map(0),
1765     m_render_faces(m_faceCentroidPoints, GL_POINTS),
1766     m_render_vertices(m_uniqueVertexPoints, GL_POINTS),
1767     m_render_edges(m_uniqueEdgePoints, GL_POINTS),
1768     m_planeChanged(false),
1769     m_transformChanged(false)
1770   {
1771     copy(other);
1772   }
1773   ~Brush()
1774   {
1775     ASSERT_MESSAGE(m_observers.empty(), "Brush::~Brush: observers still attached");
1776   }
1777
1778   // assignment not supported
1779   Brush& operator=(const Brush& other);
1780
1781   void setDoom3GroupOrigin(const Vector3& origin)
1782   {
1783     //globalOutputStream() << "func_static origin before: " << m_funcStaticOrigin << " after: " << origin << "\n";
1784     for(Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1785     {
1786       (*i)->getPlane().m_funcStaticOrigin = origin;
1787       (*i)->getPlane().updateTranslated();
1788       (*i)->planeChanged();
1789     }
1790     planeChanged();
1791   }
1792
1793   void attach(BrushObserver& observer)
1794   {
1795     for(Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1796     {
1797       observer.push_back(*(*i));
1798     }
1799
1800     for(SelectableEdges::iterator i = m_select_edges.begin(); i !=m_select_edges.end(); ++i)
1801     {
1802       observer.edge_push_back(*i);
1803     }
1804
1805     for(SelectableVertices::iterator i = m_select_vertices.begin(); i != m_select_vertices.end(); ++i)
1806     {
1807       observer.vertex_push_back(*i);
1808     }
1809
1810     m_observers.insert(&observer);
1811   }
1812   void detach(BrushObserver& observer)
1813   {
1814     m_observers.erase(&observer);
1815   }
1816
1817   void forEachFace(const BrushVisitor& visitor) const
1818   {
1819     for(Faces::const_iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1820     {
1821       visitor.visit(*(*i));
1822     }
1823   }
1824
1825   void forEachFace_instanceAttach(MapFile* map) const
1826   {
1827     for(Faces::const_iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1828     {
1829       (*i)->instanceAttach(map);
1830     }
1831   }
1832   void forEachFace_instanceDetach(MapFile* map) const
1833   {
1834     for(Faces::const_iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1835     {
1836       (*i)->instanceDetach(map);
1837     }
1838   }
1839
1840   InstanceCounter m_instanceCounter;
1841   void instanceAttach(const scene::Path& path)
1842   {
1843     if(++m_instanceCounter.m_count == 1)
1844     {
1845       m_map = path_find_mapfile(path.begin(), path.end());
1846       m_undoable_observer = GlobalUndoSystem().observer(this);
1847       GlobalFilterSystem().registerFilterable(*this);
1848       forEachFace_instanceAttach(m_map);
1849     }
1850     else
1851     {
1852       ASSERT_MESSAGE(path_find_mapfile(path.begin(), path.end()) == m_map, "node is instanced across more than one file");
1853     }
1854   }
1855   void instanceDetach(const scene::Path& path)
1856   {
1857     if(--m_instanceCounter.m_count == 0)
1858     {
1859       forEachFace_instanceDetach(m_map);
1860       GlobalFilterSystem().unregisterFilterable(*this);
1861       m_map = 0;
1862       m_undoable_observer = 0;
1863       GlobalUndoSystem().release(this);
1864     }
1865   }
1866
1867   // nameable
1868   const char* name() const
1869   {
1870     return "brush";
1871   }
1872   void attach(const NameCallback& callback)
1873   {
1874   }
1875   void detach(const NameCallback& callback)
1876   {
1877   }
1878
1879   // filterable
1880   void updateFiltered()
1881   {
1882     if(m_node != 0)
1883     {
1884       if(brush_filtered(*this))
1885       {
1886         m_node->enable(scene::Node::eFiltered);
1887       }
1888       else
1889       {
1890         m_node->disable(scene::Node::eFiltered);
1891       }
1892     }
1893   }
1894
1895   // observer
1896   void planeChanged()
1897   {
1898     m_planeChanged = true;
1899     aabbChanged();
1900     m_lightsChanged();
1901   }
1902   void shaderChanged()
1903   {
1904     updateFiltered();
1905   }
1906
1907   void evaluateBRep() const
1908   {
1909     if(m_planeChanged)
1910     {
1911       m_planeChanged = false;
1912       const_cast<Brush*>(this)->buildBRep();
1913     }
1914   }
1915
1916   void transformChanged()
1917   {
1918     m_transformChanged = true;
1919     planeChanged();
1920   }
1921   typedef MemberCaller<Brush, &Brush::transformChanged> TransformChangedCaller;
1922
1923   void evaluateTransform()
1924   {
1925     if(m_transformChanged)
1926     {
1927       m_transformChanged = false;
1928       revertTransform();
1929       m_evaluateTransform();
1930     }
1931   }
1932   const Matrix4& localToParent() const
1933   {
1934     return g_matrix4_identity;
1935   }
1936   void aabbChanged()
1937   {
1938     m_boundsChanged();
1939   }
1940   const AABB& localAABB() const
1941   {
1942     evaluateBRep();
1943     return m_aabb_local;
1944   }
1945
1946   VolumeIntersectionValue intersectVolume(const VolumeTest& test, const Matrix4& localToWorld) const
1947   {
1948     return test.TestAABB(m_aabb_local, localToWorld);
1949   }
1950
1951   void renderComponents(SelectionSystem::EComponentMode mode, Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
1952   {
1953     switch(mode)
1954     {
1955     case SelectionSystem::eVertex:
1956       renderer.addRenderable(m_render_vertices, localToWorld);
1957       break;
1958     case SelectionSystem::eEdge:
1959       renderer.addRenderable(m_render_edges, localToWorld);
1960       break;
1961     case SelectionSystem::eFace:
1962       renderer.addRenderable(m_render_faces, localToWorld);
1963       break;
1964     default:
1965       break;
1966     }
1967   }
1968
1969   void transform(const Matrix4& matrix)
1970   {
1971     bool mirror = matrix4_handedness(matrix) == MATRIX4_LEFTHANDED;
1972
1973     for(Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1974     {
1975       (*i)->transform(matrix, mirror);
1976     }
1977   }
1978   void snapto(float snap)
1979   {
1980     for(Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1981     {
1982       (*i)->snapto(snap);
1983     }
1984   }
1985   void revertTransform()
1986   {
1987     for(Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1988     {
1989       (*i)->revertTransform();
1990     }
1991   }
1992   void freezeTransform()
1993   {
1994     for(Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1995     {
1996       (*i)->freezeTransform();
1997     }
1998   }
1999
2000   /// \brief Returns the absolute index of the \p faceVertex.
2001   std::size_t absoluteIndex(FaceVertexId faceVertex)
2002   {
2003     std::size_t index = 0;
2004     for(std::size_t i = 0; i < faceVertex.getFace(); ++i)
2005     {
2006       index += m_faces[i]->getWinding().numpoints;
2007     }
2008     return index + faceVertex.getVertex();
2009   }
2010
2011   void appendFaces(const Faces& other)
2012   {
2013     clear();
2014     for(Faces::const_iterator i = other.begin(); i != other.end(); ++i)
2015     {
2016       push_back(*i);
2017     }
2018   }
2019
2020   /// \brief The undo memento for a brush stores only the list of face references - the faces are not copied.
2021   class BrushUndoMemento : public UndoMemento
2022   {
2023   public:
2024     BrushUndoMemento(const Faces& faces) : m_faces(faces)
2025     {
2026     }
2027     void release()
2028     {
2029       delete this;
2030     }
2031
2032     Faces m_faces;
2033   };
2034
2035   void undoSave()
2036   {
2037     if(m_map != 0)
2038     {
2039       m_map->changed();
2040     }
2041     if(m_undoable_observer != 0)
2042     {
2043       m_undoable_observer->save(this);
2044     }
2045   }
2046
2047   UndoMemento* exportState() const
2048   {
2049     return new BrushUndoMemento(m_faces);
2050   }
2051
2052   void importState(const UndoMemento* state)
2053   {
2054     undoSave();
2055     appendFaces(static_cast<const BrushUndoMemento*>(state)->m_faces);
2056     planeChanged();
2057
2058     for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2059     {
2060       (*i)->DEBUG_verify();
2061     }
2062   }
2063
2064   bool isDetail()
2065   {
2066     return !m_faces.empty() && m_faces.front()->isDetail();
2067   }
2068
2069   /// \brief Appends a copy of \p face to the end of the face list.
2070   Face* addFace(const Face& face)
2071   {
2072     if(m_faces.size() == c_brush_maxFaces)
2073     {
2074       return 0;
2075     }
2076     undoSave();
2077     push_back(FaceSmartPointer(new Face(face, this)));
2078     m_faces.back()->setDetail(isDetail());
2079     planeChanged();
2080     return m_faces.back();
2081   }
2082
2083   /// \brief Appends a new face constructed from the parameters to the end of the face list.
2084   Face* addPlane(const Vector3& p0, const Vector3& p1, const Vector3& p2, const char* shader, const TextureProjection& projection)
2085   {
2086     if(m_faces.size() == c_brush_maxFaces)
2087     {
2088       return 0;
2089     }
2090     undoSave();
2091     push_back(FaceSmartPointer(new Face(p0, p1, p2, shader, projection, this)));
2092     m_faces.back()->setDetail(isDetail());
2093     planeChanged();
2094     return m_faces.back();
2095   }
2096
2097   static void constructStatic(EBrushType type)
2098   {
2099     m_type = type;
2100     Face::m_type = type;
2101     FacePlane::m_type = type;
2102
2103     g_bp_globals.m_texdefTypeId = TEXDEFTYPEID_QUAKE;
2104     if(m_type == eBrushTypeQuake3BP || m_type == eBrushTypeDoom3 || m_type == eBrushTypeQuake4)
2105     {
2106       g_bp_globals.m_texdefTypeId = TEXDEFTYPEID_BRUSHPRIMITIVES;
2107       g_brush_texturelock_enabled = true;
2108     }
2109     else if(m_type == eBrushTypeHalfLife)
2110     {
2111       g_bp_globals.m_texdefTypeId = TEXDEFTYPEID_HALFLIFE;
2112       g_brush_texturelock_enabled = true;
2113     }
2114
2115     Face::m_quantise = (m_type == eBrushTypeQuake) ? quantiseInteger : quantiseFloating;
2116
2117     m_state_point = GlobalShaderCache().capture("$POINT");
2118   }
2119   static void destroyStatic()
2120   {
2121     GlobalShaderCache().release("$POINT");
2122   }
2123
2124   std::size_t DEBUG_size()
2125   {
2126     return m_faces.size();
2127   }
2128
2129   typedef Faces::const_iterator const_iterator;
2130
2131   const_iterator begin() const
2132   {
2133     return m_faces.begin();
2134   }
2135   const_iterator end() const
2136   {
2137     return m_faces.end();
2138   }
2139
2140   Face* back()
2141   {
2142     return m_faces.back();
2143   }
2144   const Face* back() const
2145   {
2146     return m_faces.back();
2147   }
2148   void reserve(std::size_t size)
2149   {
2150     m_faces.reserve(size);
2151     for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2152     {
2153       (*i)->reserve(size);
2154     }
2155   }
2156   void push_back(Faces::value_type face)
2157   {
2158     m_faces.push_back(face);
2159     if(m_instanceCounter.m_count != 0)
2160     {
2161       m_faces.back()->instanceAttach(m_map);
2162     }
2163     for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2164     {
2165       (*i)->push_back(*face);
2166       (*i)->DEBUG_verify();
2167     }
2168   }
2169   void pop_back()
2170   {
2171     if(m_instanceCounter.m_count != 0)
2172     {
2173       m_faces.back()->instanceDetach(m_map);
2174     }
2175     m_faces.pop_back();
2176     for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2177     {
2178       (*i)->pop_back();
2179       (*i)->DEBUG_verify();
2180     }
2181   }
2182   void erase(std::size_t index)
2183   {
2184     if(m_instanceCounter.m_count != 0)
2185     {
2186       m_faces[index]->instanceDetach(m_map);
2187     }
2188     m_faces.erase(m_faces.begin() + index);
2189     for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2190     {
2191       (*i)->erase(index);
2192       (*i)->DEBUG_verify();
2193     }
2194   }
2195   void connectivityChanged()
2196   {
2197     for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2198     {
2199       (*i)->connectivityChanged();
2200     }
2201   }
2202
2203
2204   void clear()
2205   {
2206     if(m_instanceCounter.m_count != 0)
2207     {
2208       forEachFace_instanceDetach(m_map);
2209     }
2210     m_faces.clear();
2211     for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2212     {
2213       (*i)->clear();
2214       (*i)->DEBUG_verify();
2215     }
2216   }
2217   std::size_t size() const
2218   {
2219     return m_faces.size();
2220   }
2221   bool empty() const
2222   {
2223     return m_faces.empty();
2224   }
2225
2226   /// \brief Returns true if any face of the brush contributes to the final B-Rep.
2227   bool hasContributingFaces() const
2228   {
2229     for(const_iterator i = begin(); i != end(); ++i)
2230     {
2231       if((*i)->contributes())
2232       {
2233         return true;
2234       }
2235     }
2236     return false;
2237   }
2238
2239   /// \brief Removes faces that do not contribute to the brush. This is useful for cleaning up after CSG operations on the brush.
2240   /// Note: removal of empty faces is not performed during direct brush manipulations, because it would make a manipulation irreversible if it created an empty face.
2241   void removeEmptyFaces()
2242   {
2243     evaluateBRep();
2244
2245     {
2246       std::size_t i = 0;
2247       while(i < m_faces.size())
2248       {
2249         if(!m_faces[i]->contributes())
2250         {
2251           erase(i);
2252           planeChanged();
2253         }
2254         else
2255         {
2256           ++i;
2257         }
2258       }
2259     }
2260   }
2261
2262   /// \brief Constructs \p winding from the intersection of \p plane with the other planes of the brush.
2263   void windingForClipPlane(Winding& winding, const Plane3& plane) const
2264   {
2265     FixedWinding buffer[2];
2266     bool swap = false;
2267
2268     // get a poly that covers an effectively infinite area
2269     Winding_createInfinite(buffer[swap], plane, m_maxWorldCoord + 1);
2270
2271     // chop the poly by all of the other faces
2272     {
2273       for (std::size_t i = 0;  i < m_faces.size(); ++i)
2274       {
2275         const Face& clip = *m_faces[i];
2276
2277         if(plane3_equal(clip.plane3(), plane)
2278           || !plane3_valid(clip.plane3()) || !plane_unique(i)
2279           || plane3_opposing(plane, clip.plane3()))
2280         {
2281           continue;
2282         }
2283
2284         buffer[!swap].clear();
2285
2286 #if BRUSH_CONNECTIVITY_DEBUG
2287         globalOutputStream() << "clip vs face: " << i << "\n";
2288 #endif
2289
2290         {
2291           // flip the plane, because we want to keep the back side
2292           Plane3 clipPlane(vector3_negated(clip.plane3().normal()), -clip.plane3().dist());
2293           Winding_Clip(buffer[swap], plane, clipPlane, i, buffer[!swap]);
2294         }
2295
2296 #if BRUSH_CONNECTIVITY_DEBUG
2297         for(FixedWinding::Points::iterator k = buffer[!swap].points.begin(), j = buffer[!swap].points.end() - 1; k != buffer[!swap].points.end(); j = k, ++k)
2298         {
2299           if(vector3_length_squared(vector3_subtracted((*k).vertex, (*j).vertex)) < 1)
2300           {
2301             globalOutputStream() << "v: " << std::distance(buffer[!swap].points.begin(), j) << " tiny edge adjacent to face " << (*j).adjacent << "\n";
2302           }
2303         }
2304 #endif
2305
2306         //ASSERT_MESSAGE(buffer[!swap].numpoints != 1, "created single-point winding");
2307
2308         swap = !swap;
2309       }
2310     }
2311
2312     Winding_forFixedWinding(winding, buffer[swap]);
2313
2314 #if BRUSH_CONNECTIVITY_DEBUG
2315     Winding_printConnectivity(winding);
2316
2317     for(Winding::iterator i = winding.begin(), j = winding.end() - 1; i != winding.end(); j = i, ++i)
2318     {
2319       if(vector3_length_squared(vector3_subtracted((*i).vertex, (*j).vertex)) < 1)
2320       {
2321         globalOutputStream() << "v: " << std::distance(winding.begin(), j) << " tiny edge adjacent to face " << (*j).adjacent << "\n";
2322       }
2323     }
2324 #endif
2325   }
2326
2327   void update_wireframe(RenderableWireframe& wire, const bool* faces_visible) const
2328   {
2329     wire.m_faceVertex.resize(m_edge_indices.size());
2330     wire.m_vertices = m_uniqueVertexPoints.data();
2331     wire.m_size = 0;
2332     for(std::size_t i = 0; i < m_edge_faces.size(); ++i)
2333     {
2334       if(faces_visible[m_edge_faces[i].first]
2335         || faces_visible[m_edge_faces[i].second])
2336       {
2337         wire.m_faceVertex[wire.m_size++] = m_edge_indices[i];
2338       }
2339     }
2340   }
2341
2342
2343   void update_faces_wireframe(Array<PointVertex>& wire, const bool* faces_visible) const
2344   {
2345     std::size_t count = 0;
2346     for(std::size_t i = 0; i < m_faceCentroidPoints.size(); ++i)
2347     {
2348       if(faces_visible[i])
2349       {
2350         ++count;
2351       }
2352     }
2353
2354     wire.resize(count);
2355     Array<PointVertex>::iterator p = wire.begin();
2356     for(std::size_t i = 0; i < m_faceCentroidPoints.size(); ++i)
2357     {
2358       if(faces_visible[i])
2359       {
2360         *p++ = m_faceCentroidPoints[i];
2361       }
2362     }
2363   }
2364
2365   /// \brief Makes this brush a deep-copy of the \p other.
2366   void copy(const Brush& other)
2367   {
2368     for(Faces::const_iterator i = other.m_faces.begin(); i != other.m_faces.end(); ++i)
2369     {
2370       addFace(*(*i));
2371     }
2372     planeChanged();
2373   }
2374
2375 private:
2376   void edge_push_back(FaceVertexId faceVertex)
2377   {
2378     m_select_edges.push_back(SelectableEdge(m_faces, faceVertex));
2379     for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2380     {
2381       (*i)->edge_push_back(m_select_edges.back());
2382     }
2383   }
2384   void edge_clear()
2385   {
2386     m_select_edges.clear();
2387     for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2388     {
2389       (*i)->edge_clear();
2390     }
2391   }
2392   void vertex_push_back(FaceVertexId faceVertex)
2393   {
2394     m_select_vertices.push_back(SelectableVertex(m_faces, faceVertex));
2395     for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2396     {
2397       (*i)->vertex_push_back(m_select_vertices.back());
2398     }
2399   }
2400   void vertex_clear()
2401   {
2402     m_select_vertices.clear();
2403     for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2404     {
2405       (*i)->vertex_clear();
2406     }
2407   }
2408
2409   /// \brief Returns true if the face identified by \p index is preceded by another plane that takes priority over it.
2410   bool plane_unique(std::size_t index) const
2411   {
2412     // duplicate plane
2413     for(std::size_t i = 0; i < m_faces.size(); ++i)
2414     {
2415       if(index != i && !plane3_inside(m_faces[index]->plane3(), m_faces[i]->plane3()))
2416       {
2417         return false;
2418       }
2419     }
2420     return true;
2421   }
2422
2423   /// \brief Removes edges that are smaller than the tolerance used when generating brush windings.
2424   void removeDegenerateEdges()
2425   {
2426     for (std::size_t i = 0;  i < m_faces.size(); ++i)
2427     {
2428       Winding& winding = m_faces[i]->getWinding();
2429       for(Winding::iterator j = winding.begin(); j != winding.end();)
2430       {
2431         std::size_t index = std::distance(winding.begin(), j);
2432         std::size_t next = Winding_next(winding, index);
2433         if(Edge_isDegenerate(winding[index].vertex, winding[next].vertex))
2434         {
2435 #if BRUSH_DEGENERATE_DEBUG
2436           globalOutputStream() << "Brush::buildWindings: face " << i << ": degenerate edge adjacent to " << winding[index].adjacent << "\n";
2437 #endif
2438           Winding& other = m_faces[winding[index].adjacent]->getWinding();
2439           std::size_t adjacent = Winding_FindAdjacent(other, i);
2440           if(adjacent != c_brush_maxFaces)
2441           {
2442             other.erase(other.begin() + adjacent);
2443           }
2444           winding.erase(j);
2445         }
2446         else
2447         {
2448           ++j;
2449         }
2450       }
2451     }
2452   }
2453
2454   /// \brief Invalidates faces that have only two vertices in their winding, while preserving edge-connectivity information.
2455   void removeDegenerateFaces()
2456   {
2457     // save adjacency info for degenerate faces
2458     for (std::size_t i = 0;  i < m_faces.size(); ++i)
2459     {
2460       Winding& degen = m_faces[i]->getWinding();
2461
2462       if(degen.numpoints == 2)
2463       {
2464 #if BRUSH_DEGENERATE_DEBUG
2465         globalOutputStream() << "Brush::buildWindings: face " << i << ": degenerate winding adjacent to " << degen[0].adjacent << ", " << degen[1].adjacent << "\n";
2466 #endif
2467         // this is an "edge" face, where the plane touches the edge of the brush
2468         {
2469           Winding& winding = m_faces[degen[0].adjacent]->getWinding();
2470           std::size_t index = Winding_FindAdjacent(winding, i);
2471           if(index != c_brush_maxFaces)
2472           {
2473 #if BRUSH_DEGENERATE_DEBUG
2474             globalOutputStream() << "Brush::buildWindings: face " << degen[0].adjacent << ": remapping adjacent " << winding[index].adjacent << " to " << degen[1].adjacent << "\n";
2475 #endif
2476             winding[index].adjacent = degen[1].adjacent;
2477           }
2478         }
2479
2480         {
2481           Winding& winding = m_faces[degen[1].adjacent]->getWinding();
2482           std::size_t index = Winding_FindAdjacent(winding, i);
2483           if(index != c_brush_maxFaces)
2484           {
2485 #if BRUSH_DEGENERATE_DEBUG
2486             globalOutputStream() << "Brush::buildWindings: face " << degen[1].adjacent << ": remapping adjacent " << winding[index].adjacent << " to " << degen[0].adjacent << "\n";
2487 #endif
2488             winding[index].adjacent = degen[0].adjacent;
2489           }
2490         }
2491
2492         degen.resize(0);
2493       }
2494     }
2495   }
2496
2497   /// \brief Removes edges that have the same adjacent-face as their immediate neighbour.
2498   void removeDuplicateEdges()
2499   {
2500     // verify face connectivity graph
2501     for(std::size_t i = 0; i < m_faces.size(); ++i)
2502     {
2503       //if(m_faces[i]->contributes())
2504       {
2505         Winding& winding = m_faces[i]->getWinding();
2506         for(std::size_t j = 0; j != winding.numpoints;)
2507         {
2508           std::size_t next = Winding_next(winding, j);
2509           if(winding[j].adjacent == winding[next].adjacent)
2510           {
2511 #if BRUSH_DEGENERATE_DEBUG
2512             globalOutputStream() << "Brush::buildWindings: face " << i << ": removed duplicate edge adjacent to face " << winding[j].adjacent << "\n";
2513 #endif
2514             winding.erase(winding.begin() + next);
2515           }
2516           else
2517           {
2518             ++j;
2519           }
2520         }
2521       }
2522     }
2523   }
2524
2525   /// \brief Removes edges that do not have a matching pair in their adjacent-face.
2526   void verifyConnectivityGraph()
2527   {
2528     // verify face connectivity graph
2529     for(std::size_t i = 0; i < m_faces.size(); ++i)
2530     {
2531       //if(m_faces[i]->contributes())
2532       {
2533         Winding& winding = m_faces[i]->getWinding();
2534         for(Winding::iterator j = winding.begin(); j != winding.end();)
2535         {
2536 #if BRUSH_CONNECTIVITY_DEBUG
2537           globalOutputStream() << "Brush::buildWindings: face " << i << ": adjacent to face " << (*j).adjacent << "\n";
2538 #endif
2539           // remove unidirectional graph edges
2540           if((*j).adjacent == c_brush_maxFaces
2541             || Winding_FindAdjacent(m_faces[(*j).adjacent]->getWinding(), i) == c_brush_maxFaces)
2542           {
2543 #if BRUSH_CONNECTIVITY_DEBUG
2544             globalOutputStream() << "Brush::buildWindings: face " << i << ": removing unidirectional connectivity graph edge adjacent to face " << (*j).adjacent << "\n";
2545 #endif
2546             winding.erase(j);
2547           }
2548           else
2549           {
2550             ++j;
2551           }
2552         }
2553       }
2554     }
2555   }
2556
2557   /// \brief Returns true if the brush is a finite volume. A brush without a finite volume extends past the maximum world bounds and is not valid.
2558   bool isBounded()
2559   {
2560     for(const_iterator i = begin(); i != end(); ++i)
2561     {
2562       if(!(*i)->is_bounded())
2563       {
2564         return false;
2565       }
2566     }
2567     return true;
2568   }
2569
2570   /// \brief Constructs the polygon windings for each face of the brush. Also updates the brush bounding-box and face texture-coordinates.
2571   bool buildWindings()
2572   {
2573
2574     {
2575       m_aabb_local = AABB();
2576
2577       for (std::size_t i = 0;  i < m_faces.size(); ++i)
2578       {
2579         Face& f = *m_faces[i];
2580
2581         if(!plane3_valid(f.plane3()) || !plane_unique(i))
2582         {
2583           f.getWinding().resize(0);
2584         }
2585         else
2586         {
2587 #if BRUSH_CONNECTIVITY_DEBUG
2588           globalOutputStream() << "face: " << i << "\n";
2589 #endif
2590           windingForClipPlane(f.getWinding(), f.plane3());
2591
2592           // update brush bounds
2593           const Winding& winding = f.getWinding();
2594           for(Winding::const_iterator i = winding.begin(); i != winding.end(); ++i)
2595           {
2596             aabb_extend_by_point_safe(m_aabb_local, (*i).vertex);
2597           }
2598
2599           // update texture coordinates
2600           f.EmitTextureCoordinates();
2601         }
2602       }
2603     }
2604
2605     bool degenerate = !isBounded();
2606
2607     if(!degenerate)
2608     {
2609       // clean up connectivity information.
2610       // these cleanups must be applied in a specific order.
2611       removeDegenerateEdges();
2612       removeDegenerateFaces();
2613       removeDuplicateEdges();
2614       verifyConnectivityGraph();
2615     }
2616
2617     return degenerate;
2618   }
2619
2620   /// \brief Constructs the face windings and updates anything that depends on them.
2621   void buildBRep();
2622 };
2623
2624
2625
2626 class FaceInstance;
2627
2628 class FaceInstanceSet
2629 {
2630   typedef SelectionList<FaceInstance> FaceInstances;
2631   FaceInstances m_faceInstances;
2632 public:
2633   void insert(FaceInstance& faceInstance)
2634   {
2635     m_faceInstances.append(faceInstance);
2636   }
2637   void erase(FaceInstance& faceInstance)
2638   {
2639     m_faceInstances.erase(faceInstance);
2640   }
2641
2642   template<typename Functor>
2643   void foreach(Functor functor)
2644   {
2645     for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
2646     {
2647       functor(*(*i));
2648     }
2649   }
2650
2651   bool empty() const
2652   {
2653     return m_faceInstances.empty();
2654   }
2655   FaceInstance& last() const
2656   {
2657     return m_faceInstances.back();
2658   }
2659 };
2660
2661 extern FaceInstanceSet g_SelectedFaceInstances;
2662
2663 typedef std::list<std::size_t> VertexSelection;
2664
2665 inline VertexSelection::iterator VertexSelection_find(VertexSelection& self, std::size_t value)
2666 {
2667   return std::find(self.begin(), self.end(), value);
2668 }
2669
2670 inline VertexSelection::const_iterator VertexSelection_find(const VertexSelection& self, std::size_t value)
2671 {
2672   return std::find(self.begin(), self.end(), value);
2673 }
2674
2675 inline VertexSelection::iterator VertexSelection_insert(VertexSelection& self, std::size_t value)
2676 {
2677   VertexSelection::iterator i = VertexSelection_find(self, value);
2678   if(i == self.end())
2679   {
2680     self.push_back(value);
2681     return --self.end();
2682   }
2683   return i;
2684 }
2685 inline void VertexSelection_erase(VertexSelection& self, std::size_t value)
2686 {
2687   VertexSelection::iterator i = VertexSelection_find(self, value);
2688   if(i != self.end())
2689   {
2690     self.erase(i);
2691   }
2692 }
2693
2694 inline bool triangle_reversed(std::size_t x, std::size_t y, std::size_t z)
2695 {
2696   return !((x < y && y < z) || (z < x && x < y) || (y < z && z < x));
2697 }
2698 template<typename Element>
2699 inline Vector3 triangle_cross(const BasicVector3<Element>& x, const BasicVector3<Element> y, const BasicVector3<Element>& z)
2700 {
2701   return vector3_cross(y - x, z - x);
2702 }
2703 template<typename Element>
2704 inline bool triangles_same_winding(const BasicVector3<Element>& x1, const BasicVector3<Element> y1, const BasicVector3<Element>& z1, const BasicVector3<Element>& x2, const BasicVector3<Element> y2, const BasicVector3<Element>& z2)
2705 {
2706   return vector3_dot(triangle_cross(x1, y1, z1), triangle_cross(x2, y2, z2)) > 0;
2707 }
2708
2709
2710 typedef const Plane3* PlanePointer;
2711 typedef PlanePointer* PlanesIterator;
2712
2713 class VectorLightList : public LightList
2714 {
2715   typedef std::vector<const RendererLight*> Lights;
2716   Lights m_lights;
2717 public:
2718   void addLight(const RendererLight& light)
2719   {
2720     m_lights.push_back(&light);
2721   }
2722   void clear()
2723   {
2724     m_lights.clear();
2725   }
2726   void evaluateLights() const
2727   {
2728   }
2729   void lightsChanged() const
2730   {
2731   }
2732   void forEachLight(const RendererLightCallback& callback) const
2733   {
2734     for(Lights::const_iterator i = m_lights.begin(); i != m_lights.end(); ++i)
2735     {
2736       callback(*(*i));
2737     }
2738   }
2739 };
2740
2741 class FaceInstance
2742 {
2743   Face* m_face;
2744   ObservedSelectable m_selectable;
2745   ObservedSelectable m_selectableVertices;
2746   ObservedSelectable m_selectableEdges;
2747   SelectionChangeCallback m_selectionChanged;
2748
2749   VertexSelection m_vertexSelection;
2750   VertexSelection m_edgeSelection;
2751
2752 public:
2753   mutable VectorLightList m_lights;
2754
2755   FaceInstance(Face& face, const SelectionChangeCallback& observer) :
2756     m_face(&face),
2757     m_selectable(SelectedChangedCaller(*this)),
2758     m_selectableVertices(observer),
2759     m_selectableEdges(observer),
2760     m_selectionChanged(observer)
2761   {
2762   }
2763   FaceInstance(const FaceInstance& other) :
2764     m_face(other.m_face),
2765     m_selectable(SelectedChangedCaller(*this)),
2766     m_selectableVertices(other.m_selectableVertices),
2767     m_selectableEdges(other.m_selectableEdges),
2768     m_selectionChanged(other.m_selectionChanged)
2769   {
2770   }
2771   FaceInstance& operator=(const FaceInstance& other)
2772   {
2773     m_face = other.m_face;
2774     return *this;
2775   }
2776
2777   Face& getFace()
2778   {
2779     return *m_face;
2780   }
2781   const Face& getFace() const
2782   {
2783     return *m_face;
2784   }
2785
2786   void selectedChanged(const Selectable& selectable)
2787   {
2788     if(selectable.isSelected())
2789     {
2790       g_SelectedFaceInstances.insert(*this);
2791     }
2792     else
2793     {
2794       g_SelectedFaceInstances.erase(*this);
2795     }
2796     m_selectionChanged(selectable);
2797   }
2798   typedef MemberCaller1<FaceInstance, const Selectable&, &FaceInstance::selectedChanged> SelectedChangedCaller;
2799
2800   bool selectedVertices() const
2801   {
2802     return !m_vertexSelection.empty();
2803   }
2804   bool selectedEdges() const
2805   {
2806     return !m_edgeSelection.empty();
2807   }
2808   bool isSelected() const
2809   {
2810     return m_selectable.isSelected();
2811   }
2812
2813   bool selectedComponents() const
2814   {
2815     return selectedVertices() || selectedEdges() || isSelected();
2816   }
2817   bool selectedComponents(SelectionSystem::EComponentMode mode) const
2818   {
2819     switch(mode)
2820     {
2821     case SelectionSystem::eVertex:
2822       return selectedVertices();
2823     case SelectionSystem::eEdge:
2824       return selectedEdges();
2825     case SelectionSystem::eFace:
2826       return isSelected();
2827     default:
2828       return false;
2829     }
2830   }
2831   void setSelected(SelectionSystem::EComponentMode mode, bool select)
2832   {
2833     switch(mode)
2834     {
2835     case SelectionSystem::eFace:
2836       m_selectable.setSelected(select);
2837       break;
2838     case SelectionSystem::eVertex:
2839       ASSERT_MESSAGE(!select, "select-all not supported");
2840
2841       m_vertexSelection.clear();
2842       m_selectableVertices.setSelected(false);
2843       break;
2844     case SelectionSystem::eEdge:
2845       ASSERT_MESSAGE(!select, "select-all not supported");
2846
2847       m_edgeSelection.clear();
2848       m_selectableEdges.setSelected(false);
2849       break;
2850     default:
2851       break;
2852     }
2853   }
2854
2855   template<typename Functor>
2856   void SelectedVertices_foreach(Functor functor) const
2857   {
2858     for(VertexSelection::const_iterator i = m_vertexSelection.begin(); i != m_vertexSelection.end(); ++i)
2859     {
2860       std::size_t index = Winding_FindAdjacent(getFace().getWinding(), *i);
2861       if(index != c_brush_maxFaces)
2862       {
2863         functor(getFace().getWinding()[index].vertex);
2864       }
2865     }
2866   }
2867   template<typename Functor>
2868   void SelectedEdges_foreach(Functor functor) const
2869   {
2870     for(VertexSelection::const_iterator i = m_edgeSelection.begin(); i != m_edgeSelection.end(); ++i)
2871     {
2872       std::size_t index = Winding_FindAdjacent(getFace().getWinding(), *i);
2873       if(index != c_brush_maxFaces)
2874       {
2875         const Winding& winding = getFace().getWinding();
2876         std::size_t adjacent = Winding_next(winding, index);
2877         functor(vector3_mid(winding[index].vertex, winding[adjacent].vertex));
2878       }
2879     }
2880   }
2881   template<typename Functor>
2882   void SelectedFaces_foreach(Functor functor) const
2883   {
2884     if(isSelected())
2885     {
2886       functor(centroid());
2887     }
2888   }
2889
2890   template<typename Functor>
2891   void SelectedComponents_foreach(Functor functor) const
2892   {
2893     SelectedVertices_foreach(functor);
2894     SelectedEdges_foreach(functor);
2895     SelectedFaces_foreach(functor);
2896   }
2897
2898   void iterate_selected(AABB& aabb) const
2899   {
2900     SelectedComponents_foreach(AABBExtendByPoint(aabb));
2901   }
2902
2903   class RenderablePointVectorPushBack
2904   {
2905     RenderablePointVector& m_points;
2906   public:
2907     RenderablePointVectorPushBack(RenderablePointVector& points) : m_points(points)
2908     {
2909     }
2910     void operator()(const Vector3& point) const
2911     {
2912       const Colour4b colour_selected(0, 0, 255, 255);
2913       m_points.push_back(pointvertex_for_windingpoint(point, colour_selected));
2914     }
2915   };
2916
2917   void iterate_selected(RenderablePointVector& points) const
2918   {
2919     SelectedComponents_foreach(RenderablePointVectorPushBack(points));
2920   }
2921
2922   bool intersectVolume(const VolumeTest& volume, const Matrix4& localToWorld) const
2923   {
2924     return m_face->intersectVolume(volume, localToWorld);
2925   }
2926
2927   void render(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
2928   {
2929     if(!m_face->isFiltered() && m_face->contributes() && intersectVolume(volume, localToWorld))
2930     {
2931       renderer.PushState();
2932       if(selectedComponents())
2933       {
2934         renderer.Highlight(Renderer::eFace);
2935       }
2936       m_face->render(renderer, localToWorld);
2937       renderer.PopState();
2938     }
2939   }
2940
2941   void testSelect(SelectionTest& test, SelectionIntersection& best)
2942   {
2943     if(!m_face->isFiltered())
2944     {
2945       m_face->testSelect(test, best);
2946     }
2947   }
2948   void testSelect(Selector& selector, SelectionTest& test)
2949   {
2950     SelectionIntersection best;
2951     testSelect(test, best);
2952     if(best.valid())
2953     {
2954       Selector_add(selector, m_selectable, best);
2955     }
2956   }
2957   void testSelect_centroid(Selector& selector, SelectionTest& test)
2958   {
2959     if(m_face->contributes() && !m_face->isFiltered())
2960     {
2961       SelectionIntersection best;
2962       m_face->testSelect_centroid(test, best);
2963       if(best.valid())
2964       {
2965         Selector_add(selector, m_selectable, best);
2966       }
2967     }
2968   }
2969
2970   void selectPlane(Selector& selector, const Line& line, PlanesIterator first, PlanesIterator last, const PlaneCallback& selectedPlaneCallback)
2971   {
2972     for(Winding::const_iterator i = getFace().getWinding().begin(); i != getFace().getWinding().end(); ++i)
2973     {
2974       Vector3 v(vector3_subtracted(line_closest_point(line, (*i).vertex), (*i).vertex));
2975       double dot = vector3_dot(getFace().plane3().normal(), v);
2976       if(dot <= 0)
2977       {
2978         return;
2979       }
2980     }
2981
2982     Selector_add(selector, m_selectable);
2983
2984     selectedPlaneCallback(getFace().plane3());
2985   }
2986   void selectReversedPlane(Selector& selector, const SelectedPlanes& selectedPlanes)
2987   {
2988     if(selectedPlanes.contains(plane3_flipped(getFace().plane3())))
2989     {
2990       Selector_add(selector, m_selectable);
2991     }
2992   }
2993
2994   void transformComponents(const Matrix4& matrix)
2995   {
2996     if(isSelected())
2997     {
2998       m_face->transform(matrix, false);
2999     }
3000     if(selectedVertices())
3001     {
3002       if(m_vertexSelection.size() == 1)
3003       {
3004         matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[1]);
3005         m_face->assign_planepts(m_face->m_move_planeptsTransformed);
3006       }
3007       else if(m_vertexSelection.size() == 2)
3008       {
3009         matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[1]);
3010         matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[2]);
3011         m_face->assign_planepts(m_face->m_move_planeptsTransformed);
3012       }
3013       else if(m_vertexSelection.size() >= 3)
3014       {
3015         matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[0]);
3016         matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[1]);
3017         matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[2]);
3018         m_face->assign_planepts(m_face->m_move_planeptsTransformed);
3019       }
3020     }
3021     if(selectedEdges())
3022     {
3023       if(m_edgeSelection.size() == 1)
3024       {
3025         matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[0]);
3026         matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[1]);
3027         m_face->assign_planepts(m_face->m_move_planeptsTransformed);
3028       }
3029       else if(m_edgeSelection.size() >= 2)
3030       {
3031         matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[0]);
3032         matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[1]);
3033         matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[2]);
3034         m_face->assign_planepts(m_face->m_move_planeptsTransformed);
3035       }
3036     }
3037   }
3038
3039   void snapto(float snap)
3040   {
3041     m_face->snapto(snap);
3042   }
3043
3044   void snapComponents(float snap)
3045   {
3046     if(isSelected())
3047     {
3048       snapto(snap);
3049     }
3050     if(selectedVertices())
3051     {
3052       vector3_snap(m_face->m_move_planepts[0], snap);
3053       vector3_snap(m_face->m_move_planepts[1], snap);
3054       vector3_snap(m_face->m_move_planepts[2], snap);
3055       m_face->assign_planepts(m_face->m_move_planepts);
3056       planepts_assign(m_face->m_move_planeptsTransformed, m_face->m_move_planepts);
3057       m_face->freezeTransform();
3058     }
3059     if(selectedEdges())
3060     {
3061       vector3_snap(m_face->m_move_planepts[0], snap);
3062       vector3_snap(m_face->m_move_planepts[1], snap);
3063       vector3_snap(m_face->m_move_planepts[2], snap);
3064       m_face->assign_planepts(m_face->m_move_planepts);
3065       planepts_assign(m_face->m_move_planeptsTransformed, m_face->m_move_planepts);
3066       m_face->freezeTransform();
3067     }
3068   }
3069   void update_move_planepts_vertex(std::size_t index)
3070   {
3071     m_face->update_move_planepts_vertex(index, m_face->m_move_planepts);
3072   }
3073   void update_move_planepts_vertex2(std::size_t index, std::size_t other)
3074   {
3075     const std::size_t numpoints = m_face->getWinding().numpoints;
3076     ASSERT_MESSAGE(index < numpoints, "select_vertex: invalid index");
3077
3078     const std::size_t opposite = Winding_Opposite(m_face->getWinding(), index, other);
3079
3080     if(triangle_reversed(index, other, opposite))
3081     {
3082       std::swap(index, other);
3083     }
3084
3085     ASSERT_MESSAGE(
3086       triangles_same_winding(
3087         m_face->getWinding()[opposite].vertex,
3088         m_face->getWinding()[index].vertex,
3089         m_face->getWinding()[other].vertex,
3090         m_face->getWinding()[0].vertex,
3091         m_face->getWinding()[1].vertex,
3092         m_face->getWinding()[2].vertex
3093       ),
3094       "update_move_planepts_vertex2: error"
3095     )
3096
3097     m_face->m_move_planepts[0] = m_face->getWinding()[opposite].vertex;
3098     m_face->m_move_planepts[1] = m_face->getWinding()[index].vertex;
3099     m_face->m_move_planepts[2] = m_face->getWinding()[other].vertex;
3100     planepts_quantise(m_face->m_move_planepts, GRID_MIN); // winding points are very inaccurate
3101   }
3102   void update_selection_vertex()
3103   {
3104     if(m_vertexSelection.size() == 0)
3105     {
3106       m_selectableVertices.setSelected(false);
3107     }
3108     else
3109     {
3110       m_selectableVertices.setSelected(true);
3111
3112       if(m_vertexSelection.size() == 1)
3113       {
3114         std::size_t index = Winding_FindAdjacent(getFace().getWinding(), *m_vertexSelection.begin());
3115
3116         if(index != c_brush_maxFaces)
3117         {
3118           update_move_planepts_vertex(index);
3119         }
3120       }
3121       else if(m_vertexSelection.size() == 2)
3122       {
3123         std::size_t index = Winding_FindAdjacent(getFace().getWinding(), *m_vertexSelection.begin());
3124         std::size_t other = Winding_FindAdjacent(getFace().getWinding(), *(++m_vertexSelection.begin()));
3125
3126         if(index != c_brush_maxFaces
3127           && other != c_brush_maxFaces)
3128         {
3129           update_move_planepts_vertex2(index, other);
3130         }
3131       }
3132     }
3133   }
3134   void select_vertex(std::size_t index, bool select)
3135   {
3136     if(select)
3137     {
3138       VertexSelection_insert(m_vertexSelection, getFace().getWinding()[index].adjacent);
3139     }
3140     else
3141     {
3142       VertexSelection_erase(m_vertexSelection, getFace().getWinding()[index].adjacent);
3143     }
3144
3145     SceneChangeNotify();
3146     update_selection_vertex();
3147   }
3148
3149   bool selected_vertex(std::size_t index) const
3150   {
3151     return VertexSelection_find(m_vertexSelection, getFace().getWinding()[index].adjacent) != m_vertexSelection.end();
3152   }
3153
3154   void update_move_planepts_edge(std::size_t index)
3155   {
3156     std::size_t numpoints = m_face->getWinding().numpoints;
3157     ASSERT_MESSAGE(index < numpoints, "select_edge: invalid index");
3158
3159     std::size_t adjacent = Winding_next(m_face->getWinding(), index);
3160     std::size_t opposite = Winding_Opposite(m_face->getWinding(), index);
3161     m_face->m_move_planepts[0] = m_face->getWinding()[index].vertex;
3162     m_face->m_move_planepts[1] = m_face->getWinding()[adjacent].vertex;
3163     m_face->m_move_planepts[2] = m_face->getWinding()[opposite].vertex;
3164     planepts_quantise(m_face->m_move_planepts, GRID_MIN); // winding points are very inaccurate
3165   }
3166   void update_selection_edge()
3167   {
3168     if(m_edgeSelection.size() == 0)
3169     {
3170       m_selectableEdges.setSelected(false);
3171     }
3172     else
3173     {
3174       m_selectableEdges.setSelected(true);
3175
3176       if(m_edgeSelection.size() == 1)
3177       {
3178         std::size_t index = Winding_FindAdjacent(getFace().getWinding(), *m_edgeSelection.begin());
3179
3180         if(index != c_brush_maxFaces)
3181         {
3182           update_move_planepts_edge(index);
3183         }
3184       }
3185     }
3186   }
3187   void select_edge(std::size_t index, bool select)
3188   {
3189     if(select)
3190     {
3191       VertexSelection_insert(m_edgeSelection, getFace().getWinding()[index].adjacent);
3192     }
3193     else
3194     {
3195       VertexSelection_erase(m_edgeSelection, getFace().getWinding()[index].adjacent);
3196     }
3197
3198     SceneChangeNotify();
3199     update_selection_edge();
3200   }
3201
3202   bool selected_edge(std::size_t index) const
3203   {
3204     return VertexSelection_find(m_edgeSelection, getFace().getWinding()[index].adjacent) != m_edgeSelection.end();
3205   }
3206
3207   const Vector3& centroid() const
3208   {
3209     return m_face->centroid();
3210   }
3211
3212   void connectivityChanged()
3213   {
3214     // This occurs when a face is added or removed.
3215     // The current vertex and edge selections no longer valid and must be cleared.
3216     m_vertexSelection.clear();
3217     m_selectableVertices.setSelected(false);
3218     m_edgeSelection.clear();
3219     m_selectableEdges.setSelected(false);
3220   }
3221 };
3222
3223 class BrushClipPlane : public OpenGLRenderable
3224 {
3225   Plane3 m_plane;
3226   Winding m_winding;
3227   static Shader* m_state;
3228 public:
3229   static void constructStatic()
3230   {
3231     m_state = GlobalShaderCache().capture("$CLIPPER_OVERLAY");
3232   }
3233   static void destroyStatic()
3234   {
3235     GlobalShaderCache().release("$CLIPPER_OVERLAY");
3236   }
3237
3238   void setPlane(const Brush& brush, const Plane3& plane)
3239   {
3240     m_plane = plane;
3241     if(plane3_valid(m_plane))
3242     {
3243       brush.windingForClipPlane(m_winding, m_plane);
3244     }
3245     else
3246     {
3247       m_winding.resize(0);
3248     }
3249   }
3250
3251   void render(RenderStateFlags state) const
3252   {
3253     if((state & RENDER_FILL) != 0)
3254     {
3255       Winding_Draw(m_winding, m_plane.normal(), state);
3256     }
3257     else
3258     {
3259       Winding_DrawWireframe(m_winding);
3260     }
3261   }
3262
3263   void render(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
3264   {
3265     renderer.SetState(m_state, Renderer::eWireframeOnly);
3266     renderer.SetState(m_state, Renderer::eFullMaterials);
3267     renderer.addRenderable(*this, localToWorld);
3268   }
3269 };
3270
3271 inline void Face_addLight(const FaceInstance& face, const Matrix4& localToWorld, const RendererLight& light)
3272 {
3273   const Plane3& facePlane = face.getFace().plane3();
3274   const Vector3& origin = light.aabb().origin;
3275   Plane3 tmp(plane3_transformed(Plane3(facePlane.normal(), -facePlane.dist()), localToWorld));
3276   if(!plane3_test_point(tmp, origin)
3277     || !plane3_test_point(tmp, vector3_added(origin, light.offset())))
3278   {
3279     face.m_lights.addLight(light);
3280   }
3281 }
3282
3283
3284
3285 typedef std::vector<FaceInstance> FaceInstances;
3286
3287 class EdgeInstance : public Selectable
3288 {
3289   FaceInstances& m_faceInstances;
3290   SelectableEdge* m_edge;
3291
3292   void select_edge(bool select)
3293   {
3294     FaceVertexId faceVertex = m_edge->m_faceVertex;
3295     m_faceInstances[faceVertex.getFace()].select_edge(faceVertex.getVertex(), select);
3296     faceVertex = next_edge(m_edge->m_faces, faceVertex);
3297     m_faceInstances[faceVertex.getFace()].select_edge(faceVertex.getVertex(), select);
3298   }
3299   bool selected_edge() const
3300   {
3301     FaceVertexId faceVertex = m_edge->m_faceVertex;
3302     if(!m_faceInstances[faceVertex.getFace()].selected_edge(faceVertex.getVertex()))
3303     {
3304       return false;
3305     }
3306     faceVertex = next_edge(m_edge->m_faces, faceVertex);
3307     if(!m_faceInstances[faceVertex.getFace()].selected_edge(faceVertex.getVertex()))
3308     {
3309       return false;
3310     }
3311
3312     return true;
3313   }
3314
3315 public:
3316   EdgeInstance(FaceInstances& faceInstances, SelectableEdge& edge)
3317     : m_faceInstances(faceInstances), m_edge(&edge)
3318   {
3319   }
3320   EdgeInstance& operator=(const EdgeInstance& other)
3321   {
3322     m_edge = other.m_edge;
3323     return *this;
3324   }
3325
3326   void setSelected(bool select)
3327   {
3328     select_edge(select);
3329   }
3330   bool isSelected() const
3331   {
3332     return selected_edge();
3333   }
3334
3335
3336   void testSelect(Selector& selector, SelectionTest& test)
3337   {
3338     SelectionIntersection best;
3339     m_edge->testSelect(test, best);
3340     if(best.valid())
3341     {
3342       Selector_add(selector, *this, best);
3343     }
3344   }
3345 };
3346
3347 class VertexInstance : public Selectable
3348 {
3349   FaceInstances& m_faceInstances;
3350   SelectableVertex* m_vertex;
3351
3352   void select_vertex(bool select)
3353   {
3354     FaceVertexId faceVertex = m_vertex->m_faceVertex;
3355     do
3356     {
3357       m_faceInstances[faceVertex.getFace()].select_vertex(faceVertex.getVertex(), select);
3358       faceVertex = next_vertex(m_vertex->m_faces, faceVertex);
3359     }
3360     while(faceVertex.getFace() != m_vertex->m_faceVertex.getFace());
3361   }
3362   bool selected_vertex() const
3363   {
3364     FaceVertexId faceVertex = m_vertex->m_faceVertex;
3365     do
3366     {
3367       if(!m_faceInstances[faceVertex.getFace()].selected_vertex(faceVertex.getVertex()))
3368       {
3369         return false;
3370       }
3371       faceVertex = next_vertex(m_vertex->m_faces, faceVertex);
3372     }
3373     while(faceVertex.getFace() != m_vertex->m_faceVertex.getFace());
3374     return true;
3375   }
3376
3377 public:
3378   VertexInstance(FaceInstances& faceInstances, SelectableVertex& vertex)
3379     : m_faceInstances(faceInstances), m_vertex(&vertex)
3380   {
3381   }
3382   VertexInstance& operator=(const VertexInstance& other)
3383   {
3384     m_vertex = other.m_vertex;
3385     return *this;
3386   }
3387
3388   void setSelected(bool select)
3389   {
3390     select_vertex(select);
3391   }
3392   bool isSelected() const
3393   {
3394     return selected_vertex();
3395   }
3396
3397   void testSelect(Selector& selector, SelectionTest& test)
3398   {
3399     SelectionIntersection best;
3400     m_vertex->testSelect(test, best);
3401     if(best.valid())
3402     {
3403       Selector_add(selector, *this, best);
3404     }
3405   }
3406 };
3407
3408 class BrushInstanceVisitor
3409 {
3410 public:
3411   virtual void visit(FaceInstance& face) const = 0;
3412 };
3413
3414 class BrushInstance :
3415 public BrushObserver,
3416 public scene::Instance,
3417 public Selectable,
3418 public Renderable,
3419 public SelectionTestable,
3420 public ComponentSelectionTestable,
3421 public ComponentEditable,
3422 public ComponentSnappable,
3423 public PlaneSelectable,
3424 public LightCullable
3425 {
3426   class TypeCasts
3427   {
3428     InstanceTypeCastTable m_casts;
3429   public:
3430     TypeCasts()
3431     {
3432       InstanceStaticCast<BrushInstance, Selectable>::install(m_casts);
3433       InstanceContainedCast<BrushInstance, Bounded>::install(m_casts);
3434       InstanceContainedCast<BrushInstance, Cullable>::install(m_casts);
3435       InstanceStaticCast<BrushInstance, Renderable>::install(m_casts);
3436       InstanceStaticCast<BrushInstance, SelectionTestable>::install(m_casts);
3437       InstanceStaticCast<BrushInstance, ComponentSelectionTestable>::install(m_casts);
3438       InstanceStaticCast<BrushInstance, ComponentEditable>::install(m_casts);
3439       InstanceStaticCast<BrushInstance, ComponentSnappable>::install(m_casts);
3440       InstanceStaticCast<BrushInstance, PlaneSelectable>::install(m_casts);
3441       InstanceIdentityCast<BrushInstance>::install(m_casts);
3442       InstanceContainedCast<BrushInstance, Transformable>::install(m_casts);
3443     }
3444     InstanceTypeCastTable& get()
3445     {
3446       return m_casts;
3447     }
3448   };
3449
3450
3451   Brush& m_brush;
3452
3453   FaceInstances m_faceInstances;
3454
3455   typedef std::vector<EdgeInstance> EdgeInstances;
3456   EdgeInstances m_edgeInstances;
3457   typedef std::vector<VertexInstance> VertexInstances;
3458   VertexInstances m_vertexInstances;
3459
3460   ObservedSelectable m_selectable;
3461
3462   mutable RenderableWireframe m_render_wireframe;
3463   mutable RenderablePointVector m_render_selected;
3464   mutable AABB m_aabb_component;
3465   mutable Array<PointVertex> m_faceCentroidPointsCulled;
3466   RenderablePointArray m_render_faces_wireframe;
3467   mutable bool m_viewChanged; // requires re-evaluation of view-dependent cached data
3468
3469   BrushClipPlane m_clipPlane;
3470
3471   static Shader* m_state_selpoint;
3472
3473   const LightList* m_lightList;
3474
3475   TransformModifier m_transform;
3476
3477   BrushInstance(const BrushInstance& other); // NOT COPYABLE
3478   BrushInstance& operator=(const BrushInstance& other); // NOT ASSIGNABLE
3479 public:
3480   static Counter* m_counter;
3481
3482   typedef LazyStatic<TypeCasts> StaticTypeCasts;
3483
3484   void lightsChanged()
3485   {
3486     m_lightList->lightsChanged();
3487   }
3488   typedef MemberCaller<BrushInstance, &BrushInstance::lightsChanged> LightsChangedCaller;
3489
3490   STRING_CONSTANT(Name, "BrushInstance");
3491
3492   BrushInstance(const scene::Path& path, scene::Instance* parent, Brush& brush) :
3493     Instance(path, parent, this, StaticTypeCasts::instance().get()),
3494     m_brush(brush),
3495     m_selectable(SelectedChangedCaller(*this)),
3496     m_render_selected(GL_POINTS),
3497     m_render_faces_wireframe(m_faceCentroidPointsCulled, GL_POINTS),
3498     m_viewChanged(false),
3499     m_transform(Brush::TransformChangedCaller(m_brush), ApplyTransformCaller(*this))
3500   {
3501     m_brush.instanceAttach(Instance::path());
3502     m_brush.attach(*this);
3503     m_counter->increment();
3504
3505     m_lightList = &GlobalShaderCache().attach(*this);
3506     m_brush.m_lightsChanged = LightsChangedCaller(*this); ///\todo Make this work with instancing.
3507
3508     Instance::setTransformChangedCallback(LightsChangedCaller(*this));
3509   }
3510   ~BrushInstance()
3511   {
3512     Instance::setTransformChangedCallback(Callback());
3513
3514     m_brush.m_lightsChanged = Callback();
3515     GlobalShaderCache().detach(*this);
3516
3517     m_counter->decrement();
3518     m_brush.detach(*this);
3519     m_brush.instanceDetach(Instance::path());
3520   }
3521
3522   Brush& getBrush()
3523   {
3524     return m_brush;
3525   }
3526   const Brush& getBrush() const
3527   {
3528     return m_brush;
3529   }
3530
3531   Bounded& get(NullType<Bounded>)
3532   {
3533     return m_brush;
3534   }
3535   Cullable& get(NullType<Cullable>)
3536   {
3537     return m_brush;
3538   }
3539   Transformable& get(NullType<Transformable>)
3540   {
3541     return m_transform;
3542   }
3543
3544   void selectedChanged(const Selectable& selectable)
3545   {
3546     GlobalSelectionSystem().getObserver(SelectionSystem::ePrimitive)(selectable);
3547     GlobalSelectionSystem().onSelectedChanged(*this, selectable);
3548
3549     Instance::selectedChanged();
3550   }
3551   typedef MemberCaller1<BrushInstance, const Selectable&, &BrushInstance::selectedChanged> SelectedChangedCaller;
3552
3553   void selectedChangedComponent(const Selectable& selectable)
3554   {
3555     GlobalSelectionSystem().getObserver(SelectionSystem::eComponent)(selectable);
3556     GlobalSelectionSystem().onComponentSelection(*this, selectable);
3557   }
3558   typedef MemberCaller1<BrushInstance, const Selectable&, &BrushInstance::selectedChangedComponent> SelectedChangedComponentCaller;
3559
3560   void forEachFaceInstance(const BrushInstanceVisitor& visitor)
3561   {
3562     for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3563     {
3564       visitor.visit(*i);
3565     }
3566   }
3567
3568   static void constructStatic()
3569   {
3570     m_state_selpoint = GlobalShaderCache().capture("$SELPOINT");
3571   }
3572   static void destroyStatic()
3573   {
3574     GlobalShaderCache().release("$SELPOINT");
3575   }
3576
3577   void clear()
3578   {
3579     m_faceInstances.clear();
3580   }
3581   void reserve(std::size_t size)
3582   {
3583     m_faceInstances.reserve(size);
3584   }
3585
3586   void push_back(Face& face)
3587   {
3588     m_faceInstances.push_back(FaceInstance(face, SelectedChangedComponentCaller(*this)));
3589   }
3590   void pop_back()
3591   {
3592     ASSERT_MESSAGE(!m_faceInstances.empty(), "erasing invalid element");
3593     m_faceInstances.pop_back();
3594   }
3595   void erase(std::size_t index)
3596   {
3597     ASSERT_MESSAGE(index < m_faceInstances.size(), "erasing invalid element");
3598     m_faceInstances.erase(m_faceInstances.begin() + index);
3599   }
3600   void connectivityChanged()
3601   {
3602     for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3603     {
3604       (*i).connectivityChanged();
3605     }
3606   }
3607
3608   void edge_clear()
3609   {
3610     m_edgeInstances.clear();
3611   }
3612   void edge_push_back(SelectableEdge& edge)
3613   {
3614     m_edgeInstances.push_back(EdgeInstance(m_faceInstances, edge));
3615   }
3616
3617   void vertex_clear()
3618   {
3619     m_vertexInstances.clear();
3620   }
3621   void vertex_push_back(SelectableVertex& vertex)
3622   {
3623     m_vertexInstances.push_back(VertexInstance(m_faceInstances, vertex));
3624   }
3625
3626   void DEBUG_verify() const
3627   {
3628     ASSERT_MESSAGE(m_faceInstances.size() == m_brush.DEBUG_size(), "FATAL: mismatch");
3629   }
3630
3631   bool isSelected() const
3632   {
3633     return m_selectable.isSelected();
3634   }
3635   void setSelected(bool select)
3636   {
3637     m_selectable.setSelected(select);
3638   }
3639
3640   void update_selected() const
3641   {
3642     m_render_selected.clear();
3643     for(FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3644     {
3645       if((*i).getFace().contributes())
3646       {
3647         (*i).iterate_selected(m_render_selected);
3648       }
3649     }
3650   }
3651
3652   void evaluateViewDependent(const VolumeTest& volume, const Matrix4& localToWorld) const
3653   {
3654     if(m_viewChanged)
3655     {
3656       m_viewChanged = false;
3657
3658       bool faces_visible[c_brush_maxFaces];
3659       {
3660         bool* j = faces_visible;
3661         for(FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i, ++j)
3662         {
3663           *j = (*i).intersectVolume(volume, localToWorld);
3664         }
3665       }
3666
3667       m_brush.update_wireframe(m_render_wireframe, faces_visible);
3668       m_brush.update_faces_wireframe(m_faceCentroidPointsCulled, faces_visible);
3669     }
3670   }
3671
3672   void renderComponentsSelected(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
3673   {
3674     m_brush.evaluateBRep();
3675
3676     update_selected();
3677     if(!m_render_selected.empty())
3678     {
3679       renderer.Highlight(Renderer::ePrimitive, false);
3680       renderer.SetState(m_state_selpoint, Renderer::eWireframeOnly);
3681       renderer.SetState(m_state_selpoint, Renderer::eFullMaterials);
3682       renderer.addRenderable(m_render_selected, localToWorld);
3683     }
3684   }
3685
3686   void renderComponents(Renderer& renderer, const VolumeTest& volume) const
3687   {
3688     m_brush.evaluateBRep();
3689
3690     const Matrix4& localToWorld = Instance::localToWorld();
3691
3692     renderer.SetState(m_brush.m_state_point, Renderer::eWireframeOnly);
3693     renderer.SetState(m_brush.m_state_point, Renderer::eFullMaterials);
3694
3695     if(volume.fill() && GlobalSelectionSystem().ComponentMode() == SelectionSystem::eFace)
3696     {
3697       evaluateViewDependent(volume, localToWorld);
3698       renderer.addRenderable(m_render_faces_wireframe, localToWorld);
3699     }
3700     else
3701     {
3702       m_brush.renderComponents(GlobalSelectionSystem().ComponentMode(), renderer, volume, localToWorld);
3703     }
3704   }
3705
3706   void renderClipPlane(Renderer& renderer, const VolumeTest& volume) const
3707   {
3708     if(GlobalSelectionSystem().ManipulatorMode() == SelectionSystem::eClip && isSelected())
3709     {
3710       m_clipPlane.render(renderer, volume, localToWorld());
3711     }
3712   }
3713
3714   void renderCommon(Renderer& renderer, const VolumeTest& volume) const
3715   {
3716     bool componentMode = GlobalSelectionSystem().Mode() == SelectionSystem::eComponent;
3717
3718     if(componentMode && isSelected())
3719     {
3720       renderComponents(renderer, volume);
3721     }
3722
3723     if(parentSelected())
3724     {
3725       if(!componentMode)
3726       {
3727         renderer.Highlight(Renderer::eFace);
3728       }
3729       renderer.Highlight(Renderer::ePrimitive);
3730     }
3731   }
3732
3733   void renderSolid(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
3734   {
3735     //renderCommon(renderer, volume);
3736
3737     m_lightList->evaluateLights();
3738
3739     for(FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3740     {
3741       renderer.setLights((*i).m_lights);
3742       (*i).render(renderer, volume, localToWorld);
3743     }
3744
3745     renderComponentsSelected(renderer, volume, localToWorld);
3746   }
3747
3748   void renderWireframe(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
3749   {
3750     //renderCommon(renderer, volume);
3751
3752     evaluateViewDependent(volume, localToWorld);
3753
3754     if(m_render_wireframe.m_size != 0)
3755     {
3756       renderer.addRenderable(m_render_wireframe, localToWorld);
3757     }
3758
3759     renderComponentsSelected(renderer, volume, localToWorld);
3760   }
3761
3762   void renderSolid(Renderer& renderer, const VolumeTest& volume) const
3763   {
3764     m_brush.evaluateBRep();
3765
3766     renderClipPlane(renderer, volume);
3767
3768     renderSolid(renderer, volume, localToWorld());
3769   }
3770
3771   void renderWireframe(Renderer& renderer, const VolumeTest& volume) const
3772   {
3773     m_brush.evaluateBRep();
3774
3775     renderClipPlane(renderer, volume);
3776
3777     renderWireframe(renderer, volume, localToWorld());
3778   }
3779
3780   void viewChanged() const
3781   {
3782     m_viewChanged = true;
3783   }
3784
3785   void testSelect(Selector& selector, SelectionTest& test)
3786   {
3787     test.BeginMesh(localToWorld());
3788
3789     SelectionIntersection best;
3790     for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3791     {
3792       (*i).testSelect(test, best);
3793     }
3794     if(best.valid())
3795     {
3796       selector.addIntersection(best);
3797     }
3798   }
3799
3800   bool isSelectedComponents() const
3801   {
3802     for(FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3803     {
3804       if((*i).selectedComponents())
3805       {
3806         return true;
3807       }
3808     }
3809     return false;
3810   }
3811   void setSelectedComponents(bool select, SelectionSystem::EComponentMode mode)
3812   {
3813     for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3814     {
3815       (*i).setSelected(mode, select);
3816     }
3817   }
3818   void testSelectComponents(Selector& selector, SelectionTest& test, SelectionSystem::EComponentMode mode)
3819   {
3820     test.BeginMesh(localToWorld());
3821
3822     switch(mode)
3823     {
3824     case SelectionSystem::eVertex:
3825       {
3826         for(VertexInstances::iterator i = m_vertexInstances.begin(); i != m_vertexInstances.end(); ++i)
3827         {
3828           (*i).testSelect(selector, test);
3829         }
3830       }
3831       break;
3832     case SelectionSystem::eEdge:
3833       {
3834         for(EdgeInstances::iterator i = m_edgeInstances.begin(); i != m_edgeInstances.end(); ++i)
3835         {
3836           (*i).testSelect(selector, test);
3837         }
3838       }
3839       break;
3840     case SelectionSystem::eFace:
3841       {
3842         if(test.getVolume().fill())
3843         {
3844           for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3845           {
3846             (*i).testSelect(selector, test);
3847           }
3848         }
3849         else
3850         {
3851           for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3852           {
3853             (*i).testSelect_centroid(selector, test);
3854           }
3855         }
3856       }
3857       break;
3858     default:
3859       break;
3860     }
3861   }
3862
3863   void selectPlanes(Selector& selector, SelectionTest& test, const PlaneCallback& selectedPlaneCallback)
3864   {
3865     test.BeginMesh(localToWorld());
3866
3867     PlanePointer brushPlanes[c_brush_maxFaces];
3868     PlanesIterator j = brushPlanes;
3869
3870     for(Brush::const_iterator i = m_brush.begin(); i != m_brush.end(); ++i)
3871     {
3872       *j++ = &(*i)->plane3();
3873     }
3874
3875     for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3876     {
3877       (*i).selectPlane(selector, Line(test.getNear(), test.getFar()), brushPlanes, j, selectedPlaneCallback);
3878     }
3879   }
3880   void selectReversedPlanes(Selector& selector, const SelectedPlanes& selectedPlanes)
3881   {
3882     for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3883     {
3884       (*i).selectReversedPlane(selector, selectedPlanes);
3885     }
3886   }
3887
3888
3889   void transformComponents(const Matrix4& matrix)
3890   {
3891     for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3892     {
3893       (*i).transformComponents(matrix);
3894     }
3895   }
3896   const AABB& getSelectedComponentsBounds() const
3897   {
3898     m_aabb_component = AABB();
3899
3900     for(FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3901     {
3902       (*i).iterate_selected(m_aabb_component);
3903     }
3904
3905     return m_aabb_component;
3906   }
3907
3908   void snapComponents(float snap)
3909   {
3910     for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3911     {
3912       (*i).snapComponents(snap);
3913     }
3914   }
3915   void evaluateTransform()
3916   {
3917     Matrix4 matrix(m_transform.calculateTransform());
3918     //globalOutputStream() << "matrix: " << matrix << "\n";
3919
3920     if(m_transform.getType() == TRANSFORM_PRIMITIVE)
3921     {
3922       m_brush.transform(matrix);
3923     }
3924     else
3925     {
3926       transformComponents(matrix);
3927     }
3928   }
3929   void applyTransform()
3930   {
3931     m_brush.revertTransform();
3932     evaluateTransform();
3933     m_brush.freezeTransform();
3934   }
3935   typedef MemberCaller<BrushInstance, &BrushInstance::applyTransform> ApplyTransformCaller;
3936
3937   void setClipPlane(const Plane3& plane)
3938   {
3939     m_clipPlane.setPlane(m_brush, plane);
3940   }
3941
3942   bool testLight(const RendererLight& light) const
3943   {
3944     return light.testAABB(worldAABB());
3945   }
3946   void insertLight(const RendererLight& light)
3947   {
3948     const Matrix4& localToWorld = Instance::localToWorld();
3949     for(FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3950     {
3951       Face_addLight(*i, localToWorld, light);
3952     }
3953   }
3954   void clearLights()
3955   {
3956     for(FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3957     {
3958       (*i).m_lights.clear();
3959     }
3960   }
3961 };
3962
3963 inline BrushInstance* Instance_getBrush(scene::Instance& instance)
3964 {
3965   return InstanceTypeCast<BrushInstance>::cast(instance);
3966 }
3967
3968
3969 template<typename Functor>
3970 class BrushSelectedVisitor : public SelectionSystem::Visitor
3971 {
3972   const Functor& m_functor;
3973 public:
3974   BrushSelectedVisitor(const Functor& functor) : m_functor(functor)
3975   {
3976   }
3977   void visit(scene::Instance& instance) const
3978   {
3979     BrushInstance* brush = Instance_getBrush(instance);
3980     if(brush != 0)
3981     {
3982       m_functor(*brush);
3983     }
3984   }
3985 };
3986
3987 template<typename Functor>
3988 inline void Scene_forEachSelectedBrush(const Functor& functor)
3989 {
3990   GlobalSelectionSystem().foreachSelected(BrushSelectedVisitor<Functor>(functor));
3991 }
3992
3993 template<typename Functor>
3994 class BrushVisibleSelectedVisitor : public SelectionSystem::Visitor
3995 {
3996   const Functor& m_functor;
3997 public:
3998   BrushVisibleSelectedVisitor(const Functor& functor) : m_functor(functor)
3999   {
4000   }
4001   void visit(scene::Instance& instance) const
4002   {
4003     BrushInstance* brush = Instance_getBrush(instance);
4004     if(brush != 0
4005       && instance.path().top().get().visible())
4006     {
4007       m_functor(*brush);
4008     }
4009   }
4010 };
4011
4012 template<typename Functor>
4013 inline void Scene_forEachVisibleSelectedBrush(const Functor& functor)
4014 {
4015   GlobalSelectionSystem().foreachSelected(BrushVisibleSelectedVisitor<Functor>(functor));
4016 }
4017
4018 #endif