Cleanup: refactor passing of OSL kernel globals for upcoming changes

13 files changed, 106 insertions, 95 deletions

diff --git a/intern/cycles/kernel/kernel_types.h b/intern/cycles/kernel/kernel_types.h
index 0c6b4b401f0..7d4f655a32e 100644
--- a/intern/cycles/kernel/kernel_types.h
+++ b/intern/cycles/kernel/kernel_types.h
@@ -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
 
diff --git a/intern/cycles/kernel/osl/background.cpp b/intern/cycles/kernel/osl/background.cpp
index b395227845d..03fa88f40ad 100644
--- a/intern/cycles/kernel/osl/background.cpp
+++ b/intern/cycles/kernel/osl/background.cpp
@@ -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;
diff --git a/intern/cycles/kernel/osl/bsdf_diffuse_ramp.cpp b/intern/cycles/kernel/osl/bsdf_diffuse_ramp.cpp
index c5edc7c9be3..419837ab8d6 100644
--- a/intern/cycles/kernel/osl/bsdf_diffuse_ramp.cpp
+++ b/intern/cycles/kernel/osl/bsdf_diffuse_ramp.cpp
@@ -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);
diff --git a/intern/cycles/kernel/osl/bsdf_phong_ramp.cpp b/intern/cycles/kernel/osl/bsdf_phong_ramp.cpp
index 4b7e59ff932..6bf39934235 100644
--- a/intern/cycles/kernel/osl/bsdf_phong_ramp.cpp
+++ b/intern/cycles/kernel/osl/bsdf_phong_ramp.cpp
@@ -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);
diff --git a/intern/cycles/kernel/osl/emissive.cpp b/intern/cycles/kernel/osl/emissive.cpp
index c29ddb13e2e..894727a5c7b 100644
--- a/intern/cycles/kernel/osl/emissive.cpp
+++ b/intern/cycles/kernel/osl/emissive.cpp
@@ -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);
   }
diff --git a/intern/cycles/kernel/osl/osl_bssrdf.cpp b/intern/cycles/kernel/osl/osl_bssrdf.cpp
index dd52c33071c..b487aef09a1 100644
--- a/intern/cycles/kernel/osl/osl_bssrdf.cpp
+++ b/intern/cycles/kernel/osl/osl_bssrdf.cpp
@@ -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);
diff --git a/intern/cycles/kernel/osl/osl_closures.cpp b/intern/cycles/kernel/osl/osl_closures.cpp
index 27205df3732..7152a56bd70 100644
--- a/intern/cycles/kernel/osl/osl_closures.cpp
+++ b/intern/cycles/kernel/osl/osl_closures.cpp
@@ -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);
 
diff --git a/intern/cycles/kernel/osl/osl_closures.h b/intern/cycles/kernel/osl/osl_closures.h
index d3db6b71f5c..9de1e036194 100644
--- a/intern/cycles/kernel/osl/osl_closures.h
+++ b/intern/cycles/kernel/osl/osl_closures.h
@@ -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; \
       } \
diff --git a/intern/cycles/kernel/osl/osl_services.cpp b/intern/cycles/kernel/osl/osl_services.cpp
index 6404690224a..b4329ab0a71 100644
--- a/intern/cycles/kernel/osl/osl_services.cpp
+++ b/intern/cycles/kernel/osl/osl_services.cpp
@@ -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;
         }
 
diff --git a/intern/cycles/kernel/osl/osl_services.h b/intern/cycles/kernel/osl/osl_services.h
index 2fad5833fc9..e881e528fc5 100644
--- a/intern/cycles/kernel/osl/osl_services.h
+++ b/intern/cycles/kernel/osl/osl_services.h
@@ -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;
diff --git a/intern/cycles/kernel/osl/osl_shader.cpp b/intern/cycles/kernel/osl/osl_shader.cpp
index 3d9c579c9ff..69599825bc0 100644
--- a/intern/cycles/kernel/osl/osl_shader.cpp
+++ b/intern/cycles/kernel/osl/osl_shader.cpp
@@ -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 */
diff --git a/intern/cycles/render/osl.cpp b/intern/cycles/render/osl.cpp
index b66a46938be..24c5a599c1a 100644
--- a/intern/cycles/render/osl.cpp
+++ b/intern/cycles/render/osl.cpp
@@ -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
diff --git a/intern/cycles/render/osl.h b/intern/cycles/render/osl.h
index aec518a6c2b..4d930d65e45 100644
--- a/intern/cycles/render/osl.h
+++ b/intern/cycles/render/osl.h
@@ -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;
 };