forked from bartvdbraak/blender
b20a7e01d0
instead of sobol. So far one doesn't seem to be consistently better or worse than the other for the same number of samples but more testing is needed. The random number generator itself is slower than sobol for most number of samples, except 16, 64, 256, .. because they can be computed faster. This can probably be optimized, but we can do that when/if this actually turns out to be useful. Paper this implementation is based on: http://graphics.pixar.com/library/MultiJitteredSampling/ Also includes some refactoring of RNG code, fixing a Sobol correlation issue with the first BSDF and < 16 samples, skipping some unneeded RNG calls and using a simpler unit square to unit disk function.
186 lines
5.6 KiB
C++
186 lines
5.6 KiB
C++
/*
|
|
* Copyright 2011, Blender Foundation.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "device.h"
|
|
#include "integrator.h"
|
|
#include "light.h"
|
|
#include "scene.h"
|
|
#include "sobol.h"
|
|
|
|
#include "util_foreach.h"
|
|
#include "util_hash.h"
|
|
|
|
CCL_NAMESPACE_BEGIN
|
|
|
|
Integrator::Integrator()
|
|
{
|
|
min_bounce = 2;
|
|
max_bounce = 7;
|
|
|
|
max_diffuse_bounce = max_bounce;
|
|
max_glossy_bounce = max_bounce;
|
|
max_transmission_bounce = max_bounce;
|
|
probalistic_termination = true;
|
|
|
|
transparent_min_bounce = min_bounce;
|
|
transparent_max_bounce = max_bounce;
|
|
transparent_probalistic = true;
|
|
transparent_shadows = false;
|
|
|
|
no_caustics = false;
|
|
filter_glossy = 0.0f;
|
|
seed = 0;
|
|
layer_flag = ~0;
|
|
sample_clamp = 0.0f;
|
|
motion_blur = false;
|
|
|
|
aa_samples = 0;
|
|
diffuse_samples = 1;
|
|
glossy_samples = 1;
|
|
transmission_samples = 1;
|
|
ao_samples = 1;
|
|
mesh_light_samples = 1;
|
|
subsurface_samples = 1;
|
|
progressive = true;
|
|
|
|
sampling_pattern = SAMPLING_PATTERN_SOBOL;
|
|
|
|
need_update = true;
|
|
}
|
|
|
|
Integrator::~Integrator()
|
|
{
|
|
}
|
|
|
|
void Integrator::device_update(Device *device, DeviceScene *dscene, Scene *scene)
|
|
{
|
|
if(!need_update)
|
|
return;
|
|
|
|
device_free(device, dscene);
|
|
|
|
KernelIntegrator *kintegrator = &dscene->data.integrator;
|
|
|
|
/* integrator parameters */
|
|
kintegrator->max_bounce = max_bounce + 1;
|
|
if(probalistic_termination)
|
|
kintegrator->min_bounce = min_bounce + 1;
|
|
else
|
|
kintegrator->min_bounce = kintegrator->max_bounce;
|
|
|
|
kintegrator->max_diffuse_bounce = max_diffuse_bounce + 1;
|
|
kintegrator->max_glossy_bounce = max_glossy_bounce + 1;
|
|
kintegrator->max_transmission_bounce = max_transmission_bounce + 1;
|
|
|
|
kintegrator->transparent_max_bounce = transparent_max_bounce + 1;
|
|
if(transparent_probalistic)
|
|
kintegrator->transparent_min_bounce = transparent_min_bounce + 1;
|
|
else
|
|
kintegrator->transparent_min_bounce = kintegrator->transparent_max_bounce;
|
|
|
|
kintegrator->transparent_shadows = transparent_shadows;
|
|
|
|
kintegrator->no_caustics = no_caustics;
|
|
kintegrator->filter_glossy = (filter_glossy == 0.0f)? FLT_MAX: 1.0f/filter_glossy;
|
|
|
|
kintegrator->seed = hash_int(seed);
|
|
kintegrator->layer_flag = layer_flag << PATH_RAY_LAYER_SHIFT;
|
|
|
|
kintegrator->use_ambient_occlusion =
|
|
((dscene->data.film.pass_flag & PASS_AO) || dscene->data.background.ao_factor != 0.0f);
|
|
|
|
kintegrator->sample_clamp = (sample_clamp == 0.0f)? FLT_MAX: sample_clamp*3.0f;
|
|
|
|
kintegrator->progressive = progressive;
|
|
kintegrator->aa_samples = aa_samples;
|
|
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->sampling_pattern = sampling_pattern;
|
|
|
|
/* sobol directions table */
|
|
int max_samples = 1;
|
|
|
|
if(!progressive) {
|
|
foreach(Light *light, scene->lights)
|
|
max_samples = max(max_samples, light->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_bounce + transparent_max_bounce + 2);
|
|
|
|
int dimensions = PRNG_BASE_NUM + max_samples*PRNG_BOUNCE_NUM;
|
|
dimensions = min(dimensions, SOBOL_MAX_DIMENSIONS);
|
|
|
|
uint *directions = dscene->sobol_directions.resize(SOBOL_BITS*dimensions);
|
|
|
|
sobol_generate_direction_vectors((uint(*)[SOBOL_BITS])directions, dimensions);
|
|
|
|
device->tex_alloc("__sobol_directions", dscene->sobol_directions);
|
|
|
|
need_update = false;
|
|
}
|
|
|
|
void Integrator::device_free(Device *device, DeviceScene *dscene)
|
|
{
|
|
device->tex_free(dscene->sobol_directions);
|
|
dscene->sobol_directions.clear();
|
|
}
|
|
|
|
bool Integrator::modified(const Integrator& integrator)
|
|
{
|
|
return !(min_bounce == integrator.min_bounce &&
|
|
max_bounce == integrator.max_bounce &&
|
|
max_diffuse_bounce == integrator.max_diffuse_bounce &&
|
|
max_glossy_bounce == integrator.max_glossy_bounce &&
|
|
max_transmission_bounce == integrator.max_transmission_bounce &&
|
|
probalistic_termination == integrator.probalistic_termination &&
|
|
transparent_min_bounce == integrator.transparent_min_bounce &&
|
|
transparent_max_bounce == integrator.transparent_max_bounce &&
|
|
transparent_probalistic == integrator.transparent_probalistic &&
|
|
transparent_shadows == integrator.transparent_shadows &&
|
|
no_caustics == integrator.no_caustics &&
|
|
filter_glossy == integrator.filter_glossy &&
|
|
layer_flag == integrator.layer_flag &&
|
|
seed == integrator.seed &&
|
|
sample_clamp == integrator.sample_clamp &&
|
|
progressive == integrator.progressive &&
|
|
aa_samples == integrator.aa_samples &&
|
|
diffuse_samples == integrator.diffuse_samples &&
|
|
glossy_samples == integrator.glossy_samples &&
|
|
transmission_samples == integrator.transmission_samples &&
|
|
ao_samples == integrator.ao_samples &&
|
|
mesh_light_samples == integrator.mesh_light_samples &&
|
|
subsurface_samples == integrator.subsurface_samples &&
|
|
motion_blur == integrator.motion_blur);
|
|
}
|
|
|
|
void Integrator::tag_update(Scene *scene)
|
|
{
|
|
need_update = true;
|
|
}
|
|
|
|
CCL_NAMESPACE_END
|
|
|