diff options
author | Campbell Barton <ideasman42@gmail.com> | 2019-04-17 07:17:24 +0300 |
---|---|---|
committer | Campbell Barton <ideasman42@gmail.com> | 2019-04-17 07:21:24 +0300 |
commit | e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 (patch) | |
tree | 8cf3453d12edb177a218ef8009357518ec6cab6a /intern/cycles/kernel/osl | |
parent | b3dabc200a4b0399ec6b81f2ff2730d07b44fcaa (diff) |
ClangFormat: apply to source, most of intern
Apply clang format as proposed in T53211.
For details on usage and instructions for migrating branches
without conflicts, see:
https://wiki.blender.org/wiki/Tools/ClangFormat
Diffstat (limited to 'intern/cycles/kernel/osl')
-rw-r--r-- | intern/cycles/kernel/osl/CMakeLists.txt | 28 | ||||
-rw-r--r-- | intern/cycles/kernel/osl/background.cpp | 37 | ||||
-rw-r--r-- | intern/cycles/kernel/osl/bsdf_diffuse_ramp.cpp | 43 | ||||
-rw-r--r-- | intern/cycles/kernel/osl/bsdf_phong_ramp.cpp | 45 | ||||
-rw-r--r-- | intern/cycles/kernel/osl/emissive.cpp | 18 | ||||
-rw-r--r-- | intern/cycles/kernel/osl/osl_bssrdf.cpp | 133 | ||||
-rw-r--r-- | intern/cycles/kernel/osl/osl_closures.cpp | 1300 | ||||
-rw-r--r-- | intern/cycles/kernel/osl/osl_closures.h | 86 | ||||
-rw-r--r-- | intern/cycles/kernel/osl/osl_globals.h | 106 | ||||
-rw-r--r-- | intern/cycles/kernel/osl/osl_services.cpp | 2064 | ||||
-rw-r--r-- | intern/cycles/kernel/osl/osl_services.h | 388 | ||||
-rw-r--r-- | intern/cycles/kernel/osl/osl_shader.cpp | 580 | ||||
-rw-r--r-- | intern/cycles/kernel/osl/osl_shader.h | 35 |
13 files changed, 2540 insertions, 2323 deletions
diff --git a/intern/cycles/kernel/osl/CMakeLists.txt b/intern/cycles/kernel/osl/CMakeLists.txt index 0a3d0b974cb..28d9ca854db 100644 --- a/intern/cycles/kernel/osl/CMakeLists.txt +++ b/intern/cycles/kernel/osl/CMakeLists.txt @@ -1,6 +1,6 @@ set(INC - ../.. + ../.. ) set(INC_SYS @@ -8,25 +8,25 @@ set(INC_SYS ) set(SRC - background.cpp - bsdf_diffuse_ramp.cpp - bsdf_phong_ramp.cpp - emissive.cpp - osl_bssrdf.cpp - osl_closures.cpp - osl_services.cpp - osl_shader.cpp + background.cpp + bsdf_diffuse_ramp.cpp + bsdf_phong_ramp.cpp + emissive.cpp + osl_bssrdf.cpp + osl_closures.cpp + osl_services.cpp + osl_shader.cpp ) set(HEADER_SRC - osl_closures.h - osl_globals.h - osl_services.h - osl_shader.h + osl_closures.h + osl_globals.h + osl_services.h + osl_shader.h ) set(LIB - cycles_render + cycles_render ) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${RTTI_DISABLE_FLAGS}") diff --git a/intern/cycles/kernel/osl/background.cpp b/intern/cycles/kernel/osl/background.cpp index 6924a4144c5..b395227845d 100644 --- a/intern/cycles/kernel/osl/background.cpp +++ b/intern/cycles/kernel/osl/background.cpp @@ -51,11 +51,11 @@ using namespace OSL; /// only the weight is taking into account /// class GenericBackgroundClosure : public CClosurePrimitive { -public: - void setup(ShaderData *sd, int /* path_flag */, float3 weight) - { - background_setup(sd, weight); - } + public: + void setup(ShaderData *sd, int /* path_flag */, float3 weight) + { + background_setup(sd, weight); + } }; /// Holdout closure @@ -66,31 +66,28 @@ public: /// used /// class HoldoutClosure : CClosurePrimitive { -public: - void setup(ShaderData *sd, int /* path_flag */, float3 weight) - { - closure_alloc(sd, sizeof(ShaderClosure), CLOSURE_HOLDOUT_ID, weight); - sd->flag |= SD_HOLDOUT; - } + public: + void setup(ShaderData *sd, int /* path_flag */, float3 weight) + { + closure_alloc(sd, sizeof(ShaderClosure), CLOSURE_HOLDOUT_ID, weight); + sd->flag |= SD_HOLDOUT; + } }; ClosureParam *closure_background_params() { - static ClosureParam params[] = { - CLOSURE_STRING_KEYPARAM(GenericBackgroundClosure, label, "label"), - CLOSURE_FINISH_PARAM(GenericBackgroundClosure) - }; - return params; + static ClosureParam params[] = { + CLOSURE_STRING_KEYPARAM(GenericBackgroundClosure, label, "label"), + CLOSURE_FINISH_PARAM(GenericBackgroundClosure)}; + return params; } CCLOSURE_PREPARE(closure_background_prepare, GenericBackgroundClosure) ClosureParam *closure_holdout_params() { - static ClosureParam params[] = { - CLOSURE_FINISH_PARAM(HoldoutClosure) - }; - return params; + static ClosureParam params[] = {CLOSURE_FINISH_PARAM(HoldoutClosure)}; + return params; } CCLOSURE_PREPARE(closure_holdout_prepare, HoldoutClosure) diff --git a/intern/cycles/kernel/osl/bsdf_diffuse_ramp.cpp b/intern/cycles/kernel/osl/bsdf_diffuse_ramp.cpp index ed5d5235a34..c5edc7c9be3 100644 --- a/intern/cycles/kernel/osl/bsdf_diffuse_ramp.cpp +++ b/intern/cycles/kernel/osl/bsdf_diffuse_ramp.cpp @@ -47,36 +47,35 @@ CCL_NAMESPACE_BEGIN using namespace OSL; class DiffuseRampClosure : public CBSDFClosure { -public: - DiffuseRampBsdf params; - Color3 colors[8]; + public: + DiffuseRampBsdf params; + Color3 colors[8]; - void setup(ShaderData *sd, int /* path_flag */, float3 weight) - { - DiffuseRampBsdf *bsdf = (DiffuseRampBsdf*)bsdf_alloc_osl(sd, sizeof(DiffuseRampBsdf), weight, ¶ms); + void setup(ShaderData *sd, int /* path_flag */, float3 weight) + { + DiffuseRampBsdf *bsdf = (DiffuseRampBsdf *)bsdf_alloc_osl( + sd, sizeof(DiffuseRampBsdf), weight, ¶ms); - if(bsdf) { - bsdf->colors = (float3*)closure_alloc_extra(sd, sizeof(float3)*8); + if (bsdf) { + bsdf->colors = (float3 *)closure_alloc_extra(sd, sizeof(float3) * 8); - if(bsdf->colors) { - for(int i = 0; i < 8; i++) - bsdf->colors[i] = TO_FLOAT3(colors[i]); + if (bsdf->colors) { + for (int i = 0; i < 8; i++) + bsdf->colors[i] = TO_FLOAT3(colors[i]); - sd->flag |= bsdf_diffuse_ramp_setup(bsdf); - } - } - } + sd->flag |= bsdf_diffuse_ramp_setup(bsdf); + } + } + } }; ClosureParam *closure_bsdf_diffuse_ramp_params() { - static ClosureParam params[] = { - CLOSURE_FLOAT3_PARAM(DiffuseRampClosure, params.N), - CLOSURE_COLOR_ARRAY_PARAM(DiffuseRampClosure, colors, 8), - CLOSURE_STRING_KEYPARAM(DiffuseRampClosure, label, "label"), - CLOSURE_FINISH_PARAM(DiffuseRampClosure) - }; - return params; + static ClosureParam params[] = {CLOSURE_FLOAT3_PARAM(DiffuseRampClosure, params.N), + CLOSURE_COLOR_ARRAY_PARAM(DiffuseRampClosure, colors, 8), + CLOSURE_STRING_KEYPARAM(DiffuseRampClosure, label, "label"), + CLOSURE_FINISH_PARAM(DiffuseRampClosure)}; + return params; } CCLOSURE_PREPARE(closure_bsdf_diffuse_ramp_prepare, DiffuseRampClosure) diff --git a/intern/cycles/kernel/osl/bsdf_phong_ramp.cpp b/intern/cycles/kernel/osl/bsdf_phong_ramp.cpp index a8acdb8e342..4b7e59ff932 100644 --- a/intern/cycles/kernel/osl/bsdf_phong_ramp.cpp +++ b/intern/cycles/kernel/osl/bsdf_phong_ramp.cpp @@ -46,37 +46,36 @@ CCL_NAMESPACE_BEGIN using namespace OSL; class PhongRampClosure : public CBSDFClosure { -public: - PhongRampBsdf params; - Color3 colors[8]; + public: + PhongRampBsdf params; + Color3 colors[8]; - void setup(ShaderData *sd, int /* path_flag */, float3 weight) - { - PhongRampBsdf *bsdf = (PhongRampBsdf*)bsdf_alloc_osl(sd, sizeof(PhongRampBsdf), weight, ¶ms); + void setup(ShaderData *sd, int /* path_flag */, float3 weight) + { + PhongRampBsdf *bsdf = (PhongRampBsdf *)bsdf_alloc_osl( + sd, sizeof(PhongRampBsdf), weight, ¶ms); - if(bsdf) { - bsdf->colors = (float3*)closure_alloc_extra(sd, sizeof(float3)*8); + if (bsdf) { + bsdf->colors = (float3 *)closure_alloc_extra(sd, sizeof(float3) * 8); - if(bsdf->colors) { - for(int i = 0; i < 8; i++) - bsdf->colors[i] = TO_FLOAT3(colors[i]); + if (bsdf->colors) { + for (int i = 0; i < 8; i++) + bsdf->colors[i] = TO_FLOAT3(colors[i]); - sd->flag |= bsdf_phong_ramp_setup(bsdf); - } - } - } + sd->flag |= bsdf_phong_ramp_setup(bsdf); + } + } + } }; ClosureParam *closure_bsdf_phong_ramp_params() { - static ClosureParam params[] = { - CLOSURE_FLOAT3_PARAM(PhongRampClosure, params.N), - CLOSURE_FLOAT_PARAM(PhongRampClosure, params.exponent), - CLOSURE_COLOR_ARRAY_PARAM(PhongRampClosure, colors, 8), - CLOSURE_STRING_KEYPARAM(PhongRampClosure, label, "label"), - CLOSURE_FINISH_PARAM(PhongRampClosure) - }; - return params; + static ClosureParam params[] = {CLOSURE_FLOAT3_PARAM(PhongRampClosure, params.N), + CLOSURE_FLOAT_PARAM(PhongRampClosure, params.exponent), + CLOSURE_COLOR_ARRAY_PARAM(PhongRampClosure, colors, 8), + CLOSURE_STRING_KEYPARAM(PhongRampClosure, label, "label"), + CLOSURE_FINISH_PARAM(PhongRampClosure)}; + return params; } CCLOSURE_PREPARE(closure_bsdf_phong_ramp_prepare, PhongRampClosure) diff --git a/intern/cycles/kernel/osl/emissive.cpp b/intern/cycles/kernel/osl/emissive.cpp index c2a848231f2..c29ddb13e2e 100644 --- a/intern/cycles/kernel/osl/emissive.cpp +++ b/intern/cycles/kernel/osl/emissive.cpp @@ -53,20 +53,18 @@ using namespace OSL; /// if the provided angles are PI/2, which is the default /// class GenericEmissiveClosure : public CClosurePrimitive { -public: - void setup(ShaderData *sd, int /* path_flag */, float3 weight) - { - emission_setup(sd, weight); - } + public: + void setup(ShaderData *sd, int /* path_flag */, float3 weight) + { + emission_setup(sd, weight); + } }; ClosureParam *closure_emission_params() { - static ClosureParam params[] = { - CLOSURE_STRING_KEYPARAM(GenericEmissiveClosure, label, "label"), - CLOSURE_FINISH_PARAM(GenericEmissiveClosure) - }; - return params; + static ClosureParam params[] = {CLOSURE_STRING_KEYPARAM(GenericEmissiveClosure, label, "label"), + CLOSURE_FINISH_PARAM(GenericEmissiveClosure)}; + return params; } CCLOSURE_PREPARE(closure_emission_prepare, GenericEmissiveClosure) diff --git a/intern/cycles/kernel/osl/osl_bssrdf.cpp b/intern/cycles/kernel/osl/osl_bssrdf.cpp index 66ec8a996ca..dd52c33071c 100644 --- a/intern/cycles/kernel/osl/osl_bssrdf.cpp +++ b/intern/cycles/kernel/osl/osl_bssrdf.cpp @@ -56,77 +56,76 @@ static ustring u_random_walk("random_walk"); static ustring u_principled_random_walk("principled_random_walk"); class CBSSRDFClosure : public CClosurePrimitive { -public: - Bssrdf params; - ustring method; - - CBSSRDFClosure() - { - params.texture_blur = 0.0f; - params.sharpness = 0.0f; - params.roughness = 0.0f; - } - - void setup(ShaderData *sd, int path_flag, float3 weight) - { - if(method == u_cubic) { - alloc(sd, path_flag, weight, CLOSURE_BSSRDF_CUBIC_ID); - } - else if(method == u_gaussian) { - alloc(sd, path_flag, weight, CLOSURE_BSSRDF_GAUSSIAN_ID); - } - else if(method == u_burley) { - alloc(sd, path_flag, weight, CLOSURE_BSSRDF_BURLEY_ID); - } - else if(method == u_principled) { - alloc(sd, path_flag, weight, CLOSURE_BSSRDF_PRINCIPLED_ID); - } - else if(method == u_random_walk) { - alloc(sd, path_flag, weight, CLOSURE_BSSRDF_RANDOM_WALK_ID); - } - else if(method == u_principled_random_walk) { - alloc(sd, path_flag, weight, CLOSURE_BSSRDF_PRINCIPLED_RANDOM_WALK_ID); - } - } - - void alloc(ShaderData *sd, int path_flag, float3 weight, ClosureType type) - { - Bssrdf *bssrdf = bssrdf_alloc(sd, weight); - - if(bssrdf) { - /* disable in case of diffuse ancestor, can't see it well then and - * adds considerably noise due to probabilities of continuing path - * getting lower and lower */ - if(path_flag & PATH_RAY_DIFFUSE_ANCESTOR) { - params.radius = make_float3(0.0f, 0.0f, 0.0f); - } - - /* create one closure per color channel */ - bssrdf->radius = params.radius; - bssrdf->albedo = params.albedo; - bssrdf->texture_blur = params.texture_blur; - bssrdf->sharpness = params.sharpness; - bssrdf->N = params.N; - bssrdf->roughness = params.roughness; - sd->flag |= bssrdf_setup(sd, bssrdf, (ClosureType)type); - } - } + public: + Bssrdf params; + ustring method; + + CBSSRDFClosure() + { + params.texture_blur = 0.0f; + params.sharpness = 0.0f; + params.roughness = 0.0f; + } + + void setup(ShaderData *sd, int path_flag, float3 weight) + { + if (method == u_cubic) { + alloc(sd, path_flag, weight, CLOSURE_BSSRDF_CUBIC_ID); + } + else if (method == u_gaussian) { + alloc(sd, path_flag, weight, CLOSURE_BSSRDF_GAUSSIAN_ID); + } + else if (method == u_burley) { + alloc(sd, path_flag, weight, CLOSURE_BSSRDF_BURLEY_ID); + } + else if (method == u_principled) { + alloc(sd, path_flag, weight, CLOSURE_BSSRDF_PRINCIPLED_ID); + } + else if (method == u_random_walk) { + alloc(sd, path_flag, weight, CLOSURE_BSSRDF_RANDOM_WALK_ID); + } + else if (method == u_principled_random_walk) { + alloc(sd, path_flag, weight, CLOSURE_BSSRDF_PRINCIPLED_RANDOM_WALK_ID); + } + } + + void alloc(ShaderData *sd, int path_flag, float3 weight, ClosureType type) + { + Bssrdf *bssrdf = bssrdf_alloc(sd, weight); + + if (bssrdf) { + /* disable in case of diffuse ancestor, can't see it well then and + * adds considerably noise due to probabilities of continuing path + * getting lower and lower */ + if (path_flag & PATH_RAY_DIFFUSE_ANCESTOR) { + params.radius = make_float3(0.0f, 0.0f, 0.0f); + } + + /* create one closure per color channel */ + bssrdf->radius = params.radius; + bssrdf->albedo = params.albedo; + bssrdf->texture_blur = params.texture_blur; + bssrdf->sharpness = params.sharpness; + bssrdf->N = params.N; + bssrdf->roughness = params.roughness; + sd->flag |= bssrdf_setup(sd, bssrdf, (ClosureType)type); + } + } }; ClosureParam *closure_bssrdf_params() { - static ClosureParam params[] = { - CLOSURE_STRING_PARAM(CBSSRDFClosure, method), - CLOSURE_FLOAT3_PARAM(CBSSRDFClosure, params.N), - CLOSURE_FLOAT3_PARAM(CBSSRDFClosure, params.radius), - CLOSURE_FLOAT3_PARAM(CBSSRDFClosure, params.albedo), - CLOSURE_FLOAT_KEYPARAM(CBSSRDFClosure, params.texture_blur, "texture_blur"), - CLOSURE_FLOAT_KEYPARAM(CBSSRDFClosure, params.sharpness, "sharpness"), - CLOSURE_FLOAT_KEYPARAM(CBSSRDFClosure, params.roughness, "roughness"), - CLOSURE_STRING_KEYPARAM(CBSSRDFClosure, label, "label"), - CLOSURE_FINISH_PARAM(CBSSRDFClosure) - }; - return params; + static ClosureParam params[] = { + CLOSURE_STRING_PARAM(CBSSRDFClosure, method), + CLOSURE_FLOAT3_PARAM(CBSSRDFClosure, params.N), + CLOSURE_FLOAT3_PARAM(CBSSRDFClosure, params.radius), + CLOSURE_FLOAT3_PARAM(CBSSRDFClosure, params.albedo), + CLOSURE_FLOAT_KEYPARAM(CBSSRDFClosure, params.texture_blur, "texture_blur"), + CLOSURE_FLOAT_KEYPARAM(CBSSRDFClosure, params.sharpness, "sharpness"), + CLOSURE_FLOAT_KEYPARAM(CBSSRDFClosure, params.roughness, "roughness"), + CLOSURE_STRING_KEYPARAM(CBSSRDFClosure, label, "label"), + CLOSURE_FINISH_PARAM(CBSSRDFClosure)}; + return params; } CCLOSURE_PREPARE(closure_bssrdf_prepare, CBSSRDFClosure) diff --git a/intern/cycles/kernel/osl/osl_closures.cpp b/intern/cycles/kernel/osl/osl_closures.cpp index 169351d5ad9..aa7e2727577 100644 --- a/intern/cycles/kernel/osl/osl_closures.cpp +++ b/intern/cycles/kernel/osl/osl_closures.cpp @@ -71,706 +71,787 @@ using namespace OSL; /* BSDF class definitions */ BSDF_CLOSURE_CLASS_BEGIN(Diffuse, diffuse, DiffuseBsdf, LABEL_DIFFUSE) - CLOSURE_FLOAT3_PARAM(DiffuseClosure, params.N), -BSDF_CLOSURE_CLASS_END(Diffuse, diffuse) - -BSDF_CLOSURE_CLASS_BEGIN(Translucent, translucent, DiffuseBsdf, LABEL_DIFFUSE) - CLOSURE_FLOAT3_PARAM(TranslucentClosure, params.N), -BSDF_CLOSURE_CLASS_END(Translucent, translucent) - -BSDF_CLOSURE_CLASS_BEGIN(OrenNayar, oren_nayar, OrenNayarBsdf, LABEL_DIFFUSE) - CLOSURE_FLOAT3_PARAM(OrenNayarClosure, params.N), - CLOSURE_FLOAT_PARAM(OrenNayarClosure, params.roughness), -BSDF_CLOSURE_CLASS_END(OrenNayar, oren_nayar) - -BSDF_CLOSURE_CLASS_BEGIN(Reflection, reflection, MicrofacetBsdf, LABEL_SINGULAR) - CLOSURE_FLOAT3_PARAM(ReflectionClosure, params.N), -BSDF_CLOSURE_CLASS_END(Reflection, reflection) - -BSDF_CLOSURE_CLASS_BEGIN(Refraction, refraction, MicrofacetBsdf, LABEL_SINGULAR) - CLOSURE_FLOAT3_PARAM(RefractionClosure, params.N), - CLOSURE_FLOAT_PARAM(RefractionClosure, params.ior), -BSDF_CLOSURE_CLASS_END(Refraction, refraction) - -BSDF_CLOSURE_CLASS_BEGIN(AshikhminVelvet, ashikhmin_velvet, VelvetBsdf, LABEL_DIFFUSE) - CLOSURE_FLOAT3_PARAM(AshikhminVelvetClosure, params.N), - CLOSURE_FLOAT_PARAM(AshikhminVelvetClosure, params.sigma), -BSDF_CLOSURE_CLASS_END(AshikhminVelvet, ashikhmin_velvet) - -BSDF_CLOSURE_CLASS_BEGIN(AshikhminShirley, ashikhmin_shirley_aniso, MicrofacetBsdf, LABEL_GLOSSY|LABEL_REFLECT) - CLOSURE_FLOAT3_PARAM(AshikhminShirleyClosure, params.N), - CLOSURE_FLOAT3_PARAM(AshikhminShirleyClosure, params.T), - CLOSURE_FLOAT_PARAM(AshikhminShirleyClosure, params.alpha_x), - CLOSURE_FLOAT_PARAM(AshikhminShirleyClosure, params.alpha_y), -BSDF_CLOSURE_CLASS_END(AshikhminShirley, ashikhmin_shirley_aniso) - -BSDF_CLOSURE_CLASS_BEGIN(DiffuseToon, diffuse_toon, ToonBsdf, LABEL_DIFFUSE) - CLOSURE_FLOAT3_PARAM(DiffuseToonClosure, params.N), - CLOSURE_FLOAT_PARAM(DiffuseToonClosure, params.size), - CLOSURE_FLOAT_PARAM(DiffuseToonClosure, params.smooth), -BSDF_CLOSURE_CLASS_END(DiffuseToon, diffuse_toon) - -BSDF_CLOSURE_CLASS_BEGIN(GlossyToon, glossy_toon, ToonBsdf, LABEL_GLOSSY) - CLOSURE_FLOAT3_PARAM(GlossyToonClosure, params.N), - CLOSURE_FLOAT_PARAM(GlossyToonClosure, params.size), - CLOSURE_FLOAT_PARAM(GlossyToonClosure, params.smooth), -BSDF_CLOSURE_CLASS_END(GlossyToon, glossy_toon) - -BSDF_CLOSURE_CLASS_BEGIN(MicrofacetGGX, microfacet_ggx, MicrofacetBsdf, LABEL_GLOSSY|LABEL_REFLECT) - CLOSURE_FLOAT3_PARAM(MicrofacetGGXClosure, params.N), - CLOSURE_FLOAT_PARAM(MicrofacetGGXClosure, params.alpha_x), -BSDF_CLOSURE_CLASS_END(MicrofacetGGX, microfacet_ggx) - -BSDF_CLOSURE_CLASS_BEGIN(MicrofacetGGXAniso, microfacet_ggx_aniso, MicrofacetBsdf, LABEL_GLOSSY|LABEL_REFLECT) - CLOSURE_FLOAT3_PARAM(MicrofacetGGXAnisoClosure, params.N), - CLOSURE_FLOAT3_PARAM(MicrofacetGGXAnisoClosure, params.T), - CLOSURE_FLOAT_PARAM(MicrofacetGGXAnisoClosure, params.alpha_x), - CLOSURE_FLOAT_PARAM(MicrofacetGGXAnisoClosure, params.alpha_y), -BSDF_CLOSURE_CLASS_END(MicrofacetGGXAniso, microfacet_ggx_aniso) - -BSDF_CLOSURE_CLASS_BEGIN(MicrofacetBeckmann, microfacet_beckmann, MicrofacetBsdf, LABEL_GLOSSY|LABEL_REFLECT) - CLOSURE_FLOAT3_PARAM(MicrofacetBeckmannClosure, params.N), - CLOSURE_FLOAT_PARAM(MicrofacetBeckmannClosure, params.alpha_x), -BSDF_CLOSURE_CLASS_END(MicrofacetBeckmann, microfacet_beckmann) - -BSDF_CLOSURE_CLASS_BEGIN(MicrofacetBeckmannAniso, microfacet_beckmann_aniso, MicrofacetBsdf, LABEL_GLOSSY|LABEL_REFLECT) - CLOSURE_FLOAT3_PARAM(MicrofacetBeckmannAnisoClosure, params.N), - CLOSURE_FLOAT3_PARAM(MicrofacetBeckmannAnisoClosure, params.T), - CLOSURE_FLOAT_PARAM(MicrofacetBeckmannAnisoClosure, params.alpha_x), - CLOSURE_FLOAT_PARAM(MicrofacetBeckmannAnisoClosure, params.alpha_y), -BSDF_CLOSURE_CLASS_END(MicrofacetBeckmannAniso, microfacet_beckmann_aniso) - -BSDF_CLOSURE_CLASS_BEGIN(MicrofacetGGXRefraction, microfacet_ggx_refraction, MicrofacetBsdf, LABEL_GLOSSY|LABEL_TRANSMIT) - CLOSURE_FLOAT3_PARAM(MicrofacetGGXRefractionClosure, params.N), - CLOSURE_FLOAT_PARAM(MicrofacetGGXRefractionClosure, params.alpha_x), - CLOSURE_FLOAT_PARAM(MicrofacetGGXRefractionClosure, params.ior), -BSDF_CLOSURE_CLASS_END(MicrofacetGGXRefraction, microfacet_ggx_refraction) - -BSDF_CLOSURE_CLASS_BEGIN(MicrofacetBeckmannRefraction, microfacet_beckmann_refraction, MicrofacetBsdf, LABEL_GLOSSY|LABEL_TRANSMIT) - CLOSURE_FLOAT3_PARAM(MicrofacetBeckmannRefractionClosure, params.N), - CLOSURE_FLOAT_PARAM(MicrofacetBeckmannRefractionClosure, params.alpha_x), - CLOSURE_FLOAT_PARAM(MicrofacetBeckmannRefractionClosure, params.ior), -BSDF_CLOSURE_CLASS_END(MicrofacetBeckmannRefraction, microfacet_beckmann_refraction) - -BSDF_CLOSURE_CLASS_BEGIN(HairReflection, hair_reflection, HairBsdf, LABEL_GLOSSY) - CLOSURE_FLOAT3_PARAM(HairReflectionClosure, params.N), - CLOSURE_FLOAT_PARAM(HairReflectionClosure, params.roughness1), - CLOSURE_FLOAT_PARAM(HairReflectionClosure, params.roughness2), - CLOSURE_FLOAT3_PARAM(HairReflectionClosure, params.T), - CLOSURE_FLOAT_PARAM(HairReflectionClosure, params.offset), -BSDF_CLOSURE_CLASS_END(HairReflection, hair_reflection) - -BSDF_CLOSURE_CLASS_BEGIN(HairTransmission, hair_transmission, HairBsdf, LABEL_GLOSSY) - CLOSURE_FLOAT3_PARAM(HairTransmissionClosure, params.N), - CLOSURE_FLOAT_PARAM(HairTransmissionClosure, params.roughness1), - CLOSURE_FLOAT_PARAM(HairTransmissionClosure, params.roughness2), - CLOSURE_FLOAT3_PARAM(HairReflectionClosure, params.T), - CLOSURE_FLOAT_PARAM(HairReflectionClosure, params.offset), -BSDF_CLOSURE_CLASS_END(HairTransmission, hair_transmission) - -BSDF_CLOSURE_CLASS_BEGIN(PrincipledDiffuse, principled_diffuse, PrincipledDiffuseBsdf, LABEL_DIFFUSE) - CLOSURE_FLOAT3_PARAM(PrincipledDiffuseClosure, params.N), - CLOSURE_FLOAT_PARAM(PrincipledDiffuseClosure, params.roughness), -BSDF_CLOSURE_CLASS_END(PrincipledDiffuse, principled_diffuse) - -BSDF_CLOSURE_CLASS_BEGIN(PrincipledSheen, principled_sheen, PrincipledSheenBsdf, LABEL_DIFFUSE) - CLOSURE_FLOAT3_PARAM(PrincipledSheenClosure, params.N), -BSDF_CLOSURE_CLASS_END(PrincipledSheen, principled_sheen) - -/* PRINCIPLED HAIR BSDF */ -class PrincipledHairClosure : public CBSDFClosure { -public: - PrincipledHairBSDF params; - - PrincipledHairBSDF *alloc(ShaderData *sd, int path_flag, float3 weight) - { - PrincipledHairBSDF *bsdf = (PrincipledHairBSDF*)bsdf_alloc_osl(sd, sizeof(PrincipledHairBSDF), weight, ¶ms); - if(!bsdf) { - return NULL; - } - - PrincipledHairExtra *extra = (PrincipledHairExtra*)closure_alloc_extra(sd, sizeof(PrincipledHairExtra)); - if(!extra) { - return NULL; - } - - bsdf->extra = extra; - return bsdf; - } - - void setup(ShaderData *sd, int path_flag, float3 weight) - { - if(!skip(sd, path_flag, LABEL_GLOSSY)) { - PrincipledHairBSDF *bsdf = (PrincipledHairBSDF*)alloc(sd, path_flag, weight); - if(!bsdf) { - return; - } - - sd->flag |= (bsdf) ? bsdf_principled_hair_setup(sd, bsdf) : 0; - } - } +CLOSURE_FLOAT3_PARAM(DiffuseClosure, params.N), + BSDF_CLOSURE_CLASS_END(Diffuse, diffuse) + + BSDF_CLOSURE_CLASS_BEGIN(Translucent, translucent, DiffuseBsdf, LABEL_DIFFUSE) + CLOSURE_FLOAT3_PARAM(TranslucentClosure, params.N), + BSDF_CLOSURE_CLASS_END(Translucent, translucent) + + BSDF_CLOSURE_CLASS_BEGIN(OrenNayar, oren_nayar, OrenNayarBsdf, LABEL_DIFFUSE) + CLOSURE_FLOAT3_PARAM(OrenNayarClosure, params.N), + CLOSURE_FLOAT_PARAM(OrenNayarClosure, params.roughness), + BSDF_CLOSURE_CLASS_END(OrenNayar, oren_nayar) + + BSDF_CLOSURE_CLASS_BEGIN(Reflection, reflection, MicrofacetBsdf, LABEL_SINGULAR) + CLOSURE_FLOAT3_PARAM(ReflectionClosure, params.N), + BSDF_CLOSURE_CLASS_END(Reflection, reflection) + + BSDF_CLOSURE_CLASS_BEGIN(Refraction, refraction, MicrofacetBsdf, LABEL_SINGULAR) + CLOSURE_FLOAT3_PARAM(RefractionClosure, params.N), + CLOSURE_FLOAT_PARAM(RefractionClosure, params.ior), + BSDF_CLOSURE_CLASS_END(Refraction, refraction) + + BSDF_CLOSURE_CLASS_BEGIN(AshikhminVelvet, ashikhmin_velvet, VelvetBsdf, LABEL_DIFFUSE) + CLOSURE_FLOAT3_PARAM(AshikhminVelvetClosure, params.N), + CLOSURE_FLOAT_PARAM(AshikhminVelvetClosure, params.sigma), + BSDF_CLOSURE_CLASS_END(AshikhminVelvet, ashikhmin_velvet) + + BSDF_CLOSURE_CLASS_BEGIN(AshikhminShirley, + ashikhmin_shirley_aniso, + MicrofacetBsdf, + LABEL_GLOSSY | LABEL_REFLECT) + CLOSURE_FLOAT3_PARAM(AshikhminShirleyClosure, params.N), + CLOSURE_FLOAT3_PARAM(AshikhminShirleyClosure, params.T), + CLOSURE_FLOAT_PARAM(AshikhminShirleyClosure, params.alpha_x), + CLOSURE_FLOAT_PARAM(AshikhminShirleyClosure, params.alpha_y), + BSDF_CLOSURE_CLASS_END(AshikhminShirley, ashikhmin_shirley_aniso) + + BSDF_CLOSURE_CLASS_BEGIN(DiffuseToon, diffuse_toon, ToonBsdf, LABEL_DIFFUSE) + CLOSURE_FLOAT3_PARAM(DiffuseToonClosure, params.N), + CLOSURE_FLOAT_PARAM(DiffuseToonClosure, params.size), + CLOSURE_FLOAT_PARAM(DiffuseToonClosure, params.smooth), + BSDF_CLOSURE_CLASS_END(DiffuseToon, diffuse_toon) + + BSDF_CLOSURE_CLASS_BEGIN(GlossyToon, glossy_toon, ToonBsdf, LABEL_GLOSSY) + CLOSURE_FLOAT3_PARAM(GlossyToonClosure, params.N), + CLOSURE_FLOAT_PARAM(GlossyToonClosure, params.size), + CLOSURE_FLOAT_PARAM(GlossyToonClosure, params.smooth), + BSDF_CLOSURE_CLASS_END(GlossyToon, glossy_toon) + + BSDF_CLOSURE_CLASS_BEGIN(MicrofacetGGX, + microfacet_ggx, + MicrofacetBsdf, + LABEL_GLOSSY | LABEL_REFLECT) + CLOSURE_FLOAT3_PARAM(MicrofacetGGXClosure, params.N), + CLOSURE_FLOAT_PARAM(MicrofacetGGXClosure, params.alpha_x), + BSDF_CLOSURE_CLASS_END(MicrofacetGGX, microfacet_ggx) + + BSDF_CLOSURE_CLASS_BEGIN(MicrofacetGGXAniso, + microfacet_ggx_aniso, + MicrofacetBsdf, + LABEL_GLOSSY | LABEL_REFLECT) + CLOSURE_FLOAT3_PARAM(MicrofacetGGXAnisoClosure, params.N), + CLOSURE_FLOAT3_PARAM(MicrofacetGGXAnisoClosure, params.T), + CLOSURE_FLOAT_PARAM(MicrofacetGGXAnisoClosure, params.alpha_x), + CLOSURE_FLOAT_PARAM(MicrofacetGGXAnisoClosure, params.alpha_y), + BSDF_CLOSURE_CLASS_END(MicrofacetGGXAniso, microfacet_ggx_aniso) + + BSDF_CLOSURE_CLASS_BEGIN(MicrofacetBeckmann, + microfacet_beckmann, + MicrofacetBsdf, + LABEL_GLOSSY | LABEL_REFLECT) + CLOSURE_FLOAT3_PARAM(MicrofacetBeckmannClosure, params.N), + CLOSURE_FLOAT_PARAM(MicrofacetBeckmannClosure, params.alpha_x), + BSDF_CLOSURE_CLASS_END(MicrofacetBeckmann, microfacet_beckmann) + + BSDF_CLOSURE_CLASS_BEGIN(MicrofacetBeckmannAniso, + microfacet_beckmann_aniso, + MicrofacetBsdf, + LABEL_GLOSSY | LABEL_REFLECT) + CLOSURE_FLOAT3_PARAM(MicrofacetBeckmannAnisoClosure, params.N), + CLOSURE_FLOAT3_PARAM(MicrofacetBeckmannAnisoClosure, params.T), + CLOSURE_FLOAT_PARAM(MicrofacetBeckmannAnisoClosure, params.alpha_x), + CLOSURE_FLOAT_PARAM(MicrofacetBeckmannAnisoClosure, params.alpha_y), + BSDF_CLOSURE_CLASS_END(MicrofacetBeckmannAniso, microfacet_beckmann_aniso) + + BSDF_CLOSURE_CLASS_BEGIN(MicrofacetGGXRefraction, + microfacet_ggx_refraction, + MicrofacetBsdf, + LABEL_GLOSSY | LABEL_TRANSMIT) + CLOSURE_FLOAT3_PARAM(MicrofacetGGXRefractionClosure, params.N), + CLOSURE_FLOAT_PARAM(MicrofacetGGXRefractionClosure, params.alpha_x), + CLOSURE_FLOAT_PARAM(MicrofacetGGXRefractionClosure, params.ior), + BSDF_CLOSURE_CLASS_END(MicrofacetGGXRefraction, microfacet_ggx_refraction) + + BSDF_CLOSURE_CLASS_BEGIN(MicrofacetBeckmannRefraction, + microfacet_beckmann_refraction, + MicrofacetBsdf, + LABEL_GLOSSY | LABEL_TRANSMIT) + CLOSURE_FLOAT3_PARAM(MicrofacetBeckmannRefractionClosure, params.N), + CLOSURE_FLOAT_PARAM(MicrofacetBeckmannRefractionClosure, params.alpha_x), + CLOSURE_FLOAT_PARAM(MicrofacetBeckmannRefractionClosure, params.ior), + BSDF_CLOSURE_CLASS_END(MicrofacetBeckmannRefraction, microfacet_beckmann_refraction) + + BSDF_CLOSURE_CLASS_BEGIN(HairReflection, hair_reflection, HairBsdf, LABEL_GLOSSY) + CLOSURE_FLOAT3_PARAM(HairReflectionClosure, params.N), + CLOSURE_FLOAT_PARAM(HairReflectionClosure, params.roughness1), + CLOSURE_FLOAT_PARAM(HairReflectionClosure, params.roughness2), + CLOSURE_FLOAT3_PARAM(HairReflectionClosure, params.T), + CLOSURE_FLOAT_PARAM(HairReflectionClosure, params.offset), + BSDF_CLOSURE_CLASS_END(HairReflection, hair_reflection) + + BSDF_CLOSURE_CLASS_BEGIN(HairTransmission, hair_transmission, HairBsdf, LABEL_GLOSSY) + CLOSURE_FLOAT3_PARAM(HairTransmissionClosure, params.N), + CLOSURE_FLOAT_PARAM(HairTransmissionClosure, params.roughness1), + CLOSURE_FLOAT_PARAM(HairTransmissionClosure, params.roughness2), + CLOSURE_FLOAT3_PARAM(HairReflectionClosure, params.T), + CLOSURE_FLOAT_PARAM(HairReflectionClosure, params.offset), + BSDF_CLOSURE_CLASS_END(HairTransmission, hair_transmission) + + BSDF_CLOSURE_CLASS_BEGIN(PrincipledDiffuse, + principled_diffuse, + PrincipledDiffuseBsdf, + LABEL_DIFFUSE) + CLOSURE_FLOAT3_PARAM(PrincipledDiffuseClosure, params.N), + CLOSURE_FLOAT_PARAM(PrincipledDiffuseClosure, params.roughness), + BSDF_CLOSURE_CLASS_END(PrincipledDiffuse, principled_diffuse) + + BSDF_CLOSURE_CLASS_BEGIN(PrincipledSheen, + principled_sheen, + PrincipledSheenBsdf, + LABEL_DIFFUSE) + CLOSURE_FLOAT3_PARAM(PrincipledSheenClosure, params.N), + BSDF_CLOSURE_CLASS_END(PrincipledSheen, principled_sheen) + + /* PRINCIPLED HAIR BSDF */ + class PrincipledHairClosure : public CBSDFClosure { + public: + PrincipledHairBSDF params; + + PrincipledHairBSDF *alloc(ShaderData *sd, int path_flag, float3 weight) + { + PrincipledHairBSDF *bsdf = (PrincipledHairBSDF *)bsdf_alloc_osl( + sd, sizeof(PrincipledHairBSDF), weight, ¶ms); + if (!bsdf) { + return NULL; + } + + PrincipledHairExtra *extra = (PrincipledHairExtra *)closure_alloc_extra( + sd, sizeof(PrincipledHairExtra)); + if (!extra) { + return NULL; + } + + bsdf->extra = extra; + return bsdf; + } + + void setup(ShaderData *sd, int path_flag, float3 weight) + { + if (!skip(sd, path_flag, LABEL_GLOSSY)) { + PrincipledHairBSDF *bsdf = (PrincipledHairBSDF *)alloc(sd, path_flag, weight); + if (!bsdf) { + return; + } + + sd->flag |= (bsdf) ? bsdf_principled_hair_setup(sd, bsdf) : 0; + } + } }; static ClosureParam *closure_bsdf_principled_hair_params() { - static ClosureParam params[] = { - CLOSURE_FLOAT3_PARAM(PrincipledHairClosure, params.N), - CLOSURE_FLOAT3_PARAM(PrincipledHairClosure, params.sigma), - CLOSURE_FLOAT_PARAM(PrincipledHairClosure, params.v), - CLOSURE_FLOAT_PARAM(PrincipledHairClosure, params.s), - CLOSURE_FLOAT_PARAM(PrincipledHairClosure, params.m0_roughness), - CLOSURE_FLOAT_PARAM(PrincipledHairClosure, params.alpha), - CLOSURE_FLOAT_PARAM(PrincipledHairClosure, params.eta), - CLOSURE_STRING_KEYPARAM(PrincipledHairClosure, label, "label"), - CLOSURE_FINISH_PARAM(PrincipledHairClosure) - }; - - return params; + static ClosureParam params[] = {CLOSURE_FLOAT3_PARAM(PrincipledHairClosure, params.N), + CLOSURE_FLOAT3_PARAM(PrincipledHairClosure, params.sigma), + CLOSURE_FLOAT_PARAM(PrincipledHairClosure, params.v), + CLOSURE_FLOAT_PARAM(PrincipledHairClosure, params.s), + CLOSURE_FLOAT_PARAM(PrincipledHairClosure, params.m0_roughness), + CLOSURE_FLOAT_PARAM(PrincipledHairClosure, params.alpha), + CLOSURE_FLOAT_PARAM(PrincipledHairClosure, params.eta), + CLOSURE_STRING_KEYPARAM(PrincipledHairClosure, label, "label"), + CLOSURE_FINISH_PARAM(PrincipledHairClosure)}; + + return params; } CCLOSURE_PREPARE(closure_bsdf_principled_hair_prepare, PrincipledHairClosure) /* DISNEY PRINCIPLED CLEARCOAT */ class PrincipledClearcoatClosure : public CBSDFClosure { -public: - MicrofacetBsdf params; - float clearcoat, clearcoat_roughness; - - MicrofacetBsdf *alloc(ShaderData *sd, int path_flag, float3 weight) - { - MicrofacetBsdf *bsdf = (MicrofacetBsdf*)bsdf_alloc_osl(sd, sizeof(MicrofacetBsdf), weight, ¶ms); - if(!bsdf) { - return NULL; - } - - MicrofacetExtra *extra = (MicrofacetExtra*)closure_alloc_extra(sd, sizeof(MicrofacetExtra)); - if(!extra) { - return NULL; - } - - bsdf->T = make_float3(0.0f, 0.0f, 0.0f); - bsdf->extra = extra; - bsdf->ior = 1.5f; - bsdf->alpha_x = clearcoat_roughness; - bsdf->alpha_y = clearcoat_roughness; - bsdf->extra->color = make_float3(0.0f, 0.0f, 0.0f); - bsdf->extra->cspec0 = make_float3(0.04f, 0.04f, 0.04f); - bsdf->extra->clearcoat = clearcoat; - return bsdf; - } - - void setup(ShaderData *sd, int path_flag, float3 weight) - { - MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); - if(!bsdf) { - return; - } - - sd->flag |= bsdf_microfacet_ggx_clearcoat_setup(bsdf, sd); - } + public: + MicrofacetBsdf params; + float clearcoat, clearcoat_roughness; + + MicrofacetBsdf *alloc(ShaderData *sd, int path_flag, float3 weight) + { + MicrofacetBsdf *bsdf = (MicrofacetBsdf *)bsdf_alloc_osl( + sd, sizeof(MicrofacetBsdf), weight, ¶ms); + if (!bsdf) { + return NULL; + } + + MicrofacetExtra *extra = (MicrofacetExtra *)closure_alloc_extra(sd, sizeof(MicrofacetExtra)); + if (!extra) { + return NULL; + } + + bsdf->T = make_float3(0.0f, 0.0f, 0.0f); + bsdf->extra = extra; + bsdf->ior = 1.5f; + bsdf->alpha_x = clearcoat_roughness; + bsdf->alpha_y = clearcoat_roughness; + bsdf->extra->color = make_float3(0.0f, 0.0f, 0.0f); + bsdf->extra->cspec0 = make_float3(0.04f, 0.04f, 0.04f); + bsdf->extra->clearcoat = clearcoat; + return bsdf; + } + + void setup(ShaderData *sd, int path_flag, float3 weight) + { + MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); + if (!bsdf) { + return; + } + + sd->flag |= bsdf_microfacet_ggx_clearcoat_setup(bsdf, sd); + } }; ClosureParam *closure_bsdf_principled_clearcoat_params() { - static ClosureParam params[] = { - CLOSURE_FLOAT3_PARAM(PrincipledClearcoatClosure, params.N), - CLOSURE_FLOAT_PARAM(PrincipledClearcoatClosure, clearcoat), - CLOSURE_FLOAT_PARAM(PrincipledClearcoatClosure, clearcoat_roughness), - CLOSURE_STRING_KEYPARAM(PrincipledClearcoatClosure, label, "label"), - CLOSURE_FINISH_PARAM(PrincipledClearcoatClosure) - }; - return params; + static ClosureParam params[] = { + CLOSURE_FLOAT3_PARAM(PrincipledClearcoatClosure, params.N), + CLOSURE_FLOAT_PARAM(PrincipledClearcoatClosure, clearcoat), + CLOSURE_FLOAT_PARAM(PrincipledClearcoatClosure, clearcoat_roughness), + CLOSURE_STRING_KEYPARAM(PrincipledClearcoatClosure, label, "label"), + CLOSURE_FINISH_PARAM(PrincipledClearcoatClosure)}; + return params; } CCLOSURE_PREPARE(closure_bsdf_principled_clearcoat_prepare, PrincipledClearcoatClosure) - /* Registration */ -static void register_closure(OSL::ShadingSystem *ss, const char *name, int id, OSL::ClosureParam *params, OSL::PrepareClosureFunc prepare) +static void register_closure(OSL::ShadingSystem *ss, + const char *name, + int id, + OSL::ClosureParam *params, + OSL::PrepareClosureFunc prepare) { - /* optimization: it's possible to not use a prepare function at all and - * only initialize the actual class when accessing the closure component - * data, but then we need to map the id to the class somehow */ + /* optimization: it's possible to not use a prepare function at all and + * only initialize the actual class when accessing the closure component + * data, but then we need to map the id to the class somehow */ #if OSL_LIBRARY_VERSION_CODE >= 10900 - ss->register_closure(name, id, params, prepare, NULL); + ss->register_closure(name, id, params, prepare, NULL); #else - ss->register_closure(name, id, params, prepare, NULL, 16); + ss->register_closure(name, id, params, prepare, NULL, 16); #endif } void OSLShader::register_closures(OSLShadingSystem *ss_) { - OSL::ShadingSystem *ss = (OSL::ShadingSystem*)ss_; - int id = 0; - - register_closure(ss, "diffuse", id++, - bsdf_diffuse_params(), bsdf_diffuse_prepare); - register_closure(ss, "oren_nayar", id++, - bsdf_oren_nayar_params(), bsdf_oren_nayar_prepare); - register_closure(ss, "translucent", id++, - bsdf_translucent_params(), bsdf_translucent_prepare); - register_closure(ss, "reflection", id++, - bsdf_reflection_params(), bsdf_reflection_prepare); - register_closure(ss, "refraction", id++, - bsdf_refraction_params(), bsdf_refraction_prepare); - register_closure(ss, "transparent", id++, - closure_bsdf_transparent_params(), closure_bsdf_transparent_prepare); - register_closure(ss, "microfacet_ggx", id++, - bsdf_microfacet_ggx_params(), bsdf_microfacet_ggx_prepare); - register_closure(ss, "microfacet_ggx_aniso", id++, - bsdf_microfacet_ggx_aniso_params(), bsdf_microfacet_ggx_aniso_prepare); - register_closure(ss, "microfacet_ggx_refraction", id++, - bsdf_microfacet_ggx_refraction_params(), bsdf_microfacet_ggx_refraction_prepare); - register_closure(ss, "microfacet_multi_ggx", id++, - closure_bsdf_microfacet_multi_ggx_params(), closure_bsdf_microfacet_multi_ggx_prepare); - register_closure(ss, "microfacet_multi_ggx_glass", id++, - closure_bsdf_microfacet_multi_ggx_glass_params(), closure_bsdf_microfacet_multi_ggx_glass_prepare); - register_closure(ss, "microfacet_multi_ggx_aniso", id++, - closure_bsdf_microfacet_multi_ggx_aniso_params(), closure_bsdf_microfacet_multi_ggx_aniso_prepare); - register_closure(ss, "microfacet_ggx_fresnel", id++, - closure_bsdf_microfacet_ggx_fresnel_params(), closure_bsdf_microfacet_ggx_fresnel_prepare); - register_closure(ss, "microfacet_ggx_aniso_fresnel", id++, - closure_bsdf_microfacet_ggx_aniso_fresnel_params(), closure_bsdf_microfacet_ggx_aniso_fresnel_prepare); - register_closure(ss, "microfacet_multi_ggx_fresnel", id++, - closure_bsdf_microfacet_multi_ggx_fresnel_params(), closure_bsdf_microfacet_multi_ggx_fresnel_prepare); - register_closure(ss, "microfacet_multi_ggx_glass_fresnel", id++, - closure_bsdf_microfacet_multi_ggx_glass_fresnel_params(), closure_bsdf_microfacet_multi_ggx_glass_fresnel_prepare); - register_closure(ss, "microfacet_multi_ggx_aniso_fresnel", id++, - closure_bsdf_microfacet_multi_ggx_aniso_fresnel_params(), closure_bsdf_microfacet_multi_ggx_aniso_fresnel_prepare); - register_closure(ss, "microfacet_beckmann", id++, - bsdf_microfacet_beckmann_params(), bsdf_microfacet_beckmann_prepare); - register_closure(ss, "microfacet_beckmann_aniso", id++, - bsdf_microfacet_beckmann_aniso_params(), bsdf_microfacet_beckmann_aniso_prepare); - register_closure(ss, "microfacet_beckmann_refraction", id++, - bsdf_microfacet_beckmann_refraction_params(), bsdf_microfacet_beckmann_refraction_prepare); - register_closure(ss, "ashikhmin_shirley", id++, - bsdf_ashikhmin_shirley_aniso_params(), bsdf_ashikhmin_shirley_aniso_prepare); - register_closure(ss, "ashikhmin_velvet", id++, - bsdf_ashikhmin_velvet_params(), bsdf_ashikhmin_velvet_prepare); - register_closure(ss, "diffuse_toon", id++, - bsdf_diffuse_toon_params(), bsdf_diffuse_toon_prepare); - register_closure(ss, "glossy_toon", id++, - bsdf_glossy_toon_params(), bsdf_glossy_toon_prepare); - register_closure(ss, "principled_diffuse", id++, - bsdf_principled_diffuse_params(), bsdf_principled_diffuse_prepare); - register_closure(ss, "principled_sheen", id++, - bsdf_principled_sheen_params(), bsdf_principled_sheen_prepare); - register_closure(ss, "principled_clearcoat", id++, - closure_bsdf_principled_clearcoat_params(), closure_bsdf_principled_clearcoat_prepare); - - register_closure(ss, "emission", id++, - closure_emission_params(), closure_emission_prepare); - register_closure(ss, "background", id++, - closure_background_params(), closure_background_prepare); - register_closure(ss, "holdout", id++, - closure_holdout_params(), closure_holdout_prepare); - register_closure(ss, "diffuse_ramp", id++, - closure_bsdf_diffuse_ramp_params(), closure_bsdf_diffuse_ramp_prepare); - register_closure(ss, "phong_ramp", id++, - closure_bsdf_phong_ramp_params(), closure_bsdf_phong_ramp_prepare); - register_closure(ss, "bssrdf", id++, - closure_bssrdf_params(), closure_bssrdf_prepare); - - register_closure(ss, "hair_reflection", id++, - bsdf_hair_reflection_params(), bsdf_hair_reflection_prepare); - register_closure(ss, "hair_transmission", id++, - bsdf_hair_transmission_params(), bsdf_hair_transmission_prepare); - - register_closure(ss, "principled_hair", id++, - closure_bsdf_principled_hair_params(), closure_bsdf_principled_hair_prepare); - - register_closure(ss, "henyey_greenstein", id++, - closure_henyey_greenstein_params(), closure_henyey_greenstein_prepare); - register_closure(ss, "absorption", id++, - closure_absorption_params(), closure_absorption_prepare); + OSL::ShadingSystem *ss = (OSL::ShadingSystem *)ss_; + int id = 0; + + register_closure(ss, "diffuse", id++, bsdf_diffuse_params(), bsdf_diffuse_prepare); + register_closure(ss, "oren_nayar", id++, bsdf_oren_nayar_params(), bsdf_oren_nayar_prepare); + register_closure(ss, "translucent", id++, bsdf_translucent_params(), bsdf_translucent_prepare); + register_closure(ss, "reflection", id++, bsdf_reflection_params(), bsdf_reflection_prepare); + register_closure(ss, "refraction", id++, bsdf_refraction_params(), bsdf_refraction_prepare); + register_closure(ss, + "transparent", + id++, + closure_bsdf_transparent_params(), + closure_bsdf_transparent_prepare); + register_closure( + ss, "microfacet_ggx", id++, bsdf_microfacet_ggx_params(), bsdf_microfacet_ggx_prepare); + register_closure(ss, + "microfacet_ggx_aniso", + id++, + bsdf_microfacet_ggx_aniso_params(), + bsdf_microfacet_ggx_aniso_prepare); + register_closure(ss, + "microfacet_ggx_refraction", + id++, + bsdf_microfacet_ggx_refraction_params(), + bsdf_microfacet_ggx_refraction_prepare); + register_closure(ss, + "microfacet_multi_ggx", + id++, + closure_bsdf_microfacet_multi_ggx_params(), + closure_bsdf_microfacet_multi_ggx_prepare); + register_closure(ss, + "microfacet_multi_ggx_glass", + id++, + closure_bsdf_microfacet_multi_ggx_glass_params(), + closure_bsdf_microfacet_multi_ggx_glass_prepare); + register_closure(ss, + "microfacet_multi_ggx_aniso", + id++, + closure_bsdf_microfacet_multi_ggx_aniso_params(), + closure_bsdf_microfacet_multi_ggx_aniso_prepare); + register_closure(ss, + "microfacet_ggx_fresnel", + id++, + closure_bsdf_microfacet_ggx_fresnel_params(), + closure_bsdf_microfacet_ggx_fresnel_prepare); + register_closure(ss, + "microfacet_ggx_aniso_fresnel", + id++, + closure_bsdf_microfacet_ggx_aniso_fresnel_params(), + closure_bsdf_microfacet_ggx_aniso_fresnel_prepare); + register_closure(ss, + "microfacet_multi_ggx_fresnel", + id++, + closure_bsdf_microfacet_multi_ggx_fresnel_params(), + closure_bsdf_microfacet_multi_ggx_fresnel_prepare); + register_closure(ss, + "microfacet_multi_ggx_glass_fresnel", + id++, + closure_bsdf_microfacet_multi_ggx_glass_fresnel_params(), + closure_bsdf_microfacet_multi_ggx_glass_fresnel_prepare); + register_closure(ss, + "microfacet_multi_ggx_aniso_fresnel", + id++, + closure_bsdf_microfacet_multi_ggx_aniso_fresnel_params(), + closure_bsdf_microfacet_multi_ggx_aniso_fresnel_prepare); + register_closure(ss, + "microfacet_beckmann", + id++, + bsdf_microfacet_beckmann_params(), + bsdf_microfacet_beckmann_prepare); + register_closure(ss, + "microfacet_beckmann_aniso", + id++, + bsdf_microfacet_beckmann_aniso_params(), + bsdf_microfacet_beckmann_aniso_prepare); + register_closure(ss, + "microfacet_beckmann_refraction", + id++, + bsdf_microfacet_beckmann_refraction_params(), + bsdf_microfacet_beckmann_refraction_prepare); + register_closure(ss, + "ashikhmin_shirley", + id++, + bsdf_ashikhmin_shirley_aniso_params(), + bsdf_ashikhmin_shirley_aniso_prepare); + register_closure( + ss, "ashikhmin_velvet", id++, bsdf_ashikhmin_velvet_params(), bsdf_ashikhmin_velvet_prepare); + register_closure( + ss, "diffuse_toon", id++, bsdf_diffuse_toon_params(), bsdf_diffuse_toon_prepare); + register_closure(ss, "glossy_toon", id++, bsdf_glossy_toon_params(), bsdf_glossy_toon_prepare); + register_closure(ss, + "principled_diffuse", + id++, + bsdf_principled_diffuse_params(), + bsdf_principled_diffuse_prepare); + register_closure( + ss, "principled_sheen", id++, bsdf_principled_sheen_params(), bsdf_principled_sheen_prepare); + register_closure(ss, + "principled_clearcoat", + id++, + closure_bsdf_principled_clearcoat_params(), + closure_bsdf_principled_clearcoat_prepare); + + register_closure(ss, "emission", id++, closure_emission_params(), closure_emission_prepare); + register_closure( + ss, "background", id++, closure_background_params(), closure_background_prepare); + register_closure(ss, "holdout", id++, closure_holdout_params(), closure_holdout_prepare); + register_closure(ss, + "diffuse_ramp", + id++, + closure_bsdf_diffuse_ramp_params(), + closure_bsdf_diffuse_ramp_prepare); + register_closure( + ss, "phong_ramp", id++, closure_bsdf_phong_ramp_params(), closure_bsdf_phong_ramp_prepare); + register_closure(ss, "bssrdf", id++, closure_bssrdf_params(), closure_bssrdf_prepare); + + register_closure( + ss, "hair_reflection", id++, bsdf_hair_reflection_params(), bsdf_hair_reflection_prepare); + register_closure(ss, + "hair_transmission", + id++, + bsdf_hair_transmission_params(), + bsdf_hair_transmission_prepare); + + register_closure(ss, + "principled_hair", + id++, + closure_bsdf_principled_hair_params(), + closure_bsdf_principled_hair_prepare); + + register_closure(ss, + "henyey_greenstein", + id++, + closure_henyey_greenstein_params(), + closure_henyey_greenstein_prepare); + register_closure( + ss, "absorption", id++, closure_absorption_params(), closure_absorption_prepare); } /* BSDF Closure */ bool CBSDFClosure::skip(const ShaderData *sd, int path_flag, int scattering) { - /* caustic options */ - if((scattering & LABEL_GLOSSY) && (path_flag & PATH_RAY_DIFFUSE)) { - KernelGlobals *kg = sd->osl_globals; - - if((!kernel_data.integrator.caustics_reflective && (scattering & LABEL_REFLECT)) || - (!kernel_data.integrator.caustics_refractive && (scattering & LABEL_TRANSMIT))) - { - return true; - } - } - - return false; -} + /* caustic options */ + if ((scattering & LABEL_GLOSSY) && (path_flag & PATH_RAY_DIFFUSE)) { + KernelGlobals *kg = sd->osl_globals; + if ((!kernel_data.integrator.caustics_reflective && (scattering & LABEL_REFLECT)) || + (!kernel_data.integrator.caustics_refractive && (scattering & LABEL_TRANSMIT))) { + return true; + } + } + + return false; +} /* GGX closures with Fresnel */ class MicrofacetFresnelClosure : public CBSDFClosure { -public: - MicrofacetBsdf params; - float3 color; - float3 cspec0; - - MicrofacetBsdf *alloc(ShaderData *sd, int path_flag, float3 weight) - { - /* Technically, the MultiGGX Glass closure may also transmit. However, - * since this is set statically and only used for caustic flags, this - * is probably as good as it gets. */ - if(skip(sd, path_flag, LABEL_GLOSSY | LABEL_REFLECT)) { - return NULL; - } - - MicrofacetBsdf *bsdf = (MicrofacetBsdf*)bsdf_alloc_osl(sd, sizeof(MicrofacetBsdf), weight, ¶ms); - if(!bsdf) { - return NULL; - } - - MicrofacetExtra *extra = (MicrofacetExtra*)closure_alloc_extra(sd, sizeof(MicrofacetExtra)); - if(!extra) { - return NULL; - } - - bsdf->extra = extra; - bsdf->extra->color = color; - bsdf->extra->cspec0 = cspec0; - bsdf->extra->clearcoat = 0.0f; - return bsdf; - } + public: + MicrofacetBsdf params; + float3 color; + float3 cspec0; + + MicrofacetBsdf *alloc(ShaderData *sd, int path_flag, float3 weight) + { + /* Technically, the MultiGGX Glass closure may also transmit. However, + * since this is set statically and only used for caustic flags, this + * is probably as good as it gets. */ + if (skip(sd, path_flag, LABEL_GLOSSY | LABEL_REFLECT)) { + return NULL; + } + + MicrofacetBsdf *bsdf = (MicrofacetBsdf *)bsdf_alloc_osl( + sd, sizeof(MicrofacetBsdf), weight, ¶ms); + if (!bsdf) { + return NULL; + } + + MicrofacetExtra *extra = (MicrofacetExtra *)closure_alloc_extra(sd, sizeof(MicrofacetExtra)); + if (!extra) { + return NULL; + } + + bsdf->extra = extra; + bsdf->extra->color = color; + bsdf->extra->cspec0 = cspec0; + bsdf->extra->clearcoat = 0.0f; + return bsdf; + } }; class MicrofacetGGXFresnelClosure : public MicrofacetFresnelClosure { -public: - void setup(ShaderData *sd, int path_flag, float3 weight) - { - MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); - if(!bsdf) { - return; - } - - bsdf->T = make_float3(0.0f, 0.0f, 0.0f); - bsdf->alpha_y = bsdf->alpha_x; - sd->flag |= bsdf_microfacet_ggx_fresnel_setup(bsdf, sd); - } + public: + void setup(ShaderData *sd, int path_flag, float3 weight) + { + MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); + if (!bsdf) { + return; + } + + bsdf->T = make_float3(0.0f, 0.0f, 0.0f); + bsdf->alpha_y = bsdf->alpha_x; + sd->flag |= bsdf_microfacet_ggx_fresnel_setup(bsdf, sd); + } }; ClosureParam *closure_bsdf_microfacet_ggx_fresnel_params() { - static ClosureParam params[] = { - CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, params.N), - CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.alpha_x), - CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.ior), - CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, color), - CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, cspec0), - CLOSURE_STRING_KEYPARAM(MicrofacetGGXFresnelClosure, label, "label"), - CLOSURE_FINISH_PARAM(MicrofacetGGXFresnelClosure) - }; - return params; + static ClosureParam params[] = { + CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, params.N), + CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.alpha_x), + CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.ior), + CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, color), + CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, cspec0), + CLOSURE_STRING_KEYPARAM(MicrofacetGGXFresnelClosure, label, "label"), + CLOSURE_FINISH_PARAM(MicrofacetGGXFresnelClosure)}; + return params; } CCLOSURE_PREPARE(closure_bsdf_microfacet_ggx_fresnel_prepare, MicrofacetGGXFresnelClosure); class MicrofacetGGXAnisoFresnelClosure : public MicrofacetFresnelClosure { -public: - void setup(ShaderData *sd, int path_flag, float3 weight) - { - MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); - if(!bsdf) { - return; - } - - sd->flag |= bsdf_microfacet_ggx_aniso_fresnel_setup(bsdf, sd); - } + public: + void setup(ShaderData *sd, int path_flag, float3 weight) + { + MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); + if (!bsdf) { + return; + } + + sd->flag |= bsdf_microfacet_ggx_aniso_fresnel_setup(bsdf, sd); + } }; ClosureParam *closure_bsdf_microfacet_ggx_aniso_fresnel_params() { - static ClosureParam params[] = { - CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, params.N), - CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, params.T), - CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.alpha_x), - CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.alpha_y), - CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.ior), - CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, color), - CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, cspec0), - CLOSURE_STRING_KEYPARAM(MicrofacetGGXFresnelClosure, label, "label"), - CLOSURE_FINISH_PARAM(MicrofacetGGXFresnelClosure) - }; - return params; + static ClosureParam params[] = { + CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, params.N), + CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, params.T), + CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.alpha_x), + CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.alpha_y), + CLOSURE_FLOAT_PARAM(MicrofacetGGXFresnelClosure, params.ior), + CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, color), + CLOSURE_FLOAT3_PARAM(MicrofacetGGXFresnelClosure, cspec0), + CLOSURE_STRING_KEYPARAM(MicrofacetGGXFresnelClosure, label, "label"), + CLOSURE_FINISH_PARAM(MicrofacetGGXFresnelClosure)}; + return params; } -CCLOSURE_PREPARE(closure_bsdf_microfacet_ggx_aniso_fresnel_prepare, MicrofacetGGXAnisoFresnelClosure); - +CCLOSURE_PREPARE(closure_bsdf_microfacet_ggx_aniso_fresnel_prepare, + MicrofacetGGXAnisoFresnelClosure); /* Multiscattering GGX closures */ class MicrofacetMultiClosure : public CBSDFClosure { -public: - MicrofacetBsdf params; - float3 color; - - MicrofacetBsdf *alloc(ShaderData *sd, int path_flag, float3 weight) - { - /* Technically, the MultiGGX closure may also transmit. However, - * since this is set statically and only used for caustic flags, this - * is probably as good as it gets. */ - if(skip(sd, path_flag, LABEL_GLOSSY|LABEL_REFLECT)) { - return NULL; - } - - MicrofacetBsdf *bsdf = (MicrofacetBsdf*)bsdf_alloc_osl(sd, sizeof(MicrofacetBsdf), weight, ¶ms); - if(!bsdf) { - return NULL; - } - - MicrofacetExtra *extra = (MicrofacetExtra*)closure_alloc_extra(sd, sizeof(MicrofacetExtra)); - if(!extra) { - return NULL; - } - - bsdf->extra = extra; - bsdf->extra->color = color; - bsdf->extra->cspec0 = make_float3(0.0f, 0.0f, 0.0f); - bsdf->extra->clearcoat = 0.0f; - return bsdf; - } + public: + MicrofacetBsdf params; + float3 color; + + MicrofacetBsdf *alloc(ShaderData *sd, int path_flag, float3 weight) + { + /* Technically, the MultiGGX closure may also transmit. However, + * since this is set statically and only used for caustic flags, this + * is probably as good as it gets. */ + if (skip(sd, path_flag, LABEL_GLOSSY | LABEL_REFLECT)) { + return NULL; + } + + MicrofacetBsdf *bsdf = (MicrofacetBsdf *)bsdf_alloc_osl( + sd, sizeof(MicrofacetBsdf), weight, ¶ms); + if (!bsdf) { + return NULL; + } + + MicrofacetExtra *extra = (MicrofacetExtra *)closure_alloc_extra(sd, sizeof(MicrofacetExtra)); + if (!extra) { + return NULL; + } + + bsdf->extra = extra; + bsdf->extra->color = color; + bsdf->extra->cspec0 = make_float3(0.0f, 0.0f, 0.0f); + bsdf->extra->clearcoat = 0.0f; + return bsdf; + } }; class MicrofacetMultiGGXClosure : public MicrofacetMultiClosure { -public: - void setup(ShaderData *sd, int path_flag, float3 weight) - { - MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); - if(!bsdf) { - return; - } - - bsdf->ior = 0.0f; - bsdf->T = make_float3(0.0f, 0.0f, 0.0f); - bsdf->alpha_y = bsdf->alpha_x; - sd->flag |= bsdf_microfacet_multi_ggx_setup(bsdf); - } + public: + void setup(ShaderData *sd, int path_flag, float3 weight) + { + MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); + if (!bsdf) { + return; + } + + bsdf->ior = 0.0f; + bsdf->T = make_float3(0.0f, 0.0f, 0.0f); + bsdf->alpha_y = bsdf->alpha_x; + sd->flag |= bsdf_microfacet_multi_ggx_setup(bsdf); + } }; ClosureParam *closure_bsdf_microfacet_multi_ggx_params() { - static ClosureParam params[] = { - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXClosure, params.N), - CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXClosure, params.alpha_x), - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXClosure, color), - CLOSURE_STRING_KEYPARAM(MicrofacetMultiGGXClosure, label, "label"), - CLOSURE_FINISH_PARAM(MicrofacetMultiGGXClosure) - }; - return params; + static ClosureParam params[] = { + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXClosure, params.N), + CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXClosure, params.alpha_x), + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXClosure, color), + CLOSURE_STRING_KEYPARAM(MicrofacetMultiGGXClosure, label, "label"), + CLOSURE_FINISH_PARAM(MicrofacetMultiGGXClosure)}; + return params; } CCLOSURE_PREPARE(closure_bsdf_microfacet_multi_ggx_prepare, MicrofacetMultiGGXClosure); class MicrofacetMultiGGXAnisoClosure : public MicrofacetMultiClosure { -public: - void setup(ShaderData *sd, int path_flag, float3 weight) - { - MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); - if(!bsdf) { - return; - } - - bsdf->ior = 0.0f; - sd->flag |= bsdf_microfacet_multi_ggx_aniso_setup(bsdf); - } + public: + void setup(ShaderData *sd, int path_flag, float3 weight) + { + MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); + if (!bsdf) { + return; + } + + bsdf->ior = 0.0f; + sd->flag |= bsdf_microfacet_multi_ggx_aniso_setup(bsdf); + } }; ClosureParam *closure_bsdf_microfacet_multi_ggx_aniso_params() { - static ClosureParam params[] = { - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXClosure, params.N), - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXClosure, params.T), - CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXClosure, params.alpha_x), - CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXClosure, params.alpha_y), - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXClosure, color), - CLOSURE_STRING_KEYPARAM(MicrofacetMultiGGXClosure, label, "label"), - CLOSURE_FINISH_PARAM(MicrofacetMultiGGXClosure) - }; - return params; + static ClosureParam params[] = { + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXClosure, params.N), + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXClosure, params.T), + CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXClosure, params.alpha_x), + CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXClosure, params.alpha_y), + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXClosure, color), + CLOSURE_STRING_KEYPARAM(MicrofacetMultiGGXClosure, label, "label"), + CLOSURE_FINISH_PARAM(MicrofacetMultiGGXClosure)}; + return params; } CCLOSURE_PREPARE(closure_bsdf_microfacet_multi_ggx_aniso_prepare, MicrofacetMultiGGXAnisoClosure); class MicrofacetMultiGGXGlassClosure : public MicrofacetMultiClosure { -public: - MicrofacetMultiGGXGlassClosure() : MicrofacetMultiClosure() {} - - void setup(ShaderData *sd, int path_flag, float3 weight) - { - MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); - if(!bsdf) { - return; - } - - bsdf->T = make_float3(0.0f, 0.0f, 0.0f); - bsdf->alpha_y = bsdf->alpha_x; - sd->flag |= bsdf_microfacet_multi_ggx_glass_setup(bsdf); - } + public: + MicrofacetMultiGGXGlassClosure() : MicrofacetMultiClosure() + { + } + + void setup(ShaderData *sd, int path_flag, float3 weight) + { + MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); + if (!bsdf) { + return; + } + + bsdf->T = make_float3(0.0f, 0.0f, 0.0f); + bsdf->alpha_y = bsdf->alpha_x; + sd->flag |= bsdf_microfacet_multi_ggx_glass_setup(bsdf); + } }; ClosureParam *closure_bsdf_microfacet_multi_ggx_glass_params() { - static ClosureParam params[] = { - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXClosure, params.N), - CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXClosure, params.alpha_x), - CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXClosure, params.ior), - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXClosure, color), - CLOSURE_STRING_KEYPARAM(MicrofacetMultiGGXClosure, label, "label"), - CLOSURE_FINISH_PARAM(MicrofacetMultiGGXClosure) - }; - return params; + static ClosureParam params[] = { + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXClosure, params.N), + CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXClosure, params.alpha_x), + CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXClosure, params.ior), + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXClosure, color), + CLOSURE_STRING_KEYPARAM(MicrofacetMultiGGXClosure, label, "label"), + CLOSURE_FINISH_PARAM(MicrofacetMultiGGXClosure)}; + return params; } CCLOSURE_PREPARE(closure_bsdf_microfacet_multi_ggx_glass_prepare, MicrofacetMultiGGXGlassClosure); - /* Multiscattering GGX closures with Fresnel */ class MicrofacetMultiFresnelClosure : public CBSDFClosure { -public: - MicrofacetBsdf params; - float3 color; - float3 cspec0; - - MicrofacetBsdf *alloc(ShaderData *sd, int path_flag, float3 weight) - { - /* Technically, the MultiGGX closure may also transmit. However, - * since this is set statically and only used for caustic flags, this - * is probably as good as it gets. */ - if(skip(sd, path_flag, LABEL_GLOSSY | LABEL_REFLECT)) { - return NULL; - } - - MicrofacetBsdf *bsdf = (MicrofacetBsdf*)bsdf_alloc_osl(sd, sizeof(MicrofacetBsdf), weight, ¶ms); - if(!bsdf) { - return NULL; - } - - MicrofacetExtra *extra = (MicrofacetExtra*)closure_alloc_extra(sd, sizeof(MicrofacetExtra)); - if(!extra) { - return NULL; - } - - bsdf->extra = extra; - bsdf->extra->color = color; - bsdf->extra->cspec0 = cspec0; - bsdf->extra->clearcoat = 0.0f; - return bsdf; - } + public: + MicrofacetBsdf params; + float3 color; + float3 cspec0; + + MicrofacetBsdf *alloc(ShaderData *sd, int path_flag, float3 weight) + { + /* Technically, the MultiGGX closure may also transmit. However, + * since this is set statically and only used for caustic flags, this + * is probably as good as it gets. */ + if (skip(sd, path_flag, LABEL_GLOSSY | LABEL_REFLECT)) { + return NULL; + } + + MicrofacetBsdf *bsdf = (MicrofacetBsdf *)bsdf_alloc_osl( + sd, sizeof(MicrofacetBsdf), weight, ¶ms); + if (!bsdf) { + return NULL; + } + + MicrofacetExtra *extra = (MicrofacetExtra *)closure_alloc_extra(sd, sizeof(MicrofacetExtra)); + if (!extra) { + return NULL; + } + + bsdf->extra = extra; + bsdf->extra->color = color; + bsdf->extra->cspec0 = cspec0; + bsdf->extra->clearcoat = 0.0f; + return bsdf; + } }; class MicrofacetMultiGGXFresnelClosure : public MicrofacetMultiFresnelClosure { -public: - void setup(ShaderData *sd, int path_flag, float3 weight) - { - MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); - if(!bsdf) { - return; - } - - bsdf->T = make_float3(0.0f, 0.0f, 0.0f); - bsdf->alpha_y = bsdf->alpha_x; - sd->flag |= bsdf_microfacet_multi_ggx_fresnel_setup(bsdf, sd); - } + public: + void setup(ShaderData *sd, int path_flag, float3 weight) + { + MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); + if (!bsdf) { + return; + } + + bsdf->T = make_float3(0.0f, 0.0f, 0.0f); + bsdf->alpha_y = bsdf->alpha_x; + sd->flag |= bsdf_microfacet_multi_ggx_fresnel_setup(bsdf, sd); + } }; ClosureParam *closure_bsdf_microfacet_multi_ggx_fresnel_params() { - static ClosureParam params[] = { - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, params.N), - CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.alpha_x), - CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.ior), - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, color), - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, cspec0), - CLOSURE_STRING_KEYPARAM(MicrofacetMultiGGXFresnelClosure, label, "label"), - CLOSURE_FINISH_PARAM(MicrofacetMultiGGXFresnelClosure) - }; - return params; + static ClosureParam params[] = { + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, params.N), + CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.alpha_x), + CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.ior), + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, color), + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, cspec0), + CLOSURE_STRING_KEYPARAM(MicrofacetMultiGGXFresnelClosure, label, "label"), + CLOSURE_FINISH_PARAM(MicrofacetMultiGGXFresnelClosure)}; + return params; } -CCLOSURE_PREPARE(closure_bsdf_microfacet_multi_ggx_fresnel_prepare, MicrofacetMultiGGXFresnelClosure); +CCLOSURE_PREPARE(closure_bsdf_microfacet_multi_ggx_fresnel_prepare, + MicrofacetMultiGGXFresnelClosure); class MicrofacetMultiGGXAnisoFresnelClosure : public MicrofacetMultiFresnelClosure { -public: - void setup(ShaderData *sd, int path_flag, float3 weight) - { - MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); - if(!bsdf) { - return; - } - - sd->flag |= bsdf_microfacet_multi_ggx_aniso_fresnel_setup(bsdf, sd); - } + public: + void setup(ShaderData *sd, int path_flag, float3 weight) + { + MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); + if (!bsdf) { + return; + } + + sd->flag |= bsdf_microfacet_multi_ggx_aniso_fresnel_setup(bsdf, sd); + } }; ClosureParam *closure_bsdf_microfacet_multi_ggx_aniso_fresnel_params() { - static ClosureParam params[] = { - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, params.N), - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, params.T), - CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.alpha_x), - CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.alpha_y), - CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.ior), - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, color), - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, cspec0), - CLOSURE_STRING_KEYPARAM(MicrofacetMultiGGXFresnelClosure, label, "label"), - CLOSURE_FINISH_PARAM(MicrofacetMultiGGXFresnelClosure) - }; - return params; + static ClosureParam params[] = { + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, params.N), + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, params.T), + CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.alpha_x), + CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.alpha_y), + CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.ior), + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, color), + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, cspec0), + CLOSURE_STRING_KEYPARAM(MicrofacetMultiGGXFresnelClosure, label, "label"), + CLOSURE_FINISH_PARAM(MicrofacetMultiGGXFresnelClosure)}; + return params; } -CCLOSURE_PREPARE(closure_bsdf_microfacet_multi_ggx_aniso_fresnel_prepare, MicrofacetMultiGGXAnisoFresnelClosure); +CCLOSURE_PREPARE(closure_bsdf_microfacet_multi_ggx_aniso_fresnel_prepare, + MicrofacetMultiGGXAnisoFresnelClosure); class MicrofacetMultiGGXGlassFresnelClosure : public MicrofacetMultiFresnelClosure { -public: - MicrofacetMultiGGXGlassFresnelClosure() : MicrofacetMultiFresnelClosure() {} - - void setup(ShaderData *sd, int path_flag, float3 weight) - { - MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); - if(!bsdf) { - return; - } - - bsdf->T = make_float3(0.0f, 0.0f, 0.0f); - bsdf->alpha_y = bsdf->alpha_x; - sd->flag |= bsdf_microfacet_multi_ggx_glass_fresnel_setup(bsdf, sd); - } + public: + MicrofacetMultiGGXGlassFresnelClosure() : MicrofacetMultiFresnelClosure() + { + } + + void setup(ShaderData *sd, int path_flag, float3 weight) + { + MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight); + if (!bsdf) { + return; + } + + bsdf->T = make_float3(0.0f, 0.0f, 0.0f); + bsdf->alpha_y = bsdf->alpha_x; + sd->flag |= bsdf_microfacet_multi_ggx_glass_fresnel_setup(bsdf, sd); + } }; ClosureParam *closure_bsdf_microfacet_multi_ggx_glass_fresnel_params() { - static ClosureParam params[] = { - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, params.N), - CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.alpha_x), - CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.ior), - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, color), - CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, cspec0), - CLOSURE_STRING_KEYPARAM(MicrofacetMultiGGXFresnelClosure, label, "label"), - CLOSURE_FINISH_PARAM(MicrofacetMultiGGXFresnelClosure) - }; - return params; + static ClosureParam params[] = { + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, params.N), + CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.alpha_x), + CLOSURE_FLOAT_PARAM(MicrofacetMultiGGXFresnelClosure, params.ior), + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, color), + CLOSURE_FLOAT3_PARAM(MicrofacetMultiGGXFresnelClosure, cspec0), + CLOSURE_STRING_KEYPARAM(MicrofacetMultiGGXFresnelClosure, label, "label"), + CLOSURE_FINISH_PARAM(MicrofacetMultiGGXFresnelClosure)}; + return params; } -CCLOSURE_PREPARE(closure_bsdf_microfacet_multi_ggx_glass_fresnel_prepare, MicrofacetMultiGGXGlassFresnelClosure); +CCLOSURE_PREPARE(closure_bsdf_microfacet_multi_ggx_glass_fresnel_prepare, + MicrofacetMultiGGXGlassFresnelClosure); /* Transparent */ class TransparentClosure : public CBSDFClosure { -public: - ShaderClosure params; - float3 unused; - - void setup(ShaderData *sd, int path_flag, float3 weight) - { - bsdf_transparent_setup(sd, weight, path_flag); - } + public: + ShaderClosure params; + float3 unused; + + void setup(ShaderData *sd, int path_flag, float3 weight) + { + bsdf_transparent_setup(sd, weight, path_flag); + } }; ClosureParam *closure_bsdf_transparent_params() { - static ClosureParam params[] = { - CLOSURE_STRING_KEYPARAM(TransparentClosure, label, "label"), - CLOSURE_FINISH_PARAM(TransparentClosure) - }; - return params; + static ClosureParam params[] = {CLOSURE_STRING_KEYPARAM(TransparentClosure, label, "label"), + CLOSURE_FINISH_PARAM(TransparentClosure)}; + return params; } CCLOSURE_PREPARE(closure_bsdf_transparent_prepare, TransparentClosure) @@ -778,52 +859,49 @@ CCLOSURE_PREPARE(closure_bsdf_transparent_prepare, TransparentClosure) /* Volume */ class VolumeAbsorptionClosure : public CBSDFClosure { -public: - void setup(ShaderData *sd, int path_flag, float3 weight) - { - volume_extinction_setup(sd, weight); - } + public: + void setup(ShaderData *sd, int path_flag, float3 weight) + { + volume_extinction_setup(sd, weight); + } }; ClosureParam *closure_absorption_params() { - static ClosureParam params[] = { - CLOSURE_STRING_KEYPARAM(VolumeAbsorptionClosure, label, "label"), - CLOSURE_FINISH_PARAM(VolumeAbsorptionClosure) - }; - return params; + static ClosureParam params[] = {CLOSURE_STRING_KEYPARAM(VolumeAbsorptionClosure, label, "label"), + CLOSURE_FINISH_PARAM(VolumeAbsorptionClosure)}; + return params; } CCLOSURE_PREPARE(closure_absorption_prepare, VolumeAbsorptionClosure) class VolumeHenyeyGreensteinClosure : public CBSDFClosure { -public: - HenyeyGreensteinVolume params; + public: + HenyeyGreensteinVolume params; - void setup(ShaderData *sd, int path_flag, float3 weight) - { - volume_extinction_setup(sd, weight); + void setup(ShaderData *sd, int path_flag, float3 weight) + { + volume_extinction_setup(sd, weight); - HenyeyGreensteinVolume *volume = (HenyeyGreensteinVolume*)bsdf_alloc_osl(sd, sizeof(HenyeyGreensteinVolume), weight, ¶ms); - if(!volume) { - return; - } + HenyeyGreensteinVolume *volume = (HenyeyGreensteinVolume *)bsdf_alloc_osl( + sd, sizeof(HenyeyGreensteinVolume), weight, ¶ms); + if (!volume) { + return; + } - sd->flag |= volume_henyey_greenstein_setup(volume); - } + sd->flag |= volume_henyey_greenstein_setup(volume); + } }; ClosureParam *closure_henyey_greenstein_params() { - static ClosureParam params[] = { - CLOSURE_FLOAT_PARAM(VolumeHenyeyGreensteinClosure, params.g), - CLOSURE_STRING_KEYPARAM(VolumeHenyeyGreensteinClosure, label, "label"), - CLOSURE_FINISH_PARAM(VolumeHenyeyGreensteinClosure) - }; - return params; + static ClosureParam params[] = { + CLOSURE_FLOAT_PARAM(VolumeHenyeyGreensteinClosure, params.g), + CLOSURE_STRING_KEYPARAM(VolumeHenyeyGreensteinClosure, label, "label"), + CLOSURE_FINISH_PARAM(VolumeHenyeyGreensteinClosure)}; + return params; } CCLOSURE_PREPARE(closure_henyey_greenstein_prepare, VolumeHenyeyGreensteinClosure) - CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/osl/osl_closures.h b/intern/cycles/kernel/osl/osl_closures.h index 2a50704b569..d3db6b71f5c 100644 --- a/intern/cycles/kernel/osl/osl_closures.h +++ b/intern/cycles/kernel/osl/osl_closures.h @@ -74,24 +74,34 @@ void closure_bsdf_microfacet_multi_ggx_prepare(OSL::RendererServices *, int id, void closure_bsdf_microfacet_multi_ggx_glass_prepare(OSL::RendererServices *, int id, void *data); void closure_bsdf_microfacet_multi_ggx_aniso_prepare(OSL::RendererServices *, int id, void *data); void closure_bsdf_microfacet_ggx_fresnel_prepare(OSL::RendererServices *, int id, void *data); -void closure_bsdf_microfacet_ggx_aniso_fresnel_prepare(OSL::RendererServices *, int id, void *data); -void closure_bsdf_microfacet_multi_ggx_fresnel_prepare(OSL::RendererServices *, int id, void *data); -void closure_bsdf_microfacet_multi_ggx_glass_fresnel_prepare(OSL::RendererServices *, int id, void *data); -void closure_bsdf_microfacet_multi_ggx_aniso_fresnel_prepare(OSL::RendererServices *, int id, void *data); +void closure_bsdf_microfacet_ggx_aniso_fresnel_prepare(OSL::RendererServices *, + int id, + void *data); +void closure_bsdf_microfacet_multi_ggx_fresnel_prepare(OSL::RendererServices *, + int id, + void *data); +void closure_bsdf_microfacet_multi_ggx_glass_fresnel_prepare(OSL::RendererServices *, + int id, + void *data); +void closure_bsdf_microfacet_multi_ggx_aniso_fresnel_prepare(OSL::RendererServices *, + int id, + void *data); void closure_bsdf_principled_clearcoat_prepare(OSL::RendererServices *, int id, void *data); void closure_bsdf_principled_hair_prepare(OSL::RendererServices *, int id, void *data); -#define CCLOSURE_PREPARE(name, classname) \ -void name(RendererServices *, int id, void *data) \ -{ \ - memset(data, 0, sizeof(classname)); \ - new (data) classname(); \ -} +#define CCLOSURE_PREPARE(name, classname) \ + void name(RendererServices *, int id, void *data) \ + { \ + memset(data, 0, sizeof(classname)); \ + new (data) classname(); \ + } #define CCLOSURE_PREPARE_STATIC(name, classname) static CCLOSURE_PREPARE(name, classname) #define CLOSURE_FLOAT3_PARAM(st, fld) \ - { TypeDesc::TypeVector, (int)reckless_offsetof(st, fld), NULL, sizeof(OSL::Vec3) } + { \ + TypeDesc::TypeVector, (int)reckless_offsetof(st, fld), NULL, sizeof(OSL::Vec3) \ + } #define TO_VEC3(v) OSL::Vec3(v.x, v.y, v.z) #define TO_COLOR3(v) OSL::Color3(v.x, v.y, v.z) @@ -100,50 +110,50 @@ void name(RendererServices *, int id, void *data) \ /* Closure */ class CClosurePrimitive { -public: - virtual void setup(ShaderData *sd, int path_flag, float3 weight) = 0; + public: + virtual void setup(ShaderData *sd, int path_flag, float3 weight) = 0; - OSL::ustring label; + OSL::ustring label; }; /* BSDF */ class CBSDFClosure : public CClosurePrimitive { -public: - bool skip(const ShaderData *sd, int path_flag, int scattering); + public: + bool skip(const ShaderData *sd, int path_flag, int scattering); }; #define BSDF_CLOSURE_CLASS_BEGIN(Upper, lower, structname, TYPE) \ \ -class Upper##Closure : public CBSDFClosure { \ -public: \ - structname params; \ - float3 unused; \ + class Upper##Closure : public CBSDFClosure { \ + public: \ + structname params; \ + float3 unused; \ \ - void setup(ShaderData *sd, int path_flag, float3 weight) \ - { \ - if(!skip(sd, path_flag, TYPE)) { \ - structname *bsdf = (structname*)bsdf_alloc_osl(sd, sizeof(structname), weight, ¶ms); \ - sd->flag |= (bsdf) ? bsdf_##lower##_setup(bsdf) : 0; \ - } \ - } \ -}; \ + void setup(ShaderData *sd, int path_flag, float3 weight) \ + { \ + if (!skip(sd, path_flag, TYPE)) { \ + structname *bsdf = (structname *)bsdf_alloc_osl(sd, sizeof(structname), weight, ¶ms); \ + sd->flag |= (bsdf) ? bsdf_##lower##_setup(bsdf) : 0; \ + } \ + } \ + }; \ \ -static ClosureParam *bsdf_##lower##_params() \ -{ \ - static ClosureParam params[] = { + static ClosureParam *bsdf_##lower##_params() \ + { \ + static ClosureParam params[] = { /* parameters */ #define BSDF_CLOSURE_CLASS_END(Upper, lower) \ - CLOSURE_STRING_KEYPARAM(Upper##Closure, label, "label"), \ - CLOSURE_FINISH_PARAM(Upper##Closure) \ - }; \ - return params; \ -} \ + CLOSURE_STRING_KEYPARAM(Upper##Closure, label, "label"), CLOSURE_FINISH_PARAM(Upper##Closure) \ + } \ + ; \ + return params; \ + } \ \ -CCLOSURE_PREPARE_STATIC(bsdf_##lower##_prepare, Upper##Closure) + CCLOSURE_PREPARE_STATIC(bsdf_##lower##_prepare, Upper##Closure) CCL_NAMESPACE_END -#endif /* __OSL_CLOSURES_H__ */ +#endif /* __OSL_CLOSURES_H__ */ diff --git a/intern/cycles/kernel/osl/osl_globals.h b/intern/cycles/kernel/osl/osl_globals.h index 88192fbcccb..641c9967586 100644 --- a/intern/cycles/kernel/osl/osl_globals.h +++ b/intern/cycles/kernel/osl/osl_globals.h @@ -19,79 +19,79 @@ #ifdef WITH_OSL -#include <OSL/oslexec.h> +# include <OSL/oslexec.h> -#include "util/util_map.h" -#include "util/util_param.h" -#include "util/util_thread.h" -#include "util/util_vector.h" +# include "util/util_map.h" +# include "util/util_param.h" +# include "util/util_thread.h" +# include "util/util_vector.h" -#ifndef WIN32 +# ifndef WIN32 using std::isfinite; -#endif +# endif CCL_NAMESPACE_BEGIN class OSLRenderServices; struct OSLGlobals { - OSLGlobals() - { - ss = NULL; - ts = NULL; - services = NULL; - use = false; - } - - bool use; - - /* shading system */ - OSL::ShadingSystem *ss; - OSL::TextureSystem *ts; - OSLRenderServices *services; - - /* shader states */ - vector<OSL::ShaderGroupRef> surface_state; - vector<OSL::ShaderGroupRef> volume_state; - vector<OSL::ShaderGroupRef> displacement_state; - vector<OSL::ShaderGroupRef> bump_state; - OSL::ShaderGroupRef background_state; - - /* attributes */ - struct Attribute { - TypeDesc type; - AttributeDescriptor desc; - ParamValue value; - }; - - typedef unordered_map<ustring, Attribute, ustringHash> AttributeMap; - typedef unordered_map<ustring, int, ustringHash> ObjectNameMap; - - vector<AttributeMap> attribute_map; - ObjectNameMap object_name_map; - vector<ustring> object_names; + OSLGlobals() + { + ss = NULL; + ts = NULL; + services = NULL; + use = false; + } + + bool use; + + /* shading system */ + OSL::ShadingSystem *ss; + OSL::TextureSystem *ts; + OSLRenderServices *services; + + /* shader states */ + vector<OSL::ShaderGroupRef> surface_state; + vector<OSL::ShaderGroupRef> volume_state; + vector<OSL::ShaderGroupRef> displacement_state; + vector<OSL::ShaderGroupRef> bump_state; + OSL::ShaderGroupRef background_state; + + /* attributes */ + struct Attribute { + TypeDesc type; + AttributeDescriptor desc; + ParamValue value; + }; + + typedef unordered_map<ustring, Attribute, ustringHash> AttributeMap; + typedef unordered_map<ustring, int, ustringHash> ObjectNameMap; + + vector<AttributeMap> attribute_map; + ObjectNameMap object_name_map; + vector<ustring> object_names; }; /* trace() call result */ struct OSLTraceData { - Ray ray; - Intersection isect; - ShaderData sd; - bool setup; - bool init; + Ray ray; + Intersection isect; + ShaderData sd; + bool setup; + bool init; }; /* thread key for thread specific data lookup */ struct OSLThreadData { - OSL::ShaderGlobals globals; - OSL::PerThreadInfo *osl_thread_info; - OSLTraceData tracedata; - OSL::ShadingContext *context; - OIIO::TextureSystem::Perthread *oiio_thread_info; + OSL::ShaderGlobals globals; + OSL::PerThreadInfo *osl_thread_info; + OSLTraceData tracedata; + OSL::ShadingContext *context; + OIIO::TextureSystem::Perthread *oiio_thread_info; }; CCL_NAMESPACE_END #endif -#endif /* __OSL_GLOBALS_H__ */ +#endif /* __OSL_GLOBALS_H__ */ diff --git a/intern/cycles/kernel/osl/osl_services.cpp b/intern/cycles/kernel/osl/osl_services.cpp index 6464d382634..eb9f672fd8a 100644 --- a/intern/cycles/kernel/osl/osl_services.cpp +++ b/intern/cycles/kernel/osl/osl_services.cpp @@ -63,16 +63,16 @@ CCL_NAMESPACE_BEGIN /* RenderServices implementation */ -static void copy_matrix(OSL::Matrix44& m, const Transform& tfm) +static void copy_matrix(OSL::Matrix44 &m, const Transform &tfm) { - ProjectionTransform t = projection_transpose(ProjectionTransform(tfm)); - memcpy((void *)&m, &t, sizeof(m)); + ProjectionTransform t = projection_transpose(ProjectionTransform(tfm)); + memcpy((void *)&m, &t, sizeof(m)); } -static void copy_matrix(OSL::Matrix44& m, const ProjectionTransform& tfm) +static void copy_matrix(OSL::Matrix44 &m, const ProjectionTransform &tfm) { - ProjectionTransform t = projection_transpose(tfm); - memcpy((void *)&m, &t, sizeof(m)); + ProjectionTransform t = projection_transpose(tfm); + memcpy((void *)&m, &t, sizeof(m)); } /* static ustrings */ @@ -129,815 +129,846 @@ ustring OSLRenderServices::u_at_ao("@ao"); OSLRenderServices::OSLRenderServices() { - kernel_globals = NULL; - osl_ts = NULL; + kernel_globals = NULL; + osl_ts = NULL; #ifdef WITH_PTEX - size_t maxmem = 16384 * 1024; - ptex_cache = PtexCache::create(0, maxmem); + size_t maxmem = 16384 * 1024; + ptex_cache = PtexCache::create(0, maxmem); #endif } OSLRenderServices::~OSLRenderServices() { - if(osl_ts) { - VLOG(2) << "OSL texture system stats:\n" - << osl_ts->getstats(); - } + if (osl_ts) { + VLOG(2) << "OSL texture system stats:\n" << osl_ts->getstats(); + } #ifdef WITH_PTEX - ptex_cache->release(); + ptex_cache->release(); #endif } void OSLRenderServices::thread_init(KernelGlobals *kernel_globals_, OSL::TextureSystem *osl_ts_) { - kernel_globals = kernel_globals_; - osl_ts = osl_ts_; + kernel_globals = kernel_globals_; + osl_ts = osl_ts_; } -bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, OSL::TransformationPtr xform, float time) +bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg, + OSL::Matrix44 &result, + OSL::TransformationPtr xform, + float time) { - /* this is only used for shader and object space, we don't really have - * a concept of shader space, so we just use object space for both. */ - if(xform) { - const ShaderData *sd = (const ShaderData *)xform; - KernelGlobals *kg = sd->osl_globals; - int object = sd->object; - - if(object != OBJECT_NONE) { + /* this is only used for shader and object space, we don't really have + * a concept of shader space, so we just use object space for both. */ + if (xform) { + const ShaderData *sd = (const ShaderData *)xform; + KernelGlobals *kg = sd->osl_globals; + int object = sd->object; + + if (object != OBJECT_NONE) { #ifdef __OBJECT_MOTION__ - Transform tfm; + Transform tfm; - if(time == sd->time) - tfm = sd->ob_tfm; - else - tfm = object_fetch_transform_motion_test(kg, object, time, NULL); + if (time == sd->time) + tfm = sd->ob_tfm; + else + tfm = object_fetch_transform_motion_test(kg, object, time, NULL); #else - Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM); + Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM); #endif - copy_matrix(result, tfm); + copy_matrix(result, tfm); - return true; - } - else if(sd->type == PRIMITIVE_LAMP) { - copy_matrix(result, sd->ob_tfm); + return true; + } + else if (sd->type == PRIMITIVE_LAMP) { + copy_matrix(result, sd->ob_tfm); - return true; - } - } + return true; + } + } - return false; + return false; } -bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, OSL::TransformationPtr xform, float time) +bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg, + OSL::Matrix44 &result, + OSL::TransformationPtr xform, + float time) { - /* this is only used for shader and object space, we don't really have - * a concept of shader space, so we just use object space for both. */ - if(xform) { - const ShaderData *sd = (const ShaderData *)xform; - KernelGlobals *kg = sd->osl_globals; - int object = sd->object; - - if(object != OBJECT_NONE) { + /* this is only used for shader and object space, we don't really have + * a concept of shader space, so we just use object space for both. */ + if (xform) { + const ShaderData *sd = (const ShaderData *)xform; + KernelGlobals *kg = sd->osl_globals; + int object = sd->object; + + if (object != OBJECT_NONE) { #ifdef __OBJECT_MOTION__ - Transform itfm; + Transform itfm; - if(time == sd->time) - itfm = sd->ob_itfm; - else - object_fetch_transform_motion_test(kg, object, time, &itfm); + if (time == sd->time) + itfm = sd->ob_itfm; + else + object_fetch_transform_motion_test(kg, object, time, &itfm); #else - Transform itfm = object_fetch_transform(kg, object, OBJECT_INVERSE_TRANSFORM); + Transform itfm = object_fetch_transform(kg, object, OBJECT_INVERSE_TRANSFORM); #endif - copy_matrix(result, itfm); + copy_matrix(result, itfm); - return true; - } - else if(sd->type == PRIMITIVE_LAMP) { - copy_matrix(result, sd->ob_itfm); + return true; + } + else if (sd->type == PRIMITIVE_LAMP) { + copy_matrix(result, sd->ob_itfm); - return true; - } - } + return true; + } + } - return false; + return false; } -bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, ustring from, float time) +bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg, + OSL::Matrix44 &result, + ustring from, + float time) { - KernelGlobals *kg = kernel_globals; - - if(from == u_ndc) { - copy_matrix(result, kernel_data.cam.ndctoworld); - return true; - } - else if(from == u_raster) { - copy_matrix(result, kernel_data.cam.rastertoworld); - return true; - } - else if(from == u_screen) { - copy_matrix(result, kernel_data.cam.screentoworld); - return true; - } - else if(from == u_camera) { - copy_matrix(result, kernel_data.cam.cameratoworld); - return true; - } - else if(from == u_world) { - result.makeIdentity(); - return true; - } - - return false; + KernelGlobals *kg = kernel_globals; + + if (from == u_ndc) { + copy_matrix(result, kernel_data.cam.ndctoworld); + return true; + } + else if (from == u_raster) { + copy_matrix(result, kernel_data.cam.rastertoworld); + return true; + } + else if (from == u_screen) { + copy_matrix(result, kernel_data.cam.screentoworld); + return true; + } + else if (from == u_camera) { + copy_matrix(result, kernel_data.cam.cameratoworld); + return true; + } + else if (from == u_world) { + result.makeIdentity(); + return true; + } + + return false; } -bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, ustring to, float time) +bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg, + OSL::Matrix44 &result, + ustring to, + float time) { - KernelGlobals *kg = kernel_globals; - - if(to == u_ndc) { - copy_matrix(result, kernel_data.cam.worldtondc); - return true; - } - else if(to == u_raster) { - copy_matrix(result, kernel_data.cam.worldtoraster); - return true; - } - else if(to == u_screen) { - copy_matrix(result, kernel_data.cam.worldtoscreen); - return true; - } - else if(to == u_camera) { - copy_matrix(result, kernel_data.cam.worldtocamera); - return true; - } - else if(to == u_world) { - result.makeIdentity(); - return true; - } - - return false; + KernelGlobals *kg = kernel_globals; + + if (to == u_ndc) { + copy_matrix(result, kernel_data.cam.worldtondc); + return true; + } + else if (to == u_raster) { + copy_matrix(result, kernel_data.cam.worldtoraster); + return true; + } + else if (to == u_screen) { + copy_matrix(result, kernel_data.cam.worldtoscreen); + return true; + } + else if (to == u_camera) { + copy_matrix(result, kernel_data.cam.worldtocamera); + return true; + } + else if (to == u_world) { + result.makeIdentity(); + return true; + } + + return false; } -bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, OSL::TransformationPtr xform) +bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg, + OSL::Matrix44 &result, + OSL::TransformationPtr xform) { - /* this is only used for shader and object space, we don't really have - * a concept of shader space, so we just use object space for both. */ - if(xform) { - const ShaderData *sd = (const ShaderData *)xform; - int object = sd->object; + /* this is only used for shader and object space, we don't really have + * a concept of shader space, so we just use object space for both. */ + if (xform) { + const ShaderData *sd = (const ShaderData *)xform; + int object = sd->object; - if(object != OBJECT_NONE) { + if (object != OBJECT_NONE) { #ifdef __OBJECT_MOTION__ - Transform tfm = sd->ob_tfm; + Transform tfm = sd->ob_tfm; #else - KernelGlobals *kg = sd->osl_globals; - Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM); + KernelGlobals *kg = sd->osl_globals; + Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM); #endif - copy_matrix(result, tfm); + copy_matrix(result, tfm); - return true; - } - else if(sd->type == PRIMITIVE_LAMP) { - copy_matrix(result, sd->ob_tfm); + return true; + } + else if (sd->type == PRIMITIVE_LAMP) { + copy_matrix(result, sd->ob_tfm); - return true; - } - } + return true; + } + } - return false; + return false; } -bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, OSL::TransformationPtr xform) +bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg, + OSL::Matrix44 &result, + OSL::TransformationPtr xform) { - /* this is only used for shader and object space, we don't really have - * a concept of shader space, so we just use object space for both. */ - if(xform) { - const ShaderData *sd = (const ShaderData *)xform; - int object = sd->object; + /* this is only used for shader and object space, we don't really have + * a concept of shader space, so we just use object space for both. */ + if (xform) { + const ShaderData *sd = (const ShaderData *)xform; + int object = sd->object; - if(object != OBJECT_NONE) { + if (object != OBJECT_NONE) { #ifdef __OBJECT_MOTION__ - Transform tfm = sd->ob_itfm; + Transform tfm = sd->ob_itfm; #else - KernelGlobals *kg = sd->osl_globals; - Transform tfm = object_fetch_transform(kg, object, OBJECT_INVERSE_TRANSFORM); + KernelGlobals *kg = sd->osl_globals; + Transform tfm = object_fetch_transform(kg, object, OBJECT_INVERSE_TRANSFORM); #endif - copy_matrix(result, tfm); + copy_matrix(result, tfm); - return true; - } - else if(sd->type == PRIMITIVE_LAMP) { - copy_matrix(result, sd->ob_itfm); + return true; + } + else if (sd->type == PRIMITIVE_LAMP) { + copy_matrix(result, sd->ob_itfm); - return true; - } - } + return true; + } + } - return false; + return false; } bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, ustring from) { - KernelGlobals *kg = kernel_globals; - - if(from == u_ndc) { - copy_matrix(result, kernel_data.cam.ndctoworld); - return true; - } - else if(from == u_raster) { - copy_matrix(result, kernel_data.cam.rastertoworld); - return true; - } - else if(from == u_screen) { - copy_matrix(result, kernel_data.cam.screentoworld); - return true; - } - else if(from == u_camera) { - copy_matrix(result, kernel_data.cam.cameratoworld); - return true; - } - - return false; + KernelGlobals *kg = kernel_globals; + + if (from == u_ndc) { + copy_matrix(result, kernel_data.cam.ndctoworld); + return true; + } + else if (from == u_raster) { + copy_matrix(result, kernel_data.cam.rastertoworld); + return true; + } + else if (from == u_screen) { + copy_matrix(result, kernel_data.cam.screentoworld); + return true; + } + else if (from == u_camera) { + copy_matrix(result, kernel_data.cam.cameratoworld); + return true; + } + + return false; } -bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, ustring to) +bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg, + OSL::Matrix44 &result, + ustring to) { - KernelGlobals *kg = kernel_globals; - - if(to == u_ndc) { - copy_matrix(result, kernel_data.cam.worldtondc); - return true; - } - else if(to == u_raster) { - copy_matrix(result, kernel_data.cam.worldtoraster); - return true; - } - else if(to == u_screen) { - copy_matrix(result, kernel_data.cam.worldtoscreen); - return true; - } - else if(to == u_camera) { - copy_matrix(result, kernel_data.cam.worldtocamera); - return true; - } - - return false; + KernelGlobals *kg = kernel_globals; + + if (to == u_ndc) { + copy_matrix(result, kernel_data.cam.worldtondc); + return true; + } + else if (to == u_raster) { + copy_matrix(result, kernel_data.cam.worldtoraster); + return true; + } + else if (to == u_screen) { + copy_matrix(result, kernel_data.cam.worldtoscreen); + return true; + } + else if (to == u_camera) { + copy_matrix(result, kernel_data.cam.worldtocamera); + return true; + } + + return false; } -bool OSLRenderServices::get_array_attribute(OSL::ShaderGlobals *sg, bool derivatives, - ustring object, TypeDesc type, ustring name, - int index, void *val) +bool OSLRenderServices::get_array_attribute(OSL::ShaderGlobals *sg, + bool derivatives, + ustring object, + TypeDesc type, + ustring name, + int index, + void *val) { - return false; + return false; } static bool set_attribute_float2(float2 f[3], TypeDesc type, bool derivatives, void *val) { - if(type == TypeDesc::TypePoint || type == TypeDesc::TypeVector || - type == TypeDesc::TypeNormal || type == TypeDesc::TypeColor) - { - float *fval = (float *)val; - - fval[0] = f[0].x; - fval[1] = f[0].y; - fval[2] = 0.0f; - - if(derivatives) { - fval[3] = f[1].x; - fval[4] = f[1].y; - fval[5] = 0.0f; - - fval[6] = f[2].x; - fval[7] = f[2].y; - fval[8] = 0.0f; - } - - return true; - } - else if(type == TypeDesc::TypeFloat) { - float *fval = (float *)val; - fval[0] = average(f[0]); - - if(derivatives) { - fval[1] = average(f[1]); - fval[2] = average(f[2]); - } - - return true; - } - - return false; + if (type == TypeDesc::TypePoint || type == TypeDesc::TypeVector || + type == TypeDesc::TypeNormal || type == TypeDesc::TypeColor) { + float *fval = (float *)val; + + fval[0] = f[0].x; + fval[1] = f[0].y; + fval[2] = 0.0f; + + if (derivatives) { + fval[3] = f[1].x; + fval[4] = f[1].y; + fval[5] = 0.0f; + + fval[6] = f[2].x; + fval[7] = f[2].y; + fval[8] = 0.0f; + } + + return true; + } + else if (type == TypeDesc::TypeFloat) { + float *fval = (float *)val; + fval[0] = average(f[0]); + + if (derivatives) { + fval[1] = average(f[1]); + fval[2] = average(f[2]); + } + + return true; + } + + return false; } static bool set_attribute_float3(float3 f[3], TypeDesc type, bool derivatives, void *val) { - if(type == TypeDesc::TypePoint || type == TypeDesc::TypeVector || - type == TypeDesc::TypeNormal || type == TypeDesc::TypeColor) - { - float *fval = (float *)val; - - fval[0] = f[0].x; - fval[1] = f[0].y; - fval[2] = f[0].z; - - if(derivatives) { - fval[3] = f[1].x; - fval[4] = f[1].y; - fval[5] = f[1].z; - - fval[6] = f[2].x; - fval[7] = f[2].y; - fval[8] = f[2].z; - } - - return true; - } - else if(type == TypeDesc::TypeFloat) { - float *fval = (float *)val; - fval[0] = average(f[0]); - - if(derivatives) { - fval[1] = average(f[1]); - fval[2] = average(f[2]); - } - - return true; - } - - return false; + if (type == TypeDesc::TypePoint || type == TypeDesc::TypeVector || + type == TypeDesc::TypeNormal || type == TypeDesc::TypeColor) { + float *fval = (float *)val; + + fval[0] = f[0].x; + fval[1] = f[0].y; + fval[2] = f[0].z; + + if (derivatives) { + fval[3] = f[1].x; + fval[4] = f[1].y; + fval[5] = f[1].z; + + fval[6] = f[2].x; + fval[7] = f[2].y; + fval[8] = f[2].z; + } + + return true; + } + else if (type == TypeDesc::TypeFloat) { + float *fval = (float *)val; + fval[0] = average(f[0]); + + if (derivatives) { + fval[1] = average(f[1]); + fval[2] = average(f[2]); + } + + return true; + } + + return false; } static bool set_attribute_float3(float3 f, TypeDesc type, bool derivatives, void *val) { - float3 fv[3]; + float3 fv[3]; - fv[0] = f; - fv[1] = make_float3(0.0f, 0.0f, 0.0f); - fv[2] = make_float3(0.0f, 0.0f, 0.0f); + fv[0] = f; + fv[1] = make_float3(0.0f, 0.0f, 0.0f); + fv[2] = make_float3(0.0f, 0.0f, 0.0f); - return set_attribute_float3(fv, type, derivatives, val); + return set_attribute_float3(fv, type, derivatives, val); } static bool set_attribute_float(float f[3], TypeDesc type, bool derivatives, void *val) { - if(type == TypeDesc::TypePoint || type == TypeDesc::TypeVector || - type == TypeDesc::TypeNormal || type == TypeDesc::TypeColor) - { - float *fval = (float *)val; - fval[0] = f[0]; - fval[1] = f[1]; - fval[2] = f[2]; - - if(derivatives) { - fval[3] = f[1]; - fval[4] = f[1]; - fval[5] = f[1]; - - fval[6] = f[2]; - fval[7] = f[2]; - fval[8] = f[2]; - } - - return true; - } - else if(type == TypeDesc::TypeFloat) { - float *fval = (float *)val; - fval[0] = f[0]; - - if(derivatives) { - fval[1] = f[1]; - fval[2] = f[2]; - } - - return true; - } - - return false; + if (type == TypeDesc::TypePoint || type == TypeDesc::TypeVector || + type == TypeDesc::TypeNormal || type == TypeDesc::TypeColor) { + float *fval = (float *)val; + fval[0] = f[0]; + fval[1] = f[1]; + fval[2] = f[2]; + + if (derivatives) { + fval[3] = f[1]; + fval[4] = f[1]; + fval[5] = f[1]; + + fval[6] = f[2]; + fval[7] = f[2]; + fval[8] = f[2]; + } + + return true; + } + else if (type == TypeDesc::TypeFloat) { + float *fval = (float *)val; + fval[0] = f[0]; + + if (derivatives) { + fval[1] = f[1]; + fval[2] = f[2]; + } + + return true; + } + + return false; } static bool set_attribute_float(float f, TypeDesc type, bool derivatives, void *val) { - float fv[3]; + float fv[3]; - fv[0] = f; - fv[1] = 0.0f; - fv[2] = 0.0f; + fv[0] = f; + fv[1] = 0.0f; + fv[2] = 0.0f; - return set_attribute_float(fv, type, derivatives, val); + return set_attribute_float(fv, type, derivatives, val); } static bool set_attribute_int(int i, TypeDesc type, bool derivatives, void *val) { - if(type.basetype == TypeDesc::INT && type.aggregate == TypeDesc::SCALAR && type.arraylen == 0) { - int *ival = (int *)val; - ival[0] = i; + if (type.basetype == TypeDesc::INT && type.aggregate == TypeDesc::SCALAR && type.arraylen == 0) { + int *ival = (int *)val; + ival[0] = i; - if(derivatives) { - ival[1] = 0; - ival[2] = 0; - } + if (derivatives) { + ival[1] = 0; + ival[2] = 0; + } - return true; - } + return true; + } - return false; + return false; } static bool set_attribute_string(ustring str, TypeDesc type, bool derivatives, void *val) { - if(type.basetype == TypeDesc::STRING && type.aggregate == TypeDesc::SCALAR && type.arraylen == 0) { - ustring *sval = (ustring *)val; - sval[0] = str; + if (type.basetype == TypeDesc::STRING && type.aggregate == TypeDesc::SCALAR && + type.arraylen == 0) { + ustring *sval = (ustring *)val; + sval[0] = str; - if(derivatives) { - sval[1] = OSLRenderServices::u_empty; - sval[2] = OSLRenderServices::u_empty; - } + if (derivatives) { + sval[1] = OSLRenderServices::u_empty; + sval[2] = OSLRenderServices::u_empty; + } - return true; - } + return true; + } - return false; + return false; } static bool set_attribute_float3_3(float3 P[3], TypeDesc type, bool derivatives, void *val) { - if(type.vecsemantics == TypeDesc::POINT && type.arraylen >= 3) { - float *fval = (float *)val; + if (type.vecsemantics == TypeDesc::POINT && type.arraylen >= 3) { + float *fval = (float *)val; - fval[0] = P[0].x; - fval[1] = P[0].y; - fval[2] = P[0].z; + fval[0] = P[0].x; + fval[1] = P[0].y; + fval[2] = P[0].z; - fval[3] = P[1].x; - fval[4] = P[1].y; - fval[5] = P[1].z; + fval[3] = P[1].x; + fval[4] = P[1].y; + fval[5] = P[1].z; - fval[6] = P[2].x; - fval[7] = P[2].y; - fval[8] = P[2].z; + fval[6] = P[2].x; + fval[7] = P[2].y; + fval[8] = P[2].z; - if(type.arraylen > 3) - memset(fval + 3*3, 0, sizeof(float)*3*(type.arraylen - 3)); - if(derivatives) - memset(fval + type.arraylen*3, 0, sizeof(float)*2*3*type.arraylen); + if (type.arraylen > 3) + memset(fval + 3 * 3, 0, sizeof(float) * 3 * (type.arraylen - 3)); + if (derivatives) + memset(fval + type.arraylen * 3, 0, sizeof(float) * 2 * 3 * type.arraylen); - return true; - } + return true; + } - return false; + return false; } -static bool set_attribute_matrix(const Transform& tfm, TypeDesc type, void *val) +static bool set_attribute_matrix(const Transform &tfm, TypeDesc type, void *val) { - if(type == TypeDesc::TypeMatrix) { - copy_matrix(*(OSL::Matrix44*)val, tfm); - return true; - } + if (type == TypeDesc::TypeMatrix) { + copy_matrix(*(OSL::Matrix44 *)val, tfm); + return true; + } - return false; + return false; } -static bool get_primitive_attribute(KernelGlobals *kg, const ShaderData *sd, const OSLGlobals::Attribute& attr, - const TypeDesc& type, bool derivatives, void *val) +static bool get_primitive_attribute(KernelGlobals *kg, + const ShaderData *sd, + const OSLGlobals::Attribute &attr, + const TypeDesc &type, + bool derivatives, + void *val) { - if(attr.type == TypeDesc::TypePoint || attr.type == TypeDesc::TypeVector || - attr.type == TypeDesc::TypeNormal || attr.type == TypeDesc::TypeColor) - { - float3 fval[3]; - fval[0] = primitive_attribute_float3(kg, sd, attr.desc, - (derivatives) ? &fval[1] : NULL, (derivatives) ? &fval[2] : NULL); - return set_attribute_float3(fval, type, derivatives, val); - } - else if(attr.type == TypeFloat2) { - float2 fval[2]; - fval[0] = primitive_attribute_float2(kg, sd, attr.desc, - (derivatives) ? &fval[1] : NULL, (derivatives) ? &fval[2] : NULL); - return set_attribute_float2(fval, type, derivatives, val); - } - else if(attr.type == TypeDesc::TypeFloat) { - float fval[3]; - fval[0] = primitive_attribute_float(kg, sd, attr.desc, - (derivatives) ? &fval[1] : NULL, (derivatives) ? &fval[2] : NULL); - return set_attribute_float(fval, type, derivatives, val); - } - else { - return false; - } + if (attr.type == TypeDesc::TypePoint || attr.type == TypeDesc::TypeVector || + attr.type == TypeDesc::TypeNormal || attr.type == TypeDesc::TypeColor) { + float3 fval[3]; + fval[0] = primitive_attribute_float3( + kg, sd, attr.desc, (derivatives) ? &fval[1] : NULL, (derivatives) ? &fval[2] : NULL); + return set_attribute_float3(fval, type, derivatives, val); + } + else if (attr.type == TypeFloat2) { + float2 fval[2]; + fval[0] = primitive_attribute_float2( + kg, sd, attr.desc, (derivatives) ? &fval[1] : NULL, (derivatives) ? &fval[2] : NULL); + return set_attribute_float2(fval, type, derivatives, val); + } + else if (attr.type == TypeDesc::TypeFloat) { + float fval[3]; + fval[0] = primitive_attribute_float( + kg, sd, attr.desc, (derivatives) ? &fval[1] : NULL, (derivatives) ? &fval[2] : NULL); + return set_attribute_float(fval, type, derivatives, val); + } + else { + return false; + } } -static bool get_mesh_attribute(KernelGlobals *kg, const ShaderData *sd, const OSLGlobals::Attribute& attr, - const TypeDesc& type, bool derivatives, void *val) +static bool get_mesh_attribute(KernelGlobals *kg, + const ShaderData *sd, + const OSLGlobals::Attribute &attr, + const TypeDesc &type, + bool derivatives, + void *val) { - if(attr.type == TypeDesc::TypeMatrix) { - Transform tfm = primitive_attribute_matrix(kg, sd, attr.desc); - return set_attribute_matrix(tfm, type, val); - } - else { - return false; - } + if (attr.type == TypeDesc::TypeMatrix) { + Transform tfm = primitive_attribute_matrix(kg, sd, attr.desc); + return set_attribute_matrix(tfm, type, val); + } + else { + return false; + } } -static void get_object_attribute(const OSLGlobals::Attribute& attr, bool derivatives, void *val) +static void get_object_attribute(const OSLGlobals::Attribute &attr, bool derivatives, void *val) { - size_t datasize = attr.value.datasize(); + size_t datasize = attr.value.datasize(); - memcpy(val, attr.value.data(), datasize); - if(derivatives) - memset((char *)val + datasize, 0, datasize * 2); + memcpy(val, attr.value.data(), datasize); + if (derivatives) + memset((char *)val + datasize, 0, datasize * 2); } -bool OSLRenderServices::get_object_standard_attribute(KernelGlobals *kg, ShaderData *sd, ustring name, - TypeDesc type, bool derivatives, void *val) +bool OSLRenderServices::get_object_standard_attribute( + KernelGlobals *kg, ShaderData *sd, ustring name, TypeDesc type, bool derivatives, void *val) { - /* todo: turn this into hash table? */ - - /* Object Attributes */ - if(name == u_object_location) { - float3 f = object_location(kg, sd); - return set_attribute_float3(f, type, derivatives, val); - } - else if(name == u_object_index) { - float f = object_pass_id(kg, sd->object); - return set_attribute_float(f, type, derivatives, val); - } - else if(name == u_geom_dupli_generated) { - float3 f = object_dupli_generated(kg, sd->object); - return set_attribute_float3(f, type, derivatives, val); - } - else if(name == u_geom_dupli_uv) { - float3 f = object_dupli_uv(kg, sd->object); - return set_attribute_float3(f, type, derivatives, val); - } - else if(name == u_material_index) { - float f = shader_pass_id(kg, sd); - return set_attribute_float(f, type, derivatives, val); - } - else if(name == u_object_random) { - float f = object_random_number(kg, sd->object); - return set_attribute_float(f, type, derivatives, val); - } - - /* Particle Attributes */ - else if(name == u_particle_index) { - int particle_id = object_particle_id(kg, sd->object); - float f = particle_index(kg, particle_id); - return set_attribute_float(f, type, derivatives, val); - } - else if(name == u_particle_random) { - int particle_id = object_particle_id(kg, sd->object); - float f = hash_int_01(particle_index(kg, particle_id)); - return set_attribute_float(f, type, derivatives, val); - } - - else if(name == u_particle_age) { - int particle_id = object_particle_id(kg, sd->object); - float f = particle_age(kg, particle_id); - return set_attribute_float(f, type, derivatives, val); - } - else if(name == u_particle_lifetime) { - int particle_id = object_particle_id(kg, sd->object); - float f = particle_lifetime(kg, particle_id); - return set_attribute_float(f, type, derivatives, val); - } - else if(name == u_particle_location) { - int particle_id = object_particle_id(kg, sd->object); - float3 f = particle_location(kg, particle_id); - return set_attribute_float3(f, type, derivatives, val); - } -#if 0 /* unsupported */ - else if(name == u_particle_rotation) { - int particle_id = object_particle_id(kg, sd->object); - float4 f = particle_rotation(kg, particle_id); - return set_attribute_float4(f, type, derivatives, val); - } + /* todo: turn this into hash table? */ + + /* Object Attributes */ + if (name == u_object_location) { + float3 f = object_location(kg, sd); + return set_attribute_float3(f, type, derivatives, val); + } + else if (name == u_object_index) { + float f = object_pass_id(kg, sd->object); + return set_attribute_float(f, type, derivatives, val); + } + else if (name == u_geom_dupli_generated) { + float3 f = object_dupli_generated(kg, sd->object); + return set_attribute_float3(f, type, derivatives, val); + } + else if (name == u_geom_dupli_uv) { + float3 f = object_dupli_uv(kg, sd->object); + return set_attribute_float3(f, type, derivatives, val); + } + else if (name == u_material_index) { + float f = shader_pass_id(kg, sd); + return set_attribute_float(f, type, derivatives, val); + } + else if (name == u_object_random) { + float f = object_random_number(kg, sd->object); + return set_attribute_float(f, type, derivatives, val); + } + + /* Particle Attributes */ + else if (name == u_particle_index) { + int particle_id = object_particle_id(kg, sd->object); + float f = particle_index(kg, particle_id); + return set_attribute_float(f, type, derivatives, val); + } + else if (name == u_particle_random) { + int particle_id = object_particle_id(kg, sd->object); + float f = hash_int_01(particle_index(kg, particle_id)); + return set_attribute_float(f, type, derivatives, val); + } + + else if (name == u_particle_age) { + int particle_id = object_particle_id(kg, sd->object); + float f = particle_age(kg, particle_id); + return set_attribute_float(f, type, derivatives, val); + } + else if (name == u_particle_lifetime) { + int particle_id = object_particle_id(kg, sd->object); + float f = particle_lifetime(kg, particle_id); + return set_attribute_float(f, type, derivatives, val); + } + else if (name == u_particle_location) { + int particle_id = object_particle_id(kg, sd->object); + float3 f = particle_location(kg, particle_id); + return set_attribute_float3(f, type, derivatives, val); + } +#if 0 /* unsupported */ + else if(name == u_particle_rotation) { + int particle_id = object_particle_id(kg, sd->object); + float4 f = particle_rotation(kg, particle_id); + return set_attribute_float4(f, type, derivatives, val); + } #endif - else if(name == u_particle_size) { - int particle_id = object_particle_id(kg, sd->object); - float f = particle_size(kg, particle_id); - return set_attribute_float(f, type, derivatives, val); - } - else if(name == u_particle_velocity) { - int particle_id = object_particle_id(kg, sd->object); - float3 f = particle_velocity(kg, particle_id); - return set_attribute_float3(f, type, derivatives, val); - } - else if(name == u_particle_angular_velocity) { - int particle_id = object_particle_id(kg, sd->object); - float3 f = particle_angular_velocity(kg, particle_id); - return set_attribute_float3(f, type, derivatives, val); - } - - /* Geometry Attributes */ - else if(name == u_geom_numpolyvertices) { - return set_attribute_int(3, type, derivatives, val); - } - else if((name == u_geom_trianglevertices || name == u_geom_polyvertices) - && sd->type & PRIMITIVE_ALL_TRIANGLE) - { - float3 P[3]; - - if(sd->type & PRIMITIVE_TRIANGLE) - triangle_vertices(kg, sd->prim, P); - else - motion_triangle_vertices(kg, sd->object, sd->prim, sd->time, P); - - if(!(sd->object_flag & SD_OBJECT_TRANSFORM_APPLIED)) { - object_position_transform(kg, sd, &P[0]); - object_position_transform(kg, sd, &P[1]); - object_position_transform(kg, sd, &P[2]); - } - - return set_attribute_float3_3(P, type, derivatives, val); - } - else if(name == u_geom_name) { - ustring object_name = kg->osl->object_names[sd->object]; - return set_attribute_string(object_name, type, derivatives, val); - } - else if(name == u_is_smooth) { - float f = ((sd->shader & SHADER_SMOOTH_NORMAL) != 0); - return set_attribute_float(f, type, derivatives, val); - } - /* Hair Attributes */ - else if(name == u_is_curve) { - float f = (sd->type & PRIMITIVE_ALL_CURVE) != 0; - return set_attribute_float(f, type, derivatives, val); - } - else if(name == u_curve_thickness) { - float f = curve_thickness(kg, sd); - return set_attribute_float(f, type, derivatives, val); - } - else if(name == u_curve_tangent_normal) { - float3 f = curve_tangent_normal(kg, sd); - return set_attribute_float3(f, type, derivatives, val); - } - else - return false; + else if (name == u_particle_size) { + int particle_id = object_particle_id(kg, sd->object); + float f = particle_size(kg, particle_id); + return set_attribute_float(f, type, derivatives, val); + } + else if (name == u_particle_velocity) { + int particle_id = object_particle_id(kg, sd->object); + float3 f = particle_velocity(kg, particle_id); + return set_attribute_float3(f, type, derivatives, val); + } + else if (name == u_particle_angular_velocity) { + int particle_id = object_particle_id(kg, sd->object); + float3 f = particle_angular_velocity(kg, particle_id); + return set_attribute_float3(f, type, derivatives, val); + } + + /* Geometry Attributes */ + else if (name == u_geom_numpolyvertices) { + return set_attribute_int(3, type, derivatives, val); + } + else if ((name == u_geom_trianglevertices || name == u_geom_polyvertices) && + sd->type & PRIMITIVE_ALL_TRIANGLE) { + float3 P[3]; + + if (sd->type & PRIMITIVE_TRIANGLE) + triangle_vertices(kg, sd->prim, P); + else + motion_triangle_vertices(kg, sd->object, sd->prim, sd->time, P); + + if (!(sd->object_flag & SD_OBJECT_TRANSFORM_APPLIED)) { + object_position_transform(kg, sd, &P[0]); + object_position_transform(kg, sd, &P[1]); + object_position_transform(kg, sd, &P[2]); + } + + return set_attribute_float3_3(P, type, derivatives, val); + } + else if (name == u_geom_name) { + ustring object_name = kg->osl->object_names[sd->object]; + return set_attribute_string(object_name, type, derivatives, val); + } + else if (name == u_is_smooth) { + float f = ((sd->shader & SHADER_SMOOTH_NORMAL) != 0); + return set_attribute_float(f, type, derivatives, val); + } + /* Hair Attributes */ + else if (name == u_is_curve) { + float f = (sd->type & PRIMITIVE_ALL_CURVE) != 0; + return set_attribute_float(f, type, derivatives, val); + } + else if (name == u_curve_thickness) { + float f = curve_thickness(kg, sd); + return set_attribute_float(f, type, derivatives, val); + } + else if (name == u_curve_tangent_normal) { + float3 f = curve_tangent_normal(kg, sd); + return set_attribute_float3(f, type, derivatives, val); + } + else + return false; } -bool OSLRenderServices::get_background_attribute(KernelGlobals *kg, ShaderData *sd, ustring name, - TypeDesc type, bool derivatives, void *val) +bool OSLRenderServices::get_background_attribute( + KernelGlobals *kg, ShaderData *sd, ustring name, TypeDesc type, bool derivatives, void *val) { - if(name == u_path_ray_length) { - /* Ray Length */ - float f = sd->ray_length; - return set_attribute_float(f, type, derivatives, val); - } - else if(name == u_path_ray_depth) { - /* Ray Depth */ - PathState *state = sd->osl_path_state; - int f = state->bounce; - return set_attribute_int(f, type, derivatives, val); - } - else if(name == u_path_diffuse_depth) { - /* Diffuse Ray Depth */ - PathState *state = sd->osl_path_state; - int f = state->diffuse_bounce; - return set_attribute_int(f, type, derivatives, val); - } - else if(name == u_path_glossy_depth) { - /* Glossy Ray Depth */ - PathState *state = sd->osl_path_state; - int f = state->glossy_bounce; - return set_attribute_int(f, type, derivatives, val); - } - else if(name == u_path_transmission_depth) { - /* Transmission Ray Depth */ - PathState *state = sd->osl_path_state; - int f = state->transmission_bounce; - return set_attribute_int(f, type, derivatives, val); - } - else if(name == u_path_transparent_depth) { - /* Transparent Ray Depth */ - PathState *state = sd->osl_path_state; - int f = state->transparent_bounce; - return set_attribute_int(f, type, derivatives, val); - } - else if(name == u_path_transmission_depth) { - /* Transmission Ray Depth */ - PathState *state = sd->osl_path_state; - int f = state->transmission_bounce; - return set_attribute_int(f, type, derivatives, val); - } - else if(name == u_ndc) { - /* NDC coordinates with special exception for otho */ - OSLThreadData *tdata = kg->osl_tdata; - OSL::ShaderGlobals *globals = &tdata->globals; - float3 ndc[3]; - - if((globals->raytype & PATH_RAY_CAMERA) && sd->object == OBJECT_NONE && kernel_data.cam.type == CAMERA_ORTHOGRAPHIC) { - ndc[0] = camera_world_to_ndc(kg, sd, sd->ray_P); - - if(derivatives) { - ndc[1] = camera_world_to_ndc(kg, sd, sd->ray_P + sd->ray_dP.dx) - ndc[0]; - ndc[2] = camera_world_to_ndc(kg, sd, sd->ray_P + sd->ray_dP.dy) - ndc[0]; - } - } - else { - ndc[0] = camera_world_to_ndc(kg, sd, sd->P); - - if(derivatives) { - ndc[1] = camera_world_to_ndc(kg, sd, sd->P + sd->dP.dx) - ndc[0]; - ndc[2] = camera_world_to_ndc(kg, sd, sd->P + sd->dP.dy) - ndc[0]; - } - } - - return set_attribute_float3(ndc, type, derivatives, val); - } - else - return false; + if (name == u_path_ray_length) { + /* Ray Length */ + float f = sd->ray_length; + return set_attribute_float(f, type, derivatives, val); + } + else if (name == u_path_ray_depth) { + /* Ray Depth */ + PathState *state = sd->osl_path_state; + int f = state->bounce; + return set_attribute_int(f, type, derivatives, val); + } + else if (name == u_path_diffuse_depth) { + /* Diffuse Ray Depth */ + PathState *state = sd->osl_path_state; + int f = state->diffuse_bounce; + return set_attribute_int(f, type, derivatives, val); + } + else if (name == u_path_glossy_depth) { + /* Glossy Ray Depth */ + PathState *state = sd->osl_path_state; + int f = state->glossy_bounce; + return set_attribute_int(f, type, derivatives, val); + } + else if (name == u_path_transmission_depth) { + /* Transmission Ray Depth */ + PathState *state = sd->osl_path_state; + int f = state->transmission_bounce; + return set_attribute_int(f, type, derivatives, val); + } + else if (name == u_path_transparent_depth) { + /* Transparent Ray Depth */ + PathState *state = sd->osl_path_state; + int f = state->transparent_bounce; + return set_attribute_int(f, type, derivatives, val); + } + else if (name == u_path_transmission_depth) { + /* Transmission Ray Depth */ + PathState *state = sd->osl_path_state; + int f = state->transmission_bounce; + return set_attribute_int(f, type, derivatives, val); + } + else if (name == u_ndc) { + /* NDC coordinates with special exception for otho */ + OSLThreadData *tdata = kg->osl_tdata; + OSL::ShaderGlobals *globals = &tdata->globals; + float3 ndc[3]; + + if ((globals->raytype & PATH_RAY_CAMERA) && sd->object == OBJECT_NONE && + kernel_data.cam.type == CAMERA_ORTHOGRAPHIC) { + ndc[0] = camera_world_to_ndc(kg, sd, sd->ray_P); + + if (derivatives) { + ndc[1] = camera_world_to_ndc(kg, sd, sd->ray_P + sd->ray_dP.dx) - ndc[0]; + ndc[2] = camera_world_to_ndc(kg, sd, sd->ray_P + sd->ray_dP.dy) - ndc[0]; + } + } + else { + ndc[0] = camera_world_to_ndc(kg, sd, sd->P); + + if (derivatives) { + ndc[1] = camera_world_to_ndc(kg, sd, sd->P + sd->dP.dx) - ndc[0]; + ndc[2] = camera_world_to_ndc(kg, sd, sd->P + sd->dP.dy) - ndc[0]; + } + } + + return set_attribute_float3(ndc, type, derivatives, val); + } + else + return false; } -bool OSLRenderServices::get_attribute(OSL::ShaderGlobals *sg, bool derivatives, ustring object_name, - TypeDesc type, ustring name, void *val) +bool OSLRenderServices::get_attribute(OSL::ShaderGlobals *sg, + bool derivatives, + ustring object_name, + TypeDesc type, + ustring name, + void *val) { - if(sg == NULL || sg->renderstate == NULL) - return false; + if (sg == NULL || sg->renderstate == NULL) + return false; - ShaderData *sd = (ShaderData *)(sg->renderstate); - return get_attribute(sd, derivatives, object_name, type, name, val); + ShaderData *sd = (ShaderData *)(sg->renderstate); + return get_attribute(sd, derivatives, object_name, type, name, val); } -bool OSLRenderServices::get_attribute(ShaderData *sd, bool derivatives, ustring object_name, - TypeDesc type, ustring name, void *val) +bool OSLRenderServices::get_attribute( + ShaderData *sd, bool derivatives, ustring object_name, TypeDesc type, ustring name, void *val) { - KernelGlobals *kg = sd->osl_globals; - int prim_type = 0; - int object; - - /* lookup of attribute on another object */ - if(object_name != u_empty) { - OSLGlobals::ObjectNameMap::iterator it = kg->osl->object_name_map.find(object_name); - - if(it == kg->osl->object_name_map.end()) - return false; - - object = it->second; - } - else { - object = sd->object; - prim_type = attribute_primitive_type(kg, sd); - - if(object == OBJECT_NONE) - return get_background_attribute(kg, sd, name, type, derivatives, val); - } - - /* find attribute on object */ - object = object*ATTR_PRIM_TYPES + prim_type; - OSLGlobals::AttributeMap& attribute_map = kg->osl->attribute_map[object]; - OSLGlobals::AttributeMap::iterator it = attribute_map.find(name); - - if(it != attribute_map.end()) { - const OSLGlobals::Attribute& attr = it->second; - - if(attr.desc.element != ATTR_ELEMENT_OBJECT) { - /* triangle and vertex attributes */ - if(get_primitive_attribute(kg, sd, attr, type, derivatives, val)) - return true; - else - return get_mesh_attribute(kg, sd, attr, type, derivatives, val); - } - else { - /* object attribute */ - get_object_attribute(attr, derivatives, val); - return true; - } - } - else { - /* not found in attribute, check standard object info */ - bool is_std_object_attribute = get_object_standard_attribute(kg, sd, name, type, derivatives, val); - - if(is_std_object_attribute) - return true; - - return get_background_attribute(kg, sd, name, type, derivatives, val); - } - - return false; + KernelGlobals *kg = sd->osl_globals; + int prim_type = 0; + int object; + + /* lookup of attribute on another object */ + if (object_name != u_empty) { + OSLGlobals::ObjectNameMap::iterator it = kg->osl->object_name_map.find(object_name); + + if (it == kg->osl->object_name_map.end()) + return false; + + object = it->second; + } + else { + object = sd->object; + prim_type = attribute_primitive_type(kg, sd); + + if (object == OBJECT_NONE) + return get_background_attribute(kg, sd, name, type, derivatives, val); + } + + /* find attribute on object */ + object = object * ATTR_PRIM_TYPES + prim_type; + OSLGlobals::AttributeMap &attribute_map = kg->osl->attribute_map[object]; + OSLGlobals::AttributeMap::iterator it = attribute_map.find(name); + + if (it != attribute_map.end()) { + const OSLGlobals::Attribute &attr = it->second; + + if (attr.desc.element != ATTR_ELEMENT_OBJECT) { + /* triangle and vertex attributes */ + if (get_primitive_attribute(kg, sd, attr, type, derivatives, val)) + return true; + else + return get_mesh_attribute(kg, sd, attr, type, derivatives, val); + } + else { + /* object attribute */ + get_object_attribute(attr, derivatives, val); + return true; + } + } + else { + /* not found in attribute, check standard object info */ + bool is_std_object_attribute = get_object_standard_attribute( + kg, sd, name, type, derivatives, val); + + if (is_std_object_attribute) + return true; + + return get_background_attribute(kg, sd, name, type, derivatives, val); + } + + return false; } -bool OSLRenderServices::get_userdata(bool derivatives, ustring name, TypeDesc type, - OSL::ShaderGlobals *sg, void *val) +bool OSLRenderServices::get_userdata( + bool derivatives, ustring name, TypeDesc type, OSL::ShaderGlobals *sg, void *val) { - return false; /* disabled by lockgeom */ + return false; /* disabled by lockgeom */ } TextureSystem::TextureHandle *OSLRenderServices::get_texture_handle(ustring filename) { - if(filename.length() && filename[0] == '@') { - /* Dummy, we don't use texture handles for builtin textures but need - * to tell the OSL runtime optimizer that this is a valid texture. */ - return NULL; - } - else { - return texturesys()->get_texture_handle(filename); - } + if (filename.length() && filename[0] == '@') { + /* Dummy, we don't use texture handles for builtin textures but need + * to tell the OSL runtime optimizer that this is a valid texture. */ + return NULL; + } + else { + return texturesys()->get_texture_handle(filename); + } } bool OSLRenderServices::good(TextureSystem::TextureHandle *texture_handle) { - return texturesys()->good(texture_handle); + return texturesys()->good(texture_handle); } bool OSLRenderServices::texture(ustring filename, @@ -945,157 +976,169 @@ bool OSLRenderServices::texture(ustring filename, TexturePerthread *texture_thread_info, TextureOpt &options, OSL::ShaderGlobals *sg, - float s, float t, - float dsdx, float dtdx, float dsdy, float dtdy, + float s, + float t, + float dsdx, + float dtdx, + float dsdy, + float dtdy, int nchannels, float *result, float *dresultds, float *dresultdt, ustring *errormessage) { - OSL::TextureSystem *ts = osl_ts; - ShaderData *sd = (ShaderData *)(sg->renderstate); - KernelGlobals *kg = sd->osl_globals; + OSL::TextureSystem *ts = osl_ts; + ShaderData *sd = (ShaderData *)(sg->renderstate); + KernelGlobals *kg = sd->osl_globals; - if(texture_thread_info == NULL) { - OSLThreadData *tdata = kg->osl_tdata; - texture_thread_info = tdata->oiio_thread_info; - } + if (texture_thread_info == NULL) { + OSLThreadData *tdata = kg->osl_tdata; + texture_thread_info = tdata->oiio_thread_info; + } #ifdef WITH_PTEX - /* todo: this is just a quick hack, only works with particular files and options */ - if(string_endswith(filename.string(), ".ptx")) { - float2 uv; - int faceid; + /* todo: this is just a quick hack, only works with particular files and options */ + if (string_endswith(filename.string(), ".ptx")) { + float2 uv; + int faceid; - if(!primitive_ptex(kg, sd, &uv, &faceid)) - return false; + if (!primitive_ptex(kg, sd, &uv, &faceid)) + return false; - float u = uv.x; - float v = uv.y; - float dudx = 0.0f; - float dvdx = 0.0f; - float dudy = 0.0f; - float dvdy = 0.0f; + float u = uv.x; + float v = uv.y; + float dudx = 0.0f; + float dvdx = 0.0f; + float dudy = 0.0f; + float dvdy = 0.0f; - Ptex::String error; - PtexPtr<PtexTexture> r(ptex_cache->get(filename.c_str(), error)); + Ptex::String error; + PtexPtr<PtexTexture> r(ptex_cache->get(filename.c_str(), error)); - if(!r) { - //std::cerr << error.c_str() << std::endl; - return false; - } + if (!r) { + //std::cerr << error.c_str() << std::endl; + return false; + } - bool mipmaplerp = false; - float sharpness = 1.0f; - PtexFilter::Options opts(PtexFilter::f_bicubic, mipmaplerp, sharpness); - PtexPtr<PtexFilter> f(PtexFilter::getFilter(r, opts)); + bool mipmaplerp = false; + float sharpness = 1.0f; + PtexFilter::Options opts(PtexFilter::f_bicubic, mipmaplerp, sharpness); + PtexPtr<PtexFilter> f(PtexFilter::getFilter(r, opts)); - f->eval(result, options.firstchannel, nchannels, faceid, u, v, dudx, dvdx, dudy, dvdy); + f->eval(result, options.firstchannel, nchannels, faceid, u, v, dudx, dvdx, dudy, dvdy); - for(int c = r->numChannels(); c < nchannels; c++) - result[c] = result[0]; + for (int c = r->numChannels(); c < nchannels; c++) + result[c] = result[0]; - return true; - } + return true; + } #endif - bool status = false; - - if(filename.length() && filename[0] == '@') { - if(filename == u_at_bevel) { - /* Bevel shader hack. */ - if(nchannels >= 3) { - PathState *state = sd->osl_path_state; - int num_samples = (int)s; - float radius = t; - float3 N = svm_bevel(kg, sd, state, radius, num_samples); - result[0] = N.x; - result[1] = N.y; - result[2] = N.z; - status = true; - } - } - else if(filename == u_at_ao) { - /* AO shader hack. */ - PathState *state = sd->osl_path_state; - int num_samples = (int)s; - float radius = t; - float3 N = make_float3(dsdx, dtdx, dsdy); - int flags = 0; - if((int)dtdy) { - flags |= NODE_AO_INSIDE; - } - if((int)options.sblur) { - flags |= NODE_AO_ONLY_LOCAL; - } - if((int)options.tblur) { - flags |= NODE_AO_GLOBAL_RADIUS; - } - result[0] = svm_ao(kg, sd, N, state, radius, num_samples, flags); - status = true; - } - else if(filename[1] == 'l') { - /* IES light. */ - int slot = atoi(filename.c_str() + 2); - result[0] = kernel_ies_interp(kg, slot, s, t); - status = true; - } - else { - /* Packed texture. */ - int slot = atoi(filename.c_str() + 2); - float4 rgba = kernel_tex_image_interp(kg, slot, s, 1.0f - t); - - result[0] = rgba[0]; - if(nchannels > 1) - result[1] = rgba[1]; - if(nchannels > 2) - result[2] = rgba[2]; - if(nchannels > 3) - result[3] = rgba[3]; - status = true; - } - } - else { - if(texture_handle != NULL) { - status = ts->texture(texture_handle, - texture_thread_info, - options, - s, t, - dsdx, dtdx, - dsdy, dtdy, - nchannels, - result, - dresultds, dresultdt); - } - else { - status = ts->texture(filename, - options, - s, t, - dsdx, dtdx, - dsdy, dtdy, - nchannels, - result, - dresultds, dresultdt); - } - } - - if(!status) { - if(nchannels == 3 || nchannels == 4) { - result[0] = 1.0f; - result[1] = 0.0f; - result[2] = 1.0f; - - if(nchannels == 4) - result[3] = 1.0f; - } - /* This might be slow, but prevents error messages leak and - * other nasty stuff happening. - */ - string err = ts->geterror(); - (void) err; - } - - return status; + bool status = false; + + if (filename.length() && filename[0] == '@') { + if (filename == u_at_bevel) { + /* Bevel shader hack. */ + if (nchannels >= 3) { + PathState *state = sd->osl_path_state; + int num_samples = (int)s; + float radius = t; + float3 N = svm_bevel(kg, sd, state, radius, num_samples); + result[0] = N.x; + result[1] = N.y; + result[2] = N.z; + status = true; + } + } + else if (filename == u_at_ao) { + /* AO shader hack. */ + PathState *state = sd->osl_path_state; + int num_samples = (int)s; + float radius = t; + float3 N = make_float3(dsdx, dtdx, dsdy); + int flags = 0; + if ((int)dtdy) { + flags |= NODE_AO_INSIDE; + } + if ((int)options.sblur) { + flags |= NODE_AO_ONLY_LOCAL; + } + if ((int)options.tblur) { + flags |= NODE_AO_GLOBAL_RADIUS; + } + result[0] = svm_ao(kg, sd, N, state, radius, num_samples, flags); + status = true; + } + else if (filename[1] == 'l') { + /* IES light. */ + int slot = atoi(filename.c_str() + 2); + result[0] = kernel_ies_interp(kg, slot, s, t); + status = true; + } + else { + /* Packed texture. */ + int slot = atoi(filename.c_str() + 2); + float4 rgba = kernel_tex_image_interp(kg, slot, s, 1.0f - t); + + result[0] = rgba[0]; + if (nchannels > 1) + result[1] = rgba[1]; + if (nchannels > 2) + result[2] = rgba[2]; + if (nchannels > 3) + result[3] = rgba[3]; + status = true; + } + } + else { + if (texture_handle != NULL) { + status = ts->texture(texture_handle, + texture_thread_info, + options, + s, + t, + dsdx, + dtdx, + dsdy, + dtdy, + nchannels, + result, + dresultds, + dresultdt); + } + else { + status = ts->texture(filename, + options, + s, + t, + dsdx, + dtdx, + dsdy, + dtdy, + nchannels, + result, + dresultds, + dresultdt); + } + } + + if (!status) { + if (nchannels == 3 || nchannels == 4) { + result[0] = 1.0f; + result[1] = 0.0f; + result[2] = 1.0f; + + if (nchannels == 4) + result[3] = 1.0f; + } + /* This might be slow, but prevents error messages leak and + * other nasty stuff happening. + */ + string err = ts->geterror(); + (void)err; + } + + return status; } bool OSLRenderServices::texture3d(ustring filename, @@ -1114,68 +1157,76 @@ bool OSLRenderServices::texture3d(ustring filename, float *dresultdr, ustring *errormessage) { - OSL::TextureSystem *ts = osl_ts; - ShaderData *sd = (ShaderData *)(sg->renderstate); - KernelGlobals *kg = sd->osl_globals; - - if(texture_thread_info == NULL) { - OSLThreadData *tdata = kg->osl_tdata; - texture_thread_info = tdata->oiio_thread_info; - } - - bool status; - if(filename.length() && filename[0] == '@') { - int slot = atoi(filename.c_str() + 1); - float4 rgba = kernel_tex_image_interp_3d(kg, slot, P.x, P.y, P.z, INTERPOLATION_NONE); - - result[0] = rgba[0]; - if(nchannels > 1) - result[1] = rgba[1]; - if(nchannels > 2) - result[2] = rgba[2]; - if(nchannels > 3) - result[3] = rgba[3]; - status = true; - } - else { - if(texture_handle != NULL) { - status = ts->texture3d(texture_handle, - texture_thread_info, - options, - P, - dPdx, dPdy, dPdz, - nchannels, - result, - dresultds, dresultdt, dresultdr); - } - else { - status = ts->texture3d(filename, - options, - P, - dPdx, dPdy, dPdz, - nchannels, - result, - dresultds, dresultdt, dresultdr); - } - } - - if(!status) { - if(nchannels == 3 || nchannels == 4) { - result[0] = 1.0f; - result[1] = 0.0f; - result[2] = 1.0f; - - if(nchannels == 4) - result[3] = 1.0f; - } - /* This might be slow, but prevents error messages leak and - * other nasty stuff happening. - */ - string err = ts->geterror(); - (void) err; - } - - return status; + OSL::TextureSystem *ts = osl_ts; + ShaderData *sd = (ShaderData *)(sg->renderstate); + KernelGlobals *kg = sd->osl_globals; + + if (texture_thread_info == NULL) { + OSLThreadData *tdata = kg->osl_tdata; + texture_thread_info = tdata->oiio_thread_info; + } + + bool status; + if (filename.length() && filename[0] == '@') { + int slot = atoi(filename.c_str() + 1); + float4 rgba = kernel_tex_image_interp_3d(kg, slot, P.x, P.y, P.z, INTERPOLATION_NONE); + + result[0] = rgba[0]; + if (nchannels > 1) + result[1] = rgba[1]; + if (nchannels > 2) + result[2] = rgba[2]; + if (nchannels > 3) + result[3] = rgba[3]; + status = true; + } + else { + if (texture_handle != NULL) { + status = ts->texture3d(texture_handle, + texture_thread_info, + options, + P, + dPdx, + dPdy, + dPdz, + nchannels, + result, + dresultds, + dresultdt, + dresultdr); + } + else { + status = ts->texture3d(filename, + options, + P, + dPdx, + dPdy, + dPdz, + nchannels, + result, + dresultds, + dresultdt, + dresultdr); + } + } + + if (!status) { + if (nchannels == 3 || nchannels == 4) { + result[0] = 1.0f; + result[1] = 0.0f; + result[2] = 1.0f; + + if (nchannels == 4) + result[3] = 1.0f; + } + /* This might be slow, but prevents error messages leak and + * other nasty stuff happening. + */ + string err = ts->geterror(); + (void)err; + } + + return status; } bool OSLRenderServices::environment(ustring filename, @@ -1192,35 +1243,34 @@ bool OSLRenderServices::environment(ustring filename, float *dresultdt, ustring *errormessage) { - OSL::TextureSystem *ts = osl_ts; - - if (thread_info == NULL) { - ShaderData *sd = (ShaderData *)(sg->renderstate); - KernelGlobals *kg = sd->osl_globals; - OSLThreadData *tdata = kg->osl_tdata; - thread_info = tdata->oiio_thread_info; - } - - if (th == NULL) { - th = ts->get_texture_handle(filename, thread_info); - } - - bool status = ts->environment(th, thread_info, - options, R, dRdx, dRdy, - nchannels, result, dresultds, dresultdt); - - if(!status) { - if(nchannels == 3 || nchannels == 4) { - result[0] = 1.0f; - result[1] = 0.0f; - result[2] = 1.0f; - - if(nchannels == 4) - result[3] = 1.0f; - } - } - - return status; + OSL::TextureSystem *ts = osl_ts; + + if (thread_info == NULL) { + ShaderData *sd = (ShaderData *)(sg->renderstate); + KernelGlobals *kg = sd->osl_globals; + OSLThreadData *tdata = kg->osl_tdata; + thread_info = tdata->oiio_thread_info; + } + + if (th == NULL) { + th = ts->get_texture_handle(filename, thread_info); + } + + bool status = ts->environment( + th, thread_info, options, R, dRdx, dRdy, nchannels, result, dresultds, dresultdt); + + if (!status) { + if (nchannels == 3 || nchannels == 4) { + result[0] = 1.0f; + result[1] = 0.0f; + result[2] = 1.0f; + + if (nchannels == 4) + result[3] = 1.0f; + } + } + + return status; } bool OSLRenderServices::get_texture_info(OSL::ShaderGlobals *sg, @@ -1231,138 +1281,158 @@ bool OSLRenderServices::get_texture_info(OSL::ShaderGlobals *sg, TypeDesc datatype, void *data) { - OSL::TextureSystem *ts = osl_ts; - if(filename.length() && filename[0] == '@') { - /* Special builtin textures. */ - return false; - } - else { - return ts->get_texture_info(filename, subimage, dataname, datatype, data); - } + OSL::TextureSystem *ts = osl_ts; + if (filename.length() && filename[0] == '@') { + /* Special builtin textures. */ + return false; + } + else { + return ts->get_texture_info(filename, subimage, dataname, datatype, data); + } } -int OSLRenderServices::pointcloud_search(OSL::ShaderGlobals *sg, ustring filename, const OSL::Vec3 ¢er, - float radius, int max_points, bool sort, - size_t *out_indices, float *out_distances, int derivs_offset) +int OSLRenderServices::pointcloud_search(OSL::ShaderGlobals *sg, + ustring filename, + const OSL::Vec3 ¢er, + float radius, + int max_points, + bool sort, + size_t *out_indices, + float *out_distances, + int derivs_offset) { - return 0; + return 0; } -int OSLRenderServices::pointcloud_get(OSL::ShaderGlobals *sg, ustring filename, size_t *indices, int count, - ustring attr_name, TypeDesc attr_type, void *out_data) +int OSLRenderServices::pointcloud_get(OSL::ShaderGlobals *sg, + ustring filename, + size_t *indices, + int count, + ustring attr_name, + TypeDesc attr_type, + void *out_data) { - return 0; + return 0; } bool OSLRenderServices::pointcloud_write(OSL::ShaderGlobals *sg, - ustring filename, const OSL::Vec3 &pos, - int nattribs, const ustring *names, + ustring filename, + const OSL::Vec3 &pos, + int nattribs, + const ustring *names, const TypeDesc *types, const void **data) { - return false; + return false; } -bool OSLRenderServices::trace(TraceOpt &options, OSL::ShaderGlobals *sg, - const OSL::Vec3 &P, const OSL::Vec3 &dPdx, - const OSL::Vec3 &dPdy, const OSL::Vec3 &R, - const OSL::Vec3 &dRdx, const OSL::Vec3 &dRdy) +bool OSLRenderServices::trace(TraceOpt &options, + OSL::ShaderGlobals *sg, + const OSL::Vec3 &P, + const OSL::Vec3 &dPdx, + const OSL::Vec3 &dPdy, + const OSL::Vec3 &R, + const OSL::Vec3 &dRdx, + const OSL::Vec3 &dRdy) { - /* todo: options.shader support, maybe options.traceset */ - ShaderData *sd = (ShaderData *)(sg->renderstate); - - /* setup ray */ - Ray ray; - - ray.P = TO_FLOAT3(P); - ray.D = TO_FLOAT3(R); - ray.t = (options.maxdist == 1.0e30f)? FLT_MAX: options.maxdist - options.mindist; - ray.time = sd->time; - - if(options.mindist == 0.0f) { - /* avoid self-intersections */ - if(ray.P == sd->P) { - bool transmit = (dot(sd->Ng, ray.D) < 0.0f); - ray.P = ray_offset(sd->P, (transmit)? -sd->Ng: sd->Ng); - } - } - else { - /* offset for minimum distance */ - ray.P += options.mindist*ray.D; - } - - /* ray differentials */ - ray.dP.dx = TO_FLOAT3(dPdx); - ray.dP.dy = TO_FLOAT3(dPdy); - ray.dD.dx = TO_FLOAT3(dRdx); - ray.dD.dy = TO_FLOAT3(dRdy); - - /* allocate trace data */ - OSLTraceData *tracedata = (OSLTraceData*)sg->tracedata; - tracedata->ray = ray; - tracedata->setup = false; - tracedata->init = true; - tracedata->sd.osl_globals = sd->osl_globals; - - /* Raytrace, leaving out shadow opaque to avoid early exit. */ - uint visibility = PATH_RAY_ALL_VISIBILITY - PATH_RAY_SHADOW_OPAQUE; - return scene_intersect(sd->osl_globals, ray, visibility, &tracedata->isect, NULL, 0.0f, 0.0f); + /* todo: options.shader support, maybe options.traceset */ + ShaderData *sd = (ShaderData *)(sg->renderstate); + + /* setup ray */ + Ray ray; + + ray.P = TO_FLOAT3(P); + ray.D = TO_FLOAT3(R); + ray.t = (options.maxdist == 1.0e30f) ? FLT_MAX : options.maxdist - options.mindist; + ray.time = sd->time; + + if (options.mindist == 0.0f) { + /* avoid self-intersections */ + if (ray.P == sd->P) { + bool transmit = (dot(sd->Ng, ray.D) < 0.0f); + ray.P = ray_offset(sd->P, (transmit) ? -sd->Ng : sd->Ng); + } + } + else { + /* offset for minimum distance */ + ray.P += options.mindist * ray.D; + } + + /* ray differentials */ + ray.dP.dx = TO_FLOAT3(dPdx); + ray.dP.dy = TO_FLOAT3(dPdy); + ray.dD.dx = TO_FLOAT3(dRdx); + ray.dD.dy = TO_FLOAT3(dRdy); + + /* allocate trace data */ + OSLTraceData *tracedata = (OSLTraceData *)sg->tracedata; + tracedata->ray = ray; + tracedata->setup = false; + tracedata->init = true; + tracedata->sd.osl_globals = sd->osl_globals; + + /* Raytrace, leaving out shadow opaque to avoid early exit. */ + uint visibility = PATH_RAY_ALL_VISIBILITY - PATH_RAY_SHADOW_OPAQUE; + return scene_intersect(sd->osl_globals, ray, visibility, &tracedata->isect, NULL, 0.0f, 0.0f); } - -bool OSLRenderServices::getmessage(OSL::ShaderGlobals *sg, ustring source, ustring name, - TypeDesc type, void *val, bool derivatives) +bool OSLRenderServices::getmessage(OSL::ShaderGlobals *sg, + ustring source, + ustring name, + TypeDesc type, + void *val, + bool derivatives) { - OSLTraceData *tracedata = (OSLTraceData*)sg->tracedata; - - if(source == u_trace && tracedata->init) { - if(name == u_hit) { - return set_attribute_int((tracedata->isect.prim != PRIM_NONE), type, derivatives, val); - } - else if(tracedata->isect.prim != PRIM_NONE) { - if(name == u_hitdist) { - float f[3] = {tracedata->isect.t, 0.0f, 0.0f}; - return set_attribute_float(f, type, derivatives, val); - } - else { - ShaderData *sd = &tracedata->sd; - KernelGlobals *kg = sd->osl_globals; - - if(!tracedata->setup) { - /* lazy shader data setup */ - shader_setup_from_ray(kg, sd, &tracedata->isect, &tracedata->ray); - tracedata->setup = true; - } - - if(name == u_N) { - return set_attribute_float3(sd->N, type, derivatives, val); - } - else if(name == u_Ng) { - return set_attribute_float3(sd->Ng, type, derivatives, val); - } - else if(name == u_P) { - float3 f[3] = {sd->P, sd->dP.dx, sd->dP.dy}; - return set_attribute_float3(f, type, derivatives, val); - } - else if(name == u_I) { - float3 f[3] = {sd->I, sd->dI.dx, sd->dI.dy}; - return set_attribute_float3(f, type, derivatives, val); - } - else if(name == u_u) { - float f[3] = {sd->u, sd->du.dx, sd->du.dy}; - return set_attribute_float(f, type, derivatives, val); - } - else if(name == u_v) { - float f[3] = {sd->v, sd->dv.dx, sd->dv.dy}; - return set_attribute_float(f, type, derivatives, val); - } - - return get_attribute(sd, derivatives, u_empty, type, name, val); - } - } - } - - return false; + OSLTraceData *tracedata = (OSLTraceData *)sg->tracedata; + + if (source == u_trace && tracedata->init) { + if (name == u_hit) { + return set_attribute_int((tracedata->isect.prim != PRIM_NONE), type, derivatives, val); + } + else if (tracedata->isect.prim != PRIM_NONE) { + if (name == u_hitdist) { + float f[3] = {tracedata->isect.t, 0.0f, 0.0f}; + return set_attribute_float(f, type, derivatives, val); + } + else { + ShaderData *sd = &tracedata->sd; + KernelGlobals *kg = sd->osl_globals; + + if (!tracedata->setup) { + /* lazy shader data setup */ + shader_setup_from_ray(kg, sd, &tracedata->isect, &tracedata->ray); + tracedata->setup = true; + } + + if (name == u_N) { + return set_attribute_float3(sd->N, type, derivatives, val); + } + else if (name == u_Ng) { + return set_attribute_float3(sd->Ng, type, derivatives, val); + } + else if (name == u_P) { + float3 f[3] = {sd->P, sd->dP.dx, sd->dP.dy}; + return set_attribute_float3(f, type, derivatives, val); + } + else if (name == u_I) { + float3 f[3] = {sd->I, sd->dI.dx, sd->dI.dy}; + return set_attribute_float3(f, type, derivatives, val); + } + else if (name == u_u) { + float f[3] = {sd->u, sd->du.dx, sd->du.dy}; + return set_attribute_float(f, type, derivatives, val); + } + else if (name == u_v) { + float f[3] = {sd->v, sd->dv.dx, sd->dv.dy}; + return set_attribute_float(f, type, derivatives, val); + } + + return get_attribute(sd, derivatives, u_empty, type, name, val); + } + } + } + + return false; } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/osl/osl_services.h b/intern/cycles/kernel/osl/osl_services.h index 3990a22aefd..2fad5833fc9 100644 --- a/intern/cycles/kernel/osl/osl_services.h +++ b/intern/cycles/kernel/osl/osl_services.h @@ -40,177 +40,229 @@ class Shader; struct ShaderData; struct float3; struct KernelGlobals; -class OSLRenderServices : public OSL::RendererServices -{ -public: - OSLRenderServices(); - ~OSLRenderServices(); - - void thread_init(KernelGlobals *kernel_globals, OSL::TextureSystem *ts); - - bool get_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, OSL::TransformationPtr xform, float time) override; - bool get_inverse_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, OSL::TransformationPtr xform, float time) override; - - bool get_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, ustring from, float time) override; - bool get_inverse_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, ustring to, float time) override; - - bool get_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, OSL::TransformationPtr xform) override; - bool get_inverse_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, OSL::TransformationPtr xform) override; - - bool get_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, ustring from) override; - bool get_inverse_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, ustring from) override; - - bool get_array_attribute(OSL::ShaderGlobals *sg, bool derivatives, - ustring object, TypeDesc type, ustring name, - int index, void *val) override; - bool get_attribute(OSL::ShaderGlobals *sg, bool derivatives, ustring object, - TypeDesc type, ustring name, void *val) override; - bool get_attribute(ShaderData *sd, bool derivatives, ustring object_name, - TypeDesc type, ustring name, void *val); - - bool get_userdata(bool derivatives, ustring name, TypeDesc type, - OSL::ShaderGlobals *sg, void *val) override; - - int pointcloud_search(OSL::ShaderGlobals *sg, ustring filename, const OSL::Vec3 ¢er, - float radius, int max_points, bool sort, size_t *out_indices, - float *out_distances, int derivs_offset) override; - - int pointcloud_get(OSL::ShaderGlobals *sg, ustring filename, size_t *indices, int count, - ustring attr_name, TypeDesc attr_type, void *out_data) override; - - bool pointcloud_write(OSL::ShaderGlobals *sg, - ustring filename, const OSL::Vec3 &pos, - int nattribs, const ustring *names, - const TypeDesc *types, - const void **data) override; - - bool trace(TraceOpt &options, OSL::ShaderGlobals *sg, - const OSL::Vec3 &P, const OSL::Vec3 &dPdx, - const OSL::Vec3 &dPdy, const OSL::Vec3 &R, - const OSL::Vec3 &dRdx, const OSL::Vec3 &dRdy) override; - - bool getmessage(OSL::ShaderGlobals *sg, ustring source, ustring name, - TypeDesc type, void *val, bool derivatives) override; - - TextureSystem::TextureHandle *get_texture_handle(ustring filename) override; - - bool good(TextureSystem::TextureHandle *texture_handle) override; - - bool texture(ustring filename, - TextureSystem::TextureHandle *texture_handle, - TexturePerthread *texture_thread_info, - TextureOpt &options, - OSL::ShaderGlobals *sg, - float s, float t, - float dsdx, float dtdx, float dsdy, float dtdy, - int nchannels, - float *result, - float *dresultds, - float *dresultdt, - ustring *errormessage) override; - - bool texture3d(ustring filename, - TextureHandle *texture_handle, - TexturePerthread *texture_thread_info, - TextureOpt &options, - OSL::ShaderGlobals *sg, - const OSL::Vec3 &P, - const OSL::Vec3 &dPdx, - const OSL::Vec3 &dPdy, - const OSL::Vec3 &dPdz, - int nchannels, - float *result, - float *dresultds, - float *dresultdt, - float *dresultdr, - ustring *errormessage) override; - - bool environment(ustring filename, - TextureHandle *texture_handle, - TexturePerthread *texture_thread_info, - TextureOpt &options, - OSL::ShaderGlobals *sg, - const OSL::Vec3 &R, - const OSL::Vec3 &dRdx, - const OSL::Vec3 &dRdy, - int nchannels, - float *result, - float *dresultds, - float *dresultdt, - ustring *errormessage) override; - - bool get_texture_info(OSL::ShaderGlobals *sg, - ustring filename, - TextureHandle *texture_handle, - int subimage, - ustring dataname, - TypeDesc datatype, - void *data) override; - - static bool get_background_attribute(KernelGlobals *kg, ShaderData *sd, ustring name, - TypeDesc type, bool derivatives, void *val); - static bool get_object_standard_attribute(KernelGlobals *kg, ShaderData *sd, ustring name, - TypeDesc type, bool derivatives, void *val); - - static ustring u_distance; - static ustring u_index; - static ustring u_world; - static ustring u_camera; - static ustring u_screen; - static ustring u_raster; - static ustring u_ndc; - static ustring u_object_location; - static ustring u_object_index; - static ustring u_geom_dupli_generated; - static ustring u_geom_dupli_uv; - static ustring u_material_index; - static ustring u_object_random; - static ustring u_particle_index; - static ustring u_particle_random; - static ustring u_particle_age; - static ustring u_particle_lifetime; - static ustring u_particle_location; - static ustring u_particle_rotation; - static ustring u_particle_size; - static ustring u_particle_velocity; - static ustring u_particle_angular_velocity; - static ustring u_geom_numpolyvertices; - static ustring u_geom_trianglevertices; - static ustring u_geom_polyvertices; - static ustring u_geom_name; - static ustring u_geom_undisplaced; - static ustring u_is_smooth; - static ustring u_is_curve; - static ustring u_curve_thickness; - static ustring u_curve_tangent_normal; - static ustring u_curve_random; - static ustring u_path_ray_length; - static ustring u_path_ray_depth; - static ustring u_path_diffuse_depth; - static ustring u_path_glossy_depth; - static ustring u_path_transparent_depth; - static ustring u_path_transmission_depth; - static ustring u_trace; - static ustring u_hit; - static ustring u_hitdist; - static ustring u_N; - static ustring u_Ng; - static ustring u_P; - static ustring u_I; - static ustring u_u; - static ustring u_v; - static ustring u_empty; - static ustring u_at_bevel; - static ustring u_at_ao; - -private: - KernelGlobals *kernel_globals; - OSL::TextureSystem *osl_ts; +class OSLRenderServices : public OSL::RendererServices { + public: + OSLRenderServices(); + ~OSLRenderServices(); + + void thread_init(KernelGlobals *kernel_globals, OSL::TextureSystem *ts); + + bool get_matrix(OSL::ShaderGlobals *sg, + OSL::Matrix44 &result, + OSL::TransformationPtr xform, + float time) override; + bool get_inverse_matrix(OSL::ShaderGlobals *sg, + OSL::Matrix44 &result, + OSL::TransformationPtr xform, + float time) override; + + bool get_matrix(OSL::ShaderGlobals *sg, + OSL::Matrix44 &result, + ustring from, + float time) override; + bool get_inverse_matrix(OSL::ShaderGlobals *sg, + OSL::Matrix44 &result, + ustring to, + float time) override; + + bool get_matrix(OSL::ShaderGlobals *sg, + OSL::Matrix44 &result, + OSL::TransformationPtr xform) override; + bool get_inverse_matrix(OSL::ShaderGlobals *sg, + OSL::Matrix44 &result, + OSL::TransformationPtr xform) override; + + bool get_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, ustring from) override; + bool get_inverse_matrix(OSL::ShaderGlobals *sg, OSL::Matrix44 &result, ustring from) override; + + bool get_array_attribute(OSL::ShaderGlobals *sg, + bool derivatives, + ustring object, + TypeDesc type, + ustring name, + int index, + void *val) override; + bool get_attribute(OSL::ShaderGlobals *sg, + bool derivatives, + ustring object, + TypeDesc type, + ustring name, + void *val) override; + bool get_attribute(ShaderData *sd, + bool derivatives, + ustring object_name, + TypeDesc type, + ustring name, + void *val); + + bool get_userdata( + bool derivatives, ustring name, TypeDesc type, OSL::ShaderGlobals *sg, void *val) override; + + int pointcloud_search(OSL::ShaderGlobals *sg, + ustring filename, + const OSL::Vec3 ¢er, + float radius, + int max_points, + bool sort, + size_t *out_indices, + float *out_distances, + int derivs_offset) override; + + int pointcloud_get(OSL::ShaderGlobals *sg, + ustring filename, + size_t *indices, + int count, + ustring attr_name, + TypeDesc attr_type, + void *out_data) override; + + bool pointcloud_write(OSL::ShaderGlobals *sg, + ustring filename, + const OSL::Vec3 &pos, + int nattribs, + const ustring *names, + const TypeDesc *types, + const void **data) override; + + bool trace(TraceOpt &options, + OSL::ShaderGlobals *sg, + const OSL::Vec3 &P, + const OSL::Vec3 &dPdx, + const OSL::Vec3 &dPdy, + const OSL::Vec3 &R, + const OSL::Vec3 &dRdx, + const OSL::Vec3 &dRdy) override; + + bool getmessage(OSL::ShaderGlobals *sg, + ustring source, + ustring name, + TypeDesc type, + void *val, + bool derivatives) override; + + TextureSystem::TextureHandle *get_texture_handle(ustring filename) override; + + bool good(TextureSystem::TextureHandle *texture_handle) override; + + bool texture(ustring filename, + TextureSystem::TextureHandle *texture_handle, + TexturePerthread *texture_thread_info, + TextureOpt &options, + OSL::ShaderGlobals *sg, + float s, + float t, + float dsdx, + float dtdx, + float dsdy, + float dtdy, + int nchannels, + float *result, + float *dresultds, + float *dresultdt, + ustring *errormessage) override; + + bool texture3d(ustring filename, + TextureHandle *texture_handle, + TexturePerthread *texture_thread_info, + TextureOpt &options, + OSL::ShaderGlobals *sg, + const OSL::Vec3 &P, + const OSL::Vec3 &dPdx, + const OSL::Vec3 &dPdy, + const OSL::Vec3 &dPdz, + int nchannels, + float *result, + float *dresultds, + float *dresultdt, + float *dresultdr, + ustring *errormessage) override; + + bool environment(ustring filename, + TextureHandle *texture_handle, + TexturePerthread *texture_thread_info, + TextureOpt &options, + OSL::ShaderGlobals *sg, + const OSL::Vec3 &R, + const OSL::Vec3 &dRdx, + const OSL::Vec3 &dRdy, + int nchannels, + float *result, + float *dresultds, + float *dresultdt, + ustring *errormessage) override; + + bool get_texture_info(OSL::ShaderGlobals *sg, + ustring filename, + TextureHandle *texture_handle, + int subimage, + ustring dataname, + TypeDesc datatype, + void *data) override; + + static bool get_background_attribute( + KernelGlobals *kg, ShaderData *sd, ustring name, TypeDesc type, bool derivatives, void *val); + static bool get_object_standard_attribute( + KernelGlobals *kg, ShaderData *sd, ustring name, TypeDesc type, bool derivatives, void *val); + + static ustring u_distance; + static ustring u_index; + static ustring u_world; + static ustring u_camera; + static ustring u_screen; + static ustring u_raster; + static ustring u_ndc; + static ustring u_object_location; + static ustring u_object_index; + static ustring u_geom_dupli_generated; + static ustring u_geom_dupli_uv; + static ustring u_material_index; + static ustring u_object_random; + static ustring u_particle_index; + static ustring u_particle_random; + static ustring u_particle_age; + static ustring u_particle_lifetime; + static ustring u_particle_location; + static ustring u_particle_rotation; + static ustring u_particle_size; + static ustring u_particle_velocity; + static ustring u_particle_angular_velocity; + static ustring u_geom_numpolyvertices; + static ustring u_geom_trianglevertices; + static ustring u_geom_polyvertices; + static ustring u_geom_name; + static ustring u_geom_undisplaced; + static ustring u_is_smooth; + static ustring u_is_curve; + static ustring u_curve_thickness; + static ustring u_curve_tangent_normal; + static ustring u_curve_random; + static ustring u_path_ray_length; + static ustring u_path_ray_depth; + static ustring u_path_diffuse_depth; + static ustring u_path_glossy_depth; + static ustring u_path_transparent_depth; + static ustring u_path_transmission_depth; + static ustring u_trace; + static ustring u_hit; + static ustring u_hitdist; + static ustring u_N; + static ustring u_Ng; + static ustring u_P; + static ustring u_I; + static ustring u_u; + static ustring u_v; + static ustring u_empty; + static ustring u_at_bevel; + static ustring u_at_ao; + + private: + KernelGlobals *kernel_globals; + OSL::TextureSystem *osl_ts; #ifdef WITH_PTEX - PtexCache *ptex_cache; + PtexCache *ptex_cache; #endif }; CCL_NAMESPACE_END -#endif /* __OSL_SERVICES_H__ */ +#endif /* __OSL_SERVICES_H__ */ diff --git a/intern/cycles/kernel/osl/osl_shader.cpp b/intern/cycles/kernel/osl/osl_shader.cpp index a89bb3fd1a3..3d9c579c9ff 100644 --- a/intern/cycles/kernel/osl/osl_shader.cpp +++ b/intern/cycles/kernel/osl/osl_shader.cpp @@ -33,103 +33,104 @@ #include "render/attribute.h" - CCL_NAMESPACE_BEGIN /* Threads */ -void OSLShader::thread_init(KernelGlobals *kg, KernelGlobals *kernel_globals, OSLGlobals *osl_globals) +void OSLShader::thread_init(KernelGlobals *kg, + KernelGlobals *kernel_globals, + OSLGlobals *osl_globals) { - /* no osl used? */ - if(!osl_globals->use) { - kg->osl = NULL; - return; - } + /* no osl used? */ + if (!osl_globals->use) { + kg->osl = NULL; + return; + } - /* per thread kernel data init*/ - kg->osl = osl_globals; - kg->osl->services->thread_init(kernel_globals, osl_globals->ts); + /* per thread kernel data init*/ + kg->osl = osl_globals; + kg->osl->services->thread_init(kernel_globals, osl_globals->ts); - OSL::ShadingSystem *ss = kg->osl->ss; - OSLThreadData *tdata = new OSLThreadData(); + OSL::ShadingSystem *ss = kg->osl->ss; + OSLThreadData *tdata = new OSLThreadData(); - memset((void *)&tdata->globals, 0, sizeof(OSL::ShaderGlobals)); - tdata->globals.tracedata = &tdata->tracedata; - tdata->globals.flipHandedness = false; - tdata->osl_thread_info = ss->create_thread_info(); - tdata->context = ss->get_context(tdata->osl_thread_info); + memset((void *)&tdata->globals, 0, sizeof(OSL::ShaderGlobals)); + tdata->globals.tracedata = &tdata->tracedata; + tdata->globals.flipHandedness = false; + tdata->osl_thread_info = ss->create_thread_info(); + tdata->context = ss->get_context(tdata->osl_thread_info); - tdata->oiio_thread_info = osl_globals->ts->get_perthread_info(); + tdata->oiio_thread_info = osl_globals->ts->get_perthread_info(); - kg->osl_ss = (OSLShadingSystem*)ss; - kg->osl_tdata = tdata; + kg->osl_ss = (OSLShadingSystem *)ss; + kg->osl_tdata = tdata; } void OSLShader::thread_free(KernelGlobals *kg) { - if(!kg->osl) - return; + if (!kg->osl) + return; - OSL::ShadingSystem *ss = (OSL::ShadingSystem*)kg->osl_ss; - OSLThreadData *tdata = kg->osl_tdata; - ss->release_context(tdata->context); + OSL::ShadingSystem *ss = (OSL::ShadingSystem *)kg->osl_ss; + OSLThreadData *tdata = kg->osl_tdata; + ss->release_context(tdata->context); - ss->destroy_thread_info(tdata->osl_thread_info); + ss->destroy_thread_info(tdata->osl_thread_info); - delete tdata; + delete tdata; - kg->osl = NULL; - kg->osl_ss = NULL; - kg->osl_tdata = NULL; + kg->osl = NULL; + kg->osl_ss = NULL; + kg->osl_tdata = NULL; } /* Globals */ -static void shaderdata_to_shaderglobals(KernelGlobals *kg, ShaderData *sd, PathState *state, - int path_flag, OSLThreadData *tdata) +static void shaderdata_to_shaderglobals( + KernelGlobals *kg, ShaderData *sd, PathState *state, int path_flag, OSLThreadData *tdata) { - OSL::ShaderGlobals *globals = &tdata->globals; - - /* copy from shader data to shader globals */ - globals->P = TO_VEC3(sd->P); - globals->dPdx = TO_VEC3(sd->dP.dx); - globals->dPdy = TO_VEC3(sd->dP.dy); - globals->I = TO_VEC3(sd->I); - globals->dIdx = TO_VEC3(sd->dI.dx); - globals->dIdy = TO_VEC3(sd->dI.dy); - globals->N = TO_VEC3(sd->N); - globals->Ng = TO_VEC3(sd->Ng); - globals->u = sd->u; - globals->dudx = sd->du.dx; - globals->dudy = sd->du.dy; - globals->v = sd->v; - globals->dvdx = sd->dv.dx; - globals->dvdy = sd->dv.dy; - globals->dPdu = TO_VEC3(sd->dPdu); - globals->dPdv = TO_VEC3(sd->dPdv); - globals->surfacearea = (sd->object == OBJECT_NONE) ? 1.0f : object_surface_area(kg, sd->object); - globals->time = sd->time; - - /* booleans */ - globals->raytype = path_flag; - globals->backfacing = (sd->flag & SD_BACKFACING); - - /* shader data to be used in services callbacks */ - globals->renderstate = sd; - - /* hacky, we leave it to services to fetch actual object matrix */ - globals->shader2common = sd; - globals->object2common = sd; - - /* must be set to NULL before execute */ - globals->Ci = NULL; - - /* clear trace data */ - tdata->tracedata.init = false; - - /* used by renderservices */ - sd->osl_globals = kg; - sd->osl_path_state = state; + OSL::ShaderGlobals *globals = &tdata->globals; + + /* copy from shader data to shader globals */ + globals->P = TO_VEC3(sd->P); + globals->dPdx = TO_VEC3(sd->dP.dx); + globals->dPdy = TO_VEC3(sd->dP.dy); + globals->I = TO_VEC3(sd->I); + globals->dIdx = TO_VEC3(sd->dI.dx); + globals->dIdy = TO_VEC3(sd->dI.dy); + globals->N = TO_VEC3(sd->N); + globals->Ng = TO_VEC3(sd->Ng); + globals->u = sd->u; + globals->dudx = sd->du.dx; + globals->dudy = sd->du.dy; + globals->v = sd->v; + globals->dvdx = sd->dv.dx; + globals->dvdy = sd->dv.dy; + globals->dPdu = TO_VEC3(sd->dPdu); + globals->dPdv = TO_VEC3(sd->dPdv); + globals->surfacearea = (sd->object == OBJECT_NONE) ? 1.0f : object_surface_area(kg, sd->object); + globals->time = sd->time; + + /* booleans */ + globals->raytype = path_flag; + globals->backfacing = (sd->flag & SD_BACKFACING); + + /* shader data to be used in services callbacks */ + globals->renderstate = sd; + + /* hacky, we leave it to services to fetch actual object matrix */ + globals->shader2common = sd; + globals->object2common = sd; + + /* must be set to NULL before execute */ + globals->Ci = NULL; + + /* clear trace data */ + tdata->tracedata.init = false; + + /* used by renderservices */ + sd->osl_globals = kg; + sd->osl_path_state = state; } /* Surface */ @@ -139,97 +140,101 @@ static void flatten_surface_closure_tree(ShaderData *sd, const OSL::ClosureColor *closure, float3 weight = make_float3(1.0f, 1.0f, 1.0f)) { - /* OSL gives us a closure tree, we flatten it into arrays per - * closure type, for evaluation, sampling, etc later on. */ - - switch(closure->id) { - case OSL::ClosureColor::MUL: { - OSL::ClosureMul *mul = (OSL::ClosureMul *)closure; - flatten_surface_closure_tree(sd, path_flag, mul->closure, TO_FLOAT3(mul->weight) * weight); - break; - } - case OSL::ClosureColor::ADD: { - OSL::ClosureAdd *add = (OSL::ClosureAdd *)closure; - flatten_surface_closure_tree(sd, path_flag, add->closureA, weight); - flatten_surface_closure_tree(sd, path_flag, add->closureB, weight); - break; - } - default: { - OSL::ClosureComponent *comp = (OSL::ClosureComponent *)closure; - CClosurePrimitive *prim = (CClosurePrimitive *)comp->data(); - - if(prim) { + /* OSL gives us a closure tree, we flatten it into arrays per + * closure type, for evaluation, sampling, etc later on. */ + + switch (closure->id) { + case OSL::ClosureColor::MUL: { + OSL::ClosureMul *mul = (OSL::ClosureMul *)closure; + flatten_surface_closure_tree(sd, path_flag, mul->closure, TO_FLOAT3(mul->weight) * weight); + break; + } + case OSL::ClosureColor::ADD: { + OSL::ClosureAdd *add = (OSL::ClosureAdd *)closure; + flatten_surface_closure_tree(sd, path_flag, add->closureA, weight); + flatten_surface_closure_tree(sd, path_flag, add->closureB, weight); + break; + } + default: { + OSL::ClosureComponent *comp = (OSL::ClosureComponent *)closure; + CClosurePrimitive *prim = (CClosurePrimitive *)comp->data(); + + if (prim) { #ifdef OSL_SUPPORTS_WEIGHTED_CLOSURE_COMPONENTS - weight = weight*TO_FLOAT3(comp->w); + weight = weight * TO_FLOAT3(comp->w); #endif - prim->setup(sd, path_flag, weight); - } - break; - } - } + prim->setup(sd, path_flag, weight); + } + break; + } + } } void OSLShader::eval_surface(KernelGlobals *kg, ShaderData *sd, PathState *state, int path_flag) { - /* setup shader globals from shader data */ - OSLThreadData *tdata = kg->osl_tdata; - shaderdata_to_shaderglobals(kg, sd, state, path_flag, tdata); - - /* execute shader for this point */ - OSL::ShadingSystem *ss = (OSL::ShadingSystem*)kg->osl_ss; - OSL::ShaderGlobals *globals = &tdata->globals; - OSL::ShadingContext *octx = tdata->context; - int shader = sd->shader & SHADER_MASK; - - /* automatic bump shader */ - if(kg->osl->bump_state[shader]) { - /* save state */ - float3 P = sd->P; - float3 dPdx = sd->dP.dx; - float3 dPdy = sd->dP.dy; - - /* set state as if undisplaced */ - if(sd->flag & SD_HAS_DISPLACEMENT) { - float data[9]; - bool found = kg->osl->services->get_attribute(sd, true, OSLRenderServices::u_empty, TypeDesc::TypeVector, - OSLRenderServices::u_geom_undisplaced, data); - (void) found; - assert(found); - - memcpy(&sd->P, data, sizeof(float)*3); - memcpy(&sd->dP.dx, data+3, sizeof(float)*3); - memcpy(&sd->dP.dy, data+6, sizeof(float)*3); - - object_position_transform(kg, sd, &sd->P); - object_dir_transform(kg, sd, &sd->dP.dx); - object_dir_transform(kg, sd, &sd->dP.dy); - - globals->P = TO_VEC3(sd->P); - globals->dPdx = TO_VEC3(sd->dP.dx); - globals->dPdy = TO_VEC3(sd->dP.dy); - } - - /* execute bump shader */ - ss->execute(octx, *(kg->osl->bump_state[shader]), *globals); - - /* reset state */ - sd->P = P; - sd->dP.dx = dPdx; - sd->dP.dy = dPdy; - - globals->P = TO_VEC3(P); - globals->dPdx = TO_VEC3(dPdx); - globals->dPdy = TO_VEC3(dPdy); - } - - /* surface shader */ - if(kg->osl->surface_state[shader]) { - ss->execute(octx, *(kg->osl->surface_state[shader]), *globals); - } - - /* flatten closure tree */ - if(globals->Ci) - flatten_surface_closure_tree(sd, path_flag, globals->Ci); + /* setup shader globals from shader data */ + OSLThreadData *tdata = kg->osl_tdata; + shaderdata_to_shaderglobals(kg, sd, state, path_flag, tdata); + + /* execute shader for this point */ + OSL::ShadingSystem *ss = (OSL::ShadingSystem *)kg->osl_ss; + OSL::ShaderGlobals *globals = &tdata->globals; + OSL::ShadingContext *octx = tdata->context; + int shader = sd->shader & SHADER_MASK; + + /* automatic bump shader */ + if (kg->osl->bump_state[shader]) { + /* save state */ + float3 P = sd->P; + float3 dPdx = sd->dP.dx; + float3 dPdy = sd->dP.dy; + + /* set state as if undisplaced */ + if (sd->flag & SD_HAS_DISPLACEMENT) { + float data[9]; + bool found = kg->osl->services->get_attribute(sd, + true, + OSLRenderServices::u_empty, + TypeDesc::TypeVector, + OSLRenderServices::u_geom_undisplaced, + data); + (void)found; + assert(found); + + memcpy(&sd->P, data, sizeof(float) * 3); + memcpy(&sd->dP.dx, data + 3, sizeof(float) * 3); + memcpy(&sd->dP.dy, data + 6, sizeof(float) * 3); + + object_position_transform(kg, sd, &sd->P); + object_dir_transform(kg, sd, &sd->dP.dx); + object_dir_transform(kg, sd, &sd->dP.dy); + + globals->P = TO_VEC3(sd->P); + globals->dPdx = TO_VEC3(sd->dP.dx); + globals->dPdy = TO_VEC3(sd->dP.dy); + } + + /* execute bump shader */ + ss->execute(octx, *(kg->osl->bump_state[shader]), *globals); + + /* reset state */ + sd->P = P; + sd->dP.dx = dPdx; + sd->dP.dy = dPdy; + + globals->P = TO_VEC3(P); + globals->dPdx = TO_VEC3(dPdx); + globals->dPdy = TO_VEC3(dPdy); + } + + /* surface shader */ + if (kg->osl->surface_state[shader]) { + ss->execute(octx, *(kg->osl->surface_state[shader]), *globals); + } + + /* flatten closure tree */ + if (globals->Ci) + flatten_surface_closure_tree(sd, path_flag, globals->Ci); } /* Background */ @@ -238,56 +243,56 @@ static void flatten_background_closure_tree(ShaderData *sd, const OSL::ClosureColor *closure, float3 weight = make_float3(1.0f, 1.0f, 1.0f)) { - /* OSL gives us a closure tree, if we are shading for background there - * is only one supported closure type at the moment, which has no evaluation - * functions, so we just sum the weights */ - - switch(closure->id) { - case OSL::ClosureColor::MUL: { - OSL::ClosureMul *mul = (OSL::ClosureMul *)closure; - flatten_background_closure_tree(sd, mul->closure, weight * TO_FLOAT3(mul->weight)); - break; - } - case OSL::ClosureColor::ADD: { - OSL::ClosureAdd *add = (OSL::ClosureAdd *)closure; - - flatten_background_closure_tree(sd, add->closureA, weight); - flatten_background_closure_tree(sd, add->closureB, weight); - break; - } - default: { - OSL::ClosureComponent *comp = (OSL::ClosureComponent *)closure; - CClosurePrimitive *prim = (CClosurePrimitive *)comp->data(); - - if(prim) { + /* OSL gives us a closure tree, if we are shading for background there + * is only one supported closure type at the moment, which has no evaluation + * functions, so we just sum the weights */ + + switch (closure->id) { + case OSL::ClosureColor::MUL: { + OSL::ClosureMul *mul = (OSL::ClosureMul *)closure; + flatten_background_closure_tree(sd, mul->closure, weight * TO_FLOAT3(mul->weight)); + break; + } + case OSL::ClosureColor::ADD: { + OSL::ClosureAdd *add = (OSL::ClosureAdd *)closure; + + flatten_background_closure_tree(sd, add->closureA, weight); + flatten_background_closure_tree(sd, add->closureB, weight); + break; + } + default: { + OSL::ClosureComponent *comp = (OSL::ClosureComponent *)closure; + CClosurePrimitive *prim = (CClosurePrimitive *)comp->data(); + + if (prim) { #ifdef OSL_SUPPORTS_WEIGHTED_CLOSURE_COMPONENTS - weight = weight*TO_FLOAT3(comp->w); + weight = weight * TO_FLOAT3(comp->w); #endif - prim->setup(sd, 0, weight); - } - break; - } - } + prim->setup(sd, 0, weight); + } + break; + } + } } void OSLShader::eval_background(KernelGlobals *kg, ShaderData *sd, PathState *state, int path_flag) { - /* setup shader globals from shader data */ - OSLThreadData *tdata = kg->osl_tdata; - shaderdata_to_shaderglobals(kg, sd, state, path_flag, tdata); - - /* execute shader for this point */ - OSL::ShadingSystem *ss = (OSL::ShadingSystem*)kg->osl_ss; - OSL::ShaderGlobals *globals = &tdata->globals; - OSL::ShadingContext *octx = tdata->context; - - if(kg->osl->background_state) { - ss->execute(octx, *(kg->osl->background_state), *globals); - } - - /* return background color immediately */ - if(globals->Ci) - flatten_background_closure_tree(sd, globals->Ci); + /* setup shader globals from shader data */ + OSLThreadData *tdata = kg->osl_tdata; + shaderdata_to_shaderglobals(kg, sd, state, path_flag, tdata); + + /* execute shader for this point */ + OSL::ShadingSystem *ss = (OSL::ShadingSystem *)kg->osl_ss; + OSL::ShaderGlobals *globals = &tdata->globals; + OSL::ShadingContext *octx = tdata->context; + + if (kg->osl->background_state) { + ss->execute(octx, *(kg->osl->background_state), *globals); + } + + /* return background color immediately */ + if (globals->Ci) + flatten_background_closure_tree(sd, globals->Ci); } /* Volume */ @@ -296,112 +301,117 @@ static void flatten_volume_closure_tree(ShaderData *sd, const OSL::ClosureColor *closure, float3 weight = make_float3(1.0f, 1.0f, 1.0f)) { - /* OSL gives us a closure tree, we flatten it into arrays per - * closure type, for evaluation, sampling, etc later on. */ - - switch(closure->id) { - case OSL::ClosureColor::MUL: { - OSL::ClosureMul *mul = (OSL::ClosureMul *)closure; - flatten_volume_closure_tree(sd, mul->closure, TO_FLOAT3(mul->weight) * weight); - break; - } - case OSL::ClosureColor::ADD: { - OSL::ClosureAdd *add = (OSL::ClosureAdd *)closure; - flatten_volume_closure_tree(sd, add->closureA, weight); - flatten_volume_closure_tree(sd, add->closureB, weight); - break; - } - default: { - OSL::ClosureComponent *comp = (OSL::ClosureComponent *)closure; - CClosurePrimitive *prim = (CClosurePrimitive *)comp->data(); - - if(prim) { + /* OSL gives us a closure tree, we flatten it into arrays per + * closure type, for evaluation, sampling, etc later on. */ + + switch (closure->id) { + case OSL::ClosureColor::MUL: { + OSL::ClosureMul *mul = (OSL::ClosureMul *)closure; + flatten_volume_closure_tree(sd, mul->closure, TO_FLOAT3(mul->weight) * weight); + break; + } + case OSL::ClosureColor::ADD: { + OSL::ClosureAdd *add = (OSL::ClosureAdd *)closure; + flatten_volume_closure_tree(sd, add->closureA, weight); + flatten_volume_closure_tree(sd, add->closureB, weight); + break; + } + default: { + OSL::ClosureComponent *comp = (OSL::ClosureComponent *)closure; + CClosurePrimitive *prim = (CClosurePrimitive *)comp->data(); + + if (prim) { #ifdef OSL_SUPPORTS_WEIGHTED_CLOSURE_COMPONENTS - weight = weight*TO_FLOAT3(comp->w); + weight = weight * TO_FLOAT3(comp->w); #endif - prim->setup(sd, 0, weight); - } - } - } + prim->setup(sd, 0, weight); + } + } + } } void OSLShader::eval_volume(KernelGlobals *kg, ShaderData *sd, PathState *state, int path_flag) { - /* setup shader globals from shader data */ - OSLThreadData *tdata = kg->osl_tdata; - shaderdata_to_shaderglobals(kg, sd, state, path_flag, tdata); - - /* execute shader */ - OSL::ShadingSystem *ss = (OSL::ShadingSystem*)kg->osl_ss; - OSL::ShaderGlobals *globals = &tdata->globals; - OSL::ShadingContext *octx = tdata->context; - int shader = sd->shader & SHADER_MASK; - - if(kg->osl->volume_state[shader]) { - ss->execute(octx, *(kg->osl->volume_state[shader]), *globals); - } - - /* flatten closure tree */ - if(globals->Ci) - flatten_volume_closure_tree(sd, globals->Ci); + /* setup shader globals from shader data */ + OSLThreadData *tdata = kg->osl_tdata; + shaderdata_to_shaderglobals(kg, sd, state, path_flag, tdata); + + /* execute shader */ + OSL::ShadingSystem *ss = (OSL::ShadingSystem *)kg->osl_ss; + OSL::ShaderGlobals *globals = &tdata->globals; + OSL::ShadingContext *octx = tdata->context; + int shader = sd->shader & SHADER_MASK; + + if (kg->osl->volume_state[shader]) { + ss->execute(octx, *(kg->osl->volume_state[shader]), *globals); + } + + /* flatten closure tree */ + if (globals->Ci) + flatten_volume_closure_tree(sd, globals->Ci); } /* Displacement */ void OSLShader::eval_displacement(KernelGlobals *kg, ShaderData *sd, PathState *state) { - /* setup shader globals from shader data */ - OSLThreadData *tdata = kg->osl_tdata; + /* setup shader globals from shader data */ + OSLThreadData *tdata = kg->osl_tdata; - shaderdata_to_shaderglobals(kg, sd, state, 0, tdata); + shaderdata_to_shaderglobals(kg, sd, state, 0, tdata); - /* execute shader */ - OSL::ShadingSystem *ss = (OSL::ShadingSystem*)kg->osl_ss; - OSL::ShaderGlobals *globals = &tdata->globals; - OSL::ShadingContext *octx = tdata->context; - int shader = sd->shader & SHADER_MASK; + /* execute shader */ + OSL::ShadingSystem *ss = (OSL::ShadingSystem *)kg->osl_ss; + OSL::ShaderGlobals *globals = &tdata->globals; + OSL::ShadingContext *octx = tdata->context; + int shader = sd->shader & SHADER_MASK; - if(kg->osl->displacement_state[shader]) { - ss->execute(octx, *(kg->osl->displacement_state[shader]), *globals); - } + if (kg->osl->displacement_state[shader]) { + ss->execute(octx, *(kg->osl->displacement_state[shader]), *globals); + } - /* get back position */ - sd->P = TO_FLOAT3(globals->P); + /* get back position */ + sd->P = TO_FLOAT3(globals->P); } /* Attributes */ -int OSLShader::find_attribute(KernelGlobals *kg, const ShaderData *sd, uint id, AttributeDescriptor *desc) +int OSLShader::find_attribute(KernelGlobals *kg, + const ShaderData *sd, + uint id, + AttributeDescriptor *desc) { - /* for OSL, a hash map is used to lookup the attribute by name. */ - int object = sd->object*ATTR_PRIM_TYPES; + /* for OSL, a hash map is used to lookup the attribute by name. */ + int object = sd->object * ATTR_PRIM_TYPES; #ifdef __HAIR__ - if(sd->type & PRIMITIVE_ALL_CURVE) object += ATTR_PRIM_CURVE; + if (sd->type & PRIMITIVE_ALL_CURVE) + object += ATTR_PRIM_CURVE; #endif - OSLGlobals::AttributeMap &attr_map = kg->osl->attribute_map[object]; - ustring stdname(std::string("geom:") + std::string(Attribute::standard_name((AttributeStandard)id))); - OSLGlobals::AttributeMap::const_iterator it = attr_map.find(stdname); - - if(it != attr_map.end()) { - const OSLGlobals::Attribute &osl_attr = it->second; - *desc = osl_attr.desc; - - if(sd->prim == PRIM_NONE && (AttributeElement)osl_attr.desc.element != ATTR_ELEMENT_MESH) { - desc->offset = ATTR_STD_NOT_FOUND; - return ATTR_STD_NOT_FOUND; - } - - /* return result */ - if(osl_attr.desc.element == ATTR_ELEMENT_NONE) { - desc->offset = ATTR_STD_NOT_FOUND; - } - return desc->offset; - } - else { - desc->offset = ATTR_STD_NOT_FOUND; - return (int)ATTR_STD_NOT_FOUND; - } + OSLGlobals::AttributeMap &attr_map = kg->osl->attribute_map[object]; + ustring stdname(std::string("geom:") + + std::string(Attribute::standard_name((AttributeStandard)id))); + OSLGlobals::AttributeMap::const_iterator it = attr_map.find(stdname); + + if (it != attr_map.end()) { + const OSLGlobals::Attribute &osl_attr = it->second; + *desc = osl_attr.desc; + + if (sd->prim == PRIM_NONE && (AttributeElement)osl_attr.desc.element != ATTR_ELEMENT_MESH) { + desc->offset = ATTR_STD_NOT_FOUND; + return ATTR_STD_NOT_FOUND; + } + + /* return result */ + if (osl_attr.desc.element == ATTR_ELEMENT_NONE) { + desc->offset = ATTR_STD_NOT_FOUND; + } + return desc->offset; + } + else { + desc->offset = ATTR_STD_NOT_FOUND; + return (int)ATTR_STD_NOT_FOUND; + } } CCL_NAMESPACE_END diff --git a/intern/cycles/kernel/osl/osl_shader.h b/intern/cycles/kernel/osl/osl_shader.h index 9824f966a44..a4fa24d0a90 100644 --- a/intern/cycles/kernel/osl/osl_shader.h +++ b/intern/cycles/kernel/osl/osl_shader.h @@ -29,7 +29,7 @@ * This means no thread state must be passed along in the kernel itself. */ -#include "kernel/kernel_types.h" +# include "kernel/kernel_types.h" CCL_NAMESPACE_BEGIN @@ -44,26 +44,31 @@ struct OSLGlobals; struct OSLShadingSystem; class OSLShader { -public: - /* init */ - static void register_closures(OSLShadingSystem *ss); + public: + /* init */ + static void register_closures(OSLShadingSystem *ss); - /* per thread data */ - static void thread_init(KernelGlobals *kg, KernelGlobals *kernel_globals, OSLGlobals *osl_globals); - static void thread_free(KernelGlobals *kg); + /* per thread data */ + static void thread_init(KernelGlobals *kg, + KernelGlobals *kernel_globals, + OSLGlobals *osl_globals); + static void thread_free(KernelGlobals *kg); - /* eval */ - static void eval_surface(KernelGlobals *kg, ShaderData *sd, PathState *state, int path_flag); - static void eval_background(KernelGlobals *kg, ShaderData *sd, PathState *state, int path_flag); - static void eval_volume(KernelGlobals *kg, ShaderData *sd, PathState *state, int path_flag); - static void eval_displacement(KernelGlobals *kg, ShaderData *sd, PathState *state); + /* eval */ + static void eval_surface(KernelGlobals *kg, ShaderData *sd, PathState *state, int path_flag); + static void eval_background(KernelGlobals *kg, ShaderData *sd, PathState *state, int path_flag); + static void eval_volume(KernelGlobals *kg, ShaderData *sd, PathState *state, int path_flag); + static void eval_displacement(KernelGlobals *kg, ShaderData *sd, PathState *state); - /* attributes */ - static int find_attribute(KernelGlobals *kg, const ShaderData *sd, uint id, AttributeDescriptor *desc); + /* attributes */ + static int find_attribute(KernelGlobals *kg, + const ShaderData *sd, + uint id, + AttributeDescriptor *desc); }; CCL_NAMESPACE_END #endif -#endif /* __OSL_SHADER_H__ */ +#endif /* __OSL_SHADER_H__ */ |