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