2011-02-23 10:52:22 +00:00
|
|
|
/*
|
2008-12-30 13:16:14 +00:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software Foundation,
|
2010-02-12 13:34:04 +00:00
|
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
2008-12-30 13:16:14 +00:00
|
|
|
*
|
|
|
|
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
|
|
|
* All rights reserved.
|
|
|
|
*/
|
|
|
|
|
2019-02-18 08:08:12 +11:00
|
|
|
/** \file
|
|
|
|
* \ingroup edmesh
|
2011-02-27 20:29:51 +00:00
|
|
|
*/
|
|
|
|
|
2008-12-30 13:16:14 +00:00
|
|
|
/* Internal for editmesh_xxxx.c functions */
|
|
|
|
|
2012-02-17 18:59:41 +00:00
|
|
|
#ifndef __MESH_INTERN_H__
|
|
|
|
#define __MESH_INTERN_H__
|
2008-12-30 13:16:14 +00:00
|
|
|
|
2012-03-27 04:46:52 +00:00
|
|
|
struct BMEditMesh;
|
2015-12-27 18:03:20 +11:00
|
|
|
struct BMElem;
|
2019-01-28 21:08:24 +11:00
|
|
|
struct BMOperator;
|
2012-02-11 08:46:56 +00:00
|
|
|
struct EnumPropertyItem;
|
2019-01-28 21:08:24 +11:00
|
|
|
struct LinkNode;
|
2012-03-27 04:46:52 +00:00
|
|
|
struct bContext;
|
|
|
|
struct wmKeyConfig;
|
|
|
|
struct wmKeyMap;
|
|
|
|
struct wmOperator;
|
|
|
|
struct wmOperatorType;
|
2009-12-24 16:10:26 +00:00
|
|
|
|
2013-04-01 10:18:01 +00:00
|
|
|
/* *** editmesh_utils.c *** */
|
2009-05-26 04:17:47 +00:00
|
|
|
|
|
|
|
/*
|
2018-06-01 18:19:39 +02:00
|
|
|
* ok: the EDBM module is for editmode bmesh stuff. in contrast, the
|
2012-03-03 16:31:46 +00:00
|
|
|
* BMEdit module is for code shared with blenkernel that concerns
|
2013-04-01 10:18:01 +00:00
|
|
|
* the BMEditMesh structure. */
|
2009-05-26 04:17:47 +00:00
|
|
|
|
2013-04-01 10:18:01 +00:00
|
|
|
/* Calls a bmesh op, reporting errors to the user, etc */
|
2013-03-24 12:13:13 +00:00
|
|
|
bool EDBM_op_callf(struct BMEditMesh *em, struct wmOperator *op, const char *fmt, ...);
|
2019-04-17 06:17:24 +02:00
|
|
|
bool EDBM_op_call_and_selectf(struct BMEditMesh *em,
|
|
|
|
struct wmOperator *op,
|
|
|
|
const char *select_slot,
|
|
|
|
const bool select_replace,
|
|
|
|
const char *fmt,
|
|
|
|
...);
|
2013-04-01 10:18:01 +00:00
|
|
|
/* Same as above, but doesn't report errors.*/
|
2013-03-24 12:13:13 +00:00
|
|
|
bool EDBM_op_call_silentf(struct BMEditMesh *em, const char *fmt, ...);
|
Created a printf-style method of calling operators. I did this to cut down on duplicated
code, and also because calling operators was such a pain. The basic form of the format
is "opname %[code]", where each % matches to an argument.
The codes are fairly simple:
d - int
i - int
f - float
h[v/e/f] - all verts/edges/faces with a certain header flag.
f[v/e/f] - all verts/edges/faces with a certain flag.
For example:
EDBM_CallOpf(em, op, "dissolveverts %hv", BM_SELECT)
will call the dissolve verts operator.
The relevent functions are:
//calls a bmesh operator, doing necassary conversions and error reporting.
int EDBM_CallOpf(EditMesh *em, struct wmOperator *op, char *fmt, ...);
//execute an operator
int BMO_CallOpf(BMesh *bm, char *fmt, ...);
//initializes but doesn't execute an op.
int BMO_InitOpf(BMesh *bm, BMOperator *op, char *fmt, ...);
//vlist version of above.
int BMO_VInitOpf(BMesh *bm, BMOperator *op, char *fmt, va_list vlist);
Note this system is dependant on getting the slot codes from the argument
order. I'd like to make it better, possibly pass in slot names, but that'd
mean actually giving the slots names (which I can do, but wanted to discuss with
Briggs and others what I have now first).
2009-03-02 04:08:24 +00:00
|
|
|
|
2012-03-27 04:46:52 +00:00
|
|
|
/* these next two functions are the split version of EDBM_op_callf, so you can
|
2012-03-03 16:31:46 +00:00
|
|
|
* do stuff with a bmesh operator, after initializing it but before executing
|
|
|
|
* it.
|
|
|
|
*
|
|
|
|
* execute the operator with BM_Exec_Op */
|
2019-04-17 06:17:24 +02:00
|
|
|
bool EDBM_op_init(
|
|
|
|
struct BMEditMesh *em, struct BMOperator *bmop, struct wmOperator *op, const char *fmt, ...);
|
2013-04-01 10:18:01 +00:00
|
|
|
/* Cleans up after a bmesh operator */
|
2019-04-17 06:17:24 +02:00
|
|
|
bool EDBM_op_finish(struct BMEditMesh *em,
|
|
|
|
struct BMOperator *bmop,
|
|
|
|
struct wmOperator *op,
|
|
|
|
const bool do_report);
|
Created a printf-style method of calling operators. I did this to cut down on duplicated
code, and also because calling operators was such a pain. The basic form of the format
is "opname %[code]", where each % matches to an argument.
The codes are fairly simple:
d - int
i - int
f - float
h[v/e/f] - all verts/edges/faces with a certain header flag.
f[v/e/f] - all verts/edges/faces with a certain flag.
For example:
EDBM_CallOpf(em, op, "dissolveverts %hv", BM_SELECT)
will call the dissolve verts operator.
The relevent functions are:
//calls a bmesh operator, doing necassary conversions and error reporting.
int EDBM_CallOpf(EditMesh *em, struct wmOperator *op, char *fmt, ...);
//execute an operator
int BMO_CallOpf(BMesh *bm, char *fmt, ...);
//initializes but doesn't execute an op.
int BMO_InitOpf(BMesh *bm, BMOperator *op, char *fmt, ...);
//vlist version of above.
int BMO_VInitOpf(BMesh *bm, BMOperator *op, char *fmt, va_list vlist);
Note this system is dependant on getting the slot codes from the argument
order. I'd like to make it better, possibly pass in slot names, but that'd
mean actually giving the slots names (which I can do, but wanted to discuss with
Briggs and others what I have now first).
2009-03-02 04:08:24 +00:00
|
|
|
|
2009-05-18 14:55:34 +00:00
|
|
|
void EDBM_stats_update(struct BMEditMesh *em);
|
2009-03-02 02:21:18 +00:00
|
|
|
|
2018-07-02 11:47:00 +02:00
|
|
|
bool EDBM_view3d_poll(struct bContext *C);
|
2008-12-30 13:16:14 +00:00
|
|
|
|
2019-04-17 06:17:24 +02:00
|
|
|
struct BMElem *EDBM_elem_from_selectmode(struct BMEditMesh *em,
|
|
|
|
struct BMVert *eve,
|
|
|
|
struct BMEdge *eed,
|
|
|
|
struct BMFace *efa);
|
|
|
|
int EDBM_elem_to_index_any(struct BMEditMesh *em, struct BMElem *ele);
|
2015-12-27 18:03:20 +11:00
|
|
|
struct BMElem *EDBM_elem_from_index_any(struct BMEditMesh *em, int index);
|
2009-01-30 15:01:14 +00:00
|
|
|
|
2019-09-10 15:18:51 +02:00
|
|
|
bool edbm_extrude_edges_indiv(struct BMEditMesh *em,
|
|
|
|
struct wmOperator *op,
|
|
|
|
const char hflag,
|
|
|
|
const bool use_normal_flip);
|
|
|
|
|
2013-04-01 10:18:01 +00:00
|
|
|
/* *** editmesh_add.c *** */
|
2009-04-12 17:28:16 +00:00
|
|
|
void MESH_OT_primitive_plane_add(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_primitive_cube_add(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_primitive_circle_add(struct wmOperatorType *ot);
|
2010-09-01 21:11:33 +00:00
|
|
|
void MESH_OT_primitive_cylinder_add(struct wmOperatorType *ot);
|
2009-04-12 17:28:16 +00:00
|
|
|
void MESH_OT_primitive_cone_add(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_primitive_grid_add(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_primitive_monkey_add(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_primitive_uv_sphere_add(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_primitive_ico_sphere_add(struct wmOperatorType *ot);
|
2009-07-08 16:17:47 +00:00
|
|
|
|
2018-07-14 23:49:00 +02:00
|
|
|
/* *** editmesh_add_gizmo.c *** */
|
|
|
|
void MESH_OT_primitive_cube_add_gizmo(struct wmOperatorType *ot);
|
2013-04-01 10:18:01 +00:00
|
|
|
|
|
|
|
/* *** editmesh_bevel.c *** */
|
|
|
|
void MESH_OT_bevel(struct wmOperatorType *ot);
|
2019-02-10 16:08:25 -05:00
|
|
|
struct wmKeyMap *bevel_modal_keymap(struct wmKeyConfig *keyconf);
|
2013-04-01 10:18:01 +00:00
|
|
|
|
2013-08-29 18:45:04 +00:00
|
|
|
/* *** editmesh_bisect.c *** */
|
|
|
|
void MESH_OT_bisect(struct wmOperatorType *ot);
|
2013-04-01 10:18:01 +00:00
|
|
|
|
|
|
|
/* *** editmesh_extrude.c *** */
|
|
|
|
void MESH_OT_extrude_repeat(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_extrude_region(struct wmOperatorType *ot);
|
2018-05-07 21:30:55 +02:00
|
|
|
void MESH_OT_extrude_context(struct wmOperatorType *ot);
|
2013-04-01 10:18:01 +00:00
|
|
|
void MESH_OT_extrude_verts_indiv(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_extrude_edges_indiv(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_extrude_faces_indiv(struct wmOperatorType *ot);
|
2009-07-08 16:17:47 +00:00
|
|
|
void MESH_OT_dupli_extrude_cursor(struct wmOperatorType *ot);
|
2018-05-03 08:13:17 +02:00
|
|
|
|
|
|
|
/* *** editmesh_extrude_screw.c *** */
|
2013-04-01 10:18:01 +00:00
|
|
|
void MESH_OT_screw(struct wmOperatorType *ot);
|
2008-12-30 13:16:14 +00:00
|
|
|
|
2018-05-03 08:13:17 +02:00
|
|
|
/* *** editmesh_extrude_spin.c *** */
|
|
|
|
void MESH_OT_spin(struct wmOperatorType *ot);
|
2018-09-18 09:47:56 +10:00
|
|
|
/* *** editmesh_extrude_spin_gizmo.c *** */
|
2018-09-18 13:24:35 +10:00
|
|
|
void MESH_GGT_spin(struct wmGizmoGroupType *gzgt);
|
2018-09-18 09:58:27 +10:00
|
|
|
void MESH_GGT_spin_redo(struct wmGizmoGroupType *gzgt);
|
2008-12-30 13:16:14 +00:00
|
|
|
|
2017-10-25 15:42:08 +11:00
|
|
|
/* *** editmesh_polybuild.c *** */
|
|
|
|
void MESH_OT_polybuild_face_at_cursor(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_polybuild_split_at_cursor(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_polybuild_dissolve_at_cursor(struct wmOperatorType *ot);
|
2019-08-27 16:19:25 +02:00
|
|
|
void MESH_OT_polybuild_transform_at_cursor(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_polybuild_delete_at_cursor(struct wmOperatorType *ot);
|
2008-12-30 13:16:14 +00:00
|
|
|
|
2013-04-01 10:18:01 +00:00
|
|
|
/* *** editmesh_inset.c *** */
|
|
|
|
void MESH_OT_inset(struct wmOperatorType *ot);
|
|
|
|
|
2014-07-11 10:32:33 +10:00
|
|
|
/* *** editmesh_intersect.c *** */
|
2014-03-19 15:28:38 +11:00
|
|
|
void MESH_OT_intersect(struct wmOperatorType *ot);
|
2015-12-11 17:46:19 +11:00
|
|
|
void MESH_OT_intersect_boolean(struct wmOperatorType *ot);
|
2014-07-11 10:32:33 +10:00
|
|
|
void MESH_OT_face_split_by_edges(struct wmOperatorType *ot);
|
|
|
|
|
2013-04-01 10:18:01 +00:00
|
|
|
/* *** editmesh_knife.c *** */
|
|
|
|
void MESH_OT_knife_tool(struct wmOperatorType *ot);
|
2013-06-04 01:23:51 +00:00
|
|
|
void MESH_OT_knife_project(struct wmOperatorType *ot);
|
2019-04-17 06:17:24 +02:00
|
|
|
void EDBM_mesh_knife(struct bContext *C, struct LinkNode *polys, bool use_tag, bool cut_through);
|
2008-12-30 13:16:14 +00:00
|
|
|
|
2012-04-28 15:42:27 +00:00
|
|
|
struct wmKeyMap *knifetool_modal_keymap(struct wmKeyConfig *keyconf);
|
2011-05-09 21:38:55 +00:00
|
|
|
|
2013-04-01 10:18:01 +00:00
|
|
|
/* *** editmesh_loopcut.c *** */
|
|
|
|
void MESH_OT_loopcut(struct wmOperatorType *ot);
|
2008-12-30 13:16:14 +00:00
|
|
|
|
2013-04-01 10:18:01 +00:00
|
|
|
/* *** editmesh_rip.c *** */
|
|
|
|
void MESH_OT_rip(struct wmOperatorType *ot);
|
2014-06-14 01:38:57 +10:00
|
|
|
void MESH_OT_rip_edge(struct wmOperatorType *ot);
|
2008-12-30 13:16:14 +00:00
|
|
|
|
2013-04-01 10:18:01 +00:00
|
|
|
/* *** editmesh_select.c *** */
|
|
|
|
void MESH_OT_select_similar(struct wmOperatorType *ot);
|
2014-09-15 15:40:50 +10:00
|
|
|
void MESH_OT_select_similar_region(struct wmOperatorType *ot);
|
2013-04-01 10:18:01 +00:00
|
|
|
void MESH_OT_select_mode(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_loop_multi_select(struct wmOperatorType *ot);
|
2009-04-12 17:43:43 +00:00
|
|
|
void MESH_OT_loop_select(struct wmOperatorType *ot);
|
2013-04-01 10:18:01 +00:00
|
|
|
void MESH_OT_edgering_select(struct wmOperatorType *ot);
|
2009-11-29 22:16:29 +00:00
|
|
|
void MESH_OT_select_all(struct wmOperatorType *ot);
|
2012-02-19 20:27:30 +00:00
|
|
|
void MESH_OT_select_interior_faces(struct wmOperatorType *ot);
|
2013-06-04 01:23:51 +00:00
|
|
|
void MESH_OT_shortest_path_pick(struct wmOperatorType *ot);
|
2009-02-01 12:40:27 +00:00
|
|
|
void MESH_OT_select_linked(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_select_linked_pick(struct wmOperatorType *ot);
|
2012-11-01 05:07:15 +00:00
|
|
|
void MESH_OT_select_face_by_sides(struct wmOperatorType *ot);
|
2013-04-29 16:59:53 +00:00
|
|
|
void MESH_OT_select_loose(struct wmOperatorType *ot);
|
2009-10-20 16:31:03 +00:00
|
|
|
void MESH_OT_select_mirror(struct wmOperatorType *ot);
|
2013-04-01 10:18:01 +00:00
|
|
|
void MESH_OT_select_more(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_select_less(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_select_nth(struct wmOperatorType *ot);
|
2009-04-12 17:43:43 +00:00
|
|
|
void MESH_OT_edges_select_sharp(struct wmOperatorType *ot);
|
2013-04-01 10:18:01 +00:00
|
|
|
void MESH_OT_faces_select_linked_flat(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_select_non_manifold(struct wmOperatorType *ot);
|
2009-02-01 12:40:27 +00:00
|
|
|
void MESH_OT_select_random(struct wmOperatorType *ot);
|
2013-03-16 16:11:50 +00:00
|
|
|
void MESH_OT_select_ungrouped(struct wmOperatorType *ot);
|
2013-04-01 10:18:01 +00:00
|
|
|
void MESH_OT_select_axis(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_region_to_loop(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_loop_to_region(struct wmOperatorType *ot);
|
2013-06-04 01:23:51 +00:00
|
|
|
void MESH_OT_shortest_path_select(struct wmOperatorType *ot);
|
2009-12-14 23:35:13 +00:00
|
|
|
|
2012-02-11 08:46:56 +00:00
|
|
|
extern struct EnumPropertyItem *corner_type_items;
|
2009-01-13 02:09:58 +00:00
|
|
|
|
2013-04-01 10:18:01 +00:00
|
|
|
/* *** editmesh_tools.c *** */
|
2009-01-16 04:48:33 +00:00
|
|
|
void MESH_OT_subdivide(struct wmOperatorType *ot);
|
2013-05-23 06:19:04 +00:00
|
|
|
void MESH_OT_subdivide_edgering(struct wmOperatorType *ot);
|
2012-10-16 16:04:12 +00:00
|
|
|
void MESH_OT_unsubdivide(struct wmOperatorType *ot);
|
2013-04-01 10:18:01 +00:00
|
|
|
void MESH_OT_normals_make_consistent(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_vertices_smooth(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_vertices_smooth_laplacian(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_vert_connect(struct wmOperatorType *ot);
|
2015-02-06 15:46:38 +11:00
|
|
|
void MESH_OT_vert_connect_path(struct wmOperatorType *ot);
|
2015-02-02 09:04:31 +11:00
|
|
|
void MESH_OT_vert_connect_concave(struct wmOperatorType *ot);
|
2013-07-28 19:53:46 +00:00
|
|
|
void MESH_OT_vert_connect_nonplanar(struct wmOperatorType *ot);
|
2015-06-11 21:46:51 +10:00
|
|
|
void MESH_OT_face_make_planar(struct wmOperatorType *ot);
|
2013-04-01 10:18:01 +00:00
|
|
|
void MESH_OT_edge_split(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_bridge_edge_loops(struct wmOperatorType *ot);
|
2015-06-15 10:58:07 +10:00
|
|
|
void MESH_OT_offset_edge_loops(struct wmOperatorType *ot);
|
2013-04-01 10:18:01 +00:00
|
|
|
void MESH_OT_wireframe(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_convex_hull(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_symmetrize(struct wmOperatorType *ot);
|
2013-06-19 21:35:06 +00:00
|
|
|
void MESH_OT_symmetry_snap(struct wmOperatorType *ot);
|
2013-04-01 10:18:01 +00:00
|
|
|
void MESH_OT_shape_propagate_to_all(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_blend_from_shape(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_sort_elements(struct wmOperatorType *ot);
|
2009-04-12 17:54:07 +00:00
|
|
|
void MESH_OT_uvs_rotate(struct wmOperatorType *ot);
|
2009-09-12 07:08:57 +00:00
|
|
|
void MESH_OT_uvs_reverse(struct wmOperatorType *ot);
|
2009-04-12 17:54:07 +00:00
|
|
|
void MESH_OT_colors_rotate(struct wmOperatorType *ot);
|
2009-09-20 18:18:40 +00:00
|
|
|
void MESH_OT_colors_reverse(struct wmOperatorType *ot);
|
2009-02-01 12:40:27 +00:00
|
|
|
void MESH_OT_delete(struct wmOperatorType *ot);
|
2014-01-17 12:08:12 +11:00
|
|
|
void MESH_OT_delete_loose(struct wmOperatorType *ot);
|
2012-03-23 10:30:42 +00:00
|
|
|
void MESH_OT_edge_collapse(struct wmOperatorType *ot);
|
2013-04-01 10:18:01 +00:00
|
|
|
void MESH_OT_faces_shade_smooth(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_faces_shade_flat(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_split(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_edge_rotate(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_hide(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_reveal(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_mark_seam(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_mark_sharp(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_flip_normals(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_solidify(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_knife_cut(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_separate(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_fill(struct wmOperatorType *ot);
|
2013-05-15 20:34:40 +00:00
|
|
|
void MESH_OT_fill_grid(struct wmOperatorType *ot);
|
2013-07-25 18:43:05 +00:00
|
|
|
void MESH_OT_fill_holes(struct wmOperatorType *ot);
|
2013-04-01 10:18:01 +00:00
|
|
|
void MESH_OT_beautify_fill(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_quads_convert_to_tris(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_tris_convert_to_quads(struct wmOperatorType *ot);
|
2016-07-08 23:35:27 +10:00
|
|
|
void MESH_OT_decimate(struct wmOperatorType *ot);
|
2013-05-08 13:48:57 +00:00
|
|
|
void MESH_OT_dissolve_verts(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_dissolve_edges(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_dissolve_faces(struct wmOperatorType *ot);
|
2013-08-06 05:01:11 +00:00
|
|
|
void MESH_OT_dissolve_mode(struct wmOperatorType *ot);
|
2013-04-01 10:18:01 +00:00
|
|
|
void MESH_OT_dissolve_limited(struct wmOperatorType *ot);
|
2014-02-17 11:32:35 +11:00
|
|
|
void MESH_OT_dissolve_degenerate(struct wmOperatorType *ot);
|
2013-06-14 03:04:36 +00:00
|
|
|
void MESH_OT_delete_edgeloop(struct wmOperatorType *ot);
|
2013-04-01 10:18:01 +00:00
|
|
|
void MESH_OT_edge_face_add(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_duplicate(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_merge(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_remove_doubles(struct wmOperatorType *ot);
|
2013-04-06 02:45:43 +00:00
|
|
|
void MESH_OT_poke(struct wmOperatorType *ot);
|
2018-05-25 22:24:24 +05:30
|
|
|
void MESH_OT_point_normals(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_merge_normals(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_split_normals(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_normals_tools(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_set_normals_from_faces(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_average_normals(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_smoothen_normals(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_mod_weighted_strength(struct wmOperatorType *ot);
|
|
|
|
|
2019-09-10 15:18:51 +02:00
|
|
|
/* *** editmesh_mask_extract.c *** */
|
|
|
|
void MESH_OT_paint_mask_extract(struct wmOperatorType *ot);
|
|
|
|
|
2018-05-25 22:24:24 +05:30
|
|
|
struct wmKeyMap *point_normals_modal_keymap(wmKeyConfig *keyconf);
|
2009-01-31 02:31:58 +00:00
|
|
|
|
2012-12-20 07:57:26 +00:00
|
|
|
#ifdef WITH_FREESTYLE
|
2013-04-01 13:47:19 +00:00
|
|
|
void MESH_OT_mark_freestyle_edge(struct wmOperatorType *ot);
|
2011-10-06 02:04:43 +00:00
|
|
|
void MESH_OT_mark_freestyle_face(struct wmOperatorType *ot);
|
2012-12-20 07:57:26 +00:00
|
|
|
#endif
|
2009-10-16 10:05:58 +00:00
|
|
|
|
2013-04-01 10:18:01 +00:00
|
|
|
/* *** mesh_data.c *** */
|
2009-07-01 22:25:49 +00:00
|
|
|
void MESH_OT_uv_texture_add(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_uv_texture_remove(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_vertex_color_add(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_vertex_color_remove(struct wmOperatorType *ot);
|
2012-09-23 18:50:56 +00:00
|
|
|
/* no create_mask yet */
|
2015-05-03 15:18:27 +02:00
|
|
|
void MESH_OT_customdata_mask_clear(struct wmOperatorType *ot);
|
2015-05-03 15:09:48 +02:00
|
|
|
void MESH_OT_customdata_skin_add(struct wmOperatorType *ot);
|
2015-05-03 15:18:27 +02:00
|
|
|
void MESH_OT_customdata_skin_clear(struct wmOperatorType *ot);
|
Add Custom Loop Normals.
This is the core code for it, tools (datatransfer and modifier) will come in next commits).
RNA api is already there, though.
See the code for details, but basically, we define, for each 'smooth fan'
(which is a set of adjacent loops around a same vertex that are smooth, i.e. have a single same normal),
a 'loop normal space' (or lnor space), using auto-computed normal and relevant edges, and store
custom normal as two angular factors inside that space. This allows to have custom normals
'following' deformations of the geometry, and to only save two shorts per loop in new clnor CDLayer.
Normal manipulation (editing, mixing, interpolating, etc.) shall always happen with plain 3D vectors normals,
and be converted back into storage format at the end.
Clnor computation has also been threaded (at least for Mesh case, not for BMesh), since the process can
be rather heavy with high poly meshes.
Also, bumping subversion, and fix mess in 2.70 versioning code.
2015-02-05 14:24:48 +01:00
|
|
|
void MESH_OT_customdata_custom_splitnormals_add(struct wmOperatorType *ot);
|
|
|
|
void MESH_OT_customdata_custom_splitnormals_clear(struct wmOperatorType *ot);
|
2009-07-01 22:25:49 +00:00
|
|
|
|
2019-04-17 06:17:24 +02:00
|
|
|
#endif /* __MESH_INTERN_H__ */
|