diff options
author | Miika Hamalainen <blender@miikah.org> | 2011-11-09 19:46:53 +0400 |
---|---|---|
committer | Miika Hamalainen <blender@miikah.org> | 2011-11-09 19:46:53 +0400 |
commit | 1b4a54ad73c058baa59ffdc9e5f18b0b79030fb0 (patch) | |
tree | a5b84d392ea14b0d760a5e24f7a8e51f203d558c /intern/cycles/kernel/svm/svm_closure.h | |
parent | edec46b0a6aac18f406991b9e16228d4bd848c61 (diff) | |
parent | bc5ec4e69cf3308c2563239c0e8372b853800a78 (diff) |
Merge with trunk r41701soc-2011-carrot
Diffstat (limited to 'intern/cycles/kernel/svm/svm_closure.h')
-rw-r--r-- | intern/cycles/kernel/svm/svm_closure.h | 424 |
1 files changed, 424 insertions, 0 deletions
diff --git a/intern/cycles/kernel/svm/svm_closure.h b/intern/cycles/kernel/svm/svm_closure.h new file mode 100644 index 00000000000..fcda7ac6fe1 --- /dev/null +++ b/intern/cycles/kernel/svm/svm_closure.h @@ -0,0 +1,424 @@ +/* + * Copyright 2011, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +CCL_NAMESPACE_BEGIN + +/* Closure Nodes */ + +__device void svm_node_glossy_setup(ShaderData *sd, ShaderClosure *sc, int type, float eta, float roughness, bool refract) +{ + if(type == CLOSURE_BSDF_REFRACTION_ID) { + if(refract) + bsdf_refraction_setup(sd, sc, eta); + else + bsdf_reflection_setup(sd, sc); + } + else if(type == CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID) { + bsdf_microfacet_beckmann_setup(sd, sc, roughness, eta, refract); + } + else + bsdf_microfacet_ggx_setup(sd, sc, roughness, eta, refract); +} + +__device_inline ShaderClosure *svm_node_closure_get(ShaderData *sd) +{ +#ifdef __MULTI_CLOSURE__ + ShaderClosure *sc = &sd->closure[sd->num_closure]; + + if(sd->num_closure < MAX_CLOSURE) + sd->num_closure++; + + return sc; +#else + return &sd->closure; +#endif +} + +__device_inline void svm_node_closure_set_mix_weight(ShaderClosure *sc, float mix_weight) +{ +#ifdef __MULTI_CLOSURE__ + sc->weight *= mix_weight; + sc->sample_weight = fabsf(average(sc->weight)); +#endif +} + +__device void svm_node_closure_bsdf(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node, float randb, int path_flag) +{ + uint type, param1_offset, param2_offset; + +#ifdef __MULTI_CLOSURE__ + uint mix_weight_offset; + decode_node_uchar4(node.y, &type, ¶m1_offset, ¶m2_offset, &mix_weight_offset); + float mix_weight = (stack_valid(mix_weight_offset)? stack_load_float(stack, mix_weight_offset): 1.0f); + + if(mix_weight == 0.0f) + return; +#else + decode_node_uchar4(node.y, &type, ¶m1_offset, ¶m2_offset, NULL); + float mix_weight = 1.0f; +#endif + + float param1 = (stack_valid(param1_offset))? stack_load_float(stack, param1_offset): __int_as_float(node.z); + float param2 = (stack_valid(param2_offset))? stack_load_float(stack, param2_offset): __int_as_float(node.w); + + switch(type) { + case CLOSURE_BSDF_DIFFUSE_ID: { + ShaderClosure *sc = svm_node_closure_get(sd); + svm_node_closure_set_mix_weight(sc, mix_weight); + bsdf_diffuse_setup(sd, sc); + break; + } + case CLOSURE_BSDF_TRANSLUCENT_ID: { + ShaderClosure *sc = svm_node_closure_get(sd); + svm_node_closure_set_mix_weight(sc, mix_weight); + bsdf_translucent_setup(sd, sc); + break; + } + case CLOSURE_BSDF_TRANSPARENT_ID: { + ShaderClosure *sc = svm_node_closure_get(sd); + svm_node_closure_set_mix_weight(sc, mix_weight); + bsdf_transparent_setup(sd, sc); + break; + } + case CLOSURE_BSDF_REFLECTION_ID: + case CLOSURE_BSDF_MICROFACET_GGX_ID: + case CLOSURE_BSDF_MICROFACET_BECKMANN_ID: { +#ifdef __CAUSTICS_TRICKS__ + if(kernel_data.integrator.no_caustics && (path_flag & PATH_RAY_DIFFUSE)) + break; +#endif + ShaderClosure *sc = svm_node_closure_get(sd); + svm_node_closure_set_mix_weight(sc, mix_weight); + + float roughness = param1; + + /* setup bsdf */ + if(type == CLOSURE_BSDF_REFLECTION_ID) + bsdf_reflection_setup(sd, sc); + else if(type == CLOSURE_BSDF_MICROFACET_BECKMANN_ID) + bsdf_microfacet_beckmann_setup(sd, sc, roughness, 1.0f, false); + else + bsdf_microfacet_ggx_setup(sd, sc, roughness, 1.0f, false); + + break; + } + case CLOSURE_BSDF_REFRACTION_ID: + case CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID: + case CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID: { +#ifdef __CAUSTICS_TRICKS__ + if(kernel_data.integrator.no_caustics && (path_flag & PATH_RAY_DIFFUSE)) + break; +#endif + /* index of refraction */ + float eta = fmaxf(param2, 1.0f + 1e-5f); + eta = (sd->flag & SD_BACKFACING)? 1.0f/eta: eta; + + /* fresnel */ + float cosNO = dot(sd->N, sd->I); + float fresnel = fresnel_dielectric_cos(cosNO, eta); + float roughness = param1; + +#ifdef __MULTI_CLOSURE__ + /* reflection */ + ShaderClosure *sc = svm_node_closure_get(sd); + + float3 weight = sc->weight; + float sample_weight = sc->sample_weight; + + svm_node_closure_set_mix_weight(sc, mix_weight*fresnel); + svm_node_glossy_setup(sd, sc, type, eta, roughness, false); + + /* refraction */ + sc = svm_node_closure_get(sd); + + sc->weight = weight; + sc->sample_weight = sample_weight; + + svm_node_closure_set_mix_weight(sc, mix_weight*(1.0f - fresnel)); + svm_node_glossy_setup(sd, sc, type, eta, roughness, true); +#else + ShaderClosure *sc = svm_node_closure_get(sd); + + bool refract = (randb > fresnel); + + svm_node_closure_set_mix_weight(sc, mix_weight); + svm_node_glossy_setup(sd, sc, type, eta, roughness, refract); +#endif + + break; + } +#ifdef __DPDU__ + case CLOSURE_BSDF_WARD_ID: { +#ifdef __CAUSTICS_TRICKS__ + if(kernel_data.integrator.no_caustics && (path_flag & PATH_RAY_DIFFUSE)) + break; +#endif + ShaderClosure *sc = svm_node_closure_get(sd); + svm_node_closure_set_mix_weight(sc, mix_weight); + + float roughness_u = param1; + float roughness_v = param2; + + bsdf_ward_setup(sd, sc, normalize(sd->dPdu), roughness_u, roughness_v); + break; + } +#endif + case CLOSURE_BSDF_ASHIKHMIN_VELVET_ID: { + ShaderClosure *sc = svm_node_closure_get(sd); + svm_node_closure_set_mix_weight(sc, mix_weight); + + /* sigma */ + float sigma = clamp(param1, 0.0f, 1.0f); + bsdf_ashikhmin_velvet_setup(sd, sc, sigma); + break; + } + default: + break; + } +} + +__device void svm_node_closure_volume(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node, int path_flag) +{ + uint type, param1_offset, param2_offset; + +#ifdef __MULTI_CLOSURE__ + uint mix_weight_offset; + decode_node_uchar4(node.y, &type, ¶m1_offset, ¶m2_offset, &mix_weight_offset); + float mix_weight = (stack_valid(mix_weight_offset)? stack_load_float(stack, mix_weight_offset): 1.0f); + + if(mix_weight == 0.0f) + return; +#else + decode_node_uchar4(node.y, &type, ¶m1_offset, ¶m2_offset, NULL); + float mix_weight = 1.0f; +#endif + + float param1 = (stack_valid(param1_offset))? stack_load_float(stack, param1_offset): __int_as_float(node.z); + //float param2 = (stack_valid(param2_offset))? stack_load_float(stack, param2_offset): __int_as_float(node.w); + + switch(type) { + case CLOSURE_VOLUME_TRANSPARENT_ID: { + ShaderClosure *sc = svm_node_closure_get(sd); + svm_node_closure_set_mix_weight(sc, mix_weight); + + float density = param1; + volume_transparent_setup(sd, sc, density); + break; + } + case CLOSURE_VOLUME_ISOTROPIC_ID: { + ShaderClosure *sc = svm_node_closure_get(sd); + svm_node_closure_set_mix_weight(sc, mix_weight); + + float density = param1; + volume_isotropic_setup(sd, sc, density); + break; + } + default: + break; + } +} + +__device void svm_node_closure_emission(ShaderData *sd, float *stack, uint4 node) +{ +#ifdef __MULTI_CLOSURE__ + uint mix_weight_offset = node.y; + + if(stack_valid(mix_weight_offset)) { + float mix_weight = stack_load_float(stack, mix_weight_offset); + + if(mix_weight == 0.0f) + return; + + ShaderClosure *sc = svm_node_closure_get(sd); + sc->weight *= mix_weight; + sc->type = CLOSURE_EMISSION_ID; + } + else { + ShaderClosure *sc = svm_node_closure_get(sd); + sc->type = CLOSURE_EMISSION_ID; + } + +#else + ShaderClosure *sc = &sd->closure; + sc->type = CLOSURE_EMISSION_ID; +#endif + + sd->flag |= SD_EMISSION; +} + +__device void svm_node_closure_background(ShaderData *sd, float *stack, uint4 node) +{ +#ifdef __MULTI_CLOSURE__ + uint mix_weight_offset = node.y; + + if(stack_valid(mix_weight_offset)) { + float mix_weight = stack_load_float(stack, mix_weight_offset); + + if(mix_weight == 0.0f) + return; + + ShaderClosure *sc = svm_node_closure_get(sd); + sc->weight *= mix_weight; + sc->type = CLOSURE_BACKGROUND_ID; + } + else { + ShaderClosure *sc = svm_node_closure_get(sd); + sc->type = CLOSURE_BACKGROUND_ID; + } + +#else + ShaderClosure *sc = &sd->closure; + sc->type = CLOSURE_BACKGROUND_ID; +#endif +} + +__device void svm_node_closure_holdout(ShaderData *sd, float *stack, uint4 node) +{ +#ifdef __MULTI_CLOSURE__ + uint mix_weight_offset = node.y; + + if(stack_valid(mix_weight_offset)) { + float mix_weight = stack_load_float(stack, mix_weight_offset); + + if(mix_weight == 0.0f) + return; + + ShaderClosure *sc = svm_node_closure_get(sd); + sc->weight = make_float3(mix_weight, mix_weight, mix_weight); + sc->type = CLOSURE_HOLDOUT_ID; + } + else { + ShaderClosure *sc = svm_node_closure_get(sd); + sc->weight = make_float3(1.0f, 1.0f, 1.0f); + sc->type = CLOSURE_HOLDOUT_ID; + } +#else + ShaderClosure *sc = &sd->closure; + sc->type = CLOSURE_HOLDOUT_ID; +#endif + + sd->flag |= SD_HOLDOUT; +} + +/* Closure Nodes */ + +__device_inline void svm_node_closure_store_weight(ShaderData *sd, float3 weight) +{ +#ifdef __MULTI_CLOSURE__ + sd->closure[sd->num_closure].weight = weight; +#else + sd->closure.weight = weight; +#endif +} + +__device void svm_node_closure_set_weight(ShaderData *sd, uint r, uint g, uint b) +{ + float3 weight = make_float3(__int_as_float(r), __int_as_float(g), __int_as_float(b)); + svm_node_closure_store_weight(sd, weight); +} + +__device void svm_node_emission_set_weight_total(KernelGlobals *kg, ShaderData *sd, uint r, uint g, uint b) +{ + float3 weight = make_float3(__int_as_float(r), __int_as_float(g), __int_as_float(b)); + + if(sd->object != ~0) + weight /= object_surface_area(kg, sd->object); + + svm_node_closure_store_weight(sd, weight); +} + +__device void svm_node_closure_weight(ShaderData *sd, float *stack, uint weight_offset) +{ + float3 weight = stack_load_float3(stack, weight_offset); + + svm_node_closure_store_weight(sd, weight); +} + +__device void svm_node_emission_weight(KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node) +{ + uint color_offset = node.y; + uint strength_offset = node.z; + uint total_power = node.w; + + float strength = stack_load_float(stack, strength_offset); + float3 weight = stack_load_float3(stack, color_offset)*strength; + + if(total_power && sd->object != ~0) + weight /= object_surface_area(kg, sd->object); + + svm_node_closure_store_weight(sd, weight); +} + +__device void svm_node_mix_closure(ShaderData *sd, float *stack, + uint4 node, int *offset, float *randb) +{ +#ifdef __MULTI_CLOSURE__ + /* fetch weight from blend input, previous mix closures, + and write to stack to be used by closure nodes later */ + uint weight_offset, in_weight_offset, weight1_offset, weight2_offset; + decode_node_uchar4(node.y, &weight_offset, &in_weight_offset, &weight1_offset, &weight2_offset); + + float weight = stack_load_float(stack, weight_offset); + float in_weight = (stack_valid(in_weight_offset))? stack_load_float(stack, in_weight_offset): 1.0f; + + if(stack_valid(weight1_offset)) + stack_store_float(stack, weight1_offset, in_weight*(1.0f - weight)); + if(stack_valid(weight2_offset)) + stack_store_float(stack, weight2_offset, in_weight*weight); +#else + /* pick a closure and make the random number uniform over 0..1 again. + closure 1 starts on the next node, for closure 2 the start is at an + offset from the current node, so we jump */ + uint weight_offset = node.y; + uint node_jump = node.z; + float weight = stack_load_float(stack, weight_offset); + weight = clamp(weight, 0.0f, 1.0f); + + if(*randb < weight) { + *offset += node_jump; + *randb = *randb/weight; + } + else + *randb = (*randb - weight)/(1.0f - weight); +#endif +} + +__device void svm_node_add_closure(ShaderData *sd, float *stack, uint unused, + uint node_jump, int *offset, float *randb, float *closure_weight) +{ +#ifdef __MULTI_CLOSURE__ + /* nothing to do, handled in compiler */ +#else + /* pick one of the two closures with probability 0.5. sampling quality + is not going to be great, for that we'd need to evaluate the weights + of the two closures being added */ + float weight = 0.5f; + + if(*randb < weight) { + *offset += node_jump; + *randb = *randb/weight; + } + else + *randb = (*randb - weight)/(1.0f - weight); + + *closure_weight *= 2.0f; +#endif +} + +CCL_NAMESPACE_END + |