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