2 Copyright (C) 1999-2006 Id Software, Inc. and contributors.
3 For a list of contributors, see the accompanying CONTRIBUTORS file.
5 This file is part of GtkRadiant.
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 #if !defined(INCLUDED_BRUSH_H)
23 #define INCLUDED_BRUSH_H
26 /// \brief The brush primitive.
28 /// A collection of planes that define a convex polyhedron.
29 /// The Boundary-Representation of this primitive is a manifold polygonal mesh.
30 /// Each face polygon is represented by a list of vertices in a \c Winding.
31 /// Each vertex is associated with another face that is adjacent to the edge
32 /// formed by itself and the next vertex in the winding. This information can
33 /// be used to find edge-pairs and vertex-rings.
36 #include "debugging/debugging.h"
40 #include "iselection.h"
47 #include "moduleobserver.h"
52 #include "renderable.h"
53 #include "selectable.h"
57 #include "math/frustum.h"
58 #include "selectionlib.h"
60 #include "texturelib.h"
61 #include "container/container.h"
62 #include "generic/bitfield.h"
63 #include "signal/signalfwd.h"
66 #include "brush_primit.h"
68 const unsigned int BRUSH_DETAIL_FLAG = 27;
69 const unsigned int BRUSH_DETAIL_MASK = (1 << BRUSH_DETAIL_FLAG);
83 #define BRUSH_CONNECTIVITY_DEBUG 0
84 #define BRUSH_DEGENERATE_DEBUG 0
86 template<typename TextOuputStreamType>
87 inline TextOuputStreamType& ostream_write(TextOuputStreamType& ostream, const Matrix4& m)
89 return ostream << "(" << m[0] << " " << m[1] << " " << m[2] << " " << m[3] << ", "
90 << m[4] << " " << m[5] << " " << m[6] << " " << m[7] << ", "
91 << m[8] << " " << m[9] << " " << m[10] << " " << m[11] << ", "
92 << m[12] << " " << m[13] << " " << m[14] << " " << m[15] << ")";
95 inline void print_vector3(const Vector3& v)
97 globalOutputStream() << "( " << v.x() << " " << v.y() << " " << v.z() << " )\n";
100 inline void print_3x3(const Matrix4& m)
102 globalOutputStream() << "( " << m.xx() << " " << m.xy() << " " << m.xz() << " ) "
103 << "( " << m.yx() << " " << m.yy() << " " << m.yz() << " ) "
104 << "( " << m.zx() << " " << m.zy() << " " << m.zz() << " )\n";
109 inline bool texdef_sane(const texdef_t& texdef)
111 return fabs(texdef.shift[0]) < (1 << 16)
112 && fabs(texdef.shift[1]) < (1 << 16);
115 inline void Winding_DrawWireframe(const Winding& winding)
117 glVertexPointer(3, GL_FLOAT, sizeof(WindingVertex), &winding.points.data()->vertex);
118 glDrawArrays(GL_LINE_LOOP, 0, GLsizei(winding.numpoints));
121 inline void Winding_Draw(const Winding& winding, const Vector3& normal, RenderStateFlags state)
123 glVertexPointer(3, GL_FLOAT, sizeof(WindingVertex), &winding.points.data()->vertex);
125 if((state & RENDER_BUMP) != 0)
127 Vector3 normals[c_brush_maxFaces];
128 typedef Vector3* Vector3Iter;
129 for(Vector3Iter i = normals, end = normals + winding.numpoints; i != end; ++i)
133 if(GlobalShaderCache().useShaderLanguage())
135 glNormalPointer(GL_FLOAT, sizeof(Vector3), normals);
136 glVertexAttribPointerARB(c_attr_TexCoord0, 2, GL_FLOAT, 0, sizeof(WindingVertex), &winding.points.data()->texcoord);
137 glVertexAttribPointerARB(c_attr_Tangent, 3, GL_FLOAT, 0, sizeof(WindingVertex), &winding.points.data()->tangent);
138 glVertexAttribPointerARB(c_attr_Binormal, 3, GL_FLOAT, 0, sizeof(WindingVertex), &winding.points.data()->bitangent);
142 glVertexAttribPointerARB(11, 3, GL_FLOAT, 0, sizeof(Vector3), normals);
143 glVertexAttribPointerARB(8, 2, GL_FLOAT, 0, sizeof(WindingVertex), &winding.points.data()->texcoord);
144 glVertexAttribPointerARB(9, 3, GL_FLOAT, 0, sizeof(WindingVertex), &winding.points.data()->tangent);
145 glVertexAttribPointerARB(10, 3, GL_FLOAT, 0, sizeof(WindingVertex), &winding.points.data()->bitangent);
150 if (state & RENDER_LIGHTING)
152 Vector3 normals[c_brush_maxFaces];
153 typedef Vector3* Vector3Iter;
154 for(Vector3Iter i = normals, last = normals + winding.numpoints; i != last; ++i)
158 glNormalPointer(GL_FLOAT, sizeof(Vector3), normals);
161 if (state & RENDER_TEXTURE)
163 glTexCoordPointer(2, GL_FLOAT, sizeof(WindingVertex), &winding.points.data()->texcoord);
167 if (state & RENDER_FILL)
169 glDrawArrays(GL_TRIANGLE_FAN, 0, GLsizei(winding.numpoints));
173 glDrawArrays(GL_LINE_LOOP, 0, GLsizei(winding.numpoints));
176 glDrawArrays(GL_POLYGON, 0, GLsizei(winding.numpoints));
180 const Winding& winding = winding;
182 if(state & RENDER_FILL)
188 glBegin(GL_LINE_LOOP);
191 if (state & RENDER_LIGHTING)
194 for(int i = 0; i < winding.numpoints; ++i)
196 if (state & RENDER_TEXTURE)
197 glTexCoord2fv(&winding.points[i][3]);
198 glVertex3fv(winding.points[i]);
205 #include "shaderlib.h"
207 typedef DoubleVector3 PlanePoints[3];
209 inline bool planepts_equal(const PlanePoints planepts, const PlanePoints other)
211 return planepts[0] == other[0] && planepts[1] == other[1] && planepts[2] == other[2];
214 inline void planepts_assign(PlanePoints planepts, const PlanePoints other)
216 planepts[0] = other[0];
217 planepts[1] = other[1];
218 planepts[2] = other[2];
221 inline void planepts_quantise(PlanePoints planepts, double snap)
223 vector3_snap(planepts[0], snap);
224 vector3_snap(planepts[1], snap);
225 vector3_snap(planepts[2], snap);
228 inline float vector3_max_component(const Vector3& vec3)
230 return std::max(fabsf(vec3[0]), std::max(fabsf(vec3[1]), fabsf(vec3[2])));
233 inline void edge_snap(Vector3& edge, double snap)
235 float scale = static_cast<float>(ceil(fabs(snap / vector3_max_component(edge))));
238 vector3_scale(edge, scale);
240 vector3_snap(edge, snap);
243 inline void planepts_snap(PlanePoints planepts, double snap)
245 Vector3 edge01(vector3_subtracted(planepts[1], planepts[0]));
246 Vector3 edge12(vector3_subtracted(planepts[2], planepts[1]));
247 Vector3 edge20(vector3_subtracted(planepts[0], planepts[2]));
249 double length_squared_01 = vector3_dot(edge01, edge01);
250 double length_squared_12 = vector3_dot(edge12, edge12);
251 double length_squared_20 = vector3_dot(edge20, edge20);
253 vector3_snap(planepts[0], snap);
255 if(length_squared_01 < length_squared_12)
257 if(length_squared_12 < length_squared_20)
259 edge_snap(edge01, snap);
260 edge_snap(edge12, snap);
261 planepts[1] = vector3_added(planepts[0], edge01);
262 planepts[2] = vector3_added(planepts[1], edge12);
266 edge_snap(edge20, snap);
267 edge_snap(edge01, snap);
268 planepts[1] = vector3_added(planepts[0], edge20);
269 planepts[2] = vector3_added(planepts[1], edge01);
274 if(length_squared_01 < length_squared_20)
276 edge_snap(edge01, snap);
277 edge_snap(edge12, snap);
278 planepts[1] = vector3_added(planepts[0], edge01);
279 planepts[2] = vector3_added(planepts[1], edge12);
283 edge_snap(edge12, snap);
284 edge_snap(edge20, snap);
285 planepts[1] = vector3_added(planepts[0], edge12);
286 planepts[2] = vector3_added(planepts[1], edge20);
291 inline PointVertex pointvertex_for_planept(const DoubleVector3& point, const Colour4b& colour)
295 static_cast<float>(point.x()),
296 static_cast<float>(point.y()),
297 static_cast<float>(point.z())
303 inline PointVertex pointvertex_for_windingpoint(const Vector3& point, const Colour4b& colour)
306 vertex3f_for_vector3(point),
311 inline bool check_plane_is_integer(const PlanePoints& planePoints)
313 return !float_is_integer(planePoints[0][0])
314 || !float_is_integer(planePoints[0][1])
315 || !float_is_integer(planePoints[0][2])
316 || !float_is_integer(planePoints[1][0])
317 || !float_is_integer(planePoints[1][1])
318 || !float_is_integer(planePoints[1][2])
319 || !float_is_integer(planePoints[2][0])
320 || !float_is_integer(planePoints[2][1])
321 || !float_is_integer(planePoints[2][2]);
324 inline void brush_check_shader(const char* name)
326 if(!shader_valid(name))
328 globalErrorStream() << "brush face has invalid texture name: '" << name << "'\n";
332 class FaceShaderObserver
335 virtual void realiseShader() = 0;
336 virtual void unrealiseShader() = 0;
339 class FaceShaderObserverRealise
342 void operator()(FaceShaderObserver& observer) const
344 observer.realiseShader();
348 class FaceShaderObserverUnrealise
351 void operator()(FaceShaderObserver& observer) const
353 observer.unrealiseShader();
357 typedef ReferencePair<FaceShaderObserver> FaceShaderObserverPair;
360 class ContentsFlagsValue
366 ContentsFlagsValue(int surfaceFlags, int contentFlags, int value, bool specified) :
367 m_surfaceFlags(surfaceFlags),
368 m_contentFlags(contentFlags),
370 m_specified(specified)
379 inline void ContentsFlagsValue_assignMasked(ContentsFlagsValue& flags, const ContentsFlagsValue& other)
381 bool detail = bitfield_enabled(flags.m_contentFlags, BRUSH_DETAIL_MASK);
385 flags.m_contentFlags = bitfield_enable(flags.m_contentFlags, BRUSH_DETAIL_MASK);
389 flags.m_contentFlags = bitfield_disable(flags.m_contentFlags, BRUSH_DETAIL_MASK);
394 class FaceShader : public ModuleObserver
400 CopiedString m_shader;
401 ContentsFlagsValue m_flags;
403 SavedState(const FaceShader& faceShader)
405 m_shader = faceShader.getShader();
406 m_flags = faceShader.m_flags;
409 void exportState(FaceShader& faceShader) const
411 faceShader.setShader(m_shader.c_str());
412 faceShader.setFlags(m_flags);
416 CopiedString m_shader;
418 ContentsFlagsValue m_flags;
419 FaceShaderObserverPair m_observers;
423 FaceShader(const char* shader, const ContentsFlagsValue& flags = ContentsFlagsValue(0, 0, 0, false)) :
436 // copy-construction not supported
437 FaceShader(const FaceShader& other);
439 void instanceAttach()
442 m_state->incrementUsed();
444 void instanceDetach()
446 m_state->decrementUsed();
452 ASSERT_MESSAGE(m_state == 0, "shader cannot be captured");
453 brush_check_shader(m_shader.c_str());
454 m_state = GlobalShaderCache().capture(m_shader.c_str());
455 m_state->attach(*this);
459 ASSERT_MESSAGE(m_state != 0, "shader cannot be released");
460 m_state->detach(*this);
461 GlobalShaderCache().release(m_shader.c_str());
467 ASSERT_MESSAGE(!m_realised, "FaceTexdef::realise: already realised");
469 m_observers.forEach(FaceShaderObserverRealise());
473 ASSERT_MESSAGE(m_realised, "FaceTexdef::unrealise: already unrealised");
474 m_observers.forEach(FaceShaderObserverUnrealise());
478 void attach(FaceShaderObserver& observer)
480 m_observers.attach(observer);
483 observer.realiseShader();
487 void detach(FaceShaderObserver& observer)
491 observer.unrealiseShader();
493 m_observers.detach(observer);
496 const char* getShader() const
498 return m_shader.c_str();
500 void setShader(const char* name)
504 m_state->decrementUsed();
511 m_state->incrementUsed();
514 ContentsFlagsValue getFlags() const
516 ASSERT_MESSAGE(m_realised, "FaceShader::getFlags: flags not valid when unrealised");
517 if(!m_flags.m_specified)
519 return ContentsFlagsValue(
520 m_state->getTexture().surfaceFlags,
521 m_state->getTexture().contentFlags,
522 m_state->getTexture().value,
528 void setFlags(const ContentsFlagsValue& flags)
530 ASSERT_MESSAGE(m_realised, "FaceShader::setFlags: flags not valid when unrealised");
531 ContentsFlagsValue_assignMasked(m_flags, flags);
534 Shader* state() const
539 std::size_t width() const
543 return m_state->getTexture().width;
547 std::size_t height() const
551 return m_state->getTexture().height;
555 unsigned int shaderFlags() const
559 return m_state->getFlags();
568 class FaceTexdef : public FaceShaderObserver
571 FaceTexdef(const FaceTexdef& other);
573 FaceTexdef& operator=(const FaceTexdef& other);
578 TextureProjection m_projection;
580 SavedState(const FaceTexdef& faceTexdef)
582 m_projection = faceTexdef.m_projection;
585 void exportState(FaceTexdef& faceTexdef) const
587 Texdef_Assign(faceTexdef.m_projection, m_projection);
591 FaceShader& m_shader;
592 TextureProjection m_projection;
593 bool m_projectionInitialised;
598 const TextureProjection& projection,
599 bool projectionInitialised = true
602 m_projection(projection),
603 m_projectionInitialised(projectionInitialised),
604 m_scaleApplied(false)
606 m_shader.attach(*this);
610 m_shader.detach(*this);
615 ASSERT_MESSAGE(!m_scaleApplied, "texture scale aready added");
616 m_scaleApplied = true;
617 m_projection.m_brushprimit_texdef.addScale(m_shader.width(), m_shader.height());
621 ASSERT_MESSAGE(m_scaleApplied, "texture scale aready removed");
622 m_scaleApplied = false;
623 m_projection.m_brushprimit_texdef.removeScale(m_shader.width(), m_shader.height());
628 if(m_projectionInitialised && !m_scaleApplied)
633 void unrealiseShader()
635 if(m_projectionInitialised && m_scaleApplied)
641 void setTexdef(const TextureProjection& projection)
644 Texdef_Assign(m_projection, projection);
648 void shift(float s, float t)
650 ASSERT_MESSAGE(texdef_sane(m_projection.m_texdef), "FaceTexdef::shift: bad texdef");
652 Texdef_Shift(m_projection, s, t);
656 void scale(float s, float t)
659 Texdef_Scale(m_projection, s, t);
663 void rotate(float angle)
666 Texdef_Rotate(m_projection, angle);
670 void fit(const Vector3& normal, const Winding& winding, float s_repeat, float t_repeat)
672 Texdef_FitTexture(m_projection, m_shader.width(), m_shader.height(), normal, winding, s_repeat, t_repeat);
675 void emitTextureCoordinates(Winding& winding, const Vector3& normal, const Matrix4& localToWorld)
677 Texdef_EmitTextureCoordinates(m_projection, m_shader.width(), m_shader.height(), winding, normal, localToWorld);
680 void transform(const Plane3& plane, const Matrix4& matrix)
683 Texdef_transformLocked(m_projection, m_shader.width(), m_shader.height(), plane, matrix);
687 TextureProjection normalised() const
689 brushprimit_texdef_t tmp(m_projection.m_brushprimit_texdef);
690 tmp.removeScale(m_shader.width(), m_shader.height());
691 return TextureProjection(m_projection.m_texdef, tmp, m_projection.m_basis_s, m_projection.m_basis_t);
693 void setBasis(const Vector3& normal)
696 Normal_GetTransform(normal, basis);
697 m_projection.m_basis_s = Vector3(basis.xx(), basis.yx(), basis.zx());
698 m_projection.m_basis_t = Vector3(-basis.xy(), -basis.yy(), -basis.zy());
702 inline void planepts_print(const PlanePoints& planePoints, TextOutputStream& ostream)
704 ostream << "( " << planePoints[0][0] << " " << planePoints[0][1] << " " << planePoints[0][2] << " ) "
705 << "( " << planePoints[1][0] << " " << planePoints[1][1] << " " << planePoints[1][2] << " ) "
706 << "( " << planePoints[2][0] << " " << planePoints[2][1] << " " << planePoints[2][2] << " )";
710 inline Plane3 Plane3_applyTranslation(const Plane3& plane, const Vector3& translation)
712 Plane3 tmp(plane3_translated(Plane3(plane.normal(), -plane.dist()), translation));
713 return Plane3(tmp.normal(), -tmp.dist());
716 inline Plane3 Plane3_applyTransform(const Plane3& plane, const Matrix4& matrix)
718 Plane3 tmp(plane3_transformed(Plane3(plane.normal(), -plane.dist()), matrix));
719 return Plane3(tmp.normal(), -tmp.dist());
724 PlanePoints m_planepts;
725 Plane3 m_planeCached;
728 Vector3 m_funcStaticOrigin;
730 static EBrushType m_type;
732 static bool isDoom3Plane()
734 return FacePlane::m_type == eBrushTypeDoom3 || FacePlane::m_type == eBrushTypeQuake4;
740 PlanePoints m_planepts;
743 SavedState(const FacePlane& facePlane)
745 if(facePlane.isDoom3Plane())
747 m_plane = facePlane.m_plane;
751 planepts_assign(m_planepts, facePlane.planePoints());
755 void exportState(FacePlane& facePlane) const
757 if(facePlane.isDoom3Plane())
759 facePlane.m_plane = m_plane;
760 facePlane.updateTranslated();
764 planepts_assign(facePlane.planePoints(), m_planepts);
765 facePlane.MakePlane();
770 FacePlane() : m_funcStaticOrigin(0, 0, 0)
773 FacePlane(const FacePlane& other) : m_funcStaticOrigin(0, 0, 0)
777 planepts_assign(m_planepts, other.m_planepts);
782 m_plane = other.m_plane;
792 if(check_plane_is_integer(m_planepts))
794 globalErrorStream() << "non-integer planepts: ";
795 planepts_print(m_planepts, globalErrorStream());
796 globalErrorStream() << "\n";
799 m_planeCached = plane3_for_points(m_planepts);
807 vector3_swap(m_planepts[0], m_planepts[2]);
812 m_planeCached = plane3_flipped(m_plane);
816 void transform(const Matrix4& matrix, bool mirror)
822 bool off = check_plane_is_integer(planePoints());
825 matrix4_transform_point(matrix, m_planepts[0]);
826 matrix4_transform_point(matrix, m_planepts[1]);
827 matrix4_transform_point(matrix, m_planepts[2]);
835 if(check_plane_is_integer(planePoints()))
839 globalErrorStream() << "caused by transform\n";
847 m_planeCached = Plane3_applyTransform(m_planeCached, matrix);
851 void offset(float offset)
855 Vector3 move(vector3_scaled(m_planeCached.normal(), -offset));
857 vector3_subtract(m_planepts[0], move);
858 vector3_subtract(m_planepts[1], move);
859 vector3_subtract(m_planepts[2], move);
865 m_planeCached.d += offset;
870 void updateTranslated()
872 m_planeCached = Plane3_applyTranslation(m_plane, m_funcStaticOrigin);
876 m_plane = Plane3_applyTranslation(m_planeCached, vector3_negated(m_funcStaticOrigin));
880 PlanePoints& planePoints()
884 const PlanePoints& planePoints() const
888 const Plane3& plane3() const
890 return m_planeCached;
892 void setDoom3Plane(const Plane3& plane)
897 const Plane3& getDoom3Plane() const
902 void copy(const FacePlane& other)
906 planepts_assign(m_planepts, other.m_planepts);
911 m_planeCached = other.m_plane;
915 void copy(const Vector3& p0, const Vector3& p1, const Vector3& p2)
926 m_planeCached = plane3_for_points(p2, p1, p0);
932 inline void Winding_testSelect(Winding& winding, SelectionTest& test, SelectionIntersection& best)
934 test.TestPolygon(VertexPointer(reinterpret_cast<VertexPointer::pointer>(&winding.points.data()->vertex), sizeof(WindingVertex)), winding.numpoints, best);
937 const double GRID_MIN = 0.125;
939 inline double quantiseInteger(double f)
941 return float_to_integer(f);
944 inline double quantiseFloating(double f)
946 return float_snapped(f, 1.f / (1 << 16));
949 typedef double (*QuantiseFunc)(double f);
956 virtual bool filter(const Face& face) const = 0;
959 bool face_filtered(Face& face);
960 void add_face_filter(FaceFilter& filter, int mask, bool invert = false);
962 void Brush_addTextureChangedCallback(const SignalHandler& callback);
963 void Brush_textureChanged();
966 extern bool g_brush_texturelock_enabled;
971 virtual void planeChanged() = 0;
972 virtual void connectivityChanged() = 0;
973 virtual void shaderChanged() = 0;
974 virtual void evaluateTransform() = 0;
978 public OpenGLRenderable,
981 public FaceShaderObserver
983 std::size_t m_refcount;
985 class SavedState : public UndoMemento
988 FacePlane::SavedState m_planeState;
989 FaceTexdef::SavedState m_texdefState;
990 FaceShader::SavedState m_shaderState;
992 SavedState(const Face& face) : m_planeState(face.getPlane()), m_texdefState(face.getTexdef()), m_shaderState(face.getShader())
996 void exportState(Face& face) const
998 m_planeState.exportState(face.getPlane());
999 m_shaderState.exportState(face.getShader());
1000 m_texdefState.exportState(face.getTexdef());
1010 static QuantiseFunc m_quantise;
1011 static EBrushType m_type;
1013 PlanePoints m_move_planepts;
1014 PlanePoints m_move_planeptsTransformed;
1017 FacePlane m_planeTransformed;
1018 FaceShader m_shader;
1019 FaceTexdef m_texdef;
1020 TextureProjection m_texdefTransformed;
1026 FaceObserver* m_observer;
1027 UndoObserver* m_undoable_observer;
1030 // assignment not supported
1031 Face& operator=(const Face& other);
1032 // copy-construction not supported
1033 Face(const Face& other);
1037 Face(FaceObserver* observer) :
1039 m_shader(texdef_name_default()),
1040 m_texdef(m_shader, TextureProjection(), false),
1042 m_observer(observer),
1043 m_undoable_observer(0),
1046 m_shader.attach(*this);
1047 m_plane.copy(Vector3(0, 0, 0), Vector3(64, 0, 0), Vector3(0, 64, 0));
1048 m_texdef.setBasis(m_plane.plane3().normal());
1056 const TextureProjection& projection,
1057 FaceObserver* observer
1061 m_texdef(m_shader, projection),
1062 m_observer(observer),
1063 m_undoable_observer(0),
1066 m_shader.attach(*this);
1067 m_plane.copy(p0, p1, p2);
1068 m_texdef.setBasis(m_plane.plane3().normal());
1072 Face(const Face& other, FaceObserver* observer) :
1074 m_shader(other.m_shader.getShader(), other.m_shader.m_flags),
1075 m_texdef(m_shader, other.getTexdef().normalised()),
1076 m_observer(observer),
1077 m_undoable_observer(0),
1080 m_shader.attach(*this);
1081 m_plane.copy(other.m_plane);
1082 planepts_assign(m_move_planepts, other.m_move_planepts);
1083 m_texdef.setBasis(m_plane.plane3().normal());
1089 m_shader.detach(*this);
1095 m_observer->planeChanged();
1098 void realiseShader()
1100 m_observer->shaderChanged();
1102 void unrealiseShader()
1106 void instanceAttach(MapFile* map)
1108 m_shader.instanceAttach();
1110 m_undoable_observer = GlobalUndoSystem().observer(this);
1111 GlobalFilterSystem().registerFilterable(*this);
1113 void instanceDetach(MapFile* map)
1115 GlobalFilterSystem().unregisterFilterable(*this);
1116 m_undoable_observer = 0;
1117 GlobalUndoSystem().release(this);
1119 m_shader.instanceDetach();
1122 void render(RenderStateFlags state) const
1124 Winding_Draw(m_winding, m_planeTransformed.plane3().normal(), state);
1127 void updateFiltered()
1129 m_filtered = face_filtered(*this);
1131 bool isFiltered() const
1142 if(m_undoable_observer != 0)
1144 m_undoable_observer->save(this);
1149 UndoMemento* exportState() const
1151 return new SavedState(*this);
1153 void importState(const UndoMemento* data)
1157 static_cast<const SavedState*>(data)->exportState(*this);
1160 m_observer->connectivityChanged();
1162 m_observer->shaderChanged();
1172 if(--m_refcount == 0)
1182 bool intersectVolume(const VolumeTest& volume, const Matrix4& localToWorld) const
1184 return volume.TestPlane(Plane3(plane3().normal(), -plane3().dist()), localToWorld);
1187 void render(Renderer& renderer, const Matrix4& localToWorld) const
1189 renderer.SetState(m_shader.state(), Renderer::eFullMaterials);
1190 renderer.addRenderable(*this, localToWorld);
1193 void transform(const Matrix4& matrix, bool mirror)
1195 if(g_brush_texturelock_enabled)
1196 Texdef_transformLocked(m_texdefTransformed, m_shader.width(), m_shader.height(), m_plane.plane3(), matrix);
1198 m_planeTransformed.transform(matrix, mirror);
1201 ASSERT_MESSAGE(projectionaxis_for_normal(normal) == projectionaxis_for_normal(plane3().normal()), "bleh");
1203 m_observer->planeChanged();
1205 if(g_brush_texturelock_enabled)
1206 Brush_textureChanged();
1209 void assign_planepts(const PlanePoints planepts)
1211 m_planeTransformed.copy(planepts[0], planepts[1], planepts[2]);
1212 m_observer->planeChanged();
1215 /// \brief Reverts the transformable state of the brush to identity.
1216 void revertTransform()
1218 m_planeTransformed = m_plane;
1219 planepts_assign(m_move_planeptsTransformed, m_move_planepts);
1220 m_texdefTransformed = m_texdef.m_projection;
1222 void freezeTransform()
1225 m_plane = m_planeTransformed;
1226 planepts_assign(m_move_planepts, m_move_planeptsTransformed);
1227 m_texdef.m_projection = m_texdefTransformed;
1230 void update_move_planepts_vertex(std::size_t index, PlanePoints planePoints)
1232 std::size_t numpoints = getWinding().numpoints;
1233 ASSERT_MESSAGE(index < numpoints, "update_move_planepts_vertex: invalid index");
1235 std::size_t opposite = Winding_Opposite(getWinding(), index);
1236 std::size_t adjacent = Winding_wrap(getWinding(), opposite+numpoints-1);
1237 planePoints[0] = getWinding()[opposite].vertex;
1238 planePoints[1] = getWinding()[index].vertex;
1239 planePoints[2] = getWinding()[adjacent].vertex;
1240 // winding points are very inaccurate, so they must be quantised before using them to generate the face-plane
1241 planepts_quantise(planePoints, GRID_MIN);
1244 void snapto(float snap)
1249 ASSERT_MESSAGE(plane3_valid(m_plane.plane3()), "invalid plane before snap to grid");
1250 planepts_snap(m_plane.planePoints(), snap);
1251 ASSERT_MESSAGE(plane3_valid(m_plane.plane3()), "invalid plane after snap to grid");
1253 PlanePoints planePoints;
1254 update_move_planepts_vertex(0, planePoints);
1255 vector3_snap(planePoints[0], snap);
1256 vector3_snap(planePoints[1], snap);
1257 vector3_snap(planePoints[2], snap);
1258 assign_planepts(planePoints);
1261 SceneChangeNotify();
1262 if(!plane3_valid(m_plane.plane3()))
1264 globalErrorStream() << "WARNING: invalid plane after snap to grid\n";
1269 void testSelect(SelectionTest& test, SelectionIntersection& best)
1271 Winding_testSelect(m_winding, test, best);
1274 void testSelect_centroid(SelectionTest& test, SelectionIntersection& best)
1276 test.TestPoint(m_centroid, best);
1279 void shaderChanged()
1281 EmitTextureCoordinates();
1282 Brush_textureChanged();
1283 m_observer->shaderChanged();
1286 SceneChangeNotify();
1289 const char* GetShader() const
1291 return m_shader.getShader();
1293 void SetShader(const char* name)
1296 m_shader.setShader(name);
1302 m_texdefTransformed = m_texdef.m_projection;
1304 void texdefChanged()
1307 EmitTextureCoordinates();
1308 Brush_textureChanged();
1311 void GetTexdef(TextureProjection& projection) const
1313 projection = m_texdef.normalised();
1315 void SetTexdef(const TextureProjection& projection)
1318 m_texdef.setTexdef(projection);
1322 void GetFlags(ContentsFlagsValue& flags) const
1324 flags = m_shader.getFlags();
1326 void SetFlags(const ContentsFlagsValue& flags)
1329 m_shader.setFlags(flags);
1330 m_observer->shaderChanged();
1334 void ShiftTexdef(float s, float t)
1337 m_texdef.shift(s, t);
1341 void ScaleTexdef(float s, float t)
1344 m_texdef.scale(s, t);
1348 void RotateTexdef(float angle)
1351 m_texdef.rotate(angle);
1355 void FitTexture(float s_repeat, float t_repeat)
1358 m_texdef.fit(m_plane.plane3().normal(), m_winding, s_repeat, t_repeat);
1362 void EmitTextureCoordinates()
1364 Texdef_EmitTextureCoordinates(m_texdefTransformed, m_shader.width(), m_shader.height(), m_winding, plane3().normal(), g_matrix4_identity);
1368 const Vector3& centroid() const
1373 void construct_centroid()
1375 Winding_Centroid(m_winding, plane3(), m_centroid);
1378 const Winding& getWinding() const
1382 Winding& getWinding()
1387 const Plane3& plane3() const
1389 m_observer->evaluateTransform();
1390 return m_planeTransformed.plane3();
1392 FacePlane& getPlane()
1396 const FacePlane& getPlane() const
1400 FaceTexdef& getTexdef()
1404 const FaceTexdef& getTexdef() const
1408 FaceShader& getShader()
1412 const FaceShader& getShader() const
1417 bool isDetail() const
1419 return (m_shader.m_flags.m_contentFlags & BRUSH_DETAIL_MASK) != 0;
1421 void setDetail(bool detail)
1424 if(detail && !isDetail())
1426 m_shader.m_flags.m_contentFlags |= BRUSH_DETAIL_MASK;
1428 else if(!detail && isDetail())
1430 m_shader.m_flags.m_contentFlags &= ~BRUSH_DETAIL_MASK;
1432 m_observer->shaderChanged();
1435 bool contributes() const
1437 return m_winding.numpoints > 2;
1439 bool is_bounded() const
1441 for(Winding::const_iterator i = m_winding.begin(); i != m_winding.end(); ++i)
1443 if((*i).adjacent == c_brush_maxFaces)
1456 std::size_t m_vertex;
1459 FaceVertexId(std::size_t face, std::size_t vertex)
1460 : m_face(face), m_vertex(vertex)
1464 std::size_t getFace() const
1468 std::size_t getVertex() const
1474 typedef std::size_t faceIndex_t;
1476 struct EdgeRenderIndices
1482 : first(0), second(0)
1485 EdgeRenderIndices(const RenderIndex _first, const RenderIndex _second)
1486 : first(_first), second(_second)
1497 : first(c_brush_maxFaces), second(c_brush_maxFaces)
1500 EdgeFaces(const faceIndex_t _first, const faceIndex_t _second)
1501 : first(_first), second(_second)
1506 class RenderableWireframe : public OpenGLRenderable
1509 void render(RenderStateFlags state) const
1512 glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_vertices->colour);
1513 glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_vertices->vertex);
1514 glDrawElements(GL_LINES, GLsizei(m_size<<1), RenderIndexTypeID, m_faceVertex.data());
1517 for(std::size_t i = 0; i < m_size; ++i)
1519 glVertex3fv(&m_vertices[m_faceVertex[i].first].vertex.x);
1520 glVertex3fv(&m_vertices[m_faceVertex[i].second].vertex.x);
1526 Array<EdgeRenderIndices> m_faceVertex;
1528 const PointVertex* m_vertices;
1532 typedef std::vector<Brush*> brush_vector_t;
1537 virtual bool filter(const Brush& brush) const = 0;
1540 bool brush_filtered(Brush& brush);
1541 void add_brush_filter(BrushFilter& filter, int mask, bool invert = false);
1544 /// \brief Returns true if 'self' takes priority when building brush b-rep.
1545 inline bool plane3_inside(const Plane3& self, const Plane3& other, bool selfIsLater)
1547 if(vector3_equal_epsilon(self.normal(), other.normal(), 0.001))
1549 // same plane? prefer the one with smaller index
1550 if(self.dist() == other.dist())
1552 return self.dist() < other.dist();
1557 typedef SmartPointer<Face> FaceSmartPointer;
1558 typedef std::vector<FaceSmartPointer> Faces;
1560 /// \brief Returns the unique-id of the edge adjacent to \p faceVertex in the edge-pair for the set of \p faces.
1561 inline FaceVertexId next_edge(const Faces& faces, FaceVertexId faceVertex)
1563 std::size_t adjacent_face = faces[faceVertex.getFace()]->getWinding()[faceVertex.getVertex()].adjacent;
1564 std::size_t adjacent_vertex = Winding_FindAdjacent(faces[adjacent_face]->getWinding(), faceVertex.getFace());
1566 ASSERT_MESSAGE(adjacent_vertex != c_brush_maxFaces, "connectivity data invalid");
1567 if(adjacent_vertex == c_brush_maxFaces)
1572 return FaceVertexId(adjacent_face, adjacent_vertex);
1575 /// \brief Returns the unique-id of the vertex adjacent to \p faceVertex in the vertex-ring for the set of \p faces.
1576 inline FaceVertexId next_vertex(const Faces& faces, FaceVertexId faceVertex)
1578 FaceVertexId nextEdge = next_edge(faces, faceVertex);
1579 return FaceVertexId(nextEdge.getFace(), Winding_next(faces[nextEdge.getFace()]->getWinding(), nextEdge.getVertex()));
1582 class SelectableEdge
1584 Vector3 getEdge() const
1586 const Winding& winding = getFace().getWinding();
1587 return vector3_mid(winding[m_faceVertex.getVertex()].vertex, winding[Winding_next(winding, m_faceVertex.getVertex())].vertex);
1592 FaceVertexId m_faceVertex;
1594 SelectableEdge(Faces& faces, FaceVertexId faceVertex)
1595 : m_faces(faces), m_faceVertex(faceVertex)
1598 SelectableEdge& operator=(const SelectableEdge& other)
1600 m_faceVertex = other.m_faceVertex;
1604 Face& getFace() const
1606 return *m_faces[m_faceVertex.getFace()];
1609 void testSelect(SelectionTest& test, SelectionIntersection& best)
1611 test.TestPoint(getEdge(), best);
1615 class SelectableVertex
1617 Vector3 getVertex() const
1619 return getFace().getWinding()[m_faceVertex.getVertex()].vertex;
1624 FaceVertexId m_faceVertex;
1626 SelectableVertex(Faces& faces, FaceVertexId faceVertex)
1627 : m_faces(faces), m_faceVertex(faceVertex)
1630 SelectableVertex& operator=(const SelectableVertex& other)
1632 m_faceVertex = other.m_faceVertex;
1636 Face& getFace() const
1638 return *m_faces[m_faceVertex.getFace()];
1641 void testSelect(SelectionTest& test, SelectionIntersection& best)
1643 test.TestPoint(getVertex(), best);
1650 virtual void reserve(std::size_t size) = 0;
1651 virtual void clear() = 0;
1652 virtual void push_back(Face& face) = 0;
1653 virtual void pop_back() = 0;
1654 virtual void erase(std::size_t index) = 0;
1655 virtual void connectivityChanged() = 0;
1657 virtual void edge_clear() = 0;
1658 virtual void edge_push_back(SelectableEdge& edge) = 0;
1660 virtual void vertex_clear() = 0;
1661 virtual void vertex_push_back(SelectableVertex& vertex) = 0;
1663 virtual void DEBUG_verify() const = 0;
1669 virtual void visit(Face& face) const = 0;
1673 public TransformNode,
1678 public FaceObserver,
1684 scene::Node* m_node;
1685 typedef UniqueSet<BrushObserver*> Observers;
1686 Observers m_observers;
1687 UndoObserver* m_undoable_observer;
1694 // cached data compiled from state
1695 Array<PointVertex> m_faceCentroidPoints;
1696 RenderablePointArray m_render_faces;
1698 Array<PointVertex> m_uniqueVertexPoints;
1699 typedef std::vector<SelectableVertex> SelectableVertices;
1700 SelectableVertices m_select_vertices;
1701 RenderablePointArray m_render_vertices;
1703 Array<PointVertex> m_uniqueEdgePoints;
1704 typedef std::vector<SelectableEdge> SelectableEdges;
1705 SelectableEdges m_select_edges;
1706 RenderablePointArray m_render_edges;
1708 Array<EdgeRenderIndices> m_edge_indices;
1709 Array<EdgeFaces> m_edge_faces;
1714 Callback m_evaluateTransform;
1715 Callback m_boundsChanged;
1717 mutable bool m_planeChanged; // b-rep evaluation required
1718 mutable bool m_transformChanged; // transform evaluation required
1722 STRING_CONSTANT(Name, "Brush");
1724 Callback m_lightsChanged;
1727 static Shader* m_state_point;
1730 static EBrushType m_type;
1731 static double m_maxWorldCoord;
1733 Brush(scene::Node& node, const Callback& evaluateTransform, const Callback& boundsChanged) :
1735 m_undoable_observer(0),
1737 m_render_faces(m_faceCentroidPoints, GL_POINTS),
1738 m_render_vertices(m_uniqueVertexPoints, GL_POINTS),
1739 m_render_edges(m_uniqueEdgePoints, GL_POINTS),
1740 m_evaluateTransform(evaluateTransform),
1741 m_boundsChanged(boundsChanged),
1742 m_planeChanged(false),
1743 m_transformChanged(false)
1747 Brush(const Brush& other, scene::Node& node, const Callback& evaluateTransform, const Callback& boundsChanged) :
1749 m_undoable_observer(0),
1751 m_render_faces(m_faceCentroidPoints, GL_POINTS),
1752 m_render_vertices(m_uniqueVertexPoints, GL_POINTS),
1753 m_render_edges(m_uniqueEdgePoints, GL_POINTS),
1754 m_evaluateTransform(evaluateTransform),
1755 m_boundsChanged(boundsChanged),
1756 m_planeChanged(false),
1757 m_transformChanged(false)
1761 Brush(const Brush& other) :
1762 TransformNode(other),
1767 FaceObserver(other),
1772 m_undoable_observer(0),
1774 m_render_faces(m_faceCentroidPoints, GL_POINTS),
1775 m_render_vertices(m_uniqueVertexPoints, GL_POINTS),
1776 m_render_edges(m_uniqueEdgePoints, GL_POINTS),
1777 m_planeChanged(false),
1778 m_transformChanged(false)
1784 ASSERT_MESSAGE(m_observers.empty(), "Brush::~Brush: observers still attached");
1787 // assignment not supported
1788 Brush& operator=(const Brush& other);
1790 void setDoom3GroupOrigin(const Vector3& origin)
1792 //globalOutputStream() << "func_static origin before: " << m_funcStaticOrigin << " after: " << origin << "\n";
1793 for(Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1795 (*i)->getPlane().m_funcStaticOrigin = origin;
1796 (*i)->getPlane().updateTranslated();
1797 (*i)->planeChanged();
1802 void attach(BrushObserver& observer)
1804 for(Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1806 observer.push_back(*(*i));
1809 for(SelectableEdges::iterator i = m_select_edges.begin(); i !=m_select_edges.end(); ++i)
1811 observer.edge_push_back(*i);
1814 for(SelectableVertices::iterator i = m_select_vertices.begin(); i != m_select_vertices.end(); ++i)
1816 observer.vertex_push_back(*i);
1819 m_observers.insert(&observer);
1821 void detach(BrushObserver& observer)
1823 m_observers.erase(&observer);
1826 void forEachFace(const BrushVisitor& visitor) const
1828 for(Faces::const_iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1830 visitor.visit(*(*i));
1834 void forEachFace_instanceAttach(MapFile* map) const
1836 for(Faces::const_iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1838 (*i)->instanceAttach(map);
1841 void forEachFace_instanceDetach(MapFile* map) const
1843 for(Faces::const_iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1845 (*i)->instanceDetach(map);
1849 InstanceCounter m_instanceCounter;
1850 void instanceAttach(const scene::Path& path)
1852 if(++m_instanceCounter.m_count == 1)
1854 m_map = path_find_mapfile(path.begin(), path.end());
1855 m_undoable_observer = GlobalUndoSystem().observer(this);
1856 GlobalFilterSystem().registerFilterable(*this);
1857 forEachFace_instanceAttach(m_map);
1861 ASSERT_MESSAGE(path_find_mapfile(path.begin(), path.end()) == m_map, "node is instanced across more than one file");
1864 void instanceDetach(const scene::Path& path)
1866 if(--m_instanceCounter.m_count == 0)
1868 forEachFace_instanceDetach(m_map);
1869 GlobalFilterSystem().unregisterFilterable(*this);
1871 m_undoable_observer = 0;
1872 GlobalUndoSystem().release(this);
1877 const char* name() const
1881 void attach(const NameCallback& callback)
1884 void detach(const NameCallback& callback)
1889 void updateFiltered()
1893 if(brush_filtered(*this))
1895 m_node->enable(scene::Node::eFiltered);
1899 m_node->disable(scene::Node::eFiltered);
1907 m_planeChanged = true;
1911 void shaderChanged()
1917 void evaluateBRep() const
1921 m_planeChanged = false;
1922 const_cast<Brush*>(this)->buildBRep();
1926 void transformChanged()
1928 m_transformChanged = true;
1931 typedef MemberCaller<Brush, &Brush::transformChanged> TransformChangedCaller;
1933 void evaluateTransform()
1935 if(m_transformChanged)
1937 m_transformChanged = false;
1939 m_evaluateTransform();
1942 const Matrix4& localToParent() const
1944 return g_matrix4_identity;
1950 const AABB& localAABB() const
1953 return m_aabb_local;
1956 VolumeIntersectionValue intersectVolume(const VolumeTest& test, const Matrix4& localToWorld) const
1958 return test.TestAABB(m_aabb_local, localToWorld);
1961 void renderComponents(SelectionSystem::EComponentMode mode, Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
1965 case SelectionSystem::eVertex:
1966 renderer.addRenderable(m_render_vertices, localToWorld);
1968 case SelectionSystem::eEdge:
1969 renderer.addRenderable(m_render_edges, localToWorld);
1971 case SelectionSystem::eFace:
1972 renderer.addRenderable(m_render_faces, localToWorld);
1979 void transform(const Matrix4& matrix)
1981 bool mirror = matrix4_handedness(matrix) == MATRIX4_LEFTHANDED;
1983 for(Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1985 (*i)->transform(matrix, mirror);
1988 void snapto(float snap)
1990 for(Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1995 void revertTransform()
1997 for(Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i)
1999 (*i)->revertTransform();
2002 void freezeTransform()
2004 for(Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i)
2006 (*i)->freezeTransform();
2010 /// \brief Returns the absolute index of the \p faceVertex.
2011 std::size_t absoluteIndex(FaceVertexId faceVertex)
2013 std::size_t index = 0;
2014 for(std::size_t i = 0; i < faceVertex.getFace(); ++i)
2016 index += m_faces[i]->getWinding().numpoints;
2018 return index + faceVertex.getVertex();
2021 void appendFaces(const Faces& other)
2024 for(Faces::const_iterator i = other.begin(); i != other.end(); ++i)
2030 /// \brief The undo memento for a brush stores only the list of face references - the faces are not copied.
2031 class BrushUndoMemento : public UndoMemento
2034 BrushUndoMemento(const Faces& faces) : m_faces(faces)
2051 if(m_undoable_observer != 0)
2053 m_undoable_observer->save(this);
2057 UndoMemento* exportState() const
2059 return new BrushUndoMemento(m_faces);
2062 void importState(const UndoMemento* state)
2065 appendFaces(static_cast<const BrushUndoMemento*>(state)->m_faces);
2068 for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2070 (*i)->DEBUG_verify();
2076 return !m_faces.empty() && m_faces.front()->isDetail();
2079 /// \brief Appends a copy of \p face to the end of the face list.
2080 Face* addFace(const Face& face)
2082 if(m_faces.size() == c_brush_maxFaces)
2087 push_back(FaceSmartPointer(new Face(face, this)));
2088 m_faces.back()->setDetail(isDetail());
2090 return m_faces.back();
2093 /// \brief Appends a new face constructed from the parameters to the end of the face list.
2094 Face* addPlane(const Vector3& p0, const Vector3& p1, const Vector3& p2, const char* shader, const TextureProjection& projection)
2096 if(m_faces.size() == c_brush_maxFaces)
2101 push_back(FaceSmartPointer(new Face(p0, p1, p2, shader, projection, this)));
2102 m_faces.back()->setDetail(isDetail());
2104 return m_faces.back();
2107 static void constructStatic(EBrushType type)
2110 Face::m_type = type;
2111 FacePlane::m_type = type;
2113 g_bp_globals.m_texdefTypeId = TEXDEFTYPEID_QUAKE;
2114 if(m_type == eBrushTypeQuake3BP || m_type == eBrushTypeDoom3 || m_type == eBrushTypeQuake4)
2116 g_bp_globals.m_texdefTypeId = TEXDEFTYPEID_BRUSHPRIMITIVES;
2117 // g_brush_texturelock_enabled = true; // bad idea, this overrides user setting
2119 else if(m_type == eBrushTypeHalfLife)
2121 g_bp_globals.m_texdefTypeId = TEXDEFTYPEID_HALFLIFE;
2122 // g_brush_texturelock_enabled = true; // bad idea, this overrides user setting
2125 Face::m_quantise = (m_type == eBrushTypeQuake) ? quantiseInteger : quantiseFloating;
2127 m_state_point = GlobalShaderCache().capture("$POINT");
2129 static void destroyStatic()
2131 GlobalShaderCache().release("$POINT");
2134 std::size_t DEBUG_size()
2136 return m_faces.size();
2139 typedef Faces::const_iterator const_iterator;
2141 const_iterator begin() const
2143 return m_faces.begin();
2145 const_iterator end() const
2147 return m_faces.end();
2152 return m_faces.back();
2154 const Face* back() const
2156 return m_faces.back();
2158 void reserve(std::size_t count)
2160 m_faces.reserve(count);
2161 for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2163 (*i)->reserve(count);
2166 void push_back(Faces::value_type face)
2168 m_faces.push_back(face);
2169 if(m_instanceCounter.m_count != 0)
2171 m_faces.back()->instanceAttach(m_map);
2173 for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2175 (*i)->push_back(*face);
2176 (*i)->DEBUG_verify();
2181 if(m_instanceCounter.m_count != 0)
2183 m_faces.back()->instanceDetach(m_map);
2186 for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2189 (*i)->DEBUG_verify();
2192 void erase(std::size_t index)
2194 if(m_instanceCounter.m_count != 0)
2196 m_faces[index]->instanceDetach(m_map);
2198 m_faces.erase(m_faces.begin() + index);
2199 for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2202 (*i)->DEBUG_verify();
2205 void connectivityChanged()
2207 for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2209 (*i)->connectivityChanged();
2217 if(m_instanceCounter.m_count != 0)
2219 forEachFace_instanceDetach(m_map);
2222 for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2225 (*i)->DEBUG_verify();
2228 std::size_t size() const
2230 return m_faces.size();
2234 return m_faces.empty();
2237 /// \brief Returns true if any face of the brush contributes to the final B-Rep.
2238 bool hasContributingFaces() const
2240 for(const_iterator i = begin(); i != end(); ++i)
2242 if((*i)->contributes())
2250 /// \brief Removes faces that do not contribute to the brush. This is useful for cleaning up after CSG operations on the brush.
2251 /// 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.
2252 void removeEmptyFaces()
2258 while(i < m_faces.size())
2260 if(!m_faces[i]->contributes())
2273 /// \brief Constructs \p winding from the intersection of \p plane with the other planes of the brush.
2274 void windingForClipPlane(Winding& winding, const Plane3& plane) const
2276 FixedWinding buffer[2];
2279 // get a poly that covers an effectively infinite area
2280 Winding_createInfinite(buffer[swap], plane, m_maxWorldCoord + 1);
2282 // chop the poly by all of the other faces
2284 for (std::size_t i = 0; i < m_faces.size(); ++i)
2286 const Face& clip = *m_faces[i];
2288 if(plane3_equal(clip.plane3(), plane)
2289 || !plane3_valid(clip.plane3()) || !plane_unique(i)
2290 || plane3_opposing(plane, clip.plane3()))
2295 buffer[!swap].clear();
2297 #if BRUSH_CONNECTIVITY_DEBUG
2298 globalOutputStream() << "clip vs face: " << i << "\n";
2302 // flip the plane, because we want to keep the back side
2303 Plane3 clipPlane(vector3_negated(clip.plane3().normal()), -clip.plane3().dist());
2304 Winding_Clip(buffer[swap], plane, clipPlane, i, buffer[!swap]);
2307 #if BRUSH_CONNECTIVITY_DEBUG
2308 for(FixedWinding::Points::iterator k = buffer[!swap].points.begin(), j = buffer[!swap].points.end() - 1; k != buffer[!swap].points.end(); j = k, ++k)
2310 if(vector3_length_squared(vector3_subtracted((*k).vertex, (*j).vertex)) < 1)
2312 globalOutputStream() << "v: " << std::distance(buffer[!swap].points.begin(), j) << " tiny edge adjacent to face " << (*j).adjacent << "\n";
2317 //ASSERT_MESSAGE(buffer[!swap].numpoints != 1, "created single-point winding");
2323 Winding_forFixedWinding(winding, buffer[swap]);
2325 #if BRUSH_CONNECTIVITY_DEBUG
2326 Winding_printConnectivity(winding);
2328 for(Winding::iterator i = winding.begin(), j = winding.end() - 1; i != winding.end(); j = i, ++i)
2330 if(vector3_length_squared(vector3_subtracted((*i).vertex, (*j).vertex)) < 1)
2332 globalOutputStream() << "v: " << std::distance(winding.begin(), j) << " tiny edge adjacent to face " << (*j).adjacent << "\n";
2338 void update_wireframe(RenderableWireframe& wire, const bool* faces_visible) const
2340 wire.m_faceVertex.resize(m_edge_indices.size());
2341 wire.m_vertices = m_uniqueVertexPoints.data();
2343 for(std::size_t i = 0; i < m_edge_faces.size(); ++i)
2345 if(faces_visible[m_edge_faces[i].first]
2346 || faces_visible[m_edge_faces[i].second])
2348 wire.m_faceVertex[wire.m_size++] = m_edge_indices[i];
2354 void update_faces_wireframe(Array<PointVertex>& wire, const bool* faces_visible) const
2356 std::size_t count = 0;
2357 for(std::size_t i = 0; i < m_faceCentroidPoints.size(); ++i)
2359 if(faces_visible[i])
2366 Array<PointVertex>::iterator p = wire.begin();
2367 for(std::size_t i = 0; i < m_faceCentroidPoints.size(); ++i)
2369 if(faces_visible[i])
2371 *p++ = m_faceCentroidPoints[i];
2376 /// \brief Makes this brush a deep-copy of the \p other.
2377 void copy(const Brush& other)
2379 for(Faces::const_iterator i = other.m_faces.begin(); i != other.m_faces.end(); ++i)
2387 void edge_push_back(FaceVertexId faceVertex)
2389 m_select_edges.push_back(SelectableEdge(m_faces, faceVertex));
2390 for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2392 (*i)->edge_push_back(m_select_edges.back());
2397 m_select_edges.clear();
2398 for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2403 void vertex_push_back(FaceVertexId faceVertex)
2405 m_select_vertices.push_back(SelectableVertex(m_faces, faceVertex));
2406 for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2408 (*i)->vertex_push_back(m_select_vertices.back());
2413 m_select_vertices.clear();
2414 for(Observers::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
2416 (*i)->vertex_clear();
2420 /// \brief Returns true if the face identified by \p index is preceded by another plane that takes priority over it.
2421 bool plane_unique(std::size_t index) const
2424 for(std::size_t i = 0; i < m_faces.size(); ++i)
2426 if(index != i && !plane3_inside(m_faces[index]->plane3(), m_faces[i]->plane3(), index < i))
2434 /// \brief Removes edges that are smaller than the tolerance used when generating brush windings.
2435 void removeDegenerateEdges()
2437 for (std::size_t i = 0; i < m_faces.size(); ++i)
2439 Winding& winding = m_faces[i]->getWinding();
2440 for(Winding::iterator j = winding.begin(); j != winding.end();)
2442 std::size_t index = std::distance(winding.begin(), j);
2443 std::size_t next = Winding_next(winding, index);
2444 if(Edge_isDegenerate(winding[index].vertex, winding[next].vertex))
2446 #if BRUSH_DEGENERATE_DEBUG
2447 globalOutputStream() << "Brush::buildWindings: face " << i << ": degenerate edge adjacent to " << winding[index].adjacent << "\n";
2449 Winding& other = m_faces[winding[index].adjacent]->getWinding();
2450 std::size_t adjacent = Winding_FindAdjacent(other, i);
2451 if(adjacent != c_brush_maxFaces)
2453 other.erase(other.begin() + adjacent);
2465 /// \brief Invalidates faces that have only two vertices in their winding, while preserving edge-connectivity information.
2466 void removeDegenerateFaces()
2468 // save adjacency info for degenerate faces
2469 for (std::size_t i = 0; i < m_faces.size(); ++i)
2471 Winding& degen = m_faces[i]->getWinding();
2473 if(degen.numpoints == 2)
2475 #if BRUSH_DEGENERATE_DEBUG
2476 globalOutputStream() << "Brush::buildWindings: face " << i << ": degenerate winding adjacent to " << degen[0].adjacent << ", " << degen[1].adjacent << "\n";
2478 // this is an "edge" face, where the plane touches the edge of the brush
2480 Winding& winding = m_faces[degen[0].adjacent]->getWinding();
2481 std::size_t index = Winding_FindAdjacent(winding, i);
2482 if(index != c_brush_maxFaces)
2484 #if BRUSH_DEGENERATE_DEBUG
2485 globalOutputStream() << "Brush::buildWindings: face " << degen[0].adjacent << ": remapping adjacent " << winding[index].adjacent << " to " << degen[1].adjacent << "\n";
2487 winding[index].adjacent = degen[1].adjacent;
2492 Winding& winding = m_faces[degen[1].adjacent]->getWinding();
2493 std::size_t index = Winding_FindAdjacent(winding, i);
2494 if(index != c_brush_maxFaces)
2496 #if BRUSH_DEGENERATE_DEBUG
2497 globalOutputStream() << "Brush::buildWindings: face " << degen[1].adjacent << ": remapping adjacent " << winding[index].adjacent << " to " << degen[0].adjacent << "\n";
2499 winding[index].adjacent = degen[0].adjacent;
2508 /// \brief Removes edges that have the same adjacent-face as their immediate neighbour.
2509 void removeDuplicateEdges()
2511 // verify face connectivity graph
2512 for(std::size_t i = 0; i < m_faces.size(); ++i)
2514 //if(m_faces[i]->contributes())
2516 Winding& winding = m_faces[i]->getWinding();
2517 for(std::size_t j = 0; j != winding.numpoints;)
2519 std::size_t next = Winding_next(winding, j);
2520 if(winding[j].adjacent == winding[next].adjacent)
2522 #if BRUSH_DEGENERATE_DEBUG
2523 globalOutputStream() << "Brush::buildWindings: face " << i << ": removed duplicate edge adjacent to face " << winding[j].adjacent << "\n";
2525 winding.erase(winding.begin() + next);
2536 /// \brief Removes edges that do not have a matching pair in their adjacent-face.
2537 void verifyConnectivityGraph()
2539 // verify face connectivity graph
2540 for(std::size_t i = 0; i < m_faces.size(); ++i)
2542 //if(m_faces[i]->contributes())
2544 Winding& winding = m_faces[i]->getWinding();
2545 for(Winding::iterator j = winding.begin(); j != winding.end();)
2547 #if BRUSH_CONNECTIVITY_DEBUG
2548 globalOutputStream() << "Brush::buildWindings: face " << i << ": adjacent to face " << (*j).adjacent << "\n";
2550 // remove unidirectional graph edges
2551 if((*j).adjacent == c_brush_maxFaces
2552 || Winding_FindAdjacent(m_faces[(*j).adjacent]->getWinding(), i) == c_brush_maxFaces)
2554 #if BRUSH_CONNECTIVITY_DEBUG
2555 globalOutputStream() << "Brush::buildWindings: face " << i << ": removing unidirectional connectivity graph edge adjacent to face " << (*j).adjacent << "\n";
2568 /// \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.
2571 for(const_iterator i = begin(); i != end(); ++i)
2573 if(!(*i)->is_bounded())
2581 /// \brief Constructs the polygon windings for each face of the brush. Also updates the brush bounding-box and face texture-coordinates.
2582 bool buildWindings()
2586 m_aabb_local = AABB();
2588 for (std::size_t i = 0; i < m_faces.size(); ++i)
2590 Face& f = *m_faces[i];
2592 if(!plane3_valid(f.plane3()) || !plane_unique(i))
2594 f.getWinding().resize(0);
2598 #if BRUSH_CONNECTIVITY_DEBUG
2599 globalOutputStream() << "face: " << i << "\n";
2601 windingForClipPlane(f.getWinding(), f.plane3());
2603 // update brush bounds
2604 const Winding& winding = f.getWinding();
2605 for(Winding::const_iterator i = winding.begin(); i != winding.end(); ++i)
2607 aabb_extend_by_point_safe(m_aabb_local, (*i).vertex);
2610 // update texture coordinates
2611 f.EmitTextureCoordinates();
2616 bool degenerate = !isBounded();
2620 // clean up connectivity information.
2621 // these cleanups must be applied in a specific order.
2622 removeDegenerateEdges();
2623 removeDegenerateFaces();
2624 removeDuplicateEdges();
2625 verifyConnectivityGraph();
2631 /// \brief Constructs the face windings and updates anything that depends on them.
2639 class FaceInstanceSet
2641 typedef SelectionList<FaceInstance> FaceInstances;
2642 FaceInstances m_faceInstances;
2644 void insert(FaceInstance& faceInstance)
2646 m_faceInstances.append(faceInstance);
2648 void erase(FaceInstance& faceInstance)
2650 m_faceInstances.erase(faceInstance);
2653 template<typename Functor>
2654 void foreach(Functor functor)
2656 for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
2664 return m_faceInstances.empty();
2666 FaceInstance& last() const
2668 return m_faceInstances.back();
2672 extern FaceInstanceSet g_SelectedFaceInstances;
2674 typedef std::list<std::size_t> VertexSelection;
2676 inline VertexSelection::iterator VertexSelection_find(VertexSelection& self, std::size_t value)
2678 return std::find(self.begin(), self.end(), value);
2681 inline VertexSelection::const_iterator VertexSelection_find(const VertexSelection& self, std::size_t value)
2683 return std::find(self.begin(), self.end(), value);
2686 inline VertexSelection::iterator VertexSelection_insert(VertexSelection& self, std::size_t value)
2688 VertexSelection::iterator i = VertexSelection_find(self, value);
2691 self.push_back(value);
2692 return --self.end();
2696 inline void VertexSelection_erase(VertexSelection& self, std::size_t value)
2698 VertexSelection::iterator i = VertexSelection_find(self, value);
2705 inline bool triangle_reversed(std::size_t x, std::size_t y, std::size_t z)
2707 return !((x < y && y < z) || (z < x && x < y) || (y < z && z < x));
2709 template<typename Element>
2710 inline Vector3 triangle_cross(const BasicVector3<Element>& x, const BasicVector3<Element> y, const BasicVector3<Element>& z)
2712 return vector3_cross(y - x, z - x);
2714 template<typename Element>
2715 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)
2717 return vector3_dot(triangle_cross(x1, y1, z1), triangle_cross(x2, y2, z2)) > 0;
2721 typedef const Plane3* PlanePointer;
2722 typedef PlanePointer* PlanesIterator;
2724 class VectorLightList : public LightList
2726 typedef std::vector<const RendererLight*> Lights;
2729 void addLight(const RendererLight& light)
2731 m_lights.push_back(&light);
2737 void evaluateLights() const
2740 void lightsChanged() const
2743 void forEachLight(const RendererLightCallback& callback) const
2745 for(Lights::const_iterator i = m_lights.begin(); i != m_lights.end(); ++i)
2755 ObservedSelectable m_selectable;
2756 ObservedSelectable m_selectableVertices;
2757 ObservedSelectable m_selectableEdges;
2758 SelectionChangeCallback m_selectionChanged;
2760 VertexSelection m_vertexSelection;
2761 VertexSelection m_edgeSelection;
2764 mutable VectorLightList m_lights;
2766 FaceInstance(Face& face, const SelectionChangeCallback& observer) :
2768 m_selectable(SelectedChangedCaller(*this)),
2769 m_selectableVertices(observer),
2770 m_selectableEdges(observer),
2771 m_selectionChanged(observer)
2774 FaceInstance(const FaceInstance& other) :
2775 m_face(other.m_face),
2776 m_selectable(SelectedChangedCaller(*this)),
2777 m_selectableVertices(other.m_selectableVertices),
2778 m_selectableEdges(other.m_selectableEdges),
2779 m_selectionChanged(other.m_selectionChanged)
2782 FaceInstance& operator=(const FaceInstance& other)
2784 m_face = other.m_face;
2792 const Face& getFace() const
2797 void selectedChanged(const Selectable& selectable)
2799 if(selectable.isSelected())
2801 g_SelectedFaceInstances.insert(*this);
2805 g_SelectedFaceInstances.erase(*this);
2807 m_selectionChanged(selectable);
2809 typedef MemberCaller1<FaceInstance, const Selectable&, &FaceInstance::selectedChanged> SelectedChangedCaller;
2811 bool selectedVertices() const
2813 return !m_vertexSelection.empty();
2815 bool selectedEdges() const
2817 return !m_edgeSelection.empty();
2819 bool isSelected() const
2821 return m_selectable.isSelected();
2824 bool selectedComponents() const
2826 return selectedVertices() || selectedEdges() || isSelected();
2828 bool selectedComponents(SelectionSystem::EComponentMode mode) const
2832 case SelectionSystem::eVertex:
2833 return selectedVertices();
2834 case SelectionSystem::eEdge:
2835 return selectedEdges();
2836 case SelectionSystem::eFace:
2837 return isSelected();
2842 void setSelected(SelectionSystem::EComponentMode mode, bool select)
2846 case SelectionSystem::eFace:
2847 m_selectable.setSelected(select);
2849 case SelectionSystem::eVertex:
2850 ASSERT_MESSAGE(!select, "select-all not supported");
2852 m_vertexSelection.clear();
2853 m_selectableVertices.setSelected(false);
2855 case SelectionSystem::eEdge:
2856 ASSERT_MESSAGE(!select, "select-all not supported");
2858 m_edgeSelection.clear();
2859 m_selectableEdges.setSelected(false);
2866 template<typename Functor>
2867 void SelectedVertices_foreach(Functor functor) const
2869 for(VertexSelection::const_iterator i = m_vertexSelection.begin(); i != m_vertexSelection.end(); ++i)
2871 std::size_t index = Winding_FindAdjacent(getFace().getWinding(), *i);
2872 if(index != c_brush_maxFaces)
2874 functor(getFace().getWinding()[index].vertex);
2878 template<typename Functor>
2879 void SelectedEdges_foreach(Functor functor) const
2881 for(VertexSelection::const_iterator i = m_edgeSelection.begin(); i != m_edgeSelection.end(); ++i)
2883 std::size_t index = Winding_FindAdjacent(getFace().getWinding(), *i);
2884 if(index != c_brush_maxFaces)
2886 const Winding& winding = getFace().getWinding();
2887 std::size_t adjacent = Winding_next(winding, index);
2888 functor(vector3_mid(winding[index].vertex, winding[adjacent].vertex));
2892 template<typename Functor>
2893 void SelectedFaces_foreach(Functor functor) const
2897 functor(centroid());
2901 template<typename Functor>
2902 void SelectedComponents_foreach(Functor functor) const
2904 SelectedVertices_foreach(functor);
2905 SelectedEdges_foreach(functor);
2906 SelectedFaces_foreach(functor);
2909 void iterate_selected(AABB& aabb) const
2911 SelectedComponents_foreach(AABBExtendByPoint(aabb));
2914 class RenderablePointVectorPushBack
2916 RenderablePointVector& m_points;
2918 RenderablePointVectorPushBack(RenderablePointVector& points) : m_points(points)
2921 void operator()(const Vector3& point) const
2923 const Colour4b colour_selected(0, 0, 255, 255);
2924 m_points.push_back(pointvertex_for_windingpoint(point, colour_selected));
2928 void iterate_selected(RenderablePointVector& points) const
2930 SelectedComponents_foreach(RenderablePointVectorPushBack(points));
2933 bool intersectVolume(const VolumeTest& volume, const Matrix4& localToWorld) const
2935 return m_face->intersectVolume(volume, localToWorld);
2938 void render(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
2940 if(!m_face->isFiltered() && m_face->contributes() && intersectVolume(volume, localToWorld))
2942 renderer.PushState();
2943 if(selectedComponents())
2945 renderer.Highlight(Renderer::eFace);
2947 m_face->render(renderer, localToWorld);
2948 renderer.PopState();
2952 void testSelect(SelectionTest& test, SelectionIntersection& best)
2954 if(!m_face->isFiltered())
2956 m_face->testSelect(test, best);
2959 void testSelect(Selector& selector, SelectionTest& test)
2961 SelectionIntersection best;
2962 testSelect(test, best);
2965 Selector_add(selector, m_selectable, best);
2968 void testSelect_centroid(Selector& selector, SelectionTest& test)
2970 if(m_face->contributes() && !m_face->isFiltered())
2972 SelectionIntersection best;
2973 m_face->testSelect_centroid(test, best);
2976 Selector_add(selector, m_selectable, best);
2981 void selectPlane(Selector& selector, const Line& line, PlanesIterator first, PlanesIterator last, const PlaneCallback& selectedPlaneCallback)
2983 for(Winding::const_iterator i = getFace().getWinding().begin(); i != getFace().getWinding().end(); ++i)
2985 Vector3 v(vector3_subtracted(line_closest_point(line, (*i).vertex), (*i).vertex));
2986 double dot = vector3_dot(getFace().plane3().normal(), v);
2993 Selector_add(selector, m_selectable);
2995 selectedPlaneCallback(getFace().plane3());
2997 void selectReversedPlane(Selector& selector, const SelectedPlanes& selectedPlanes)
2999 if(selectedPlanes.contains(plane3_flipped(getFace().plane3())))
3001 Selector_add(selector, m_selectable);
3005 void transformComponents(const Matrix4& matrix)
3009 m_face->transform(matrix, false);
3011 if(selectedVertices())
3013 if(m_vertexSelection.size() == 1)
3015 matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[1]);
3016 m_face->assign_planepts(m_face->m_move_planeptsTransformed);
3018 else if(m_vertexSelection.size() == 2)
3020 matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[1]);
3021 matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[2]);
3022 m_face->assign_planepts(m_face->m_move_planeptsTransformed);
3024 else if(m_vertexSelection.size() >= 3)
3026 matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[0]);
3027 matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[1]);
3028 matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[2]);
3029 m_face->assign_planepts(m_face->m_move_planeptsTransformed);
3034 if(m_edgeSelection.size() == 1)
3036 matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[0]);
3037 matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[1]);
3038 m_face->assign_planepts(m_face->m_move_planeptsTransformed);
3040 else if(m_edgeSelection.size() >= 2)
3042 matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[0]);
3043 matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[1]);
3044 matrix4_transform_point(matrix, m_face->m_move_planeptsTransformed[2]);
3045 m_face->assign_planepts(m_face->m_move_planeptsTransformed);
3050 void snapto(float snap)
3052 m_face->snapto(snap);
3055 void snapComponents(float snap)
3061 if(selectedVertices())
3063 vector3_snap(m_face->m_move_planepts[0], snap);
3064 vector3_snap(m_face->m_move_planepts[1], snap);
3065 vector3_snap(m_face->m_move_planepts[2], snap);
3066 m_face->assign_planepts(m_face->m_move_planepts);
3067 planepts_assign(m_face->m_move_planeptsTransformed, m_face->m_move_planepts);
3068 m_face->freezeTransform();
3072 vector3_snap(m_face->m_move_planepts[0], snap);
3073 vector3_snap(m_face->m_move_planepts[1], snap);
3074 vector3_snap(m_face->m_move_planepts[2], snap);
3075 m_face->assign_planepts(m_face->m_move_planepts);
3076 planepts_assign(m_face->m_move_planeptsTransformed, m_face->m_move_planepts);
3077 m_face->freezeTransform();
3080 void update_move_planepts_vertex(std::size_t index)
3082 m_face->update_move_planepts_vertex(index, m_face->m_move_planepts);
3084 void update_move_planepts_vertex2(std::size_t index, std::size_t other)
3086 const std::size_t numpoints = m_face->getWinding().numpoints;
3087 ASSERT_MESSAGE(index < numpoints, "select_vertex: invalid index");
3089 const std::size_t opposite = Winding_Opposite(m_face->getWinding(), index, other);
3091 if(triangle_reversed(index, other, opposite))
3093 std::swap(index, other);
3097 triangles_same_winding(
3098 m_face->getWinding()[opposite].vertex,
3099 m_face->getWinding()[index].vertex,
3100 m_face->getWinding()[other].vertex,
3101 m_face->getWinding()[0].vertex,
3102 m_face->getWinding()[1].vertex,
3103 m_face->getWinding()[2].vertex
3105 "update_move_planepts_vertex2: error"
3108 m_face->m_move_planepts[0] = m_face->getWinding()[opposite].vertex;
3109 m_face->m_move_planepts[1] = m_face->getWinding()[index].vertex;
3110 m_face->m_move_planepts[2] = m_face->getWinding()[other].vertex;
3111 planepts_quantise(m_face->m_move_planepts, GRID_MIN); // winding points are very inaccurate
3113 void update_selection_vertex()
3115 if(m_vertexSelection.size() == 0)
3117 m_selectableVertices.setSelected(false);
3121 m_selectableVertices.setSelected(true);
3123 if(m_vertexSelection.size() == 1)
3125 std::size_t index = Winding_FindAdjacent(getFace().getWinding(), *m_vertexSelection.begin());
3127 if(index != c_brush_maxFaces)
3129 update_move_planepts_vertex(index);
3132 else if(m_vertexSelection.size() == 2)
3134 std::size_t index = Winding_FindAdjacent(getFace().getWinding(), *m_vertexSelection.begin());
3135 std::size_t other = Winding_FindAdjacent(getFace().getWinding(), *(++m_vertexSelection.begin()));
3137 if(index != c_brush_maxFaces
3138 && other != c_brush_maxFaces)
3140 update_move_planepts_vertex2(index, other);
3145 void select_vertex(std::size_t index, bool select)
3149 VertexSelection_insert(m_vertexSelection, getFace().getWinding()[index].adjacent);
3153 VertexSelection_erase(m_vertexSelection, getFace().getWinding()[index].adjacent);
3156 SceneChangeNotify();
3157 update_selection_vertex();
3160 bool selected_vertex(std::size_t index) const
3162 return VertexSelection_find(m_vertexSelection, getFace().getWinding()[index].adjacent) != m_vertexSelection.end();
3165 void update_move_planepts_edge(std::size_t index)
3167 std::size_t numpoints = m_face->getWinding().numpoints;
3168 ASSERT_MESSAGE(index < numpoints, "select_edge: invalid index");
3170 std::size_t adjacent = Winding_next(m_face->getWinding(), index);
3171 std::size_t opposite = Winding_Opposite(m_face->getWinding(), index);
3172 m_face->m_move_planepts[0] = m_face->getWinding()[index].vertex;
3173 m_face->m_move_planepts[1] = m_face->getWinding()[adjacent].vertex;
3174 m_face->m_move_planepts[2] = m_face->getWinding()[opposite].vertex;
3175 planepts_quantise(m_face->m_move_planepts, GRID_MIN); // winding points are very inaccurate
3177 void update_selection_edge()
3179 if(m_edgeSelection.size() == 0)
3181 m_selectableEdges.setSelected(false);
3185 m_selectableEdges.setSelected(true);
3187 if(m_edgeSelection.size() == 1)
3189 std::size_t index = Winding_FindAdjacent(getFace().getWinding(), *m_edgeSelection.begin());
3191 if(index != c_brush_maxFaces)
3193 update_move_planepts_edge(index);
3198 void select_edge(std::size_t index, bool select)
3202 VertexSelection_insert(m_edgeSelection, getFace().getWinding()[index].adjacent);
3206 VertexSelection_erase(m_edgeSelection, getFace().getWinding()[index].adjacent);
3209 SceneChangeNotify();
3210 update_selection_edge();
3213 bool selected_edge(std::size_t index) const
3215 return VertexSelection_find(m_edgeSelection, getFace().getWinding()[index].adjacent) != m_edgeSelection.end();
3218 const Vector3& centroid() const
3220 return m_face->centroid();
3223 void connectivityChanged()
3225 // This occurs when a face is added or removed.
3226 // The current vertex and edge selections no longer valid and must be cleared.
3227 m_vertexSelection.clear();
3228 m_selectableVertices.setSelected(false);
3229 m_edgeSelection.clear();
3230 m_selectableEdges.setSelected(false);
3234 class BrushClipPlane : public OpenGLRenderable
3238 static Shader* m_state;
3240 static void constructStatic()
3242 m_state = GlobalShaderCache().capture("$CLIPPER_OVERLAY");
3244 static void destroyStatic()
3246 GlobalShaderCache().release("$CLIPPER_OVERLAY");
3249 void setPlane(const Brush& brush, const Plane3& plane)
3252 if(plane3_valid(m_plane))
3254 brush.windingForClipPlane(m_winding, m_plane);
3258 m_winding.resize(0);
3262 void render(RenderStateFlags state) const
3264 if((state & RENDER_FILL) != 0)
3266 Winding_Draw(m_winding, m_plane.normal(), state);
3270 Winding_DrawWireframe(m_winding);
3272 // also draw a line indicating the direction of the cut
3273 Vector3 lineverts[2];
3274 Winding_Centroid(m_winding, m_plane, lineverts[0]);
3275 lineverts[1] = vector3_added(lineverts[0], vector3_scaled(m_plane.normal(), Brush::m_maxWorldCoord * 4));
3277 glVertexPointer(3, GL_FLOAT, sizeof(Vector3), &lineverts[0]);
3278 glDrawArrays(GL_LINES, 0, GLsizei(2));
3282 void render(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
3284 renderer.SetState(m_state, Renderer::eWireframeOnly);
3285 renderer.SetState(m_state, Renderer::eFullMaterials);
3286 renderer.addRenderable(*this, localToWorld);
3290 inline void Face_addLight(const FaceInstance& face, const Matrix4& localToWorld, const RendererLight& light)
3292 const Plane3& facePlane = face.getFace().plane3();
3293 const Vector3& origin = light.aabb().origin;
3294 Plane3 tmp(plane3_transformed(Plane3(facePlane.normal(), -facePlane.dist()), localToWorld));
3295 if(!plane3_test_point(tmp, origin)
3296 || !plane3_test_point(tmp, vector3_added(origin, light.offset())))
3298 face.m_lights.addLight(light);
3304 typedef std::vector<FaceInstance> FaceInstances;
3306 class EdgeInstance : public Selectable
3308 FaceInstances& m_faceInstances;
3309 SelectableEdge* m_edge;
3311 void select_edge(bool select)
3313 FaceVertexId faceVertex = m_edge->m_faceVertex;
3314 m_faceInstances[faceVertex.getFace()].select_edge(faceVertex.getVertex(), select);
3315 faceVertex = next_edge(m_edge->m_faces, faceVertex);
3316 m_faceInstances[faceVertex.getFace()].select_edge(faceVertex.getVertex(), select);
3318 bool selected_edge() const
3320 FaceVertexId faceVertex = m_edge->m_faceVertex;
3321 if(!m_faceInstances[faceVertex.getFace()].selected_edge(faceVertex.getVertex()))
3325 faceVertex = next_edge(m_edge->m_faces, faceVertex);
3326 if(!m_faceInstances[faceVertex.getFace()].selected_edge(faceVertex.getVertex()))
3335 EdgeInstance(FaceInstances& faceInstances, SelectableEdge& edge)
3336 : m_faceInstances(faceInstances), m_edge(&edge)
3339 EdgeInstance& operator=(const EdgeInstance& other)
3341 m_edge = other.m_edge;
3345 void setSelected(bool select)
3347 select_edge(select);
3349 bool isSelected() const
3351 return selected_edge();
3355 void testSelect(Selector& selector, SelectionTest& test)
3357 SelectionIntersection best;
3358 m_edge->testSelect(test, best);
3361 Selector_add(selector, *this, best);
3366 class VertexInstance : public Selectable
3368 FaceInstances& m_faceInstances;
3369 SelectableVertex* m_vertex;
3371 void select_vertex(bool select)
3373 FaceVertexId faceVertex = m_vertex->m_faceVertex;
3376 m_faceInstances[faceVertex.getFace()].select_vertex(faceVertex.getVertex(), select);
3377 faceVertex = next_vertex(m_vertex->m_faces, faceVertex);
3379 while(faceVertex.getFace() != m_vertex->m_faceVertex.getFace());
3381 bool selected_vertex() const
3383 FaceVertexId faceVertex = m_vertex->m_faceVertex;
3386 if(!m_faceInstances[faceVertex.getFace()].selected_vertex(faceVertex.getVertex()))
3390 faceVertex = next_vertex(m_vertex->m_faces, faceVertex);
3392 while(faceVertex.getFace() != m_vertex->m_faceVertex.getFace());
3397 VertexInstance(FaceInstances& faceInstances, SelectableVertex& vertex)
3398 : m_faceInstances(faceInstances), m_vertex(&vertex)
3401 VertexInstance& operator=(const VertexInstance& other)
3403 m_vertex = other.m_vertex;
3407 void setSelected(bool select)
3409 select_vertex(select);
3411 bool isSelected() const
3413 return selected_vertex();
3416 void testSelect(Selector& selector, SelectionTest& test)
3418 SelectionIntersection best;
3419 m_vertex->testSelect(test, best);
3422 Selector_add(selector, *this, best);
3427 class BrushInstanceVisitor
3430 virtual void visit(FaceInstance& face) const = 0;
3433 class BrushInstance :
3434 public BrushObserver,
3435 public scene::Instance,
3438 public SelectionTestable,
3439 public ComponentSelectionTestable,
3440 public ComponentEditable,
3441 public ComponentSnappable,
3442 public PlaneSelectable,
3443 public LightCullable
3447 InstanceTypeCastTable m_casts;
3451 InstanceStaticCast<BrushInstance, Selectable>::install(m_casts);
3452 InstanceContainedCast<BrushInstance, Bounded>::install(m_casts);
3453 InstanceContainedCast<BrushInstance, Cullable>::install(m_casts);
3454 InstanceStaticCast<BrushInstance, Renderable>::install(m_casts);
3455 InstanceStaticCast<BrushInstance, SelectionTestable>::install(m_casts);
3456 InstanceStaticCast<BrushInstance, ComponentSelectionTestable>::install(m_casts);
3457 InstanceStaticCast<BrushInstance, ComponentEditable>::install(m_casts);
3458 InstanceStaticCast<BrushInstance, ComponentSnappable>::install(m_casts);
3459 InstanceStaticCast<BrushInstance, PlaneSelectable>::install(m_casts);
3460 InstanceIdentityCast<BrushInstance>::install(m_casts);
3461 InstanceContainedCast<BrushInstance, Transformable>::install(m_casts);
3463 InstanceTypeCastTable& get()
3472 FaceInstances m_faceInstances;
3474 typedef std::vector<EdgeInstance> EdgeInstances;
3475 EdgeInstances m_edgeInstances;
3476 typedef std::vector<VertexInstance> VertexInstances;
3477 VertexInstances m_vertexInstances;
3479 ObservedSelectable m_selectable;
3481 mutable RenderableWireframe m_render_wireframe;
3482 mutable RenderablePointVector m_render_selected;
3483 mutable AABB m_aabb_component;
3484 mutable Array<PointVertex> m_faceCentroidPointsCulled;
3485 RenderablePointArray m_render_faces_wireframe;
3486 mutable bool m_viewChanged; // requires re-evaluation of view-dependent cached data
3488 BrushClipPlane m_clipPlane;
3490 static Shader* m_state_selpoint;
3492 const LightList* m_lightList;
3494 TransformModifier m_transform;
3496 BrushInstance(const BrushInstance& other); // NOT COPYABLE
3497 BrushInstance& operator=(const BrushInstance& other); // NOT ASSIGNABLE
3499 static Counter* m_counter;
3501 typedef LazyStatic<TypeCasts> StaticTypeCasts;
3503 void lightsChanged()
3505 m_lightList->lightsChanged();
3507 typedef MemberCaller<BrushInstance, &BrushInstance::lightsChanged> LightsChangedCaller;
3509 STRING_CONSTANT(Name, "BrushInstance");
3511 BrushInstance(const scene::Path& path, scene::Instance* parent, Brush& brush) :
3512 Instance(path, parent, this, StaticTypeCasts::instance().get()),
3514 m_selectable(SelectedChangedCaller(*this)),
3515 m_render_selected(GL_POINTS),
3516 m_render_faces_wireframe(m_faceCentroidPointsCulled, GL_POINTS),
3517 m_viewChanged(false),
3518 m_transform(Brush::TransformChangedCaller(m_brush), ApplyTransformCaller(*this))
3520 m_brush.instanceAttach(Instance::path());
3521 m_brush.attach(*this);
3522 m_counter->increment();
3524 m_lightList = &GlobalShaderCache().attach(*this);
3525 m_brush.m_lightsChanged = LightsChangedCaller(*this); ///\todo Make this work with instancing.
3527 Instance::setTransformChangedCallback(LightsChangedCaller(*this));
3531 Instance::setTransformChangedCallback(Callback());
3533 m_brush.m_lightsChanged = Callback();
3534 GlobalShaderCache().detach(*this);
3536 m_counter->decrement();
3537 m_brush.detach(*this);
3538 m_brush.instanceDetach(Instance::path());
3545 const Brush& getBrush() const
3550 Bounded& get(NullType<Bounded>)
3554 Cullable& get(NullType<Cullable>)
3558 Transformable& get(NullType<Transformable>)
3563 void selectedChanged(const Selectable& selectable)
3565 GlobalSelectionSystem().getObserver(SelectionSystem::ePrimitive)(selectable);
3566 GlobalSelectionSystem().onSelectedChanged(*this, selectable);
3568 Instance::selectedChanged();
3570 typedef MemberCaller1<BrushInstance, const Selectable&, &BrushInstance::selectedChanged> SelectedChangedCaller;
3572 void selectedChangedComponent(const Selectable& selectable)
3574 GlobalSelectionSystem().getObserver(SelectionSystem::eComponent)(selectable);
3575 GlobalSelectionSystem().onComponentSelection(*this, selectable);
3577 typedef MemberCaller1<BrushInstance, const Selectable&, &BrushInstance::selectedChangedComponent> SelectedChangedComponentCaller;
3579 const BrushInstanceVisitor& forEachFaceInstance(const BrushInstanceVisitor& visitor)
3581 for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3588 static void constructStatic()
3590 m_state_selpoint = GlobalShaderCache().capture("$SELPOINT");
3592 static void destroyStatic()
3594 GlobalShaderCache().release("$SELPOINT");
3599 m_faceInstances.clear();
3601 void reserve(std::size_t size)
3603 m_faceInstances.reserve(size);
3606 void push_back(Face& face)
3608 m_faceInstances.push_back(FaceInstance(face, SelectedChangedComponentCaller(*this)));
3612 ASSERT_MESSAGE(!m_faceInstances.empty(), "erasing invalid element");
3613 m_faceInstances.pop_back();
3615 void erase(std::size_t index)
3617 ASSERT_MESSAGE(index < m_faceInstances.size(), "erasing invalid element");
3618 m_faceInstances.erase(m_faceInstances.begin() + index);
3620 void connectivityChanged()
3622 for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3624 (*i).connectivityChanged();
3630 m_edgeInstances.clear();
3632 void edge_push_back(SelectableEdge& edge)
3634 m_edgeInstances.push_back(EdgeInstance(m_faceInstances, edge));
3639 m_vertexInstances.clear();
3641 void vertex_push_back(SelectableVertex& vertex)
3643 m_vertexInstances.push_back(VertexInstance(m_faceInstances, vertex));
3646 void DEBUG_verify() const
3648 ASSERT_MESSAGE(m_faceInstances.size() == m_brush.DEBUG_size(), "FATAL: mismatch");
3651 bool isSelected() const
3653 return m_selectable.isSelected();
3655 void setSelected(bool select)
3657 m_selectable.setSelected(select);
3660 void update_selected() const
3662 m_render_selected.clear();
3663 for(FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3665 if((*i).getFace().contributes())
3667 (*i).iterate_selected(m_render_selected);
3672 void evaluateViewDependent(const VolumeTest& volume, const Matrix4& localToWorld) const
3676 m_viewChanged = false;
3678 bool faces_visible[c_brush_maxFaces];
3680 bool* j = faces_visible;
3681 for(FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i, ++j)
3683 *j = (*i).intersectVolume(volume, localToWorld);
3687 m_brush.update_wireframe(m_render_wireframe, faces_visible);
3688 m_brush.update_faces_wireframe(m_faceCentroidPointsCulled, faces_visible);
3692 void renderComponentsSelected(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
3694 m_brush.evaluateBRep();
3697 if(!m_render_selected.empty())
3699 renderer.Highlight(Renderer::ePrimitive, false);
3700 renderer.SetState(m_state_selpoint, Renderer::eWireframeOnly);
3701 renderer.SetState(m_state_selpoint, Renderer::eFullMaterials);
3702 renderer.addRenderable(m_render_selected, localToWorld);
3706 void renderComponents(Renderer& renderer, const VolumeTest& volume) const
3708 m_brush.evaluateBRep();
3710 const Matrix4& localToWorld = Instance::localToWorld();
3712 renderer.SetState(m_brush.m_state_point, Renderer::eWireframeOnly);
3713 renderer.SetState(m_brush.m_state_point, Renderer::eFullMaterials);
3715 if(volume.fill() && GlobalSelectionSystem().ComponentMode() == SelectionSystem::eFace)
3717 evaluateViewDependent(volume, localToWorld);
3718 renderer.addRenderable(m_render_faces_wireframe, localToWorld);
3722 m_brush.renderComponents(GlobalSelectionSystem().ComponentMode(), renderer, volume, localToWorld);
3726 void renderClipPlane(Renderer& renderer, const VolumeTest& volume) const
3728 if(GlobalSelectionSystem().ManipulatorMode() == SelectionSystem::eClip && isSelected())
3730 m_clipPlane.render(renderer, volume, localToWorld());
3734 void renderCommon(Renderer& renderer, const VolumeTest& volume) const
3736 bool componentMode = GlobalSelectionSystem().Mode() == SelectionSystem::eComponent;
3738 if(componentMode && isSelected())
3740 renderComponents(renderer, volume);
3743 if(parentSelected())
3747 renderer.Highlight(Renderer::eFace);
3749 renderer.Highlight(Renderer::ePrimitive);
3753 void renderSolid(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
3755 //renderCommon(renderer, volume);
3757 m_lightList->evaluateLights();
3759 for(FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3761 renderer.setLights((*i).m_lights);
3762 (*i).render(renderer, volume, localToWorld);
3765 renderComponentsSelected(renderer, volume, localToWorld);
3768 void renderWireframe(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
3770 //renderCommon(renderer, volume);
3772 evaluateViewDependent(volume, localToWorld);
3774 if(m_render_wireframe.m_size != 0)
3776 renderer.addRenderable(m_render_wireframe, localToWorld);
3779 renderComponentsSelected(renderer, volume, localToWorld);
3782 void renderSolid(Renderer& renderer, const VolumeTest& volume) const
3784 m_brush.evaluateBRep();
3786 renderClipPlane(renderer, volume);
3788 renderSolid(renderer, volume, localToWorld());
3791 void renderWireframe(Renderer& renderer, const VolumeTest& volume) const
3793 m_brush.evaluateBRep();
3795 renderClipPlane(renderer, volume);
3797 renderWireframe(renderer, volume, localToWorld());
3800 void viewChanged() const
3802 m_viewChanged = true;
3805 void testSelect(Selector& selector, SelectionTest& test)
3807 test.BeginMesh(localToWorld());
3809 SelectionIntersection best;
3810 for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3812 (*i).testSelect(test, best);
3816 selector.addIntersection(best);
3820 bool isSelectedComponents() const
3822 for(FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3824 if((*i).selectedComponents())
3831 void setSelectedComponents(bool select, SelectionSystem::EComponentMode mode)
3833 for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3835 (*i).setSelected(mode, select);
3838 void testSelectComponents(Selector& selector, SelectionTest& test, SelectionSystem::EComponentMode mode)
3840 test.BeginMesh(localToWorld());
3844 case SelectionSystem::eVertex:
3846 for(VertexInstances::iterator i = m_vertexInstances.begin(); i != m_vertexInstances.end(); ++i)
3848 (*i).testSelect(selector, test);
3852 case SelectionSystem::eEdge:
3854 for(EdgeInstances::iterator i = m_edgeInstances.begin(); i != m_edgeInstances.end(); ++i)
3856 (*i).testSelect(selector, test);
3860 case SelectionSystem::eFace:
3862 if(test.getVolume().fill())
3864 for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3866 (*i).testSelect(selector, test);
3871 for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3873 (*i).testSelect_centroid(selector, test);
3883 void selectPlanes(Selector& selector, SelectionTest& test, const PlaneCallback& selectedPlaneCallback)
3885 test.BeginMesh(localToWorld());
3887 PlanePointer brushPlanes[c_brush_maxFaces];
3888 PlanesIterator j = brushPlanes;
3890 for(Brush::const_iterator i = m_brush.begin(); i != m_brush.end(); ++i)
3892 *j++ = &(*i)->plane3();
3895 for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3897 (*i).selectPlane(selector, Line(test.getNear(), test.getFar()), brushPlanes, j, selectedPlaneCallback);
3900 void selectReversedPlanes(Selector& selector, const SelectedPlanes& selectedPlanes)
3902 for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3904 (*i).selectReversedPlane(selector, selectedPlanes);
3909 void transformComponents(const Matrix4& matrix)
3911 for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3913 (*i).transformComponents(matrix);
3916 const AABB& getSelectedComponentsBounds() const
3918 m_aabb_component = AABB();
3920 for(FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3922 (*i).iterate_selected(m_aabb_component);
3925 return m_aabb_component;
3928 void snapComponents(float snap)
3930 for(FaceInstances::iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3932 (*i).snapComponents(snap);
3935 void evaluateTransform()
3937 Matrix4 matrix(m_transform.calculateTransform());
3938 //globalOutputStream() << "matrix: " << matrix << "\n";
3940 if(m_transform.getType() == TRANSFORM_PRIMITIVE)
3942 m_brush.transform(matrix);
3946 transformComponents(matrix);
3949 void applyTransform()
3951 m_brush.revertTransform();
3952 evaluateTransform();
3953 m_brush.freezeTransform();
3955 typedef MemberCaller<BrushInstance, &BrushInstance::applyTransform> ApplyTransformCaller;
3957 void setClipPlane(const Plane3& plane)
3959 m_clipPlane.setPlane(m_brush, plane);
3962 bool testLight(const RendererLight& light) const
3964 return light.testAABB(worldAABB());
3966 void insertLight(const RendererLight& light)
3968 const Matrix4& localToWorld = Instance::localToWorld();
3969 for(FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3971 Face_addLight(*i, localToWorld, light);
3976 for(FaceInstances::const_iterator i = m_faceInstances.begin(); i != m_faceInstances.end(); ++i)
3978 (*i).m_lights.clear();
3983 inline BrushInstance* Instance_getBrush(scene::Instance& instance)
3985 return InstanceTypeCast<BrushInstance>::cast(instance);
3989 template<typename Functor>
3990 class BrushSelectedVisitor : public SelectionSystem::Visitor
3992 const Functor& m_functor;
3994 BrushSelectedVisitor(const Functor& functor) : m_functor(functor)
3997 void visit(scene::Instance& instance) const
3999 BrushInstance* brush = Instance_getBrush(instance);
4007 template<typename Functor>
4008 inline const Functor& Scene_forEachSelectedBrush(const Functor& functor)
4010 GlobalSelectionSystem().foreachSelected(BrushSelectedVisitor<Functor>(functor));
4014 template<typename Functor>
4015 class BrushVisibleSelectedVisitor : public SelectionSystem::Visitor
4017 const Functor& m_functor;
4019 BrushVisibleSelectedVisitor(const Functor& functor) : m_functor(functor)
4022 void visit(scene::Instance& instance) const
4024 BrushInstance* brush = Instance_getBrush(instance);
4026 && instance.path().top().get().visible())
4033 template<typename Functor>
4034 inline const Functor& Scene_forEachVisibleSelectedBrush(const Functor& functor)
4036 GlobalSelectionSystem().foreachSelected(BrushVisibleSelectedVisitor<Functor>(functor));
4040 class BrushForEachFace
4042 const BrushInstanceVisitor& m_visitor;
4044 BrushForEachFace(const BrushInstanceVisitor& visitor) : m_visitor(visitor)
4047 void operator()(BrushInstance& brush) const
4049 brush.forEachFaceInstance(m_visitor);
4053 template<class Functor>
4054 class FaceInstanceVisitFace : public BrushInstanceVisitor
4056 const Functor& functor;
4058 FaceInstanceVisitFace(const Functor& functor)
4062 void visit(FaceInstance& face) const
4064 functor(face.getFace());
4068 template<typename Functor>
4069 inline const Functor& Brush_forEachFace(BrushInstance& brush, const Functor& functor)
4071 brush.forEachFaceInstance(FaceInstanceVisitFace<Functor>(functor));
4075 template<class Functor>
4076 class FaceVisitAll : public BrushVisitor
4078 const Functor& functor;
4080 FaceVisitAll(const Functor& functor)
4084 void visit(Face& face) const
4090 template<typename Functor>
4091 inline const Functor& Brush_forEachFace(const Brush& brush, const Functor& functor)
4093 brush.forEachFace(FaceVisitAll<Functor>(functor));
4097 template<typename Functor>
4098 inline const Functor& Brush_forEachFace(Brush& brush, const Functor& functor)
4100 brush.forEachFace(FaceVisitAll<Functor>(functor));
4104 template<class Functor>
4105 class FaceInstanceVisitAll : public BrushInstanceVisitor
4107 const Functor& functor;
4109 FaceInstanceVisitAll(const Functor& functor)
4113 void visit(FaceInstance& face) const
4119 template<typename Functor>
4120 inline const Functor& Brush_ForEachFaceInstance(BrushInstance& brush, const Functor& functor)
4122 brush.forEachFaceInstance(FaceInstanceVisitAll<Functor>(functor));
4126 template<typename Functor>
4127 inline const Functor& Scene_forEachBrush(scene::Graph& graph, const Functor& functor)
4129 graph.traverse(InstanceWalker< InstanceApply<BrushInstance, Functor> >(functor));
4133 template<typename Type, typename Functor>
4134 class InstanceIfVisible : public Functor
4137 InstanceIfVisible(const Functor& functor) : Functor(functor)
4140 void operator()(scene::Instance& instance)
4142 if(instance.path().top().get().visible())
4144 Functor::operator()(instance);
4149 template<typename Functor>
4150 class BrushVisibleWalker : public scene::Graph::Walker
4152 const Functor& m_functor;
4154 BrushVisibleWalker(const Functor& functor) : m_functor(functor)
4157 bool pre(const scene::Path& path, scene::Instance& instance) const
4159 if(path.top().get().visible())
4161 BrushInstance* brush = Instance_getBrush(instance);
4171 template<typename Functor>
4172 inline const Functor& Scene_forEachVisibleBrush(scene::Graph& graph, const Functor& functor)
4174 graph.traverse(BrushVisibleWalker<Functor>(functor));
4178 template<typename Functor>
4179 inline const Functor& Scene_ForEachBrush_ForEachFace(scene::Graph& graph, const Functor& functor)
4181 Scene_forEachBrush(graph, BrushForEachFace(FaceInstanceVisitFace<Functor>(functor)));
4186 template<typename Functor>
4187 inline const Functor& Scene_ForEachBrush_ForEachFaceInstance(scene::Graph& graph, const Functor& functor)
4189 Scene_forEachBrush(graph, BrushForEachFace(FaceInstanceVisitAll<Functor>(functor)));
4193 template<typename Functor>
4194 inline const Functor& Scene_ForEachSelectedBrush_ForEachFace(scene::Graph& graph, const Functor& functor)
4196 Scene_forEachSelectedBrush(BrushForEachFace(FaceInstanceVisitFace<Functor>(functor)));
4200 template<typename Functor>
4201 inline const Functor& Scene_ForEachSelectedBrush_ForEachFaceInstance(scene::Graph& graph, const Functor& functor)
4203 Scene_forEachSelectedBrush(BrushForEachFace(FaceInstanceVisitAll<Functor>(functor)));
4207 template<typename Functor>
4208 class FaceVisitorWrapper
4210 const Functor& functor;
4212 FaceVisitorWrapper(const Functor& functor) : functor(functor)
4216 void operator()(FaceInstance& faceInstance) const
4218 functor(faceInstance.getFace());
4222 template<typename Functor>
4223 inline const Functor& Scene_ForEachSelectedBrushFace(scene::Graph& graph, const Functor& functor)
4225 g_SelectedFaceInstances.foreach(FaceVisitorWrapper<Functor>(functor));