Cycles: support loading images from arbitrary OpenColorIO color space
[blender.git] / intern / cycles / blender / blender_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 "render/background.h"
18 #include "render/colorspace.h"
19 #include "render/graph.h"
20 #include "render/light.h"
21 #include "render/nodes.h"
22 #include "render/osl.h"
23 #include "render/scene.h"
24 #include "render/shader.h"
25
26 #include "blender/blender_texture.h"
27 #include "blender/blender_sync.h"
28 #include "blender/blender_util.h"
29
30 #include "util/util_debug.h"
31 #include "util/util_foreach.h"
32 #include "util/util_string.h"
33 #include "util/util_set.h"
34 #include "util/util_task.h"
35
36 CCL_NAMESPACE_BEGIN
37
38 typedef map<void *, ShaderInput *> PtrInputMap;
39 typedef map<void *, ShaderOutput *> PtrOutputMap;
40 typedef map<string, ConvertNode *> ProxyMap;
41
42 /* Find */
43
44 void BlenderSync::find_shader(BL::ID &id, vector<Shader *> &used_shaders, Shader *default_shader)
45 {
46   Shader *shader = (id) ? shader_map.find(id) : default_shader;
47
48   used_shaders.push_back(shader);
49   shader->tag_used(scene);
50 }
51
52 /* RNA translation utilities */
53
54 static VolumeSampling get_volume_sampling(PointerRNA &ptr)
55 {
56   return (VolumeSampling)get_enum(
57       ptr, "volume_sampling", VOLUME_NUM_SAMPLING, VOLUME_SAMPLING_DISTANCE);
58 }
59
60 static VolumeInterpolation get_volume_interpolation(PointerRNA &ptr)
61 {
62   return (VolumeInterpolation)get_enum(
63       ptr, "volume_interpolation", VOLUME_NUM_INTERPOLATION, VOLUME_INTERPOLATION_LINEAR);
64 }
65
66 static DisplacementMethod get_displacement_method(PointerRNA &ptr)
67 {
68   return (DisplacementMethod)get_enum(
69       ptr, "displacement_method", DISPLACE_NUM_METHODS, DISPLACE_BUMP);
70 }
71
72 static int validate_enum_value(int value, int num_values, int default_value)
73 {
74   if (value >= num_values) {
75     return default_value;
76   }
77   return value;
78 }
79
80 template<typename NodeType> static InterpolationType get_image_interpolation(NodeType &b_node)
81 {
82   int value = b_node.interpolation();
83   return (InterpolationType)validate_enum_value(
84       value, INTERPOLATION_NUM_TYPES, INTERPOLATION_LINEAR);
85 }
86
87 template<typename NodeType> static ExtensionType get_image_extension(NodeType &b_node)
88 {
89   int value = b_node.extension();
90   return (ExtensionType)validate_enum_value(value, EXTENSION_NUM_TYPES, EXTENSION_REPEAT);
91 }
92
93 /* Graph */
94
95 static BL::NodeSocket get_node_output(BL::Node &b_node, const string &name)
96 {
97   BL::Node::outputs_iterator b_out;
98
99   for (b_node.outputs.begin(b_out); b_out != b_node.outputs.end(); ++b_out)
100     if (b_out->name() == name)
101       return *b_out;
102
103   assert(0);
104
105   return *b_out;
106 }
107
108 static float3 get_node_output_rgba(BL::Node &b_node, const string &name)
109 {
110   BL::NodeSocket b_sock = get_node_output(b_node, name);
111   float value[4];
112   RNA_float_get_array(&b_sock.ptr, "default_value", value);
113   return make_float3(value[0], value[1], value[2]);
114 }
115
116 static float get_node_output_value(BL::Node &b_node, const string &name)
117 {
118   BL::NodeSocket b_sock = get_node_output(b_node, name);
119   return RNA_float_get(&b_sock.ptr, "default_value");
120 }
121
122 static float3 get_node_output_vector(BL::Node &b_node, const string &name)
123 {
124   BL::NodeSocket b_sock = get_node_output(b_node, name);
125   float value[3];
126   RNA_float_get_array(&b_sock.ptr, "default_value", value);
127   return make_float3(value[0], value[1], value[2]);
128 }
129
130 static SocketType::Type convert_socket_type(BL::NodeSocket &b_socket)
131 {
132   switch (b_socket.type()) {
133     case BL::NodeSocket::type_VALUE:
134       return SocketType::FLOAT;
135     case BL::NodeSocket::type_INT:
136       return SocketType::INT;
137     case BL::NodeSocket::type_VECTOR:
138       return SocketType::VECTOR;
139     case BL::NodeSocket::type_RGBA:
140       return SocketType::COLOR;
141     case BL::NodeSocket::type_STRING:
142       return SocketType::STRING;
143     case BL::NodeSocket::type_SHADER:
144       return SocketType::CLOSURE;
145
146     default:
147       return SocketType::UNDEFINED;
148   }
149 }
150
151 static void set_default_value(ShaderInput *input,
152                               BL::NodeSocket &b_sock,
153                               BL::BlendData &b_data,
154                               BL::ID &b_id)
155 {
156   Node *node = input->parent;
157   const SocketType &socket = input->socket_type;
158
159   /* copy values for non linked inputs */
160   switch (input->type()) {
161     case SocketType::FLOAT: {
162       node->set(socket, get_float(b_sock.ptr, "default_value"));
163       break;
164     }
165     case SocketType::INT: {
166       node->set(socket, get_int(b_sock.ptr, "default_value"));
167       break;
168     }
169     case SocketType::COLOR: {
170       node->set(socket, float4_to_float3(get_float4(b_sock.ptr, "default_value")));
171       break;
172     }
173     case SocketType::NORMAL:
174     case SocketType::POINT:
175     case SocketType::VECTOR: {
176       node->set(socket, get_float3(b_sock.ptr, "default_value"));
177       break;
178     }
179     case SocketType::STRING: {
180       node->set(
181           socket,
182           (ustring)blender_absolute_path(b_data, b_id, get_string(b_sock.ptr, "default_value")));
183       break;
184     }
185     default:
186       break;
187   }
188 }
189
190 static void get_tex_mapping(TextureMapping *mapping, BL::TexMapping &b_mapping)
191 {
192   if (!b_mapping)
193     return;
194
195   mapping->translation = get_float3(b_mapping.translation());
196   mapping->rotation = get_float3(b_mapping.rotation());
197   mapping->scale = get_float3(b_mapping.scale());
198   mapping->type = (TextureMapping::Type)b_mapping.vector_type();
199
200   mapping->x_mapping = (TextureMapping::Mapping)b_mapping.mapping_x();
201   mapping->y_mapping = (TextureMapping::Mapping)b_mapping.mapping_y();
202   mapping->z_mapping = (TextureMapping::Mapping)b_mapping.mapping_z();
203 }
204
205 static void get_tex_mapping(TextureMapping *mapping, BL::ShaderNodeMapping &b_mapping)
206 {
207   if (!b_mapping)
208     return;
209
210   mapping->translation = get_float3(b_mapping.translation());
211   mapping->rotation = get_float3(b_mapping.rotation());
212   mapping->scale = get_float3(b_mapping.scale());
213   mapping->type = (TextureMapping::Type)b_mapping.vector_type();
214
215   mapping->use_minmax = b_mapping.use_min() || b_mapping.use_max();
216
217   if (b_mapping.use_min())
218     mapping->min = get_float3(b_mapping.min());
219   if (b_mapping.use_max())
220     mapping->max = get_float3(b_mapping.max());
221 }
222
223 static ShaderNode *add_node(Scene *scene,
224                             BL::RenderEngine &b_engine,
225                             BL::BlendData &b_data,
226                             BL::Depsgraph &b_depsgraph,
227                             BL::Scene &b_scene,
228                             ShaderGraph *graph,
229                             BL::ShaderNodeTree &b_ntree,
230                             BL::ShaderNode &b_node)
231 {
232   ShaderNode *node = NULL;
233
234   /* existing blender nodes */
235   if (b_node.is_a(&RNA_ShaderNodeRGBCurve)) {
236     BL::ShaderNodeRGBCurve b_curve_node(b_node);
237     BL::CurveMapping mapping(b_curve_node.mapping());
238     RGBCurvesNode *curves = new RGBCurvesNode();
239     curvemapping_color_to_array(mapping, curves->curves, RAMP_TABLE_SIZE, true);
240     curvemapping_minmax(mapping, true, &curves->min_x, &curves->max_x);
241     node = curves;
242   }
243   if (b_node.is_a(&RNA_ShaderNodeVectorCurve)) {
244     BL::ShaderNodeVectorCurve b_curve_node(b_node);
245     BL::CurveMapping mapping(b_curve_node.mapping());
246     VectorCurvesNode *curves = new VectorCurvesNode();
247     curvemapping_color_to_array(mapping, curves->curves, RAMP_TABLE_SIZE, false);
248     curvemapping_minmax(mapping, false, &curves->min_x, &curves->max_x);
249     node = curves;
250   }
251   else if (b_node.is_a(&RNA_ShaderNodeValToRGB)) {
252     RGBRampNode *ramp = new RGBRampNode();
253     BL::ShaderNodeValToRGB b_ramp_node(b_node);
254     BL::ColorRamp b_color_ramp(b_ramp_node.color_ramp());
255     colorramp_to_array(b_color_ramp, ramp->ramp, ramp->ramp_alpha, RAMP_TABLE_SIZE);
256     ramp->interpolate = b_color_ramp.interpolation() != BL::ColorRamp::interpolation_CONSTANT;
257     node = ramp;
258   }
259   else if (b_node.is_a(&RNA_ShaderNodeRGB)) {
260     ColorNode *color = new ColorNode();
261     color->value = get_node_output_rgba(b_node, "Color");
262     node = color;
263   }
264   else if (b_node.is_a(&RNA_ShaderNodeValue)) {
265     ValueNode *value = new ValueNode();
266     value->value = get_node_output_value(b_node, "Value");
267     node = value;
268   }
269   else if (b_node.is_a(&RNA_ShaderNodeCameraData)) {
270     node = new CameraNode();
271   }
272   else if (b_node.is_a(&RNA_ShaderNodeInvert)) {
273     node = new InvertNode();
274   }
275   else if (b_node.is_a(&RNA_ShaderNodeGamma)) {
276     node = new GammaNode();
277   }
278   else if (b_node.is_a(&RNA_ShaderNodeBrightContrast)) {
279     node = new BrightContrastNode();
280   }
281   else if (b_node.is_a(&RNA_ShaderNodeMixRGB)) {
282     BL::ShaderNodeMixRGB b_mix_node(b_node);
283     MixNode *mix = new MixNode();
284     mix->type = (NodeMix)b_mix_node.blend_type();
285     mix->use_clamp = b_mix_node.use_clamp();
286     node = mix;
287   }
288   else if (b_node.is_a(&RNA_ShaderNodeSeparateRGB)) {
289     node = new SeparateRGBNode();
290   }
291   else if (b_node.is_a(&RNA_ShaderNodeCombineRGB)) {
292     node = new CombineRGBNode();
293   }
294   else if (b_node.is_a(&RNA_ShaderNodeSeparateHSV)) {
295     node = new SeparateHSVNode();
296   }
297   else if (b_node.is_a(&RNA_ShaderNodeCombineHSV)) {
298     node = new CombineHSVNode();
299   }
300   else if (b_node.is_a(&RNA_ShaderNodeSeparateXYZ)) {
301     node = new SeparateXYZNode();
302   }
303   else if (b_node.is_a(&RNA_ShaderNodeCombineXYZ)) {
304     node = new CombineXYZNode();
305   }
306   else if (b_node.is_a(&RNA_ShaderNodeHueSaturation)) {
307     node = new HSVNode();
308   }
309   else if (b_node.is_a(&RNA_ShaderNodeRGBToBW)) {
310     node = new RGBToBWNode();
311   }
312   else if (b_node.is_a(&RNA_ShaderNodeMath)) {
313     BL::ShaderNodeMath b_math_node(b_node);
314     MathNode *math = new MathNode();
315     math->type = (NodeMath)b_math_node.operation();
316     math->use_clamp = b_math_node.use_clamp();
317     node = math;
318   }
319   else if (b_node.is_a(&RNA_ShaderNodeVectorMath)) {
320     BL::ShaderNodeVectorMath b_vector_math_node(b_node);
321     VectorMathNode *vmath = new VectorMathNode();
322     vmath->type = (NodeVectorMath)b_vector_math_node.operation();
323     node = vmath;
324   }
325   else if (b_node.is_a(&RNA_ShaderNodeVectorTransform)) {
326     BL::ShaderNodeVectorTransform b_vector_transform_node(b_node);
327     VectorTransformNode *vtransform = new VectorTransformNode();
328     vtransform->type = (NodeVectorTransformType)b_vector_transform_node.vector_type();
329     vtransform->convert_from = (NodeVectorTransformConvertSpace)
330                                    b_vector_transform_node.convert_from();
331     vtransform->convert_to = (NodeVectorTransformConvertSpace)b_vector_transform_node.convert_to();
332     node = vtransform;
333   }
334   else if (b_node.is_a(&RNA_ShaderNodeNormal)) {
335     BL::Node::outputs_iterator out_it;
336     b_node.outputs.begin(out_it);
337
338     NormalNode *norm = new NormalNode();
339     norm->direction = get_node_output_vector(b_node, "Normal");
340     node = norm;
341   }
342   else if (b_node.is_a(&RNA_ShaderNodeMapping)) {
343     BL::ShaderNodeMapping b_mapping_node(b_node);
344     MappingNode *mapping = new MappingNode();
345
346     get_tex_mapping(&mapping->tex_mapping, b_mapping_node);
347
348     node = mapping;
349   }
350   else if (b_node.is_a(&RNA_ShaderNodeFresnel)) {
351     node = new FresnelNode();
352   }
353   else if (b_node.is_a(&RNA_ShaderNodeLayerWeight)) {
354     node = new LayerWeightNode();
355   }
356   else if (b_node.is_a(&RNA_ShaderNodeAddShader)) {
357     node = new AddClosureNode();
358   }
359   else if (b_node.is_a(&RNA_ShaderNodeMixShader)) {
360     node = new MixClosureNode();
361   }
362   else if (b_node.is_a(&RNA_ShaderNodeAttribute)) {
363     BL::ShaderNodeAttribute b_attr_node(b_node);
364     AttributeNode *attr = new AttributeNode();
365     attr->attribute = b_attr_node.attribute_name();
366     node = attr;
367   }
368   else if (b_node.is_a(&RNA_ShaderNodeBackground)) {
369     node = new BackgroundNode();
370   }
371   else if (b_node.is_a(&RNA_ShaderNodeHoldout)) {
372     node = new HoldoutNode();
373   }
374   else if (b_node.is_a(&RNA_ShaderNodeBsdfAnisotropic)) {
375     BL::ShaderNodeBsdfAnisotropic b_aniso_node(b_node);
376     AnisotropicBsdfNode *aniso = new AnisotropicBsdfNode();
377
378     switch (b_aniso_node.distribution()) {
379       case BL::ShaderNodeBsdfAnisotropic::distribution_BECKMANN:
380         aniso->distribution = CLOSURE_BSDF_MICROFACET_BECKMANN_ANISO_ID;
381         break;
382       case BL::ShaderNodeBsdfAnisotropic::distribution_GGX:
383         aniso->distribution = CLOSURE_BSDF_MICROFACET_GGX_ANISO_ID;
384         break;
385       case BL::ShaderNodeBsdfAnisotropic::distribution_MULTI_GGX:
386         aniso->distribution = CLOSURE_BSDF_MICROFACET_MULTI_GGX_ANISO_ID;
387         break;
388       case BL::ShaderNodeBsdfAnisotropic::distribution_ASHIKHMIN_SHIRLEY:
389         aniso->distribution = CLOSURE_BSDF_ASHIKHMIN_SHIRLEY_ANISO_ID;
390         break;
391     }
392
393     node = aniso;
394   }
395   else if (b_node.is_a(&RNA_ShaderNodeBsdfDiffuse)) {
396     node = new DiffuseBsdfNode();
397   }
398   else if (b_node.is_a(&RNA_ShaderNodeSubsurfaceScattering)) {
399     BL::ShaderNodeSubsurfaceScattering b_subsurface_node(b_node);
400
401     SubsurfaceScatteringNode *subsurface = new SubsurfaceScatteringNode();
402
403     switch (b_subsurface_node.falloff()) {
404       case BL::ShaderNodeSubsurfaceScattering::falloff_CUBIC:
405         subsurface->falloff = CLOSURE_BSSRDF_CUBIC_ID;
406         break;
407       case BL::ShaderNodeSubsurfaceScattering::falloff_GAUSSIAN:
408         subsurface->falloff = CLOSURE_BSSRDF_GAUSSIAN_ID;
409         break;
410       case BL::ShaderNodeSubsurfaceScattering::falloff_BURLEY:
411         subsurface->falloff = CLOSURE_BSSRDF_BURLEY_ID;
412         break;
413       case BL::ShaderNodeSubsurfaceScattering::falloff_RANDOM_WALK:
414         subsurface->falloff = CLOSURE_BSSRDF_RANDOM_WALK_ID;
415         break;
416     }
417
418     node = subsurface;
419   }
420   else if (b_node.is_a(&RNA_ShaderNodeBsdfGlossy)) {
421     BL::ShaderNodeBsdfGlossy b_glossy_node(b_node);
422     GlossyBsdfNode *glossy = new GlossyBsdfNode();
423
424     switch (b_glossy_node.distribution()) {
425       case BL::ShaderNodeBsdfGlossy::distribution_SHARP:
426         glossy->distribution = CLOSURE_BSDF_REFLECTION_ID;
427         break;
428       case BL::ShaderNodeBsdfGlossy::distribution_BECKMANN:
429         glossy->distribution = CLOSURE_BSDF_MICROFACET_BECKMANN_ID;
430         break;
431       case BL::ShaderNodeBsdfGlossy::distribution_GGX:
432         glossy->distribution = CLOSURE_BSDF_MICROFACET_GGX_ID;
433         break;
434       case BL::ShaderNodeBsdfGlossy::distribution_ASHIKHMIN_SHIRLEY:
435         glossy->distribution = CLOSURE_BSDF_ASHIKHMIN_SHIRLEY_ID;
436         break;
437       case BL::ShaderNodeBsdfGlossy::distribution_MULTI_GGX:
438         glossy->distribution = CLOSURE_BSDF_MICROFACET_MULTI_GGX_ID;
439         break;
440     }
441     node = glossy;
442   }
443   else if (b_node.is_a(&RNA_ShaderNodeBsdfGlass)) {
444     BL::ShaderNodeBsdfGlass b_glass_node(b_node);
445     GlassBsdfNode *glass = new GlassBsdfNode();
446     switch (b_glass_node.distribution()) {
447       case BL::ShaderNodeBsdfGlass::distribution_SHARP:
448         glass->distribution = CLOSURE_BSDF_SHARP_GLASS_ID;
449         break;
450       case BL::ShaderNodeBsdfGlass::distribution_BECKMANN:
451         glass->distribution = CLOSURE_BSDF_MICROFACET_BECKMANN_GLASS_ID;
452         break;
453       case BL::ShaderNodeBsdfGlass::distribution_GGX:
454         glass->distribution = CLOSURE_BSDF_MICROFACET_GGX_GLASS_ID;
455         break;
456       case BL::ShaderNodeBsdfGlass::distribution_MULTI_GGX:
457         glass->distribution = CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID;
458         break;
459     }
460     node = glass;
461   }
462   else if (b_node.is_a(&RNA_ShaderNodeBsdfRefraction)) {
463     BL::ShaderNodeBsdfRefraction b_refraction_node(b_node);
464     RefractionBsdfNode *refraction = new RefractionBsdfNode();
465     switch (b_refraction_node.distribution()) {
466       case BL::ShaderNodeBsdfRefraction::distribution_SHARP:
467         refraction->distribution = CLOSURE_BSDF_REFRACTION_ID;
468         break;
469       case BL::ShaderNodeBsdfRefraction::distribution_BECKMANN:
470         refraction->distribution = CLOSURE_BSDF_MICROFACET_BECKMANN_REFRACTION_ID;
471         break;
472       case BL::ShaderNodeBsdfRefraction::distribution_GGX:
473         refraction->distribution = CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID;
474         break;
475     }
476     node = refraction;
477   }
478   else if (b_node.is_a(&RNA_ShaderNodeBsdfToon)) {
479     BL::ShaderNodeBsdfToon b_toon_node(b_node);
480     ToonBsdfNode *toon = new ToonBsdfNode();
481     switch (b_toon_node.component()) {
482       case BL::ShaderNodeBsdfToon::component_DIFFUSE:
483         toon->component = CLOSURE_BSDF_DIFFUSE_TOON_ID;
484         break;
485       case BL::ShaderNodeBsdfToon::component_GLOSSY:
486         toon->component = CLOSURE_BSDF_GLOSSY_TOON_ID;
487         break;
488     }
489     node = toon;
490   }
491   else if (b_node.is_a(&RNA_ShaderNodeBsdfHair)) {
492     BL::ShaderNodeBsdfHair b_hair_node(b_node);
493     HairBsdfNode *hair = new HairBsdfNode();
494     switch (b_hair_node.component()) {
495       case BL::ShaderNodeBsdfHair::component_Reflection:
496         hair->component = CLOSURE_BSDF_HAIR_REFLECTION_ID;
497         break;
498       case BL::ShaderNodeBsdfHair::component_Transmission:
499         hair->component = CLOSURE_BSDF_HAIR_TRANSMISSION_ID;
500         break;
501     }
502     node = hair;
503   }
504   else if (b_node.is_a(&RNA_ShaderNodeBsdfHairPrincipled)) {
505     BL::ShaderNodeBsdfHairPrincipled b_principled_hair_node(b_node);
506     PrincipledHairBsdfNode *principled_hair = new PrincipledHairBsdfNode();
507     principled_hair->parametrization = (NodePrincipledHairParametrization)get_enum(
508         b_principled_hair_node.ptr,
509         "parametrization",
510         NODE_PRINCIPLED_HAIR_NUM,
511         NODE_PRINCIPLED_HAIR_REFLECTANCE);
512     node = principled_hair;
513   }
514   else if (b_node.is_a(&RNA_ShaderNodeBsdfPrincipled)) {
515     BL::ShaderNodeBsdfPrincipled b_principled_node(b_node);
516     PrincipledBsdfNode *principled = new PrincipledBsdfNode();
517     switch (b_principled_node.distribution()) {
518       case BL::ShaderNodeBsdfPrincipled::distribution_GGX:
519         principled->distribution = CLOSURE_BSDF_MICROFACET_GGX_GLASS_ID;
520         break;
521       case BL::ShaderNodeBsdfPrincipled::distribution_MULTI_GGX:
522         principled->distribution = CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID;
523         break;
524     }
525     switch (b_principled_node.subsurface_method()) {
526       case BL::ShaderNodeBsdfPrincipled::subsurface_method_BURLEY:
527         principled->subsurface_method = CLOSURE_BSSRDF_PRINCIPLED_ID;
528         break;
529       case BL::ShaderNodeBsdfPrincipled::subsurface_method_RANDOM_WALK:
530         principled->subsurface_method = CLOSURE_BSSRDF_PRINCIPLED_RANDOM_WALK_ID;
531         break;
532     }
533     node = principled;
534   }
535   else if (b_node.is_a(&RNA_ShaderNodeBsdfTranslucent)) {
536     node = new TranslucentBsdfNode();
537   }
538   else if (b_node.is_a(&RNA_ShaderNodeBsdfTransparent)) {
539     node = new TransparentBsdfNode();
540   }
541   else if (b_node.is_a(&RNA_ShaderNodeBsdfVelvet)) {
542     node = new VelvetBsdfNode();
543   }
544   else if (b_node.is_a(&RNA_ShaderNodeEmission)) {
545     node = new EmissionNode();
546   }
547   else if (b_node.is_a(&RNA_ShaderNodeAmbientOcclusion)) {
548     BL::ShaderNodeAmbientOcclusion b_ao_node(b_node);
549     AmbientOcclusionNode *ao = new AmbientOcclusionNode();
550     ao->samples = b_ao_node.samples();
551     ao->inside = b_ao_node.inside();
552     ao->only_local = b_ao_node.only_local();
553     node = ao;
554   }
555   else if (b_node.is_a(&RNA_ShaderNodeVolumeScatter)) {
556     node = new ScatterVolumeNode();
557   }
558   else if (b_node.is_a(&RNA_ShaderNodeVolumeAbsorption)) {
559     node = new AbsorptionVolumeNode();
560   }
561   else if (b_node.is_a(&RNA_ShaderNodeVolumePrincipled)) {
562     PrincipledVolumeNode *principled = new PrincipledVolumeNode();
563     node = principled;
564   }
565   else if (b_node.is_a(&RNA_ShaderNodeNewGeometry)) {
566     node = new GeometryNode();
567   }
568   else if (b_node.is_a(&RNA_ShaderNodeWireframe)) {
569     BL::ShaderNodeWireframe b_wireframe_node(b_node);
570     WireframeNode *wire = new WireframeNode();
571     wire->use_pixel_size = b_wireframe_node.use_pixel_size();
572     node = wire;
573   }
574   else if (b_node.is_a(&RNA_ShaderNodeWavelength)) {
575     node = new WavelengthNode();
576   }
577   else if (b_node.is_a(&RNA_ShaderNodeBlackbody)) {
578     node = new BlackbodyNode();
579   }
580   else if (b_node.is_a(&RNA_ShaderNodeLightPath)) {
581     node = new LightPathNode();
582   }
583   else if (b_node.is_a(&RNA_ShaderNodeLightFalloff)) {
584     node = new LightFalloffNode();
585   }
586   else if (b_node.is_a(&RNA_ShaderNodeObjectInfo)) {
587     node = new ObjectInfoNode();
588   }
589   else if (b_node.is_a(&RNA_ShaderNodeParticleInfo)) {
590     node = new ParticleInfoNode();
591   }
592   else if (b_node.is_a(&RNA_ShaderNodeHairInfo)) {
593     node = new HairInfoNode();
594   }
595   else if (b_node.is_a(&RNA_ShaderNodeBump)) {
596     BL::ShaderNodeBump b_bump_node(b_node);
597     BumpNode *bump = new BumpNode();
598     bump->invert = b_bump_node.invert();
599     node = bump;
600   }
601   else if (b_node.is_a(&RNA_ShaderNodeScript)) {
602 #ifdef WITH_OSL
603     if (scene->shader_manager->use_osl()) {
604       /* create script node */
605       BL::ShaderNodeScript b_script_node(b_node);
606
607       OSLShaderManager *manager = (OSLShaderManager *)scene->shader_manager;
608       string bytecode_hash = b_script_node.bytecode_hash();
609
610       if (!bytecode_hash.empty()) {
611         node = manager->osl_node("", bytecode_hash, b_script_node.bytecode());
612       }
613       else {
614         string absolute_filepath = blender_absolute_path(
615             b_data, b_ntree, b_script_node.filepath());
616         node = manager->osl_node(absolute_filepath, "");
617       }
618     }
619 #else
620     (void)b_data;
621     (void)b_ntree;
622 #endif
623   }
624   else if (b_node.is_a(&RNA_ShaderNodeTexImage)) {
625     BL::ShaderNodeTexImage b_image_node(b_node);
626     BL::Image b_image(b_image_node.image());
627     BL::ImageUser b_image_user(b_image_node.image_user());
628     ImageTextureNode *image = new ImageTextureNode();
629     if (b_image) {
630       /* builtin images will use callback-based reading because
631        * they could only be loaded correct from blender side
632        */
633       bool is_builtin = b_image.packed_file() || b_image.source() == BL::Image::source_GENERATED ||
634                         b_image.source() == BL::Image::source_MOVIE ||
635                         (b_engine.is_preview() && b_image.source() != BL::Image::source_SEQUENCE);
636
637       if (is_builtin) {
638         /* for builtin images we're using image datablock name to find an image to
639          * read pixels from later
640          *
641          * also store frame number as well, so there's no differences in handling
642          * builtin names for packed images and movies
643          */
644         int scene_frame = b_scene.frame_current();
645         int image_frame = image_user_frame_number(b_image_user, scene_frame);
646         image->filename = b_image.name() + "@" + string_printf("%d", image_frame);
647         image->builtin_data = b_image.ptr.data;
648       }
649       else {
650         image->filename = image_user_file_path(b_image_user, b_image, b_scene.frame_current());
651         image->builtin_data = NULL;
652       }
653
654       image->animated = b_image_node.image_user().use_auto_refresh();
655       image->use_alpha = b_image.use_alpha();
656
657       /* TODO: restore */
658       /* TODO(sergey): Does not work properly when we change builtin type. */
659 #if 0
660       if (b_image.is_updated()) {
661         scene->image_manager->tag_reload_image(image->filename.string(),
662                                                image->builtin_data,
663                                                get_image_interpolation(b_image_node),
664                                                get_image_extension(b_image_node),
665                                                image->use_alpha);
666       }
667 #endif
668     }
669     switch (b_image_node.color_space()) {
670       case BL::ShaderNodeTexImage::color_space_NONE:
671         image->colorspace = u_colorspace_raw;
672         break;
673       case BL::ShaderNodeTexImage::color_space_COLOR:
674         image->colorspace = u_colorspace_auto;
675         break;
676     }
677     image->projection = (NodeImageProjection)b_image_node.projection();
678     image->interpolation = get_image_interpolation(b_image_node);
679     image->extension = get_image_extension(b_image_node);
680     image->projection_blend = b_image_node.projection_blend();
681     BL::TexMapping b_texture_mapping(b_image_node.texture_mapping());
682     get_tex_mapping(&image->tex_mapping, b_texture_mapping);
683     node = image;
684   }
685   else if (b_node.is_a(&RNA_ShaderNodeTexEnvironment)) {
686     BL::ShaderNodeTexEnvironment b_env_node(b_node);
687     BL::Image b_image(b_env_node.image());
688     BL::ImageUser b_image_user(b_env_node.image_user());
689     EnvironmentTextureNode *env = new EnvironmentTextureNode();
690     if (b_image) {
691       bool is_builtin = b_image.packed_file() || b_image.source() == BL::Image::source_GENERATED ||
692                         b_image.source() == BL::Image::source_MOVIE ||
693                         (b_engine.is_preview() && b_image.source() != BL::Image::source_SEQUENCE);
694
695       if (is_builtin) {
696         int scene_frame = b_scene.frame_current();
697         int image_frame = image_user_frame_number(b_image_user, scene_frame);
698         env->filename = b_image.name() + "@" + string_printf("%d", image_frame);
699         env->builtin_data = b_image.ptr.data;
700       }
701       else {
702         env->filename = image_user_file_path(b_image_user, b_image, b_scene.frame_current());
703         env->builtin_data = NULL;
704       }
705
706       env->animated = b_env_node.image_user().use_auto_refresh();
707       env->use_alpha = b_image.use_alpha();
708
709       /* TODO: restore */
710       /* TODO(sergey): Does not work properly when we change builtin type. */
711 #if 0
712       if (b_image.is_updated()) {
713         scene->image_manager->tag_reload_image(env->filename.string(),
714                                                env->builtin_data,
715                                                get_image_interpolation(b_env_node),
716                                                EXTENSION_REPEAT,
717                                                env->use_alpha);
718       }
719 #endif
720     }
721     switch (b_env_node.color_space()) {
722       case BL::ShaderNodeTexEnvironment::color_space_NONE:
723         env->colorspace = u_colorspace_raw;
724         break;
725       case BL::ShaderNodeTexEnvironment::color_space_COLOR:
726         env->colorspace = u_colorspace_auto;
727         break;
728     }
729     env->interpolation = get_image_interpolation(b_env_node);
730     env->projection = (NodeEnvironmentProjection)b_env_node.projection();
731     BL::TexMapping b_texture_mapping(b_env_node.texture_mapping());
732     get_tex_mapping(&env->tex_mapping, b_texture_mapping);
733     node = env;
734   }
735   else if (b_node.is_a(&RNA_ShaderNodeTexGradient)) {
736     BL::ShaderNodeTexGradient b_gradient_node(b_node);
737     GradientTextureNode *gradient = new GradientTextureNode();
738     gradient->type = (NodeGradientType)b_gradient_node.gradient_type();
739     BL::TexMapping b_texture_mapping(b_gradient_node.texture_mapping());
740     get_tex_mapping(&gradient->tex_mapping, b_texture_mapping);
741     node = gradient;
742   }
743   else if (b_node.is_a(&RNA_ShaderNodeTexVoronoi)) {
744     BL::ShaderNodeTexVoronoi b_voronoi_node(b_node);
745     VoronoiTextureNode *voronoi = new VoronoiTextureNode();
746     voronoi->coloring = (NodeVoronoiColoring)b_voronoi_node.coloring();
747     voronoi->metric = (NodeVoronoiDistanceMetric)b_voronoi_node.distance();
748     voronoi->feature = (NodeVoronoiFeature)b_voronoi_node.feature();
749     BL::TexMapping b_texture_mapping(b_voronoi_node.texture_mapping());
750     get_tex_mapping(&voronoi->tex_mapping, b_texture_mapping);
751     node = voronoi;
752   }
753   else if (b_node.is_a(&RNA_ShaderNodeTexMagic)) {
754     BL::ShaderNodeTexMagic b_magic_node(b_node);
755     MagicTextureNode *magic = new MagicTextureNode();
756     magic->depth = b_magic_node.turbulence_depth();
757     BL::TexMapping b_texture_mapping(b_magic_node.texture_mapping());
758     get_tex_mapping(&magic->tex_mapping, b_texture_mapping);
759     node = magic;
760   }
761   else if (b_node.is_a(&RNA_ShaderNodeTexWave)) {
762     BL::ShaderNodeTexWave b_wave_node(b_node);
763     WaveTextureNode *wave = new WaveTextureNode();
764     wave->type = (NodeWaveType)b_wave_node.wave_type();
765     wave->profile = (NodeWaveProfile)b_wave_node.wave_profile();
766     BL::TexMapping b_texture_mapping(b_wave_node.texture_mapping());
767     get_tex_mapping(&wave->tex_mapping, b_texture_mapping);
768     node = wave;
769   }
770   else if (b_node.is_a(&RNA_ShaderNodeTexChecker)) {
771     BL::ShaderNodeTexChecker b_checker_node(b_node);
772     CheckerTextureNode *checker = new CheckerTextureNode();
773     BL::TexMapping b_texture_mapping(b_checker_node.texture_mapping());
774     get_tex_mapping(&checker->tex_mapping, b_texture_mapping);
775     node = checker;
776   }
777   else if (b_node.is_a(&RNA_ShaderNodeTexBrick)) {
778     BL::ShaderNodeTexBrick b_brick_node(b_node);
779     BrickTextureNode *brick = new BrickTextureNode();
780     brick->offset = b_brick_node.offset();
781     brick->offset_frequency = b_brick_node.offset_frequency();
782     brick->squash = b_brick_node.squash();
783     brick->squash_frequency = b_brick_node.squash_frequency();
784     BL::TexMapping b_texture_mapping(b_brick_node.texture_mapping());
785     get_tex_mapping(&brick->tex_mapping, b_texture_mapping);
786     node = brick;
787   }
788   else if (b_node.is_a(&RNA_ShaderNodeTexNoise)) {
789     BL::ShaderNodeTexNoise b_noise_node(b_node);
790     NoiseTextureNode *noise = new NoiseTextureNode();
791     BL::TexMapping b_texture_mapping(b_noise_node.texture_mapping());
792     get_tex_mapping(&noise->tex_mapping, b_texture_mapping);
793     node = noise;
794   }
795   else if (b_node.is_a(&RNA_ShaderNodeTexMusgrave)) {
796     BL::ShaderNodeTexMusgrave b_musgrave_node(b_node);
797     MusgraveTextureNode *musgrave = new MusgraveTextureNode();
798     musgrave->type = (NodeMusgraveType)b_musgrave_node.musgrave_type();
799     BL::TexMapping b_texture_mapping(b_musgrave_node.texture_mapping());
800     get_tex_mapping(&musgrave->tex_mapping, b_texture_mapping);
801     node = musgrave;
802   }
803   else if (b_node.is_a(&RNA_ShaderNodeTexCoord)) {
804     BL::ShaderNodeTexCoord b_tex_coord_node(b_node);
805     TextureCoordinateNode *tex_coord = new TextureCoordinateNode();
806     tex_coord->from_dupli = b_tex_coord_node.from_instancer();
807     if (b_tex_coord_node.object()) {
808       tex_coord->use_transform = true;
809       tex_coord->ob_tfm = get_transform(b_tex_coord_node.object().matrix_world());
810     }
811     node = tex_coord;
812   }
813   else if (b_node.is_a(&RNA_ShaderNodeTexSky)) {
814     BL::ShaderNodeTexSky b_sky_node(b_node);
815     SkyTextureNode *sky = new SkyTextureNode();
816     sky->type = (NodeSkyType)b_sky_node.sky_type();
817     sky->sun_direction = normalize(get_float3(b_sky_node.sun_direction()));
818     sky->turbidity = b_sky_node.turbidity();
819     sky->ground_albedo = b_sky_node.ground_albedo();
820     BL::TexMapping b_texture_mapping(b_sky_node.texture_mapping());
821     get_tex_mapping(&sky->tex_mapping, b_texture_mapping);
822     node = sky;
823   }
824   else if (b_node.is_a(&RNA_ShaderNodeTexIES)) {
825     BL::ShaderNodeTexIES b_ies_node(b_node);
826     IESLightNode *ies = new IESLightNode();
827     switch (b_ies_node.mode()) {
828       case BL::ShaderNodeTexIES::mode_EXTERNAL:
829         ies->filename = blender_absolute_path(b_data, b_ntree, b_ies_node.filepath());
830         break;
831       case BL::ShaderNodeTexIES::mode_INTERNAL:
832         ies->ies = get_text_datablock_content(b_ies_node.ies().ptr);
833         if (ies->ies.empty()) {
834           ies->ies = "\n";
835         }
836         break;
837     }
838     node = ies;
839   }
840   else if (b_node.is_a(&RNA_ShaderNodeNormalMap)) {
841     BL::ShaderNodeNormalMap b_normal_map_node(b_node);
842     NormalMapNode *nmap = new NormalMapNode();
843     nmap->space = (NodeNormalMapSpace)b_normal_map_node.space();
844     nmap->attribute = b_normal_map_node.uv_map();
845     node = nmap;
846   }
847   else if (b_node.is_a(&RNA_ShaderNodeTangent)) {
848     BL::ShaderNodeTangent b_tangent_node(b_node);
849     TangentNode *tangent = new TangentNode();
850     tangent->direction_type = (NodeTangentDirectionType)b_tangent_node.direction_type();
851     tangent->axis = (NodeTangentAxis)b_tangent_node.axis();
852     tangent->attribute = b_tangent_node.uv_map();
853     node = tangent;
854   }
855   else if (b_node.is_a(&RNA_ShaderNodeUVMap)) {
856     BL::ShaderNodeUVMap b_uvmap_node(b_node);
857     UVMapNode *uvm = new UVMapNode();
858     uvm->attribute = b_uvmap_node.uv_map();
859     uvm->from_dupli = b_uvmap_node.from_instancer();
860     node = uvm;
861   }
862   else if (b_node.is_a(&RNA_ShaderNodeTexPointDensity)) {
863     BL::ShaderNodeTexPointDensity b_point_density_node(b_node);
864     PointDensityTextureNode *point_density = new PointDensityTextureNode();
865     point_density->filename = b_point_density_node.name();
866     point_density->space = (NodeTexVoxelSpace)b_point_density_node.space();
867     point_density->interpolation = get_image_interpolation(b_point_density_node);
868     point_density->builtin_data = b_point_density_node.ptr.data;
869     point_density->image_manager = scene->image_manager;
870
871     /* TODO(sergey): Use more proper update flag. */
872     if (true) {
873       point_density->add_image();
874       b_point_density_node.cache_point_density(b_depsgraph);
875       scene->image_manager->tag_reload_image(point_density->filename.string(),
876                                              point_density->builtin_data,
877                                              point_density->interpolation,
878                                              EXTENSION_CLIP,
879                                              true,
880                                              u_colorspace_raw);
881     }
882     node = point_density;
883
884     /* Transformation form world space to texture space.
885      *
886      * NOTE: Do this after the texture is cached, this is because getting
887      * min/max will need to access this cache.
888      */
889     BL::Object b_ob(b_point_density_node.object());
890     if (b_ob) {
891       float3 loc, size;
892       point_density_texture_space(b_depsgraph, b_point_density_node, loc, size);
893       point_density->tfm = transform_translate(-loc) * transform_scale(size) *
894                            transform_inverse(get_transform(b_ob.matrix_world()));
895     }
896   }
897   else if (b_node.is_a(&RNA_ShaderNodeBevel)) {
898     BL::ShaderNodeBevel b_bevel_node(b_node);
899     BevelNode *bevel = new BevelNode();
900     bevel->samples = b_bevel_node.samples();
901     node = bevel;
902   }
903   else if (b_node.is_a(&RNA_ShaderNodeDisplacement)) {
904     BL::ShaderNodeDisplacement b_disp_node(b_node);
905     DisplacementNode *disp = new DisplacementNode();
906     disp->space = (NodeNormalMapSpace)b_disp_node.space();
907     node = disp;
908   }
909   else if (b_node.is_a(&RNA_ShaderNodeVectorDisplacement)) {
910     BL::ShaderNodeVectorDisplacement b_disp_node(b_node);
911     VectorDisplacementNode *disp = new VectorDisplacementNode();
912     disp->space = (NodeNormalMapSpace)b_disp_node.space();
913     disp->attribute = "";
914     node = disp;
915   }
916
917   if (node) {
918     node->name = b_node.name();
919     graph->add(node);
920   }
921
922   return node;
923 }
924
925 static bool node_use_modified_socket_name(ShaderNode *node)
926 {
927   if (node->special_type == SHADER_SPECIAL_TYPE_OSL)
928     return false;
929
930   return true;
931 }
932
933 static ShaderInput *node_find_input_by_name(ShaderNode *node,
934                                             BL::Node &b_node,
935                                             BL::NodeSocket &b_socket)
936 {
937   string name = b_socket.name();
938
939   if (node_use_modified_socket_name(node)) {
940     BL::Node::inputs_iterator b_input;
941     bool found = false;
942     int counter = 0, total = 0;
943
944     for (b_node.inputs.begin(b_input); b_input != b_node.inputs.end(); ++b_input) {
945       if (b_input->name() == name) {
946         if (!found)
947           counter++;
948         total++;
949       }
950
951       if (b_input->ptr.data == b_socket.ptr.data)
952         found = true;
953     }
954
955     /* rename if needed */
956     if (name == "Shader")
957       name = "Closure";
958
959     if (total > 1)
960       name = string_printf("%s%d", name.c_str(), counter);
961   }
962
963   return node->input(name.c_str());
964 }
965
966 static ShaderOutput *node_find_output_by_name(ShaderNode *node,
967                                               BL::Node &b_node,
968                                               BL::NodeSocket &b_socket)
969 {
970   string name = b_socket.name();
971
972   if (node_use_modified_socket_name(node)) {
973     BL::Node::outputs_iterator b_output;
974     bool found = false;
975     int counter = 0, total = 0;
976
977     for (b_node.outputs.begin(b_output); b_output != b_node.outputs.end(); ++b_output) {
978       if (b_output->name() == name) {
979         if (!found)
980           counter++;
981         total++;
982       }
983
984       if (b_output->ptr.data == b_socket.ptr.data)
985         found = true;
986     }
987
988     /* rename if needed */
989     if (name == "Shader")
990       name = "Closure";
991
992     if (total > 1)
993       name = string_printf("%s%d", name.c_str(), counter);
994   }
995
996   return node->output(name.c_str());
997 }
998
999 static void add_nodes(Scene *scene,
1000                       BL::RenderEngine &b_engine,
1001                       BL::BlendData &b_data,
1002                       BL::Depsgraph &b_depsgraph,
1003                       BL::Scene &b_scene,
1004                       ShaderGraph *graph,
1005                       BL::ShaderNodeTree &b_ntree,
1006                       const ProxyMap &proxy_input_map,
1007                       const ProxyMap &proxy_output_map)
1008 {
1009   /* add nodes */
1010   BL::ShaderNodeTree::nodes_iterator b_node;
1011   PtrInputMap input_map;
1012   PtrOutputMap output_map;
1013
1014   BL::Node::inputs_iterator b_input;
1015   BL::Node::outputs_iterator b_output;
1016
1017   /* find the node to use for output if there are multiple */
1018   BL::ShaderNode output_node = b_ntree.get_output_node(
1019       BL::ShaderNodeOutputMaterial::target_CYCLES);
1020
1021   /* add nodes */
1022   for (b_ntree.nodes.begin(b_node); b_node != b_ntree.nodes.end(); ++b_node) {
1023     if (b_node->mute() || b_node->is_a(&RNA_NodeReroute)) {
1024       /* replace muted node with internal links */
1025       BL::Node::internal_links_iterator b_link;
1026       for (b_node->internal_links.begin(b_link); b_link != b_node->internal_links.end();
1027            ++b_link) {
1028         BL::NodeSocket to_socket(b_link->to_socket());
1029         SocketType::Type to_socket_type = convert_socket_type(to_socket);
1030         if (to_socket_type == SocketType::UNDEFINED) {
1031           continue;
1032         }
1033
1034         ConvertNode *proxy = new ConvertNode(to_socket_type, to_socket_type, true);
1035
1036         input_map[b_link->from_socket().ptr.data] = proxy->inputs[0];
1037         output_map[b_link->to_socket().ptr.data] = proxy->outputs[0];
1038
1039         graph->add(proxy);
1040       }
1041     }
1042     else if (b_node->is_a(&RNA_ShaderNodeGroup) || b_node->is_a(&RNA_NodeCustomGroup) ||
1043              b_node->is_a(&RNA_ShaderNodeCustomGroup)) {
1044
1045       BL::ShaderNodeTree b_group_ntree(PointerRNA_NULL);
1046       if (b_node->is_a(&RNA_ShaderNodeGroup))
1047         b_group_ntree = BL::ShaderNodeTree(((BL::NodeGroup)(*b_node)).node_tree());
1048       else if (b_node->is_a(&RNA_NodeCustomGroup))
1049         b_group_ntree = BL::ShaderNodeTree(((BL::NodeCustomGroup)(*b_node)).node_tree());
1050       else
1051         b_group_ntree = BL::ShaderNodeTree(((BL::ShaderNodeCustomGroup)(*b_node)).node_tree());
1052
1053       ProxyMap group_proxy_input_map, group_proxy_output_map;
1054
1055       /* Add a proxy node for each socket
1056        * Do this even if the node group has no internal tree,
1057        * so that links have something to connect to and assert won't fail.
1058        */
1059       for (b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) {
1060         SocketType::Type input_type = convert_socket_type(*b_input);
1061         if (input_type == SocketType::UNDEFINED) {
1062           continue;
1063         }
1064
1065         ConvertNode *proxy = new ConvertNode(input_type, input_type, true);
1066         graph->add(proxy);
1067
1068         /* register the proxy node for internal binding */
1069         group_proxy_input_map[b_input->identifier()] = proxy;
1070
1071         input_map[b_input->ptr.data] = proxy->inputs[0];
1072
1073         set_default_value(proxy->inputs[0], *b_input, b_data, b_ntree);
1074       }
1075       for (b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) {
1076         SocketType::Type output_type = convert_socket_type(*b_output);
1077         if (output_type == SocketType::UNDEFINED) {
1078           continue;
1079         }
1080
1081         ConvertNode *proxy = new ConvertNode(output_type, output_type, true);
1082         graph->add(proxy);
1083
1084         /* register the proxy node for internal binding */
1085         group_proxy_output_map[b_output->identifier()] = proxy;
1086
1087         output_map[b_output->ptr.data] = proxy->outputs[0];
1088       }
1089
1090       if (b_group_ntree) {
1091         add_nodes(scene,
1092                   b_engine,
1093                   b_data,
1094                   b_depsgraph,
1095                   b_scene,
1096                   graph,
1097                   b_group_ntree,
1098                   group_proxy_input_map,
1099                   group_proxy_output_map);
1100       }
1101     }
1102     else if (b_node->is_a(&RNA_NodeGroupInput)) {
1103       /* map each socket to a proxy node */
1104       for (b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) {
1105         ProxyMap::const_iterator proxy_it = proxy_input_map.find(b_output->identifier());
1106         if (proxy_it != proxy_input_map.end()) {
1107           ConvertNode *proxy = proxy_it->second;
1108
1109           output_map[b_output->ptr.data] = proxy->outputs[0];
1110         }
1111       }
1112     }
1113     else if (b_node->is_a(&RNA_NodeGroupOutput)) {
1114       BL::NodeGroupOutput b_output_node(*b_node);
1115       /* only the active group output is used */
1116       if (b_output_node.is_active_output()) {
1117         /* map each socket to a proxy node */
1118         for (b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) {
1119           ProxyMap::const_iterator proxy_it = proxy_output_map.find(b_input->identifier());
1120           if (proxy_it != proxy_output_map.end()) {
1121             ConvertNode *proxy = proxy_it->second;
1122
1123             input_map[b_input->ptr.data] = proxy->inputs[0];
1124
1125             set_default_value(proxy->inputs[0], *b_input, b_data, b_ntree);
1126           }
1127         }
1128       }
1129     }
1130     else {
1131       ShaderNode *node = NULL;
1132
1133       if (b_node->ptr.data == output_node.ptr.data) {
1134         node = graph->output();
1135       }
1136       else {
1137         BL::ShaderNode b_shader_node(*b_node);
1138         node = add_node(
1139             scene, b_engine, b_data, b_depsgraph, b_scene, graph, b_ntree, b_shader_node);
1140       }
1141
1142       if (node) {
1143         /* map node sockets for linking */
1144         for (b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) {
1145           ShaderInput *input = node_find_input_by_name(node, *b_node, *b_input);
1146           if (!input) {
1147             /* XXX should not happen, report error? */
1148             continue;
1149           }
1150           input_map[b_input->ptr.data] = input;
1151
1152           set_default_value(input, *b_input, b_data, b_ntree);
1153         }
1154         for (b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) {
1155           ShaderOutput *output = node_find_output_by_name(node, *b_node, *b_output);
1156           if (!output) {
1157             /* XXX should not happen, report error? */
1158             continue;
1159           }
1160           output_map[b_output->ptr.data] = output;
1161         }
1162       }
1163     }
1164   }
1165
1166   /* connect nodes */
1167   BL::NodeTree::links_iterator b_link;
1168
1169   for (b_ntree.links.begin(b_link); b_link != b_ntree.links.end(); ++b_link) {
1170     /* Ignore invalid links to avoid unwanted cycles created in graph. */
1171     if (!b_link->is_valid()) {
1172       continue;
1173     }
1174     /* get blender link data */
1175     BL::NodeSocket b_from_sock = b_link->from_socket();
1176     BL::NodeSocket b_to_sock = b_link->to_socket();
1177
1178     ShaderOutput *output = 0;
1179     ShaderInput *input = 0;
1180
1181     PtrOutputMap::iterator output_it = output_map.find(b_from_sock.ptr.data);
1182     if (output_it != output_map.end())
1183       output = output_it->second;
1184     PtrInputMap::iterator input_it = input_map.find(b_to_sock.ptr.data);
1185     if (input_it != input_map.end())
1186       input = input_it->second;
1187
1188     /* either node may be NULL when the node was not exported, typically
1189      * because the node type is not supported */
1190     if (output && input)
1191       graph->connect(output, input);
1192   }
1193 }
1194
1195 static void add_nodes(Scene *scene,
1196                       BL::RenderEngine &b_engine,
1197                       BL::BlendData &b_data,
1198                       BL::Depsgraph &b_depsgraph,
1199                       BL::Scene &b_scene,
1200                       ShaderGraph *graph,
1201                       BL::ShaderNodeTree &b_ntree)
1202 {
1203   static const ProxyMap empty_proxy_map;
1204   add_nodes(scene,
1205             b_engine,
1206             b_data,
1207             b_depsgraph,
1208             b_scene,
1209             graph,
1210             b_ntree,
1211             empty_proxy_map,
1212             empty_proxy_map);
1213 }
1214
1215 /* Sync Materials */
1216
1217 void BlenderSync::sync_materials(BL::Depsgraph &b_depsgraph, bool update_all)
1218 {
1219   shader_map.set_default(scene->default_surface);
1220
1221   TaskPool pool;
1222   set<Shader *> updated_shaders;
1223
1224   BL::Depsgraph::ids_iterator b_id;
1225   for (b_depsgraph.ids.begin(b_id); b_id != b_depsgraph.ids.end(); ++b_id) {
1226     if (!b_id->is_a(&RNA_Material)) {
1227       continue;
1228     }
1229
1230     BL::Material b_mat(*b_id);
1231     Shader *shader;
1232
1233     /* test if we need to sync */
1234     if (shader_map.sync(&shader, b_mat) || shader->need_sync_object || update_all) {
1235       ShaderGraph *graph = new ShaderGraph();
1236
1237       shader->name = b_mat.name().c_str();
1238       shader->pass_id = b_mat.pass_index();
1239       shader->need_sync_object = false;
1240
1241       /* create nodes */
1242       if (b_mat.use_nodes() && b_mat.node_tree()) {
1243         BL::ShaderNodeTree b_ntree(b_mat.node_tree());
1244
1245         add_nodes(scene, b_engine, b_data, b_depsgraph, b_scene, graph, b_ntree);
1246       }
1247       else {
1248         DiffuseBsdfNode *diffuse = new DiffuseBsdfNode();
1249         diffuse->color = get_float3(b_mat.diffuse_color());
1250         graph->add(diffuse);
1251
1252         ShaderNode *out = graph->output();
1253         graph->connect(diffuse->output("BSDF"), out->input("Surface"));
1254       }
1255
1256       /* settings */
1257       PointerRNA cmat = RNA_pointer_get(&b_mat.ptr, "cycles");
1258       shader->use_mis = get_boolean(cmat, "sample_as_light");
1259       shader->use_transparent_shadow = get_boolean(cmat, "use_transparent_shadow");
1260       shader->heterogeneous_volume = !get_boolean(cmat, "homogeneous_volume");
1261       shader->volume_sampling_method = get_volume_sampling(cmat);
1262       shader->volume_interpolation_method = get_volume_interpolation(cmat);
1263       shader->displacement_method = get_displacement_method(cmat);
1264
1265       shader->set_graph(graph);
1266
1267       /* By simplifying the shader graph as soon as possible, some
1268        * redundant shader nodes might be removed which prevents loading
1269        * unnecessary attributes later.
1270        *
1271        * However, since graph simplification also accounts for e.g. mix
1272        * weight, this would cause frequent expensive resyncs in interactive
1273        * sessions, so for those sessions optimization is only performed
1274        * right before compiling.
1275        */
1276       if (!preview) {
1277         pool.push(function_bind(&ShaderGraph::simplify, graph, scene));
1278         /* NOTE: Update shaders out of the threads since those routines
1279          * are accessing and writing to a global context.
1280          */
1281         updated_shaders.insert(shader);
1282       }
1283       else {
1284         /* NOTE: Update tagging can access links which are being
1285          * optimized out.
1286          */
1287         shader->tag_update(scene);
1288       }
1289     }
1290   }
1291
1292   pool.wait_work();
1293
1294   foreach (Shader *shader, updated_shaders) {
1295     shader->tag_update(scene);
1296   }
1297 }
1298
1299 /* Sync World */
1300
1301 void BlenderSync::sync_world(BL::Depsgraph &b_depsgraph, bool update_all)
1302 {
1303   Background *background = scene->background;
1304   Background prevbackground = *background;
1305
1306   BL::World b_world = b_scene.world();
1307
1308   if (world_recalc || update_all || b_world.ptr.data != world_map) {
1309     Shader *shader = scene->default_background;
1310     ShaderGraph *graph = new ShaderGraph();
1311
1312     /* create nodes */
1313     if (b_world && b_world.use_nodes() && b_world.node_tree()) {
1314       BL::ShaderNodeTree b_ntree(b_world.node_tree());
1315
1316       add_nodes(scene, b_engine, b_data, b_depsgraph, b_scene, graph, b_ntree);
1317
1318       /* volume */
1319       PointerRNA cworld = RNA_pointer_get(&b_world.ptr, "cycles");
1320       shader->heterogeneous_volume = !get_boolean(cworld, "homogeneous_volume");
1321       shader->volume_sampling_method = get_volume_sampling(cworld);
1322       shader->volume_interpolation_method = get_volume_interpolation(cworld);
1323     }
1324     else if (b_world) {
1325       BackgroundNode *background = new BackgroundNode();
1326       background->color = get_float3(b_world.color());
1327       graph->add(background);
1328
1329       ShaderNode *out = graph->output();
1330       graph->connect(background->output("Background"), out->input("Surface"));
1331     }
1332
1333     if (b_world) {
1334       /* AO */
1335       BL::WorldLighting b_light = b_world.light_settings();
1336
1337       background->use_ao = b_light.use_ambient_occlusion();
1338       background->ao_factor = b_light.ao_factor();
1339       background->ao_distance = b_light.distance();
1340
1341       /* visibility */
1342       PointerRNA cvisibility = RNA_pointer_get(&b_world.ptr, "cycles_visibility");
1343       uint visibility = 0;
1344
1345       visibility |= get_boolean(cvisibility, "camera") ? PATH_RAY_CAMERA : 0;
1346       visibility |= get_boolean(cvisibility, "diffuse") ? PATH_RAY_DIFFUSE : 0;
1347       visibility |= get_boolean(cvisibility, "glossy") ? PATH_RAY_GLOSSY : 0;
1348       visibility |= get_boolean(cvisibility, "transmission") ? PATH_RAY_TRANSMIT : 0;
1349       visibility |= get_boolean(cvisibility, "scatter") ? PATH_RAY_VOLUME_SCATTER : 0;
1350
1351       background->visibility = visibility;
1352     }
1353     else {
1354       background->use_ao = false;
1355       background->ao_factor = 0.0f;
1356       background->ao_distance = FLT_MAX;
1357     }
1358
1359     shader->set_graph(graph);
1360     shader->tag_update(scene);
1361     background->tag_update(scene);
1362   }
1363
1364   PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
1365
1366   /* when doing preview render check for BI's transparency settings,
1367    * this is so because Blender's preview render routines are not able
1368    * to tweak all cycles's settings depending on different circumstances
1369    */
1370   if (b_engine.is_preview() == false)
1371     background->transparent = get_boolean(cscene, "film_transparent");
1372   else
1373     background->transparent = b_scene.render().alpha_mode() ==
1374                               BL::RenderSettings::alpha_mode_TRANSPARENT;
1375
1376   if (background->transparent) {
1377     background->transparent_glass = get_boolean(cscene, "film_transparent_glass");
1378     background->transparent_roughness_threshold = get_float(cscene, "film_transparent_roughness");
1379   }
1380   else {
1381     background->transparent_glass = false;
1382     background->transparent_roughness_threshold = 0.0f;
1383   }
1384
1385   background->use_shader = view_layer.use_background_shader;
1386   background->use_ao = background->use_ao && view_layer.use_background_ao;
1387
1388   if (background->modified(prevbackground))
1389     background->tag_update(scene);
1390 }
1391
1392 /* Sync Lights */
1393
1394 void BlenderSync::sync_lights(BL::Depsgraph &b_depsgraph, bool update_all)
1395 {
1396   shader_map.set_default(scene->default_light);
1397
1398   BL::Depsgraph::ids_iterator b_id;
1399   for (b_depsgraph.ids.begin(b_id); b_id != b_depsgraph.ids.end(); ++b_id) {
1400     if (!b_id->is_a(&RNA_Light)) {
1401       continue;
1402     }
1403
1404     BL::Light b_light(*b_id);
1405     Shader *shader;
1406
1407     /* test if we need to sync */
1408     if (shader_map.sync(&shader, b_light) || update_all) {
1409       ShaderGraph *graph = new ShaderGraph();
1410
1411       /* create nodes */
1412       if (b_light.use_nodes() && b_light.node_tree()) {
1413         shader->name = b_light.name().c_str();
1414
1415         BL::ShaderNodeTree b_ntree(b_light.node_tree());
1416
1417         add_nodes(scene, b_engine, b_data, b_depsgraph, b_scene, graph, b_ntree);
1418       }
1419       else {
1420         float strength = 1.0f;
1421
1422         if (b_light.type() == BL::Light::type_POINT || b_light.type() == BL::Light::type_SPOT ||
1423             b_light.type() == BL::Light::type_AREA) {
1424           strength = 100.0f;
1425         }
1426
1427         EmissionNode *emission = new EmissionNode();
1428         emission->color = get_float3(b_light.color());
1429         emission->strength = strength;
1430         graph->add(emission);
1431
1432         ShaderNode *out = graph->output();
1433         graph->connect(emission->output("Emission"), out->input("Surface"));
1434       }
1435
1436       shader->set_graph(graph);
1437       shader->tag_update(scene);
1438     }
1439   }
1440 }
1441
1442 void BlenderSync::sync_shaders(BL::Depsgraph &b_depsgraph)
1443 {
1444   /* for auto refresh images */
1445   bool auto_refresh_update = false;
1446
1447   if (preview) {
1448     ImageManager *image_manager = scene->image_manager;
1449     int frame = b_scene.frame_current();
1450     auto_refresh_update = image_manager->set_animation_frame_update(frame);
1451   }
1452
1453   shader_map.pre_sync();
1454
1455   sync_world(b_depsgraph, auto_refresh_update);
1456   sync_lights(b_depsgraph, auto_refresh_update);
1457   sync_materials(b_depsgraph, auto_refresh_update);
1458
1459   /* false = don't delete unused shaders, not supported */
1460   shader_map.post_sync(false);
1461 }
1462
1463 CCL_NAMESPACE_END