Cycles: Revert all host update specific changes

The approach didn't turn out to be that useful after all as there
are unavoidable dependencies of data from the device. For example,
to know whether object intersects volume or not it is required to
run displacement kernels.

The way of splitting host and device updates caused state where
some data is not yet available, causing confusion and leaving
code to be error-prone.

1 files changed, 37 insertions, 57 deletions

diff --git a/intern/cycles/render/osl.cpp b/intern/cycles/render/osl.cpp
index dd8f1b31177..1037ebcae7e 100644
--- a/intern/cycles/render/osl.cpp
+++ b/intern/cycles/render/osl.cpp
@@ -91,51 +91,70 @@ void OSLShaderManager::reset(Scene * /*scene*/)
   shading_system_init();
 }
 
-void OSLShaderManager::host_update_specific(Scene *scene, Progress &progress)
+void OSLShaderManager::device_update_specific(Device *device,
+                                              DeviceScene *dscene,
+                                              Scene *scene,
+                                              Progress &progress)
 {
-  if (!need_update()) {
+  if (!need_update())
     return;
-  }
 
   scoped_callback_timer timer([scene](double time) {
     if (scene->update_stats) {
-      scene->update_stats->osl.times.add_entry({"host_update", time});
+      scene->update_stats->osl.times.add_entry({"device_update", time});
     }
   });
 
   VLOG(1) << "Total " << scene->shaders.size() << " shaders.";
 
+  device_free(device, dscene, scene);
+
   /* set texture system */
   scene->image_manager->set_osl_texture_system((void *)ts);
 
   /* create shaders */
+  OSLGlobals *og = (OSLGlobals *)device->get_cpu_osl_memory();
   Shader *background_shader = scene->background->get_shader(scene);
 
-  for (Shader *shader : scene->shaders) {
+  foreach (Shader *shader, scene->shaders) {
     assert(shader->graph);
 
-    if (progress.get_cancel()) {
+    if (progress.get_cancel())
       return;
-    }
 
-    /* we can only compile one shader at the time as the OSL ShadingSystem
+    /* we can only compile one shader at the time as the OSL ShadingSytem
      * has a single state, but we put the lock here so different renders can
      * compile shaders alternating */
     thread_scoped_lock lock(ss_mutex);
 
     OSLCompiler compiler(this, services, ss, scene);
     compiler.background = (shader == background_shader);
-    compiler.compile(shader);
+    compiler.compile(og, shader);
 
-    if (shader->get_use_mis() && shader->has_surface_emission) {
+    if (shader->get_use_mis() && shader->has_surface_emission)
       scene->light_manager->tag_update(scene, LightManager::SHADER_COMPILED);
-    }
   }
 
+  /* setup shader engine */
+  og->ss = ss;
+  og->ts = ts;
+  og->services = services;
+
+  int background_id = scene->shader_manager->get_shader_id(background_shader);
+  og->background_state = og->surface_state[background_id & SHADER_MASK];
+  og->use = true;
+
+  foreach (Shader *shader, scene->shaders)
+    shader->clear_modified();
+
+  update_flags = UPDATE_NONE;
+
   /* add special builtin texture types */
   services->textures.insert(ustring("@ao"), new OSLTextureHandle(OSLTextureHandle::AO));
   services->textures.insert(ustring("@bevel"), new OSLTextureHandle(OSLTextureHandle::BEVEL));
 
+  device_update_common(device, dscene, scene, progress);
+
   {
     /* Perform greedyjit optimization.
      *
@@ -153,51 +172,6 @@ void OSLShaderManager::host_update_specific(Scene *scene, Progress &progress)
   }
 }
 
-void OSLShaderManager::device_update_specific(Device *device,
-                                              DeviceScene *dscene,
-                                              Scene *scene,
-                                              Progress &progress)
-{
-  if (!need_update())
-    return;
-
-  scoped_callback_timer timer([scene](double time) {
-    if (scene->update_stats) {
-      scene->update_stats->osl.times.add_entry({"device_update", time});
-    }
-  });
-
-  device_free(device, dscene, scene);
-
-  OSLGlobals *og = (OSLGlobals *)device->get_cpu_osl_memory();
-  Shader *background_shader = scene->background->get_shader(scene);
-
-  /* Setup shader engine. */
-  og->ss = ss;
-  og->ts = ts;
-  og->services = services;
-
-  for (Shader *shader : scene->shaders) {
-    /* 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);
-
-    shader->clear_modified();
-  }
-
-  const int background_id = scene->shader_manager->get_shader_id(background_shader);
-  const int background_state_index = (background_id & SHADER_MASK);
-  DCHECK_LT(background_state_index, og->surface_state.size());
-  og->background_state = og->surface_state[background_state_index];
-  og->use = true;
-
-  update_flags = UPDATE_NONE;
-
-  device_update_common(device, dscene, scene, progress);
-}
-
 void OSLShaderManager::device_free(Device *device, DeviceScene *dscene, Scene *scene)
 {
   OSLGlobals *og = (OSLGlobals *)device->get_cpu_osl_memory();
@@ -1158,7 +1132,7 @@ OSL::ShaderGroupRef OSLCompiler::compile_type(Shader *shader, ShaderGraph *graph
   return group;
 }
 
-void OSLCompiler::compile(Shader *shader)
+void OSLCompiler::compile(OSLGlobals *og, Shader *shader)
 {
   if (shader->is_modified()) {
     ShaderGraph *graph = shader->graph;
@@ -1220,6 +1194,12 @@ void OSLCompiler::compile(Shader *shader)
     else
       shader->osl_displacement_ref = OSL::ShaderGroupRef();
   }
+
+  /* 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);
 }
 
 void OSLCompiler::parameter_texture(const char *name, ustring filename, ustring colorspace)