kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

Cleanup: refactor passing of OSL kernel globals for upcoming changes

Browse Source
This commit is contained in:
Brecht Van Lommel 2019-05-02 15:39:23 +02:00
parent 45ad6cd5a7
commit 08a44d2981
13 changed files with 106 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
intern/cycles/kernel/kernel_types.h
View File

@ -981,7 +981,6 @@ typedef ccl_addr_space struct ShaderData {
differential3 ray_dP;
#ifdef __OSL__
struct KernelGlobals *osl_globals;
struct PathState *osl_path_state;
#endif

4
intern/cycles/kernel/osl/background.cpp
View File

@ -52,7 +52,7 @@ using namespace OSL;
///
class GenericBackgroundClosure : public CClosurePrimitive {
public:
void setup(ShaderData *sd, int /* path_flag */, float3 weight)
void setup(const KernelGlobals *, ShaderData *sd, int /* path_flag */, float3 weight)
{
background_setup(sd, weight);
}
@ -67,7 +67,7 @@ class GenericBackgroundClosure : public CClosurePrimitive {
///
class HoldoutClosure : CClosurePrimitive {
public:
void setup(ShaderData *sd, int /* path_flag */, float3 weight)
void setup(const KernelGlobals *, ShaderData *sd, int /* path_flag */, float3 weight)
{
closure_alloc(sd, sizeof(ShaderClosure), CLOSURE_HOLDOUT_ID, weight);
sd->flag |= SD_HOLDOUT;

2
intern/cycles/kernel/osl/bsdf_diffuse_ramp.cpp
View File

@ -51,7 +51,7 @@ class DiffuseRampClosure : public CBSDFClosure {
DiffuseRampBsdf params;
Color3 colors[8];
void setup(ShaderData *sd, int /* path_flag */, float3 weight)
void setup(const KernelGlobals *, ShaderData *sd, int /* path_flag */, float3 weight)
{
DiffuseRampBsdf *bsdf = (DiffuseRampBsdf *)bsdf_alloc_osl(
sd, sizeof(DiffuseRampBsdf), weight, &params);

2
intern/cycles/kernel/osl/bsdf_phong_ramp.cpp
View File

@ -50,7 +50,7 @@ class PhongRampClosure : public CBSDFClosure {
PhongRampBsdf params;
Color3 colors[8];
void setup(ShaderData *sd, int /* path_flag */, float3 weight)
void setup(const KernelGlobals *, ShaderData *sd, int /* path_flag */, float3 weight)
{
PhongRampBsdf *bsdf = (PhongRampBsdf *)bsdf_alloc_osl(
sd, sizeof(PhongRampBsdf), weight, &params);

2
intern/cycles/kernel/osl/emissive.cpp
View File

@ -54,7 +54,7 @@ using namespace OSL;
///
class GenericEmissiveClosure : public CClosurePrimitive {
public:
void setup(ShaderData *sd, int /* path_flag */, float3 weight)
void setup(const KernelGlobals *, ShaderData *sd, int /* path_flag */, float3 weight)
{
emission_setup(sd, weight);
}

2
intern/cycles/kernel/osl/osl_bssrdf.cpp
View File

@ -67,7 +67,7 @@ class CBSSRDFClosure : public CClosurePrimitive {
params.roughness = 0.0f;
}
void setup(ShaderData *sd, int path_flag, float3 weight)
void setup(const KernelGlobals *, ShaderData *sd, int path_flag, float3 weight)
{
if (method == u_cubic) {
alloc(sd, path_flag, weight, CLOSURE_BSSRDF_CUBIC_ID);

63
intern/cycles/kernel/osl/osl_closures.cpp
View File

@ -227,9 +227,9 @@ CLOSURE_FLOAT3_PARAM(DiffuseClosure, params.N),
return bsdf;
}
void setup(ShaderData *sd, int path_flag, float3 weight)
void setup(const KernelGlobals *kg, ShaderData *sd, int path_flag, float3 weight)
{
if (!skip(sd, path_flag, LABEL_GLOSSY)) {
if (!skip(kg, sd, path_flag, LABEL_GLOSSY)) {
PrincipledHairBSDF *bsdf = (PrincipledHairBSDF *)alloc(sd, path_flag, weight);
if (!bsdf) {
return;
@ -287,7 +287,7 @@ class PrincipledClearcoatClosure : public CBSDFClosure {
return bsdf;
}
void setup(ShaderData *sd, int path_flag, float3 weight)
void setup(const KernelGlobals *kg, ShaderData *sd, int path_flag, float3 weight)
{
MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight);
if (!bsdf) {
@ -471,12 +471,13 @@ void OSLShader::register_closures(OSLShadingSystem *ss_)
/* BSDF Closure */
bool CBSDFClosure::skip(const ShaderData *sd, int path_flag, int scattering)
bool CBSDFClosure::skip(const KernelGlobals *kg,
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;
@ -494,12 +495,12 @@ class MicrofacetFresnelClosure : public CBSDFClosure {
float3 color;
float3 cspec0;
MicrofacetBsdf *alloc(ShaderData *sd, int path_flag, float3 weight)
MicrofacetBsdf *alloc(const KernelGlobals *kg, 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)) {
if (skip(kg, sd, path_flag, LABEL_GLOSSY | LABEL_REFLECT)) {
return NULL;
}
@ -524,9 +525,9 @@ class MicrofacetFresnelClosure : public CBSDFClosure {
class MicrofacetGGXFresnelClosure : public MicrofacetFresnelClosure {
public:
void setup(ShaderData *sd, int path_flag, float3 weight)
void setup(const KernelGlobals *kg, ShaderData *sd, int path_flag, float3 weight)
{
MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight);
MicrofacetBsdf *bsdf = alloc(kg, sd, path_flag, weight);
if (!bsdf) {
return;
}
@ -553,9 +554,9 @@ CCLOSURE_PREPARE(closure_bsdf_microfacet_ggx_fresnel_prepare, MicrofacetGGXFresn
class MicrofacetGGXAnisoFresnelClosure : public MicrofacetFresnelClosure {
public:
void setup(ShaderData *sd, int path_flag, float3 weight)
void setup(const KernelGlobals *kg, ShaderData *sd, int path_flag, float3 weight)
{
MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight);
MicrofacetBsdf *bsdf = alloc(kg, sd, path_flag, weight);
if (!bsdf) {
return;
}
@ -588,12 +589,12 @@ class MicrofacetMultiClosure : public CBSDFClosure {
MicrofacetBsdf params;
float3 color;
MicrofacetBsdf *alloc(ShaderData *sd, int path_flag, float3 weight)
MicrofacetBsdf *alloc(const KernelGlobals *kg, 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)) {
if (skip(kg, sd, path_flag, LABEL_GLOSSY | LABEL_REFLECT)) {
return NULL;
}
@ -618,9 +619,9 @@ class MicrofacetMultiClosure : public CBSDFClosure {
class MicrofacetMultiGGXClosure : public MicrofacetMultiClosure {
public:
void setup(ShaderData *sd, int path_flag, float3 weight)
void setup(const KernelGlobals *kg, ShaderData *sd, int path_flag, float3 weight)
{
MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight);
MicrofacetBsdf *bsdf = alloc(kg, sd, path_flag, weight);
if (!bsdf) {
return;
}
@ -646,9 +647,9 @@ CCLOSURE_PREPARE(closure_bsdf_microfacet_multi_ggx_prepare, MicrofacetMultiGGXCl
class MicrofacetMultiGGXAnisoClosure : public MicrofacetMultiClosure {
public:
void setup(ShaderData *sd, int path_flag, float3 weight)
void setup(const KernelGlobals *kg, ShaderData *sd, int path_flag, float3 weight)
{
MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight);
MicrofacetBsdf *bsdf = alloc(kg, sd, path_flag, weight);
if (!bsdf) {
return;
}
@ -678,9 +679,9 @@ class MicrofacetMultiGGXGlassClosure : public MicrofacetMultiClosure {
{
}
void setup(ShaderData *sd, int path_flag, float3 weight)
void setup(const KernelGlobals *kg, ShaderData *sd, int path_flag, float3 weight)
{
MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight);
MicrofacetBsdf *bsdf = alloc(kg, sd, path_flag, weight);
if (!bsdf) {
return;
}
@ -712,12 +713,12 @@ class MicrofacetMultiFresnelClosure : public CBSDFClosure {
float3 color;
float3 cspec0;
MicrofacetBsdf *alloc(ShaderData *sd, int path_flag, float3 weight)
MicrofacetBsdf *alloc(const KernelGlobals *kg, 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)) {
if (skip(kg, sd, path_flag, LABEL_GLOSSY | LABEL_REFLECT)) {
return NULL;
}
@ -742,9 +743,9 @@ class MicrofacetMultiFresnelClosure : public CBSDFClosure {
class MicrofacetMultiGGXFresnelClosure : public MicrofacetMultiFresnelClosure {
public:
void setup(ShaderData *sd, int path_flag, float3 weight)
void setup(const KernelGlobals *kg, ShaderData *sd, int path_flag, float3 weight)
{
MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight);
MicrofacetBsdf *bsdf = alloc(kg, sd, path_flag, weight);
if (!bsdf) {
return;
}
@ -772,9 +773,9 @@ CCLOSURE_PREPARE(closure_bsdf_microfacet_multi_ggx_fresnel_prepare,
class MicrofacetMultiGGXAnisoFresnelClosure : public MicrofacetMultiFresnelClosure {
public:
void setup(ShaderData *sd, int path_flag, float3 weight)
void setup(const KernelGlobals *kg, ShaderData *sd, int path_flag, float3 weight)
{
MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight);
MicrofacetBsdf *bsdf = alloc(kg, sd, path_flag, weight);
if (!bsdf) {
return;
}
@ -806,9 +807,9 @@ class MicrofacetMultiGGXGlassFresnelClosure : public MicrofacetMultiFresnelClosu
{
}
void setup(ShaderData *sd, int path_flag, float3 weight)
void setup(const KernelGlobals *kg, ShaderData *sd, int path_flag, float3 weight)
{
MicrofacetBsdf *bsdf = alloc(sd, path_flag, weight);
MicrofacetBsdf *bsdf = alloc(kg, sd, path_flag, weight);
if (!bsdf) {
return;
}
@ -841,7 +842,7 @@ class TransparentClosure : public CBSDFClosure {
ShaderClosure params;
float3 unused;
void setup(ShaderData *sd, int path_flag, float3 weight)
void setup(const KernelGlobals *kg, ShaderData *sd, int path_flag, float3 weight)
{
bsdf_transparent_setup(sd, weight, path_flag);
}
@ -860,7 +861,7 @@ CCLOSURE_PREPARE(closure_bsdf_transparent_prepare, TransparentClosure)
class VolumeAbsorptionClosure : public CBSDFClosure {
public:
void setup(ShaderData *sd, int path_flag, float3 weight)
void setup(const KernelGlobals *kg, ShaderData *sd, int path_flag, float3 weight)
{
volume_extinction_setup(sd, weight);
}
@ -879,7 +880,7 @@ class VolumeHenyeyGreensteinClosure : public CBSDFClosure {
public:
HenyeyGreensteinVolume params;
void setup(ShaderData *sd, int path_flag, float3 weight)
void setup(const KernelGlobals *kg, ShaderData *sd, int path_flag, float3 weight)
{
volume_extinction_setup(sd, weight);

10
intern/cycles/kernel/osl/osl_closures.h
View File

@ -42,6 +42,8 @@
CCL_NAMESPACE_BEGIN
struct KernelGlobals;
OSL::ClosureParam *closure_emission_params();
OSL::ClosureParam *closure_background_params();
OSL::ClosureParam *closure_holdout_params();
@ -111,7 +113,7 @@ void closure_bsdf_principled_hair_prepare(OSL::RendererServices *, int id, void
class CClosurePrimitive {
public:
virtual void setup(ShaderData *sd, int path_flag, float3 weight) = 0;
virtual void setup(const KernelGlobals *kg, ShaderData *sd, int path_flag, float3 weight) = 0;
OSL::ustring label;
};
@ -120,7 +122,7 @@ class CClosurePrimitive {
class CBSDFClosure : public CClosurePrimitive {
public:
bool skip(const ShaderData *sd, int path_flag, int scattering);
bool skip(const KernelGlobals *kg, const ShaderData *sd, int path_flag, int scattering);
};
#define BSDF_CLOSURE_CLASS_BEGIN(Upper, lower, structname, TYPE) \
@ -130,9 +132,9 @@ class CBSDFClosure : public CClosurePrimitive {
structname params; \
float3 unused; \
\
void setup(ShaderData *sd, int path_flag, float3 weight) \
void setup(const KernelGlobals *kg, ShaderData *sd, int path_flag, float3 weight) \
{ \
if (!skip(sd, path_flag, TYPE)) { \
if (!skip(kg, sd, path_flag, TYPE)) { \
structname *bsdf = (structname *)bsdf_alloc_osl(sd, sizeof(structname), weight, &params); \
sd->flag |= (bsdf) ? bsdf_##lower##_setup(bsdf) : 0; \
} \

44
intern/cycles/kernel/osl/osl_services.cpp
View File

@ -130,6 +130,7 @@ ustring OSLRenderServices::u_at_ao("@ao");
OSLRenderServices::OSLRenderServices()
{
kernel_globals = NULL;
osl_globals = NULL;
osl_ts = NULL;
#ifdef WITH_PTEX
@ -148,9 +149,12 @@ OSLRenderServices::~OSLRenderServices()
#endif
}
void OSLRenderServices::thread_init(KernelGlobals *kernel_globals_, OSL::TextureSystem *osl_ts_)
void OSLRenderServices::thread_init(KernelGlobals *kernel_globals_,
OSLGlobals *osl_globals_,
OSL::TextureSystem *osl_ts_)
{
kernel_globals = kernel_globals_;
osl_globals = osl_globals;
osl_ts = osl_ts_;
}
@ -163,7 +167,6 @@ bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg,
* 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) {
@ -173,9 +176,9 @@ bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg,
if (time == sd->time)
tfm = sd->ob_tfm;
else
tfm = object_fetch_transform_motion_test(kg, object, time, NULL);
tfm = object_fetch_transform_motion_test(kernel_globals, object, time, NULL);
#else
Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM);
Transform tfm = object_fetch_transform(kernel_globals, object, OBJECT_TRANSFORM);
#endif
copy_matrix(result, tfm);
@ -200,7 +203,6 @@ bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg,
* 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) {
@ -210,9 +212,9 @@ bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg,
if (time == sd->time)
itfm = sd->ob_itfm;
else
object_fetch_transform_motion_test(kg, object, time, &itfm);
object_fetch_transform_motion_test(kernel_globals, object, time, &itfm);
#else
Transform itfm = object_fetch_transform(kg, object, OBJECT_INVERSE_TRANSFORM);
Transform itfm = object_fetch_transform(kernel_globals, object, OBJECT_INVERSE_TRANSFORM);
#endif
copy_matrix(result, itfm);
@ -304,8 +306,7 @@ bool OSLRenderServices::get_matrix(OSL::ShaderGlobals *sg,
#ifdef __OBJECT_MOTION__
Transform tfm = sd->ob_tfm;
#else
KernelGlobals *kg = sd->osl_globals;
Transform tfm = object_fetch_transform(kg, object, OBJECT_TRANSFORM);
Transform tfm = object_fetch_transform(kernel_globals, object, OBJECT_TRANSFORM);
#endif
copy_matrix(result, tfm);
@ -335,8 +336,7 @@ bool OSLRenderServices::get_inverse_matrix(OSL::ShaderGlobals *sg,
#ifdef __OBJECT_MOTION__
Transform tfm = sd->ob_itfm;
#else
KernelGlobals *kg = sd->osl_globals;
Transform tfm = object_fetch_transform(kg, object, OBJECT_INVERSE_TRANSFORM);
Transform tfm = object_fetch_transform(kernel_globals, object, OBJECT_INVERSE_TRANSFORM);
#endif
copy_matrix(result, tfm);
@ -892,15 +892,15 @@ bool OSLRenderServices::get_attribute(OSL::ShaderGlobals *sg,
bool OSLRenderServices::get_attribute(
ShaderData *sd, bool derivatives, ustring object_name, TypeDesc type, ustring name, void *val)
{
KernelGlobals *kg = sd->osl_globals;
KernelGlobals *kg = kernel_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);
OSLGlobals::ObjectNameMap::iterator it = osl_globals->object_name_map.find(object_name);
if (it == kg->osl->object_name_map.end())
if (it == osl_globals->object_name_map.end())
return false;
object = it->second;
@ -915,7 +915,7 @@ bool OSLRenderServices::get_attribute(
/* find attribute on object */
object = object * ATTR_PRIM_TYPES + prim_type;
OSLGlobals::AttributeMap &attribute_map = kg->osl->attribute_map[object];
OSLGlobals::AttributeMap &attribute_map = osl_globals->attribute_map[object];
OSLGlobals::AttributeMap::iterator it = attribute_map.find(name);
if (it != attribute_map.end()) {
@ -990,7 +990,7 @@ bool OSLRenderServices::texture(ustring filename,
{
OSL::TextureSystem *ts = osl_ts;
ShaderData *sd = (ShaderData *)(sg->renderstate);
KernelGlobals *kg = sd->osl_globals;
KernelGlobals *kg = kernel_globals;
if (texture_thread_info == NULL) {
OSLThreadData *tdata = kg->osl_tdata;
@ -1159,7 +1159,7 @@ bool OSLRenderServices::texture3d(ustring filename,
{
OSL::TextureSystem *ts = osl_ts;
ShaderData *sd = (ShaderData *)(sg->renderstate);
KernelGlobals *kg = sd->osl_globals;
KernelGlobals *kg = kernel_globals;
if (texture_thread_info == NULL) {
OSLThreadData *tdata = kg->osl_tdata;
@ -1246,9 +1246,7 @@ bool OSLRenderServices::environment(ustring filename,
OSL::TextureSystem *ts = osl_ts;
if (thread_info == NULL) {
ShaderData *sd = (ShaderData *)(sg->renderstate);
KernelGlobals *kg = sd->osl_globals;
OSLThreadData *tdata = kg->osl_tdata;
OSLThreadData *tdata = kernel_globals->osl_tdata;
thread_info = tdata->oiio_thread_info;
}
@ -1369,11 +1367,10 @@ bool OSLRenderServices::trace(TraceOpt &options,
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);
return scene_intersect(kernel_globals, ray, visibility, &tracedata->isect);
}
bool OSLRenderServices::getmessage(OSL::ShaderGlobals *sg,
@ -1396,11 +1393,10 @@ bool OSLRenderServices::getmessage(OSL::ShaderGlobals *sg,
}
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);
shader_setup_from_ray(kernel_globals, sd, &tracedata->isect, &tracedata->ray);
tracedata->setup = true;
}

3
intern/cycles/kernel/osl/osl_services.h
View File

@ -45,7 +45,7 @@ class OSLRenderServices : public OSL::RendererServices {
OSLRenderServices();
~OSLRenderServices();
void thread_init(KernelGlobals *kernel_globals, OSL::TextureSystem *ts);
void thread_init(KernelGlobals *kernel_globals, OSLGlobals *osl_globals, OSL::TextureSystem *ts);
bool get_matrix(OSL::ShaderGlobals *sg,
OSL::Matrix44 &result,
@ -257,6 +257,7 @@ class OSLRenderServices : public OSL::RendererServices {
private:
KernelGlobals *kernel_globals;
OSLGlobals *osl_globals;
OSL::TextureSystem *osl_ts;
#ifdef WITH_PTEX
PtexCache *ptex_cache;

43
intern/cycles/kernel/osl/osl_shader.cpp
View File

@ -49,7 +49,7 @@ void OSLShader::thread_init(KernelGlobals *kg,
/* per thread kernel data init*/
kg->osl = osl_globals;
kg->osl->services->thread_init(kernel_globals, osl_globals->ts);
kg->osl->services->thread_init(kernel_globals, osl_globals, osl_globals->ts);
OSL::ShadingSystem *ss = kg->osl->ss;
OSLThreadData *tdata = new OSLThreadData();
@ -129,13 +129,13 @@ static void shaderdata_to_shaderglobals(
tdata->tracedata.init = false;
/* used by renderservices */
sd->osl_globals = kg;
sd->osl_path_state = state;
}
/* Surface */
static void flatten_surface_closure_tree(ShaderData *sd,
static void flatten_surface_closure_tree(KernelGlobals *kg,
ShaderData *sd,
int path_flag,
const OSL::ClosureColor *closure,
float3 weight = make_float3(1.0f, 1.0f, 1.0f))
@ -146,13 +146,14 @@ static void flatten_surface_closure_tree(ShaderData *sd,
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);
flatten_surface_closure_tree(
kg, 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);
flatten_surface_closure_tree(kg, sd, path_flag, add->closureA, weight);
flatten_surface_closure_tree(kg, sd, path_flag, add->closureB, weight);
break;
}
default: {
@ -163,7 +164,7 @@ static void flatten_surface_closure_tree(ShaderData *sd,
#ifdef OSL_SUPPORTS_WEIGHTED_CLOSURE_COMPONENTS
weight = weight * TO_FLOAT3(comp->w);
#endif
prim->setup(sd, path_flag, weight);
prim->setup(kg, sd, path_flag, weight);
}
break;
}
@ -234,12 +235,13 @@ void OSLShader::eval_surface(KernelGlobals *kg, ShaderData *sd, PathState *state
/* flatten closure tree */
if (globals->Ci)
flatten_surface_closure_tree(sd, path_flag, globals->Ci);
flatten_surface_closure_tree(kg, sd, path_flag, globals->Ci);
}
/* Background */
static void flatten_background_closure_tree(ShaderData *sd,
static void flatten_background_closure_tree(KernelGlobals *kg,
ShaderData *sd,
const OSL::ClosureColor *closure,
float3 weight = make_float3(1.0f, 1.0f, 1.0f))
{
@ -250,14 +252,14 @@ static void flatten_background_closure_tree(ShaderData *sd,
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));
flatten_background_closure_tree(kg, 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);
flatten_background_closure_tree(kg, sd, add->closureA, weight);
flatten_background_closure_tree(kg, sd, add->closureB, weight);
break;
}
default: {
@ -268,7 +270,7 @@ static void flatten_background_closure_tree(ShaderData *sd,
#ifdef OSL_SUPPORTS_WEIGHTED_CLOSURE_COMPONENTS
weight = weight * TO_FLOAT3(comp->w);
#endif
prim->setup(sd, 0, weight);
prim->setup(kg, sd, 0, weight);
}
break;
}
@ -292,12 +294,13 @@ void OSLShader::eval_background(KernelGlobals *kg, ShaderData *sd, PathState *st
/* return background color immediately */
if (globals->Ci)
flatten_background_closure_tree(sd, globals->Ci);
flatten_background_closure_tree(kg, sd, globals->Ci);
}
/* Volume */
static void flatten_volume_closure_tree(ShaderData *sd,
static void flatten_volume_closure_tree(KernelGlobals *kg,
ShaderData *sd,
const OSL::ClosureColor *closure,
float3 weight = make_float3(1.0f, 1.0f, 1.0f))
{
@ -307,13 +310,13 @@ static void flatten_volume_closure_tree(ShaderData *sd,
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);
flatten_volume_closure_tree(kg, 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);
flatten_volume_closure_tree(kg, sd, add->closureA, weight);
flatten_volume_closure_tree(kg, sd, add->closureB, weight);
break;
}
default: {
@ -324,7 +327,7 @@ static void flatten_volume_closure_tree(ShaderData *sd,
#ifdef OSL_SUPPORTS_WEIGHTED_CLOSURE_COMPONENTS
weight = weight * TO_FLOAT3(comp->w);
#endif
prim->setup(sd, 0, weight);
prim->setup(kg, sd, 0, weight);
}
}
}
@ -348,7 +351,7 @@ void OSLShader::eval_volume(KernelGlobals *kg, ShaderData *sd, PathState *state,
/* flatten closure tree */
if (globals->Ci)
flatten_volume_closure_tree(sd, globals->Ci);
flatten_volume_closure_tree(kg, sd, globals->Ci);
}
/* Displacement */

21
intern/cycles/render/osl.cpp
View File

@ -104,6 +104,11 @@ void OSLShaderManager::device_update(Device *device,
/* create shaders */
OSLGlobals *og = (OSLGlobals *)device->osl_memory();
/* Partial thread init of services, the OSL compiler can query data like
* constant texture handles. This will be done again right before rendering
* with full data available. */
services->thread_init(NULL, og, ts);
foreach (Shader *shader, scene->shaders) {
assert(shader->graph);
@ -115,9 +120,9 @@ void OSLShaderManager::device_update(Device *device,
* compile shaders alternating */
thread_scoped_lock lock(ss_mutex);
OSLCompiler compiler((void *)this, (void *)ss, scene->image_manager, scene->light_manager);
OSLCompiler compiler((void *)this, (void *)ss, og, scene->image_manager, scene->light_manager);
compiler.background = (shader == scene->default_background);
compiler.compile(scene, og, shader);
compiler.compile(scene, shader);
if (shader->use_mis && shader->has_surface_emission)
scene->light_manager->need_update = true;
@ -557,11 +562,13 @@ OSLNode *OSLShaderManager::osl_node(const std::string &filepath,
OSLCompiler::OSLCompiler(void *manager_,
void *shadingsys_,
OSLGlobals *osl_globals_,
ImageManager *image_manager_,
LightManager *light_manager_)
{
manager = manager_;
shadingsys = shadingsys_;
osl_globals = osl_globals_;
image_manager = image_manager_;
light_manager = light_manager_;
current_type = SHADER_TYPE_SURFACE;
@ -1123,7 +1130,7 @@ OSL::ShaderGroupRef OSLCompiler::compile_type(Shader *shader, ShaderGraph *graph
return group;
}
void OSLCompiler::compile(Scene *scene, OSLGlobals *og, Shader *shader)
void OSLCompiler::compile(Scene *scene, Shader *shader)
{
if (shader->need_update) {
ShaderGraph *graph = shader->graph;
@ -1188,10 +1195,10 @@ void OSLCompiler::compile(Scene *scene, OSLGlobals *og, Shader *shader)
}
/* push state to array for lookup */
og->surface_state.push_back(shader->osl_surface_ref);
og->volume_state.push_back(shader->osl_volume_ref);
og->displacement_state.push_back(shader->osl_displacement_ref);
og->bump_state.push_back(shader->osl_surface_bump_ref);
osl_globals->surface_state.push_back(shader->osl_surface_ref);
osl_globals->volume_state.push_back(shader->osl_volume_ref);
osl_globals->displacement_state.push_back(shader->osl_displacement_ref);
osl_globals->bump_state.push_back(shader->osl_surface_bump_ref);
}
#else

4
intern/cycles/render/osl.h
View File

@ -129,9 +129,10 @@ class OSLCompiler {
public:
OSLCompiler(void *manager,
void *shadingsys,
OSLGlobals *osl_globals,
ImageManager *image_manager,
LightManager *light_manager);
void compile(Scene *scene, OSLGlobals *og, Shader *shader);
void compile(Scene *scene, Shader *shader);
void add(ShaderNode *node, const char *name, bool isfilepath = false);
@ -175,6 +176,7 @@ class OSLCompiler {
void *shadingsys;
void *manager;
OSLGlobals *osl_globals;
ShaderType current_type;
Shader *current_shader;
};