various: reindent classes
authorAntoine Fontaine <antoine.fontaine@epfl.ch>
Sun, 21 Mar 2021 02:51:11 +0000 (03:51 +0100)
committerAntoine Fontaine <antoine.fontaine@epfl.ch>
Tue, 23 Mar 2021 12:34:41 +0000 (13:34 +0100)
libs/eclasslib.h
libs/entitylib.h
libs/splines/math_angles.h
libs/splines/math_quaternion.h
libs/splines/math_vector.h
libs/string/string.h
radiant/brush.h
radiant/mru.cpp

index 2a92fcdb738fcdd2fb14cf5a5027b5d9663c6c8e..a733676a81d4faa559c59e6c1f5e0f08a4b2ce9f 100644 (file)
@@ -38,48 +38,48 @@ typedef Vector3 Colour3;
 
 class ListAttributeType
 {
-using ListItem = std::pair<CopiedString, CopiedString>;
-using ListItems = std::vector<ListItem>;
-ListItems m_items;
+       using ListItem = std::pair<CopiedString, CopiedString>;
+       using ListItems = std::vector<ListItem>;
+       ListItems m_items;
 public:
 
-typedef ListItems::const_iterator const_iterator;
-const_iterator begin() const {
-       return m_items.begin();
-}
-const_iterator end() const {
-       return m_items.end();
-}
+       typedef ListItems::const_iterator const_iterator;
+       const_iterator begin() const {
+               return m_items.begin();
+       }
+       const_iterator end() const {
+               return m_items.end();
+       }
 
-const ListItem& operator[]( std::size_t i ) const {
-       return m_items[i];
-}
-const_iterator findValue( const char* value ) const {
-       for ( ListItems::const_iterator i = m_items.begin(); i != m_items.end(); ++i )
-       {
-               if ( string_equal( value, ( *i ).second.c_str() ) ) {
-                       return i;
+       const ListItem& operator[]( std::size_t i ) const {
+               return m_items[i];
+       }
+       const_iterator findValue( const char* value ) const {
+               for ( ListItems::const_iterator i = m_items.begin(); i != m_items.end(); ++i )
+               {
+                       if ( string_equal( value, ( *i ).second.c_str() ) ) {
+                               return i;
+                       }
                }
+               return m_items.end();
        }
-       return m_items.end();
-}
 
-void push_back( const char* name, const char* value ){
-       m_items.push_back( ListItems::value_type( name, value ) );
-}
+       void push_back( const char* name, const char* value ){
+               m_items.push_back( ListItems::value_type( name, value ) );
+       }
 };
 
 class EntityClassAttribute
 {
-public:
-CopiedString m_type;
-CopiedString m_name;
-CopiedString m_value;
-CopiedString m_description;
-EntityClassAttribute(){
-}
-EntityClassAttribute( const char* type, const char* name, const char* value = "", const char* description = "" ) : m_type( type ), m_name( name ), m_value( value ), m_description( description ){
-}
+       public:
+               CopiedString m_type;
+               CopiedString m_name;
+               CopiedString m_value;
+               CopiedString m_description;
+               EntityClassAttribute(){
+               }
+               EntityClassAttribute( const char* type, const char* name, const char* value = "", const char* description = "" ) : m_type( type ), m_name( name ), m_value( value ), m_description( description ){
+               }
 };
 
 typedef std::pair<CopiedString, EntityClassAttribute> EntityClassAttributePair;
@@ -103,44 +103,44 @@ inline const char* EntityClassAttributePair_getDescription( const EntityClassAtt
 class EntityClass
 {
 public:
-CopiedString m_name;
-StringList m_parent;
-bool fixedsize;
-bool unknown;               // wasn't found in source
-Vector3 mins;
-Vector3 maxs;
+       CopiedString m_name;
+       StringList m_parent;
+       bool fixedsize;
+       bool unknown;               // wasn't found in source
+       Vector3 mins;
+       Vector3 maxs;
 
-Colour3 color;
-Shader* m_state_fill;
-Shader* m_state_wire;
-Shader* m_state_blend;
+       Colour3 color;
+       Shader* m_state_fill;
+       Shader* m_state_wire;
+       Shader* m_state_blend;
 
-CopiedString m_comments;
-char flagnames[MAX_FLAGS][32];
+       CopiedString m_comments;
+       char flagnames[MAX_FLAGS][32];
 
-CopiedString m_modelpath;
-CopiedString m_skin;
+       CopiedString m_modelpath;
+       CopiedString m_skin;
 
-void ( *free )( EntityClass* );
+       void ( *free )( EntityClass* );
 
-EntityClassAttributes m_attributes;
+       EntityClassAttributes m_attributes;
 
-bool inheritanceResolved;
-bool sizeSpecified;
-bool colorSpecified;
+       bool inheritanceResolved;
+       bool sizeSpecified;
+       bool colorSpecified;
 
-const char* name() const {
-       return m_name.c_str();
-}
-const char* comments() const {
-       return m_comments.c_str();
-}
-const char* modelpath() const {
-       return m_modelpath.c_str();
-}
-const char* skin() const {
-       return m_skin.c_str();
-}
+       const char* name() const {
+               return m_name.c_str();
+       }
+       const char* comments() const {
+               return m_comments.c_str();
+       }
+       const char* modelpath() const {
+               return m_modelpath.c_str();
+       }
+       const char* skin() const {
+               return m_skin.c_str();
+       }
 };
 
 inline const char* EntityClass_valueForKey( const EntityClass& entityClass, const char* key ){
index 83f35f02ea959b758f4f9afbfa0cc587aee44fa2..87ac4fe50a6abac065984d44134316ecdf6bd06b 100644 (file)
@@ -293,80 +293,80 @@ void render( RenderStateFlags state ) const {
 /// - Provides undo support through the global undo system.
 class KeyValue : public EntityKeyValue
 {
-typedef UnsortedSet<KeyObserver> KeyObservers;
-
-std::size_t m_refcount;
-KeyObservers m_observers;
-CopiedString m_string;
-const char* m_empty;
-ObservedUndoableObject<CopiedString> m_undo;
-static EntityCreator::KeyValueChangedFunc m_entityKeyValueChanged;
-public:
+       typedef UnsortedSet<KeyObserver> KeyObservers;
 
-KeyValue( const char* string, const char* empty )
-       : m_refcount( 0 ), m_string( string ), m_empty( empty ), m_undo( m_string, UndoImportCaller( *this ) ){
-       notify();
-}
-~KeyValue(){
-       ASSERT_MESSAGE( m_observers.empty(), "KeyValue::~KeyValue: observers still attached" );
-}
+       std::size_t m_refcount;
+       KeyObservers m_observers;
+       CopiedString m_string;
+       const char* m_empty;
+       ObservedUndoableObject<CopiedString> m_undo;
+       static EntityCreator::KeyValueChangedFunc m_entityKeyValueChanged;
 
-static void setKeyValueChangedFunc( EntityCreator::KeyValueChangedFunc func ){
-       m_entityKeyValueChanged = func;
-}
+public:
+       KeyValue( const char* string, const char* empty )
+               : m_refcount( 0 ), m_string( string ), m_empty( empty ), m_undo( m_string, UndoImportCaller( *this ) ){
+               notify();
+       }
+       ~KeyValue(){
+               ASSERT_MESSAGE( m_observers.empty(), "KeyValue::~KeyValue: observers still attached" );
+       }
 
-void IncRef(){
-       ++m_refcount;
-}
-void DecRef(){
-       if ( --m_refcount == 0 ) {
-               delete this;
+       static void setKeyValueChangedFunc( EntityCreator::KeyValueChangedFunc func ){
+               m_entityKeyValueChanged = func;
        }
-}
 
-void instanceAttach( MapFile* map ){
-       m_undo.instanceAttach( map );
-}
-void instanceDetach( MapFile* map ){
-       m_undo.instanceDetach( map );
-}
+       void IncRef(){
+               ++m_refcount;
+       }
+       void DecRef(){
+               if ( --m_refcount == 0 ) {
+                       delete this;
+               }
+       }
 
-void attach( const KeyObserver& observer ){
-       ( *m_observers.insert ( observer ) )( c_str() );
-}
-void detach( const KeyObserver& observer ){
-       observer( m_empty );
-       m_observers.erase( observer );
-}
-const char* c_str() const {
-       if ( string_empty( m_string.c_str() ) ) {
-               return m_empty;
+       void instanceAttach( MapFile* map ){
+               m_undo.instanceAttach( map );
        }
-       return m_string.c_str();
-}
-void assign( const char* other ){
-       if ( !string_equal( m_string.c_str(), other ) ) {
-               m_undo.save();
-               m_string = other;
-               notify();
+       void instanceDetach( MapFile* map ){
+               m_undo.instanceDetach( map );
        }
-}
 
-void notify(){
-       m_entityKeyValueChanged();
-       KeyObservers::reverse_iterator i = m_observers.rbegin();
-       while ( i != m_observers.rend() )
-       {
-               ( *i++ )( c_str() );
+       void attach( const KeyObserver& observer ){
+               ( *m_observers.insert ( observer ) )( c_str() );
+       }
+       void detach( const KeyObserver& observer ){
+               observer( m_empty );
+               m_observers.erase( observer );
+       }
+       const char* c_str() const {
+               if ( string_empty( m_string.c_str() ) ) {
+                       return m_empty;
+               }
+               return m_string.c_str();
+       }
+       void assign( const char* other ){
+               if ( !string_equal( m_string.c_str(), other ) ) {
+                       m_undo.save();
+                       m_string = other;
+                       notify();
+               }
+       }
+
+       void notify(){
+               m_entityKeyValueChanged();
+               KeyObservers::reverse_iterator i = m_observers.rbegin();
+               while ( i != m_observers.rend() )
+               {
+                       ( *i++ )( c_str() );
+               }
        }
-}
 
-void importState( const CopiedString& string ){
-       m_string = string;
+       void importState( const CopiedString& string ){
+               m_string = string;
 
-       notify();
-}
-typedef MemberCaller<KeyValue, void(const CopiedString&), &KeyValue::importState> UndoImportCaller;
+               notify();
+       }
+       typedef MemberCaller<KeyValue, void(const CopiedString&), &KeyValue::importState> UndoImportCaller;
 };
 
 /// \brief An unsorted list of key/value pairs.
index f356b56943555d5586116163e983d4ad3b4cb2ff..ee1d1f82bb9d90ebe2167d97862bd9bf2071fca2 100644 (file)
@@ -34,50 +34,50 @@ typedef idVec3 &vec3_p;
 
 class angles_t {
 public:
-float pitch;
-float yaw;
-float roll;
+       float pitch;
+       float yaw;
+       float roll;
 
-angles_t();
-angles_t( float pitch, float yaw, float roll );
-angles_t( const idVec3 &vec );
+       angles_t();
+       angles_t( float pitch, float yaw, float roll );
+       angles_t( const idVec3 &vec );
 
-friend void     toAngles( idVec3 &src, angles_t &dst );
-friend void     toAngles( quat_t &src, angles_t &dst );
-friend void     toAngles( mat3_t &src, angles_t &dst );
+       friend void     toAngles( idVec3 &src, angles_t &dst );
+       friend void     toAngles( quat_t &src, angles_t &dst );
+       friend void     toAngles( mat3_t &src, angles_t &dst );
 
-operator vec3_p();
+       operator vec3_p();
 
-float operator[]( int index ) const;
-float&          operator[]( int index );
+       float operator[]( int index ) const;
+       float&          operator[]( int index );
 
-void            set( float pitch, float yaw, float roll );
+       void            set( float pitch, float yaw, float roll );
 
-void operator=( angles_t const &a );
-void operator=( idVec3 const &a );
+       void operator=( angles_t const &a );
+       void operator=( idVec3 const &a );
 
-friend angles_t operator+( const angles_t &a, const angles_t &b );
-angles_t        &operator+=( angles_t const &a );
-angles_t        &operator+=( idVec3 const &a );
+       friend angles_t operator+( const angles_t &a, const angles_t &b );
+       angles_t        &operator+=( angles_t const &a );
+       angles_t        &operator+=( idVec3 const &a );
 
-friend angles_t operator-( angles_t &a, angles_t &b );
-angles_t        &operator-=( angles_t &a );
+       friend angles_t operator-( angles_t &a, angles_t &b );
+       angles_t        &operator-=( angles_t &a );
 
-friend angles_t operator*( const angles_t &a, float b );
-friend angles_t operator*( float a, const angles_t &b );
-angles_t        &operator*=( float a );
+       friend angles_t operator*( const angles_t &a, float b );
+       friend angles_t operator*( float a, const angles_t &b );
+       angles_t        &operator*=( float a );
 
-friend int operator==( angles_t &a, angles_t &b );
+       friend int operator==( angles_t &a, angles_t &b );
 
-friend int operator!=( angles_t &a, angles_t &b );
+       friend int operator!=( angles_t &a, angles_t &b );
 
-void            toVectors( idVec3 *forward, idVec3 *right = NULL, idVec3 *up = NULL );
-idVec3          toForward( void );
+       void            toVectors( idVec3 *forward, idVec3 *right = NULL, idVec3 *up = NULL );
+       idVec3          toForward( void );
 
-angles_t        &Zero( void );
+       angles_t        &Zero( void );
 
-angles_t        &Normalize360( void );
-angles_t        &Normalize180( void );
+       angles_t        &Normalize360( void );
+       angles_t        &Normalize180( void );
 };
 
 extern angles_t ang_zero;
index b33f4425d28c2b6b660df07058c1ff1d56cd480b..d428afbd5f8d1b5423cd52a84ede1d8f2489af40 100644 (file)
@@ -31,44 +31,44 @@ class mat3_t;
 
 class quat_t {
 public:
-float x;
-float y;
-float z;
-float w;
+       float x;
+       float y;
+       float z;
+       float w;
 
-quat_t();
-quat_t( float x, float y, float z, float w );
+       quat_t();
+       quat_t( float x, float y, float z, float w );
 
-friend void     toQuat( idVec3_t &src, quat_t &dst );
-friend void     toQuat( angles_t &src, quat_t &dst );
-friend void     toQuat( mat3_t &src, quat_t &dst );
+       friend void toQuat( idVec3_t &src, quat_t &dst );
+       friend void toQuat( angles_t &src, quat_t &dst );
+       friend void toQuat( mat3_t &src, quat_t &dst );
 
-float           *vec4( void );
+       float *vec4( void );
 
-float operator[]( int index ) const;
-float           &operator[]( int index );
+       float  operator[]( int index ) const;
+       float &operator[]( int index );
 
-void            set( float x, float y, float z, float w );
+       void set( float x, float y, float z, float w );
 
-void operator=( quat_t a );
+       void operator=( quat_t a );
 
-friend quat_t operator+( quat_t a, quat_t b );
-quat_t          &operator+=( quat_t a );
+       friend quat_t operator+( quat_t a, quat_t b );
+       quat_t &operator+=( quat_t a );
 
-friend quat_t operator-( quat_t a, quat_t b );
-quat_t          &operator-=( quat_t a );
+       friend quat_t operator-( quat_t a, quat_t b );
+       quat_t &operator-=( quat_t a );
 
-friend quat_t operator*( quat_t a, float b );
-friend quat_t operator*( float a, quat_t b );
-quat_t          &operator*=( float a );
+       friend quat_t operator*( quat_t a, float b );
+       friend quat_t operator*( float a, quat_t b );
+       quat_t &operator*=( float a );
 
-friend int operator==( quat_t a, quat_t b );
-friend int operator!=( quat_t a, quat_t b );
+       friend int operator==( quat_t a, quat_t b );
+       friend int operator!=( quat_t a, quat_t b );
 
-float           Length( void );
-quat_t          &Normalize( void );
+       float Length( void );
+       quat_t &Normalize( void );
 
-quat_t operator-();
+       quat_t operator-();
 };
 
 inline quat_t::quat_t() {
index 4fbe8d9dc5820f8071af22b13308e98aaad0288b..3e6372e5db44335c231af4a403258b02e69ccfec 100644 (file)
@@ -124,59 +124,59 @@ static inline double idSqrt( double x ) {
 class idVec3 {
 public:
 #ifndef FAT_VEC3
-float x,y,z;
+       float x,y,z;
 #else
-float x,y,z,dist;
+       float x,y,z,dist;
 #endif
 
 #ifndef FAT_VEC3
-idVec3() {};
+       idVec3() {};
 #else
-idVec3() {dist = 0.0f; };
+       idVec3() {dist = 0.0f; };
 #endif
-idVec3( const float x, const float y, const float z );
+       idVec3( const float x, const float y, const float z );
 
-operator float *();
+       operator float *();
 
-float operator[]( const int index ) const;
-float           &operator[]( const int index );
+       float operator[]( const int index ) const;
+       float &operator[]( const int index );
 
-void            set( const float x, const float y, const float z );
+       void set( const float x, const float y, const float z );
 
-idVec3 operator-() const;
+       idVec3 operator-() const;
 
-idVec3          &operator=( const idVec3 &a );
+       idVec3 &operator=( const idVec3 &a );
 
-float operator*( const idVec3 &a ) const;
-idVec3 operator*( const float a ) const;
-friend idVec3 operator*( float a, idVec3 b );
+       float operator*( const idVec3 &a ) const;
+       idVec3 operator*( const float a ) const;
+       friend idVec3 operator*( float a, idVec3 b );
 
-idVec3 operator+( const idVec3 &a ) const;
-idVec3 operator-( const idVec3 &a ) const;
+       idVec3 operator+( const idVec3 &a ) const;
+       idVec3 operator-( const idVec3 &a ) const;
 
-idVec3          &operator+=( const idVec3 &a );
-idVec3          &operator-=( const idVec3 &a );
-idVec3          &operator*=( const float a );
+       idVec3 &operator+=( const idVec3 &a );
+       idVec3 &operator-=( const idVec3 &a );
+       idVec3 &operator*=( const float a );
 
-int operator==( const idVec3 &a ) const;
-int operator!=( const idVec3 &a ) const;
+       int operator==( const idVec3 &a ) const;
+       int operator!=( const idVec3 &a ) const;
 
-idVec3          Cross( const idVec3 &a ) const;
-idVec3          &Cross( const idVec3 &a, const idVec3 &b );
+       idVec3          Cross( const idVec3 &a ) const;
+       idVec3          &Cross( const idVec3 &a, const idVec3 &b );
 
-float           Length( void ) const;
-float           Normalize( void );
+       float           Length( void ) const;
+       float           Normalize( void );
 
-void            Zero( void );
-void            Snap( void );
-void            SnapTowards( const idVec3 &to );
+       void            Zero( void );
+       void            Snap( void );
+       void            SnapTowards( const idVec3 &to );
 
-float           toYaw( void );
-float           toPitch( void );
-angles_t        toAngles( void );
-friend idVec3   LerpVector( const idVec3 &w1, const idVec3 &w2, const float t );
+       float           toYaw( void );
+       float           toPitch( void );
+       angles_t        toAngles( void );
+       friend idVec3   LerpVector( const idVec3 &w1, const idVec3 &w2, const float t );
 
-char            *string( void );
+       char            *string( void );
 };
 
 extern idVec3 vec_zero;
index ff7dc4536c9245ce116e612534f0d1ff826a49a6..72423b57b03e97692bdb5fc97f2e8dfe3f4de9ae 100644 (file)
@@ -259,50 +259,52 @@ inline char* string_to_uppercase( char* string ){
 /// \brief A re-entrant string tokeniser similar to strchr.
 class StringTokeniser
 {
-bool istoken( char c ) const {
-       if ( strchr( m_delimiters, c ) != 0 ) {
-               return false;
-       }
-       return true;
-}
-const char* advance(){
-       const char* token = m_pos;
-       bool intoken = true;
-       while ( !string_empty( m_pos ) )
-       {
-               if ( !istoken( *m_pos ) ) {
-                       *m_pos = '\0';
-                       intoken = false;
+private:
+       bool istoken( char c ) const {
+               if ( strchr( m_delimiters, c ) != 0 ) {
+                       return false;
                }
-               else if ( !intoken ) {
-                       return token;
+               return true;
+       }
+       const char* advance(){
+               const char* token = m_pos;
+               bool intoken = true;
+               while ( !string_empty( m_pos ) )
+               {
+                       if ( !istoken( *m_pos ) ) {
+                               *m_pos = '\0';
+                               intoken = false;
+                       }
+                       else if ( !intoken ) {
+                               return token;
+                       }
+                       ++m_pos;
                }
-               ++m_pos;
+               return token;
        }
-       return token;
-}
-std::size_t m_length;
-char* m_string;
-char* m_pos;
-const char* m_delimiters;
+       std::size_t m_length;
+       char* m_string;
+       char* m_pos;
+       const char* m_delimiters;
+
 public:
-StringTokeniser( const char* string, const char* delimiters = " \n\r\t\v" ) :
-       m_length( string_length( string ) ),
-       m_string( string_copy( string_new( m_length ), string ) ),
-       m_pos( m_string ),
-       m_delimiters( delimiters ){
-       while ( !string_empty( m_pos ) && !istoken( *m_pos ) )
-       {
-               ++m_pos;
+       StringTokeniser( const char* string, const char* delimiters = " \n\r\t\v" ) :
+               m_length( string_length( string ) ),
+               m_string( string_copy( string_new( m_length ), string ) ),
+               m_pos( m_string ),
+               m_delimiters( delimiters ){
+               while ( !string_empty( m_pos ) && !istoken( *m_pos ) )
+               {
+                       ++m_pos;
+               }
+       }
+       ~StringTokeniser(){
+               string_release( m_string, m_length );
+       }
+       /// \brief Returns the next token or "" if there are no more tokens available.
+       const char* getToken(){
+               return advance();
        }
-}
-~StringTokeniser(){
-       string_release( m_string, m_length );
-}
-/// \brief Returns the next token or "" if there are no more tokens available.
-const char* getToken(){
-       return advance();
-}
 };
 
 /// \brief A non-mutable c-style string.
@@ -316,40 +318,39 @@ template<typename Buffer>
 class String : public Buffer
 {
 public:
+       String()
+               : Buffer(){
+       }
+       String( const char* string )
+               : Buffer( string ){
+       }
+       String( StringRange range )
+               : Buffer( range ){
+       }
 
-String()
-       : Buffer(){
-}
-String( const char* string )
-       : Buffer( string ){
-}
-String( StringRange range )
-       : Buffer( range ){
-}
-
-String& operator=( const String& other ){
-       String temp( other );
-       temp.swap( *this );
-       return *this;
-}
-String& operator=( const char* string ){
-       String temp( string );
-       temp.swap( *this );
-       return *this;
-}
-String& operator=( StringRange range ){
-       String temp( range );
-       temp.swap( *this );
-       return *this;
-}
+       String& operator=( const String& other ){
+               String temp( other );
+               temp.swap( *this );
+               return *this;
+       }
+       String& operator=( const char* string ){
+               String temp( string );
+               temp.swap( *this );
+               return *this;
+       }
+       String& operator=( StringRange range ){
+               String temp( range );
+               temp.swap( *this );
+               return *this;
+       }
 
-void swap( String& other ){
-       Buffer::swap( other );
-}
+       void swap( String& other ){
+               Buffer::swap( other );
+       }
 
-bool empty() const {
-       return string_empty( Buffer::c_str() );
-}
+       bool empty() const {
+               return string_empty( Buffer::c_str() );
+       }
 };
 
 template<typename Buffer>
@@ -397,44 +398,45 @@ inline void swap( String<Buffer>& self, String<Buffer>& other ){
 template<typename Allocator>
 class CopiedBuffer : private Allocator
 {
-char* m_string;
+       char* m_string;
 
-char* copy_range( StringRange range ){
-       return string_clone_range( range, static_cast<Allocator&>( *this ) );
-}
-char* copy( const char* other ){
-       return string_clone( other, static_cast<Allocator&>( *this ) );
-}
-void destroy( char* string ){
-       string_release( string, string_length( string ), static_cast<Allocator&>( *this ) );
-}
+       char* copy_range( StringRange range ){
+               return string_clone_range( range, static_cast<Allocator&>( *this ) );
+       }
+       char* copy( const char* other ){
+               return string_clone( other, static_cast<Allocator&>( *this ) );
+       }
+       void destroy( char* string ){
+               string_release( string, string_length( string ), static_cast<Allocator&>( *this ) );
+       }
 
 protected:
-~CopiedBuffer(){
-       destroy( m_string );
-}
+       ~CopiedBuffer(){
+               destroy( m_string );
+       }
+
 public:
-CopiedBuffer()
-       : m_string( copy( "" ) ){
-}
-explicit CopiedBuffer( const Allocator& allocator )
-       : Allocator( allocator ), m_string( copy( "" ) ){
-}
-CopiedBuffer( const CopiedBuffer& other )
-       : Allocator( other ), m_string( copy( other.m_string ) ){
-}
-CopiedBuffer( const char* string, const Allocator& allocator = Allocator() )
-       : Allocator( allocator ), m_string( copy( string ) ){
-}
-CopiedBuffer( StringRange range, const Allocator& allocator = Allocator() )
-       : Allocator( allocator ), m_string( copy_range( range ) ){
-}
-const char* c_str() const {
-       return m_string;
-}
-void swap( CopiedBuffer& other ){
-       string_swap( m_string, other.m_string );
-}
+       CopiedBuffer()
+               : m_string( copy( "" ) ){
+       }
+       explicit CopiedBuffer( const Allocator& allocator )
+               : Allocator( allocator ), m_string( copy( "" ) ){
+       }
+       CopiedBuffer( const CopiedBuffer& other )
+               : Allocator( other ), m_string( copy( other.m_string ) ){
+       }
+       CopiedBuffer( const char* string, const Allocator& allocator = Allocator() )
+               : Allocator( allocator ), m_string( copy( string ) ){
+       }
+       CopiedBuffer( StringRange range, const Allocator& allocator = Allocator() )
+               : Allocator( allocator ), m_string( copy_range( range ) ){
+       }
+       const char* c_str() const {
+               return m_string;
+       }
+       void swap( CopiedBuffer& other ){
+               string_swap( m_string, other.m_string );
+       }
 };
 
 /// \brief A non-mutable string which uses copy-by-value for assignment.
@@ -445,65 +447,67 @@ typedef String< CopiedBuffer< DefaultAllocator<char> > > CopiedString;
 template<typename Allocator>
 class SmartBuffer : private Allocator
 {
-char* m_buffer;
-
-char* copy_range( StringRange range ){
-       char* buffer = Allocator::allocate( sizeof( std::size_t ) + ( range.last - range.first ) + 1 );
-       strncpy( buffer + sizeof( std::size_t ), range.first, range.last - range.first );
-       buffer[sizeof( std::size_t ) + ( range.last - range.first )] = '\0';
-       *reinterpret_cast<std::size_t*>( buffer ) = 0;
-       return buffer;
-}
-char* copy( const char* string ){
-       char* buffer = Allocator::allocate( sizeof( std::size_t ) + string_length( string ) + 1 );
-       strcpy( buffer + sizeof( std::size_t ), string );
-       *reinterpret_cast<std::size_t*>( buffer ) = 0;
-       return buffer;
-}
-void destroy( char* buffer ){
-       Allocator::deallocate( buffer, sizeof( std::size_t ) + string_length( c_str() ) + 1 );
-}
+private:
+       char* m_buffer;
+
+       char* copy_range( StringRange range ){
+               char* buffer = Allocator::allocate( sizeof( std::size_t ) + ( range.last - range.first ) + 1 );
+               strncpy( buffer + sizeof( std::size_t ), range.first, range.last - range.first );
+               buffer[sizeof( std::size_t ) + ( range.last - range.first )] = '\0';
+               *reinterpret_cast<std::size_t*>( buffer ) = 0;
+               return buffer;
+       }
+       char* copy( const char* string ){
+               char* buffer = Allocator::allocate( sizeof( std::size_t ) + string_length( string ) + 1 );
+               strcpy( buffer + sizeof( std::size_t ), string );
+               *reinterpret_cast<std::size_t*>( buffer ) = 0;
+               return buffer;
+       }
+       void destroy( char* buffer ){
+               Allocator::deallocate( buffer, sizeof( std::size_t ) + string_length( c_str() ) + 1 );
+       }
 
-void incref( char* buffer ){
-       ++( *reinterpret_cast<std::size_t*>( buffer ) );
-}
-void decref( char* buffer ){
-       if ( --( *reinterpret_cast<std::size_t*>( buffer ) ) == 0 ) {
-               destroy( buffer );
+       void incref( char* buffer ){
+               ++( *reinterpret_cast<std::size_t*>( buffer ) );
+       }
+       void decref( char* buffer ){
+               if ( --( *reinterpret_cast<std::size_t*>( buffer ) ) == 0 ) {
+                       destroy( buffer );
+               }
        }
-}
 
 protected:
-~SmartBuffer(){
-       decref( m_buffer );
-}
+       ~SmartBuffer(){
+               decref( m_buffer );
+       }
+
 public:
-SmartBuffer()
-       : m_buffer( copy( "" ) ){
-       incref( m_buffer );
-}
-explicit SmartBuffer( const Allocator& allocator )
-       : Allocator( allocator ), m_buffer( copy( "" ) ){
-       incref( m_buffer );
-}
-SmartBuffer( const SmartBuffer& other )
-       : Allocator( other ), m_buffer( other.m_buffer ){
-       incref( m_buffer );
-}
-SmartBuffer( const char* string, const Allocator& allocator = Allocator() )
-       : Allocator( allocator ), m_buffer( copy( string ) ){
-       incref( m_buffer );
-}
-SmartBuffer( StringRange range, const Allocator& allocator = Allocator() )
-       : Allocator( allocator ), m_buffer( copy_range( range ) ){
-       incref( m_buffer );
-}
-const char* c_str() const {
-       return m_buffer + sizeof( std::size_t );
-}
-void swap( SmartBuffer& other ){
-       string_swap( m_buffer, other.m_buffer );
-}
+       SmartBuffer()
+               : m_buffer( copy( "" ) ){
+               incref( m_buffer );
+       }
+       explicit SmartBuffer( const Allocator& allocator )
+               : Allocator( allocator ), m_buffer( copy( "" ) ){
+               incref( m_buffer );
+       }
+       SmartBuffer( const SmartBuffer& other )
+               : Allocator( other ), m_buffer( other.m_buffer ){
+               incref( m_buffer );
+       }
+       SmartBuffer( const char* string, const Allocator& allocator = Allocator() )
+               : Allocator( allocator ), m_buffer( copy( string ) ){
+               incref( m_buffer );
+       }
+       SmartBuffer( StringRange range, const Allocator& allocator = Allocator() )
+               : Allocator( allocator ), m_buffer( copy_range( range ) ){
+               incref( m_buffer );
+       }
+       const char* c_str() const {
+               return m_buffer + sizeof( std::size_t );
+       }
+       void swap( SmartBuffer& other ){
+               string_swap( m_buffer, other.m_buffer );
+       }
 };
 
 /// \brief A non-mutable string which uses copy-by-reference for assignment of SmartString.
@@ -512,9 +516,9 @@ typedef String< SmartBuffer< DefaultAllocator<char> > > SmartString;
 class StringEqualNoCase
 {
 public:
-bool operator()( const CopiedString& key, const CopiedString& other ) const {
-       return string_equal_nocase( key.c_str(), other.c_str() );
-}
+       bool operator()( const CopiedString& key, const CopiedString& other ) const {
+               return string_equal_nocase( key.c_str(), other.c_str() );
+       }
 };
 
 struct StringLessNoCase
index 7748327d089b520da17d63caa28ceffe2c5d4af7..9b91386c1e085b0c0ceae2785769d12df7ab9e20 100644 (file)
@@ -306,9 +306,8 @@ inline void brush_check_shader( const char* name ){
 class FaceShaderObserver
 {
 public:
-virtual void realiseShader() = 0;
-
-virtual void unrealiseShader() = 0;
+       virtual void realiseShader() = 0;
+       virtual void unrealiseShader() = 0;
 };
 
 typedef ReferencePair<FaceShaderObserver> FaceShaderObserverPair;
@@ -317,20 +316,20 @@ typedef ReferencePair<FaceShaderObserver> FaceShaderObserverPair;
 class ContentsFlagsValue
 {
 public:
-ContentsFlagsValue(){
-}
+       ContentsFlagsValue(){
+       }
 
-ContentsFlagsValue( int surfaceFlags, int contentFlags, int value, bool specified ) :
-       m_surfaceFlags( surfaceFlags ),
-       m_contentFlags( contentFlags ),
-       m_value( value ),
-       m_specified( specified ){
-}
+       ContentsFlagsValue( int surfaceFlags, int contentFlags, int value, bool specified ) :
+               m_surfaceFlags( surfaceFlags ),
+               m_contentFlags( contentFlags ),
+               m_value( value ),
+               m_specified( specified ){
+       }
 
-int m_surfaceFlags;
-int m_contentFlags;
-int m_value;
-bool m_specified;
+       int m_surfaceFlags;
+       int m_contentFlags;
+       int m_value;
+       bool m_specified;
 };
 
 inline void ContentsFlagsValue_assignMasked( ContentsFlagsValue& flags, const ContentsFlagsValue& other ){
@@ -349,279 +348,279 @@ inline void ContentsFlagsValue_assignMasked( ContentsFlagsValue& flags, const Co
 class FaceShader : public ModuleObserver
 {
 public:
-class SavedState
-{
-public:
-CopiedString m_shader;
-ContentsFlagsValue m_flags;
+       class SavedState
+       {
+       public:
+               CopiedString m_shader;
+               ContentsFlagsValue m_flags;
 
-SavedState( const FaceShader& faceShader ){
-       m_shader = faceShader.getShader();
-       m_flags = faceShader.m_flags;
-}
+               SavedState( const FaceShader& faceShader ){
+                       m_shader = faceShader.getShader();
+                       m_flags = faceShader.m_flags;
+               }
 
-void exportState( FaceShader& faceShader ) const {
-       faceShader.setShader( m_shader.c_str() );
-       faceShader.m_flags = m_flags;
-}
-};
+               void exportState( FaceShader& faceShader ) const {
+                       faceShader.setShader( m_shader.c_str() );
+                       faceShader.m_flags = m_flags;
+               }
+       };
 
-CopiedString m_shader;
-Shader* m_state;
-ContentsFlagsValue m_flags;
-FaceShaderObserverPair m_observers;
-bool m_instanced;
-bool m_realised;
+       CopiedString m_shader;
+       Shader* m_state;
+       ContentsFlagsValue m_flags;
+       FaceShaderObserverPair m_observers;
+       bool m_instanced;
+       bool m_realised;
 
-FaceShader( const char* shader, const ContentsFlagsValue& flags = ContentsFlagsValue( 0, 0, 0, false ) ) :
-       m_shader( shader ),
-       m_state( 0 ),
-       m_flags( flags ),
-       m_instanced( false ),
-       m_realised( false ){
-       captureShader();
-}
+       FaceShader( const char* shader, const ContentsFlagsValue& flags = ContentsFlagsValue( 0, 0, 0, false ) ) :
+               m_shader( shader ),
+               m_state( 0 ),
+               m_flags( flags ),
+               m_instanced( false ),
+               m_realised( false ){
+               captureShader();
+       }
 
-~FaceShader(){
-       releaseShader();
-}
+       ~FaceShader(){
+               releaseShader();
+       }
 
-// copy-construction not supported
-FaceShader( const FaceShader& other );
+       // copy-construction not supported
+       FaceShader( const FaceShader& other );
 
-void instanceAttach(){
-       m_instanced = true;
-       m_state->incrementUsed();
-}
+       void instanceAttach(){
+               m_instanced = true;
+               m_state->incrementUsed();
+       }
 
-void instanceDetach(){
-       m_state->decrementUsed();
-       m_instanced = false;
-}
+       void instanceDetach(){
+               m_state->decrementUsed();
+               m_instanced = false;
+       }
 
-void captureShader(){
-       ASSERT_MESSAGE( m_state == 0, "shader cannot be captured" );
-       brush_check_shader( m_shader.c_str() );
-       m_state = GlobalShaderCache().capture( m_shader.c_str() );
-       m_state->attach( *this );
-}
+       void captureShader(){
+               ASSERT_MESSAGE( m_state == 0, "shader cannot be captured" );
+               brush_check_shader( m_shader.c_str() );
+               m_state = GlobalShaderCache().capture( m_shader.c_str() );
+               m_state->attach( *this );
+       }
 
-void releaseShader(){
-       ASSERT_MESSAGE( m_state != 0, "shader cannot be released" );
-       m_state->detach( *this );
-       GlobalShaderCache().release( m_shader.c_str() );
-       m_state = 0;
-}
+       void releaseShader(){
+               ASSERT_MESSAGE( m_state != 0, "shader cannot be released" );
+               m_state->detach( *this );
+               GlobalShaderCache().release( m_shader.c_str() );
+               m_state = 0;
+       }
 
-void realise(){
-       ASSERT_MESSAGE( !m_realised, "FaceTexdef::realise: already realised" );
-       m_realised = true;
-       m_observers.forEach([](FaceShaderObserver &observer) {
-               observer.realiseShader();
-       });
-}
+       void realise(){
+               ASSERT_MESSAGE( !m_realised, "FaceTexdef::realise: already realised" );
+               m_realised = true;
+               m_observers.forEach([](FaceShaderObserver &observer) {
+                       observer.realiseShader();
+               });
+       }
 
-void unrealise(){
-       ASSERT_MESSAGE( m_realised, "FaceTexdef::unrealise: already unrealised" );
-       m_observers.forEach([](FaceShaderObserver &observer) {
-               observer.unrealiseShader();
-       });
-       m_realised = false;
-}
+       void unrealise(){
+               ASSERT_MESSAGE( m_realised, "FaceTexdef::unrealise: already unrealised" );
+               m_observers.forEach([](FaceShaderObserver &observer) {
+                       observer.unrealiseShader();
+               });
+               m_realised = false;
+       }
 
-void attach( FaceShaderObserver& observer ){
-       m_observers.attach( observer );
-       if ( m_realised ) {
-               observer.realiseShader();
+       void attach( FaceShaderObserver& observer ){
+               m_observers.attach( observer );
+               if ( m_realised ) {
+                       observer.realiseShader();
+               }
        }
-}
 
-void detach( FaceShaderObserver& observer ){
-       if ( m_realised ) {
-               observer.unrealiseShader();
+       void detach( FaceShaderObserver& observer ){
+               if ( m_realised ) {
+                       observer.unrealiseShader();
+               }
+               m_observers.detach( observer );
        }
-       m_observers.detach( observer );
-}
 
-const char* getShader() const {
-       return m_shader.c_str();
-}
-void setShader( const char* name ){
-       if ( m_instanced ) {
-               m_state->decrementUsed();
+       const char* getShader() const {
+               return m_shader.c_str();
        }
-       releaseShader();
-       m_shader = name;
-       captureShader();
-       if ( m_instanced ) {
-               m_state->incrementUsed();
+       void setShader( const char* name ){
+               if ( m_instanced ) {
+                       m_state->decrementUsed();
+               }
+               releaseShader();
+               m_shader = name;
+               captureShader();
+               if ( m_instanced ) {
+                       m_state->incrementUsed();
+               }
        }
-}
 
-ContentsFlagsValue getFlags() const {
-       ASSERT_MESSAGE( m_realised, "FaceShader::getFlags: flags not valid when unrealised" );
-       if ( !m_flags.m_specified ) {
-               return ContentsFlagsValue(
-                                  m_state->getTexture().surfaceFlags,
-                                  m_state->getTexture().contentFlags,
-                                  m_state->getTexture().value,
-                                  true
-                                  );
+       ContentsFlagsValue getFlags() const {
+               ASSERT_MESSAGE( m_realised, "FaceShader::getFlags: flags not valid when unrealised" );
+               if ( !m_flags.m_specified ) {
+                       return ContentsFlagsValue(
+                                          m_state->getTexture().surfaceFlags,
+                                          m_state->getTexture().contentFlags,
+                                          m_state->getTexture().value,
+                                          true
+                                          );
+               }
+               return m_flags;
        }
-       return m_flags;
-}
 
-void setFlags( const ContentsFlagsValue& flags ){
-       ASSERT_MESSAGE( m_realised, "FaceShader::setFlags: flags not valid when unrealised" );
-       ContentsFlagsValue_assignMasked( m_flags, flags );
-}
+       void setFlags( const ContentsFlagsValue& flags ){
+               ASSERT_MESSAGE( m_realised, "FaceShader::setFlags: flags not valid when unrealised" );
+               ContentsFlagsValue_assignMasked( m_flags, flags );
+       }
 
-Shader* state() const {
-       return m_state;
-}
+       Shader* state() const {
+               return m_state;
+       }
 
-std::size_t width() const {
-       if ( m_realised ) {
-               return m_state->getTexture().width;
+       std::size_t width() const {
+               if ( m_realised ) {
+                       return m_state->getTexture().width;
+               }
+               return 1;
        }
-       return 1;
-}
 
-std::size_t height() const {
-       if ( m_realised ) {
-               return m_state->getTexture().height;
+       std::size_t height() const {
+               if ( m_realised ) {
+                       return m_state->getTexture().height;
+               }
+               return 1;
        }
-       return 1;
-}
 
-unsigned int shaderFlags() const {
-       if ( m_realised ) {
-               return m_state->getFlags();
+       unsigned int shaderFlags() const {
+               if ( m_realised ) {
+                       return m_state->getFlags();
+               }
+               return 0;
        }
-       return 0;
-}
 };
 
 
 class FaceTexdef : public FaceShaderObserver
 {
-// not copyable
-FaceTexdef( const FaceTexdef& other );
+       // not copyable
+       FaceTexdef( const FaceTexdef& other );
 
-// not assignable
-FaceTexdef& operator=( const FaceTexdef& other );
+       // not assignable
+       FaceTexdef& operator=( const FaceTexdef& other );
 
 public:
-class SavedState
-{
-public:
-TextureProjection m_projection;
+       class SavedState
+       {
+       public:
+               TextureProjection m_projection;
 
-SavedState( const FaceTexdef& faceTexdef ){
-       m_projection = faceTexdef.m_projection;
-}
+               SavedState( const FaceTexdef& faceTexdef ){
+                       m_projection = faceTexdef.m_projection;
+               }
 
-void exportState( FaceTexdef& faceTexdef ) const {
-       Texdef_Assign( faceTexdef.m_projection, m_projection );
-}
-};
+               void exportState( FaceTexdef& faceTexdef ) const {
+                       Texdef_Assign( faceTexdef.m_projection, m_projection );
+               }
+       };
 
-FaceShader& m_shader;
-TextureProjection m_projection;
-bool m_projectionInitialised;
-bool m_scaleApplied;
+       FaceShader& m_shader;
+       TextureProjection m_projection;
+       bool m_projectionInitialised;
+       bool m_scaleApplied;
 
-FaceTexdef(
-       FaceShader& shader,
-       const TextureProjection& projection,
-       bool projectionInitialised = true
-       ) :
-       m_shader( shader ),
-       m_projection( projection ),
-       m_projectionInitialised( projectionInitialised ),
-       m_scaleApplied( false ){
-       m_shader.attach( *this );
-}
+       FaceTexdef(
+               FaceShader& shader,
+               const TextureProjection& projection,
+               bool projectionInitialised = true
+               ) :
+               m_shader( shader ),
+               m_projection( projection ),
+               m_projectionInitialised( projectionInitialised ),
+               m_scaleApplied( false ){
+               m_shader.attach( *this );
+       }
 
-~FaceTexdef(){
-       m_shader.detach( *this );
-}
+       ~FaceTexdef(){
+               m_shader.detach( *this );
+       }
 
-void addScale(){
-       ASSERT_MESSAGE( !m_scaleApplied, "texture scale aready added" );
-       m_scaleApplied = true;
-       m_projection.m_brushprimit_texdef.addScale( m_shader.width(), m_shader.height() );
-}
+       void addScale(){
+               ASSERT_MESSAGE( !m_scaleApplied, "texture scale aready added" );
+               m_scaleApplied = true;
+               m_projection.m_brushprimit_texdef.addScale( m_shader.width(), m_shader.height() );
+       }
 
-void removeScale(){
-       ASSERT_MESSAGE( m_scaleApplied, "texture scale aready removed" );
-       m_scaleApplied = false;
-       m_projection.m_brushprimit_texdef.removeScale( m_shader.width(), m_shader.height() );
-}
+       void removeScale(){
+               ASSERT_MESSAGE( m_scaleApplied, "texture scale aready removed" );
+               m_scaleApplied = false;
+               m_projection.m_brushprimit_texdef.removeScale( m_shader.width(), m_shader.height() );
+       }
 
-void realiseShader(){
-       if ( m_projectionInitialised && !m_scaleApplied ) {
-               addScale();
+       void realiseShader(){
+               if ( m_projectionInitialised && !m_scaleApplied ) {
+                       addScale();
+               }
        }
-}
 
-void unrealiseShader(){
-       if ( m_projectionInitialised && m_scaleApplied ) {
-               removeScale();
+       void unrealiseShader(){
+               if ( m_projectionInitialised && m_scaleApplied ) {
+                       removeScale();
+               }
        }
-}
 
-void setTexdef( const TextureProjection& projection ){
-       removeScale();
-       Texdef_Assign( m_projection, projection );
-       addScale();
-}
+       void setTexdef( const TextureProjection& projection ){
+               removeScale();
+               Texdef_Assign( m_projection, projection );
+               addScale();
+       }
 
-void shift( float s, float t ){
-       ASSERT_MESSAGE( texdef_sane( m_projection.m_texdef ), "FaceTexdef::shift: bad texdef" );
-       removeScale();
-       Texdef_Shift( m_projection, s, t );
-       addScale();
-}
+       void shift( float s, float t ){
+               ASSERT_MESSAGE( texdef_sane( m_projection.m_texdef ), "FaceTexdef::shift: bad texdef" );
+               removeScale();
+               Texdef_Shift( m_projection, s, t );
+               addScale();
+       }
 
-void scale( float s, float t ){
-       removeScale();
-       Texdef_Scale( m_projection, s, t );
-       addScale();
-}
+       void scale( float s, float t ){
+               removeScale();
+               Texdef_Scale( m_projection, s, t );
+               addScale();
+       }
 
-void rotate( float angle ){
-       removeScale();
-       Texdef_Rotate( m_projection, angle );
-       addScale();
-}
+       void rotate( float angle ){
+               removeScale();
+               Texdef_Rotate( m_projection, angle );
+               addScale();
+       }
 
-void fit( const Vector3& normal, const Winding& winding, float s_repeat, float t_repeat ){
-       Texdef_FitTexture( m_projection, m_shader.width(), m_shader.height(), normal, winding, s_repeat, t_repeat );
-}
+       void fit( const Vector3& normal, const Winding& winding, float s_repeat, float t_repeat ){
+               Texdef_FitTexture( m_projection, m_shader.width(), m_shader.height(), normal, winding, s_repeat, t_repeat );
+       }
 
-void emitTextureCoordinates( Winding& winding, const Vector3& normal, const Matrix4& localToWorld ){
-       Texdef_EmitTextureCoordinates( m_projection, m_shader.width(), m_shader.height(), winding, normal, localToWorld );
-}
+       void emitTextureCoordinates( Winding& winding, const Vector3& normal, const Matrix4& localToWorld ){
+               Texdef_EmitTextureCoordinates( m_projection, m_shader.width(), m_shader.height(), winding, normal, localToWorld );
+       }
 
-void transform( const Plane3& plane, const Matrix4& matrix ){
-       removeScale();
-       Texdef_transformLocked( m_projection, m_shader.width(), m_shader.height(), plane, matrix );
-       addScale();
-}
+       void transform( const Plane3& plane, const Matrix4& matrix ){
+               removeScale();
+               Texdef_transformLocked( m_projection, m_shader.width(), m_shader.height(), plane, matrix );
+               addScale();
+       }
 
-TextureProjection normalised() const {
-       brushprimit_texdef_t tmp( m_projection.m_brushprimit_texdef );
-       tmp.removeScale( m_shader.width(), m_shader.height() );
-       return TextureProjection( m_projection.m_texdef, tmp, m_projection.m_basis_s, m_projection.m_basis_t );
-}
+       TextureProjection normalised() const {
+               brushprimit_texdef_t tmp( m_projection.m_brushprimit_texdef );
+               tmp.removeScale( m_shader.width(), m_shader.height() );
+               return TextureProjection( m_projection.m_texdef, tmp, m_projection.m_basis_s, m_projection.m_basis_t );
+       }
 
-void setBasis( const Vector3& normal ){
-       Matrix4 basis;
-       Normal_GetTransform( normal, basis );
-       m_projection.m_basis_s = Vector3( basis.xx(), basis.yx(), basis.zx() );
-       m_projection.m_basis_t = Vector3( -basis.xy(), -basis.yy(), -basis.zy() );
-}
+       void setBasis( const Vector3& normal ){
+               Matrix4 basis;
+               Normal_GetTransform( normal, basis );
+               m_projection.m_basis_s = Vector3( basis.xx(), basis.yx(), basis.zx() );
+               m_projection.m_basis_t = Vector3( -basis.xy(), -basis.yy(), -basis.zy() );
+       }
 };
 
 inline void planepts_print( const PlanePoints& planePoints, TextOutputStream& ostream ){
@@ -643,190 +642,190 @@ inline Plane3 Plane3_applyTransform( const Plane3& plane, const Matrix4& matrix
 
 class FacePlane
 {
-PlanePoints m_planepts;
-Plane3 m_planeCached;
-Plane3 m_plane;
+       PlanePoints m_planepts;
+       Plane3 m_planeCached;
+       Plane3 m_plane;
 public:
-Vector3 m_funcStaticOrigin;
-
-static EBrushType m_type;
-
-static bool isDoom3Plane(){
-       return FacePlane::m_type == eBrushTypeDoom3 || FacePlane::m_type == eBrushTypeQuake4;
-}
+       Vector3 m_funcStaticOrigin;
 
-class SavedState
-{
-public:
-PlanePoints m_planepts;
-Plane3 m_plane;
+       static EBrushType m_type;
 
-SavedState( const FacePlane& facePlane ){
-       if ( facePlane.isDoom3Plane() ) {
-               m_plane = facePlane.m_plane;
-       }
-       else
-       {
-               planepts_assign( m_planepts, facePlane.planePoints() );
+       static bool isDoom3Plane(){
+               return FacePlane::m_type == eBrushTypeDoom3 || FacePlane::m_type == eBrushTypeQuake4;
        }
-}
 
-void exportState( FacePlane& facePlane ) const {
-       if ( facePlane.isDoom3Plane() ) {
-               facePlane.m_plane = m_plane;
-               facePlane.updateTranslated();
-       }
-       else
+       class SavedState
        {
-               planepts_assign( facePlane.planePoints(), m_planepts );
-               facePlane.MakePlane();
-       }
-}
-};
+       public:
+               PlanePoints m_planepts;
+               Plane3 m_plane;
 
-FacePlane() : m_funcStaticOrigin( 0, 0, 0 ){
-}
+               SavedState( const FacePlane& facePlane ){
+                       if ( facePlane.isDoom3Plane() ) {
+                               m_plane = facePlane.m_plane;
+                       }
+                       else
+                       {
+                               planepts_assign( m_planepts, facePlane.planePoints() );
+                       }
+               }
+
+               void exportState( FacePlane& facePlane ) const {
+                       if ( facePlane.isDoom3Plane() ) {
+                               facePlane.m_plane = m_plane;
+                               facePlane.updateTranslated();
+                       }
+                       else
+                       {
+                               planepts_assign( facePlane.planePoints(), m_planepts );
+                               facePlane.MakePlane();
+                       }
+               }
+       };
 
-FacePlane( const FacePlane& other ) : m_funcStaticOrigin( 0, 0, 0 ){
-       if ( !isDoom3Plane() ) {
-               planepts_assign( m_planepts, other.m_planepts );
-               MakePlane();
+       FacePlane() : m_funcStaticOrigin( 0, 0, 0 ){
        }
-       else
-       {
-               m_plane = other.m_plane;
-               updateTranslated();
+
+       FacePlane( const FacePlane& other ) : m_funcStaticOrigin( 0, 0, 0 ){
+               if ( !isDoom3Plane() ) {
+                       planepts_assign( m_planepts, other.m_planepts );
+                       MakePlane();
+               }
+               else
+               {
+                       m_plane = other.m_plane;
+                       updateTranslated();
+               }
        }
-}
 
-void MakePlane(){
-       if ( !isDoom3Plane() ) {
+       void MakePlane(){
+               if ( !isDoom3Plane() ) {
 #if 0
-               if ( check_plane_is_integer( m_planepts ) ) {
-                       globalErrorStream() << "non-integer planepts: ";
-                       planepts_print( m_planepts, globalErrorStream() );
-                       globalErrorStream() << "\n";
-               }
+                       if ( check_plane_is_integer( m_planepts ) ) {
+                               globalErrorStream() << "non-integer planepts: ";
+                               planepts_print( m_planepts, globalErrorStream() );
+                               globalErrorStream() << "\n";
+                       }
 #endif
-               m_planeCached = plane3_for_points( m_planepts );
+                       m_planeCached = plane3_for_points( m_planepts );
+               }
        }
-}
 
-void reverse(){
-       if ( !isDoom3Plane() ) {
-               vector3_swap( m_planepts[0], m_planepts[2] );
-               MakePlane();
-       }
-       else
-       {
-               m_planeCached = plane3_flipped( m_plane );
-               updateSource();
+       void reverse(){
+               if ( !isDoom3Plane() ) {
+                       vector3_swap( m_planepts[0], m_planepts[2] );
+                       MakePlane();
+               }
+               else
+               {
+                       m_planeCached = plane3_flipped( m_plane );
+                       updateSource();
+               }
        }
-}
 
-void transform( const Matrix4& matrix, bool mirror ){
-       if ( !isDoom3Plane() ) {
+       void transform( const Matrix4& matrix, bool mirror ){
+               if ( !isDoom3Plane() ) {
 
 #if 0
-               bool off = check_plane_is_integer( planePoints() );
+                       bool off = check_plane_is_integer( planePoints() );
 #endif
 
-               matrix4_transform_point( matrix, m_planepts[0] );
-               matrix4_transform_point( matrix, m_planepts[1] );
-               matrix4_transform_point( matrix, m_planepts[2] );
+                       matrix4_transform_point( matrix, m_planepts[0] );
+                       matrix4_transform_point( matrix, m_planepts[1] );
+                       matrix4_transform_point( matrix, m_planepts[2] );
 
-               if ( mirror ) {
-                       reverse();
-               }
+                       if ( mirror ) {
+                               reverse();
+                       }
 
 #if 0
-               if ( check_plane_is_integer( planePoints() ) ) {
-                       if ( !off ) {
-                               globalErrorStream() << "caused by transform\n";
+                       if ( check_plane_is_integer( planePoints() ) ) {
+                               if ( !off ) {
+                                       globalErrorStream() << "caused by transform\n";
+                               }
                        }
-               }
 #endif
-               MakePlane();
-       }
-       else
-       {
-               m_planeCached = Plane3_applyTransform( m_planeCached, matrix );
-               updateSource();
+                       MakePlane();
+               }
+               else
+               {
+                       m_planeCached = Plane3_applyTransform( m_planeCached, matrix );
+                       updateSource();
+               }
        }
-}
 
-void offset( float offset ){
-       if ( !isDoom3Plane() ) {
-               Vector3 move( vector3_scaled( m_planeCached.normal(), -offset ) );
+       void offset( float offset ){
+               if ( !isDoom3Plane() ) {
+                       Vector3 move( vector3_scaled( m_planeCached.normal(), -offset ) );
 
-               vector3_subtract( m_planepts[0], move );
-               vector3_subtract( m_planepts[1], move );
-               vector3_subtract( m_planepts[2], move );
+                       vector3_subtract( m_planepts[0], move );
+                       vector3_subtract( m_planepts[1], move );
+                       vector3_subtract( m_planepts[2], move );
 
-               MakePlane();
-       }
-       else
-       {
-               m_planeCached.d += offset;
-               updateSource();
+                       MakePlane();
+               }
+               else
+               {
+                       m_planeCached.d += offset;
+                       updateSource();
+               }
        }
-}
-
-void updateTranslated(){
-       m_planeCached = Plane3_applyTranslation( m_plane, m_funcStaticOrigin );
-}
-
-void updateSource(){
-       m_plane = Plane3_applyTranslation( m_planeCached, vector3_negated( m_funcStaticOrigin ) );
-}
 
+       void updateTranslated(){
+               m_planeCached = Plane3_applyTranslation( m_plane, m_funcStaticOrigin );
+       }
 
-PlanePoints& planePoints(){
-       return m_planepts;
-}
+       void updateSource(){
+               m_plane = Plane3_applyTranslation( m_planeCached, vector3_negated( m_funcStaticOrigin ) );
+       }
 
-const PlanePoints& planePoints() const {
-       return m_planepts;
-}
 
-const Plane3& plane3() const {
-       return m_planeCached;
-}
+       PlanePoints& planePoints(){
+               return m_planepts;
+       }
 
-void setDoom3Plane( const Plane3& plane ){
-       m_plane = plane;
-       updateTranslated();
-}
+       const PlanePoints& planePoints() const {
+               return m_planepts;
+       }
 
-const Plane3& getDoom3Plane() const {
-       return m_plane;
-}
+       const Plane3& plane3() const {
+               return m_planeCached;
+       }
 
-void copy( const FacePlane& other ){
-       if ( !isDoom3Plane() ) {
-               planepts_assign( m_planepts, other.m_planepts );
-               MakePlane();
+       void setDoom3Plane( const Plane3& plane ){
+               m_plane = plane;
+               updateTranslated();
        }
-       else
-       {
-               m_planeCached = other.m_plane;
-               updateSource();
+
+       const Plane3& getDoom3Plane() const {
+               return m_plane;
        }
-}
 
-void copy( const Vector3& p0, const Vector3& p1, const Vector3& p2 ){
-       if ( !isDoom3Plane() ) {
-               m_planepts[0] = p0;
-               m_planepts[1] = p1;
-               m_planepts[2] = p2;
-               MakePlane();
+       void copy( const FacePlane& other ){
+               if ( !isDoom3Plane() ) {
+                       planepts_assign( m_planepts, other.m_planepts );
+                       MakePlane();
+               }
+               else
+               {
+                       m_planeCached = other.m_plane;
+                       updateSource();
+               }
        }
-       else
-       {
-               m_planeCached = plane3_for_points( p2, p1, p0 );
-               updateSource();
+
+       void copy( const Vector3& p0, const Vector3& p1, const Vector3& p2 ){
+               if ( !isDoom3Plane() ) {
+                       m_planepts[0] = p0;
+                       m_planepts[1] = p1;
+                       m_planepts[2] = p2;
+                       MakePlane();
+               }
+               else
+               {
+                       m_planeCached = plane3_for_points( p2, p1, p0 );
+                       updateSource();
+               }
        }
-}
 };
 
 inline void Winding_testSelect( Winding& winding, SelectionTest& test, SelectionIntersection& best ){
@@ -850,7 +849,7 @@ class Face;
 class FaceFilter
 {
 public:
-virtual bool filter( const Face& face ) const = 0;
+       virtual bool filter( const Face& face ) const = 0;
 };
 
 bool face_filtered( Face& face );
@@ -867,13 +866,10 @@ extern bool g_brush_texturelock_enabled;
 class FaceObserver
 {
 public:
-virtual void planeChanged() = 0;
-
-virtual void connectivityChanged() = 0;
-
-virtual void shaderChanged() = 0;
-
-virtual void evaluateTransform() = 0;
+       virtual void planeChanged() = 0;
+       virtual void connectivityChanged() = 0;
+       virtual void shaderChanged() = 0;
+       virtual void evaluateTransform() = 0;
 };
 
 class Face :
@@ -1312,21 +1308,21 @@ bool is_bounded() const {
 
 class FaceVertexId
 {
-std::size_t m_face;
-std::size_t m_vertex;
+       std::size_t m_face;
+       std::size_t m_vertex;
 
 public:
-FaceVertexId( std::size_t face, std::size_t vertex )
-       : m_face( face ), m_vertex( vertex ){
-}
+       FaceVertexId( std::size_t face, std::size_t vertex )
+               : m_face( face ), m_vertex( vertex ){
+       }
 
-std::size_t getFace() const {
-       return m_face;
-}
+       std::size_t getFace() const {
+               return m_face;
+       }
 
-std::size_t getVertex() const {
-       return m_vertex;
-}
+       std::size_t getVertex() const {
+               return m_vertex;
+       }
 };
 
 typedef std::size_t faceIndex_t;
@@ -1390,7 +1386,7 @@ typedef std::vector<Brush*> brush_vector_t;
 class BrushFilter
 {
 public:
-virtual bool filter( const Brush& brush ) const = 0;
+       virtual bool filter( const Brush& brush ) const = 0;
 };
 
 bool brush_filtered( Brush& brush );
@@ -1434,91 +1430,81 @@ inline FaceVertexId next_vertex( const Faces& faces, FaceVertexId faceVertex ){
 
 class SelectableEdge
 {
-Vector3 getEdge() const {
-       const Winding& winding = getFace().getWinding();
-       return vector3_mid( winding[m_faceVertex.getVertex()].vertex, winding[Winding_next( winding, m_faceVertex.getVertex() )].vertex );
-}
+       Vector3 getEdge() const {
+               const Winding& winding = getFace().getWinding();
+               return vector3_mid( winding[m_faceVertex.getVertex()].vertex, winding[Winding_next( winding, m_faceVertex.getVertex() )].vertex );
+       }
 
 public:
-Faces& m_faces;
-FaceVertexId m_faceVertex;
+       Faces& m_faces;
+       FaceVertexId m_faceVertex;
 
-SelectableEdge( Faces& faces, FaceVertexId faceVertex )
-       : m_faces( faces ), m_faceVertex( faceVertex ){
-}
+       SelectableEdge( Faces& faces, FaceVertexId faceVertex )
+               : m_faces( faces ), m_faceVertex( faceVertex ){
+       }
 
-SelectableEdge& operator=( const SelectableEdge& other ){
-       m_faceVertex = other.m_faceVertex;
-       return *this;
-}
+       SelectableEdge& operator=( const SelectableEdge& other ){
+               m_faceVertex = other.m_faceVertex;
+               return *this;
+       }
 
-Face& getFace() const {
-       return *m_faces[m_faceVertex.getFace()];
-}
+       Face& getFace() const {
+               return *m_faces[m_faceVertex.getFace()];
+       }
 
-void testSelect( SelectionTest& test, SelectionIntersection& best ){
-       test.TestPoint( getEdge(), best );
-}
+       void testSelect( SelectionTest& test, SelectionIntersection& best ){
+               test.TestPoint( getEdge(), best );
+       }
 };
 
 class SelectableVertex
 {
-Vector3 getVertex() const {
-       return getFace().getWinding()[m_faceVertex.getVertex()].vertex;
-}
+       Vector3 getVertex() const {
+               return getFace().getWinding()[m_faceVertex.getVertex()].vertex;
+       }
 
 public:
-Faces& m_faces;
-FaceVertexId m_faceVertex;
+       Faces& m_faces;
+       FaceVertexId m_faceVertex;
 
-SelectableVertex( Faces& faces, FaceVertexId faceVertex )
-       : m_faces( faces ), m_faceVertex( faceVertex ){
-}
+       SelectableVertex( Faces& faces, FaceVertexId faceVertex )
+               : m_faces( faces ), m_faceVertex( faceVertex ){
+       }
 
-SelectableVertex& operator=( const SelectableVertex& other ){
-       m_faceVertex = other.m_faceVertex;
-       return *this;
-}
+       SelectableVertex& operator=( const SelectableVertex& other ){
+               m_faceVertex = other.m_faceVertex;
+               return *this;
+       }
 
-Face& getFace() const {
-       return *m_faces[m_faceVertex.getFace()];
-}
+       Face& getFace() const {
+               return *m_faces[m_faceVertex.getFace()];
+       }
 
-void testSelect( SelectionTest& test, SelectionIntersection& best ){
-       test.TestPoint( getVertex(), best );
-}
+       void testSelect( SelectionTest& test, SelectionIntersection& best ){
+               test.TestPoint( getVertex(), best );
+       }
 };
 
 class BrushObserver
 {
 public:
-virtual void reserve( std::size_t size ) = 0;
-
-virtual void clear() = 0;
-
-virtual void push_back( Face& face ) = 0;
-
-virtual void pop_back() = 0;
-
-virtual void erase( std::size_t index ) = 0;
-
-virtual void connectivityChanged() = 0;
-
-virtual void edge_clear() = 0;
-
-virtual void edge_push_back( SelectableEdge& edge ) = 0;
-
-virtual void vertex_clear() = 0;
-
-virtual void vertex_push_back( SelectableVertex& vertex ) = 0;
-
-virtual void DEBUG_verify() const = 0;
+       virtual void reserve( std::size_t size ) = 0;
+       virtual void clear() = 0;
+       virtual void push_back( Face& face ) = 0;
+       virtual void pop_back() = 0;
+       virtual void erase( std::size_t index ) = 0;
+       virtual void connectivityChanged() = 0;
+       virtual void edge_clear() = 0;
+       virtual void edge_push_back( SelectableEdge& edge ) = 0;
+       virtual void vertex_clear() = 0;
+       virtual void vertex_push_back( SelectableVertex& vertex ) = 0;
+       virtual void DEBUG_verify() const = 0;
 };
 
 class BrushVisitor
 {
 public:
-virtual void visit( Face& face ) const = 0;
+       virtual void visit( Face& face ) const = 0;
 };
 
 class Brush :
@@ -1533,878 +1519,878 @@ class Brush :
        public BrushDoom3
 {
 private:
-scene::Node* m_node;
-typedef UniqueSet<BrushObserver*> Observers;
-Observers m_observers;
-UndoObserver* m_undoable_observer;
-MapFile* m_map;
+       scene::Node* m_node;
+       typedef UniqueSet<BrushObserver*> Observers;
+       Observers m_observers;
+       UndoObserver* m_undoable_observer;
+       MapFile* m_map;
 
-// state
-Faces m_faces;
-// ----
+       // state
+       Faces m_faces;
+       // ----
 
-// cached data compiled from state
-Array<PointVertex> m_faceCentroidPoints;
-RenderablePointArray m_render_faces;
+       // cached data compiled from state
+       Array<PointVertex> m_faceCentroidPoints;
+       RenderablePointArray m_render_faces;
 
-Array<PointVertex> m_uniqueVertexPoints;
-typedef std::vector<SelectableVertex> SelectableVertices;
-SelectableVertices m_select_vertices;
-RenderablePointArray m_render_vertices;
+       Array<PointVertex> m_uniqueVertexPoints;
+       typedef std::vector<SelectableVertex> SelectableVertices;
+       SelectableVertices m_select_vertices;
+       RenderablePointArray m_render_vertices;
 
-Array<PointVertex> m_uniqueEdgePoints;
-typedef std::vector<SelectableEdge> SelectableEdges;
-SelectableEdges m_select_edges;
-RenderablePointArray m_render_edges;
+       Array<PointVertex> m_uniqueEdgePoints;
+       typedef std::vector<SelectableEdge> SelectableEdges;
+       SelectableEdges m_select_edges;
+       RenderablePointArray m_render_edges;
 
-Array<EdgeRenderIndices> m_edge_indices;
-Array<EdgeFaces> m_edge_faces;
+       Array<EdgeRenderIndices> m_edge_indices;
+       Array<EdgeFaces> m_edge_faces;
 
-AABB m_aabb_local;
-// ----
+       AABB m_aabb_local;
+       // ----
 
-Callback<void()> m_evaluateTransform;
-Callback<void()> m_boundsChanged;
+       Callback<void()> m_evaluateTransform;
+       Callback<void()> m_boundsChanged;
 
-mutable bool m_planeChanged;   // b-rep evaluation required
-mutable bool m_transformChanged;   // transform evaluation required
-// ----
+       mutable bool m_planeChanged;   // b-rep evaluation required
+       mutable bool m_transformChanged;   // transform evaluation required
+       // ----
 
 public:
-STRING_CONSTANT( Name, "Brush" );
-
-Callback<void()> m_lightsChanged;
-
-// static data
-static Shader* m_state_point;
-// ----
-
-static EBrushType m_type;
-static double m_maxWorldCoord;
+       STRING_CONSTANT( Name, "Brush" );
+
+       Callback<void()> m_lightsChanged;
+
+       // static data
+       static Shader* m_state_point;
+       // ----
+
+       static EBrushType m_type;
+       static double m_maxWorldCoord;
+
+       Brush( scene::Node& node, const Callback<void()>& evaluateTransform, const Callback<void()>& boundsChanged ) :
+               m_node( &node ),
+               m_undoable_observer( 0 ),
+               m_map( 0 ),
+               m_render_faces( m_faceCentroidPoints, GL_POINTS ),
+               m_render_vertices( m_uniqueVertexPoints, GL_POINTS ),
+               m_render_edges( m_uniqueEdgePoints, GL_POINTS ),
+               m_evaluateTransform( evaluateTransform ),
+               m_boundsChanged( boundsChanged ),
+               m_planeChanged( false ),
+               m_transformChanged( false ){
+               planeChanged();
+       }
+       Brush( const Brush& other, scene::Node& node, const Callback<void()>& evaluateTransform, const Callback<void()>& boundsChanged ) :
+               m_node( &node ),
+               m_undoable_observer( 0 ),
+               m_map( 0 ),
+               m_render_faces( m_faceCentroidPoints, GL_POINTS ),
+               m_render_vertices( m_uniqueVertexPoints, GL_POINTS ),
+               m_render_edges( m_uniqueEdgePoints, GL_POINTS ),
+               m_evaluateTransform( evaluateTransform ),
+               m_boundsChanged( boundsChanged ),
+               m_planeChanged( false ),
+               m_transformChanged( false ){
+               copy( other );
+       }
+
+       Brush( const Brush& other ) :
+               TransformNode( other ),
+               Bounded( other ),
+               Cullable( other ),
+               Snappable(),
+               Undoable( other ),
+               FaceObserver( other ),
+               Filterable( other ),
+               Nameable( other ),
+               BrushDoom3( other ),
+               m_node( 0 ),
+               m_undoable_observer( 0 ),
+               m_map( 0 ),
+               m_render_faces( m_faceCentroidPoints, GL_POINTS ),
+               m_render_vertices( m_uniqueVertexPoints, GL_POINTS ),
+               m_render_edges( m_uniqueEdgePoints, GL_POINTS ),
+               m_planeChanged( false ),
+               m_transformChanged( false ){
+               copy( other );
+       }
+
+       ~Brush(){
+               ASSERT_MESSAGE( m_observers.empty(), "Brush::~Brush: observers still attached" );
+       }
+
+       // assignment not supported
+       Brush& operator=( const Brush& other );
+
+       void setDoom3GroupOrigin( const Vector3& origin ){
+               //globalOutputStream() << "func_static origin before: " << m_funcStaticOrigin << " after: " << origin << "\n";
+               for ( Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i )
+               {
+                       ( *i )->getPlane().m_funcStaticOrigin = origin;
+                       ( *i )->getPlane().updateTranslated();
+                       ( *i )->planeChanged();
+               }
+               planeChanged();
+       }
 
-Brush( scene::Node& node, const Callback<void()>& evaluateTransform, const Callback<void()>& boundsChanged ) :
-       m_node( &node ),
-       m_undoable_observer( 0 ),
-       m_map( 0 ),
-       m_render_faces( m_faceCentroidPoints, GL_POINTS ),
-       m_render_vertices( m_uniqueVertexPoints, GL_POINTS ),
-       m_render_edges( m_uniqueEdgePoints, GL_POINTS ),
-       m_evaluateTransform( evaluateTransform ),
-       m_boundsChanged( boundsChanged ),
-       m_planeChanged( false ),
-       m_transformChanged( false ){
-       planeChanged();
-}
-Brush( const Brush& other, scene::Node& node, const Callback<void()>& evaluateTransform, const Callback<void()>& boundsChanged ) :
-       m_node( &node ),
-       m_undoable_observer( 0 ),
-       m_map( 0 ),
-       m_render_faces( m_faceCentroidPoints, GL_POINTS ),
-       m_render_vertices( m_uniqueVertexPoints, GL_POINTS ),
-       m_render_edges( m_uniqueEdgePoints, GL_POINTS ),
-       m_evaluateTransform( evaluateTransform ),
-       m_boundsChanged( boundsChanged ),
-       m_planeChanged( false ),
-       m_transformChanged( false ){
-       copy( other );
-}
-
-Brush( const Brush& other ) :
-       TransformNode( other ),
-       Bounded( other ),
-       Cullable( other ),
-       Snappable(),
-       Undoable( other ),
-       FaceObserver( other ),
-       Filterable( other ),
-       Nameable( other ),
-       BrushDoom3( other ),
-       m_node( 0 ),
-       m_undoable_observer( 0 ),
-       m_map( 0 ),
-       m_render_faces( m_faceCentroidPoints, GL_POINTS ),
-       m_render_vertices( m_uniqueVertexPoints, GL_POINTS ),
-       m_render_edges( m_uniqueEdgePoints, GL_POINTS ),
-       m_planeChanged( false ),
-       m_transformChanged( false ){
-       copy( other );
-}
+       void attach( BrushObserver& observer ){
+               for ( Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i )
+               {
+                       observer.push_back( *( *i ) );
+               }
 
-~Brush(){
-       ASSERT_MESSAGE( m_observers.empty(), "Brush::~Brush: observers still attached" );
-}
+               for ( SelectableEdges::iterator i = m_select_edges.begin(); i != m_select_edges.end(); ++i )
+               {
+                       observer.edge_push_back( *i );
+               }
 
-// assignment not supported
-Brush& operator=( const Brush& other );
+               for ( SelectableVertices::iterator i = m_select_vertices.begin(); i != m_select_vertices.end(); ++i )
+               {
+                       observer.vertex_push_back( *i );
+               }
 
-void setDoom3GroupOrigin( const Vector3& origin ){
-       //globalOutputStream() << "func_static origin before: " << m_funcStaticOrigin << " after: " << origin << "\n";
-       for ( Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i )
-       {
-               ( *i )->getPlane().m_funcStaticOrigin = origin;
-               ( *i )->getPlane().updateTranslated();
-               ( *i )->planeChanged();
+               m_observers.insert( &observer );
        }
-       planeChanged();
-}
 
-void attach( BrushObserver& observer ){
-       for ( Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i )
-       {
-               observer.push_back( *( *i ) );
+       void detach( BrushObserver& observer ){
+               m_observers.erase( &observer );
        }
 
-       for ( SelectableEdges::iterator i = m_select_edges.begin(); i != m_select_edges.end(); ++i )
-       {
-               observer.edge_push_back( *i );
+       void forEachFace( const BrushVisitor& visitor ) const {
+               for ( Faces::const_iterator i = m_faces.begin(); i != m_faces.end(); ++i )
+               {
+                       visitor.visit( *( *i ) );
+               }
        }
 
-       for ( SelectableVertices::iterator i = m_select_vertices.begin(); i != m_select_vertices.end(); ++i )
-       {
-               observer.vertex_push_back( *i );
+       void forEachFace_instanceAttach( MapFile* map ) const {
+               for ( Faces::const_iterator i = m_faces.begin(); i != m_faces.end(); ++i )
+               {
+                       ( *i )->instanceAttach( map );
+               }
        }
 
-       m_observers.insert( &observer );
-}
+       void forEachFace_instanceDetach( MapFile* map ) const {
+               for ( Faces::const_iterator i = m_faces.begin(); i != m_faces.end(); ++i )
+               {
+                       ( *i )->instanceDetach( map );
+               }
+       }
 
-void detach( BrushObserver& observer ){
-       m_observers.erase( &observer );
-}
+       InstanceCounter m_instanceCounter;
 
-void forEachFace( const BrushVisitor& visitor ) const {
-       for ( Faces::const_iterator i = m_faces.begin(); i != m_faces.end(); ++i )
-       {
-               visitor.visit( *( *i ) );
+       void instanceAttach( const scene::Path& path ){
+               if ( ++m_instanceCounter.m_count == 1 ) {
+                       m_map = path_find_mapfile( path.begin(), path.end() );
+                       m_undoable_observer = GlobalUndoSystem().observer( this );
+                       GlobalFilterSystem().registerFilterable( *this );
+                       forEachFace_instanceAttach( m_map );
+               }
+               else
+               {
+                       ASSERT_MESSAGE( path_find_mapfile( path.begin(), path.end() ) == m_map, "node is instanced across more than one file" );
+               }
        }
-}
 
-void forEachFace_instanceAttach( MapFile* map ) const {
-       for ( Faces::const_iterator i = m_faces.begin(); i != m_faces.end(); ++i )
-       {
-               ( *i )->instanceAttach( map );
+       void instanceDetach( const scene::Path& path ){
+               if ( --m_instanceCounter.m_count == 0 ) {
+                       forEachFace_instanceDetach( m_map );
+                       GlobalFilterSystem().unregisterFilterable( *this );
+                       m_map = 0;
+                       m_undoable_observer = 0;
+                       GlobalUndoSystem().release( this );
+               }
        }
-}
 
-void forEachFace_instanceDetach( MapFile* map ) const {
-       for ( Faces::const_iterator i = m_faces.begin(); i != m_faces.end(); ++i )
-       {
-               ( *i )->instanceDetach( map );
+       // nameable
+       const char* name() const {
+               return "brush";
        }
-}
-
-InstanceCounter m_instanceCounter;
 
-void instanceAttach( const scene::Path& path ){
-       if ( ++m_instanceCounter.m_count == 1 ) {
-               m_map = path_find_mapfile( path.begin(), path.end() );
-               m_undoable_observer = GlobalUndoSystem().observer( this );
-               GlobalFilterSystem().registerFilterable( *this );
-               forEachFace_instanceAttach( m_map );
-       }
-       else
-       {
-               ASSERT_MESSAGE( path_find_mapfile( path.begin(), path.end() ) == m_map, "node is instanced across more than one file" );
+       void attach( const NameCallback& callback ){
        }
-}
 
-void instanceDetach( const scene::Path& path ){
-       if ( --m_instanceCounter.m_count == 0 ) {
-               forEachFace_instanceDetach( m_map );
-               GlobalFilterSystem().unregisterFilterable( *this );
-               m_map = 0;
-               m_undoable_observer = 0;
-               GlobalUndoSystem().release( this );
+       void detach( const NameCallback& callback ){
        }
-}
 
-// nameable
-const char* name() const {
-       return "brush";
-}
+       // filterable
+       void updateFiltered(){
+               if ( m_node != 0 ) {
+                       if ( brush_filtered( *this ) ) {
+                               m_node->enable( scene::Node::eFiltered );
+                       }
+                       else
+                       {
+                               m_node->disable( scene::Node::eFiltered );
+                       }
+               }
+       }
 
-void attach( const NameCallback& callback ){
-}
+       // observer
+       void planeChanged(){
+               m_planeChanged = true;
+               aabbChanged();
+               m_lightsChanged();
+       }
 
-void detach( const NameCallback& callback ){
-}
+       void shaderChanged(){
+               updateFiltered();
+               planeChanged();
+       }
 
-// filterable
-void updateFiltered(){
-       if ( m_node != 0 ) {
-               if ( brush_filtered( *this ) ) {
-                       m_node->enable( scene::Node::eFiltered );
-               }
-               else
-               {
-                       m_node->disable( scene::Node::eFiltered );
+       void evaluateBRep() const {
+               if ( m_planeChanged ) {
+                       m_planeChanged = false;
+                       const_cast<Brush*>( this )->buildBRep();
                }
        }
-}
 
-// observer
-void planeChanged(){
-       m_planeChanged = true;
-       aabbChanged();
-       m_lightsChanged();
-}
+       void transformChanged(){
+               m_transformChanged = true;
+               planeChanged();
+       }
 
-void shaderChanged(){
-       updateFiltered();
-       planeChanged();
-}
+       typedef MemberCaller<Brush, void(), &Brush::transformChanged> TransformChangedCaller;
 
-void evaluateBRep() const {
-       if ( m_planeChanged ) {
-               m_planeChanged = false;
-               const_cast<Brush*>( this )->buildBRep();
+       void evaluateTransform(){
+               if ( m_transformChanged ) {
+                       m_transformChanged = false;
+                       revertTransform();
+                       m_evaluateTransform();
+               }
        }
-}
 
-void transformChanged(){
-       m_transformChanged = true;
-       planeChanged();
-}
+       const Matrix4& localToParent() const {
+               return g_matrix4_identity;
+       }
 
-typedef MemberCaller<Brush, void(), &Brush::transformChanged> TransformChangedCaller;
+       void aabbChanged(){
+               m_boundsChanged();
+       }
 
-void evaluateTransform(){
-       if ( m_transformChanged ) {
-               m_transformChanged = false;
-               revertTransform();
-               m_evaluateTransform();
+       const AABB& localAABB() const {
+               evaluateBRep();
+               return m_aabb_local;
        }
-}
 
-const Matrix4& localToParent() const {
-       return g_matrix4_identity;
-}
+       VolumeIntersectionValue intersectVolume( const VolumeTest& test, const Matrix4& localToWorld ) const {
+               return test.TestAABB( m_aabb_local, localToWorld );
+       }
 
-void aabbChanged(){
-       m_boundsChanged();
-}
+       void renderComponents( SelectionSystem::EComponentMode mode, Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
+               switch ( mode )
+               {
+               case SelectionSystem::eVertex:
+                       renderer.addRenderable( m_render_vertices, localToWorld );
+                       break;
+               case SelectionSystem::eEdge:
+                       renderer.addRenderable( m_render_edges, localToWorld );
+                       break;
+               case SelectionSystem::eFace:
+                       renderer.addRenderable( m_render_faces, localToWorld );
+                       break;
+               default:
+                       break;
+               }
+       }
 
-const AABB& localAABB() const {
-       evaluateBRep();
-       return m_aabb_local;
-}
+       void transform( const Matrix4& matrix ){
+               bool mirror = matrix4_handedness( matrix ) == MATRIX4_LEFTHANDED;
 
-VolumeIntersectionValue intersectVolume( const VolumeTest& test, const Matrix4& localToWorld ) const {
-       return test.TestAABB( m_aabb_local, localToWorld );
-}
-
-void renderComponents( SelectionSystem::EComponentMode mode, Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
-       switch ( mode )
-       {
-       case SelectionSystem::eVertex:
-               renderer.addRenderable( m_render_vertices, localToWorld );
-               break;
-       case SelectionSystem::eEdge:
-               renderer.addRenderable( m_render_edges, localToWorld );
-               break;
-       case SelectionSystem::eFace:
-               renderer.addRenderable( m_render_faces, localToWorld );
-               break;
-       default:
-               break;
+               for ( Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i )
+               {
+                       ( *i )->transform( matrix, mirror );
+               }
        }
-}
 
-void transform( const Matrix4& matrix ){
-       bool mirror = matrix4_handedness( matrix ) == MATRIX4_LEFTHANDED;
-
-       for ( Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i )
-       {
-               ( *i )->transform( matrix, mirror );
+       void snapto( float snap ){
+               for ( Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i )
+               {
+                       ( *i )->snapto( snap );
+               }
        }
-}
 
-void snapto( float snap ){
-       for ( Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i )
-       {
-               ( *i )->snapto( snap );
+       void revertTransform(){
+               for ( Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i )
+               {
+                       ( *i )->revertTransform();
+               }
        }
-}
 
-void revertTransform(){
-       for ( Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i )
-       {
-               ( *i )->revertTransform();
+       void freezeTransform(){
+               for ( Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i )
+               {
+                       ( *i )->freezeTransform();
+               }
        }
-}
 
-void freezeTransform(){
-       for ( Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i )
-       {
-               ( *i )->freezeTransform();
+       /// \brief Returns the absolute index of the \p faceVertex.
+       std::size_t absoluteIndex( FaceVertexId faceVertex ){
+               std::size_t index = 0;
+               for ( std::size_t i = 0; i < faceVertex.getFace(); ++i )
+               {
+                       index += m_faces[i]->getWinding().numpoints;
+               }
+               return index + faceVertex.getVertex();
        }
-}
 
-/// \brief Returns the absolute index of the \p faceVertex.
-std::size_t absoluteIndex( FaceVertexId faceVertex ){
-       std::size_t index = 0;
-       for ( std::size_t i = 0; i < faceVertex.getFace(); ++i )
-       {
-               index += m_faces[i]->getWinding().numpoints;
+       void appendFaces( const Faces& other ){
+               clear();
+               for ( Faces::const_iterator i = other.begin(); i != other.end(); ++i )
+               {
+                       push_back( *i );
+               }
        }
-       return index + faceVertex.getVertex();
-}
 
-void appendFaces( const Faces& other ){
-       clear();
-       for ( Faces::const_iterator i = other.begin(); i != other.end(); ++i )
+       /// \brief The undo memento for a brush stores only the list of face references - the faces are not copied.
+       class BrushUndoMemento : public UndoMemento
        {
-               push_back( *i );
+       public:
+               BrushUndoMemento( const Faces& faces ) : m_faces( faces ){
        }
-}
 
-/// \brief The undo memento for a brush stores only the list of face references - the faces are not copied.
-class BrushUndoMemento : public UndoMemento
-{
-public:
-BrushUndoMemento( const Faces& faces ) : m_faces( faces ){
-}
-
-void release(){
-       delete this;
-}
-
-Faces m_faces;
-};
-
-void undoSave(){
-       if ( m_map != 0 ) {
-               m_map->changed();
-       }
-       if ( m_undoable_observer != 0 ) {
-               m_undoable_observer->save( this );
+       void release(){
+               delete this;
        }
-}
 
-UndoMemento* exportState() const {
-       return new BrushUndoMemento( m_faces );
-}
+       Faces m_faces;
+       };
 
-void importState( const UndoMemento* state ){
-       undoSave();
-       appendFaces( static_cast<const BrushUndoMemento*>( state )->m_faces );
-       planeChanged();
+       void undoSave(){
+               if ( m_map != 0 ) {
+                       m_map->changed();
+               }
+               if ( m_undoable_observer != 0 ) {
+                       m_undoable_observer->save( this );
+               }
+       }
 
-       for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
-       {
-               ( *i )->DEBUG_verify();
+       UndoMemento* exportState() const {
+               return new BrushUndoMemento( m_faces );
        }
-}
 
-bool isDetail(){
-       return !m_faces.empty() && m_faces.front()->isDetail();
-}
+       void importState( const UndoMemento* state ){
+               undoSave();
+               appendFaces( static_cast<const BrushUndoMemento*>( state )->m_faces );
+               planeChanged();
 
-/// \brief Appends a copy of \p face to the end of the face list.
-Face* addFace( const Face& face ){
-       if ( m_faces.size() == c_brush_maxFaces ) {
-               return 0;
+               for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
+               {
+                       ( *i )->DEBUG_verify();
+               }
        }
-       undoSave();
-       push_back( FaceSmartPointer( new Face( face, this ) ) );
-       m_faces.back()->setDetail( isDetail() );
-       planeChanged();
-       return m_faces.back();
-}
 
-/// \brief Appends a new face constructed from the parameters to the end of the face list.
-Face* addPlane( const Vector3& p0, const Vector3& p1, const Vector3& p2, const char* shader, const TextureProjection& projection ){
-       if ( m_faces.size() == c_brush_maxFaces ) {
-               return 0;
+       bool isDetail(){
+               return !m_faces.empty() && m_faces.front()->isDetail();
        }
-       undoSave();
-       push_back( FaceSmartPointer( new Face( p0, p1, p2, shader, projection, this ) ) );
-       m_faces.back()->setDetail( isDetail() );
-       planeChanged();
-       return m_faces.back();
-}
 
-static void constructStatic( EBrushType type ){
-       m_type = type;
-       Face::m_type = type;
-       FacePlane::m_type = type;
-
-       g_bp_globals.m_texdefTypeId = TEXDEFTYPEID_QUAKE;
-       if ( m_type == eBrushTypeQuake3BP || m_type == eBrushTypeDoom3 || m_type == eBrushTypeQuake4 ) {
-               g_bp_globals.m_texdefTypeId = TEXDEFTYPEID_BRUSHPRIMITIVES;
-               // g_brush_texturelock_enabled = true; // bad idea, this overrides user setting
-       }
-       else if ( m_type == eBrushTypeHalfLife ) {
-               g_bp_globals.m_texdefTypeId = TEXDEFTYPEID_HALFLIFE;
-               // g_brush_texturelock_enabled = true; // bad idea, this overrides user setting
+       /// \brief Appends a copy of \p face to the end of the face list.
+       Face* addFace( const Face& face ){
+               if ( m_faces.size() == c_brush_maxFaces ) {
+                       return 0;
+               }
+               undoSave();
+               push_back( FaceSmartPointer( new Face( face, this ) ) );
+               m_faces.back()->setDetail( isDetail() );
+               planeChanged();
+               return m_faces.back();
        }
 
-       Face::m_quantise = ( m_type == eBrushTypeQuake ) ? quantiseInteger : quantiseFloating;
-
-       m_state_point = GlobalShaderCache().capture( "$POINT" );
-}
-
-static void destroyStatic(){
-       GlobalShaderCache().release( "$POINT" );
-}
+       /// \brief Appends a new face constructed from the parameters to the end of the face list.
+       Face* addPlane( const Vector3& p0, const Vector3& p1, const Vector3& p2, const char* shader, const TextureProjection& projection ){
+               if ( m_faces.size() == c_brush_maxFaces ) {
+                       return 0;
+               }
+               undoSave();
+               push_back( FaceSmartPointer( new Face( p0, p1, p2, shader, projection, this ) ) );
+               m_faces.back()->setDetail( isDetail() );
+               planeChanged();
+               return m_faces.back();
+       }
+
+       static void constructStatic( EBrushType type ){
+               m_type = type;
+               Face::m_type = type;
+               FacePlane::m_type = type;
+
+               g_bp_globals.m_texdefTypeId = TEXDEFTYPEID_QUAKE;
+               if ( m_type == eBrushTypeQuake3BP || m_type == eBrushTypeDoom3 || m_type == eBrushTypeQuake4 ) {
+                       g_bp_globals.m_texdefTypeId = TEXDEFTYPEID_BRUSHPRIMITIVES;
+                       // g_brush_texturelock_enabled = true; // bad idea, this overrides user setting
+               }
+               else if ( m_type == eBrushTypeHalfLife ) {
+                       g_bp_globals.m_texdefTypeId = TEXDEFTYPEID_HALFLIFE;
+                       // g_brush_texturelock_enabled = true; // bad idea, this overrides user setting
+               }
 
-std::size_t DEBUG_size(){
-       return m_faces.size();
-}
+               Face::m_quantise = ( m_type == eBrushTypeQuake ) ? quantiseInteger : quantiseFloating;
 
-typedef Faces::const_iterator const_iterator;
+               m_state_point = GlobalShaderCache().capture( "$POINT" );
+       }
 
-const_iterator begin() const {
-       return m_faces.begin();
-}
+       static void destroyStatic(){
+               GlobalShaderCache().release( "$POINT" );
+       }
 
-const_iterator end() const {
-       return m_faces.end();
-}
+       std::size_t DEBUG_size(){
+               return m_faces.size();
+       }
 
-Face* back(){
-       return m_faces.back();
-}
+       typedef Faces::const_iterator const_iterator;
 
-const Face* back() const {
-       return m_faces.back();
-}
+       const_iterator begin() const {
+               return m_faces.begin();
+       }
 
-void reserve( std::size_t count ){
-       m_faces.reserve( count );
-       for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
-       {
-               ( *i )->reserve( count );
+       const_iterator end() const {
+               return m_faces.end();
        }
-}
 
-void push_back( Faces::value_type face ){
-       m_faces.push_back( face );
-       if ( m_instanceCounter.m_count != 0 ) {
-               m_faces.back()->instanceAttach( m_map );
+       Face* back(){
+               return m_faces.back();
        }
-       for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
-       {
-               ( *i )->push_back( *face );
-               ( *i )->DEBUG_verify();
+
+       const Face* back() const {
+               return m_faces.back();
        }
-}
 
-void pop_back(){
-       if ( m_instanceCounter.m_count != 0 ) {
-               m_faces.back()->instanceDetach( m_map );
+       void reserve( std::size_t count ){
+               m_faces.reserve( count );
+               for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
+               {
+                       ( *i )->reserve( count );
+               }
        }
-       m_faces.pop_back();
-       for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
-       {
-               ( *i )->pop_back();
-               ( *i )->DEBUG_verify();
+
+       void push_back( Faces::value_type face ){
+               m_faces.push_back( face );
+               if ( m_instanceCounter.m_count != 0 ) {
+                       m_faces.back()->instanceAttach( m_map );
+               }
+               for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
+               {
+                       ( *i )->push_back( *face );
+                       ( *i )->DEBUG_verify();
+               }
        }
-}
 
-void erase( std::size_t index ){
-       if ( m_instanceCounter.m_count != 0 ) {
-               m_faces[index]->instanceDetach( m_map );
+       void pop_back(){
+               if ( m_instanceCounter.m_count != 0 ) {
+                       m_faces.back()->instanceDetach( m_map );
+               }
+               m_faces.pop_back();
+               for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
+               {
+                       ( *i )->pop_back();
+                       ( *i )->DEBUG_verify();
+               }
        }
-       m_faces.erase( m_faces.begin() + index );
-       for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
-       {
-               ( *i )->erase( index );
-               ( *i )->DEBUG_verify();
+
+       void erase( std::size_t index ){
+               if ( m_instanceCounter.m_count != 0 ) {
+                       m_faces[index]->instanceDetach( m_map );
+               }
+               m_faces.erase( m_faces.begin() + index );
+               for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
+               {
+                       ( *i )->erase( index );
+                       ( *i )->DEBUG_verify();
+               }
        }
-}
 
-void connectivityChanged(){
-       for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
-       {
-               ( *i )->connectivityChanged();
+       void connectivityChanged(){
+               for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
+               {
+                       ( *i )->connectivityChanged();
+               }
        }
-}
 
 
-void clear(){
-       undoSave();
-       if ( m_instanceCounter.m_count != 0 ) {
-               forEachFace_instanceDetach( m_map );
-       }
-       m_faces.clear();
-       for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
-       {
-               ( *i )->clear();
-               ( *i )->DEBUG_verify();
+       void clear(){
+               undoSave();
+               if ( m_instanceCounter.m_count != 0 ) {
+                       forEachFace_instanceDetach( m_map );
+               }
+               m_faces.clear();
+               for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
+               {
+                       ( *i )->clear();
+                       ( *i )->DEBUG_verify();
+               }
        }
-}
 
-std::size_t size() const {
-       return m_faces.size();
-}
+       std::size_t size() const {
+               return m_faces.size();
+       }
 
-bool empty() const {
-       return m_faces.empty();
-}
+       bool empty() const {
+               return m_faces.empty();
+       }
 
-/// \brief Returns true if any face of the brush contributes to the final B-Rep.
-bool hasContributingFaces() const {
-       for ( const_iterator i = begin(); i != end(); ++i )
-       {
-               if ( ( *i )->contributes() ) {
-                       return true;
+       /// \brief Returns true if any face of the brush contributes to the final B-Rep.
+       bool hasContributingFaces() const {
+               for ( const_iterator i = begin(); i != end(); ++i )
+               {
+                       if ( ( *i )->contributes() ) {
+                               return true;
+                       }
                }
+               return false;
        }
-       return false;
-}
 
-/// \brief Removes faces that do not contribute to the brush. This is useful for cleaning up after CSG operations on the brush.
-/// 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.
-void removeEmptyFaces(){
-       evaluateBRep();
+       /// \brief Removes faces that do not contribute to the brush. This is useful for cleaning up after CSG operations on the brush.
+       /// 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.
+       void removeEmptyFaces(){
+               evaluateBRep();
 
-       {
-               std::size_t i = 0;
-               while ( i < m_faces.size() )
                {
-                       if ( !m_faces[i]->contributes() ) {
-                               erase( i );
-                               planeChanged();
-                       }
-                       else
+                       std::size_t i = 0;
+                       while ( i < m_faces.size() )
                        {
-                               ++i;
+                               if ( !m_faces[i]->contributes() ) {
+                                       erase( i );
+                                       planeChanged();
+                               }
+                               else
+                               {
+                                       ++i;
+                               }
                        }
                }
        }
-}
 
-/// \brief Constructs \p winding from the intersection of \p plane with the other planes of the brush.
-void windingForClipPlane( Winding& winding, const Plane3& plane ) const {
-       FixedWinding buffer[2];
-       bool swap = false;
+       /// \brief Constructs \p winding from the intersection of \p plane with the other planes of the brush.
+       void windingForClipPlane( Winding& winding, const Plane3& plane ) const {
+               FixedWinding buffer[2];
+               bool swap = false;
 
-       // get a poly that covers an effectively infinite area
-       Winding_createInfinite( buffer[swap], plane, m_maxWorldCoord + 1 );
+               // get a poly that covers an effectively infinite area
+               Winding_createInfinite( buffer[swap], plane, m_maxWorldCoord + 1 );
 
-       // chop the poly by all of the other faces
-       {
-               for ( std::size_t i = 0; i < m_faces.size(); ++i )
+               // chop the poly by all of the other faces
                {
-                       const Face& clip = *m_faces[i];
+                       for ( std::size_t i = 0; i < m_faces.size(); ++i )
+                       {
+                               const Face& clip = *m_faces[i];
 
-                       if ( plane3_equal( clip.plane3(), plane )
-                                || !plane3_valid( clip.plane3() ) || !plane_unique( i )
-                                || plane3_opposing( plane, clip.plane3() ) ) {
-                               continue;
-                       }
+                               if ( plane3_equal( clip.plane3(), plane )
+                                        || !plane3_valid( clip.plane3() ) || !plane_unique( i )
+                                        || plane3_opposing( plane, clip.plane3() ) ) {
+                                       continue;
+                               }
 
-                       buffer[!swap].clear();
+                               buffer[!swap].clear();
 
 #if BRUSH_CONNECTIVITY_DEBUG
-                       globalOutputStream() << "clip vs face: " << i << "\n";
+                               globalOutputStream() << "clip vs face: " << i << "\n";
 #endif
 
-                       {
-                               // flip the plane, because we want to keep the back side
-                               Plane3 clipPlane( vector3_negated( clip.plane3().normal() ), -clip.plane3().dist() );
-                               Winding_Clip( buffer[swap], plane, clipPlane, i, buffer[!swap] );
-                       }
+                               {
+                                       // flip the plane, because we want to keep the back side
+                                       Plane3 clipPlane( vector3_negated( clip.plane3().normal() ), -clip.plane3().dist() );
+                                       Winding_Clip( buffer[swap], plane, clipPlane, i, buffer[!swap] );
+                               }
 
 #if BRUSH_CONNECTIVITY_DEBUG
-                       for ( FixedWinding::Points::iterator k = buffer[!swap].points.begin(), j = buffer[!swap].points.end() - 1; k != buffer[!swap].points.end(); j = k, ++k )
-                       {
-                               if ( vector3_length_squared( vector3_subtracted( ( *k ).vertex, ( *j ).vertex ) ) < 1 ) {
-                                       globalOutputStream() << "v: " << std::distance( buffer[!swap].points.begin(), j ) << " tiny edge adjacent to face " << ( *j ).adjacent << "\n";
+                               for ( FixedWinding::Points::iterator k = buffer[!swap].points.begin(), j = buffer[!swap].points.end() - 1; k != buffer[!swap].points.end(); j = k, ++k )
+                               {
+                                       if ( vector3_length_squared( vector3_subtracted( ( *k ).vertex, ( *j ).vertex ) ) < 1 ) {
+                                               globalOutputStream() << "v: " << std::distance( buffer[!swap].points.begin(), j ) << " tiny edge adjacent to face " << ( *j ).adjacent << "\n";
+                                       }
                                }
-                       }
 #endif
 
-                       //ASSERT_MESSAGE(buffer[!swap].numpoints != 1, "created single-point winding");
+                               //ASSERT_MESSAGE(buffer[!swap].numpoints != 1, "created single-point winding");
 
-                       swap = !swap;
+                               swap = !swap;
+                       }
                }
-       }
 
-       Winding_forFixedWinding( winding, buffer[swap] );
+               Winding_forFixedWinding( winding, buffer[swap] );
 
 #if BRUSH_CONNECTIVITY_DEBUG
-       Winding_printConnectivity( winding );
+               Winding_printConnectivity( winding );
 
-       for ( Winding::iterator i = winding.begin(), j = winding.end() - 1; i != winding.end(); j = i, ++i )
-       {
-               if ( vector3_length_squared( vector3_subtracted( ( *i ).vertex, ( *j ).vertex ) ) < 1 ) {
-                       globalOutputStream() << "v: " << std::distance( winding.begin(), j ) << " tiny edge adjacent to face " << ( *j ).adjacent << "\n";
+               for ( Winding::iterator i = winding.begin(), j = winding.end() - 1; i != winding.end(); j = i, ++i )
+               {
+                       if ( vector3_length_squared( vector3_subtracted( ( *i ).vertex, ( *j ).vertex ) ) < 1 ) {
+                               globalOutputStream() << "v: " << std::distance( winding.begin(), j ) << " tiny edge adjacent to face " << ( *j ).adjacent << "\n";
+                       }
                }
-       }
 #endif
-}
+       }
 
-void update_wireframe( RenderableWireframe& wire, const bool* faces_visible ) const {
-       wire.m_faceVertex.resize( m_edge_indices.size() );
-       wire.m_vertices = m_uniqueVertexPoints.data();
-       wire.m_size = 0;
-       for ( std::size_t i = 0; i < m_edge_faces.size(); ++i )
-       {
-               if ( faces_visible[m_edge_faces[i].first]
-                        || faces_visible[m_edge_faces[i].second] ) {
-                       wire.m_faceVertex[wire.m_size++] = m_edge_indices[i];
+       void update_wireframe( RenderableWireframe& wire, const bool* faces_visible ) const {
+               wire.m_faceVertex.resize( m_edge_indices.size() );
+               wire.m_vertices = m_uniqueVertexPoints.data();
+               wire.m_size = 0;
+               for ( std::size_t i = 0; i < m_edge_faces.size(); ++i )
+               {
+                       if ( faces_visible[m_edge_faces[i].first]
+                                || faces_visible[m_edge_faces[i].second] ) {
+                               wire.m_faceVertex[wire.m_size++] = m_edge_indices[i];
+                       }
                }
        }
-}
 
 
-void update_faces_wireframe( Array<PointVertex>& wire, const bool* faces_visible ) const {
-       std::size_t count = 0;
-       for ( std::size_t i = 0; i < m_faceCentroidPoints.size(); ++i )
-       {
-               if ( faces_visible[i] ) {
-                       ++count;
+       void update_faces_wireframe( Array<PointVertex>& wire, const bool* faces_visible ) const {
+               std::size_t count = 0;
+               for ( std::size_t i = 0; i < m_faceCentroidPoints.size(); ++i )
+               {
+                       if ( faces_visible[i] ) {
+                               ++count;
+                       }
                }
-       }
 
-       wire.resize( count );
-       Array<PointVertex>::iterator p = wire.begin();
-       for ( std::size_t i = 0; i < m_faceCentroidPoints.size(); ++i )
-       {
-               if ( faces_visible[i] ) {
-                       *p++ = m_faceCentroidPoints[i];
+               wire.resize( count );
+               Array<PointVertex>::iterator p = wire.begin();
+               for ( std::size_t i = 0; i < m_faceCentroidPoints.size(); ++i )
+               {
+                       if ( faces_visible[i] ) {
+                               *p++ = m_faceCentroidPoints[i];
+                       }
                }
        }
-}
 
-/// \brief Makes this brush a deep-copy of the \p other.
-void copy( const Brush& other ){
-       for ( Faces::const_iterator i = other.m_faces.begin(); i != other.m_faces.end(); ++i )
-       {
-               addFace( *( *i ) );
+       /// \brief Makes this brush a deep-copy of the \p other.
+       void copy( const Brush& other ){
+               for ( Faces::const_iterator i = other.m_faces.begin(); i != other.m_faces.end(); ++i )
+               {
+                       addFace( *( *i ) );
+               }
+               planeChanged();
        }
-       planeChanged();
-}
 
-private:
-void edge_push_back( FaceVertexId faceVertex ){
-       m_select_edges.push_back( SelectableEdge( m_faces, faceVertex ) );
-       for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
-       {
-               ( *i )->edge_push_back( m_select_edges.back() );
+       private:
+       void edge_push_back( FaceVertexId faceVertex ){
+               m_select_edges.push_back( SelectableEdge( m_faces, faceVertex ) );
+               for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
+               {
+                       ( *i )->edge_push_back( m_select_edges.back() );
+               }
        }
-}
 
-void edge_clear(){
-       m_select_edges.clear();
-       for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
-       {
-               ( *i )->edge_clear();
+       void edge_clear(){
+               m_select_edges.clear();
+               for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
+               {
+                       ( *i )->edge_clear();
+               }
        }
-}
 
-void vertex_push_back( FaceVertexId faceVertex ){
-       m_select_vertices.push_back( SelectableVertex( m_faces, faceVertex ) );
-       for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
-       {
-               ( *i )->vertex_push_back( m_select_vertices.back() );
+       void vertex_push_back( FaceVertexId faceVertex ){
+               m_select_vertices.push_back( SelectableVertex( m_faces, faceVertex ) );
+               for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
+               {
+                       ( *i )->vertex_push_back( m_select_vertices.back() );
+               }
        }
-}
 
-void vertex_clear(){
-       m_select_vertices.clear();
-       for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
-       {
-               ( *i )->vertex_clear();
+       void vertex_clear(){
+               m_select_vertices.clear();
+               for ( Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i )
+               {
+                       ( *i )->vertex_clear();
+               }
        }
-}
 
-/// \brief Returns true if the face identified by \p index is preceded by another plane that takes priority over it.
-bool plane_unique( std::size_t index ) const {
-       // duplicate plane
-       for ( std::size_t i = 0; i < m_faces.size(); ++i )
-       {
-               if ( index != i && !plane3_inside( m_faces[index]->plane3(), m_faces[i]->plane3(), index < i ) ) {
-                       return false;
+       /// \brief Returns true if the face identified by \p index is preceded by another plane that takes priority over it.
+       bool plane_unique( std::size_t index ) const {
+               // duplicate plane
+               for ( std::size_t i = 0; i < m_faces.size(); ++i )
+               {
+                       if ( index != i && !plane3_inside( m_faces[index]->plane3(), m_faces[i]->plane3(), index < i ) ) {
+                               return false;
+                       }
                }
+               return true;
        }
-       return true;
-}
 
-/// \brief Removes edges that are smaller than the tolerance used when generating brush windings.
-void removeDegenerateEdges(){
-       for ( std::size_t i = 0; i < m_faces.size(); ++i )
-       {
-               Winding& winding = m_faces[i]->getWinding();
-               for ( Winding::iterator j = winding.begin(); j != winding.end(); )
+       /// \brief Removes edges that are smaller than the tolerance used when generating brush windings.
+       void removeDegenerateEdges(){
+               for ( std::size_t i = 0; i < m_faces.size(); ++i )
                {
-                       std::size_t index = std::distance( winding.begin(), j );
-                       std::size_t next = Winding_next( winding, index );
-                       if ( Edge_isDegenerate( winding[index].vertex, winding[next].vertex ) ) {
+                       Winding& winding = m_faces[i]->getWinding();
+                       for ( Winding::iterator j = winding.begin(); j != winding.end(); )
+                       {
+                               std::size_t index = std::distance( winding.begin(), j );
+                               std::size_t next = Winding_next( winding, index );
+                               if ( Edge_isDegenerate( winding[index].vertex, winding[next].vertex ) ) {
 #if BRUSH_DEGENERATE_DEBUG
-                               globalOutputStream() << "Brush::buildWindings: face " << i << ": degenerate edge adjacent to " << winding[index].adjacent << "\n";
+                                       globalOutputStream() << "Brush::buildWindings: face " << i << ": degenerate edge adjacent to " << winding[index].adjacent << "\n";
 #endif
-                               Winding& other = m_faces[winding[index].adjacent]->getWinding();
-                               std::size_t adjacent = Winding_FindAdjacent( other, i );
-                               if ( adjacent != c_brush_maxFaces ) {
-                                       other.erase( other.begin() + adjacent );
+                                       Winding& other = m_faces[winding[index].adjacent]->getWinding();
+                                       std::size_t adjacent = Winding_FindAdjacent( other, i );
+                                       if ( adjacent != c_brush_maxFaces ) {
+                                               other.erase( other.begin() + adjacent );
+                                       }
+                                       winding.erase( j );
+                               }
+                               else
+                               {
+                                       ++j;
                                }
-                               winding.erase( j );
-                       }
-                       else
-                       {
-                               ++j;
                        }
                }
        }
-}
 
-/// \brief Invalidates faces that have only two vertices in their winding, while preserving edge-connectivity information.
-void removeDegenerateFaces(){
-       // save adjacency info for degenerate faces
-       for ( std::size_t i = 0; i < m_faces.size(); ++i )
-       {
-               Winding& degen = m_faces[i]->getWinding();
+       /// \brief Invalidates faces that have only two vertices in their winding, while preserving edge-connectivity information.
+       void removeDegenerateFaces(){
+               // save adjacency info for degenerate faces
+               for ( std::size_t i = 0; i < m_faces.size(); ++i )
+               {
+                       Winding& degen = m_faces[i]->getWinding();
 
-               if ( degen.numpoints == 2 ) {
+                       if ( degen.numpoints == 2 ) {
 #if BRUSH_DEGENERATE_DEBUG
-                       globalOutputStream() << "Brush::buildWindings: face " << i << ": degenerate winding adjacent to " << degen[0].adjacent << ", " << degen[1].adjacent << "\n";
+                               globalOutputStream() << "Brush::buildWindings: face " << i << ": degenerate winding adjacent to " << degen[0].adjacent << ", " << degen[1].adjacent << "\n";
 #endif
-                       // this is an "edge" face, where the plane touches the edge of the brush
-                       {
-                               Winding& winding = m_faces[degen[0].adjacent]->getWinding();
-                               std::size_t index = Winding_FindAdjacent( winding, i );
-                               if ( index != c_brush_maxFaces ) {
+                               // this is an "edge" face, where the plane touches the edge of the brush
+                               {
+                                       Winding& winding = m_faces[degen[0].adjacent]->getWinding();
+                                       std::size_t index = Winding_FindAdjacent( winding, i );
+                                       if ( index != c_brush_maxFaces ) {
 #if BRUSH_DEGENERATE_DEBUG
-                                       globalOutputStream() << "Brush::buildWindings: face " << degen[0].adjacent << ": remapping adjacent " << winding[index].adjacent << " to " << degen[1].adjacent << "\n";
+                                               globalOutputStream() << "Brush::buildWindings: face " << degen[0].adjacent << ": remapping adjacent " << winding[index].adjacent << " to " << degen[1].adjacent << "\n";
 #endif
-                                       winding[index].adjacent = degen[1].adjacent;
+                                               winding[index].adjacent = degen[1].adjacent;
+                                       }
                                }
-                       }
 
-                       {
-                               Winding& winding = m_faces[degen[1].adjacent]->getWinding();
-                               std::size_t index = Winding_FindAdjacent( winding, i );
-                               if ( index != c_brush_maxFaces ) {
+                               {
+                                       Winding& winding = m_faces[degen[1].adjacent]->getWinding();
+                                       std::size_t index = Winding_FindAdjacent( winding, i );
+                                       if ( index != c_brush_maxFaces ) {
 #if BRUSH_DEGENERATE_DEBUG
-                                       globalOutputStream() << "Brush::buildWindings: face " << degen[1].adjacent << ": remapping adjacent " << winding[index].adjacent << " to " << degen[0].adjacent << "\n";
+                                               globalOutputStream() << "Brush::buildWindings: face " << degen[1].adjacent << ": remapping adjacent " << winding[index].adjacent << " to " << degen[0].adjacent << "\n";
 #endif
-                                       winding[index].adjacent = degen[0].adjacent;
+                                               winding[index].adjacent = degen[0].adjacent;
+                                       }
                                }
-                       }
 
-                       degen.resize( 0 );
+                               degen.resize( 0 );
+                       }
                }
        }
-}
 
-/// \brief Removes edges that have the same adjacent-face as their immediate neighbour.
-void removeDuplicateEdges(){
-       // verify face connectivity graph
-       for ( std::size_t i = 0; i < m_faces.size(); ++i )
-       {
-               //if(m_faces[i]->contributes())
+       /// \brief Removes edges that have the same adjacent-face as their immediate neighbour.
+       void removeDuplicateEdges(){
+               // verify face connectivity graph
+               for ( std::size_t i = 0; i < m_faces.size(); ++i )
                {
-                       Winding& winding = m_faces[i]->getWinding();
-                       for ( std::size_t j = 0; j != winding.numpoints; )
+                       //if(m_faces[i]->contributes())
                        {
-                               std::size_t next = Winding_next( winding, j );
-                               if ( winding[j].adjacent == winding[next].adjacent ) {
+                               Winding& winding = m_faces[i]->getWinding();
+                               for ( std::size_t j = 0; j != winding.numpoints; )
+                               {
+                                       std::size_t next = Winding_next( winding, j );
+                                       if ( winding[j].adjacent == winding[next].adjacent ) {
 #if BRUSH_DEGENERATE_DEBUG
-                                       globalOutputStream() << "Brush::buildWindings: face " << i << ": removed duplicate edge adjacent to face " << winding[j].adjacent << "\n";
+                                               globalOutputStream() << "Brush::buildWindings: face " << i << ": removed duplicate edge adjacent to face " << winding[j].adjacent << "\n";
 #endif
-                                       winding.erase( winding.begin() + next );
-                               }
-                               else
-                               {
-                                       ++j;
+                                               winding.erase( winding.begin() + next );
+                                       }
+                                       else
+                                       {
+                                               ++j;
+                                       }
                                }
                        }
                }
        }
-}
 
-/// \brief Removes edges that do not have a matching pair in their adjacent-face.
-void verifyConnectivityGraph(){
-       // verify face connectivity graph
-       for ( std::size_t i = 0; i < m_faces.size(); ++i )
-       {
-               //if(m_faces[i]->contributes())
+       /// \brief Removes edges that do not have a matching pair in their adjacent-face.
+       void verifyConnectivityGraph(){
+               // verify face connectivity graph
+               for ( std::size_t i = 0; i < m_faces.size(); ++i )
                {
-                       Winding& winding = m_faces[i]->getWinding();
-                       for ( Winding::iterator j = winding.begin(); j != winding.end(); )
+                       //if(m_faces[i]->contributes())
                        {
+                               Winding& winding = m_faces[i]->getWinding();
+                               for ( Winding::iterator j = winding.begin(); j != winding.end(); )
+                               {
 #if BRUSH_CONNECTIVITY_DEBUG
-                               globalOutputStream() << "Brush::buildWindings: face " << i << ": adjacent to face " << ( *j ).adjacent << "\n";
+                                       globalOutputStream() << "Brush::buildWindings: face " << i << ": adjacent to face " << ( *j ).adjacent << "\n";
 #endif
-                               // remove unidirectional graph edges
-                               if ( ( *j ).adjacent == c_brush_maxFaces
-                                        || Winding_FindAdjacent( m_faces[( *j ).adjacent]->getWinding(), i ) == c_brush_maxFaces ) {
+                                       // remove unidirectional graph edges
+                                       if ( ( *j ).adjacent == c_brush_maxFaces
+                                                || Winding_FindAdjacent( m_faces[( *j ).adjacent]->getWinding(), i ) == c_brush_maxFaces ) {
 #if BRUSH_CONNECTIVITY_DEBUG
-                                       globalOutputStream() << "Brush::buildWindings: face " << i << ": removing unidirectional connectivity graph edge adjacent to face " << ( *j ).adjacent << "\n";
+                                               globalOutputStream() << "Brush::buildWindings: face " << i << ": removing unidirectional connectivity graph edge adjacent to face " << ( *j ).adjacent << "\n";
 #endif
-                                       winding.erase( j );
-                               }
-                               else
-                               {
-                                       ++j;
+                                               winding.erase( j );
+                                       }
+                                       else
+                                       {
+                                               ++j;
+                                       }
                                }
                        }
                }
        }
-}
 
-/// \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.
-bool isBounded(){
-       for ( const_iterator i = begin(); i != end(); ++i )
-       {
-               if ( !( *i )->is_bounded() ) {
-                       return false;
+       /// \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.
+       bool isBounded(){
+               for ( const_iterator i = begin(); i != end(); ++i )
+               {
+                       if ( !( *i )->is_bounded() ) {
+                               return false;
+                       }
                }
+               return true;
        }
-       return true;
-}
-
-/// \brief Constructs the polygon windings for each face of the brush. Also updates the brush bounding-box and face texture-coordinates.
-bool buildWindings(){
 
-       {
-               m_aabb_local = AABB();
+       /// \brief Constructs the polygon windings for each face of the brush. Also updates the brush bounding-box and face texture-coordinates.
+       bool buildWindings(){
 
-               for ( std::size_t i = 0; i < m_faces.size(); ++i )
                {
-                       Face& f = *m_faces[i];
+                       m_aabb_local = AABB();
 
-                       if ( !plane3_valid( f.plane3() ) || !plane_unique( i ) ) {
-                               f.getWinding().resize( 0 );
-                       }
-                       else
+                       for ( std::size_t i = 0; i < m_faces.size(); ++i )
                        {
+                               Face& f = *m_faces[i];
+
+                               if ( !plane3_valid( f.plane3() ) || !plane_unique( i ) ) {
+                                       f.getWinding().resize( 0 );
+                               }
+                               else
+                               {
 #if BRUSH_CONNECTIVITY_DEBUG
-                               globalOutputStream() << "face: " << i << "\n";
+                                       globalOutputStream() << "face: " << i << "\n";
 #endif
-                               windingForClipPlane( f.getWinding(), f.plane3() );
+                                       windingForClipPlane( f.getWinding(), f.plane3() );
 
-                               // update brush bounds
-                               const Winding& winding = f.getWinding();
-                               for ( Winding::const_iterator i = winding.begin(); i != winding.end(); ++i )
-                               {
-                                       aabb_extend_by_point_safe( m_aabb_local, ( *i ).vertex );
-                               }
+                                       // update brush bounds
+                                       const Winding& winding = f.getWinding();
+                                       for ( Winding::const_iterator i = winding.begin(); i != winding.end(); ++i )
+                                       {
+                                               aabb_extend_by_point_safe( m_aabb_local, ( *i ).vertex );
+                                       }
 
-                               // update texture coordinates
-                               f.EmitTextureCoordinates();
+                                       // update texture coordinates
+                                       f.EmitTextureCoordinates();
+                               }
                        }
                }
-       }
 
-       bool degenerate = !isBounded();
+               bool degenerate = !isBounded();
 
-       if ( !degenerate ) {
-               // clean up connectivity information.
-               // these cleanups must be applied in a specific order.
-               removeDegenerateEdges();
-               removeDegenerateFaces();
-               removeDuplicateEdges();
-               verifyConnectivityGraph();
-       }
+               if ( !degenerate ) {
+                       // clean up connectivity information.
+                       // these cleanups must be applied in a specific order.
+                       removeDegenerateEdges();
+                       removeDegenerateFaces();
+                       removeDuplicateEdges();
+                       verifyConnectivityGraph();
+               }
 
-       return degenerate;
-}
+               return degenerate;
+       }
 
-/// \brief Constructs the face windings and updates anything that depends on them.
-void buildBRep();
+       /// \brief Constructs the face windings and updates anything that depends on them.
+       void buildBRep();
 };
 
 
@@ -2412,32 +2398,32 @@ class FaceInstance;
 
 class FaceInstanceSet
 {
-typedef SelectionList<FaceInstance> FaceInstances;
-FaceInstances m_faceInstances;
+       typedef SelectionList<FaceInstance> FaceInstances;
+       FaceInstances m_faceInstances;
 public:
-void insert( FaceInstance& faceInstance ){
-       m_faceInstances.append( faceInstance );
-}
+       void insert( FaceInstance& faceInstance ){
+               m_faceInstances.append( faceInstance );
+       }
 
-void erase( FaceInstance& faceInstance ){
-       m_faceInstances.erase( faceInstance );
-}
+       void erase( FaceInstance& faceInstance ){
+               m_faceInstances.erase( faceInstance );
+       }
 
-template<typename Functor>
-void foreach( Functor functor ){
-       for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
-       {
-               functor( *( *i ) );
+       template<typename Functor>
+       void foreach( Functor functor ){
+               for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+               {
+                       functor( *( *i ) );
+               }
        }
-}
 
-bool empty() const {
-       return m_faceInstances.empty();
-}
+       bool empty() const {
+               return m_faceInstances.empty();
+       }
 
-FaceInstance& last() const {
-       return m_faceInstances.back();
-}
+       FaceInstance& last() const {
+               return m_faceInstances.back();
+       }
 };
 
 extern FaceInstanceSet g_SelectedFaceInstances;
@@ -2488,498 +2474,498 @@ typedef PlanePointer* PlanesIterator;
 
 class VectorLightList : public LightList
 {
-typedef std::vector<const RendererLight*> Lights;
-Lights m_lights;
+       typedef std::vector<const RendererLight*> Lights;
+       Lights m_lights;
 public:
-void addLight( const RendererLight& light ){
-       m_lights.push_back( &light );
-}
+       void addLight( const RendererLight& light ){
+               m_lights.push_back( &light );
+       }
 
-void clear(){
-       m_lights.clear();
-}
+       void clear(){
+               m_lights.clear();
+       }
 
-void evaluateLights() const {
-}
+       void evaluateLights() const {
+       }
 
-void lightsChanged() const {
-}
+       void lightsChanged() const {
+       }
 
-void forEachLight( const RendererLightCallback& callback ) const {
-       for ( Lights::const_iterator i = m_lights.begin(); i != m_lights.end(); ++i )
-       {
-               callback( *( *i ) );
+       void forEachLight( const RendererLightCallback& callback ) const {
+               for ( Lights::const_iterator i = m_lights.begin(); i != m_lights.end(); ++i )
+               {
+                       callback( *( *i ) );
+               }
        }
-}
 };
 
 class FaceInstance
 {
-Face* m_face;
-ObservedSelectable m_selectable;
-ObservedSelectable m_selectableVertices;
-ObservedSelectable m_selectableEdges;
-SelectionChangeCallback m_selectionChanged;
+       Face* m_face;
+       ObservedSelectable m_selectable;
+       ObservedSelectable m_selectableVertices;
+       ObservedSelectable m_selectableEdges;
+       SelectionChangeCallback m_selectionChanged;
 
-VertexSelection m_vertexSelection;
-VertexSelection m_edgeSelection;
+       VertexSelection m_vertexSelection;
+       VertexSelection m_edgeSelection;
 
 public:
-mutable VectorLightList m_lights;
-
-FaceInstance( Face& face, const SelectionChangeCallback& observer ) :
-       m_face( &face ),
-       m_selectable( SelectedChangedCaller( *this ) ),
-       m_selectableVertices( observer ),
-       m_selectableEdges( observer ),
-       m_selectionChanged( observer ){
-}
-
-FaceInstance( const FaceInstance& other ) :
-       m_face( other.m_face ),
-       m_selectable( SelectedChangedCaller( *this ) ),
-       m_selectableVertices( other.m_selectableVertices ),
-       m_selectableEdges( other.m_selectableEdges ),
-       m_selectionChanged( other.m_selectionChanged ){
-}
-
-FaceInstance& operator=( const FaceInstance& other ){
-       m_face = other.m_face;
-       return *this;
-}
-
-Face& getFace(){
-       return *m_face;
-}
+       mutable VectorLightList m_lights;
 
-const Face& getFace() const {
-       return *m_face;
-}
+       FaceInstance( Face& face, const SelectionChangeCallback& observer ) :
+               m_face( &face ),
+               m_selectable( SelectedChangedCaller( *this ) ),
+               m_selectableVertices( observer ),
+               m_selectableEdges( observer ),
+               m_selectionChanged( observer ){
+       }
 
-void selectedChanged( const Selectable& selectable ){
-       if ( selectable.isSelected() ) {
-               g_SelectedFaceInstances.insert( *this );
+       FaceInstance( const FaceInstance& other ) :
+               m_face( other.m_face ),
+               m_selectable( SelectedChangedCaller( *this ) ),
+               m_selectableVertices( other.m_selectableVertices ),
+               m_selectableEdges( other.m_selectableEdges ),
+               m_selectionChanged( other.m_selectionChanged ){
        }
-       else
-       {
-               g_SelectedFaceInstances.erase( *this );
+
+       FaceInstance& operator=( const FaceInstance& other ){
+               m_face = other.m_face;
+               return *this;
        }
-       m_selectionChanged( selectable );
-}
 
-typedef MemberCaller<FaceInstance, void(const Selectable&), &FaceInstance::selectedChanged> SelectedChangedCaller;
+       Face& getFace(){
+               return *m_face;
+       }
 
-bool selectedVertices() const {
-       return !m_vertexSelection.empty();
-}
+       const Face& getFace() const {
+               return *m_face;
+       }
 
-bool selectedEdges() const {
-       return !m_edgeSelection.empty();
-}
+       void selectedChanged( const Selectable& selectable ){
+               if ( selectable.isSelected() ) {
+                       g_SelectedFaceInstances.insert( *this );
+               }
+               else
+               {
+                       g_SelectedFaceInstances.erase( *this );
+               }
+               m_selectionChanged( selectable );
+       }
 
-bool isSelected() const {
-       return m_selectable.isSelected();
-}
+       typedef MemberCaller<FaceInstance, void(const Selectable&), &FaceInstance::selectedChanged> SelectedChangedCaller;
 
-bool selectedComponents() const {
-       return selectedVertices() || selectedEdges() || isSelected();
-}
+       bool selectedVertices() const {
+               return !m_vertexSelection.empty();
+       }
 
-bool selectedComponents( SelectionSystem::EComponentMode mode ) const {
-       switch ( mode )
-       {
-       case SelectionSystem::eVertex:
-               return selectedVertices();
-       case SelectionSystem::eEdge:
-               return selectedEdges();
-       case SelectionSystem::eFace:
-               return isSelected();
-       default:
-               return false;
+       bool selectedEdges() const {
+               return !m_edgeSelection.empty();
        }
-}
 
-void setSelected( SelectionSystem::EComponentMode mode, bool select ){
-       switch ( mode )
-       {
-       case SelectionSystem::eFace:
-               m_selectable.setSelected( select );
-               break;
-       case SelectionSystem::eVertex:
-               ASSERT_MESSAGE( !select, "select-all not supported" );
+       bool isSelected() const {
+               return m_selectable.isSelected();
+       }
 
-               m_vertexSelection.clear();
-               m_selectableVertices.setSelected( false );
-               break;
-       case SelectionSystem::eEdge:
-               ASSERT_MESSAGE( !select, "select-all not supported" );
+       bool selectedComponents() const {
+               return selectedVertices() || selectedEdges() || isSelected();
+       }
 
-               m_edgeSelection.clear();
-               m_selectableEdges.setSelected( false );
-               break;
-       default:
-               break;
+       bool selectedComponents( SelectionSystem::EComponentMode mode ) const {
+               switch ( mode )
+               {
+               case SelectionSystem::eVertex:
+                       return selectedVertices();
+               case SelectionSystem::eEdge:
+                       return selectedEdges();
+               case SelectionSystem::eFace:
+                       return isSelected();
+               default:
+                       return false;
+               }
        }
-}
 
-template<typename Functor>
-void SelectedVertices_foreach( Functor functor ) const {
-       for ( VertexSelection::const_iterator i = m_vertexSelection.begin(); i != m_vertexSelection.end(); ++i )
-       {
-               std::size_t index = Winding_FindAdjacent( getFace().getWinding(), *i );
-               if ( index != c_brush_maxFaces ) {
-                       functor( getFace().getWinding()[index].vertex );
+       void setSelected( SelectionSystem::EComponentMode mode, bool select ){
+               switch ( mode )
+               {
+               case SelectionSystem::eFace:
+                       m_selectable.setSelected( select );
+                       break;
+               case SelectionSystem::eVertex:
+                       ASSERT_MESSAGE( !select, "select-all not supported" );
+
+                       m_vertexSelection.clear();
+                       m_selectableVertices.setSelected( false );
+                       break;
+               case SelectionSystem::eEdge:
+                       ASSERT_MESSAGE( !select, "select-all not supported" );
+
+                       m_edgeSelection.clear();
+                       m_selectableEdges.setSelected( false );
+                       break;
+               default:
+                       break;
                }
        }
-}
 
-template<typename Functor>
-void SelectedEdges_foreach( Functor functor ) const {
-       for ( VertexSelection::const_iterator i = m_edgeSelection.begin(); i != m_edgeSelection.end(); ++i )
-       {
-               std::size_t index = Winding_FindAdjacent( getFace().getWinding(), *i );
-               if ( index != c_brush_maxFaces ) {
-                       const Winding& winding = getFace().getWinding();
-                       std::size_t adjacent = Winding_next( winding, index );
-                       functor( vector3_mid( winding[index].vertex, winding[adjacent].vertex ) );
+       template<typename Functor>
+       void SelectedVertices_foreach( Functor functor ) const {
+               for ( VertexSelection::const_iterator i = m_vertexSelection.begin(); i != m_vertexSelection.end(); ++i )
+               {
+                       std::size_t index = Winding_FindAdjacent( getFace().getWinding(), *i );
+                       if ( index != c_brush_maxFaces ) {
+                               functor( getFace().getWinding()[index].vertex );
+                       }
                }
        }
-}
 
-template<typename Functor>
-void SelectedFaces_foreach( Functor functor ) const {
-       if ( isSelected() ) {
-               functor( centroid() );
+       template<typename Functor>
+       void SelectedEdges_foreach( Functor functor ) const {
+               for ( VertexSelection::const_iterator i = m_edgeSelection.begin(); i != m_edgeSelection.end(); ++i )
+               {
+                       std::size_t index = Winding_FindAdjacent( getFace().getWinding(), *i );
+                       if ( index != c_brush_maxFaces ) {
+                               const Winding& winding = getFace().getWinding();
+                               std::size_t adjacent = Winding_next( winding, index );
+                               functor( vector3_mid( winding[index].vertex, winding[adjacent].vertex ) );
+                       }
+               }
        }
-}
 
-template<typename Functor>
-void SelectedComponents_foreach( Functor functor ) const {
-       SelectedVertices_foreach( functor );
-       SelectedEdges_foreach( functor );
-       SelectedFaces_foreach( functor );
-}
+       template<typename Functor>
+       void SelectedFaces_foreach( Functor functor ) const {
+               if ( isSelected() ) {
+                       functor( centroid() );
+               }
+       }
 
-void iterate_selected( AABB& aabb ) const {
-       SelectedComponents_foreach([&](const Vector3 &point) {
-               aabb_extend_by_point_safe(aabb, point);
-       });
-}
+       template<typename Functor>
+       void SelectedComponents_foreach( Functor functor ) const {
+               SelectedVertices_foreach( functor );
+               SelectedEdges_foreach( functor );
+               SelectedFaces_foreach( functor );
+       }
 
-void iterate_selected( RenderablePointVector& points ) const {
-       SelectedComponents_foreach([&](const Vector3 &point) {
-               const Colour4b colour_selected(0, 0, 255, 255);
-               points.push_back(pointvertex_for_windingpoint(point, colour_selected));
-       });
-}
+       void iterate_selected( AABB& aabb ) const {
+               SelectedComponents_foreach([&](const Vector3 &point) {
+                       aabb_extend_by_point_safe(aabb, point);
+               });
+       }
 
-bool intersectVolume( const VolumeTest& volume, const Matrix4& localToWorld ) const {
-       return m_face->intersectVolume( volume, localToWorld );
-}
+       void iterate_selected( RenderablePointVector& points ) const {
+               SelectedComponents_foreach([&](const Vector3 &point) {
+                       const Colour4b colour_selected(0, 0, 255, 255);
+                       points.push_back(pointvertex_for_windingpoint(point, colour_selected));
+               });
+       }
 
-void render( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
-       if ( !m_face->isFiltered() && m_face->contributes() && intersectVolume( volume, localToWorld ) ) {
-               renderer.PushState();
-               if ( selectedComponents() ) {
-                       renderer.Highlight( Renderer::eFace );
-               }
-               m_face->render( renderer, localToWorld );
-               renderer.PopState();
+       bool intersectVolume( const VolumeTest& volume, const Matrix4& localToWorld ) const {
+               return m_face->intersectVolume( volume, localToWorld );
        }
-}
 
-void testSelect( SelectionTest& test, SelectionIntersection& best ){
-       if ( !m_face->isFiltered() ) {
-               m_face->testSelect( test, best );
+       void render( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
+               if ( !m_face->isFiltered() && m_face->contributes() && intersectVolume( volume, localToWorld ) ) {
+                       renderer.PushState();
+                       if ( selectedComponents() ) {
+                               renderer.Highlight( Renderer::eFace );
+                       }
+                       m_face->render( renderer, localToWorld );
+                       renderer.PopState();
+               }
        }
-}
 
-void testSelect( Selector& selector, SelectionTest& test ){
-       SelectionIntersection best;
-       testSelect( test, best );
-       if ( best.valid() ) {
-               Selector_add( selector, m_selectable, best );
+       void testSelect( SelectionTest& test, SelectionIntersection& best ){
+               if ( !m_face->isFiltered() ) {
+                       m_face->testSelect( test, best );
+               }
        }
-}
 
-void testSelect_centroid( Selector& selector, SelectionTest& test ){
-       if ( m_face->contributes() && !m_face->isFiltered() ) {
+       void testSelect( Selector& selector, SelectionTest& test ){
                SelectionIntersection best;
-               m_face->testSelect_centroid( test, best );
+               testSelect( test, best );
                if ( best.valid() ) {
                        Selector_add( selector, m_selectable, best );
                }
        }
-}
 
-void selectPlane( Selector& selector, const Line& line, PlanesIterator first, PlanesIterator last, const PlaneCallback& selectedPlaneCallback ){
-       for ( Winding::const_iterator i = getFace().getWinding().begin(); i != getFace().getWinding().end(); ++i )
-       {
-               Vector3 v( vector3_subtracted( line_closest_point( line, ( *i ).vertex ), ( *i ).vertex ) );
-               double dot = vector3_dot( getFace().plane3().normal(), v );
-               if ( dot <= 0 ) {
-                       return;
+       void testSelect_centroid( Selector& selector, SelectionTest& test ){
+               if ( m_face->contributes() && !m_face->isFiltered() ) {
+                       SelectionIntersection best;
+                       m_face->testSelect_centroid( test, best );
+                       if ( best.valid() ) {
+                               Selector_add( selector, m_selectable, best );
+                       }
                }
        }
 
-       Selector_add( selector, m_selectable );
-
-       selectedPlaneCallback( getFace().plane3() );
-}
+       void selectPlane( Selector& selector, const Line& line, PlanesIterator first, PlanesIterator last, const PlaneCallback& selectedPlaneCallback ){
+               for ( Winding::const_iterator i = getFace().getWinding().begin(); i != getFace().getWinding().end(); ++i )
+               {
+                       Vector3 v( vector3_subtracted( line_closest_point( line, ( *i ).vertex ), ( *i ).vertex ) );
+                       double dot = vector3_dot( getFace().plane3().normal(), v );
+                       if ( dot <= 0 ) {
+                               return;
+                       }
+               }
 
-void selectReversedPlane( Selector& selector, const SelectedPlanes& selectedPlanes ){
-       if ( selectedPlanes.contains( plane3_flipped( getFace().plane3() ) ) ) {
                Selector_add( selector, m_selectable );
+
+               selectedPlaneCallback( getFace().plane3() );
        }
-}
 
-void transformComponents( const Matrix4& matrix ){
-       if ( isSelected() ) {
-               m_face->transform( matrix, false );
+       void selectReversedPlane( Selector& selector, const SelectedPlanes& selectedPlanes ){
+               if ( selectedPlanes.contains( plane3_flipped( getFace().plane3() ) ) ) {
+                       Selector_add( selector, m_selectable );
+               }
        }
-       if ( selectedVertices() ) {
-               if ( m_vertexSelection.size() == 1 ) {
-                       matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[1] );
-                       m_face->assign_planepts( m_face->m_move_planeptsTransformed );
+
+       void transformComponents( const Matrix4& matrix ){
+               if ( isSelected() ) {
+                       m_face->transform( matrix, false );
                }
-               else if ( m_vertexSelection.size() == 2 ) {
-                       matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[1] );
-                       matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[2] );
-                       m_face->assign_planepts( m_face->m_move_planeptsTransformed );
+               if ( selectedVertices() ) {
+                       if ( m_vertexSelection.size() == 1 ) {
+                               matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[1] );
+                               m_face->assign_planepts( m_face->m_move_planeptsTransformed );
+                       }
+                       else if ( m_vertexSelection.size() == 2 ) {
+                               matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[1] );
+                               matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[2] );
+                               m_face->assign_planepts( m_face->m_move_planeptsTransformed );
+                       }
+                       else if ( m_vertexSelection.size() >= 3 ) {
+                               matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[0] );
+                               matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[1] );
+                               matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[2] );
+                               m_face->assign_planepts( m_face->m_move_planeptsTransformed );
+                       }
                }
-               else if ( m_vertexSelection.size() >= 3 ) {
-                       matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[0] );
-                       matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[1] );
-                       matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[2] );
-                       m_face->assign_planepts( m_face->m_move_planeptsTransformed );
+               if ( selectedEdges() ) {
+                       if ( m_edgeSelection.size() == 1 ) {
+                               matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[0] );
+                               matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[1] );
+                               m_face->assign_planepts( m_face->m_move_planeptsTransformed );
+                       }
+                       else if ( m_edgeSelection.size() >= 2 ) {
+                               matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[0] );
+                               matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[1] );
+                               matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[2] );
+                               m_face->assign_planepts( m_face->m_move_planeptsTransformed );
+                       }
                }
        }
-       if ( selectedEdges() ) {
-               if ( m_edgeSelection.size() == 1 ) {
-                       matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[0] );
-                       matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[1] );
-                       m_face->assign_planepts( m_face->m_move_planeptsTransformed );
+
+       void snapto( float snap ){
+               m_face->snapto( snap );
+       }
+
+       void snapComponents( float snap ){
+               if ( isSelected() ) {
+                       snapto( snap );
+               }
+               if ( selectedVertices() ) {
+                       vector3_snap( m_face->m_move_planepts[0], snap );
+                       vector3_snap( m_face->m_move_planepts[1], snap );
+                       vector3_snap( m_face->m_move_planepts[2], snap );
+                       m_face->assign_planepts( m_face->m_move_planepts );
+                       planepts_assign( m_face->m_move_planeptsTransformed, m_face->m_move_planepts );
+                       m_face->freezeTransform();
                }
-               else if ( m_edgeSelection.size() >= 2 ) {
-                       matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[0] );
-                       matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[1] );
-                       matrix4_transform_point( matrix, m_face->m_move_planeptsTransformed[2] );
-                       m_face->assign_planepts( m_face->m_move_planeptsTransformed );
+               if ( selectedEdges() ) {
+                       vector3_snap( m_face->m_move_planepts[0], snap );
+                       vector3_snap( m_face->m_move_planepts[1], snap );
+                       vector3_snap( m_face->m_move_planepts[2], snap );
+                       m_face->assign_planepts( m_face->m_move_planepts );
+                       planepts_assign( m_face->m_move_planeptsTransformed, m_face->m_move_planepts );
+                       m_face->freezeTransform();
                }
        }
-}
-
-void snapto( float snap ){
-       m_face->snapto( snap );
-}
 
-void snapComponents( float snap ){
-       if ( isSelected() ) {
-               snapto( snap );
-       }
-       if ( selectedVertices() ) {
-               vector3_snap( m_face->m_move_planepts[0], snap );
-               vector3_snap( m_face->m_move_planepts[1], snap );
-               vector3_snap( m_face->m_move_planepts[2], snap );
-               m_face->assign_planepts( m_face->m_move_planepts );
-               planepts_assign( m_face->m_move_planeptsTransformed, m_face->m_move_planepts );
-               m_face->freezeTransform();
-       }
-       if ( selectedEdges() ) {
-               vector3_snap( m_face->m_move_planepts[0], snap );
-               vector3_snap( m_face->m_move_planepts[1], snap );
-               vector3_snap( m_face->m_move_planepts[2], snap );
-               m_face->assign_planepts( m_face->m_move_planepts );
-               planepts_assign( m_face->m_move_planeptsTransformed, m_face->m_move_planepts );
-               m_face->freezeTransform();
+       void update_move_planepts_vertex( std::size_t index ){
+               m_face->update_move_planepts_vertex( index, m_face->m_move_planepts );
        }
-}
-
-void update_move_planepts_vertex( std::size_t index ){
-       m_face->update_move_planepts_vertex( index, m_face->m_move_planepts );
-}
-
-void update_move_planepts_vertex2( std::size_t index, std::size_t other ){
-       const std::size_t numpoints = m_face->getWinding().numpoints;
-       ASSERT_MESSAGE( index < numpoints, "select_vertex: invalid index" );
 
-       const std::size_t opposite = Winding_Opposite( m_face->getWinding(), index, other );
+       void update_move_planepts_vertex2( std::size_t index, std::size_t other ){
+               const std::size_t numpoints = m_face->getWinding().numpoints;
+               ASSERT_MESSAGE( index < numpoints, "select_vertex: invalid index" );
 
-       if ( triangle_reversed( index, other, opposite ) ) {
-               std::swap( index, other );
-       }
-
-       ASSERT_MESSAGE(
-               triangles_same_winding(
-                       m_face->getWinding()[opposite].vertex,
-                       m_face->getWinding()[index].vertex,
-                       m_face->getWinding()[other].vertex,
-                       m_face->getWinding()[0].vertex,
-                       m_face->getWinding()[1].vertex,
-                       m_face->getWinding()[2].vertex
-                       ),
-               "update_move_planepts_vertex2: error"
-               );
+               const std::size_t opposite = Winding_Opposite( m_face->getWinding(), index, other );
 
-       m_face->m_move_planepts[0] = m_face->getWinding()[opposite].vertex;
-       m_face->m_move_planepts[1] = m_face->getWinding()[index].vertex;
-       m_face->m_move_planepts[2] = m_face->getWinding()[other].vertex;
-       planepts_quantise( m_face->m_move_planepts, GRID_MIN ); // winding points are very inaccurate
-}
+               if ( triangle_reversed( index, other, opposite ) ) {
+                       std::swap( index, other );
+               }
 
-void update_selection_vertex(){
-       if ( m_vertexSelection.size() == 0 ) {
-               m_selectableVertices.setSelected( false );
-       }
-       else
-       {
-               m_selectableVertices.setSelected( true );
+               ASSERT_MESSAGE(
+                       triangles_same_winding(
+                               m_face->getWinding()[opposite].vertex,
+                               m_face->getWinding()[index].vertex,
+                               m_face->getWinding()[other].vertex,
+                               m_face->getWinding()[0].vertex,
+                               m_face->getWinding()[1].vertex,
+                               m_face->getWinding()[2].vertex
+                               ),
+                       "update_move_planepts_vertex2: error"
+                       );
+
+               m_face->m_move_planepts[0] = m_face->getWinding()[opposite].vertex;
+               m_face->m_move_planepts[1] = m_face->getWinding()[index].vertex;
+               m_face->m_move_planepts[2] = m_face->getWinding()[other].vertex;
+               planepts_quantise( m_face->m_move_planepts, GRID_MIN ); // winding points are very inaccurate
+       }
+
+       void update_selection_vertex(){
+               if ( m_vertexSelection.size() == 0 ) {
+                       m_selectableVertices.setSelected( false );
+               }
+               else
+               {
+                       m_selectableVertices.setSelected( true );
 
-               if ( m_vertexSelection.size() == 1 ) {
-                       std::size_t index = Winding_FindAdjacent( getFace().getWinding(), *m_vertexSelection.begin() );
+                       if ( m_vertexSelection.size() == 1 ) {
+                               std::size_t index = Winding_FindAdjacent( getFace().getWinding(), *m_vertexSelection.begin() );
 
-                       if ( index != c_brush_maxFaces ) {
-                               update_move_planepts_vertex( index );
+                               if ( index != c_brush_maxFaces ) {
+                                       update_move_planepts_vertex( index );
+                               }
                        }
-               }
-               else if ( m_vertexSelection.size() == 2 ) {
-                       std::size_t index = Winding_FindAdjacent( getFace().getWinding(), *m_vertexSelection.begin() );
-                       std::size_t other = Winding_FindAdjacent( getFace().getWinding(), *( ++m_vertexSelection.begin() ) );
+                       else if ( m_vertexSelection.size() == 2 ) {
+                               std::size_t index = Winding_FindAdjacent( getFace().getWinding(), *m_vertexSelection.begin() );
+                               std::size_t other = Winding_FindAdjacent( getFace().getWinding(), *( ++m_vertexSelection.begin() ) );
 
-                       if ( index != c_brush_maxFaces
-                                && other != c_brush_maxFaces ) {
-                               update_move_planepts_vertex2( index, other );
+                               if ( index != c_brush_maxFaces
+                                        && other != c_brush_maxFaces ) {
+                                       update_move_planepts_vertex2( index, other );
+                               }
                        }
                }
        }
-}
-
-void select_vertex( std::size_t index, bool select ){
-       if ( select ) {
-               VertexSelection_insert( m_vertexSelection, getFace().getWinding()[index].adjacent );
-       }
-       else
-       {
-               VertexSelection_erase( m_vertexSelection, getFace().getWinding()[index].adjacent );
-       }
 
-       SceneChangeNotify();
-       update_selection_vertex();
-}
+       void select_vertex( std::size_t index, bool select ){
+               if ( select ) {
+                       VertexSelection_insert( m_vertexSelection, getFace().getWinding()[index].adjacent );
+               }
+               else
+               {
+                       VertexSelection_erase( m_vertexSelection, getFace().getWinding()[index].adjacent );
+               }
 
-bool selected_vertex( std::size_t index ) const {
-       return VertexSelection_find( m_vertexSelection, getFace().getWinding()[index].adjacent ) != m_vertexSelection.end();
-}
+               SceneChangeNotify();
+               update_selection_vertex();
+       }
 
-void update_move_planepts_edge( std::size_t index ){
-       std::size_t numpoints = m_face->getWinding().numpoints;
-       ASSERT_MESSAGE( index < numpoints, "select_edge: invalid index" );
+       bool selected_vertex( std::size_t index ) const {
+               return VertexSelection_find( m_vertexSelection, getFace().getWinding()[index].adjacent ) != m_vertexSelection.end();
+       }
 
-       std::size_t adjacent = Winding_next( m_face->getWinding(), index );
-       std::size_t opposite = Winding_Opposite( m_face->getWinding(), index );
-       m_face->m_move_planepts[0] = m_face->getWinding()[index].vertex;
-       m_face->m_move_planepts[1] = m_face->getWinding()[adjacent].vertex;
-       m_face->m_move_planepts[2] = m_face->getWinding()[opposite].vertex;
-       planepts_quantise( m_face->m_move_planepts, GRID_MIN ); // winding points are very inaccurate
-}
+       void update_move_planepts_edge( std::size_t index ){
+               std::size_t numpoints = m_face->getWinding().numpoints;
+               ASSERT_MESSAGE( index < numpoints, "select_edge: invalid index" );
 
-void update_selection_edge(){
-       if ( m_edgeSelection.size() == 0 ) {
-               m_selectableEdges.setSelected( false );
+               std::size_t adjacent = Winding_next( m_face->getWinding(), index );
+               std::size_t opposite = Winding_Opposite( m_face->getWinding(), index );
+               m_face->m_move_planepts[0] = m_face->getWinding()[index].vertex;
+               m_face->m_move_planepts[1] = m_face->getWinding()[adjacent].vertex;
+               m_face->m_move_planepts[2] = m_face->getWinding()[opposite].vertex;
+               planepts_quantise( m_face->m_move_planepts, GRID_MIN ); // winding points are very inaccurate
        }
-       else
-       {
-               m_selectableEdges.setSelected( true );
 
-               if ( m_edgeSelection.size() == 1 ) {
-                       std::size_t index = Winding_FindAdjacent( getFace().getWinding(), *m_edgeSelection.begin() );
+       void update_selection_edge(){
+               if ( m_edgeSelection.size() == 0 ) {
+                       m_selectableEdges.setSelected( false );
+               }
+               else
+               {
+                       m_selectableEdges.setSelected( true );
 
-                       if ( index != c_brush_maxFaces ) {
-                               update_move_planepts_edge( index );
+                       if ( m_edgeSelection.size() == 1 ) {
+                               std::size_t index = Winding_FindAdjacent( getFace().getWinding(), *m_edgeSelection.begin() );
+
+                               if ( index != c_brush_maxFaces ) {
+                                       update_move_planepts_edge( index );
+                               }
                        }
                }
        }
-}
 
-void select_edge( std::size_t index, bool select ){
-       if ( select ) {
-               VertexSelection_insert( m_edgeSelection, getFace().getWinding()[index].adjacent );
-       }
-       else
-       {
-               VertexSelection_erase( m_edgeSelection, getFace().getWinding()[index].adjacent );
-       }
+       void select_edge( std::size_t index, bool select ){
+               if ( select ) {
+                       VertexSelection_insert( m_edgeSelection, getFace().getWinding()[index].adjacent );
+               }
+               else
+               {
+                       VertexSelection_erase( m_edgeSelection, getFace().getWinding()[index].adjacent );
+               }
 
-       SceneChangeNotify();
-       update_selection_edge();
-}
+               SceneChangeNotify();
+               update_selection_edge();
+       }
 
-bool selected_edge( std::size_t index ) const {
-       return VertexSelection_find( m_edgeSelection, getFace().getWinding()[index].adjacent ) != m_edgeSelection.end();
-}
+       bool selected_edge( std::size_t index ) const {
+               return VertexSelection_find( m_edgeSelection, getFace().getWinding()[index].adjacent ) != m_edgeSelection.end();
+       }
 
-const Vector3& centroid() const {
-       return m_face->centroid();
-}
+       const Vector3& centroid() const {
+               return m_face->centroid();
+       }
 
-void connectivityChanged(){
-       // This occurs when a face is added or removed.
-       // The current vertex and edge selections no longer valid and must be cleared.
-       m_vertexSelection.clear();
-       m_selectableVertices.setSelected( false );
-       m_edgeSelection.clear();
-       m_selectableEdges.setSelected( false );
-}
+       void connectivityChanged(){
+               // This occurs when a face is added or removed.
+               // The current vertex and edge selections no longer valid and must be cleared.
+               m_vertexSelection.clear();
+               m_selectableVertices.setSelected( false );
+               m_edgeSelection.clear();
+               m_selectableEdges.setSelected( false );
+       }
 };
 
 class BrushClipPlane : public OpenGLRenderable
 {
-Plane3 m_plane;
-Winding m_winding;
-static Shader* m_state;
+       Plane3 m_plane;
+       Winding m_winding;
+       static Shader* m_state;
 public:
-static void constructStatic(){
-       m_state = GlobalShaderCache().capture( "$CLIPPER_OVERLAY" );
-}
-
-static void destroyStatic(){
-       GlobalShaderCache().release( "$CLIPPER_OVERLAY" );
-}
-
-void setPlane( const Brush& brush, const Plane3& plane ){
-       m_plane = plane;
-       if ( plane3_valid( m_plane ) ) {
-               brush.windingForClipPlane( m_winding, m_plane );
+       static void constructStatic(){
+               m_state = GlobalShaderCache().capture( "$CLIPPER_OVERLAY" );
        }
-       else
-       {
-               m_winding.resize( 0 );
+
+       static void destroyStatic(){
+               GlobalShaderCache().release( "$CLIPPER_OVERLAY" );
        }
-}
 
-void render( RenderStateFlags state ) const {
-       if ( ( state & RENDER_FILL ) != 0 ) {
-               Winding_Draw( m_winding, m_plane.normal(), state );
+       void setPlane( const Brush& brush, const Plane3& plane ){
+               m_plane = plane;
+               if ( plane3_valid( m_plane ) ) {
+                       brush.windingForClipPlane( m_winding, m_plane );
+               }
+               else
+               {
+                       m_winding.resize( 0 );
+               }
        }
-       else
-       {
-               Winding_DrawWireframe( m_winding );
 
-               // also draw a line indicating the direction of the cut
-               Vector3 lineverts[2];
-               Winding_Centroid( m_winding, m_plane, lineverts[0] );
-               lineverts[1] = vector3_added( lineverts[0], vector3_scaled( m_plane.normal(), Brush::m_maxWorldCoord * 4 ) );
+       void render( RenderStateFlags state ) const {
+               if ( ( state & RENDER_FILL ) != 0 ) {
+                       Winding_Draw( m_winding, m_plane.normal(), state );
+               }
+               else
+               {
+                       Winding_DrawWireframe( m_winding );
+
+                       // also draw a line indicating the direction of the cut
+                       Vector3 lineverts[2];
+                       Winding_Centroid( m_winding, m_plane, lineverts[0] );
+                       lineverts[1] = vector3_added( lineverts[0], vector3_scaled( m_plane.normal(), Brush::m_maxWorldCoord * 4 ) );
 
-               glVertexPointer( 3, GL_FLOAT, sizeof( Vector3 ), &lineverts[0] );
-               glDrawArrays( GL_LINES, 0, GLsizei( 2 ) );
+                       glVertexPointer( 3, GL_FLOAT, sizeof( Vector3 ), &lineverts[0] );
+                       glDrawArrays( GL_LINES, 0, GLsizei( 2 ) );
+               }
        }
-}
 
-void render( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
-       renderer.SetState( m_state, Renderer::eWireframeOnly );
-       renderer.SetState( m_state, Renderer::eFullMaterials );
-       renderer.addRenderable( *this, localToWorld );
-}
+       void render( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
+               renderer.SetState( m_state, Renderer::eWireframeOnly );
+               renderer.SetState( m_state, Renderer::eFullMaterials );
+               renderer.addRenderable( *this, localToWorld );
+       }
 };
 
 inline void Face_addLight( const FaceInstance& face, const Matrix4& localToWorld, const RendererLight& light ){
@@ -2997,114 +2983,114 @@ typedef std::vector<FaceInstance> FaceInstances;
 
 class EdgeInstance : public Selectable
 {
-FaceInstances& m_faceInstances;
-SelectableEdge* m_edge;
+       FaceInstances& m_faceInstances;
+       SelectableEdge* m_edge;
 
-void select_edge( bool select ){
-       FaceVertexId faceVertex = m_edge->m_faceVertex;
-       m_faceInstances[faceVertex.getFace()].select_edge( faceVertex.getVertex(), select );
-       faceVertex = next_edge( m_edge->m_faces, faceVertex );
-       m_faceInstances[faceVertex.getFace()].select_edge( faceVertex.getVertex(), select );
-}
-
-bool selected_edge() const {
-       FaceVertexId faceVertex = m_edge->m_faceVertex;
-       if ( !m_faceInstances[faceVertex.getFace()].selected_edge( faceVertex.getVertex() ) ) {
-               return false;
-       }
-       faceVertex = next_edge( m_edge->m_faces, faceVertex );
-       if ( !m_faceInstances[faceVertex.getFace()].selected_edge( faceVertex.getVertex() ) ) {
-               return false;
+       void select_edge( bool select ){
+               FaceVertexId faceVertex = m_edge->m_faceVertex;
+               m_faceInstances[faceVertex.getFace()].select_edge( faceVertex.getVertex(), select );
+               faceVertex = next_edge( m_edge->m_faces, faceVertex );
+               m_faceInstances[faceVertex.getFace()].select_edge( faceVertex.getVertex(), select );
        }
 
-       return true;
-}
+       bool selected_edge() const {
+               FaceVertexId faceVertex = m_edge->m_faceVertex;
+               if ( !m_faceInstances[faceVertex.getFace()].selected_edge( faceVertex.getVertex() ) ) {
+                       return false;
+               }
+               faceVertex = next_edge( m_edge->m_faces, faceVertex );
+               if ( !m_faceInstances[faceVertex.getFace()].selected_edge( faceVertex.getVertex() ) ) {
+                       return false;
+               }
+
+               return true;
+       }
 
 public:
-EdgeInstance( FaceInstances& faceInstances, SelectableEdge& edge )
-       : m_faceInstances( faceInstances ), m_edge( &edge ){
-}
-EdgeInstance& operator=( const EdgeInstance& other ){
-       m_edge = other.m_edge;
-       return *this;
-}
+       EdgeInstance( FaceInstances& faceInstances, SelectableEdge& edge )
+               : m_faceInstances( faceInstances ), m_edge( &edge ){
+       }
+       EdgeInstance& operator=( const EdgeInstance& other ){
+               m_edge = other.m_edge;
+               return *this;
+       }
 
-void setSelected( bool select ){
-       select_edge( select );
-}
+       void setSelected( bool select ){
+               select_edge( select );
+       }
 
-bool isSelected() const {
-       return selected_edge();
-}
+       bool isSelected() const {
+               return selected_edge();
+       }
 
 
-void testSelect( Selector& selector, SelectionTest& test ){
-       SelectionIntersection best;
-       m_edge->testSelect( test, best );
-       if ( best.valid() ) {
-               Selector_add( selector, *this, best );
+       void testSelect( Selector& selector, SelectionTest& test ){
+               SelectionIntersection best;
+               m_edge->testSelect( test, best );
+               if ( best.valid() ) {
+                       Selector_add( selector, *this, best );
+               }
        }
-}
 };
 
 class VertexInstance : public Selectable
 {
-FaceInstances& m_faceInstances;
-SelectableVertex* m_vertex;
+       FaceInstances& m_faceInstances;
+       SelectableVertex* m_vertex;
 
-void select_vertex( bool select ){
-       FaceVertexId faceVertex = m_vertex->m_faceVertex;
-       do
-       {
-               m_faceInstances[faceVertex.getFace()].select_vertex( faceVertex.getVertex(), select );
-               faceVertex = next_vertex( m_vertex->m_faces, faceVertex );
+       void select_vertex( bool select ){
+               FaceVertexId faceVertex = m_vertex->m_faceVertex;
+               do
+               {
+                       m_faceInstances[faceVertex.getFace()].select_vertex( faceVertex.getVertex(), select );
+                       faceVertex = next_vertex( m_vertex->m_faces, faceVertex );
+               }
+               while ( faceVertex.getFace() != m_vertex->m_faceVertex.getFace() );
        }
-       while ( faceVertex.getFace() != m_vertex->m_faceVertex.getFace() );
-}
 
-bool selected_vertex() const {
-       FaceVertexId faceVertex = m_vertex->m_faceVertex;
-       do
-       {
-               if ( !m_faceInstances[faceVertex.getFace()].selected_vertex( faceVertex.getVertex() ) ) {
-                       return false;
+       bool selected_vertex() const {
+               FaceVertexId faceVertex = m_vertex->m_faceVertex;
+               do
+               {
+                       if ( !m_faceInstances[faceVertex.getFace()].selected_vertex( faceVertex.getVertex() ) ) {
+                               return false;
+                       }
+                       faceVertex = next_vertex( m_vertex->m_faces, faceVertex );
                }
-               faceVertex = next_vertex( m_vertex->m_faces, faceVertex );
+               while ( faceVertex.getFace() != m_vertex->m_faceVertex.getFace() );
+               return true;
        }
-       while ( faceVertex.getFace() != m_vertex->m_faceVertex.getFace() );
-       return true;
-}
 
-public:
-VertexInstance( FaceInstances& faceInstances, SelectableVertex& vertex )
-       : m_faceInstances( faceInstances ), m_vertex( &vertex ){
-}
-VertexInstance& operator=( const VertexInstance& other ){
-       m_vertex = other.m_vertex;
-       return *this;
-}
+       public:
+       VertexInstance( FaceInstances& faceInstances, SelectableVertex& vertex )
+               : m_faceInstances( faceInstances ), m_vertex( &vertex ){
+       }
+       VertexInstance& operator=( const VertexInstance& other ){
+               m_vertex = other.m_vertex;
+               return *this;
+       }
 
-void setSelected( bool select ){
-       select_vertex( select );
-}
+       void setSelected( bool select ){
+               select_vertex( select );
+       }
 
-bool isSelected() const {
-       return selected_vertex();
-}
+       bool isSelected() const {
+               return selected_vertex();
+       }
 
-void testSelect( Selector& selector, SelectionTest& test ){
-       SelectionIntersection best;
-       m_vertex->testSelect( test, best );
-       if ( best.valid() ) {
-               Selector_add( selector, *this, best );
+       void testSelect( Selector& selector, SelectionTest& test ){
+               SelectionIntersection best;
+               m_vertex->testSelect( test, best );
+               if ( best.valid() ) {
+                       Selector_add( selector, *this, best );
+               }
        }
-}
 };
 
 class BrushInstanceVisitor
 {
 public:
-virtual void visit( FaceInstance& face ) const = 0;
+       virtual void visit( FaceInstance& face ) const = 0;
 };
 
 class BrushInstance :
@@ -3119,497 +3105,498 @@ class BrushInstance :
        public PlaneSelectable,
        public LightCullable
 {
-class TypeCasts
-{
-InstanceTypeCastTable m_casts;
-public:
-TypeCasts(){
-       InstanceStaticCast<BrushInstance, Selectable>::install( m_casts );
-       InstanceContainedCast<BrushInstance, Bounded>::install( m_casts );
-       InstanceContainedCast<BrushInstance, Cullable>::install( m_casts );
-       InstanceStaticCast<BrushInstance, Renderable>::install( m_casts );
-       InstanceStaticCast<BrushInstance, SelectionTestable>::install( m_casts );
-       InstanceStaticCast<BrushInstance, ComponentSelectionTestable>::install( m_casts );
-       InstanceStaticCast<BrushInstance, ComponentEditable>::install( m_casts );
-       InstanceStaticCast<BrushInstance, ComponentSnappable>::install( m_casts );
-       InstanceStaticCast<BrushInstance, PlaneSelectable>::install( m_casts );
-       InstanceIdentityCast<BrushInstance>::install( m_casts );
-       InstanceContainedCast<BrushInstance, Transformable>::install( m_casts );
-}
-
-InstanceTypeCastTable& get(){
-       return m_casts;
-}
-};
+       class TypeCasts
+       {
+               InstanceTypeCastTable m_casts;
+       public:
+               TypeCasts(){
+                       InstanceStaticCast<BrushInstance, Selectable>::install( m_casts );
+                       InstanceContainedCast<BrushInstance, Bounded>::install( m_casts );
+                       InstanceContainedCast<BrushInstance, Cullable>::install( m_casts );
+                       InstanceStaticCast<BrushInstance, Renderable>::install( m_casts );
+                       InstanceStaticCast<BrushInstance, SelectionTestable>::install( m_casts );
+                       InstanceStaticCast<BrushInstance, ComponentSelectionTestable>::install( m_casts );
+                       InstanceStaticCast<BrushInstance, ComponentEditable>::install( m_casts );
+                       InstanceStaticCast<BrushInstance, ComponentSnappable>::install( m_casts );
+                       InstanceStaticCast<BrushInstance, PlaneSelectable>::install( m_casts );
+                       InstanceIdentityCast<BrushInstance>::install( m_casts );
+                       InstanceContainedCast<BrushInstance, Transformable>::install( m_casts );
+               }
+
+               InstanceTypeCastTable& get(){
+                       return m_casts;
+               }
+       };
+
 
+       Brush& m_brush;
 
-Brush& m_brush;
+       FaceInstances m_faceInstances;
 
-FaceInstances m_faceInstances;
+       typedef std::vector<EdgeInstance> EdgeInstances;
+       EdgeInstances m_edgeInstances;
+       typedef std::vector<VertexInstance> VertexInstances;
+       VertexInstances m_vertexInstances;
 
-typedef std::vector<EdgeInstance> EdgeInstances;
-EdgeInstances m_edgeInstances;
-typedef std::vector<VertexInstance> VertexInstances;
-VertexInstances m_vertexInstances;
+       ObservedSelectable m_selectable;
 
-ObservedSelectable m_selectable;
+       mutable RenderableWireframe m_render_wireframe;
+       mutable RenderablePointVector m_render_selected;
+       mutable AABB m_aabb_component;
+       mutable Array<PointVertex> m_faceCentroidPointsCulled;
+       RenderablePointArray m_render_faces_wireframe;
+       mutable bool m_viewChanged;   // requires re-evaluation of view-dependent cached data
 
-mutable RenderableWireframe m_render_wireframe;
-mutable RenderablePointVector m_render_selected;
-mutable AABB m_aabb_component;
-mutable Array<PointVertex> m_faceCentroidPointsCulled;
-RenderablePointArray m_render_faces_wireframe;
-mutable bool m_viewChanged;   // requires re-evaluation of view-dependent cached data
+       BrushClipPlane m_clipPlane;
 
-BrushClipPlane m_clipPlane;
+       static Shader* m_state_selpoint;
 
-static Shader* m_state_selpoint;
+       const LightList* m_lightList;
 
-const LightList* m_lightList;
+       TransformModifier m_transform;
 
-TransformModifier m_transform;
+       BrushInstance( const BrushInstance& other ); // NOT COPYABLE
+       BrushInstance& operator=( const BrushInstance& other ); // NOT ASSIGNABLE
 
-BrushInstance( const BrushInstance& other ); // NOT COPYABLE
-BrushInstance& operator=( const BrushInstance& other ); // NOT ASSIGNABLE
 public:
-static Counter* m_counter;
+       static Counter* m_counter;
 
-typedef LazyStatic<TypeCasts> StaticTypeCasts;
+       typedef LazyStatic<TypeCasts> StaticTypeCasts;
 
-void lightsChanged(){
-       m_lightList->lightsChanged();
-}
+       void lightsChanged(){
+               m_lightList->lightsChanged();
+       }
 
-typedef MemberCaller<BrushInstance, void(), &BrushInstance::lightsChanged> LightsChangedCaller;
+       typedef MemberCaller<BrushInstance, void(), &BrushInstance::lightsChanged> LightsChangedCaller;
 
-STRING_CONSTANT( Name, "BrushInstance" );
+       STRING_CONSTANT( Name, "BrushInstance" );
 
-BrushInstance( const scene::Path& path, scene::Instance* parent, Brush& brush ) :
-       Instance( path, parent, this, StaticTypeCasts::instance().get() ),
-       m_brush( brush ),
-       m_selectable( SelectedChangedCaller( *this ) ),
-       m_render_selected( GL_POINTS ),
-       m_render_faces_wireframe( m_faceCentroidPointsCulled, GL_POINTS ),
-       m_viewChanged( false ),
-       m_transform( Brush::TransformChangedCaller( m_brush ), ApplyTransformCaller( *this ) ){
-       m_brush.instanceAttach( Instance::path() );
-       m_brush.attach( *this );
-       m_counter->increment();
+       BrushInstance( const scene::Path& path, scene::Instance* parent, Brush& brush ) :
+               Instance( path, parent, this, StaticTypeCasts::instance().get() ),
+               m_brush( brush ),
+               m_selectable( SelectedChangedCaller( *this ) ),
+               m_render_selected( GL_POINTS ),
+               m_render_faces_wireframe( m_faceCentroidPointsCulled, GL_POINTS ),
+               m_viewChanged( false ),
+               m_transform( Brush::TransformChangedCaller( m_brush ), ApplyTransformCaller( *this ) ){
+               m_brush.instanceAttach( Instance::path() );
+               m_brush.attach( *this );
+               m_counter->increment();
 
-       m_lightList = &GlobalShaderCache().attach( *this );
-       m_brush.m_lightsChanged = LightsChangedCaller( *this ); ///\todo Make this work with instancing.
+               m_lightList = &GlobalShaderCache().attach( *this );
+               m_brush.m_lightsChanged = LightsChangedCaller( *this ); ///\todo Make this work with instancing.
 
-       Instance::setTransformChangedCallback( LightsChangedCaller( *this ) );
-}
+               Instance::setTransformChangedCallback( LightsChangedCaller( *this ) );
+       }
 
-~BrushInstance(){
-       Instance::setTransformChangedCallback( Callback<void()>() );
+       ~BrushInstance(){
+               Instance::setTransformChangedCallback( Callback<void()>() );
 
-       m_brush.m_lightsChanged = Callback<void()>();
-       GlobalShaderCache().detach( *this );
+               m_brush.m_lightsChanged = Callback<void()>();
+               GlobalShaderCache().detach( *this );
 
-       m_counter->decrement();
-       m_brush.detach( *this );
-       m_brush.instanceDetach( Instance::path() );
-}
+               m_counter->decrement();
+               m_brush.detach( *this );
+               m_brush.instanceDetach( Instance::path() );
+       }
 
-Brush& getBrush(){
-       return m_brush;
-}
-const Brush& getBrush() const {
-       return m_brush;
-}
+       Brush& getBrush(){
+               return m_brush;
+       }
+       const Brush& getBrush() const {
+               return m_brush;
+       }
 
-Bounded& get( NullType<Bounded>){
-       return m_brush;
-}
+       Bounded& get( NullType<Bounded>){
+               return m_brush;
+       }
 
-Cullable& get( NullType<Cullable>){
-       return m_brush;
-}
+       Cullable& get( NullType<Cullable>){
+               return m_brush;
+       }
 
-Transformable& get( NullType<Transformable>){
-       return m_transform;
-}
+       Transformable& get( NullType<Transformable>){
+               return m_transform;
+       }
 
-void selectedChanged( const Selectable& selectable ){
-       GlobalSelectionSystem().getObserver ( SelectionSystem::ePrimitive )( selectable );
-       GlobalSelectionSystem().onSelectedChanged( *this, selectable );
+       void selectedChanged( const Selectable& selectable ){
+               GlobalSelectionSystem().getObserver ( SelectionSystem::ePrimitive )( selectable );
+               GlobalSelectionSystem().onSelectedChanged( *this, selectable );
 
-       Instance::selectedChanged();
-}
-typedef MemberCaller<BrushInstance, void(const Selectable&), &BrushInstance::selectedChanged> SelectedChangedCaller;
+               Instance::selectedChanged();
+       }
+       typedef MemberCaller<BrushInstance, void(const Selectable&), &BrushInstance::selectedChanged> SelectedChangedCaller;
 
-void selectedChangedComponent( const Selectable& selectable ){
-       GlobalSelectionSystem().getObserver ( SelectionSystem::eComponent )( selectable );
-       GlobalSelectionSystem().onComponentSelection( *this, selectable );
-}
-typedef MemberCaller<BrushInstance, void(const Selectable&), &BrushInstance::selectedChangedComponent> SelectedChangedComponentCaller;
+       void selectedChangedComponent( const Selectable& selectable ){
+               GlobalSelectionSystem().getObserver ( SelectionSystem::eComponent )( selectable );
+               GlobalSelectionSystem().onComponentSelection( *this, selectable );
+       }
+       typedef MemberCaller<BrushInstance, void(const Selectable&), &BrushInstance::selectedChangedComponent> SelectedChangedComponentCaller;
 
-const BrushInstanceVisitor& forEachFaceInstance( const BrushInstanceVisitor& visitor ){
-       for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
-       {
-               visitor.visit( *i );
+       const BrushInstanceVisitor& forEachFaceInstance( const BrushInstanceVisitor& visitor ){
+               for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+               {
+                       visitor.visit( *i );
+               }
+               return visitor;
        }
-       return visitor;
-}
 
-static void constructStatic(){
-       m_state_selpoint = GlobalShaderCache().capture( "$SELPOINT" );
-}
+       static void constructStatic(){
+               m_state_selpoint = GlobalShaderCache().capture( "$SELPOINT" );
+       }
 
-static void destroyStatic(){
-       GlobalShaderCache().release( "$SELPOINT" );
-}
+       static void destroyStatic(){
+               GlobalShaderCache().release( "$SELPOINT" );
+       }
 
-void clear(){
-       m_faceInstances.clear();
-}
+       void clear(){
+               m_faceInstances.clear();
+       }
 
-void reserve( std::size_t size ){
-       m_faceInstances.reserve( size );
-}
+       void reserve( std::size_t size ){
+               m_faceInstances.reserve( size );
+       }
 
-void push_back( Face& face ){
-       m_faceInstances.push_back( FaceInstance( face, SelectedChangedComponentCaller( *this ) ) );
-}
+       void push_back( Face& face ){
+               m_faceInstances.push_back( FaceInstance( face, SelectedChangedComponentCaller( *this ) ) );
+       }
 
-void pop_back(){
-       ASSERT_MESSAGE( !m_faceInstances.empty(), "erasing invalid element" );
-       m_faceInstances.pop_back();
-}
+       void pop_back(){
+               ASSERT_MESSAGE( !m_faceInstances.empty(), "erasing invalid element" );
+               m_faceInstances.pop_back();
+       }
 
-void erase( std::size_t index ){
-       ASSERT_MESSAGE( index < m_faceInstances.size(), "erasing invalid element" );
-       m_faceInstances.erase( m_faceInstances.begin() + index );
-}
+       void erase( std::size_t index ){
+               ASSERT_MESSAGE( index < m_faceInstances.size(), "erasing invalid element" );
+               m_faceInstances.erase( m_faceInstances.begin() + index );
+       }
 
-void connectivityChanged(){
-       for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
-       {
-               ( *i ).connectivityChanged();
+       void connectivityChanged(){
+               for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+               {
+                       ( *i ).connectivityChanged();
+               }
        }
-}
 
-void edge_clear(){
-       m_edgeInstances.clear();
-}
+       void edge_clear(){
+               m_edgeInstances.clear();
+       }
 
-void edge_push_back( SelectableEdge& edge ){
-       m_edgeInstances.push_back( EdgeInstance( m_faceInstances, edge ) );
-}
+       void edge_push_back( SelectableEdge& edge ){
+               m_edgeInstances.push_back( EdgeInstance( m_faceInstances, edge ) );
+       }
 
-void vertex_clear(){
-       m_vertexInstances.clear();
-}
+       void vertex_clear(){
+               m_vertexInstances.clear();
+       }
 
-void vertex_push_back( SelectableVertex& vertex ){
-       m_vertexInstances.push_back( VertexInstance( m_faceInstances, vertex ) );
-}
+       void vertex_push_back( SelectableVertex& vertex ){
+               m_vertexInstances.push_back( VertexInstance( m_faceInstances, vertex ) );
+       }
 
-void DEBUG_verify() const {
-       ASSERT_MESSAGE( m_faceInstances.size() == m_brush.DEBUG_size(), "FATAL: mismatch" );
-}
+       void DEBUG_verify() const {
+               ASSERT_MESSAGE( m_faceInstances.size() == m_brush.DEBUG_size(), "FATAL: mismatch" );
+       }
 
-bool isSelected() const {
-       return m_selectable.isSelected();
-}
+       bool isSelected() const {
+               return m_selectable.isSelected();
+       }
 
-void setSelected( bool select ){
-       m_selectable.setSelected( select );
-}
+       void setSelected( bool select ){
+               m_selectable.setSelected( select );
+       }
 
-void update_selected() const {
-       m_render_selected.clear();
-       for ( FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
-       {
-               if ( ( *i ).getFace().contributes() ) {
-                       ( *i ).iterate_selected( m_render_selected );
+       void update_selected() const {
+               m_render_selected.clear();
+               for ( FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+               {
+                       if ( ( *i ).getFace().contributes() ) {
+                               ( *i ).iterate_selected( m_render_selected );
+                       }
                }
        }
-}
 
-void evaluateViewDependent( const VolumeTest& volume, const Matrix4& localToWorld ) const {
-       if ( m_viewChanged ) {
-               m_viewChanged = false;
+       void evaluateViewDependent( const VolumeTest& volume, const Matrix4& localToWorld ) const {
+               if ( m_viewChanged ) {
+                       m_viewChanged = false;
 
-               bool faces_visible[c_brush_maxFaces];
-               {
-                       bool* j = faces_visible;
-                       for ( FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i, ++j )
+                       bool faces_visible[c_brush_maxFaces];
                        {
-                               *j = ( *i ).intersectVolume( volume, localToWorld );
+                               bool* j = faces_visible;
+                               for ( FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i, ++j )
+                               {
+                                       *j = ( *i ).intersectVolume( volume, localToWorld );
+                               }
                        }
-               }
 
-               m_brush.update_wireframe( m_render_wireframe, faces_visible );
-               m_brush.update_faces_wireframe( m_faceCentroidPointsCulled, faces_visible );
+                       m_brush.update_wireframe( m_render_wireframe, faces_visible );
+                       m_brush.update_faces_wireframe( m_faceCentroidPointsCulled, faces_visible );
+               }
        }
-}
 
-void renderComponentsSelected( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
-       m_brush.evaluateBRep();
+       void renderComponentsSelected( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
+               m_brush.evaluateBRep();
 
-       update_selected();
-       if ( !m_render_selected.empty() ) {
-               renderer.Highlight( Renderer::ePrimitive, false );
-               renderer.SetState( m_state_selpoint, Renderer::eWireframeOnly );
-               renderer.SetState( m_state_selpoint, Renderer::eFullMaterials );
-               renderer.addRenderable( m_render_selected, localToWorld );
+               update_selected();
+               if ( !m_render_selected.empty() ) {
+                       renderer.Highlight( Renderer::ePrimitive, false );
+                       renderer.SetState( m_state_selpoint, Renderer::eWireframeOnly );
+                       renderer.SetState( m_state_selpoint, Renderer::eFullMaterials );
+                       renderer.addRenderable( m_render_selected, localToWorld );
+               }
        }
-}
 
-void renderComponents( Renderer& renderer, const VolumeTest& volume ) const {
-       m_brush.evaluateBRep();
+       void renderComponents( Renderer& renderer, const VolumeTest& volume ) const {
+               m_brush.evaluateBRep();
 
-       const Matrix4& localToWorld = Instance::localToWorld();
+               const Matrix4& localToWorld = Instance::localToWorld();
 
-       renderer.SetState( m_brush.m_state_point, Renderer::eWireframeOnly );
-       renderer.SetState( m_brush.m_state_point, Renderer::eFullMaterials );
+               renderer.SetState( m_brush.m_state_point, Renderer::eWireframeOnly );
+               renderer.SetState( m_brush.m_state_point, Renderer::eFullMaterials );
 
-       if ( volume.fill() && GlobalSelectionSystem().ComponentMode() == SelectionSystem::eFace ) {
-               evaluateViewDependent( volume, localToWorld );
-               renderer.addRenderable( m_render_faces_wireframe, localToWorld );
-       }
-       else
-       {
-               m_brush.renderComponents( GlobalSelectionSystem().ComponentMode(), renderer, volume, localToWorld );
+               if ( volume.fill() && GlobalSelectionSystem().ComponentMode() == SelectionSystem::eFace ) {
+                       evaluateViewDependent( volume, localToWorld );
+                       renderer.addRenderable( m_render_faces_wireframe, localToWorld );
+               }
+               else
+               {
+                       m_brush.renderComponents( GlobalSelectionSystem().ComponentMode(), renderer, volume, localToWorld );
+               }
        }
-}
 
-void renderClipPlane( Renderer& renderer, const VolumeTest& volume ) const {
-       if ( GlobalSelectionSystem().ManipulatorMode() == SelectionSystem::eClip && isSelected() ) {
-               m_clipPlane.render( renderer, volume, localToWorld() );
+       void renderClipPlane( Renderer& renderer, const VolumeTest& volume ) const {
+               if ( GlobalSelectionSystem().ManipulatorMode() == SelectionSystem::eClip && isSelected() ) {
+                       m_clipPlane.render( renderer, volume, localToWorld() );
+               }
        }
-}
 
-void renderCommon( Renderer& renderer, const VolumeTest& volume ) const {
-       bool componentMode = GlobalSelectionSystem().Mode() == SelectionSystem::eComponent;
+       void renderCommon( Renderer& renderer, const VolumeTest& volume ) const {
+               bool componentMode = GlobalSelectionSystem().Mode() == SelectionSystem::eComponent;
 
-       if ( componentMode && isSelected() ) {
-               renderComponents( renderer, volume );
-       }
+               if ( componentMode && isSelected() ) {
+                       renderComponents( renderer, volume );
+               }
 
-       if ( parentSelected() ) {
-               if ( !componentMode ) {
-                       renderer.Highlight( Renderer::eFace );
+               if ( parentSelected() ) {
+                       if ( !componentMode ) {
+                               renderer.Highlight( Renderer::eFace );
+                       }
+                       renderer.Highlight( Renderer::ePrimitive );
                }
-               renderer.Highlight( Renderer::ePrimitive );
        }
-}
 
-void renderSolid( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
-       //renderCommon(renderer, volume);
+       void renderSolid( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
+               //renderCommon(renderer, volume);
 
-       m_lightList->evaluateLights();
+               m_lightList->evaluateLights();
 
-       for ( FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
-       {
-               renderer.setLights( ( *i ).m_lights );
-               ( *i ).render( renderer, volume, localToWorld );
+               for ( FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+               {
+                       renderer.setLights( ( *i ).m_lights );
+                       ( *i ).render( renderer, volume, localToWorld );
+               }
+
+               renderComponentsSelected( renderer, volume, localToWorld );
        }
 
-       renderComponentsSelected( renderer, volume, localToWorld );
-}
+       void renderWireframe( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
+               //renderCommon(renderer, volume);
 
-void renderWireframe( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
-       //renderCommon(renderer, volume);
+               evaluateViewDependent( volume, localToWorld );
 
-       evaluateViewDependent( volume, localToWorld );
+               if ( m_render_wireframe.m_size != 0 ) {
+                       renderer.addRenderable( m_render_wireframe, localToWorld );
+               }
 
-       if ( m_render_wireframe.m_size != 0 ) {
-               renderer.addRenderable( m_render_wireframe, localToWorld );
+               renderComponentsSelected( renderer, volume, localToWorld );
        }
 
-       renderComponentsSelected( renderer, volume, localToWorld );
-}
-
-void renderSolid( Renderer& renderer, const VolumeTest& volume ) const {
-       m_brush.evaluateBRep();
+       void renderSolid( Renderer& renderer, const VolumeTest& volume ) const {
+               m_brush.evaluateBRep();
 
-       renderClipPlane( renderer, volume );
+               renderClipPlane( renderer, volume );
 
-       renderSolid( renderer, volume, localToWorld() );
-}
+               renderSolid( renderer, volume, localToWorld() );
+       }
 
-void renderWireframe( Renderer& renderer, const VolumeTest& volume ) const {
-       m_brush.evaluateBRep();
+       void renderWireframe( Renderer& renderer, const VolumeTest& volume ) const {
+               m_brush.evaluateBRep();
 
-       renderClipPlane( renderer, volume );
+               renderClipPlane( renderer, volume );
 
-       renderWireframe( renderer, volume, localToWorld() );
-}
+               renderWireframe( renderer, volume, localToWorld() );
+       }
 
-void viewChanged() const {
-       m_viewChanged = true;
-}
+       void viewChanged() const {
+               m_viewChanged = true;
+       }
 
-void testSelect( Selector& selector, SelectionTest& test ){
-       test.BeginMesh( localToWorld() );
+       void testSelect( Selector& selector, SelectionTest& test ){
+               test.BeginMesh( localToWorld() );
 
-       SelectionIntersection best;
-       for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
-       {
-               ( *i ).testSelect( test, best );
-       }
-       if ( best.valid() ) {
-               selector.addIntersection( best );
+               SelectionIntersection best;
+               for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+               {
+                       ( *i ).testSelect( test, best );
+               }
+               if ( best.valid() ) {
+                       selector.addIntersection( best );
+               }
        }
-}
 
-bool isSelectedComponents() const {
-       for ( FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
-       {
-               if ( ( *i ).selectedComponents() ) {
-                       return true;
+       bool isSelectedComponents() const {
+               for ( FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+               {
+                       if ( ( *i ).selectedComponents() ) {
+                               return true;
+                       }
                }
+               return false;
        }
-       return false;
-}
 
-void setSelectedComponents( bool select, SelectionSystem::EComponentMode mode ){
-       for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
-       {
-               ( *i ).setSelected( mode, select );
+       void setSelectedComponents( bool select, SelectionSystem::EComponentMode mode ){
+               for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+               {
+                       ( *i ).setSelected( mode, select );
+               }
        }
-}
 
-void testSelectComponents( Selector& selector, SelectionTest& test, SelectionSystem::EComponentMode mode ){
-       test.BeginMesh( localToWorld() );
+       void testSelectComponents( Selector& selector, SelectionTest& test, SelectionSystem::EComponentMode mode ){
+               test.BeginMesh( localToWorld() );
 
-       switch ( mode )
-       {
-       case SelectionSystem::eVertex:
-       {
-               for ( VertexInstances::iterator i = m_vertexInstances.begin(); i != m_vertexInstances.end(); ++i )
+               switch ( mode )
                {
-                       ( *i ).testSelect( selector, test );
-               }
-       }
-       break;
-       case SelectionSystem::eEdge:
-       {
-               for ( EdgeInstances::iterator i = m_edgeInstances.begin(); i != m_edgeInstances.end(); ++i )
+               case SelectionSystem::eVertex:
                {
-                       ( *i ).testSelect( selector, test );
+                       for ( VertexInstances::iterator i = m_vertexInstances.begin(); i != m_vertexInstances.end(); ++i )
+                       {
+                               ( *i ).testSelect( selector, test );
+                       }
                }
-       }
-       break;
-       case SelectionSystem::eFace:
-       {
-               if ( test.getVolume().fill() ) {
-                       for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+               break;
+               case SelectionSystem::eEdge:
+               {
+                       for ( EdgeInstances::iterator i = m_edgeInstances.begin(); i != m_edgeInstances.end(); ++i )
                        {
                                ( *i ).testSelect( selector, test );
                        }
                }
-               else
+               break;
+               case SelectionSystem::eFace:
                {
-                       for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+                       if ( test.getVolume().fill() ) {
+                               for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+                               {
+                                       ( *i ).testSelect( selector, test );
+                               }
+                       }
+                       else
                        {
-                               ( *i ).testSelect_centroid( selector, test );
+                               for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+                               {
+                                       ( *i ).testSelect_centroid( selector, test );
+                               }
                        }
                }
-       }
-       break;
-       default:
                break;
+               default:
+                       break;
+               }
        }
-}
 
-void selectPlanes( Selector& selector, SelectionTest& test, const PlaneCallback& selectedPlaneCallback ){
-       test.BeginMesh( localToWorld() );
+       void selectPlanes( Selector& selector, SelectionTest& test, const PlaneCallback& selectedPlaneCallback ){
+               test.BeginMesh( localToWorld() );
 
-       PlanePointer brushPlanes[c_brush_maxFaces];
-       PlanesIterator j = brushPlanes;
+               PlanePointer brushPlanes[c_brush_maxFaces];
+               PlanesIterator j = brushPlanes;
 
-       for ( Brush::const_iterator i = m_brush.begin(); i != m_brush.end(); ++i )
-       {
-               *j++ = &( *i )->plane3();
-       }
+               for ( Brush::const_iterator i = m_brush.begin(); i != m_brush.end(); ++i )
+               {
+                       *j++ = &( *i )->plane3();
+               }
 
-       for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
-       {
-               ( *i ).selectPlane( selector, Line( test.getNear(), test.getFar() ), brushPlanes, j, selectedPlaneCallback );
+               for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+               {
+                       ( *i ).selectPlane( selector, Line( test.getNear(), test.getFar() ), brushPlanes, j, selectedPlaneCallback );
+               }
        }
-}
 
-void selectReversedPlanes( Selector& selector, const SelectedPlanes& selectedPlanes ){
-       for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
-       {
-               ( *i ).selectReversedPlane( selector, selectedPlanes );
+       void selectReversedPlanes( Selector& selector, const SelectedPlanes& selectedPlanes ){
+               for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+               {
+                       ( *i ).selectReversedPlane( selector, selectedPlanes );
+               }
        }
-}
 
 
-void transformComponents( const Matrix4& matrix ){
-       for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
-       {
-               ( *i ).transformComponents( matrix );
+       void transformComponents( const Matrix4& matrix ){
+               for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+               {
+                       ( *i ).transformComponents( matrix );
+               }
        }
-}
 
-const AABB& getSelectedComponentsBounds() const {
-       m_aabb_component = AABB();
+       const AABB& getSelectedComponentsBounds() const {
+               m_aabb_component = AABB();
 
-       for ( FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
-       {
-               ( *i ).iterate_selected( m_aabb_component );
-       }
+               for ( FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+               {
+                       ( *i ).iterate_selected( m_aabb_component );
+               }
 
-       return m_aabb_component;
-}
+               return m_aabb_component;
+       }
 
-void snapComponents( float snap ){
-       for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
-       {
-               ( *i ).snapComponents( snap );
+       void snapComponents( float snap ){
+               for ( FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+               {
+                       ( *i ).snapComponents( snap );
+               }
        }
-}
 
-void evaluateTransform(){
-       Matrix4 matrix( m_transform.calculateTransform() );
-       //globalOutputStream() << "matrix: " << matrix << "\n";
+       void evaluateTransform(){
+               Matrix4 matrix( m_transform.calculateTransform() );
+               //globalOutputStream() << "matrix: " << matrix << "\n";
 
-       if ( m_transform.getType() == TRANSFORM_PRIMITIVE ) {
-               m_brush.transform( matrix );
-       }
-       else
-       {
-               transformComponents( matrix );
+               if ( m_transform.getType() == TRANSFORM_PRIMITIVE ) {
+                       m_brush.transform( matrix );
+               }
+               else
+               {
+                       transformComponents( matrix );
+               }
        }
-}
 
-void applyTransform(){
-       m_brush.revertTransform();
-       evaluateTransform();
-       m_brush.freezeTransform();
-}
+       void applyTransform(){
+               m_brush.revertTransform();
+               evaluateTransform();
+               m_brush.freezeTransform();
+       }
 
-typedef MemberCaller<BrushInstance, void(), &BrushInstance::applyTransform> ApplyTransformCaller;
+       typedef MemberCaller<BrushInstance, void(), &BrushInstance::applyTransform> ApplyTransformCaller;
 
-void setClipPlane( const Plane3& plane ){
-       m_clipPlane.setPlane( m_brush, plane );
-}
+       void setClipPlane( const Plane3& plane ){
+               m_clipPlane.setPlane( m_brush, plane );
+       }
 
-bool testLight( const RendererLight& light ) const {
-       return light.testAABB( worldAABB() );
-}
+       bool testLight( const RendererLight& light ) const {
+               return light.testAABB( worldAABB() );
+       }
 
-void insertLight( const RendererLight& light ){
-       const Matrix4& localToWorld = Instance::localToWorld();
-       for ( FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
-       {
-               Face_addLight( *i, localToWorld, light );
+       void insertLight( const RendererLight& light ){
+               const Matrix4& localToWorld = Instance::localToWorld();
+               for ( FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+               {
+                       Face_addLight( *i, localToWorld, light );
+               }
        }
-}
 
-void clearLights(){
-       for ( FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
-       {
-               ( *i ).m_lights.clear();
+       void clearLights(){
+               for ( FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i )
+               {
+                       ( *i ).m_lights.clear();
+               }
        }
-}
 };
 
 inline BrushInstance* Instance_getBrush( scene::Instance& instance ){
@@ -3620,17 +3607,17 @@ inline BrushInstance* Instance_getBrush( scene::Instance& instance ){
 template<typename Functor>
 class BrushSelectedVisitor : public SelectionSystem::Visitor
 {
-const Functor& m_functor;
+       const Functor& m_functor;
 public:
-BrushSelectedVisitor( const Functor& functor ) : m_functor( functor ){
-}
+       BrushSelectedVisitor( const Functor& functor ) : m_functor( functor ){
+       }
 
-void visit( scene::Instance& instance ) const {
-       BrushInstance* brush = Instance_getBrush( instance );
-       if ( brush != 0 ) {
-               m_functor( *brush );
+       void visit( scene::Instance& instance ) const {
+               BrushInstance* brush = Instance_getBrush( instance );
+               if ( brush != 0 ) {
+                       m_functor( *brush );
+               }
        }
-}
 };
 
 template<typename Functor>
@@ -3642,18 +3629,18 @@ inline const Functor& Scene_forEachSelectedBrush( const Functor& functor ){
 template<typename Functor>
 class BrushVisibleSelectedVisitor : public SelectionSystem::Visitor
 {
-const Functor& m_functor;
+       const Functor& m_functor;
 public:
-BrushVisibleSelectedVisitor( const Functor& functor ) : m_functor( functor ){
-}
+       BrushVisibleSelectedVisitor( const Functor& functor ) : m_functor( functor ){
+       }
 
-void visit( scene::Instance& instance ) const {
-       BrushInstance* brush = Instance_getBrush( instance );
-       if ( brush != 0
-                && instance.path().top().get().visible() ) {
-               m_functor( *brush );
+       void visit( scene::Instance& instance ) const {
+               BrushInstance* brush = Instance_getBrush( instance );
+               if ( brush != 0
+                        && instance.path().top().get().visible() ) {
+                       m_functor( *brush );
+               }
        }
-}
 };
 
 template<typename Functor>
@@ -3664,28 +3651,28 @@ inline const Functor& Scene_forEachVisibleSelectedBrush( const Functor& functor
 
 class BrushForEachFace
 {
-const BrushInstanceVisitor& m_visitor;
+       const BrushInstanceVisitor& m_visitor;
 public:
-BrushForEachFace( const BrushInstanceVisitor& visitor ) : m_visitor( visitor ){
-}
+       BrushForEachFace( const BrushInstanceVisitor& visitor ) : m_visitor( visitor ){
+       }
 
-void operator()( BrushInstance& brush ) const {
-       brush.forEachFaceInstance( m_visitor );
-}
+       void operator()( BrushInstance& brush ) const {
+               brush.forEachFaceInstance( m_visitor );
+       }
 };
 
 template<class Functor>
 class FaceInstanceVisitFace : public BrushInstanceVisitor
 {
-const Functor& functor;
+       const Functor& functor;
 public:
-FaceInstanceVisitFace( const Functor& functor )
-       : functor( functor ){
-}
+       FaceInstanceVisitFace( const Functor& functor )
+               : functor( functor ){
+       }
 
-void visit( FaceInstance& face ) const {
-       functor( face.getFace() );
-}
+       void visit( FaceInstance& face ) const {
+               functor( face.getFace() );
+       }
 };
 
 template<typename Functor>
@@ -3697,15 +3684,15 @@ inline const Functor& Brush_forEachFace( BrushInstance& brush, const Functor& fu
 template<class Functor>
 class FaceVisitAll : public BrushVisitor
 {
-const Functor& functor;
+       const Functor& functor;
 public:
-FaceVisitAll( const Functor& functor )
-       : functor( functor ){
-}
+       FaceVisitAll( const Functor& functor )
+               : functor( functor ){
+       }
 
-void visit( Face& face ) const {
-       functor( face );
-}
+       void visit( Face& face ) const {
+               functor( face );
+       }
 };
 
 template<typename Functor>
@@ -3723,15 +3710,15 @@ inline const Functor& Brush_forEachFace( Brush& brush, const Functor& functor ){
 template<class Functor>
 class FaceInstanceVisitAll : public BrushInstanceVisitor
 {
-const Functor& functor;
+       const Functor& functor;
 public:
-FaceInstanceVisitAll( const Functor& functor )
-       : functor( functor ){
-}
+       FaceInstanceVisitAll( const Functor& functor )
+               : functor( functor ){
+       }
 
-void visit( FaceInstance& face ) const {
-       functor( face );
-}
+       void visit( FaceInstance& face ) const {
+               functor( face );
+       }
 };
 
 template<typename Functor>
@@ -3750,33 +3737,33 @@ template<typename Type, typename Functor>
 class InstanceIfVisible : public Functor
 {
 public:
-InstanceIfVisible( const Functor& functor ) : Functor( functor ){
-}
+       InstanceIfVisible( const Functor& functor ) : Functor( functor ){
+       }
 
-void operator()( scene::Instance& instance ){
-       if ( instance.path().top().get().visible() ) {
-               Functor::operator()( instance );
+       void operator()( scene::Instance& instance ){
+               if ( instance.path().top().get().visible() ) {
+                       Functor::operator()( instance );
+               }
        }
-}
 };
 
 template<typename Functor>
 class BrushVisibleWalker : public scene::Graph::Walker
 {
-const Functor& m_functor;
+       const Functor& m_functor;
 public:
-BrushVisibleWalker( const Functor& functor ) : m_functor( functor ){
-}
+       BrushVisibleWalker( const Functor& functor ) : m_functor( functor ){
+       }
 
-bool pre( const scene::Path& path, scene::Instance& instance ) const {
-       if ( path.top().get().visible() ) {
-               BrushInstance* brush = Instance_getBrush( instance );
-               if ( brush != 0 ) {
-                       m_functor( *brush );
+       bool pre( const scene::Path& path, scene::Instance& instance ) const {
+               if ( path.top().get().visible() ) {
+                       BrushInstance* brush = Instance_getBrush( instance );
+                       if ( brush != 0 ) {
+                               m_functor( *brush );
+                       }
                }
+               return true;
        }
-       return true;
-}
 };
 
 template<typename Functor>
@@ -3813,14 +3800,14 @@ inline const Functor& Scene_ForEachSelectedBrush_ForEachFaceInstance( scene::Gra
 template<typename Functor>
 class FaceVisitorWrapper
 {
-const Functor& functor;
+       const Functor& functor;
 public:
-FaceVisitorWrapper( const Functor& functor ) : functor( functor ){
-}
+       FaceVisitorWrapper( const Functor& functor ) : functor( functor ){
+       }
 
-void operator()( FaceInstance& faceInstance ) const {
-       functor( faceInstance.getFace() );
-}
+       void operator()( FaceInstance& faceInstance ) const {
+               functor( faceInstance.getFace() );
+       }
 };
 
 template<typename Functor>
index 37fd9a17a734933c9437363324eb40bedf83f029..798e7f5eccd01044c78a2468470aa38f0e081d37 100644 (file)
 
 const int MRU_MAX = 4;
 namespace {
-GtkMenuItem *MRU_items[MRU_MAX];
-std::size_t MRU_used;
-typedef CopiedString MRU_filename_t;
-MRU_filename_t MRU_filenames[MRU_MAX];
-typedef const char* MRU_key_t;
-MRU_key_t MRU_keys[MRU_MAX] = { "File0", "File1", "File2", "File3" };
+       GtkMenuItem *MRU_items[MRU_MAX];
+       std::size_t MRU_used;
+       typedef CopiedString MRU_filename_t;
+       MRU_filename_t MRU_filenames[MRU_MAX];
+       typedef const char* MRU_key_t;
+       MRU_key_t MRU_keys[MRU_MAX] = { "File0", "File1", "File2", "File3" };
 }
 
 inline const char* MRU_GetText( std::size_t index ){
@@ -50,28 +50,30 @@ inline const char* MRU_GetText( std::size_t index ){
 
 class EscapedMnemonic
 {
-StringBuffer m_buffer;
+private:
+       StringBuffer m_buffer;
+
 public:
-EscapedMnemonic( std::size_t capacity ) : m_buffer( capacity ){
-       m_buffer.push_back( '_' );
-}
-const char* c_str() const {
-       return m_buffer.c_str();
-}
-void push_back( char c ){ // not escaped
-       m_buffer.push_back( c );
-}
-std::size_t write( const char* buffer, std::size_t length ){
-       for ( const char* end = buffer + length; buffer != end; ++buffer )
-       {
-               if ( *buffer == '_' ) {
-                       m_buffer.push_back( '_' );
-               }
+       EscapedMnemonic( std::size_t capacity ) : m_buffer( capacity ){
+               m_buffer.push_back( '_' );
+       }
+       const char* c_str() const {
+               return m_buffer.c_str();
+       }
+       void push_back( char c ){ // not escaped
+               m_buffer.push_back( c );
+       }
+       std::size_t write( const char* buffer, std::size_t length ){
+               for ( const char* end = buffer + length; buffer != end; ++buffer )
+               {
+                       if ( *buffer == '_' ) {
+                               m_buffer.push_back( '_' );
+                       }
 
-               m_buffer.push_back( *buffer );
+                       m_buffer.push_back( *buffer );
+               }
+               return length;
        }
-       return length;
-}
 };
 
 template<typename T>
@@ -173,16 +175,18 @@ void MRU_Activate( std::size_t index ){
 
 class LoadMRU
 {
-std::size_t m_number;
+private:
+       std::size_t m_number;
+
 public:
-LoadMRU( std::size_t number )
-       : m_number( number ){
-}
-void load(){
-       if ( ConfirmModified( "Open Map" ) ) {
-               MRU_Activate( m_number - 1 );
+       LoadMRU( std::size_t number )
+               : m_number( number ){
+       }
+       void load(){
+               if ( ConfirmModified( "Open Map" ) ) {
+                       MRU_Activate( m_number - 1 );
+               }
        }
-}
 };
 
 typedef MemberCaller<LoadMRU, void(), &LoadMRU::load> LoadMRUCaller;