griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cleanup: wrap long lines in operator tests

Browse Source
This commit is contained in:
Campbell Barton
2025-07-11 17:13:50 +10:00
parent 808cc599f8
commit 7323ebf192
1 changed files with 642 additions and 304 deletions
Download Patch File Download Diff File Expand all files Collapse all files

946
tests/python/operators.py
View File

@@ -13,264 +13,346 @@ sys.path.append(os.path.dirname(os.path.realpath(__file__)))
from modules.mesh_test import SpecMeshTest, OperatorSpecEditMode, RunTest from modules.mesh_test import SpecMeshTest, OperatorSpecEditMode, RunTest
# Central vertical loop of Suzanne # Central vertical loop of Suzanne
MONKEY_LOOP_VERT = {68, 69, 71, 73, 74, 75, 76, 77, 90, 129, 136, 175, 188, 189, 198, 207, MONKEY_LOOP_VERT = {
216, 223, 230, 301, 302, 303, 304, 305, 306, 307, 308} 68, 69, 71, 73, 74, 75, 76, 77, 90, 129, 136, 175, 188, 189, 198, 207,
MONKEY_LOOP_EDGE = {131, 278, 299, 305, 307, 334, 337, 359, 384, 396, 399, 412, 415, 560, 216, 223, 230, 301, 302, 303, 304, 305, 306, 307, 308,
567, 572, 577, 615, 622, 627, 632, 643, 648, 655, 660, 707} }
MONKEY_LOOP_EDGE = {
131, 278, 299, 305, 307, 334, 337, 359, 384, 396, 399, 412, 415, 560,
567, 572, 577, 615, 622, 627, 632, 643, 648, 655, 660, 707,
}
def main(): def main():
tests = [ tests = [
# bisect # bisect
SpecMeshTest( SpecMeshTest(
"CubeBisect", "testCubeBisect", "expectedCubeBisect", "CubeBisect",
[OperatorSpecEditMode("bisect", "testCubeBisect",
{"plane_co": (0, 0, 0), "plane_no": (0, 1, 1), "clear_inner": True, "expectedCubeBisect",
"use_fill": True}, 'FACE', {0, 1, 2, 3, 4, 5}, )], [
OperatorSpecEditMode(
"bisect",
{"plane_co": (0, 0, 0), "plane_no": (0, 1, 1), "clear_inner": True, "use_fill": True},
'FACE',
{0, 1, 2, 3, 4, 5},
)
],
), ),
# blend from shape # blend from shape
SpecMeshTest( SpecMeshTest(
"CubeBlendFromShape", "testCubeBlendFromShape", "expectedCubeBlendFromShape", "CubeBlendFromShape",
"testCubeBlendFromShape",
"expectedCubeBlendFromShape",
[OperatorSpecEditMode("blend_from_shape", {"shape": "Key 1"}, 'FACE', {0, 1, 2, 3, 4, 5})], [OperatorSpecEditMode("blend_from_shape", {"shape": "Key 1"}, 'FACE', {0, 1, 2, 3, 4, 5})],
), ),
# bridge edge loops # bridge edge loops
SpecMeshTest( SpecMeshTest(
"CubeBridgeEdgeLoop", "testCubeBrigeEdgeLoop", "expectedCubeBridgeEdgeLoop", "CubeBridgeEdgeLoop",
"testCubeBrigeEdgeLoop",
"expectedCubeBridgeEdgeLoop",
[OperatorSpecEditMode("bridge_edge_loops", {}, "FACE", {0, 1})], [OperatorSpecEditMode("bridge_edge_loops", {}, "FACE", {0, 1})],
), ),
# decimate # decimate
SpecMeshTest( SpecMeshTest(
"MonkeyDecimate", "testMonkeyDecimate", "expectedMonkeyDecimate", "MonkeyDecimate",
[OperatorSpecEditMode("decimate", "testMonkeyDecimate",
{"ratio": 0.1}, "FACE", {i for i in range(500)})], "expectedMonkeyDecimate",
[OperatorSpecEditMode("decimate", {"ratio": 0.1}, "FACE", {i for i in range(500)})],
), ),
# delete # delete
SpecMeshTest( SpecMeshTest(
"CubeDeleteVertices", "testCubeDeleteVertices", "expectedCubeDeleteVertices", "CubeDeleteVertices",
"testCubeDeleteVertices",
"expectedCubeDeleteVertices",
[OperatorSpecEditMode("delete", {}, "VERT", {3})], [OperatorSpecEditMode("delete", {}, "VERT", {3})],
), ),
SpecMeshTest( SpecMeshTest(
"CubeDeleteFaces", "testCubeDeleteFaces", "expectedCubeDeleteFaces", "CubeDeleteFaces",
"testCubeDeleteFaces",
"expectedCubeDeleteFaces",
[OperatorSpecEditMode("delete", {}, "FACE", {0})], [OperatorSpecEditMode("delete", {}, "FACE", {0})],
), ),
SpecMeshTest( SpecMeshTest(
"CubeDeleteEdges", "testCubeDeleteEdges", "expectedCubeDeleteEdges", "CubeDeleteEdges",
"testCubeDeleteEdges",
"expectedCubeDeleteEdges",
[OperatorSpecEditMode("delete", {}, "EDGE", {0, 1, 2, 3})], [OperatorSpecEditMode("delete", {}, "EDGE", {0, 1, 2, 3})],
), ),
# delete edge loop # delete edge loop
SpecMeshTest( SpecMeshTest(
"MonkeyDeleteEdgeLoopVertices", "testMokneyDeleteEdgeLoopVertices", "MonkeyDeleteEdgeLoopVertices",
"testMokneyDeleteEdgeLoopVertices",
"expectedMonkeyDeleteEdgeLoopVertices", "expectedMonkeyDeleteEdgeLoopVertices",
[OperatorSpecEditMode("delete_edgeloop", {}, "VERT", MONKEY_LOOP_VERT)], [OperatorSpecEditMode("delete_edgeloop", {}, "VERT", MONKEY_LOOP_VERT)],
), ),
SpecMeshTest( SpecMeshTest(
"MonkeyDeleteEdgeLoopEdges", "testMokneyDeleteEdgeLoopEdges", "MonkeyDeleteEdgeLoopEdges",
"testMokneyDeleteEdgeLoopEdges",
"expectedMonkeyDeleteEdgeLoopEdges", "expectedMonkeyDeleteEdgeLoopEdges",
[OperatorSpecEditMode("delete_edgeloop", {}, "EDGE", MONKEY_LOOP_EDGE)], [OperatorSpecEditMode("delete_edgeloop", {}, "EDGE", MONKEY_LOOP_EDGE)],
), ),
# delete loose # delete loose
SpecMeshTest( SpecMeshTest(
"CubeDeleteLooseVertices", "testCubeDeleteLooseVertices", "CubeDeleteLooseVertices",
"testCubeDeleteLooseVertices",
"expectedCubeDeleteLooseVertices", "expectedCubeDeleteLooseVertices",
[OperatorSpecEditMode("delete_loose", {"use_verts": True, "use_edges": False, "use_faces": False}, [
"VERT", OperatorSpecEditMode(
{i for i in range(12)})], "delete_loose",
{"use_verts": True, "use_edges": False, "use_faces": False},
"VERT",
{i for i in range(12)},
)
],
), ),
SpecMeshTest( SpecMeshTest(
"CubeDeleteLooseEdges", "testCubeDeleteLooseEdges", "CubeDeleteLooseEdges",
"testCubeDeleteLooseEdges",
"expectedCubeDeleteLooseEdges", "expectedCubeDeleteLooseEdges",
[OperatorSpecEditMode("delete_loose", {"use_verts": False, "use_edges": True, "use_faces": False}, [
"EDGE", OperatorSpecEditMode(
{i for i in range(14)})], "delete_loose",
{"use_verts": False, "use_edges": True, "use_faces": False},
"EDGE",
{i for i in range(14)},
)
],
), ),
SpecMeshTest( SpecMeshTest(
"CubeDeleteLooseFaces", "testCubeDeleteLooseFaces", "CubeDeleteLooseFaces",
"testCubeDeleteLooseFaces",
"expectedCubeDeleteLooseFaces", "expectedCubeDeleteLooseFaces",
[OperatorSpecEditMode("delete_loose", {"use_verts": False, "use_edges": False, "use_faces": True}, [
"FACE", OperatorSpecEditMode(
{i for i in range(7)})], "delete_loose",
{"use_verts": False, "use_edges": False, "use_faces": True},
"FACE",
{i for i in range(7)},
)
],
), ),
# dissolve degenerate # dissolve degenerate
SpecMeshTest( SpecMeshTest(
"CubeDissolveDegenerate", "testCubeDissolveDegenerate", "CubeDissolveDegenerate",
"testCubeDissolveDegenerate",
"expectedCubeDissolveDegenerate", "expectedCubeDissolveDegenerate",
[OperatorSpecEditMode("dissolve_degenerate", {}, "VERT", {i for i in range(8)})], [OperatorSpecEditMode("dissolve_degenerate", {}, "VERT", {i for i in range(8)})],
), ),
# dissolve edges # dissolve edges
SpecMeshTest( SpecMeshTest(
"CylinderDissolveEdges.UseVertsFalse", "testCylinderDissolveEdges", "expectedCylinderDissolveEdges.DissolveNoVerts", "CylinderDissolveEdges.UseVertsFalse",
"testCylinderDissolveEdges",
"expectedCylinderDissolveEdges.DissolveNoVerts",
[OperatorSpecEditMode("dissolve_edges", {"use_verts": False}, "EDGE", {0, 5, 6, 9})], [OperatorSpecEditMode("dissolve_edges", {"use_verts": False}, "EDGE", {0, 5, 6, 9})],
), ),
SpecMeshTest( SpecMeshTest(
"CylinderDissolveEdges.AngleThrehsoldNoDissolve", "testCylinderDissolveEdges", "expectedCylinderDissolveEdges.DissolveNoVerts", "CylinderDissolveEdges.AngleThrehsoldNoDissolve",
[OperatorSpecEditMode("dissolve_edges", {"use_verts": True, "testCylinderDissolveEdges",
"angle_threshold": 0}, "EDGE", {0, 5, 6, 9})], "expectedCylinderDissolveEdges.DissolveNoVerts",
[OperatorSpecEditMode("dissolve_edges", {"use_verts": True, "angle_threshold": 0}, "EDGE", {0, 5, 6, 9})],
), ),
SpecMeshTest( SpecMeshTest(
"CylinderDissolveEdges.AngleThresholdSomeDissolve", "testCylinderDissolveEdges", "expectedCylinderDissolveEdges.DissolveThresh.218166", "CylinderDissolveEdges.AngleThresholdSomeDissolve",
[OperatorSpecEditMode("dissolve_edges", {"use_verts": True, "testCylinderDissolveEdges",
"angle_threshold": 0.218166}, "EDGE", {0, 5, 6, 9})], "expectedCylinderDissolveEdges.DissolveThresh.218166",
[
OperatorSpecEditMode(
"dissolve_edges", {"use_verts": True, "angle_threshold": 0.218166}, "EDGE", {0, 5, 6, 9}
)
],
), ),
SpecMeshTest( SpecMeshTest(
"CylinderDissolveEdges.AngleThresholdAllDissolve", "testCylinderDissolveEdges", "expectedCylinderDissolveEdges.DissolveAllVerts", "CylinderDissolveEdges.AngleThresholdAllDissolve",
[OperatorSpecEditMode("dissolve_edges", {"use_verts": True, "testCylinderDissolveEdges",
"angle_threshold": 3.14159}, "EDGE", {0, 5, 6, 9})], "expectedCylinderDissolveEdges.DissolveAllVerts",
[
OperatorSpecEditMode(
"dissolve_edges", {"use_verts": True, "angle_threshold": 3.14159}, "EDGE", {0, 5, 6, 9}
)
],
), ),
# dissolve faces # dissolve faces
SpecMeshTest( SpecMeshTest(
"CubeDissolveFaces", "testCubeDissolveFaces", "expectedCubeDissolveFaces", "CubeDissolveFaces",
"testCubeDissolveFaces",
"expectedCubeDissolveFaces",
[OperatorSpecEditMode("dissolve_faces", {}, "VERT", {5, 34, 47, 49, 83, 91, 95})], [OperatorSpecEditMode("dissolve_faces", {}, "VERT", {5, 34, 47, 49, 83, 91, 95})],
), ),
# dissolve limited # dissolve limited
SpecMeshTest( SpecMeshTest(
"SphereDissolveLimited", "testSphereDissolveLimited", "expectedSphereDissolveLimited", "SphereDissolveLimited",
"testSphereDissolveLimited",
"expectedSphereDissolveLimited",
[OperatorSpecEditMode("dissolve_limited", {"angle_limit": 0.610865}, "FACE", {20, 23, 26, 29, 32})], [OperatorSpecEditMode("dissolve_limited", {"angle_limit": 0.610865}, "FACE", {20, 23, 26, 29, 32})],
), ),
# dissolve mode # dissolve mode
SpecMeshTest( SpecMeshTest(
"PlaneDissolveMode", "testPlaneDissolveMode", "expectedPlaneDissolveMode", "PlaneDissolveMode",
"testPlaneDissolveMode",
"expectedPlaneDissolveMode",
[OperatorSpecEditMode("dissolve_mode", {"use_verts": True}, "FACE", {0, 1, 2, 10, 12, 13})], [OperatorSpecEditMode("dissolve_mode", {"use_verts": True}, "FACE", {0, 1, 2, 10, 12, 13})],
), ),
# dissolve verts # dissolve verts
SpecMeshTest( SpecMeshTest(
"CubeDissolveVerts", "testCubeDissolveVerts", "expectedCubeDissolveVerts", "CubeDissolveVerts",
"testCubeDissolveVerts",
"expectedCubeDissolveVerts",
[OperatorSpecEditMode("dissolve_verts", {}, "VERT", {16, 20, 22, 23, 25})], [OperatorSpecEditMode("dissolve_verts", {}, "VERT", {16, 20, 22, 23, 25})],
), ),
# duplicate # duplicate
SpecMeshTest( SpecMeshTest(
"ConeDuplicateVertices", "testConeDuplicateVertices", "ConeDuplicateVertices",
"testConeDuplicateVertices",
"expectedConeDuplicateVertices", "expectedConeDuplicateVertices",
[OperatorSpecEditMode("duplicate", {}, "VERT", {i for i in range(33)} - {23})], [OperatorSpecEditMode("duplicate", {}, "VERT", {i for i in range(33)} - {23})],
), ),
SpecMeshTest( SpecMeshTest(
"ConeDuplicateOneVertex", "testConeDuplicateOneVertex", "expectedConeDuplicateOneVertex", "ConeDuplicateOneVertex",
"testConeDuplicateOneVertex",
"expectedConeDuplicateOneVertex",
[OperatorSpecEditMode("duplicate", {}, "VERT", {23})], [OperatorSpecEditMode("duplicate", {}, "VERT", {23})],
), ),
SpecMeshTest( SpecMeshTest(
"ConeDuplicateFaces", "testConeDuplicateFaces", "expectedConeDuplicateFaces", "ConeDuplicateFaces",
"testConeDuplicateFaces",
"expectedConeDuplicateFaces",
[OperatorSpecEditMode("duplicate", {}, "FACE", {6, 9})], [OperatorSpecEditMode("duplicate", {}, "FACE", {6, 9})],
), ),
SpecMeshTest( SpecMeshTest(
"ConeDuplicateEdges", "testConeDuplicateEdges", "expectedConeDuplicateEdges", "ConeDuplicateEdges",
"testConeDuplicateEdges",
"expectedConeDuplicateEdges",
[OperatorSpecEditMode("duplicate", {}, "EDGE", {i for i in range(64)})], [OperatorSpecEditMode("duplicate", {}, "EDGE", {i for i in range(64)})],
), ),
# edge collapse # edge collapse
SpecMeshTest( SpecMeshTest(
"CylinderEdgeCollapse", "testCylinderEdgeCollapse", "expectedCylinderEdgeCollapse", "CylinderEdgeCollapse",
"testCylinderEdgeCollapse",
"expectedCylinderEdgeCollapse",
[OperatorSpecEditMode("edge_collapse", {}, "EDGE", {1, 9, 4})], [OperatorSpecEditMode("edge_collapse", {}, "EDGE", {1, 9, 4})],
), ),
# edge face add # edge face add
SpecMeshTest( SpecMeshTest(
"CubeEdgeFaceAddFace", "testCubeEdgeFaceAddFace", "expectedCubeEdgeFaceAddFace", "CubeEdgeFaceAddFace",
"testCubeEdgeFaceAddFace",
"expectedCubeEdgeFaceAddFace",
[OperatorSpecEditMode("edge_face_add", {}, "VERT", {1, 3, 4, 5, 7})], [OperatorSpecEditMode("edge_face_add", {}, "VERT", {1, 3, 4, 5, 7})],
), ),
SpecMeshTest( SpecMeshTest(
"CubeEdgeFaceAddEdge", "testCubeEdgeFaceAddEdge", "expectedCubeEdgeFaceAddEdge", "CubeEdgeFaceAddEdge",
"testCubeEdgeFaceAddEdge",
"expectedCubeEdgeFaceAddEdge",
[OperatorSpecEditMode("edge_face_add", {}, "VERT", {4, 5})], [OperatorSpecEditMode("edge_face_add", {}, "VERT", {4, 5})],
), ),
# edge rotate # edge rotate
SpecMeshTest( SpecMeshTest(
"CubeEdgeRotate", "testCubeEdgeRotate", "expectedCubeEdgeRotate", "CubeEdgeRotate",
"testCubeEdgeRotate",
"expectedCubeEdgeRotate",
[OperatorSpecEditMode("edge_rotate", {}, "EDGE", {1})], [OperatorSpecEditMode("edge_rotate", {}, "EDGE", {1})],
), ),
# edge split # edge split
SpecMeshTest( SpecMeshTest(
"CubeEdgeSplit", "testCubeEdgeSplit", "expectedCubeEdgeSplit", "CubeEdgeSplit",
"testCubeEdgeSplit",
"expectedCubeEdgeSplit",
[OperatorSpecEditMode("edge_split", {}, "EDGE", {2, 5, 8, 11, 14, 17, 20, 23})], [OperatorSpecEditMode("edge_split", {}, "EDGE", {2, 5, 8, 11, 14, 17, 20, 23})],
), ),
# edge ring select - Cannot be tested. Need user input. # edge ring select - Cannot be tested. Need user input.
# SpecMeshTest("CubeEdgeRingSelect", "testCubeEdgeRingSelect", "expectedCubeEdgeRingSelect", # SpecMeshTest(
# [OperatorSpecEditMode("edgering_select", {}, "EDGE", {5, 20, 25, 26})]), # "CubeEdgeRingSelect",
# SpecMeshTest("EmptyMeshEdgeRingSelect", "testGridEdgeRingSelect", "expectedGridEdgeRingSelect", # "testCubeEdgeRingSelect",
# [OperatorSpecEditMode("edgering_select", {}, "VERT", {65, 66, 67})]), # "expectedCubeEdgeRingSelect",
# SpecMeshTest("EmptyMeshEdgeRingSelect", "testEmptyMeshdgeRingSelect", "expectedEmptyMeshEdgeRingSelect", # [OperatorSpecEditMode("edgering_select", {}, "EDGE", {5, 20, 25, 26})],
# [OperatorSpecEditMode("edgering_select", {}, "VERT", {})]), # ),
# SpecMeshTest(
# "EmptyMeshEdgeRingSelect",
# "testGridEdgeRingSelect",
# "expectedGridEdgeRingSelect",
# [OperatorSpecEditMode("edgering_select", {}, "VERT", {65, 66, 67})],
# ),
# SpecMeshTest(
# "EmptyMeshEdgeRingSelect",
# "testEmptyMeshdgeRingSelect",
# "expectedEmptyMeshEdgeRingSelect",
# [OperatorSpecEditMode("edgering_select", {}, "VERT", {})],
# ),
# edges select sharp # edges select sharp
SpecMeshTest( SpecMeshTest(
"CubeEdgesSelectSharp", "testCubeEdgeSelectSharp", "expectedCubeEdgeSelectSharp", "CubeEdgesSelectSharp",
"testCubeEdgeSelectSharp",
"expectedCubeEdgeSelectSharp",
[OperatorSpecEditMode("edges_select_sharp", {}, "EDGE", {20})], [OperatorSpecEditMode("edges_select_sharp", {}, "EDGE", {20})],
), ),
SpecMeshTest( SpecMeshTest(
"SphereEdgesSelectSharp", "testSphereEdgesSelectSharp", "expectedSphereEdgeSelectSharp", "SphereEdgesSelectSharp",
"testSphereEdgesSelectSharp",
"expectedSphereEdgeSelectSharp",
[OperatorSpecEditMode("edges_select_sharp", {"sharpness": 0.25}, "EDGE", {288})], [OperatorSpecEditMode("edges_select_sharp", {"sharpness": 0.25}, "EDGE", {288})],
), ),
SpecMeshTest( SpecMeshTest(
"HoledSphereEdgesSelectSharp", "testHoledSphereEdgesSelectSharp", "expectedHoledSphereEdgeSelectSharp", "HoledSphereEdgesSelectSharp",
"testHoledSphereEdgesSelectSharp",
"expectedHoledSphereEdgeSelectSharp",
[OperatorSpecEditMode("edges_select_sharp", {"sharpness": 0.18}, "VERT", {})], [OperatorSpecEditMode("edges_select_sharp", {"sharpness": 0.18}, "VERT", {})],
), ),
SpecMeshTest( SpecMeshTest(
"EmptyMeshEdgesSelectSharp", "testEmptyMeshEdgeSelectSharp", "expectedEmptyMeshEdgeSelectSharp", "EmptyMeshEdgesSelectSharp",
"testEmptyMeshEdgeSelectSharp",
"expectedEmptyMeshEdgeSelectSharp",
[OperatorSpecEditMode("edges_select_sharp", {}, "VERT", {})], [OperatorSpecEditMode("edges_select_sharp", {}, "VERT", {})],
), ),
# face make planar # face make planar
SpecMeshTest( SpecMeshTest(
"MonkeyFaceMakePlanar", "testMonkeyFaceMakePlanar", "MonkeyFaceMakePlanar",
"testMonkeyFaceMakePlanar",
"expectedMonkeyFaceMakePlanar", "expectedMonkeyFaceMakePlanar",
[OperatorSpecEditMode("face_make_planar", {}, "FACE", {i for i in range(500)})], [OperatorSpecEditMode("face_make_planar", {}, "FACE", {i for i in range(500)})],
), ),
# face split by edges # face split by edges
SpecMeshTest( SpecMeshTest(
"PlaneFaceSplitByEdges", "testPlaneFaceSplitByEdges", "PlaneFaceSplitByEdges",
"testPlaneFaceSplitByEdges",
"expectedPlaneFaceSplitByEdges", "expectedPlaneFaceSplitByEdges",
[OperatorSpecEditMode("face_split_by_edges", {}, "VERT", {i for i in range(6)})], [OperatorSpecEditMode("face_split_by_edges", {}, "VERT", {i for i in range(6)})],
), ),
# faces select linked flat # faces select linked flat
SpecMeshTest( SpecMeshTest(
"CubeFacesSelectLinkedFlat", "testCubeFaceSelectLinkedFlat", "expectedCubeFaceSelectLinkedFlat", "CubeFacesSelectLinkedFlat",
"testCubeFaceSelectLinkedFlat",
"expectedCubeFaceSelectLinkedFlat",
[OperatorSpecEditMode("faces_select_linked_flat", {}, "FACE", {7})], [OperatorSpecEditMode("faces_select_linked_flat", {}, "FACE", {7})],
), ),
SpecMeshTest( SpecMeshTest(
"PlaneFacesSelectLinkedFlat", "testPlaneFaceSelectLinkedFlat", "expectedPlaneFaceSelectLinkedFlat", "PlaneFacesSelectLinkedFlat",
"testPlaneFaceSelectLinkedFlat",
"expectedPlaneFaceSelectLinkedFlat",
[OperatorSpecEditMode("faces_select_linked_flat", {}, "VERT", {1})], [OperatorSpecEditMode("faces_select_linked_flat", {}, "VERT", {1})],
), ),
SpecMeshTest( SpecMeshTest(
"EmptyMeshFacesSelectLinkedFlat", "testEmptyMeshFaceSelectLinkedFlat", "EmptyMeshFacesSelectLinkedFlat",
"testEmptyMeshFaceSelectLinkedFlat",
"expectedEmptyMeshFaceSelectLinkedFlat", "expectedEmptyMeshFaceSelectLinkedFlat",
[OperatorSpecEditMode("faces_select_linked_flat", {}, "VERT", {})], [OperatorSpecEditMode("faces_select_linked_flat", {}, "VERT", {})],
), ),
# fill # fill
SpecMeshTest( SpecMeshTest(
"IcosphereFill", "testIcosphereFill", "expectedIcosphereFill", "IcosphereFill",
"testIcosphereFill",
"expectedIcosphereFill",
[OperatorSpecEditMode("fill", {}, "EDGE", {20, 21, 22, 23, 24, 45, 46, 47, 48, 49})], [OperatorSpecEditMode("fill", {}, "EDGE", {20, 21, 22, 23, 24, 45, 46, 47, 48, 49})],
), ),
SpecMeshTest( SpecMeshTest(
"IcosphereFillUseBeautyFalse", "IcosphereFillUseBeautyFalse",
"testIcosphereFillUseBeautyFalse", "expectedIcosphereFillUseBeautyFalse", "testIcosphereFillUseBeautyFalse",
[OperatorSpecEditMode("fill", {"use_beauty": False}, "EDGE", "expectedIcosphereFillUseBeautyFalse",
{20, 21, 22, 23, 24, 45, 46, 47, 48, 49})], [OperatorSpecEditMode("fill", {"use_beauty": False}, "EDGE", {20, 21, 22, 23, 24, 45, 46, 47, 48, 49})],
), ),
# fill grid # fill grid
SpecMeshTest( SpecMeshTest(
"PlaneFillGrid", "testPlaneFillGrid", "PlaneFillGrid",
"testPlaneFillGrid",
"expectedPlaneFillGrid", "expectedPlaneFillGrid",
[OperatorSpecEditMode("fill_grid", {}, "EDGE", {1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 15})], [OperatorSpecEditMode("fill_grid", {}, "EDGE", {1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 15})],
), ),
@@ -278,129 +360,183 @@ def main():
"PlaneFillGridSimpleBlending", "PlaneFillGridSimpleBlending",
"testPlaneFillGridSimpleBlending", "testPlaneFillGridSimpleBlending",
"expectedPlaneFillGridSimpleBlending", "expectedPlaneFillGridSimpleBlending",
[OperatorSpecEditMode("fill_grid", {"use_interp_simple": True}, "EDGE", [
{1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 15})], OperatorSpecEditMode(
"fill_grid", {"use_interp_simple": True}, "EDGE", {1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 15}
)
],
), ),
SpecMeshTest( SpecMeshTest(
"PlaneFillGridReplaceExistingTris", "testPlaneFillGridReplaceExisting", "PlaneFillGridReplaceExistingTris",
"testPlaneFillGridReplaceExisting",
"expectedPlaneFillGridReplaceExistingTris", "expectedPlaneFillGridReplaceExistingTris",
[OperatorSpecEditMode("fill_grid", {}, "EDGE", {44, 60, 45, 68, 43, 75, 76, 73, 74, 70, 33, 59, 35, 67})], [OperatorSpecEditMode("fill_grid", {}, "EDGE", {44, 60, 45, 68, 43, 75, 76, 73, 74, 70, 33, 59, 35, 67})],
), ),
SpecMeshTest( SpecMeshTest(
"PlaneFillGridReplaceExistingQuads", "testPlaneFillGridReplaceExisting", "PlaneFillGridReplaceExistingQuads",
"testPlaneFillGridReplaceExisting",
"expectedPlaneFillGridReplaceExistingQuads", "expectedPlaneFillGridReplaceExistingQuads",
[OperatorSpecEditMode("fill_grid", {}, "FACE", {3, 4, 5, 9, 10, 11, 14, 15, 16})], [OperatorSpecEditMode("fill_grid", {}, "FACE", {3, 4, 5, 9, 10, 11, 14, 15, 16})],
), ),
# fill holes # fill holes
SpecMeshTest( SpecMeshTest(
"SphereFillHoles", "testSphereFillHoles", "expectedSphereFillHoles", "SphereFillHoles",
"testSphereFillHoles",
"expectedSphereFillHoles",
[OperatorSpecEditMode("fill_holes", {"sides": 9}, "VERT", {i for i in range(481)})], [OperatorSpecEditMode("fill_holes", {"sides": 9}, "VERT", {i for i in range(481)})],
), ),
# face shade smooth (not a real test) # face shade smooth (not a real test)
SpecMeshTest( SpecMeshTest(
"CubeShadeSmooth", "testCubeShadeSmooth", "expectedCubeShadeSmooth", "CubeShadeSmooth",
"testCubeShadeSmooth",
"expectedCubeShadeSmooth",
[OperatorSpecEditMode("faces_shade_smooth", {}, "VERT", {i for i in range(8)})], [OperatorSpecEditMode("faces_shade_smooth", {}, "VERT", {i for i in range(8)})],
), ),
# faces shade flat (not a real test) # faces shade flat (not a real test)
SpecMeshTest( SpecMeshTest(
"CubeShadeFlat", "testCubeShadeFlat", "expectedCubeShadeFlat", "CubeShadeFlat",
"testCubeShadeFlat",
"expectedCubeShadeFlat",
[OperatorSpecEditMode("faces_shade_flat", {}, "FACE", {i for i in range(6)})], [OperatorSpecEditMode("faces_shade_flat", {}, "FACE", {i for i in range(6)})],
), ),
# hide # hide
SpecMeshTest( SpecMeshTest(
"HideFace", "testCubeHideFace", "expectedCubeHideFace", "HideFace",
"testCubeHideFace",
"expectedCubeHideFace",
[OperatorSpecEditMode("hide", {}, "FACE", {3})], [OperatorSpecEditMode("hide", {}, "FACE", {3})],
), ),
SpecMeshTest( SpecMeshTest(
"HideEdge", "testCubeHideEdge", "expectedCubeHideEdge", "HideEdge",
"testCubeHideEdge",
"expectedCubeHideEdge",
[OperatorSpecEditMode("hide", {}, "EDGE", {1})], [OperatorSpecEditMode("hide", {}, "EDGE", {1})],
), ),
SpecMeshTest( SpecMeshTest(
"HideVertex", "testCubeHideVertex", "expectedCubeHideVertex", "HideVertex",
"testCubeHideVertex",
"expectedCubeHideVertex",
[OperatorSpecEditMode("hide", {}, "VERT", {0})], [OperatorSpecEditMode("hide", {}, "VERT", {0})],
), ),
# inset faces # inset faces
SpecMeshTest( SpecMeshTest(
"CubeInset", "CubeInset",
"testCubeInset", "expectedCubeInset", [OperatorSpecEditMode("inset", {"thickness": 0.2}, "VERT", "testCubeInset",
{5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, "expectedCubeInset",
52, [
59, 61, 62, 65, 83, 91, 95})], OperatorSpecEditMode(
"inset",
{"thickness": 0.2},
"VERT",
{5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, 52, 59, 61, 62, 65, 83, 91, 95},
)
],
), ),
SpecMeshTest( SpecMeshTest(
"CubeInsetEvenOffsetFalse", "CubeInsetEvenOffsetFalse",
"testCubeInsetEvenOffsetFalse", "expectedCubeInsetEvenOffsetFalse", "testCubeInsetEvenOffsetFalse",
[OperatorSpecEditMode("inset", {"thickness": 0.2, "use_even_offset": False}, "VERT", "expectedCubeInsetEvenOffsetFalse",
{5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, 52, 59, 61, 62, 65, 83, 91, 95})], [
OperatorSpecEditMode(
"inset",
{"thickness": 0.2, "use_even_offset": False},
"VERT",
{5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, 52, 59, 61, 62, 65, 83, 91, 95},
)
],
), ),
SpecMeshTest( SpecMeshTest(
"CubeInsetDepth", "CubeInsetDepth",
"testCubeInsetDepth", "testCubeInsetDepth",
"expectedCubeInsetDepth", [OperatorSpecEditMode("inset", {"thickness": 0.2, "depth": 0.2}, "VERT", "expectedCubeInsetDepth",
{5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, 52, 59, 61, [
62, OperatorSpecEditMode(
65, 83, 91, 95})], "inset",
{"thickness": 0.2, "depth": 0.2},
"VERT",
{5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, 52, 59, 61, 62, 65, 83, 91, 95},
)
],
), ),
SpecMeshTest( SpecMeshTest(
"GridInsetRelativeOffset", "testGridInsetRelativeOffset", "GridInsetRelativeOffset",
"testGridInsetRelativeOffset",
"expectedGridInsetRelativeOffset", "expectedGridInsetRelativeOffset",
[OperatorSpecEditMode("inset", {"thickness": 0.4, [
"use_relative_offset": True}, "FACE", OperatorSpecEditMode(
{35, 36, 37, 45, 46, 47, 55, 56, 57})], "inset",
{"thickness": 0.4, "use_relative_offset": True},
"FACE",
{35, 36, 37, 45, 46, 47, 55, 56, 57},
)
],
), ),
# loop multi select # loop multi select
SpecMeshTest( SpecMeshTest(
"MokeyLoopMultiSelect", "testMonkeyLoopMultiSelect", "expectedMonkeyLoopMultiSelect", "MokeyLoopMultiSelect",
"testMonkeyLoopMultiSelect",
"expectedMonkeyLoopMultiSelect",
[OperatorSpecEditMode("loop_multi_select", {}, "VERT", {355, 359, 73, 301, 302})], [OperatorSpecEditMode("loop_multi_select", {}, "VERT", {355, 359, 73, 301, 302})],
), ),
SpecMeshTest( SpecMeshTest(
"HoledGridLoopMultiSelect", "testGridLoopMultiSelect", "expectedGridLoopMultiSelect", "HoledGridLoopMultiSelect",
"testGridLoopMultiSelect",
"expectedGridLoopMultiSelect",
[OperatorSpecEditMode("loop_multi_select", {}, "VERT", {257, 169, 202, 207, 274, 278, 63})], [OperatorSpecEditMode("loop_multi_select", {}, "VERT", {257, 169, 202, 207, 274, 278, 63})],
), ),
SpecMeshTest( SpecMeshTest(
"EmptyMeshLoopMultiSelect", "testEmptyMeshLoopMultiSelect", "expectedEmptyMeshLoopMultiSelect", "EmptyMeshLoopMultiSelect",
"testEmptyMeshLoopMultiSelect",
"expectedEmptyMeshLoopMultiSelect",
[OperatorSpecEditMode("loop_multi_select", {}, "VERT", {})], [OperatorSpecEditMode("loop_multi_select", {}, "VERT", {})],
), ),
# mark seam # mark seam
SpecMeshTest( SpecMeshTest(
"CubeMarkSeam", "testCubeMarkSeam", "expectedCubeMarkSeam", "CubeMarkSeam",
"testCubeMarkSeam",
"expectedCubeMarkSeam",
[OperatorSpecEditMode("mark_seam", {}, "EDGE", {1})], [OperatorSpecEditMode("mark_seam", {}, "EDGE", {1})],
), ),
# merge normals # merge normals
SpecMeshTest( SpecMeshTest(
"CubeMergeNormals", "testCubeMergeNormals", "expectedCubeMergeNormals", "CubeMergeNormals",
"testCubeMergeNormals",
"expectedCubeMergeNormals",
[OperatorSpecEditMode("merge_normals", {}, "FACE", {3, 5})], [OperatorSpecEditMode("merge_normals", {}, "FACE", {3, 5})],
), ),
# Quads convert to tris # Quads convert to tris
SpecMeshTest( SpecMeshTest(
"CubeQuadsConvertToTris", "testCubeQuadsConvertToTris", "expectedCubeQuadsConvertToTris", "CubeQuadsConvertToTris",
[OperatorSpecEditMode("quads_convert_to_tris", {"quad_method": "BEAUTY", "ngon_method": "BEAUTY"}, "testCubeQuadsConvertToTris",
'FACE', {0, 1, 2, 3, 4, 5})], "expectedCubeQuadsConvertToTris",
[
OperatorSpecEditMode(
"quads_convert_to_tris",
{"quad_method": "BEAUTY", "ngon_method": "BEAUTY"},
'FACE',
{0, 1, 2, 3, 4, 5},
)
],
), ),
# select all # select all
SpecMeshTest( SpecMeshTest(
"CircleSelectAll", "testCircleSelectAll", "expectedCircleSelectAll", "CircleSelectAll",
"testCircleSelectAll",
"expectedCircleSelectAll",
[OperatorSpecEditMode("select_all", {}, "VERT", {1})], [OperatorSpecEditMode("select_all", {}, "VERT", {1})],
), ),
SpecMeshTest( SpecMeshTest(
"IsolatedVertsSelectAll", "testIsolatedVertsSelectAll", "expectedIsolatedVertsSelectAll", "IsolatedVertsSelectAll",
"testIsolatedVertsSelectAll",
"expectedIsolatedVertsSelectAll",
[OperatorSpecEditMode("select_all", {}, "VERT", {})], [OperatorSpecEditMode("select_all", {}, "VERT", {})],
), ),
SpecMeshTest( SpecMeshTest(
"EmptyMeshSelectAll", "testEmptyMeshSelectAll", "expectedEmptyMeshSelectAll", "EmptyMeshSelectAll",
"testEmptyMeshSelectAll",
"expectedEmptyMeshSelectAll",
[OperatorSpecEditMode("select_all", {}, "VERT", {})], [OperatorSpecEditMode("select_all", {}, "VERT", {})],
), ),
# select axis - Cannot be tested. Needs active vert selection # select axis - Cannot be tested. Needs active vert selection
# SpecMeshTest("MonkeySelectAxisX", "testMonkeySelectAxisX", "expectedMonkeySelectAxisX", # SpecMeshTest("MonkeySelectAxisX", "testMonkeySelectAxisX", "expectedMonkeySelectAxisX",
# [OperatorSpecEditMode("select_axis", {"axis": "X"}, "VERT", {13})]), # [OperatorSpecEditMode("select_axis", {"axis": "X"}, "VERT", {13})]),
@@ -410,285 +546,487 @@ def main():
# [OperatorSpecEditMode("select_axis", {"axis": "X", "sign": "NEG"}, "FACE", {317}), # [OperatorSpecEditMode("select_axis", {"axis": "X", "sign": "NEG"}, "FACE", {317}),
# OperatorSpecEditMode("select_axis", {"axis": "Y", "sign": "POS"}, "FACE", {}), # OperatorSpecEditMode("select_axis", {"axis": "Y", "sign": "POS"}, "FACE", {}),
# OperatorSpecEditMode("select_axis", {"axis": "Z", "sign": "NEG"}, "FACE", {})]), # OperatorSpecEditMode("select_axis", {"axis": "Z", "sign": "NEG"}, "FACE", {})]),
# select faces by sides # select faces by sides
SpecMeshTest( SpecMeshTest(
"CubeSelectFacesBySide", "testCubeSelectFacesBySide", "expectedCubeSelectFacesBySide", "CubeSelectFacesBySide",
"testCubeSelectFacesBySide",
"expectedCubeSelectFacesBySide",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})], [OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})],
), ),
SpecMeshTest( SpecMeshTest(
"CubeSelectFacesBySideGreater", "testCubeSelectFacesBySideGreater", "expectedCubeSelectFacesBySideGreater", "CubeSelectFacesBySideGreater",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4, "testCubeSelectFacesBySideGreater",
"type": "GREATER", "extend": True}, "FACE", {})], "expectedCubeSelectFacesBySideGreater",
[
OperatorSpecEditMode(
"select_face_by_sides", {"number": 4, "type": "GREATER", "extend": True}, "FACE", {}
)
],
), ),
SpecMeshTest( SpecMeshTest(
"CubeSelectFacesBySideLess", "testCubeSelectFacesBySideLess", "expectedCubeSelectFacesBySideLess", "CubeSelectFacesBySideLess",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4, "testCubeSelectFacesBySideLess",
"type": "GREATER", "extend": True}, "FACE", {})], "expectedCubeSelectFacesBySideLess",
[
OperatorSpecEditMode(
"select_face_by_sides", {"number": 4, "type": "GREATER", "extend": True}, "FACE", {}
)
],
), ),
# select interior faces # select interior faces
SpecMeshTest( SpecMeshTest(
"CubeSelectInteriorFaces", "testCubeSelectInteriorFaces", "expectedCubeSelectInteriorFaces", "CubeSelectInteriorFaces",
"testCubeSelectInteriorFaces",
"expectedCubeSelectInteriorFaces",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})], [OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})],
), ),
SpecMeshTest( SpecMeshTest(
"HoledCubeSelectInteriorFaces", "testHoledCubeSelectInteriorFaces", "expectedHoledCubeSelectInteriorFaces", "HoledCubeSelectInteriorFaces",
"testHoledCubeSelectInteriorFaces",
"expectedHoledCubeSelectInteriorFaces",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})], [OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})],
), ),
SpecMeshTest( SpecMeshTest(
"EmptyMeshSelectInteriorFaces", "testEmptyMeshSelectInteriorFaces", "expectedEmptyMeshSelectInteriorFaces", "EmptyMeshSelectInteriorFaces",
"testEmptyMeshSelectInteriorFaces",
"expectedEmptyMeshSelectInteriorFaces",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})], [OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})],
), ),
# select less # select less
SpecMeshTest( SpecMeshTest(
"MonkeySelectLess", "testMonkeySelectLess", "expectedMonkeySelectLess", "MonkeySelectLess",
[OperatorSpecEditMode("select_less", {}, "VERT", { "testMonkeySelectLess",
2, 8, 24, 34, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 68, "expectedMonkeySelectLess",
69, 70, 71, 74, 75, 78, 80, 81, 82, 83, 90, 91, 93, 95, 97, 99, [
101, 109, 111, 115, 117, 119, 121, 123, 125, 127, 129, 130, 131, OperatorSpecEditMode(
132, 133, 134, 135, 136, 138, 141, 143, 145, 147, 149, 151, 153, "select_less",
155, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, {},
175, 176, 177, 178, 181, 182, 184, 185, 186, 187, 188, 189, 190, "VERT",
192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, {
206, 207, 208, 210, 216, 217, 218, 219, 220, 221, 222, 229, 230, 2, 8, 24, 34, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 68,
231, 233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 255, 69, 70, 71, 74, 75, 78, 80, 81, 82, 83, 90, 91, 93, 95, 97, 99,
257, 259, 263, 267, 269, 271, 275, 277, 289, 291, 293, 295, 309, 101, 109, 111, 115, 117, 119, 121, 123, 125, 127, 129, 130, 131,
310, 311, 312, 316, 317, 318, 319, 320, 323, 325, 327, 329, 331, 132, 133, 134, 135, 136, 138, 141, 143, 145, 147, 149, 151, 153,
341, 347, 349, 350, 351, 354, 356, 359, 361, 363, 365, 367, 369, 155, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174,
375, 379, 381, 382, 385, 386, 387, 388, 389, 390, 391, 392, 393, 175, 176, 177, 178, 181, 182, 184, 185, 186, 187, 188, 189, 190,
394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 206, 207, 208, 210, 216, 217, 218, 219, 220, 221, 222, 229, 230,
420, 421, 423, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 231, 233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 255,
435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 257, 259, 263, 267, 269, 271, 275, 277, 289, 291, 293, 295, 309,
448, 449, 450, 451, 452, 454, 455, 456, 457, 458, 459, 460, 461, 310, 311, 312, 316, 317, 318, 319, 320, 323, 325, 327, 329, 331,
462, 463, 464, 471, 473, 474, 475, 476, 477, 478, 479, 480, 481, 341, 347, 349, 350, 351, 354, 356, 359, 361, 363, 365, 367, 369,
482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 495, 375, 379, 381, 382, 385, 386, 387, 388, 389, 390, 391, 392, 393,
496, 497, 498, 499, 502, 505, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406,
})], 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419,
420, 421, 423, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434,
435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447,
448, 449, 450, 451, 452, 454, 455, 456, 457, 458, 459, 460, 461,
462, 463, 464, 471, 473, 474, 475, 476, 477, 478, 479, 480, 481,
482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 495,
496, 497, 498, 499, 502, 505,
},
)
],
), ),
SpecMeshTest( SpecMeshTest(
"HoledCubeSelectLess", "testHoledCubeSelectLess", "expectedHoledCubeSelectLess", "HoledCubeSelectLess",
"testHoledCubeSelectLess",
"expectedHoledCubeSelectLess",
[OperatorSpecEditMode("select_face_by_sides", {}, "FACE", {})], [OperatorSpecEditMode("select_face_by_sides", {}, "FACE", {})],
), ),
SpecMeshTest( SpecMeshTest(
"EmptyMeshSelectLess", "testEmptyMeshSelectLess", "expectedEmptyMeshSelectLess", "EmptyMeshSelectLess",
"testEmptyMeshSelectLess",
"expectedEmptyMeshSelectLess",
[OperatorSpecEditMode("select_face_by_sides", {}, "VERT", {})], [OperatorSpecEditMode("select_face_by_sides", {}, "VERT", {})],
), ),
# select linked # select linked
SpecMeshTest( SpecMeshTest(
"PlanesSelectLinked", "testPlanesSelectLinked", "expectedPlanesSelectedLinked", "PlanesSelectLinked",
"testPlanesSelectLinked",
"expectedPlanesSelectedLinked",
[OperatorSpecEditMode("select_linked", {}, "VERT", {7})], [OperatorSpecEditMode("select_linked", {}, "VERT", {7})],
), ),
SpecMeshTest( SpecMeshTest(
"CubesSelectLinked", "testCubesSelectLinked", "expectedCubesSelectLinked", "CubesSelectLinked",
"testCubesSelectLinked",
"expectedCubesSelectLinked",
[OperatorSpecEditMode("select_linked", {}, "VERT", {11})], [OperatorSpecEditMode("select_linked", {}, "VERT", {11})],
), ),
SpecMeshTest( SpecMeshTest(
"EmptyMeshSelectLinked", "testEmptyMeshSelectLinked", "expectedEmptyMeshSelectLinked", "EmptyMeshSelectLinked",
"testEmptyMeshSelectLinked",
"expectedEmptyMeshSelectLinked",
[OperatorSpecEditMode("select_linked", {}, "VERT", {})], [OperatorSpecEditMode("select_linked", {}, "VERT", {})],
), ),
# select nth (checkered deselect) # select nth (checkered deselect)
SpecMeshTest( SpecMeshTest(
"CircleSelect2nd", "testCircleSelect2nd", "expectedCircleSelect2nd", "CircleSelect2nd",
"testCircleSelect2nd",
"expectedCircleSelect2nd",
[OperatorSpecEditMode("select_nth", {}, "VERT", {i for i in range(32)})], [OperatorSpecEditMode("select_nth", {}, "VERT", {i for i in range(32)})],
), ),
# Subdivide edgering - Not currently functional, operator returns inconsistently # Subdivide edgering - Not currently functional, operator returns inconsistently
# SpecMeshTest("SubdivideEdgeringSurface", "testCylinderSubdivideEdgering", "expectedCylinderSubdivideEdgeringSurface", # SpecMeshTest(
# [OperatorSpecEditMode("subdivide_edgering", {"number_cuts": 5, "interpolation": 'SURFACE', "profile_shape_factor": 0.1}, "EDGE", {0, (i for i in range(96) if (i % 3))})]), # "SubdivideEdgeringSurface",
# SpecMeshTest("SubdivideEdgeringPath", "testCylinderSubdivideEdgering", "expectedCylinderSubdivideEdgeringPath", # "testCylinderSubdivideEdgering",
# [OperatorSpecEditMode("subdivide_edgering", {"number_cuts": 5, "interpolation": 'PATH', "profile_shape_factor": 0.1}, "EDGE", {0, (i for i in range(96) if (i % 3))})]), # "expectedCylinderSubdivideEdgeringSurface",
# SpecMeshTest("SubdivideEdgeringLinear", "testCylinderSubdivideEdgering", "expectedCylinderSubdivideEdgeringLinear", # [
# [OperatorSpecEditMode("subdivide_edgering", {"number_cuts": 5, "interpolation": 'LINEAR', "profile_shape_factor": 0.1}, "EDGE", {0, (i for i in range(96) if (i % 3))})]), # OperatorSpecEditMode(
# "subdivide_edgering",
# {"number_cuts": 5, "interpolation": 'SURFACE', "profile_shape_factor": 0.1},
# "EDGE",
# {0, (i for i in range(96) if (i % 3))},
# )
# ],
# ),
# SpecMeshTest(
# "SubdivideEdgeringPath",
# "testCylinderSubdivideEdgering",
# "expectedCylinderSubdivideEdgeringPath",
# [
# OperatorSpecEditMode(
# "subdivide_edgering",
# {"number_cuts": 5, "interpolation": 'PATH', "profile_shape_factor": 0.1},
# "EDGE",
# {0, (i for i in range(96) if (i % 3))},
# )
# ],
# ),
# SpecMeshTest(
# "SubdivideEdgeringLinear",
# "testCylinderSubdivideEdgering",
# "expectedCylinderSubdivideEdgeringLinear",
# [
# OperatorSpecEditMode(
# "subdivide_edgering",
# {"number_cuts": 5, "interpolation": 'LINEAR', "profile_shape_factor": 0.1},
# "EDGE",
# {0, (i for i in range(96) if (i % 3))},
# )
# ],
# ),
# Symmetry Snap # Symmetry Snap
SpecMeshTest( SpecMeshTest(
"SymmetrySnap", "testPlaneSymmetrySnap", "expectedPlaneSymmetrySnap", "SymmetrySnap",
[OperatorSpecEditMode("symmetry_snap", {"direction": 'POSITIVE_X', "threshold": 1, "factor": 0.75, "testPlaneSymmetrySnap",
"use_center": False}, "VERT", {i for i in range(5)})], "expectedPlaneSymmetrySnap",
[
OperatorSpecEditMode(
"symmetry_snap",
{"direction": 'POSITIVE_X', "threshold": 1, "factor": 0.75, "use_center": False},
"VERT",
{i for i in range(5)},
)
],
), ),
SpecMeshTest( SpecMeshTest(
"SymmetrySnapCenter", "testPlaneSymmetrySnap", "expectedPlaneSymmetrySnapCenter", "SymmetrySnapCenter",
[OperatorSpecEditMode("symmetry_snap", {"direction": 'NEGATIVE_X', "threshold": 1, "factor": 0.75, "testPlaneSymmetrySnap",
"use_center": True}, "VERT", {i for i in range(5)})], "expectedPlaneSymmetrySnapCenter",
[
OperatorSpecEditMode(
"symmetry_snap",
{"direction": 'NEGATIVE_X', "threshold": 1, "factor": 0.75, "use_center": True},
"VERT",
{i for i in range(5)},
)
],
), ),
# Triangulate Faces # Triangulate Faces
SpecMeshTest( SpecMeshTest(
"Triangulate Faces", "testCubeTriangulate", "expectedCubeTriangulate", "Triangulate Faces",
"testCubeTriangulate",
"expectedCubeTriangulate",
[OperatorSpecEditMode("quads_convert_to_tris", {}, "FACE", {i for i in range(6)})], [OperatorSpecEditMode("quads_convert_to_tris", {}, "FACE", {i for i in range(6)})],
), ),
# Tris to Quads # Tris to Quads
SpecMeshTest( SpecMeshTest(
"TrisToQuads 10 deg no topo", "testPlanesTrisToQuad", "expectedPlanesTrisToQuad.10.notopo", "TrisToQuads 10 deg no topo",
[OperatorSpecEditMode( "testPlanesTrisToQuad",
"tris_convert_to_quads", "expectedPlanesTrisToQuad.10.notopo",
{"face_threshold": 0.174533, "shape_threshold": 0.174533, [
"topology_influence": 0, "deselect_joined": False, OperatorSpecEditMode(
"uvs": True, "vcols": True, "seam": True, "sharp": True, "materials": True}, "tris_convert_to_quads",
"VERT", {i for i in range(42)})], {
"face_threshold": 0.174533,
"shape_threshold": 0.174533,
"topology_influence": 0,
"deselect_joined": False,
"uvs": True,
"vcols": True,
"seam": True,
"sharp": True,
"materials": True,
},
"VERT",
{i for i in range(42)},
)
],
), ),
SpecMeshTest( SpecMeshTest(
"TrisToQuads 10 deg negligible topo", "testPlanesTrisToQuad", "expectedPlanesTrisToQuad.10.notopo", "TrisToQuads 10 deg negligible topo",
[OperatorSpecEditMode( "testPlanesTrisToQuad",
"tris_convert_to_quads", "expectedPlanesTrisToQuad.10.notopo",
{"face_threshold": 0.174533, "shape_threshold": 0.174533, [
"topology_influence": 0.01, "deselect_joined": False, OperatorSpecEditMode(
"uvs": True, "vcols": True, "seam": True, "sharp": True, "materials": True}, "tris_convert_to_quads",
"VERT", {i for i in range(42)})], {
"face_threshold": 0.174533,
"shape_threshold": 0.174533,
"topology_influence": 0.01,
"deselect_joined": False,
"uvs": True,
"vcols": True,
"seam": True,
"sharp": True,
"materials": True,
},
"VERT",
{i for i in range(42)},
)
],
), ),
SpecMeshTest( SpecMeshTest(
"TrisToQuads 180 deg no topo", "testPlanesTrisToQuad", "expectedPlanesTrisToQuad.180.notopo", "TrisToQuads 180 deg no topo",
[OperatorSpecEditMode( "testPlanesTrisToQuad",
"tris_convert_to_quads", "expectedPlanesTrisToQuad.180.notopo",
{"face_threshold": 3.14159, "shape_threshold": 3.14159, [
"topology_influence": 0, "deselect_joined": False, OperatorSpecEditMode(
"uvs": True, "vcols": True, "seam": True, "sharp": True, "materials": True}, "tris_convert_to_quads",
"VERT", {i for i in range(42)})], {
"face_threshold": 3.14159,
"shape_threshold": 3.14159,
"topology_influence": 0,
"deselect_joined": False,
"uvs": True,
"vcols": True,
"seam": True,
"sharp": True,
"materials": True,
},
"VERT",
{i for i in range(42)},
)
],
), ),
SpecMeshTest( SpecMeshTest(
"TrisToQuads 180 deg topo", "testPlanesTrisToQuad", "expectedPlanesTrisToQuad.180.topo", "TrisToQuads 180 deg topo",
[OperatorSpecEditMode( "testPlanesTrisToQuad",
"tris_convert_to_quads", "expectedPlanesTrisToQuad.180.topo",
{"face_threshold": 3.14159, "shape_threshold": 3.14159, [
"topology_influence": 1, "deselect_joined": False, OperatorSpecEditMode(
"uvs": True, "vcols": True, "seam": True, "sharp": True, "materials": True}, "tris_convert_to_quads",
"VERT", {i for i in range(42)})], {
"face_threshold": 3.14159,
"shape_threshold": 3.14159,
"topology_influence": 1,
"deselect_joined": False,
"uvs": True,
"vcols": True,
"seam": True,
"sharp": True,
"materials": True,
},
"VERT",
{i for i in range(42)},
)
],
), ),
# unsubdivide # unsubdivide
# normal case # normal case
SpecMeshTest( SpecMeshTest(
"CubeFaceUnsubdivide", "testCubeUnsubdivide", "expectedCubeUnsubdivide", "CubeFaceUnsubdivide",
"testCubeUnsubdivide",
"expectedCubeUnsubdivide",
[OperatorSpecEditMode("unsubdivide", {}, "FACE", {i for i in range(6)})], [OperatorSpecEditMode("unsubdivide", {}, "FACE", {i for i in range(6)})],
), ),
# UV Manipulation # UV Manipulation
SpecMeshTest( SpecMeshTest(
"UVRotate", "testCubeUV", "expectedCubeUVRotate", "UVRotate",
"testCubeUV",
"expectedCubeUVRotate",
[OperatorSpecEditMode("uvs_rotate", {}, "FACE", {2})], [OperatorSpecEditMode("uvs_rotate", {}, "FACE", {2})],
), ),
SpecMeshTest( SpecMeshTest(
"UVRotateCCW", "testCubeUV", "expectedCubeUVRotateCCW", "UVRotateCCW",
"testCubeUV",
"expectedCubeUVRotateCCW",
[OperatorSpecEditMode("uvs_rotate", {"use_ccw": True}, "FACE", {2})], [OperatorSpecEditMode("uvs_rotate", {"use_ccw": True}, "FACE", {2})],
), ),
SpecMeshTest( SpecMeshTest(
"UVReverse", "testCubeUV", "expectedCubeUVReverse", "UVReverse",
"testCubeUV",
"expectedCubeUVReverse",
[OperatorSpecEditMode("uvs_reverse", {}, "FACE", {2})], [OperatorSpecEditMode("uvs_reverse", {}, "FACE", {2})],
), ),
SpecMeshTest( SpecMeshTest(
"UVAdd", "testCubeUV", "expectedCubeUVAdd", "UVAdd",
[OperatorSpecEditMode("uv_texture_add", {}, "FACE", {})], "testCubeUV",
"expectedCubeUVAdd",
[OperatorSpecEditMode("uv_texture_add", {}, "FACE", {})],
), ),
SpecMeshTest( SpecMeshTest(
"UVRemove", "testCubeUV", "expectedCubeUVRemove", "UVRemove",
"testCubeUV",
"expectedCubeUVRemove",
[OperatorSpecEditMode("uv_texture_remove", {}, "FACE", {})], [OperatorSpecEditMode("uv_texture_remove", {}, "FACE", {})],
), ),
# Vert Connect Concave # Vert Connect Concave
SpecMeshTest( SpecMeshTest(
"VertexConnectConcave", "testPlaneVertConnectConcave", "expectedPlaneVertConnectConcave", "VertexConnectConcave",
"testPlaneVertConnectConcave",
"expectedPlaneVertConnectConcave",
[OperatorSpecEditMode("vert_connect_concave", {}, "FACE", {0})], [OperatorSpecEditMode("vert_connect_concave", {}, "FACE", {0})],
), ),
SpecMeshTest( SpecMeshTest(
"VertexConnectConcaveConvexPentagon", "testPentagonVertConnectConcave", "expectedPentagonVertConnectConcave", "VertexConnectConcaveConvexPentagon",
"testPentagonVertConnectConcave",
"expectedPentagonVertConnectConcave",
[OperatorSpecEditMode("vert_connect_concave", {}, "FACE", {0})], [OperatorSpecEditMode("vert_connect_concave", {}, "FACE", {0})],
), ),
SpecMeshTest( SpecMeshTest(
"VertexConnectConcaveQuad", "testPlaneVertConnectConcaveQuad", "expectedPlaneVertConnectConcaveQuad", "VertexConnectConcaveQuad",
"testPlaneVertConnectConcaveQuad",
"expectedPlaneVertConnectConcaveQuad",
[OperatorSpecEditMode("vert_connect_concave", {}, "FACE", {0})], [OperatorSpecEditMode("vert_connect_concave", {}, "FACE", {0})],
), ),
# Vert Connect Nonplanar # Vert Connect Nonplanar
SpecMeshTest( SpecMeshTest(
"VertexConnectNonplanar", "testPlaneVertConnectNonplanar", "expectedPlaneVertConnectNonplanar", "VertexConnectNonplanar",
[OperatorSpecEditMode("vert_connect_nonplanar", { "testPlaneVertConnectNonplanar",
"angle_limit": 0.17453292}, "VERT", {i for i in range(9)})], "expectedPlaneVertConnectNonplanar",
[
OperatorSpecEditMode(
"vert_connect_nonplanar", {"angle_limit": 0.17453292}, "VERT", {i for i in range(9)}
)
],
), ),
SpecMeshTest( SpecMeshTest(
"VertexConnectNonplanarNgon", "testPlaneVertConnectNonplanarNgon", "expectedPlaneVertConnectNonplanarNgon", "VertexConnectNonplanarNgon",
"testPlaneVertConnectNonplanarNgon",
"expectedPlaneVertConnectNonplanarNgon",
[OperatorSpecEditMode("vert_connect_nonplanar", {"angle_limit": 0.218166}, "VERT", {i for i in range(6)})], [OperatorSpecEditMode("vert_connect_nonplanar", {"angle_limit": 0.218166}, "VERT", {i for i in range(6)})],
), ),
# #87259 - test cases # #87259 - test cases
SpecMeshTest( SpecMeshTest(
"CubeEdgeUnsubdivide", "testCubeEdgeUnsubdivide", "expectedCubeEdgeUnsubdivide", "CubeEdgeUnsubdivide",
"testCubeEdgeUnsubdivide",
"expectedCubeEdgeUnsubdivide",
[OperatorSpecEditMode("unsubdivide", {}, "EDGE", {i for i in range(6)})], [OperatorSpecEditMode("unsubdivide", {}, "EDGE", {i for i in range(6)})],
), ),
SpecMeshTest( SpecMeshTest(
"UVSphereUnsubdivide", "testUVSphereUnsubdivide", "expectedUVSphereUnsubdivide", "UVSphereUnsubdivide",
"testUVSphereUnsubdivide",
"expectedUVSphereUnsubdivide",
[OperatorSpecEditMode("unsubdivide", {'iterations': 9}, "FACE", {i for i in range(512)})], [OperatorSpecEditMode("unsubdivide", {'iterations': 9}, "FACE", {i for i in range(512)})],
), ),
# vert connect path # vert connect path
# Tip: It works only if there is an already existing face or more than 2 vertices. # Tip: It works only if there is an already existing face or more than 2 vertices.
SpecMeshTest( SpecMeshTest(
"PlaneVertConnectPath", "testPlaneVertConnectPath", "expectedPlaneVertConnectPath", "PlaneVertConnectPath",
[OperatorSpecEditMode( "testPlaneVertConnectPath",
"vert_connect_path", {}, "VERT", (0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14), "expectedPlaneVertConnectPath",
select_history=True, [
)], OperatorSpecEditMode(
"vert_connect_path",
{},
"VERT",
(0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14),
select_history=True,
)
],
), ),
# Laplacian Smooth # Laplacian Smooth
SpecMeshTest( SpecMeshTest(
"LaplacianSmoothDefault", "testSphereLaplacianSmoothDefault", "expectedSphereLaplacianSmoothDefault", "LaplacianSmoothDefault",
[OperatorSpecEditMode("vertices_smooth_laplacian", { "testSphereLaplacianSmoothDefault",
"preserve_volume": False}, "VERT", {i for i in range(482)})], "expectedSphereLaplacianSmoothDefault",
[
OperatorSpecEditMode(
"vertices_smooth_laplacian", {"preserve_volume": False}, "VERT", {i for i in range(482)}
)
],
), ),
SpecMeshTest( SpecMeshTest(
"LaplacianSmoothHighValues", "testSphereLaplacianSmoothHigh", "expectedSphereLaplacianSmoothHigh", "LaplacianSmoothHighValues",
[OperatorSpecEditMode("vertices_smooth_laplacian", "testSphereLaplacianSmoothHigh",
{"preserve_volume": False, "expectedSphereLaplacianSmoothHigh",
"repeat": 100, [
"lambda_factor": 10.0}, OperatorSpecEditMode(
"VERT", "vertices_smooth_laplacian",
{i for i in range(482)})], {"preserve_volume": False, "repeat": 100, "lambda_factor": 10.0},
"VERT",
{i for i in range(482)},
)
],
), ),
SpecMeshTest( SpecMeshTest(
"LaplacianSmoothBorder", "testCubeLaplacianSmoothBorder", "expectedCubeLaplacianSmoothBorder", "LaplacianSmoothBorder",
[OperatorSpecEditMode("vertices_smooth_laplacian", { "testCubeLaplacianSmoothBorder",
"preserve_volume": False, "lambda_border": 1.0}, "VERT", {i for i in range(25)})], "expectedCubeLaplacianSmoothBorder",
[
OperatorSpecEditMode(
"vertices_smooth_laplacian",
{"preserve_volume": False, "lambda_border": 1.0},
"VERT",
{i for i in range(25)},
)
],
), ),
SpecMeshTest( SpecMeshTest(
"LaplacianSmoothHighBorder", "testCubeLaplacianSmoothHighBorder", "expectedCubeLaplacianSmoothHighBorder", "LaplacianSmoothHighBorder",
[OperatorSpecEditMode("vertices_smooth_laplacian", { "testCubeLaplacianSmoothHighBorder",
"preserve_volume": False, "lambda_border": 100.0}, "VERT", {i for i in range(25)})], "expectedCubeLaplacianSmoothHighBorder",
[
OperatorSpecEditMode(
"vertices_smooth_laplacian",
{"preserve_volume": False, "lambda_border": 100.0},
"VERT",
{i for i in range(25)},
)
],
), ),
SpecMeshTest( SpecMeshTest(
"LaplacianSmoothPreserveVolume", "testSphereLaplacianSmoothPreserveVol", "expectedSphereLaplacianSmoothPreserveVol", "LaplacianSmoothPreserveVolume",
[OperatorSpecEditMode("vertices_smooth_laplacian", { "testSphereLaplacianSmoothPreserveVol",
"preserve_volume": True}, "VERT", {i for i in range(482)})], "expectedSphereLaplacianSmoothPreserveVol",
[
OperatorSpecEditMode(
"vertices_smooth_laplacian", {"preserve_volume": True}, "VERT", {i for i in range(482)}
)
],
), ),
# wireframe # wireframe
SpecMeshTest( SpecMeshTest(
"WireFrameDefault", "testCubeWireframeDefault", "expectedCubeWireframeDefault", "WireFrameDefault",
"testCubeWireframeDefault",
"expectedCubeWireframeDefault",
[OperatorSpecEditMode("wireframe", {}, "FACE", {i for i in range(6)})], [OperatorSpecEditMode("wireframe", {}, "FACE", {i for i in range(6)})],
), ),
SpecMeshTest( SpecMeshTest(
"WireFrameAlt", "testCubeWireframeAlt", "expectedCubeWireframeAlt", "WireFrameAlt",
[OperatorSpecEditMode( "testCubeWireframeAlt",
"wireframe", { "expectedCubeWireframeAlt",
"use_boundary": False, "use_even_offset": False, [
"use_relative_offset": True, "use_replace": False, "thickness": 0.3, "offset": 0.3, OperatorSpecEditMode(
"use_crease": True, "crease_weight": 0.01, "wireframe",
}, "FACE", {i for i in range(6)})], {
"use_boundary": False,
"use_even_offset": False,
"use_relative_offset": True,
"use_replace": False,
"thickness": 0.3,
"offset": 0.3,
"use_crease": True,
"crease_weight": 0.01,
},
"FACE",
{i for i in range(6)},
)
],
), ),
] ]
operators_test = RunTest(tests) operators_test = RunTest(tests)