/*
   Copyright (C) 1999-2006 Id Software, Inc. and contributors.
   For a list of contributors, see the accompanying CONTRIBUTORS file.

   This file is part of GtkRadiant.

   GtkRadiant is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GtkRadiant is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#if !defined( INCLUDED_BRUSH_H )
#define INCLUDED_BRUSH_H

/// \file
/// \brief The brush primitive.
///
/// A collection of planes that define a convex polyhedron.
/// The Boundary-Representation of this primitive is a manifold polygonal mesh.
/// Each face polygon is represented by a list of vertices in a \c Winding.
/// Each vertex is associated with another face that is adjacent to the edge
/// formed by itself and the next vertex in the winding. This information can
/// be used to find edge-pairs and vertex-rings.


#include "debugging/debugging.h"

#include "itexdef.h"
#include "iundo.h"
#include "iselection.h"
#include "irender.h"
#include "imap.h"
#include "ibrush.h"
#include "igl.h"
#include "ifilter.h"
#include "nameable.h"
#include "moduleobserver.h"

#include <set>

#include "cullable.h"
#include "renderable.h"
#include "selectable.h"
#include "editable.h"
#include "mapfile.h"

#include "math/frustum.h"
#include "selectionlib.h"
#include "render.h"
#include "texturelib.h"
#include "container/container.h"
#include "generic/bitfield.h"
#include "signal/signalfwd.h"

#include "winding.h"
#include "brush_primit.h"

const unsigned int BRUSH_DETAIL_FLAG = 27;
const unsigned int BRUSH_DETAIL_MASK = (1 << BRUSH_DETAIL_FLAG);

enum EBrushType {
    eBrushTypeQuake,
    eBrushTypeQuake2,
    eBrushTypeQuake3,
    eBrushTypeQuake3BP,
    eBrushTypeDoom3,
    eBrushTypeQuake4,
    eBrushTypeHalfLife,
};


#define BRUSH_CONNECTIVITY_DEBUG 0
#define BRUSH_DEGENERATE_DEBUG 0

template<typename TextOuputStreamType>
inline TextOuputStreamType &ostream_write(TextOuputStreamType &ostream, const Matrix4 &m)
{
    return ostream << "(" << m[0] << " " << m[1] << " " << m[2] << " " << m[3] << ", "
                   << m[4] << " " << m[5] << " " << m[6] << " " << m[7] << ", "
                   << m[8] << " " << m[9] << " " << m[10] << " " << m[11] << ", "
                   << m[12] << " " << m[13] << " " << m[14] << " " << m[15] << ")";
}

inline void print_vector3(const Vector3 &v)
{
    globalOutputStream() << "( " << v.x() << " " << v.y() << " " << v.z() << " )\n";
}

inline void print_3x3(const Matrix4 &m)
{
    globalOutputStream() << "( " << m.xx() << " " << m.xy() << " " << m.xz() << " ) "
                         << "( " << m.yx() << " " << m.yy() << " " << m.yz() << " ) "
                         << "( " << m.zx() << " " << m.zy() << " " << m.zz() << " )\n";
}


inline bool texdef_sane(const texdef_t &texdef)
{
    return fabs(texdef.shift[0]) < (1 << 16)
           && fabs(texdef.shift[1]) < (1 << 16);
}

inline void Winding_DrawWireframe(const Winding &winding)
{
    glVertexPointer(3, GL_FLOAT, sizeof(WindingVertex), &winding.points.data()->vertex);
    glDrawArrays(GL_LINE_LOOP, 0, GLsizei(winding.numpoints));
}

inline void Winding_Draw(const Winding &winding, const Vector3 &normal, RenderStateFlags state)
{
    glVertexPointer(3, GL_FLOAT, sizeof(WindingVertex), &winding.points.data()->vertex);

    if ((state & RENDER_BUMP) != 0) {
        Vector3 normals[c_brush_maxFaces];
        typedef Vector3 *Vector3Iter;
        for (Vector3Iter i = normals, end = normals + winding.numpoints; i != end; ++i) {
            *i = normal;
        }
        if (GlobalShaderCache().useShaderLanguage()) {
            glNormalPointer(GL_FLOAT, sizeof(Vector3), normals);
            glVertexAttribPointerARB(c_attr_TexCoord0, 2, GL_FLOAT, 0, sizeof(WindingVertex),
                                     &winding.points.data()->texcoord);
            glVertexAttribPointerARB(c_attr_Tangent, 3, GL_FLOAT, 0, sizeof(WindingVertex),
                                     &winding.points.data()->tangent);
            glVertexAttribPointerARB(c_attr_Binormal, 3, GL_FLOAT, 0, sizeof(WindingVertex),
                                     &winding.points.data()->bitangent);
        } else {
            glVertexAttribPointerARB(11, 3, GL_FLOAT, 0, sizeof(Vector3), normals);
            glVertexAttribPointerARB(8, 2, GL_FLOAT, 0, sizeof(WindingVertex), &winding.points.data()->texcoord);
            glVertexAttribPointerARB(9, 3, GL_FLOAT, 0, sizeof(WindingVertex), &winding.points.data()->tangent);
            glVertexAttribPointerARB(10, 3, GL_FLOAT, 0, sizeof(WindingVertex), &winding.points.data()->bitangent);
        }
    } else {
        if (state & RENDER_LIGHTING) {
            Vector3 normals[c_brush_maxFaces];
            typedef Vector3 *Vector3Iter;
            for (Vector3Iter i = normals, last = normals + winding.numpoints; i != last; ++i) {
                *i = normal;
            }
            glNormalPointer(GL_FLOAT, sizeof(Vector3), normals);
        }

        if (state & RENDER_TEXTURE) {
            glTexCoordPointer(2, GL_FLOAT, sizeof(WindingVertex), &winding.points.data()->texcoord);
        }
    }
#if 0
                                                                                                                            if ( state & RENDER_FILL ) {
		glDrawArrays( GL_TRIANGLE_FAN, 0, GLsizei( winding.numpoints ) );
	}
	else
	{
		glDrawArrays( GL_LINE_LOOP, 0, GLsizei( winding.numpoints ) );
	}
#else
    glDrawArrays(GL_POLYGON, 0, GLsizei(winding.numpoints));
#endif

#if 0
                                                                                                                            const Winding& winding = winding;

	if ( state & RENDER_FILL ) {
		glBegin( GL_POLYGON );
	}
	else
	{
		glBegin( GL_LINE_LOOP );
	}

	if ( state & RENDER_LIGHTING ) {
		glNormal3fv( normal );
	}

	for ( int i = 0; i < winding.numpoints; ++i )
	{
		if ( state & RENDER_TEXTURE ) {
			glTexCoord2fv( &winding.points[i][3] );
		}
		glVertex3fv( winding.points[i] );
	}
	glEnd();
#endif
}


#include "shaderlib.h"

typedef DoubleVector3 PlanePoints[3];

inline bool planepts_equal(const PlanePoints planepts, const PlanePoints other)
{
    return planepts[0] == other[0] && planepts[1] == other[1] && planepts[2] == other[2];
}

inline void planepts_assign(PlanePoints planepts, const PlanePoints other)
{
    planepts[0] = other[0];
    planepts[1] = other[1];
    planepts[2] = other[2];
}

inline void planepts_quantise(PlanePoints planepts, double snap)
{
    vector3_snap(planepts[0], snap);
    vector3_snap(planepts[1], snap);
    vector3_snap(planepts[2], snap);
}

inline float vector3_max_component(const Vector3 &vec3)
{
    return std::max(fabsf(vec3[0]), std::max(fabsf(vec3[1]), fabsf(vec3[2])));
}

inline void edge_snap(Vector3 &edge, double snap)
{
    float scale = static_cast<float>( ceil(fabs(snap / vector3_max_component(edge))));
    if (scale > 0.0f) {
        vector3_scale(edge, scale);
    }
    vector3_snap(edge, snap);
}

inline void planepts_snap(PlanePoints planepts, double snap)
{
    Vector3 edge01(vector3_subtracted(planepts[1], planepts[0]));
    Vector3 edge12(vector3_subtracted(planepts[2], planepts[1]));
    Vector3 edge20(vector3_subtracted(planepts[0], planepts[2]));

    double length_squared_01 = vector3_dot(edge01, edge01);
    double length_squared_12 = vector3_dot(edge12, edge12);
    double length_squared_20 = vector3_dot(edge20, edge20);

    vector3_snap(planepts[0], snap);

    if (length_squared_01 < length_squared_12) {
        if (length_squared_12 < length_squared_20) {
            edge_snap(edge01, snap);
            edge_snap(edge12, snap);
            planepts[1] = vector3_added(planepts[0], edge01);
            planepts[2] = vector3_added(planepts[1], edge12);
        } else {
            edge_snap(edge20, snap);
            edge_snap(edge01, snap);
            planepts[1] = vector3_added(planepts[0], edge20);
            planepts[2] = vector3_added(planepts[1], edge01);
        }
    } else {
        if (length_squared_01 < length_squared_20) {
            edge_snap(edge01, snap);
            edge_snap(edge12, snap);
            planepts[1] = vector3_added(planepts[0], edge01);
            planepts[2] = vector3_added(planepts[1], edge12);
        } else {
            edge_snap(edge12, snap);
            edge_snap(edge20, snap);
            planepts[1] = vector3_added(planepts[0], edge12);
            planepts[2] = vector3_added(planepts[1], edge20);
        }
    }
}

inline PointVertex pointvertex_for_planept(const DoubleVector3 &point, const Colour4b &colour)
{
    return PointVertex(
            Vertex3f(
                    static_cast<float>( point.x()),
                    static_cast<float>( point.y()),
                    static_cast<float>( point.z())
            ),
            colour
    );
}

inline PointVertex pointvertex_for_windingpoint(const Vector3 &point, const Colour4b &colour)
{
    return PointVertex(
            vertex3f_for_vector3(point),
            colour
    );
}

inline bool check_plane_is_integer(const PlanePoints &planePoints)
{
    return !float_is_integer(planePoints[0][0])
           || !float_is_integer(planePoints[0][1])
           || !float_is_integer(planePoints[0][2])
           || !float_is_integer(planePoints[1][0])
           || !float_is_integer(planePoints[1][1])
           || !float_is_integer(planePoints[1][2])
           || !float_is_integer(planePoints[2][0])
           || !float_is_integer(planePoints[2][1])
           || !float_is_integer(planePoints[2][2]);
}

inline void brush_check_shader(const char *name)
{
    if (!shader_valid(name)) {
        globalErrorStream() << "brush face has invalid texture name: '" << name << "'\n";
    }
}

class FaceShaderObserver {
public:
    virtual void realiseShader() = 0;

    virtual void unrealiseShader() = 0;
};

typedef ReferencePair<FaceShaderObserver> FaceShaderObserverPair;


class ContentsFlagsValue {
public:
    ContentsFlagsValue()
    {
    }

    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;
};

inline void ContentsFlagsValue_assignMasked(ContentsFlagsValue &flags, const ContentsFlagsValue &other)
{
    bool detail = bitfield_enabled(flags.m_contentFlags, BRUSH_DETAIL_MASK);
    flags = other;
    if (detail) {
        flags.m_contentFlags = bitfield_enable(flags.m_contentFlags, BRUSH_DETAIL_MASK);
    } else {
        flags.m_contentFlags = bitfield_disable(flags.m_contentFlags, BRUSH_DETAIL_MASK);
    }
}


class FaceShader : public ModuleObserver {
public:
    class SavedState {
    public:
        CopiedString m_shader;
        ContentsFlagsValue 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.setFlags(m_flags);
        }
    };

    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()
    {
        releaseShader();
    }

// copy-construction not supported
    FaceShader(const FaceShader &other);

    void instanceAttach()
    {
        m_instanced = true;
        m_state->incrementUsed();
    }

    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 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 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 detach(FaceShaderObserver &observer)
    {
        if (m_realised) {
            observer.unrealiseShader();
        }
        m_observers.detach(observer);
    }

    const char *getShader() const
    {
        return m_shader.c_str();
    }

    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
            );
        }
        return m_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;
    }

    std::size_t width() const
    {
        if (m_realised) {
            return m_state->getTexture().width;
        }
        return 1;
    }

    std::size_t height() const
    {
        if (m_realised) {
            return m_state->getTexture().height;
        }
        return 1;
    }

    unsigned int shaderFlags() const
    {
        if (m_realised) {
            return m_state->getFlags();
        }
        return 0;
    }
};


class FaceTexdef : public FaceShaderObserver {
// not copyable
    FaceTexdef(const FaceTexdef &other);

// not assignable
    FaceTexdef &operator=(const FaceTexdef &other);

public:
    class SavedState {
    public:
        TextureProjection m_projection;

        SavedState(const FaceTexdef &faceTexdef)
        {
            m_projection = faceTexdef.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;

    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);
    }

    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 realiseShader()
    {
        if (m_projectionInitialised && !m_scaleApplied) {
            addScale();
        }
    }

    void unrealiseShader()
    {
        if (m_projectionInitialised && m_scaleApplied) {
            removeScale();
        }
    }

    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 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 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 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);
    }

    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)
{
    ostream << "( " << planePoints[0][0] << " " << planePoints[0][1] << " " << planePoints[0][2] << " ) "
            << "( " << planePoints[1][0] << " " << planePoints[1][1] << " " << planePoints[1][2] << " ) "
            << "( " << planePoints[2][0] << " " << planePoints[2][1] << " " << planePoints[2][2] << " )";
}


inline Plane3 Plane3_applyTranslation(const Plane3 &plane, const Vector3 &translation)
{
    Plane3 tmp(plane3_translated(Plane3(plane.normal(), -plane.dist()), translation));
    return Plane3(tmp.normal(), -tmp.dist());
}

inline Plane3 Plane3_applyTransform(const Plane3 &plane, const Matrix4 &matrix)
{
    Plane3 tmp(plane3_transformed(Plane3(plane.normal(), -plane.dist()), matrix));
    return Plane3(tmp.normal(), -tmp.dist());
}

class FacePlane {
    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;
    }

    class SavedState {
    public:
        PlanePoints m_planepts;
        Plane3 m_plane;

        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() : m_funcStaticOrigin(0, 0, 0)
    {
    }

    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()) {
#if 0
                                                                                                                                    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);
        }
    }

    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()) {

#if 0
            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]);

            if (mirror) {
                reverse();
            }

#if 0
                                                                                                                                    if ( check_plane_is_integer( planePoints() ) ) {
			if ( !off ) {
				globalErrorStream() << "caused by transform\n";
			}
		}
#endif
            MakePlane();
        } else {
            m_planeCached = Plane3_applyTransform(m_planeCached, matrix);
            updateSource();
        }
    }

    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);

            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));
    }


    PlanePoints &planePoints()
    {
        return m_planepts;
    }

    const PlanePoints &planePoints() const
    {
        return m_planepts;
    }

    const Plane3 &plane3() const
    {
        return m_planeCached;
    }

    void setDoom3Plane(const Plane3 &plane)
    {
        m_plane = plane;
        updateTranslated();
    }

    const Plane3 &getDoom3Plane() const
    {
        return m_plane;
    }

    void copy(const FacePlane &other)
    {
        if (!isDoom3Plane()) {
            planepts_assign(m_planepts, other.m_planepts);
            MakePlane();
        } else {
            m_planeCached = other.m_plane;
            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)
{
    test.TestPolygon(VertexPointer(reinterpret_cast<VertexPointer::pointer>( &winding.points.data()->vertex ),
                                   sizeof(WindingVertex)), winding.numpoints, best);
}

const double GRID_MIN = 0.125;

inline double quantiseInteger(double f)
{
    return float_to_integer(f);
}

inline double quantiseFloating(double f)
{
    return float_snapped(f, 1.f / (1 << 16));
}

typedef double ( *QuantiseFunc )(double f);

class Face;

class FaceFilter {
public:
    virtual bool filter(const Face &face) const = 0;
};

bool face_filtered(Face &face);

void add_face_filter(FaceFilter &filter, int mask, bool invert = false);

void Brush_addTextureChangedCallback(const SignalHandler &callback);

void Brush_textureChanged();


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;
};

class Face :
        public OpenGLRenderable,
        public Filterable,
        public Undoable,
        public FaceShaderObserver {
    std::size_t m_refcount;

    class SavedState : public UndoMemento {
    public:
        FacePlane::SavedState m_planeState;
        FaceTexdef::SavedState m_texdefState;
        FaceShader::SavedState m_shaderState;

        SavedState(const Face &face) : m_planeState(face.getPlane()), m_texdefState(face.getTexdef()),
                                       m_shaderState(face.getShader())
        {
        }

        void exportState(Face &face) const
        {
            m_planeState.exportState(face.getPlane());
            m_shaderState.exportState(face.getShader());
            m_texdefState.exportState(face.getTexdef());
        }

        void release()
        {
            delete this;
        }
    };

public:
    static QuantiseFunc m_quantise;
    static EBrushType m_type;

    PlanePoints m_move_planepts;
    PlanePoints m_move_planeptsTransformed;
private:
    FacePlane m_plane;
    FacePlane m_planeTransformed;
    FaceShader m_shader;
    FaceTexdef m_texdef;
    TextureProjection m_texdefTransformed;

    Winding m_winding;
    Vector3 m_centroid;
    bool m_filtered;

    FaceObserver *m_observer;
    UndoObserver *m_undoable_observer;
    MapFile *m_map;

// assignment not supported
    Face &operator=(const Face &other);

// copy-construction not supported
    Face(const Face &other);

public:

    Face(FaceObserver *observer) :
            m_refcount(0),
            m_shader(texdef_name_default()),
            m_texdef(m_shader, TextureProjection(), false),
            m_filtered(false),
            m_observer(observer),
            m_undoable_observer(0),
            m_map(0)
    {
        m_shader.attach(*this);
        m_plane.copy(Vector3(0, 0, 0), Vector3(64, 0, 0), Vector3(0, 64, 0));
        m_texdef.setBasis(m_plane.plane3().normal());
        planeChanged();
    }

    Face(
            const Vector3 &p0,
            const Vector3 &p1,
            const Vector3 &p2,
            const char *shader,
            const TextureProjection &projection,
            FaceObserver *observer
    ) :
            m_refcount(0),
            m_shader(shader),
            m_texdef(m_shader, projection),
            m_observer(observer),
            m_undoable_observer(0),
            m_map(0)
    {
        m_shader.attach(*this);
        m_plane.copy(p0, p1, p2);
        m_texdef.setBasis(m_plane.plane3().normal());
        planeChanged();
        updateFiltered();
    }

    Face(const Face &other, FaceObserver *observer) :
            m_refcount(0),
            m_shader(other.m_shader.getShader(), other.m_shader.m_flags),
            m_texdef(m_shader, other.getTexdef().normalised()),
            m_observer(observer),
            m_undoable_observer(0),
            m_map(0)
    {
        m_shader.attach(*this);
        m_plane.copy(other.m_plane);
        planepts_assign(m_move_planepts, other.m_move_planepts);
        m_texdef.setBasis(m_plane.plane3().normal());
        planeChanged();
        updateFiltered();
    }

    ~Face()
    {
        m_shader.detach(*this);
    }

    void planeChanged()
    {
        revertTransform();
        m_observer->planeChanged();
    }

    void realiseShader()
    {
        m_observer->shaderChanged();
    }

    void unrealiseShader()
    {
    }

    void instanceAttach(MapFile *map)
    {
        m_shader.instanceAttach();
        m_map = map;
        m_undoable_observer = GlobalUndoSystem().observer(this);
        GlobalFilterSystem().registerFilterable(*this);
    }

    void instanceDetach(MapFile *map)
    {
        GlobalFilterSystem().unregisterFilterable(*this);
        m_undoable_observer = 0;
        GlobalUndoSystem().release(this);
        m_map = 0;
        m_shader.instanceDetach();
    }

    void render(RenderStateFlags state) const
    {
        Winding_Draw(m_winding, m_planeTransformed.plane3().normal(), state);
    }

    void updateFiltered()
    {
        m_filtered = face_filtered(*this);
    }

    bool isFiltered() const
    {
        return m_filtered;
    }

    void undoSave()
    {
        if (m_map != 0) {
            m_map->changed();
        }
        if (m_undoable_observer != 0) {
            m_undoable_observer->save(this);
        }
    }

// undoable
    UndoMemento *exportState() const
    {
        return new SavedState(*this);
    }

    void importState(const UndoMemento *data)
    {
        undoSave();

        static_cast<const SavedState *>( data )->exportState(*this);

        planeChanged();
        m_observer->connectivityChanged();
        texdefChanged();
        m_observer->shaderChanged();
        updateFiltered();
    }

    void IncRef()
    {
        ++m_refcount;
    }

    void DecRef()
    {
        if (--m_refcount == 0) {
            delete this;
        }
    }

    void flipWinding()
    {
        m_plane.reverse();
        planeChanged();
    }

    bool intersectVolume(const VolumeTest &volume, const Matrix4 &localToWorld) const
    {
        return volume.TestPlane(Plane3(plane3().normal(), -plane3().dist()), localToWorld);
    }

    void render(Renderer &renderer, const Matrix4 &localToWorld) const
    {
        renderer.SetState(m_shader.state(), Renderer::eFullMaterials);
        renderer.addRenderable(*this, localToWorld);
    }

    void transform(const Matrix4 &matrix, bool mirror)
    {
        if (g_brush_texturelock_enabled) {
            Texdef_transformLocked(m_texdefTransformed, m_shader.width(), m_shader.height(), m_plane.plane3(), matrix);
        }

        m_planeTransformed.transform(matrix, mirror);

#if 0
        ASSERT_MESSAGE( projectionaxis_for_normal( normal ) == projectionaxis_for_normal( plane3().normal() ), "bleh" );
#endif
        m_observer->planeChanged();

        if (g_brush_texturelock_enabled) {
            Brush_textureChanged();
        }
    }

    void assign_planepts(const PlanePoints planepts)
    {
        m_planeTransformed.copy(planepts[0], planepts[1], planepts[2]);
        m_observer->planeChanged();
    }

/// \brief Reverts the transformable state of the brush to identity.
    void revertTransform()
    {
        m_planeTransformed = m_plane;
        planepts_assign(m_move_planeptsTransformed, m_move_planepts);
        m_texdefTransformed = m_texdef.m_projection;
    }

    void freezeTransform()
    {
        undoSave();
        m_plane = m_planeTransformed;
        planepts_assign(m_move_planepts, m_move_planeptsTransformed);
        m_texdef.m_projection = m_texdefTransformed;
    }

    void update_move_planepts_vertex(std::size_t index, PlanePoints planePoints)
    {
        std::size_t numpoints = getWinding().numpoints;
        ASSERT_MESSAGE(index < numpoints, "update_move_planepts_vertex: invalid index");

        std::size_t opposite = Winding_Opposite(getWinding(), index);
        std::size_t adjacent = Winding_wrap(getWinding(), opposite + numpoints - 1);
        planePoints[0] = getWinding()[opposite].vertex;
        planePoints[1] = getWinding()[index].vertex;
        planePoints[2] = getWinding()[adjacent].vertex;
        // winding points are very inaccurate, so they must be quantised before using them to generate the face-plane
        planepts_quantise(planePoints, GRID_MIN);
    }

    void snapto(float snap)
    {
        if (contributes()) {
#if 0
                                                                                                                                    ASSERT_MESSAGE( plane3_valid( m_plane.plane3() ), "invalid plane before snap to grid" );
		planepts_snap( m_plane.planePoints(), snap );
		ASSERT_MESSAGE( plane3_valid( m_plane.plane3() ), "invalid plane after snap to grid" );
#else
            PlanePoints planePoints;
            update_move_planepts_vertex(0, planePoints);
            vector3_snap(planePoints[0], snap);
            vector3_snap(planePoints[1], snap);
            vector3_snap(planePoints[2], snap);
            assign_planepts(planePoints);
            freezeTransform();
#endif
            SceneChangeNotify();
            if (!plane3_valid(m_plane.plane3())) {
                globalErrorStream() << "WARNING: invalid plane after snap to grid\n";
            }
        }
    }

    void testSelect(SelectionTest &test, SelectionIntersection &best)
    {
        Winding_testSelect(m_winding, test, best);
    }

    void testSelect_centroid(SelectionTest &test, SelectionIntersection &best)
    {
        test.TestPoint(m_centroid, best);
    }

    void shaderChanged()
    {
        EmitTextureCoordinates();
        Brush_textureChanged();
        m_observer->shaderChanged();
        updateFiltered();
        planeChanged();
        SceneChangeNotify();
    }

    const char *GetShader() const
    {
        return m_shader.getShader();
    }

    void SetShader(const char *name)
    {
        undoSave();
        m_shader.setShader(name);
        shaderChanged();
    }

    void revertTexdef()
    {
        m_texdefTransformed = m_texdef.m_projection;
    }

    void texdefChanged()
    {
        revertTexdef();
        EmitTextureCoordinates();
        Brush_textureChanged();
    }

    void GetTexdef(TextureProjection &projection) const
    {
        projection = m_texdef.normalised();
    }

    void SetTexdef(const TextureProjection &projection)
    {
        undoSave();
        m_texdef.setTexdef(projection);
        texdefChanged();
    }

    void GetFlags(ContentsFlagsValue &flags) const
    {
        flags = m_shader.getFlags();
    }

    void SetFlags(const ContentsFlagsValue &flags)
    {
        undoSave();
        m_shader.setFlags(flags);
        m_observer->shaderChanged();
        updateFiltered();
    }

    void ShiftTexdef(float s, float t)
    {
        undoSave();
        m_texdef.shift(s, t);
        texdefChanged();
    }

    void ScaleTexdef(float s, float t)
    {
        undoSave();
        m_texdef.scale(s, t);
        texdefChanged();
    }

    void RotateTexdef(float angle)
    {
        undoSave();
        m_texdef.rotate(angle);
        texdefChanged();
    }

    void FitTexture(float s_repeat, float t_repeat)
    {
        undoSave();
        m_texdef.fit(m_plane.plane3().normal(), m_winding, s_repeat, t_repeat);
        texdefChanged();
    }

    void EmitTextureCoordinates()
    {
        Texdef_EmitTextureCoordinates(m_texdefTransformed, m_shader.width(), m_shader.height(), m_winding,
                                      plane3().normal(), g_matrix4_identity);
    }


    const Vector3 &centroid() const
    {
        return m_centroid;
    }

    void construct_centroid()
    {
        Winding_Centroid(m_winding, plane3(), m_centroid);
    }

    const Winding &getWinding() const
    {
        return m_winding;
    }

    Winding &getWinding()
    {
        return m_winding;
    }

    const Plane3 &plane3() const
    {
        m_observer->evaluateTransform();
        return m_planeTransformed.plane3();
    }

    FacePlane &getPlane()
    {
        return m_plane;
    }

    const FacePlane &getPlane() const
    {
        return m_plane;
    }

    FaceTexdef &getTexdef()
    {
        return m_texdef;
    }

    const FaceTexdef &getTexdef() const
    {
        return m_texdef;
    }

    FaceShader &getShader()
    {
        return m_shader;
    }

    const FaceShader &getShader() const
    {
        return m_shader;
    }

    bool isDetail() const
    {
        return (m_shader.m_flags.m_contentFlags & BRUSH_DETAIL_MASK) != 0;
    }

    void setDetail(bool detail)
    {
        undoSave();
        if (detail && !isDetail()) {
            m_shader.m_flags.m_contentFlags |= BRUSH_DETAIL_MASK;
        } else if (!detail && isDetail()) {
            m_shader.m_flags.m_contentFlags &= ~BRUSH_DETAIL_MASK;
        }
        m_observer->shaderChanged();
    }

    bool contributes() const
    {
        return m_winding.numpoints > 2;
    }

    bool is_bounded() const
    {
        for (Winding::const_iterator i = m_winding.begin(); i != m_winding.end(); ++i) {
            if ((*i).adjacent == c_brush_maxFaces) {
                return false;
            }
        }
        return true;
    }
};


class FaceVertexId {
    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)
    {
    }

    std::size_t getFace() const
    {
        return m_face;
    }

    std::size_t getVertex() const
    {
        return m_vertex;
    }
};

typedef std::size_t faceIndex_t;

struct EdgeRenderIndices {
    RenderIndex first;
    RenderIndex second;

    EdgeRenderIndices()
            : first(0), second(0)
    {
    }

    EdgeRenderIndices(const RenderIndex _first, const RenderIndex _second)
            : first(_first), second(_second)
    {
    }
};

struct EdgeFaces {
    faceIndex_t first;
    faceIndex_t second;

    EdgeFaces()
            : first(c_brush_maxFaces), second(c_brush_maxFaces)
    {
    }

    EdgeFaces(const faceIndex_t _first, const faceIndex_t _second)
            : first(_first), second(_second)
    {
    }
};

class RenderableWireframe : public OpenGLRenderable {
public:
    void render(RenderStateFlags state) const
    {
#if 1
        glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_vertices->colour);
        glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_vertices->vertex);
        glDrawElements(GL_LINES, GLsizei(m_size << 1), RenderIndexTypeID, m_faceVertex.data());
#else
                                                                                                                                glBegin( GL_LINES );
	for ( std::size_t i = 0; i < m_size; ++i )
	{
		glVertex3fv( &m_vertices[m_faceVertex[i].first].vertex.x );
		glVertex3fv( &m_vertices[m_faceVertex[i].second].vertex.x );
	}
	glEnd();
#endif
    }

    Array<EdgeRenderIndices> m_faceVertex;
    std::size_t m_size;
    const PointVertex *m_vertices;
};

class Brush;

typedef std::vector<Brush *> brush_vector_t;

class BrushFilter {
public:
    virtual bool filter(const Brush &brush) const = 0;
};

bool brush_filtered(Brush &brush);

void add_brush_filter(BrushFilter &filter, int mask, bool invert = false);


/// \brief Returns true if 'self' takes priority when building brush b-rep.
inline bool plane3_inside(const Plane3 &self, const Plane3 &other, bool selfIsLater)
{
    if (vector3_equal_epsilon(self.normal(), other.normal(), 0.001)) {
        // same plane? prefer the one with smaller index
        if (self.dist() == other.dist()) {
            return selfIsLater;
        }
        return self.dist() < other.dist();
    }
    return true;
}

typedef SmartPointer<Face> FaceSmartPointer;
typedef std::vector<FaceSmartPointer> Faces;

/// \brief Returns the unique-id of the edge adjacent to \p faceVertex in the edge-pair for the set of \p faces.
inline FaceVertexId next_edge(const Faces &faces, FaceVertexId faceVertex)
{
    std::size_t adjacent_face = faces[faceVertex.getFace()]->getWinding()[faceVertex.getVertex()].adjacent;
    std::size_t adjacent_vertex = Winding_FindAdjacent(faces[adjacent_face]->getWinding(), faceVertex.getFace());

    ASSERT_MESSAGE(adjacent_vertex != c_brush_maxFaces, "connectivity data invalid");
    if (adjacent_vertex == c_brush_maxFaces) {
        return faceVertex;
    }

    return FaceVertexId(adjacent_face, adjacent_vertex);
}

/// \brief Returns the unique-id of the vertex adjacent to \p faceVertex in the vertex-ring for the set of \p faces.
inline FaceVertexId next_vertex(const Faces &faces, FaceVertexId faceVertex)
{
    FaceVertexId nextEdge = next_edge(faces, faceVertex);
    return FaceVertexId(nextEdge.getFace(),
                        Winding_next(faces[nextEdge.getFace()]->getWinding(), nextEdge.getVertex()));
}

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);
    }

public:
    Faces &m_faces;
    FaceVertexId m_faceVertex;

    SelectableEdge(Faces &faces, FaceVertexId faceVertex)
            : m_faces(faces), m_faceVertex(faceVertex)
    {
    }

    SelectableEdge &operator=(const SelectableEdge &other)
    {
        m_faceVertex = other.m_faceVertex;
        return *this;
    }

    Face &getFace() const
    {
        return *m_faces[m_faceVertex.getFace()];
    }

    void testSelect(SelectionTest &test, SelectionIntersection &best)
    {
        test.TestPoint(getEdge(), best);
    }
};

class SelectableVertex {
    Vector3 getVertex() const
    {
        return getFace().getWinding()[m_faceVertex.getVertex()].vertex;
    }

public:
    Faces &m_faces;
    FaceVertexId m_faceVertex;

    SelectableVertex(Faces &faces, FaceVertexId faceVertex)
            : m_faces(faces), m_faceVertex(faceVertex)
    {
    }

    SelectableVertex &operator=(const SelectableVertex &other)
    {
        m_faceVertex = other.m_faceVertex;
        return *this;
    }

    Face &getFace() const
    {
        return *m_faces[m_faceVertex.getFace()];
    }

    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;
};

class BrushVisitor {
public:
    virtual void visit(Face &face) const = 0;
};

class Brush :
        public TransformNode,
        public Bounded,
        public Cullable,
        public Snappable,
        public Undoable,
        public FaceObserver,
        public Filterable,
        public Nameable,
        public BrushDoom3 {
private:
    scene::Node *m_node;
    typedef UniqueSet<BrushObserver *> Observers;
    Observers m_observers;
    UndoObserver *m_undoable_observer;
    MapFile *m_map;

// state
    Faces m_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_uniqueEdgePoints;
    typedef std::vector<SelectableEdge> SelectableEdges;
    SelectableEdges m_select_edges;
    RenderablePointArray m_render_edges;

    Array<EdgeRenderIndices> m_edge_indices;
    Array<EdgeFaces> m_edge_faces;

    AABB m_aabb_local;
// ----

    Callback<void()> m_evaluateTransform;
    Callback<void()> m_boundsChanged;

    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;

    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();
    }

    void attach(BrushObserver &observer)
    {
        for (Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i) {
            observer.push_back(*(*i));
        }

        for (SelectableEdges::iterator i = m_select_edges.begin(); i != m_select_edges.end(); ++i) {
            observer.edge_push_back(*i);
        }

        for (SelectableVertices::iterator i = m_select_vertices.begin(); i != m_select_vertices.end(); ++i) {
            observer.vertex_push_back(*i);
        }

        m_observers.insert(&observer);
    }

    void detach(BrushObserver &observer)
    {
        m_observers.erase(&observer);
    }

    void forEachFace(const BrushVisitor &visitor) const
    {
        for (Faces::const_iterator i = m_faces.begin(); i != m_faces.end(); ++i) {
            visitor.visit(*(*i));
        }
    }

    void forEachFace_instanceAttach(MapFile *map) const
    {
        for (Faces::const_iterator i = m_faces.begin(); i != m_faces.end(); ++i) {
            (*i)->instanceAttach(map);
        }
    }

    void forEachFace_instanceDetach(MapFile *map) const
    {
        for (Faces::const_iterator i = m_faces.begin(); i != m_faces.end(); ++i) {
            (*i)->instanceDetach(map);
        }
    }

    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 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);
        }
    }

// nameable
    const char *name() const
    {
        return "brush";
    }

    void attach(const NameCallback &callback)
    {
    }

    void detach(const NameCallback &callback)
    {
    }

// filterable
    void updateFiltered()
    {
        if (m_node != 0) {
            if (brush_filtered(*this)) {
                m_node->enable(scene::Node::eFiltered);
            } else {
                m_node->disable(scene::Node::eFiltered);
            }
        }
    }

// observer
    void planeChanged()
    {
        m_planeChanged = true;
        aabbChanged();
        m_lightsChanged();
    }

    void shaderChanged()
    {
        updateFiltered();
        planeChanged();
    }

    void evaluateBRep() const
    {
        if (m_planeChanged) {
            m_planeChanged = false;
            const_cast<Brush *>( this )->buildBRep();
        }
    }

    void transformChanged()
    {
        m_transformChanged = true;
        planeChanged();
    }

    typedef MemberCaller<Brush, void(), &Brush::transformChanged> TransformChangedCaller;

    void evaluateTransform()
    {
        if (m_transformChanged) {
            m_transformChanged = false;
            revertTransform();
            m_evaluateTransform();
        }
    }

    const Matrix4 &localToParent() const
    {
        return g_matrix4_identity;
    }

    void aabbChanged()
    {
        m_boundsChanged();
    }

    const AABB &localAABB() const
    {
        evaluateBRep();
        return m_aabb_local;
    }

    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;
        }
    }

    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 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();
        }
    }

/// \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();
    }

    void appendFaces(const Faces &other)
    {
        clear();
        for (Faces::const_iterator i = other.begin(); i != other.end(); ++i) {
            push_back(*i);
        }
    }

/// \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);
        }
    }

    UndoMemento *exportState() const
    {
        return new BrushUndoMemento(m_faces);
    }

    void importState(const UndoMemento *state)
    {
        undoSave();
        appendFaces(static_cast<const BrushUndoMemento *>( state )->m_faces);
        planeChanged();

        for (Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i) {
            (*i)->DEBUG_verify();
        }
    }

    bool isDetail()
    {
        return !m_faces.empty() && m_faces.front()->isDetail();
    }

/// \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();
    }

/// \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
        }

        Face::m_quantise = (m_type == eBrushTypeQuake) ? quantiseInteger : quantiseFloating;

        m_state_point = GlobalShaderCache().capture("$POINT");
    }

    static void destroyStatic()
    {
        GlobalShaderCache().release("$POINT");
    }

    std::size_t DEBUG_size()
    {
        return m_faces.size();
    }

    typedef Faces::const_iterator const_iterator;

    const_iterator begin() const
    {
        return m_faces.begin();
    }

    const_iterator end() const
    {
        return m_faces.end();
    }

    Face *back()
    {
        return m_faces.back();
    }

    const Face *back() const
    {
        return m_faces.back();
    }

    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);
        }
    }

    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 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();
        }
    }

    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 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();
    }

    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;
            }
        }
        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();

        {
            std::size_t i = 0;
            while (i < m_faces.size()) {
                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;

        // 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) {
                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;
                }

                buffer[!swap].clear();

#if BRUSH_CONNECTIVITY_DEBUG
                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]);
                }

#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";
				}
			}
#endif

                //ASSERT_MESSAGE(buffer[!swap].numpoints != 1, "created single-point winding");

                swap = !swap;
            }
        }

        Winding_forFixedWinding(winding, buffer[swap]);

#if BRUSH_CONNECTIVITY_DEBUG
                                                                                                                                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";
		}
	}
#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_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];
            }
        }
    }

/// \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();
    }

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 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();
        }
    }

/// \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;
    }

/// \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();) {
                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";
#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.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();

            if (degen.numpoints == 2) {
#if BRUSH_DEGENERATE_DEBUG
                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) {
#if BRUSH_DEGENERATE_DEBUG
                        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 &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";
#endif
                        winding[index].adjacent = degen[0].adjacent;
                    }
                }

                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())
            {
                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";
#endif
                        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())
            {
                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";
#endif
                    // 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";
#endif
                        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;
            }
        }
        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();

            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";
#endif
                    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 texture coordinates
                    f.EmitTextureCoordinates();
                }
            }
        }

        bool degenerate = !isBounded();

        if (!degenerate) {
            // clean up connectivity information.
            // these cleanups must be applied in a specific order.
            removeDegenerateEdges();
            removeDegenerateFaces();
            removeDuplicateEdges();
            verifyConnectivityGraph();
        }

        return degenerate;
    }

/// \brief Constructs the face windings and updates anything that depends on them.
    void buildBRep();
};


class FaceInstance;

class FaceInstanceSet {
    typedef SelectionList<FaceInstance> FaceInstances;
    FaceInstances m_faceInstances;
public:
    void insert(FaceInstance &faceInstance)
    {
        m_faceInstances.append(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));
        }
    }

    bool empty() const
    {
        return m_faceInstances.empty();
    }

    FaceInstance &last() const
    {
        return m_faceInstances.back();
    }
};

extern FaceInstanceSet g_SelectedFaceInstances;

typedef std::list<std::size_t> VertexSelection;

inline VertexSelection::iterator VertexSelection_find(VertexSelection &self, std::size_t value)
{
    return std::find(self.begin(), self.end(), value);
}

inline VertexSelection::const_iterator VertexSelection_find(const VertexSelection &self, std::size_t value)
{
    return std::find(self.begin(), self.end(), value);
}

inline VertexSelection::iterator VertexSelection_insert(VertexSelection &self, std::size_t value)
{
    VertexSelection::iterator i = VertexSelection_find(self, value);
    if (i == self.end()) {
        self.push_back(value);
        return --self.end();
    }
    return i;
}

inline void VertexSelection_erase(VertexSelection &self, std::size_t value)
{
    VertexSelection::iterator i = VertexSelection_find(self, value);
    if (i != self.end()) {
        self.erase(i);
    }
}

inline bool triangle_reversed(std::size_t x, std::size_t y, std::size_t z)
{
    return !((x < y && y < z) || (z < x && x < y) || (y < z && z < x));
}

template<typename Element>
inline Vector3
triangle_cross(const BasicVector3<Element> &x, const BasicVector3<Element> y, const BasicVector3<Element> &z)
{
    return vector3_cross(y - x, z - x);
}

template<typename Element>
inline bool
triangles_same_winding(const BasicVector3<Element> &x1, const BasicVector3<Element> y1, const BasicVector3<Element> &z1,
                       const BasicVector3<Element> &x2, const BasicVector3<Element> y2, const BasicVector3<Element> &z2)
{
    return vector3_dot(triangle_cross(x1, y1, z1), triangle_cross(x2, y2, z2)) > 0;
}


typedef const Plane3 *PlanePointer;
typedef PlanePointer *PlanesIterator;

class VectorLightList : public LightList {
    typedef std::vector<const RendererLight *> Lights;
    Lights m_lights;
public:
    void addLight(const RendererLight &light)
    {
        m_lights.push_back(&light);
    }

    void clear()
    {
        m_lights.clear();
    }

    void evaluateLights() 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));
        }
    }
};

class FaceInstance {
    Face *m_face;
    ObservedSelectable m_selectable;
    ObservedSelectable m_selectableVertices;
    ObservedSelectable m_selectableEdges;
    SelectionChangeCallback m_selectionChanged;

    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;
    }

    const Face &getFace() const
    {
        return *m_face;
    }

    void selectedChanged(const Selectable &selectable)
    {
        if (selectable.isSelected()) {
            g_SelectedFaceInstances.insert(*this);
        } else {
            g_SelectedFaceInstances.erase(*this);
        }
        m_selectionChanged(selectable);
    }

    typedef MemberCaller<FaceInstance, void(const Selectable &), &FaceInstance::selectedChanged> SelectedChangedCaller;

    bool selectedVertices() const
    {
        return !m_vertexSelection.empty();
    }

    bool selectedEdges() const
    {
        return !m_edgeSelection.empty();
    }

    bool isSelected() const
    {
        return m_selectable.isSelected();
    }

    bool selectedComponents() const
    {
        return selectedVertices() || selectedEdges() || isSelected();
    }

    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;
        }
    }

    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 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 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 SelectedFaces_foreach(Functor functor) const
    {
        if (isSelected()) {
            functor(centroid());
        }
    }

    template<typename Functor>
    void SelectedComponents_foreach(Functor functor) const
    {
        SelectedVertices_foreach(functor);
        SelectedEdges_foreach(functor);
        SelectedFaces_foreach(functor);
    }

    void iterate_selected(AABB &aabb) const
    {
        SelectedComponents_foreach([&](const Vector3 &point) {
            aabb_extend_by_point_safe(aabb, point);
        });
    }

    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));
        });
    }

    bool intersectVolume(const VolumeTest &volume, const Matrix4 &localToWorld) const
    {
        return m_face->intersectVolume(volume, localToWorld);
    }

    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(SelectionTest &test, SelectionIntersection &best)
    {
        if (!m_face->isFiltered()) {
            m_face->testSelect(test, best);
        }
    }

    void testSelect(Selector &selector, SelectionTest &test)
    {
        SelectionIntersection best;
        testSelect(test, best);
        if (best.valid()) {
            Selector_add(selector, m_selectable, best);
        }
    }

    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);
            }
        }
    }

    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;
            }
        }

        Selector_add(selector, m_selectable);

        selectedPlaneCallback(getFace().plane3());
    }

    void selectReversedPlane(Selector &selector, const SelectedPlanes &selectedPlanes)
    {
        if (selectedPlanes.contains(plane3_flipped(getFace().plane3()))) {
            Selector_add(selector, m_selectable);
        }
    }

    void transformComponents(const Matrix4 &matrix)
    {
        if (isSelected()) {
            m_face->transform(matrix, false);
        }
        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);
            }
        }
        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);
            }
        }
    }

    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_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);

        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"
        );

        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 (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()));

                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();
    }

    bool selected_vertex(std::size_t index) const
    {
        return VertexSelection_find(m_vertexSelection, getFace().getWinding()[index].adjacent) !=
               m_vertexSelection.end();
    }

    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");

        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_selection_edge()
    {
        if (m_edgeSelection.size() == 0) {
            m_selectableEdges.setSelected(false);
        } else {
            m_selectableEdges.setSelected(true);

            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);
        }

        SceneChangeNotify();
        update_selection_edge();
    }

    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();
    }

    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;
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);
        } else {
            m_winding.resize(0);
        }
    }

    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));
        }
    }

    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)
{
    const Plane3 &facePlane = face.getFace().plane3();
    const Vector3 &origin = light.aabb().origin;
    Plane3 tmp(plane3_transformed(Plane3(facePlane.normal(), -facePlane.dist()), localToWorld));
    if (!plane3_test_point(tmp, origin)
        || !plane3_test_point(tmp, vector3_added(origin, light.offset()))) {
        face.m_lights.addLight(light);
    }
}


typedef std::vector<FaceInstance> FaceInstances;

class EdgeInstance : public Selectable {
    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;
        }

        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;
    }

    void setSelected(bool select)
    {
        select_edge(select);
    }

    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);
        }
    }
};

class VertexInstance : public Selectable {
    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);
        } 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;
            }
            faceVertex = next_vertex(m_vertex->m_faces, faceVertex);
        } 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;
    }

    void setSelected(bool select)
    {
        select_vertex(select);
    }

    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);
        }
    }
};

class BrushInstanceVisitor {
public:
    virtual void visit(FaceInstance &face) const = 0;
};

class BrushInstance :
        public BrushObserver,
        public scene::Instance,
        public Selectable,
        public Renderable,
        public SelectionTestable,
        public ComponentSelectionTestable,
        public ComponentEditable,
        public ComponentSnappable,
        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;
        }
    };


    Brush &m_brush;

    FaceInstances m_faceInstances;

    typedef std::vector<EdgeInstance> EdgeInstances;
    EdgeInstances m_edgeInstances;
    typedef std::vector<VertexInstance> VertexInstances;
    VertexInstances m_vertexInstances;

    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

    BrushClipPlane m_clipPlane;

    static Shader *m_state_selpoint;

    const LightList *m_lightList;

    TransformModifier m_transform;

    BrushInstance(const BrushInstance &other); // NOT COPYABLE
    BrushInstance &operator=(const BrushInstance &other); // NOT ASSIGNABLE
public:
    static Counter *m_counter;

    typedef LazyStatic<TypeCasts> StaticTypeCasts;

    void lightsChanged()
    {
        m_lightList->lightsChanged();
    }

    typedef MemberCaller<BrushInstance, void(), &BrushInstance::lightsChanged> LightsChangedCaller;

    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();

        m_lightList = &GlobalShaderCache().attach(*this);
        m_brush.m_lightsChanged = LightsChangedCaller(*this); ///\todo Make this work with instancing.

        Instance::setTransformChangedCallback(LightsChangedCaller(*this));
    }

    ~BrushInstance()
    {
        Instance::setTransformChangedCallback(Callback<void()>());

        m_brush.m_lightsChanged = Callback<void()>();
        GlobalShaderCache().detach(*this);

        m_counter->decrement();
        m_brush.detach(*this);
        m_brush.instanceDetach(Instance::path());
    }

    Brush &getBrush()
    {
        return m_brush;
    }

    const Brush &getBrush() const
    {
        return m_brush;
    }

    Bounded &get(NullType<Bounded>)
    {
        return m_brush;
    }

    Cullable &get(NullType<Cullable>)
    {
        return m_brush;
    }

    Transformable &get(NullType<Transformable>)
    {
        return m_transform;
    }

    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;

    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);
        }
        return visitor;
    }

    static void constructStatic()
    {
        m_state_selpoint = GlobalShaderCache().capture("$SELPOINT");
    }

    static void destroyStatic()
    {
        GlobalShaderCache().release("$SELPOINT");
    }

    void clear()
    {
        m_faceInstances.clear();
    }

    void reserve(std::size_t size)
    {
        m_faceInstances.reserve(size);
    }

    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 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 edge_clear()
    {
        m_edgeInstances.clear();
    }

    void edge_push_back(SelectableEdge &edge)
    {
        m_edgeInstances.push_back(EdgeInstance(m_faceInstances, edge));
    }

    void vertex_clear()
    {
        m_vertexInstances.clear();
    }

    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");
    }

    bool isSelected() const
    {
        return m_selectable.isSelected();
    }

    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 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) {
                    *j = (*i).intersectVolume(volume, localToWorld);
                }
            }

            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();

        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();

        const Matrix4 &localToWorld = Instance::localToWorld();

        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);
        }
    }

    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;

        if (componentMode && isSelected()) {
            renderComponents(renderer, volume);
        }

        if (parentSelected()) {
            if (!componentMode) {
                renderer.Highlight(Renderer::eFace);
            }
            renderer.Highlight(Renderer::ePrimitive);
        }
    }

    void renderSolid(Renderer &renderer, const VolumeTest &volume, const Matrix4 &localToWorld) const
    {
        //renderCommon(renderer, volume);

        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);
        }

        renderComponentsSelected(renderer, volume, localToWorld);
    }

    void renderWireframe(Renderer &renderer, const VolumeTest &volume, const Matrix4 &localToWorld) const
    {
        //renderCommon(renderer, volume);

        evaluateViewDependent(volume, localToWorld);

        if (m_render_wireframe.m_size != 0) {
            renderer.addRenderable(m_render_wireframe, localToWorld);
        }

        renderComponentsSelected(renderer, volume, localToWorld);
    }

    void renderSolid(Renderer &renderer, const VolumeTest &volume) const
    {
        m_brush.evaluateBRep();

        renderClipPlane(renderer, volume);

        renderSolid(renderer, volume, localToWorld());
    }

    void renderWireframe(Renderer &renderer, const VolumeTest &volume) const
    {
        m_brush.evaluateBRep();

        renderClipPlane(renderer, volume);

        renderWireframe(renderer, volume, localToWorld());
    }

    void viewChanged() const
    {
        m_viewChanged = true;
    }

    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);
        }
    }

    bool isSelectedComponents() const
    {
        for (FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i) {
            if ((*i).selectedComponents()) {
                return true;
            }
        }
        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 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) {
                    (*i).testSelect(selector, test);
                }
            }
                break;
            case SelectionSystem::eEdge: {
                for (EdgeInstances::iterator i = m_edgeInstances.begin(); i != m_edgeInstances.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) {
                        (*i).testSelect(selector, test);
                    }
                } else {
                    for (FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i) {
                        (*i).testSelect_centroid(selector, test);
                    }
                }
            }
                break;
            default:
                break;
        }
    }

    void selectPlanes(Selector &selector, SelectionTest &test, const PlaneCallback &selectedPlaneCallback)
    {
        test.BeginMesh(localToWorld());

        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 (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 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();

        for (FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i) {
            (*i).iterate_selected(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 evaluateTransform()
    {
        Matrix4 matrix(m_transform.calculateTransform());
        //globalOutputStream() << "matrix: " << matrix << "\n";

        if (m_transform.getType() == TRANSFORM_PRIMITIVE) {
            m_brush.transform(matrix);
        } else {
            transformComponents(matrix);
        }
    }

    void applyTransform()
    {
        m_brush.revertTransform();
        evaluateTransform();
        m_brush.freezeTransform();
    }

    typedef MemberCaller<BrushInstance, void(), &BrushInstance::applyTransform> ApplyTransformCaller;

    void setClipPlane(const Plane3 &plane)
    {
        m_clipPlane.setPlane(m_brush, plane);
    }

    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 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)
{
    return InstanceTypeCast<BrushInstance>::cast(instance);
}


template<typename Functor>
class BrushSelectedVisitor : public SelectionSystem::Visitor {
    const Functor &m_functor;
public:
    BrushSelectedVisitor(const Functor &functor) : m_functor(functor)
    {
    }

    void visit(scene::Instance &instance) const
    {
        BrushInstance *brush = Instance_getBrush(instance);
        if (brush != 0) {
            m_functor(*brush);
        }
    }
};

template<typename Functor>
inline const Functor &Scene_forEachSelectedBrush(const Functor &functor)
{
    GlobalSelectionSystem().foreachSelected(BrushSelectedVisitor<Functor>(functor));
    return functor;
}

template<typename Functor>
class BrushVisibleSelectedVisitor : public SelectionSystem::Visitor {
    const Functor &m_functor;
public:
    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);
        }
    }
};

template<typename Functor>
inline const Functor &Scene_forEachVisibleSelectedBrush(const Functor &functor)
{
    GlobalSelectionSystem().foreachSelected(BrushVisibleSelectedVisitor<Functor>(functor));
    return functor;
}

class BrushForEachFace {
    const BrushInstanceVisitor &m_visitor;
public:
    BrushForEachFace(const BrushInstanceVisitor &visitor) : m_visitor(visitor)
    {
    }

    void operator()(BrushInstance &brush) const
    {
        brush.forEachFaceInstance(m_visitor);
    }
};

template<class Functor>
class FaceInstanceVisitFace : public BrushInstanceVisitor {
    const Functor &functor;
public:
    FaceInstanceVisitFace(const Functor &functor)
            : functor(functor)
    {
    }

    void visit(FaceInstance &face) const
    {
        functor(face.getFace());
    }
};

template<typename Functor>
inline const Functor &Brush_forEachFace(BrushInstance &brush, const Functor &functor)
{
    brush.forEachFaceInstance(FaceInstanceVisitFace<Functor>(functor));
    return functor;
}

template<class Functor>
class FaceVisitAll : public BrushVisitor {
    const Functor &functor;
public:
    FaceVisitAll(const Functor &functor)
            : functor(functor)
    {
    }

    void visit(Face &face) const
    {
        functor(face);
    }
};

template<typename Functor>
inline const Functor &Brush_forEachFace(const Brush &brush, const Functor &functor)
{
    brush.forEachFace(FaceVisitAll<Functor>(functor));
    return functor;
}

template<typename Functor>
inline const Functor &Brush_forEachFace(Brush &brush, const Functor &functor)
{
    brush.forEachFace(FaceVisitAll<Functor>(functor));
    return functor;
}

template<class Functor>
class FaceInstanceVisitAll : public BrushInstanceVisitor {
    const Functor &functor;
public:
    FaceInstanceVisitAll(const Functor &functor)
            : functor(functor)
    {
    }

    void visit(FaceInstance &face) const
    {
        functor(face);
    }
};

template<typename Functor>
inline const Functor &Brush_ForEachFaceInstance(BrushInstance &brush, const Functor &functor)
{
    brush.forEachFaceInstance(FaceInstanceVisitAll<Functor>(functor));
    return functor;
}

template<typename Functor>
inline const Functor &Scene_forEachBrush(scene::Graph &graph, const Functor &functor)
{
    graph.traverse(InstanceWalker<InstanceApply<BrushInstance, Functor> >(functor));
    return functor;
}

template<typename Type, typename Functor>
class InstanceIfVisible : public Functor {
public:
    InstanceIfVisible(const Functor &functor) : Functor(functor)
    {
    }

    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;
public:
    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);
            }
        }
        return true;
    }
};

template<typename Functor>
inline const Functor &Scene_forEachVisibleBrush(scene::Graph &graph, const Functor &functor)
{
    graph.traverse(BrushVisibleWalker<Functor>(functor));
    return functor;
}

template<typename Functor>
inline const Functor &Scene_ForEachBrush_ForEachFace(scene::Graph &graph, const Functor &functor)
{
    Scene_forEachBrush(graph, BrushForEachFace(FaceInstanceVisitFace<Functor>(functor)));
    return functor;
}

// d1223m
template<typename Functor>
inline const Functor &Scene_ForEachBrush_ForEachFaceInstance(scene::Graph &graph, const Functor &functor)
{
    Scene_forEachBrush(graph, BrushForEachFace(FaceInstanceVisitAll<Functor>(functor)));
    return functor;
}

template<typename Functor>
inline const Functor &Scene_ForEachSelectedBrush_ForEachFace(scene::Graph &graph, const Functor &functor)
{
    Scene_forEachSelectedBrush(BrushForEachFace(FaceInstanceVisitFace<Functor>(functor)));
    return functor;
}

template<typename Functor>
inline const Functor &Scene_ForEachSelectedBrush_ForEachFaceInstance(scene::Graph &graph, const Functor &functor)
{
    Scene_forEachSelectedBrush(BrushForEachFace(FaceInstanceVisitAll<Functor>(functor)));
    return functor;
}

template<typename Functor>
class FaceVisitorWrapper {
    const Functor &functor;
public:
    FaceVisitorWrapper(const Functor &functor) : functor(functor)
    {
    }

    void operator()(FaceInstance &faceInstance) const
    {
        functor(faceInstance.getFace());
    }
};

template<typename Functor>
inline const Functor &Scene_ForEachSelectedBrushFace(scene::Graph &graph, const Functor &functor)
{
    g_SelectedFaceInstances.foreach(FaceVisitorWrapper<Functor>(functor));
    return functor;
}


#endif