mirror of
https://github.com/blender/blender
synced 2026-09-29 04:37:17 +03:00
e1fa0c2805
Adds the option to use DLSS Ray Reconstruction for viewport denoising in Cycles. For this to work, scheduling is adjusted to continuously reset samples (so that independent frames are rendered), pixel jitter is forced on and the required denoising passes (color, depth, diffuse albedo, specular albedo, normals, roughness, motion vectors, specular motion vectors) are enabled. DLSS expects those inputs in the form of CUDA textures, while Cycles keeps passes in an interleaved buffer layout. The data therefore has to be converted, for which specialized versions of the existing denoising filter kernels are introduced, which read/write directly to temporary CUDA textures that are managed in denoiser_dlss.cpp. The integration of DLSS itself is done in a similar fashion to OptiX: The DLSS SDK is pulled in for the type definitions, but the DLSS implementation is loaded by the NVIDIA driver installed on the system. Pull Request: https://projects.blender.org/blender/blender/pulls/153077
238 lines
9.1 KiB
C++
238 lines
9.1 KiB
C++
/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0 */
|
|
|
|
#include "device/kernel.h"
|
|
|
|
#ifndef __KERNEL_ONEAPI__
|
|
# include "util/log.h"
|
|
#endif
|
|
|
|
CCL_NAMESPACE_BEGIN
|
|
|
|
bool device_kernel_has_shading(DeviceKernel kernel)
|
|
{
|
|
return (kernel == DEVICE_KERNEL_INTEGRATOR_SHADE_BACKGROUND ||
|
|
kernel == DEVICE_KERNEL_INTEGRATOR_SHADE_LIGHT_NEE ||
|
|
kernel == DEVICE_KERNEL_INTEGRATOR_SHADE_LIGHT_FORWARD ||
|
|
kernel == DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE ||
|
|
kernel == DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE_RAYTRACE ||
|
|
kernel == DEVICE_KERNEL_INTEGRATOR_SHADE_VOLUME ||
|
|
kernel == DEVICE_KERNEL_INTEGRATOR_SHADE_VOLUME_RAY_MARCHING ||
|
|
kernel == DEVICE_KERNEL_INTEGRATOR_SHADE_SHADOW ||
|
|
kernel == DEVICE_KERNEL_INTEGRATOR_SHADE_DEDICATED_LIGHT ||
|
|
kernel == DEVICE_KERNEL_SHADER_EVAL_DISPLACE ||
|
|
kernel == DEVICE_KERNEL_SHADER_EVAL_BACKGROUND ||
|
|
kernel == DEVICE_KERNEL_SHADER_EVAL_CURVE_SHADOW_TRANSPARENCY ||
|
|
kernel == DEVICE_KERNEL_SHADER_EVAL_VOLUME_DENSITY);
|
|
}
|
|
|
|
bool device_kernel_has_intersection(DeviceKernel kernel)
|
|
{
|
|
return (kernel == DEVICE_KERNEL_INTEGRATOR_INTERSECT_CLOSEST ||
|
|
kernel == DEVICE_KERNEL_INTEGRATOR_INTERSECT_SHADOW ||
|
|
kernel == DEVICE_KERNEL_INTEGRATOR_INTERSECT_SUBSURFACE ||
|
|
kernel == DEVICE_KERNEL_INTEGRATOR_INTERSECT_VOLUME_STACK ||
|
|
kernel == DEVICE_KERNEL_INTEGRATOR_INTERSECT_DEDICATED_LIGHT ||
|
|
kernel == DEVICE_KERNEL_INTEGRATOR_INTERSECT_MNEE ||
|
|
kernel == DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE_RAYTRACE);
|
|
}
|
|
|
|
bool device_kernel_has_gpu_function(DeviceKernel kernel)
|
|
{
|
|
return !(kernel == DEVICE_KERNEL_INTEGRATOR_MEGAKERNEL ||
|
|
kernel == DEVICE_KERNEL_INTEGRATOR_SHADOW_PATH_MNEE_PENDING);
|
|
}
|
|
|
|
const char *device_kernel_as_string(DeviceKernel kernel)
|
|
{
|
|
switch (kernel) {
|
|
/* Integrator. */
|
|
case DEVICE_KERNEL_INTEGRATOR_INIT_FROM_CAMERA:
|
|
return "integrator_init_from_camera";
|
|
case DEVICE_KERNEL_INTEGRATOR_INIT_FROM_BAKE:
|
|
return "integrator_init_from_bake";
|
|
case DEVICE_KERNEL_INTEGRATOR_INTERSECT_CLOSEST:
|
|
return "integrator_intersect_closest";
|
|
case DEVICE_KERNEL_INTEGRATOR_INTERSECT_SHADOW:
|
|
return "integrator_intersect_shadow";
|
|
case DEVICE_KERNEL_INTEGRATOR_INTERSECT_SUBSURFACE:
|
|
return "integrator_intersect_subsurface";
|
|
case DEVICE_KERNEL_INTEGRATOR_INTERSECT_VOLUME_STACK:
|
|
return "integrator_intersect_volume_stack";
|
|
case DEVICE_KERNEL_INTEGRATOR_INTERSECT_DEDICATED_LIGHT:
|
|
return "integrator_intersect_dedicated_light";
|
|
case DEVICE_KERNEL_INTEGRATOR_INTERSECT_MNEE:
|
|
return "integrator_intersect_mnee";
|
|
case DEVICE_KERNEL_INTEGRATOR_SHADOW_PATH_MNEE_PENDING:
|
|
return "integrator_shadow_path_mnee_pending";
|
|
case DEVICE_KERNEL_INTEGRATOR_SHADE_BACKGROUND:
|
|
return "integrator_shade_background";
|
|
case DEVICE_KERNEL_INTEGRATOR_SHADE_LIGHT_NEE:
|
|
return "integrator_shade_light_nee";
|
|
case DEVICE_KERNEL_INTEGRATOR_SHADE_LIGHT_FORWARD:
|
|
return "integrator_shade_light_forward";
|
|
case DEVICE_KERNEL_INTEGRATOR_SHADE_SHADOW:
|
|
return "integrator_shade_shadow";
|
|
case DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE:
|
|
return "integrator_shade_surface";
|
|
case DEVICE_KERNEL_INTEGRATOR_SHADE_SURFACE_RAYTRACE:
|
|
return "integrator_shade_surface_raytrace";
|
|
case DEVICE_KERNEL_INTEGRATOR_SHADE_VOLUME:
|
|
return "integrator_shade_volume";
|
|
case DEVICE_KERNEL_INTEGRATOR_SHADE_VOLUME_RAY_MARCHING:
|
|
return "integrator_shade_volume_ray_marching";
|
|
case DEVICE_KERNEL_INTEGRATOR_SHADE_DEDICATED_LIGHT:
|
|
return "integrator_shade_dedicated_light";
|
|
case DEVICE_KERNEL_INTEGRATOR_MEGAKERNEL:
|
|
return "integrator_megakernel";
|
|
case DEVICE_KERNEL_INTEGRATOR_QUEUED_PATHS_ARRAY:
|
|
return "integrator_queued_paths_array";
|
|
case DEVICE_KERNEL_INTEGRATOR_QUEUED_SHADOW_PATHS_ARRAY:
|
|
return "integrator_queued_shadow_paths_array";
|
|
case DEVICE_KERNEL_INTEGRATOR_ACTIVE_PATHS_ARRAY:
|
|
return "integrator_active_paths_array";
|
|
case DEVICE_KERNEL_INTEGRATOR_TERMINATED_PATHS_ARRAY:
|
|
return "integrator_terminated_paths_array";
|
|
case DEVICE_KERNEL_INTEGRATOR_SORTED_PATHS_ARRAY:
|
|
return "integrator_sorted_paths_array";
|
|
case DEVICE_KERNEL_INTEGRATOR_SORT_BUCKET_PASS:
|
|
return "integrator_sort_bucket_pass";
|
|
case DEVICE_KERNEL_INTEGRATOR_SORT_WRITE_PASS:
|
|
return "integrator_sort_write_pass";
|
|
case DEVICE_KERNEL_INTEGRATOR_COMPACT_PATHS_ARRAY:
|
|
return "integrator_compact_paths_array";
|
|
case DEVICE_KERNEL_INTEGRATOR_COMPACT_STATES:
|
|
return "integrator_compact_states";
|
|
case DEVICE_KERNEL_INTEGRATOR_TERMINATED_SHADOW_PATHS_ARRAY:
|
|
return "integrator_terminated_shadow_paths_array";
|
|
case DEVICE_KERNEL_INTEGRATOR_COMPACT_SHADOW_PATHS_ARRAY:
|
|
return "integrator_compact_shadow_paths_array";
|
|
case DEVICE_KERNEL_INTEGRATOR_COMPACT_SHADOW_STATES:
|
|
return "integrator_compact_shadow_states";
|
|
case DEVICE_KERNEL_INTEGRATOR_RESET:
|
|
return "integrator_reset";
|
|
case DEVICE_KERNEL_INTEGRATOR_SHADOW_CATCHER_COUNT_POSSIBLE_SPLITS:
|
|
return "integrator_shadow_catcher_count_possible_splits";
|
|
|
|
/* Shader evaluation. */
|
|
case DEVICE_KERNEL_SHADER_EVAL_DISPLACE:
|
|
return "shader_eval_displace";
|
|
case DEVICE_KERNEL_SHADER_EVAL_BACKGROUND:
|
|
return "shader_eval_background";
|
|
case DEVICE_KERNEL_SHADER_EVAL_CURVE_SHADOW_TRANSPARENCY:
|
|
return "shader_eval_curve_shadow_transparency";
|
|
case DEVICE_KERNEL_SHADER_EVAL_VOLUME_DENSITY:
|
|
return "shader_eval_volume_density";
|
|
|
|
/* Film. */
|
|
|
|
#define FILM_CONVERT_KERNEL_AS_STRING(variant, variant_lowercase) \
|
|
case DEVICE_KERNEL_FILM_CONVERT_##variant: \
|
|
return "film_convert_" #variant_lowercase; \
|
|
case DEVICE_KERNEL_FILM_CONVERT_##variant##_HALF_RGBA: \
|
|
return "film_convert_" #variant_lowercase "_half_rgba";
|
|
|
|
FILM_CONVERT_KERNEL_AS_STRING(DEPTH, depth)
|
|
FILM_CONVERT_KERNEL_AS_STRING(MIST, mist)
|
|
FILM_CONVERT_KERNEL_AS_STRING(VOLUME_MAJORANT, volume_majorant)
|
|
FILM_CONVERT_KERNEL_AS_STRING(SAMPLE_COUNT, sample_count)
|
|
FILM_CONVERT_KERNEL_AS_STRING(FLOAT, float)
|
|
FILM_CONVERT_KERNEL_AS_STRING(LIGHT_PATH, light_path)
|
|
FILM_CONVERT_KERNEL_AS_STRING(RGBE, rgbe)
|
|
FILM_CONVERT_KERNEL_AS_STRING(FLOAT3, float3)
|
|
FILM_CONVERT_KERNEL_AS_STRING(MOTION, motion)
|
|
FILM_CONVERT_KERNEL_AS_STRING(CRYPTOMATTE, cryptomatte)
|
|
FILM_CONVERT_KERNEL_AS_STRING(SHADOW_CATCHER, shadow_catcher)
|
|
FILM_CONVERT_KERNEL_AS_STRING(SHADOW_CATCHER_MATTE_WITH_SHADOW,
|
|
shadow_catcher_matte_with_shadow)
|
|
FILM_CONVERT_KERNEL_AS_STRING(COMBINED, combined)
|
|
FILM_CONVERT_KERNEL_AS_STRING(FLOAT4, float4)
|
|
|
|
#undef FILM_CONVERT_KERNEL_AS_STRING
|
|
|
|
/* Adaptive sampling. */
|
|
case DEVICE_KERNEL_ADAPTIVE_SAMPLING_CONVERGENCE_CHECK:
|
|
return "adaptive_sampling_convergence_check";
|
|
case DEVICE_KERNEL_ADAPTIVE_SAMPLING_CONVERGENCE_FILTER_X:
|
|
return "adaptive_sampling_filter_x";
|
|
case DEVICE_KERNEL_ADAPTIVE_SAMPLING_CONVERGENCE_FILTER_Y:
|
|
return "adaptive_sampling_filter_y";
|
|
|
|
/* Denoising. */
|
|
case DEVICE_KERNEL_FILTER_GUIDING_PREPROCESS:
|
|
return "filter_guiding_preprocess";
|
|
case DEVICE_KERNEL_FILTER_GUIDING_PREPROCESS_TO_SURFACE:
|
|
return "filter_guiding_preprocess_to_surface";
|
|
case DEVICE_KERNEL_FILTER_GUIDING_SET_FAKE_ALBEDO:
|
|
return "filter_guiding_set_fake_albedo";
|
|
case DEVICE_KERNEL_FILTER_COLOR_PREPROCESS:
|
|
return "filter_color_preprocess";
|
|
case DEVICE_KERNEL_FILTER_COLOR_PREPROCESS_TO_SURFACE:
|
|
return "filter_color_preprocess_to_surface";
|
|
case DEVICE_KERNEL_FILTER_COLOR_POSTPROCESS:
|
|
return "filter_color_postprocess";
|
|
case DEVICE_KERNEL_FILTER_COLOR_POSTPROCESS_FROM_SURFACE:
|
|
return "filter_color_postprocess_from_surface";
|
|
case DEVICE_KERNEL_FILTER_COLOR_FLIP_Y:
|
|
return "filter_color_flip_y";
|
|
|
|
/* Volume Scattering Probability Guiding. */
|
|
case DEVICE_KERNEL_VOLUME_GUIDING_FILTER_X:
|
|
return "volume_guiding_filter_x";
|
|
case DEVICE_KERNEL_VOLUME_GUIDING_FILTER_Y:
|
|
return "volume_guiding_filter_y";
|
|
|
|
/* Cryptomatte. */
|
|
case DEVICE_KERNEL_CRYPTOMATTE_POSTPROCESS:
|
|
return "cryptomatte_postprocess";
|
|
|
|
/* Generic */
|
|
case DEVICE_KERNEL_PREFIX_SUM:
|
|
return "prefix_sum";
|
|
|
|
case DEVICE_KERNEL_NUM:
|
|
break;
|
|
};
|
|
#ifndef __KERNEL_ONEAPI__
|
|
LOG_FATAL << "Unhandled kernel " << static_cast<int>(kernel) << ", should never happen.";
|
|
#endif
|
|
return "UNKNOWN";
|
|
}
|
|
|
|
#ifndef __KERNEL_ONEAPI__
|
|
std::ostream &operator<<(std::ostream &os, DeviceKernel kernel)
|
|
{
|
|
os << device_kernel_as_string(kernel);
|
|
return os;
|
|
}
|
|
|
|
string device_kernel_mask_as_string(DeviceKernelMask mask)
|
|
{
|
|
string str;
|
|
|
|
for (uint64_t i = 0; i < mask.size(); i++) {
|
|
if (mask.test(i)) {
|
|
if (!str.empty()) {
|
|
str += " ";
|
|
}
|
|
str += device_kernel_as_string((DeviceKernel)i);
|
|
}
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
bool DeviceKernelMask::operator<(const DeviceKernelMask &other) const
|
|
{
|
|
for (size_t i = 0; i < size(); i++) {
|
|
if (test(i) ^ other.test(i)) {
|
|
return other.test(i);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
CCL_NAMESPACE_END
|