Merge branch 'blender2.7'
[blender.git] / source / blender / bmesh / intern / bmesh_query_inline.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file \ingroup bmesh
18  */
19
20
21 #ifndef __BMESH_QUERY_INLINE_H__
22 #define __BMESH_QUERY_INLINE_H__
23
24 /**
25  * Returns whether or not a given vertex is
26  * is part of a given edge.
27  */
28 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
29 BLI_INLINE bool BM_vert_in_edge(const BMEdge *e, const BMVert *v)
30 {
31         return (ELEM(v, e->v1, e->v2));
32 }
33
34 /**
35  * Returns whether or not a given edge is part of a given loop.
36  */
37 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2)
38 BLI_INLINE bool BM_edge_in_loop(const BMEdge *e, const BMLoop *l)
39 {
40         return (l->e == e || l->prev->e == e);
41 }
42
43 /**
44  * Returns whether or not two vertices are in
45  * a given edge
46  */
47 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2, 3)
48 BLI_INLINE bool BM_verts_in_edge(const BMVert *v1, const BMVert *v2, const BMEdge *e)
49 {
50         return ((e->v1 == v1 && e->v2 == v2) ||
51                 (e->v1 == v2 && e->v2 == v1));
52 }
53
54 /**
55  * Given a edge and one of its vertices, returns
56  * the other vertex.
57  */
58 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2)
59 BLI_INLINE BMVert *BM_edge_other_vert(BMEdge *e, const BMVert *v)
60 {
61         if (e->v1 == v) {
62                 return e->v2;
63         }
64         else if (e->v2 == v) {
65                 return e->v1;
66         }
67         return NULL;
68 }
69
70 /**
71  * Tests whether or not the edge is part of a wire.
72  * (ie: has no faces attached to it)
73  */
74 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
75 BLI_INLINE bool BM_edge_is_wire(const BMEdge *e)
76 {
77         return (e->l == NULL);
78 }
79
80 /**
81  * Tests whether or not this edge is manifold.
82  * A manifold edge has exactly 2 faces attached to it.
83  */
84
85 #if 1 /* fast path for checking manifold */
86 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
87 BLI_INLINE bool BM_edge_is_manifold(const BMEdge *e)
88 {
89         const BMLoop *l = e->l;
90         return (l && (l->radial_next != l) &&             /* not 0 or 1 face users */
91                      (l->radial_next->radial_next == l)); /* 2 face users */
92 }
93 #else
94 BLI_INLINE int BM_edge_is_manifold(BMEdge *e)
95 {
96         return (BM_edge_face_count(e) == 2);
97 }
98 #endif
99
100 /**
101  * Tests that the edge is manifold and
102  * that both its faces point the same way.
103  */
104 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
105 BLI_INLINE bool BM_edge_is_contiguous(const BMEdge *e)
106 {
107         const BMLoop *l = e->l;
108         const BMLoop *l_other;
109         return (l && ((l_other = l->radial_next) != l) &&  /* not 0 or 1 face users */
110                      (l_other->radial_next == l) &&        /* 2 face users */
111                      (l_other->v != l->v));
112 }
113
114 /**
115  * Tests whether or not an edge is on the boundary
116  * of a shell (has one face associated with it)
117  */
118
119 #if 1 /* fast path for checking boundary */
120 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
121 BLI_INLINE bool BM_edge_is_boundary(const BMEdge *e)
122 {
123         const BMLoop *l = e->l;
124         return (l && (l->radial_next == l));
125 }
126 #else
127 BLI_INLINE int BM_edge_is_boundary(BMEdge *e)
128 {
129         return (BM_edge_face_count(e) == 1);
130 }
131 #endif
132
133 /**
134  * Tests whether one loop is next to another within the same face.
135  */
136 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2)
137 BLI_INLINE bool BM_loop_is_adjacent(const BMLoop *l_a, const BMLoop *l_b)
138 {
139         BLI_assert(l_a->f == l_b->f);
140         BLI_assert(l_a != l_b);
141         return (ELEM(l_b, l_a->next, l_a->prev));
142 }
143
144 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
145 BLI_INLINE bool BM_loop_is_manifold(const BMLoop *l)
146 {
147         return ((l != l->radial_next) &&
148                 (l == l->radial_next->radial_next));
149 }
150
151 /**
152  * Check if we have a single wire edge user.
153  */
154 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
155 BLI_INLINE bool BM_vert_is_wire_endpoint(const BMVert *v)
156 {
157         const BMEdge *e = v->e;
158         if (e && e->l == NULL) {
159                 return (BM_DISK_EDGE_NEXT(e, v) == e);
160         }
161         return false;
162 }
163
164 #endif /* __BMESH_QUERY_INLINE_H__ */