Commit: c571be4e05788b8d3447a0bfe59942ebb4464750
Author: Brecht Van Lommel
Date: Wed Nov 1 21:07:15 2017 +0100
Branches: master
https://developer.blender.org/rBc571be4e05788b8d3447a0bfe59942ebb4464750
Code refactor: sum transparent and absorption weights outside closures.
===================================================================
M intern/cycles/kernel/closure/bsdf_transparent.h
M intern/cycles/kernel/closure/volume.h
M intern/cycles/kernel/kernel_shader.h
M intern/cycles/kernel/kernel_types.h
M intern/cycles/kernel/kernel_volume.h
M intern/cycles/kernel/osl/osl_closures.cpp
M intern/cycles/kernel/osl/osl_closures.h
M intern/cycles/kernel/svm/svm.h
M intern/cycles/kernel/svm/svm_closure.h
===================================================================
diff --git a/intern/cycles/kernel/closure/bsdf_transparent.h
b/intern/cycles/kernel/closure/bsdf_transparent.h
index 3c2fd8004df..22ca7f3847e 100644
--- a/intern/cycles/kernel/closure/bsdf_transparent.h
+++ b/intern/cycles/kernel/closure/bsdf_transparent.h
@@ -35,10 +35,22 @@
CCL_NAMESPACE_BEGIN
-ccl_device int bsdf_transparent_setup(ShaderClosure *sc)
+ccl_device void bsdf_transparent_setup(ShaderData *sd, const float3 weight)
{
- sc->type = CLOSURE_BSDF_TRANSPARENT_ID;
- return SD_BSDF|SD_TRANSPARENT;
+ if(sd->flag & SD_TRANSPARENT) {
+ sd->closure_transparent_extinction += weight;
+ }
+ else {
+ sd->flag |= SD_BSDF|SD_TRANSPARENT;
+ sd->closure_transparent_extinction = weight;
+ }
+
+ ShaderClosure *bsdf = bsdf_alloc(sd, sizeof(ShaderClosure), weight);
+
+ if(bsdf) {
+ bsdf->N = sd->N;
+ bsdf->type = CLOSURE_BSDF_TRANSPARENT_ID;
+ }
}
ccl_device float3 bsdf_transparent_eval_reflect(const ShaderClosure *sc, const
float3 I, const float3 omega_in, float *pdf)
diff --git a/intern/cycles/kernel/closure/volume.h
b/intern/cycles/kernel/closure/volume.h
index 01e67c7c2fd..4bb5e680723 100644
--- a/intern/cycles/kernel/closure/volume.h
+++ b/intern/cycles/kernel/closure/volume.h
@@ -19,14 +19,27 @@
CCL_NAMESPACE_BEGIN
+/* VOLUME EXTINCTION */
+
+ccl_device void volume_extinction_setup(ShaderData *sd, float3 weight)
+{
+ if(sd->flag & SD_EXTINCTION) {
+ sd->closure_transparent_extinction += weight;
+ }
+ else {
+ sd->flag |= SD_EXTINCTION;
+ sd->closure_transparent_extinction = weight;
+ }
+}
+
+/* HENYEY-GREENSTEIN CLOSURE */
+
typedef ccl_addr_space struct HenyeyGreensteinVolume {
SHADER_CLOSURE_BASE;
float g;
} HenyeyGreensteinVolume;
-/* HENYEY-GREENSTEIN CLOSURE */
-
/* Given cosine between rays, return probability density that a photon bounces
* to that direction. The g parameter controls how different it is from the
* uniform sphere. g=0 uniform diffuse-like, g=1 close to sharp single ray. */
@@ -110,15 +123,6 @@ ccl_device int volume_henyey_greenstein_sample(const
ShaderClosure *sc, float3 I
return LABEL_VOLUME_SCATTER;
}
-/* ABSORPTION VOLUME CLOSURE */
-
-ccl_device int volume_absorption_setup(ShaderClosure *sc)
-{
- sc->type = CLOSURE_VOLUME_ABSORPTION_ID;
-
- return SD_ABSORPTION;
-}
-
/* VOLUME CLOSURE */
ccl_device float3 volume_phase_eval(const ShaderData *sd, const ShaderClosure
*sc, float3 omega_in, float *pdf)
diff --git a/intern/cycles/kernel/kernel_shader.h
b/intern/cycles/kernel/kernel_shader.h
index 30195605f2e..1ba37eda8cc 100644
--- a/intern/cycles/kernel/kernel_shader.h
+++ b/intern/cycles/kernel/kernel_shader.h
@@ -764,30 +764,30 @@ ccl_device void shader_bsdf_blur(KernelGlobals *kg,
ShaderData *sd, float roughn
ccl_device float3 shader_bsdf_transparency(KernelGlobals *kg, const ShaderData
*sd)
{
- if(sd->flag & SD_HAS_ONLY_VOLUME)
+ if(sd->flag & SD_HAS_ONLY_VOLUME) {
return make_float3(1.0f, 1.0f, 1.0f);
-
- float3 eval = make_float3(0.0f, 0.0f, 0.0f);
-
- for(int i = 0; i < sd->num_closure; i++) {
- const ShaderClosure *sc = &sd->closure[i];
-
- if(sc->type == CLOSURE_BSDF_TRANSPARENT_ID) // todo: make this
work for osl
- eval += sc->weight;
}
-
- return eval;
+ else if(sd->flag & SD_TRANSPARENT) {
+ return sd->closure_transparent_extinction;
+ }
+ else {
+ return make_float3(0.0f, 0.0f, 0.0f);
+ }
}
ccl_device void shader_bsdf_disable_transparency(KernelGlobals *kg, ShaderData
*sd)
{
- for(int i = 0; i < sd->num_closure; i++) {
- ShaderClosure *sc = &sd->closure[i];
+ if(sd->flag & SD_TRANSPARENT) {
+ for(int i = 0; i < sd->num_closure; i++) {
+ ShaderClosure *sc = &sd->closure[i];
- if(sc->type == CLOSURE_BSDF_TRANSPARENT_ID) {
- sc->sample_weight = 0.0f;
- sc->weight = make_float3(0.0f, 0.0f, 0.0f);
+ if(sc->type == CLOSURE_BSDF_TRANSPARENT_ID) {
+ sc->sample_weight = 0.0f;
+ sc->weight = make_float3(0.0f, 0.0f, 0.0f);
+ }
}
+
+ sd->flag &= ~SD_TRANSPARENT;
}
}
diff --git a/intern/cycles/kernel/kernel_types.h
b/intern/cycles/kernel/kernel_types.h
index acd06b57a81..cac3ef226f9 100644
--- a/intern/cycles/kernel/kernel_types.h
+++ b/intern/cycles/kernel/kernel_types.h
@@ -822,8 +822,8 @@ enum ShaderDataFlag {
SD_BSSRDF = (1 << 4),
/* Shader has holdout closure. */
SD_HOLDOUT = (1 << 5),
- /* Shader has volume absorption closure. */
- SD_ABSORPTION = (1 << 6),
+ /* Shader has non-zero volume extinction. */
+ SD_EXTINCTION = (1 << 6),
/* Shader has have volume phase (scatter) closure. */
SD_SCATTER = (1 << 7),
/* Shader has AO closure. */
@@ -838,7 +838,7 @@ enum ShaderDataFlag {
SD_BSDF_HAS_EVAL |
SD_BSSRDF |
SD_HOLDOUT |
- SD_ABSORPTION |
+ SD_EXTINCTION |
SD_SCATTER |
SD_AO |
SD_BSDF_NEEDS_LCG),
@@ -991,6 +991,7 @@ typedef ccl_addr_space struct ShaderData {
/* Closure weights summed directly, so we can evaluate
* emission and shadow transparency with MAX_CLOSURE 0. */
float3 closure_emission_background;
+ float3 closure_transparent_extinction;
/* At the end so we can adjust size in ShaderDataTinyStorage. */
struct ShaderClosure closure[MAX_CLOSURE];
diff --git a/intern/cycles/kernel/kernel_volume.h
b/intern/cycles/kernel/kernel_volume.h
index 657417e1642..89af16aa9be 100644
--- a/intern/cycles/kernel/kernel_volume.h
+++ b/intern/cycles/kernel/kernel_volume.h
@@ -30,7 +30,7 @@ typedef enum VolumeIntegrateResult {
* sigma_t = sigma_a + sigma_s */
typedef struct VolumeShaderCoefficients {
- float3 sigma_a;
+ float3 sigma_t;
float3 sigma_s;
float3 emission;
} VolumeShaderCoefficients;
@@ -45,20 +45,13 @@ ccl_device_inline bool
volume_shader_extinction_sample(KernelGlobals *kg,
sd->P = P;
shader_eval_volume(kg, sd, state, state->volume_stack, PATH_RAY_SHADOW);
- if(!(sd->flag & (SD_ABSORPTION|SD_SCATTER)))
+ if(sd->flag & SD_EXTINCTION) {
+ *extinction = sd->closure_transparent_extinction;
+ return true;
+ }
+ else {
return false;
-
- float3 sigma_t = make_float3(0.0f, 0.0f, 0.0f);
-
- for(int i = 0; i < sd->num_closure; i++) {
- const ShaderClosure *sc = &sd->closure[i];
-
- if(CLOSURE_IS_VOLUME(sc->type))
- sigma_t += sc->weight;
}
-
- *extinction = sigma_t;
- return true;
}
/* evaluate shader to get absorption, scattering and emission at P */
@@ -71,30 +64,27 @@ ccl_device_inline bool volume_shader_sample(KernelGlobals
*kg,
sd->P = P;
shader_eval_volume(kg, sd, state, state->volume_stack, state->flag);
- if(!(sd->flag & (SD_ABSORPTION|SD_SCATTER|SD_EMISSION)))
+ if(!(sd->flag & (SD_EXTINCTION|SD_SCATTER|SD_EMISSION)))
return false;
- coeff->sigma_a = make_float3(0.0f, 0.0f, 0.0f);
coeff->sigma_s = make_float3(0.0f, 0.0f, 0.0f);
+ coeff->sigma_t = (sd->flag & SD_EXTINCTION)?
sd->closure_transparent_extinction:
+ make_float3(0.0f, 0.0f,
0.0f);
coeff->emission = (sd->flag & SD_EMISSION)?
sd->closure_emission_background:
make_float3(0.0f, 0.0f,
0.0f);
- for(int i = 0; i < sd->num_closure; i++) {
- const ShaderClosure *sc = &sd->closure[i];
-
- if(sc->type == CLOSURE_VOLUME_ABSORPTION_ID)
- coeff->sigma_a += sc->weight;
- else if(CLOSURE_IS_VOLUME(sc->type))
- coeff->sigma_s += sc->weight;
- }
-
- /* when at the max number of bounces, treat scattering as absorption */
if(sd->flag & SD_SCATTER) {
- if(state->volume_bounce >=
kernel_data.integrator.max_volume_bounce) {
- coeff->sigma_a += coeff->sigma_s;
- coeff->sigma_s = make_float3(0.0f, 0.0f, 0.0f);
+ if(state->volume_bounce <
kernel_data.integrator.max_volume_bounce) {
+ for(int i = 0; i < sd->num_closure; i++) {
+ const ShaderClosure *sc = &sd->closure[i];
+
+ if(CLOSURE_IS_VOLUME(sc->type))
+ coeff->sigma_s += sc->weight;
+ }
+ }
+ else {
+ /* When at the max number of bounces, clear scattering.
*/
sd->flag &= ~SD_SCATTER;
- sd->flag |= SD_ABSORPTION;
}
}
@@ -335,8 +325,8 @@ ccl_device float3
kernel_volume_emission_integrate(VolumeShaderCoefficients *coe
* todo: we should use an epsilon to avoid precision issues near zero
sigma_t */
float3 emission = coeff->emission;
- if(closure_flag & SD_ABSORPTION) {
- float3 sigma_t = coeff->sigma_a + coeff->sigma_s;
+ if(closure_flag & SD_EXTINCTION) {
+ float3 sigma_t = coeff->sigma_t;
emission.x *= (sigma_t.x > 0.0f)? (1.0f -
transmittance.x)/sigma_t.x: t;
emission.y *= (sigma_t.y > 0.0f)? (1.0f -
transmittance.y)/sigma_t.y: t;
@@ -374,7 +364,7 @@ ccl_device VolumeIntegrateResult
kernel_volume_integrate_homogeneous(
/* randomly scatter, and if we do t is shortened */
if(closure_flag & SD_SCATTER) {
/* extinction coefficient */
- float3 sigma_t = coeff.sigma_a + coeff.sigma_s;
+ float3 sigma_t = coeff.sigma_t;
/* pick random color channel, we use the Veach one-sample
* model with balance heuristic for the channels */
@@ -425,22 +415,22 @@ ccl_device VolumeIntegrateResult
kernel_volume_integrate_homogeneous(
}
else
#endif
- if(closure_flag & SD_ABSORPTION) {
+ if(closure_flag & SD_EXTINCTION) {
/* absorption only, no sampling needed */
- float3 transmittance =
volume_color_transmittance(coeff.sigma_a, t);
+ float3 transmittance =
volume_color_transmittance(coeff.sigma_t, t);
new_tp = *throughput * transmittance;
}
/* integrate emission attenuated by extinction */
if(L && (closure_flag & SD_EMISSION)) {
- float3 sigma_t = coeff.sigma_a + coeff.sigma_s;
+ float3 sigma_t = coeff.sigma_t;
float3 transmittance = volume_color_transmittance(sigma_t,
ray->t);
float3 emission = kernel_volume_emission_integrate(&coeff,
closure_flag, transmittance, ray->t);
path_radiance_accum_emission(L, state, *throughput, emission);
}
/* modify throughput */
- if(closure_flag & (SD_ABSORPTION|SD_SCATTER)) {
+ if(closure_flag & SD_EXTINCTION) {
*throughput = new_tp;
/* prepare to scatter to new direction */
@@ -507,10 +497,10 @@ ccl_device VolumeIntegrateResult
kernel_volume_integrate_heterogeneous_distance(
/* distance sampling */
#ifdef __VOLUME_SCATTER__
- if((clo
@@ Diff output truncated at 10240 characters. @@
_______________________________________________
Bf-blender-cvs mailing list
[email protected]
https://lists.blender.org/mailman/listinfo/bf-blender-cvs
