430 lines
17 KiB
Python
430 lines
17 KiB
Python
#!/usr/bin/env python3
|
|
# SPDX-FileCopyrightText: 2015-2022 Blender Authors
|
|
#
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
|
|
import argparse
|
|
import os
|
|
import pathlib
|
|
import subprocess
|
|
import sys
|
|
from pathlib import Path
|
|
try:
|
|
# Render report is not always available and leads to errors in the console logs that can be ignored.
|
|
from modules import render_report
|
|
|
|
class EEVEEReport(render_report.Report):
|
|
def __init__(self, title, output_dir, oiiotool, variation=None, blocklist=[]):
|
|
super().__init__(title, output_dir, oiiotool, variation=variation, blocklist=blocklist)
|
|
self.gpu_backend = variation
|
|
|
|
def _get_render_arguments(self, arguments_cb, filepath, base_output_filepath):
|
|
return arguments_cb(filepath, base_output_filepath, gpu_backend=self.gpu_backend)
|
|
|
|
except ImportError:
|
|
# render_report can only be loaded when running the render tests. It errors when
|
|
# this script is run during preparation steps.
|
|
pass
|
|
|
|
# List of .blend files that are known to be failing and are not ready to be
|
|
# tested, or that only make sense on some devices. Accepts regular expressions.
|
|
BLOCKLIST = [
|
|
# Blocked due to point cloud volume differences between platforms (to be fixed).
|
|
"points_volume.blend",
|
|
# Blocked due to GBuffer encoding of small IOR difference between platforms (to be fixed).
|
|
"principled_bsdf_thinfilm_transmission.blend",
|
|
"ray_offset.blend",
|
|
# Blocked due to difference in border texel handling between platforms (to be fixed).
|
|
"render_passes_thinfilm_color.blend",
|
|
# Blocked due to a significant amount of transparency that have a different nosie pattern between devices.
|
|
"light_path_is_shadow_ray.blend",
|
|
# Blocked as the test seems to alternate between two different states
|
|
"light_path_is_diffuse_ray.blend",
|
|
# Blocked due to platform-dependent noise differences (likely floating-point/fast-math differences).
|
|
"raycast_bump.blend",
|
|
# Blocked due to platform-dependent uninitialized pixels.
|
|
"image_mapping_udim.blend",
|
|
# Redundant with hair_linear_close_up.
|
|
"hair_ribbon_close_up.blend",
|
|
# Redundant with transparent_shadow.
|
|
"transparent_shadow_limit_.*",
|
|
# Redundant with transparent_shadow_hair.
|
|
"transparent_shadow_hair_blur.blend",
|
|
# Unsupported feature. Redundant tests. (except osl_camera_advanced which tests triangular bokeh)
|
|
"osl_camera_advanced_manual_dof.blend",
|
|
"osl_camera_advanced_manual_dof_138188.blend",
|
|
"osl_camera_cubemap.blend",
|
|
"osl_camera_cubemap_auto_derivatives.blend",
|
|
"osl_camera_offset_in_volume.blend",
|
|
"osl_camera_bevel.blend",
|
|
# Extreme texture values interpolate differently on different GPUs.
|
|
"image_log.blend",
|
|
# Exhibit the LTC light leaking issue. To be enabeld back after fixing.
|
|
"light_path_glossy_depth.blend",
|
|
# Exhibit non-deterministic behavior because of tracing outside the spotlight 45° cone.
|
|
"light_path_is_camera_ray.blend",
|
|
# Exhibit non-deterministic (to be fixed).
|
|
"background_scene.blend",
|
|
]
|
|
|
|
BLOCKLIST_METAL = [
|
|
# Blocked due to difference in volume lightprobe bakes (to be fixed).
|
|
"light_path_is_volume_scatter_ray.blend",
|
|
# Blocked due to difference in volume lightprobe bakes(maybe?) (to be fixed).
|
|
"volume_zero_extinction_channel.blend",
|
|
# Blocked due to difference in mipmap interpolation (to be fixed).
|
|
"environment_mirror_ball.blend",
|
|
# Blocked due to difference in mipmap interpolation / anisotropic filtering (to be fixed).
|
|
"image.blend",
|
|
]
|
|
|
|
BLOCKLIST_VULKAN = [
|
|
# Blocked due to UB in the background pixels (to be fixed).
|
|
"lightprobe_planar.blend",
|
|
# Blocked due to texture interpolation differences (to be investigated).
|
|
"principled_blackbody.blend",
|
|
# Blocked due to difference in indirect light (AMD linux) (to be investigated).
|
|
"sss_concave_clamp.blend",
|
|
# Blocked due to difference in screen space tracing (to be investigated).
|
|
"image.blend",
|
|
]
|
|
|
|
BLOCKLIST_OPENGL = [
|
|
]
|
|
|
|
BLOCKLIST_INTEL = [
|
|
]
|
|
|
|
BLOCKLIST_AMD_WINDOWS_VK = [
|
|
# Fails inside driver during XML serialization (See #159880).
|
|
"implicit_volume.blend"
|
|
]
|
|
|
|
# Block list for AMD official driver. On buildbot this driver can fail and the artifacts are likely
|
|
# caused by incorrect index buffer synchronization or vertex shader execution.
|
|
BLOCKLIST_AMD_VK = [
|
|
".*"
|
|
]
|
|
|
|
BLOCKLIST_INTEL_WINDOWS_GL = [
|
|
# Fails sporadically and causes all subsequent volume tests to fail (See #153612).
|
|
"volume_instance.blend"
|
|
]
|
|
|
|
BLOCKLIST_NVIDIA_GL = [
|
|
# Non-deterministic behavior. Unkown reason, the pool size doesn't seem to be exceeded.
|
|
"shadow_min_pool_size.blend",
|
|
]
|
|
|
|
|
|
def setup():
|
|
import bpy
|
|
|
|
for scene in bpy.data.scenes:
|
|
scene.render.engine = 'BLENDER_EEVEE'
|
|
|
|
skip_hair_setup = scene.get("EEVEE_skip_hair_setup", False)
|
|
skip_probes_setup = scene.get("EEVEE_skip_probes_setup", False)
|
|
skip_raytracing_setup = scene.get("EEVEE_skip_raytracing_setup", False)
|
|
skip_shadow_setup = scene.get("EEVEE_skip_shadow_setup", False)
|
|
skip_subsurface_setup = scene.get("EEVEE_skip_subsurface_setup", False)
|
|
|
|
# Enable Eevee features
|
|
eevee = scene.eevee
|
|
|
|
# Overscan of 50 will doesn't offset the final image, and adds more information for screen based ray tracing.
|
|
eevee.use_overscan = True
|
|
eevee.overscan_size = 50.0
|
|
|
|
# Ambient Occlusion Pass
|
|
for view_layer in scene.view_layers:
|
|
view_layer.eevee.ambient_occlusion_distance = 1
|
|
|
|
# Lights
|
|
eevee.light_threshold = 0.001
|
|
|
|
# Hair
|
|
if not skip_hair_setup:
|
|
scene.render.hair_type = 'STRIP'
|
|
|
|
# Shadow
|
|
if not skip_shadow_setup:
|
|
eevee.shadow_step_count = 16
|
|
eevee.shadow_pool_size = '1024'
|
|
|
|
# Volumetric
|
|
eevee.volumetric_tile_size = '2'
|
|
eevee.volumetric_start = 1.0
|
|
eevee.volumetric_end = 50.0
|
|
eevee.volumetric_samples = 128
|
|
eevee.use_volumetric_shadows = True
|
|
eevee.clamp_volume_indirect = 0.0
|
|
|
|
# Motion Blur
|
|
if scene.render.use_motion_blur:
|
|
eevee.motion_blur_steps = 10
|
|
|
|
if not skip_raytracing_setup:
|
|
# Ray-tracing
|
|
eevee.use_raytracing = True
|
|
eevee.ray_tracing_method = 'SCREEN'
|
|
ray_tracing = eevee.ray_tracing_options
|
|
ray_tracing.resolution_scale = "1"
|
|
ray_tracing.screen_trace_quality = 1.0
|
|
ray_tracing.screen_trace_thickness = 1.0
|
|
# Fast GI
|
|
eevee.fast_gi_quality = 0.8
|
|
|
|
# Light-probes
|
|
if not skip_probes_setup:
|
|
eevee.gi_cubemap_resolution = '256'
|
|
|
|
# Light-path intensity
|
|
eevee.direct_light_intensity = 1.0
|
|
eevee.indirect_light_intensity = 1.0
|
|
|
|
for ob in scene.objects:
|
|
if ob.type == 'LIGHT' and not skip_shadow_setup:
|
|
# Set maximum resolution
|
|
ob.data.shadow_maximum_resolution = 0.0
|
|
|
|
# Only include the plane in probes
|
|
if ob.name != 'Plane' and ob.type != 'LIGHT' and not skip_probes_setup:
|
|
ob.hide_probe_volume = True
|
|
ob.hide_probe_sphere = True
|
|
|
|
# Counteract the versioning from legacy EEVEE. Should be changed per file at some point.
|
|
if not skip_subsurface_setup:
|
|
for mat_slot in ob.material_slots:
|
|
if mat_slot.material:
|
|
mat_slot.material.thickness_mode = 'SPHERE'
|
|
|
|
if bpy.data.objects.get('Volume_Probe_Baked') is not None:
|
|
# Some file already have pre existing probe setup with baked data.
|
|
pass
|
|
# Does not work in edit mode
|
|
elif bpy.context.mode == 'OBJECT' and not skip_probes_setup:
|
|
# Simple probe setup
|
|
bpy.ops.object.lightprobe_add(type='SPHERE', location=(0.0, 0.1, 1.0))
|
|
cubemap = bpy.context.selected_objects[0]
|
|
cubemap.scale = (5.0, 5.0, 2.0)
|
|
cubemap.data.falloff = 0.0
|
|
cubemap.data.clip_start = 0.8
|
|
cubemap.data.influence_distance = 1.2
|
|
|
|
bpy.ops.object.lightprobe_add(type='VOLUME', location=(0.0, 0.0, 2.0))
|
|
grid = bpy.context.selected_objects[0]
|
|
grid.scale = (8.0, 4.5, 4.5)
|
|
grid.data.resolution_x = 32
|
|
grid.data.resolution_y = 16
|
|
grid.data.resolution_z = 8
|
|
grid.data.bake_samples = 128
|
|
grid.data.capture_world = True
|
|
grid.data.surfel_density = 100
|
|
# Make lighting smoother for most of the case.
|
|
grid.data.dilation_threshold = 1.0
|
|
bpy.ops.object.lightprobe_cache_bake(subset='ACTIVE')
|
|
|
|
|
|
# When run from inside Blender, render and exit.
|
|
try:
|
|
import bpy
|
|
inside_blender = True
|
|
except ImportError:
|
|
inside_blender = False
|
|
|
|
if inside_blender:
|
|
try:
|
|
setup()
|
|
except Exception as e:
|
|
print(e)
|
|
sys.exit(1)
|
|
|
|
|
|
def get_arguments(filepath, output_filepath, gpu_backend):
|
|
arguments = [
|
|
"--background",
|
|
"--factory-startup",
|
|
"--enable-autoexec",
|
|
"--debug-memory",
|
|
"--console-crash-handler",
|
|
"--debug-exit-on-error"]
|
|
|
|
if gpu_backend:
|
|
arguments.extend(["--gpu-backend", gpu_backend])
|
|
|
|
arguments.extend([
|
|
filepath,
|
|
"-E", "BLENDER_EEVEE",
|
|
"-P",
|
|
os.path.realpath(__file__),
|
|
"-o", output_filepath,
|
|
"-F", "PNG",
|
|
"-f", "1"])
|
|
|
|
return arguments
|
|
|
|
|
|
def create_argparse():
|
|
parser = argparse.ArgumentParser(
|
|
description="Run test script for each blend file in TESTDIR, comparing the render result with known output."
|
|
)
|
|
parser.add_argument("--blender", required=True)
|
|
parser.add_argument("--testdir", required=True)
|
|
parser.add_argument("--outdir", required=True)
|
|
parser.add_argument("--oiiotool", required=True)
|
|
parser.add_argument('--batch', default=False, action='store_true')
|
|
parser.add_argument('--gpu-backend')
|
|
return parser
|
|
|
|
|
|
def main():
|
|
parser = create_argparse()
|
|
args = parser.parse_args()
|
|
|
|
blocklist = BLOCKLIST
|
|
if args.gpu_backend == "metal":
|
|
blocklist += BLOCKLIST_METAL
|
|
elif args.gpu_backend == "vulkan":
|
|
blocklist += BLOCKLIST_VULKAN
|
|
elif args.gpu_backend == "opengl":
|
|
blocklist += BLOCKLIST_OPENGL
|
|
|
|
gpu_vendor = render_report.get_gpu_device_vendor(args.blender)
|
|
if os.getenv("BLENDER_TEST_IGNORE_VENDOR_BLOCKLIST") is None:
|
|
if gpu_vendor == "INTEL":
|
|
blocklist += BLOCKLIST_INTEL
|
|
if gpu_vendor == "INTEL" and sys.platform == "win32" and args.gpu_backend == "opengl":
|
|
blocklist += BLOCKLIST_INTEL_WINDOWS_GL
|
|
if gpu_vendor == "NVIDIA" and args.gpu_backend == "opengl":
|
|
blocklist += BLOCKLIST_NVIDIA_GL
|
|
if gpu_vendor == "AMD" and sys.platform == "win32" and args.gpu_backend == "vulkan":
|
|
blocklist += BLOCKLIST_AMD_WINDOWS_VK
|
|
if gpu_vendor == "AMD" and args.gpu_backend == "vulkan":
|
|
blocklist += BLOCKLIST_AMD_VK
|
|
|
|
report = EEVEEReport("EEVEE", args.outdir, args.oiiotool, variation=args.gpu_backend, blocklist=blocklist)
|
|
if args.gpu_backend == "vulkan":
|
|
report.set_compare_engine('eevee', 'opengl')
|
|
else:
|
|
report.set_compare_engine('cycles', 'CPU')
|
|
|
|
report.set_pixelated(True)
|
|
report.set_reference_dir("eevee_renders")
|
|
# Default settings are too lose. EEVEE renders have much less noise than a path tracer.
|
|
report.set_fail_percent(0.08)
|
|
report.set_fail_threshold(4.0 / 255.0)
|
|
|
|
test_dir_name = Path(args.testdir).name
|
|
if gpu_vendor == "NVIDIA" and args.gpu_backend == "opengl":
|
|
# References are supposed to be generated on OpenGL Nvidia. Tighten the threshold for this platform.
|
|
report.set_fail_percent(0.049)
|
|
report.set_fail_threshold(2.0 / 255.0)
|
|
# Some different GPU arch have different texture sampling behavior.
|
|
if test_dir_name in {"image_mapping"}:
|
|
report.set_fail_percent(0.08)
|
|
report.set_fail_threshold(4.0 / 255.0)
|
|
elif test_dir_name in {"displacement"}:
|
|
report.set_fail_percent(0.11)
|
|
report.set_fail_threshold(5.0 / 255.0)
|
|
elif test_dir_name in {"texture"}:
|
|
report.set_fail_percent(0.14)
|
|
report.set_fail_threshold(6.0 / 255.0)
|
|
elif test_dir_name.startswith('camera'):
|
|
# camera_stereo_panoramic have some platform specific small differences
|
|
report.set_fail_percent(0.14)
|
|
report.set_fail_threshold(6.0 / 255.0)
|
|
elif test_dir_name.startswith('image_colorspace'):
|
|
# image_log has hot pixels that result in platform differences.
|
|
report.set_fail_percent(0.15)
|
|
elif test_dir_name.startswith('displacement'):
|
|
# Raster difference across hardware (subdiv geometry).
|
|
report.set_fail_percent(0.1)
|
|
report.set_fail_threshold(7.0 / 255.0)
|
|
if args.gpu_backend == "metal":
|
|
# Difference in shadows in true_displacement_image and vector_displacement_tangent.
|
|
report.set_fail_percent(0.21)
|
|
elif gpu_vendor == "AMD":
|
|
# Difference in bump_normal_texture likely caused by different derivatives.
|
|
report.set_fail_percent(0.29)
|
|
elif test_dir_name.startswith('transparency'):
|
|
# Dithered transparency uses platform dependent noise pattern.
|
|
report.set_fail_percent(0.22)
|
|
report.set_fail_threshold(10.0 / 255.0)
|
|
elif test_dir_name.startswith('instancing'):
|
|
# Small pointcloud has platform dependent raster pattern
|
|
report.set_fail_threshold(8.0 / 255.0)
|
|
if args.gpu_backend == "metal":
|
|
report.set_fail_percent(0.33)
|
|
elif test_dir_name.startswith('hair'):
|
|
# hair_close_up has differences of line rasterization on linux.
|
|
if gpu_vendor == "INTEL":
|
|
report.set_fail_percent(0.13)
|
|
elif test_dir_name.startswith('principled_bsdf'):
|
|
# principled_bsdf_thinfilm_metallic has some weird behavior in reflection of
|
|
# black surfaces. to be investigated
|
|
report.set_fail_percent(0.09)
|
|
elif test_dir_name.startswith('integrator'):
|
|
# Noise difference in transparent materials (mostly transparent_spatial_splits)
|
|
report.set_fail_threshold(8.0 / 255.0)
|
|
if gpu_vendor == "INTEL":
|
|
# light_path_is_singular_ray has some fireflies.
|
|
report.set_fail_percent(0.11)
|
|
if args.gpu_backend == "vulkan":
|
|
report.set_fail_threshold(9.0 / 255.0)
|
|
if gpu_vendor == "AMD":
|
|
# light_path_is_singular_ray has some fireflies.
|
|
report.set_fail_threshold(9.0 / 255.0)
|
|
elif test_dir_name.startswith('light_linking'):
|
|
# Noise difference in transparent materials (mostly shadow_link_transparency) and volume
|
|
report.set_fail_threshold(8.0 / 255.0)
|
|
elif test_dir_name.startswith('texture'):
|
|
# Texture sampling and noise function different per platform.
|
|
# Also voronoi_f1 test uses `pow()` which has different precision depending on platform.
|
|
report.set_fail_percent(0.46)
|
|
report.set_fail_threshold(6.0 / 255.0)
|
|
elif test_dir_name.startswith('shader'):
|
|
# normal_mapping_light_leak fireflies.
|
|
# fresnel_layer_weight high values are accumulated differently on different platform.
|
|
report.set_fail_percent(0.2)
|
|
if gpu_vendor == "INTEL":
|
|
# mix_color uses implementation dependent function.
|
|
report.set_fail_percent(0.41)
|
|
elif test_dir_name.startswith('render_layer'):
|
|
# Because of aov_transparency noise pattern
|
|
report.set_fail_percent(0.5)
|
|
report.set_fail_threshold(8.0 / 255.0)
|
|
elif test_dir_name.startswith('grease_pencil'):
|
|
# TAA dependent look? To be investigated.
|
|
report.set_fail_percent(0.1)
|
|
report.set_fail_threshold(6.0 / 255.0)
|
|
elif test_dir_name.startswith('raycast') and gpu_vendor == "AMD":
|
|
# Some slight contour differences on AMD
|
|
report.set_fail_percent(0.37)
|
|
report.set_fail_threshold(10.0 / 255.0)
|
|
elif test_dir_name.startswith('pointcloud'):
|
|
# Only because of points_transparent
|
|
report.set_fail_threshold(8.0 / 255.0)
|
|
elif test_dir_name.startswith('motion_blur'):
|
|
# Failure can be subtle, tighten threshold
|
|
report.set_fail_percent(0.04)
|
|
report.set_fail_threshold(2.0 / 255.0)
|
|
if args.gpu_backend == "metal":
|
|
# subd_motion_blur has some differences in bump on M1.
|
|
report.set_fail_percent(0.06)
|
|
if args.gpu_backend == "opengl" and gpu_vendor == "AMD":
|
|
# large_combined_motion has 1 hot pixel difference in rasterization.
|
|
report.set_fail_percent(0.043)
|
|
report.set_fail_threshold(3.0 / 255.0)
|
|
elif test_dir_name.startswith('lightprobe') and args.gpu_backend == "metal":
|
|
# Some shadow difference, to be investigated
|
|
report.set_fail_percent(0.09)
|
|
report.set_fail_threshold(6.0 / 255.0)
|
|
|
|
ok = report.run(args.testdir, args.blender, get_arguments, batch=args.batch)
|
|
sys.exit(not ok)
|
|
|
|
|
|
if not inside_blender and __name__ == "__main__":
|
|
main()
|