Cleanup: remove redundant, invalid info from headers
[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 blender/bmesh/intern/bmesh_query_inline.h
18  *  \ingroup bmesh
19  */
20
21
22 #ifndef __BMESH_QUERY_INLINE_H__
23 #define __BMESH_QUERY_INLINE_H__
24
25 /**
26  * Returns whether or not a given vertex is
27  * is part of a given edge.
28  */
29 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
30 BLI_INLINE bool BM_vert_in_edge(const BMEdge *e, const BMVert *v)
31 {
32         return (ELEM(v, e->v1, e->v2));
33 }
34
35 /**
36  * Returns whether or not a given edge is part of a given loop.
37  */
38 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2)
39 BLI_INLINE bool BM_edge_in_loop(const BMEdge *e, const BMLoop *l)
40 {
41         return (l->e == e || l->prev->e == e);
42 }
43
44 /**
45  * Returns whether or not two vertices are in
46  * a given edge
47  */
48 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2, 3)
49 BLI_INLINE bool BM_verts_in_edge(const BMVert *v1, const BMVert *v2, const BMEdge *e)
50 {
51         return ((e->v1 == v1 && e->v2 == v2) ||
52                 (e->v1 == v2 && e->v2 == v1));
53 }
54
55 /**
56  * Given a edge and one of its vertices, returns
57  * the other vertex.
58  */
59 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2)
60 BLI_INLINE BMVert *BM_edge_other_vert(BMEdge *e, const BMVert *v)
61 {
62         if (e->v1 == v) {
63                 return e->v2;
64         }
65         else if (e->v2 == v) {
66                 return e->v1;
67         }
68         return NULL;
69 }
70
71 /**
72  * Tests whether or not the edge is part of a wire.
73  * (ie: has no faces attached to it)
74  */
75 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
76 BLI_INLINE bool BM_edge_is_wire(const BMEdge *e)
77 {
78         return (e->l == NULL);
79 }
80
81 /**
82  * Tests whether or not this edge is manifold.
83  * A manifold edge has exactly 2 faces attached to it.
84  */
85
86 #if 1 /* fast path for checking manifold */
87 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
88 BLI_INLINE bool BM_edge_is_manifold(const BMEdge *e)
89 {
90         const BMLoop *l = e->l;
91         return (l && (l->radial_next != l) &&             /* not 0 or 1 face users */
92                      (l->radial_next->radial_next == l)); /* 2 face users */
93 }
94 #else
95 BLI_INLINE int BM_edge_is_manifold(BMEdge *e)
96 {
97         return (BM_edge_face_count(e) == 2);
98 }
99 #endif
100
101 /**
102  * Tests that the edge is manifold and
103  * that both its faces point the same way.
104  */
105 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
106 BLI_INLINE bool BM_edge_is_contiguous(const BMEdge *e)
107 {
108         const BMLoop *l = e->l;
109         const BMLoop *l_other;
110         return (l && ((l_other = l->radial_next) != l) &&  /* not 0 or 1 face users */
111                      (l_other->radial_next == l) &&        /* 2 face users */
112                      (l_other->v != l->v));
113 }
114
115 /**
116  * Tests whether or not an edge is on the boundary
117  * of a shell (has one face associated with it)
118  */
119
120 #if 1 /* fast path for checking boundary */
121 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
122 BLI_INLINE bool BM_edge_is_boundary(const BMEdge *e)
123 {
124         const BMLoop *l = e->l;
125         return (l && (l->radial_next == l));
126 }
127 #else
128 BLI_INLINE int BM_edge_is_boundary(BMEdge *e)
129 {
130         return (BM_edge_face_count(e) == 1);
131 }
132 #endif
133
134 /**
135  * Tests whether one loop is next to another within the same face.
136  */
137 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2)
138 BLI_INLINE bool BM_loop_is_adjacent(const BMLoop *l_a, const BMLoop *l_b)
139 {
140         BLI_assert(l_a->f == l_b->f);
141         BLI_assert(l_a != l_b);
142         return (ELEM(l_b, l_a->next, l_a->prev));
143 }
144
145 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
146 BLI_INLINE bool BM_loop_is_manifold(const BMLoop *l)
147 {
148         return ((l != l->radial_next) &&
149                 (l == l->radial_next->radial_next));
150 }
151
152 /**
153  * Check if we have a single wire edge user.
154  */
155 ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
156 BLI_INLINE bool BM_vert_is_wire_endpoint(const BMVert *v)
157 {
158         const BMEdge *e = v->e;
159         if (e && e->l == NULL) {
160                 return (BM_DISK_EDGE_NEXT(e, v) == e);
161         }
162         return false;
163 }
164
165 #endif /* __BMESH_QUERY_INLINE_H__ */