Compare commits
38 Commits
tmp-eevee-
...
soc-2021-g
| Author | SHA1 | Date | |
|---|---|---|---|
| dff47e3b94 | |||
| fd32fe6b02 | |||
| 0708e605d5 | |||
| 5fc1779b65 | |||
| b8f3df9817 | |||
| ad3afa02af | |||
| c54b53fa14 | |||
| 8e41ce4959 | |||
| 25e388c8b1 | |||
| 5040638dbf | |||
| 53fc2ca51f | |||
| af0743c47d | |||
| d066f16a6c | |||
| 3d18b2d9f7 | |||
| faae72e8ee | |||
| 09566e510a | |||
| a5baa450d1 | |||
| 82aa700fe6 | |||
| 43fd05d8d8 | |||
| 16f7672513 | |||
| 984ad47d93 | |||
| c400f79582 | |||
| 7e45a760b4 | |||
| 3c996fe7e2 | |||
| 2edc2136a1 | |||
| fec564b321 | |||
| 70e8acf0ba | |||
| 2778211cea | |||
| 24a401c36d | |||
| 959fe77e9c | |||
| 6f699690ee | |||
| f52c674991 | |||
| 5dc85773eb | |||
| 825081a2d0 | |||
| 10ace20bcf | |||
| 8b151c5cdb | |||
| fd25c2c59a | |||
| 225f638afd |
@@ -740,6 +740,29 @@ if(WITH_COMPOSITOR)
|
||||
|
||||
endif()
|
||||
|
||||
set(geo_node_tests
|
||||
curves
|
||||
geometry
|
||||
mesh
|
||||
points
|
||||
)
|
||||
|
||||
foreach(geo_node_test ${geo_node_tests})
|
||||
if(EXISTS "${TEST_SRC_DIR}/modeling/geometry_nodes/${geo_node_test}/")
|
||||
file(GLOB files "${TEST_SRC_DIR}/modeling/geometry_nodes/${geo_node_test}/*.blend")
|
||||
foreach(file ${files})
|
||||
get_filename_component(filename ${file} NAME_WE)
|
||||
add_blender_test(
|
||||
geo_node_${geo_node_test}_test_${filename}
|
||||
${file}
|
||||
--python ${TEST_PYTHON_DIR}/geo_node_test.py
|
||||
)
|
||||
endforeach()
|
||||
else()
|
||||
MESSAGE(STATUS "No directory named ${TEST_SRC_DIR}/modeling/geometry_nodes/${geo_node_test}/ found, disabling test.")
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
if(WITH_OPENGL_DRAW_TESTS)
|
||||
if(NOT OPENIMAGEIO_IDIFF)
|
||||
MESSAGE(STATUS "Disabling OpenGL draw tests because OIIO idiff does not exist")
|
||||
|
||||
@@ -27,272 +27,272 @@ import os
|
||||
import sys
|
||||
|
||||
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
|
||||
from modules.mesh_test import MeshTest, OperatorSpecEditMode, RunTest
|
||||
from modules.mesh_test import SpecMeshTest, OperatorSpecEditMode, RunTest
|
||||
|
||||
|
||||
def main():
|
||||
tests = [
|
||||
# 0
|
||||
MeshTest('Cube_test_1', 'Cube_test', 'Cube_result_1',
|
||||
SpecMeshTest('Cube_test_1', 'Cube_test', 'Cube_result_1',
|
||||
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2}, 'EDGE', {10})]),
|
||||
MeshTest('Cube_test_2', 'Cube_test', 'Cube_result_2',
|
||||
SpecMeshTest('Cube_test_2', 'Cube_test', 'Cube_result_2',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'offset_type': 'WIDTH'}, 'EDGE', {10, 7}, )]),
|
||||
MeshTest('Cube_test_3', 'Cube_test', 'Cube_result_3',
|
||||
SpecMeshTest('Cube_test_3', 'Cube_test', 'Cube_result_3',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'offset_type': 'DEPTH'}, 'EDGE', {8, 10, 7}, )]),
|
||||
MeshTest('Cube_test_4', 'Cube_test', 'Cube_result_4',
|
||||
SpecMeshTest('Cube_test_4', 'Cube_test', 'Cube_result_4',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.4, 'segments': 2}, 'EDGE', {10}, )]),
|
||||
MeshTest('Cube_test_5', 'Cube_test', 'Cube_result_5',
|
||||
SpecMeshTest('Cube_test_5', 'Cube_test', 'Cube_result_5',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.4, 'segments': 3}, 'EDGE', {10, 7}, )]),
|
||||
# 5
|
||||
MeshTest('Cube_test_6', 'Cube_test', 'Cube_result_6',
|
||||
SpecMeshTest('Cube_test_6', 'Cube_test', 'Cube_result_6',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.4, 'segments': 4}, 'EDGE', {8, 10, 7}, )]),
|
||||
MeshTest('Cube_test_7', 'Cube_test', 'Cube_result_7',
|
||||
SpecMeshTest('Cube_test_7', 'Cube_test', 'Cube_result_7',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.4, 'segments': 5, 'profile': 0.2}, 'EDGE', {0, 10, 4, 7}, )]),
|
||||
MeshTest('Cube_test_8', 'Cube_test', 'Cube_result_8',
|
||||
SpecMeshTest('Cube_test_8', 'Cube_test', 'Cube_result_8',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.4, 'segments': 5, 'profile': 0.25}, 'EDGE', {8, 10, 7}, )]),
|
||||
MeshTest('Cube_test_9', 'Cube_test', 'Cube_result_9',
|
||||
SpecMeshTest('Cube_test_9', 'Cube_test', 'Cube_result_9',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.4, 'segments': 6, 'profile': 0.9}, 'EDGE', {8, 10, 7}, )]),
|
||||
MeshTest('Cube_test_10', 'Cube_test', 'Cube_result_10',
|
||||
SpecMeshTest('Cube_test_10', 'Cube_test', 'Cube_result_10',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.4, 'segments': 4, 'profile': 1.0}, 'EDGE', {10, 7}, )]),
|
||||
# 10
|
||||
MeshTest('Cube_test_11', 'Cube_test', 'Cube_result_11',
|
||||
SpecMeshTest('Cube_test_11', 'Cube_test', 'Cube_result_11',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.4, 'segments': 5, 'profile': 1.0}, 'EDGE', {8, 10, 7}, )]),
|
||||
MeshTest("test 12", 'Cube_test', 'Cube_result_12',
|
||||
SpecMeshTest("test 12", 'Cube_test', 'Cube_result_12',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.4, 'segments': 8}, 'EDGE',
|
||||
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, )]),
|
||||
MeshTest('Pyramid4_test_1', 'Pyr4_test', 'Pyr4_result_1',
|
||||
SpecMeshTest('Pyramid4_test_1', 'Pyr4_test', 'Pyr4_result_1',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {5}, )]),
|
||||
MeshTest('Pyramid4_test_2', 'Pyr4_test', 'Pyr4_result_2',
|
||||
SpecMeshTest('Pyramid4_test_2', 'Pyr4_test', 'Pyr4_result_2',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {2, 5}, )]),
|
||||
MeshTest('Pyramid4_test_3', 'Pyr4_test', 'Pyr4_result_3',
|
||||
SpecMeshTest('Pyramid4_test_3', 'Pyr4_test', 'Pyr4_result_3',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {2, 3, 5}, )]),
|
||||
# 15
|
||||
MeshTest('Pyramid4_test_4', 'Pyr4_test', 'Pyr4_result_4',
|
||||
SpecMeshTest('Pyramid4_test_4', 'Pyr4_test', 'Pyr4_result_4',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {1, 2, 3, 5}, )]),
|
||||
MeshTest('Pyramid4_test_5', 'Pyr4_test', 'Pyr4_result_5',
|
||||
SpecMeshTest('Pyramid4_test_5', 'Pyr4_test', 'Pyr4_result_5',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 3}, 'EDGE', {1, 2, 3, 5}, )]),
|
||||
MeshTest('Pyramid4_test_6', 'Pyr4_test', 'Pyr4_result_6',
|
||||
SpecMeshTest('Pyramid4_test_6', 'Pyr4_test', 'Pyr4_result_6',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {2, 3}, )]),
|
||||
MeshTest('Pyramid4_test_7', 'Pyr4_test', 'Pyr4_result_7',
|
||||
SpecMeshTest('Pyramid4_test_7', 'Pyr4_test', 'Pyr4_result_7',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 4, 'profile': 0.15}, 'EDGE', {1, 2, 3, 5}, )]),
|
||||
MeshTest('Pyramid4_test_8', 'Pyr4_test', 'Pyr4_result_8',
|
||||
SpecMeshTest('Pyramid4_test_8', 'Pyr4_test', 'Pyr4_result_8',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.75, 'segments': 4, 'affect': 'VERTICES'}, 'VERT', {1}, )]),
|
||||
# 20
|
||||
MeshTest('Pyramid4_test_9', 'Pyr4_test', 'Pyr4_result_9',
|
||||
SpecMeshTest('Pyramid4_test_9', 'Pyr4_test', 'Pyr4_result_9',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.75, 'segments': 3, 'affect': 'VERTICES', 'profile': 0.25}, 'VERT',
|
||||
{1}, )]),
|
||||
MeshTest('Pyramid6_test_1', 'Pyr6_test', 'Pyr6_result_1',
|
||||
SpecMeshTest('Pyramid6_test_1', 'Pyr6_test', 'Pyr6_result_1',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {2, 3}, )]),
|
||||
MeshTest('Pyramid6_test_2', 'Pyr6_test', 'Pyr6_result_2',
|
||||
SpecMeshTest('Pyramid6_test_2', 'Pyr6_test', 'Pyr6_result_2',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {8, 2, 3}, )]),
|
||||
MeshTest('Pyramid6_test_3', 'Pyr6_test', 'Pyr6_result_3',
|
||||
SpecMeshTest('Pyramid6_test_3', 'Pyr6_test', 'Pyr6_result_3',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 4, 'profile': 0.8}, 'EDGE',
|
||||
{0, 2, 3, 4, 6, 7, 9, 10, 11}, )]),
|
||||
MeshTest('Sept_test_1', 'Sept_test', 'Sept_result_1',
|
||||
SpecMeshTest('Sept_test_1', 'Sept_test', 'Sept_result_1',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.1}, 'EDGE', {8, 9, 3, 11}, )]),
|
||||
# 25
|
||||
MeshTest('Sept_test_2', 'Sept_test', 'Sept_result_2',
|
||||
SpecMeshTest('Sept_test_2', 'Sept_test', 'Sept_result_2',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.1, 'offset_type': 'WIDTH'}, 'EDGE', {8, 9, 11}, )]),
|
||||
MeshTest('Saddle_test_1', 'Saddle_test', 'Saddle_result_1',
|
||||
SpecMeshTest('Saddle_test_1', 'Saddle_test', 'Saddle_result_1',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.3, 'segments': 5}, 'EDGE', {2, 8, 9, 12, 13, 14}, )]),
|
||||
MeshTest('Saddle_test_2', 'Saddle_test', 'Saddle_result_2',
|
||||
SpecMeshTest('Saddle_test_2', 'Saddle_test', 'Saddle_result_2',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.6, 'segments': 6, 'affect': 'VERTICES'}, 'VERT', {4}, )]),
|
||||
|
||||
MeshTest('Bent_test', 'Bent_test', 'Bent_result_1',
|
||||
SpecMeshTest('Bent_test', 'Bent_test', 'Bent_result_1',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 3},
|
||||
'EDGE',
|
||||
{2, 5, 8, 11, 14, 18, 21, 24, 27, 30, 34, 37, 40, 43, 46, 50, 53, 56, 59, 62,
|
||||
112, 113, 114, 115}, )]),
|
||||
MeshTest('Bentlines_test_1', 'Bentlines_test', 'Bentlines_result_1',
|
||||
SpecMeshTest('Bentlines_test_1', 'Bentlines_test', 'Bentlines_result_1',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 3}, 'EDGE', {1, 8, 9, 10, 11}, )]),
|
||||
# 30
|
||||
MeshTest('Flaretop_test_1', 'Flaretop_test', 'Flaretop_result_1',
|
||||
SpecMeshTest('Flaretop_test_1', 'Flaretop_test', 'Flaretop_result_1',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.4, 'segments': 2}, 'EDGE', {26, 12, 20}, )]),
|
||||
MeshTest('Flaretop_test_2', 'Flaretop_test', 'Flaretop_result_2',
|
||||
SpecMeshTest('Flaretop_test_2', 'Flaretop_test', 'Flaretop_result_2',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.4, 'segments': 2, 'profile': 1.0}, 'EDGE', {26, 12, 20}, )]),
|
||||
MeshTest('Flaretop_test_3', 'Flaretop_test', 'Flaretop_result_3',
|
||||
SpecMeshTest('Flaretop_test_3', 'Flaretop_test', 'Flaretop_result_3',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.4, 'segments': 4}, 'FACE', {1, 6, 7, 8, 9, 10, 11, 12}, )]),
|
||||
MeshTest('BentL_test', 'BentL_test', 'BentL_result_1',
|
||||
SpecMeshTest('BentL_test', 'BentL_test', 'BentL_result_1',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {4, 8, 10, 18, 24}, )]),
|
||||
MeshTest('Wires_test_1', 'Wires_test', 'Wires_test_result_1',
|
||||
SpecMeshTest('Wires_test_1', 'Wires_test', 'Wires_test_result_1',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.3}, 'EDGE', {0, 1, 2, 10}, )]),
|
||||
# 35
|
||||
MeshTest('Wires_test_2', 'Wires_test', 'Wires_test_result_2',
|
||||
SpecMeshTest('Wires_test_2', 'Wires_test', 'Wires_test_result_2',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.3, 'affect': 'VERTICES'}, 'VERT',
|
||||
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, )]),
|
||||
MeshTest('tri_test_1', 'tri', 'tri_result_1',
|
||||
SpecMeshTest('tri_test_1', 'tri', 'tri_result_1',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {3, 4, 5}, )]),
|
||||
MeshTest('tri_test_2', 'tri', 'tri_result_2',
|
||||
SpecMeshTest('tri_test_2', 'tri', 'tri_result_2',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {3, 4, 5}, )]),
|
||||
MeshTest('tri_test_3', 'tri', 'tri_result_3',
|
||||
SpecMeshTest('tri_test_3', 'tri', 'tri_result_3',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 3}, 'EDGE', {3, 4, 5}, )]),
|
||||
MeshTest('tri_test_4', 'tri', 'tri_result_4',
|
||||
SpecMeshTest('tri_test_4', 'tri', 'tri_result_4',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {3, 4}, )]),
|
||||
# 40
|
||||
MeshTest('tri_test_5', 'tri', 'tri_result_5',
|
||||
SpecMeshTest('tri_test_5', 'tri', 'tri_result_5',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {3, 4}, )]),
|
||||
MeshTest('tri_test_6', 'tri', 'tri_result_6',
|
||||
SpecMeshTest('tri_test_6', 'tri', 'tri_result_6',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'affect': 'VERTICES'}, 'VERT', {3}, )]),
|
||||
MeshTest('tri_test_7', 'tri', 'tri_result_7',
|
||||
SpecMeshTest('tri_test_7', 'tri', 'tri_result_7',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 2, 'affect': 'VERTICES'}, 'VERT', {3}, )]),
|
||||
MeshTest('tri_test_8', 'tri', 'tri_result_8',
|
||||
SpecMeshTest('tri_test_8', 'tri', 'tri_result_8',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 3, 'affect': 'VERTICES'}, 'VERT', {3}, )]),
|
||||
MeshTest('tri_test_9', 'tri', 'tri_result_9',
|
||||
SpecMeshTest('tri_test_9', 'tri', 'tri_result_9',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'affect': 'VERTICES'}, 'VERT', {1}, )]),
|
||||
# 45
|
||||
MeshTest('tri1gap_test_2', 'tri1gap', 'tri1gap_result_2',
|
||||
SpecMeshTest('tri1gap_test_2', 'tri1gap', 'tri1gap_result_2',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {3, 4, 5}, )]),
|
||||
MeshTest('tri1gap_test_3', 'tri1gap', 'tri1gap_result_3',
|
||||
SpecMeshTest('tri1gap_test_3', 'tri1gap', 'tri1gap_result_3',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 3}, 'EDGE', {3, 4, 5}, )]),
|
||||
MeshTest('tri1gap_test_1', 'tri1gap', 'tri1gap_result_1',
|
||||
SpecMeshTest('tri1gap_test_1', 'tri1gap', 'tri1gap_result_1',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {3, 4, 5}, )]),
|
||||
MeshTest('tri1gap_test_4', 'tri1gap', 'tri1gap_result_4',
|
||||
SpecMeshTest('tri1gap_test_4', 'tri1gap', 'tri1gap_result_4',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {3, 4}, )]),
|
||||
MeshTest('tri1gap_test_5', 'tri1gap', 'tri1gap_result_5',
|
||||
SpecMeshTest('tri1gap_test_5', 'tri1gap', 'tri1gap_result_5',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {3, 4}, )]),
|
||||
# 50
|
||||
MeshTest('tri1gap_test_6', 'tri1gap', 'tri1gap_result_6',
|
||||
SpecMeshTest('tri1gap_test_6', 'tri1gap', 'tri1gap_result_6',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 3}, 'EDGE', {3, 4}, )]),
|
||||
MeshTest('tri1gap_test_7', 'tri1gap', 'tri1gap_result_7',
|
||||
SpecMeshTest('tri1gap_test_7', 'tri1gap', 'tri1gap_result_7',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {3, 5}, )]),
|
||||
MeshTest('tri1gap_test_8', 'tri1gap', 'tri1gap_result_8',
|
||||
SpecMeshTest('tri1gap_test_8', 'tri1gap', 'tri1gap_result_8',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {3, 5}, )]),
|
||||
MeshTest('tri1gap_test_9', 'tri1gap', 'tri1gap_result_9',
|
||||
SpecMeshTest('tri1gap_test_9', 'tri1gap', 'tri1gap_result_9',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 3}, 'EDGE', {3, 5}, )]),
|
||||
MeshTest('tri1gap_test_10', 'tri1gap', 'tri1gap_result_10',
|
||||
SpecMeshTest('tri1gap_test_10', 'tri1gap', 'tri1gap_result_10',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'affect': 'VERTICES'}, 'VERT', {3}, )]),
|
||||
# 55
|
||||
MeshTest('tri2gaps_test_1', 'tri2gaps', 'tri2gaps_result_1',
|
||||
SpecMeshTest('tri2gaps_test_1', 'tri2gaps', 'tri2gaps_result_1',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {3, 4, 5}, )]),
|
||||
MeshTest('tri2gaps_test_2', 'tri2gaps', 'tri2gaps_result_2',
|
||||
SpecMeshTest('tri2gaps_test_2', 'tri2gaps', 'tri2gaps_result_2',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 2}, 'EDGE', {3, 4, 5}, )]),
|
||||
MeshTest('tri2gaps_test_3', 'tri2gaps', 'tri2gaps_result_3',
|
||||
SpecMeshTest('tri2gaps_test_3', 'tri2gaps', 'tri2gaps_result_3',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 3}, 'EDGE', {3, 4, 5}, )]),
|
||||
MeshTest('tri2gaps_test_4', 'tri2gaps', 'tri2gaps_result_4',
|
||||
SpecMeshTest('tri2gaps_test_4', 'tri2gaps', 'tri2gaps_result_4',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {3, 4}, )]),
|
||||
MeshTest('tri2gaps_test_5', 'tri2gaps', 'tri2gaps_result_5',
|
||||
SpecMeshTest('tri2gaps_test_5', 'tri2gaps', 'tri2gaps_result_5',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {3, 4}, )]),
|
||||
# 60
|
||||
MeshTest('tri2gaps_test_6', 'tri2gaps', 'tri2gaps_result_6',
|
||||
SpecMeshTest('tri2gaps_test_6', 'tri2gaps', 'tri2gaps_result_6',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 3}, 'EDGE', {3, 4}, )]),
|
||||
MeshTest('tri3gaps_test_1', 'tri3gaps', 'tri3gaps_result_1',
|
||||
SpecMeshTest('tri3gaps_test_1', 'tri3gaps', 'tri3gaps_result_1',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {3, 4, 5}, )]),
|
||||
MeshTest('tri3gaps_test_2', 'tri3gaps', 'tri3gaps_result_2',
|
||||
SpecMeshTest('tri3gaps_test_2', 'tri3gaps', 'tri3gaps_result_2',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 2}, 'EDGE', {3, 4, 5}, )]),
|
||||
MeshTest('tri3gaps_test_3', 'tri3gaps', 'tri3gaps_result_3',
|
||||
SpecMeshTest('tri3gaps_test_3', 'tri3gaps', 'tri3gaps_result_3',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 3}, 'EDGE', {3, 4, 5}, )]),
|
||||
MeshTest('cube3_test_1', 'cube3', 'cube3_result_1',
|
||||
SpecMeshTest('cube3_test_1', 'cube3', 'cube3_result_1',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2}, 'EDGE', {32, 33, 34, 35, 24, 25, 26, 27, 28, 29, 30, 31}, )]),
|
||||
# 65
|
||||
MeshTest('cube3_test_2', 'cube3', 'cube3_result_2',
|
||||
SpecMeshTest('cube3_test_2', 'cube3', 'cube3_result_2',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 2}, 'EDGE',
|
||||
{32, 33, 34, 35, 24, 25, 26, 27, 28, 29, 30, 31}, )]),
|
||||
MeshTest('cube3_test_3', 'cube3', 'cube3_result_3',
|
||||
SpecMeshTest('cube3_test_3', 'cube3', 'cube3_result_3',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {32, 35}, )]),
|
||||
MeshTest('cube3_test_4', 'cube3', 'cube3_result_4',
|
||||
SpecMeshTest('cube3_test_4', 'cube3', 'cube3_result_4',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {24, 35}, )]),
|
||||
MeshTest('cube3_test_5', 'cube3', 'cube3_result_5',
|
||||
SpecMeshTest('cube3_test_5', 'cube3', 'cube3_result_5',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {24, 32, 35}, )]),
|
||||
MeshTest('cube3_test_6', 'cube3', 'cube3_result_6',
|
||||
SpecMeshTest('cube3_test_6', 'cube3', 'cube3_result_6',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 3}, 'EDGE', {24, 32, 35}, )]),
|
||||
# 70
|
||||
MeshTest('Tray', 'Tray', 'Tray_result_1',
|
||||
SpecMeshTest('Tray', 'Tray', 'Tray_result_1',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.01, 'segments': 2}, 'EDGE', {0, 1, 6, 7, 12, 14, 16, 17}, )]),
|
||||
MeshTest("test 73", 'Bumptop', 'Bumptop_result_1',
|
||||
SpecMeshTest("test 73", 'Bumptop', 'Bumptop_result_1',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.1, 'segments': 4}, 'EDGE',
|
||||
{33, 4, 38, 8, 41, 10, 42, 12, 14, 17, 24, 31}, )]),
|
||||
MeshTest('Multisegment_test_1', 'Multisegment_test', 'Multisegment_result_1',
|
||||
SpecMeshTest('Multisegment_test_1', 'Multisegment_test', 'Multisegment_result_1',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2}, 'EDGE', {16, 14, 15}, )]),
|
||||
MeshTest('Window_test', 'Window_test', 'Window_result_1',
|
||||
SpecMeshTest('Window_test', 'Window_test', 'Window_result_1',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.05, 'segments': 2}, 'EDGE', {19, 20, 23, 15}, )]),
|
||||
# 75
|
||||
MeshTest("test 77", 'Cube_hn_test', 'Cube_hn_result_1',
|
||||
SpecMeshTest("test 77", 'Cube_hn_test', 'Cube_hn_result_1',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'harden_normals': True}, 'EDGE', {8}, )]),
|
||||
MeshTest('Blocksteps_test_1', 'Blocksteps_test', 'Blocksteps_result_1',
|
||||
SpecMeshTest('Blocksteps_test_1', 'Blocksteps_test', 'Blocksteps_result_1',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'miter_outer': 'PATCH'}, 'EDGE', {4, 7, 39, 27, 30, 31}, )]),
|
||||
MeshTest('Blocksteps_test_2', 'Blocksteps_test', 'Blocksteps_result_2',
|
||||
SpecMeshTest('Blocksteps_test_2', 'Blocksteps_test', 'Blocksteps_result_2',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 2, 'miter_outer': 'PATCH'}, 'EDGE',
|
||||
{4, 7, 39, 27, 30, 31}, )]),
|
||||
MeshTest('Blocksteps_test_3', 'Blocksteps_test', 'Blocksteps_result_3',
|
||||
SpecMeshTest('Blocksteps_test_3', 'Blocksteps_test', 'Blocksteps_result_3',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 3, 'miter_outer': 'PATCH'}, 'EDGE',
|
||||
{4, 7, 39, 27, 30, 31}, )]),
|
||||
MeshTest('Blocksteps_test_4', 'Blocksteps_test', 'Blocksteps_result_4',
|
||||
SpecMeshTest('Blocksteps_test_4', 'Blocksteps_test', 'Blocksteps_result_4',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'miter_outer': 'ARC'}, 'EDGE', {4, 7, 39, 27, 30, 31}, )]),
|
||||
# 80
|
||||
MeshTest('Blocksteps_test_5', 'Blocksteps_test', 'Blocksteps_result_5',
|
||||
SpecMeshTest('Blocksteps_test_5', 'Blocksteps_test', 'Blocksteps_result_5',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 2, 'miter_outer': 'ARC'}, 'EDGE',
|
||||
{4, 7, 39, 27, 30, 31}, )]),
|
||||
MeshTest('Blocksteps_test_6', 'Blocksteps_test', 'Blocksteps_result_6',
|
||||
SpecMeshTest('Blocksteps_test_6', 'Blocksteps_test', 'Blocksteps_result_6',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 3, 'miter_outer': 'ARC'}, 'EDGE',
|
||||
{4, 7, 39, 27, 30, 31}, )]),
|
||||
MeshTest('Blocksteps_test_7', 'Blocksteps_test', 'Blocksteps_result_7',
|
||||
SpecMeshTest('Blocksteps_test_7', 'Blocksteps_test', 'Blocksteps_result_7',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'miter_outer': 'PATCH', 'miter_inner': 'ARC'}, 'EDGE',
|
||||
{4, 7, 39, 27, 30, 31}, )]),
|
||||
MeshTest("Blocksteps_test_8", 'Blocksteps_test', 'Blocksteps_result_8',
|
||||
SpecMeshTest("Blocksteps_test_8", 'Blocksteps_test', 'Blocksteps_result_8',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 2, 'miter_outer': 'PATCH', 'miter_inner': 'ARC'},
|
||||
'EDGE', {4, 7, 39, 27, 30, 31}, )]),
|
||||
MeshTest('Blocksteps2_test', 'Blocksteps2_test', 'Blocksteps2_result_9',
|
||||
SpecMeshTest('Blocksteps2_test', 'Blocksteps2_test', 'Blocksteps2_result_9',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 2, 'miter_outer': 'ARC'}, 'EDGE',
|
||||
{4, 7, 39, 27, 30, 31}, )]),
|
||||
# 85
|
||||
MeshTest('Blocksteps3_test', 'Blocksteps3_test', 'Blocksteps3_result_10',
|
||||
SpecMeshTest('Blocksteps3_test', 'Blocksteps3_test', 'Blocksteps3_result_10',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 2, 'miter_outer': 'ARC'}, 'EDGE',
|
||||
{4, 7, 39, 27, 30, 31}, )]),
|
||||
MeshTest('Blocksteps4_test_1', 'Blocksteps4_test', 'Blocksteps4_result_11',
|
||||
SpecMeshTest('Blocksteps4_test_1', 'Blocksteps4_test', 'Blocksteps4_result_11',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 2, 'miter_outer': 'ARC'}, 'EDGE',
|
||||
{4, 7, 39, 27, 30, 31}, )]),
|
||||
MeshTest('Blocksteps4_test_2', 'Blocksteps4_test', 'Blocksteps4_result_12',
|
||||
SpecMeshTest('Blocksteps4_test_2', 'Blocksteps4_test', 'Blocksteps4_result_12',
|
||||
[OperatorSpecEditMode('bevel',
|
||||
{'offset': 0.2, 'segments': 3, 'miter_outer': 'ARC'}, 'EDGE',
|
||||
{4, 7, 39, 27, 30, 31}, )]),
|
||||
MeshTest('Spike_test', 'Spike_test', 'Spike_result_1',
|
||||
SpecMeshTest('Spike_test', 'Spike_test', 'Spike_result_1',
|
||||
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 3}, 'EDGE', {1, 7})])
|
||||
|
||||
]
|
||||
|
||||
@@ -29,37 +29,37 @@ import os
|
||||
import sys
|
||||
|
||||
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
|
||||
from modules.mesh_test import MeshTest, OperatorSpecEditMode, RunTest
|
||||
from modules.mesh_test import SpecMeshTest, OperatorSpecEditMode, RunTest
|
||||
|
||||
|
||||
def main():
|
||||
tests = [
|
||||
|
||||
MeshTest('Cubecube_intersect_union', 'Cubecube', 'Cubecube_result_1',
|
||||
SpecMeshTest('Cubecube_intersect_union', 'Cubecube', 'Cubecube_result_1',
|
||||
[OperatorSpecEditMode('intersect_boolean',
|
||||
{'operation': 'UNION', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
|
||||
MeshTest('Cubecube_intersect_intersect', 'Cubecube', 'Cubecube_result_2',
|
||||
SpecMeshTest('Cubecube_intersect_intersect', 'Cubecube', 'Cubecube_result_2',
|
||||
[OperatorSpecEditMode('intersect_boolean', {'operation': 'INTERSECT', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
|
||||
MeshTest('Cubecube_intersect_difference', 'Cubecube', 'Cubecube_result_3',
|
||||
SpecMeshTest('Cubecube_intersect_difference', 'Cubecube', 'Cubecube_result_3',
|
||||
[OperatorSpecEditMode('intersect_boolean', {'operation': 'DIFFERENCE', 'solver': 'FAST'}, 'FACE',
|
||||
{0, 1, 2, 3, 4, 5}, )]),
|
||||
MeshTest('Cubecube_intersect_cut', 'Cubecube', 'Cubecube_result_4', [OperatorSpecEditMode('intersect',
|
||||
SpecMeshTest('Cubecube_intersect_cut', 'Cubecube', 'Cubecube_result_4', [OperatorSpecEditMode('intersect',
|
||||
{'separate_mode': 'CUT', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
|
||||
MeshTest('Cubecube_intersect_all', 'Cubecube', 'Cubecube_result_5',
|
||||
SpecMeshTest('Cubecube_intersect_all', 'Cubecube', 'Cubecube_result_5',
|
||||
[OperatorSpecEditMode('intersect',
|
||||
{'separate_mode': 'ALL', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
|
||||
MeshTest('Cubecube_intersect_none', 'Cubecube', 'Cubecube_result_6',
|
||||
SpecMeshTest('Cubecube_intersect_none', 'Cubecube', 'Cubecube_result_6',
|
||||
[OperatorSpecEditMode('intersect',
|
||||
{'separate_mode': 'NONE', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
|
||||
MeshTest('Cubecube_intersect_select_none', 'Cubecube',
|
||||
SpecMeshTest('Cubecube_intersect_select_none', 'Cubecube',
|
||||
'Cubecube_result_7',
|
||||
[OperatorSpecEditMode('intersect',
|
||||
{'mode': 'SELECT', 'separate_mode': 'NONE', 'solver': 'FAST'}, 'FACE',
|
||||
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, )]),
|
||||
MeshTest('Cubecone_intersect_union', 'Cubecone', 'Cubecone_result_1',
|
||||
SpecMeshTest('Cubecone_intersect_union', 'Cubecone', 'Cubecone_result_1',
|
||||
[OperatorSpecEditMode('intersect_boolean',
|
||||
{'operation': 'UNION', 'solver': 'FAST'}, 'FACE', {6, 7, 8, 9, 10}, )]),
|
||||
MeshTest('Cubecones_intersect_union', 'Cubecones', 'Cubecones_result_1',
|
||||
SpecMeshTest('Cubecones_intersect_union', 'Cubecones', 'Cubecones_result_1',
|
||||
[OperatorSpecEditMode('intersect_boolean', {'operation': 'UNION', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
|
||||
|
||||
]
|
||||
|
||||
@@ -24,74 +24,74 @@ import os
|
||||
import sys
|
||||
|
||||
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
|
||||
from modules.mesh_test import MeshTest, OperatorSpecObjectMode, RunTest
|
||||
from modules.mesh_test import SpecMeshTest, OperatorSpecObjectMode, RunTest
|
||||
|
||||
|
||||
def main():
|
||||
tests = [
|
||||
MeshTest('2D Non Cyclic', 'test2DNonCyclic', 'expected2DNonCyclic',
|
||||
SpecMeshTest('2D Non Cyclic', 'test2DNonCyclic', 'expected2DNonCyclic',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('2D NURBS With Tail', 'test2DNURBSWithTail', 'expected2DNURBSWithTail',
|
||||
SpecMeshTest('2D NURBS With Tail', 'test2DNURBSWithTail', 'expected2DNURBSWithTail',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('2D Shape With Hole', 'test2DShapeWithHole', 'expected2DShapeWithHole',
|
||||
SpecMeshTest('2D Shape With Hole', 'test2DShapeWithHole', 'expected2DShapeWithHole',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('2D Simple Lower Res', 'test2DSimpleLowerRes', 'expected2DSimpleLowerRes',
|
||||
SpecMeshTest('2D Simple Lower Res', 'test2DSimpleLowerRes', 'expected2DSimpleLowerRes',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('2D Simple Low Res', 'test2DSimpleLowRes', 'expected2DSimpleLowRes',
|
||||
SpecMeshTest('2D Simple Low Res', 'test2DSimpleLowRes', 'expected2DSimpleLowRes',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('2D Square', 'test2DSquare', 'expected2DSquare',
|
||||
SpecMeshTest('2D Square', 'test2DSquare', 'expected2DSquare',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('2D Extrude', 'test2DExtrude', 'expected2DExtrude',
|
||||
SpecMeshTest('2D Extrude', 'test2DExtrude', 'expected2DExtrude',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Bevel Back', 'testBevelBack', 'expectedBevelBack',
|
||||
SpecMeshTest('Bevel Back', 'testBevelBack', 'expectedBevelBack',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Bevel Back Low Res', 'testBevelBackLowRes', 'expectedBevelBackLowRes',
|
||||
SpecMeshTest('Bevel Back Low Res', 'testBevelBackLowRes', 'expectedBevelBackLowRes',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Bevel Extrude Back', 'testBevelExtrudeBack', 'expectedBevelExtrudeBack',
|
||||
SpecMeshTest('Bevel Extrude Back', 'testBevelExtrudeBack', 'expectedBevelExtrudeBack',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Bevel Extrude Front', 'testBevelExtrudeFront', 'expectedBevelExtrudeFront',
|
||||
SpecMeshTest('Bevel Extrude Front', 'testBevelExtrudeFront', 'expectedBevelExtrudeFront',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Bevel Extrude Full', 'testBevelExtrudeFull', 'expectedBevelExtrudeFull',
|
||||
SpecMeshTest('Bevel Extrude Full', 'testBevelExtrudeFull', 'expectedBevelExtrudeFull',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Bevel Extrude Half', 'testBevelExtrudeHalf', 'expectedBevelExtrudeHalf',
|
||||
SpecMeshTest('Bevel Extrude Half', 'testBevelExtrudeHalf', 'expectedBevelExtrudeHalf',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Bevel Front', 'testBevelFront', 'expectedBevelFront',
|
||||
SpecMeshTest('Bevel Front', 'testBevelFront', 'expectedBevelFront',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Bevel Front Low Res', 'testBevelFrontLowRes', 'expectedBevelFrontLowRes',
|
||||
SpecMeshTest('Bevel Front Low Res', 'testBevelFrontLowRes', 'expectedBevelFrontLowRes',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Bevel Full', 'testBevelFull', 'expectedBevelFull',
|
||||
SpecMeshTest('Bevel Full', 'testBevelFull', 'expectedBevelFull',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Bevel Full Low Res', 'testBevelFullLowRes', 'expectedBevelFullLowRes',
|
||||
SpecMeshTest('Bevel Full Low Res', 'testBevelFullLowRes', 'expectedBevelFullLowRes',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Bevel Half', 'testBevelHalf', 'expectedBevelHalf',
|
||||
SpecMeshTest('Bevel Half', 'testBevelHalf', 'expectedBevelHalf',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Bevel Half Low Res', 'testBevelHalfLowRes', 'expectedBevelHalfLowRes',
|
||||
SpecMeshTest('Bevel Half Low Res', 'testBevelHalfLowRes', 'expectedBevelHalfLowRes',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Caps None', 'testCapsNone', 'expectedCapsNone',
|
||||
SpecMeshTest('Caps None', 'testCapsNone', 'expectedCapsNone',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Caps Object Bevel', 'testCapsObjectBevel', 'expectedCapsObjectBevel',
|
||||
SpecMeshTest('Caps Object Bevel', 'testCapsObjectBevel', 'expectedCapsObjectBevel',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Caps Profile Bevel', 'testCapsProfileBevel', 'expectedCapsProfileBevel',
|
||||
SpecMeshTest('Caps Profile Bevel', 'testCapsProfileBevel', 'expectedCapsProfileBevel',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Caps Profile Bevel Half', 'testCapsProfileBevelHalf', 'expectedCapsProfileBevelHalf',
|
||||
SpecMeshTest('Caps Profile Bevel Half', 'testCapsProfileBevelHalf', 'expectedCapsProfileBevelHalf',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Caps Profile Bevel Quarter', 'testCapsProfileBevelQuarter', 'expectedCapsProfileBevelQuarter',
|
||||
SpecMeshTest('Caps Profile Bevel Quarter', 'testCapsProfileBevelQuarter', 'expectedCapsProfileBevelQuarter',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Caps Round Bevel', 'testCapsRoundBevel', 'expectedCapsRoundBevel',
|
||||
SpecMeshTest('Caps Round Bevel', 'testCapsRoundBevel', 'expectedCapsRoundBevel',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Caps Round Bevel Extrude', 'testCapsRoundBevelExtrude', 'expectedCapsRoundBevelExtrude',
|
||||
SpecMeshTest('Caps Round Bevel Extrude', 'testCapsRoundBevelExtrude', 'expectedCapsRoundBevelExtrude',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Caps Round Bevel Half', 'testCapsRoundBevelHalf', 'expectedCapsRoundBevelHalf',
|
||||
SpecMeshTest('Caps Round Bevel Half', 'testCapsRoundBevelHalf', 'expectedCapsRoundBevelHalf',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Caps Round Bevel Quarter', 'testCapsRoundBevelQuarter', 'expectedCapsRoundBevelQuarter',
|
||||
SpecMeshTest('Caps Round Bevel Quarter', 'testCapsRoundBevelQuarter', 'expectedCapsRoundBevelQuarter',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Extrude Back', 'testExtrudeBack', 'expectedExtrudeBack',
|
||||
SpecMeshTest('Extrude Back', 'testExtrudeBack', 'expectedExtrudeBack',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Extrude Front', 'testExtrudeFront', 'expectedExtrudeFront',
|
||||
SpecMeshTest('Extrude Front', 'testExtrudeFront', 'expectedExtrudeFront',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Extrude Full', 'testExtrudeFull', 'expectedExtrudeFull',
|
||||
SpecMeshTest('Extrude Full', 'testExtrudeFull', 'expectedExtrudeFull',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
MeshTest('Extrude Half', 'testExtrudeHalf', 'expectedExtrudeHalf',
|
||||
SpecMeshTest('Extrude Half', 'testExtrudeHalf', 'expectedExtrudeHalf',
|
||||
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
|
||||
]
|
||||
operator_test = RunTest(tests)
|
||||
|
||||
@@ -28,14 +28,14 @@ import sys
|
||||
import bpy
|
||||
|
||||
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
|
||||
from modules.mesh_test import MeshTest, ModifierSpec, OperatorSpecObjectMode, DeformModifierSpec, RunTest
|
||||
from modules.mesh_test import SpecMeshTest, ModifierSpec, OperatorSpecObjectMode, DeformModifierSpec, RunTest
|
||||
|
||||
tests = [
|
||||
|
||||
# Surface Deform Test, finally can bind to the Target object.
|
||||
# Actual deformation occurs by animating imitating user input.
|
||||
|
||||
MeshTest("SurfaceDeform", "testObjMonkeySurfaceDeform", "expObjMonkeySurfaceDeform",
|
||||
SpecMeshTest("SurfaceDeform", "testObjMonkeySurfaceDeform", "expObjMonkeySurfaceDeform",
|
||||
[DeformModifierSpec(10, [
|
||||
ModifierSpec('surface_deform', 'SURFACE_DEFORM', {'target': bpy.data.objects["Cube"]})],
|
||||
OperatorSpecObjectMode('surfacedeform_bind', {'modifier': 'surface_deform'}))]),
|
||||
@@ -43,7 +43,7 @@ tests = [
|
||||
# Mesh Deform Test, finally can bind to the Target object.
|
||||
# Actual deformation occurs by animating imitating user input.
|
||||
|
||||
MeshTest("MeshDeform", "testObjMonkeyMeshDeform", "expObjMonkeyMeshDeform",
|
||||
SpecMeshTest("MeshDeform", "testObjMonkeyMeshDeform", "expObjMonkeyMeshDeform",
|
||||
[DeformModifierSpec(10, [ModifierSpec('mesh_deform', 'MESH_DEFORM',
|
||||
{'object': bpy.data.objects["MeshCube"], 'precision': 2})],
|
||||
OperatorSpecObjectMode('meshdeform_bind', {'modifier': 'mesh_deform'}))]),
|
||||
@@ -51,21 +51,21 @@ tests = [
|
||||
# Surface Deform Test, finally can bind to the Target object.
|
||||
# Actual deformation occurs by animating imitating user input.
|
||||
|
||||
MeshTest("Hook", "testObjHookPlane", "expObjHookPlane",
|
||||
SpecMeshTest("Hook", "testObjHookPlane", "expObjHookPlane",
|
||||
[DeformModifierSpec(10, [ModifierSpec('hook', 'HOOK',
|
||||
{'object': bpy.data.objects["Empty"], 'falloff_radius': 1,
|
||||
'vertex_group': 'Group'})])]),
|
||||
|
||||
# Laplacian Deform Test, first a hook is attached.
|
||||
|
||||
MeshTest("Laplace", "testObjCubeLaplacian", "expObjCubeLaplacian",
|
||||
SpecMeshTest("Laplace", "testObjCubeLaplacian", "expObjCubeLaplacian",
|
||||
[DeformModifierSpec(10,
|
||||
[ModifierSpec('hook2', 'HOOK', {'object': bpy.data.objects["Empty.001"],
|
||||
'vertex_group': 'hook_vg'}),
|
||||
ModifierSpec('laplace', 'LAPLACIANDEFORM', {'vertex_group': 'laplace_vg'})],
|
||||
OperatorSpecObjectMode('laplaciandeform_bind', {'modifier': 'laplace'}))]),
|
||||
|
||||
MeshTest("WarpPlane", "testObjPlaneWarp", "expObjPlaneWarp",
|
||||
SpecMeshTest("WarpPlane", "testObjPlaneWarp", "expObjPlaneWarp",
|
||||
[DeformModifierSpec(10, [ModifierSpec('warp', 'WARP',
|
||||
{'object_from': bpy.data.objects["From"],
|
||||
'object_to': bpy.data.objects["To"],
|
||||
@@ -74,29 +74,29 @@ tests = [
|
||||
#############################################
|
||||
# Curves Deform Modifiers
|
||||
#############################################
|
||||
MeshTest("CurveArmature", "testObjBezierCurveArmature", "expObjBezierCurveArmature",
|
||||
SpecMeshTest("CurveArmature", "testObjBezierCurveArmature", "expObjBezierCurveArmature",
|
||||
[DeformModifierSpec(10, [ModifierSpec('curve_armature', 'ARMATURE',
|
||||
{'object': bpy.data.objects['testArmatureHelper'],
|
||||
'use_vertex_groups': False, 'use_bone_envelopes': True})])]),
|
||||
|
||||
MeshTest("CurveLattice", "testObjBezierCurveLattice", "expObjBezierCurveLattice",
|
||||
SpecMeshTest("CurveLattice", "testObjBezierCurveLattice", "expObjBezierCurveLattice",
|
||||
[DeformModifierSpec(10, [ModifierSpec('curve_lattice', 'LATTICE',
|
||||
{'object': bpy.data.objects['testLatticeCurve']})])]),
|
||||
|
||||
# HOOK for Curves can't be tested with current framework, as it requires going to Edit Mode to select vertices,
|
||||
# here is no equivalent of a vertex group in Curves.
|
||||
# Dummy test for Hook, can also be called corner case
|
||||
MeshTest("CurveHook", "testObjBezierCurveHook", "expObjBezierCurveHook",
|
||||
SpecMeshTest("CurveHook", "testObjBezierCurveHook", "expObjBezierCurveHook",
|
||||
[DeformModifierSpec(10,
|
||||
[ModifierSpec('curve_Hook', 'HOOK', {'object': bpy.data.objects['EmptyCurve']})])]),
|
||||
|
||||
MeshTest("MeshDeformCurve", "testObjCurveMeshDeform", "expObjCurveMeshDeform",
|
||||
SpecMeshTest("MeshDeformCurve", "testObjCurveMeshDeform", "expObjCurveMeshDeform",
|
||||
[DeformModifierSpec(10, [
|
||||
ModifierSpec('mesh_deform_curve', 'MESH_DEFORM', {'object': bpy.data.objects["Cylinder"],
|
||||
'precision': 2})],
|
||||
OperatorSpecObjectMode('meshdeform_bind', {'modifier': 'mesh_deform_curve'}))]),
|
||||
|
||||
MeshTest("WarpCurve", "testObjBezierCurveWarp", "expObjBezierCurveWarp",
|
||||
SpecMeshTest("WarpCurve", "testObjBezierCurveWarp", "expObjBezierCurveWarp",
|
||||
[DeformModifierSpec(10, [ModifierSpec('warp_curve', 'WARP',
|
||||
{'object_from': bpy.data.objects["From_curve"],
|
||||
'object_to': bpy.data.objects["To_curve"]})])]),
|
||||
|
||||
33
tests/python/geo_node_test.py
Normal file
33
tests/python/geo_node_test.py
Normal file
@@ -0,0 +1,33 @@
|
||||
# ##### BEGIN GPL LICENSE BLOCK #####
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software Foundation,
|
||||
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
#
|
||||
# ##### END GPL LICENSE BLOCK #####
|
||||
|
||||
# <pep8 compliant>
|
||||
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
|
||||
from modules.mesh_test import BlendFileTest
|
||||
|
||||
geo_node_test = BlendFileTest("test_object", "expected_object")
|
||||
result = geo_node_test.run_test()
|
||||
|
||||
# Telling `ctest` about the failed test by raising Exception.
|
||||
if result == False:
|
||||
raise Exception("Failed {}".format(geo_node_test.test_name))
|
||||
@@ -26,7 +26,7 @@ from random import shuffle, seed
|
||||
import bpy
|
||||
|
||||
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
|
||||
from modules.mesh_test import RunTest, ModifierSpec, MeshTest
|
||||
from modules.mesh_test import RunTest, ModifierSpec, SpecMeshTest
|
||||
|
||||
seed(0)
|
||||
|
||||
@@ -87,22 +87,22 @@ def main():
|
||||
# List of 'Generate' modifiers on a cube
|
||||
###############################
|
||||
# 0
|
||||
# MeshTest("testCube", "expectedCube", get_generate_modifiers_list("testCube")),
|
||||
MeshTest("CubeRandom", "testCubeRandom", "expectedCubeRandom",
|
||||
# SpecMeshTest("testCube", "expectedCube", get_generate_modifiers_list("testCube")),
|
||||
SpecMeshTest("CubeRandom", "testCubeRandom", "expectedCubeRandom",
|
||||
get_generate_modifiers_list("testCubeRandom", randomize=True)),
|
||||
MeshTest("CubeMaskFirst", "testCubeMaskFirst", "expectedCubeMaskFirst", mask_first_list),
|
||||
SpecMeshTest("CubeMaskFirst", "testCubeMaskFirst", "expectedCubeMaskFirst", mask_first_list),
|
||||
|
||||
MeshTest("CollapseDecimate", "testCollapseDecimate", "expectedCollapseDecimate",
|
||||
SpecMeshTest("CollapseDecimate", "testCollapseDecimate", "expectedCollapseDecimate",
|
||||
[ModifierSpec('decimate', 'DECIMATE',
|
||||
{'decimate_type': 'COLLAPSE', 'ratio': 0.25, 'use_collapse_triangulate': True})]),
|
||||
MeshTest("PlanarDecimate", "testPlanarDecimate", "expectedPlanarDecimate",
|
||||
SpecMeshTest("PlanarDecimate", "testPlanarDecimate", "expectedPlanarDecimate",
|
||||
[ModifierSpec('decimate', 'DECIMATE',
|
||||
{'decimate_type': 'DISSOLVE', 'angle_limit': math.radians(30)})]),
|
||||
MeshTest("UnsubdivideDecimate", "testUnsubdivideDecimate", "expectedUnsubdivideDecimate",
|
||||
SpecMeshTest("UnsubdivideDecimate", "testUnsubdivideDecimate", "expectedUnsubdivideDecimate",
|
||||
[ModifierSpec('decimate', 'DECIMATE', {'decimate_type': 'UNSUBDIV', 'iterations': 2})]),
|
||||
|
||||
# 5
|
||||
MeshTest("RadialBisectMirror", "testRadialBisectMirror", "expectedRadialBisectMirror",
|
||||
SpecMeshTest("RadialBisectMirror", "testRadialBisectMirror", "expectedRadialBisectMirror",
|
||||
[ModifierSpec('mirror1', 'MIRROR', {'use_bisect_axis': (True, False, False)}),
|
||||
ModifierSpec('mirror2', 'MIRROR', {'use_bisect_axis': (True, False, False),
|
||||
'mirror_object': bpy.data.objects[
|
||||
@@ -111,17 +111,17 @@ def main():
|
||||
{'use_axis': (False, True, False), 'use_bisect_axis': (False, True, False),
|
||||
'use_bisect_flip_axis': (False, True, False),
|
||||
'mirror_object': bpy.data.objects["testRadialBisectMirrorHelper"]})]),
|
||||
MeshTest("T58411Mirror", "regressT58411Mirror", "expectedT58411Mirror",
|
||||
SpecMeshTest("T58411Mirror", "regressT58411Mirror", "expectedT58411Mirror",
|
||||
[ModifierSpec('mirror', 'MIRROR', {}),
|
||||
ModifierSpec('bevel', 'BEVEL', {'segments': 2, 'limit_method': 'WEIGHT'}),
|
||||
ModifierSpec('subd', 'SUBSURF', {'levels': 1})]),
|
||||
|
||||
MeshTest("BasicScrew", "testBasicScrew", "expectedBasicScrew",
|
||||
SpecMeshTest("BasicScrew", "testBasicScrew", "expectedBasicScrew",
|
||||
[ModifierSpec('mirror', 'MIRROR', {'mirror_object': bpy.data.objects["testBasicScrewHelper"]}),
|
||||
ModifierSpec("screw", 'SCREW',
|
||||
{'angle': math.radians(400), 'steps': 20, 'iterations': 2, 'screw_offset': 2,
|
||||
'use_normal_calculate': True})]),
|
||||
MeshTest("ObjectScrew", "testObjectScrew", "expectedObjectScrew",
|
||||
SpecMeshTest("ObjectScrew", "testObjectScrew", "expectedObjectScrew",
|
||||
[ModifierSpec('mirror', 'MIRROR', {'mirror_object': bpy.data.objects["testObjectScrewHelper2"]}),
|
||||
ModifierSpec("screw", 'SCREW',
|
||||
{"angle": math.radians(600), 'steps': 32, 'iterations': 1,
|
||||
@@ -129,16 +129,16 @@ def main():
|
||||
'use_normal_calculate': True, 'object': bpy.data.objects["testObjectScrewHelper1"]})]),
|
||||
|
||||
# 9
|
||||
MeshTest("MergedScrewWeld", "testMergedScrewWeld", "expectedMergedScrewWeld",
|
||||
SpecMeshTest("MergedScrewWeld", "testMergedScrewWeld", "expectedMergedScrewWeld",
|
||||
[ModifierSpec("screw", 'SCREW',
|
||||
{'angle': math.radians(360), 'steps': 12, 'iterations': 1, 'screw_offset': 1,
|
||||
'use_normal_calculate': True, 'use_merge_vertices': True}),
|
||||
ModifierSpec("weld", 'WELD', {"merge_threshold": 0.001})]),
|
||||
MeshTest("T72380Weld", "regressT72380Weld", "expectedT72380Weld",
|
||||
SpecMeshTest("T72380Weld", "regressT72380Weld", "expectedT72380Weld",
|
||||
[ModifierSpec('vedit', 'VERTEX_WEIGHT_EDIT',
|
||||
{'vertex_group': 'Group', 'use_remove': True, 'remove_threshold': 1}),
|
||||
ModifierSpec("weld", 'WELD', {"merge_threshold": 0.2, "vertex_group": "Group"})]),
|
||||
MeshTest("T72792Weld", "regressT72792Weld", "expectedT72792Weld",
|
||||
SpecMeshTest("T72792Weld", "regressT72792Weld", "expectedT72792Weld",
|
||||
[ModifierSpec('array', 'ARRAY', {'fit_type': 'FIXED_COUNT', 'count': 2}),
|
||||
ModifierSpec("weld", 'WELD', {"merge_threshold": 0.1, "vertex_group": "Group"})]),
|
||||
|
||||
@@ -146,89 +146,89 @@ def main():
|
||||
# One 'Generate' modifier on primitive meshes
|
||||
#############################################
|
||||
# 12
|
||||
MeshTest("CubeArray", "testCubeArray", "expectedCubeArray",
|
||||
SpecMeshTest("CubeArray", "testCubeArray", "expectedCubeArray",
|
||||
[ModifierSpec('array', 'ARRAY', {})]),
|
||||
MeshTest("CapArray", "testCapArray", "expectedCapArray",
|
||||
SpecMeshTest("CapArray", "testCapArray", "expectedCapArray",
|
||||
[ModifierSpec('array', 'ARRAY',
|
||||
{'fit_type': 'FIT_LENGTH', 'fit_length': 2.0,
|
||||
'start_cap': bpy.data.objects["testCapStart"],
|
||||
'end_cap': bpy.data.objects["testCapEnd"]})]),
|
||||
MeshTest("CurveArray", "testCurveArray", "expectedCurveArray",
|
||||
SpecMeshTest("CurveArray", "testCurveArray", "expectedCurveArray",
|
||||
[ModifierSpec('array', 'ARRAY',
|
||||
{'fit_type': 'FIT_CURVE', 'curve': bpy.data.objects["testCurveArrayHelper"],
|
||||
'use_relative_offset': False, 'use_constant_offset': True,
|
||||
'constant_offset_displace': (0.5, 0, 0)})]),
|
||||
MeshTest("RadialArray", "testRadialArray", "expectedRadialArray",
|
||||
SpecMeshTest("RadialArray", "testRadialArray", "expectedRadialArray",
|
||||
[ModifierSpec('array', 'ARRAY', {'fit_type': 'FIXED_COUNT', 'count': 3, 'use_merge_vertices': True,
|
||||
'use_merge_vertices_cap': True, 'use_relative_offset': False,
|
||||
'use_object_offset': True,
|
||||
'offset_object': bpy.data.objects["testRadialArrayHelper"]})]),
|
||||
|
||||
MeshTest("CylinderBuild", "testCylinderBuild", "expectedCylinderBuild",
|
||||
SpecMeshTest("CylinderBuild", "testCylinderBuild", "expectedCylinderBuild",
|
||||
[ModifierSpec('build', 'BUILD', {'frame_start': 1, 'frame_duration': 1}, 2)]),
|
||||
|
||||
# 17
|
||||
MeshTest("ConeDecimate", "testConeDecimate", "expectedConeDecimate",
|
||||
SpecMeshTest("ConeDecimate", "testConeDecimate", "expectedConeDecimate",
|
||||
[ModifierSpec('decimate', 'DECIMATE', {'ratio': 0.5})]),
|
||||
MeshTest("CubeEdgeSplit", "testCubeEdgeSplit", "expectedCubeEdgeSplit",
|
||||
SpecMeshTest("CubeEdgeSplit", "testCubeEdgeSplit", "expectedCubeEdgeSplit",
|
||||
[ModifierSpec('edge split', 'EDGE_SPLIT', {})]),
|
||||
|
||||
MeshTest("SphereMirror", "testSphereMirror", "expectedSphereMirror",
|
||||
SpecMeshTest("SphereMirror", "testSphereMirror", "expectedSphereMirror",
|
||||
[ModifierSpec('mirror', 'MIRROR', {})]),
|
||||
MeshTest("LocalMirror", "testLocalMirror", "expectedLocalMirror",
|
||||
SpecMeshTest("LocalMirror", "testLocalMirror", "expectedLocalMirror",
|
||||
[ModifierSpec('mirror', 'MIRROR', {'use_clip': True})]),
|
||||
MeshTest("ObjectOffsetMirror", "testObjectOffsetMirror", "expectedObjectOffsetMirror",
|
||||
SpecMeshTest("ObjectOffsetMirror", "testObjectOffsetMirror", "expectedObjectOffsetMirror",
|
||||
[ModifierSpec('mirror', 'MIRROR',
|
||||
{'mirror_object': bpy.data.objects["testObjectOffsetMirrorHelper"]})]),
|
||||
|
||||
MeshTest("CylinderMask", "testCylinderMask", "expectedCylinderMask",
|
||||
SpecMeshTest("CylinderMask", "testCylinderMask", "expectedCylinderMask",
|
||||
[ModifierSpec('mask', 'MASK', {'vertex_group': "mask_vertex_group"})]),
|
||||
MeshTest("ConeMultiRes", "testConeMultiRes", "expectedConeMultiRes",
|
||||
SpecMeshTest("ConeMultiRes", "testConeMultiRes", "expectedConeMultiRes",
|
||||
[ModifierSpec('multires', 'MULTIRES', {})]),
|
||||
|
||||
# 24
|
||||
MeshTest("CubeScrew", "testCubeScrew", "expectedCubeScrew",
|
||||
SpecMeshTest("CubeScrew", "testCubeScrew", "expectedCubeScrew",
|
||||
[ModifierSpec('screw', 'SCREW', {})]),
|
||||
|
||||
MeshTest("CubeSolidify", "testCubeSolidify", "expectedCubeSolidify",
|
||||
SpecMeshTest("CubeSolidify", "testCubeSolidify", "expectedCubeSolidify",
|
||||
[ModifierSpec('solidify', 'SOLIDIFY', {})]),
|
||||
MeshTest("ComplexSolidify", "testComplexSolidify", "expectedComplexSolidify",
|
||||
SpecMeshTest("ComplexSolidify", "testComplexSolidify", "expectedComplexSolidify",
|
||||
[ModifierSpec('solidify', 'SOLIDIFY', {'solidify_mode': 'NON_MANIFOLD', 'thickness': 0.05, 'offset': 0,
|
||||
'nonmanifold_thickness_mode': 'CONSTRAINTS'})]),
|
||||
MeshTest("T63063Solidify", "regressT63063Solidify", "expectedT63063Solidify",
|
||||
SpecMeshTest("T63063Solidify", "regressT63063Solidify", "expectedT63063Solidify",
|
||||
[ModifierSpec('solid', 'SOLIDIFY', {'thickness': 0.1, 'offset': 0.7})]),
|
||||
MeshTest("T61979Solidify", "regressT61979Solidify", "expectedT61979Solidify",
|
||||
SpecMeshTest("T61979Solidify", "regressT61979Solidify", "expectedT61979Solidify",
|
||||
[ModifierSpec('solid', 'SOLIDIFY',
|
||||
{'thickness': -0.25, 'use_even_offset': True, 'use_quality_normals': True})]),
|
||||
|
||||
MeshTest("MonkeySubsurf", "testMonkeySubsurf", "expectedMonkeySubsurf",
|
||||
SpecMeshTest("MonkeySubsurf", "testMonkeySubsurf", "expectedMonkeySubsurf",
|
||||
[ModifierSpec('subsurf', 'SUBSURF', {})]),
|
||||
MeshTest("CatmullClarkSubdivisionSurface", "testCatmullClarkSubdivisionSurface",
|
||||
SpecMeshTest("CatmullClarkSubdivisionSurface", "testCatmullClarkSubdivisionSurface",
|
||||
"expectedCatmullClarkSubdivisionSurface",
|
||||
[ModifierSpec("subdivision", 'SUBSURF', {"levels": 2})]),
|
||||
MeshTest("SimpleSubdivisionSurface", "testSimpleSubdivisionSurface", "expectedSimpleSubdivisionSurface",
|
||||
SpecMeshTest("SimpleSubdivisionSurface", "testSimpleSubdivisionSurface", "expectedSimpleSubdivisionSurface",
|
||||
[ModifierSpec("subdivision", 'SUBSURF', {"levels": 2, 'subdivision_type': 'SIMPLE'})]),
|
||||
MeshTest("Crease2dSubdivisionSurface", "testCrease2dSubdivisionSurface", "expectedCrease2dSubdivisionSurface",
|
||||
SpecMeshTest("Crease2dSubdivisionSurface", "testCrease2dSubdivisionSurface", "expectedCrease2dSubdivisionSurface",
|
||||
[ModifierSpec("subdivision", 'SUBSURF', {"levels": 2})]),
|
||||
MeshTest("Crease3dSubdivisionSurface", "testCrease3dSubdivisionSurface", "expectedCrease3dSubdivisionSurface",
|
||||
SpecMeshTest("Crease3dSubdivisionSurface", "testCrease3dSubdivisionSurface", "expectedCrease3dSubdivisionSurface",
|
||||
[ModifierSpec("subdivision", 'SUBSURF', {"levels": 2})]),
|
||||
|
||||
# 34
|
||||
|
||||
MeshTest("SphereTriangulate", "testSphereTriangulate", "expectedSphereTriangulate",
|
||||
SpecMeshTest("SphereTriangulate", "testSphereTriangulate", "expectedSphereTriangulate",
|
||||
[ModifierSpec('triangulate', 'TRIANGULATE', {})]),
|
||||
MeshTest("MonkeyWireframe", "testMonkeyWireframe", "expectedMonkeyWireframe",
|
||||
SpecMeshTest("MonkeyWireframe", "testMonkeyWireframe", "expectedMonkeyWireframe",
|
||||
[ModifierSpec('wireframe', 'WIREFRAME', {})]),
|
||||
|
||||
# Duplicate the object, test object and expected object have same world coordinates.
|
||||
MeshTest("Skin", "testObjPlaneSkin", "expObjPlaneSkin",
|
||||
SpecMeshTest("Skin", "testObjPlaneSkin", "expObjPlaneSkin",
|
||||
[ModifierSpec('skin', 'SKIN', {})]),
|
||||
|
||||
MeshTest("MergedWeld", "testMergedWeld", "expectedMergedWeld",
|
||||
SpecMeshTest("MergedWeld", "testMergedWeld", "expectedMergedWeld",
|
||||
[ModifierSpec("weld", 'WELD', {"merge_threshold": 0.021})]),
|
||||
MeshTest("MergedAllWeld", "testMergedAllWeld", "expectedMergedAllWeld",
|
||||
SpecMeshTest("MergedAllWeld", "testMergedAllWeld", "expectedMergedAllWeld",
|
||||
[ModifierSpec("weld", 'WELD', {"merge_threshold": 1.8})]),
|
||||
MeshTest("MergedNoneWeld", "testMergedNoneWeld", "expectedMergedNoneWeld",
|
||||
SpecMeshTest("MergedNoneWeld", "testMergedNoneWeld", "expectedMergedNoneWeld",
|
||||
[ModifierSpec("weld", 'WELD', {"merge_threshold": 0.019})]),
|
||||
|
||||
|
||||
@@ -236,109 +236,109 @@ def main():
|
||||
# One 'Deform' modifier on primitive meshes
|
||||
#############################################
|
||||
# 39
|
||||
MeshTest("MonkeyArmature", "testMonkeyArmature", "expectedMonkeyArmature",
|
||||
SpecMeshTest("MonkeyArmature", "testMonkeyArmature", "expectedMonkeyArmature",
|
||||
[ModifierSpec('armature', 'ARMATURE',
|
||||
{'object': bpy.data.objects['testArmature'], 'use_vertex_groups': True})]),
|
||||
MeshTest("TorusCast", "testTorusCast", "expectedTorusCast",
|
||||
SpecMeshTest("TorusCast", "testTorusCast", "expectedTorusCast",
|
||||
[ModifierSpec('cast', 'CAST', {'factor': 2.64})]),
|
||||
MeshTest("CubeCurve", "testCubeCurve", "expectedCubeCurve",
|
||||
SpecMeshTest("CubeCurve", "testCubeCurve", "expectedCubeCurve",
|
||||
[ModifierSpec('curve', 'CURVE', {'object': bpy.data.objects['testBezierCurve']})]),
|
||||
MeshTest("MonkeyDisplace", "testMonkeyDisplace", "expectedMonkeyDisplace",
|
||||
SpecMeshTest("MonkeyDisplace", "testMonkeyDisplace", "expectedMonkeyDisplace",
|
||||
[ModifierSpec('displace', "DISPLACE", {})]),
|
||||
|
||||
# Hook modifier requires moving the hook object to get a mesh change
|
||||
# so can't test it with the current framework
|
||||
# MeshTest("MonkeyHook", "testMonkeyHook", "expectedMonkeyHook",
|
||||
# SpecMeshTest("MonkeyHook", "testMonkeyHook", "expectedMonkeyHook",
|
||||
# [ModifierSpec('hook', 'HOOK', {'object': bpy.data.objects["EmptyHook"], 'vertex_group':
|
||||
# "HookVertexGroup"})]),
|
||||
|
||||
# 43
|
||||
# ModifierSpec('laplacian_deform', 'LAPLACIANDEFORM', {}) Laplacian requires a more complex mesh
|
||||
MeshTest("CubeLattice", "testCubeLattice", "expectedCubeLattice",
|
||||
SpecMeshTest("CubeLattice", "testCubeLattice", "expectedCubeLattice",
|
||||
[ModifierSpec('lattice', 'LATTICE', {'object': bpy.data.objects["testLattice"]})]),
|
||||
|
||||
MeshTest("PlaneShrinkWrap", "testPlaneShrinkWrap", "expectedPlaneShrinkWrap",
|
||||
SpecMeshTest("PlaneShrinkWrap", "testPlaneShrinkWrap", "expectedPlaneShrinkWrap",
|
||||
[ModifierSpec('shrinkwrap', 'SHRINKWRAP',
|
||||
{'target': bpy.data.objects["testCubeWrap"], 'offset': 0.5})]),
|
||||
|
||||
MeshTest("CylinderSimpleDeform", "testCylinderSimpleDeform", "expectedCylinderSimpleDeform",
|
||||
SpecMeshTest("CylinderSimpleDeform", "testCylinderSimpleDeform", "expectedCylinderSimpleDeform",
|
||||
[ModifierSpec('simple_deform', 'SIMPLE_DEFORM', {'angle': math.radians(180), 'deform_axis': 'Z'})]),
|
||||
|
||||
MeshTest("PlaneSmooth", "testPlaneSmooth", "expectedPlaneSmooth",
|
||||
SpecMeshTest("PlaneSmooth", "testPlaneSmooth", "expectedPlaneSmooth",
|
||||
[ModifierSpec('smooth', 'SMOOTH', {'iterations': 11})]),
|
||||
|
||||
# Smooth corrective requires a complex mesh.
|
||||
|
||||
MeshTest("BalloonLaplacianSmooth", "testBalloonLaplacianSmooth", "expectedBalloonLaplacianSmooth",
|
||||
SpecMeshTest("BalloonLaplacianSmooth", "testBalloonLaplacianSmooth", "expectedBalloonLaplacianSmooth",
|
||||
[ModifierSpec('laplaciansmooth', 'LAPLACIANSMOOTH', {'lambda_factor': 12, 'lambda_border': 12})]),
|
||||
|
||||
# Gets updated often
|
||||
MeshTest("WavePlane", "testObjPlaneWave", "expObjPlaneWave",
|
||||
SpecMeshTest("WavePlane", "testObjPlaneWave", "expObjPlaneWave",
|
||||
[ModifierSpec('wave', 'WAVE', {})]),
|
||||
|
||||
#############################################
|
||||
# CURVES Generate Modifiers
|
||||
#############################################
|
||||
# Caution: Make sure test object has no modifier in "added" state, the test may fail.
|
||||
MeshTest("BezCurveArray", "testObjBezierCurveArray", "expObjBezierCurveArray",
|
||||
SpecMeshTest("BezCurveArray", "testObjBezierCurveArray", "expObjBezierCurveArray",
|
||||
[ModifierSpec('array', 'ARRAY', {})]),
|
||||
|
||||
MeshTest("CurveBevel", "testObjBezierCurveBevel", "expObjBezierCurveBevel",
|
||||
SpecMeshTest("CurveBevel", "testObjBezierCurveBevel", "expObjBezierCurveBevel",
|
||||
[ModifierSpec('bevel', 'BEVEL', {'limit_method': 'NONE'})]),
|
||||
|
||||
MeshTest("CurveBuild", "testObjBezierCurveBuild", "expObjBezierCurveBuild",
|
||||
SpecMeshTest("CurveBuild", "testObjBezierCurveBuild", "expObjBezierCurveBuild",
|
||||
[ModifierSpec('build', 'BUILD', {'frame_start': 1, 'frame_duration': 1}, 2)]),
|
||||
|
||||
MeshTest("CurveDecimate", "testObjBezierCurveDecimate", "expObjBezierCurveDecimate",
|
||||
SpecMeshTest("CurveDecimate", "testObjBezierCurveDecimate", "expObjBezierCurveDecimate",
|
||||
[ModifierSpec('decimate', 'DECIMATE', {'ratio': 0.5})]),
|
||||
|
||||
MeshTest("CurveEdgeSplit", "testObjBezierCurveEdgeSplit", "expObjBezierCurveEdgeSplit",
|
||||
SpecMeshTest("CurveEdgeSplit", "testObjBezierCurveEdgeSplit", "expObjBezierCurveEdgeSplit",
|
||||
[ModifierSpec('edgeSplit', 'EDGE_SPLIT', {})]),
|
||||
|
||||
MeshTest("CurveMirror", "testObjBezierCurveMirror", "expObjBezierCurveMirror",
|
||||
SpecMeshTest("CurveMirror", "testObjBezierCurveMirror", "expObjBezierCurveMirror",
|
||||
[ModifierSpec('mirror', 'MIRROR', {'use_axis': (True, True, False)})]),
|
||||
|
||||
MeshTest("CurveScrew", "testObjBezierCurveScrew", "expObjBezierCurveScrew",
|
||||
SpecMeshTest("CurveScrew", "testObjBezierCurveScrew", "expObjBezierCurveScrew",
|
||||
[ModifierSpec('screw', 'SCREW', {})]),
|
||||
|
||||
MeshTest("CurveSolidify", "testObjBezierCurveSolidify", "expObjBezierCurveSolidify",
|
||||
SpecMeshTest("CurveSolidify", "testObjBezierCurveSolidify", "expObjBezierCurveSolidify",
|
||||
[ModifierSpec('solidify', 'SOLIDIFY', {'thickness': 1})]),
|
||||
|
||||
MeshTest("CurveSubSurf", "testObjBezierCurveSubSurf", "expObjBezierCurveSubSurf",
|
||||
SpecMeshTest("CurveSubSurf", "testObjBezierCurveSubSurf", "expObjBezierCurveSubSurf",
|
||||
[ModifierSpec('subSurf', 'SUBSURF', {})]),
|
||||
|
||||
MeshTest("CurveTriangulate", "testObjBezierCurveTriangulate", "expObjBezierCurveTriangulate",
|
||||
SpecMeshTest("CurveTriangulate", "testObjBezierCurveTriangulate", "expObjBezierCurveTriangulate",
|
||||
[ModifierSpec('triangulate', 'TRIANGULATE', {})]),
|
||||
|
||||
# Test 60
|
||||
# Caution Weld: if the distance is increased beyond a limit, the object disappears
|
||||
MeshTest("CurveWeld", "testObjBezierCurveWeld", "expObjBezierCurveWeld",
|
||||
SpecMeshTest("CurveWeld", "testObjBezierCurveWeld", "expObjBezierCurveWeld",
|
||||
[ModifierSpec('weld', 'WELD', {})]),
|
||||
|
||||
MeshTest("CurveWeld2", "testObjBezierCurveWeld2", "expObjBezierCurveWeld2",
|
||||
SpecMeshTest("CurveWeld2", "testObjBezierCurveWeld2", "expObjBezierCurveWeld2",
|
||||
[ModifierSpec('weld', 'WELD', {})]),
|
||||
|
||||
#############################################
|
||||
# Curves Deform Modifiers
|
||||
#############################################
|
||||
# Test 62
|
||||
MeshTest("CurveCast", "testObjBezierCurveCast", "expObjBezierCurveCast",
|
||||
SpecMeshTest("CurveCast", "testObjBezierCurveCast", "expObjBezierCurveCast",
|
||||
[ModifierSpec('Cast', 'CAST', {'cast_type': 'CYLINDER', 'factor': 10})]),
|
||||
|
||||
MeshTest("CurveShrinkWrap", "testObjBezierCurveShrinkWrap", "expObjBezierCurveShrinkWrap",
|
||||
SpecMeshTest("CurveShrinkWrap", "testObjBezierCurveShrinkWrap", "expObjBezierCurveShrinkWrap",
|
||||
[ModifierSpec('ShrinkWrap', 'SHRINKWRAP',
|
||||
{'target': bpy.data.objects['testShrinkWrapHelperSuzanne']})]),
|
||||
|
||||
MeshTest("CurveSimpleDeform", "testObjBezierCurveSimpleDeform", "expObjBezierCurveSimpleDeform",
|
||||
SpecMeshTest("CurveSimpleDeform", "testObjBezierCurveSimpleDeform", "expObjBezierCurveSimpleDeform",
|
||||
[ModifierSpec('simple_deform', 'SIMPLE_DEFORM', {'angle': math.radians(90)})]),
|
||||
|
||||
MeshTest("CurveSmooth", "testObjBezierCurveSmooth", "expObjBezierCurveSmooth",
|
||||
SpecMeshTest("CurveSmooth", "testObjBezierCurveSmooth", "expObjBezierCurveSmooth",
|
||||
[ModifierSpec('smooth', 'SMOOTH', {'factor': 10})]),
|
||||
|
||||
MeshTest("CurveWave", "testObjBezierCurveWave", "expObjBezierCurveWave",
|
||||
SpecMeshTest("CurveWave", "testObjBezierCurveWave", "expObjBezierCurveWave",
|
||||
[ModifierSpec('curve_wave', 'WAVE', {'time_offset': -1.5})]),
|
||||
|
||||
MeshTest("CurveCurve", "testObjBezierCurveCurve", "expObjBezierCurveCurve",
|
||||
SpecMeshTest("CurveCurve", "testObjBezierCurveCurve", "expObjBezierCurveCurve",
|
||||
[ModifierSpec('curve_Curve', 'CURVE', {'object': bpy.data.objects['NurbsCurve']})]),
|
||||
|
||||
]
|
||||
|
||||
@@ -33,13 +33,14 @@
|
||||
# delete the duplicate object
|
||||
#
|
||||
# The words in angle brackets are parameters of the test, and are specified in
|
||||
# the main class MeshTest.
|
||||
# the abstract class MeshTest.
|
||||
#
|
||||
# If the environment variable BLENDER_TEST_UPDATE is set to 1, the <expected_object>
|
||||
# is updated with the new test result.
|
||||
# Tests are verbose when the environment variable BLENDER_VERBOSE is set.
|
||||
|
||||
|
||||
from abc import ABC, abstractmethod
|
||||
import bpy
|
||||
import functools
|
||||
import inspect
|
||||
@@ -161,121 +162,321 @@ class DeformModifierSpec:
|
||||
return "Modifier: " + str(self.modifier_list) + " with object operator " + str(self.object_operator_spec)
|
||||
|
||||
|
||||
class MeshTest:
|
||||
class MeshTest(ABC):
|
||||
"""
|
||||
A mesh testing class targeted at testing modifiers and operators on a single object.
|
||||
It holds a stack of mesh operations, i.e. modifiers or operators. The test is executed using
|
||||
the public method run_test().
|
||||
A mesh testing Abstract class that hold common functionalities for testting operations.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
test_name: str,
|
||||
test_object_name: str,
|
||||
expected_object_name: str,
|
||||
operations_stack=None,
|
||||
apply_modifiers=False,
|
||||
do_compare=False,
|
||||
threshold=None
|
||||
):
|
||||
def __init__(self, test_object_name, exp_object_name, test_name=None, threshold=None, do_compare=True):
|
||||
"""
|
||||
Constructs a MeshTest object. Raises a KeyError if objects with names expected_object_name
|
||||
or test_object_name don't exist.
|
||||
:param test_name: str - unique test name identifier.
|
||||
:param test_object_name: str - Name of object of mesh type to run the operations on.
|
||||
:param expected_object_name: str - Name of object of mesh type that has the expected
|
||||
:param exp_object_name: str - Name of object of mesh type that has the expected
|
||||
geometry after running the operations.
|
||||
:param operations_stack: list - stack holding operations to perform on the test_object.
|
||||
:param apply_modifiers: bool - True if we want to apply the modifiers right after adding them to the object.
|
||||
- True if we want to apply the modifier to a list of modifiers, after some operation.
|
||||
This affects operations of type ModifierSpec and DeformModifierSpec.
|
||||
:param test_name: str - Name of the test.
|
||||
:param threshold: exponent: To allow variations and accept difference to a certain degree.
|
||||
:param do_compare: bool - True if we want to compare the test and expected objects, False otherwise.
|
||||
:param threshold : exponent: To allow variations and accept difference to a certain degree.
|
||||
|
||||
"""
|
||||
if operations_stack is None:
|
||||
operations_stack = []
|
||||
for operation in operations_stack:
|
||||
if not (isinstance(operation, ModifierSpec) or isinstance(operation, OperatorSpecEditMode)
|
||||
or isinstance(operation, OperatorSpecObjectMode) or isinstance(operation, DeformModifierSpec)
|
||||
or isinstance(operation, ParticleSystemSpec)):
|
||||
raise ValueError("Expected operation of type {} or {} or {} or {}. Got {}".
|
||||
format(type(ModifierSpec), type(OperatorSpecEditMode),
|
||||
type(DeformModifierSpec), type(ParticleSystemSpec),
|
||||
type(operation)))
|
||||
self.operations_stack = operations_stack
|
||||
self.apply_modifier = apply_modifiers
|
||||
self.do_compare = do_compare
|
||||
self.threshold = threshold
|
||||
self.test_name = test_name
|
||||
|
||||
self.verbose = os.environ.get("BLENDER_VERBOSE") is not None
|
||||
self.update = os.getenv('BLENDER_TEST_UPDATE') is not None
|
||||
|
||||
# Initialize test objects.
|
||||
objects = bpy.data.objects
|
||||
self.test_object = objects[test_object_name]
|
||||
self.expected_object = objects[expected_object_name]
|
||||
if self.verbose:
|
||||
print("Found test object {}".format(test_object_name))
|
||||
print("Found test object {}".format(expected_object_name))
|
||||
|
||||
# Private flag to indicate whether the blend file was updated after the test.
|
||||
self._test_updated = False
|
||||
|
||||
def set_test_object(self, test_object_name):
|
||||
"""
|
||||
Set test object for the test. Raises a KeyError if object with given name does not exist.
|
||||
:param test_object_name: name of test object to run operations on.
|
||||
"""
|
||||
objects = bpy.data.objects
|
||||
self.test_object = objects[test_object_name]
|
||||
|
||||
def set_expected_object(self, expected_object_name):
|
||||
"""
|
||||
Set expected object for the test. Raises a KeyError if object with given name does not exist
|
||||
:param expected_object_name: Name of expected object.
|
||||
"""
|
||||
objects = bpy.data.objects
|
||||
self.expected_object = objects[expected_object_name]
|
||||
|
||||
def _on_failed_test(self, compare_result, validation_success, evaluated_test_object):
|
||||
if self.update and validation_success:
|
||||
if self.verbose:
|
||||
print("Test failed expectantly. Updating expected mesh...")
|
||||
|
||||
# Replace expected object with object we ran operations on, i.e. evaluated_test_object.
|
||||
evaluated_test_object.location = self.expected_object.location
|
||||
expected_object_name = self.expected_object.name
|
||||
evaluated_selection = {v.index for v in evaluated_test_object.data.vertices if v.select}
|
||||
|
||||
bpy.data.objects.remove(self.expected_object, do_unlink=True)
|
||||
evaluated_test_object.name = expected_object_name
|
||||
self._do_selection(evaluated_test_object.data, "VERT", evaluated_selection)
|
||||
|
||||
# Save file.
|
||||
bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath)
|
||||
|
||||
self._test_updated = True
|
||||
|
||||
# Set new expected object.
|
||||
self.expected_object = evaluated_test_object
|
||||
return True
|
||||
|
||||
self.test_object_name = test_object_name
|
||||
self.exp_object_name = exp_object_name
|
||||
if test_name:
|
||||
self.test_name = test_name
|
||||
else:
|
||||
print("Test comparison result: {}".format(compare_result))
|
||||
print("Test validation result: {}".format(validation_success))
|
||||
print("Resulting object mesh '{}' did not match expected object '{}' from file {}".
|
||||
format(evaluated_test_object.name, self.expected_object.name, bpy.data.filepath))
|
||||
filepath = bpy.data.filepath
|
||||
self.test_name = bpy.path.display_name_from_filepath(filepath)
|
||||
self.threshold = threshold
|
||||
self.do_compare = do_compare
|
||||
self.update = os.getenv("BLENDER_TEST_UPDATE") is not None
|
||||
self.verbose = os.getenv("BLENDER_VERBOSE") is not None
|
||||
self.test_updated_counter = 0
|
||||
objects = bpy.data.objects
|
||||
self.evaluated_object = None
|
||||
self.test_object = objects[self.test_object_name]
|
||||
|
||||
if self.update:
|
||||
if exp_object_name in objects:
|
||||
self.expected_object = objects[self.exp_object_name]
|
||||
else:
|
||||
self.create_expected_object()
|
||||
else:
|
||||
self.expected_object = objects[self.exp_object_name]
|
||||
|
||||
def create_expected_object(self):
|
||||
"""
|
||||
Creates an expected object 10 units away
|
||||
in Y direction from test object.
|
||||
"""
|
||||
if self.verbose:
|
||||
print("Creating expected object...")
|
||||
self.create_evaluated_object()
|
||||
self.expected_object = self.evaluated_object
|
||||
self.expected_object.name = self.exp_object_name
|
||||
x, y, z = self.test_object.location
|
||||
self.expected_object.location = (x, y+10, z)
|
||||
bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath)
|
||||
|
||||
def create_evaluated_object(self):
|
||||
"""
|
||||
Creates an evaluated object.
|
||||
"""
|
||||
bpy.context.view_layer.objects.active = self.test_object
|
||||
|
||||
# Duplicate test object.
|
||||
bpy.ops.object.mode_set(mode="OBJECT")
|
||||
bpy.ops.object.select_all(action="DESELECT")
|
||||
bpy.context.view_layer.objects.active = self.test_object
|
||||
|
||||
self.test_object.select_set(True)
|
||||
bpy.ops.object.duplicate()
|
||||
self.evaluated_object = bpy.context.active_object
|
||||
self.evaluated_object.name = "evaluated_object"
|
||||
|
||||
@staticmethod
|
||||
def _print_result(result):
|
||||
"""
|
||||
Prints the comparison, selection and validation result.
|
||||
"""
|
||||
print("Results:")
|
||||
for key in result:
|
||||
print("{} : {}".format(key, result[key][1]))
|
||||
print()
|
||||
|
||||
def run_test(self):
|
||||
"""
|
||||
Runs a single test, runs it again if test file is updated.
|
||||
"""
|
||||
|
||||
self.create_evaluated_object()
|
||||
self.apply_operations(self.evaluated_object.name)
|
||||
|
||||
if not self.do_compare:
|
||||
print("\nVisualization purpose only: Open Blender in GUI mode")
|
||||
print("Compare evaluated and expected object in Blender.\n")
|
||||
return False
|
||||
|
||||
def is_test_updated(self):
|
||||
result = self.compare_meshes(self.evaluated_object, self.expected_object, self.threshold)
|
||||
|
||||
# Initializing with True to get correct resultant of result_code booleans.
|
||||
success = True
|
||||
inside_loop_flag = False
|
||||
for key in result:
|
||||
inside_loop_flag = True
|
||||
success = success and result[key][0]
|
||||
|
||||
# Check "success" is actually evaluated and is not the default True value.
|
||||
if not inside_loop_flag:
|
||||
success = False
|
||||
|
||||
|
||||
if success:
|
||||
self.print_passed_test_result(result)
|
||||
# Clean up.
|
||||
if self.verbose:
|
||||
print("Cleaning up...")
|
||||
# Delete evaluated_test_object.
|
||||
bpy.ops.object.delete()
|
||||
return True
|
||||
|
||||
elif self.update:
|
||||
self.print_failed_test_result(result)
|
||||
self.update_failed_test()
|
||||
# Check for testing the blend file is updated and re-running.
|
||||
# Also safety check to avoid infinite recursion loop.
|
||||
if self.test_updated_counter == 1:
|
||||
print("Re-running test...")
|
||||
self.run_test()
|
||||
else:
|
||||
print("The test fails consistently. Exiting...")
|
||||
return False
|
||||
|
||||
else:
|
||||
self.print_failed_test_result(result)
|
||||
return False
|
||||
|
||||
def print_failed_test_result(self, result):
|
||||
"""
|
||||
Check whether running the test with BLENDER_TEST_UPDATE actually modified the .blend test file.
|
||||
:return: Bool - True if blend file has been updated. False otherwise.
|
||||
Print results for failed test.
|
||||
"""
|
||||
return self._test_updated
|
||||
print("\nFAILED {} test with the following: ".format(self.test_name))
|
||||
self._print_result(result)
|
||||
|
||||
def print_passed_test_result(self, result):
|
||||
"""
|
||||
Print results for passing test.
|
||||
"""
|
||||
print("\nPASSED {} test successfully.".format(self.test_name))
|
||||
self._print_result(result)
|
||||
|
||||
def do_selection(self, mesh: bpy.types.Mesh, select_mode: str, selection: set):
|
||||
"""
|
||||
Do selection on a mesh.
|
||||
:param mesh: bpy.types.Mesh - input mesh
|
||||
:param: select_mode: str - selection mode. Must be 'VERT', 'EDGE' or 'FACE'
|
||||
:param: selection: set - indices of selection.
|
||||
|
||||
Example: select_mode='VERT' and selection={1,2,3} selects veritces 1, 2 and 3 of input mesh
|
||||
"""
|
||||
# Deselect all objects.
|
||||
bpy.ops.object.mode_set(mode='EDIT')
|
||||
bpy.ops.mesh.select_all(action='DESELECT')
|
||||
bpy.ops.object.mode_set(mode='OBJECT')
|
||||
|
||||
bpy.context.tool_settings.mesh_select_mode = (select_mode == 'VERT',
|
||||
select_mode == 'EDGE',
|
||||
select_mode == 'FACE')
|
||||
|
||||
items = (mesh.vertices if select_mode == 'VERT'
|
||||
else mesh.edges if select_mode == 'EDGE'
|
||||
else mesh.polygons if select_mode == 'FACE'
|
||||
else None)
|
||||
if items is None:
|
||||
raise ValueError("Invalid selection mode")
|
||||
for index in selection:
|
||||
items[index].select = True
|
||||
|
||||
def update_failed_test(self):
|
||||
"""
|
||||
Updates expected object.
|
||||
"""
|
||||
self.evaluated_object.location = self.expected_object.location
|
||||
expected_object_name = self.expected_object.name
|
||||
evaluated_selection = {
|
||||
v.index for v in self.evaluated_object.data.vertices if v.select}
|
||||
|
||||
bpy.data.objects.remove(self.expected_object, do_unlink=True)
|
||||
self.evaluated_object.name = expected_object_name
|
||||
self.do_selection(self.evaluated_object.data,
|
||||
"VERT", evaluated_selection)
|
||||
|
||||
# Save file.
|
||||
bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath)
|
||||
self.test_updated_counter += 1
|
||||
self.expected_object = self.evaluated_object
|
||||
|
||||
@staticmethod
|
||||
def compare_meshes(evaluated_object, expected_object, threshold):
|
||||
"""
|
||||
Compares evaluated object mesh with expected object mesh.
|
||||
:param evaluated_object: first object for comparison.
|
||||
:param expected_object: second object for comparison.
|
||||
:param threshold: exponent: To allow variations and accept difference to a certain degree.
|
||||
:return: dict: Contains results of different comparisons.
|
||||
"""
|
||||
objects = bpy.data.objects
|
||||
evaluated_test_mesh = objects[evaluated_object.name].data
|
||||
expected_mesh = expected_object.data
|
||||
result_codes = {}
|
||||
|
||||
# Mesh Comparison.
|
||||
if threshold:
|
||||
result_mesh = expected_mesh.unit_test_compare(
|
||||
mesh=evaluated_test_mesh, threshold=threshold)
|
||||
else:
|
||||
result_mesh = expected_mesh.unit_test_compare(
|
||||
mesh=evaluated_test_mesh)
|
||||
|
||||
if result_mesh == "Same":
|
||||
result_codes['Mesh Comparison'] = (True, result_mesh)
|
||||
else:
|
||||
result_codes['Mesh Comparison'] = (False, result_mesh)
|
||||
|
||||
# Selection comparison.
|
||||
|
||||
selected_evaluated_verts = [
|
||||
v.index for v in evaluated_test_mesh.vertices if v.select]
|
||||
selected_expected_verts = [
|
||||
v.index for v in expected_mesh.vertices if v.select]
|
||||
|
||||
if selected_evaluated_verts == selected_expected_verts:
|
||||
result_selection = "Same"
|
||||
result_codes['Selection Comparison'] = (True, result_selection)
|
||||
else:
|
||||
result_selection = "Selection doesn't match."
|
||||
result_codes['Selection Comparison'] = (False, result_selection)
|
||||
|
||||
# Validation check.
|
||||
result_validation = evaluated_test_mesh.validate(verbose=True)
|
||||
if result_validation:
|
||||
result_validation = "Invalid Mesh"
|
||||
result_codes['Mesh Validation'] = (False, result_validation)
|
||||
else:
|
||||
result_validation = "Valid"
|
||||
result_codes['Mesh Validation'] = (True, result_validation)
|
||||
|
||||
return result_codes
|
||||
|
||||
@abstractmethod
|
||||
def apply_operations(self, object_name):
|
||||
"""
|
||||
Apply operations on this object.
|
||||
|
||||
object_name (str): Name of the test object on which operations will be applied.
|
||||
"""
|
||||
pass
|
||||
|
||||
|
||||
class SpecMeshTest(MeshTest):
|
||||
"""
|
||||
A mesh testing class inherited from MeshTest class targeted at testing modifiers and operators on a single object.
|
||||
It holds a stack of mesh operations, i.e. modifiers or operators. The test is executed using MeshTest's run_test.
|
||||
"""
|
||||
|
||||
def __init__(self, test_name,
|
||||
test_object_name,
|
||||
exp_object_name,
|
||||
operations_stack=None,
|
||||
apply_modifier=True,
|
||||
threshold=None):
|
||||
"""
|
||||
Constructor for SpecMeshTest.
|
||||
|
||||
:param test_name: str - Name of the test.
|
||||
:param test_object_name: str - Name of object of mesh type to run the operations on.
|
||||
:param exp_object_name: str - Name of object of mesh type that has the expected
|
||||
geometry after running the operations.
|
||||
:param operations_stack: list - stack holding operations to perform on the test_object.
|
||||
:param apply_modifier: bool - True if we want to apply the modifiers right after adding them to the object.
|
||||
- True if we want to apply the modifier to list of modifiers, after some operation.
|
||||
This affects operations of type ModifierSpec and DeformModifierSpec.
|
||||
"""
|
||||
|
||||
super().__init__(test_object_name, exp_object_name, test_name, threshold)
|
||||
self.test_name = test_name
|
||||
if operations_stack is None:
|
||||
self.operations_stack = []
|
||||
else:
|
||||
self.operations_stack = operations_stack
|
||||
self.apply_modifier = apply_modifier
|
||||
|
||||
def apply_operations(self, evaluated_test_object_name):
|
||||
# Add modifiers and operators.
|
||||
SpecMeshTest.apply_operations.__doc__ = MeshTest.apply_operations.__doc__
|
||||
evaluated_test_object = bpy.data.objects[evaluated_test_object_name]
|
||||
if self.verbose:
|
||||
print("Applying operations...")
|
||||
for operation in self.operations_stack:
|
||||
if isinstance(operation, ModifierSpec):
|
||||
self._add_modifier(evaluated_test_object, operation)
|
||||
if self.apply_modifier:
|
||||
self._apply_modifier(
|
||||
evaluated_test_object, operation.modifier_name)
|
||||
|
||||
elif isinstance(operation, OperatorSpecEditMode):
|
||||
self._apply_operator_edit_mode(
|
||||
evaluated_test_object, operation)
|
||||
|
||||
elif isinstance(operation, OperatorSpecObjectMode):
|
||||
self._apply_operator_object_mode(operation)
|
||||
|
||||
elif isinstance(operation, DeformModifierSpec):
|
||||
self._apply_deform_modifier(evaluated_test_object, operation)
|
||||
|
||||
elif isinstance(operation, ParticleSystemSpec):
|
||||
self._apply_particle_system(evaluated_test_object, operation)
|
||||
|
||||
else:
|
||||
raise ValueError("Expected operation of type {} or {} or {} or {}. Got {}".
|
||||
format(type(ModifierSpec), type(OperatorSpecEditMode),
|
||||
type(OperatorSpecObjectMode), type(ParticleSystemSpec), type(operation)))
|
||||
|
||||
def _set_parameters_impl(self, modifier, modifier_parameters, nested_settings_path, modifier_name):
|
||||
"""
|
||||
@@ -312,14 +513,15 @@ class MeshTest:
|
||||
|
||||
for key in modifier_parameters:
|
||||
nested_settings_path.append(key)
|
||||
self._set_parameters_impl(modifier, modifier_parameters[key], nested_settings_path, modifier_name)
|
||||
self._set_parameters_impl(
|
||||
modifier, modifier_parameters[key], nested_settings_path, modifier_name)
|
||||
|
||||
if nested_settings_path:
|
||||
nested_settings_path.pop()
|
||||
|
||||
def set_parameters(self, modifier, modifier_parameters):
|
||||
"""
|
||||
Wrapper for _set_parameters_util
|
||||
Wrapper for _set_parameters_impl.
|
||||
"""
|
||||
settings = []
|
||||
modifier_name = modifier.name
|
||||
@@ -430,40 +632,14 @@ class MeshTest:
|
||||
if self.apply_modifier:
|
||||
self._apply_modifier(test_object, particle_sys_spec.modifier_name)
|
||||
|
||||
def _do_selection(self, mesh: bpy.types.Mesh, select_mode: str, selection: set):
|
||||
"""
|
||||
Do selection on a mesh
|
||||
:param mesh: bpy.types.Mesh - input mesh
|
||||
:param: select_mode: str - selection mode. Must be 'VERT', 'EDGE' or 'FACE'
|
||||
:param: selection: set - indices of selection.
|
||||
|
||||
Example: select_mode='VERT' and selection={1,2,3} selects veritces 1, 2 and 3 of input mesh
|
||||
"""
|
||||
# deselect all
|
||||
bpy.ops.object.mode_set(mode='EDIT')
|
||||
bpy.ops.mesh.select_all(action='DESELECT')
|
||||
bpy.ops.object.mode_set(mode='OBJECT')
|
||||
|
||||
bpy.context.tool_settings.mesh_select_mode = (select_mode == 'VERT',
|
||||
select_mode == 'EDGE',
|
||||
select_mode == 'FACE')
|
||||
|
||||
items = (mesh.vertices if select_mode == 'VERT'
|
||||
else mesh.edges if select_mode == 'EDGE'
|
||||
else mesh.polygons if select_mode == 'FACE'
|
||||
else None)
|
||||
if items is None:
|
||||
raise ValueError("Invalid selection mode")
|
||||
for index in selection:
|
||||
items[index].select = True
|
||||
|
||||
def _apply_operator_edit_mode(self, test_object, operator: OperatorSpecEditMode):
|
||||
"""
|
||||
Apply operator on test object.
|
||||
:param test_object: bpy.types.Object - Blender object to apply operator on.
|
||||
:param operator: OperatorSpecEditMode - OperatorSpecEditMode object with parameters.
|
||||
"""
|
||||
self._do_selection(test_object.data, operator.select_mode, operator.selection)
|
||||
self.do_selection(
|
||||
test_object.data, operator.select_mode, operator.selection)
|
||||
|
||||
# Apply operator in edit mode.
|
||||
bpy.ops.object.mode_set(mode='EDIT')
|
||||
@@ -528,96 +704,27 @@ class MeshTest:
|
||||
for mod_name in modifier_names:
|
||||
self._apply_modifier(test_object, mod_name)
|
||||
|
||||
def run_test(self):
|
||||
"""
|
||||
Apply operations in self.operations_stack on self.test_object and compare the
|
||||
resulting mesh with self.expected_object.data
|
||||
:return: bool - True if the test passed, False otherwise.
|
||||
"""
|
||||
self._test_updated = False
|
||||
bpy.context.view_layer.objects.active = self.test_object
|
||||
|
||||
# Duplicate test object.
|
||||
bpy.ops.object.mode_set(mode="OBJECT")
|
||||
bpy.ops.object.select_all(action="DESELECT")
|
||||
bpy.context.view_layer.objects.active = self.test_object
|
||||
class BlendFileTest(MeshTest):
|
||||
"""
|
||||
A mesh testing class inherited from MeshTest aimed at testing operations like modifiers loaded directly from
|
||||
blend file i.e. without adding them from scratch or without adding specifications.
|
||||
"""
|
||||
|
||||
self.test_object.select_set(True)
|
||||
bpy.ops.object.duplicate()
|
||||
evaluated_test_object = bpy.context.active_object
|
||||
evaluated_test_object.name = "evaluated_object"
|
||||
if self.verbose:
|
||||
print()
|
||||
print(evaluated_test_object.name, "is set to active")
|
||||
def apply_operations(self, evaluated_test_object_name):
|
||||
|
||||
# Add modifiers and operators.
|
||||
for operation in self.operations_stack:
|
||||
if isinstance(operation, ModifierSpec):
|
||||
self._add_modifier(evaluated_test_object, operation)
|
||||
if self.apply_modifier:
|
||||
self._apply_modifier(evaluated_test_object, operation.modifier_name)
|
||||
|
||||
elif isinstance(operation, OperatorSpecEditMode):
|
||||
self._apply_operator_edit_mode(evaluated_test_object, operation)
|
||||
|
||||
elif isinstance(operation, OperatorSpecObjectMode):
|
||||
self._apply_operator_object_mode(operation)
|
||||
|
||||
elif isinstance(operation, DeformModifierSpec):
|
||||
self._apply_deform_modifier(evaluated_test_object, operation)
|
||||
|
||||
elif isinstance(operation, ParticleSystemSpec):
|
||||
self._apply_particle_system(evaluated_test_object, operation)
|
||||
|
||||
else:
|
||||
raise ValueError("Expected operation of type {} or {} or {} or {}. Got {}".
|
||||
format(type(ModifierSpec), type(OperatorSpecEditMode),
|
||||
type(OperatorSpecObjectMode), type(ParticleSystemSpec), type(operation)))
|
||||
|
||||
# Compare resulting mesh with expected one.
|
||||
# Compare only when self.do_compare is set to True, it is set to False for run-test and returns.
|
||||
if not self.do_compare:
|
||||
print("Meshes/objects are not compared, compare evaluated and expected object in Blender for "
|
||||
"visualization only.")
|
||||
return False
|
||||
|
||||
if self.verbose:
|
||||
print("Comparing expected mesh with resulting mesh...")
|
||||
evaluated_test_mesh = evaluated_test_object.data
|
||||
expected_mesh = self.expected_object.data
|
||||
if self.threshold:
|
||||
compare_result = evaluated_test_mesh.unit_test_compare(mesh=expected_mesh, threshold=self.threshold)
|
||||
else:
|
||||
compare_result = evaluated_test_mesh.unit_test_compare(mesh=expected_mesh)
|
||||
compare_success = (compare_result == 'Same')
|
||||
|
||||
selected_evaluatated_verts = [v.index for v in evaluated_test_mesh.vertices if v.select]
|
||||
selected_expected_verts = [v.index for v in expected_mesh.vertices if v.select]
|
||||
if selected_evaluatated_verts != selected_expected_verts:
|
||||
compare_result = "Selection doesn't match"
|
||||
compare_success = False
|
||||
|
||||
# Also check if invalid geometry (which is never expected) had to be corrected...
|
||||
validation_success = not evaluated_test_mesh.validate(verbose=True)
|
||||
|
||||
if compare_success and validation_success:
|
||||
if self.verbose:
|
||||
print("Success!")
|
||||
|
||||
# Clean up.
|
||||
if self.verbose:
|
||||
print("Cleaning up...")
|
||||
# Delete evaluated_test_object.
|
||||
bpy.ops.object.delete()
|
||||
return True
|
||||
|
||||
else:
|
||||
return self._on_failed_test(compare_result, validation_success, evaluated_test_object)
|
||||
BlendFileTest.apply_operations.__doc__ = MeshTest.apply_operations.__doc__
|
||||
evaluated_test_object = bpy.data.objects[evaluated_test_object_name]
|
||||
modifiers_list = evaluated_test_object.modifiers
|
||||
if not modifiers_list:
|
||||
raise Exception("No modifiers are added to test object.")
|
||||
for modifier in modifiers_list:
|
||||
bpy.ops.object.modifier_apply(modifier=modifier.name)
|
||||
|
||||
|
||||
class RunTest:
|
||||
"""
|
||||
Helper class that stores and executes modifier tests.
|
||||
Helper class that stores and executes SpecMeshTest tests.
|
||||
|
||||
Example usage:
|
||||
|
||||
@@ -629,9 +736,9 @@ class RunTest:
|
||||
>>> OperatorSpecEditMode("delete_edgeloop", {}, "EDGE", MONKEY_LOOP_EDGE),
|
||||
>>> ]
|
||||
>>> tests = [
|
||||
>>> MeshTest("Test1", "testCube", "expectedCube", modifier_list),
|
||||
>>> MeshTest("Test2", "testCube_2", "expectedCube_2", modifier_list),
|
||||
>>> MeshTest("MonkeyDeleteEdge", "testMonkey","expectedMonkey", operator_list)
|
||||
>>> SpecMeshTest("Test1", "testCube", "expectedCube", modifier_list),
|
||||
>>> SpecMeshTest("Test2", "testCube_2", "expectedCube_2", modifier_list),
|
||||
>>> SpecMeshTest("MonkeyDeleteEdge", "testMonkey","expectedMonkey", operator_list)
|
||||
>>> ]
|
||||
>>> modifiers_test = RunTest(tests)
|
||||
>>> modifiers_test.run_all_tests()
|
||||
@@ -639,7 +746,7 @@ class RunTest:
|
||||
|
||||
def __init__(self, tests, apply_modifiers=False, do_compare=False):
|
||||
"""
|
||||
Construct a modifier test.
|
||||
Construct a test suite.
|
||||
:param tests: list - list of modifier or operator test cases. Each element in the list must contain the
|
||||
following
|
||||
in the correct order:
|
||||
@@ -674,7 +781,7 @@ class RunTest:
|
||||
|
||||
def run_all_tests(self):
|
||||
"""
|
||||
Run all tests in self.tests list. Raises an exception if one the tests fails.
|
||||
Run all tests in self.tests list. Displays all failed tests at bottom.
|
||||
"""
|
||||
for test_number, each_test in enumerate(self.tests):
|
||||
test_name = each_test.test_name
|
||||
@@ -717,15 +824,8 @@ class RunTest:
|
||||
raise Exception('No test called {} found!'.format(test_name))
|
||||
|
||||
test = case
|
||||
if self.apply_modifiers:
|
||||
test.apply_modifier = True
|
||||
|
||||
if self.do_compare:
|
||||
test.do_compare = True
|
||||
test.apply_modifier = self.apply_modifiers
|
||||
test.do_compare = self.do_compare
|
||||
|
||||
success = test.run_test()
|
||||
if test.is_test_updated():
|
||||
# Run the test again if the blend file has been updated.
|
||||
success = test.run_test()
|
||||
|
||||
return success
|
||||
|
||||
@@ -26,7 +26,7 @@ from random import shuffle, seed
|
||||
seed(0)
|
||||
|
||||
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
|
||||
from modules.mesh_test import MeshTest, OperatorSpecEditMode, RunTest
|
||||
from modules.mesh_test import SpecMeshTest, OperatorSpecEditMode, RunTest
|
||||
|
||||
# Central vertical loop of Suzanne
|
||||
MONKEY_LOOP_VERT = {68, 69, 71, 73, 74, 75, 76, 77, 90, 129, 136, 175, 188, 189, 198, 207,
|
||||
@@ -38,242 +38,242 @@ MONKEY_LOOP_EDGE = {131, 278, 299, 305, 307, 334, 337, 359, 384, 396, 399, 412,
|
||||
def main():
|
||||
tests = [
|
||||
# bisect
|
||||
MeshTest("CubeBisect", "testCubeBisect", "expectedCubeBisect",
|
||||
SpecMeshTest("CubeBisect", "testCubeBisect", "expectedCubeBisect",
|
||||
[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
|
||||
MeshTest("CubeBlendFromShape", "testCubeBlendFromShape", "expectedCubeBlendFromShape",
|
||||
SpecMeshTest("CubeBlendFromShape", "testCubeBlendFromShape", "expectedCubeBlendFromShape",
|
||||
[OperatorSpecEditMode("blend_from_shape", {"shape": "Key 1"}, 'FACE', {0, 1, 2, 3, 4, 5})]),
|
||||
|
||||
# bridge edge loops
|
||||
MeshTest("CubeBridgeEdgeLoop", "testCubeBrigeEdgeLoop", "expectedCubeBridgeEdgeLoop",
|
||||
SpecMeshTest("CubeBridgeEdgeLoop", "testCubeBrigeEdgeLoop", "expectedCubeBridgeEdgeLoop",
|
||||
[OperatorSpecEditMode("bridge_edge_loops", {}, "FACE", {0, 1})]),
|
||||
|
||||
# decimate
|
||||
MeshTest("MonkeyDecimate", "testMonkeyDecimate", "expectedMonkeyDecimate",
|
||||
SpecMeshTest("MonkeyDecimate", "testMonkeyDecimate", "expectedMonkeyDecimate",
|
||||
[OperatorSpecEditMode("decimate",
|
||||
{"ratio": 0.1}, "FACE", {i for i in range(500)})]),
|
||||
|
||||
# delete
|
||||
MeshTest("CubeDeleteVertices", "testCubeDeleteVertices", "expectedCubeDeleteVertices",
|
||||
SpecMeshTest("CubeDeleteVertices", "testCubeDeleteVertices", "expectedCubeDeleteVertices",
|
||||
[OperatorSpecEditMode("delete", {}, "VERT", {3})]),
|
||||
MeshTest("CubeDeleteFaces", "testCubeDeleteFaces", "expectedCubeDeleteFaces",
|
||||
SpecMeshTest("CubeDeleteFaces", "testCubeDeleteFaces", "expectedCubeDeleteFaces",
|
||||
[OperatorSpecEditMode("delete", {}, "FACE", {0})]),
|
||||
MeshTest("CubeDeleteEdges", "testCubeDeleteEdges", "expectedCubeDeleteEdges",
|
||||
SpecMeshTest("CubeDeleteEdges", "testCubeDeleteEdges", "expectedCubeDeleteEdges",
|
||||
[OperatorSpecEditMode("delete", {}, "EDGE", {0, 1, 2, 3})]),
|
||||
|
||||
# delete edge loop
|
||||
MeshTest("MonkeyDeleteEdgeLoopVertices", "testMokneyDeleteEdgeLoopVertices",
|
||||
SpecMeshTest("MonkeyDeleteEdgeLoopVertices", "testMokneyDeleteEdgeLoopVertices",
|
||||
"expectedMonkeyDeleteEdgeLoopVertices",
|
||||
[OperatorSpecEditMode("delete_edgeloop", {}, "VERT", MONKEY_LOOP_VERT)]),
|
||||
|
||||
MeshTest("MonkeyDeleteEdgeLoopEdges", "testMokneyDeleteEdgeLoopEdges",
|
||||
SpecMeshTest("MonkeyDeleteEdgeLoopEdges", "testMokneyDeleteEdgeLoopEdges",
|
||||
"expectedMonkeyDeleteEdgeLoopEdges",
|
||||
[OperatorSpecEditMode("delete_edgeloop", {}, "EDGE", MONKEY_LOOP_EDGE)]),
|
||||
|
||||
# delete loose
|
||||
MeshTest("CubeDeleteLooseVertices", "testCubeDeleteLooseVertices",
|
||||
SpecMeshTest("CubeDeleteLooseVertices", "testCubeDeleteLooseVertices",
|
||||
"expectedCubeDeleteLooseVertices",
|
||||
[OperatorSpecEditMode("delete_loose", {"use_verts": True, "use_edges": False, "use_faces": False},
|
||||
"VERT",
|
||||
{i for i in range(12)})]),
|
||||
MeshTest("CubeDeleteLooseEdges", "testCubeDeleteLooseEdges",
|
||||
SpecMeshTest("CubeDeleteLooseEdges", "testCubeDeleteLooseEdges",
|
||||
"expectedCubeDeleteLooseEdges",
|
||||
[OperatorSpecEditMode("delete_loose", {"use_verts": False, "use_edges": True, "use_faces": False},
|
||||
"EDGE",
|
||||
{i for i in range(14)})]),
|
||||
MeshTest("CubeDeleteLooseFaces", "testCubeDeleteLooseFaces",
|
||||
SpecMeshTest("CubeDeleteLooseFaces", "testCubeDeleteLooseFaces",
|
||||
"expectedCubeDeleteLooseFaces",
|
||||
[OperatorSpecEditMode("delete_loose", {"use_verts": False, "use_edges": False, "use_faces": True},
|
||||
"FACE",
|
||||
{i for i in range(7)})]),
|
||||
|
||||
# dissolve degenerate
|
||||
MeshTest("CubeDissolveDegenerate", "testCubeDissolveDegenerate",
|
||||
SpecMeshTest("CubeDissolveDegenerate", "testCubeDissolveDegenerate",
|
||||
"expectedCubeDissolveDegenerate",
|
||||
[OperatorSpecEditMode("dissolve_degenerate", {}, "VERT", {i for i in range(8)})]),
|
||||
|
||||
# dissolve edges
|
||||
MeshTest("CylinderDissolveEdges", "testCylinderDissolveEdges", "expectedCylinderDissolveEdges",
|
||||
SpecMeshTest("CylinderDissolveEdges", "testCylinderDissolveEdges", "expectedCylinderDissolveEdges",
|
||||
[OperatorSpecEditMode("dissolve_edges", {}, "EDGE", {0, 5, 6, 9})]),
|
||||
|
||||
# dissolve faces
|
||||
MeshTest("CubeDissolveFaces", "testCubeDissolveFaces", "expectedCubeDissolveFaces",
|
||||
SpecMeshTest("CubeDissolveFaces", "testCubeDissolveFaces", "expectedCubeDissolveFaces",
|
||||
[OperatorSpecEditMode("dissolve_faces", {}, "VERT", {5, 34, 47, 49, 83, 91, 95})]),
|
||||
|
||||
# dissolve verts
|
||||
MeshTest("CubeDissolveVerts", "testCubeDissolveVerts", "expectedCubeDissolveVerts",
|
||||
SpecMeshTest("CubeDissolveVerts", "testCubeDissolveVerts", "expectedCubeDissolveVerts",
|
||||
[OperatorSpecEditMode("dissolve_verts", {}, "VERT", {16, 20, 22, 23, 25})]),
|
||||
|
||||
# duplicate
|
||||
MeshTest("ConeDuplicateVertices", "testConeDuplicateVertices",
|
||||
SpecMeshTest("ConeDuplicateVertices", "testConeDuplicateVertices",
|
||||
"expectedConeDuplicateVertices",
|
||||
[OperatorSpecEditMode("duplicate", {}, "VERT", {i for i in range(33)} - {23})]),
|
||||
|
||||
MeshTest("ConeDuplicateOneVertex", "testConeDuplicateOneVertex", "expectedConeDuplicateOneVertex",
|
||||
SpecMeshTest("ConeDuplicateOneVertex", "testConeDuplicateOneVertex", "expectedConeDuplicateOneVertex",
|
||||
[OperatorSpecEditMode("duplicate", {}, "VERT", {23})]),
|
||||
MeshTest("ConeDuplicateFaces", "testConeDuplicateFaces", "expectedConeDuplicateFaces",
|
||||
SpecMeshTest("ConeDuplicateFaces", "testConeDuplicateFaces", "expectedConeDuplicateFaces",
|
||||
[OperatorSpecEditMode("duplicate", {}, "FACE", {6, 9})]),
|
||||
MeshTest("ConeDuplicateEdges", "testConeDuplicateEdges", "expectedConeDuplicateEdges",
|
||||
SpecMeshTest("ConeDuplicateEdges", "testConeDuplicateEdges", "expectedConeDuplicateEdges",
|
||||
[OperatorSpecEditMode("duplicate", {}, "EDGE", {i for i in range(64)})]),
|
||||
|
||||
# edge collapse
|
||||
MeshTest("CylinderEdgeCollapse", "testCylinderEdgeCollapse", "expectedCylinderEdgeCollapse",
|
||||
SpecMeshTest("CylinderEdgeCollapse", "testCylinderEdgeCollapse", "expectedCylinderEdgeCollapse",
|
||||
[OperatorSpecEditMode("edge_collapse", {}, "EDGE", {1, 9, 4})]),
|
||||
|
||||
# edge face add
|
||||
MeshTest("CubeEdgeFaceAddFace", "testCubeEdgeFaceAddFace", "expectedCubeEdgeFaceAddFace",
|
||||
SpecMeshTest("CubeEdgeFaceAddFace", "testCubeEdgeFaceAddFace", "expectedCubeEdgeFaceAddFace",
|
||||
[OperatorSpecEditMode("edge_face_add", {}, "VERT", {1, 3, 4, 5, 7})]),
|
||||
MeshTest("CubeEdgeFaceAddEdge", "testCubeEdgeFaceAddEdge", "expectedCubeEdgeFaceAddEdge",
|
||||
SpecMeshTest("CubeEdgeFaceAddEdge", "testCubeEdgeFaceAddEdge", "expectedCubeEdgeFaceAddEdge",
|
||||
[OperatorSpecEditMode("edge_face_add", {}, "VERT", {4, 5})]),
|
||||
|
||||
# edge rotate
|
||||
MeshTest("CubeEdgeRotate", "testCubeEdgeRotate", "expectedCubeEdgeRotate",
|
||||
SpecMeshTest("CubeEdgeRotate", "testCubeEdgeRotate", "expectedCubeEdgeRotate",
|
||||
[OperatorSpecEditMode("edge_rotate", {}, "EDGE", {1})]),
|
||||
|
||||
# edge split
|
||||
MeshTest("CubeEdgeSplit", "testCubeEdgeSplit", "expectedCubeEdgeSplit",
|
||||
SpecMeshTest("CubeEdgeSplit", "testCubeEdgeSplit", "expectedCubeEdgeSplit",
|
||||
[OperatorSpecEditMode("edge_split", {}, "EDGE", {2, 5, 8, 11, 14, 17, 20, 23})]),
|
||||
|
||||
# edge ring select - Cannot be tested. Need user input.
|
||||
# MeshTest("CubeEdgeRingSelect", "testCubeEdgeRingSelect", "expectedCubeEdgeRingSelect",
|
||||
# SpecMeshTest("CubeEdgeRingSelect", "testCubeEdgeRingSelect", "expectedCubeEdgeRingSelect",
|
||||
# [OperatorSpecEditMode("edgering_select", {}, "EDGE", {5, 20, 25, 26})]),
|
||||
# MeshTest("EmptyMeshEdgeRingSelect", "testGridEdgeRingSelect", "expectedGridEdgeRingSelect",
|
||||
# SpecMeshTest("EmptyMeshEdgeRingSelect", "testGridEdgeRingSelect", "expectedGridEdgeRingSelect",
|
||||
# [OperatorSpecEditMode("edgering_select", {}, "VERT", {65, 66, 67})]),
|
||||
# MeshTest("EmptyMeshEdgeRingSelect", "testEmptyMeshdgeRingSelect", "expectedEmptyMeshEdgeRingSelect",
|
||||
# SpecMeshTest("EmptyMeshEdgeRingSelect", "testEmptyMeshdgeRingSelect", "expectedEmptyMeshEdgeRingSelect",
|
||||
# [OperatorSpecEditMode("edgering_select", {}, "VERT", {})]),
|
||||
|
||||
# edges select sharp
|
||||
MeshTest("CubeEdgesSelectSharp", "testCubeEdgeSelectSharp", "expectedCubeEdgeSelectSharp",
|
||||
SpecMeshTest("CubeEdgesSelectSharp", "testCubeEdgeSelectSharp", "expectedCubeEdgeSelectSharp",
|
||||
[OperatorSpecEditMode("edges_select_sharp", {}, "EDGE", {20})]),
|
||||
MeshTest("SphereEdgesSelectSharp", "testSphereEdgesSelectSharp", "expectedSphereEdgeSelectSharp",
|
||||
SpecMeshTest("SphereEdgesSelectSharp", "testSphereEdgesSelectSharp", "expectedSphereEdgeSelectSharp",
|
||||
[OperatorSpecEditMode("edges_select_sharp", {"sharpness": 0.25}, "EDGE", {288})]),
|
||||
MeshTest("HoledSphereEdgesSelectSharp", "testHoledSphereEdgesSelectSharp", "expectedHoledSphereEdgeSelectSharp",
|
||||
SpecMeshTest("HoledSphereEdgesSelectSharp", "testHoledSphereEdgesSelectSharp", "expectedHoledSphereEdgeSelectSharp",
|
||||
[OperatorSpecEditMode("edges_select_sharp", {"sharpness": 0.18}, "VERT", {})]),
|
||||
MeshTest("EmptyMeshEdgesSelectSharp", "testEmptyMeshEdgeSelectSharp", "expectedEmptyMeshEdgeSelectSharp",
|
||||
SpecMeshTest("EmptyMeshEdgesSelectSharp", "testEmptyMeshEdgeSelectSharp", "expectedEmptyMeshEdgeSelectSharp",
|
||||
[OperatorSpecEditMode("edges_select_sharp", {}, "VERT", {})]),
|
||||
|
||||
# face make planar
|
||||
MeshTest("MonkeyFaceMakePlanar", "testMonkeyFaceMakePlanar",
|
||||
SpecMeshTest("MonkeyFaceMakePlanar", "testMonkeyFaceMakePlanar",
|
||||
"expectedMonkeyFaceMakePlanar",
|
||||
[OperatorSpecEditMode("face_make_planar", {}, "FACE", {i for i in range(500)})]),
|
||||
|
||||
# face split by edges
|
||||
MeshTest("PlaneFaceSplitByEdges", "testPlaneFaceSplitByEdges",
|
||||
SpecMeshTest("PlaneFaceSplitByEdges", "testPlaneFaceSplitByEdges",
|
||||
"expectedPlaneFaceSplitByEdges",
|
||||
[OperatorSpecEditMode("face_split_by_edges", {}, "VERT", {i for i in range(6)})]),
|
||||
|
||||
# faces select linked flat
|
||||
MeshTest("CubeFacesSelectLinkedFlat", "testCubeFaceSelectLinkedFlat", "expectedCubeFaceSelectLinkedFlat",
|
||||
SpecMeshTest("CubeFacesSelectLinkedFlat", "testCubeFaceSelectLinkedFlat", "expectedCubeFaceSelectLinkedFlat",
|
||||
[OperatorSpecEditMode("faces_select_linked_flat", {}, "FACE", {7})]),
|
||||
MeshTest("PlaneFacesSelectLinkedFlat", "testPlaneFaceSelectLinkedFlat", "expectedPlaneFaceSelectLinkedFlat",
|
||||
SpecMeshTest("PlaneFacesSelectLinkedFlat", "testPlaneFaceSelectLinkedFlat", "expectedPlaneFaceSelectLinkedFlat",
|
||||
[OperatorSpecEditMode("faces_select_linked_flat", {}, "VERT", {1})]),
|
||||
MeshTest("EmptyMeshFacesSelectLinkedFlat", "testEmptyMeshFaceSelectLinkedFlat",
|
||||
SpecMeshTest("EmptyMeshFacesSelectLinkedFlat", "testEmptyMeshFaceSelectLinkedFlat",
|
||||
"expectedEmptyMeshFaceSelectLinkedFlat",
|
||||
[OperatorSpecEditMode("faces_select_linked_flat", {}, "VERT", {})]),
|
||||
|
||||
# fill
|
||||
MeshTest("IcosphereFill", "testIcosphereFill", "expectedIcosphereFill",
|
||||
SpecMeshTest("IcosphereFill", "testIcosphereFill", "expectedIcosphereFill",
|
||||
[OperatorSpecEditMode("fill", {}, "EDGE", {20, 21, 22, 23, 24, 45, 46, 47, 48, 49})]),
|
||||
MeshTest("IcosphereFillUseBeautyFalse",
|
||||
SpecMeshTest("IcosphereFillUseBeautyFalse",
|
||||
"testIcosphereFillUseBeautyFalse", "expectedIcosphereFillUseBeautyFalse",
|
||||
[OperatorSpecEditMode("fill", {"use_beauty": False}, "EDGE",
|
||||
{20, 21, 22, 23, 24, 45, 46, 47, 48, 49})]),
|
||||
|
||||
# fill grid
|
||||
MeshTest("PlaneFillGrid", "testPlaneFillGrid",
|
||||
SpecMeshTest("PlaneFillGrid", "testPlaneFillGrid",
|
||||
"expectedPlaneFillGrid",
|
||||
[OperatorSpecEditMode("fill_grid", {}, "EDGE", {1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 15})]),
|
||||
MeshTest("PlaneFillGridSimpleBlending",
|
||||
SpecMeshTest("PlaneFillGridSimpleBlending",
|
||||
"testPlaneFillGridSimpleBlending",
|
||||
"expectedPlaneFillGridSimpleBlending",
|
||||
[OperatorSpecEditMode("fill_grid", {"use_interp_simple": True}, "EDGE",
|
||||
{1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 15})]),
|
||||
|
||||
# fill holes
|
||||
MeshTest("SphereFillHoles", "testSphereFillHoles", "expectedSphereFillHoles",
|
||||
SpecMeshTest("SphereFillHoles", "testSphereFillHoles", "expectedSphereFillHoles",
|
||||
[OperatorSpecEditMode("fill_holes", {"sides": 9}, "VERT", {i for i in range(481)})]),
|
||||
|
||||
# face shade smooth (not a real test)
|
||||
MeshTest("CubeShadeSmooth", "testCubeShadeSmooth", "expectedCubeShadeSmooth",
|
||||
SpecMeshTest("CubeShadeSmooth", "testCubeShadeSmooth", "expectedCubeShadeSmooth",
|
||||
[OperatorSpecEditMode("faces_shade_smooth", {}, "VERT", {i for i in range(8)})]),
|
||||
|
||||
# faces shade flat (not a real test)
|
||||
MeshTest("CubeShadeFlat", "testCubeShadeFlat", "expectedCubeShadeFlat",
|
||||
SpecMeshTest("CubeShadeFlat", "testCubeShadeFlat", "expectedCubeShadeFlat",
|
||||
[OperatorSpecEditMode("faces_shade_flat", {}, "FACE", {i for i in range(6)})]),
|
||||
|
||||
# inset faces
|
||||
MeshTest("CubeInset",
|
||||
SpecMeshTest("CubeInset",
|
||||
"testCubeInset", "expectedCubeInset", [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})]),
|
||||
MeshTest("CubeInsetEvenOffsetFalse",
|
||||
SpecMeshTest("CubeInsetEvenOffsetFalse",
|
||||
"testCubeInsetEvenOffsetFalse", "expectedCubeInsetEvenOffsetFalse",
|
||||
[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})]),
|
||||
MeshTest("CubeInsetDepth",
|
||||
SpecMeshTest("CubeInsetDepth",
|
||||
"testCubeInsetDepth",
|
||||
"expectedCubeInsetDepth", [OperatorSpecEditMode("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})]),
|
||||
MeshTest("GridInsetRelativeOffset", "testGridInsetRelativeOffset",
|
||||
SpecMeshTest("GridInsetRelativeOffset", "testGridInsetRelativeOffset",
|
||||
"expectedGridInsetRelativeOffset",
|
||||
[OperatorSpecEditMode("inset", {"thickness": 0.4,
|
||||
"use_relative_offset": True}, "FACE",
|
||||
{35, 36, 37, 45, 46, 47, 55, 56, 57})]),
|
||||
|
||||
# loop multi select
|
||||
MeshTest("MokeyLoopMultiSelect", "testMonkeyLoopMultiSelect", "expectedMonkeyLoopMultiSelect",
|
||||
SpecMeshTest("MokeyLoopMultiSelect", "testMonkeyLoopMultiSelect", "expectedMonkeyLoopMultiSelect",
|
||||
[OperatorSpecEditMode("loop_multi_select", {}, "VERT", {355, 359, 73, 301, 302})]),
|
||||
MeshTest("HoledGridLoopMultiSelect", "testGridLoopMultiSelect", "expectedGridLoopMultiSelect",
|
||||
SpecMeshTest("HoledGridLoopMultiSelect", "testGridLoopMultiSelect", "expectedGridLoopMultiSelect",
|
||||
[OperatorSpecEditMode("loop_multi_select", {}, "VERT", {257, 169, 202, 207, 274, 278, 63})]),
|
||||
MeshTest("EmptyMeshLoopMultiSelect", "testEmptyMeshLoopMultiSelect", "expectedEmptyMeshLoopMultiSelect",
|
||||
SpecMeshTest("EmptyMeshLoopMultiSelect", "testEmptyMeshLoopMultiSelect", "expectedEmptyMeshLoopMultiSelect",
|
||||
[OperatorSpecEditMode("loop_multi_select", {}, "VERT", {})]),
|
||||
|
||||
# mark seam
|
||||
MeshTest("CubeMarkSeam", "testCubeMarkSeam", "expectedCubeMarkSeam",
|
||||
SpecMeshTest("CubeMarkSeam", "testCubeMarkSeam", "expectedCubeMarkSeam",
|
||||
[OperatorSpecEditMode("mark_seam", {}, "EDGE", {1})]),
|
||||
|
||||
# select all
|
||||
MeshTest("CircleSelectAll", "testCircleSelectAll", "expectedCircleSelectAll",
|
||||
SpecMeshTest("CircleSelectAll", "testCircleSelectAll", "expectedCircleSelectAll",
|
||||
[OperatorSpecEditMode("select_all", {}, "VERT", {1})]),
|
||||
MeshTest("IsolatedVertsSelectAll", "testIsolatedVertsSelectAll", "expectedIsolatedVertsSelectAll",
|
||||
SpecMeshTest("IsolatedVertsSelectAll", "testIsolatedVertsSelectAll", "expectedIsolatedVertsSelectAll",
|
||||
[OperatorSpecEditMode("select_all", {}, "VERT", {})]),
|
||||
MeshTest("EmptyMeshSelectAll", "testEmptyMeshSelectAll", "expectedEmptyMeshSelectAll",
|
||||
SpecMeshTest("EmptyMeshSelectAll", "testEmptyMeshSelectAll", "expectedEmptyMeshSelectAll",
|
||||
[OperatorSpecEditMode("select_all", {}, "VERT", {})]),
|
||||
|
||||
# select axis - Cannot be tested. Needs active vert selection
|
||||
# MeshTest("MonkeySelectAxisX", "testMonkeySelectAxisX", "expectedMonkeySelectAxisX",
|
||||
# SpecMeshTest("MonkeySelectAxisX", "testMonkeySelectAxisX", "expectedMonkeySelectAxisX",
|
||||
# [OperatorSpecEditMode("select_axis", {"axis": "X"}, "VERT", {13})]),
|
||||
# MeshTest("MonkeySelectAxisY", "testMonkeySelectAxisY", "expectedMonkeySelectAxisY",
|
||||
# SpecMeshTest("MonkeySelectAxisY", "testMonkeySelectAxisY", "expectedMonkeySelectAxisY",
|
||||
# [OperatorSpecEditMode("select_axis", {"axis": "Y", "sign": "NEG"}, "FACE", {317})]),
|
||||
# MeshTest("MonkeySelectAxisXYZ", "testMonkeySelectAxisXYZ", "expectedMonkeySelectAxisXYZ",
|
||||
# SpecMeshTest("MonkeySelectAxisXYZ", "testMonkeySelectAxisXYZ", "expectedMonkeySelectAxisXYZ",
|
||||
# [OperatorSpecEditMode("select_axis", {"axis": "X", "sign": "NEG"}, "FACE", {317}),
|
||||
# OperatorSpecEditMode("select_axis", {"axis": "Y", "sign": "POS"}, "FACE", {}),
|
||||
# OperatorSpecEditMode("select_axis", {"axis": "Z", "sign": "NEG"}, "FACE", {})]),
|
||||
|
||||
# select faces by sides
|
||||
MeshTest("CubeSelectFacesBySide", "testCubeSelectFacesBySide", "expectedCubeSelectFacesBySide",
|
||||
SpecMeshTest("CubeSelectFacesBySide", "testCubeSelectFacesBySide", "expectedCubeSelectFacesBySide",
|
||||
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})]),
|
||||
MeshTest("CubeSelectFacesBySideGreater", "testCubeSelectFacesBySideGreater", "expectedCubeSelectFacesBySideGreater",
|
||||
SpecMeshTest("CubeSelectFacesBySideGreater", "testCubeSelectFacesBySideGreater", "expectedCubeSelectFacesBySideGreater",
|
||||
[OperatorSpecEditMode("select_face_by_sides", {"number": 4, "type": "GREATER", "extend": True}, "FACE", {})]),
|
||||
MeshTest("CubeSelectFacesBySideLess", "testCubeSelectFacesBySideLess", "expectedCubeSelectFacesBySideLess",
|
||||
SpecMeshTest("CubeSelectFacesBySideLess", "testCubeSelectFacesBySideLess", "expectedCubeSelectFacesBySideLess",
|
||||
[OperatorSpecEditMode("select_face_by_sides", {"number": 4, "type": "GREATER", "extend": True}, "FACE", {})]),
|
||||
|
||||
# select interior faces
|
||||
MeshTest("CubeSelectInteriorFaces", "testCubeSelectInteriorFaces", "expectedCubeSelectInteriorFaces",
|
||||
SpecMeshTest("CubeSelectInteriorFaces", "testCubeSelectInteriorFaces", "expectedCubeSelectInteriorFaces",
|
||||
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})]),
|
||||
MeshTest("HoledCubeSelectInteriorFaces", "testHoledCubeSelectInteriorFaces", "expectedHoledCubeSelectInteriorFaces",
|
||||
SpecMeshTest("HoledCubeSelectInteriorFaces", "testHoledCubeSelectInteriorFaces", "expectedHoledCubeSelectInteriorFaces",
|
||||
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})]),
|
||||
MeshTest("EmptyMeshSelectInteriorFaces", "testEmptyMeshSelectInteriorFaces", "expectedEmptyMeshSelectInteriorFaces",
|
||||
SpecMeshTest("EmptyMeshSelectInteriorFaces", "testEmptyMeshSelectInteriorFaces", "expectedEmptyMeshSelectInteriorFaces",
|
||||
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})]),
|
||||
|
||||
# select less
|
||||
MeshTest("MonkeySelectLess", "testMonkeySelectLess", "expectedMonkeySelectLess",
|
||||
SpecMeshTest("MonkeySelectLess", "testMonkeySelectLess", "expectedMonkeySelectLess",
|
||||
[OperatorSpecEditMode("select_less", {}, "VERT", {2, 8, 24, 34, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 68,
|
||||
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,
|
||||
@@ -295,37 +295,37 @@ def main():
|
||||
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})]),
|
||||
MeshTest("HoledCubeSelectLess", "testHoledCubeSelectLess", "expectedHoledCubeSelectLess",
|
||||
SpecMeshTest("HoledCubeSelectLess", "testHoledCubeSelectLess", "expectedHoledCubeSelectLess",
|
||||
[OperatorSpecEditMode("select_face_by_sides", {}, "FACE", {})]),
|
||||
MeshTest("EmptyMeshSelectLess", "testEmptyMeshSelectLess", "expectedEmptyMeshSelectLess",
|
||||
SpecMeshTest("EmptyMeshSelectLess", "testEmptyMeshSelectLess", "expectedEmptyMeshSelectLess",
|
||||
[OperatorSpecEditMode("select_face_by_sides", {}, "VERT", {})]),
|
||||
|
||||
# select linked
|
||||
MeshTest("PlanesSelectLinked", "testPlanesSelectLinked", "expectedPlanesSelectedLinked",
|
||||
SpecMeshTest("PlanesSelectLinked", "testPlanesSelectLinked", "expectedPlanesSelectedLinked",
|
||||
[OperatorSpecEditMode("select_linked", {}, "VERT", {7})]),
|
||||
MeshTest("CubesSelectLinked", "testCubesSelectLinked", "expectedCubesSelectLinked",
|
||||
SpecMeshTest("CubesSelectLinked", "testCubesSelectLinked", "expectedCubesSelectLinked",
|
||||
[OperatorSpecEditMode("select_linked", {}, "VERT", {11})]),
|
||||
MeshTest("EmptyMeshSelectLinked", "testEmptyMeshSelectLinked", "expectedEmptyMeshSelectLinked",
|
||||
SpecMeshTest("EmptyMeshSelectLinked", "testEmptyMeshSelectLinked", "expectedEmptyMeshSelectLinked",
|
||||
[OperatorSpecEditMode("select_linked", {}, "VERT", {})]),
|
||||
|
||||
# select nth (checkered deselect)
|
||||
MeshTest("CircleSelect2nd", "testCircleSelect2nd", "expectedCircleSelect2nd",
|
||||
SpecMeshTest("CircleSelect2nd", "testCircleSelect2nd", "expectedCircleSelect2nd",
|
||||
[OperatorSpecEditMode("select_nth", {}, "VERT", {i for i in range(32)})]),
|
||||
|
||||
# unsubdivide
|
||||
# normal case
|
||||
MeshTest("CubeFaceUnsubdivide", "testCubeUnsubdivide", "expectedCubeUnsubdivide",
|
||||
SpecMeshTest("CubeFaceUnsubdivide", "testCubeUnsubdivide", "expectedCubeUnsubdivide",
|
||||
[OperatorSpecEditMode("unsubdivide", {}, "FACE", {i for i in range(6)})]),
|
||||
|
||||
# T87259 - test cases
|
||||
MeshTest("CubeEdgeUnsubdivide", "testCubeEdgeUnsubdivide", "expectedCubeEdgeUnsubdivide",
|
||||
SpecMeshTest("CubeEdgeUnsubdivide", "testCubeEdgeUnsubdivide", "expectedCubeEdgeUnsubdivide",
|
||||
[OperatorSpecEditMode("unsubdivide", {}, "EDGE", {i for i in range(6)})]),
|
||||
MeshTest("UVSphereUnsubdivide", "testUVSphereUnsubdivide", "expectedUVSphereUnsubdivide",
|
||||
[OperatorSpecEditMode("unsubdivide", {'iterations': 9}, "FACE", {i for i in range(512)})]),
|
||||
SpecMeshTest("UVSphereUnsubdivide", "testUVSphereUnsubdivide", "expectedUVSphereUnsubdivide",
|
||||
[OperatorSpecEditMode("unsubdivide", {'iterations': 9}, "FACE", {i for i in range(512)})]),
|
||||
|
||||
# vert connect path
|
||||
# Tip: It works only if there is an already existing face or more than 2 vertices.
|
||||
MeshTest("CubeVertConnectPath", "testCubeVertConnectPath", "expectedCubeVertConnectPath",
|
||||
SpecMeshTest("CubeVertConnectPath", "testCubeVertConnectPath", "expectedCubeVertConnectPath",
|
||||
[OperatorSpecEditMode("vert_connect_path", {}, "VERT", {0, 5})]),
|
||||
|
||||
]
|
||||
|
||||
@@ -24,25 +24,25 @@ import sys
|
||||
import bpy
|
||||
|
||||
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
|
||||
from modules.mesh_test import RunTest, ModifierSpec, MeshTest
|
||||
from modules.mesh_test import RunTest, ModifierSpec, SpecMeshTest
|
||||
|
||||
|
||||
def main():
|
||||
test = [
|
||||
|
||||
MeshTest("ClothSimple", "testClothPlane", "expectedClothPlane",
|
||||
SpecMeshTest("ClothSimple", "testClothPlane", "expectedClothPlane",
|
||||
[ModifierSpec('Cloth', 'CLOTH', {'settings': {'quality': 5}}, 15)], threshold=1e-3),
|
||||
|
||||
# Not reproducible
|
||||
# MeshTest("ClothPressure", "testObjClothPressure", "expObjClothPressure",
|
||||
# SpecMeshTest("ClothPressure", "testObjClothPressure", "expObjClothPressure",
|
||||
# [ModifierSpec('Cloth2', 'CLOTH', {'settings': {'use_pressure': True,
|
||||
# 'uniform_pressure_force': 1}}, 16)]),
|
||||
|
||||
# Not reproducible
|
||||
# MeshTest("ClothSelfCollision", "testClothCollision", "expClothCollision",
|
||||
# SpecMeshTest("ClothSelfCollision", "testClothCollision", "expClothCollision",
|
||||
# [ModifierSpec('Cloth', 'CLOTH', {'collision_settings': {'use_self_collision': True}}, 67)]),
|
||||
|
||||
MeshTest("ClothSpring", "testTorusClothSpring", "expTorusClothSpring",
|
||||
SpecMeshTest("ClothSpring", "testTorusClothSpring", "expTorusClothSpring",
|
||||
[ModifierSpec('Cloth2', 'CLOTH', {'settings': {'use_internal_springs': True}}, 10)], threshold=1e-3),
|
||||
|
||||
]
|
||||
|
||||
@@ -24,13 +24,13 @@ import sys
|
||||
import bpy
|
||||
|
||||
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
|
||||
from modules.mesh_test import RunTest, ModifierSpec, MeshTest
|
||||
from modules.mesh_test import RunTest, ModifierSpec, SpecMeshTest
|
||||
|
||||
|
||||
def main():
|
||||
test = [
|
||||
|
||||
MeshTest("DynamicPaintSimple", "testObjDynamicPaintPlane", "expObjDynamicPaintPlane",
|
||||
SpecMeshTest("DynamicPaintSimple", "testObjDynamicPaintPlane", "expObjDynamicPaintPlane",
|
||||
[ModifierSpec('dynamic_paint', 'DYNAMIC_PAINT',
|
||||
{'ui_type': 'CANVAS',
|
||||
'canvas_settings': {'canvas_surfaces': {'surface_type': 'WAVE', 'frame_end': 15}}},
|
||||
|
||||
@@ -24,13 +24,13 @@ import sys
|
||||
import bpy
|
||||
|
||||
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
|
||||
from modules.mesh_test import RunTest, ModifierSpec, MeshTest
|
||||
from modules.mesh_test import RunTest, ModifierSpec, SpecMeshTest
|
||||
|
||||
|
||||
def main():
|
||||
test = [
|
||||
# World coordinates of test and expected object should be same.
|
||||
MeshTest("PlaneOcean", "testObjPlaneOcean", "expObjPlaneOcean",
|
||||
SpecMeshTest("PlaneOcean", "testObjPlaneOcean", "expObjPlaneOcean",
|
||||
[ModifierSpec('Ocean', 'OCEAN', {})]),
|
||||
]
|
||||
ocean_test = RunTest(test)
|
||||
|
||||
@@ -24,13 +24,13 @@ import sys
|
||||
import bpy
|
||||
|
||||
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
|
||||
from modules.mesh_test import RunTest, ModifierSpec, MeshTest
|
||||
from modules.mesh_test import RunTest, ModifierSpec, SpecMeshTest
|
||||
|
||||
|
||||
def main():
|
||||
test = [
|
||||
|
||||
MeshTest("ParticleInstanceSimple", "testParticleInstance", "expectedParticleInstance",
|
||||
SpecMeshTest("ParticleInstanceSimple", "testParticleInstance", "expectedParticleInstance",
|
||||
[ModifierSpec('ParticleInstance', 'PARTICLE_INSTANCE', {'object': bpy.data.objects['Cube']})],
|
||||
threshold=1e-3),
|
||||
|
||||
|
||||
@@ -20,16 +20,15 @@
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
import bpy
|
||||
|
||||
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
|
||||
from modules.mesh_test import RunTest, ParticleSystemSpec, MeshTest
|
||||
from modules.mesh_test import RunTest, ParticleSystemSpec, SpecMeshTest
|
||||
|
||||
|
||||
def main():
|
||||
test = [
|
||||
MeshTest("ParticleSystemTest", "testParticleSystem", "expParticleSystem",
|
||||
SpecMeshTest("ParticleSystemTest", "testParticleSystem", "expParticleSystem",
|
||||
[ParticleSystemSpec('Particles', 'PARTICLE_SYSTEM', {'render_type': "OBJECT",
|
||||
'instance_object': bpy.data.objects['Cube']}, 20)], threshold=1e-3),
|
||||
|
||||
|
||||
@@ -24,13 +24,13 @@ import sys
|
||||
import bpy
|
||||
|
||||
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
|
||||
from modules.mesh_test import RunTest, ModifierSpec, MeshTest
|
||||
from modules.mesh_test import RunTest, ModifierSpec, SpecMeshTest
|
||||
|
||||
|
||||
def main():
|
||||
test = [
|
||||
|
||||
MeshTest("SoftBodySimple", "testSoftBody", "expectedSoftBody",
|
||||
SpecMeshTest("SoftBodySimple", "testSoftBody", "expectedSoftBody",
|
||||
[ModifierSpec('Softbody', 'SOFT_BODY',
|
||||
{'settings': {'use_goal': False, 'bend': 8, 'pull': 0.8, 'push': 0.8}},
|
||||
45)]),
|
||||
|
||||
Reference in New Issue
Block a user