e955c94ed3
Listing the "Blender Foundation" as copyright holder implied the Blender Foundation holds copyright to files which may include work from many developers. While keeping copyright on headers makes sense for isolated libraries, Blender's own code may be refactored or moved between files in a way that makes the per file copyright holders less meaningful. Copyright references to the "Blender Foundation" have been replaced with "Blender Authors", with the exception of `./extern/` since these this contains libraries which are more isolated, any changed to license headers there can be handled on a case-by-case basis. Some directories in `./intern/` have also been excluded: - `./intern/cycles/` it's own `AUTHORS` file is planned. - `./intern/opensubdiv/`. An "AUTHORS" file has been added, using the chromium projects authors file as a template. Design task: #110784 Ref !110783.
886 lines
35 KiB
Python
886 lines
35 KiB
Python
# SPDX-FileCopyrightText: 2020-2023 Blender Authors
|
|
#
|
|
# SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
# A framework to run regression tests on mesh modifiers and operators based on howardt's mesh_ops_test.py
|
|
#
|
|
# General idea:
|
|
# A test is:
|
|
# Object mode
|
|
# Select <test_object>
|
|
# Duplicate the object
|
|
# Select the object
|
|
# Apply operation for each operation in <operations_stack> with given parameters
|
|
# (an operation is either a modifier or an operator)
|
|
# test_mesh = <test_object>.data
|
|
# run test_mesh.unit_test_compare(<expected object>.data)
|
|
# delete the duplicate object
|
|
#
|
|
# The words in angle brackets are parameters of the test, and are specified in
|
|
# 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 bmesh
|
|
import functools
|
|
import inspect
|
|
import os
|
|
|
|
# Output from this module and from blender itself will occur during tests.
|
|
# We need to flush python so that the output is properly interleaved, otherwise
|
|
# blender's output for one test will end up showing in the middle of another test...
|
|
print = functools.partial(print, flush=True)
|
|
|
|
|
|
class ModifierSpec:
|
|
"""
|
|
Holds a Generate or Deform or Physics modifier type and its parameters.
|
|
"""
|
|
|
|
def __init__(self, modifier_name: str, modifier_type: str, modifier_parameters: dict, frame_end=0):
|
|
"""
|
|
Constructs a modifier spec.
|
|
|
|
:arg modifier_name: str - name of object modifier, e.g. "myFirstSubsurfModif"
|
|
:arg modifier_type: str - type of object modifier, e.g. "SUBSURF"
|
|
:arg modifier_parameters: dict - {name : val} dictionary giving modifier parameters, e.g. {"quality" : 4}
|
|
:arg frame_end: int - frame at which simulation needs to be baked or modifier needs to be applied.
|
|
"""
|
|
self.modifier_name = modifier_name
|
|
self.modifier_type = modifier_type
|
|
self.modifier_parameters = modifier_parameters
|
|
self.frame_end = frame_end
|
|
|
|
def __str__(self):
|
|
return "Modifier: " + self.modifier_name + " of type " + self.modifier_type + \
|
|
" with parameters: " + str(self.modifier_parameters)
|
|
|
|
|
|
class ParticleSystemSpec:
|
|
"""
|
|
Holds a Particle System modifier and its parameters.
|
|
"""
|
|
|
|
def __init__(self, modifier_name: str, modifier_type: str, modifier_parameters: dict, frame_end: int):
|
|
"""
|
|
Constructs a particle system spec.
|
|
|
|
:arg modifier_name: str - name of object modifier, e.g. "Particles"
|
|
:arg modifier_type: str - type of object modifier, e.g. "PARTICLE_SYSTEM"
|
|
:arg modifier_parameters: dict - {name : val} dictionary giving modifier parameters, e.g. {"seed" : 1}
|
|
:arg frame_end: int - the last frame of the simulation at which the modifier is applied
|
|
"""
|
|
self.modifier_name = modifier_name
|
|
self.modifier_type = modifier_type
|
|
self.modifier_parameters = modifier_parameters
|
|
self.frame_end = frame_end
|
|
|
|
def __str__(self):
|
|
return "Physics Modifier: " + self.modifier_name + " of type " + self.modifier_type + \
|
|
" with parameters: " + str(self.modifier_parameters) + " with frame end: " + str(self.frame_end)
|
|
|
|
|
|
class OperatorSpecEditMode:
|
|
"""
|
|
Holds one operator and its parameters.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
operator_name: str,
|
|
operator_parameters: dict,
|
|
select_mode: str,
|
|
selection,
|
|
*,
|
|
select_history: bool = False,
|
|
):
|
|
"""
|
|
Constructs an OperatorSpecEditMode. Raises ValueError if selec_mode is invalid.
|
|
|
|
:arg operator_name: str - name of mesh operator from bpy.ops.mesh, e.g. "bevel" or "fill"
|
|
:arg operator_parameters: dict - {name : val} dictionary containing operator parameters.
|
|
:arg select_mode: str - mesh selection mode, must be either 'VERT', 'EDGE' or 'FACE'
|
|
:arg selection: sequence - vertices/edges/faces indices to select, e.g. [0, 9, 10].
|
|
:arg: select_history: bool - load selection into bmesh selection history.
|
|
"""
|
|
self.operator_name = operator_name
|
|
self.operator_parameters = operator_parameters
|
|
if select_mode not in {'VERT', 'EDGE', 'FACE'}:
|
|
raise ValueError("select_mode must be either {}, {} or {}".format('VERT', 'EDGE', 'FACE'))
|
|
self.select_mode = select_mode
|
|
self.selection = selection
|
|
self.select_history = select_history
|
|
|
|
def __str__(self):
|
|
return "Operator: " + self.operator_name + " with parameters: " + str(self.operator_parameters) + \
|
|
" in selection mode: " + self.select_mode + ", selecting " + str(self.selection) + \
|
|
("and loading bmesh selection history" if (self.select_history) else "")
|
|
|
|
|
|
class OperatorSpecObjectMode:
|
|
"""
|
|
Holds an object operator and its parameters. Helper class for DeformModifierSpec.
|
|
Needed to support operations in Object Mode and not Edit Mode which is supported by OperatorSpecEditMode.
|
|
"""
|
|
|
|
def __init__(self, operator_name: str, operator_parameters: dict):
|
|
"""
|
|
:arg operator_name: str - name of the object operator from bpy.ops.object, e.g. "shade_smooth" or "shape_keys"
|
|
:arg operator_parameters: dict - contains operator parameters.
|
|
"""
|
|
self.operator_name = operator_name
|
|
self.operator_parameters = operator_parameters
|
|
|
|
def __str__(self):
|
|
return "Operator: " + self.operator_name + " with parameters: " + str(self.operator_parameters)
|
|
|
|
|
|
class DeformModifierSpec:
|
|
"""
|
|
Holds a list of deform modifier and OperatorSpecObjectMode.
|
|
For deform modifiers which have an object operator
|
|
"""
|
|
|
|
def __init__(self, frame_number: int, modifier_list: list, object_operator_spec: OperatorSpecObjectMode = None):
|
|
"""
|
|
Constructs a Deform Modifier spec (for user input).
|
|
|
|
:arg frame_number: int - the frame at which animated keyframe is inserted
|
|
:arg modifier_list: ModifierSpec - contains modifiers
|
|
:arg object_operator_spec: OperatorSpecObjectMode - contains object operators
|
|
"""
|
|
self.frame_number = frame_number
|
|
self.modifier_list = modifier_list
|
|
self.object_operator_spec = object_operator_spec
|
|
|
|
def __str__(self):
|
|
return "Modifier: " + str(self.modifier_list) + " with object operator " + str(self.object_operator_spec)
|
|
|
|
|
|
class MeshTest(ABC):
|
|
"""
|
|
A mesh testing Abstract class that hold common functionalities for testting operations.
|
|
"""
|
|
|
|
def __init__(self, test_object_name, exp_object_name, test_name=None, threshold=None, do_compare=True):
|
|
"""
|
|
:arg test_object_name: str - Name of object of mesh type to run the operations on.
|
|
:arg exp_object_name: str - Name of object of mesh type that has the expected
|
|
geometry after running the operations.
|
|
:arg test_name: str - Name of the test.
|
|
:arg threshold: exponent: To allow variations and accept difference to a certain degree.
|
|
:arg do_compare: bool - True if we want to compare the test and expected objects, False otherwise.
|
|
"""
|
|
self.test_object_name = test_object_name
|
|
self.exp_object_name = exp_object_name
|
|
if test_name:
|
|
self.test_name = test_name
|
|
else:
|
|
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.
|
|
"""
|
|
print("\nSTART {} test.".format(self.test_name))
|
|
|
|
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
|
|
|
|
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):
|
|
"""
|
|
Print results for failed test.
|
|
"""
|
|
print("FAILED {} 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("PASSED {} test successfully.".format(self.test_name))
|
|
self._print_result(result)
|
|
|
|
def do_selection(self, mesh: bpy.types.Mesh, select_mode: str, selection, select_history: bool):
|
|
"""
|
|
Do selection on a mesh.
|
|
|
|
:arg mesh: bpy.types.Mesh - input mesh
|
|
:arg: select_mode: str - selection mode. Must be 'VERT', 'EDGE' or 'FACE'
|
|
:arg: selection: sequence - indices of selection.
|
|
:arg: select_history: bool - load selection into bmesh selection history
|
|
|
|
Example: select_mode='VERT' and selection={1,2,3} selects veritces 1, 2 and 3 of input mesh
|
|
"""
|
|
if select_history and isinstance(selection, set):
|
|
raise Exception("'selection' must be an ordered sequence, not a 'set' type when 'select_history=True'")
|
|
|
|
# Deselect all objects.
|
|
bpy.ops.object.mode_set(mode='EDIT')
|
|
bpy.ops.mesh.select_all(action='DESELECT')
|
|
|
|
bm = bmesh.from_edit_mesh(mesh)
|
|
|
|
# bpy.ops.object.mode_set(mode='OBJECT')
|
|
|
|
bpy.context.tool_settings.mesh_select_mode = (select_mode == 'VERT',
|
|
select_mode == 'EDGE',
|
|
select_mode == 'FACE')
|
|
|
|
items = (
|
|
bm.verts if select_mode == 'VERT' else
|
|
bm.edges if select_mode == 'EDGE' else
|
|
bm.faces if select_mode == 'FACE' else None
|
|
)
|
|
|
|
items.ensure_lookup_table()
|
|
|
|
if items is None:
|
|
raise ValueError("Invalid selection mode")
|
|
for index in selection:
|
|
items[index].select = True
|
|
|
|
if select_history:
|
|
for index in selection:
|
|
bm.select_history.add(items[index])
|
|
bm.select_history.validate()
|
|
|
|
bpy.ops.object.mode_set(mode='OBJECT')
|
|
|
|
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, False)
|
|
|
|
# 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.
|
|
|
|
:arg evaluated_object: first object for comparison.
|
|
:arg expected_object: second object for comparison.
|
|
:arg 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.
|
|
|
|
:arg test_name: str - Name of the test.
|
|
:arg test_object_name: str - Name of object of mesh type to run the operations on.
|
|
:arg exp_object_name: str - Name of object of mesh type that has the expected
|
|
geometry after running the operations.
|
|
:arg operations_stack: list - stack holding operations to perform on the test_object.
|
|
:arg 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):
|
|
"""
|
|
Doing a depth first traversal of the modifier parameters and setting their values.
|
|
:arg: modifier: Of type modifier, its altered to become a setting in recursion.
|
|
:arg: modifier_parameters : dict or sequence, a simple/nested dictionary of modifier parameters.
|
|
:arg: nested_settings_path : list(stack): helps in tracing path to each node.
|
|
"""
|
|
if not isinstance(modifier_parameters, dict):
|
|
param_setting = None
|
|
for i, setting in enumerate(nested_settings_path):
|
|
|
|
# We want to set the attribute only when we have reached the last setting.
|
|
# Applying of intermediate settings is meaningless.
|
|
if i == len(nested_settings_path) - 1:
|
|
setattr(modifier, setting, modifier_parameters)
|
|
|
|
elif hasattr(modifier, setting):
|
|
param_setting = getattr(modifier, setting)
|
|
# getattr doesn't accept canvas_surfaces["Surface"], but we need to pass it to setattr.
|
|
if setting == "canvas_surfaces":
|
|
modifier = param_setting.active
|
|
else:
|
|
modifier = param_setting
|
|
else:
|
|
# Clean up first
|
|
bpy.ops.object.delete()
|
|
raise Exception("Modifier '{}' has no parameter named '{}'".
|
|
format(modifier_name, setting))
|
|
|
|
# It pops the current node before moving on to its sibling.
|
|
nested_settings_path.pop()
|
|
return
|
|
|
|
for key in modifier_parameters:
|
|
nested_settings_path.append(key)
|
|
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_impl.
|
|
"""
|
|
settings = []
|
|
modifier_name = modifier.name
|
|
self._set_parameters_impl(modifier, modifier_parameters, settings, modifier_name)
|
|
|
|
def _add_modifier(self, test_object, modifier_spec: ModifierSpec):
|
|
"""
|
|
Add modifier to object.
|
|
|
|
:arg test_object: bpy.types.Object - Blender object to apply modifier on.
|
|
:arg modifier_spec: ModifierSpec - ModifierSpec object with parameters
|
|
"""
|
|
bakers_list = ['CLOTH', 'SOFT_BODY', 'DYNAMIC_PAINT', 'FLUID']
|
|
scene = bpy.context.scene
|
|
scene.frame_set(1)
|
|
modifier = test_object.modifiers.new(modifier_spec.modifier_name,
|
|
modifier_spec.modifier_type)
|
|
|
|
if modifier is None:
|
|
raise Exception("This modifier type is already added on the Test Object, please remove it and try again.")
|
|
|
|
if self.verbose:
|
|
print("Created modifier '{}' of type '{}'.".
|
|
format(modifier_spec.modifier_name, modifier_spec.modifier_type))
|
|
|
|
# Special case for Dynamic Paint, need to toggle Canvas on.
|
|
if modifier.type == "DYNAMIC_PAINT":
|
|
bpy.ops.dpaint.type_toggle(type='CANVAS')
|
|
|
|
self.set_parameters(modifier, modifier_spec.modifier_parameters)
|
|
|
|
if modifier.type in bakers_list:
|
|
self._bake_current_simulation(test_object, modifier.name, modifier_spec.frame_end)
|
|
|
|
scene.frame_set(modifier_spec.frame_end)
|
|
|
|
def _apply_modifier(self, test_object, modifier_name):
|
|
# Modifier automatically gets applied when converting from Curve to Mesh.
|
|
if test_object.type == 'CURVE':
|
|
bpy.ops.object.convert(target='MESH')
|
|
elif test_object.type == 'MESH':
|
|
bpy.ops.object.modifier_apply(modifier=modifier_name)
|
|
else:
|
|
raise Exception("This object type is not yet supported!")
|
|
|
|
def _bake_current_simulation(self, test_object, test_modifier_name, frame_end):
|
|
"""
|
|
FLUID: Bakes the simulation
|
|
SOFT BODY, CLOTH, DYNAMIC PAINT: Overrides the point_cache context and then bakes.
|
|
"""
|
|
|
|
for scene in bpy.data.scenes:
|
|
for modifier in test_object.modifiers:
|
|
if modifier.type == 'FLUID':
|
|
bpy.ops.fluid.bake_all()
|
|
break
|
|
|
|
elif modifier.type == 'CLOTH' or modifier.type == 'SOFT_BODY':
|
|
test_object.modifiers[test_modifier_name].point_cache.frame_end = frame_end
|
|
override_setting = modifier.point_cache
|
|
context_override = {'scene': scene, 'active_object': test_object, 'point_cache': override_setting}
|
|
with bpy.context.temp_override(**context_override):
|
|
bpy.ops.ptcache.bake(bake=True)
|
|
break
|
|
|
|
elif modifier.type == 'DYNAMIC_PAINT':
|
|
dynamic_paint_setting = modifier.canvas_settings.canvas_surfaces.active
|
|
override_setting = dynamic_paint_setting.point_cache
|
|
context_override = {'scene': scene, 'active_object': test_object, 'point_cache': override_setting}
|
|
with bpy.context.temp_override(**context_override):
|
|
bpy.ops.ptcache.bake(bake=True)
|
|
break
|
|
|
|
def _apply_particle_system(self, test_object, particle_sys_spec: ParticleSystemSpec):
|
|
"""
|
|
Applies Particle System settings to test objects
|
|
"""
|
|
bpy.context.scene.frame_set(1)
|
|
bpy.ops.object.select_all(action='DESELECT')
|
|
|
|
test_object.modifiers.new(particle_sys_spec.modifier_name, particle_sys_spec.modifier_type)
|
|
|
|
settings_name = test_object.particle_systems.active.settings.name
|
|
particle_setting = bpy.data.particles[settings_name]
|
|
if self.verbose:
|
|
print("Created modifier '{}' of type '{}'.".
|
|
format(particle_sys_spec.modifier_name, particle_sys_spec.modifier_type))
|
|
|
|
for param_name in particle_sys_spec.modifier_parameters:
|
|
try:
|
|
if param_name == "seed":
|
|
system_setting = test_object.particle_systems[particle_sys_spec.modifier_name]
|
|
setattr(system_setting, param_name, particle_sys_spec.modifier_parameters[param_name])
|
|
else:
|
|
setattr(particle_setting, param_name, particle_sys_spec.modifier_parameters[param_name])
|
|
|
|
if self.verbose:
|
|
print("\t set parameter '{}' with value '{}'".
|
|
format(param_name, particle_sys_spec.modifier_parameters[param_name]))
|
|
except AttributeError:
|
|
# Clean up first
|
|
bpy.ops.object.delete()
|
|
raise AttributeError("Modifier '{}' has no parameter named '{}'".
|
|
format(particle_sys_spec.modifier_type, param_name))
|
|
|
|
bpy.context.scene.frame_set(particle_sys_spec.frame_end)
|
|
test_object.select_set(True)
|
|
bpy.ops.object.duplicates_make_real()
|
|
test_object.select_set(True)
|
|
bpy.ops.object.join()
|
|
if self.apply_modifier:
|
|
self._apply_modifier(test_object, particle_sys_spec.modifier_name)
|
|
|
|
def _apply_operator_edit_mode(self, test_object, operator: OperatorSpecEditMode):
|
|
"""
|
|
Apply operator on test object.
|
|
|
|
:arg test_object: bpy.types.Object - Blender object to apply operator on.
|
|
:arg operator: OperatorSpecEditMode - OperatorSpecEditMode object with parameters.
|
|
"""
|
|
self.do_selection(
|
|
test_object.data,
|
|
operator.select_mode,
|
|
operator.selection,
|
|
select_history=operator.select_history,
|
|
)
|
|
|
|
# Apply operator in edit mode.
|
|
bpy.ops.object.mode_set(mode='EDIT')
|
|
bpy.ops.mesh.select_mode(type=operator.select_mode)
|
|
mesh_operator = getattr(bpy.ops.mesh, operator.operator_name)
|
|
|
|
try:
|
|
retval = mesh_operator(**operator.operator_parameters)
|
|
except AttributeError:
|
|
raise AttributeError("bpy.ops.mesh has no attribute {}".format(operator.operator_name))
|
|
except TypeError as ex:
|
|
raise TypeError("Incorrect operator parameters {!r} raised {!r}".format(operator.operator_parameters, ex))
|
|
|
|
if retval != {'FINISHED'}:
|
|
raise RuntimeError("Unexpected operator return value: {}".format(operator.operator_name))
|
|
if self.verbose:
|
|
print("Applied {}".format(operator))
|
|
|
|
bpy.ops.object.mode_set(mode='OBJECT')
|
|
|
|
def _apply_operator_object_mode(self, operator: OperatorSpecObjectMode):
|
|
"""
|
|
Applies the object operator.
|
|
"""
|
|
bpy.ops.object.mode_set(mode='OBJECT')
|
|
object_operator = getattr(bpy.ops.object, operator.operator_name)
|
|
|
|
try:
|
|
retval = object_operator(**operator.operator_parameters)
|
|
except AttributeError:
|
|
raise AttributeError("bpy.ops.object has no attribute {}".format(operator.operator_name))
|
|
except TypeError as ex:
|
|
raise TypeError("Incorrect operator parameters {!r} raised {!r}".format(operator.operator_parameters, ex))
|
|
|
|
if retval != {'FINISHED'}:
|
|
raise RuntimeError("Unexpected operator return value: {}".format(retval))
|
|
if self.verbose:
|
|
print("Applied operator {}".format(operator))
|
|
|
|
def _apply_deform_modifier(self, test_object, operation: list):
|
|
"""
|
|
arg: operation: list: List of modifiers or combination of modifier and object operator.
|
|
"""
|
|
|
|
scene = bpy.context.scene
|
|
scene.frame_set(1)
|
|
bpy.ops.object.mode_set(mode='OBJECT')
|
|
modifier_operations_list = operation.modifier_list
|
|
modifier_names = []
|
|
object_operations = operation.object_operator_spec
|
|
for modifier_operations in modifier_operations_list:
|
|
if isinstance(modifier_operations, ModifierSpec):
|
|
self._add_modifier(test_object, modifier_operations)
|
|
modifier_names.append(modifier_operations.modifier_name)
|
|
|
|
if isinstance(object_operations, OperatorSpecObjectMode):
|
|
self._apply_operator_object_mode(object_operations)
|
|
|
|
scene.frame_set(operation.frame_number)
|
|
|
|
if self.apply_modifier:
|
|
for mod_name in modifier_names:
|
|
self._apply_modifier(test_object, mod_name)
|
|
|
|
|
|
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.
|
|
"""
|
|
|
|
def apply_operations(self, evaluated_test_object_name):
|
|
|
|
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 GeoNodesSimulationTest(MeshTest):
|
|
"""
|
|
A mesh test that works similar to BlendFileTest but evaluates the scene at multiple
|
|
frames so that simulations can run.
|
|
"""
|
|
|
|
def __init__(self, test_object_name, exp_object_name, *, frames_num, **kwargs):
|
|
super().__init__(test_object_name, exp_object_name, **kwargs)
|
|
self.frames_num = frames_num
|
|
|
|
def apply_operations(self, evaluated_test_object_name):
|
|
GeoNodesSimulationTest.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("The object has no modifiers.")
|
|
|
|
scene = bpy.context.scene
|
|
for frame in range(1, self.frames_num + 1):
|
|
scene.frame_set(frame)
|
|
|
|
for modifier in modifiers_list:
|
|
bpy.ops.object.modifier_apply(modifier=modifier.name)
|
|
|
|
|
|
class RunTest:
|
|
"""
|
|
Helper class that stores and executes SpecMeshTest tests.
|
|
|
|
Example usage:
|
|
|
|
>>> modifier_list = [
|
|
>>> ModifierSpec("firstSUBSURF", "SUBSURF", {"quality": 5}),
|
|
>>> ModifierSpec("firstSOLIDIFY", "SOLIDIFY", {"thickness_clamp": 0.9, "thickness": 1})
|
|
>>> ]
|
|
>>> operator_list = [
|
|
>>> OperatorSpecEditMode("delete_edgeloop", {}, "EDGE", MONKEY_LOOP_EDGE),
|
|
>>> ]
|
|
>>> tests = [
|
|
>>> 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()
|
|
"""
|
|
|
|
def __init__(self, tests, apply_modifiers=False, do_compare=False):
|
|
"""
|
|
Construct a test suite.
|
|
|
|
:arg tests: list - list of modifier or operator test cases. Each element in the list must contain the
|
|
following in the correct order:
|
|
0) test_name: str - unique test name
|
|
1) test_object_name: bpy.Types.Object - test object
|
|
2) expected_object_name: bpy.Types.Object - expected object
|
|
3) modifiers or operators: list - list of mesh_test.ModifierSpec objects or
|
|
mesh_test.OperatorSpecEditMode objects
|
|
"""
|
|
self.tests = tests
|
|
self._ensure_unique_test_name_or_raise_error()
|
|
self.apply_modifiers = apply_modifiers
|
|
self.do_compare = do_compare
|
|
self.verbose = os.environ.get("BLENDER_VERBOSE") is not None
|
|
self._failed_tests_list = []
|
|
|
|
def _ensure_unique_test_name_or_raise_error(self):
|
|
"""
|
|
Check if the test name is unique else raise an error.
|
|
"""
|
|
all_test_names = []
|
|
for each_test in self.tests:
|
|
test_name = each_test.test_name
|
|
all_test_names.append(test_name)
|
|
|
|
seen_name = set()
|
|
for ele in all_test_names:
|
|
if ele in seen_name:
|
|
raise ValueError("{} is a duplicate, write a new unique name.".format(ele))
|
|
else:
|
|
seen_name.add(ele)
|
|
|
|
def run_all_tests(self):
|
|
"""
|
|
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
|
|
if self.verbose:
|
|
print()
|
|
print("Running test {}/{}: {}...".format(test_number + 1, len(self.tests), test_name))
|
|
success = self.run_test(test_name)
|
|
|
|
if not success:
|
|
self._failed_tests_list.append(test_name)
|
|
|
|
if len(self._failed_tests_list) != 0:
|
|
print("\nFollowing tests failed: {}".format(self._failed_tests_list))
|
|
|
|
blender_path = bpy.app.binary_path
|
|
blend_path = bpy.data.filepath
|
|
frame = inspect.stack()[1]
|
|
module = inspect.getmodule(frame[0])
|
|
python_path = module.__file__
|
|
|
|
print("Run following command to open Blender and run the failing test:")
|
|
print("{} {} --python {} -- {} {}"
|
|
.format(blender_path, blend_path, python_path, "--run-test", "<test_name>"))
|
|
|
|
raise Exception("Tests {} failed".format(self._failed_tests_list))
|
|
|
|
def run_test(self, test_name: str):
|
|
"""
|
|
Run a single test from self.tests list.
|
|
|
|
:arg test_name: int - name of test
|
|
:return: bool - True if test passed, False otherwise.
|
|
"""
|
|
case = None
|
|
for index, each_test in enumerate(self.tests):
|
|
if test_name == each_test.test_name:
|
|
case = self.tests[index]
|
|
break
|
|
|
|
if case is None:
|
|
raise Exception('No test called {} found!'.format(test_name))
|
|
|
|
test = case
|
|
test.apply_modifier = self.apply_modifiers
|
|
test.do_compare = self.do_compare
|
|
|
|
success = test.run_test()
|
|
return success
|