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 planeplane_no (
mathutils.Vector
of 3 items in [-1, 1], (optional)) – Plane Normal, The direction the plane pointsuse_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, topology_influence=0.0, uvs=False, vcols=False, seam=False, sharp=False, materials=False, deselect_joined=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
topology_influence (float in [0, 2], (optional)) – Topology Influence, How much to prioritize regular grids of quads as well as quads that touch existing quads
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
deselect_joined (boolean, (optional)) – Deselect Joined, Only select remaining triangles that were not merged
- 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 facesTRANSFORM_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 selectionTRANSFORM_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 onlyTRANSFORM_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 onlyTRANSFORM_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 facesTRANSFORM_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 facesTRANSFORM_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 facesTRANSFORM_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 vectorscale_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 onlyTRANSFORM_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:
- 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 loopsTRANSFORM_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
Remove navmesh data from this mesh
Add a new index and assign it to selected faces
Copy the index from the active face
Create navigation mesh for selected objects
Assign a new index to every face
- 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 selectionTRANSFORM_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 pointspherize (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 CursorMESH_OT_extrude_edges_indiv (
MESH_OT_extrude_edges_indiv
, (optional)) – Extrude Only Edges, Extrude individual edges onlyTRANSFORM_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 CursorTRANSFORM_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 CursorTRANSFORM_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 CursorTRANSFORM_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 objectrotation (
mathutils.Euler
rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added objectscale (
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 objectrotation (
mathutils.Euler
rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added objectscale (
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 objectrotation (
mathutils.Euler
rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added objectscale (
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 objectrotation (
mathutils.Euler
rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added objectscale (
mathutils.Vector
of 3 items in [-inf, inf], (optional)) – Scale, Scale for the newly added objectmatrix (
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 objectrotation (
mathutils.Euler
rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added objectscale (
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 objectrotation (
mathutils.Euler
rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added objectscale (
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 objectrotation (
mathutils.Euler
rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added objectscale (
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 objectrotation (
mathutils.Euler
rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added objectscale (
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 objectrotation (
mathutils.Euler
rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added objectscale (
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)) – Locationrotation (
mathutils.Euler
rotation of 3 items in [-inf, inf], (optional)) – Rotationmajor_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:
- 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 objectrotation (
mathutils.Euler
rotation of 3 items in [-inf, inf], (optional)) – Rotation, Rotation for the newly added objectscale (
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 cursorTRANSFORM_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 geometryTRANSFORM_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 spaceaxis (
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_by_pole_count(*, pole_count=4, type='NOTEQUAL', extend=False, exclude_nonmanifold=True)¶
Select vertices at poles by the number of connected edges. In edge and face mode the geometry connected to the vertices is selected
- Parameters:
pole_count (int in [0, inf], (optional)) – Pole Count
type (enum in ['LESS', 'EQUAL', 'GREATER', 'NOTEQUAL'], (optional)) – Type, Type of comparison to make
extend (boolean, (optional)) – Extend, Extend the selection
exclude_nonmanifold (boolean, (optional)) – Exclude Non Manifold, Exclude non-manifold poles
- 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)
- 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)
- 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 spaceaxis (
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, topology_influence=0.0, uvs=False, vcols=False, seam=False, sharp=False, materials=False, deselect_joined=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
topology_influence (float in [0, 2], (optional)) – Topology Influence, How much to prioritize regular grids of quads as well as quads that touch existing quads
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
deselect_joined (boolean, (optional)) – Deselect Joined, Only select remaining triangles that were not merged
- 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