numerical error fix for tesselator
[blender.git] / source / blender / bmesh / bmesh_operator_api.h
1 #ifndef _BMESH_OPERATOR_H
2 #define _BMESH_OPERATOR_H
3
4 #include "BLI_memarena.h"
5 #include "BLI_ghash.h"
6
7 #include <stdarg.h>
8
9 /*
10 operators represent logical, executable mesh modules.  all operations
11 involving a bmesh has to go through them.
12
13 operators are nested, and certain data (e.g. tool flags) are also nested,
14 and are private to an operator when it's executed.
15 */
16
17 struct GHashIterator;
18
19 #define BMOP_OPSLOT_INT                 0
20 #define BMOP_OPSLOT_FLT                 1
21 #define BMOP_OPSLOT_PNT                 2
22 #define BMOP_OPSLOT_VEC                 6
23
24 /*after BMOP_OPSLOT_VEC, everything is 
25   dynamically allocated arrays.  we
26   leave a space in the identifiers
27   for future growth.*/
28 #define BMOP_OPSLOT_ELEMENT_BUF         7
29 #define BMOP_OPSLOT_MAPPING             8
30 #define BMOP_OPSLOT_TYPES               9
31
32 /*don't access the contents of this directly*/
33 typedef struct BMOpSlot{
34         int slottype;
35         int len;
36         int flag;
37         int index; /*index within slot array*/
38         union {
39                 int i;
40                 float f;                                        
41                 void *p;                                        
42                 float vec[3];
43                 void *buf;
44                 GHash *ghash;
45         } data;
46 }BMOpSlot;
47
48 #define BMOP_MAX_SLOTS                  16 /*way more than probably needed*/
49
50 typedef struct BMOperator {
51         int type;
52         int slottype;
53         int needflag;
54         struct BMOpSlot slots[BMOP_MAX_SLOTS];
55         void (*exec)(struct BMesh *bm, struct BMOperator *op);
56         MemArena *arena;
57 } BMOperator;
58
59 #define MAX_SLOTNAME    32
60
61 typedef struct slottype {
62         int type;
63         char name[MAX_SLOTNAME];
64 } slottype;
65
66 typedef struct BMOpDefine {
67         char *name;
68         slottype slottypes[BMOP_MAX_SLOTS];
69         void (*exec)(BMesh *bm, BMOperator *op);
70         int totslot;
71         int flag; /*doesn't do anything right now*/
72 } BMOpDefine;
73
74 /*------------- Operator API --------------*/
75
76 /*data types that use pointers (arrays, etc) should never
77   have it set directly.  and never use BMO_Set_Pnt to
78   pass in a list of edges or any arrays, really.*/
79 void BMO_Init_Op(struct BMOperator *op, int opcode);
80 void BMO_Exec_Op(struct BMesh *bm, struct BMOperator *op);
81 void BMO_Finish_Op(struct BMesh *bm, struct BMOperator *op);
82
83 /*tool flag API. never, ever ever should tool code put junk in 
84   header flags (element->head.flag), nor should they use 
85   element->head.eflag1/eflag2.  instead, use this api to set
86   flags.  
87   
88   if you need to store a value per element, use a 
89   ghash or a mapping slot to do it.*/
90 /*flags 15 and 16 (1<<14 and 1<<15) are reserved for bmesh api use*/
91 void BMO_SetFlag(struct BMesh *bm, void *element, int flag);
92 void BMO_ClearFlag(struct BMesh *bm, void *element, int flag);
93 int BMO_TestFlag(struct BMesh *bm, void *element, int flag);
94 int BMO_CountFlag(struct BMesh *bm, int flag, int type);
95
96 /*---------formatted operator initialization/execution-----------*/
97 /*
98   this system is used to execute or initialize an operator,
99   using a formatted-string system.
100
101   for example, BMO_CallOpf(bm, "del geom=%hf context=%d", BM_SELECT, DEL_FACES);
102   . . .will execute the delete operator, feeding in selected faces, deleting them.
103
104   the basic format for the format string is:
105     [operatorname] [slotname]=%[code] [slotname]=%[code]
106   
107   as in printf, you pass in one additional argument to the function
108   for every code.
109
110   the formatting codes are:
111      %d - put int in slot
112      %f - put float in float
113      %h[f/e/v] - put elements with a header flag in slot.
114           the letters after %h define which element types to use,
115           so e.g. %hf will do faces, %hfe will do faces and edges,
116           %hv will do verts, etc.  must pass in at least one
117           element type letter.
118      %f[f/e/v] - same as %h.
119 */
120 /*executes an operator*/
121 int BMO_CallOpf(BMesh *bm, char *fmt, ...);
122
123 /*initializes, but doesn't execute an operator*/
124 int BMO_InitOpf(BMesh *bm, BMOperator *op, char *fmt, ...);
125
126 /*va_list version, used to implement the above two functions,
127    plus EDBM_CallOpf in bmeshutils.c.*/
128 int BMO_VInitOpf(BMesh *bm, BMOperator *op, char *fmt, va_list vlist);
129 /*------end of formatted op system -------*/
130
131 BMOpSlot *BMO_GetSlot(struct BMOperator *op, int slotcode);
132 void BMO_CopySlot(struct BMOperator *source_op, struct BMOperator *dest_op, int src, int dst);
133
134 void BMO_Set_Float(struct BMOperator *op, int slotcode, float f);
135 void BMO_Set_Int(struct BMOperator *op, int slotcode, int i);
136 /*don't pass in arrays that are supposed to map to elements this way.
137   
138   so, e.g. passing in list of floats per element in another slot is bad.
139   passing in, e.g. pointer to an editmesh for the conversion operator is fine
140   though.*/
141 void BMO_Set_Pnt(struct BMOperator *op, int slotcode, void *p);
142 void BMO_Set_Vec(struct BMOperator *op, int slotcode, float *vec);
143
144 /*puts every element of type type (which is a bitmask) with tool flag flag,
145   into a slot.*/
146 void BMO_Flag_To_Slot(struct BMesh *bm, struct BMOperator *op, int slotcode, int flag, int type);
147 void BMO_Flag_Buffer(struct BMesh *bm, struct BMOperator *op, int slotcode, int flag);
148 void BMO_Unflag_Buffer(struct BMesh *bm, struct BMOperator *op, int slotcode, int flag);
149
150 /*puts every element of type type (which is a bitmask) with header flag 
151   flag, into a slot.*/
152 void BMO_HeaderFlag_To_Slot(struct BMesh *bm, struct BMOperator *op, int slotcode, int flag, int type);
153 int BMO_CountSlotBuf(struct BMesh *bm, struct BMOperator *op, int slotcode);
154
155 /*copies data, doesn't store a reference to it.*/
156 void BMO_Insert_Mapping(BMesh *bm, BMOperator *op, int slotcode, 
157                         void *element, void *data, int len);
158 void BMO_Insert_MapFloat(BMesh *bm, BMOperator *op, int slotcode, 
159                         void *element, float val);
160 //returns 1 if the specified element is in the map.
161 int BMO_InMap(BMesh *bm, BMOperator *op, int slotcode, void *element);
162 void *BMO_Get_MapData(BMesh *bm, BMOperator *op, int slotcode, void *element);
163 float BMO_Get_MapFloat(BMesh *bm, BMOperator *op, int slotcode, void *element);
164 void BMO_Mapping_To_Flag(struct BMesh *bm, struct BMOperator *op, 
165                          int slotcode, int flag);
166
167 /*do NOT use these for non-operator-api-allocated memory! instead
168   use BMO_Get_MapData and BMO_Insert_Mapping, which copies the data.*/
169 void BMO_Insert_MapPointer(BMesh *bm, BMOperator *op, int slotcode, 
170                         void *element, void *val);
171 void *BMO_Get_MapPointer(BMesh *bm, BMOperator *op, int slotcode,
172                        void *element);
173
174 /*contents of this structure are private,
175   don't directly access.*/
176 typedef struct BMOIter {
177         BMOpSlot *slot;
178         int cur; //for arrays
179         struct GHashIterator giter;
180         void *val;
181 } BMOIter;
182
183 /*this part of the API is used to iterate over element buffer or
184   mapping slots.
185   
186   for example, iterating over the faces in a slot is:
187
188           BMOIter oiter;
189           BMFace *f;
190
191           f = BMO_IterNew(&oiter, bm, some_operator, SOME_SLOT_CODE);
192           for (; f; f=BMO_IterStep) {
193                 /do something with the face
194           }
195
196   another example, iterating over a mapping:
197           BMOIter oiter;
198           void *key;
199           void *val;
200
201           key = BMO_IterNew(&oiter, bm, some_operator, SOME_SLOT_CODE);
202           for (; key; key=BMO_IterStep) {
203                 val = BMO_IterMapVal(&oiter);
204                 //do something with the key/val pair
205           }
206
207   */
208
209 void *BMO_IterNew(BMOIter *iter, BMesh *bm, BMOperator *op, 
210                   int slotcode);
211 void *BMO_IterStep(BMOIter *iter);
212
213 /*returns a pointer to the key value when iterating over mappings.
214   remember for pointer maps this will be a pointer to a pointer.*/
215 void *BMO_IterMapVal(BMOIter *iter);
216
217 #endif /* _BMESH_OPERATOR_H */