Mesh Operators#

bpy.ops.mesh.attribute_set(value_float=0.0, value_float_vector_2d=(0.0, 0.0), value_float_vector_3d=(0.0, 0.0, 0.0), value_int=0, value_int_vector_2d=(0, 0), value_color=(1.0, 1.0, 1.0, 1.0), value_bool=False)#

Set values of the active attribute for selected elements

Parameters:

value_float (float in [-inf, inf], (optional)) – Value
value_float_vector_2d (float array of 2 items in [-inf, inf], (optional)) – Value
value_float_vector_3d (float array of 3 items in [-inf, inf], (optional)) – Value
value_int (int in [-inf, inf], (optional)) – Value
value_int_vector_2d (int array of 2 items in [-inf, inf], (optional)) – Value
value_color (float array of 4 items in [-inf, inf], (optional)) – Value
value_bool (boolean, (optional)) – Value

bpy.ops.mesh.average_normals(average_type='CUSTOM_NORMAL', weight=50, threshold=0.01)#

Average custom normals of selected vertices

Parameters:

average_type (enum in ['CUSTOM_NORMAL', 'FACE_AREA', 'CORNER_ANGLE'], (optional)) –
Type, Averaging method
- CUSTOM_NORMAL Custom Normal – Take average of vertex normals.
- FACE_AREA Face Area – Set all vertex normals by face area.
- CORNER_ANGLE Corner Angle – Set all vertex normals by corner angle.
weight (int in [1, 100], (optional)) – Weight, Weight applied per face
threshold (float in [0, 10], (optional)) – Threshold, Threshold value for different weights to be considered equal

bpy.ops.mesh.beautify_fill(angle_limit=3.14159)#

Rearrange some faces to try to get less degenerated geometry

Parameters:: angle_limit (float in [0, 3.14159], (optional)) – Max Angle, Angle limit

bpy.ops.mesh.bevel(offset_type='OFFSET', offset=0.0, profile_type='SUPERELLIPSE', offset_pct=0.0, segments=1, profile=0.5, affect='EDGES', clamp_overlap=False, loop_slide=True, mark_seam=False, mark_sharp=False, material=-1, harden_normals=False, face_strength_mode='NONE', miter_outer='SHARP', miter_inner='SHARP', spread=0.1, vmesh_method='ADJ', release_confirm=False)#

Cut into selected items at an angle to create bevel or chamfer

Parameters:

offset_type (enum in ['OFFSET', 'WIDTH', 'DEPTH', 'PERCENT', 'ABSOLUTE'], (optional)) –
Width Type, The method for determining the size of the bevel
- OFFSET Offset – Amount is offset of new edges from original.
- WIDTH Width – Amount is width of new face.
- DEPTH Depth – Amount is perpendicular distance from original edge to bevel face.
- PERCENT Percent – Amount is percent of adjacent edge length.
- ABSOLUTE Absolute – Amount is absolute distance along adjacent edge.
offset (float in [0, 1e+06], (optional)) – Width, Bevel amount
profile_type (enum in ['SUPERELLIPSE', 'CUSTOM'], (optional)) –
Profile Type, The type of shape used to rebuild a beveled section
- SUPERELLIPSE Superellipse – The profile can be a concave or convex curve.
- CUSTOM Custom – The profile can be any arbitrary path between its endpoints.
offset_pct (float in [0, 100], (optional)) – Width Percent, Bevel amount for percentage method
segments (int in [1, 1000], (optional)) – Segments, Segments for curved edge
profile (float in [0, 1], (optional)) – Profile, Controls profile shape (0.5 = round)
affect (enum in ['VERTICES', 'EDGES'], (optional)) –
Affect, Affect edges or vertices
- VERTICES Vertices – Affect only vertices.
- EDGES Edges – Affect only edges.
clamp_overlap (boolean, (optional)) – Clamp Overlap, Do not allow beveled edges/vertices to overlap each other
loop_slide (boolean, (optional)) – Loop Slide, Prefer sliding along edges to even widths
mark_seam (boolean, (optional)) – Mark Seams, Mark Seams along beveled edges
mark_sharp (boolean, (optional)) – Mark Sharp, Mark beveled edges as sharp
material (int in [-1, inf], (optional)) – Material Index, Material for bevel faces (-1 means use adjacent faces)
harden_normals (boolean, (optional)) – Harden Normals, Match normals of new faces to adjacent faces
face_strength_mode (enum in ['NONE', 'NEW', 'AFFECTED', 'ALL'], (optional)) –
Face Strength Mode, Whether to set face strength, and which faces to set face strength on
- NONE None – Do not set face strength.
- NEW New – Set face strength on new faces only.
- AFFECTED Affected – Set face strength on new and modified faces only.
- ALL All – Set face strength on all faces.
miter_outer (enum in ['SHARP', 'PATCH', 'ARC'], (optional)) –
Outer Miter, Pattern to use for outside of miters
- SHARP Sharp – Outside of miter is sharp.
- PATCH Patch – Outside of miter is squared-off patch.
- ARC Arc – Outside of miter is arc.
miter_inner (enum in ['SHARP', 'ARC'], (optional)) –
Inner Miter, Pattern to use for inside of miters
- SHARP Sharp – Inside of miter is sharp.
- ARC Arc – Inside of miter is arc.
spread (float in [0, 1e+06], (optional)) – Spread, Amount to spread arcs for arc inner miters
vmesh_method (enum in ['ADJ', 'CUTOFF'], (optional)) –
Vertex Mesh Method, The method to use to create meshes at intersections
- ADJ Grid Fill – Default patterned fill.
- CUTOFF Cutoff – A cutoff at each profile’s end before the intersection.
release_confirm (boolean, (optional)) – Confirm on Release

bpy.ops.mesh.bisect(plane_co=(0.0, 0.0, 0.0), plane_no=(0.0, 0.0, 0.0), use_fill=False, clear_inner=False, clear_outer=False, threshold=0.0001, xstart=0, xend=0, ystart=0, yend=0, flip=False, cursor=5)#

Cut geometry along a plane (click-drag to define plane)

Parameters:

plane_co (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Plane Point, A point on the plane
plane_no (mathutils.Vector of 3 items in [-1, 1], (optional)) – Plane Normal, The direction the plane points
use_fill (boolean, (optional)) – Fill, Fill in the cut
clear_inner (boolean, (optional)) – Clear Inner, Remove geometry behind the plane
clear_outer (boolean, (optional)) – Clear Outer, Remove geometry in front of the plane
threshold (float in [0, 10], (optional)) – Axis Threshold, Preserves the existing geometry along the cut plane
xstart (int in [-inf, inf], (optional)) – X Start
xend (int in [-inf, inf], (optional)) – X End
ystart (int in [-inf, inf], (optional)) – Y Start
yend (int in [-inf, inf], (optional)) – Y End
flip (boolean, (optional)) – Flip
cursor (int in [0, inf], (optional)) – Cursor, Mouse cursor style to use during the modal operator

bpy.ops.mesh.blend_from_shape(shape='', blend=1.0, add=True)#

Blend in shape from a shape key

Parameters:

shape (enum in [], (optional)) – Shape, Shape key to use for blending
blend (float in [-1000, 1000], (optional)) – Blend, Blending factor
add (boolean, (optional)) – Add, Add rather than blend between shapes

bpy.ops.mesh.bridge_edge_loops(type='SINGLE', use_merge=False, merge_factor=0.5, twist_offset=0, number_cuts=0, interpolation='PATH', smoothness=1.0, profile_shape_factor=0.0, profile_shape='SMOOTH')#

Create a bridge of faces between two or more selected edge loops

Parameters:

type (enum in ['SINGLE', 'CLOSED', 'PAIRS'], (optional)) – Connect Loops, Method of bridging multiple loops
use_merge (boolean, (optional)) – Merge, Merge rather than creating faces
merge_factor (float in [0, 1], (optional)) – Merge Factor
twist_offset (int in [-1000, 1000], (optional)) – Twist, Twist offset for closed loops
number_cuts (int in [0, 1000], (optional)) – Number of Cuts
interpolation (enum in ['LINEAR', 'PATH', 'SURFACE'], (optional)) – Interpolation, Interpolation method
smoothness (float in [0, 1000], (optional)) – Smoothness, Smoothness factor
profile_shape_factor (float in [-1000, 1000], (optional)) – Profile Factor, How much intermediary new edges are shrunk/expanded
profile_shape (enum in Proportional Falloff Curve Only Items, (optional)) – Profile Shape, Shape of the profile

bpy.ops.mesh.colors_reverse()#: Flip direction of face corner color attribute inside faces

bpy.ops.mesh.colors_rotate(use_ccw=False)#

Rotate face corner color attribute inside faces

Parameters:: use_ccw (boolean, (optional)) – Counter Clockwise

bpy.ops.mesh.convex_hull(delete_unused=True, use_existing_faces=True, make_holes=False, join_triangles=True, face_threshold=0.698132, shape_threshold=0.698132, uvs=False, vcols=False, seam=False, sharp=False, materials=False)#

Enclose selected vertices in a convex polyhedron

Parameters:

delete_unused (boolean, (optional)) – Delete Unused, Delete selected elements that are not used by the hull
use_existing_faces (boolean, (optional)) – Use Existing Faces, Skip hull triangles that are covered by a pre-existing face
make_holes (boolean, (optional)) – Make Holes, Delete selected faces that are used by the hull
join_triangles (boolean, (optional)) – Join Triangles, Merge adjacent triangles into quads
face_threshold (float in [0, 3.14159], (optional)) – Max Face Angle, Face angle limit
shape_threshold (float in [0, 3.14159], (optional)) – Max Shape Angle, Shape angle limit
uvs (boolean, (optional)) – Compare UVs
vcols (boolean, (optional)) – Compare Color Attributes
seam (boolean, (optional)) – Compare Seam
sharp (boolean, (optional)) – Compare Sharp
materials (boolean, (optional)) – Compare Materials

bpy.ops.mesh.customdata_custom_splitnormals_add()#: Add a custom split normals layer, if none exists yet

bpy.ops.mesh.customdata_custom_splitnormals_clear()#: Remove the custom split normals layer, if it exists

bpy.ops.mesh.customdata_mask_clear()#: Clear vertex sculpt masking data from the mesh

bpy.ops.mesh.customdata_skin_add()#: Add a vertex skin layer

bpy.ops.mesh.customdata_skin_clear()#: Clear vertex skin layer

bpy.ops.mesh.decimate(ratio=1.0, use_vertex_group=False, vertex_group_factor=1.0, invert_vertex_group=False, use_symmetry=False, symmetry_axis='Y')#

Simplify geometry by collapsing edges

Parameters:

ratio (float in [0, 1], (optional)) – Ratio
use_vertex_group (boolean, (optional)) – Vertex Group, Use active vertex group as an influence
vertex_group_factor (float in [0, 1000], (optional)) – Weight, Vertex group strength
invert_vertex_group (boolean, (optional)) – Invert, Invert vertex group influence
use_symmetry (boolean, (optional)) – Symmetry, Maintain symmetry on an axis
symmetry_axis (enum in Axis Xyz Items, (optional)) – Axis, Axis of symmetry

bpy.ops.mesh.delete(type='VERT')#

Delete selected vertices, edges or faces

Parameters:: type (enum in ['VERT', 'EDGE', 'FACE', 'EDGE_FACE', 'ONLY_FACE'], (optional)) – Type, Method used for deleting mesh data

bpy.ops.mesh.delete_edgeloop(use_face_split=True)#

Delete an edge loop by merging the faces on each side

Parameters:: use_face_split (boolean, (optional)) – Face Split, Split off face corners to maintain surrounding geometry

bpy.ops.mesh.delete_loose(use_verts=True, use_edges=True, use_faces=False)#

Delete loose vertices, edges or faces

Parameters:

use_verts (boolean, (optional)) – Vertices, Remove loose vertices
use_edges (boolean, (optional)) – Edges, Remove loose edges
use_faces (boolean, (optional)) – Faces, Remove loose faces

bpy.ops.mesh.dissolve_degenerate(threshold=0.0001)#

Dissolve zero area faces and zero length edges

Parameters:: threshold (float in [1e-06, 50], (optional)) – Merge Distance, Maximum distance between elements to merge

bpy.ops.mesh.dissolve_edges(use_verts=True, use_face_split=False)#

Dissolve edges, merging faces

Parameters:

use_verts (boolean, (optional)) – Dissolve Vertices, Dissolve remaining vertices
use_face_split (boolean, (optional)) – Face Split, Split off face corners to maintain surrounding geometry

bpy.ops.mesh.dissolve_faces(use_verts=False)#

Dissolve faces

Parameters:: use_verts (boolean, (optional)) – Dissolve Vertices, Dissolve remaining vertices

bpy.ops.mesh.dissolve_limited(angle_limit=0.0872665, use_dissolve_boundaries=False, delimit={'NORMAL'})#

Dissolve selected edges and vertices, limited by the angle of surrounding geometry

Parameters:

angle_limit (float in [0, 3.14159], (optional)) – Max Angle, Angle limit
use_dissolve_boundaries (boolean, (optional)) – All Boundaries, Dissolve all vertices in between face boundaries
delimit (enum set in Mesh Delimit Mode Items, (optional)) – Delimit, Delimit dissolve operation

bpy.ops.mesh.dissolve_mode(use_verts=False, use_face_split=False, use_boundary_tear=False)#

Dissolve geometry based on the selection mode

Parameters:

use_verts (boolean, (optional)) – Dissolve Vertices, Dissolve remaining vertices
use_face_split (boolean, (optional)) – Face Split, Split off face corners to maintain surrounding geometry
use_boundary_tear (boolean, (optional)) – Tear Boundary, Split off face corners instead of merging faces

bpy.ops.mesh.dissolve_verts(use_face_split=False, use_boundary_tear=False)#

Dissolve vertices, merge edges and faces

Parameters:

use_face_split (boolean, (optional)) – Face Split, Split off face corners to maintain surrounding geometry
use_boundary_tear (boolean, (optional)) – Tear Boundary, Split off face corners instead of merging faces

bpy.ops.mesh.dupli_extrude_cursor(rotate_source=True)#

Duplicate and extrude selected vertices, edges or faces towards the mouse cursor

Parameters:: rotate_source (boolean, (optional)) – Rotate Source, Rotate initial selection giving better shape

bpy.ops.mesh.duplicate(mode=1)#

Duplicate selected vertices, edges or faces

Parameters:: mode (int in [0, inf], (optional)) – Mode

bpy.ops.mesh.duplicate_move(MESH_OT_duplicate=None, TRANSFORM_OT_translate=None)#

Duplicate mesh and move

Parameters:

MESH_OT_duplicate (MESH_OT_duplicate, (optional)) – Duplicate, Duplicate selected vertices, edges or faces
TRANSFORM_OT_translate (TRANSFORM_OT_translate, (optional)) – Move, Move selected items

bpy.ops.mesh.edge_collapse()#: Collapse isolated edge and face regions, merging data such as UVs and color attributes. This can collapse edge-rings as well as regions of connected faces into vertices

bpy.ops.mesh.edge_face_add()#: Add an edge or face to selected

bpy.ops.mesh.edge_rotate(use_ccw=False)#

Rotate selected edge or adjoining faces

Parameters:: use_ccw (boolean, (optional)) – Counter Clockwise

bpy.ops.mesh.edge_split(type='EDGE')#

Split selected edges so that each neighbor face gets its own copy

Parameters:

type (enum in ['EDGE', 'VERT'], (optional)) –

Type, Method to use for splitting

EDGE Faces by Edges – Split faces along selected edges.
VERT Faces & Edges by Vertices – Split faces and edges connected to selected vertices.

bpy.ops.mesh.edgering_select(extend=False, deselect=False, toggle=False, ring=True)#

Select an edge ring

Parameters:

extend (boolean, (optional)) – Extend, Extend the selection
deselect (boolean, (optional)) – Deselect, Remove from the selection
toggle (boolean, (optional)) – Toggle Select, Toggle the selection
ring (boolean, (optional)) – Select Ring, Select ring

bpy.ops.mesh.edges_select_sharp(sharpness=0.523599)#

Select all sharp enough edges

Parameters:: sharpness (float in [0.000174533, 3.14159], (optional)) – Sharpness

bpy.ops.mesh.extrude_context(use_normal_flip=False, use_dissolve_ortho_edges=False, mirror=False)#

Extrude selection

Parameters:

use_normal_flip (boolean, (optional)) – Flip Normals
use_dissolve_ortho_edges (boolean, (optional)) – Dissolve Orthogonal Edges
mirror (boolean, (optional)) – Mirror Editing

bpy.ops.mesh.extrude_context_move(MESH_OT_extrude_context=None, TRANSFORM_OT_translate=None)#

Extrude region together along the average normal

Parameters:

MESH_OT_extrude_context (MESH_OT_extrude_context, (optional)) – Extrude Context, Extrude selection
TRANSFORM_OT_translate (TRANSFORM_OT_translate, (optional)) – Move, Move selected items

bpy.ops.mesh.extrude_edges_indiv(use_normal_flip=False, mirror=False)#

Extrude individual edges only

Parameters:

use_normal_flip (boolean, (optional)) – Flip Normals
mirror (boolean, (optional)) – Mirror Editing

bpy.ops.mesh.extrude_edges_move(MESH_OT_extrude_edges_indiv=None, TRANSFORM_OT_translate=None)#

Extrude edges and move result

Parameters:

MESH_OT_extrude_edges_indiv (MESH_OT_extrude_edges_indiv, (optional)) – Extrude Only Edges, Extrude individual edges only
TRANSFORM_OT_translate (TRANSFORM_OT_translate, (optional)) – Move, Move selected items

bpy.ops.mesh.extrude_faces_indiv(mirror=False)#

Extrude individual faces only

Parameters:: mirror (boolean, (optional)) – Mirror Editing

bpy.ops.mesh.extrude_faces_move(MESH_OT_extrude_faces_indiv=None, TRANSFORM_OT_shrink_fatten=None)#

Extrude each individual face separately along local normals

Parameters:

MESH_OT_extrude_faces_indiv (MESH_OT_extrude_faces_indiv, (optional)) – Extrude Individual Faces, Extrude individual faces only
TRANSFORM_OT_shrink_fatten (TRANSFORM_OT_shrink_fatten, (optional)) – Shrink/Fatten, Shrink/fatten selected vertices along normals

bpy.ops.mesh.extrude_manifold(MESH_OT_extrude_region=None, TRANSFORM_OT_translate=None)#

Extrude, dissolves edges whose faces form a flat surface and intersect new edges

Parameters:

MESH_OT_extrude_region (MESH_OT_extrude_region, (optional)) – Extrude Region, Extrude region of faces
TRANSFORM_OT_translate (TRANSFORM_OT_translate, (optional)) – Move, Move selected items

bpy.ops.mesh.extrude_region(use_normal_flip=False, use_dissolve_ortho_edges=False, mirror=False)#

Extrude region of faces

Parameters:

use_normal_flip (boolean, (optional)) – Flip Normals
use_dissolve_ortho_edges (boolean, (optional)) – Dissolve Orthogonal Edges
mirror (boolean, (optional)) – Mirror Editing

bpy.ops.mesh.extrude_region_move(MESH_OT_extrude_region=None, TRANSFORM_OT_translate=None)#

Extrude region and move result

Parameters:

MESH_OT_extrude_region (MESH_OT_extrude_region, (optional)) – Extrude Region, Extrude region of faces
TRANSFORM_OT_translate (TRANSFORM_OT_translate, (optional)) – Move, Move selected items

bpy.ops.mesh.extrude_region_shrink_fatten(MESH_OT_extrude_region=None, TRANSFORM_OT_shrink_fatten=None)#

Extrude region together along local normals

Parameters:

MESH_OT_extrude_region (MESH_OT_extrude_region, (optional)) – Extrude Region, Extrude region of faces
TRANSFORM_OT_shrink_fatten (TRANSFORM_OT_shrink_fatten, (optional)) – Shrink/Fatten, Shrink/fatten selected vertices along normals

bpy.ops.mesh.extrude_repeat(steps=10, offset=(0.0, 0.0, 0.0), scale_offset=1.0)#

Extrude selected vertices, edges or faces repeatedly

Parameters:

steps (int in [0, 1000000], (optional)) – Steps
offset (mathutils.Vector of 3 items in [-100000, 100000], (optional)) – Offset, Offset vector
scale_offset (float in [0, inf], (optional)) – Scale Offset

bpy.ops.mesh.extrude_vertices_move(MESH_OT_extrude_verts_indiv=None, TRANSFORM_OT_translate=None)#

Extrude vertices and move result

Parameters:

MESH_OT_extrude_verts_indiv (MESH_OT_extrude_verts_indiv, (optional)) – Extrude Only Vertices, Extrude individual vertices only
TRANSFORM_OT_translate (TRANSFORM_OT_translate, (optional)) – Move, Move selected items

bpy.ops.mesh.extrude_verts_indiv(mirror=False)#

Extrude individual vertices only

Parameters:: mirror (boolean, (optional)) – Mirror Editing

bpy.ops.mesh.face_make_planar(factor=1.0, repeat=1)#

Flatten selected faces

Parameters:

factor (float in [-10, 10], (optional)) – Factor
repeat (int in [1, 10000], (optional)) – Iterations

bpy.ops.mesh.face_set_extract(add_boundary_loop=True, smooth_iterations=4, apply_shrinkwrap=True, add_solidify=True)#

Create a new mesh object from the selected Face Set

Parameters:

add_boundary_loop (boolean, (optional)) – Add Boundary Loop, Add an extra edge loop to better preserve the shape when applying a subdivision surface modifier
smooth_iterations (int in [0, inf], (optional)) – Smooth Iterations, Smooth iterations applied to the extracted mesh
apply_shrinkwrap (boolean, (optional)) – Project to Sculpt, Project the extracted mesh into the original sculpt
add_solidify (boolean, (optional)) – Extract as Solid, Extract the mask as a solid object with a solidify modifier

bpy.ops.mesh.face_split_by_edges()#: Weld loose edges into faces (splitting them into new faces)

bpy.ops.mesh.faces_mirror_uv(direction='POSITIVE', precision=3)#

Copy mirror UV coordinates on the X axis based on a mirrored mesh

Parameters:

direction (enum in ['POSITIVE', 'NEGATIVE'], (optional)) – Axis Direction
precision (int in [1, 16], (optional)) – Precision, Tolerance for finding vertex duplicates

File:

startup/bl_operators/mesh.py:134

bpy.ops.mesh.faces_select_linked_flat(sharpness=0.0174533)#

Select linked faces by angle

Parameters:: sharpness (float in [0.000174533, 3.14159], (optional)) – Sharpness

bpy.ops.mesh.faces_shade_flat()#: Display faces flat

bpy.ops.mesh.faces_shade_smooth()#: Display faces smooth (using vertex normals)

bpy.ops.mesh.fill(use_beauty=True)#

Fill a selected edge loop with faces

Parameters:: use_beauty (boolean, (optional)) – Beauty, Use best triangulation division

bpy.ops.mesh.fill_grid(span=1, offset=0, use_interp_simple=False)#

Fill grid from two loops

Parameters:

span (int in [1, 1000], (optional)) – Span, Number of grid columns
offset (int in [-1000, 1000], (optional)) – Offset, Vertex that is the corner of the grid
use_interp_simple (boolean, (optional)) – Simple Blending, Use simple interpolation of grid vertices

bpy.ops.mesh.fill_holes(sides=4)#

Fill in holes (boundary edge loops)

Parameters:: sides (int in [0, 1000], (optional)) – Sides, Number of sides in hole required to fill (zero fills all holes)

bpy.ops.mesh.flip_normals(only_clnors=False)#

Flip the direction of selected faces’ normals (and of their vertices)

Parameters:: only_clnors (boolean, (optional)) – Custom Normals Only, Only flip the custom loop normals of the selected elements

bpy.ops.mesh.flip_quad_tessellation()#: Flips the tessellation of selected quads

bpy.ops.mesh.hide(unselected=False)#

Hide (un)selected vertices, edges or faces

Parameters:: unselected (boolean, (optional)) – Unselected, Hide unselected rather than selected

bpy.ops.mesh.inset(use_boundary=True, use_even_offset=True, use_relative_offset=False, use_edge_rail=False, thickness=0.0, depth=0.0, use_outset=False, use_select_inset=False, use_individual=False, use_interpolate=True, release_confirm=False)#

Inset new faces into selected faces

Parameters:

use_boundary (boolean, (optional)) – Boundary, Inset face boundaries
use_even_offset (boolean, (optional)) – Offset Even, Scale the offset to give more even thickness
use_relative_offset (boolean, (optional)) – Offset Relative, Scale the offset by surrounding geometry
use_edge_rail (boolean, (optional)) – Edge Rail, Inset the region along existing edges
thickness (float in [0, inf], (optional)) – Thickness
depth (float in [-inf, inf], (optional)) – Depth
use_outset (boolean, (optional)) – Outset, Outset rather than inset
use_select_inset (boolean, (optional)) – Select Outer, Select the new inset faces
use_individual (boolean, (optional)) – Individual, Individual face inset
use_interpolate (boolean, (optional)) – Interpolate, Blend face data across the inset
release_confirm (boolean, (optional)) – Confirm on Release

bpy.ops.mesh.intersect(mode='SELECT_UNSELECT', separate_mode='CUT', threshold=1e-06, solver='EXACT')#

Cut an intersection into faces

Parameters:

mode (enum in ['SELECT', 'SELECT_UNSELECT'], (optional)) –
Source
- SELECT Self Intersect – Self intersect selected faces.
- SELECT_UNSELECT Selected/Unselected – Intersect selected with unselected faces.
separate_mode (enum in ['ALL', 'CUT', 'NONE'], (optional)) –
Separate Mode
- ALL All – Separate all geometry from intersections.
- CUT Cut – Cut into geometry keeping each side separate (Selected/Unselected only).
- NONE Merge – Merge all geometry from the intersection.
threshold (float in [0, 0.01], (optional)) – Merge Threshold
solver (enum in ['FAST', 'EXACT'], (optional)) –
Solver, Which Intersect solver to use
- FAST Fast – Faster solver, some limitations.
- EXACT Exact – Exact solver, slower, handles more cases.

bpy.ops.mesh.intersect_boolean(operation='DIFFERENCE', use_swap=False, use_self=False, threshold=1e-06, solver='EXACT')#

Cut solid geometry from selected to unselected

Parameters:

operation (enum in ['INTERSECT', 'UNION', 'DIFFERENCE'], (optional)) – Boolean Operation, Which boolean operation to apply
use_swap (boolean, (optional)) – Swap, Use with difference intersection to swap which side is kept
use_self (boolean, (optional)) – Self Intersection, Do self-union or self-intersection
threshold (float in [0, 0.01], (optional)) – Merge Threshold
solver (enum in ['FAST', 'EXACT'], (optional)) –
Solver, Which Boolean solver to use
- FAST Fast – Faster solver, some limitations.
- EXACT Exact – Exact solver, slower, handles more cases.

bpy.ops.mesh.knife_project(cut_through=False)#

Use other objects outlines and boundaries to project knife cuts

Parameters:: cut_through (boolean, (optional)) – Cut Through, Cut through all faces, not just visible ones

bpy.ops.mesh.knife_tool(use_occlude_geometry=True, only_selected=False, xray=True, visible_measurements='NONE', angle_snapping='NONE', angle_snapping_increment=0.523599, wait_for_input=True)#

Cut new topology

Parameters:

use_occlude_geometry (boolean, (optional)) – Occlude Geometry, Only cut the front most geometry
only_selected (boolean, (optional)) – Only Selected, Only cut selected geometry
xray (boolean, (optional)) – X-Ray, Show cuts hidden by geometry
visible_measurements (enum in ['NONE', 'BOTH', 'DISTANCE', 'ANGLE'], (optional)) –
Measurements, Visible distance and angle measurements
- NONE None – Show no measurements.
- BOTH Both – Show both distances and angles.
- DISTANCE Distance – Show just distance measurements.
- ANGLE Angle – Show just angle measurements.
angle_snapping (enum in ['NONE', 'SCREEN', 'RELATIVE'], (optional)) –
Angle Snapping, Angle snapping mode
- NONE None – No angle snapping.
- SCREEN Screen – Screen space angle snapping.
- RELATIVE Relative – Angle snapping relative to the previous cut edge.
angle_snapping_increment (float in [0, 3.14159], (optional)) – Angle Snap Increment, The angle snap increment used when in constrained angle mode
wait_for_input (boolean, (optional)) – Wait for Input

bpy.ops.mesh.loop_multi_select(ring=False)#

Select a loop of connected edges by connection type

Parameters:: ring (boolean, (optional)) – Ring

bpy.ops.mesh.loop_select(extend=False, deselect=False, toggle=False, ring=False)#

Select a loop of connected edges

Parameters:

extend (boolean, (optional)) – Extend Select, Extend the selection
deselect (boolean, (optional)) – Deselect, Remove from the selection
toggle (boolean, (optional)) – Toggle Select, Toggle the selection
ring (boolean, (optional)) – Select Ring, Select ring

bpy.ops.mesh.loop_to_region(select_bigger=False)#

Select region of faces inside of a selected loop of edges

Parameters:: select_bigger (boolean, (optional)) – Select Bigger, Select bigger regions instead of smaller ones

bpy.ops.mesh.loopcut(number_cuts=1, smoothness=0.0, falloff='INVERSE_SQUARE', object_index=-1, edge_index=-1, mesh_select_mode_init=(False, False, False))#

Add a new loop between existing loops

Parameters:

number_cuts (int in [1, 1000000], (optional)) – Number of Cuts
smoothness (float in [-1000, 1000], (optional)) – Smoothness, Smoothness factor
falloff (enum in Proportional Falloff Curve Only Items, (optional)) – Falloff, Falloff type of the feather
object_index (int in [-1, inf], (optional)) – Object Index
edge_index (int in [-1, inf], (optional)) – Edge Index

bpy.ops.mesh.loopcut_slide(MESH_OT_loopcut=None, TRANSFORM_OT_edge_slide=None)#

Cut mesh loop and slide it

Parameters:

MESH_OT_loopcut (MESH_OT_loopcut, (optional)) – Loop Cut, Add a new loop between existing loops
TRANSFORM_OT_edge_slide (TRANSFORM_OT_edge_slide, (optional)) – Edge Slide, Slide an edge loop along a mesh

bpy.ops.mesh.mark_freestyle_edge(clear=False)#

(Un)mark selected edges as Freestyle feature edges

Parameters:: clear (boolean, (optional)) – Clear

bpy.ops.mesh.mark_freestyle_face(clear=False)#

(Un)mark selected faces for exclusion from Freestyle feature edge detection

Parameters:: clear (boolean, (optional)) – Clear

bpy.ops.mesh.mark_seam(clear=False)#

(Un)mark selected edges as a seam

Parameters:: clear (boolean, (optional)) – Clear

bpy.ops.mesh.mark_sharp(clear=False, use_verts=False)#

(Un)mark selected edges as sharp

Parameters:

clear (boolean, (optional)) – Clear
use_verts (boolean, (optional)) – Vertices, Consider vertices instead of edges to select which edges to (un)tag as sharp

bpy.ops.mesh.merge(type='CENTER', uvs=False)#

Merge selected vertices

Parameters:

type (enum in ['CENTER', 'CURSOR', 'COLLAPSE', 'FIRST', 'LAST'], (optional)) – Type, Merge method to use
uvs (boolean, (optional)) – UVs, Move UVs according to merge

bpy.ops.mesh.merge_normals()#: Merge custom normals of selected vertices

bpy.ops.mesh.mod_weighted_strength(set=False, face_strength='MEDIUM')#

Set/Get strength of face (used in Weighted Normal modifier)

Parameters:

set (boolean, (optional)) – Set Value, Set value of faces
face_strength (enum in ['WEAK', 'MEDIUM', 'STRONG'], (optional)) – Face Strength, Strength to use for assigning or selecting face influence for weighted normal modifier

bpy.ops.mesh.normals_make_consistent(inside=False)#

Make face and vertex normals point either outside or inside the mesh

Parameters:: inside (boolean, (optional)) – Inside

bpy.ops.mesh.normals_tools(mode='COPY', absolute=False)#

Custom normals tools using Normal Vector of UI

Parameters:

mode (enum in ['COPY', 'PASTE', 'ADD', 'MULTIPLY', 'RESET'], (optional)) –
Mode, Mode of tools taking input from interface
- COPY Copy Normal – Copy normal to the internal clipboard.
- PASTE Paste Normal – Paste normal from the internal clipboard.
- ADD Add Normal – Add normal vector with selection.
- MULTIPLY Multiply Normal – Multiply normal vector with selection.
- RESET Reset Normal – Reset the internal clipboard and/or normal of selected element.
absolute (boolean, (optional)) – Absolute Coordinates, Copy Absolute coordinates of Normal vector

bpy.ops.mesh.offset_edge_loops(use_cap_endpoint=False)#

Create offset edge loop from the current selection

Parameters:: use_cap_endpoint (boolean, (optional)) – Cap Endpoint, Extend loop around end-points

bpy.ops.mesh.offset_edge_loops_slide(MESH_OT_offset_edge_loops=None, TRANSFORM_OT_edge_slide=None)#

Offset edge loop slide

Parameters:

MESH_OT_offset_edge_loops (MESH_OT_offset_edge_loops, (optional)) – Offset Edge Loop, Create offset edge loop from the current selection
TRANSFORM_OT_edge_slide (TRANSFORM_OT_edge_slide, (optional)) – Edge Slide, Slide an edge loop along a mesh

bpy.ops.mesh.paint_mask_extract(mask_threshold=0.5, add_boundary_loop=True, smooth_iterations=4, apply_shrinkwrap=True, add_solidify=True)#

Create a new mesh object from the current paint mask

Parameters:

mask_threshold (float in [0, 1], (optional)) – Threshold, Minimum mask value to consider the vertex valid to extract a face from the original mesh
add_boundary_loop (boolean, (optional)) – Add Boundary Loop, Add an extra edge loop to better preserve the shape when applying a subdivision surface modifier
smooth_iterations (int in [0, inf], (optional)) – Smooth Iterations, Smooth iterations applied to the extracted mesh
apply_shrinkwrap (boolean, (optional)) – Project to Sculpt, Project the extracted mesh into the original sculpt
add_solidify (boolean, (optional)) – Extract as Solid, Extract the mask as a solid object with a solidify modifier

bpy.ops.mesh.paint_mask_slice(mask_threshold=0.5, fill_holes=True, new_object=True)#

Slices the paint mask from the mesh

Parameters:

mask_threshold (float in [0, 1], (optional)) – Threshold, Minimum mask value to consider the vertex valid to extract a face from the original mesh
fill_holes (boolean, (optional)) – Fill Holes, Fill holes after slicing the mask
new_object (boolean, (optional)) – Slice to New Object, Create a new object from the sliced mask

bpy.ops.mesh.point_normals(mode='COORDINATES', invert=False, align=False, target_location=(0.0, 0.0, 0.0), spherize=False, spherize_strength=0.1)#

Point selected custom normals to specified Target

Parameters:

mode (enum in ['COORDINATES', 'MOUSE'], (optional)) –
Mode, How to define coordinates to point custom normals to
- COORDINATES Coordinates – Use static coordinates (defined by various means).
- MOUSE Mouse – Follow mouse cursor.
invert (boolean, (optional)) – Invert, Invert affected normals
align (boolean, (optional)) – Align, Make all affected normals parallel
target_location (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Target, Target location to which normals will point
spherize (boolean, (optional)) – Spherize, Interpolate between original and new normals
spherize_strength (float in [0, 1], (optional)) – Spherize Strength, Ratio of spherized normal to original normal

bpy.ops.mesh.poke(offset=0.0, use_relative_offset=False, center_mode='MEDIAN_WEIGHTED')#

Split a face into a fan

Parameters:

offset (float in [-1000, 1000], (optional)) – Poke Offset, Poke Offset
use_relative_offset (boolean, (optional)) – Offset Relative, Scale the offset by surrounding geometry
center_mode (enum in ['MEDIAN_WEIGHTED', 'MEDIAN', 'BOUNDS'], (optional)) –
Poke Center, Poke face center calculation
- MEDIAN_WEIGHTED Weighted Median – Weighted median face center.
- MEDIAN Median – Median face center.
- BOUNDS Bounds – Face bounds center.

bpy.ops.mesh.polybuild_delete_at_cursor(mirror=False, use_proportional_edit=False, proportional_edit_falloff='SMOOTH', proportional_size=1.0, use_proportional_connected=False, use_proportional_projected=False, release_confirm=False, use_accurate=False)#

Undocumented, consider contributing.

Parameters:

mirror (boolean, (optional)) – Mirror Editing
use_proportional_edit (boolean, (optional)) – Proportional Editing
proportional_edit_falloff (enum in Proportional Falloff Items, (optional)) – Proportional Falloff, Falloff type for proportional editing mode
proportional_size (float in [1e-06, inf], (optional)) – Proportional Size
use_proportional_connected (boolean, (optional)) – Connected
use_proportional_projected (boolean, (optional)) – Projected (2D)
release_confirm (boolean, (optional)) – Confirm on Release, Always confirm operation when releasing button
use_accurate (boolean, (optional)) – Accurate, Use accurate transformation

bpy.ops.mesh.polybuild_dissolve_at_cursor()#: Undocumented, consider contributing.

bpy.ops.mesh.polybuild_extrude_at_cursor_move(MESH_OT_polybuild_transform_at_cursor=None, MESH_OT_extrude_edges_indiv=None, TRANSFORM_OT_translate=None)#

Undocumented, consider contributing.

Parameters:

MESH_OT_polybuild_transform_at_cursor (MESH_OT_polybuild_transform_at_cursor, (optional)) – Poly Build Transform at Cursor
MESH_OT_extrude_edges_indiv (MESH_OT_extrude_edges_indiv, (optional)) – Extrude Only Edges, Extrude individual edges only
TRANSFORM_OT_translate (TRANSFORM_OT_translate, (optional)) – Move, Move selected items

bpy.ops.mesh.polybuild_face_at_cursor(create_quads=True, mirror=False, use_proportional_edit=False, proportional_edit_falloff='SMOOTH', proportional_size=1.0, use_proportional_connected=False, use_proportional_projected=False, release_confirm=False, use_accurate=False)#

Undocumented, consider contributing.

Parameters:

create_quads (boolean, (optional)) – Create Quads, Automatically split edges in triangles to maintain quad topology
mirror (boolean, (optional)) – Mirror Editing
use_proportional_edit (boolean, (optional)) – Proportional Editing
proportional_edit_falloff (enum in Proportional Falloff Items, (optional)) – Proportional Falloff, Falloff type for proportional editing mode
proportional_size (float in [1e-06, inf], (optional)) – Proportional Size
use_proportional_connected (boolean, (optional)) – Connected
use_proportional_projected (boolean, (optional)) – Projected (2D)
release_confirm (boolean, (optional)) – Confirm on Release, Always confirm operation when releasing button
use_accurate (boolean, (optional)) – Accurate, Use accurate transformation

bpy.ops.mesh.polybuild_face_at_cursor_move(MESH_OT_polybuild_face_at_cursor=None, TRANSFORM_OT_translate=None)#

Undocumented, consider contributing.

Parameters:

MESH_OT_polybuild_face_at_cursor (MESH_OT_polybuild_face_at_cursor, (optional)) – Poly Build Face at Cursor
TRANSFORM_OT_translate (TRANSFORM_OT_translate, (optional)) – Move, Move selected items

bpy.ops.mesh.polybuild_split_at_cursor(mirror=False, use_proportional_edit=False, proportional_edit_falloff='SMOOTH', proportional_size=1.0, use_proportional_connected=False, use_proportional_projected=False, release_confirm=False, use_accurate=False)#

Undocumented, consider contributing.

Parameters:

mirror (boolean, (optional)) – Mirror Editing
use_proportional_edit (boolean, (optional)) – Proportional Editing
proportional_edit_falloff (enum in Proportional Falloff Items, (optional)) – Proportional Falloff, Falloff type for proportional editing mode
proportional_size (float in [1e-06, inf], (optional)) – Proportional Size
use_proportional_connected (boolean, (optional)) – Connected
use_proportional_projected (boolean, (optional)) – Projected (2D)
release_confirm (boolean, (optional)) – Confirm on Release, Always confirm operation when releasing button
use_accurate (boolean, (optional)) – Accurate, Use accurate transformation

bpy.ops.mesh.polybuild_split_at_cursor_move(MESH_OT_polybuild_split_at_cursor=None, TRANSFORM_OT_translate=None)#

Undocumented, consider contributing.

Parameters:

MESH_OT_polybuild_split_at_cursor (MESH_OT_polybuild_split_at_cursor, (optional)) – Poly Build Split at Cursor
TRANSFORM_OT_translate (TRANSFORM_OT_translate, (optional)) – Move, Move selected items

bpy.ops.mesh.polybuild_transform_at_cursor(mirror=False, use_proportional_edit=False, proportional_edit_falloff='SMOOTH', proportional_size=1.0, use_proportional_connected=False, use_proportional_projected=False, release_confirm=False, use_accurate=False)#

Undocumented, consider contributing.

Parameters:

mirror (boolean, (optional)) – Mirror Editing
use_proportional_edit (boolean, (optional)) – Proportional Editing
proportional_edit_falloff (enum in Proportional Falloff Items, (optional)) – Proportional Falloff, Falloff type for proportional editing mode
proportional_size (float in [1e-06, inf], (optional)) – Proportional Size
use_proportional_connected (boolean, (optional)) – Connected
use_proportional_projected (boolean, (optional)) – Projected (2D)
release_confirm (boolean, (optional)) – Confirm on Release, Always confirm operation when releasing button
use_accurate (boolean, (optional)) – Accurate, Use accurate transformation

bpy.ops.mesh.polybuild_transform_at_cursor_move(MESH_OT_polybuild_transform_at_cursor=None, TRANSFORM_OT_translate=None)#

Undocumented, consider contributing.

Parameters:

MESH_OT_polybuild_transform_at_cursor (MESH_OT_polybuild_transform_at_cursor, (optional)) – Poly Build Transform at Cursor
TRANSFORM_OT_translate (TRANSFORM_OT_translate, (optional)) – Move, Move selected items

bpy.ops.mesh.primitive_circle_add(vertices=32, radius=1.0, fill_type='NOTHING', calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), scale=(0.0, 0.0, 0.0))#

Construct a circle mesh

Parameters:

vertices (int in [3, 10000000], (optional)) – Vertices
radius (float in [0, inf], (optional)) – Radius
fill_type (enum in ['NOTHING', 'NGON', 'TRIFAN'], (optional)) –
Fill Type
- NOTHING Nothing – Don’t fill at all.
- NGON N-Gon – Use n-gons.
- TRIFAN Triangle Fan – Use triangle fans.
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
enter_editmode (boolean, (optional)) – Enter Edit Mode, Enter edit mode when adding this object
align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) –
Align, The alignment of the new object
- WORLD World – Align the new object to the world.
- VIEW View – Align the new object to the view.
- CURSOR 3D Cursor – Use the 3D cursor orientation for the new object.
location (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (mathutils.Euler rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
scale (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Scale, Scale for the newly added object

bpy.ops.mesh.primitive_cone_add(vertices=32, radius1=1.0, radius2=0.0, depth=2.0, end_fill_type='NGON', calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), scale=(0.0, 0.0, 0.0))#

Construct a conic mesh

Parameters:

vertices (int in [3, 10000000], (optional)) – Vertices
radius1 (float in [0, inf], (optional)) – Radius 1
radius2 (float in [0, inf], (optional)) – Radius 2
depth (float in [0, inf], (optional)) – Depth
end_fill_type (enum in ['NOTHING', 'NGON', 'TRIFAN'], (optional)) –
Base Fill Type
- NOTHING Nothing – Don’t fill at all.
- NGON N-Gon – Use n-gons.
- TRIFAN Triangle Fan – Use triangle fans.
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
enter_editmode (boolean, (optional)) – Enter Edit Mode, Enter edit mode when adding this object
align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) –
Align, The alignment of the new object
- WORLD World – Align the new object to the world.
- VIEW View – Align the new object to the view.
- CURSOR 3D Cursor – Use the 3D cursor orientation for the new object.
location (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (mathutils.Euler rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
scale (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Scale, Scale for the newly added object

bpy.ops.mesh.primitive_cube_add(size=2.0, calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), scale=(0.0, 0.0, 0.0))#

Construct a cube mesh that consists of six square faces

Parameters:

size (float in [0, inf], (optional)) – Size
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
enter_editmode (boolean, (optional)) – Enter Edit Mode, Enter edit mode when adding this object
align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) –
Align, The alignment of the new object
- WORLD World – Align the new object to the world.
- VIEW View – Align the new object to the view.
- CURSOR 3D Cursor – Use the 3D cursor orientation for the new object.
location (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (mathutils.Euler rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
scale (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Scale, Scale for the newly added object

bpy.ops.mesh.primitive_cube_add_gizmo(calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), scale=(0.0, 0.0, 0.0), matrix=((0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0), (0.0, 0.0, 0.0, 0.0)))#

Construct a cube mesh

Parameters:

calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
enter_editmode (boolean, (optional)) – Enter Edit Mode, Enter edit mode when adding this object
align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) –
Align, The alignment of the new object
- WORLD World – Align the new object to the world.
- VIEW View – Align the new object to the view.
- CURSOR 3D Cursor – Use the 3D cursor orientation for the new object.
location (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (mathutils.Euler rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
scale (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Scale, Scale for the newly added object
matrix (mathutils.Matrix of 4 * 4 items in [-inf, inf], (optional)) – Matrix

bpy.ops.mesh.primitive_cylinder_add(vertices=32, radius=1.0, depth=2.0, end_fill_type='NGON', calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), scale=(0.0, 0.0, 0.0))#

Construct a cylinder mesh

Parameters:

vertices (int in [3, 10000000], (optional)) – Vertices
radius (float in [0, inf], (optional)) – Radius
depth (float in [0, inf], (optional)) – Depth
end_fill_type (enum in ['NOTHING', 'NGON', 'TRIFAN'], (optional)) –
Cap Fill Type
- NOTHING Nothing – Don’t fill at all.
- NGON N-Gon – Use n-gons.
- TRIFAN Triangle Fan – Use triangle fans.
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
enter_editmode (boolean, (optional)) – Enter Edit Mode, Enter edit mode when adding this object
align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) –
Align, The alignment of the new object
- WORLD World – Align the new object to the world.
- VIEW View – Align the new object to the view.
- CURSOR 3D Cursor – Use the 3D cursor orientation for the new object.
location (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (mathutils.Euler rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
scale (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Scale, Scale for the newly added object

bpy.ops.mesh.primitive_grid_add(x_subdivisions=10, y_subdivisions=10, size=2.0, calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), scale=(0.0, 0.0, 0.0))#

Construct a subdivided plane mesh

Parameters:

x_subdivisions (int in [1, 10000000], (optional)) – X Subdivisions
y_subdivisions (int in [1, 10000000], (optional)) – Y Subdivisions
size (float in [0, inf], (optional)) – Size
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
enter_editmode (boolean, (optional)) – Enter Edit Mode, Enter edit mode when adding this object
align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) –
Align, The alignment of the new object
- WORLD World – Align the new object to the world.
- VIEW View – Align the new object to the view.
- CURSOR 3D Cursor – Use the 3D cursor orientation for the new object.
location (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (mathutils.Euler rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
scale (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Scale, Scale for the newly added object

bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=2, radius=1.0, calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), scale=(0.0, 0.0, 0.0))#

Construct a spherical mesh that consists of equally sized triangles

Parameters:

subdivisions (int in [1, 10], (optional)) – Subdivisions
radius (float in [0, inf], (optional)) – Radius
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
enter_editmode (boolean, (optional)) – Enter Edit Mode, Enter edit mode when adding this object
align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) –
Align, The alignment of the new object
- WORLD World – Align the new object to the world.
- VIEW View – Align the new object to the view.
- CURSOR 3D Cursor – Use the 3D cursor orientation for the new object.
location (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (mathutils.Euler rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
scale (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Scale, Scale for the newly added object

bpy.ops.mesh.primitive_monkey_add(size=2.0, calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), scale=(0.0, 0.0, 0.0))#

Construct a Suzanne mesh

Parameters:

size (float in [0, inf], (optional)) – Size
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
enter_editmode (boolean, (optional)) – Enter Edit Mode, Enter edit mode when adding this object
align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) –
Align, The alignment of the new object
- WORLD World – Align the new object to the world.
- VIEW View – Align the new object to the view.
- CURSOR 3D Cursor – Use the 3D cursor orientation for the new object.
location (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (mathutils.Euler rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
scale (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Scale, Scale for the newly added object

bpy.ops.mesh.primitive_plane_add(size=2.0, calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), scale=(0.0, 0.0, 0.0))#

Construct a filled planar mesh with 4 vertices

Parameters:

size (float in [0, inf], (optional)) – Size
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
enter_editmode (boolean, (optional)) – Enter Edit Mode, Enter edit mode when adding this object
align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) –
Align, The alignment of the new object
- WORLD World – Align the new object to the world.
- VIEW View – Align the new object to the view.
- CURSOR 3D Cursor – Use the 3D cursor orientation for the new object.
location (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (mathutils.Euler rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
scale (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Scale, Scale for the newly added object

bpy.ops.mesh.primitive_torus_add(align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), major_segments=48, minor_segments=12, mode='MAJOR_MINOR', major_radius=1.0, minor_radius=0.25, abso_major_rad=1.25, abso_minor_rad=0.75, generate_uvs=True)#

Construct a torus mesh

Parameters:

align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) –
Align
- WORLD World – Align the new object to the world.
- VIEW View – Align the new object to the view.
- CURSOR 3D Cursor – Use the 3D cursor orientation for the new object.
location (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Location
rotation (mathutils.Euler rotation of 3 items in [-inf, inf], (optional)) – Rotation
major_segments (int in [3, 256], (optional)) – Major Segments, Number of segments for the main ring of the torus
minor_segments (int in [3, 256], (optional)) – Minor Segments, Number of segments for the minor ring of the torus
mode (enum in ['MAJOR_MINOR', 'EXT_INT'], (optional)) –
Dimensions Mode
- MAJOR_MINOR Major/Minor – Use the major/minor radii for torus dimensions.
- EXT_INT Exterior/Interior – Use the exterior/interior radii for torus dimensions.
major_radius (float in [0, 10000], (optional)) – Major Radius, Radius from the origin to the center of the cross sections
minor_radius (float in [0, 10000], (optional)) – Minor Radius, Radius of the torus’ cross section
abso_major_rad (float in [0, 10000], (optional)) – Exterior Radius, Total Exterior Radius of the torus
abso_minor_rad (float in [0, 10000], (optional)) – Interior Radius, Total Interior Radius of the torus
generate_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map

File:

startup/bl_operators/add_mesh_torus.py:222

bpy.ops.mesh.primitive_uv_sphere_add(segments=32, ring_count=16, radius=1.0, calc_uvs=True, enter_editmode=False, align='WORLD', location=(0.0, 0.0, 0.0), rotation=(0.0, 0.0, 0.0), scale=(0.0, 0.0, 0.0))#

Construct a spherical mesh with quad faces, except for triangle faces at the top and bottom

Parameters:

segments (int in [3, 100000], (optional)) – Segments
ring_count (int in [3, 100000], (optional)) – Rings
radius (float in [0, inf], (optional)) – Radius
calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
enter_editmode (boolean, (optional)) – Enter Edit Mode, Enter edit mode when adding this object
align (enum in ['WORLD', 'VIEW', 'CURSOR'], (optional)) –
Align, The alignment of the new object
- WORLD World – Align the new object to the world.
- VIEW View – Align the new object to the view.
- CURSOR 3D Cursor – Use the 3D cursor orientation for the new object.
location (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
rotation (mathutils.Euler rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
scale (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Scale, Scale for the newly added object

bpy.ops.mesh.quads_convert_to_tris(quad_method='BEAUTY', ngon_method='BEAUTY')#

Triangulate selected faces

Parameters:

quad_method (enum in Modifier Triangulate Quad Method Items, (optional)) – Quad Method, Method for splitting the quads into triangles
ngon_method (enum in Modifier Triangulate Ngon Method Items, (optional)) – N-gon Method, Method for splitting the n-gons into triangles

bpy.ops.mesh.region_to_loop()#: Select boundary edges around the selected faces

bpy.ops.mesh.remove_doubles(threshold=0.0001, use_unselected=False, use_sharp_edge_from_normals=False)#

Merge vertices based on their proximity

Parameters:

threshold (float in [1e-06, 50], (optional)) – Merge Distance, Maximum distance between elements to merge
use_unselected (boolean, (optional)) – Unselected, Merge selected to other unselected vertices
use_sharp_edge_from_normals (boolean, (optional)) – Sharp Edges, Calculate sharp edges using custom normal data (when available)

bpy.ops.mesh.reveal(select=True)#

Reveal all hidden vertices, edges and faces

Parameters:: select (boolean, (optional)) – Select

bpy.ops.mesh.rip(mirror=False, use_proportional_edit=False, proportional_edit_falloff='SMOOTH', proportional_size=1.0, use_proportional_connected=False, use_proportional_projected=False, release_confirm=False, use_accurate=False, use_fill=False)#

Disconnect vertex or edges from connected geometry

Parameters:

mirror (boolean, (optional)) – Mirror Editing
use_proportional_edit (boolean, (optional)) – Proportional Editing
proportional_edit_falloff (enum in Proportional Falloff Items, (optional)) – Proportional Falloff, Falloff type for proportional editing mode
proportional_size (float in [1e-06, inf], (optional)) – Proportional Size
use_proportional_connected (boolean, (optional)) – Connected
use_proportional_projected (boolean, (optional)) – Projected (2D)
release_confirm (boolean, (optional)) – Confirm on Release, Always confirm operation when releasing button
use_accurate (boolean, (optional)) – Accurate, Use accurate transformation
use_fill (boolean, (optional)) – Fill, Fill the ripped region

bpy.ops.mesh.rip_edge(mirror=False, use_proportional_edit=False, proportional_edit_falloff='SMOOTH', proportional_size=1.0, use_proportional_connected=False, use_proportional_projected=False, release_confirm=False, use_accurate=False)#

Extend vertices along the edge closest to the cursor

Parameters:

mirror (boolean, (optional)) – Mirror Editing
use_proportional_edit (boolean, (optional)) – Proportional Editing
proportional_edit_falloff (enum in Proportional Falloff Items, (optional)) – Proportional Falloff, Falloff type for proportional editing mode
proportional_size (float in [1e-06, inf], (optional)) – Proportional Size
use_proportional_connected (boolean, (optional)) – Connected
use_proportional_projected (boolean, (optional)) – Projected (2D)
release_confirm (boolean, (optional)) – Confirm on Release, Always confirm operation when releasing button
use_accurate (boolean, (optional)) – Accurate, Use accurate transformation

bpy.ops.mesh.rip_edge_move(MESH_OT_rip_edge=None, TRANSFORM_OT_translate=None)#

Extend vertices and move the result

Parameters:

MESH_OT_rip_edge (MESH_OT_rip_edge, (optional)) – Extend Vertices, Extend vertices along the edge closest to the cursor
TRANSFORM_OT_translate (TRANSFORM_OT_translate, (optional)) – Move, Move selected items

bpy.ops.mesh.rip_move(MESH_OT_rip=None, TRANSFORM_OT_translate=None)#

Rip polygons and move the result

Parameters:

MESH_OT_rip (MESH_OT_rip, (optional)) – Rip, Disconnect vertex or edges from connected geometry
TRANSFORM_OT_translate (TRANSFORM_OT_translate, (optional)) – Move, Move selected items

bpy.ops.mesh.screw(steps=9, turns=1, center=(0.0, 0.0, 0.0), axis=(0.0, 0.0, 0.0))#

Extrude selected vertices in screw-shaped rotation around the cursor in indicated viewport

Parameters:

steps (int in [1, 100000], (optional)) – Steps, Steps
turns (int in [1, 100000], (optional)) – Turns, Turns
center (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Center, Center in global view space
axis (mathutils.Vector of 3 items in [-1, 1], (optional)) – Axis, Axis in global view space

bpy.ops.mesh.select_all(action='TOGGLE')#

(De)select all vertices, edges or faces

Parameters:

action (enum in ['TOGGLE', 'SELECT', 'DESELECT', 'INVERT'], (optional)) –

Action, Selection action to execute

TOGGLE Toggle – Toggle selection for all elements.
SELECT Select – Select all elements.
DESELECT Deselect – Deselect all elements.
INVERT Invert – Invert selection of all elements.

bpy.ops.mesh.select_axis(orientation='LOCAL', sign='POS', axis='X', threshold=0.0001)#

Select all data in the mesh on a single axis

Parameters:

orientation (enum in Transform Orientation Items, (optional)) – Axis Mode, Axis orientation
sign (enum in ['POS', 'NEG', 'ALIGN'], (optional)) – Axis Sign, Side to select
axis (enum in Axis Xyz Items, (optional)) – Axis, Select the axis to compare each vertex on
threshold (float in [1e-06, 50], (optional)) – Threshold

bpy.ops.mesh.select_by_attribute()#: Select elements based on the active boolean attribute

bpy.ops.mesh.select_face_by_sides(number=4, type='EQUAL', extend=True)#

Select vertices or faces by the number of face sides

Parameters:

number (int in [3, inf], (optional)) – Number of Vertices
type (enum in ['LESS', 'EQUAL', 'GREATER', 'NOTEQUAL'], (optional)) – Type, Type of comparison to make
extend (boolean, (optional)) – Extend, Extend the selection

bpy.ops.mesh.select_interior_faces()#: Select faces where all edges have more than 2 face users

bpy.ops.mesh.select_less(use_face_step=True)#

Deselect vertices, edges or faces at the boundary of each selection region

Parameters:: use_face_step (boolean, (optional)) – Face Step, Connected faces (instead of edges)

bpy.ops.mesh.select_linked(delimit={'SEAM'})#

Select all vertices connected to the current selection

Parameters:: delimit (enum set in Mesh Delimit Mode Items, (optional)) – Delimit, Delimit selected region

bpy.ops.mesh.select_linked_pick(deselect=False, delimit={'SEAM'}, object_index=-1, index=-1)#

(De)select all vertices linked to the edge under the mouse cursor

Parameters:

deselect (boolean, (optional)) – Deselect
delimit (enum set in Mesh Delimit Mode Items, (optional)) – Delimit, Delimit selected region

bpy.ops.mesh.select_loose(extend=False)#

Select loose geometry based on the selection mode

Parameters:: extend (boolean, (optional)) – Extend, Extend the selection

bpy.ops.mesh.select_mirror(axis={'X'}, extend=False)#

Select mesh items at mirrored locations

Parameters:

axis (enum set in Axis Flag Xyz Items, (optional)) – Axis
extend (boolean, (optional)) – Extend, Extend the existing selection

bpy.ops.mesh.select_mode(use_extend=False, use_expand=False, type='VERT', action='TOGGLE')#

Change selection mode

Parameters:

use_extend (boolean, (optional)) – Extend
use_expand (boolean, (optional)) – Expand
type (enum in Mesh Select Mode Items, (optional)) – Type
action (enum in ['DISABLE', 'ENABLE', 'TOGGLE'], (optional)) –
Action, Selection action to execute
- DISABLE Disable – Disable selected markers.
- ENABLE Enable – Enable selected markers.
- TOGGLE Toggle – Toggle disabled flag for selected markers.

bpy.ops.mesh.select_more(use_face_step=True)#

Select more vertices, edges or faces connected to initial selection

Parameters:: use_face_step (boolean, (optional)) – Face Step, Connected faces (instead of edges)

bpy.ops.mesh.select_next_item()#

Select the next element (using selection order)

File:: startup/bl_operators/mesh.py:206

bpy.ops.mesh.select_non_manifold(extend=True, use_wire=True, use_boundary=True, use_multi_face=True, use_non_contiguous=True, use_verts=True)#

Select all non-manifold vertices or edges

Parameters:

extend (boolean, (optional)) – Extend, Extend the selection
use_wire (boolean, (optional)) – Wire, Wire edges
use_boundary (boolean, (optional)) – Boundaries, Boundary edges
use_multi_face (boolean, (optional)) – Multiple Faces, Edges shared by more than two faces
use_non_contiguous (boolean, (optional)) – Non Contiguous, Edges between faces pointing in alternate directions
use_verts (boolean, (optional)) – Vertices, Vertices connecting multiple face regions

bpy.ops.mesh.select_nth(skip=1, nth=1, offset=0)#

Deselect every Nth element starting from the active vertex, edge or face

Parameters:

skip (int in [1, inf], (optional)) – Deselected, Number of deselected elements in the repetitive sequence
nth (int in [1, inf], (optional)) – Selected, Number of selected elements in the repetitive sequence
offset (int in [-inf, inf], (optional)) – Offset, Offset from the starting point

bpy.ops.mesh.select_prev_item()#

Select the previous element (using selection order)

File:: startup/bl_operators/mesh.py:231

bpy.ops.mesh.select_random(ratio=0.5, seed=0, action='SELECT')#

Randomly select vertices

Parameters:

ratio (float in [0, 1], (optional)) – Ratio, Portion of items to select randomly
seed (int in [0, inf], (optional)) – Random Seed, Seed for the random number generator
action (enum in ['SELECT', 'DESELECT'], (optional)) –
Action, Selection action to execute
- SELECT Select – Select all elements.
- DESELECT Deselect – Deselect all elements.

bpy.ops.mesh.select_similar(type='VERT_NORMAL', compare='EQUAL', threshold=0.0)#

Select similar vertices, edges or faces by property types

Parameters:

type (enum in ['VERT_NORMAL', 'VERT_FACES', 'VERT_GROUPS', 'VERT_EDGES', 'VERT_CREASE', 'EDGE_LENGTH', 'EDGE_DIR', 'EDGE_FACES', 'EDGE_FACE_ANGLE', 'EDGE_CREASE', 'EDGE_BEVEL', 'EDGE_SEAM', 'EDGE_SHARP', 'EDGE_FREESTYLE', 'FACE_MATERIAL', 'FACE_AREA', 'FACE_SIDES', 'FACE_PERIMETER', 'FACE_NORMAL', 'FACE_COPLANAR', 'FACE_SMOOTH', 'FACE_FREESTYLE'], (optional)) – Type
compare (enum in ['EQUAL', 'GREATER', 'LESS'], (optional)) – Compare
threshold (float in [0, 1], (optional)) – Threshold

bpy.ops.mesh.select_similar_region()#: Select similar face regions to the current selection

bpy.ops.mesh.select_ungrouped(extend=False)#

Select vertices without a group

Parameters:: extend (boolean, (optional)) – Extend, Extend the selection

bpy.ops.mesh.separate(type='SELECTED')#

Separate selected geometry into a new mesh

Parameters:: type (enum in ['SELECTED', 'MATERIAL', 'LOOSE'], (optional)) – Type

bpy.ops.mesh.set_normals_from_faces(keep_sharp=False)#

Set the custom normals from the selected faces ones

Parameters:: keep_sharp (boolean, (optional)) – Keep Sharp Edges, Do not set sharp edges to face

bpy.ops.mesh.set_sharpness_by_angle(angle=0.523599, extend=False)#

Set edge sharpness based on the angle between neighboring faces

Parameters:

angle (float in [0.000174533, 3.14159], (optional)) – Angle
extend (boolean, (optional)) – Extend, Add new sharp edges without clearing existing sharp edges

bpy.ops.mesh.shape_propagate_to_all()#: Apply selected vertex locations to all other shape keys

bpy.ops.mesh.shortest_path_pick(edge_mode='SELECT', use_face_step=False, use_topology_distance=False, use_fill=False, skip=0, nth=1, offset=0, index=-1)#

Select shortest path between two selections

Parameters:

edge_mode (enum in ['SELECT', 'SEAM', 'SHARP', 'CREASE', 'BEVEL', 'FREESTYLE'], (optional)) – Edge Tag, The edge flag to tag when selecting the shortest path
use_face_step (boolean, (optional)) – Face Stepping, Traverse connected faces (includes diagonals and edge-rings)
use_topology_distance (boolean, (optional)) – Topology Distance, Find the minimum number of steps, ignoring spatial distance
use_fill (boolean, (optional)) – Fill Region, Select all paths between the source/destination elements
skip (int in [0, inf], (optional)) – Deselected, Number of deselected elements in the repetitive sequence
nth (int in [1, inf], (optional)) – Selected, Number of selected elements in the repetitive sequence
offset (int in [-inf, inf], (optional)) – Offset, Offset from the starting point

bpy.ops.mesh.shortest_path_select(edge_mode='SELECT', use_face_step=False, use_topology_distance=False, use_fill=False, skip=0, nth=1, offset=0)#

Selected shortest path between two vertices/edges/faces

Parameters:

edge_mode (enum in ['SELECT', 'SEAM', 'SHARP', 'CREASE', 'BEVEL', 'FREESTYLE'], (optional)) – Edge Tag, The edge flag to tag when selecting the shortest path
use_face_step (boolean, (optional)) – Face Stepping, Traverse connected faces (includes diagonals and edge-rings)
use_topology_distance (boolean, (optional)) – Topology Distance, Find the minimum number of steps, ignoring spatial distance
use_fill (boolean, (optional)) – Fill Region, Select all paths between the source/destination elements
skip (int in [0, inf], (optional)) – Deselected, Number of deselected elements in the repetitive sequence
nth (int in [1, inf], (optional)) – Selected, Number of selected elements in the repetitive sequence
offset (int in [-inf, inf], (optional)) – Offset, Offset from the starting point

bpy.ops.mesh.smooth_normals(factor=0.5)#

Smooth custom normals based on adjacent vertex normals

Parameters:: factor (float in [0, 1], (optional)) – Factor, Specifies weight of smooth vs original normal

bpy.ops.mesh.solidify(thickness=0.01)#

Create a solid skin by extruding, compensating for sharp angles

Parameters:: thickness (float in [-10000, 10000], (optional)) – Thickness

bpy.ops.mesh.sort_elements(type='VIEW_ZAXIS', elements={'VERT'}, reverse=False, seed=0)#

The order of selected vertices/edges/faces is modified, based on a given method

Parameters:

type (enum in ['VIEW_ZAXIS', 'VIEW_XAXIS', 'CURSOR_DISTANCE', 'MATERIAL', 'SELECTED', 'RANDOMIZE', 'REVERSE'], (optional)) –
Type, Type of reordering operation to apply
- VIEW_ZAXIS View Z Axis – Sort selected elements from farthest to nearest one in current view.
- VIEW_XAXIS View X Axis – Sort selected elements from left to right one in current view.
- CURSOR_DISTANCE Cursor Distance – Sort selected elements from nearest to farthest from 3D cursor.
- MATERIAL Material – Sort selected faces from smallest to greatest material index.
- SELECTED Selected – Move all selected elements in first places, preserving their relative order. Warning: This will affect unselected elements’ indices as well.
- RANDOMIZE Randomize – Randomize order of selected elements.
- REVERSE Reverse – Reverse current order of selected elements.
elements (enum set in {'VERT', 'EDGE', 'FACE'}, (optional)) – Elements, Which elements to affect (vertices, edges and/or faces)
reverse (boolean, (optional)) – Reverse, Reverse the sorting effect
seed (int in [0, inf], (optional)) – Seed, Seed for random-based operations

bpy.ops.mesh.spin(steps=12, dupli=False, angle=1.5708, use_auto_merge=True, use_normal_flip=False, center=(0.0, 0.0, 0.0), axis=(0.0, 0.0, 0.0))#

Extrude selected vertices in a circle around the cursor in indicated viewport

Parameters:

steps (int in [0, 1000000], (optional)) – Steps, Steps
dupli (boolean, (optional)) – Use Duplicates
angle (float in [-inf, inf], (optional)) – Angle, Rotation for each step
use_auto_merge (boolean, (optional)) – Auto Merge, Merge first/last when the angle is a full revolution
use_normal_flip (boolean, (optional)) – Flip Normals
center (mathutils.Vector of 3 items in [-inf, inf], (optional)) – Center, Center in global view space
axis (mathutils.Vector of 3 items in [-1, 1], (optional)) – Axis, Axis in global view space

bpy.ops.mesh.split()#: Split off selected geometry from connected unselected geometry

bpy.ops.mesh.split_normals()#: Split custom normals of selected vertices

bpy.ops.mesh.subdivide(number_cuts=1, smoothness=0.0, ngon=True, quadcorner='STRAIGHT_CUT', fractal=0.0, fractal_along_normal=0.0, seed=0)#

Subdivide selected edges

Parameters:

number_cuts (int in [1, 100], (optional)) – Number of Cuts
smoothness (float in [0, 1000], (optional)) – Smoothness, Smoothness factor
ngon (boolean, (optional)) – Create N-Gons, When disabled, newly created faces are limited to 3 and 4 sided faces
quadcorner (enum in ['INNERVERT', 'PATH', 'STRAIGHT_CUT', 'FAN'], (optional)) – Quad Corner Type, How to subdivide quad corners (anything other than Straight Cut will prevent n-gons)
fractal (float in [0, 1e+06], (optional)) – Fractal, Fractal randomness factor
fractal_along_normal (float in [0, 1], (optional)) – Along Normal, Apply fractal displacement along normal only
seed (int in [0, inf], (optional)) – Random Seed, Seed for the random number generator

bpy.ops.mesh.subdivide_edgering(number_cuts=10, interpolation='PATH', smoothness=1.0, profile_shape_factor=0.0, profile_shape='SMOOTH')#

Subdivide perpendicular edges to the selected edge-ring

Parameters:

number_cuts (int in [0, 1000], (optional)) – Number of Cuts
interpolation (enum in ['LINEAR', 'PATH', 'SURFACE'], (optional)) – Interpolation, Interpolation method
smoothness (float in [0, 1000], (optional)) – Smoothness, Smoothness factor
profile_shape_factor (float in [-1000, 1000], (optional)) – Profile Factor, How much intermediary new edges are shrunk/expanded
profile_shape (enum in Proportional Falloff Curve Only Items, (optional)) – Profile Shape, Shape of the profile

bpy.ops.mesh.symmetrize(direction='NEGATIVE_X', threshold=0.0001)#

Enforce symmetry (both form and topological) across an axis

Parameters:

direction (enum in Symmetrize Direction Items, (optional)) – Direction, Which sides to copy from and to
threshold (float in [0, 10], (optional)) – Threshold, Limit for snap middle vertices to the axis center

bpy.ops.mesh.symmetry_snap(direction='NEGATIVE_X', threshold=0.05, factor=0.5, use_center=True)#

Snap vertex pairs to their mirrored locations

Parameters:

direction (enum in Symmetrize Direction Items, (optional)) – Direction, Which sides to copy from and to
threshold (float in [0, 10], (optional)) – Threshold, Distance within which matching vertices are searched
factor (float in [0, 1], (optional)) – Factor, Mix factor of the locations of the vertices
use_center (boolean, (optional)) – Center, Snap middle vertices to the axis center

bpy.ops.mesh.tris_convert_to_quads(face_threshold=0.698132, shape_threshold=0.698132, uvs=False, vcols=False, seam=False, sharp=False, materials=False)#

Join triangles into quads

Parameters:

face_threshold (float in [0, 3.14159], (optional)) – Max Face Angle, Face angle limit
shape_threshold (float in [0, 3.14159], (optional)) – Max Shape Angle, Shape angle limit
uvs (boolean, (optional)) – Compare UVs
vcols (boolean, (optional)) – Compare Color Attributes
seam (boolean, (optional)) – Compare Seam
sharp (boolean, (optional)) – Compare Sharp
materials (boolean, (optional)) – Compare Materials

bpy.ops.mesh.unsubdivide(iterations=2)#

Un-subdivide selected edges and faces

Parameters:: iterations (int in [1, 1000], (optional)) – Iterations, Number of times to un-subdivide

bpy.ops.mesh.uv_texture_add()#: Add UV map

bpy.ops.mesh.uv_texture_remove()#: Remove UV map

bpy.ops.mesh.uvs_reverse()#: Flip direction of UV coordinates inside faces

bpy.ops.mesh.uvs_rotate(use_ccw=False)#

Rotate UV coordinates inside faces

Parameters:: use_ccw (boolean, (optional)) – Counter Clockwise

bpy.ops.mesh.vert_connect()#: Connect selected vertices of faces, splitting the face

bpy.ops.mesh.vert_connect_concave()#: Make all faces convex

bpy.ops.mesh.vert_connect_nonplanar(angle_limit=0.0872665)#

Split non-planar faces that exceed the angle threshold

Parameters:: angle_limit (float in [0, 3.14159], (optional)) – Max Angle, Angle limit

bpy.ops.mesh.vert_connect_path()#: Connect vertices by their selection order, creating edges, splitting faces

bpy.ops.mesh.vertices_smooth(factor=0.0, repeat=1, xaxis=True, yaxis=True, zaxis=True, wait_for_input=True)#

Flatten angles of selected vertices

Parameters:

factor (float in [-10, 10], (optional)) – Smoothing, Smoothing factor
repeat (int in [1, 1000], (optional)) – Repeat, Number of times to smooth the mesh
xaxis (boolean, (optional)) – X-Axis, Smooth along the X axis
yaxis (boolean, (optional)) – Y-Axis, Smooth along the Y axis
zaxis (boolean, (optional)) – Z-Axis, Smooth along the Z axis
wait_for_input (boolean, (optional)) – Wait for Input

bpy.ops.mesh.vertices_smooth_laplacian(repeat=1, lambda_factor=1.0, lambda_border=5e-05, use_x=True, use_y=True, use_z=True, preserve_volume=True)#

Laplacian smooth of selected vertices

Parameters:

repeat (int in [1, 1000], (optional)) – Number of iterations to smooth the mesh
lambda_factor (float in [1e-07, 1000], (optional)) – Lambda factor
lambda_border (float in [1e-07, 1000], (optional)) – Lambda factor in border
use_x (boolean, (optional)) – Smooth X Axis, Smooth object along X axis
use_y (boolean, (optional)) – Smooth Y Axis, Smooth object along Y axis
use_z (boolean, (optional)) – Smooth Z Axis, Smooth object along Z axis
preserve_volume (boolean, (optional)) – Preserve Volume, Apply volume preservation after smooth

bpy.ops.mesh.wireframe(use_boundary=True, use_even_offset=True, use_relative_offset=False, use_replace=True, thickness=0.01, offset=0.01, use_crease=False, crease_weight=0.01)#

Create a solid wireframe from faces

Parameters:

use_boundary (boolean, (optional)) – Boundary, Inset face boundaries
use_even_offset (boolean, (optional)) – Offset Even, Scale the offset to give more even thickness
use_relative_offset (boolean, (optional)) – Offset Relative, Scale the offset by surrounding geometry
use_replace (boolean, (optional)) – Replace, Remove original faces
thickness (float in [0, 10000], (optional)) – Thickness
offset (float in [0, 10000], (optional)) – Offset
use_crease (boolean, (optional)) – Crease, Crease hub edges for an improved subdivision surface
crease_weight (float in [0, 1000], (optional)) – Crease Weight