forked from bartvdbraak/blender
677 lines
15 KiB
C
677 lines
15 KiB
C
/*
|
|
* 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.
|
|
*/
|
|
|
|
/*
|
|
* ShaderData, used in four steps:
|
|
*
|
|
* Setup from incoming ray, sampled position and background.
|
|
* Execute for surface, volume or displacement.
|
|
* Evaluate one or more closures.
|
|
* Release.
|
|
*
|
|
*/
|
|
|
|
#ifdef __OSL__
|
|
|
|
#include "osl_shader.h"
|
|
|
|
#else
|
|
|
|
#include "svm/bsdf.h"
|
|
#include "svm/emissive.h"
|
|
#include "svm/volume.h"
|
|
#include "svm/svm_bsdf.h"
|
|
#include "svm/svm.h"
|
|
|
|
#endif
|
|
|
|
CCL_NAMESPACE_BEGIN
|
|
|
|
/* ShaderData setup from incoming ray */
|
|
|
|
__device_inline void shader_setup_from_ray(KernelGlobals *kg, ShaderData *sd,
|
|
const Intersection *isect, const Ray *ray)
|
|
{
|
|
/* fetch triangle data */
|
|
int prim = kernel_tex_fetch(__prim_index, isect->prim);
|
|
float4 Ns = kernel_tex_fetch(__tri_normal, prim);
|
|
float3 Ng = make_float3(Ns.x, Ns.y, Ns.z);
|
|
int shader = __float_as_int(Ns.w);
|
|
|
|
/* vectors */
|
|
sd->P = bvh_triangle_refine(kg, isect, ray);
|
|
sd->Ng = Ng;
|
|
sd->N = Ng;
|
|
sd->I = -ray->D;
|
|
sd->shader = shader;
|
|
|
|
/* triangle */
|
|
#ifdef __INSTANCING__
|
|
sd->object = isect->object;
|
|
#endif
|
|
sd->prim = prim;
|
|
#ifdef __UV__
|
|
sd->u = isect->u;
|
|
sd->v = isect->v;
|
|
#endif
|
|
|
|
/* smooth normal */
|
|
if(sd->shader & SHADER_SMOOTH_NORMAL)
|
|
sd->N = triangle_smooth_normal(kg, sd->prim, sd->u, sd->v);
|
|
|
|
sd->flag = kernel_tex_fetch(__shader_flag, (sd->shader & SHADER_MASK)*2);
|
|
|
|
#ifdef __DPDU__
|
|
/* dPdu/dPdv */
|
|
triangle_dPdudv(kg, &sd->dPdu, &sd->dPdv, sd->prim);
|
|
#endif
|
|
|
|
#ifdef __INSTANCING__
|
|
if(sd->object != ~0) {
|
|
/* instance transform */
|
|
object_normal_transform(kg, sd->object, &sd->N);
|
|
object_normal_transform(kg, sd->object, &sd->Ng);
|
|
#ifdef __DPDU__
|
|
object_dir_transform(kg, sd->object, &sd->dPdu);
|
|
object_dir_transform(kg, sd->object, &sd->dPdv);
|
|
#endif
|
|
}
|
|
else {
|
|
/* non-instanced object index */
|
|
sd->object = kernel_tex_fetch(__prim_object, isect->prim);
|
|
}
|
|
#endif
|
|
|
|
/* backfacing test */
|
|
bool backfacing = (dot(sd->Ng, sd->I) < 0.0f);
|
|
|
|
if(backfacing) {
|
|
sd->flag |= SD_BACKFACING;
|
|
sd->Ng = -sd->Ng;
|
|
sd->N = -sd->N;
|
|
#ifdef __DPDU__
|
|
sd->dPdu = -sd->dPdu;
|
|
sd->dPdv = -sd->dPdv;
|
|
#endif
|
|
}
|
|
|
|
#ifdef __RAY_DIFFERENTIALS__
|
|
/* differentials */
|
|
differential_transfer(&sd->dP, ray->dP, ray->D, ray->dD, sd->Ng, isect->t);
|
|
differential_incoming(&sd->dI, ray->dD);
|
|
differential_dudv(&sd->du, &sd->dv, sd->dPdu, sd->dPdv, sd->dP, sd->Ng);
|
|
#endif
|
|
}
|
|
|
|
/* ShaderData setup from position sampled on mesh */
|
|
|
|
__device void shader_setup_from_sample(KernelGlobals *kg, ShaderData *sd,
|
|
const float3 P, const float3 Ng, const float3 I,
|
|
int shader, int object, int prim, float u, float v)
|
|
{
|
|
/* vectors */
|
|
sd->P = P;
|
|
sd->N = Ng;
|
|
sd->Ng = Ng;
|
|
sd->I = I;
|
|
sd->shader = shader;
|
|
|
|
/* primitive */
|
|
#ifdef __INSTANCING__
|
|
sd->object = object;
|
|
#endif
|
|
sd->prim = prim;
|
|
#ifdef __UV__
|
|
sd->u = u;
|
|
sd->v = v;
|
|
#endif
|
|
|
|
/* detect instancing, for non-instanced the object index is -object-1 */
|
|
#ifdef __INSTANCING__
|
|
bool instanced = false;
|
|
|
|
if(sd->prim != ~0) {
|
|
if(sd->object >= 0)
|
|
instanced = true;
|
|
else
|
|
#endif
|
|
sd->object = ~sd->object;
|
|
#ifdef __INSTANCING__
|
|
}
|
|
#endif
|
|
|
|
/* smooth normal */
|
|
if(sd->shader & SHADER_SMOOTH_NORMAL) {
|
|
sd->N = triangle_smooth_normal(kg, sd->prim, sd->u, sd->v);
|
|
|
|
#ifdef __INSTANCING__
|
|
if(instanced)
|
|
object_normal_transform(kg, sd->object, &sd->N);
|
|
#endif
|
|
}
|
|
|
|
sd->flag = kernel_tex_fetch(__shader_flag, (sd->shader & SHADER_MASK)*2);
|
|
|
|
#ifdef __DPDU__
|
|
/* dPdu/dPdv */
|
|
if(sd->prim == ~0) {
|
|
sd->dPdu = make_float3(0.0f, 0.0f, 0.0f);
|
|
sd->dPdv = make_float3(0.0f, 0.0f, 0.0f);
|
|
}
|
|
else {
|
|
triangle_dPdudv(kg, &sd->dPdu, &sd->dPdv, sd->prim);
|
|
|
|
#ifdef __INSTANCING__
|
|
if(instanced) {
|
|
object_dir_transform(kg, sd->object, &sd->dPdu);
|
|
object_dir_transform(kg, sd->object, &sd->dPdv);
|
|
}
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
/* backfacing test */
|
|
if(sd->prim != ~0) {
|
|
bool backfacing = (dot(sd->Ng, sd->I) < 0.0f);
|
|
|
|
if(backfacing) {
|
|
sd->flag |= SD_BACKFACING;
|
|
sd->Ng = -sd->Ng;
|
|
sd->N = -sd->N;
|
|
#ifdef __DPDU__
|
|
sd->dPdu = -sd->dPdu;
|
|
sd->dPdv = -sd->dPdv;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#ifdef __RAY_DIFFERENTIALS__
|
|
/* no ray differentials here yet */
|
|
sd->dP.dx = make_float3(0.0f, 0.0f, 0.0f);
|
|
sd->dP.dy = make_float3(0.0f, 0.0f, 0.0f);
|
|
sd->dI.dx = make_float3(0.0f, 0.0f, 0.0f);
|
|
sd->dI.dy = make_float3(0.0f, 0.0f, 0.0f);
|
|
sd->du.dx = 0.0f;
|
|
sd->du.dy = 0.0f;
|
|
sd->dv.dx = 0.0f;
|
|
sd->dv.dy = 0.0f;
|
|
#endif
|
|
}
|
|
|
|
/* ShaderData setup for displacement */
|
|
|
|
__device void shader_setup_from_displace(KernelGlobals *kg, ShaderData *sd,
|
|
int object, int prim, float u, float v)
|
|
{
|
|
float3 P, Ng, I = make_float3(0.0f, 0.0f, 0.0f);
|
|
int shader;
|
|
|
|
P = triangle_point_MT(kg, prim, u, v);
|
|
Ng = triangle_normal_MT(kg, prim, &shader);
|
|
|
|
/* force smooth shading for displacement */
|
|
shader |= SHADER_SMOOTH_NORMAL;
|
|
|
|
/* watch out: no instance transform currently */
|
|
|
|
shader_setup_from_sample(kg, sd, P, Ng, I, shader, object, prim, u, v);
|
|
}
|
|
|
|
/* ShaderData setup from ray into background */
|
|
|
|
__device_inline void shader_setup_from_background(KernelGlobals *kg, ShaderData *sd, const Ray *ray)
|
|
{
|
|
/* vectors */
|
|
sd->P = ray->D;
|
|
sd->N = -sd->P;
|
|
sd->Ng = -sd->P;
|
|
sd->I = -sd->P;
|
|
sd->shader = kernel_data.background.shader;
|
|
sd->flag = kernel_tex_fetch(__shader_flag, (sd->shader & SHADER_MASK)*2);
|
|
|
|
#ifdef __INSTANCING__
|
|
sd->object = ~0;
|
|
#endif
|
|
sd->prim = ~0;
|
|
#ifdef __UV__
|
|
sd->u = 0.0f;
|
|
sd->v = 0.0f;
|
|
#endif
|
|
|
|
#ifdef __DPDU__
|
|
/* dPdu/dPdv */
|
|
sd->dPdu = make_float3(0.0f, 0.0f, 0.0f);
|
|
sd->dPdv = make_float3(0.0f, 0.0f, 0.0f);
|
|
#endif
|
|
|
|
#ifdef __RAY_DIFFERENTIALS__
|
|
/* differentials */
|
|
sd->dP = ray->dD;
|
|
differential_incoming(&sd->dI, sd->dP);
|
|
sd->du.dx = 0.0f;
|
|
sd->du.dy = 0.0f;
|
|
sd->dv.dx = 0.0f;
|
|
sd->dv.dy = 0.0f;
|
|
#endif
|
|
}
|
|
|
|
/* BSDF */
|
|
|
|
#ifdef __MULTI_CLOSURE__
|
|
|
|
__device_inline void _shader_bsdf_multi_eval(const ShaderData *sd, const float3 omega_in, float *pdf,
|
|
int skip_bsdf, BsdfEval *bsdf_eval, float sum_pdf, float sum_sample_weight)
|
|
{
|
|
for(int i = 0; i< sd->num_closure; i++) {
|
|
if(i == skip_bsdf)
|
|
continue;
|
|
|
|
const ShaderClosure *sc = &sd->closure[i];
|
|
|
|
if(CLOSURE_IS_BSDF(sc->type)) {
|
|
float bsdf_pdf = 0.0f;
|
|
#ifdef __OSL__
|
|
float3 eval = OSLShader::bsdf_eval(sd, sc, omega_in, bsdf_pdf);
|
|
#else
|
|
float3 eval = svm_bsdf_eval(sd, sc, omega_in, &bsdf_pdf);
|
|
#endif
|
|
|
|
if(bsdf_pdf != 0.0f) {
|
|
bsdf_eval_accum(bsdf_eval, sc->type, eval*sc->weight);
|
|
sum_pdf += bsdf_pdf*sc->sample_weight;
|
|
}
|
|
|
|
sum_sample_weight += sc->sample_weight;
|
|
}
|
|
}
|
|
|
|
*pdf = (sum_sample_weight > 0.0f)? sum_pdf/sum_sample_weight: 0.0f;
|
|
}
|
|
|
|
#endif
|
|
|
|
__device void shader_bsdf_eval(KernelGlobals *kg, const ShaderData *sd,
|
|
const float3 omega_in, BsdfEval *eval, float *pdf)
|
|
{
|
|
#ifdef __MULTI_CLOSURE__
|
|
bsdf_eval_init(eval, NBUILTIN_CLOSURES, make_float3(0.0f, 0.0f, 0.0f), kernel_data.film.use_light_pass);
|
|
|
|
return _shader_bsdf_multi_eval(sd, omega_in, pdf, -1, eval, 0.0f, 0.0f);
|
|
#else
|
|
const ShaderClosure *sc = &sd->closure;
|
|
|
|
*pdf = 0.0f;
|
|
*eval = svm_bsdf_eval(sd, sc, omega_in, pdf)*sc->weight;
|
|
#endif
|
|
}
|
|
|
|
__device int shader_bsdf_sample(KernelGlobals *kg, const ShaderData *sd,
|
|
float randu, float randv, BsdfEval *bsdf_eval,
|
|
float3 *omega_in, differential3 *domega_in, float *pdf)
|
|
{
|
|
#ifdef __MULTI_CLOSURE__
|
|
int sampled = 0;
|
|
|
|
if(sd->num_closure > 1) {
|
|
/* pick a BSDF closure based on sample weights */
|
|
float sum = 0.0f;
|
|
|
|
for(sampled = 0; sampled < sd->num_closure; sampled++) {
|
|
const ShaderClosure *sc = &sd->closure[sampled];
|
|
|
|
if(CLOSURE_IS_BSDF(sc->type))
|
|
sum += sc->sample_weight;
|
|
}
|
|
|
|
float r = sd->randb_closure*sum;
|
|
sum = 0.0f;
|
|
|
|
for(sampled = 0; sampled < sd->num_closure; sampled++) {
|
|
const ShaderClosure *sc = &sd->closure[sampled];
|
|
|
|
if(CLOSURE_IS_BSDF(sc->type)) {
|
|
sum += sd->closure[sampled].sample_weight;
|
|
|
|
if(r <= sum)
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(sampled == sd->num_closure) {
|
|
*pdf = 0.0f;
|
|
return LABEL_NONE;
|
|
}
|
|
}
|
|
|
|
const ShaderClosure *sc = &sd->closure[sampled];
|
|
int label;
|
|
float3 eval;
|
|
|
|
*pdf = 0.0f;
|
|
#ifdef __OSL__
|
|
label = OSLShader::bsdf_sample(sd, sc, randu, randv, eval, *omega_in, *domega_in, *pdf);
|
|
#else
|
|
label = svm_bsdf_sample(sd, sc, randu, randv, &eval, omega_in, domega_in, pdf);
|
|
#endif
|
|
|
|
bsdf_eval_init(bsdf_eval, sc->type, eval*sc->weight, kernel_data.film.use_light_pass);
|
|
|
|
if(sd->num_closure > 1 && *pdf != 0.0f) {
|
|
float sweight = sc->sample_weight;
|
|
_shader_bsdf_multi_eval(sd, *omega_in, pdf, sampled, bsdf_eval, *pdf*sweight, sweight);
|
|
}
|
|
|
|
return label;
|
|
#else
|
|
/* sample the single closure that we picked */
|
|
*pdf = 0.0f;
|
|
int label = svm_bsdf_sample(sd, &sd->closure, randu, randv, bsdf_eval, omega_in, domega_in, pdf);
|
|
*bsdf_eval *= sd->closure.weight;
|
|
return label;
|
|
#endif
|
|
}
|
|
|
|
__device void shader_bsdf_blur(KernelGlobals *kg, ShaderData *sd, float roughness)
|
|
{
|
|
#ifndef __OSL__
|
|
#ifdef __MULTI_CLOSURE__
|
|
for(int i = 0; i< sd->num_closure; i++) {
|
|
ShaderClosure *sc = &sd->closure[i];
|
|
|
|
if(CLOSURE_IS_BSDF(sc->type))
|
|
svm_bsdf_blur(sc, roughness);
|
|
}
|
|
#else
|
|
svm_bsdf_blur(&sd->closure, roughness);
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
__device float3 shader_bsdf_transparency(KernelGlobals *kg, ShaderData *sd)
|
|
{
|
|
#ifdef __MULTI_CLOSURE__
|
|
float3 eval = make_float3(0.0f, 0.0f, 0.0f);
|
|
|
|
for(int i = 0; i< sd->num_closure; i++) {
|
|
ShaderClosure *sc = &sd->closure[i];
|
|
|
|
if(sc->type == CLOSURE_BSDF_TRANSPARENT_ID) // todo: make this work for osl
|
|
eval += sc->weight;
|
|
}
|
|
|
|
return eval;
|
|
#else
|
|
if(sd->closure.type == CLOSURE_BSDF_TRANSPARENT_ID)
|
|
return sd->closure.weight;
|
|
else
|
|
return make_float3(0.0f, 0.0f, 0.0f);
|
|
#endif
|
|
}
|
|
|
|
__device float3 shader_bsdf_diffuse(KernelGlobals *kg, ShaderData *sd)
|
|
{
|
|
#ifdef __MULTI_CLOSURE__
|
|
float3 eval = make_float3(0.0f, 0.0f, 0.0f);
|
|
|
|
for(int i = 0; i< sd->num_closure; i++) {
|
|
ShaderClosure *sc = &sd->closure[i];
|
|
|
|
if(CLOSURE_IS_BSDF_DIFFUSE(sc->type))
|
|
eval += sc->weight;
|
|
}
|
|
|
|
return eval;
|
|
#else
|
|
if(CLOSURE_IS_BSDF_DIFFUSE(sd->closure.type))
|
|
return sd->closure.weight;
|
|
else
|
|
return make_float3(0.0f, 0.0f, 0.0f);
|
|
#endif
|
|
}
|
|
|
|
__device float3 shader_bsdf_glossy(KernelGlobals *kg, ShaderData *sd)
|
|
{
|
|
#ifdef __MULTI_CLOSURE__
|
|
float3 eval = make_float3(0.0f, 0.0f, 0.0f);
|
|
|
|
for(int i = 0; i< sd->num_closure; i++) {
|
|
ShaderClosure *sc = &sd->closure[i];
|
|
|
|
if(CLOSURE_IS_BSDF_GLOSSY(sc->type))
|
|
eval += sc->weight;
|
|
}
|
|
|
|
return eval;
|
|
#else
|
|
if(CLOSURE_IS_BSDF_GLOSSY(sd->closure.type))
|
|
return sd->closure.weight;
|
|
else
|
|
return make_float3(0.0f, 0.0f, 0.0f);
|
|
#endif
|
|
}
|
|
|
|
__device float3 shader_bsdf_transmission(KernelGlobals *kg, ShaderData *sd)
|
|
{
|
|
#ifdef __MULTI_CLOSURE__
|
|
float3 eval = make_float3(0.0f, 0.0f, 0.0f);
|
|
|
|
for(int i = 0; i< sd->num_closure; i++) {
|
|
ShaderClosure *sc = &sd->closure[i];
|
|
|
|
if(CLOSURE_IS_BSDF_TRANSMISSION(sc->type))
|
|
eval += sc->weight;
|
|
}
|
|
|
|
return eval;
|
|
#else
|
|
if(CLOSURE_IS_BSDF_TRANSMISSION(sd->closure.type))
|
|
return sd->closure.weight;
|
|
else
|
|
return make_float3(0.0f, 0.0f, 0.0f);
|
|
#endif
|
|
}
|
|
|
|
/* Emission */
|
|
|
|
__device float3 shader_emissive_eval(KernelGlobals *kg, ShaderData *sd)
|
|
{
|
|
float3 eval;
|
|
#ifdef __MULTI_CLOSURE__
|
|
eval = make_float3(0.0f, 0.0f, 0.0f);
|
|
|
|
for(int i = 0; i < sd->num_closure; i++) {
|
|
ShaderClosure *sc = &sd->closure[i];
|
|
|
|
if(CLOSURE_IS_EMISSION(sc->type)) {
|
|
#ifdef __OSL__
|
|
eval += OSLShader::emissive_eval(sd)*sc->weight;
|
|
#else
|
|
eval += svm_emissive_eval(sd, sc)*sc->weight;
|
|
#endif
|
|
}
|
|
}
|
|
#else
|
|
eval = svm_emissive_eval(sd, &sd->closure)*sd->closure.weight;
|
|
#endif
|
|
|
|
return eval;
|
|
}
|
|
|
|
/* Holdout */
|
|
|
|
__device float3 shader_holdout_eval(KernelGlobals *kg, ShaderData *sd)
|
|
{
|
|
#ifdef __MULTI_CLOSURE__
|
|
float3 weight = make_float3(0.0f, 0.0f, 0.0f);
|
|
|
|
for(int i = 0; i < sd->num_closure; i++) {
|
|
ShaderClosure *sc = &sd->closure[i];
|
|
|
|
if(CLOSURE_IS_HOLDOUT(sc->type))
|
|
weight += sc->weight;
|
|
}
|
|
|
|
return weight;
|
|
#else
|
|
if(sd->closure.type == CLOSURE_HOLDOUT_ID)
|
|
return make_float3(1.0f, 1.0f, 1.0f);
|
|
|
|
return make_float3(0.0f, 0.0f, 0.0f);
|
|
#endif
|
|
}
|
|
|
|
/* Surface Evaluation */
|
|
|
|
__device void shader_eval_surface(KernelGlobals *kg, ShaderData *sd,
|
|
float randb, int path_flag)
|
|
{
|
|
#ifdef __OSL__
|
|
OSLShader::eval_surface(kg, sd, randb, path_flag);
|
|
#else
|
|
|
|
#ifdef __SVM__
|
|
svm_eval_nodes(kg, sd, SHADER_TYPE_SURFACE, randb, path_flag);
|
|
#else
|
|
bsdf_diffuse_setup(sd, &sd->closure);
|
|
sd->closure.weight = make_float3(0.8f, 0.8f, 0.8f);
|
|
#endif
|
|
|
|
#endif
|
|
}
|
|
|
|
/* Background Evaluation */
|
|
|
|
__device float3 shader_eval_background(KernelGlobals *kg, ShaderData *sd, int path_flag)
|
|
{
|
|
#ifdef __OSL__
|
|
return OSLShader::eval_background(kg, sd, path_flag);
|
|
#else
|
|
|
|
#ifdef __SVM__
|
|
svm_eval_nodes(kg, sd, SHADER_TYPE_SURFACE, 0.0f, path_flag);
|
|
|
|
#ifdef __MULTI_CLOSURE__
|
|
float3 eval = make_float3(0.0f, 0.0f, 0.0f);
|
|
|
|
for(int i = 0; i< sd->num_closure; i++) {
|
|
const ShaderClosure *sc = &sd->closure[i];
|
|
|
|
if(CLOSURE_IS_BACKGROUND(sc->type))
|
|
eval += sc->weight;
|
|
}
|
|
|
|
return eval;
|
|
#else
|
|
if(sd->closure.type == CLOSURE_BACKGROUND_ID)
|
|
return sd->closure.weight;
|
|
else
|
|
return make_float3(0.0f, 0.0f, 0.0f);
|
|
#endif
|
|
|
|
#else
|
|
return make_float3(0.8f, 0.8f, 0.8f);
|
|
#endif
|
|
|
|
#endif
|
|
}
|
|
|
|
/* Volume */
|
|
|
|
__device float3 shader_volume_eval_phase(KernelGlobals *kg, ShaderData *sd,
|
|
float3 omega_in, float3 omega_out)
|
|
{
|
|
#ifdef __MULTI_CLOSURE__
|
|
float3 eval = make_float3(0.0f, 0.0f, 0.0f);
|
|
|
|
for(int i = 0; i< sd->num_closure; i++) {
|
|
const ShaderClosure *sc = &sd->closure[i];
|
|
|
|
if(CLOSURE_IS_VOLUME(sc->type)) {
|
|
#ifdef __OSL__
|
|
eval += OSLShader::volume_eval_phase(sd, omega_in, omega_out);
|
|
#else
|
|
eval += volume_eval_phase(sd, sc, omega_in, omega_out);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
return eval;
|
|
#else
|
|
return volume_eval_phase(sd, &sd->closure, omega_in, omega_out);
|
|
#endif
|
|
}
|
|
|
|
/* Volume Evaluation */
|
|
|
|
__device void shader_eval_volume(KernelGlobals *kg, ShaderData *sd,
|
|
float randb, int path_flag)
|
|
{
|
|
#ifdef __SVM__
|
|
#ifdef __OSL__
|
|
OSLShader::eval_volume(kg, sd, randb, path_flag);
|
|
#else
|
|
svm_eval_nodes(kg, sd, SHADER_TYPE_VOLUME, randb, path_flag);
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
/* Displacement Evaluation */
|
|
|
|
__device void shader_eval_displacement(KernelGlobals *kg, ShaderData *sd)
|
|
{
|
|
/* this will modify sd->P */
|
|
#ifdef __SVM__
|
|
#ifdef __OSL__
|
|
OSLShader::eval_displacement(kg, sd);
|
|
#else
|
|
svm_eval_nodes(kg, sd, SHADER_TYPE_DISPLACEMENT, 0.0f, 0);
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
/* Transparent Shadows */
|
|
|
|
#ifdef __TRANSPARENT_SHADOWS__
|
|
__device bool shader_transparent_shadow(KernelGlobals *kg, Intersection *isect)
|
|
{
|
|
int prim = kernel_tex_fetch(__prim_index, isect->prim);
|
|
float4 Ns = kernel_tex_fetch(__tri_normal, prim);
|
|
int shader = __float_as_int(Ns.w);
|
|
int flag = kernel_tex_fetch(__shader_flag, (shader & SHADER_MASK)*2);
|
|
|
|
return (flag & SD_HAS_SURFACE_TRANSPARENT) != 0;
|
|
}
|
|
#endif
|
|
|
|
__device int shader_pass_id(KernelGlobals *kg, ShaderData *sd)
|
|
{
|
|
return kernel_tex_fetch(__shader_flag, (sd->shader & SHADER_MASK)*2 + 1);
|
|
}
|
|
|
|
/* Free ShaderData */
|
|
|
|
__device void shader_release(KernelGlobals *kg, ShaderData *sd)
|
|
{
|
|
#ifdef __OSL__
|
|
OSLShader::release(kg, sd);
|
|
#endif
|
|
}
|
|
|
|
CCL_NAMESPACE_END
|
|
|