Fix T75203: Crash when changing active keying set
[blender.git] / intern / cycles / render / shader.cpp
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include "device/device.h"
18
19 #include "render/background.h"
20 #include "render/camera.h"
21 #include "render/colorspace.h"
22 #include "render/graph.h"
23 #include "render/integrator.h"
24 #include "render/light.h"
25 #include "render/mesh.h"
26 #include "render/nodes.h"
27 #include "render/object.h"
28 #include "render/osl.h"
29 #include "render/scene.h"
30 #include "render/shader.h"
31 #include "render/svm.h"
32 #include "render/tables.h"
33
34 #include "util/util_foreach.h"
35 #include "util/util_murmurhash.h"
36
37 #ifdef WITH_OCIO
38 #  include <OpenColorIO/OpenColorIO.h>
39 namespace OCIO = OCIO_NAMESPACE;
40 #endif
41
42 CCL_NAMESPACE_BEGIN
43
44 thread_mutex ShaderManager::lookup_table_mutex;
45 vector<float> ShaderManager::beckmann_table;
46 bool ShaderManager::beckmann_table_ready = false;
47
48 /* Beckmann sampling precomputed table, see bsdf_microfacet.h */
49
50 /* 2D slope distribution (alpha = 1.0) */
51 static float beckmann_table_P22(const float slope_x, const float slope_y)
52 {
53   return expf(-(slope_x * slope_x + slope_y * slope_y));
54 }
55
56 /* maximal slope amplitude (range that contains 99.99% of the distribution) */
57 static float beckmann_table_slope_max()
58 {
59   return 6.0;
60 }
61
62 /* MSVC 2015 needs this ugly hack to prevent a codegen bug on x86
63  * see T50176 for details
64  */
65 #if defined(_MSC_VER) && (_MSC_VER == 1900)
66 #  define MSVC_VOLATILE volatile
67 #else
68 #  define MSVC_VOLATILE
69 #endif
70
71 /* Paper used: Importance Sampling Microfacet-Based BSDFs with the
72  * Distribution of Visible Normals. Supplemental Material 2/2.
73  *
74  * http://hal.inria.fr/docs/01/00/66/20/ANNEX/supplemental2.pdf
75  */
76 static void beckmann_table_rows(float *table, int row_from, int row_to)
77 {
78   /* allocate temporary data */
79   const int DATA_TMP_SIZE = 512;
80   vector<double> slope_x(DATA_TMP_SIZE);
81   vector<double> CDF_P22_omega_i(DATA_TMP_SIZE);
82
83   /* loop over incident directions */
84   for (int index_theta = row_from; index_theta < row_to; index_theta++) {
85     /* incident vector */
86     const float cos_theta = index_theta / (BECKMANN_TABLE_SIZE - 1.0f);
87     const float sin_theta = safe_sqrtf(1.0f - cos_theta * cos_theta);
88
89     /* for a given incident vector
90      * integrate P22_{omega_i}(x_slope, 1, 1), Eq. (10) */
91     slope_x[0] = (double)-beckmann_table_slope_max();
92     CDF_P22_omega_i[0] = 0;
93
94     for (MSVC_VOLATILE int index_slope_x = 1; index_slope_x < DATA_TMP_SIZE; ++index_slope_x) {
95       /* slope_x */
96       slope_x[index_slope_x] = (double)(-beckmann_table_slope_max() +
97                                         2.0f * beckmann_table_slope_max() * index_slope_x /
98                                             (DATA_TMP_SIZE - 1.0f));
99
100       /* dot product with incident vector */
101       float dot_product = fmaxf(0.0f, -(float)slope_x[index_slope_x] * sin_theta + cos_theta);
102       /* marginalize P22_{omega_i}(x_slope, 1, 1), Eq. (10) */
103       float P22_omega_i = 0.0f;
104
105       for (int j = 0; j < 100; ++j) {
106         float slope_y = -beckmann_table_slope_max() +
107                         2.0f * beckmann_table_slope_max() * j * (1.0f / 99.0f);
108         P22_omega_i += dot_product * beckmann_table_P22((float)slope_x[index_slope_x], slope_y);
109       }
110
111       /* CDF of P22_{omega_i}(x_slope, 1, 1), Eq. (10) */
112       CDF_P22_omega_i[index_slope_x] = CDF_P22_omega_i[index_slope_x - 1] + (double)P22_omega_i;
113     }
114
115     /* renormalize CDF_P22_omega_i */
116     for (int index_slope_x = 1; index_slope_x < DATA_TMP_SIZE; ++index_slope_x)
117       CDF_P22_omega_i[index_slope_x] /= CDF_P22_omega_i[DATA_TMP_SIZE - 1];
118
119     /* loop over random number U1 */
120     int index_slope_x = 0;
121
122     for (int index_U = 0; index_U < BECKMANN_TABLE_SIZE; ++index_U) {
123       const double U = 0.0000001 + 0.9999998 * index_U / (double)(BECKMANN_TABLE_SIZE - 1);
124
125       /* inverse CDF_P22_omega_i, solve Eq.(11) */
126       while (CDF_P22_omega_i[index_slope_x] <= U)
127         ++index_slope_x;
128
129       const double interp = (CDF_P22_omega_i[index_slope_x] - U) /
130                             (CDF_P22_omega_i[index_slope_x] - CDF_P22_omega_i[index_slope_x - 1]);
131
132       /* store value */
133       table[index_U + index_theta * BECKMANN_TABLE_SIZE] =
134           (float)(interp * slope_x[index_slope_x - 1] + (1.0 - interp) * slope_x[index_slope_x]);
135     }
136   }
137 }
138
139 #undef MSVC_VOLATILE
140
141 static void beckmann_table_build(vector<float> &table)
142 {
143   table.resize(BECKMANN_TABLE_SIZE * BECKMANN_TABLE_SIZE);
144
145   /* multithreaded build */
146   TaskPool pool;
147
148   for (int i = 0; i < BECKMANN_TABLE_SIZE; i += 8)
149     pool.push(function_bind(&beckmann_table_rows, &table[0], i, i + 8));
150
151   pool.wait_work();
152 }
153
154 /* Shader */
155
156 NODE_DEFINE(Shader)
157 {
158   NodeType *type = NodeType::add("shader", create);
159
160   SOCKET_BOOLEAN(use_mis, "Use MIS", true);
161   SOCKET_BOOLEAN(use_transparent_shadow, "Use Transparent Shadow", true);
162   SOCKET_BOOLEAN(heterogeneous_volume, "Heterogeneous Volume", true);
163
164   static NodeEnum volume_sampling_method_enum;
165   volume_sampling_method_enum.insert("distance", VOLUME_SAMPLING_DISTANCE);
166   volume_sampling_method_enum.insert("equiangular", VOLUME_SAMPLING_EQUIANGULAR);
167   volume_sampling_method_enum.insert("multiple_importance", VOLUME_SAMPLING_MULTIPLE_IMPORTANCE);
168   SOCKET_ENUM(volume_sampling_method,
169               "Volume Sampling Method",
170               volume_sampling_method_enum,
171               VOLUME_SAMPLING_MULTIPLE_IMPORTANCE);
172
173   static NodeEnum volume_interpolation_method_enum;
174   volume_interpolation_method_enum.insert("linear", VOLUME_INTERPOLATION_LINEAR);
175   volume_interpolation_method_enum.insert("cubic", VOLUME_INTERPOLATION_CUBIC);
176   SOCKET_ENUM(volume_interpolation_method,
177               "Volume Interpolation Method",
178               volume_interpolation_method_enum,
179               VOLUME_INTERPOLATION_LINEAR);
180
181   SOCKET_FLOAT(volume_step_rate, "Volume Step Rate", 1.0f);
182
183   static NodeEnum displacement_method_enum;
184   displacement_method_enum.insert("bump", DISPLACE_BUMP);
185   displacement_method_enum.insert("true", DISPLACE_TRUE);
186   displacement_method_enum.insert("both", DISPLACE_BOTH);
187   SOCKET_ENUM(displacement_method, "Displacement Method", displacement_method_enum, DISPLACE_BUMP);
188
189   return type;
190 }
191
192 Shader::Shader() : Node(node_type)
193 {
194   pass_id = 0;
195
196   graph = NULL;
197
198   has_surface = false;
199   has_surface_transparent = false;
200   has_surface_emission = false;
201   has_surface_bssrdf = false;
202   has_volume = false;
203   has_displacement = false;
204   has_bump = false;
205   has_bssrdf_bump = false;
206   has_surface_spatial_varying = false;
207   has_volume_spatial_varying = false;
208   has_volume_attribute_dependency = false;
209   has_object_dependency = false;
210   has_integrator_dependency = false;
211   has_volume_connected = false;
212   prev_volume_step_rate = 0.0f;
213
214   displacement_method = DISPLACE_BUMP;
215
216   id = -1;
217   used = false;
218
219   need_update = true;
220   need_update_geometry = true;
221   need_sync_object = false;
222 }
223
224 Shader::~Shader()
225 {
226   delete graph;
227 }
228
229 bool Shader::is_constant_emission(float3 *emission)
230 {
231   /* If the shader has AOVs, they need to be evaluated, so we can't skip the shader. */
232   foreach (ShaderNode *node, graph->nodes) {
233     if (node->special_type == SHADER_SPECIAL_TYPE_OUTPUT_AOV) {
234       return false;
235     }
236   }
237
238   ShaderInput *surf = graph->output()->input("Surface");
239
240   if (surf->link == NULL) {
241     return false;
242   }
243
244   if (surf->link->parent->type == EmissionNode::node_type) {
245     EmissionNode *node = (EmissionNode *)surf->link->parent;
246
247     assert(node->input("Color"));
248     assert(node->input("Strength"));
249
250     if (node->input("Color")->link || node->input("Strength")->link) {
251       return false;
252     }
253
254     *emission = node->color * node->strength;
255   }
256   else if (surf->link->parent->type == BackgroundNode::node_type) {
257     BackgroundNode *node = (BackgroundNode *)surf->link->parent;
258
259     assert(node->input("Color"));
260     assert(node->input("Strength"));
261
262     if (node->input("Color")->link || node->input("Strength")->link) {
263       return false;
264     }
265
266     *emission = node->color * node->strength;
267   }
268   else {
269     return false;
270   }
271
272   return true;
273 }
274
275 void Shader::set_graph(ShaderGraph *graph_)
276 {
277   /* do this here already so that we can detect if mesh or object attributes
278    * are needed, since the node attribute callbacks check if their sockets
279    * are connected but proxy nodes should not count */
280   if (graph_) {
281     graph_->remove_proxy_nodes();
282
283     if (displacement_method != DISPLACE_BUMP) {
284       graph_->compute_displacement_hash();
285     }
286   }
287
288   /* update geometry if displacement changed */
289   if (displacement_method != DISPLACE_BUMP) {
290     const char *old_hash = (graph) ? graph->displacement_hash.c_str() : "";
291     const char *new_hash = (graph_) ? graph_->displacement_hash.c_str() : "";
292
293     if (strcmp(old_hash, new_hash) != 0) {
294       need_update_geometry = true;
295     }
296   }
297
298   /* assign graph */
299   delete graph;
300   graph = graph_;
301
302   /* Store info here before graph optimization to make sure that
303    * nodes that get optimized away still count. */
304   has_volume_connected = (graph->output()->input("Volume")->link != NULL);
305 }
306
307 void Shader::tag_update(Scene *scene)
308 {
309   /* update tag */
310   need_update = true;
311   scene->shader_manager->need_update = true;
312
313   /* if the shader previously was emissive, update light distribution,
314    * if the new shader is emissive, a light manager update tag will be
315    * done in the shader manager device update. */
316   if (use_mis && has_surface_emission)
317     scene->light_manager->need_update = true;
318
319   /* Special handle of background MIS light for now: for some reason it
320    * has use_mis set to false. We are quite close to release now, so
321    * better to be safe.
322    */
323   if (this == scene->background->get_shader(scene) &&
324       scene->light_manager->has_background_light(scene)) {
325     scene->light_manager->need_update = true;
326   }
327
328   /* quick detection of which kind of shaders we have to avoid loading
329    * e.g. surface attributes when there is only a volume shader. this could
330    * be more fine grained but it's better than nothing */
331   OutputNode *output = graph->output();
332   bool prev_has_volume = has_volume;
333   has_surface = has_surface || output->input("Surface")->link;
334   has_volume = has_volume || output->input("Volume")->link;
335   has_displacement = has_displacement || output->input("Displacement")->link;
336
337   /* get requested attributes. this could be optimized by pruning unused
338    * nodes here already, but that's the job of the shader manager currently,
339    * and may not be so great for interactive rendering where you temporarily
340    * disconnect a node */
341
342   AttributeRequestSet prev_attributes = attributes;
343
344   attributes.clear();
345   foreach (ShaderNode *node, graph->nodes)
346     node->attributes(this, &attributes);
347
348   if (has_displacement && displacement_method == DISPLACE_BOTH) {
349     attributes.add(ATTR_STD_POSITION_UNDISPLACED);
350   }
351
352   /* compare if the attributes changed, mesh manager will check
353    * need_update_geometry, update the relevant meshes and clear it. */
354   if (attributes.modified(prev_attributes)) {
355     need_update_geometry = true;
356     scene->geometry_manager->need_update = true;
357   }
358
359   if (has_volume != prev_has_volume || volume_step_rate != prev_volume_step_rate) {
360     scene->geometry_manager->need_flags_update = true;
361     scene->object_manager->need_flags_update = true;
362     prev_volume_step_rate = volume_step_rate;
363   }
364 }
365
366 void Shader::tag_used(Scene *scene)
367 {
368   /* if an unused shader suddenly gets used somewhere, it needs to be
369    * recompiled because it was skipped for compilation before */
370   if (!used) {
371     need_update = true;
372     scene->shader_manager->need_update = true;
373   }
374 }
375
376 /* Shader Manager */
377
378 ShaderManager::ShaderManager()
379 {
380   need_update = true;
381   beckmann_table_offset = TABLE_OFFSET_INVALID;
382
383   xyz_to_r = make_float3(3.2404542f, -1.5371385f, -0.4985314f);
384   xyz_to_g = make_float3(-0.9692660f, 1.8760108f, 0.0415560f);
385   xyz_to_b = make_float3(0.0556434f, -0.2040259f, 1.0572252f);
386   rgb_to_y = make_float3(0.2126729f, 0.7151522f, 0.0721750f);
387
388 #ifdef WITH_OCIO
389   OCIO::ConstConfigRcPtr config = OCIO::GetCurrentConfig();
390   if (config) {
391     if (config->hasRole("XYZ") && config->hasRole("scene_linear")) {
392       OCIO::ConstProcessorRcPtr to_rgb_processor = config->getProcessor("XYZ", "scene_linear");
393       OCIO::ConstProcessorRcPtr to_xyz_processor = config->getProcessor("scene_linear", "XYZ");
394       if (to_rgb_processor && to_xyz_processor) {
395         float r[] = {1.0f, 0.0f, 0.0f};
396         float g[] = {0.0f, 1.0f, 0.0f};
397         float b[] = {0.0f, 0.0f, 1.0f};
398         to_xyz_processor->applyRGB(r);
399         to_xyz_processor->applyRGB(g);
400         to_xyz_processor->applyRGB(b);
401         rgb_to_y = make_float3(r[1], g[1], b[1]);
402
403         float x[] = {1.0f, 0.0f, 0.0f};
404         float y[] = {0.0f, 1.0f, 0.0f};
405         float z[] = {0.0f, 0.0f, 1.0f};
406         to_rgb_processor->applyRGB(x);
407         to_rgb_processor->applyRGB(y);
408         to_rgb_processor->applyRGB(z);
409         xyz_to_r = make_float3(x[0], y[0], z[0]);
410         xyz_to_g = make_float3(x[1], y[1], z[1]);
411         xyz_to_b = make_float3(x[2], y[2], z[2]);
412       }
413     }
414   }
415 #endif
416 }
417
418 ShaderManager::~ShaderManager()
419 {
420 }
421
422 ShaderManager *ShaderManager::create(int shadingsystem)
423 {
424   ShaderManager *manager;
425
426   (void)shadingsystem; /* Ignored when built without OSL. */
427
428 #ifdef WITH_OSL
429   if (shadingsystem == SHADINGSYSTEM_OSL) {
430     manager = new OSLShaderManager();
431   }
432   else
433 #endif
434   {
435     manager = new SVMShaderManager();
436   }
437
438   return manager;
439 }
440
441 uint ShaderManager::get_attribute_id(ustring name)
442 {
443   thread_scoped_spin_lock lock(attribute_lock_);
444
445   /* get a unique id for each name, for SVM attribute lookup */
446   AttributeIDMap::iterator it = unique_attribute_id.find(name);
447
448   if (it != unique_attribute_id.end())
449     return it->second;
450
451   uint id = (uint)ATTR_STD_NUM + unique_attribute_id.size();
452   unique_attribute_id[name] = id;
453   return id;
454 }
455
456 uint ShaderManager::get_attribute_id(AttributeStandard std)
457 {
458   return (uint)std;
459 }
460
461 int ShaderManager::get_shader_id(Shader *shader, bool smooth)
462 {
463   /* get a shader id to pass to the kernel */
464   int id = shader->id;
465
466   /* smooth flag */
467   if (smooth)
468     id |= SHADER_SMOOTH_NORMAL;
469
470   /* default flags */
471   id |= SHADER_CAST_SHADOW | SHADER_AREA_LIGHT;
472
473   return id;
474 }
475
476 void ShaderManager::update_shaders_used(Scene *scene)
477 {
478   if (!need_update) {
479     return;
480   }
481
482   /* figure out which shaders are in use, so SVM/OSL can skip compiling them
483    * for speed and avoid loading image textures into memory */
484   uint id = 0;
485   foreach (Shader *shader, scene->shaders) {
486     shader->used = false;
487     shader->id = id++;
488   }
489
490   scene->default_surface->used = true;
491   scene->default_light->used = true;
492   scene->default_background->used = true;
493   scene->default_empty->used = true;
494
495   if (scene->background->shader)
496     scene->background->shader->used = true;
497
498   foreach (Geometry *geom, scene->geometry)
499     foreach (Shader *shader, geom->used_shaders)
500       shader->used = true;
501
502   foreach (Light *light, scene->lights)
503     if (light->shader)
504       light->shader->used = true;
505 }
506
507 void ShaderManager::device_update_common(Device *device,
508                                          DeviceScene *dscene,
509                                          Scene *scene,
510                                          Progress & /*progress*/)
511 {
512   dscene->shaders.free();
513
514   if (scene->shaders.size() == 0)
515     return;
516
517   KernelShader *kshader = dscene->shaders.alloc(scene->shaders.size());
518   bool has_volumes = false;
519   bool has_transparent_shadow = false;
520
521   foreach (Shader *shader, scene->shaders) {
522     uint flag = 0;
523
524     if (shader->use_mis)
525       flag |= SD_USE_MIS;
526     if (shader->has_surface_transparent && shader->use_transparent_shadow)
527       flag |= SD_HAS_TRANSPARENT_SHADOW;
528     if (shader->has_volume) {
529       flag |= SD_HAS_VOLUME;
530       has_volumes = true;
531
532       /* todo: this could check more fine grained, to skip useless volumes
533        * enclosed inside an opaque bsdf.
534        */
535       flag |= SD_HAS_TRANSPARENT_SHADOW;
536     }
537     /* in this case we can assume transparent surface */
538     if (shader->has_volume_connected && !shader->has_surface)
539       flag |= SD_HAS_ONLY_VOLUME;
540     if (shader->has_volume) {
541       if (shader->heterogeneous_volume && shader->has_volume_spatial_varying)
542         flag |= SD_HETEROGENEOUS_VOLUME;
543     }
544     if (shader->has_volume_attribute_dependency)
545       flag |= SD_NEED_VOLUME_ATTRIBUTES;
546     if (shader->has_bssrdf_bump)
547       flag |= SD_HAS_BSSRDF_BUMP;
548     if (device->info.has_volume_decoupled) {
549       if (shader->volume_sampling_method == VOLUME_SAMPLING_EQUIANGULAR)
550         flag |= SD_VOLUME_EQUIANGULAR;
551       if (shader->volume_sampling_method == VOLUME_SAMPLING_MULTIPLE_IMPORTANCE)
552         flag |= SD_VOLUME_MIS;
553     }
554     if (shader->volume_interpolation_method == VOLUME_INTERPOLATION_CUBIC)
555       flag |= SD_VOLUME_CUBIC;
556     if (shader->has_bump)
557       flag |= SD_HAS_BUMP;
558     if (shader->displacement_method != DISPLACE_BUMP)
559       flag |= SD_HAS_DISPLACEMENT;
560
561     /* constant emission check */
562     float3 constant_emission = make_float3(0.0f, 0.0f, 0.0f);
563     if (shader->is_constant_emission(&constant_emission))
564       flag |= SD_HAS_CONSTANT_EMISSION;
565
566     uint32_t cryptomatte_id = util_murmur_hash3(shader->name.c_str(), shader->name.length(), 0);
567
568     /* regular shader */
569     kshader->flags = flag;
570     kshader->pass_id = shader->pass_id;
571     kshader->constant_emission[0] = constant_emission.x;
572     kshader->constant_emission[1] = constant_emission.y;
573     kshader->constant_emission[2] = constant_emission.z;
574     kshader->cryptomatte_id = util_hash_to_float(cryptomatte_id);
575     kshader++;
576
577     has_transparent_shadow |= (flag & SD_HAS_TRANSPARENT_SHADOW) != 0;
578   }
579
580   dscene->shaders.copy_to_device();
581
582   /* lookup tables */
583   KernelTables *ktables = &dscene->data.tables;
584
585   /* beckmann lookup table */
586   if (beckmann_table_offset == TABLE_OFFSET_INVALID) {
587     if (!beckmann_table_ready) {
588       thread_scoped_lock lock(lookup_table_mutex);
589       if (!beckmann_table_ready) {
590         beckmann_table_build(beckmann_table);
591         beckmann_table_ready = true;
592       }
593     }
594     beckmann_table_offset = scene->lookup_tables->add_table(dscene, beckmann_table);
595   }
596   ktables->beckmann_offset = (int)beckmann_table_offset;
597
598   /* integrator */
599   KernelIntegrator *kintegrator = &dscene->data.integrator;
600   kintegrator->use_volumes = has_volumes;
601   /* TODO(sergey): De-duplicate with flags set in integrator.cpp. */
602   kintegrator->transparent_shadows = has_transparent_shadow;
603
604   /* film */
605   KernelFilm *kfilm = &dscene->data.film;
606   /* color space, needs to be here because e.g. displacement shaders could depend on it */
607   kfilm->xyz_to_r = float3_to_float4(xyz_to_r);
608   kfilm->xyz_to_g = float3_to_float4(xyz_to_g);
609   kfilm->xyz_to_b = float3_to_float4(xyz_to_b);
610   kfilm->rgb_to_y = float3_to_float4(rgb_to_y);
611 }
612
613 void ShaderManager::device_free_common(Device *, DeviceScene *dscene, Scene *scene)
614 {
615   scene->lookup_tables->remove_table(&beckmann_table_offset);
616
617   dscene->shaders.free();
618 }
619
620 void ShaderManager::add_default(Scene *scene)
621 {
622   /* default surface */
623   {
624     ShaderGraph *graph = new ShaderGraph();
625
626     DiffuseBsdfNode *diffuse = new DiffuseBsdfNode();
627     diffuse->color = make_float3(0.8f, 0.8f, 0.8f);
628     graph->add(diffuse);
629
630     graph->connect(diffuse->output("BSDF"), graph->output()->input("Surface"));
631
632     Shader *shader = new Shader();
633     shader->name = "default_surface";
634     shader->set_graph(graph);
635     scene->shaders.push_back(shader);
636     scene->default_surface = shader;
637     shader->tag_update(scene);
638   }
639
640   /* default volume */
641   {
642     ShaderGraph *graph = new ShaderGraph();
643
644     PrincipledVolumeNode *principled = new PrincipledVolumeNode();
645     graph->add(principled);
646
647     graph->connect(principled->output("Volume"), graph->output()->input("Volume"));
648
649     Shader *shader = new Shader();
650     shader->name = "default_volume";
651     shader->set_graph(graph);
652     scene->shaders.push_back(shader);
653     scene->default_volume = shader;
654     shader->tag_update(scene);
655   }
656
657   /* default light */
658   {
659     ShaderGraph *graph = new ShaderGraph();
660
661     EmissionNode *emission = new EmissionNode();
662     emission->color = make_float3(0.8f, 0.8f, 0.8f);
663     emission->strength = 0.0f;
664     graph->add(emission);
665
666     graph->connect(emission->output("Emission"), graph->output()->input("Surface"));
667
668     Shader *shader = new Shader();
669     shader->name = "default_light";
670     shader->set_graph(graph);
671     scene->shaders.push_back(shader);
672     scene->default_light = shader;
673     shader->tag_update(scene);
674   }
675
676   /* default background */
677   {
678     ShaderGraph *graph = new ShaderGraph();
679
680     Shader *shader = new Shader();
681     shader->name = "default_background";
682     shader->set_graph(graph);
683     scene->shaders.push_back(shader);
684     scene->default_background = shader;
685     shader->tag_update(scene);
686   }
687
688   /* default empty */
689   {
690     ShaderGraph *graph = new ShaderGraph();
691
692     Shader *shader = new Shader();
693     shader->name = "default_empty";
694     shader->set_graph(graph);
695     scene->shaders.push_back(shader);
696     scene->default_empty = shader;
697     shader->tag_update(scene);
698   }
699 }
700
701 void ShaderManager::get_requested_graph_features(ShaderGraph *graph,
702                                                  DeviceRequestedFeatures *requested_features)
703 {
704   foreach (ShaderNode *node, graph->nodes) {
705     requested_features->max_nodes_group = max(requested_features->max_nodes_group,
706                                               node->get_group());
707     requested_features->nodes_features |= node->get_feature();
708     if (node->special_type == SHADER_SPECIAL_TYPE_CLOSURE) {
709       BsdfBaseNode *bsdf_node = static_cast<BsdfBaseNode *>(node);
710       if (CLOSURE_IS_VOLUME(bsdf_node->closure)) {
711         requested_features->nodes_features |= NODE_FEATURE_VOLUME;
712       }
713       else if (CLOSURE_IS_PRINCIPLED(bsdf_node->closure)) {
714         requested_features->use_principled = true;
715       }
716     }
717     if (node->has_surface_bssrdf()) {
718       requested_features->use_subsurface = true;
719     }
720     if (node->has_surface_transparent()) {
721       requested_features->use_transparent = true;
722     }
723     if (node->has_raytrace()) {
724       requested_features->use_shader_raytrace = true;
725     }
726   }
727 }
728
729 void ShaderManager::get_requested_features(Scene *scene,
730                                            DeviceRequestedFeatures *requested_features)
731 {
732   requested_features->max_nodes_group = NODE_GROUP_LEVEL_0;
733   requested_features->nodes_features = 0;
734   for (int i = 0; i < scene->shaders.size(); i++) {
735     Shader *shader = scene->shaders[i];
736     if (!shader->used) {
737       continue;
738     }
739
740     /* Gather requested features from all the nodes from the graph nodes. */
741     get_requested_graph_features(shader->graph, requested_features);
742     ShaderNode *output_node = shader->graph->output();
743     if (output_node->input("Displacement")->link != NULL) {
744       requested_features->nodes_features |= NODE_FEATURE_BUMP;
745       if (shader->displacement_method == DISPLACE_BOTH) {
746         requested_features->nodes_features |= NODE_FEATURE_BUMP_STATE;
747         requested_features->max_nodes_group = max(requested_features->max_nodes_group,
748                                                   NODE_GROUP_LEVEL_1);
749       }
750     }
751     /* On top of volume nodes, also check if we need volume sampling because
752      * e.g. an Emission node would slip through the NODE_FEATURE_VOLUME check */
753     if (shader->has_volume)
754       requested_features->use_volume |= true;
755   }
756 }
757
758 void ShaderManager::free_memory()
759 {
760   beckmann_table.free_memory();
761
762 #ifdef WITH_OSL
763   OSLShaderManager::free_memory();
764 #endif
765
766   ColorSpaceManager::free_memory();
767 }
768
769 float ShaderManager::linear_rgb_to_gray(float3 c)
770 {
771   return dot(c, rgb_to_y);
772 }
773
774 string ShaderManager::get_cryptomatte_materials(Scene *scene)
775 {
776   string manifest = "{";
777   unordered_set<ustring, ustringHash> materials;
778   foreach (Shader *shader, scene->shaders) {
779     if (materials.count(shader->name)) {
780       continue;
781     }
782     materials.insert(shader->name);
783     uint32_t cryptomatte_id = util_murmur_hash3(shader->name.c_str(), shader->name.length(), 0);
784     manifest += string_printf("\"%s\":\"%08x\",", shader->name.c_str(), cryptomatte_id);
785   }
786   manifest[manifest.size() - 1] = '}';
787   return manifest;
788 }
789
790 CCL_NAMESPACE_END