ilusha/blender
1
0
Fork 0
mirror of https://github.com/blender/blender synced 2026-09-29 04:37:17 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Refactor: Cycles: Separate shader flags and runtime flags

Browse source 
We are running out of bits. Split the original `ShaderDataFlag` into
`ShaderRuntimeFlag`, which is determined by closures in the shader and
set up during rendering, and `ShaderDataFlag`, which is the same for the
whole shader graph and hence determined during shader compilation

The size of `ShaderData` did not change due to padding

Pull Request: https://projects.blender.org/blender/blender/pulls/161856
This commit is contained in:
Weizhen Huang 2026-07-27 19:31:18 +02:00 • committed by Weizhen Huang
parent 6a379f755f
commit cc93b7f5a4
63 changed files with 305 additions and 295 deletions
Download patch file Download diff file Expand all files Collapse all files

11
intern/cycles/kernel/bake/bake.h
View file

@ -38,7 +38,7 @@ ccl_device void kernel_displace_evaluate(KernelGlobals kg,
const float3 P = sd.P;
displacement_shader_eval(kg, state, &sd);
float3 D = sd.P - P;
if (sd.flag & SD_CACHE_MISS) {
if (sd.runtime_flag & SR_CACHE_MISS) {
*cache_miss = true;
}
object_inverse_dir_transform(kg, &sd, &D);
@ -90,7 +90,7 @@ ccl_device void kernel_background_evaluate(KernelGlobals kg,
surface_shader_eval<KERNEL_FEATURE_NODE_MASK_SURFACE_LIGHT &
~(KERNEL_FEATURE_NODE_RAYTRACE | KERNEL_FEATURE_NODE_LIGHT_PATH)>(
kg, state, &sd, nullptr, PATH_RAY_VISIBILITY_NONE, path_flag);
if (sd.flag & SD_CACHE_MISS) {
if (sd.runtime_flag & SR_CACHE_MISS) {
*cache_miss = true;
}
@ -133,7 +133,7 @@ ccl_device void kernel_curve_shadow_transparency_evaluate(
~(KERNEL_FEATURE_NODE_RAYTRACE | KERNEL_FEATURE_NODE_LIGHT_PATH)>(
kg, state, &sd, nullptr, PATH_RAY_VISIBILITY_SHADOW, PATH_RAY_FLAG_NONE);
if (sd.flag & SD_CACHE_MISS) {
if (sd.runtime_flag & SR_CACHE_MISS) {
*cache_miss = true;
}
@ -167,7 +167,8 @@ ccl_device void kernel_volume_density_evaluate(KernelGlobals kg,
/* Setup shader data. */
ShaderData sd;
shader_setup_from_volume(&sd, &ray, in.object);
sd.flag = SD_IS_VOLUME_SHADER_EVAL;
sd.runtime_flag = SR_IS_VOLUME_SHADER_EVAL;
sd.shader_flag = 0;
/* For stochastic texture sampling. */
sd.lcg_state = lcg_state_init(offset, 0, 0, 0x15b4f88d);
@ -217,7 +218,7 @@ ccl_device void kernel_volume_density_evaluate(KernelGlobals kg,
KERNEL_FEATURE_NODE_MASK_VOLUME & ~KERNEL_FEATURE_NODE_LIGHT_PATH>(
kg, state, &sd, entry, path_visibility, path_flag);
if (sd.flag & SD_CACHE_MISS) {
if (sd.runtime_flag & SR_CACHE_MISS) {
/* Note we keep rendering other samples so we find all cache misses in one go. */
*cache_miss = true;
}

5
intern/cycles/kernel/camera/camera.h
View file

@ -324,14 +324,15 @@ ccl_device_inline Spectrum camera_sample_custom(KernelGlobals kg,
sd->prim = PRIM_NONE;
sd->shader = SHADER_NONE;
sd->type = PRIMITIVE_NONE;
sd->flag = 0;
sd->runtime_flag = 0;
sd->shader_flag = 0;
/* Execute OSL shader to sample position, direction and transmission. */
packed_float3 P, dPdx, dPdy, D, dDdx, dDdy, throughput;
r_cache_miss = false;
throughput = osl_eval_camera(
kg, sd, sensor, dSdx, dSdy, rand_lens, P, dPdx, dPdy, D, dDdx, dDdy);
if (sd->flag & SD_CACHE_MISS) {
if (sd->runtime_flag & SR_CACHE_MISS) {
r_cache_miss = true;
return zero_spectrum();
}

8
intern/cycles/kernel/closure/alloc.h
View file

@ -52,7 +52,7 @@ ccl_device ccl_private void *closure_alloc_extra(ccl_private ShaderData *sd, con
return (ccl_private void *)(sd->closure + sd->num_closure + sd->num_closure_left);
}
ccl_device_inline float closure_sample_weight(const int flag, ccl_private Spectrum &weight)
ccl_device_inline float closure_sample_weight(const int runtime_flag, ccl_private Spectrum &weight)
{
kernel_assert(isfinite_safe(weight));
@ -66,7 +66,7 @@ ccl_device_inline float closure_sample_weight(const int flag, ccl_private Spectr
* the cutoff. */
/* Use comparison this way to help dealing with non-finite weight: if the average is not finite
* we will not allocate new closure. */
if ((sample_weight >= CLOSURE_WEIGHT_CUTOFF) || (flag & SD_IS_VOLUME_SHADER_EVAL)) {
if ((sample_weight >= CLOSURE_WEIGHT_CUTOFF) || (runtime_flag & SR_IS_VOLUME_SHADER_EVAL)) {
return sample_weight;
}
@ -77,7 +77,7 @@ ccl_device_inline ccl_private ShaderClosure *bsdf_alloc(ccl_private ShaderData *
const int size,
Spectrum weight)
{
const float sample_weight = closure_sample_weight(sd->flag, weight);
const float sample_weight = closure_sample_weight(sd->runtime_flag, weight);
if (!(sample_weight > 0.0f)) {
return nullptr;
}
@ -102,7 +102,7 @@ ccl_device_inline ccl_private Bsdf *bsdf_alloc_maybe_emission(ccl_private Shader
if (path_flag & PATH_RAY_EMISSION) {
/* When evaluating emission we don't allocate closures, but we still need a valid closure to
* compute the weight. */
const float sample_weight = closure_sample_weight(sd->flag, weight);
const float sample_weight = closure_sample_weight(sd->runtime_flag, weight);
if (!(sample_weight > 0.0f)) {
return nullptr;
}

2
intern/cycles/kernel/closure/bsdf.h
View file

@ -123,7 +123,7 @@ ccl_device_inline float bump_shadowing_term(const ccl_private ShaderData *sd,
}
/* When bump map correction is not used do skip the smoothing. */
if ((sd->flag & SD_USE_BUMP_MAP_CORRECTION) == 0) {
if ((sd->shader_flag & SD_USE_BUMP_MAP_CORRECTION) == 0) {
return 1.0f;
}

2
intern/cycles/kernel/closure/bsdf_ashikhmin_shirley.h
View file

@ -29,7 +29,7 @@ ccl_device int bsdf_ashikhmin_shirley_setup(ccl_private MicrofacetBsdf *bsdf)
bsdf->fresnel_type = MicrofacetFresnel::NONE;
bsdf->type = CLOSURE_BSDF_ASHIKHMIN_SHIRLEY_ID;
return SD_BSDF | SD_BSDF_HAS_EVAL;
return SR_BSDF | SR_BSDF_HAS_EVAL;
}
ccl_device void bsdf_ashikhmin_shirley_blur(ccl_private ShaderClosure *sc, const float roughness)

2
intern/cycles/kernel/closure/bsdf_ashikhmin_velvet.h
View file

@ -29,7 +29,7 @@ ccl_device int bsdf_ashikhmin_velvet_setup(ccl_private VelvetBsdf *bsdf)
bsdf->type = CLOSURE_BSDF_ASHIKHMIN_VELVET_ID;
return SD_BSDF | SD_BSDF_HAS_EVAL;
return SR_BSDF | SR_BSDF_HAS_EVAL;
}
ccl_device Spectrum bsdf_ashikhmin_velvet_eval(const ccl_private ShaderClosure *sc,

2
intern/cycles/kernel/closure/bsdf_burley.h
View file

@ -40,7 +40,7 @@ ccl_device int bsdf_burley_setup(ccl_private BurleyBsdf *bsdf, const float rough
{
bsdf->type = CLOSURE_BSDF_BURLEY_ID;
bsdf->roughness = saturatef(roughness);
return SD_BSDF | SD_BSDF_HAS_EVAL;
return SR_BSDF | SR_BSDF_HAS_EVAL;
}
ccl_device Spectrum bsdf_burley_eval(ccl_private const ShaderClosure *sc,

4
intern/cycles/kernel/closure/bsdf_diffuse.h
View file

@ -31,7 +31,7 @@ ccl_device void bsdf_diffuse_setup(ccl_private ShaderData *sd,
if (bsdf) {
bsdf->N = N;
bsdf->type = CLOSURE_BSDF_DIFFUSE_ID;
sd->flag |= (SD_BSDF | SD_BSDF_HAS_EVAL);
sd->runtime_flag |= (SR_BSDF | SR_BSDF_HAS_EVAL);
}
}
@ -83,7 +83,7 @@ ccl_device void bsdf_translucent_setup(ccl_private ShaderData *sd,
if (bsdf) {
bsdf->N = N;
bsdf->type = CLOSURE_BSDF_TRANSLUCENT_ID;
sd->flag |= (SD_BSDF | SD_BSDF_HAS_EVAL | SD_BSDF_HAS_TRANSMISSION);
sd->runtime_flag |= (SR_BSDF | SR_BSDF_HAS_EVAL | SR_BSDF_HAS_TRANSMISSION);
}
}

2
intern/cycles/kernel/closure/bsdf_diffuse_ramp.h
View file

@ -43,7 +43,7 @@ ccl_device float3 bsdf_diffuse_ramp_get_color(const float3 colors[8], float pos)
ccl_device int bsdf_diffuse_ramp_setup(DiffuseRampBsdf *bsdf)
{
bsdf->type = CLOSURE_BSDF_DIFFUSE_RAMP_ID;
return SD_BSDF | SD_BSDF_HAS_EVAL;
return SR_BSDF | SR_BSDF_HAS_EVAL;
}
ccl_device void bsdf_diffuse_ramp_blur(ccl_private ShaderClosure * /*sc*/,

4
intern/cycles/kernel/closure/bsdf_hair.h
View file

@ -29,7 +29,7 @@ ccl_device int bsdf_hair_reflection_setup(ccl_private HairBsdf *bsdf)
bsdf->type = CLOSURE_BSDF_HAIR_REFLECTION_ID;
bsdf->roughness1 = clamp(bsdf->roughness1, 0.001f, 1.0f);
bsdf->roughness2 = clamp(bsdf->roughness2, 0.001f, 1.0f);
return SD_BSDF | SD_BSDF_HAS_EVAL;
return SR_BSDF | SR_BSDF_HAS_EVAL;
}
ccl_device int bsdf_hair_transmission_setup(ccl_private HairBsdf *bsdf)
@ -37,7 +37,7 @@ ccl_device int bsdf_hair_transmission_setup(ccl_private HairBsdf *bsdf)
bsdf->type = CLOSURE_BSDF_HAIR_TRANSMISSION_ID;
bsdf->roughness1 = clamp(bsdf->roughness1, 0.001f, 1.0f);
bsdf->roughness2 = clamp(bsdf->roughness2, 0.001f, 1.0f);
return SD_BSDF | SD_BSDF_HAS_EVAL | SD_BSDF_HAS_TRANSMISSION;
return SR_BSDF | SR_BSDF_HAS_EVAL | SR_BSDF_HAS_TRANSMISSION;
}
ccl_device Spectrum bsdf_hair_reflection_eval(const ccl_private ShaderClosure *sc,

18
intern/cycles/kernel/closure/bsdf_microfacet.h
View file

@ -681,7 +681,7 @@ ccl_device_forceinline bool roughness_is_almost_specular(const float alpha_x, co
/* A specular BSDF has no eval. */
ccl_device_forceinline int bsdf_microfacet_eval_flag(const ccl_private MicrofacetBsdf *bsdf)
{
return roughness_is_almost_specular(bsdf->alpha_x, bsdf->alpha_y) ? 0 : SD_BSDF_HAS_EVAL;
return roughness_is_almost_specular(bsdf->alpha_x, bsdf->alpha_y) ? 0 : SR_BSDF_HAS_EVAL;
}
template<MicrofacetType m_type>
@ -1068,7 +1068,7 @@ ccl_device int bsdf_microfacet_ggx_setup(ccl_private MicrofacetBsdf *bsdf)
bsdf->energy_scale = 1.0f;
bsdf->type = CLOSURE_BSDF_MICROFACET_GGX_ID;
return SD_BSDF | bsdf_microfacet_eval_flag(bsdf);
return SR_BSDF | bsdf_microfacet_eval_flag(bsdf);
}
ccl_device int bsdf_microfacet_ggx_refraction_setup(ccl_private MicrofacetBsdf *bsdf)
@ -1080,7 +1080,7 @@ ccl_device int bsdf_microfacet_ggx_refraction_setup(ccl_private MicrofacetBsdf *
bsdf->energy_scale = 1.0f;
bsdf->type = CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID;
return SD_BSDF | SD_BSDF_HAS_TRANSMISSION | bsdf_microfacet_eval_flag(bsdf);
return SR_BSDF | SR_BSDF_HAS_TRANSMISSION | bsdf_microfacet_eval_flag(bsdf);
}
ccl_device int bsdf_microfacet_ggx_glass_setup(ccl_private MicrofacetBsdf *bsdf)
@ -1092,7 +1092,7 @@ ccl_device int bsdf_microfacet_ggx_glass_setup(ccl_private MicrofacetBsdf *bsdf)
bsdf->energy_scale = 1.0f;
bsdf->type = CLOSURE_BSDF_MICROFACET_GGX_GLASS_ID;
return SD_BSDF | SD_BSDF_HAS_TRANSMISSION | bsdf_microfacet_eval_flag(bsdf);
return SR_BSDF | SR_BSDF_HAS_TRANSMISSION | bsdf_microfacet_eval_flag(bsdf);
}
ccl_device void bsdf_microfacet_blur(ccl_private ShaderClosure *sc, const float roughness)
@ -1143,7 +1143,7 @@ ccl_device int bsdf_microfacet_beckmann_setup(ccl_private MicrofacetBsdf *bsdf)
bsdf->fresnel_type = MicrofacetFresnel::NONE;
bsdf->type = CLOSURE_BSDF_MICROFACET_BECKMANN_ID;
return SD_BSDF | bsdf_microfacet_eval_flag(bsdf);
return SR_BSDF | bsdf_microfacet_eval_flag(bsdf);
}
ccl_device int bsdf_microfacet_beckmann_refraction_setup(ccl_private MicrofacetBsdf *bsdf)
@ -1154,7 +1154,7 @@ ccl_device int bsdf_microfacet_beckmann_refraction_setup(ccl_private MicrofacetB
bsdf->fresnel_type = MicrofacetFresnel::NONE;
bsdf->type = CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID;
return SD_BSDF | SD_BSDF_HAS_TRANSMISSION | bsdf_microfacet_eval_flag(bsdf);
return SR_BSDF | SR_BSDF_HAS_TRANSMISSION | bsdf_microfacet_eval_flag(bsdf);
}
ccl_device int bsdf_microfacet_beckmann_glass_setup(ccl_private MicrofacetBsdf *bsdf)
@ -1165,7 +1165,7 @@ ccl_device int bsdf_microfacet_beckmann_glass_setup(ccl_private MicrofacetBsdf *
bsdf->fresnel_type = MicrofacetFresnel::DIELECTRIC;
bsdf->type = CLOSURE_BSDF_MICROFACET_BECKMANN_GLASS_ID;
return SD_BSDF | SD_BSDF_HAS_TRANSMISSION | bsdf_microfacet_eval_flag(bsdf);
return SR_BSDF | SR_BSDF_HAS_TRANSMISSION | bsdf_microfacet_eval_flag(bsdf);
}
ccl_device Spectrum bsdf_microfacet_beckmann_eval(KernelGlobals kg,
@ -1269,7 +1269,7 @@ ccl_device_inline void bsdf_thin_glass_reflection_setup(KernelGlobals kg,
bsdf->T = zero_float3();
bsdf->alpha_x = bsdf->alpha_y = roughness;
bsdf->ior = 1.0f;
sd->flag |= bsdf_microfacet_ggx_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
bsdf_microfacet_setup_fresnel_constant(kg, bsdf, sd->wi, color);
}
}
@ -1314,7 +1314,7 @@ ccl_device_inline void bsdf_thin_glass_transmission_setup(KernelGlobals kg,
bsdf->fresnel_type = MicrofacetFresnel::NONE;
bsdf->energy_scale = 1.0f;
bsdf->type = CLOSURE_BSDF_THIN_GLASS_TRANSMISSION_ID;
sd->flag |= (SD_BSDF | SD_BSDF_HAS_TRANSMISSION | bsdf_microfacet_eval_flag(bsdf));
sd->runtime_flag |= (SR_BSDF | SR_BSDF_HAS_TRANSMISSION | bsdf_microfacet_eval_flag(bsdf));
bsdf_microfacet_setup_fresnel_constant(kg, bsdf, reflect(sd->wi, N), one_spectrum());
}
}

6
intern/cycles/kernel/closure/bsdf_oren_nayar.h
View file

@ -107,7 +107,7 @@ ccl_device void bsdf_oren_nayar_setup(ccl_private ShaderData *sd,
bsdf->N = N;
bsdf->type = CLOSURE_BSDF_OREN_NAYAR_ID;
bsdf->param = bsdf_oren_nayar_param(color, dot(bsdf->N, sd->wi), roughness);
sd->flag |= SD_BSDF | SD_BSDF_HAS_EVAL;
sd->runtime_flag |= SR_BSDF | SR_BSDF_HAS_EVAL;
}
}
@ -199,7 +199,7 @@ ccl_device_inline void bsdf_thin_subsurface_setup(ccl_private ShaderData *sd,
bsdf->type = CLOSURE_BSDF_OREN_NAYAR_ID;
bsdf->N = N;
bsdf->param = param;
sd->flag |= SD_BSDF | SD_BSDF_HAS_EVAL;
sd->runtime_flag |= SR_BSDF | SR_BSDF_HAS_EVAL;
}
}
@ -211,7 +211,7 @@ ccl_device_inline void bsdf_thin_subsurface_setup(ccl_private ShaderData *sd,
bsdf->type = CLOSURE_BSDF_ROUGH_TRANSLUCENT_ID;
bsdf->N = -N;
bsdf->param = param;
sd->flag |= SD_BSDF | SD_BSDF_HAS_EVAL | SD_BSDF_HAS_TRANSMISSION;
sd->runtime_flag |= SR_BSDF | SR_BSDF_HAS_EVAL | SR_BSDF_HAS_TRANSMISSION;
}
}
}

2
intern/cycles/kernel/closure/bsdf_phong_ramp.h
View file

@ -44,7 +44,7 @@ ccl_device int bsdf_phong_ramp_setup(ccl_private PhongRampBsdf *bsdf)
{
bsdf->type = CLOSURE_BSDF_PHONG_RAMP_ID;
bsdf->exponent = max(bsdf->exponent, 0.0f);
return SD_BSDF | SD_BSDF_HAS_EVAL;
return SR_BSDF | SR_BSDF_HAS_EVAL;
}
ccl_device Spectrum bsdf_phong_ramp_eval(const ccl_private ShaderClosure *sc,

2
intern/cycles/kernel/closure/bsdf_principled_hair_chiang.h
View file

@ -190,7 +190,7 @@ ccl_device int bsdf_hair_chiang_setup(ccl_private ShaderData *sd, ccl_private Ch
bsdf->N = Y;
bsdf->alpha = -bsdf->alpha;
return SD_BSDF | SD_BSDF_HAS_EVAL | SD_BSDF_HAS_TRANSMISSION;
return SR_BSDF | SR_BSDF_HAS_EVAL | SR_BSDF_HAS_TRANSMISSION;
}
#endif /* __HAIR__ */

2
intern/cycles/kernel/closure/bsdf_principled_hair_huang.h
View file

@ -305,7 +305,7 @@ ccl_device int bsdf_hair_huang_setup(ccl_private ShaderData *sd,
return 0;
}
return SD_BSDF | SD_BSDF_HAS_EVAL | SD_BSDF_HAS_TRANSMISSION;
return SR_BSDF | SR_BSDF_HAS_EVAL | SR_BSDF_HAS_TRANSMISSION;
}
#endif /* __HAIR__ */

2
intern/cycles/kernel/closure/bsdf_ray_portal.h
View file

@ -36,7 +36,7 @@ ccl_device void bsdf_ray_portal_setup(ccl_private ShaderData *sd,
sd, sizeof(RayPortalClosure), CLOSURE_BSDF_RAY_PORTAL_ID, weight);
if (pc) {
sd->flag |= SD_BSDF | SD_RAY_PORTAL;
sd->runtime_flag |= SR_BSDF | SR_RAY_PORTAL;
if (is_zero(direction)) {
direction = -sd->wi;
}

2
intern/cycles/kernel/closure/bsdf_sheen.h
View file

@ -50,7 +50,7 @@ ccl_device int bsdf_sheen_setup(KernelGlobals kg,
bsdf->weight *= albedo;
bsdf->sample_weight *= albedo;
return SD_BSDF | SD_BSDF_HAS_EVAL;
return SR_BSDF | SR_BSDF_HAS_EVAL;
}
ccl_device Spectrum bsdf_sheen_eval(const ccl_private ShaderClosure *sc,

2
intern/cycles/kernel/closure/bsdf_toon.h
View file

@ -27,7 +27,7 @@ ccl_device_inline int bsdf_toon_setup_common(ccl_private ToonBsdf *bsdf)
bsdf->size = clamp(bsdf->size, 1e-5f, 1.0f) * M_PI_2_F;
bsdf->smooth = saturatef(bsdf->smooth) * M_PI_2_F;
return SD_BSDF | SD_BSDF_HAS_EVAL;
return SR_BSDF | SR_BSDF_HAS_EVAL;
}
/* DIFFUSE TOON */

4
intern/cycles/kernel/closure/bsdf_transparent.h
View file

@ -25,7 +25,7 @@ ccl_device void bsdf_transparent_setup(ccl_private ShaderData *sd,
sd->closure_transparent_extinction += weight;
if (sd->flag & SD_TRANSPARENT) {
if (sd->runtime_flag & SR_TRANSPARENT) {
/* Add weight to existing transparent BSDF. */
for (int i = 0; i < sd->num_closure; i++) {
ccl_private ShaderClosure *sc = &sd->closure[i];
@ -38,7 +38,7 @@ ccl_device void bsdf_transparent_setup(ccl_private ShaderData *sd,
}
}
else {
sd->flag |= SD_BSDF | SD_TRANSPARENT;
sd->runtime_flag |= SR_BSDF | SR_TRANSPARENT;
if (path_flag & PATH_RAY_TERMINATE) {
/* In this case the number of closures is set to zero to disable

2
intern/cycles/kernel/closure/bsdf_util.h
View file

@ -399,7 +399,7 @@ ccl_device float3 ensure_valid_specular_reflection(const float3 Ng, const float3
ccl_device float3 maybe_ensure_valid_specular_reflection(ccl_private ShaderData *sd,
const float3 N)
{
if ((sd->flag & SD_USE_BUMP_MAP_CORRECTION) == 0) {
if ((sd->shader_flag & SD_USE_BUMP_MAP_CORRECTION) == 0) {
return N;
}
if ((sd->type & PRIMITIVE_CURVE) || isequal(sd->Ng, N)) {

2
intern/cycles/kernel/closure/bssrdf.h
View file

@ -342,7 +342,7 @@ ccl_device int bssrdf_setup(ccl_private ShaderData *sd,
bssrdf_setup_radius(bssrdf, type);
flag |= SD_BSSRDF;
flag |= SR_BSSRDF;
}
else {
bssrdf->type = CLOSURE_NONE_ID;

8
intern/cycles/kernel/closure/emissive.h
View file

@ -15,11 +15,11 @@ CCL_NAMESPACE_BEGIN
ccl_device void background_setup(ccl_private ShaderData *sd, const Spectrum weight)
{
if (sd->flag & SD_EMISSION) {
if (sd->runtime_flag & SR_EMISSION) {
sd->closure_emission_background += weight;
}
else {
sd->flag |= SD_EMISSION;
sd->runtime_flag |= SR_EMISSION;
sd->closure_emission_background = weight;
}
}
@ -28,11 +28,11 @@ ccl_device void background_setup(ccl_private ShaderData *sd, const Spectrum weig
ccl_device void emission_setup(ccl_private ShaderData *sd, const Spectrum weight)
{
if (sd->flag & SD_EMISSION) {
if (sd->runtime_flag & SR_EMISSION) {
sd->closure_emission_background += weight;
}
else {
sd->flag |= SD_EMISSION;
sd->runtime_flag |= SR_EMISSION;
sd->closure_emission_background = weight;
}
}

4
intern/cycles/kernel/closure/volume.h
View file

@ -17,11 +17,11 @@ CCL_NAMESPACE_BEGIN
ccl_device void volume_extinction_setup(ccl_private ShaderData *sd, Spectrum weight)
{
if (sd->flag & SD_EXTINCTION) {
if (sd->runtime_flag & SR_EXTINCTION) {
sd->closure_transparent_extinction += weight;
}
else {
sd->flag |= SD_EXTINCTION;
sd->runtime_flag |= SR_EXTINCTION;
sd->closure_transparent_extinction = weight;
}
}

2
intern/cycles/kernel/closure/volume_draine.h
View file

@ -26,7 +26,7 @@ ccl_device int volume_draine_setup(ccl_private DraineVolume *volume)
/* clamp anisotropy */
volume->g = signf(volume->g) * min(fabsf(volume->g), 1.0f - 1e-3f);
return SD_SCATTER;
return SR_SCATTER;
}
ccl_device Spectrum volume_draine_eval(const ccl_private ShaderData *sd,

2
intern/cycles/kernel/closure/volume_fournier_forand.h
View file

@ -35,7 +35,7 @@ ccl_device int volume_fournier_forand_setup(ccl_private FournierForandVolume *vo
volume->c2 = coeffs.y;
volume->c3 = coeffs.z;
return SD_SCATTER;
return SR_SCATTER;
}
ccl_device Spectrum volume_fournier_forand_eval(const ccl_private ShaderData *sd,

2
intern/cycles/kernel/closure/volume_henyey_greenstein.h
View file

@ -26,7 +26,7 @@ ccl_device int volume_henyey_greenstein_setup(ccl_private HenyeyGreensteinVolume
/* clamp anisotropy to avoid delta function */
volume->g = signf(volume->g) * min(fabsf(volume->g), 1.0f - 1e-3f);
return SD_SCATTER;
return SR_SCATTER;
}
ccl_device Spectrum volume_henyey_greenstein_eval(const ccl_private ShaderData *sd,

2
intern/cycles/kernel/closure/volume_rayleigh.h
View file

@ -21,7 +21,7 @@ static_assert(sizeof(ShaderVolumeClosure) >= sizeof(RayleighVolume),
ccl_device int volume_rayleigh_setup(ccl_private RayleighVolume *volume)
{
volume->type = CLOSURE_VOLUME_RAYLEIGH_ID;
return SD_SCATTER;
return SR_SCATTER;
}
ccl_device Spectrum volume_rayleigh_eval(const ccl_private ShaderData *sd,

2
intern/cycles/kernel/film/data_passes.h
View file

@ -70,7 +70,7 @@ ccl_device_inline void film_write_data_passes(KernelGlobals kg,
}
}
if (!(sd->flag & (SD_TRANSPARENT | SD_RAY_PORTAL)) ||
if (!(sd->runtime_flag & (SR_TRANSPARENT | SR_RAY_PORTAL)) ||
kernel_data.film.pass_alpha_threshold == 0.0f ||
average(surface_shader_alpha(sd)) >= kernel_data.film.pass_alpha_threshold)
{

2
intern/cycles/kernel/geom/primitive.h
View file

@ -78,7 +78,7 @@ ccl_device void primitive_normal_set_undisplaced(KernelGlobals kg,
}
object_normal_transform(kg, sd, &N);
sd->N = (sd->flag & SD_BACKFACING) ? -N : N;
sd->N = (sd->runtime_flag & SR_BACKFACING) ? -N : N;
}
#ifdef __VOLUME__

22
intern/cycles/kernel/geom/shader_data.h
View file

@ -61,7 +61,8 @@ ccl_device_inline
sd->object = isect->object;
sd->object_flag = kernel_data_fetch(object_flag, sd->object);
sd->prim = isect->prim;
sd->flag = 0;
sd->runtime_flag = 0;
sd->shader_flag = 0;
/* Read matrices and time. */
sd->time = ray->time;
@ -110,13 +111,13 @@ ccl_device_inline
}
}
sd->flag = kernel_data_fetch(shaders, (sd->shader & SHADER_MASK)).flags;
sd->shader_flag = kernel_data_fetch(shaders, (sd->shader & SHADER_MASK)).flags;
/* backfacing test */
const bool backfacing = (dot(sd->Ng, sd->wi) < 0.0f);
if (backfacing) {
sd->flag |= SD_BACKFACING;
sd->runtime_flag |= SR_BACKFACING;
sd->Ng = -sd->Ng;
sd->N = -sd->N;
#ifdef __DPDU__
@ -174,8 +175,8 @@ ccl_device_inline void shader_setup_from_sample(KernelGlobals kg,
sd->v = v;
sd->time = time;
sd->ray_length = t;
sd->flag = kernel_data_fetch(shaders, (sd->shader & SHADER_MASK)).flags;
sd->runtime_flag = 0;
sd->shader_flag = kernel_data_fetch(shaders, (sd->shader & SHADER_MASK)).flags;
sd->object_flag = 0;
if (sd->object != OBJECT_NONE) {
sd->object_flag |= kernel_data_fetch(object_flag, sd->object);
@ -232,7 +233,7 @@ ccl_device_inline void shader_setup_from_sample(KernelGlobals kg,
const bool backfacing = (dot(sd->Ng, sd->wi) < 0.0f);
if (backfacing) {
sd->flag |= SD_BACKFACING;
sd->runtime_flag |= SR_BACKFACING;
sd->Ng = -sd->Ng;
sd->N = -sd->N;
#ifdef __DPDU__
@ -321,7 +322,8 @@ ccl_device void shader_setup_from_curve(KernelGlobals kg,
/* Shader */
sd->shader = kernel_data_fetch(curves, prim).shader_id;
sd->flag = kernel_data_fetch(shaders, (sd->shader & SHADER_MASK)).flags;
sd->runtime_flag = 0;
sd->shader_flag = kernel_data_fetch(shaders, (sd->shader & SHADER_MASK)).flags;
/* Object */
sd->object = object;
@ -400,7 +402,8 @@ ccl_device_inline void shader_setup_from_background(KernelGlobals kg,
sd->Ng = -ray_D;
sd->wi = -ray_D;
sd->shader = kernel_data.background.surface_shader;
sd->flag = kernel_data_fetch(shaders, (sd->shader & SHADER_MASK)).flags;
sd->runtime_flag = 0;
sd->shader_flag = kernel_data_fetch(shaders, (sd->shader & SHADER_MASK)).flags;
sd->object_flag = 0;
sd->time = ray_time;
sd->ray_length = FLT_MAX;
@ -441,7 +444,8 @@ ccl_device_inline void shader_setup_from_volume(ccl_private ShaderData *ccl_rest
sd->Ng = -ray->D;
sd->wi = -ray->D;
sd->shader = SHADER_NONE;
sd->flag = 0;
sd->runtime_flag = 0;
sd->shader_flag = 0;
sd->object_flag = 0;
sd->time = ray->time;
sd->ray_length = 0.0f; /* todo: can we set this to some useful value? */

4
intern/cycles/kernel/geom/volume.h
View file

@ -102,8 +102,8 @@ ccl_device float4 volume_attribute_float4(KernelGlobals kg,
* common case where transform is translation/scale only. */
float3 P = sd->P;
object_inverse_position_transform(kg, sd, &P);
const InterpolationType interp = (sd->flag & SD_VOLUME_CUBIC) ? INTERPOLATION_CUBIC :
INTERPOLATION_NONE;
const InterpolationType interp = (sd->shader_flag & SD_VOLUME_CUBIC) ? INTERPOLATION_CUBIC :
INTERPOLATION_NONE;
const float4 value = kernel_image_interp_3d(kg, sd, desc.offset, P, interp, stochastic);
if (value.w > 1e-6f && value.w != 1.0f) {
/* For RGBA colors, unpremultiply after interpolation. */

8
intern/cycles/kernel/integrator/intersect_closest.h
View file

@ -173,11 +173,11 @@ ccl_device_forceinline void integrator_intersect_next_kernel_after_shadow_catche
integrator_state_read_isect(state, &isect);
const int shader = intersection_get_shader(kg, &isect);
const int flags = kernel_data_fetch(shaders, shader).flags;
const int shader_flags = kernel_data_fetch(shaders, shader).flags;
const uint object_flags = intersection_get_object_flags(kg, &isect);
const bool use_caustics = kernel_data.integrator.use_caustics &&
(object_flags & SD_OBJECT_CAUSTICS_RECEIVER);
const bool use_raytrace_kernel = (flags & SD_HAS_RAYTRACE);
const bool use_raytrace_kernel = (shader_flags & SD_HAS_RAYTRACE);
if (use_caustics) {
integrator_path_next(state, current_kernel, DEVICE_KERNEL_INTEGRATOR_INTERSECT_MNEE);
@ -315,11 +315,11 @@ ccl_device_forceinline void integrator_intersect_next_kernel_after_volume(
/* Hit a surface, continue with surface kernel unless terminated. */
const int shader = intersection_get_shader(kg, isect);
const int flags = kernel_data_fetch(shaders, shader).flags;
const int shader_flags = kernel_data_fetch(shaders, shader).flags;
const uint object_flags = intersection_get_object_flags(kg, isect);
const bool use_caustics = kernel_data.integrator.use_caustics &&
(object_flags & SD_OBJECT_CAUSTICS_RECEIVER);
const bool use_raytrace_kernel = (flags & SD_HAS_RAYTRACE);
const bool use_raytrace_kernel = (shader_flags & SD_HAS_RAYTRACE);
if (use_caustics) {
integrator_path_next(state, current_kernel, DEVICE_KERNEL_INTEGRATOR_INTERSECT_MNEE);

2
intern/cycles/kernel/integrator/intersect_mnee.h
View file

@ -40,7 +40,7 @@ integrate_surface_mnee(KernelGlobals kg,
sd->P,
sd->N,
light_link_receiver_nee(kg, sd),
sd->flag,
sd->runtime_flag,
bounce,
path_flag,
&ls))

4
intern/cycles/kernel/integrator/intersect_volume_stack.h
View file

@ -133,7 +133,7 @@ ccl_device void integrator_volume_stack_init(KernelGlobals kg, IntegratorState s
for (uint hit = 0; hit < num_hits; ++hit, ++isect) {
shader_setup_from_ray(kg, stack_sd, &volume_ray, isect);
if (stack_sd->flag & SD_BACKFACING) {
if (stack_sd->runtime_flag & SR_BACKFACING) {
bool need_add = true;
for (int i = 0; i < enclosed_index && need_add; ++i) {
/* If ray exited the volume and never entered to that volume
@ -179,7 +179,7 @@ ccl_device void integrator_volume_stack_init(KernelGlobals kg, IntegratorState s
}
shader_setup_from_ray(kg, stack_sd, &volume_ray, &isect);
if (stack_sd->flag & SD_BACKFACING) {
if (stack_sd->runtime_flag & SR_BACKFACING) {
/* If ray exited the volume and never entered to that volume
* it means that camera is inside such a volume.
*/

13
intern/cycles/kernel/integrator/mnee.h
View file

@ -130,7 +130,8 @@ ccl_device_inline void mnee_setup_manifold_vertex(KernelGlobals kg,
isect->object;
sd_vtx->type = isect->type;
sd_vtx->flag = 0;
sd_vtx->runtime_flag = 0;
sd_vtx->shader_flag = 0;
sd_vtx->object_flag = kernel_data_fetch(object_flag, sd_vtx->object);
/* Matrices and time. */
@ -825,7 +826,7 @@ ccl_device_inline ShaderEvalResult mnee_path_contribution(KernelGlobals kg,
1;
INTEGRATOR_STATE_WRITE(state, path, bounce) = bounce + vertex_count;
if (sd_mnee->flag & SD_CACHE_MISS) {
if (sd_mnee->runtime_flag & SR_CACHE_MISS) {
/* Restore original state path bounce info. */
INTEGRATOR_STATE_WRITE(state, path, transmission_bounce) = transmission_bounce;
INTEGRATOR_STATE_WRITE(state, path, diffuse_bounce) = diffuse_bounce;
@ -915,7 +916,7 @@ ccl_device_inline ShaderEvalResult mnee_path_contribution(KernelGlobals kg,
/* Evaluate shader nodes at solution vi. */
surface_shader_eval<KERNEL_FEATURE_NODE_MASK_SURFACE_SHADOW>(
kg, state, sd_mnee, nullptr, PATH_RAY_VISIBILITY_DIFFUSE, PATH_RAY_FLAG_NONE, true);
if (sd_mnee->flag & SD_CACHE_MISS) {
if (sd_mnee->runtime_flag & SR_CACHE_MISS) {
/* Restore original state path bounce info. */
INTEGRATOR_STATE_WRITE(state, path, transmission_bounce) = transmission_bounce;
INTEGRATOR_STATE_WRITE(state, path, diffuse_bounce) = diffuse_bounce;
@ -1021,7 +1022,7 @@ ccl_device_inline ShaderEvalResult kernel_path_mnee_sample(KernelGlobals kg,
/* Last bool argument is the MNEE flag (for TINY_MAX_CLOSURE cap in kernel_shader.h). */
surface_shader_eval<KERNEL_FEATURE_NODE_MASK_SURFACE_SHADOW>(
kg, state, sd_mnee, nullptr, PATH_RAY_VISIBILITY_DIFFUSE, PATH_RAY_FLAG_NONE, true);
if (sd_mnee->flag & SD_CACHE_MISS) {
if (sd_mnee->runtime_flag & SR_CACHE_MISS) {
return SHADER_EVAL_CACHE_MISS;
}
@ -1036,8 +1037,8 @@ ccl_device_inline ShaderEvalResult kernel_path_mnee_sample(KernelGlobals kg,
ccl_private MicrofacetBsdf *microfacet_bsdf = (ccl_private MicrofacetBsdf *)bsdf;
/* Figure out appropriate index of refraction ratio. */
const float eta = (sd_mnee->flag & SD_BACKFACING) ? 1.0f / microfacet_bsdf->ior :
microfacet_bsdf->ior;
const float eta = (sd_mnee->runtime_flag & SR_BACKFACING) ? 1.0f / microfacet_bsdf->ior :
microfacet_bsdf->ior;
float2 h = zero_float2();
if (microfacet_bsdf->alpha_x > 0.f && microfacet_bsdf->alpha_y > 0.f) {

6
intern/cycles/kernel/integrator/path_state.h
View file

@ -110,7 +110,7 @@ ccl_device_inline void path_state_init_integrator(KernelGlobals kg,
ccl_device_inline void path_state_next(KernelGlobals kg,
IntegratorState state,
const int label,
const int shader_flag)
const int runtime_flag)
{
PathRayVisibility visibility = INTEGRATOR_STATE(state, path, visibility);
uint32_t flag = INTEGRATOR_STATE(state, path, flag);
@ -127,7 +127,7 @@ ccl_device_inline void path_state_next(KernelGlobals kg,
flag |= PATH_RAY_TERMINATE_ON_NEXT_SURFACE;
}
if (shader_flag & SD_RAY_PORTAL) {
if (runtime_flag & SR_RAY_PORTAL) {
flag |= PATH_RAY_MIS_SKIP;
INTEGRATOR_STATE_WRITE(
state, path, portal_bounce) = INTEGRATOR_STATE(state, path, portal_bounce) + 1;
@ -223,7 +223,7 @@ ccl_device_inline void path_state_next(KernelGlobals kg,
}
/* Flag for consistent MIS weights with light tree. */
if (shader_flag & SD_BSDF_HAS_TRANSMISSION) {
if (runtime_flag & SR_BSDF_HAS_TRANSMISSION) {
flag |= PATH_RAY_MIS_HAD_TRANSMISSION;
}

2
intern/cycles/kernel/integrator/shade_background.h
View file

@ -86,7 +86,7 @@ ccl_device Spectrum integrator_eval_background_shader(KernelGlobals kg,
surface_shader_eval<KERNEL_FEATURE_NODE_MASK_SURFACE_BACKGROUND>(
kg, state, emission_sd, render_buffer, path_visibility, path_flag | PATH_RAY_EMISSION);
result = (emission_sd->flag & SD_CACHE_MISS) ? SHADER_EVAL_CACHE_MISS : SHADER_EVAL_OK;
result = (emission_sd->runtime_flag & SR_CACHE_MISS) ? SHADER_EVAL_CACHE_MISS : SHADER_EVAL_OK;
return surface_shader_background(emission_sd);
}

2
intern/cycles/kernel/integrator/shade_dedicated_light.h
View file

@ -126,7 +126,7 @@ ccl_device bool shadow_linking_shade_surface_emission(KernelGlobals kg,
integrate_surface_shader_setup(kg, state, emission_sd);
# ifdef __VOLUME__
if (emission_sd->flag & SD_HAS_ONLY_VOLUME) {
if (emission_sd->shader_flag & SD_HAS_ONLY_VOLUME) {
return SHADER_EVAL_EMPTY;
}
# endif

2
intern/cycles/kernel/integrator/shade_light.h
View file

@ -194,7 +194,7 @@ ccl_device ShaderEvalResult integrate_light_nee(KernelGlobals kg, IntegratorShad
surface_shader_eval<KERNEL_FEATURE_NODE_MASK_SURFACE_LIGHT>(
kg, state, emission_sd, nullptr, PATH_RAY_VISIBILITY_NONE, PATH_RAY_EMISSION);
if (emission_sd->flag & SD_CACHE_MISS) {
if (emission_sd->runtime_flag & SR_CACHE_MISS) {
return SHADER_EVAL_CACHE_MISS;
}

8
intern/cycles/kernel/integrator/shade_shadow.h
View file

@ -111,10 +111,10 @@ integrate_transparent_surface_shadow(KernelGlobals kg,
shader_setup_from_ray(kg, shadow_sd, &ray, &isect);
/* Evaluate shader. */
if (!(shadow_sd->flag & SD_HAS_ONLY_VOLUME)) {
if (!(shadow_sd->shader_flag & SD_HAS_ONLY_VOLUME)) {
surface_shader_eval<KERNEL_FEATURE_NODE_MASK_SURFACE_SHADOW>(
kg, state, shadow_sd, nullptr, PATH_RAY_VISIBILITY_SHADOW, PATH_RAY_FLAG_NONE);
if (shadow_sd->flag & SD_CACHE_MISS) {
if (shadow_sd->runtime_flag & SR_CACHE_MISS) {
result = SHADER_EVAL_CACHE_MISS;
return zero_spectrum();
}
@ -129,7 +129,7 @@ integrate_transparent_surface_shadow(KernelGlobals kg,
# endif
/* Disable transparent shadows for ray portals */
if (shadow_sd->flag & SD_RAY_PORTAL) {
if (shadow_sd->runtime_flag & SR_RAY_PORTAL) {
result = SHADER_EVAL_EMPTY;
return zero_spectrum();
}
@ -176,7 +176,7 @@ ccl_device_inline bool integrate_transparent_volume_shadow(KernelGlobals kg,
volume_shadow_null_scattering(kg, state, &ray, shadow_sd, throughput);
}
return shadow_sd->flag & SD_CACHE_MISS;
return shadow_sd->runtime_flag & SR_CACHE_MISS;
}
# endif

20
intern/cycles/kernel/integrator/shade_surface.h
View file

@ -100,7 +100,7 @@ ccl_device_forceinline bool integrate_surface_holdout(KernelGlobals kg,
/* Write holdout transparency to render buffer and stop if fully holdout. */
const uint32_t path_flag = INTEGRATOR_STATE(state, path, flag);
if (((sd->flag & SD_HOLDOUT) || (sd->object_flag & SD_OBJECT_HOLDOUT_MASK)) &&
if (((sd->runtime_flag & SR_HOLDOUT) || (sd->object_flag & SD_OBJECT_HOLDOUT_MASK)) &&
(path_flag & PATH_RAY_TRANSPARENT_BACKGROUND))
{
const Spectrum holdout_weight = surface_shader_apply_holdout(sd);
@ -194,7 +194,7 @@ ccl_device int integrate_surface_ray_portal(KernelGlobals kg,
INTEGRATOR_STATE_WRITE(state, path, throughput) *= pc->weight / pick_pdf;
const int label = LABEL_TRANSMIT | LABEL_RAY_PORTAL;
path_state_next(kg, state, label, sd->flag);
path_state_next(kg, state, label, sd->runtime_flag);
return label;
}
@ -322,7 +322,7 @@ ccl_device
const ccl_private RNGState *rng_state)
{
/* Test if there is a light or BSDF that needs direct light. */
if (!(kernel_data.integrator.use_direct_light && (sd->flag & SD_BSDF_HAS_EVAL))) {
if (!(kernel_data.integrator.use_direct_light && (sd->runtime_flag & SR_BSDF_HAS_EVAL))) {
return SHADER_EVAL_EMPTY;
}
@ -350,7 +350,7 @@ ccl_device
sd->P,
sd->N,
light_link_receiver_nee(kg, sd),
sd->flag,
sd->runtime_flag,
bounce,
path_flag,
&ls))
@ -494,7 +494,7 @@ ccl_device_forceinline int integrate_surface_bsdf_bssrdf_bounce(
const ccl_private RNGState *rng_state)
{
/* Sample BSDF or BSSRDF. */
if (!(sd->flag & (SD_BSDF | SD_BSSRDF))) {
if (!(sd->runtime_flag & (SR_BSDF | SR_BSSRDF))) {
return LABEL_NONE;
}
@ -618,7 +618,7 @@ ccl_device_forceinline int integrate_surface_bsdf_bssrdf_bounce(
#endif
}
path_state_next(kg, state, label, sd->flag);
path_state_next(kg, state, label, sd->runtime_flag);
guiding_record_surface_bounce(kg,
state,
@ -775,11 +775,11 @@ ccl_device int integrate_surface(KernelGlobals kg,
/* Skip most work for volume bounding surface. */
#ifdef __VOLUME__
if (!(sd.flag & SD_HAS_ONLY_VOLUME)) {
if (!(sd.shader_flag & SD_HAS_ONLY_VOLUME)) {
#endif
#ifdef __SUBSURFACE__
/* Can skip shader evaluation for BSSRDF exit point without bump mapping. */
if (!(path_flag & PATH_RAY_SUBSURFACE) || ((sd.flag & SD_HAS_BSSRDF_BUMP)))
if (!(path_flag & PATH_RAY_SUBSURFACE) || ((sd.shader_flag & SD_HAS_BSSRDF_BUMP)))
#endif
{
/* Evaluate shader. */
@ -788,7 +788,7 @@ ccl_device int integrate_surface(KernelGlobals kg,
kg, state, &sd, render_buffer, path_visibility, path_flag);
}
if (sd.flag & SD_CACHE_MISS) {
if (sd.runtime_flag & SR_CACHE_MISS) {
return LABEL_CACHE_MISS;
}
@ -814,7 +814,7 @@ ccl_device int integrate_surface(KernelGlobals kg,
}
/* Write emission. */
if (sd.flag & SD_EMISSION) {
if (sd.runtime_flag & SR_EMISSION) {
integrate_surface_emission(kg, state, &sd, render_buffer);
}

61
intern/cycles/kernel/integrator/shade_volume.h
View file

@ -94,7 +94,7 @@ ccl_device_inline Spectrum volume_shader_eval_extinction(KernelGlobals kg,
volume_shader_eval<shadow>(kg, state, sd, path_visibility, path_flag);
return (sd->flag & SD_EXTINCTION) ? sd->closure_transparent_extinction : zero_spectrum();
return (sd->runtime_flag & SR_EXTINCTION) ? sd->closure_transparent_extinction : zero_spectrum();
}
/* Evaluate shader to get absorption, scattering and emission at P. */
@ -107,16 +107,17 @@ ccl_device_inline bool volume_shader_sample(KernelGlobals kg,
const uint32_t path_flag = INTEGRATOR_STATE(state, path, flag);
volume_shader_eval<false>(kg, state, sd, path_visibility, path_flag);
if (!(sd->flag & (SD_EXTINCTION | SD_SCATTER | SD_EMISSION))) {
if (!(sd->runtime_flag & (SR_EXTINCTION | SR_SCATTER | SR_EMISSION))) {
return false;
}
coeff->sigma_s = zero_spectrum();
coeff->sigma_t = (sd->flag & SD_EXTINCTION) ? sd->closure_transparent_extinction :
zero_spectrum();
coeff->emission = (sd->flag & SD_EMISSION) ? sd->closure_emission_background : zero_spectrum();
coeff->sigma_t = (sd->runtime_flag & SR_EXTINCTION) ? sd->closure_transparent_extinction :
zero_spectrum();
coeff->emission = (sd->runtime_flag & SR_EMISSION) ? sd->closure_emission_background :
zero_spectrum();
if (sd->flag & SD_SCATTER) {
if (sd->runtime_flag & SR_SCATTER) {
for (int i = 0; i < sd->num_closure; i++) {
const ccl_private ShaderClosure *sc = &sd->closure[i];
@ -805,14 +806,14 @@ ccl_device_inline bool volume_valid_direct_ray_segment(KernelGlobals kg,
/* Emission */
ccl_device Spectrum volume_emission_integrate(ccl_private VolumeShaderCoefficients *coeff,
const int closure_flag,
const int runtime_flag,
const float t)
{
/* integral E * exp(-sigma_t * t) from 0 to t = E * (1 - exp(-sigma_t * t))/sigma_t
* this goes to E * t as sigma_t goes to zero. */
Spectrum emission = coeff->emission;
if (closure_flag & SD_EXTINCTION) {
if (runtime_flag & SR_EXTINCTION) {
const Spectrum optical_depth = coeff->sigma_t * t;
emission *= select(optical_depth > 1e-5f,
(1.0f - exp(-optical_depth)) / coeff->sigma_t,
@ -1215,7 +1216,7 @@ ccl_device_inline void volume_distance_sampling_finalize(
return;
}
kernel_assert(sd->flag & SD_SCATTER);
kernel_assert(sd->runtime_flag & SR_SCATTER);
if (sample_distance) {
/* Direct scatter. */
result.direct_scatter = true;
@ -1460,7 +1461,7 @@ ccl_device void volume_integrate_step_scattering(
}
/* Emission. */
if (sd->flag & SD_EMISSION) {
if (sd->runtime_flag & SR_EMISSION) {
/* Emission = inv_sigma * (L_e + sigma_n * (inv_sigma * (L_e + sigma_n * ···))). */
vstate.emission += result.indirect_throughput * coeff.emission;
if (!result.indirect_scatter) {
@ -1509,7 +1510,7 @@ ccl_device_inline void volume_equiangular_direct_scatter(
sd->P = ray->P + ray->D * result.direct_t;
VolumeShaderCoefficients coeff ccl_optional_struct_init;
if (volume_shader_sample(kg, state, sd, &coeff) && (sd->flag & SD_SCATTER)) {
if (volume_shader_sample(kg, state, sd, &coeff) && (sd->runtime_flag & SR_SCATTER)) {
volume_shader_copy_phases(&result.direct_phases, sd);
if (vstate.use_mis) {
@ -1734,8 +1735,8 @@ ccl_device_forceinline void volume_integrate_homogeneous(KernelGlobals kg,
/* Emission. */
const Spectrum throughput = INTEGRATOR_STATE(state, path, throughput);
if (sd->flag & SD_EMISSION) {
const Spectrum emission = volume_emission_integrate(&coeff, sd->flag, ray_length);
if (sd->runtime_flag & SR_EMISSION) {
const Spectrum emission = volume_emission_integrate(&coeff, sd->runtime_flag, ray_length);
vstate.emission = throughput * emission;
guiding_record_volume_emission(kg, state, emission);
}
@ -2355,29 +2356,29 @@ ccl_device_forceinline void volume_integrate_ray_marching(
/* compute segment */
VolumeShaderCoefficients coeff ccl_optional_struct_init;
if (volume_shader_sample(kg, state, sd, &coeff)) {
const int closure_flag = sd->flag;
const int runtime_flag = sd->runtime_flag;
/* Evaluate transmittance over segment. */
const float dt = vstep.t.length();
const Spectrum transmittance = (closure_flag & SD_EXTINCTION) ?
const Spectrum transmittance = (runtime_flag & SR_EXTINCTION) ?
volume_color_transmittance(coeff.sigma_t, dt) :
one_spectrum();
/* Emission. */
if (closure_flag & SD_EMISSION) {
if (runtime_flag & SR_EMISSION) {
/* Only write emission before indirect light scatter position, since we terminate
* stepping at that point if we have already found a direct light scatter position. */
if (!result.indirect_scatter) {
const Spectrum emission = volume_emission_integrate(&coeff, closure_flag, dt);
const Spectrum emission = volume_emission_integrate(&coeff, runtime_flag, dt);
accum_emission += result.indirect_throughput * emission;
guiding_record_volume_emission(kg, state, emission);
}
}
if (closure_flag & SD_SCATTER) {
if (runtime_flag & SR_SCATTER) {
# ifdef __DENOISING_FEATURES__
/* Accumulate albedo for denoising features. */
if (write_denoising_features && (closure_flag & SD_SCATTER)) {
if (write_denoising_features && (runtime_flag & SR_SCATTER)) {
const Spectrum albedo = safe_divide_color(coeff.sigma_s, coeff.sigma_t);
accum_albedo += result.indirect_throughput * albedo * (one_spectrum() - transmittance);
}
@ -2387,7 +2388,7 @@ ccl_device_forceinline void volume_integrate_ray_marching(
volume_ray_marching_step_scattering(
sd, ray, equiangular_coeffs, coeff, transmittance, vstep.t, vstate, result);
}
else if (closure_flag & SD_EXTINCTION) {
else if (runtime_flag & SR_EXTINCTION) {
/* Absorption only. */
result.indirect_throughput *= transmittance;
result.direct_throughput *= transmittance;
@ -2446,10 +2447,18 @@ ccl_device_forceinline void integrate_volume_direct_light(
const float3 rand_light = path_state_rng_3D(kg, rng_state, PRNG_LIGHT);
const float3 N = zero_float3();
const int object_receiver = light_link_receiver_nee(kg, sd);
const int shader_flags = SD_BSDF_HAS_TRANSMISSION;
const int runtime_flags = SR_BSDF_HAS_TRANSMISSION;
if (!light_sample<false>(
kg, rand_light, sd->time, P, N, object_receiver, shader_flags, bounce, path_flag, &ls))
if (!light_sample<false>(kg,
rand_light,
sd->time,
P,
N,
object_receiver,
runtime_flags,
bounce,
path_flag,
&ls))
{
return;
}
@ -2681,7 +2690,7 @@ ccl_device_forceinline bool integrate_volume_phase_scatter(
}
# endif
path_state_next(kg, state, label, sd->flag);
path_state_next(kg, state, label, sd->runtime_flag);
return true;
}
@ -2862,7 +2871,7 @@ ccl_device VolumeIntegrateEvent volume_integrate(KernelGlobals kg,
VolumeIntegrateResult result = {};
volume_integrate_null_scattering(kg, state, ray, &sd, &rng_state, render_buffer, &ls, result);
if (sd.flag & SD_CACHE_MISS) {
if (sd.runtime_flag & SR_CACHE_MISS) {
return VOLUME_PATH_CACHE_MISS;
}
@ -2903,7 +2912,7 @@ volume_integrate_ray_marching(KernelGlobals kg,
volume_integrate_ray_marching(
kg, state, ray, &sd, &rng_state, render_buffer, step_size, &ls, result);
if (sd.flag & SD_CACHE_MISS) {
if (sd.runtime_flag & SR_CACHE_MISS) {
return VOLUME_PATH_CACHE_MISS;
}

6
intern/cycles/kernel/integrator/subsurface.h
View file

@ -123,7 +123,7 @@ ccl_device int subsurface_bounce(KernelGlobals kg,
INTEGRATOR_STATE_WRITE(state, subsurface, N) = sd->N;
}
if (sd->flag & SD_BACKFACING) {
if (sd->runtime_flag & SR_BACKFACING) {
path_flag |= PATH_RAY_SUBSURFACE_BACKFACING;
}
@ -156,12 +156,12 @@ ccl_device void subsurface_shader_data_setup(KernelGlobals kg, ccl_private Shade
{
/* Get bump mapped normal from shader evaluation at exit point. */
float3 N = sd->N;
if (sd->flag & SD_HAS_BSSRDF_BUMP) {
if (sd->shader_flag & SD_HAS_BSSRDF_BUMP) {
N = surface_shader_bssrdf_normal(sd);
}
/* Setup diffuse BSDF at the exit point. This replaces shader_eval_surface. */
sd->flag &= ~SD_CLOSURE_FLAGS;
sd->runtime_flag = 0;
sd->num_closure = 0;
sd->num_closure_left = kernel_data.max_closures;

22
intern/cycles/kernel/integrator/surface_shader.h
View file

@ -54,7 +54,7 @@ ccl_device_inline void surface_shader_prepare_guiding(KernelGlobals kg,
const ccl_private RNGState *rng_state)
{
/* Have any BSDF to guide? */
if (!(kernel_data.integrator.use_surface_guiding && (sd->flag & SD_BSDF_HAS_EVAL))) {
if (!(kernel_data.integrator.use_surface_guiding && (sd->runtime_flag & SR_BSDF_HAS_EVAL))) {
INTEGRATOR_STATE_WRITE(state, guiding, use_surface_guiding) = false;
return;
}
@ -153,7 +153,7 @@ ccl_device_inline void surface_shader_prepare_closures(KernelGlobals kg,
if (path_visibility & PATH_RAY_VISIBILITY_CAMERA) {
if (filter_closures & FILTER_CLOSURE_DIRECT_LIGHT) {
sd->flag &= ~SD_BSDF_HAS_EVAL;
sd->runtime_flag &= ~SR_BSDF_HAS_EVAL;
}
for (int i = 0; i < sd->num_closure; i++) {
@ -176,7 +176,7 @@ ccl_device_inline void surface_shader_prepare_closures(KernelGlobals kg,
{
sc->type = CLOSURE_HOLDOUT_ID;
sc->sample_weight = 0.0f;
sd->flag |= SD_HOLDOUT;
sd->runtime_flag |= SR_HOLDOUT;
}
}
}
@ -208,7 +208,7 @@ ccl_device_inline void surface_shader_prepare_closures(KernelGlobals kg,
/* NOTE: this is a sufficient condition. If `blur_roughness < THRESH < original_roughness`
* then the flag was already set. */
if (!roughness_is_almost_specular(blur_roughness, blur_roughness)) {
sd->flag |= SD_BSDF_HAS_EVAL;
sd->runtime_flag |= SR_BSDF_HAS_EVAL;
}
}
}
@ -1046,10 +1046,10 @@ ccl_device float surface_shader_average_roughness(const ccl_private ShaderData *
ccl_device Spectrum surface_shader_transparency(const ccl_private ShaderData *sd)
{
if (sd->flag & SD_HAS_ONLY_VOLUME) {
if (sd->shader_flag & SD_HAS_ONLY_VOLUME) {
return one_spectrum();
}
if (sd->flag & (SD_TRANSPARENT | SD_RAY_PORTAL)) {
if (sd->runtime_flag & (SR_TRANSPARENT | SR_RAY_PORTAL)) {
return sd->closure_transparent_extinction;
}
return zero_spectrum();
@ -1190,7 +1190,7 @@ ccl_device bool surface_shader_constant_emission(KernelGlobals kg,
ccl_device Spectrum surface_shader_background(const ccl_private ShaderData *sd)
{
if (sd->flag & SD_EMISSION) {
if (sd->runtime_flag & SR_EMISSION) {
return sd->closure_emission_background;
}
return zero_spectrum();
@ -1200,7 +1200,7 @@ ccl_device Spectrum surface_shader_background(const ccl_private ShaderData *sd)
ccl_device Spectrum surface_shader_emission(const ccl_private ShaderData *sd)
{
if (sd->flag & SD_EMISSION) {
if (sd->runtime_flag & SR_EMISSION) {
return emissive_simple_eval(sd->Ng, sd->wi) * sd->closure_emission_background;
}
return zero_spectrum();
@ -1215,7 +1215,7 @@ ccl_device Spectrum surface_shader_apply_holdout(ccl_private ShaderData *sd)
/* For objects marked as holdout, preserve transparency and remove all other
* closures, replacing them with a holdout weight. */
if (sd->object_flag & SD_OBJECT_HOLDOUT_MASK) {
if ((sd->flag & SD_TRANSPARENT) && !(sd->flag & SD_HAS_ONLY_VOLUME)) {
if ((sd->runtime_flag & SR_TRANSPARENT) && !(sd->shader_flag & SD_HAS_ONLY_VOLUME)) {
weight = one_spectrum() - sd->closure_transparent_extinction;
for (int i = 0; i < sd->num_closure; i++) {
@ -1225,7 +1225,7 @@ ccl_device Spectrum surface_shader_apply_holdout(ccl_private ShaderData *sd)
}
}
sd->flag &= ~(SD_CLOSURE_FLAGS - (SD_TRANSPARENT | SD_BSDF));
sd->runtime_flag &= (SR_TRANSPARENT | SR_BSDF);
}
else {
weight = one_spectrum();
@ -1287,7 +1287,7 @@ ccl_device void surface_shader_eval(KernelGlobals kg,
#else
if (sd->object == OBJECT_NONE) {
sd->closure_emission_background = make_spectrum(0.8f);
sd->flag |= SD_EMISSION;
sd->runtime_flag |= SR_EMISSION;
}
else {
bsdf_diffuse_setup(sd, sd->N, make_spectrum(0.8f));

12
intern/cycles/kernel/integrator/volume_shader.h
View file

@ -410,8 +410,8 @@ ccl_device_inline void volume_shader_motion_blur(KernelGlobals kg,
*/
/* Always use linear interpolation for velocity. */
const int cubic_flag = sd->flag & SD_VOLUME_CUBIC;
sd->flag &= ~SD_VOLUME_CUBIC;
const int cubic_flag = sd->shader_flag & SD_VOLUME_CUBIC;
sd->shader_flag &= ~SD_VOLUME_CUBIC;
/* Find velocity. */
float3 velocity = primitive_volume_attribute<float3>(kg, sd, v_desc, false);
@ -428,7 +428,7 @@ ccl_device_inline void volume_shader_motion_blur(KernelGlobals kg,
sd->P = P - (time - time_offset) * velocity_scale * velocity;
/* Restore flag. */
sd->flag |= cubic_flag;
sd->shader_flag |= cubic_flag;
}
# endif
@ -451,8 +451,7 @@ ccl_device_inline bool volume_shader_eval_entry(KernelGlobals kg,
sd->object = entry.object;
sd->shader = entry.shader;
sd->flag &= ~SD_SHADER_FLAGS;
sd->flag |= kernel_data_fetch(shaders, (sd->shader & SHADER_MASK)).flags;
sd->shader_flag = kernel_data_fetch(shaders, (sd->shader & SHADER_MASK)).flags;
sd->object_flag &= ~SD_OBJECT_FLAGS;
if (sd->object != OBJECT_NONE) {
@ -516,7 +515,8 @@ ccl_device_inline void volume_shader_eval(KernelGlobals kg,
* for all volumes in the stack into a single array of closures */
sd->num_closure = 0;
sd->num_closure_left = max_closures;
sd->flag = SD_IS_VOLUME_SHADER_EVAL | (sd->flag & SD_CACHE_MISS);
sd->shader_flag = 0;
sd->runtime_flag = SR_IS_VOLUME_SHADER_EVAL | (sd->runtime_flag & SR_CACHE_MISS);
sd->object_flag = 0;
for (int i = 0;; i++) {

4
intern/cycles/kernel/integrator/volume_stack.h
View file

@ -82,11 +82,11 @@ ccl_device void volume_stack_enter_exit(KernelGlobals kg,
/* todo: we should have some way for objects to indicate if they want the
* world shader to work inside them. excluding it by default is problematic
* because non-volume objects can't be assumed to be closed manifolds */
if (!(sd->flag & SD_HAS_VOLUME)) {
if (!(sd->shader_flag & SD_HAS_VOLUME)) {
return;
}
if (sd->flag & SD_BACKFACING) {
if (sd->runtime_flag & SR_BACKFACING) {
/* Exit volume object: remove from stack. */
for (int i = 0;; i++) {
const VolumeStack entry = volume_stack_read<shadow>(state, i);

10
intern/cycles/kernel/light/light.h
View file

@ -85,7 +85,7 @@ ccl_device_inline bool light_sample(KernelGlobals kg,
const float2 rand,
const float3 P,
const float3 N,
const int shader_flags,
const int runtime_flags,
const uint32_t path_flag,
ccl_private LightSample *ls)
{
@ -132,12 +132,12 @@ ccl_device_inline bool light_sample(KernelGlobals kg,
ls->eval_fac = 1.0f;
}
else if (type == LIGHT_SPOT) {
if (!spot_light_sample<in_volume_segment>(kg, klight, rand, P, N, shader_flags, ls)) {
if (!spot_light_sample<in_volume_segment>(kg, klight, rand, P, N, runtime_flags, ls)) {
return false;
}
}
else if (type == LIGHT_POINT) {
if (!point_light_sample(klight, rand, P, N, shader_flags, ls)) {
if (!point_light_sample(klight, rand, P, N, runtime_flags, ls)) {
return false;
}
}
@ -160,7 +160,7 @@ ccl_device bool light_sample(KernelGlobals kg,
const float3 P,
const float3 N,
const int object_receiver,
const int shader_flags,
const int runtime_flags,
const int bounce,
const uint32_t path_flag,
ccl_private LightSample *ls)
@ -216,7 +216,7 @@ ccl_device bool light_sample(KernelGlobals kg,
return false;
}
if (!light_sample<in_volume_segment>(kg, light, rand, P, N, shader_flags, path_flag, ls)) {
if (!light_sample<in_volume_segment>(kg, light, rand, P, N, runtime_flags, path_flag, ls)) {
return false;
}
}

4
intern/cycles/kernel/light/point.h
View file

@ -19,7 +19,7 @@ ccl_device_inline bool point_light_sample(const ccl_global KernelLight *klight,
const float2 rand,
const float3 P,
const float3 N,
const int shader_flags,
const int runtime_flags,
ccl_private LightSample *ls)
{
const float r_sq = sqr(klight->spot.radius);
@ -41,7 +41,7 @@ ccl_device_inline bool point_light_sample(const ccl_global KernelLight *klight,
}
else {
/* Inside sphere. */
const bool has_transmission = (shader_flags & SD_BSDF_HAS_TRANSMISSION);
const bool has_transmission = (runtime_flags & SR_BSDF_HAS_TRANSMISSION);
if (has_transmission) {
ls->D = sample_uniform_sphere(rand);
ls->pdf = M_1_2PI_F * 0.5f;

17
intern/cycles/kernel/light/sample.h
View file

@ -91,7 +91,7 @@ light_sample_shader_eval_forward(KernelGlobals kg,
* weak but we'd have to do multiple evaluations otherwise. */
surface_shader_eval<KERNEL_FEATURE_NODE_MASK_SURFACE_LIGHT>(
kg, state, emission_sd, nullptr, PATH_RAY_VISIBILITY_NONE, PATH_RAY_EMISSION);
if (emission_sd->flag & SD_CACHE_MISS) {
if (emission_sd->runtime_flag & SR_CACHE_MISS) {
return SHADER_EVAL_CACHE_MISS;
}
@ -379,11 +379,11 @@ ccl_device_inline bool light_sample_from_volume_segment(KernelGlobals kg,
const uint32_t path_flag,
ccl_private LightSample *ls)
{
const int shader_flags = SD_BSDF_HAS_TRANSMISSION;
const int runtime_flags = SR_BSDF_HAS_TRANSMISSION;
#ifdef __LIGHT_TREE__
if (kernel_data.integrator.use_light_tree) {
if (!light_tree_sample<true>(kg, rand.z, P, D, t, object_receiver, shader_flags, ls)) {
if (!light_tree_sample<true>(kg, rand.z, P, D, t, object_receiver, runtime_flags, ls)) {
return false;
}
}
@ -397,7 +397,7 @@ ccl_device_inline bool light_sample_from_volume_segment(KernelGlobals kg,
/* Sample position on the selected light. */
return light_sample<true>(
kg, rand, time, P, D, object_receiver, shader_flags, bounce, path_flag, ls);
kg, rand, time, P, D, object_receiver, runtime_flags, bounce, path_flag, ls);
}
ccl_device bool light_sample_from_position(KernelGlobals kg,
@ -406,7 +406,7 @@ ccl_device bool light_sample_from_position(KernelGlobals kg,
const float3 P,
const float3 N,
const int object_receiver,
const int shader_flags,
const int runtime_flags,
const int bounce,
const uint32_t path_flag,
ccl_private LightSample *ls)
@ -414,7 +414,7 @@ ccl_device bool light_sample_from_position(KernelGlobals kg,
/* Randomly select a light. */
#ifdef __LIGHT_TREE__
if (kernel_data.integrator.use_light_tree) {
if (!light_tree_sample<false>(kg, rand.z, P, N, 0.0f, object_receiver, shader_flags, ls)) {
if (!light_tree_sample<false>(kg, rand.z, P, N, 0.0f, object_receiver, runtime_flags, ls)) {
return false;
}
}
@ -428,7 +428,7 @@ ccl_device bool light_sample_from_position(KernelGlobals kg,
/* Sample position on the selected light. */
return light_sample<false>(
kg, rand, time, P, N, object_receiver, shader_flags, bounce, path_flag, ls);
kg, rand, time, P, N, object_receiver, runtime_flags, bounce, path_flag, ls);
}
/* Update light sample with new shading point position for MNEE. The position on the light is fixed
@ -474,7 +474,8 @@ ccl_device_inline float light_sample_mis_weight_forward_surface(
const ccl_private ShaderData *sd)
{
bool has_mis = !(path_flag & PATH_RAY_MIS_SKIP) &&
(sd->flag & ((sd->flag & SD_BACKFACING) ? SD_MIS_BACK : SD_MIS_FRONT));
(sd->shader_flag &
((sd->runtime_flag & SR_BACKFACING) ? SD_MIS_BACK : SD_MIS_FRONT));
#ifdef __HAIR__
has_mis &= (sd->type & PRIMITIVE_TRIANGLE);

4
intern/cycles/kernel/light/spot.h
View file

@ -45,7 +45,7 @@ ccl_device_inline bool spot_light_sample(KernelGlobals kg,
const float2 rand,
const float3 P,
const float3 N,
const int shader_flags,
const int runtime_flags,
ccl_private LightSample *ls)
{
const float r_sq = sqr(klight->spot.radius);
@ -85,7 +85,7 @@ ccl_device_inline bool spot_light_sample(KernelGlobals kg,
}
else {
/* Inside sphere. */
const bool has_transmission = (shader_flags & SD_BSDF_HAS_TRANSMISSION);
const bool has_transmission = (runtime_flags & SR_BSDF_HAS_TRANSMISSION);
if (has_transmission) {
ls->D = sample_uniform_sphere(rand);
ls->pdf = M_1_2PI_F * 0.5f;

4
intern/cycles/kernel/light/tree.h
View file

@ -746,14 +746,14 @@ ccl_device bool light_tree_sample(KernelGlobals kg,
float3 N_or_D,
float t,
const int object_receiver,
const int shader_flags,
const int runtime_flags,
ccl_private LightSample *ls)
{
if (!kernel_data.integrator.use_direct_light) {
return false;
}
const bool has_transmission = (shader_flags & SD_BSDF_HAS_TRANSMISSION);
const bool has_transmission = (runtime_flags & SR_BSDF_HAS_TRANSMISSION);
float pdf_leaf = 1.0f;
float pdf_selection = 1.0f;
int selected_emitter = -1;

2
intern/cycles/kernel/osl/closures.cpp
View file

@ -135,7 +135,7 @@ void osl_eval_nodes_surface(const ThreadKernelGlobalsCPU *kg,
const OSL::Vec3 dPdy = globals->dPdy;
/* set state as if undisplaced */
if (sd->flag & SD_HAS_DISPLACEMENT) {
if (sd->shader_flag & SD_HAS_DISPLACEMENT) {
const AttributeDescriptor desc = find_attribute(kg, sd, ATTR_STD_POSITION_UNDISPLACED);
kernel_assert(is_attribute_found(desc));

100
intern/cycles/kernel/osl/closures_setup.h
View file

@ -150,7 +150,7 @@ ccl_device void osl_closure_burley_diffuse_bsdf_setup(
bsdf->N = safe_normalize_fallback(closure->N, sd->N);
sd->flag |= bsdf_burley_setup(bsdf, closure->roughness);
sd->runtime_flag |= bsdf_burley_setup(bsdf, closure->roughness);
}
ccl_device void osl_closure_translucent_setup(KernelGlobals kg,
@ -207,7 +207,7 @@ ccl_device void osl_closure_reflection_setup(KernelGlobals kg,
bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
bsdf->alpha_x = bsdf->alpha_y = 0.0f;
sd->flag |= bsdf_microfacet_ggx_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
}
ccl_device void osl_closure_refraction_setup(KernelGlobals kg,
@ -232,7 +232,7 @@ ccl_device void osl_closure_refraction_setup(KernelGlobals kg,
bsdf->ior = closure->ior;
bsdf->alpha_x = bsdf->alpha_y = 0.0f;
sd->flag |= bsdf_microfacet_ggx_refraction_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_refraction_setup(bsdf);
}
ccl_device void osl_closure_transparent_setup(KernelGlobals /*kg*/,
@ -319,25 +319,25 @@ ccl_device void osl_closure_dielectric_bsdf_setup(KernelGlobals kg,
/* Beckmann */
if (closure->distribution == make_string("beckmann", 14712237670914973463ull)) {
if (has_reflection && has_transmission) {
sd->flag |= bsdf_microfacet_beckmann_glass_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_beckmann_glass_setup(bsdf);
}
else if (has_transmission) {
sd->flag |= bsdf_microfacet_beckmann_refraction_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_beckmann_refraction_setup(bsdf);
}
else {
sd->flag |= bsdf_microfacet_beckmann_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_beckmann_setup(bsdf);
}
}
/* GGX (either single- or multi-scattering). */
else {
if (has_reflection && has_transmission) {
sd->flag |= bsdf_microfacet_ggx_glass_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_glass_setup(bsdf);
}
else if (has_transmission) {
sd->flag |= bsdf_microfacet_ggx_refraction_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_refraction_setup(bsdf);
}
else {
sd->flag |= bsdf_microfacet_ggx_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
}
preserve_energy = (closure->distribution == make_string("multi_ggx", 16842698693386468366ull));
@ -393,11 +393,11 @@ ccl_device void osl_closure_conductor_bsdf_setup(KernelGlobals kg,
/* Beckmann */
if (closure->distribution == make_string("beckmann", 14712237670914973463ull)) {
sd->flag |= bsdf_microfacet_beckmann_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_beckmann_setup(bsdf);
}
/* GGX (either single- or multi-scattering) */
else {
sd->flag |= bsdf_microfacet_ggx_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
preserve_energy = (closure->distribution == make_string("multi_ggx", 16842698693386468366ull));
}
@ -464,25 +464,25 @@ ccl_device void osl_closure_generalized_schlick_bsdf_setup(
/* Beckmann */
if (closure->distribution == make_string("beckmann", 14712237670914973463ull)) {
if (has_reflection && has_transmission) {
sd->flag |= bsdf_microfacet_beckmann_glass_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_beckmann_glass_setup(bsdf);
}
else if (has_transmission) {
sd->flag |= bsdf_microfacet_beckmann_refraction_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_beckmann_refraction_setup(bsdf);
}
else {
sd->flag |= bsdf_microfacet_beckmann_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_beckmann_setup(bsdf);
}
}
/* GGX (either single- or multi-scattering) */
else {
if (has_reflection && has_transmission) {
sd->flag |= bsdf_microfacet_ggx_glass_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_glass_setup(bsdf);
}
else if (has_transmission) {
sd->flag |= bsdf_microfacet_ggx_refraction_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_refraction_setup(bsdf);
}
else {
sd->flag |= bsdf_microfacet_ggx_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
}
preserve_energy = (closure->distribution == make_string("multi_ggx", 16842698693386468366ull));
@ -623,29 +623,29 @@ ccl_device void osl_closure_microfacet_setup(KernelGlobals kg,
/* Beckmann */
if (closure->distribution == make_string("beckmann", 14712237670914973463ull)) {
if (closure->refract == 1) {
sd->flag |= bsdf_microfacet_beckmann_refraction_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_beckmann_refraction_setup(bsdf);
}
else if (closure->refract == 2) {
sd->flag |= bsdf_microfacet_beckmann_glass_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_beckmann_glass_setup(bsdf);
}
else {
sd->flag |= bsdf_microfacet_beckmann_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_beckmann_setup(bsdf);
}
}
/* Ashikhmin-Shirley */
else if (closure->distribution == make_string("ashikhmin_shirley", 11318482998918370922ull)) {
sd->flag |= bsdf_ashikhmin_shirley_setup(bsdf);
sd->runtime_flag |= bsdf_ashikhmin_shirley_setup(bsdf);
}
/* GGX (either single- or multi-scattering) */
else {
if (closure->refract == 1) {
sd->flag |= bsdf_microfacet_ggx_refraction_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_refraction_setup(bsdf);
}
else if (closure->refract == 2) {
sd->flag |= bsdf_microfacet_ggx_glass_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_glass_setup(bsdf);
}
else {
sd->flag |= bsdf_microfacet_ggx_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
}
if (closure->distribution == make_string("multi_ggx", 16842698693386468366ull)) {
@ -701,11 +701,11 @@ ccl_device void osl_closure_microfacet_f82_tint_setup(
/* Beckmann */
if (closure->distribution == make_string("beckmann", 14712237670914973463ull)) {
sd->flag |= bsdf_microfacet_beckmann_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_beckmann_setup(bsdf);
}
/* GGX (either single- or multi-scattering) */
else {
sd->flag |= bsdf_microfacet_ggx_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
preserve_energy = (closure->distribution == make_string("multi_ggx", 16842698693386468366ull));
}
@ -746,7 +746,7 @@ ccl_device void osl_closure_microfacet_multi_ggx_glass_setup(
bsdf->T = zero_float3();
sd->flag |= bsdf_microfacet_ggx_glass_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_glass_setup(bsdf);
bsdf_microfacet_setup_fresnel_constant(kg, bsdf, sd->wi, rgb_to_spectrum(closure->color));
}
@ -778,7 +778,7 @@ ccl_device void osl_closure_microfacet_multi_ggx_aniso_setup(
bsdf->T = closure->T;
sd->flag |= bsdf_microfacet_ggx_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
bsdf_microfacet_setup_fresnel_constant(kg, bsdf, sd->wi, rgb_to_spectrum(closure->color));
if (layer_albedo != nullptr) {
@ -810,7 +810,7 @@ ccl_device void osl_closure_ashikhmin_velvet_setup(
bsdf->N = maybe_ensure_valid_specular_reflection(sd, safe_normalize_fallback(closure->N, sd->N));
bsdf->sigma = closure->sigma;
sd->flag |= bsdf_ashikhmin_velvet_setup(bsdf);
sd->runtime_flag |= bsdf_ashikhmin_velvet_setup(bsdf);
}
/* Sheen */
@ -842,7 +842,7 @@ ccl_device void osl_closure_sheen_setup(KernelGlobals kg,
const int sheen_flag = bsdf_sheen_setup(kg, sd, bsdf);
if (sheen_flag) {
sd->flag |= sheen_flag;
sd->runtime_flag |= sheen_flag;
if (layer_albedo != nullptr) {
*layer_albedo = bsdf->weight;
@ -877,7 +877,7 @@ ccl_device void osl_closure_sheen_bsdf_setup(KernelGlobals kg,
const int sheen_flag = bsdf_sheen_setup(kg, sd, bsdf);
if (sheen_flag) {
sd->flag |= sheen_flag;
sd->runtime_flag |= sheen_flag;
if (layer_albedo != nullptr) {
*layer_albedo = bsdf->weight * closure->albedo;
@ -907,7 +907,7 @@ ccl_device void osl_closure_diffuse_toon_setup(KernelGlobals kg,
bsdf->size = closure->size;
bsdf->smooth = closure->smooth;
sd->flag |= bsdf_diffuse_toon_setup(bsdf);
sd->runtime_flag |= bsdf_diffuse_toon_setup(bsdf);
}
ccl_device void osl_closure_glossy_toon_setup(KernelGlobals kg,
@ -932,7 +932,7 @@ ccl_device void osl_closure_glossy_toon_setup(KernelGlobals kg,
bsdf->size = closure->size;
bsdf->smooth = closure->smooth;
sd->flag |= bsdf_glossy_toon_setup(bsdf);
sd->runtime_flag |= bsdf_glossy_toon_setup(bsdf);
}
/* Variable cone emissive closure
@ -949,7 +949,7 @@ ccl_device void osl_closure_emission_setup(KernelGlobals kg,
const ccl_private GenericEmissiveClosure * /*closure*/,
float3 * /*layer_albedo*/)
{
if (sd->flag & SD_IS_VOLUME_SHADER_EVAL) {
if (sd->runtime_flag & SR_IS_VOLUME_SHADER_EVAL) {
if ((path_visibility & PATH_RAY_VISIBILITY_SHADOW) || (path_flag & PATH_RAY_EXTINCTION)) {
/* Don't need emission for shadows and extinction. */
return;
@ -990,7 +990,7 @@ ccl_device void osl_closure_uniform_edf_setup(KernelGlobals kg,
float3 * /*layer_albedo*/)
{
weight *= closure->emittance;
if (sd->flag & SD_IS_VOLUME_SHADER_EVAL) {
if (sd->runtime_flag & SR_IS_VOLUME_SHADER_EVAL) {
if ((path_visibility & PATH_RAY_VISIBILITY_SHADOW) || (path_flag & PATH_RAY_EXTINCTION)) {
/* Don't need emission for shadows and extinction. */
return;
@ -1014,7 +1014,7 @@ ccl_device void osl_closure_holdout_setup(KernelGlobals /*kg*/,
float3 * /*layer_albedo*/)
{
closure_alloc(sd, sizeof(ShaderClosure), CLOSURE_HOLDOUT_ID, rgb_to_spectrum(weight));
sd->flag |= SD_HOLDOUT;
sd->runtime_flag |= SR_HOLDOUT;
}
ccl_device void osl_closure_diffuse_ramp_setup(KernelGlobals /*kg*/,
@ -1043,7 +1043,7 @@ ccl_device void osl_closure_diffuse_ramp_setup(KernelGlobals /*kg*/,
bsdf->colors[i] = closure->colors[i];
}
sd->flag |= bsdf_diffuse_ramp_setup(bsdf);
sd->runtime_flag |= bsdf_diffuse_ramp_setup(bsdf);
}
ccl_device void osl_closure_phong_ramp_setup(KernelGlobals /*kg*/,
@ -1072,7 +1072,7 @@ ccl_device void osl_closure_phong_ramp_setup(KernelGlobals /*kg*/,
bsdf->colors[i] = closure->colors[i];
}
sd->flag |= bsdf_phong_ramp_setup(bsdf);
sd->runtime_flag |= bsdf_phong_ramp_setup(bsdf);
}
ccl_device void osl_closure_bssrdf_setup(KernelGlobals /*kg*/,
@ -1114,7 +1114,7 @@ ccl_device void osl_closure_bssrdf_setup(KernelGlobals /*kg*/,
bssrdf->ior = closure->ior;
bssrdf->anisotropy = closure->anisotropy;
sd->flag |= bssrdf_setup(sd, bssrdf, path_flag, type);
sd->runtime_flag |= bssrdf_setup(sd, bssrdf, path_flag, type);
}
/* MaterialX-compatible subsurface_bssrdf */
@ -1145,7 +1145,7 @@ ccl_device void osl_closure_subsurface_bssrdf_setup(
bssrdf->ior = 1.4f;
bssrdf->anisotropy = closure->anisotropy;
sd->flag |= bssrdf_setup(sd, bssrdf, path_flag, CLOSURE_BSSRDF_RANDOM_WALK_ID);
sd->runtime_flag |= bssrdf_setup(sd, bssrdf, path_flag, CLOSURE_BSSRDF_RANDOM_WALK_ID);
}
/* Hair */
@ -1174,7 +1174,7 @@ ccl_device void osl_closure_hair_reflection_setup(KernelGlobals kg,
bsdf->roughness2 = closure->roughness2;
bsdf->offset = closure->offset;
sd->flag |= bsdf_hair_reflection_setup(bsdf);
sd->runtime_flag |= bsdf_hair_reflection_setup(bsdf);
}
ccl_device void osl_closure_hair_transmission_setup(
@ -1202,7 +1202,7 @@ ccl_device void osl_closure_hair_transmission_setup(
bsdf->roughness2 = closure->roughness2;
bsdf->offset = closure->offset;
sd->flag |= bsdf_hair_transmission_setup(bsdf);
sd->runtime_flag |= bsdf_hair_transmission_setup(bsdf);
}
ccl_device void osl_closure_hair_chiang_setup(KernelGlobals kg,
@ -1232,7 +1232,7 @@ ccl_device void osl_closure_hair_chiang_setup(KernelGlobals kg,
bsdf->eta = closure->eta;
bsdf->m0_roughness = closure->m0_roughness;
sd->flag |= bsdf_hair_chiang_setup(sd, bsdf);
sd->runtime_flag |= bsdf_hair_chiang_setup(sd, bsdf);
#endif
}
@ -1294,7 +1294,7 @@ ccl_device void osl_closure_hair_huang_setup(KernelGlobals kg,
bsdf->extra->pixel_coverage = 0.5f * sd->dP / radius;
}
sd->flag |= bsdf_hair_huang_setup(sd, bsdf, path_flag);
sd->runtime_flag |= bsdf_hair_huang_setup(sd, bsdf, path_flag);
#endif
}
@ -1332,7 +1332,7 @@ ccl_device void osl_closure_henyey_greenstein_setup(
volume->g = closure->g;
sd->flag |= volume_henyey_greenstein_setup(volume);
sd->runtime_flag |= volume_henyey_greenstein_setup(volume);
}
ccl_device void osl_closure_fournier_forand_setup(
@ -1352,7 +1352,7 @@ ccl_device void osl_closure_fournier_forand_setup(
return;
}
sd->flag |= volume_fournier_forand_setup(volume, closure->B, closure->IOR);
sd->runtime_flag |= volume_fournier_forand_setup(volume, closure->B, closure->IOR);
}
ccl_device void osl_closure_draine_setup(KernelGlobals /*kg*/,
@ -1374,7 +1374,7 @@ ccl_device void osl_closure_draine_setup(KernelGlobals /*kg*/,
volume->g = closure->g;
volume->alpha = closure->alpha;
sd->flag |= volume_draine_setup(volume);
sd->runtime_flag |= volume_draine_setup(volume);
}
ccl_device void osl_closure_rayleigh_setup(KernelGlobals /*kg*/,
@ -1393,7 +1393,7 @@ ccl_device void osl_closure_rayleigh_setup(KernelGlobals /*kg*/,
return;
}
sd->flag |= volume_rayleigh_setup(volume);
sd->runtime_flag |= volume_rayleigh_setup(volume);
}
ccl_device void osl_closure_anisotropic_vdf_setup(KernelGlobals kg,
@ -1404,7 +1404,7 @@ ccl_device void osl_closure_anisotropic_vdf_setup(KernelGlobals kg,
const ccl_private AnisotropicVDFClosure *closure,
float3 * /*layer_albedo*/)
{
if (!(sd->flag & SD_IS_VOLUME_SHADER_EVAL)) {
if (!(sd->runtime_flag & SR_IS_VOLUME_SHADER_EVAL)) {
return;
}
@ -1419,7 +1419,7 @@ ccl_device void osl_closure_anisotropic_vdf_setup(KernelGlobals kg,
volume->g = closure->anisotropy;
sd->flag |= volume_henyey_greenstein_setup(volume);
sd->runtime_flag |= volume_henyey_greenstein_setup(volume);
}
CCL_NAMESPACE_END

6
intern/cycles/kernel/osl/osl.h
View file

@ -54,7 +54,7 @@ ccl_device_inline void shaderdata_to_shaderglobals(ccl_private ShaderData *sd,
globals->surfacearea = 1.0f;
globals->raytype = OSL_RAYTYPE_PACK(path_visibility, path_flag);
globals->flipHandedness = 0;
globals->backfacing = (sd->flag & SD_BACKFACING);
globals->backfacing = (sd->runtime_flag & SR_BACKFACING);
/* shader data to be used in services callbacks */
globals->sd = sd;
@ -214,7 +214,7 @@ ccl_device_inline void osl_eval_nodes(KernelGlobals kg,
/* For surface shaders, we might have an automatic bump shader that needs to be executed before
* the main shader to update globals.N. */
if constexpr (type == SHADER_TYPE_SURFACE) {
if (sd->flag & SD_HAS_BUMP_FROM_DISPLACEMENT) {
if (sd->shader_flag & SD_HAS_BUMP_FROM_DISPLACEMENT) {
/* Save state. */
const float3 P = sd->P;
const float dP = sd->dP;
@ -222,7 +222,7 @@ ccl_device_inline void osl_eval_nodes(KernelGlobals kg,
const packed_float3 dPdy = globals.dPdy;
/* Set position state as if undisplaced. */
if (sd->flag & SD_HAS_DISPLACEMENT) {
if (sd->shader_flag & SD_HAS_DISPLACEMENT) {
const AttributeDescriptor desc = find_attribute(kg, sd, ATTR_STD_POSITION_UNDISPLACED);
kernel_assert(is_attribute_found(desc));

2
intern/cycles/kernel/osl/services_shared.h
View file

@ -531,7 +531,7 @@ ccl_device bool attribute_bump_map_normal(KernelGlobals kg,
return false;
}
const bool backfacing = (sd->flag & SD_BACKFACING);
const bool backfacing = (sd->runtime_flag & SR_BACKFACING);
/* Fallback when the smooth normal is zero. */
float3 Ng = backfacing ? -sd->Ng : sd->Ng;

4
intern/cycles/kernel/svm/aov.h
View file

@ -31,7 +31,7 @@ ccl_device void svm_node_aov_color(KernelGlobals kg,
IF_KERNEL_NODES_FEATURE(AOV)
{
/* Don't write AOV on texture cache miss, we'll try again when the texture exists. */
if (sd->flag & SD_CACHE_MISS) {
if (sd->runtime_flag & SR_CACHE_MISS) {
return;
}
@ -51,7 +51,7 @@ ccl_device void svm_node_aov_value(KernelGlobals kg,
IF_KERNEL_NODES_FEATURE(AOV)
{
/* Don't write AOV on texture cache miss, we'll try again when the texture exists. */
if (sd->flag & SD_CACHE_MISS) {
if (sd->runtime_flag & SR_CACHE_MISS) {
return;
}

2
intern/cycles/kernel/svm/bevel.h
View file

@ -287,7 +287,7 @@ ccl_device float3 svm_bevel(
/* Normalize. */
const float3 N = safe_normalize(sum_N);
return is_zero(N) ? sd->N : (sd->flag & SD_BACKFACING) ? -N : N;
return is_zero(N) ? sd->N : (sd->runtime_flag & SR_BACKFACING) ? -N : N;
}
template<uint node_feature_mask, typename ConstIntegratorGenericState>

75
intern/cycles/kernel/svm/closure.h
View file

@ -133,7 +133,7 @@ principled_bsdf_emission(KernelGlobals kg,
const int sheen_flag = bsdf_sheen_setup(kg, sd, bsdf);
if (sheen_flag) {
sd->flag |= sheen_flag;
sd->runtime_flag |= sheen_flag;
/* Attenuate lower layers */
const Spectrum albedo = bsdf_albedo(
@ -165,7 +165,7 @@ principled_bsdf_emission(KernelGlobals kg,
bsdf->alpha_x = bsdf->alpha_y = sqr(coat_roughness);
/* setup bsdf */
sd->flag |= bsdf_microfacet_ggx_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
bsdf_microfacet_setup_fresnel_dielectric(kg, bsdf, sd->wi);
/* Attenuate lower layers */
@ -342,7 +342,7 @@ ccl_device
fresnel->thin_film.ior = thinfilm_ior;
/* setup bsdf */
sd->flag |= bsdf_microfacet_ggx_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
const bool is_multiggx = (distribution == CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID);
bsdf_microfacet_setup_fresnel_f82_tint(kg, bsdf, sd->wi, fresnel, f82, is_multiggx);
}
@ -392,7 +392,7 @@ ccl_device
nullptr;
if (bsdf && fresnel) {
const bool backfacing = (sd->flag & SD_BACKFACING);
const bool backfacing = (sd->runtime_flag & SR_BACKFACING);
bsdf->N = valid_reflection_N;
bsdf->T = zero_float3();
@ -410,7 +410,7 @@ ccl_device
thinfilm);
/* setup bsdf */
sd->flag |= bsdf_microfacet_ggx_glass_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_glass_setup(bsdf);
const bool is_multiggx = (distribution ==
CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID);
bsdf_microfacet_setup_fresnel_generalized_schlick(
@ -459,7 +459,7 @@ ccl_device
fresnel->thin_film.ior = thinfilm_ior;
/* setup bsdf */
sd->flag |= bsdf_microfacet_ggx_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
const bool is_multiggx = (distribution == CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID);
bsdf_microfacet_setup_fresnel_generalized_schlick(
kg, bsdf, sd->wi, fresnel, is_multiggx);
@ -503,7 +503,7 @@ ccl_device
}
/* setup bsdf */
sd->flag |= bssrdf_setup(sd, bssrdf, path_flag, subsurface_method);
sd->runtime_flag |= bssrdf_setup(sd, bssrdf, path_flag, subsurface_method);
}
}
}
@ -604,10 +604,10 @@ ccl_device
const ClosureType distribution = cdata.distribution;
/* Setup BSDF */
if (distribution == CLOSURE_BSDF_MICROFACET_BECKMANN_ID) {
sd->flag |= bsdf_microfacet_beckmann_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_beckmann_setup(bsdf);
}
else {
sd->flag |= bsdf_microfacet_ggx_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
}
const bool is_multiggx = (distribution == CLOSURE_BSDF_MICROFACET_MULTI_GGX_ID);
@ -718,13 +718,13 @@ ccl_device
/* setup bsdf */
if (type == CLOSURE_BSDF_MICROFACET_BECKMANN_ID) {
sd->flag |= bsdf_microfacet_beckmann_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_beckmann_setup(bsdf);
}
else if (type == CLOSURE_BSDF_ASHIKHMIN_SHIRLEY_ID) {
sd->flag |= bsdf_ashikhmin_shirley_setup(bsdf);
sd->runtime_flag |= bsdf_ashikhmin_shirley_setup(bsdf);
}
else {
sd->flag |= bsdf_microfacet_ggx_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_setup(bsdf);
if (type == CLOSURE_BSDF_MICROFACET_MULTI_GGX_ID) {
const Spectrum color = max(rgb_to_spectrum(stack_load(stack, bsdf_data.color)),
zero_spectrum());
@ -758,7 +758,7 @@ ccl_device
bsdf->T = zero_float3();
float eta = fmaxf(stack_load(stack, bsdf_data.ior), 1e-5f);
eta = (sd->flag & SD_BACKFACING) ? 1.0f / eta : eta;
eta = (sd->runtime_flag & SR_BACKFACING) ? 1.0f / eta : eta;
/* setup bsdf */
const float roughness = sqr(stack_load(stack, bsdf_data.roughness));
@ -767,10 +767,10 @@ ccl_device
bsdf->ior = eta;
if (type == CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID) {
sd->flag |= bsdf_microfacet_beckmann_refraction_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_beckmann_refraction_setup(bsdf);
}
else {
sd->flag |= bsdf_microfacet_ggx_refraction_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_refraction_setup(bsdf);
}
}
@ -813,7 +813,7 @@ ccl_device
bsdf->T = zero_float3();
const float ior = fmaxf(stack_load(stack, bsdf_data.ior), 1e-5f);
bsdf->ior = (sd->flag & SD_BACKFACING) ? 1.0f / ior : ior;
bsdf->ior = (sd->runtime_flag & SR_BACKFACING) ? 1.0f / ior : ior;
bsdf->alpha_x = bsdf->alpha_y = sqr(saturatef(stack_load(stack, bsdf_data.roughness)));
fresnel->f0 = make_float3(F0_from_ior(ior));
@ -824,13 +824,14 @@ ccl_device
fresnel->transmission_tint = refractive_caustics ? rgb_to_spectrum(color) :
zero_spectrum();
fresnel->thin_film.thickness = thinfilm_thickness;
fresnel->thin_film.ior = (sd->flag & SD_BACKFACING) ? thinfilm_ior / ior : thinfilm_ior;
fresnel->thin_film.ior = (sd->runtime_flag & SR_BACKFACING) ? thinfilm_ior / ior :
thinfilm_ior;
/* setup bsdf */
if (type == CLOSURE_BSDF_MICROFACET_BECKMANN_GLASS_ID) {
sd->flag |= bsdf_microfacet_beckmann_glass_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_beckmann_glass_setup(bsdf);
}
else {
sd->flag |= bsdf_microfacet_ggx_glass_setup(bsdf);
sd->runtime_flag |= bsdf_microfacet_ggx_glass_setup(bsdf);
}
const bool is_multiggx = (type == CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID);
bsdf_microfacet_setup_fresnel_generalized_schlick(kg, bsdf, sd->wi, fresnel, is_multiggx);
@ -851,7 +852,7 @@ ccl_device
bsdf->N = N;
bsdf->sigma = saturatef(stack_load(stack, bsdf_data.param1));
sd->flag |= bsdf_ashikhmin_velvet_setup(bsdf);
sd->runtime_flag |= bsdf_ashikhmin_velvet_setup(bsdf);
}
break;
}
@ -869,7 +870,7 @@ ccl_device
bsdf->N = N;
bsdf->roughness = saturatef(stack_load(stack, bsdf_data.param1));
sd->flag |= bsdf_sheen_setup(kg, sd, bsdf);
sd->runtime_flag |= bsdf_sheen_setup(kg, sd, bsdf);
}
break;
}
@ -898,10 +899,10 @@ ccl_device
bsdf->smooth = stack_load(stack, bsdf_data.smooth);
if (type == CLOSURE_BSDF_DIFFUSE_TOON_ID) {
sd->flag |= bsdf_diffuse_toon_setup(bsdf);
sd->runtime_flag |= bsdf_diffuse_toon_setup(bsdf);
}
else {
sd->flag |= bsdf_glossy_toon_setup(bsdf);
sd->runtime_flag |= bsdf_glossy_toon_setup(bsdf);
}
}
break;
@ -999,7 +1000,7 @@ ccl_device
bsdf->eta = ior;
bsdf->sigma = sigma;
sd->flag |= bsdf_hair_chiang_setup(sd, bsdf);
sd->runtime_flag |= bsdf_hair_chiang_setup(sd, bsdf);
}
}
else {
@ -1056,7 +1057,7 @@ ccl_device
bsdf->eta = ior;
bsdf->sigma = sigma;
sd->flag |= bsdf_hair_huang_setup(sd, bsdf, path_flag);
sd->runtime_flag |= bsdf_hair_huang_setup(sd, bsdf, path_flag);
}
}
break;
@ -1090,10 +1091,10 @@ ccl_device
}
if (type == CLOSURE_BSDF_HAIR_REFLECTION_ID) {
sd->flag |= bsdf_hair_reflection_setup(bsdf);
sd->runtime_flag |= bsdf_hair_reflection_setup(bsdf);
}
else {
sd->flag |= bsdf_hair_transmission_setup(bsdf);
sd->runtime_flag |= bsdf_hair_transmission_setup(bsdf);
}
}
@ -1123,7 +1124,7 @@ ccl_device
bssrdf->alpha = saturatef(stack_load(stack, bsdf_data.roughness));
bssrdf->anisotropy = stack_load(stack, bsdf_data.anisotropy);
sd->flag |= bssrdf_setup(sd, bssrdf, path_flag, type);
sd->runtime_flag |= bssrdf_setup(sd, bssrdf, path_flag, type);
}
break;
@ -1151,7 +1152,7 @@ ccl_device_inline void svm_alloc_closure_volume_scatter(ccl_private ShaderData *
bsdf_alloc(sd, sizeof(HenyeyGreensteinVolume), weight);
if (volume) {
volume->g = stack_load(stack, param1);
sd->flag |= volume_henyey_greenstein_setup(volume);
sd->runtime_flag |= volume_henyey_greenstein_setup(volume);
}
} break;
case CLOSURE_VOLUME_FOURNIER_FORAND_ID: {
@ -1160,14 +1161,14 @@ ccl_device_inline void svm_alloc_closure_volume_scatter(ccl_private ShaderData *
if (volume) {
const float IOR = stack_load(stack, param1);
const float B = stack_load(stack, param_extra);
sd->flag |= volume_fournier_forand_setup(volume, B, IOR);
sd->runtime_flag |= volume_fournier_forand_setup(volume, B, IOR);
}
} break;
case CLOSURE_VOLUME_RAYLEIGH_ID: {
ccl_private RayleighVolume *volume = (ccl_private RayleighVolume *)bsdf_alloc(
sd, sizeof(RayleighVolume), weight);
if (volume) {
sd->flag |= volume_rayleigh_setup(volume);
sd->runtime_flag |= volume_rayleigh_setup(volume);
}
break;
}
@ -1177,7 +1178,7 @@ ccl_device_inline void svm_alloc_closure_volume_scatter(ccl_private ShaderData *
if (volume) {
volume->g = stack_load(stack, param1);
volume->alpha = stack_load(stack, param_extra);
sd->flag |= volume_draine_setup(volume);
sd->runtime_flag |= volume_draine_setup(volume);
}
} break;
case CLOSURE_VOLUME_MIE_ID: {
@ -1191,14 +1192,14 @@ ccl_device_inline void svm_alloc_closure_volume_scatter(ccl_private ShaderData *
sd, sizeof(HenyeyGreensteinVolume), weight * (1.0f - mixture));
if (hg) {
hg->g = g_HG;
sd->flag |= volume_henyey_greenstein_setup(hg);
sd->runtime_flag |= volume_henyey_greenstein_setup(hg);
}
ccl_private DraineVolume *draine = (ccl_private DraineVolume *)bsdf_alloc(
sd, sizeof(DraineVolume), weight * mixture);
if (draine) {
draine->g = g_D;
draine->alpha = alpha;
sd->flag |= volume_draine_setup(draine);
sd->runtime_flag |= volume_draine_setup(draine);
}
} break;
default: {
@ -1350,7 +1351,7 @@ ccl_device_noinline void svm_node_principled_volume(
if (volume) {
const float anisotropy = stack_load(stack, node.anisotropy);
volume->g = anisotropy;
sd->flag |= volume_henyey_greenstein_setup(volume);
sd->runtime_flag |= volume_henyey_greenstein_setup(volume);
}
/* Add extinction weight. */
@ -1426,7 +1427,7 @@ ccl_device_noinline void svm_node_closure_emission(
weight *= mix_weight;
}
if (sd->flag & SD_IS_VOLUME_SHADER_EVAL) {
if (sd->runtime_flag & SR_IS_VOLUME_SHADER_EVAL) {
if ((path_visibility & PATH_RAY_VISIBILITY_SHADOW) || (path_flag & PATH_RAY_EXTINCTION)) {
/* Don't need emission for shadows and extinction. */
return;
@ -1477,7 +1478,7 @@ ccl_device_noinline void svm_node_closure_holdout(
closure_alloc(sd, sizeof(ShaderClosure), CLOSURE_HOLDOUT_ID, closure_weight);
}
sd->flag |= SD_HOLDOUT;
sd->runtime_flag |= SR_HOLDOUT;
}
/* Closure Nodes */

4
intern/cycles/kernel/svm/fresnel.h
View file

@ -21,7 +21,7 @@ ccl_device_noinline void svm_node_fresnel(ccl_private ShaderData *sd,
const float3 normal_in = stack_load_float3_default(stack, node.normal_offset, sd->N);
eta = fmaxf(eta, 1e-5f);
eta = (sd->flag & SD_BACKFACING) ? 1.0f / eta : eta;
eta = (sd->runtime_flag & SR_BACKFACING) ? 1.0f / eta : eta;
const float f = fresnel_dielectric_cos(dot(sd->wi, normal_in), eta);
@ -42,7 +42,7 @@ ccl_device_noinline void svm_node_layer_weight(ccl_private ShaderData *sd,
if (node.weight_type == NODE_LAYER_WEIGHT_FRESNEL) {
float eta = fmaxf(1.0f - blend, 1e-5f);
eta = (sd->flag & SD_BACKFACING) ? eta : 1.0f / eta;
eta = (sd->runtime_flag & SR_BACKFACING) ? eta : 1.0f / eta;
f = fresnel_dielectric_cos(dot(sd->wi, normal_in), eta);
}

2
intern/cycles/kernel/svm/light_path.h
View file

@ -48,7 +48,7 @@ ccl_device_noinline void svm_node_light_path(KernelGlobals kg,
info = (path_visibility & PATH_RAY_VISIBILITY_VOLUME_SCATTER) ? 1.0f : 0.0f;
break;
case NODE_LP_backfacing:
info = (sd->flag & SD_BACKFACING) ? 1.0f : 0.0f;
info = (sd->runtime_flag & SR_BACKFACING) ? 1.0f : 0.0f;
break;
case NODE_LP_ray_length:
info = sd->ray_length;

4
intern/cycles/kernel/svm/tex_coord.h
View file

@ -43,7 +43,7 @@ ccl_device_inline dual3 svm_texco_smooth_normal(KernelGlobals kg, const ccl_priv
N = motion_triangle_smooth_normal(
kg, sd->Ng, sd->object, sd->prim, sd->time, sd->u, sd->v, sd->du, sd->dv, N_x, N_y);
}
if (sd->flag & SD_BACKFACING) {
if (sd->runtime_flag & SR_BACKFACING) {
N = -N;
N_x = -N_x;
N_y = -N_y;
@ -229,7 +229,7 @@ ccl_device_noinline void svm_node_normal_map(KernelGlobals kg,
color.y = -color.y;
}
const bool is_backfacing = (sd->flag & SD_BACKFACING) != 0;
const bool is_backfacing = (sd->runtime_flag & SR_BACKFACING) != 0;
float3 N;
float strength = stack_load(stack, node.strength);
bool linear_interpolate_strength = false;

50
intern/cycles/kernel/types.h
View file

@ -900,42 +900,38 @@ struct ccl_align(16) ShaderClosure {
* are in world space.
*/
enum ShaderDataFlag {
/* Runtime flags. */
/* Shader runtime flags, determined during rendering. */
enum ShaderRuntimeFlag {
/* Set when ray hits backside of surface. */
SD_BACKFACING = (1 << 0),
SR_BACKFACING = (1 << 0),
/* Shader has non-zero emission. */
SD_EMISSION = (1 << 1),
SR_EMISSION = (1 << 1),
/* Shader has BSDF closure. */
SD_BSDF = (1 << 2),
SR_BSDF = (1 << 2),
/* Shader has non-singular BSDF closure. */
SD_BSDF_HAS_EVAL = (1 << 3),
SR_BSDF_HAS_EVAL = (1 << 3),
/* Shader has BSSRDF closure. */
SD_BSSRDF = (1 << 4),
SR_BSSRDF = (1 << 4),
/* Shader has holdout closure. */
SD_HOLDOUT = (1 << 5),
SR_HOLDOUT = (1 << 5),
/* Shader has non-zero volume extinction. */
SD_EXTINCTION = (1 << 6),
SR_EXTINCTION = (1 << 6),
/* Shader has a volume phase (scatter) closure. */
SD_SCATTER = (1 << 7),
SR_SCATTER = (1 << 7),
/* Shader is being evaluated in a volume. */
SD_IS_VOLUME_SHADER_EVAL = (1 << 8),
SR_IS_VOLUME_SHADER_EVAL = (1 << 8),
/* Shader has transparent closure. */
SD_TRANSPARENT = (1 << 9),
SR_TRANSPARENT = (1 << 9),
/* BSDF has a transmissive component. */
SD_BSDF_HAS_TRANSMISSION = (1 << 10),
SR_BSDF_HAS_TRANSMISSION = (1 << 10),
/* Shader has ray portal closure. */
SD_RAY_PORTAL = (1 << 11),
SR_RAY_PORTAL = (1 << 11),
/* Shader evaluation needs to be redone, because of texture cache miss */
SD_CACHE_MISS = (1 << 12),
SD_CLOSURE_FLAGS = (SD_EMISSION | SD_BSDF | SD_BSDF_HAS_EVAL | SD_BSSRDF | SD_HOLDOUT |
SD_EXTINCTION | SD_SCATTER | SD_IS_VOLUME_SHADER_EVAL |
SD_BSDF_HAS_TRANSMISSION | SD_RAY_PORTAL | SD_CACHE_MISS),
/* Shader flags. */
SR_CACHE_MISS = (1 << 12),
};
/* Shader flags that are set after compiling the shaders. */
enum ShaderDataFlag {
/* If Light Path Node is present in the shader graph. */
SD_HAS_LIGHT_PATH_NODE = (1 << 13),
/* Has bump mapping from BSDF connected to surface socket. */
@ -975,12 +971,6 @@ enum ShaderDataFlag {
SD_HAS_RAYTRACE = (1 << 30),
/* Use back side for direct light sampling. */
SD_MIS_BACK = (1 << 31),
SD_SHADER_FLAGS = (SD_MIS_FRONT | SD_HAS_TRANSPARENT_SHADOW | SD_HAS_VOLUME |
SD_HAS_ONLY_VOLUME | SD_HETEROGENEOUS_VOLUME | SD_HAS_BSSRDF_BUMP |
SD_VOLUME_EQUIANGULAR | SD_VOLUME_MIS | SD_VOLUME_CUBIC | SD_HAS_BUMP |
SD_HAS_DISPLACEMENT | SD_HAS_CONSTANT_EMISSION | SD_NEED_VOLUME_ATTRIBUTES |
SD_HAS_EMISSION | SD_HAS_RAYTRACE | SD_MIS_BACK)
};
/* Object flags. */
@ -1037,8 +1027,10 @@ struct ccl_align(16) ShaderData {
/* shader id */
int shader;
/* booleans describing shader, see ShaderRuntimeFlag */
int runtime_flag;
/* booleans describing shader, see ShaderDataFlag */
int flag;
int shader_flag;
/* booleans describing object of the shader, see ShaderDataObjectFlag */
uint object_flag;

2
intern/cycles/kernel/util/image_2d.h
View file

@ -152,7 +152,7 @@ kernel_image_tile_map(KernelGlobals kg,
image_texture_tile_access_state)[access_index] = KERNEL_TILE_ACCESS_REQUESTED;
}
if (tile_descriptor == KERNEL_TILE_LOAD_REQUEST) {
sd->flag |= SD_CACHE_MISS;
sd->runtime_flag |= SR_CACHE_MISS;
}
return tile_descriptor;
#else