Mesh Operators

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 vert Normals.
    • FACE_AREA Face Area, Set all vert normals by Face Area.
    • CORNER_ANGLE Corner Angle, Set all vert 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, offset_pct=0.0, segments=1, profile=0.5, vertex_only=False, 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, release_confirm=False)

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

Parameters:
  • offset_type (enum in ['OFFSET', 'WIDTH', 'DEPTH', 'PERCENT'], (optional)) –

    Width Type, What distance Width measures

    • 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.
  • offset (float in [0, 1e+06], (optional)) – Width, Bevel amount
  • 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)
  • vertex_only (boolean, (optional)) – Vertex Only, Bevel only vertices
  • clamp_overlap (boolean, (optional)) – Clamp Overlap, Do not allow beveled edges/vertices to overlap each other
  • loop_slide (boolean, (optional)) – Loop Slide, Prefer slide along edge 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, 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
  • 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, cursor=1002)

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

Parameters:
  • plane_co (float array of 3 items in [-inf, inf], (optional)) – Plane Point, A point on the plane
  • plane_no (float array 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
  • 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 ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR'], (optional)) –

    Profile Shape, Shape of the profile

    • SMOOTH Smooth, Smooth falloff.
    • SPHERE Sphere, Spherical falloff.
    • ROOT Root, Root falloff.
    • INVERSE_SQUARE Inverse Square, Inverse Square falloff.
    • SHARP Sharp, Sharp falloff.
    • LINEAR Linear, Linear falloff.
bpy.ops.mesh.colors_reverse()

Flip direction of vertex colors inside faces

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

Rotate vertex colors 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 VCols
  • 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 ['X', 'Y', 'Z'], (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 Verts, 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 Verts, Dissolve remaining vertices
bpy.ops.mesh.dissolve_limited(angle_limit=0.0872665, use_dissolve_boundaries=False, delimit={'NORMAL'})

Dissolve selected edges and verts, 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 {'NORMAL', 'MATERIAL', 'SEAM', 'SHARP', 'UV'}, (optional)) –

    Delimit, Delimit dissolve operation

    • NORMAL Regular, Delimit by face directions.
    • MATERIAL Material, Delimit by face material.
    • SEAM Seam, Delimit by edge seams.
    • SHARP Sharp, Delimit by sharp edges.
    • UV UVs, Delimit by UV coordinates.
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 Verts, 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 verts, 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 selected edges

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()

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

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, mirror=False)

Extrude selection

Parameters:
  • use_normal_flip (boolean, (optional)) – Flip Normals
  • 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_region(use_normal_flip=False, mirror=False)

Extrude region of faces

Parameters:
  • use_normal_flip (boolean, (optional)) – Flip Normals
  • 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(offset=2.0, steps=10)

Extrude selected vertices, edges or faces repeatedly

Parameters:
  • offset (float in [0, inf], (optional)) – Offset
  • steps (int in [0, 1000000], (optional)) – Steps
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_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:147

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()

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

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)

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
bpy.ops.mesh.intersect_boolean(operation='DIFFERENCE', use_swap=False, threshold=1e-06)

Cut solid geometry from selected to unselected

Parameters:
  • operation (enum in ['INTERSECT', 'UNION', 'DIFFERENCE'], (optional)) – Boolean
  • use_swap (boolean, (optional)) – Swap, Use with difference intersection to swap which side is kept
  • threshold (float in [0, 0.01], (optional)) – Merge threshold
bpy.ops.mesh.knife_project(cut_through=False)

Use other objects outlines & 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, 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
  • 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 ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR'], (optional)) –

    Falloff, Falloff type the feather

    • SMOOTH Smooth, Smooth falloff.
    • SPHERE Sphere, Spherical falloff.
    • ROOT Root, Root falloff.
    • INVERSE_SQUARE Inverse Square, Inverse Square falloff.
    • SHARP Sharp, Sharp falloff.
    • LINEAR Linear, Linear falloff.
  • 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 ['FIRST', 'LAST', 'CENTER', 'CURSOR', 'COLLAPSE'], (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 buffer.
    • PASTE Paste Normal, Paste normal from buffer.
    • ADD Add Normal, Add normal vector with selection.
    • MULTIPLY Multiply Normal, Multiply normal vector with selection.
    • RESET Reset Normal, Reset buffer and/or normal of selected element.
  • absolute (boolean, (optional)) – Absolute Coordinates, Copy Absolute coordinates or 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.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 (float array 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 contribute <https://developer.blender.org/T51061>

Parameters:
  • mirror (boolean, (optional)) – Mirror Editing
  • use_proportional_edit (boolean, (optional)) – Proportional Editing
  • proportional_edit_falloff (enum in ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'], (optional)) –

    Proportional Falloff, Falloff type for proportional editing mode

    • SMOOTH Smooth, Smooth falloff.
    • SPHERE Sphere, Spherical falloff.
    • ROOT Root, Root falloff.
    • INVERSE_SQUARE Inverse Square, Inverse Square falloff.
    • SHARP Sharp, Sharp falloff.
    • LINEAR Linear, Linear falloff.
    • CONSTANT Constant, Constant falloff.
    • RANDOM Random, Random falloff.
  • 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 contribute <https://developer.blender.org/T51061>

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 contribute <https://developer.blender.org/T51061>

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 contribute <https://developer.blender.org/T51061>

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 ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'], (optional)) –

    Proportional Falloff, Falloff type for proportional editing mode

    • SMOOTH Smooth, Smooth falloff.
    • SPHERE Sphere, Spherical falloff.
    • ROOT Root, Root falloff.
    • INVERSE_SQUARE Inverse Square, Inverse Square falloff.
    • SHARP Sharp, Sharp falloff.
    • LINEAR Linear, Linear falloff.
    • CONSTANT Constant, Constant falloff.
    • RANDOM Random, Random falloff.
  • 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 contribute <https://developer.blender.org/T51061>

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 contribute <https://developer.blender.org/T51061>

Parameters:
  • mirror (boolean, (optional)) – Mirror Editing
  • use_proportional_edit (boolean, (optional)) – Proportional Editing
  • proportional_edit_falloff (enum in ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'], (optional)) –

    Proportional Falloff, Falloff type for proportional editing mode

    • SMOOTH Smooth, Smooth falloff.
    • SPHERE Sphere, Spherical falloff.
    • ROOT Root, Root falloff.
    • INVERSE_SQUARE Inverse Square, Inverse Square falloff.
    • SHARP Sharp, Sharp falloff.
    • LINEAR Linear, Linear falloff.
    • CONSTANT Constant, Constant falloff.
    • RANDOM Random, Random falloff.
  • 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 contribute <https://developer.blender.org/T51061>

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 contribute <https://developer.blender.org/T51061>

Parameters:
  • mirror (boolean, (optional)) – Mirror Editing
  • use_proportional_edit (boolean, (optional)) – Proportional Editing
  • proportional_edit_falloff (enum in ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'], (optional)) –

    Proportional Falloff, Falloff type for proportional editing mode

    • SMOOTH Smooth, Smooth falloff.
    • SPHERE Sphere, Spherical falloff.
    • ROOT Root, Root falloff.
    • INVERSE_SQUARE Inverse Square, Inverse Square falloff.
    • SHARP Sharp, Sharp falloff.
    • LINEAR Linear, Linear falloff.
    • CONSTANT Constant, Constant falloff.
    • RANDOM Random, Random falloff.
  • 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 contribute <https://developer.blender.org/T51061>

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))

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 Ngon, Use ngons.
    • TRIFAN Triangle Fan, Use triangle fans.
  • calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
  • enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode 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 (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
  • rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation 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))

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 Ngon, Use ngons.
    • TRIFAN Triangle Fan, Use triangle fans.
  • calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
  • enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode 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 (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
  • rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation 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))

Construct a cube 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 Editmode, Enter editmode 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 (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
  • rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation 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), 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 Editmode, Enter editmode 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 (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
  • rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added object
  • matrix (float multi-dimensional array 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))

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 Ngon, Use ngons.
    • TRIFAN Triangle Fan, Use triangle fans.
  • calc_uvs (boolean, (optional)) – Generate UVs, Generate a default UV map
  • enter_editmode (boolean, (optional)) – Enter Editmode, Enter editmode 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 (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
  • rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation 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))

Construct a grid mesh

Parameters:
  • x_subdivisions (int in [2, 10000000], (optional)) – X Subdivisions
  • y_subdivisions (int in [2, 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 Editmode, Enter editmode 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 (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
  • rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation 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))

Construct an Icosphere mesh

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 Editmode, Enter editmode 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 (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
  • rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation 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))

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 Editmode, Enter editmode 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 (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
  • rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation 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))

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 Editmode, Enter editmode 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 (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
  • rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation 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)

Add 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 (float array of 3 items in [-inf, inf], (optional)) – Location
  • rotation (float array 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)) –

    Torus Dimensions

    • 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.01, 100], (optional)) – Major Radius, Radius from the origin to the center of the cross sections
  • minor_radius (float in [0.01, 100], (optional)) – Minor Radius, Radius of the torus’ cross section
  • abso_major_rad (float in [0.01, 100], (optional)) – Exterior Radius, Total Exterior Radius of the torus
  • abso_minor_rad (float in [0.01, 100], (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:248

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))

Construct a UV sphere mesh

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 Editmode, Enter editmode 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 (float array of 3 items in [-inf, inf], (optional)) – Location, Location for the newly added object
  • rotation (float array of 3 items in [-inf, inf], (optional)) – Rotation, Rotation 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 ['BEAUTY', 'FIXED', 'FIXED_ALTERNATE', 'SHORTEST_DIAGONAL'], (optional)) –

    Quad Method, Method for splitting the quads into triangles

    • BEAUTY Beauty , Split the quads in nice triangles, slower method.
    • FIXED Fixed, Split the quads on the first and third vertices.
    • FIXED_ALTERNATE Fixed Alternate, Split the quads on the 2nd and 4th vertices.
    • SHORTEST_DIAGONAL Shortest Diagonal, Split the quads based on the distance between the vertices.
  • ngon_method (enum in ['BEAUTY', 'CLIP'], (optional)) –

    Polygon Method, Method for splitting the polygons into triangles

    • BEAUTY Beauty, Arrange the new triangles evenly (slow).
    • CLIP Clip, Split the polygons with an ear clipping algorithm.
bpy.ops.mesh.region_to_loop()

Select boundary edges around the selected faces

bpy.ops.mesh.remove_doubles(threshold=0.0001, use_unselected=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
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 ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'], (optional)) –

    Proportional Falloff, Falloff type for proportional editing mode

    • SMOOTH Smooth, Smooth falloff.
    • SPHERE Sphere, Spherical falloff.
    • ROOT Root, Root falloff.
    • INVERSE_SQUARE Inverse Square, Inverse Square falloff.
    • SHARP Sharp, Sharp falloff.
    • LINEAR Linear, Linear falloff.
    • CONSTANT Constant, Constant falloff.
    • RANDOM Random, Random falloff.
  • 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 ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR', 'CONSTANT', 'RANDOM'], (optional)) –

    Proportional Falloff, Falloff type for proportional editing mode

    • SMOOTH Smooth, Smooth falloff.
    • SPHERE Sphere, Spherical falloff.
    • ROOT Root, Root falloff.
    • INVERSE_SQUARE Inverse Square, Inverse Square falloff.
    • SHARP Sharp, Sharp falloff.
    • LINEAR Linear, Linear falloff.
    • CONSTANT Constant, Constant falloff.
    • RANDOM Random, Random falloff.
  • 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 (float array of 3 items in [-inf, inf], (optional)) – Center, Center in global view space
  • axis (float array 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 ['GLOBAL', 'LOCAL', 'NORMAL', 'GIMBAL', 'VIEW', 'CURSOR'], (optional)) –

    Axis Mode, Axis orientation

    • GLOBAL Global, Align the transformation axes to world space.
    • LOCAL Local, Align the transformation axes to the selected objects’ local space.
    • NORMAL Normal, Align the transformation axes to average normal of selected elements (bone Y axis for pose mode).
    • GIMBAL Gimbal, Align each axis to the Euler rotation axis as used for input.
    • VIEW View, Align the transformation axes to the window.
    • CURSOR Cursor, Align the transformation axes to the 3D cursor.
  • sign (enum in ['POS', 'NEG', 'ALIGN'], (optional)) – Axis Sign, Side to select
  • axis (enum in ['X', 'Y', 'Z'], (optional)) – Axis, Select the axis to compare each vertex on
  • threshold (float in [1e-06, 50], (optional)) – Threshold
bpy.ops.mesh.select_face_by_sides(number=4, type='EQUAL', extend=True)

Select vertices or faces by the number of polygon 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 {'NORMAL', 'MATERIAL', 'SEAM', 'SHARP', 'UV'}, (optional)) –

Delimit, Delimit selected region

  • NORMAL Regular, Delimit by face directions.
  • MATERIAL Material, Delimit by face material.
  • SEAM Seam, Delimit by edge seams.
  • SHARP Sharp, Delimit by sharp edges.
  • UV UVs, Delimit by UV coordinates.
bpy.ops.mesh.select_linked_pick(deselect=False, delimit={'SEAM'}, index=-1)

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

Parameters:
  • deselect (boolean, (optional)) – Deselect
  • delimit (enum set in {'NORMAL', 'MATERIAL', 'SEAM', 'SHARP', 'UV'}, (optional)) –

    Delimit, Delimit selected region

    • NORMAL Regular, Delimit by face directions.
    • MATERIAL Material, Delimit by face material.
    • SEAM Seam, Delimit by edge seams.
    • SHARP Sharp, Delimit by sharp edges.
    • UV UVs, Delimit by UV coordinates.
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 {'X', 'Y', 'Z'}, (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 ['VERT', 'EDGE', 'FACE'], (optional)) –

    Type

    • VERT Vertex, Vertex selection mode.
    • EDGE Edge, Edge selection mode.
    • FACE Face, Face selection mode.
  • 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:215
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 3+ 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:240
bpy.ops.mesh.select_random(percent=50.0, seed=0, action='SELECT')

Randomly select vertices

Parameters:
  • percent (float in [0, 100], (optional)) – Percent, Percentage of objects 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='NORMAL', compare='EQUAL', threshold=0.0)

Select similar vertices, edges or faces by property types

Parameters:
  • type (enum in ['NORMAL', 'FACE', 'VGROUP', 'EDGE', 'LENGTH', 'DIR', 'FACE', 'FACE_ANGLE', 'CREASE', 'BEVEL', 'SEAM', 'SHARP', 'FREESTYLE_EDGE', 'MATERIAL', 'AREA', 'SIDES', 'PERIMETER', 'NORMAL', 'COPLANAR', 'SMOOTH', 'FACE_MAP', 'FREESTYLE_FACE'], (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.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.smoothen_normals(factor=0.5)

Smoothen 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 re-ordering 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 elements from smallest to greatest material index (faces only!).
    • 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=9, 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)) – Duplicate, Make 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 (float array of 3 items in [-inf, inf], (optional)) – Center, Center in global view space
  • axis (float array 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-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 ngons)
  • 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 ['SMOOTH', 'SPHERE', 'ROOT', 'INVERSE_SQUARE', 'SHARP', 'LINEAR'], (optional)) –

    Profile Shape, Shape of the profile

    • SMOOTH Smooth, Smooth falloff.
    • SPHERE Sphere, Spherical falloff.
    • ROOT Root, Root falloff.
    • INVERSE_SQUARE Inverse Square, Inverse Square falloff.
    • SHARP Sharp, Sharp falloff.
    • LINEAR Linear, Linear falloff.
bpy.ops.mesh.symmetrize(direction='NEGATIVE_X', threshold=0.0001)

Enforce symmetry (both form and topological) across an axis

Parameters:
  • direction (enum in ['NEGATIVE_X', 'POSITIVE_X', 'NEGATIVE_Y', 'POSITIVE_Y', 'NEGATIVE_Z', 'POSITIVE_Z'], (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 ['NEGATIVE_X', 'POSITIVE_X', 'NEGATIVE_Y', 'POSITIVE_Y', 'NEGATIVE_Z', 'POSITIVE_Z'], (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 VCols
  • seam (boolean, (optional)) – Compare Seam
  • sharp (boolean, (optional)) – Compare Sharp
  • materials (boolean, (optional)) – Compare Materials
bpy.ops.mesh.unsubdivide(iterations=2)

UnSubdivide selected edges & faces

Parameters:iterations (int in [1, 1000], (optional)) – Iterations, Number of times to unsubdivide
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.vertex_color_add()

Add vertex color layer

bpy.ops.mesh.vertex_color_remove()

Remove vertex color layer

bpy.ops.mesh.vertices_smooth(factor=0.5, repeat=1, xaxis=True, yaxis=True, zaxis=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
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 wire-frame 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 improved subsurf
  • crease_weight (float in [0, 1000], (optional)) – Crease weight