feat: Implement weight cutout boundary smoothing for image depth cutout

- Added a new proposal for boundary smoothing in the weight cutout process, differentiating between Split edges and Outline smoothing requirements.
- Introduced a new capability `cutout-boundary-smoothing` to control smoothing strength and default values.
- Updated specifications to define the behavior of boundary-specific smoothing strength and default settings.
- Created tasks to verify the implementation of boundary behavior and asset updates.
- Developed comprehensive tests for depth symmetry and normal scaling to ensure expected behavior and performance.
- Introduced new attributes for normal mapping to facilitate persistent face attributes sharing between depth symmetry and image materials.
- Built a new node group for O Image Depth Symmetry, integrating the new smoothing capabilities and ensuring compatibility with existing workflows.

tools/nodes/groups/shadeless.py

@@ -20,61 +20,46 @@ def build_shadeless_group():
     nodes = group.nodes
     links = group.links
     group_input = nodes.new("NodeGroupInput")
-    group_input.location = (-900.0, -350.0)
     group_output = nodes.new("NodeGroupOutput")
-    group_output.location = (850.0, 100.0)
 
     diffuse = nodes.new("ShaderNodeBsdfDiffuse")
-    diffuse.location = (250.0, -150.0)
     emission = nodes.new("ShaderNodeEmission")
-    emission.location = (250.0, -400.0)
     links.new(group_input.outputs["Color"], diffuse.inputs["Color"])
     links.new(group_input.outputs["Color"], emission.inputs["Color"])
 
     light_path = nodes.new("ShaderNodeLightPath")
-    light_path.location = (-900.0, 150.0)
     bounce_count = nodes.new("ShaderNodeMath")
     bounce_count.operation = "SUBTRACT"
-    bounce_count.location = (-500.0, -50.0)
     links.new(light_path.outputs["Ray Depth"], bounce_count.inputs[0])
     links.new(light_path.outputs["Transmission Depth"], bounce_count.inputs[1])
     refracted = nodes.new("ShaderNodeMath")
     refracted.operation = "SUBTRACT"
     refracted.inputs[0].default_value = 1.0
-    refracted.location = (-250.0, -50.0)
     links.new(bounce_count.outputs[0], refracted.inputs[1])
 
     reflection_limit = nodes.new("ShaderNodeMath")
     reflection_limit.operation = "SUBTRACT"
     reflection_limit.inputs[0].default_value = 2.0
-    reflection_limit.location = (-650.0, 450.0)
     links.new(light_path.outputs["Ray Depth"], reflection_limit.inputs[1])
     camera_reflected = nodes.new("ShaderNodeMath")
     camera_reflected.operation = "MULTIPLY"
-    camera_reflected.location = (-400.0, 400.0)
     links.new(reflection_limit.outputs[0], camera_reflected.inputs[0])
     links.new(light_path.outputs["Is Glossy Ray"], camera_reflected.inputs[1])
     shadow_or_reflect = nodes.new("ShaderNodeMath")
     shadow_or_reflect.operation = "MAXIMUM"
-    shadow_or_reflect.location = (-100.0, 350.0)
     links.new(camera_reflected.outputs[0], shadow_or_reflect.inputs[0])
     links.new(light_path.outputs["Is Shadow Ray"], shadow_or_reflect.inputs[1])
     shader_factor = nodes.new("ShaderNodeMath")
     shader_factor.operation = "MAXIMUM"
-    shader_factor.location = (150.0, 300.0)
     links.new(shadow_or_reflect.outputs[0], shader_factor.inputs[0])
     links.new(refracted.outputs[0], shader_factor.inputs[1])
 
     mix = nodes.new("ShaderNodeMixShader")
-    mix.location = (550.0, 100.0)
     links.new(shader_factor.outputs[0], mix.inputs["Fac"])
     links.new(diffuse.outputs["BSDF"], mix.inputs[1])
     links.new(emission.outputs["Emission"], mix.inputs[2])
     transparent = nodes.new("ShaderNodeBsdfTransparent")
-    transparent.location = (550.0, -200.0)
     alpha_mix = nodes.new("ShaderNodeMixShader")
-    alpha_mix.location = (850.0, 100.0)
-    group_output.location = (1100.0, 100.0)
     links.new(group_input.outputs["Alpha"], alpha_mix.inputs["Fac"])
     links.new(transparent.outputs["BSDF"], alpha_mix.inputs[1])
     links.new(mix.outputs["Shader"], alpha_mix.inputs[2])