Differential D12367 Diff 41308 intern/cycles/render/integrator.cpp

Changeset View

Standalone View

intern/cycles/render/integrator.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines	NODE_DEFINE(Integrator)
SOCKET_INT(max_glossy_bounce, "Max Glossy Bounce", 7);		SOCKET_INT(max_glossy_bounce, "Max Glossy Bounce", 7);
SOCKET_INT(max_transmission_bounce, "Max Transmission Bounce", 7);		SOCKET_INT(max_transmission_bounce, "Max Transmission Bounce", 7);
SOCKET_INT(max_volume_bounce, "Max Volume Bounce", 7);		SOCKET_INT(max_volume_bounce, "Max Volume Bounce", 7);

SOCKET_INT(transparent_min_bounce, "Transparent Min Bounce", 0);		SOCKET_INT(transparent_min_bounce, "Transparent Min Bounce", 0);
SOCKET_INT(transparent_max_bounce, "Transparent Max Bounce", 7);		SOCKET_INT(transparent_max_bounce, "Transparent Max Bounce", 7);

SOCKET_INT(ao_bounces, "AO Bounces", 0);		SOCKET_INT(ao_bounces, "AO Bounces", 0);
		SOCKET_FLOAT(ao_factor, "AO Factor", 0.0f);
		SOCKET_FLOAT(ao_distance, "AO Distance", FLT_MAX);

SOCKET_INT(volume_max_steps, "Volume Max Steps", 1024);		SOCKET_INT(volume_max_steps, "Volume Max Steps", 1024);
SOCKET_FLOAT(volume_step_rate, "Volume Step Rate", 1.0f);		SOCKET_FLOAT(volume_step_rate, "Volume Step Rate", 1.0f);

SOCKET_BOOLEAN(caustics_reflective, "Reflective Caustics", true);		SOCKET_BOOLEAN(caustics_reflective, "Reflective Caustics", true);
SOCKET_BOOLEAN(caustics_refractive, "Refractive Caustics", true);		SOCKET_BOOLEAN(caustics_refractive, "Refractive Caustics", true);
SOCKET_FLOAT(filter_glossy, "Filter Glossy", 0.0f);		SOCKET_FLOAT(filter_glossy, "Filter Glossy", 0.0f);
SOCKET_INT(seed, "Seed", 0);		SOCKET_INT(seed, "Seed", 0);
SOCKET_FLOAT(sample_clamp_direct, "Sample Clamp Direct", 0.0f);		SOCKET_FLOAT(sample_clamp_direct, "Sample Clamp Direct", 0.0f);
SOCKET_FLOAT(sample_clamp_indirect, "Sample Clamp Indirect", 0.0f);		SOCKET_FLOAT(sample_clamp_indirect, "Sample Clamp Indirect", 0.0f);
SOCKET_BOOLEAN(motion_blur, "Motion Blur", false);		SOCKET_BOOLEAN(motion_blur, "Motion Blur", false);

SOCKET_INT(aa_samples, "AA Samples", 0);		SOCKET_INT(aa_samples, "AA Samples", 0);
SOCKET_INT(diffuse_samples, "Diffuse Samples", 1);
SOCKET_INT(glossy_samples, "Glossy Samples", 1);
SOCKET_INT(transmission_samples, "Transmission Samples", 1);
SOCKET_INT(ao_samples, "AO Samples", 1);
SOCKET_INT(mesh_light_samples, "Mesh Light Samples", 1);
SOCKET_INT(subsurface_samples, "Subsurface Samples", 1);
SOCKET_INT(volume_samples, "Volume Samples", 1);
SOCKET_INT(start_sample, "Start Sample", 0);		SOCKET_INT(start_sample, "Start Sample", 0);

		SOCKET_BOOLEAN(use_adaptive_sampling, "Use Adaptive Sampling", false);
SOCKET_FLOAT(adaptive_threshold, "Adaptive Threshold", 0.0f);		SOCKET_FLOAT(adaptive_threshold, "Adaptive Threshold", 0.0f);
SOCKET_INT(adaptive_min_samples, "Adaptive Min Samples", 0);		SOCKET_INT(adaptive_min_samples, "Adaptive Min Samples", 0);

SOCKET_BOOLEAN(sample_all_lights_direct, "Sample All Lights Direct", true);
SOCKET_BOOLEAN(sample_all_lights_indirect, "Sample All Lights Indirect", true);
SOCKET_FLOAT(light_sampling_threshold, "Light Sampling Threshold", 0.05f);		SOCKET_FLOAT(light_sampling_threshold, "Light Sampling Threshold", 0.05f);

static NodeEnum method_enum;
method_enum.insert("path", PATH);
method_enum.insert("branched_path", BRANCHED_PATH);
SOCKET_ENUM(method, "Method", method_enum, PATH);

static NodeEnum sampling_pattern_enum;		static NodeEnum sampling_pattern_enum;
sampling_pattern_enum.insert("sobol", SAMPLING_PATTERN_SOBOL);		sampling_pattern_enum.insert("sobol", SAMPLING_PATTERN_SOBOL);
sampling_pattern_enum.insert("cmj", SAMPLING_PATTERN_CMJ);
sampling_pattern_enum.insert("pmj", SAMPLING_PATTERN_PMJ);		sampling_pattern_enum.insert("pmj", SAMPLING_PATTERN_PMJ);
SOCKET_ENUM(sampling_pattern, "Sampling Pattern", sampling_pattern_enum, SAMPLING_PATTERN_SOBOL);		SOCKET_ENUM(sampling_pattern, "Sampling Pattern", sampling_pattern_enum, SAMPLING_PATTERN_SOBOL);

		static NodeEnum denoiser_type_enum;
		denoiser_type_enum.insert("optix", DENOISER_OPTIX);
		denoiser_type_enum.insert("openimagedenoise", DENOISER_OPENIMAGEDENOISE);

		static NodeEnum denoiser_prefilter_enum;
		denoiser_prefilter_enum.insert("none", DENOISER_PREFILTER_NONE);
		denoiser_prefilter_enum.insert("fast", DENOISER_PREFILTER_FAST);
		denoiser_prefilter_enum.insert("accurate", DENOISER_PREFILTER_ACCURATE);

		/* Construct default parameters, so that they are the source of truth for defaults. */
		const DenoiseParams default_denoise_params;

		SOCKET_BOOLEAN(use_denoise, "Use Denoiser", default_denoise_params.use);
		SOCKET_ENUM(denoiser_type, "Denoiser Type", denoiser_type_enum, default_denoise_params.type);
		SOCKET_INT(denoise_start_sample, "Start Sample to Denoise", default_denoise_params.start_sample);
		SOCKET_BOOLEAN(use_denoise_pass_albedo,
		"Use Albedo Pass for Denoiser",
		default_denoise_params.use_pass_albedo);
		SOCKET_BOOLEAN(use_denoise_pass_normal,
		"Use Normal Pass for Denoiser Denoiser",
		default_denoise_params.use_pass_normal);
		SOCKET_ENUM(denoiser_prefilter,
		"Denoiser Type",
		denoiser_prefilter_enum,
		default_denoise_params.prefilter);

return type;		return type;
}		}

Integrator::Integrator() : Node(get_node_type())		Integrator::Integrator() : Node(get_node_type())
{		{
}		}

Integrator::~Integrator()		Integrator::~Integrator()
{		{
}		}

void Integrator::device_update(Device device, DeviceScene dscene, Scene *scene)		void Integrator::device_update(Device device, DeviceScene dscene, Scene *scene)
{		{
if (!is_modified())		if (!is_modified())
return;		return;

scoped_callback_timer timer([scene](double time) {		scoped_callback_timer timer([scene](double time) {
if (scene->update_stats) {		if (scene->update_stats) {
scene->update_stats->integrator.times.add_entry({"device_update", time});		scene->update_stats->integrator.times.add_entry({"device_update", time});
}		}
});		});

const bool need_update_lut = ao_samples_is_modified() \|\| diffuse_samples_is_modified() \|\|		KernelIntegrator *kintegrator = &dscene->data.integrator;
glossy_samples_is_modified() \|\| max_bounce_is_modified() \|\|
max_transmission_bounce_is_modified() \|\|		/* Adaptive sampling requires PMJ samples.
mesh_light_samples_is_modified() \|\| method_is_modified() \|\|		*
sampling_pattern_is_modified() \|\|		* This also makes detection of sampling pattern a bit more involved: can not rely on the changed
subsurface_samples_is_modified() \|\|		* state of socket, since its value might be different from the effective value used here. So
transmission_samples_is_modified() \|\| volume_samples_is_modified();		* instead compare with previous value in the KernelIntegrator. Only do it if the device was
		* updated once (in which case the `sample_pattern_lut` will be allocated to a non-zero size). */
		const SamplingPattern new_sampling_pattern = (use_adaptive_sampling) ? SAMPLING_PATTERN_PMJ :
		sampling_pattern;

		const bool need_update_lut = max_bounce_is_modified() \|\| max_transmission_bounce_is_modified() \|\|
		dscene->sample_pattern_lut.size() == 0 \|\|
		kintegrator->sampling_pattern != new_sampling_pattern;

if (need_update_lut) {		if (need_update_lut) {
dscene->sample_pattern_lut.tag_realloc();		dscene->sample_pattern_lut.tag_realloc();
}		}

device_free(device, dscene);		device_free(device, dscene);

KernelIntegrator *kintegrator = &dscene->data.integrator;

/* integrator parameters */		/* integrator parameters */
kintegrator->min_bounce = min_bounce + 1;		kintegrator->min_bounce = min_bounce + 1;
kintegrator->max_bounce = max_bounce + 1;		kintegrator->max_bounce = max_bounce + 1;

kintegrator->max_diffuse_bounce = max_diffuse_bounce + 1;		kintegrator->max_diffuse_bounce = max_diffuse_bounce + 1;
kintegrator->max_glossy_bounce = max_glossy_bounce + 1;		kintegrator->max_glossy_bounce = max_glossy_bounce + 1;
kintegrator->max_transmission_bounce = max_transmission_bounce + 1;		kintegrator->max_transmission_bounce = max_transmission_bounce + 1;
kintegrator->max_volume_bounce = max_volume_bounce + 1;		kintegrator->max_volume_bounce = max_volume_bounce + 1;

kintegrator->transparent_min_bounce = transparent_min_bounce + 1;		kintegrator->transparent_min_bounce = transparent_min_bounce + 1;
kintegrator->transparent_max_bounce = transparent_max_bounce + 1;		kintegrator->transparent_max_bounce = transparent_max_bounce + 1;

if (ao_bounces == 0) {		kintegrator->ao_bounces = ao_bounces;
kintegrator->ao_bounces = INT_MAX;		kintegrator->ao_bounces_distance = ao_distance;
}		kintegrator->ao_bounces_factor = ao_factor;
else {
kintegrator->ao_bounces = ao_bounces - 1;
}

/* Transparent Shadows		/* Transparent Shadows
* We only need to enable transparent shadows, if we actually have		* We only need to enable transparent shadows, if we actually have
* transparent shaders in the scene. Otherwise we can disable it		* transparent shaders in the scene. Otherwise we can disable it
* to improve performance a bit. */		* to improve performance a bit. */
kintegrator->transparent_shadows = false;		kintegrator->transparent_shadows = false;
foreach (Shader *shader, scene->shaders) {		foreach (Shader *shader, scene->shaders) {
/* keep this in sync with SD_HAS_TRANSPARENT_SHADOW in shader.cpp */		/* keep this in sync with SD_HAS_TRANSPARENT_SHADOW in shader.cpp */
if ((shader->has_surface_transparent && shader->get_use_transparent_shadow()) \|\|		if ((shader->has_surface_transparent && shader->get_use_transparent_shadow()) \|\|
shader->has_volume) {		shader->has_volume) {
kintegrator->transparent_shadows = true;		kintegrator->transparent_shadows = true;
break;		break;
}		}
}		}

kintegrator->volume_max_steps = volume_max_steps;		kintegrator->volume_max_steps = volume_max_steps;
kintegrator->volume_step_rate = volume_step_rate;		kintegrator->volume_step_rate = volume_step_rate;

kintegrator->caustics_reflective = caustics_reflective;		kintegrator->caustics_reflective = caustics_reflective;
kintegrator->caustics_refractive = caustics_refractive;		kintegrator->caustics_refractive = caustics_refractive;
kintegrator->filter_glossy = (filter_glossy == 0.0f) ? FLT_MAX : 1.0f / filter_glossy;		kintegrator->filter_glossy = (filter_glossy == 0.0f) ? FLT_MAX : 1.0f / filter_glossy;

kintegrator->seed = hash_uint2(seed, 0);		kintegrator->seed = hash_uint2(seed, 0);

kintegrator->use_ambient_occlusion = ((Pass::contains(scene->passes, PASS_AO)) \|\|
dscene->data.background.ao_factor != 0.0f);

kintegrator->sample_clamp_direct = (sample_clamp_direct == 0.0f) ? FLT_MAX :		kintegrator->sample_clamp_direct = (sample_clamp_direct == 0.0f) ? FLT_MAX :
sample_clamp_direct * 3.0f;		sample_clamp_direct * 3.0f;
kintegrator->sample_clamp_indirect = (sample_clamp_indirect == 0.0f) ?		kintegrator->sample_clamp_indirect = (sample_clamp_indirect == 0.0f) ?
FLT_MAX :		FLT_MAX :
sample_clamp_indirect * 3.0f;		sample_clamp_indirect * 3.0f;

kintegrator->branched = (method == BRANCHED_PATH) && device->info.has_branched_path;		kintegrator->sampling_pattern = new_sampling_pattern;
kintegrator->volume_decoupled = device->info.has_volume_decoupled;
kintegrator->diffuse_samples = diffuse_samples;
kintegrator->glossy_samples = glossy_samples;
kintegrator->transmission_samples = transmission_samples;
kintegrator->ao_samples = ao_samples;
kintegrator->mesh_light_samples = mesh_light_samples;
kintegrator->subsurface_samples = subsurface_samples;
kintegrator->volume_samples = volume_samples;
kintegrator->start_sample = start_sample;

if (kintegrator->branched) {
kintegrator->sample_all_lights_direct = sample_all_lights_direct;
kintegrator->sample_all_lights_indirect = sample_all_lights_indirect;
}
else {
kintegrator->sample_all_lights_direct = false;
kintegrator->sample_all_lights_indirect = false;
}

kintegrator->sampling_pattern = sampling_pattern;
kintegrator->aa_samples = aa_samples;
if (aa_samples > 0 && adaptive_min_samples == 0) {
kintegrator->adaptive_min_samples = max(4, (int)sqrtf(aa_samples));
VLOG(1) << "Cycles adaptive sampling: automatic min samples = "
<< kintegrator->adaptive_min_samples;
}
else {
kintegrator->adaptive_min_samples = max(4, adaptive_min_samples);
}

kintegrator->adaptive_step = 4;
kintegrator->adaptive_stop_per_sample = device->info.has_adaptive_stop_per_sample;

/* Adaptive step must be a power of two for bitwise operations to work. */
assert((kintegrator->adaptive_step & (kintegrator->adaptive_step - 1)) == 0);

if (aa_samples > 0 && adaptive_threshold == 0.0f) {
kintegrator->adaptive_threshold = max(0.001f, 1.0f / (float)aa_samples);
VLOG(1) << "Cycles adaptive sampling: automatic threshold = "
<< kintegrator->adaptive_threshold;
}
else {
kintegrator->adaptive_threshold = adaptive_threshold;
}

if (light_sampling_threshold > 0.0f) {		if (light_sampling_threshold > 0.0f) {
kintegrator->light_inv_rr_threshold = 1.0f / light_sampling_threshold;		kintegrator->light_inv_rr_threshold = 1.0f / light_sampling_threshold;
}		}
else {		else {
kintegrator->light_inv_rr_threshold = 0.0f;		kintegrator->light_inv_rr_threshold = 0.0f;
}		}

/* sobol directions table */		/* sobol directions table */
int max_samples = 1;		int max_samples = max_bounce + transparent_max_bounce + 3 + VOLUME_BOUNDS_MAX +

if (kintegrator->branched) {
foreach (Light *light, scene->lights)
max_samples = max(max_samples, light->get_samples());

max_samples = max(max_samples,
max(diffuse_samples, max(glossy_samples, transmission_samples)));
max_samples = max(max_samples, max(ao_samples, max(mesh_light_samples, subsurface_samples)));
max_samples = max(max_samples, volume_samples);
}

uint total_bounces = max_bounce + transparent_max_bounce + 3 + VOLUME_BOUNDS_MAX +
max(BSSRDF_MAX_HITS, BSSRDF_MAX_BOUNCES);		max(BSSRDF_MAX_HITS, BSSRDF_MAX_BOUNCES);

max_samples *= total_bounces;

int dimensions = PRNG_BASE_NUM + max_samples * PRNG_BOUNCE_NUM;		int dimensions = PRNG_BASE_NUM + max_samples * PRNG_BOUNCE_NUM;
dimensions = min(dimensions, SOBOL_MAX_DIMENSIONS);		dimensions = min(dimensions, SOBOL_MAX_DIMENSIONS);

if (need_update_lut) {		if (need_update_lut) {
if (sampling_pattern == SAMPLING_PATTERN_SOBOL) {		if (kintegrator->sampling_pattern == SAMPLING_PATTERN_SOBOL) {
uint directions = dscene->sample_pattern_lut.alloc(SOBOL_BITS dimensions);		uint directions = dscene->sample_pattern_lut.alloc(SOBOL_BITS dimensions);

sobol_generate_direction_vectors((uint(*)[SOBOL_BITS])directions, dimensions);		sobol_generate_direction_vectors((uint(*)[SOBOL_BITS])directions, dimensions);

dscene->sample_pattern_lut.copy_to_device();		dscene->sample_pattern_lut.copy_to_device();
}		}
else {		else {
constexpr int sequence_size = NUM_PMJ_SAMPLES;		constexpr int sequence_size = NUM_PMJ_SAMPLES;
constexpr int num_sequences = NUM_PMJ_PATTERNS;		constexpr int num_sequences = NUM_PMJ_PATTERNS;
float2 directions = (float2 )dscene->sample_pattern_lut.alloc(sequence_size *		float2 directions = (float2 )dscene->sample_pattern_lut.alloc(sequence_size *
num_sequences * 2);		num_sequences * 2);
TaskPool pool;		TaskPool pool;
for (int j = 0; j < num_sequences; ++j) {		for (int j = 0; j < num_sequences; ++j) {
float2 sequence = directions + j sequence_size;		float2 sequence = directions + j sequence_size;
pool.push(		pool.push(
function_bind(&progressive_multi_jitter_02_generate_2D, sequence, sequence_size, j));		function_bind(&progressive_multi_jitter_02_generate_2D, sequence, sequence_size, j));
}		}
pool.wait_work();		pool.wait_work();
dscene->sample_pattern_lut.copy_to_device();		dscene->sample_pattern_lut.copy_to_device();
}		}
}		}

		kintegrator->has_shadow_catcher = scene->has_shadow_catcher();

dscene->sample_pattern_lut.clear_modified();		dscene->sample_pattern_lut.clear_modified();
clear_modified();		clear_modified();
}		}

void Integrator::device_free(Device , DeviceScene dscene, bool force_free)		void Integrator::device_free(Device , DeviceScene dscene, bool force_free)
{		{
dscene->sample_pattern_lut.free_if_need_realloc(force_free);		dscene->sample_pattern_lut.free_if_need_realloc(force_free);
}		}

void Integrator::tag_update(Scene *scene, uint32_t flag)		void Integrator::tag_update(Scene *scene, uint32_t flag)
{		{
if (flag & UPDATE_ALL) {		if (flag & UPDATE_ALL) {
tag_modified();		tag_modified();
}		}

if (flag & (AO_PASS_MODIFIED \| BACKGROUND_AO_MODIFIED)) {		if (flag & AO_PASS_MODIFIED) {
/* tag only the ao_bounces socket as modified so we avoid updating sample_pattern_lut		/* tag only the ao_bounces socket as modified so we avoid updating sample_pattern_lut
* unnecessarily */		* unnecessarily */
tag_ao_bounces_modified();		tag_ao_bounces_modified();
}		}

if ((flag & LIGHT_SAMPLES_MODIFIED) && (method == BRANCHED_PATH)) {
/* the number of light samples may affect the size of the sample_pattern_lut */
tag_sampling_pattern_modified();
}

if (filter_glossy_is_modified()) {		if (filter_glossy_is_modified()) {
foreach (Shader *shader, scene->shaders) {		foreach (Shader *shader, scene->shaders) {
if (shader->has_integrator_dependency) {		if (shader->has_integrator_dependency) {
scene->shader_manager->tag_update(scene, ShaderManager::INTEGRATOR_MODIFIED);		scene->shader_manager->tag_update(scene, ShaderManager::INTEGRATOR_MODIFIED);
break;		break;
}		}
}		}
}		}

if (motion_blur_is_modified()) {		if (motion_blur_is_modified()) {
scene->object_manager->tag_update(scene, ObjectManager::MOTION_BLUR_MODIFIED);		scene->object_manager->tag_update(scene, ObjectManager::MOTION_BLUR_MODIFIED);
scene->camera->tag_modified();		scene->camera->tag_modified();
}		}
}		}

		AdaptiveSampling Integrator::get_adaptive_sampling() const
		{
		AdaptiveSampling adaptive_sampling;

		adaptive_sampling.use = use_adaptive_sampling;

		if (!adaptive_sampling.use) {
		return adaptive_sampling;
		}

		if (aa_samples > 0 && adaptive_min_samples == 0) {
		adaptive_sampling.min_samples = max(4, (int)sqrtf(aa_samples));
		VLOG(1) << "Cycles adaptive sampling: automatic min samples = "
		<< adaptive_sampling.min_samples;
		}
		else {
		adaptive_sampling.min_samples = max(4, adaptive_min_samples);
		}

		adaptive_sampling.adaptive_step = 16;

		DCHECK(is_power_of_two(adaptive_sampling.adaptive_step))
		<< "Adaptive step must be a power of two for bitwise operations to work";

		if (aa_samples > 0 && adaptive_threshold == 0.0f) {
		adaptive_sampling.threshold = max(0.001f, 1.0f / (float)aa_samples);
		VLOG(1) << "Cycles adaptive sampling: automatic threshold = " << adaptive_sampling.threshold;
		}
		else {
		adaptive_sampling.threshold = adaptive_threshold;
		}

		return adaptive_sampling;
		}

		DenoiseParams Integrator::get_denoise_params() const
		{
		DenoiseParams denoise_params;

		denoise_params.use = use_denoise;

		denoise_params.type = denoiser_type;

		denoise_params.start_sample = denoise_start_sample;

		denoise_params.use_pass_albedo = use_denoise_pass_albedo;
		denoise_params.use_pass_normal = use_denoise_pass_normal;

		denoise_params.prefilter = denoiser_prefilter;

		return denoise_params;
		}

CCL_NAMESPACE_END		CCL_NAMESPACE_END