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