957a97b61faec3707a8e8fe4ad3497588627df6b
[blender.git] / source / blender / bmesh / intern / bmesh_opdefines.c
1 #include "bmesh.h"
2 #include "bmesh_private.h"
3 #include <stdio.h>
4
5 /*
6 This file defines (and documents) all bmesh operators (bmops).
7
8 Do not rename any operator or slot names! otherwise you must go 
9 through the code and find all references to them!
10
11 A word on slot names:
12
13 For geometry input slots, the following are valid names:
14 * verts
15 * edges
16 * faces
17 * edgefacein
18 * vertfacein
19 * vertedgein
20 * vertfacein
21 * geom
22
23 The basic rules are, for single-type geometry slots, use the plural of the
24 type name (e.g. edges).  for double-type slots, use the two type names plus
25 "in" (e.g. edgefacein).  for three-type slots, use geom.
26
27 for output slots, for single-type geometry slots, use the type name plus "out",
28 (e.g. vertout), for double-type slots, use the two type names plus "out",
29 (e.g. vertfaceout), for three-type slots, use geom.  note that you can also
30 use more esohteric names (e.g. skirtout) do long as the comment next to the
31 slot definition tells you what types of elements are in it.
32
33 */
34
35 /*
36 ok, I'm going to write a little docgen script. so all
37 bmop comments must conform to the following template/rules:
38
39 template (py quotes used because nested comments don't work
40 on all C compilers):
41
42 """
43 Region Extend.
44
45 paragraph1, Extends bleh bleh bleh.
46 Bleh Bleh bleh.
47
48 Another paragraph.
49
50 Another paragraph.
51 """
52
53 so the first line is the "title" of the bmop.
54 subsequent line blocks seperated by blank lines
55 are paragraphs.  individual descriptions of slots 
56 would be extracted from comments
57 next to them, e.g.
58
59 {BMOP_OPSLOT_ELEMENT_BUF, "geomout"}, //output slot, boundary region
60
61 the doc generator would automatically detect the presence of "output slot"
62 and flag the slot as an output.  the same happens for "input slot".  also
63 note that "edges", "faces", "verts", "loops", and "geometry" are valid 
64 substitutions for "slot". 
65
66 note that slots default to being input slots.
67 */
68
69 /*
70   Vertex Smooth
71
72   Smoothes vertices by using a basic vertex averaging scheme.
73 */
74 BMOpDefine def_vertexsmooth = {
75         "vertexsmooth",
76         {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input vertices
77          {BMOP_OPSLOT_INT, "mirror_clip_x"}, //set vertices close to the x axis before the operation to 0
78          {BMOP_OPSLOT_INT, "mirror_clip_y"}, //set vertices close to the y axis before the operation to 0
79          {BMOP_OPSLOT_INT, "mirror_clip_z"}, //set vertices close to the z axis before the operation to 0
80          {BMOP_OPSLOT_FLT, "clipdist"}, //clipping threshod for the above three slots
81         {0} /*null-terminating sentinel*/,
82         },
83         bmesh_vertexsmooth_exec,
84         0
85 };
86
87 /*
88   Right-Hand Faces
89
90   Computes an "outside" normal for the specified input faces.
91 */
92
93 BMOpDefine def_righthandfaces = {
94         "righthandfaces",
95         {{BMOP_OPSLOT_ELEMENT_BUF, "faces"},
96         {0} /*null-terminating sentinel*/,
97         },
98         bmesh_righthandfaces_exec,
99         0
100 };
101
102 /*
103   Region Extend
104   
105   used to implement the select more/less tools.
106   this puts some geometry surrounding regions of
107   geometry in geom into geomout.
108   
109   if usefaces is 0 then geomout spits out verts and edges, 
110   otherwise it spits out faces.
111   */
112 BMOpDefine def_regionextend = {
113         "regionextend",
114         {{BMOP_OPSLOT_ELEMENT_BUF, "geom"}, //input geometry
115          {BMOP_OPSLOT_ELEMENT_BUF, "geomout"}, //output slot, computed boundary geometry.
116          {BMOP_OPSLOT_INT, "constrict"}, //find boundary inside the regions, not outside.
117          {BMOP_OPSLOT_INT, "usefaces"}, //extend from faces instead of edges
118         {0} /*null-terminating sentinel*/,
119         },
120         bmesh_regionextend_exec,
121         0
122 };
123
124 /*
125   Edge Rotate
126
127   Rotates edges topologically.  Also known as "spin edge" to some people.
128   Simple example: [/] becomes [|] then [\].
129 */
130 BMOpDefine def_edgerotate = {
131         "edgerotate",
132         {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, //input edges
133          {BMOP_OPSLOT_ELEMENT_BUF, "edgeout"}, //newly spun edges
134          {BMOP_OPSLOT_INT, "ccw"}, //rotate edge counter-clockwise if true, othewise clockwise
135         {0} /*null-terminating sentinel*/,
136         },
137         bmesh_edgerotate_exec,
138         0
139 };
140
141 /*
142   Reverse Faces
143
144   Reverses the winding (vertex order) of faces.  This has the effect of
145   flipping the normal.
146 */
147 BMOpDefine def_reversefaces = {
148         "reversefaces",
149         {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, //input faces
150         {0} /*null-terminating sentinel*/,
151         },
152         bmesh_reversefaces_exec,
153         0
154 };
155
156 /*
157   Edge Bisect
158
159   Splits input edges (but doesn't do anything else).
160   This creates a 2-valence vert.
161 */
162 BMOpDefine def_edgebisect = {
163         "edgebisect",
164         {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, //input edges
165         {BMOP_OPSLOT_INT, "numcuts"}, //number of cuts
166         {BMOP_OPSLOT_ELEMENT_BUF, "outsplit"}, //newly created vertices and edges
167         {0} /*null-terminating sentinel*/,
168         },
169         esplit_exec,
170         0
171 };
172
173 /*
174   Mirror
175
176   Mirrors geometry along an axis.  The resulting geometry is welded on using
177   mergedist.  Pairs of original/mirrored vertices are welded using the mergedist
178   parameter (which defines the minimum distance for welding to happen).
179 */
180
181 BMOpDefine def_mirror = {
182         "mirror",
183         {{BMOP_OPSLOT_ELEMENT_BUF, "geom"}, //input geometry
184          {BMOP_OPSLOT_MAT, "mat"}, //matrix defining the mirror transformation
185          {BMOP_OPSLOT_FLT, "mergedist"}, //maximum distance for merging.  does no merging if 0.
186          {BMOP_OPSLOT_ELEMENT_BUF, "newout"}, //output geometry, mirrored
187          {BMOP_OPSLOT_INT,         "axis"}, //the axis to use, 0, 1, or 2 for x, y, z
188          {BMOP_OPSLOT_INT,         "mirror_u"}, //mirror UVs across the u axis
189          {BMOP_OPSLOT_INT,         "mirror_v"}, //mirror UVs across the v axis
190          {0, /*null-terminating sentinel*/}},
191         bmesh_mirror_exec,
192         0,
193 };
194
195 /*
196   Find Doubles
197
198   Takes input verts and find vertices they should weld to.  Outputs a
199   mapping slot suitable for use with the weld verts bmop.
200 */
201 BMOpDefine def_finddoubles = {
202         "finddoubles",
203         {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input vertices
204          {BMOP_OPSLOT_ELEMENT_BUF, "keepverts"}, //list of verts to keep
205          {BMOP_OPSLOT_FLT,         "dist"}, //minimum distance
206          {BMOP_OPSLOT_MAPPING, "targetmapout"},
207          {0, /*null-terminating sentinel*/}},
208         bmesh_finddoubles_exec,
209         0,
210 };
211
212 /*
213   Remove Doubles
214
215   Finds groups of vertices closer then dist and merges them together,
216   using the weld verts bmop.
217 */
218 BMOpDefine def_removedoubles = {
219         "removedoubles",
220         {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input verts
221          {BMOP_OPSLOT_FLT,         "dist"}, //minimum distance
222          {0, /*null-terminating sentinel*/}},
223         bmesh_removedoubles_exec,
224         0,
225 };
226
227 /*
228   Auto Merge
229
230   Finds groups of vertices closer then dist and merges them together,
231   using the weld verts bmop.  The merges must go from a vert not in
232   verts to one in verts.
233 */
234 BMOpDefine def_automerge = {
235         "automerge",
236         {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input verts
237          {BMOP_OPSLOT_FLT,         "dist"}, //minimum distance
238          {0, /*null-terminating sentinel*/}},
239         bmesh_automerge_exec,
240         0,
241 };
242
243 /*
244   Collapse Connected
245
246   Collapses connected vertices
247 */
248 BMOpDefine def_collapse = {
249         "collapse",
250         {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, /*input edges*/
251          {0, /*null-terminating sentinel*/}},
252         bmesh_collapse_exec,
253         0,
254 };
255
256
257 /*
258   Facedata point Merge
259
260   Merge uv/vcols at a specific vertex.
261 */
262 BMOpDefine def_pointmerge_facedata = {
263         "pointmerge_facedata",
264         {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, /*input vertices*/
265          {BMOP_OPSLOT_ELEMENT_BUF, "snapv"}, /*snap vertex*/
266          {0, /*null-terminating sentinel*/}},
267         bmesh_pointmerge_facedata_exec,
268         0,
269 };
270
271 /*
272   Average Vertices Facevert Data
273
274   Merge uv/vcols associated with the input vertices at
275   the bounding box center. (I know, it's not averaging but
276   the vert_snap_to_bb_center is just too long).
277 */
278 BMOpDefine def_vert_average_facedata = {
279         "vert_average_facedata",
280         {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, /*input vertices*/
281          {0, /*null-terminating sentinel*/}},
282         bmesh_vert_average_facedata_exec,
283         0,
284 };
285
286 /*
287   Point Merge
288
289   Merge verts together at a point.
290 */
291 BMOpDefine def_pointmerge = {
292         "pointmerge",
293         {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, /*input vertices*/
294          {BMOP_OPSLOT_VEC,         "mergeco"},
295          {0, /*null-terminating sentinel*/}},
296         bmesh_pointmerge_exec,
297         0,
298 };
299
300 /*
301   Collapse Connected UVs
302
303   Collapses connected UV vertices.
304 */
305 BMOpDefine def_collapse_uvs = {
306         "collapse_uvs",
307         {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, /*input edges*/
308          {0, /*null-terminating sentinel*/}},
309         bmesh_collapsecon_exec,
310         0,
311 };
312
313 /*
314   Weld Verts
315
316   Welds verts together (kindof like remove doubles, merge, etc, all of which
317   use or will use this bmop).  You pass in mappings from vertices to the vertices
318   they weld with.
319 */
320 BMOpDefine def_weldverts = {
321         "weldverts",
322         {{BMOP_OPSLOT_MAPPING, "targetmap"}, /*maps welded vertices to verts they should weld to.*/
323          {0, /*null-terminating sentinel*/}},
324         bmesh_weldverts_exec,
325         0,
326 };
327
328 /*
329   Make Vertex
330
331   Creates a single vertex; this bmop was necassary
332   for click-create-vertex.
333 */
334 BMOpDefine def_makevert = {
335         "makevert",
336         {{BMOP_OPSLOT_VEC, "co"}, //the coordinate of the new vert
337         {BMOP_OPSLOT_ELEMENT_BUF, "newvertout"}, //the new vert
338         {0, /*null-terminating sentinel*/}},
339         bmesh_makevert_exec,
340         0,
341 };
342
343 /*
344   Join Triangles
345
346   Tries to intelligently join triangles according 
347   to various settings and stuff.
348
349   */
350 BMOpDefine def_join_triangles= {
351         "join_triangles",
352         {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, //input geometry.
353          {BMOP_OPSLOT_ELEMENT_BUF, "faceout"}, //joined faces
354          {BMOP_OPSLOT_INT, "compare_sharp"},
355          {BMOP_OPSLOT_INT, "compare_uvs"},
356          {BMOP_OPSLOT_INT, "compare_vcols"},
357          {BMOP_OPSLOT_INT, "compare_materials"},
358          {BMOP_OPSLOT_FLT, "limit"},
359          {0, /*null-terminating sentinel*/}},
360         bmesh_jointriangles_exec,
361         0,
362 };
363
364 /*
365   Contextual Create
366
367   This is basically fkey, it creates
368   new faces from vertices, makes stuff from edge nets,
369   makes wire edges, etc.  It also dissolves
370   faces.
371   
372   Three verts become a triangle, four become a quad.  Two
373   become a wire edge.
374   */
375 BMOpDefine def_contextual_create= {
376         "contextual_create",
377         {{BMOP_OPSLOT_ELEMENT_BUF, "geom"}, //input geometry.
378          {BMOP_OPSLOT_ELEMENT_BUF, "faceout"}, //newly-made face(s)
379          {0, /*null-terminating sentinel*/}},
380         bmesh_contextual_create_exec,
381         0,
382 };
383
384 BMOpDefine def_edgenet_fill= {
385         "edgenet_fill",
386         {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, /*input edges*/
387          {BMOP_OPSLOT_MAPPING,     "restrict"}, /*restricts edges to groups.  maps edges to integers*/
388          {BMOP_OPSLOT_INT,         "use_restrict"},
389          {BMOP_OPSLOT_ELEMENT_BUF, "excludefaces"}, /*list of faces to ignore for manifold checks*/
390          {BMOP_OPSLOT_MAPPING,     "faceout_groupmap"}, /*maps new faces to the group numbers they came from*/
391          {BMOP_OPSLOT_ELEMENT_BUF, "faceout"}, /*new faces*/
392         {0, /*null-terminating sentinel*/}},
393         bmesh_edgenet_fill_exec,
394         0,
395 };
396
397 /*
398   Edgenet Prepare
399
400   Identifies several useful edge loop cases and modifies them so
401   they'll become a face when edgenet_fill is called.  The cases covered are:
402
403   * One single loop; an edge is added to connect the ends
404   * Two loops; two edges are added to connect the endpoints (based on the
405     shortest distance between each endpont).
406 */
407 BMOpDefine def_edgenet_prepare= {
408         "edgenet_prepare",
409         {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, //input edges
410          {BMOP_OPSLOT_ELEMENT_BUF, "edgeout"}, //new edges
411         {0, /*null-terminating sentinel*/}},
412         bmesh_edgenet_prepare,
413         0,
414 };
415
416 /*
417   Rotate
418
419   Rotate vertices around a center, using a 3x3 rotation
420   matrix.  Equivilent of the old rotateflag function.
421 */
422 BMOpDefine def_rotate = {
423         "rotate",
424         {{BMOP_OPSLOT_VEC, "cent"}, //center of rotation
425          {BMOP_OPSLOT_MAT, "mat"}, //matrix defining rotation
426         {BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input vertices
427         {0, /*null-terminating sentinel*/}},
428         bmesh_rotate_exec,
429         0,
430 };
431
432 /*
433   Translate
434
435   Translate vertices by an offset.  Equivelent of the
436   old translateflag function.
437 */
438 BMOpDefine def_translate= {
439         "translate",
440         {{BMOP_OPSLOT_VEC, "vec"}, //translation offset
441         {BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input vertices
442         {0, /*null-terminating sentinel*/}},
443         bmesh_translate_exec,
444         0,
445 };
446
447 /*
448   Scale
449
450   Scales vertices by an offset.
451 */
452 BMOpDefine def_scale= {
453         "scale",
454         {{BMOP_OPSLOT_VEC, "vec"}, //scale factor
455         {BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input vertices
456         {0, /*null-terminating sentinel*/}},
457         bmesh_scale_exec,
458         0,
459 };
460
461
462 /*
463   Transform
464
465   Transforms a set of vertices by a matrix.  Multiplies
466   the vertex coordinates with the matrix.
467 */
468 BMOpDefine def_transform = {
469         "transform",
470         {{BMOP_OPSLOT_MAT, "mat"}, //transform matrix
471         {BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input vertices
472         {0, /*null-terminating sentinel*/}},
473         bmesh_transform_exec,
474         0,
475 };
476
477 /*
478   Object Load BMesh
479
480   Loads a bmesh into an object/mesh.  This is a "private"
481   bmop.
482 */
483 BMOpDefine def_object_load_bmesh = {
484         "object_load_bmesh",
485         {{BMOP_OPSLOT_PNT, "scene"},
486         {BMOP_OPSLOT_PNT, "object"},
487         {0, /*null-terminating sentinel*/}},
488         object_load_bmesh_exec,
489         0,
490 };
491
492
493 /*
494   BMesh to Mesh
495
496   Converts a bmesh to a Mesh.  This is reserved for exiting editmode.
497 */
498 BMOpDefine def_bmesh_to_mesh = {
499         "bmesh_to_mesh",
500         {{BMOP_OPSLOT_PNT, "mesh"}, //pointer to a mesh structure to fill in
501          {BMOP_OPSLOT_PNT, "object"}, //pointer to an object structure
502          {BMOP_OPSLOT_INT, "notesselation"}, //don't calculate mfaces
503          {0, /*null-terminating sentinel*/}},
504         bmesh_to_mesh_exec,
505         0,
506 };
507
508 /*
509   Mesh to BMesh
510
511   Load the contents of a mesh into the bmesh.  this bmop is private, it's
512   reserved exclusively for entering editmode.
513 */
514 BMOpDefine def_mesh_to_bmesh = {
515         "mesh_to_bmesh",
516         {{BMOP_OPSLOT_PNT, "mesh"}, //pointer to a Mesh structure
517          {BMOP_OPSLOT_PNT, "object"}, //pointer to an Object structure
518          {0, /*null-terminating sentinel*/}},
519         mesh_to_bmesh_exec,
520         0
521 };
522
523 /*
524   Individual Face Extrude
525
526   Extrudes faces individually.
527 */
528 BMOpDefine def_extrude_indivface = {
529         "extrude_face_indiv",
530         {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, //input faces
531         {BMOP_OPSLOT_ELEMENT_BUF, "faceout"}, //output faces
532         {BMOP_OPSLOT_ELEMENT_BUF, "skirtout"}, //output skirt geometry, faces and edges
533         {0} /*null-terminating sentinel*/},
534         bmesh_extrude_face_indiv_exec,
535         0
536 };
537
538 /*
539   Extrude Only Edges
540
541   Extrudes Edges into faces, note that this is very simple, there's no fancy
542   winged extrusion.
543 */
544 BMOpDefine def_extrude_onlyedge = {
545         "extrude_edge_only",
546         {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, //input vertices
547         {BMOP_OPSLOT_ELEMENT_BUF, "geomout"}, //output geometry
548         {0} /*null-terminating sentinel*/},
549         bmesh_extrude_onlyedge_exec,
550         0
551 };
552
553 /*
554   Individual Vertex Extrude
555
556   Extrudes wire edges from vertices.
557 */
558 BMOpDefine def_extrudeverts_indiv = {
559         "extrude_vert_indiv",
560         {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, //input vertices
561         {BMOP_OPSLOT_ELEMENT_BUF, "edgeout"}, //output wire edges
562         {BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, //output vertices
563         {0} /*null-terminating sentinel*/},
564         extrude_vert_indiv_exec,
565         0
566 };
567
568 #if 0
569 BMOpDefine def_makeprim = {
570         "makeprim",
571         {{BMOP_OPSLOT_INT, "type"},
572         {BMOP_OPSLOT_INT, "tot", /*rows/cols also applies to spheres*/
573         {BMOP_OPSLOT_INT, "seg",
574         {BMOP_OPSLOT_INT, "subdiv"},
575         {BMOP_OPSLOT_INT, "ext"},
576         {BMOP_OPSLOT_INT, "fill"},
577         {BMOP_OPSLOT_FLT, "dia"},
578         {BMOP_OPSLOT_FLT, "depth"},
579         {BMOP_OPSLOT_PNT, "mat"},
580         {BMOP_OPSLOT_ELEMENT_BUF, "geomout"}, //won't be implemented right away
581         {0}}
582         makeprim_exec,
583         0
584 };
585 #endif
586
587 BMOpDefine def_connectverts = {
588         "connectverts",
589         {{BMOP_OPSLOT_ELEMENT_BUF, "verts"},
590         {BMOP_OPSLOT_ELEMENT_BUF, "edgeout"},
591         {0} /*null-terminating sentinel*/},
592         connectverts_exec,
593         0
594 };
595
596 BMOpDefine def_extrudefaceregion = {
597         "extrudefaceregion",
598         {{BMOP_OPSLOT_ELEMENT_BUF, "edgefacein"},
599         {BMOP_OPSLOT_MAPPING, "exclude"},
600         {BMOP_OPSLOT_ELEMENT_BUF, "geomout"},
601         {0} /*null-terminating sentinel*/},
602         extrude_edge_context_exec,
603         0
604 };
605
606 BMOpDefine def_dissolvevertsop = {
607         "dissolveverts",
608         {{BMOP_OPSLOT_ELEMENT_BUF, "verts"},
609         {0} /*null-terminating sentinel*/},
610         dissolveverts_exec,
611         0
612 };
613
614 BMOpDefine def_dissolveedgessop = {
615         "dissolveedges",
616         {{BMOP_OPSLOT_ELEMENT_BUF, "edges"},
617         {BMOP_OPSLOT_ELEMENT_BUF, "regionout"},
618         {0} /*null-terminating sentinel*/},
619         dissolveedges_exec,
620         0
621 };
622
623 BMOpDefine def_dissolveedgeloopsop = {
624         "dissolveedgeloop",
625         {{BMOP_OPSLOT_ELEMENT_BUF, "edges"},
626         {BMOP_OPSLOT_ELEMENT_BUF, "regionout"},
627         {0} /*null-terminating sentinel*/},
628         dissolve_edgeloop_exec,
629         0
630 };
631
632 BMOpDefine def_dissolvefacesop = {
633         "dissolvefaces",
634         {{BMOP_OPSLOT_ELEMENT_BUF, "faces"},
635         {BMOP_OPSLOT_ELEMENT_BUF, "regionout"},
636         {0} /*null-terminating sentinel*/},
637         dissolvefaces_exec,
638         0
639 };
640
641
642 BMOpDefine def_triangop = {
643         "triangulate",
644         {{BMOP_OPSLOT_ELEMENT_BUF, "faces"},
645         {BMOP_OPSLOT_ELEMENT_BUF, "edgeout"},
646         {BMOP_OPSLOT_ELEMENT_BUF, "faceout"},
647         {BMOP_OPSLOT_MAPPING, "facemap"},
648         {0} /*null-terminating sentinel*/},
649         triangulate_exec,
650         0
651 };
652
653 BMOpDefine def_subdop = {
654         "esubd",
655         {{BMOP_OPSLOT_ELEMENT_BUF, "edges"},
656         {BMOP_OPSLOT_INT, "numcuts"},
657         {BMOP_OPSLOT_FLT, "smooth"},
658         {BMOP_OPSLOT_FLT, "fractal"},
659         {BMOP_OPSLOT_INT, "beauty"},
660         {BMOP_OPSLOT_MAPPING, "custompatterns"},
661         {BMOP_OPSLOT_MAPPING, "edgepercents"},
662         
663         /*these next three can have multiple types of elements in them.*/
664         {BMOP_OPSLOT_ELEMENT_BUF, "outinner"},
665         {BMOP_OPSLOT_ELEMENT_BUF, "outsplit"},
666         {BMOP_OPSLOT_ELEMENT_BUF, "geomout"}, /*contains all output geometry*/
667
668         {BMOP_OPSLOT_INT, "quadcornertype"}, //quad corner type, see bmesh_operators.h
669         {BMOP_OPSLOT_INT, "gridfill"}, //fill in fully-selected faces with a grid
670         {BMOP_OPSLOT_INT, "singleedge"}, //tesselate the case of one edge selected in a quad or triangle
671
672         {0} /*null-terminating sentinel*/,
673         },
674         esubdivide_exec,
675         0
676 };
677
678 BMOpDefine def_delop = {
679         "del",
680         {{BMOP_OPSLOT_ELEMENT_BUF, "geom"}, {BMOP_OPSLOT_INT, "context"},
681         {0} /*null-terminating sentinel*/},
682         delop_exec,
683         0
684 };
685
686 BMOpDefine def_dupeop = {
687         "dupe",
688         {{BMOP_OPSLOT_ELEMENT_BUF, "geom"},
689         {BMOP_OPSLOT_ELEMENT_BUF, "origout"},
690         {BMOP_OPSLOT_ELEMENT_BUF, "newout"},
691         /*facemap maps from source faces to dupe
692           faces, and from dupe faces to source faces.*/
693         {BMOP_OPSLOT_MAPPING, "facemap"},
694         {BMOP_OPSLOT_MAPPING, "boundarymap"},
695         {BMOP_OPSLOT_MAPPING, "isovertmap"},
696         {BMOP_OPSLOT_PNT, "dest"}, /*destination bmesh, if NULL will use current one*/
697         {0} /*null-terminating sentinel*/},
698         dupeop_exec,
699         0
700 };
701
702 BMOpDefine def_splitop = {
703         "split",
704         {{BMOP_OPSLOT_ELEMENT_BUF, "geom"},
705         {BMOP_OPSLOT_ELEMENT_BUF, "geomout"},
706         {BMOP_OPSLOT_MAPPING, "boundarymap"},
707         {BMOP_OPSLOT_MAPPING, "isovertmap"},
708         {BMOP_OPSLOT_PNT, "dest"}, /*destination bmesh, if NULL will use current one*/
709         {0} /*null-terminating sentinel*/},
710         splitop_exec,
711         0
712 };
713
714 /*
715   Similar faces search
716
717   Find similar faces (area/material/perimeter....).
718 */
719 BMOpDefine def_similarfaces = {
720         "similarfaces",
721         {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, /* input faces */
722          {BMOP_OPSLOT_ELEMENT_BUF, "faceout"}, /* output faces */
723          {BMOP_OPSLOT_INT, "type"},                     /* type of selection */
724          {BMOP_OPSLOT_FLT, "thresh"},           /* threshold of selection */
725          {0} /*null-terminating sentinel*/},
726         bmesh_similarfaces_exec,
727         0
728 };
729
730 /*
731   Similar edges search
732
733   Find similar edges (length, direction, edge, seam,....).
734 */
735 BMOpDefine def_similaredges = {
736         "similaredges",
737         {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, /* input edges */
738          {BMOP_OPSLOT_ELEMENT_BUF, "edgeout"}, /* output edges */
739          {BMOP_OPSLOT_INT, "type"},                     /* type of selection */
740          {BMOP_OPSLOT_FLT, "thresh"},           /* threshold of selection */
741          {0} /*null-terminating sentinel*/},
742         bmesh_similaredges_exec,
743         0
744 };
745
746 /*
747   Similar vertices search
748
749   Find similar vertices (normal, face, vertex group,....).
750 */
751 BMOpDefine def_similarverts = {
752         "similarverts",
753         {{BMOP_OPSLOT_ELEMENT_BUF, "verts"}, /* input vertices */
754          {BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, /* output vertices */
755          {BMOP_OPSLOT_INT, "type"},                     /* type of selection */
756          {BMOP_OPSLOT_FLT, "thresh"},           /* threshold of selection */
757          {0} /*null-terminating sentinel*/},
758         bmesh_similarverts_exec,
759         0
760 };
761
762 /*
763 ** uv rotation
764 ** cycle the uvs
765 */
766 BMOpDefine def_meshrotateuvs = {
767         "meshrotateuvs",
768         {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, /* input faces */
769          {BMOP_OPSLOT_INT, "dir"},                      /* direction */
770          {0} /*null-terminating sentinel*/},
771         bmesh_rotateuvs_exec,
772         0
773 };
774
775 /*
776 ** uv reverse
777 ** reverse the uvs
778 */
779 BMOpDefine def_meshreverseuvs = {
780         "meshreverseuvs",
781         {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, /* input faces */
782          {0} /*null-terminating sentinel*/},
783         bmesh_reverseuvs_exec,
784         0
785 };
786
787 /*
788 ** color rotation
789 ** cycle the colors
790 */
791 BMOpDefine def_meshrotatecolors = {
792         "meshrotatecolors",
793         {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, /* input faces */
794          {BMOP_OPSLOT_INT, "dir"},                      /* direction */
795          {0} /*null-terminating sentinel*/},
796         bmesh_rotatecolors_exec,
797         0
798 };
799
800 /*
801 ** color reverse
802 ** reverse the colors
803 */
804 BMOpDefine def_meshreversecolors = {
805         "meshreversecolors",
806         {{BMOP_OPSLOT_ELEMENT_BUF, "faces"}, /* input faces */
807          {0} /*null-terminating sentinel*/},
808         bmesh_reversecolors_exec,
809         0
810 };
811
812 /*
813   Similar vertices search
814
815   Find similar vertices (normal, face, vertex group,....).
816 */
817 BMOpDefine def_vertexshortestpath = {
818         "vertexshortestpath",
819         {{BMOP_OPSLOT_ELEMENT_BUF, "startv"}, /* start vertex */
820          {BMOP_OPSLOT_ELEMENT_BUF, "endv"}, /* end vertex */
821          {BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, /* output vertices */
822          {BMOP_OPSLOT_INT, "type"},                     /* type of selection */
823          {0} /*null-terminating sentinel*/},
824         bmesh_vertexshortestpath_exec,
825         0
826 };
827
828 /*
829   Edge Split
830
831   Disconnects faces along input edges.
832  */
833 BMOpDefine def_edgesplit = {
834         "edgesplit",
835         {{BMOP_OPSLOT_ELEMENT_BUF, "edges"}, /* input edges */
836          {BMOP_OPSLOT_ELEMENT_BUF, "edgeout1"}, /* old output disconnected edges */
837          {BMOP_OPSLOT_ELEMENT_BUF, "edgeout2"}, /* new output disconnected edges */
838          {0} /*null-terminating sentinel*/},
839         bmesh_edgesplitop_exec,
840         0
841 };
842
843 /*
844   Create Grid
845
846   Creates a grid with a variable number of subdivisions
847 */
848 BMOpDefine def_create_grid = {
849         "create_grid",
850         {{BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, //output verts
851          {BMOP_OPSLOT_INT,         "xsegments"}, //number of x segments
852          {BMOP_OPSLOT_INT,         "ysegments"}, //number of y segments
853          {BMOP_OPSLOT_FLT,         "size"}, //size of the grid
854          {BMOP_OPSLOT_MAT,         "mat"}, //matrix to multiply the new geometry with
855          {0, /*null-terminating sentinel*/}},
856         bmesh_create_grid_exec,
857         0,
858 };
859
860 /*
861   Create UV Sphere
862
863   Creates a grid with a variable number of subdivisions
864 */
865 BMOpDefine def_create_uvsphere = {
866         "create_uvsphere",
867         {{BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, //output verts
868          {BMOP_OPSLOT_INT,         "segments"}, //number of u segments
869          {BMOP_OPSLOT_INT,         "revolutions"}, //number of v segment
870          {BMOP_OPSLOT_FLT,         "diameter"}, //diameter
871          {BMOP_OPSLOT_MAT,         "mat"}, //matrix to multiply the new geometry with--
872          {0, /*null-terminating sentinel*/}},
873         bmesh_create_uvsphere_exec,
874         0,
875 };
876
877 /*
878   Create Ico Sphere
879
880   Creates a grid with a variable number of subdivisions
881 */
882 BMOpDefine def_create_icosphere = {
883         "create_icosphere",
884         {{BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, //output verts
885          {BMOP_OPSLOT_INT,         "subdivisions"}, //how many times to recursively subdivide the sphere
886          {BMOP_OPSLOT_FLT,       "diameter"}, //diameter
887          {BMOP_OPSLOT_MAT, "mat"}, //matrix to multiply the new geometry with
888          {0, /*null-terminating sentinel*/}},
889         bmesh_create_icosphere_exec,
890         0,
891 };
892
893 /*
894   Create Suzanne
895
896   Creates a monkey.  Be wary.
897 */
898 BMOpDefine def_create_monkey = {
899         "create_monkey",
900         {{BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, //output verts
901          {BMOP_OPSLOT_MAT, "mat"}, //matrix to multiply the new geometry with--
902          {0, /*null-terminating sentinel*/}},
903         bmesh_create_monkey_exec,
904         0,
905 };
906
907 /*
908   Create Cone
909
910   Creates a cone with variable depth at both ends
911 */
912 BMOpDefine def_create_cone = {
913         "create_cone",
914         {{BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, //output verts
915          {BMOP_OPSLOT_INT, "cap_ends"}, //wheter or not to fill in the ends with faces
916          {BMOP_OPSLOT_INT, "segments"},
917          {BMOP_OPSLOT_FLT, "diameter1"}, //diameter of one end
918          {BMOP_OPSLOT_FLT, "diameter2"}, //diameter of the opposite
919          {BMOP_OPSLOT_FLT, "depth"}, //distance between ends
920          {BMOP_OPSLOT_MAT, "mat"}, //matrix to multiply the new geometry with--
921          {0, /*null-terminating sentinel*/}},
922         bmesh_create_cone_exec,
923         0,
924 };
925
926 /*
927   Create Cone
928
929   Creates a cone with variable depth at both ends
930 */
931 BMOpDefine def_create_cube = {
932         "create_cube",
933         {{BMOP_OPSLOT_ELEMENT_BUF, "vertout"}, //output verts
934          {BMOP_OPSLOT_FLT, "size"}, //size of the cube
935          {BMOP_OPSLOT_MAT, "mat"}, //matrix to multiply the new geometry with--
936          {0, /*null-terminating sentinel*/}},
937         bmesh_create_cube_exec,
938         0,
939 };
940
941 BMOpDefine *opdefines[] = {
942         &def_splitop,
943         &def_dupeop,
944         &def_delop,
945         &def_subdop,
946         &def_triangop,
947         &def_dissolvefacesop,
948         &def_dissolveedgessop,
949         &def_dissolveedgeloopsop,
950         &def_dissolvevertsop,
951         &def_extrudefaceregion,
952         &def_connectverts,
953         //&def_makeprim,
954         &def_extrudeverts_indiv,
955         &def_mesh_to_bmesh,
956         &def_object_load_bmesh,
957         &def_transform,
958         &def_translate,
959         &def_rotate,
960         &def_edgenet_fill,
961         &def_contextual_create,
962         &def_makevert,
963         &def_weldverts,
964         &def_removedoubles,
965         &def_finddoubles,
966         &def_mirror,
967         &def_edgebisect,
968         &def_reversefaces,
969         &def_edgerotate,
970         &def_regionextend,
971         &def_righthandfaces,
972         &def_vertexsmooth,
973         &def_extrude_onlyedge,
974         &def_extrude_indivface,
975         &def_collapse_uvs,
976         &def_pointmerge,
977         &def_collapse,
978         &def_similarfaces,
979         &def_similaredges,
980         &def_similarverts,
981         &def_pointmerge_facedata,
982         &def_vert_average_facedata,
983         &def_meshrotateuvs,
984         &def_bmesh_to_mesh,
985         &def_meshreverseuvs,
986         &def_edgenet_prepare,
987         &def_meshrotatecolors,
988         &def_meshreversecolors,
989         &def_vertexshortestpath,
990         &def_scale,
991         &def_edgesplit,
992         &def_automerge,
993         &def_create_uvsphere,
994         &def_create_grid,
995         &def_create_icosphere,
996         &def_create_monkey,
997         &def_create_cone,
998         &def_create_cube,
999         &def_join_triangles,
1000 };
1001
1002 int bmesh_total_ops = (sizeof(opdefines) / sizeof(void*));