2011-04-27 11:58:34 +00:00
|
|
|
/*
|
2013-08-18 14:16:15 +00:00
|
|
|
* Copyright 2011-2013 Blender Foundation
|
2011-04-27 11:58:34 +00:00
|
|
|
*
|
2013-08-18 14:16:15 +00:00
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
2011-04-27 11:58:34 +00:00
|
|
|
*
|
2013-08-18 14:16:15 +00:00
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
2011-04-27 11:58:34 +00:00
|
|
|
*
|
2013-08-18 14:16:15 +00:00
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
2014-12-25 01:50:24 +00:00
|
|
|
* limitations under the License.
|
2011-04-27 11:58:34 +00:00
|
|
|
*/
|
|
|
|
|
2012-12-01 19:15:05 +00:00
|
|
|
#ifdef __OSL__
|
2016-02-12 17:33:43 +00:00
|
|
|
# include "osl_shader.h"
|
2012-12-01 19:15:05 +00:00
|
|
|
#endif
|
|
|
|
|
2014-03-29 12:03:45 +00:00
|
|
|
#include "kernel_random.h"
|
2014-03-29 12:03:48 +00:00
|
|
|
#include "kernel_projection.h"
|
|
|
|
#include "kernel_montecarlo.h"
|
|
|
|
#include "kernel_differential.h"
|
|
|
|
#include "kernel_camera.h"
|
2014-03-29 12:03:45 +00:00
|
|
|
|
2014-03-29 12:03:48 +00:00
|
|
|
#include "geom/geom.h"
|
2016-07-11 10:28:45 +00:00
|
|
|
#include "bvh/bvh.h"
|
2014-03-29 12:03:45 +00:00
|
|
|
|
Cycles: Render Passes
Currently supported passes:
* Combined, Z, Normal, Object Index, Material Index, Emission, Environment,
Diffuse/Glossy/Transmission x Direct/Indirect/Color
Not supported yet:
* UV, Vector, Mist
Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow,
also for environment importance sampling.
Documentation:
http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
|
|
|
#include "kernel_accumulate.h"
|
2011-04-27 11:58:34 +00:00
|
|
|
#include "kernel_shader.h"
|
|
|
|
#include "kernel_light.h"
|
Cycles: Render Passes
Currently supported passes:
* Combined, Z, Normal, Object Index, Material Index, Emission, Environment,
Diffuse/Glossy/Transmission x Direct/Indirect/Color
Not supported yet:
* UV, Vector, Mist
Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow,
also for environment importance sampling.
Documentation:
http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
|
|
|
#include "kernel_passes.h"
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2013-04-01 20:26:52 +00:00
|
|
|
#ifdef __SUBSURFACE__
|
2016-02-12 17:33:43 +00:00
|
|
|
# include "kernel_subsurface.h"
|
2013-04-01 20:26:52 +00:00
|
|
|
#endif
|
|
|
|
|
2013-12-28 15:56:19 +00:00
|
|
|
#ifdef __VOLUME__
|
2016-02-12 17:33:43 +00:00
|
|
|
# include "kernel_volume.h"
|
2013-12-28 15:56:19 +00:00
|
|
|
#endif
|
|
|
|
|
2013-12-28 19:02:40 +00:00
|
|
|
#include "kernel_path_state.h"
|
2013-12-28 01:56:53 +00:00
|
|
|
#include "kernel_shadow.h"
|
2014-04-04 14:45:49 +00:00
|
|
|
#include "kernel_emission.h"
|
Cycles: OpenCL kernel split
This commit contains all the work related on the AMD megakernel split work
which was mainly done by Varun Sundar, George Kyriazis and Lenny Wang, plus
some help from Sergey Sharybin, Martijn Berger, Thomas Dinges and likely
someone else which we're forgetting to mention.
Currently only AMD cards are enabled for the new split kernel, but it is
possible to force split opencl kernel to be used by setting the following
environment variable: CYCLES_OPENCL_SPLIT_KERNEL_TEST=1.
Not all the features are supported yet, and that being said no motion blur,
camera blur, SSS and volumetrics for now. Also transparent shadows are
disabled on AMD device because of some compiler bug.
This kernel is also only implements regular path tracing and supporting
branched one will take a bit. Branched path tracing is exposed to the
interface still, which is a bit misleading and will be hidden there soon.
More feature will be enabled once they're ported to the split kernel and
tested.
Neither regular CPU nor CUDA has any difference, they're generating the
same exact code, which means no regressions/improvements there.
Based on the research paper:
https://research.nvidia.com/sites/default/files/publications/laine2013hpg_paper.pdf
Here's the documentation:
https://docs.google.com/document/d/1LuXW-CV-sVJkQaEGZlMJ86jZ8FmoPfecaMdR-oiWbUY/edit
Design discussion of the patch:
https://developer.blender.org/T44197
Differential Revision: https://developer.blender.org/D1200
2015-05-09 14:34:30 +00:00
|
|
|
#include "kernel_path_common.h"
|
2014-04-04 12:35:30 +00:00
|
|
|
#include "kernel_path_surface.h"
|
|
|
|
#include "kernel_path_volume.h"
|
2011-09-12 13:13:56 +00:00
|
|
|
|
2014-10-04 13:00:26 +00:00
|
|
|
#ifdef __KERNEL_DEBUG__
|
2016-02-12 17:33:43 +00:00
|
|
|
# include "kernel_debug.h"
|
2014-10-04 13:00:26 +00:00
|
|
|
#endif
|
|
|
|
|
2013-12-28 01:56:53 +00:00
|
|
|
CCL_NAMESPACE_BEGIN
|
Cycles: Render Passes
Currently supported passes:
* Combined, Z, Normal, Object Index, Material Index, Emission, Environment,
Diffuse/Glossy/Transmission x Direct/Indirect/Color
Not supported yet:
* UV, Vector, Mist
Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow,
also for environment importance sampling.
Documentation:
http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
|
|
|
|
2016-10-30 23:40:05 +00:00
|
|
|
ccl_device_noinline void kernel_path_ao(KernelGlobals *kg,
|
|
|
|
ShaderData *sd,
|
|
|
|
ShaderData *emission_sd,
|
|
|
|
PathRadiance *L,
|
|
|
|
PathState *state,
|
|
|
|
RNG *rng,
|
|
|
|
float3 throughput,
|
|
|
|
float3 ao_alpha)
|
|
|
|
{
|
|
|
|
/* todo: solve correlation */
|
|
|
|
float bsdf_u, bsdf_v;
|
|
|
|
|
|
|
|
path_state_rng_2D(kg, rng, state, PRNG_BSDF_U, &bsdf_u, &bsdf_v);
|
|
|
|
|
|
|
|
float ao_factor = kernel_data.background.ao_factor;
|
|
|
|
float3 ao_N;
|
|
|
|
float3 ao_bsdf = shader_bsdf_ao(kg, sd, ao_factor, &ao_N);
|
|
|
|
float3 ao_D;
|
|
|
|
float ao_pdf;
|
|
|
|
|
|
|
|
sample_cos_hemisphere(ao_N, bsdf_u, bsdf_v, &ao_D, &ao_pdf);
|
|
|
|
|
|
|
|
if(dot(ccl_fetch(sd, Ng), ao_D) > 0.0f && ao_pdf != 0.0f) {
|
|
|
|
Ray light_ray;
|
|
|
|
float3 ao_shadow;
|
|
|
|
|
|
|
|
light_ray.P = ray_offset(ccl_fetch(sd, P), ccl_fetch(sd, Ng));
|
|
|
|
light_ray.D = ao_D;
|
|
|
|
light_ray.t = kernel_data.background.ao_distance;
|
|
|
|
#ifdef __OBJECT_MOTION__
|
|
|
|
light_ray.time = ccl_fetch(sd, time);
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __OBJECT_MOTION__ */
|
2016-10-30 23:40:05 +00:00
|
|
|
light_ray.dP = ccl_fetch(sd, dP);
|
|
|
|
light_ray.dD = differential3_zero();
|
|
|
|
|
|
|
|
if(!shadow_blocked(kg, emission_sd, state, &light_ray, &ao_shadow)) {
|
|
|
|
path_radiance_accum_ao(L, throughput, ao_alpha, ao_bsdf, ao_shadow, state->bounce);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-22 10:48:33 +00:00
|
|
|
ccl_device void kernel_path_indirect(KernelGlobals *kg,
|
2016-05-24 20:28:03 +00:00
|
|
|
ShaderData *sd,
|
2016-05-22 20:35:47 +00:00
|
|
|
ShaderData *emission_sd,
|
2015-11-22 10:48:33 +00:00
|
|
|
RNG *rng,
|
|
|
|
Ray *ray,
|
|
|
|
float3 throughput,
|
|
|
|
int num_samples,
|
|
|
|
PathState *state,
|
|
|
|
PathRadiance *L)
|
2013-08-24 15:02:08 +00:00
|
|
|
{
|
2011-04-27 11:58:34 +00:00
|
|
|
/* path iteration */
|
2014-01-03 01:48:48 +00:00
|
|
|
for(;;) {
|
2011-04-27 11:58:34 +00:00
|
|
|
/* intersect scene */
|
|
|
|
Intersection isect;
|
2015-11-22 10:48:33 +00:00
|
|
|
uint visibility = path_state_ray_visibility(kg, state);
|
|
|
|
bool hit = scene_intersect(kg,
|
2016-10-02 12:48:39 +00:00
|
|
|
*ray,
|
2015-11-22 10:48:33 +00:00
|
|
|
visibility,
|
|
|
|
&isect,
|
|
|
|
NULL,
|
|
|
|
0.0f, 0.0f);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2013-01-09 21:09:20 +00:00
|
|
|
#ifdef __LAMP_MIS__
|
2015-11-22 10:48:33 +00:00
|
|
|
if(kernel_data.integrator.use_lamp_mis && !(state->flag & PATH_RAY_CAMERA)) {
|
2013-01-09 21:09:20 +00:00
|
|
|
/* ray starting from previous non-transparent bounce */
|
|
|
|
Ray light_ray;
|
|
|
|
|
2015-11-22 10:48:33 +00:00
|
|
|
light_ray.P = ray->P - state->ray_t*ray->D;
|
|
|
|
state->ray_t += isect.t;
|
|
|
|
light_ray.D = ray->D;
|
|
|
|
light_ray.t = state->ray_t;
|
|
|
|
light_ray.time = ray->time;
|
|
|
|
light_ray.dD = ray->dD;
|
|
|
|
light_ray.dP = ray->dP;
|
2013-01-09 21:09:20 +00:00
|
|
|
|
|
|
|
/* intersect with lamp */
|
|
|
|
float3 emission;
|
2016-05-22 20:35:47 +00:00
|
|
|
if(indirect_lamp_emission(kg, emission_sd, state, &light_ray, &emission)) {
|
2015-11-22 10:48:33 +00:00
|
|
|
path_radiance_accum_emission(L,
|
|
|
|
throughput,
|
|
|
|
emission,
|
|
|
|
state->bounce);
|
|
|
|
}
|
2013-01-09 21:09:20 +00:00
|
|
|
}
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __LAMP_MIS__ */
|
2013-01-09 21:09:20 +00:00
|
|
|
|
2013-12-28 15:56:19 +00:00
|
|
|
#ifdef __VOLUME__
|
2016-09-08 15:07:58 +00:00
|
|
|
/* Sanitize volume stack. */
|
|
|
|
if(!hit) {
|
|
|
|
kernel_volume_clean_stack(kg, state->volume_stack);
|
|
|
|
}
|
2013-12-29 14:49:16 +00:00
|
|
|
/* volume attenuation, emission, scatter */
|
2015-11-22 10:48:33 +00:00
|
|
|
if(state->volume_stack[0].shader != SHADER_NONE) {
|
|
|
|
Ray volume_ray = *ray;
|
2013-12-29 21:19:38 +00:00
|
|
|
volume_ray.t = (hit)? isect.t: FLT_MAX;
|
2013-12-29 14:40:43 +00:00
|
|
|
|
2015-11-22 10:48:33 +00:00
|
|
|
bool heterogeneous =
|
|
|
|
volume_stack_is_heterogeneous(kg,
|
|
|
|
state->volume_stack);
|
2014-08-20 21:15:30 +00:00
|
|
|
|
2016-02-12 17:33:43 +00:00
|
|
|
# ifdef __VOLUME_DECOUPLED__
|
2015-11-22 10:48:33 +00:00
|
|
|
int sampling_method =
|
|
|
|
volume_stack_sampling_method(kg,
|
|
|
|
state->volume_stack);
|
2014-06-07 16:47:14 +00:00
|
|
|
bool decoupled = kernel_volume_use_decoupled(kg, heterogeneous, false, sampling_method);
|
2013-12-29 14:40:43 +00:00
|
|
|
|
2014-04-04 14:45:49 +00:00
|
|
|
if(decoupled) {
|
|
|
|
/* cache steps along volume for repeated sampling */
|
|
|
|
VolumeSegment volume_segment;
|
2014-04-04 12:21:35 +00:00
|
|
|
|
2015-11-22 10:48:33 +00:00
|
|
|
shader_setup_from_volume(kg,
|
2016-05-24 20:28:03 +00:00
|
|
|
sd,
|
2016-01-06 22:38:13 +00:00
|
|
|
&volume_ray);
|
2015-11-22 10:48:33 +00:00
|
|
|
kernel_volume_decoupled_record(kg,
|
|
|
|
state,
|
|
|
|
&volume_ray,
|
2016-05-24 20:28:03 +00:00
|
|
|
sd,
|
2015-11-22 10:48:33 +00:00
|
|
|
&volume_segment,
|
|
|
|
heterogeneous);
|
|
|
|
|
2014-06-07 16:47:14 +00:00
|
|
|
volume_segment.sampling_method = sampling_method;
|
2014-04-04 14:45:49 +00:00
|
|
|
|
|
|
|
/* emission */
|
2015-11-22 10:48:33 +00:00
|
|
|
if(volume_segment.closure_flag & SD_EMISSION) {
|
|
|
|
path_radiance_accum_emission(L,
|
|
|
|
throughput,
|
|
|
|
volume_segment.accum_emission,
|
|
|
|
state->bounce);
|
|
|
|
}
|
2014-04-04 14:45:49 +00:00
|
|
|
|
|
|
|
/* scattering */
|
|
|
|
VolumeIntegrateResult result = VOLUME_PATH_ATTENUATED;
|
|
|
|
|
|
|
|
if(volume_segment.closure_flag & SD_SCATTER) {
|
2016-02-18 23:39:00 +00:00
|
|
|
int all = kernel_data.integrator.sample_all_lights_indirect;
|
2014-04-04 14:45:49 +00:00
|
|
|
|
|
|
|
/* direct light sampling */
|
2015-11-22 10:48:33 +00:00
|
|
|
kernel_branched_path_volume_connect_light(kg,
|
|
|
|
rng,
|
2016-05-24 20:28:03 +00:00
|
|
|
sd,
|
2016-05-22 20:35:47 +00:00
|
|
|
emission_sd,
|
2015-11-22 10:48:33 +00:00
|
|
|
throughput,
|
|
|
|
state,
|
|
|
|
L,
|
|
|
|
all,
|
|
|
|
&volume_ray,
|
|
|
|
&volume_segment);
|
2014-04-04 14:45:49 +00:00
|
|
|
|
|
|
|
/* indirect sample. if we use distance sampling and take just
|
|
|
|
* one sample for direct and indirect light, we could share
|
|
|
|
* this computation, but makes code a bit complex */
|
2015-11-22 10:48:33 +00:00
|
|
|
float rphase = path_state_rng_1D_for_decision(kg, rng, state, PRNG_PHASE);
|
|
|
|
float rscatter = path_state_rng_1D_for_decision(kg, rng, state, PRNG_SCATTER_DISTANCE);
|
2014-04-04 14:45:49 +00:00
|
|
|
|
|
|
|
result = kernel_volume_decoupled_scatter(kg,
|
2015-11-22 10:48:33 +00:00
|
|
|
state,
|
|
|
|
&volume_ray,
|
2016-05-24 20:28:03 +00:00
|
|
|
sd,
|
2015-11-22 10:48:33 +00:00
|
|
|
&throughput,
|
|
|
|
rphase,
|
|
|
|
rscatter,
|
|
|
|
&volume_segment,
|
|
|
|
NULL,
|
|
|
|
true);
|
2014-04-04 14:45:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* free cached steps */
|
|
|
|
kernel_volume_decoupled_free(kg, &volume_segment);
|
|
|
|
|
|
|
|
if(result == VOLUME_PATH_SCATTERED) {
|
2015-11-22 10:48:33 +00:00
|
|
|
if(kernel_path_volume_bounce(kg,
|
|
|
|
rng,
|
2016-05-24 20:28:03 +00:00
|
|
|
sd,
|
2015-11-22 10:48:33 +00:00
|
|
|
&throughput,
|
|
|
|
state,
|
|
|
|
L,
|
|
|
|
ray))
|
|
|
|
{
|
2014-04-04 14:45:49 +00:00
|
|
|
continue;
|
2015-11-22 10:48:33 +00:00
|
|
|
}
|
|
|
|
else {
|
2014-04-04 14:45:49 +00:00
|
|
|
break;
|
2015-11-22 10:48:33 +00:00
|
|
|
}
|
2014-04-04 14:45:49 +00:00
|
|
|
}
|
2015-02-14 19:44:30 +00:00
|
|
|
else {
|
|
|
|
throughput *= volume_segment.accum_transmittance;
|
|
|
|
}
|
2014-04-04 14:45:49 +00:00
|
|
|
}
|
2014-08-20 21:15:30 +00:00
|
|
|
else
|
2016-10-06 12:55:56 +00:00
|
|
|
# endif /* __VOLUME_DECOUPLED__ */
|
2014-08-20 21:15:30 +00:00
|
|
|
{
|
2014-04-04 14:45:49 +00:00
|
|
|
/* integrate along volume segment with distance sampling */
|
|
|
|
VolumeIntegrateResult result = kernel_volume_integrate(
|
2016-05-24 20:28:03 +00:00
|
|
|
kg, state, sd, &volume_ray, L, &throughput, rng, heterogeneous);
|
2014-04-04 14:45:49 +00:00
|
|
|
|
2016-02-12 17:33:43 +00:00
|
|
|
# ifdef __VOLUME_SCATTER__
|
2014-04-04 14:45:49 +00:00
|
|
|
if(result == VOLUME_PATH_SCATTERED) {
|
|
|
|
/* direct lighting */
|
2015-11-22 10:48:33 +00:00
|
|
|
kernel_path_volume_connect_light(kg,
|
|
|
|
rng,
|
2016-05-24 20:28:03 +00:00
|
|
|
sd,
|
2016-05-22 20:35:47 +00:00
|
|
|
emission_sd,
|
2015-11-22 10:48:33 +00:00
|
|
|
throughput,
|
|
|
|
state,
|
|
|
|
L);
|
2014-04-04 14:45:49 +00:00
|
|
|
|
|
|
|
/* indirect light bounce */
|
2015-11-22 10:48:33 +00:00
|
|
|
if(kernel_path_volume_bounce(kg,
|
|
|
|
rng,
|
2016-05-24 20:28:03 +00:00
|
|
|
sd,
|
2015-11-22 10:48:33 +00:00
|
|
|
&throughput,
|
|
|
|
state,
|
|
|
|
L,
|
|
|
|
ray))
|
|
|
|
{
|
2014-04-04 14:45:49 +00:00
|
|
|
continue;
|
2015-11-22 10:48:33 +00:00
|
|
|
}
|
|
|
|
else {
|
2014-04-04 14:45:49 +00:00
|
|
|
break;
|
2015-11-22 10:48:33 +00:00
|
|
|
}
|
2014-04-04 14:45:49 +00:00
|
|
|
}
|
2016-10-06 12:55:56 +00:00
|
|
|
# endif /* __VOLUME_SCATTER__ */
|
2013-12-29 14:40:43 +00:00
|
|
|
}
|
2013-12-28 15:56:19 +00:00
|
|
|
}
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __VOLUME__ */
|
2013-12-28 15:56:19 +00:00
|
|
|
|
2013-01-09 21:09:20 +00:00
|
|
|
if(!hit) {
|
2012-01-26 15:37:33 +00:00
|
|
|
#ifdef __BACKGROUND__
|
Cycles: merging features from tomato branch.
=== BVH build time optimizations ===
* BVH building was multithreaded. Not all building is multithreaded, packing
and the initial bounding/splitting is still single threaded, but recursive
splitting is, which was the main bottleneck.
* Object splitting now uses binning rather than sorting of all elements, using
code from the Embree raytracer from Intel.
http://software.intel.com/en-us/articles/embree-photo-realistic-ray-tracing-kernels/
* Other small changes to avoid allocations, pack memory more tightly, avoid
some unnecessary operations, ...
These optimizations do not work yet when Spatial Splits are enabled, for that
more work is needed. There's also other optimizations still needed, in
particular for the case of many low poly objects, the packing step and node
memory allocation.
BVH raytracing time should remain about the same, but BVH build time should be
significantly reduced, test here show speedup of about 5x to 10x on a dual core
and 5x to 25x on an 8-core machine, depending on the scene.
=== Threads ===
Centralized task scheduler for multithreading, which is basically the
CPU device threading code wrapped into something reusable.
Basic idea is that there is a single TaskScheduler that keeps a pool of threads,
one for each core. Other places in the code can then create a TaskPool that they
can drop Tasks in to be executed by the scheduler, and wait for them to complete
or cancel them early.
=== Normal ====
Added a Normal output to the texture coordinate node. This currently
gives the object space normal, which is the same under object animation.
In the future this might become a "generated" normal so it's also stable for
deforming objects, but for now it's already useful for non-deforming objects.
=== Render Layers ===
Per render layer Samples control, leaving it to 0 will use the common scene
setting.
Environment pass will now render environment even if film is set to transparent.
Exclude Layers" added. Scene layers (all object that influence the render,
directly or indirectly) are shared between all render layers. However sometimes
it's useful to leave out some object influence for a particular render layer.
That's what this option allows you to do.
=== Filter Glossy ===
When using a value higher than 0.0, this will blur glossy reflections after
blurry bounces, to reduce noise at the cost of accuracy. 1.0 is a good
starting value to tweak.
Some light paths have a low probability of being found while contributing much
light to the pixel. As a result these light paths will be found in some pixels
and not in others, causing fireflies. An example of such a difficult path might
be a small light that is causing a small specular highlight on a sharp glossy
material, which we are seeing through a rough glossy material. With path tracing
it is difficult to find the specular highlight, but if we increase the roughness
on the material the highlight gets bigger and softer, and so easier to find.
Often this blurring will be hardly noticeable, because we are seeing it through
a blurry material anyway, but there are also cases where this will lead to a
loss of detail in lighting.
2012-04-28 08:53:59 +00:00
|
|
|
/* sample background shader */
|
2016-05-22 20:35:47 +00:00
|
|
|
float3 L_background = indirect_background(kg, emission_sd, state, ray);
|
2015-11-22 10:48:33 +00:00
|
|
|
path_radiance_accum_background(L,
|
|
|
|
throughput,
|
|
|
|
L_background,
|
|
|
|
state->bounce);
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __BACKGROUND__ */
|
2011-08-28 13:55:59 +00:00
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* setup shading */
|
2015-11-22 10:48:33 +00:00
|
|
|
shader_setup_from_ray(kg,
|
2016-05-24 20:28:03 +00:00
|
|
|
sd,
|
2015-11-22 10:48:33 +00:00
|
|
|
&isect,
|
2016-01-06 22:38:13 +00:00
|
|
|
ray);
|
2015-11-22 10:48:33 +00:00
|
|
|
float rbsdf = path_state_rng_1D_for_decision(kg, rng, state, PRNG_BSDF);
|
Cycles: Add multi-scattering, energy-conserving GGX as an option to the Glossy, Anisotropic and Glass BSDFs
This commit adds a new distribution to the Glossy, Anisotropic and Glass BSDFs that implements the
multiple-scattering microfacet model described in the paper "Multiple-Scattering Microfacet BSDFs with the Smith Model".
Essentially, the improvement is that unlike classical GGX, which only models single scattering and assumes
the contribution of multiple bounces to be zero, this new model performs a random walk on the microsurface until
the ray leaves it again, which ensures perfect energy conservation.
In practise, this means that the "darkening problem" - GGX materials becoming darker with increasing
roughness - is solved in a physically correct and efficient way.
The downside of this model is that it has no (known) analytic expression for evalation. However, it can be
evaluated stochastically, and although the correct PDF isn't known either, the properties of MIS and the
balance heuristic guarantee an unbiased result at the cost of slightly higher noise.
Reviewers: dingto, #cycles, brecht
Reviewed By: dingto, #cycles, brecht
Subscribers: bliblubli, ace_dragon, gregzaal, brecht, harvester, dingto, marcog, swerner, jtheninja, Blendify, nutel
Differential Revision: https://developer.blender.org/D2002
2016-06-23 20:56:43 +00:00
|
|
|
shader_eval_surface(kg, sd, rng, state, rbsdf, state->flag, SHADER_CONTEXT_INDIRECT);
|
2013-09-08 17:20:47 +00:00
|
|
|
#ifdef __BRANCHED_PATH__
|
2016-05-24 20:28:03 +00:00
|
|
|
shader_merge_closures(sd);
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __BRANCHED_PATH__ */
|
2013-06-04 15:41:45 +00:00
|
|
|
|
|
|
|
/* blurring of bsdf after bounces, for rays that have a small likelihood
|
|
|
|
* of following this particular path (diffuse, rough glossy) */
|
|
|
|
if(kernel_data.integrator.filter_glossy != FLT_MAX) {
|
2015-11-22 10:48:33 +00:00
|
|
|
float blur_pdf = kernel_data.integrator.filter_glossy*state->min_ray_pdf;
|
2013-06-04 15:41:45 +00:00
|
|
|
|
|
|
|
if(blur_pdf < 1.0f) {
|
|
|
|
float blur_roughness = sqrtf(1.0f - blur_pdf)*0.5f;
|
2016-05-24 20:28:03 +00:00
|
|
|
shader_bsdf_blur(kg, sd, blur_roughness);
|
2013-06-04 15:41:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
#ifdef __EMISSION__
|
|
|
|
/* emission */
|
2016-05-24 20:28:03 +00:00
|
|
|
if(sd->flag & SD_EMISSION) {
|
2015-11-22 10:48:33 +00:00
|
|
|
float3 emission = indirect_primitive_emission(kg,
|
2016-05-24 20:28:03 +00:00
|
|
|
sd,
|
2015-11-22 10:48:33 +00:00
|
|
|
isect.t,
|
|
|
|
state->flag,
|
|
|
|
state->ray_pdf);
|
|
|
|
path_radiance_accum_emission(L, throughput, emission, state->bounce);
|
Cycles: Render Passes
Currently supported passes:
* Combined, Z, Normal, Object Index, Material Index, Emission, Environment,
Diffuse/Glossy/Transmission x Direct/Indirect/Color
Not supported yet:
* UV, Vector, Mist
Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow,
also for environment importance sampling.
Documentation:
http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
|
|
|
}
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __EMISSION__ */
|
2011-09-01 15:53:36 +00:00
|
|
|
|
|
|
|
/* path termination. this is a strange place to put the termination, it's
|
2012-06-09 17:22:52 +00:00
|
|
|
* mainly due to the mixed in MIS that we use. gives too many unneeded
|
|
|
|
* shader evaluations, only need emission if we are going to terminate */
|
2015-11-22 10:48:33 +00:00
|
|
|
float probability =
|
|
|
|
path_state_terminate_probability(kg,
|
|
|
|
state,
|
|
|
|
throughput*num_samples);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2013-06-07 16:06:22 +00:00
|
|
|
if(probability == 0.0f) {
|
2011-09-01 15:53:36 +00:00
|
|
|
break;
|
2013-06-07 16:06:22 +00:00
|
|
|
}
|
|
|
|
else if(probability != 1.0f) {
|
2015-11-22 10:48:33 +00:00
|
|
|
float terminate = path_state_rng_1D_for_decision(kg, rng, state, PRNG_TERMINATE);
|
2013-06-07 16:06:22 +00:00
|
|
|
|
|
|
|
if(terminate >= probability)
|
|
|
|
break;
|
2011-09-01 15:53:36 +00:00
|
|
|
|
2013-06-07 16:06:22 +00:00
|
|
|
throughput /= probability;
|
|
|
|
}
|
2011-09-01 15:53:36 +00:00
|
|
|
|
2012-02-28 16:45:08 +00:00
|
|
|
#ifdef __AO__
|
|
|
|
/* ambient occlusion */
|
2016-05-24 20:28:03 +00:00
|
|
|
if(kernel_data.integrator.use_ambient_occlusion || (sd->flag & SD_AO)) {
|
2016-10-30 23:40:05 +00:00
|
|
|
kernel_path_ao(kg, sd, emission_sd, L, state, rng, throughput, make_float3(0.0f, 0.0f, 0.0f));
|
2013-08-24 15:02:08 +00:00
|
|
|
}
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __AO__ */
|
2013-08-24 15:02:08 +00:00
|
|
|
|
|
|
|
#ifdef __SUBSURFACE__
|
|
|
|
/* bssrdf scatter to a different location on the same object, replacing
|
|
|
|
* the closures with a diffuse BSDF */
|
2016-05-24 20:28:03 +00:00
|
|
|
if(sd->flag & SD_BSSRDF) {
|
2013-08-24 15:02:08 +00:00
|
|
|
float bssrdf_probability;
|
2016-05-24 20:28:03 +00:00
|
|
|
ShaderClosure *sc = subsurface_scatter_pick_closure(kg, sd, &bssrdf_probability);
|
2013-08-24 15:02:08 +00:00
|
|
|
|
|
|
|
/* modify throughput for picking bssrdf or bsdf */
|
|
|
|
throughput *= bssrdf_probability;
|
|
|
|
|
|
|
|
/* do bssrdf scatter step if we picked a bssrdf closure */
|
|
|
|
if(sc) {
|
2015-11-22 10:48:33 +00:00
|
|
|
uint lcg_state = lcg_state_init(rng, state, 0x68bc21eb);
|
2013-08-24 15:02:08 +00:00
|
|
|
|
2013-10-08 17:07:18 +00:00
|
|
|
float bssrdf_u, bssrdf_v;
|
2015-11-22 10:48:33 +00:00
|
|
|
path_state_rng_2D(kg,
|
|
|
|
rng,
|
|
|
|
state,
|
|
|
|
PRNG_BSDF_U,
|
|
|
|
&bssrdf_u, &bssrdf_v);
|
|
|
|
subsurface_scatter_step(kg,
|
2016-05-24 20:28:03 +00:00
|
|
|
sd,
|
2016-01-06 22:38:13 +00:00
|
|
|
state,
|
2015-11-22 10:48:33 +00:00
|
|
|
state->flag,
|
|
|
|
sc,
|
|
|
|
&lcg_state,
|
|
|
|
bssrdf_u, bssrdf_v,
|
|
|
|
false);
|
2012-02-28 16:45:08 +00:00
|
|
|
}
|
|
|
|
}
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __SUBSURFACE__ */
|
2012-02-28 16:45:08 +00:00
|
|
|
|
2014-01-02 21:05:07 +00:00
|
|
|
#if defined(__EMISSION__) && defined(__BRANCHED_PATH__)
|
2011-09-27 20:37:24 +00:00
|
|
|
if(kernel_data.integrator.use_direct_light) {
|
2016-02-18 23:39:00 +00:00
|
|
|
int all = kernel_data.integrator.sample_all_lights_indirect;
|
2015-11-22 10:48:33 +00:00
|
|
|
kernel_branched_path_surface_connect_light(kg,
|
|
|
|
rng,
|
2016-05-24 20:28:03 +00:00
|
|
|
sd,
|
2016-05-22 20:35:47 +00:00
|
|
|
emission_sd,
|
2015-11-22 10:48:33 +00:00
|
|
|
state,
|
|
|
|
throughput,
|
|
|
|
1.0f,
|
|
|
|
L,
|
|
|
|
all);
|
2012-06-13 11:44:48 +00:00
|
|
|
}
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* defined(__EMISSION__) && defined(__BRANCHED_PATH__) */
|
2013-12-28 15:56:19 +00:00
|
|
|
|
2016-05-24 20:28:03 +00:00
|
|
|
if(!kernel_path_surface_bounce(kg, rng, sd, &throughput, state, L, ray))
|
2013-12-28 15:56:19 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-06-13 11:44:48 +00:00
|
|
|
}
|
|
|
|
|
2014-05-07 14:55:09 +00:00
|
|
|
#ifdef __SUBSURFACE__
|
2016-08-03 13:27:48 +00:00
|
|
|
# ifndef __KERNEL_CUDA__
|
|
|
|
ccl_device
|
|
|
|
# else
|
|
|
|
ccl_device_inline
|
|
|
|
# endif
|
|
|
|
bool kernel_path_subsurface_scatter(
|
2015-11-22 10:48:33 +00:00
|
|
|
KernelGlobals *kg,
|
|
|
|
ShaderData *sd,
|
2016-05-22 20:35:47 +00:00
|
|
|
ShaderData *emission_sd,
|
2015-11-22 10:48:33 +00:00
|
|
|
PathRadiance *L,
|
|
|
|
PathState *state,
|
|
|
|
RNG *rng,
|
|
|
|
Ray *ray,
|
|
|
|
float3 *throughput,
|
|
|
|
SubsurfaceIndirectRays *ss_indirect)
|
2014-05-07 14:55:09 +00:00
|
|
|
{
|
|
|
|
float bssrdf_probability;
|
|
|
|
ShaderClosure *sc = subsurface_scatter_pick_closure(kg, sd, &bssrdf_probability);
|
|
|
|
|
|
|
|
/* modify throughput for picking bssrdf or bsdf */
|
|
|
|
*throughput *= bssrdf_probability;
|
|
|
|
|
|
|
|
/* do bssrdf scatter step if we picked a bssrdf closure */
|
|
|
|
if(sc) {
|
2015-11-28 14:30:35 +00:00
|
|
|
/* We should never have two consecutive BSSRDF bounces,
|
|
|
|
* the second one should be converted to a diffuse BSDF to
|
|
|
|
* avoid this.
|
|
|
|
*/
|
|
|
|
kernel_assert(!ss_indirect->tracing);
|
2014-05-07 14:55:09 +00:00
|
|
|
|
2015-11-28 14:30:35 +00:00
|
|
|
uint lcg_state = lcg_state_init(rng, state, 0x68bc21eb);
|
2015-11-28 10:38:12 +00:00
|
|
|
|
2015-11-22 10:00:29 +00:00
|
|
|
SubsurfaceIntersection ss_isect;
|
2014-05-07 14:55:09 +00:00
|
|
|
float bssrdf_u, bssrdf_v;
|
|
|
|
path_state_rng_2D(kg, rng, state, PRNG_BSDF_U, &bssrdf_u, &bssrdf_v);
|
2015-11-22 10:00:29 +00:00
|
|
|
int num_hits = subsurface_scatter_multi_intersect(kg,
|
|
|
|
&ss_isect,
|
|
|
|
sd,
|
|
|
|
sc,
|
|
|
|
&lcg_state,
|
|
|
|
bssrdf_u, bssrdf_v,
|
|
|
|
false);
|
2016-02-12 17:33:43 +00:00
|
|
|
# ifdef __VOLUME__
|
2015-11-22 10:48:33 +00:00
|
|
|
ss_indirect->need_update_volume_stack =
|
|
|
|
kernel_data.integrator.use_volumes &&
|
|
|
|
ccl_fetch(sd, flag) & SD_OBJECT_INTERSECTS_VOLUME;
|
2016-10-06 12:55:56 +00:00
|
|
|
# endif /* __VOLUME__ */
|
2014-05-07 14:55:09 +00:00
|
|
|
|
|
|
|
/* compute lighting with the BSDF closure */
|
|
|
|
for(int hit = 0; hit < num_hits; hit++) {
|
2015-11-22 10:00:29 +00:00
|
|
|
/* NOTE: We reuse the existing ShaderData, we assume the path
|
|
|
|
* integration loop stops when this function returns true.
|
|
|
|
*/
|
|
|
|
subsurface_scatter_multi_setup(kg,
|
|
|
|
&ss_isect,
|
|
|
|
hit,
|
|
|
|
sd,
|
2016-01-06 22:38:13 +00:00
|
|
|
state,
|
2015-11-22 10:00:29 +00:00
|
|
|
state->flag,
|
|
|
|
sc,
|
|
|
|
false);
|
|
|
|
|
2015-11-28 14:30:35 +00:00
|
|
|
PathState *hit_state = &ss_indirect->state[ss_indirect->num_rays];
|
2015-11-22 10:48:33 +00:00
|
|
|
Ray *hit_ray = &ss_indirect->rays[ss_indirect->num_rays];
|
|
|
|
float3 *hit_tp = &ss_indirect->throughputs[ss_indirect->num_rays];
|
2015-11-28 14:30:35 +00:00
|
|
|
PathRadiance *hit_L = &ss_indirect->L[ss_indirect->num_rays];
|
2015-11-22 10:48:33 +00:00
|
|
|
|
|
|
|
*hit_state = *state;
|
|
|
|
*hit_ray = *ray;
|
|
|
|
*hit_tp = *throughput;
|
2014-05-07 14:55:09 +00:00
|
|
|
|
2015-11-22 10:48:33 +00:00
|
|
|
hit_state->rng_offset += PRNG_BOUNCE_NUM;
|
2014-05-07 14:55:09 +00:00
|
|
|
|
2015-11-28 14:30:35 +00:00
|
|
|
path_radiance_init(hit_L, kernel_data.film.use_light_pass);
|
2015-12-02 10:59:12 +00:00
|
|
|
hit_L->direct_throughput = L->direct_throughput;
|
|
|
|
path_radiance_copy_indirect(hit_L, L);
|
|
|
|
|
2016-05-22 20:35:47 +00:00
|
|
|
kernel_path_surface_connect_light(kg, rng, sd, emission_sd, *hit_tp, state, hit_L);
|
2015-11-22 10:00:29 +00:00
|
|
|
|
2015-11-22 10:48:33 +00:00
|
|
|
if(kernel_path_surface_bounce(kg,
|
|
|
|
rng,
|
|
|
|
sd,
|
|
|
|
hit_tp,
|
|
|
|
hit_state,
|
2015-11-28 14:30:35 +00:00
|
|
|
hit_L,
|
2015-11-22 10:48:33 +00:00
|
|
|
hit_ray))
|
|
|
|
{
|
2016-02-12 17:33:43 +00:00
|
|
|
# ifdef __LAMP_MIS__
|
2015-11-22 10:48:33 +00:00
|
|
|
hit_state->ray_t = 0.0f;
|
2016-10-06 12:55:56 +00:00
|
|
|
# endif /* __LAMP_MIS__ */
|
2015-11-27 12:12:44 +00:00
|
|
|
|
2016-02-12 17:33:43 +00:00
|
|
|
# ifdef __VOLUME__
|
2015-11-28 15:06:44 +00:00
|
|
|
if(ss_indirect->need_update_volume_stack) {
|
|
|
|
Ray volume_ray = *ray;
|
|
|
|
/* Setup ray from previous surface point to the new one. */
|
|
|
|
volume_ray.D = normalize_len(hit_ray->P - volume_ray.P,
|
|
|
|
&volume_ray.t);
|
|
|
|
|
|
|
|
kernel_volume_stack_update_for_subsurface(
|
|
|
|
kg,
|
2016-05-22 20:35:47 +00:00
|
|
|
emission_sd,
|
2015-11-28 15:06:44 +00:00
|
|
|
&volume_ray,
|
|
|
|
hit_state->volume_stack);
|
|
|
|
}
|
2016-10-06 12:55:56 +00:00
|
|
|
# endif /* __VOLUME__ */
|
2015-12-02 10:59:12 +00:00
|
|
|
path_radiance_reset_indirect(L);
|
2015-11-22 10:48:33 +00:00
|
|
|
ss_indirect->num_rays++;
|
2015-11-28 14:30:35 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
path_radiance_accum_sample(L, hit_L, 1);
|
2015-11-22 10:48:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-11-28 14:43:54 +00:00
|
|
|
ccl_device_inline void kernel_path_subsurface_init_indirect(
|
|
|
|
SubsurfaceIndirectRays *ss_indirect)
|
|
|
|
{
|
|
|
|
ss_indirect->tracing = false;
|
|
|
|
ss_indirect->num_rays = 0;
|
|
|
|
}
|
|
|
|
|
2015-11-28 14:30:35 +00:00
|
|
|
ccl_device void kernel_path_subsurface_accum_indirect(
|
|
|
|
SubsurfaceIndirectRays *ss_indirect,
|
|
|
|
PathRadiance *L)
|
|
|
|
{
|
|
|
|
if(ss_indirect->tracing) {
|
|
|
|
path_radiance_sum_indirect(L);
|
|
|
|
path_radiance_accum_sample(&ss_indirect->direct_L, L, 1);
|
|
|
|
if(ss_indirect->num_rays == 0) {
|
|
|
|
*L = ss_indirect->direct_L;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-22 11:08:03 +00:00
|
|
|
ccl_device void kernel_path_subsurface_setup_indirect(
|
2015-11-22 10:48:33 +00:00
|
|
|
KernelGlobals *kg,
|
2015-11-22 11:08:03 +00:00
|
|
|
SubsurfaceIndirectRays *ss_indirect,
|
2015-11-22 10:48:33 +00:00
|
|
|
PathState *state,
|
|
|
|
Ray *ray,
|
2015-11-28 14:30:35 +00:00
|
|
|
PathRadiance *L,
|
2015-11-22 11:08:03 +00:00
|
|
|
float3 *throughput)
|
2015-11-22 10:48:33 +00:00
|
|
|
{
|
2015-11-28 14:30:35 +00:00
|
|
|
if(!ss_indirect->tracing) {
|
|
|
|
ss_indirect->direct_L = *L;
|
|
|
|
}
|
|
|
|
ss_indirect->tracing = true;
|
|
|
|
|
2015-11-22 11:08:03 +00:00
|
|
|
/* Setup state, ray and throughput for indirect SSS rays. */
|
|
|
|
ss_indirect->num_rays--;
|
2015-11-22 10:48:33 +00:00
|
|
|
|
2015-11-22 11:08:03 +00:00
|
|
|
Ray *indirect_ray = &ss_indirect->rays[ss_indirect->num_rays];
|
2015-11-28 14:30:35 +00:00
|
|
|
PathRadiance *indirect_L = &ss_indirect->L[ss_indirect->num_rays];
|
2014-09-18 11:06:05 +00:00
|
|
|
|
2015-11-28 14:30:35 +00:00
|
|
|
*state = ss_indirect->state[ss_indirect->num_rays];
|
2015-11-22 11:08:03 +00:00
|
|
|
*ray = *indirect_ray;
|
2015-11-28 14:30:35 +00:00
|
|
|
*L = *indirect_L;
|
|
|
|
*throughput = ss_indirect->throughputs[ss_indirect->num_rays];
|
2015-11-27 11:41:05 +00:00
|
|
|
|
2015-11-28 14:30:35 +00:00
|
|
|
state->rng_offset += ss_indirect->num_rays * PRNG_BOUNCE_NUM;
|
2014-05-07 14:55:09 +00:00
|
|
|
}
|
2015-11-27 12:12:44 +00:00
|
|
|
|
2015-11-28 14:30:35 +00:00
|
|
|
#endif /* __SUBSURFACE__ */
|
2014-05-07 14:55:09 +00:00
|
|
|
|
2016-01-14 09:53:05 +00:00
|
|
|
ccl_device_inline float4 kernel_path_integrate(KernelGlobals *kg,
|
|
|
|
RNG *rng,
|
|
|
|
int sample,
|
|
|
|
Ray ray,
|
|
|
|
ccl_global float *buffer)
|
2012-06-13 11:44:48 +00:00
|
|
|
{
|
2013-08-24 15:02:08 +00:00
|
|
|
/* initialize */
|
|
|
|
PathRadiance L;
|
|
|
|
float3 throughput = make_float3(1.0f, 1.0f, 1.0f);
|
|
|
|
float L_transparent = 0.0f;
|
|
|
|
|
|
|
|
path_radiance_init(&L, kernel_data.film.use_light_pass);
|
|
|
|
|
2016-05-22 20:35:47 +00:00
|
|
|
/* shader data memory used for both volumes and surfaces, saves stack space */
|
|
|
|
ShaderData sd;
|
|
|
|
/* shader data used by emission, shadows, volume stacks */
|
|
|
|
ShaderData emission_sd;
|
|
|
|
|
2013-08-24 15:02:08 +00:00
|
|
|
PathState state;
|
2016-05-22 20:35:47 +00:00
|
|
|
path_state_init(kg, &emission_sd, &state, rng, sample, &ray);
|
2013-08-24 15:02:08 +00:00
|
|
|
|
2014-10-04 13:00:26 +00:00
|
|
|
#ifdef __KERNEL_DEBUG__
|
|
|
|
DebugData debug_data;
|
|
|
|
debug_data_init(&debug_data);
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __KERNEL_DEBUG__ */
|
2014-10-04 13:00:26 +00:00
|
|
|
|
2015-11-22 10:48:33 +00:00
|
|
|
#ifdef __SUBSURFACE__
|
|
|
|
SubsurfaceIndirectRays ss_indirect;
|
2015-11-28 14:43:54 +00:00
|
|
|
kernel_path_subsurface_init_indirect(&ss_indirect);
|
2015-11-22 11:08:03 +00:00
|
|
|
|
2015-11-27 11:41:05 +00:00
|
|
|
for(;;) {
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __SUBSURFACE__ */
|
2015-11-22 10:48:33 +00:00
|
|
|
|
2012-06-13 11:44:48 +00:00
|
|
|
/* path iteration */
|
2014-01-03 01:48:48 +00:00
|
|
|
for(;;) {
|
2012-06-13 11:44:48 +00:00
|
|
|
/* intersect scene */
|
|
|
|
Intersection isect;
|
|
|
|
uint visibility = path_state_ray_visibility(kg, &state);
|
2013-08-24 15:02:08 +00:00
|
|
|
|
2013-05-09 15:28:38 +00:00
|
|
|
#ifdef __HAIR__
|
2013-08-24 15:02:08 +00:00
|
|
|
float difl = 0.0f, extmax = 0.0f;
|
|
|
|
uint lcg_state = 0;
|
|
|
|
|
|
|
|
if(kernel_data.bvh.have_curves) {
|
|
|
|
if((kernel_data.cam.resolution == 1) && (state.flag & PATH_RAY_CAMERA)) {
|
|
|
|
float3 pixdiff = ray.dD.dx + ray.dD.dy;
|
|
|
|
/*pixdiff = pixdiff - dot(pixdiff, ray.D)*ray.D;*/
|
|
|
|
difl = kernel_data.curve.minimum_width * len(pixdiff) * 0.5f;
|
|
|
|
}
|
|
|
|
|
|
|
|
extmax = kernel_data.curve.maximum_width;
|
2014-01-03 01:48:48 +00:00
|
|
|
lcg_state = lcg_state_init(rng, &state, 0x51633e2d);
|
2013-08-24 15:02:08 +00:00
|
|
|
}
|
|
|
|
|
2016-10-02 12:48:39 +00:00
|
|
|
bool hit = scene_intersect(kg, ray, visibility, &isect, &lcg_state, difl, extmax);
|
2013-05-09 15:28:38 +00:00
|
|
|
#else
|
2016-10-02 12:48:39 +00:00
|
|
|
bool hit = scene_intersect(kg, ray, visibility, &isect, NULL, 0.0f, 0.0f);
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __HAIR__ */
|
2012-06-13 11:44:48 +00:00
|
|
|
|
2014-10-04 13:00:26 +00:00
|
|
|
#ifdef __KERNEL_DEBUG__
|
|
|
|
if(state.flag & PATH_RAY_CAMERA) {
|
|
|
|
debug_data.num_bvh_traversal_steps += isect.num_traversal_steps;
|
2015-06-11 22:12:03 +00:00
|
|
|
debug_data.num_bvh_traversed_instances += isect.num_traversed_instances;
|
2014-10-04 13:00:26 +00:00
|
|
|
}
|
2015-06-11 08:42:38 +00:00
|
|
|
debug_data.num_ray_bounces++;
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __KERNEL_DEBUG__ */
|
2014-10-04 13:00:26 +00:00
|
|
|
|
2013-01-09 21:09:20 +00:00
|
|
|
#ifdef __LAMP_MIS__
|
2013-01-30 15:57:15 +00:00
|
|
|
if(kernel_data.integrator.use_lamp_mis && !(state.flag & PATH_RAY_CAMERA)) {
|
2013-01-09 21:09:20 +00:00
|
|
|
/* ray starting from previous non-transparent bounce */
|
|
|
|
Ray light_ray;
|
|
|
|
|
2014-01-03 01:48:48 +00:00
|
|
|
light_ray.P = ray.P - state.ray_t*ray.D;
|
|
|
|
state.ray_t += isect.t;
|
2013-01-09 21:09:20 +00:00
|
|
|
light_ray.D = ray.D;
|
2014-01-03 01:48:48 +00:00
|
|
|
light_ray.t = state.ray_t;
|
2013-01-09 21:09:20 +00:00
|
|
|
light_ray.time = ray.time;
|
2013-05-03 05:24:05 +00:00
|
|
|
light_ray.dD = ray.dD;
|
|
|
|
light_ray.dP = ray.dP;
|
2013-01-09 21:09:20 +00:00
|
|
|
|
|
|
|
/* intersect with lamp */
|
|
|
|
float3 emission;
|
|
|
|
|
2016-05-22 20:35:47 +00:00
|
|
|
if(indirect_lamp_emission(kg, &emission_sd, &state, &light_ray, &emission))
|
2013-08-24 15:02:08 +00:00
|
|
|
path_radiance_accum_emission(&L, throughput, emission, state.bounce);
|
2013-01-09 21:09:20 +00:00
|
|
|
}
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __LAMP_MIS__ */
|
2013-01-09 21:09:20 +00:00
|
|
|
|
2013-12-28 15:56:19 +00:00
|
|
|
#ifdef __VOLUME__
|
2016-09-08 15:07:58 +00:00
|
|
|
/* Sanitize volume stack. */
|
|
|
|
if(!hit) {
|
|
|
|
kernel_volume_clean_stack(kg, state.volume_stack);
|
|
|
|
}
|
2013-12-29 14:49:16 +00:00
|
|
|
/* volume attenuation, emission, scatter */
|
2014-03-29 12:03:47 +00:00
|
|
|
if(state.volume_stack[0].shader != SHADER_NONE) {
|
2013-12-29 21:19:38 +00:00
|
|
|
Ray volume_ray = ray;
|
|
|
|
volume_ray.t = (hit)? isect.t: FLT_MAX;
|
2013-12-29 14:40:43 +00:00
|
|
|
|
2014-04-04 14:45:49 +00:00
|
|
|
bool heterogeneous = volume_stack_is_heterogeneous(kg, state.volume_stack);
|
2014-08-20 21:15:30 +00:00
|
|
|
|
2016-02-12 17:33:43 +00:00
|
|
|
# ifdef __VOLUME_DECOUPLED__
|
2014-08-24 13:58:41 +00:00
|
|
|
int sampling_method = volume_stack_sampling_method(kg, state.volume_stack);
|
2014-06-07 16:47:14 +00:00
|
|
|
bool decoupled = kernel_volume_use_decoupled(kg, heterogeneous, true, sampling_method);
|
2013-12-29 14:40:43 +00:00
|
|
|
|
2014-04-04 14:45:49 +00:00
|
|
|
if(decoupled) {
|
|
|
|
/* cache steps along volume for repeated sampling */
|
|
|
|
VolumeSegment volume_segment;
|
2014-04-04 12:21:35 +00:00
|
|
|
|
2016-05-22 20:35:47 +00:00
|
|
|
shader_setup_from_volume(kg, &sd, &volume_ray);
|
2014-04-04 14:45:49 +00:00
|
|
|
kernel_volume_decoupled_record(kg, &state,
|
2016-05-22 20:35:47 +00:00
|
|
|
&volume_ray, &sd, &volume_segment, heterogeneous);
|
2014-04-04 14:45:49 +00:00
|
|
|
|
2014-06-07 16:47:14 +00:00
|
|
|
volume_segment.sampling_method = sampling_method;
|
|
|
|
|
2014-04-04 14:45:49 +00:00
|
|
|
/* emission */
|
|
|
|
if(volume_segment.closure_flag & SD_EMISSION)
|
|
|
|
path_radiance_accum_emission(&L, throughput, volume_segment.accum_emission, state.bounce);
|
|
|
|
|
|
|
|
/* scattering */
|
|
|
|
VolumeIntegrateResult result = VOLUME_PATH_ATTENUATED;
|
|
|
|
|
|
|
|
if(volume_segment.closure_flag & SD_SCATTER) {
|
2016-02-18 23:39:00 +00:00
|
|
|
int all = false;
|
2014-04-04 14:45:49 +00:00
|
|
|
|
|
|
|
/* direct light sampling */
|
2016-05-22 20:35:47 +00:00
|
|
|
kernel_branched_path_volume_connect_light(kg, rng, &sd,
|
|
|
|
&emission_sd, throughput, &state, &L, all,
|
|
|
|
&volume_ray, &volume_segment);
|
2014-04-04 14:45:49 +00:00
|
|
|
|
|
|
|
/* indirect sample. if we use distance sampling and take just
|
|
|
|
* one sample for direct and indirect light, we could share
|
|
|
|
* this computation, but makes code a bit complex */
|
|
|
|
float rphase = path_state_rng_1D_for_decision(kg, rng, &state, PRNG_PHASE);
|
|
|
|
float rscatter = path_state_rng_1D_for_decision(kg, rng, &state, PRNG_SCATTER_DISTANCE);
|
|
|
|
|
|
|
|
result = kernel_volume_decoupled_scatter(kg,
|
2016-05-22 20:35:47 +00:00
|
|
|
&state, &volume_ray, &sd, &throughput,
|
2014-04-04 14:45:49 +00:00
|
|
|
rphase, rscatter, &volume_segment, NULL, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* free cached steps */
|
|
|
|
kernel_volume_decoupled_free(kg, &volume_segment);
|
|
|
|
|
|
|
|
if(result == VOLUME_PATH_SCATTERED) {
|
2016-05-22 20:35:47 +00:00
|
|
|
if(kernel_path_volume_bounce(kg, rng, &sd, &throughput, &state, &L, &ray))
|
2014-04-04 14:45:49 +00:00
|
|
|
continue;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
2015-02-14 19:44:30 +00:00
|
|
|
else {
|
|
|
|
throughput *= volume_segment.accum_transmittance;
|
|
|
|
}
|
2014-04-04 14:45:49 +00:00
|
|
|
}
|
2016-02-12 17:33:43 +00:00
|
|
|
else
|
2016-10-06 12:55:56 +00:00
|
|
|
# endif /* __VOLUME_DECOUPLED__ */
|
2014-08-20 21:15:30 +00:00
|
|
|
{
|
2014-04-04 14:45:49 +00:00
|
|
|
/* integrate along volume segment with distance sampling */
|
|
|
|
VolumeIntegrateResult result = kernel_volume_integrate(
|
2016-05-22 20:35:47 +00:00
|
|
|
kg, &state, &sd, &volume_ray, &L, &throughput, rng, heterogeneous);
|
2014-04-04 14:45:49 +00:00
|
|
|
|
2016-02-12 17:33:43 +00:00
|
|
|
# ifdef __VOLUME_SCATTER__
|
2014-04-04 14:45:49 +00:00
|
|
|
if(result == VOLUME_PATH_SCATTERED) {
|
|
|
|
/* direct lighting */
|
2016-05-22 20:35:47 +00:00
|
|
|
kernel_path_volume_connect_light(kg, rng, &sd, &emission_sd, throughput, &state, &L);
|
2014-04-04 14:45:49 +00:00
|
|
|
|
|
|
|
/* indirect light bounce */
|
2016-05-22 20:35:47 +00:00
|
|
|
if(kernel_path_volume_bounce(kg, rng, &sd, &throughput, &state, &L, &ray))
|
2014-04-04 14:45:49 +00:00
|
|
|
continue;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
2016-10-06 12:55:56 +00:00
|
|
|
# endif /* __VOLUME_SCATTER__ */
|
2013-12-29 14:40:43 +00:00
|
|
|
}
|
2013-12-28 15:56:19 +00:00
|
|
|
}
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __VOLUME__ */
|
2013-12-28 15:56:19 +00:00
|
|
|
|
2013-01-09 21:09:20 +00:00
|
|
|
if(!hit) {
|
2013-08-24 15:02:08 +00:00
|
|
|
/* eval background shader if nothing hit */
|
|
|
|
if(kernel_data.background.transparent && (state.flag & PATH_RAY_CAMERA)) {
|
|
|
|
L_transparent += average(throughput);
|
|
|
|
|
|
|
|
#ifdef __PASSES__
|
|
|
|
if(!(kernel_data.film.pass_flag & PASS_BACKGROUND))
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __PASSES__ */
|
2013-08-24 15:02:08 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-06-13 11:44:48 +00:00
|
|
|
#ifdef __BACKGROUND__
|
|
|
|
/* sample background shader */
|
2016-05-22 20:35:47 +00:00
|
|
|
float3 L_background = indirect_background(kg, &emission_sd, &state, &ray);
|
2013-08-24 15:02:08 +00:00
|
|
|
path_radiance_accum_background(&L, throughput, L_background, state.bounce);
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __BACKGROUND__ */
|
2012-06-13 11:44:48 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* setup shading */
|
2016-01-06 22:38:13 +00:00
|
|
|
shader_setup_from_ray(kg, &sd, &isect, &ray);
|
2014-05-29 12:12:12 +00:00
|
|
|
float rbsdf = path_state_rng_1D_for_decision(kg, rng, &state, PRNG_BSDF);
|
Cycles: Add multi-scattering, energy-conserving GGX as an option to the Glossy, Anisotropic and Glass BSDFs
This commit adds a new distribution to the Glossy, Anisotropic and Glass BSDFs that implements the
multiple-scattering microfacet model described in the paper "Multiple-Scattering Microfacet BSDFs with the Smith Model".
Essentially, the improvement is that unlike classical GGX, which only models single scattering and assumes
the contribution of multiple bounces to be zero, this new model performs a random walk on the microsurface until
the ray leaves it again, which ensures perfect energy conservation.
In practise, this means that the "darkening problem" - GGX materials becoming darker with increasing
roughness - is solved in a physically correct and efficient way.
The downside of this model is that it has no (known) analytic expression for evalation. However, it can be
evaluated stochastically, and although the correct PDF isn't known either, the properties of MIS and the
balance heuristic guarantee an unbiased result at the cost of slightly higher noise.
Reviewers: dingto, #cycles, brecht
Reviewed By: dingto, #cycles, brecht
Subscribers: bliblubli, ace_dragon, gregzaal, brecht, harvester, dingto, marcog, swerner, jtheninja, Blendify, nutel
Differential Revision: https://developer.blender.org/D2002
2016-06-23 20:56:43 +00:00
|
|
|
shader_eval_surface(kg, &sd, rng, &state, rbsdf, state.flag, SHADER_CONTEXT_MAIN);
|
2013-08-24 15:02:08 +00:00
|
|
|
|
|
|
|
/* holdout */
|
|
|
|
#ifdef __HOLDOUT__
|
|
|
|
if((sd.flag & (SD_HOLDOUT|SD_HOLDOUT_MASK)) && (state.flag & PATH_RAY_CAMERA)) {
|
|
|
|
if(kernel_data.background.transparent) {
|
|
|
|
float3 holdout_weight;
|
|
|
|
|
|
|
|
if(sd.flag & SD_HOLDOUT_MASK)
|
|
|
|
holdout_weight = make_float3(1.0f, 1.0f, 1.0f);
|
|
|
|
else
|
|
|
|
holdout_weight = shader_holdout_eval(kg, &sd);
|
|
|
|
|
|
|
|
/* any throughput is ok, should all be identical here */
|
|
|
|
L_transparent += average(holdout_weight*throughput);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(sd.flag & SD_HOLDOUT_MASK)
|
|
|
|
break;
|
|
|
|
}
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __HOLDOUT__ */
|
2013-08-24 15:02:08 +00:00
|
|
|
|
|
|
|
/* holdout mask objects do not write data passes */
|
2014-02-06 14:18:34 +00:00
|
|
|
kernel_write_data_passes(kg, buffer, &L, &sd, sample, &state, throughput);
|
2012-06-13 11:44:48 +00:00
|
|
|
|
|
|
|
/* blurring of bsdf after bounces, for rays that have a small likelihood
|
|
|
|
* of following this particular path (diffuse, rough glossy) */
|
|
|
|
if(kernel_data.integrator.filter_glossy != FLT_MAX) {
|
2014-01-03 01:48:48 +00:00
|
|
|
float blur_pdf = kernel_data.integrator.filter_glossy*state.min_ray_pdf;
|
2012-06-13 11:44:48 +00:00
|
|
|
|
|
|
|
if(blur_pdf < 1.0f) {
|
|
|
|
float blur_roughness = sqrtf(1.0f - blur_pdf)*0.5f;
|
|
|
|
shader_bsdf_blur(kg, &sd, blur_roughness);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef __EMISSION__
|
|
|
|
/* emission */
|
|
|
|
if(sd.flag & SD_EMISSION) {
|
2013-08-24 15:02:08 +00:00
|
|
|
/* todo: is isect.t wrong here for transparent surfaces? */
|
2014-01-03 01:48:48 +00:00
|
|
|
float3 emission = indirect_primitive_emission(kg, &sd, isect.t, state.flag, state.ray_pdf);
|
2013-08-24 15:02:08 +00:00
|
|
|
path_radiance_accum_emission(&L, throughput, emission, state.bounce);
|
2012-06-13 11:44:48 +00:00
|
|
|
}
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __EMISSION__ */
|
2012-06-13 11:44:48 +00:00
|
|
|
|
|
|
|
/* path termination. this is a strange place to put the termination, it's
|
|
|
|
* mainly due to the mixed in MIS that we use. gives too many unneeded
|
|
|
|
* shader evaluations, only need emission if we are going to terminate */
|
2013-08-24 15:02:08 +00:00
|
|
|
float probability = path_state_terminate_probability(kg, &state, throughput);
|
2012-06-13 11:44:48 +00:00
|
|
|
|
2013-06-07 16:06:22 +00:00
|
|
|
if(probability == 0.0f) {
|
2012-06-13 11:44:48 +00:00
|
|
|
break;
|
2013-06-07 16:06:22 +00:00
|
|
|
}
|
|
|
|
else if(probability != 1.0f) {
|
2014-05-29 12:12:12 +00:00
|
|
|
float terminate = path_state_rng_1D_for_decision(kg, rng, &state, PRNG_TERMINATE);
|
2013-06-07 16:06:22 +00:00
|
|
|
if(terminate >= probability)
|
|
|
|
break;
|
2012-06-13 11:44:48 +00:00
|
|
|
|
2013-06-07 16:06:22 +00:00
|
|
|
throughput /= probability;
|
|
|
|
}
|
2012-06-13 11:44:48 +00:00
|
|
|
|
|
|
|
#ifdef __AO__
|
|
|
|
/* ambient occlusion */
|
2012-11-06 19:59:02 +00:00
|
|
|
if(kernel_data.integrator.use_ambient_occlusion || (sd.flag & SD_AO)) {
|
2016-10-30 23:40:05 +00:00
|
|
|
kernel_path_ao(kg, &sd, &emission_sd, &L, &state, rng, throughput, shader_bsdf_alpha(kg, &sd));
|
2012-06-13 11:44:48 +00:00
|
|
|
}
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __AO__ */
|
2012-06-13 11:44:48 +00:00
|
|
|
|
2013-08-24 15:02:08 +00:00
|
|
|
#ifdef __SUBSURFACE__
|
|
|
|
/* bssrdf scatter to a different location on the same object, replacing
|
|
|
|
* the closures with a diffuse BSDF */
|
|
|
|
if(sd.flag & SD_BSSRDF) {
|
2015-11-22 10:48:33 +00:00
|
|
|
if(kernel_path_subsurface_scatter(kg,
|
|
|
|
&sd,
|
2016-05-22 20:35:47 +00:00
|
|
|
&emission_sd,
|
2015-11-22 10:48:33 +00:00
|
|
|
&L,
|
|
|
|
&state,
|
|
|
|
rng,
|
|
|
|
&ray,
|
|
|
|
&throughput,
|
|
|
|
&ss_indirect))
|
|
|
|
{
|
2013-10-08 17:07:18 +00:00
|
|
|
break;
|
2015-11-22 10:48:33 +00:00
|
|
|
}
|
2013-08-24 15:02:08 +00:00
|
|
|
}
|
2015-11-27 12:12:44 +00:00
|
|
|
#endif /* __SUBSURFACE__ */
|
2013-12-28 15:56:19 +00:00
|
|
|
|
2014-04-04 12:21:35 +00:00
|
|
|
/* direct lighting */
|
2016-05-22 20:35:47 +00:00
|
|
|
kernel_path_surface_connect_light(kg, rng, &sd, &emission_sd, throughput, &state, &L);
|
2013-12-28 15:56:19 +00:00
|
|
|
|
2014-04-04 12:21:35 +00:00
|
|
|
/* compute direct lighting and next bounce */
|
|
|
|
if(!kernel_path_surface_bounce(kg, rng, &sd, &throughput, &state, &L, &ray))
|
2013-12-28 15:56:19 +00:00
|
|
|
break;
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
2013-08-24 15:02:08 +00:00
|
|
|
|
2015-11-28 14:30:35 +00:00
|
|
|
#ifdef __SUBSURFACE__
|
|
|
|
kernel_path_subsurface_accum_indirect(&ss_indirect, &L);
|
|
|
|
|
2015-11-22 11:08:03 +00:00
|
|
|
/* Trace indirect subsurface rays by restarting the loop. this uses less
|
|
|
|
* stack memory than invoking kernel_path_indirect.
|
|
|
|
*/
|
|
|
|
if(ss_indirect.num_rays) {
|
|
|
|
kernel_path_subsurface_setup_indirect(kg,
|
|
|
|
&ss_indirect,
|
2015-11-28 14:30:35 +00:00
|
|
|
&state,
|
2015-11-22 11:08:03 +00:00
|
|
|
&ray,
|
2015-11-28 14:30:35 +00:00
|
|
|
&L,
|
2015-11-22 11:08:03 +00:00
|
|
|
&throughput);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
break;
|
|
|
|
}
|
2015-11-22 10:48:33 +00:00
|
|
|
}
|
2015-11-28 14:30:35 +00:00
|
|
|
#endif /* __SUBSURFACE__ */
|
2015-11-22 10:48:33 +00:00
|
|
|
|
2014-02-10 20:44:49 +00:00
|
|
|
float3 L_sum = path_radiance_clamp_and_sum(kg, &L);
|
2013-08-24 15:02:08 +00:00
|
|
|
|
|
|
|
kernel_write_light_passes(kg, buffer, &L, sample);
|
|
|
|
|
2014-10-04 13:00:26 +00:00
|
|
|
#ifdef __KERNEL_DEBUG__
|
|
|
|
kernel_write_debug_passes(kg, buffer, &state, &debug_data, sample);
|
2016-10-06 12:55:56 +00:00
|
|
|
#endif /* __KERNEL_DEBUG__ */
|
2014-10-04 13:00:26 +00:00
|
|
|
|
2013-08-24 15:02:08 +00:00
|
|
|
return make_float4(L_sum.x, L_sum.y, L_sum.z, 1.0f - L_transparent);
|
2012-06-13 11:44:48 +00:00
|
|
|
}
|
|
|
|
|
2013-11-15 23:17:10 +00:00
|
|
|
ccl_device void kernel_path_trace(KernelGlobals *kg,
|
|
|
|
ccl_global float *buffer, ccl_global uint *rng_state,
|
2013-08-09 18:47:25 +00:00
|
|
|
int sample, int x, int y, int offset, int stride)
|
|
|
|
{
|
|
|
|
/* buffer offset */
|
|
|
|
int index = offset + x + y*stride;
|
|
|
|
int pass_stride = kernel_data.film.pass_stride;
|
|
|
|
|
|
|
|
rng_state += index;
|
|
|
|
buffer += index*pass_stride;
|
|
|
|
|
|
|
|
/* initialize random numbers and ray */
|
|
|
|
RNG rng;
|
|
|
|
Ray ray;
|
|
|
|
|
|
|
|
kernel_path_trace_setup(kg, rng_state, sample, x, y, &rng, &ray);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
/* integrate */
|
2012-05-04 16:20:51 +00:00
|
|
|
float4 L;
|
|
|
|
|
2013-12-28 15:56:19 +00:00
|
|
|
if(ray.t != 0.0f)
|
2013-08-23 23:04:50 +00:00
|
|
|
L = kernel_path_integrate(kg, &rng, sample, ray, buffer);
|
2013-08-09 18:47:25 +00:00
|
|
|
else
|
|
|
|
L = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
|
|
|
|
|
|
/* accumulate result in output buffer */
|
|
|
|
kernel_write_pass_float4(buffer, sample, L);
|
|
|
|
|
|
|
|
path_rng_end(kg, rng_state, rng);
|
|
|
|
}
|
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
CCL_NAMESPACE_END
|
|
|
|
|