use radians for 'spin' bmesh operator (since the rest of the py api uses radians...
[blender.git] / source / blender / bmesh / intern / bmesh_operator_api_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  * Contributor(s): Joseph Eagar, Geoffrey Bantle, Campbell Barton
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/bmesh/intern/bmesh_operator_api_inline.h
24  *  \ingroup bmesh
25  *
26  * BMesh inline operator functions.
27  */
28
29 #ifndef __BMESH_OPERATOR_API_INLINE_H__
30 #define __BMESH_OPERATOR_API_INLINE_H__
31
32 /* tool flag API. never, ever ever should tool code put junk in
33  * header flags (element->head.flag), nor should they use
34  * element->head.eflag1/eflag2.  instead, use this api to set
35  * flags.
36  *
37  * if you need to store a value per element, use a
38  * ghash or a mapping slot to do it. */
39
40 /* flags 15 and 16 (1 << 14 and 1 << 15) are reserved for bmesh api use */
41 BLI_INLINE short _bmo_elem_flag_test(BMesh *bm, BMFlagLayer *oflags, const short oflag)
42 {
43         return oflags[bm->stackdepth - 1].f & oflag;
44 }
45
46 BLI_INLINE short _bmo_elem_flag_test_bool(BMesh *bm, BMFlagLayer *oflags, const short oflag)
47 {
48         return (oflags[bm->stackdepth - 1].f & oflag) != 0;
49 }
50
51 BLI_INLINE void _bmo_elem_flag_enable(BMesh *bm, BMFlagLayer *oflags, const short oflag)
52 {
53         oflags[bm->stackdepth - 1].f |= oflag;
54 }
55
56 BLI_INLINE void _bmo_elem_flag_disable(BMesh *bm, BMFlagLayer *oflags, const short oflag)
57 {
58         oflags[bm->stackdepth - 1].f &= ~oflag;
59 }
60
61 BLI_INLINE void _bmo_elem_flag_set(BMesh *bm, BMFlagLayer *oflags, const short oflag, int val)
62 {
63         if (val) oflags[bm->stackdepth - 1].f |= oflag;
64         else     oflags[bm->stackdepth - 1].f &= ~oflag;
65 }
66
67 BLI_INLINE void _bmo_elem_flag_toggle(BMesh *bm, BMFlagLayer *oflags, const short oflag)
68 {
69         oflags[bm->stackdepth - 1].f ^= oflag;
70 }
71
72 BLI_INLINE void BMO_slot_map_int_insert(BMOperator *op, BMOpSlot *slot,
73                                         void *element, const int val)
74 {
75         BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_INT);
76         BMO_slot_map_insert(op, slot, element, &val, sizeof(int));
77 }
78
79 BLI_INLINE void BMO_slot_map_bool_insert(BMOperator *op, BMOpSlot *slot,
80                                         void *element, const int val)
81 {
82         BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_BOOL);
83         BLI_assert(val == FALSE || val == TRUE);
84         BMO_slot_map_insert(op, slot, element, &val, sizeof(int));
85 }
86
87 BLI_INLINE void BMO_slot_map_float_insert(BMOperator *op, BMOpSlot *slot,
88                                           void *element, const float val)
89 {
90         BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_FLT);
91         BMO_slot_map_insert(op, slot, element, &val, sizeof(float));
92 }
93
94
95 /* pointer versions of BMO_slot_map_float_get and BMO_slot_map_float_insert.
96  *
97  * do NOT use these for non-operator-api-allocated memory! instead
98  * use BMO_slot_map_data_get and BMO_slot_map_insert, which copies the data. */
99
100 BLI_INLINE void BMO_slot_map_ptr_insert(BMOperator *op, BMOpSlot *slot,
101                                         const void *element, void *val)
102 {
103         BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL);
104         BMO_slot_map_insert(op, slot, element, &val, sizeof(void *));
105 }
106
107 BLI_INLINE void BMO_slot_map_elem_insert(BMOperator *op, BMOpSlot *slot,
108                                         const void *element, void *val)
109 {
110         BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_ELEM);
111         BMO_slot_map_insert(op, slot, element, &val, sizeof(void *));
112 }
113
114
115 /* no values */
116 BLI_INLINE void BMO_slot_map_empty_insert(BMOperator *op, BMOpSlot *slot,
117                                         const void *element)
118 {
119         BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_EMPTY);
120         BMO_slot_map_insert(op, slot, element, NULL, 0);
121 }
122
123 BLI_INLINE int BMO_slot_map_contains(BMOpSlot *slot, const void *element)
124 {
125         BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
126
127         /* sanity check */
128         if (UNLIKELY(slot->data.ghash == NULL)) {
129                 return 0;
130         }
131
132         return BLI_ghash_haskey(slot->data.ghash, element);
133 }
134
135 BLI_INLINE void *BMO_slot_map_data_get(BMOpSlot *slot, const void *element)
136 {
137         BMOElemMapping *mapping;
138         BLI_assert(slot->slot_type == BMO_OP_SLOT_MAPPING);
139
140         /* sanity check */
141         if (UNLIKELY(slot->data.ghash == NULL)) {
142                 return NULL;
143         }
144
145         mapping = (BMOElemMapping *)BLI_ghash_lookup(slot->data.ghash, element);
146
147         if (!mapping) {
148                 return NULL;
149         }
150
151         return mapping + 1;
152 }
153
154 BLI_INLINE float BMO_slot_map_float_get(BMOpSlot *slot, const void *element)
155 {
156         float *val;
157         BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_FLT);
158
159         val = (float *) BMO_slot_map_data_get(slot, element);
160         if (val) return *val;
161
162         return 0.0f;
163 }
164
165 BLI_INLINE int BMO_slot_map_int_get(BMOpSlot *slot, const void *element)
166 {
167         int *val;
168         BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_INT);
169
170         val = (int *) BMO_slot_map_data_get(slot, element);
171         if (val) return *val;
172
173         return 0;
174 }
175
176 BLI_INLINE int BMO_slot_map_bool_get(BMOpSlot *slot, const void *element)
177 {
178         int *val;
179         BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_BOOL);
180
181         val = (int *) BMO_slot_map_data_get(slot, element);
182         BLI_assert(val == NULL || *val == FALSE || *val == TRUE);
183         if (val) return *val;
184
185         return 0;
186 }
187
188 BLI_INLINE void *BMO_slot_map_ptr_get(BMOpSlot *slot, const void *element)
189 {
190         void **val = (void **) BMO_slot_map_data_get(slot, element);
191         BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL);
192         if (val) return *val;
193
194         return NULL;
195 }
196
197 BLI_INLINE void *BMO_slot_map_elem_get(BMOpSlot *slot, const void *element)
198 {
199         void **val = (void **) BMO_slot_map_data_get(slot, element);
200         BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_ELEM);
201         if (val) return *val;
202
203         return NULL;
204 }
205
206 #endif /* __BMESH_OPERATOR_API_INLINE_H__ */