2011-04-27 11:58:34 +00:00
|
|
|
/*
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
|
|
|
|
|
2012-12-01 19:15:05 +00:00
|
|
|
#ifdef __OSL__
|
|
|
|
|
#include "osl_shader.h"
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
#include "kernel_differential.h"
|
|
|
|
|
#include "kernel_montecarlo.h"
|
2012-05-07 10:53:09 +00:00
|
|
|
#include "kernel_projection.h"
|
2011-04-27 11:58:34 +00:00
|
|
|
#include "kernel_object.h"
|
2012-12-01 19:15:05 +00:00
|
|
|
#include "kernel_attribute.h"
|
|
|
|
|
#include "kernel_projection.h"
|
2012-04-30 12:49:26 +00:00
|
|
|
#include "kernel_triangle.h"
|
2011-04-27 11:58:34 +00:00
|
|
|
#ifdef __QBVH__
|
|
|
|
|
#include "kernel_qbvh.h"
|
|
|
|
|
#else
|
|
|
|
|
#include "kernel_bvh.h"
|
|
|
|
|
#endif
|
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_camera.h"
|
|
|
|
|
#include "kernel_shader.h"
|
|
|
|
|
#include "kernel_light.h"
|
|
|
|
|
#include "kernel_emission.h"
|
|
|
|
|
#include "kernel_random.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
|
|
|
|
|
|
|
|
CCL_NAMESPACE_BEGIN
|
|
|
|
|
|
2011-09-01 15:53:36 +00:00
|
|
|
typedef struct PathState {
|
|
|
|
|
uint flag;
|
|
|
|
|
int bounce;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2011-09-01 15:53:36 +00:00
|
|
|
int diffuse_bounce;
|
|
|
|
|
int glossy_bounce;
|
|
|
|
|
int transmission_bounce;
|
|
|
|
|
int transparent_bounce;
|
|
|
|
|
} PathState;
|
|
|
|
|
|
|
|
|
|
__device_inline void path_state_init(PathState *state)
|
|
|
|
|
{
|
2011-10-16 17:54:43 +00:00
|
|
|
state->flag = PATH_RAY_CAMERA|PATH_RAY_SINGULAR|PATH_RAY_MIS_SKIP;
|
2011-09-01 15:53:36 +00:00
|
|
|
state->bounce = 0;
|
|
|
|
|
state->diffuse_bounce = 0;
|
|
|
|
|
state->glossy_bounce = 0;
|
|
|
|
|
state->transmission_bounce = 0;
|
|
|
|
|
state->transparent_bounce = 0;
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
2011-10-16 17:54:43 +00:00
|
|
|
__device_inline void path_state_next(KernelGlobals *kg, PathState *state, int label)
|
2011-04-27 11:58:34 +00:00
|
|
|
{
|
2011-09-01 15:53:36 +00:00
|
|
|
/* ray through transparent keeps same flags from previous ray and is
|
2012-06-09 17:22:52 +00:00
|
|
|
* not counted as a regular bounce, transparent has separate max */
|
2011-09-01 15:53:36 +00:00
|
|
|
if(label & LABEL_TRANSPARENT) {
|
|
|
|
|
state->flag |= PATH_RAY_TRANSPARENT;
|
|
|
|
|
state->transparent_bounce++;
|
|
|
|
|
|
2011-10-16 17:54:43 +00:00
|
|
|
if(!kernel_data.integrator.transparent_shadows)
|
|
|
|
|
state->flag |= PATH_RAY_MIS_SKIP;
|
|
|
|
|
|
2011-09-01 15:53:36 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
state->bounce++;
|
|
|
|
|
|
|
|
|
|
/* reflection/transmission */
|
2011-04-27 11:58:34 +00:00
|
|
|
if(label & LABEL_REFLECT) {
|
2011-09-01 15:53:36 +00:00
|
|
|
state->flag |= PATH_RAY_REFLECT;
|
|
|
|
|
state->flag &= ~(PATH_RAY_TRANSMIT|PATH_RAY_CAMERA|PATH_RAY_TRANSPARENT);
|
|
|
|
|
|
|
|
|
|
if(label & LABEL_DIFFUSE)
|
|
|
|
|
state->diffuse_bounce++;
|
|
|
|
|
else
|
|
|
|
|
state->glossy_bounce++;
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
kernel_assert(label & LABEL_TRANSMIT);
|
|
|
|
|
|
2011-09-01 15:53:36 +00:00
|
|
|
state->flag |= PATH_RAY_TRANSMIT;
|
|
|
|
|
state->flag &= ~(PATH_RAY_REFLECT|PATH_RAY_CAMERA|PATH_RAY_TRANSPARENT);
|
|
|
|
|
|
|
|
|
|
state->transmission_bounce++;
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* diffuse/glossy/singular */
|
|
|
|
|
if(label & LABEL_DIFFUSE) {
|
2011-09-01 15:53:36 +00:00
|
|
|
state->flag |= PATH_RAY_DIFFUSE;
|
2011-10-16 17:54:43 +00:00
|
|
|
state->flag &= ~(PATH_RAY_GLOSSY|PATH_RAY_SINGULAR|PATH_RAY_MIS_SKIP);
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
else if(label & LABEL_GLOSSY) {
|
2011-09-01 15:53:36 +00:00
|
|
|
state->flag |= PATH_RAY_GLOSSY;
|
2011-10-16 17:54:43 +00:00
|
|
|
state->flag &= ~(PATH_RAY_DIFFUSE|PATH_RAY_SINGULAR|PATH_RAY_MIS_SKIP);
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
else {
|
2011-09-01 15:53:36 +00:00
|
|
|
kernel_assert(label & LABEL_SINGULAR);
|
|
|
|
|
|
2011-10-16 17:54:43 +00:00
|
|
|
state->flag |= PATH_RAY_GLOSSY|PATH_RAY_SINGULAR|PATH_RAY_MIS_SKIP;
|
2011-09-01 15:53:36 +00:00
|
|
|
state->flag &= ~PATH_RAY_DIFFUSE;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-12-21 20:51:43 +00:00
|
|
|
__device_inline uint path_state_ray_visibility(KernelGlobals *kg, PathState *state)
|
2011-09-01 15:53:36 +00:00
|
|
|
{
|
|
|
|
|
uint flag = state->flag;
|
|
|
|
|
|
|
|
|
|
/* for visibility, diffuse/glossy are for reflection only */
|
|
|
|
|
if(flag & PATH_RAY_TRANSMIT)
|
|
|
|
|
flag &= ~(PATH_RAY_DIFFUSE|PATH_RAY_GLOSSY);
|
2011-12-21 20:51:43 +00:00
|
|
|
/* for camera visibility, use render layer flags */
|
|
|
|
|
if(flag & PATH_RAY_CAMERA)
|
|
|
|
|
flag |= kernel_data.integrator.layer_flag;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2011-09-01 15:53:36 +00:00
|
|
|
return flag;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
__device_inline float path_state_terminate_probability(KernelGlobals *kg, PathState *state, const float3 throughput)
|
|
|
|
|
{
|
|
|
|
|
if(state->flag & PATH_RAY_TRANSPARENT) {
|
|
|
|
|
/* transparent rays treated separately */
|
|
|
|
|
if(state->transparent_bounce >= kernel_data.integrator.transparent_max_bounce)
|
|
|
|
|
return 0.0f;
|
|
|
|
|
else if(state->transparent_bounce <= kernel_data.integrator.transparent_min_bounce)
|
|
|
|
|
return 1.0f;
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
2011-09-01 15:53:36 +00:00
|
|
|
else {
|
|
|
|
|
/* other rays */
|
|
|
|
|
if((state->bounce >= kernel_data.integrator.max_bounce) ||
|
|
|
|
|
(state->diffuse_bounce >= kernel_data.integrator.max_diffuse_bounce) ||
|
|
|
|
|
(state->glossy_bounce >= kernel_data.integrator.max_glossy_bounce) ||
|
|
|
|
|
(state->transmission_bounce >= kernel_data.integrator.max_transmission_bounce))
|
2012-06-09 18:56:12 +00:00
|
|
|
{
|
2011-09-01 15:53:36 +00:00
|
|
|
return 0.0f;
|
2012-06-09 18:56:12 +00:00
|
|
|
}
|
|
|
|
|
else if(state->bounce <= kernel_data.integrator.min_bounce) {
|
2011-09-01 15:53:36 +00:00
|
|
|
return 1.0f;
|
2012-06-09 18:56:12 +00:00
|
|
|
}
|
2011-09-01 15:53:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* probalistic termination */
|
|
|
|
|
return average(throughput);
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
2012-02-28 16:45:08 +00:00
|
|
|
__device_inline bool shadow_blocked(KernelGlobals *kg, PathState *state, Ray *ray, float3 *shadow)
|
2011-09-12 13:13:56 +00:00
|
|
|
{
|
2012-04-15 15:35:09 +00:00
|
|
|
*shadow = make_float3(1.0f, 1.0f, 1.0f);
|
|
|
|
|
|
2011-09-12 13:13:56 +00:00
|
|
|
if(ray->t == 0.0f)
|
|
|
|
|
return false;
|
|
|
|
|
|
2012-02-28 16:45:08 +00:00
|
|
|
Intersection isect;
|
|
|
|
|
bool result = scene_intersect(kg, ray, PATH_RAY_SHADOW_OPAQUE, &isect);
|
|
|
|
|
|
2011-09-12 13:13:56 +00:00
|
|
|
#ifdef __TRANSPARENT_SHADOWS__
|
|
|
|
|
if(result && kernel_data.integrator.transparent_shadows) {
|
|
|
|
|
/* transparent shadows work in such a way to try to minimize overhead
|
2012-06-09 17:22:52 +00:00
|
|
|
* in cases where we don't need them. after a regular shadow ray is
|
|
|
|
|
* cast we check if the hit primitive was potentially transparent, and
|
|
|
|
|
* only in that case start marching. this gives on extra ray cast for
|
|
|
|
|
* the cases were we do want transparency.
|
|
|
|
|
*
|
|
|
|
|
* also note that for this to work correct, multi close sampling must
|
|
|
|
|
* be used, since we don't pass a random number to shader_eval_surface */
|
2012-02-28 16:45:08 +00:00
|
|
|
if(shader_transparent_shadow(kg, &isect)) {
|
2011-09-12 13:13:56 +00:00
|
|
|
float3 throughput = make_float3(1.0f, 1.0f, 1.0f);
|
|
|
|
|
float3 Pend = ray->P + ray->D*ray->t;
|
|
|
|
|
int bounce = state->transparent_bounce;
|
|
|
|
|
|
|
|
|
|
for(;;) {
|
|
|
|
|
if(bounce >= kernel_data.integrator.transparent_max_bounce) {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
else if(bounce >= kernel_data.integrator.transparent_min_bounce) {
|
|
|
|
|
/* todo: get random number somewhere for probabilistic terminate */
|
|
|
|
|
#if 0
|
|
|
|
|
float probability = average(throughput);
|
2011-10-16 17:54:43 +00:00
|
|
|
float terminate = 0.0f;
|
2011-09-12 13:13:56 +00:00
|
|
|
|
|
|
|
|
if(terminate >= probability)
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
throughput /= probability;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2012-02-28 16:45:08 +00:00
|
|
|
if(!scene_intersect(kg, ray, PATH_RAY_SHADOW_TRANSPARENT, &isect)) {
|
|
|
|
|
*shadow *= throughput;
|
2011-09-12 13:13:56 +00:00
|
|
|
return false;
|
|
|
|
|
}
|
2011-10-16 17:54:43 +00:00
|
|
|
|
2012-02-28 16:45:08 +00:00
|
|
|
if(!shader_transparent_shadow(kg, &isect))
|
2011-09-12 13:13:56 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
ShaderData sd;
|
2012-02-28 16:45:08 +00:00
|
|
|
shader_setup_from_ray(kg, &sd, &isect, ray);
|
2011-10-16 17:54:43 +00:00
|
|
|
shader_eval_surface(kg, &sd, 0.0f, PATH_RAY_SHADOW);
|
2011-09-12 13:13:56 +00:00
|
|
|
|
|
|
|
|
throughput *= shader_bsdf_transparency(kg, &sd);
|
|
|
|
|
|
|
|
|
|
ray->P = ray_offset(sd.P, -sd.Ng);
|
2011-10-16 17:54:43 +00:00
|
|
|
if(ray->t != FLT_MAX)
|
|
|
|
|
ray->D = normalize_len(Pend - ray->P, &ray->t);
|
2011-09-12 13:13:56 +00:00
|
|
|
|
2012-09-05 08:12:22 +00:00
|
|
|
shader_release(kg, &sd);
|
|
|
|
|
|
2011-09-12 13:13:56 +00:00
|
|
|
bounce++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-13 11:44:48 +00:00
|
|
|
__device float4 kernel_path_progressive(KernelGlobals *kg, RNG *rng, int sample, Ray ray, __global float *buffer)
|
2011-04-27 11:58:34 +00:00
|
|
|
{
|
|
|
|
|
/* initialize */
|
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
|
|
|
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);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
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
|
|
|
float min_ray_pdf = FLT_MAX;
|
2011-04-27 11:58:34 +00:00
|
|
|
float ray_pdf = 0.0f;
|
2011-09-01 15:53:36 +00:00
|
|
|
PathState state;
|
2011-04-27 11:58:34 +00:00
|
|
|
int rng_offset = PRNG_BASE_NUM;
|
|
|
|
|
|
2011-09-01 15:53:36 +00:00
|
|
|
path_state_init(&state);
|
|
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
/* path iteration */
|
2011-09-01 15:53:36 +00:00
|
|
|
for(;; rng_offset += PRNG_BOUNCE_NUM) {
|
2011-04-27 11:58:34 +00:00
|
|
|
/* intersect scene */
|
|
|
|
|
Intersection isect;
|
2011-12-21 20:51:43 +00:00
|
|
|
uint visibility = path_state_ray_visibility(kg, &state);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2011-09-01 15:53:36 +00:00
|
|
|
if(!scene_intersect(kg, &ray, visibility, &isect)) {
|
2011-04-27 11:58:34 +00:00
|
|
|
/* eval background shader if nothing hit */
|
2011-09-01 15:53:36 +00:00
|
|
|
if(kernel_data.background.transparent && (state.flag & PATH_RAY_CAMERA)) {
|
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
|
|
|
L_transparent += average(throughput);
|
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
|
|
|
|
|
|
|
|
#ifdef __PASSES__
|
|
|
|
|
if(!(kernel_data.film.pass_flag & PASS_BACKGROUND))
|
|
|
|
|
#endif
|
|
|
|
|
break;
|
2011-08-28 13:55:59 +00:00
|
|
|
}
|
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
|
|
|
|
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 */
|
|
|
|
|
float3 L_background = indirect_background(kg, &ray, state.flag, ray_pdf);
|
|
|
|
|
path_radiance_accum_background(&L, throughput, L_background, state.bounce);
|
2012-01-26 15:37:33 +00:00
|
|
|
#endif
|
2011-08-28 13:55:59 +00:00
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* setup shading */
|
|
|
|
|
ShaderData sd;
|
|
|
|
|
shader_setup_from_ray(kg, &sd, &isect, &ray);
|
2011-09-16 13:14:02 +00:00
|
|
|
float rbsdf = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF);
|
2011-09-01 15:53:36 +00:00
|
|
|
shader_eval_surface(kg, &sd, rbsdf, state.flag);
|
2011-04-27 11:58:34 +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
|
|
|
kernel_write_data_passes(kg, buffer, &L, &sd, sample, state.flag, throughput);
|
|
|
|
|
|
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
|
|
|
/* blurring of bsdf after bounces, for rays that have a small likelihood
|
2012-06-09 17:22:52 +00:00
|
|
|
* of following this particular path (diffuse, rough glossy) */
|
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
|
|
|
if(kernel_data.integrator.filter_glossy != FLT_MAX) {
|
|
|
|
|
float blur_pdf = kernel_data.integrator.filter_glossy*min_ray_pdf;
|
|
|
|
|
|
|
|
|
|
if(blur_pdf < 1.0f) {
|
|
|
|
|
float blur_roughness = sqrtf(1.0f - blur_pdf)*0.5f;
|
|
|
|
|
shader_bsdf_blur(kg, &sd, blur_roughness);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* holdout */
|
2011-08-28 13:55:59 +00:00
|
|
|
#ifdef __HOLDOUT__
|
2012-05-02 09:33:45 +00:00
|
|
|
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
|
2012-08-01 12:59:47 +00:00
|
|
|
holdout_weight = shader_holdout_eval(kg, &sd);
|
2011-08-28 13:55:59 +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
|
|
|
/* any throughput is ok, should all be identical here */
|
|
|
|
|
L_transparent += average(holdout_weight*throughput);
|
2012-05-02 09:33:45 +00:00
|
|
|
}
|
|
|
|
|
|
2012-09-05 08:12:22 +00:00
|
|
|
if(sd.flag & SD_HOLDOUT_MASK) {
|
|
|
|
|
shader_release(kg, &sd);
|
2012-05-02 09:33:45 +00:00
|
|
|
break;
|
2012-09-05 08:12:22 +00:00
|
|
|
}
|
2011-08-28 13:55:59 +00:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
#ifdef __EMISSION__
|
|
|
|
|
/* emission */
|
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
|
|
|
if(sd.flag & SD_EMISSION) {
|
|
|
|
|
float3 emission = indirect_emission(kg, &sd, isect.t, state.flag, ray_pdf);
|
|
|
|
|
path_radiance_accum_emission(&L, throughput, emission, state.bounce);
|
|
|
|
|
}
|
2011-09-01 15:53:36 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* 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 */
|
2011-09-01 15:53:36 +00:00
|
|
|
float probability = path_state_terminate_probability(kg, &state, throughput);
|
2011-09-16 13:14:02 +00:00
|
|
|
float terminate = path_rng(kg, rng, sample, rng_offset + PRNG_TERMINATE);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2012-09-05 08:12:22 +00:00
|
|
|
if(terminate >= probability) {
|
|
|
|
|
shader_release(kg, &sd);
|
2011-09-01 15:53:36 +00:00
|
|
|
break;
|
2012-09-05 08:12:22 +00:00
|
|
|
}
|
2011-09-01 15:53:36 +00:00
|
|
|
|
|
|
|
|
throughput /= probability;
|
|
|
|
|
|
2012-02-28 16:45:08 +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)) {
|
2012-02-28 16:45:08 +00:00
|
|
|
/* todo: solve correlation */
|
|
|
|
|
float bsdf_u = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF_U);
|
|
|
|
|
float bsdf_v = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF_V);
|
|
|
|
|
|
2012-11-15 15:37:58 +00:00
|
|
|
float ao_factor = kernel_data.background.ao_factor;
|
|
|
|
|
float3 ao_N;
|
|
|
|
|
float3 ao_bsdf = shader_bsdf_ao(kg, &sd, ao_factor, &ao_N);
|
2012-02-28 16:45:08 +00:00
|
|
|
float3 ao_D;
|
|
|
|
|
float ao_pdf;
|
|
|
|
|
|
2012-11-15 15:37:58 +00:00
|
|
|
sample_cos_hemisphere(ao_N, bsdf_u, bsdf_v, &ao_D, &ao_pdf);
|
2012-02-28 16:45:08 +00:00
|
|
|
|
2012-11-15 21:32:05 +00:00
|
|
|
if(dot(sd.Ng, ao_D) > 0.0f && ao_pdf != 0.0f) {
|
2012-02-28 16:45:08 +00:00
|
|
|
Ray light_ray;
|
|
|
|
|
float3 ao_shadow;
|
|
|
|
|
|
|
|
|
|
light_ray.P = ray_offset(sd.P, sd.Ng);
|
|
|
|
|
light_ray.D = ao_D;
|
|
|
|
|
light_ray.t = kernel_data.background.ao_distance;
|
2012-10-09 18:37:14 +00:00
|
|
|
#ifdef __OBJECT_MOTION__
|
2012-04-30 12:49:26 +00:00
|
|
|
light_ray.time = sd.time;
|
|
|
|
|
#endif
|
2012-02-28 16:45:08 +00:00
|
|
|
|
2012-11-15 15:37:58 +00:00
|
|
|
if(!shadow_blocked(kg, &state, &light_ray, &ao_shadow))
|
2012-02-28 16:45:08 +00:00
|
|
|
path_radiance_accum_ao(&L, throughput, ao_bsdf, ao_shadow, state.bounce);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-09-01 15:53:36 +00:00
|
|
|
#ifdef __EMISSION__
|
2011-09-27 20:37:24 +00:00
|
|
|
if(kernel_data.integrator.use_direct_light) {
|
2011-04-27 11:58:34 +00:00
|
|
|
/* sample illumination from lights to find path contribution */
|
2011-09-01 15:53:36 +00:00
|
|
|
if(sd.flag & SD_BSDF_HAS_EVAL) {
|
2011-09-16 13:14:02 +00:00
|
|
|
float light_t = path_rng(kg, rng, sample, rng_offset + PRNG_LIGHT);
|
|
|
|
|
float light_o = path_rng(kg, rng, sample, rng_offset + PRNG_LIGHT_F);
|
|
|
|
|
float light_u = path_rng(kg, rng, sample, rng_offset + PRNG_LIGHT_U);
|
|
|
|
|
float light_v = path_rng(kg, rng, sample, rng_offset + PRNG_LIGHT_V);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
|
Ray light_ray;
|
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
|
|
|
BsdfEval L_light;
|
2012-03-28 10:39:21 +00:00
|
|
|
bool is_lamp;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2012-10-09 18:37:14 +00:00
|
|
|
#ifdef __OBJECT_MOTION__
|
2012-04-30 12:49:26 +00:00
|
|
|
light_ray.time = sd.time;
|
|
|
|
|
#endif
|
|
|
|
|
|
2012-06-13 11:44:48 +00:00
|
|
|
if(direct_emission(kg, &sd, -1, light_t, light_o, light_u, light_v, &light_ray, &L_light, &is_lamp)) {
|
|
|
|
|
/* trace shadow ray */
|
|
|
|
|
float3 shadow;
|
2011-09-01 15:53:36 +00:00
|
|
|
|
2012-06-13 11:44:48 +00:00
|
|
|
if(!shadow_blocked(kg, &state, &light_ray, &shadow)) {
|
|
|
|
|
/* accumulate */
|
|
|
|
|
path_radiance_accum_light(&L, throughput, &L_light, shadow, state.bounce, is_lamp);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-09-12 13:13:56 +00:00
|
|
|
#endif
|
2012-02-28 16:45:08 +00:00
|
|
|
|
2012-06-13 11:44:48 +00:00
|
|
|
/* no BSDF? we can stop here */
|
2012-09-05 08:12:22 +00:00
|
|
|
if(!(sd.flag & SD_BSDF)) {
|
|
|
|
|
shader_release(kg, &sd);
|
2012-06-13 11:44:48 +00:00
|
|
|
break;
|
2012-09-05 08:12:22 +00:00
|
|
|
}
|
2012-06-13 11:44:48 +00:00
|
|
|
|
|
|
|
|
/* sample BSDF */
|
|
|
|
|
float bsdf_pdf;
|
|
|
|
|
BsdfEval bsdf_eval;
|
|
|
|
|
float3 bsdf_omega_in;
|
|
|
|
|
differential3 bsdf_domega_in;
|
|
|
|
|
float bsdf_u = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF_U);
|
|
|
|
|
float bsdf_v = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF_V);
|
|
|
|
|
int label;
|
|
|
|
|
|
|
|
|
|
label = shader_bsdf_sample(kg, &sd, bsdf_u, bsdf_v, &bsdf_eval,
|
|
|
|
|
&bsdf_omega_in, &bsdf_domega_in, &bsdf_pdf);
|
|
|
|
|
|
2012-09-04 17:28:36 +00:00
|
|
|
shader_release(kg, &sd);
|
|
|
|
|
|
2012-06-13 11:44:48 +00:00
|
|
|
if(bsdf_pdf == 0.0f || bsdf_eval_is_zero(&bsdf_eval))
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* modify throughput */
|
|
|
|
|
path_radiance_bsdf_bounce(&L, &throughput, &bsdf_eval, bsdf_pdf, state.bounce, label);
|
|
|
|
|
|
|
|
|
|
/* set labels */
|
|
|
|
|
if(!(label & LABEL_TRANSPARENT)) {
|
|
|
|
|
ray_pdf = bsdf_pdf;
|
|
|
|
|
min_ray_pdf = fminf(bsdf_pdf, min_ray_pdf);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* update path state */
|
|
|
|
|
path_state_next(kg, &state, label);
|
|
|
|
|
|
|
|
|
|
/* setup ray */
|
|
|
|
|
ray.P = ray_offset(sd.P, (label & LABEL_TRANSMIT)? -sd.Ng: sd.Ng);
|
|
|
|
|
ray.D = bsdf_omega_in;
|
2012-11-21 13:22:24 +00:00
|
|
|
|
|
|
|
|
if(state.bounce == 0)
|
|
|
|
|
ray.t -= sd.ray_length; /* clipping works through transparent */
|
|
|
|
|
else
|
|
|
|
|
ray.t = FLT_MAX;
|
|
|
|
|
|
2012-06-13 11:44:48 +00:00
|
|
|
#ifdef __RAY_DIFFERENTIALS__
|
|
|
|
|
ray.dP = sd.dP;
|
|
|
|
|
ray.dD = bsdf_domega_in;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
float3 L_sum = path_radiance_sum(kg, &L);
|
|
|
|
|
|
|
|
|
|
#ifdef __CLAMP_SAMPLE__
|
|
|
|
|
path_radiance_clamp(&L, &L_sum, kernel_data.integrator.sample_clamp);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
kernel_write_light_passes(kg, buffer, &L, sample);
|
|
|
|
|
|
|
|
|
|
return make_float4(L_sum.x, L_sum.y, L_sum.z, 1.0f - L_transparent);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef __NON_PROGRESSIVE__
|
|
|
|
|
|
|
|
|
|
__device void kernel_path_indirect(KernelGlobals *kg, RNG *rng, int sample, Ray ray, __global float *buffer,
|
|
|
|
|
float3 throughput, float min_ray_pdf, float ray_pdf, PathState state, int rng_offset, PathRadiance *L)
|
|
|
|
|
{
|
|
|
|
|
/* path iteration */
|
|
|
|
|
for(;; rng_offset += PRNG_BOUNCE_NUM) {
|
|
|
|
|
/* intersect scene */
|
|
|
|
|
Intersection isect;
|
|
|
|
|
uint visibility = path_state_ray_visibility(kg, &state);
|
|
|
|
|
|
|
|
|
|
if(!scene_intersect(kg, &ray, visibility, &isect)) {
|
|
|
|
|
#ifdef __BACKGROUND__
|
|
|
|
|
/* sample background shader */
|
|
|
|
|
float3 L_background = indirect_background(kg, &ray, state.flag, ray_pdf);
|
|
|
|
|
path_radiance_accum_background(L, throughput, L_background, state.bounce);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* setup shading */
|
|
|
|
|
ShaderData sd;
|
|
|
|
|
shader_setup_from_ray(kg, &sd, &isect, &ray);
|
|
|
|
|
float rbsdf = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF);
|
|
|
|
|
shader_eval_surface(kg, &sd, rbsdf, state.flag);
|
|
|
|
|
shader_merge_closures(kg, &sd);
|
|
|
|
|
|
|
|
|
|
/* 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) {
|
|
|
|
|
float blur_pdf = kernel_data.integrator.filter_glossy*min_ray_pdf;
|
|
|
|
|
|
|
|
|
|
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) {
|
|
|
|
|
float3 emission = indirect_emission(kg, &sd, isect.t, state.flag, ray_pdf);
|
|
|
|
|
path_radiance_accum_emission(L, throughput, emission, state.bounce);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* 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 */
|
|
|
|
|
float probability = path_state_terminate_probability(kg, &state, throughput);
|
|
|
|
|
float terminate = path_rng(kg, rng, sample, rng_offset + PRNG_TERMINATE);
|
|
|
|
|
|
2012-09-05 08:12:22 +00:00
|
|
|
if(terminate >= probability) {
|
|
|
|
|
shader_release(kg, &sd);
|
2012-06-13 11:44:48 +00:00
|
|
|
break;
|
2012-09-05 08:12:22 +00:00
|
|
|
}
|
2012-06-13 11:44:48 +00:00
|
|
|
|
|
|
|
|
throughput /= probability;
|
|
|
|
|
|
|
|
|
|
#ifdef __AO__
|
|
|
|
|
/* ambient occlusion */
|
2012-11-06 19:59:02 +00:00
|
|
|
if(kernel_data.integrator.use_ambient_occlusion || (sd.flag & SD_AO)) {
|
2012-06-13 11:44:48 +00:00
|
|
|
/* todo: solve correlation */
|
|
|
|
|
float bsdf_u = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF_U);
|
|
|
|
|
float bsdf_v = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF_V);
|
|
|
|
|
|
2012-11-15 15:37:58 +00:00
|
|
|
float ao_factor = kernel_data.background.ao_factor;
|
|
|
|
|
float3 ao_N;
|
|
|
|
|
float3 ao_bsdf = shader_bsdf_ao(kg, &sd, ao_factor, &ao_N);
|
2012-06-13 11:44:48 +00:00
|
|
|
float3 ao_D;
|
|
|
|
|
float ao_pdf;
|
|
|
|
|
|
2012-11-15 15:37:58 +00:00
|
|
|
sample_cos_hemisphere(ao_N, bsdf_u, bsdf_v, &ao_D, &ao_pdf);
|
2012-06-13 11:44:48 +00:00
|
|
|
|
2012-11-15 21:32:05 +00:00
|
|
|
if(dot(sd.Ng, ao_D) > 0.0f && ao_pdf != 0.0f) {
|
2012-06-13 11:44:48 +00:00
|
|
|
Ray light_ray;
|
|
|
|
|
float3 ao_shadow;
|
|
|
|
|
|
|
|
|
|
light_ray.P = ray_offset(sd.P, sd.Ng);
|
|
|
|
|
light_ray.D = ao_D;
|
|
|
|
|
light_ray.t = kernel_data.background.ao_distance;
|
2012-10-09 18:37:14 +00:00
|
|
|
#ifdef __OBJECT_MOTION__
|
2012-06-13 11:44:48 +00:00
|
|
|
light_ray.time = sd.time;
|
|
|
|
|
#endif
|
|
|
|
|
|
2012-11-15 15:37:58 +00:00
|
|
|
if(!shadow_blocked(kg, &state, &light_ray, &ao_shadow))
|
2012-06-13 11:44:48 +00:00
|
|
|
path_radiance_accum_ao(L, throughput, ao_bsdf, ao_shadow, state.bounce);
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-09-12 13:13:56 +00:00
|
|
|
#endif
|
2012-06-13 11:44:48 +00:00
|
|
|
|
|
|
|
|
#ifdef __EMISSION__
|
|
|
|
|
if(kernel_data.integrator.use_direct_light) {
|
|
|
|
|
/* sample illumination from lights to find path contribution */
|
|
|
|
|
if(sd.flag & SD_BSDF_HAS_EVAL) {
|
|
|
|
|
float light_t = path_rng(kg, rng, sample, rng_offset + PRNG_LIGHT);
|
|
|
|
|
float light_o = path_rng(kg, rng, sample, rng_offset + PRNG_LIGHT_F);
|
|
|
|
|
float light_u = path_rng(kg, rng, sample, rng_offset + PRNG_LIGHT_U);
|
|
|
|
|
float light_v = path_rng(kg, rng, sample, rng_offset + PRNG_LIGHT_V);
|
|
|
|
|
|
|
|
|
|
Ray light_ray;
|
|
|
|
|
BsdfEval L_light;
|
|
|
|
|
bool is_lamp;
|
|
|
|
|
|
2012-10-09 18:37:14 +00:00
|
|
|
#ifdef __OBJECT_MOTION__
|
2012-06-13 11:44:48 +00:00
|
|
|
light_ray.time = sd.time;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* sample random light */
|
|
|
|
|
if(direct_emission(kg, &sd, -1, light_t, light_o, light_u, light_v, &light_ray, &L_light, &is_lamp)) {
|
|
|
|
|
/* trace shadow ray */
|
|
|
|
|
float3 shadow;
|
|
|
|
|
|
|
|
|
|
if(!shadow_blocked(kg, &state, &light_ray, &shadow)) {
|
|
|
|
|
/* accumulate */
|
|
|
|
|
path_radiance_accum_light(L, throughput, &L_light, shadow, state.bounce, is_lamp);
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-08-28 13:55:59 +00:00
|
|
|
/* no BSDF? we can stop here */
|
2012-09-05 08:12:22 +00:00
|
|
|
if(!(sd.flag & SD_BSDF)) {
|
|
|
|
|
shader_release(kg, &sd);
|
2011-08-28 13:55:59 +00:00
|
|
|
break;
|
2012-09-05 08:12:22 +00:00
|
|
|
}
|
2011-08-28 13:55:59 +00:00
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
/* sample BSDF */
|
|
|
|
|
float bsdf_pdf;
|
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
|
|
|
BsdfEval bsdf_eval;
|
2011-04-27 11:58:34 +00:00
|
|
|
float3 bsdf_omega_in;
|
|
|
|
|
differential3 bsdf_domega_in;
|
2011-09-16 13:14:02 +00:00
|
|
|
float bsdf_u = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF_U);
|
|
|
|
|
float bsdf_v = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF_V);
|
2011-04-27 11:58:34 +00:00
|
|
|
int label;
|
|
|
|
|
|
|
|
|
|
label = shader_bsdf_sample(kg, &sd, bsdf_u, bsdf_v, &bsdf_eval,
|
|
|
|
|
&bsdf_omega_in, &bsdf_domega_in, &bsdf_pdf);
|
|
|
|
|
|
2012-09-04 17:28:36 +00:00
|
|
|
shader_release(kg, &sd);
|
|
|
|
|
|
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
|
|
|
if(bsdf_pdf == 0.0f || bsdf_eval_is_zero(&bsdf_eval))
|
2011-04-27 11:58:34 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* modify throughput */
|
2012-06-13 11:44:48 +00:00
|
|
|
path_radiance_bsdf_bounce(L, &throughput, &bsdf_eval, bsdf_pdf, state.bounce, label);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
|
/* set labels */
|
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
|
|
|
if(!(label & LABEL_TRANSPARENT)) {
|
2012-01-31 14:57:46 +00:00
|
|
|
ray_pdf = bsdf_pdf;
|
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
|
|
|
min_ray_pdf = fminf(bsdf_pdf, min_ray_pdf);
|
|
|
|
|
}
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2011-09-01 15:53:36 +00:00
|
|
|
/* update path state */
|
2011-10-16 17:54:43 +00:00
|
|
|
path_state_next(kg, &state, label);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
|
/* setup ray */
|
|
|
|
|
ray.P = ray_offset(sd.P, (label & LABEL_TRANSMIT)? -sd.Ng: sd.Ng);
|
|
|
|
|
ray.D = bsdf_omega_in;
|
|
|
|
|
ray.t = FLT_MAX;
|
|
|
|
|
#ifdef __RAY_DIFFERENTIALS__
|
|
|
|
|
ray.dP = sd.dP;
|
|
|
|
|
ray.dD = bsdf_domega_in;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
2012-06-13 11:44:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
__device float4 kernel_path_non_progressive(KernelGlobals *kg, RNG *rng, int sample, Ray ray, __global float *buffer)
|
|
|
|
|
{
|
|
|
|
|
/* 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);
|
|
|
|
|
|
|
|
|
|
float ray_pdf = 0.0f;
|
|
|
|
|
PathState state;
|
|
|
|
|
int rng_offset = PRNG_BASE_NUM;
|
|
|
|
|
|
|
|
|
|
path_state_init(&state);
|
|
|
|
|
|
|
|
|
|
for(;; rng_offset += PRNG_BOUNCE_NUM) {
|
|
|
|
|
/* intersect scene */
|
|
|
|
|
Intersection isect;
|
|
|
|
|
uint visibility = path_state_ray_visibility(kg, &state);
|
|
|
|
|
|
|
|
|
|
if(!scene_intersect(kg, &ray, visibility, &isect)) {
|
|
|
|
|
/* eval background shader if nothing hit */
|
|
|
|
|
if(kernel_data.background.transparent) {
|
|
|
|
|
L_transparent += average(throughput);
|
|
|
|
|
|
|
|
|
|
#ifdef __PASSES__
|
|
|
|
|
if(!(kernel_data.film.pass_flag & PASS_BACKGROUND))
|
|
|
|
|
#endif
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef __BACKGROUND__
|
|
|
|
|
/* sample background shader */
|
|
|
|
|
float3 L_background = indirect_background(kg, &ray, state.flag, ray_pdf);
|
|
|
|
|
path_radiance_accum_background(&L, throughput, L_background, state.bounce);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* setup shading */
|
|
|
|
|
ShaderData sd;
|
|
|
|
|
shader_setup_from_ray(kg, &sd, &isect, &ray);
|
|
|
|
|
float rbsdf = path_rng(kg, rng, sample, rng_offset + PRNG_BSDF);
|
|
|
|
|
shader_eval_surface(kg, &sd, rbsdf, state.flag);
|
|
|
|
|
shader_merge_closures(kg, &sd);
|
|
|
|
|
|
|
|
|
|
kernel_write_data_passes(kg, buffer, &L, &sd, sample, state.flag, throughput);
|
|
|
|
|
|
|
|
|
|
/* holdout */
|
|
|
|
|
#ifdef __HOLDOUT__
|
|
|
|
|
if((sd.flag & (SD_HOLDOUT|SD_HOLDOUT_MASK))) {
|
|
|
|
|
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
|
2012-08-01 12:59:47 +00:00
|
|
|
holdout_weight = shader_holdout_eval(kg, &sd);
|
2012-06-13 11:44:48 +00:00
|
|
|
|
|
|
|
|
/* any throughput is ok, should all be identical here */
|
|
|
|
|
L_transparent += average(holdout_weight*throughput);
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-05 08:12:22 +00:00
|
|
|
if(sd.flag & SD_HOLDOUT_MASK) {
|
|
|
|
|
shader_release(kg, &sd);
|
2012-06-13 11:44:48 +00:00
|
|
|
break;
|
2012-09-05 08:12:22 +00:00
|
|
|
}
|
2012-06-13 11:44:48 +00:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef __EMISSION__
|
|
|
|
|
/* emission */
|
|
|
|
|
if(sd.flag & SD_EMISSION) {
|
|
|
|
|
float3 emission = indirect_emission(kg, &sd, isect.t, state.flag, ray_pdf);
|
|
|
|
|
path_radiance_accum_emission(&L, throughput, emission, state.bounce);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* transparency termination */
|
|
|
|
|
if(state.flag & PATH_RAY_TRANSPARENT) {
|
|
|
|
|
/* 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 */
|
|
|
|
|
float probability = path_state_terminate_probability(kg, &state, throughput);
|
|
|
|
|
float terminate = path_rng(kg, rng, sample, rng_offset + PRNG_TERMINATE);
|
|
|
|
|
|
2012-09-05 08:12:22 +00:00
|
|
|
if(terminate >= probability) {
|
|
|
|
|
shader_release(kg, &sd);
|
2012-06-13 11:44:48 +00:00
|
|
|
break;
|
2012-09-05 08:12:22 +00:00
|
|
|
}
|
2012-06-13 11:44:48 +00:00
|
|
|
|
|
|
|
|
throughput /= probability;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef __AO__
|
|
|
|
|
/* ambient occlusion */
|
2012-11-06 19:59:02 +00:00
|
|
|
if(kernel_data.integrator.use_ambient_occlusion || (sd.flag & SD_AO)) {
|
2012-06-13 11:44:48 +00:00
|
|
|
int num_samples = kernel_data.integrator.ao_samples;
|
2012-06-15 10:15:10 +00:00
|
|
|
float num_samples_inv = 1.0f/num_samples;
|
2012-09-04 13:29:07 +00:00
|
|
|
float ao_factor = kernel_data.background.ao_factor;
|
2012-11-15 15:37:58 +00:00
|
|
|
float3 ao_N;
|
|
|
|
|
float3 ao_bsdf = shader_bsdf_ao(kg, &sd, ao_factor, &ao_N);
|
2012-06-13 11:44:48 +00:00
|
|
|
|
|
|
|
|
for(int j = 0; j < num_samples; j++) {
|
|
|
|
|
/* todo: solve correlation */
|
|
|
|
|
float bsdf_u = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_BSDF_U);
|
|
|
|
|
float bsdf_v = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_BSDF_V);
|
|
|
|
|
|
|
|
|
|
float3 ao_D;
|
|
|
|
|
float ao_pdf;
|
|
|
|
|
|
2012-11-15 15:37:58 +00:00
|
|
|
sample_cos_hemisphere(ao_N, bsdf_u, bsdf_v, &ao_D, &ao_pdf);
|
2012-06-13 11:44:48 +00:00
|
|
|
|
2012-11-15 21:32:05 +00:00
|
|
|
if(dot(sd.Ng, ao_D) > 0.0f && ao_pdf != 0.0f) {
|
2012-06-13 11:44:48 +00:00
|
|
|
Ray light_ray;
|
|
|
|
|
float3 ao_shadow;
|
|
|
|
|
|
|
|
|
|
light_ray.P = ray_offset(sd.P, sd.Ng);
|
|
|
|
|
light_ray.D = ao_D;
|
|
|
|
|
light_ray.t = kernel_data.background.ao_distance;
|
2012-10-09 18:37:14 +00:00
|
|
|
#ifdef __OBJECT_MOTION__
|
2012-06-13 11:44:48 +00:00
|
|
|
light_ray.time = sd.time;
|
|
|
|
|
#endif
|
|
|
|
|
|
2012-11-15 15:37:58 +00:00
|
|
|
if(!shadow_blocked(kg, &state, &light_ray, &ao_shadow))
|
2012-06-15 10:15:10 +00:00
|
|
|
path_radiance_accum_ao(&L, throughput*num_samples_inv, ao_bsdf, ao_shadow, state.bounce);
|
2012-06-13 11:44:48 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef __EMISSION__
|
|
|
|
|
/* sample illumination from lights to find path contribution */
|
|
|
|
|
if(sd.flag & SD_BSDF_HAS_EVAL) {
|
|
|
|
|
Ray light_ray;
|
|
|
|
|
BsdfEval L_light;
|
|
|
|
|
bool is_lamp;
|
|
|
|
|
|
2012-10-09 18:37:14 +00:00
|
|
|
#ifdef __OBJECT_MOTION__
|
2012-06-13 11:44:48 +00:00
|
|
|
light_ray.time = sd.time;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* lamp sampling */
|
|
|
|
|
for(int i = 0; i < kernel_data.integrator.num_all_lights; i++) {
|
|
|
|
|
int num_samples = light_select_num_samples(kg, i);
|
|
|
|
|
float num_samples_inv = 1.0f/(num_samples*kernel_data.integrator.num_all_lights);
|
|
|
|
|
|
|
|
|
|
if(kernel_data.integrator.pdf_triangles != 0.0f)
|
|
|
|
|
num_samples_inv *= 0.5f;
|
|
|
|
|
|
|
|
|
|
for(int j = 0; j < num_samples; j++) {
|
|
|
|
|
float light_u = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_LIGHT_U);
|
|
|
|
|
float light_v = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_LIGHT_V);
|
|
|
|
|
|
|
|
|
|
if(direct_emission(kg, &sd, i, 0.0f, 0.0f, light_u, light_v, &light_ray, &L_light, &is_lamp)) {
|
|
|
|
|
/* trace shadow ray */
|
|
|
|
|
float3 shadow;
|
|
|
|
|
|
|
|
|
|
if(!shadow_blocked(kg, &state, &light_ray, &shadow)) {
|
|
|
|
|
/* accumulate */
|
|
|
|
|
path_radiance_accum_light(&L, throughput*num_samples_inv, &L_light, shadow, state.bounce, is_lamp);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* mesh light sampling */
|
|
|
|
|
if(kernel_data.integrator.pdf_triangles != 0.0f) {
|
|
|
|
|
int num_samples = kernel_data.integrator.mesh_light_samples;
|
|
|
|
|
float num_samples_inv = 1.0f/num_samples;
|
|
|
|
|
|
|
|
|
|
if(kernel_data.integrator.num_all_lights)
|
|
|
|
|
num_samples_inv *= 0.5f;
|
|
|
|
|
|
|
|
|
|
for(int j = 0; j < num_samples; j++) {
|
|
|
|
|
float light_t = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_LIGHT);
|
|
|
|
|
float light_u = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_LIGHT_U);
|
|
|
|
|
float light_v = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_LIGHT_V);
|
|
|
|
|
|
|
|
|
|
/* only sample triangle lights */
|
|
|
|
|
if(kernel_data.integrator.num_all_lights)
|
|
|
|
|
light_t = 0.5f*light_t;
|
|
|
|
|
|
|
|
|
|
if(direct_emission(kg, &sd, -1, light_t, 0.0f, light_u, light_v, &light_ray, &L_light, &is_lamp)) {
|
|
|
|
|
/* trace shadow ray */
|
|
|
|
|
float3 shadow;
|
|
|
|
|
|
|
|
|
|
if(!shadow_blocked(kg, &state, &light_ray, &shadow)) {
|
|
|
|
|
/* accumulate */
|
|
|
|
|
path_radiance_accum_light(&L, throughput*num_samples_inv, &L_light, shadow, state.bounce, is_lamp);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
for(int i = 0; i< sd.num_closure; i++) {
|
|
|
|
|
const ShaderClosure *sc = &sd.closure[i];
|
|
|
|
|
|
|
|
|
|
if(!CLOSURE_IS_BSDF(sc->type))
|
|
|
|
|
continue;
|
|
|
|
|
/* transparency is not handled here, but in outer loop */
|
|
|
|
|
if(sc->type == CLOSURE_BSDF_TRANSPARENT_ID)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
int num_samples;
|
|
|
|
|
|
|
|
|
|
if(CLOSURE_IS_BSDF_DIFFUSE(sc->type))
|
|
|
|
|
num_samples = kernel_data.integrator.diffuse_samples;
|
|
|
|
|
else if(CLOSURE_IS_BSDF_GLOSSY(sc->type))
|
|
|
|
|
num_samples = kernel_data.integrator.glossy_samples;
|
|
|
|
|
else
|
|
|
|
|
num_samples = kernel_data.integrator.transmission_samples;
|
|
|
|
|
|
|
|
|
|
float num_samples_inv = 1.0f/num_samples;
|
|
|
|
|
|
|
|
|
|
for(int j = 0; j < num_samples; j++) {
|
|
|
|
|
/* sample BSDF */
|
|
|
|
|
float bsdf_pdf;
|
|
|
|
|
BsdfEval bsdf_eval;
|
|
|
|
|
float3 bsdf_omega_in;
|
|
|
|
|
differential3 bsdf_domega_in;
|
|
|
|
|
float bsdf_u = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_BSDF_U);
|
|
|
|
|
float bsdf_v = path_rng(kg, rng, sample*num_samples + j, rng_offset + PRNG_BSDF_V);
|
|
|
|
|
int label;
|
|
|
|
|
|
|
|
|
|
label = shader_bsdf_sample_closure(kg, &sd, sc, bsdf_u, bsdf_v, &bsdf_eval,
|
|
|
|
|
&bsdf_omega_in, &bsdf_domega_in, &bsdf_pdf);
|
|
|
|
|
|
|
|
|
|
if(bsdf_pdf == 0.0f || bsdf_eval_is_zero(&bsdf_eval))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* modify throughput */
|
|
|
|
|
float3 tp = throughput;
|
|
|
|
|
path_radiance_bsdf_bounce(&L, &tp, &bsdf_eval, bsdf_pdf, state.bounce, label);
|
|
|
|
|
|
|
|
|
|
/* set labels */
|
|
|
|
|
float min_ray_pdf = FLT_MAX;
|
|
|
|
|
|
|
|
|
|
if(!(label & LABEL_TRANSPARENT))
|
|
|
|
|
min_ray_pdf = fminf(bsdf_pdf, min_ray_pdf);
|
|
|
|
|
|
|
|
|
|
/* modify path state */
|
|
|
|
|
PathState ps = state;
|
|
|
|
|
path_state_next(kg, &ps, label);
|
|
|
|
|
|
|
|
|
|
/* setup ray */
|
2012-09-03 17:41:49 +00:00
|
|
|
Ray bsdf_ray;
|
|
|
|
|
|
|
|
|
|
bsdf_ray.P = ray_offset(sd.P, (label & LABEL_TRANSMIT)? -sd.Ng: sd.Ng);
|
|
|
|
|
bsdf_ray.D = bsdf_omega_in;
|
|
|
|
|
bsdf_ray.t = FLT_MAX;
|
2012-06-13 11:44:48 +00:00
|
|
|
#ifdef __RAY_DIFFERENTIALS__
|
2012-09-03 17:41:49 +00:00
|
|
|
bsdf_ray.dP = sd.dP;
|
|
|
|
|
bsdf_ray.dD = bsdf_domega_in;
|
|
|
|
|
#endif
|
2012-10-09 18:37:14 +00:00
|
|
|
#ifdef __OBJECT_MOTION__
|
2012-09-03 17:41:49 +00:00
|
|
|
bsdf_ray.time = sd.time;
|
2012-06-13 11:44:48 +00:00
|
|
|
#endif
|
|
|
|
|
|
2012-09-03 17:41:49 +00:00
|
|
|
kernel_path_indirect(kg, rng, sample*num_samples, bsdf_ray, buffer,
|
2012-06-13 17:34:47 +00:00
|
|
|
tp*num_samples_inv, min_ray_pdf, bsdf_pdf, ps, rng_offset+PRNG_BOUNCE_NUM, &L);
|
2012-06-13 11:44:48 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* continue in case of transparency */
|
|
|
|
|
throughput *= shader_bsdf_transparency(kg, &sd);
|
2012-09-04 17:28:36 +00:00
|
|
|
shader_release(kg, &sd);
|
2012-06-13 11:44:48 +00:00
|
|
|
|
|
|
|
|
if(is_zero(throughput))
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
path_state_next(kg, &state, LABEL_TRANSPARENT);
|
|
|
|
|
ray.P = ray_offset(sd.P, -sd.Ng);
|
2012-11-21 13:22:24 +00:00
|
|
|
ray.t -= sd.ray_length; /* clipping works through transparent */
|
2012-06-13 11:44:48 +00:00
|
|
|
}
|
2011-04-27 11:58:34 +00:00
|
|
|
|
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
|
|
|
float3 L_sum = path_radiance_sum(kg, &L);
|
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
|
|
|
|
2012-04-05 15:17:45 +00:00
|
|
|
#ifdef __CLAMP_SAMPLE__
|
|
|
|
|
path_radiance_clamp(&L, &L_sum, kernel_data.integrator.sample_clamp);
|
|
|
|
|
#endif
|
|
|
|
|
|
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
|
|
|
kernel_write_light_passes(kg, buffer, &L, sample);
|
|
|
|
|
|
|
|
|
|
return make_float4(L_sum.x, L_sum.y, L_sum.z, 1.0f - L_transparent);
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
2012-06-13 11:44:48 +00:00
|
|
|
#endif
|
|
|
|
|
|
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
|
|
|
__device void kernel_path_trace(KernelGlobals *kg,
|
|
|
|
|
__global float *buffer, __global uint *rng_state,
|
|
|
|
|
int sample, int x, int y, int offset, int stride)
|
2011-04-27 11:58:34 +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
|
|
|
/* buffer offset */
|
|
|
|
|
int index = offset + x + y*stride;
|
|
|
|
|
int pass_stride = kernel_data.film.pass_stride;
|
|
|
|
|
|
|
|
|
|
rng_state += index;
|
|
|
|
|
buffer += index*pass_stride;
|
|
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
/* initialize random numbers */
|
|
|
|
|
RNG rng;
|
|
|
|
|
|
|
|
|
|
float filter_u;
|
|
|
|
|
float filter_v;
|
|
|
|
|
|
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
|
|
|
path_rng_init(kg, rng_state, sample, &rng, x, y, &filter_u, &filter_v);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
|
/* sample camera ray */
|
|
|
|
|
Ray ray;
|
|
|
|
|
|
2011-09-16 13:14:02 +00:00
|
|
|
float lens_u = path_rng(kg, &rng, sample, PRNG_LENS_U);
|
|
|
|
|
float lens_v = path_rng(kg, &rng, sample, PRNG_LENS_V);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2012-10-09 18:37:14 +00:00
|
|
|
#ifdef __CAMERA_MOTION__
|
2012-04-30 12:49:26 +00:00
|
|
|
float time = path_rng(kg, &rng, sample, PRNG_TIME);
|
|
|
|
|
#else
|
|
|
|
|
float time = 0.0f;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
camera_sample(kg, x, y, filter_u, filter_v, lens_u, lens_v, time, &ray);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
|
/* integrate */
|
2012-05-04 16:20:51 +00:00
|
|
|
float4 L;
|
|
|
|
|
|
2012-06-13 11:44:48 +00:00
|
|
|
if (ray.t != 0.0f) {
|
|
|
|
|
#ifdef __NON_PROGRESSIVE__
|
|
|
|
|
if(kernel_data.integrator.progressive)
|
|
|
|
|
#endif
|
|
|
|
|
L = kernel_path_progressive(kg, &rng, sample, ray, buffer);
|
|
|
|
|
#ifdef __NON_PROGRESSIVE__
|
|
|
|
|
else
|
|
|
|
|
L = kernel_path_non_progressive(kg, &rng, sample, ray, buffer);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
2012-05-04 16:20:51 +00:00
|
|
|
else
|
|
|
|
|
L = make_float4(0.f, 0.f, 0.f, 0.f);
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
|
/* accumulate result in output buffer */
|
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
|
|
|
kernel_write_pass_float4(buffer, sample, L);
|
2011-04-27 11:58:34 +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
|
|
|
path_rng_end(kg, rng_state, rng);
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CCL_NAMESPACE_END
|
|
|
|
|
|
