ClangFormat: apply to source, most of 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(
661                 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     image->color_space = (NodeImageColorSpace)b_image_node.color_space();
670     image->projection = (NodeImageProjection)b_image_node.projection();
671     image->interpolation = get_image_interpolation(b_image_node);
672     image->extension = get_image_extension(b_image_node);
673     image->projection_blend = b_image_node.projection_blend();
674     BL::TexMapping b_texture_mapping(b_image_node.texture_mapping());
675     get_tex_mapping(&image->tex_mapping, b_texture_mapping);
676     node = image;
677   }
678   else if (b_node.is_a(&RNA_ShaderNodeTexEnvironment)) {
679     BL::ShaderNodeTexEnvironment b_env_node(b_node);
680     BL::Image b_image(b_env_node.image());
681     BL::ImageUser b_image_user(b_env_node.image_user());
682     EnvironmentTextureNode *env = new EnvironmentTextureNode();
683     if (b_image) {
684       bool is_builtin = b_image.packed_file() || b_image.source() == BL::Image::source_GENERATED ||
685                         b_image.source() == BL::Image::source_MOVIE ||
686                         (b_engine.is_preview() && b_image.source() != BL::Image::source_SEQUENCE);
687
688       if (is_builtin) {
689         int scene_frame = b_scene.frame_current();
690         int image_frame = image_user_frame_number(b_image_user, scene_frame);
691         env->filename = b_image.name() + "@" + string_printf("%d", image_frame);
692         env->builtin_data = b_image.ptr.data;
693       }
694       else {
695         env->filename = image_user_file_path(b_image_user, b_image, b_scene.frame_current());
696         env->builtin_data = NULL;
697       }
698
699       env->animated = b_env_node.image_user().use_auto_refresh();
700       env->use_alpha = b_image.use_alpha();
701
702       /* TODO: restore */
703       /* TODO(sergey): Does not work properly when we change builtin type. */
704 #if 0
705       if(b_image.is_updated()) {
706         scene->image_manager->tag_reload_image(
707                 env->filename.string(),
708                 env->builtin_data,
709                 get_image_interpolation(b_env_node),
710                 EXTENSION_REPEAT,
711                 env->use_alpha);
712       }
713 #endif
714     }
715     env->color_space = (NodeImageColorSpace)b_env_node.color_space();
716     env->interpolation = get_image_interpolation(b_env_node);
717     env->projection = (NodeEnvironmentProjection)b_env_node.projection();
718     BL::TexMapping b_texture_mapping(b_env_node.texture_mapping());
719     get_tex_mapping(&env->tex_mapping, b_texture_mapping);
720     node = env;
721   }
722   else if (b_node.is_a(&RNA_ShaderNodeTexGradient)) {
723     BL::ShaderNodeTexGradient b_gradient_node(b_node);
724     GradientTextureNode *gradient = new GradientTextureNode();
725     gradient->type = (NodeGradientType)b_gradient_node.gradient_type();
726     BL::TexMapping b_texture_mapping(b_gradient_node.texture_mapping());
727     get_tex_mapping(&gradient->tex_mapping, b_texture_mapping);
728     node = gradient;
729   }
730   else if (b_node.is_a(&RNA_ShaderNodeTexVoronoi)) {
731     BL::ShaderNodeTexVoronoi b_voronoi_node(b_node);
732     VoronoiTextureNode *voronoi = new VoronoiTextureNode();
733     voronoi->coloring = (NodeVoronoiColoring)b_voronoi_node.coloring();
734     voronoi->metric = (NodeVoronoiDistanceMetric)b_voronoi_node.distance();
735     voronoi->feature = (NodeVoronoiFeature)b_voronoi_node.feature();
736     BL::TexMapping b_texture_mapping(b_voronoi_node.texture_mapping());
737     get_tex_mapping(&voronoi->tex_mapping, b_texture_mapping);
738     node = voronoi;
739   }
740   else if (b_node.is_a(&RNA_ShaderNodeTexMagic)) {
741     BL::ShaderNodeTexMagic b_magic_node(b_node);
742     MagicTextureNode *magic = new MagicTextureNode();
743     magic->depth = b_magic_node.turbulence_depth();
744     BL::TexMapping b_texture_mapping(b_magic_node.texture_mapping());
745     get_tex_mapping(&magic->tex_mapping, b_texture_mapping);
746     node = magic;
747   }
748   else if (b_node.is_a(&RNA_ShaderNodeTexWave)) {
749     BL::ShaderNodeTexWave b_wave_node(b_node);
750     WaveTextureNode *wave = new WaveTextureNode();
751     wave->type = (NodeWaveType)b_wave_node.wave_type();
752     wave->profile = (NodeWaveProfile)b_wave_node.wave_profile();
753     BL::TexMapping b_texture_mapping(b_wave_node.texture_mapping());
754     get_tex_mapping(&wave->tex_mapping, b_texture_mapping);
755     node = wave;
756   }
757   else if (b_node.is_a(&RNA_ShaderNodeTexChecker)) {
758     BL::ShaderNodeTexChecker b_checker_node(b_node);
759     CheckerTextureNode *checker = new CheckerTextureNode();
760     BL::TexMapping b_texture_mapping(b_checker_node.texture_mapping());
761     get_tex_mapping(&checker->tex_mapping, b_texture_mapping);
762     node = checker;
763   }
764   else if (b_node.is_a(&RNA_ShaderNodeTexBrick)) {
765     BL::ShaderNodeTexBrick b_brick_node(b_node);
766     BrickTextureNode *brick = new BrickTextureNode();
767     brick->offset = b_brick_node.offset();
768     brick->offset_frequency = b_brick_node.offset_frequency();
769     brick->squash = b_brick_node.squash();
770     brick->squash_frequency = b_brick_node.squash_frequency();
771     BL::TexMapping b_texture_mapping(b_brick_node.texture_mapping());
772     get_tex_mapping(&brick->tex_mapping, b_texture_mapping);
773     node = brick;
774   }
775   else if (b_node.is_a(&RNA_ShaderNodeTexNoise)) {
776     BL::ShaderNodeTexNoise b_noise_node(b_node);
777     NoiseTextureNode *noise = new NoiseTextureNode();
778     BL::TexMapping b_texture_mapping(b_noise_node.texture_mapping());
779     get_tex_mapping(&noise->tex_mapping, b_texture_mapping);
780     node = noise;
781   }
782   else if (b_node.is_a(&RNA_ShaderNodeTexMusgrave)) {
783     BL::ShaderNodeTexMusgrave b_musgrave_node(b_node);
784     MusgraveTextureNode *musgrave = new MusgraveTextureNode();
785     musgrave->type = (NodeMusgraveType)b_musgrave_node.musgrave_type();
786     BL::TexMapping b_texture_mapping(b_musgrave_node.texture_mapping());
787     get_tex_mapping(&musgrave->tex_mapping, b_texture_mapping);
788     node = musgrave;
789   }
790   else if (b_node.is_a(&RNA_ShaderNodeTexCoord)) {
791     BL::ShaderNodeTexCoord b_tex_coord_node(b_node);
792     TextureCoordinateNode *tex_coord = new TextureCoordinateNode();
793     tex_coord->from_dupli = b_tex_coord_node.from_instancer();
794     if (b_tex_coord_node.object()) {
795       tex_coord->use_transform = true;
796       tex_coord->ob_tfm = get_transform(b_tex_coord_node.object().matrix_world());
797     }
798     node = tex_coord;
799   }
800   else if (b_node.is_a(&RNA_ShaderNodeTexSky)) {
801     BL::ShaderNodeTexSky b_sky_node(b_node);
802     SkyTextureNode *sky = new SkyTextureNode();
803     sky->type = (NodeSkyType)b_sky_node.sky_type();
804     sky->sun_direction = normalize(get_float3(b_sky_node.sun_direction()));
805     sky->turbidity = b_sky_node.turbidity();
806     sky->ground_albedo = b_sky_node.ground_albedo();
807     BL::TexMapping b_texture_mapping(b_sky_node.texture_mapping());
808     get_tex_mapping(&sky->tex_mapping, b_texture_mapping);
809     node = sky;
810   }
811   else if (b_node.is_a(&RNA_ShaderNodeTexIES)) {
812     BL::ShaderNodeTexIES b_ies_node(b_node);
813     IESLightNode *ies = new IESLightNode();
814     switch (b_ies_node.mode()) {
815       case BL::ShaderNodeTexIES::mode_EXTERNAL:
816         ies->filename = blender_absolute_path(b_data, b_ntree, b_ies_node.filepath());
817         break;
818       case BL::ShaderNodeTexIES::mode_INTERNAL:
819         ies->ies = get_text_datablock_content(b_ies_node.ies().ptr);
820         if (ies->ies.empty()) {
821           ies->ies = "\n";
822         }
823         break;
824     }
825     node = ies;
826   }
827   else if (b_node.is_a(&RNA_ShaderNodeNormalMap)) {
828     BL::ShaderNodeNormalMap b_normal_map_node(b_node);
829     NormalMapNode *nmap = new NormalMapNode();
830     nmap->space = (NodeNormalMapSpace)b_normal_map_node.space();
831     nmap->attribute = b_normal_map_node.uv_map();
832     node = nmap;
833   }
834   else if (b_node.is_a(&RNA_ShaderNodeTangent)) {
835     BL::ShaderNodeTangent b_tangent_node(b_node);
836     TangentNode *tangent = new TangentNode();
837     tangent->direction_type = (NodeTangentDirectionType)b_tangent_node.direction_type();
838     tangent->axis = (NodeTangentAxis)b_tangent_node.axis();
839     tangent->attribute = b_tangent_node.uv_map();
840     node = tangent;
841   }
842   else if (b_node.is_a(&RNA_ShaderNodeUVMap)) {
843     BL::ShaderNodeUVMap b_uvmap_node(b_node);
844     UVMapNode *uvm = new UVMapNode();
845     uvm->attribute = b_uvmap_node.uv_map();
846     uvm->from_dupli = b_uvmap_node.from_instancer();
847     node = uvm;
848   }
849   else if (b_node.is_a(&RNA_ShaderNodeTexPointDensity)) {
850     BL::ShaderNodeTexPointDensity b_point_density_node(b_node);
851     PointDensityTextureNode *point_density = new PointDensityTextureNode();
852     point_density->filename = b_point_density_node.name();
853     point_density->space = (NodeTexVoxelSpace)b_point_density_node.space();
854     point_density->interpolation = get_image_interpolation(b_point_density_node);
855     point_density->builtin_data = b_point_density_node.ptr.data;
856     point_density->image_manager = scene->image_manager;
857
858     /* TODO(sergey): Use more proper update flag. */
859     if (true) {
860       point_density->add_image();
861       b_point_density_node.cache_point_density(b_depsgraph);
862       scene->image_manager->tag_reload_image(point_density->filename.string(),
863                                              point_density->builtin_data,
864                                              point_density->interpolation,
865                                              EXTENSION_CLIP,
866                                              true);
867     }
868     node = point_density;
869
870     /* Transformation form world space to texture space.
871      *
872      * NOTE: Do this after the texture is cached, this is because getting
873      * min/max will need to access this cache.
874      */
875     BL::Object b_ob(b_point_density_node.object());
876     if (b_ob) {
877       float3 loc, size;
878       point_density_texture_space(b_depsgraph, b_point_density_node, loc, size);
879       point_density->tfm = transform_translate(-loc) * transform_scale(size) *
880                            transform_inverse(get_transform(b_ob.matrix_world()));
881     }
882   }
883   else if (b_node.is_a(&RNA_ShaderNodeBevel)) {
884     BL::ShaderNodeBevel b_bevel_node(b_node);
885     BevelNode *bevel = new BevelNode();
886     bevel->samples = b_bevel_node.samples();
887     node = bevel;
888   }
889   else if (b_node.is_a(&RNA_ShaderNodeDisplacement)) {
890     BL::ShaderNodeDisplacement b_disp_node(b_node);
891     DisplacementNode *disp = new DisplacementNode();
892     disp->space = (NodeNormalMapSpace)b_disp_node.space();
893     node = disp;
894   }
895   else if (b_node.is_a(&RNA_ShaderNodeVectorDisplacement)) {
896     BL::ShaderNodeVectorDisplacement b_disp_node(b_node);
897     VectorDisplacementNode *disp = new VectorDisplacementNode();
898     disp->space = (NodeNormalMapSpace)b_disp_node.space();
899     disp->attribute = "";
900     node = disp;
901   }
902
903   if (node) {
904     node->name = b_node.name();
905     graph->add(node);
906   }
907
908   return node;
909 }
910
911 static bool node_use_modified_socket_name(ShaderNode *node)
912 {
913   if (node->special_type == SHADER_SPECIAL_TYPE_SCRIPT)
914     return false;
915
916   return true;
917 }
918
919 static ShaderInput *node_find_input_by_name(ShaderNode *node,
920                                             BL::Node &b_node,
921                                             BL::NodeSocket &b_socket)
922 {
923   string name = b_socket.name();
924
925   if (node_use_modified_socket_name(node)) {
926     BL::Node::inputs_iterator b_input;
927     bool found = false;
928     int counter = 0, total = 0;
929
930     for (b_node.inputs.begin(b_input); b_input != b_node.inputs.end(); ++b_input) {
931       if (b_input->name() == name) {
932         if (!found)
933           counter++;
934         total++;
935       }
936
937       if (b_input->ptr.data == b_socket.ptr.data)
938         found = true;
939     }
940
941     /* rename if needed */
942     if (name == "Shader")
943       name = "Closure";
944
945     if (total > 1)
946       name = string_printf("%s%d", name.c_str(), counter);
947   }
948
949   return node->input(name.c_str());
950 }
951
952 static ShaderOutput *node_find_output_by_name(ShaderNode *node,
953                                               BL::Node &b_node,
954                                               BL::NodeSocket &b_socket)
955 {
956   string name = b_socket.name();
957
958   if (node_use_modified_socket_name(node)) {
959     BL::Node::outputs_iterator b_output;
960     bool found = false;
961     int counter = 0, total = 0;
962
963     for (b_node.outputs.begin(b_output); b_output != b_node.outputs.end(); ++b_output) {
964       if (b_output->name() == name) {
965         if (!found)
966           counter++;
967         total++;
968       }
969
970       if (b_output->ptr.data == b_socket.ptr.data)
971         found = true;
972     }
973
974     /* rename if needed */
975     if (name == "Shader")
976       name = "Closure";
977
978     if (total > 1)
979       name = string_printf("%s%d", name.c_str(), counter);
980   }
981
982   return node->output(name.c_str());
983 }
984
985 static void add_nodes(Scene *scene,
986                       BL::RenderEngine &b_engine,
987                       BL::BlendData &b_data,
988                       BL::Depsgraph &b_depsgraph,
989                       BL::Scene &b_scene,
990                       ShaderGraph *graph,
991                       BL::ShaderNodeTree &b_ntree,
992                       const ProxyMap &proxy_input_map,
993                       const ProxyMap &proxy_output_map)
994 {
995   /* add nodes */
996   BL::ShaderNodeTree::nodes_iterator b_node;
997   PtrInputMap input_map;
998   PtrOutputMap output_map;
999
1000   BL::Node::inputs_iterator b_input;
1001   BL::Node::outputs_iterator b_output;
1002
1003   /* find the node to use for output if there are multiple */
1004   BL::ShaderNode output_node = b_ntree.get_output_node(
1005       BL::ShaderNodeOutputMaterial::target_CYCLES);
1006
1007   /* add nodes */
1008   for (b_ntree.nodes.begin(b_node); b_node != b_ntree.nodes.end(); ++b_node) {
1009     if (b_node->mute() || b_node->is_a(&RNA_NodeReroute)) {
1010       /* replace muted node with internal links */
1011       BL::Node::internal_links_iterator b_link;
1012       for (b_node->internal_links.begin(b_link); b_link != b_node->internal_links.end();
1013            ++b_link) {
1014         BL::NodeSocket to_socket(b_link->to_socket());
1015         SocketType::Type to_socket_type = convert_socket_type(to_socket);
1016         if (to_socket_type == SocketType::UNDEFINED) {
1017           continue;
1018         }
1019
1020         ConvertNode *proxy = new ConvertNode(to_socket_type, to_socket_type, true);
1021
1022         input_map[b_link->from_socket().ptr.data] = proxy->inputs[0];
1023         output_map[b_link->to_socket().ptr.data] = proxy->outputs[0];
1024
1025         graph->add(proxy);
1026       }
1027     }
1028     else if (b_node->is_a(&RNA_ShaderNodeGroup) || b_node->is_a(&RNA_NodeCustomGroup) ||
1029              b_node->is_a(&RNA_ShaderNodeCustomGroup)) {
1030
1031       BL::ShaderNodeTree b_group_ntree(PointerRNA_NULL);
1032       if (b_node->is_a(&RNA_ShaderNodeGroup))
1033         b_group_ntree = BL::ShaderNodeTree(((BL::NodeGroup)(*b_node)).node_tree());
1034       else if (b_node->is_a(&RNA_NodeCustomGroup))
1035         b_group_ntree = BL::ShaderNodeTree(((BL::NodeCustomGroup)(*b_node)).node_tree());
1036       else
1037         b_group_ntree = BL::ShaderNodeTree(((BL::ShaderNodeCustomGroup)(*b_node)).node_tree());
1038
1039       ProxyMap group_proxy_input_map, group_proxy_output_map;
1040
1041       /* Add a proxy node for each socket
1042        * Do this even if the node group has no internal tree,
1043        * so that links have something to connect to and assert won't fail.
1044        */
1045       for (b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) {
1046         SocketType::Type input_type = convert_socket_type(*b_input);
1047         if (input_type == SocketType::UNDEFINED) {
1048           continue;
1049         }
1050
1051         ConvertNode *proxy = new ConvertNode(input_type, input_type, true);
1052         graph->add(proxy);
1053
1054         /* register the proxy node for internal binding */
1055         group_proxy_input_map[b_input->identifier()] = proxy;
1056
1057         input_map[b_input->ptr.data] = proxy->inputs[0];
1058
1059         set_default_value(proxy->inputs[0], *b_input, b_data, b_ntree);
1060       }
1061       for (b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) {
1062         SocketType::Type output_type = convert_socket_type(*b_output);
1063         if (output_type == SocketType::UNDEFINED) {
1064           continue;
1065         }
1066
1067         ConvertNode *proxy = new ConvertNode(output_type, output_type, true);
1068         graph->add(proxy);
1069
1070         /* register the proxy node for internal binding */
1071         group_proxy_output_map[b_output->identifier()] = proxy;
1072
1073         output_map[b_output->ptr.data] = proxy->outputs[0];
1074       }
1075
1076       if (b_group_ntree) {
1077         add_nodes(scene,
1078                   b_engine,
1079                   b_data,
1080                   b_depsgraph,
1081                   b_scene,
1082                   graph,
1083                   b_group_ntree,
1084                   group_proxy_input_map,
1085                   group_proxy_output_map);
1086       }
1087     }
1088     else if (b_node->is_a(&RNA_NodeGroupInput)) {
1089       /* map each socket to a proxy node */
1090       for (b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) {
1091         ProxyMap::const_iterator proxy_it = proxy_input_map.find(b_output->identifier());
1092         if (proxy_it != proxy_input_map.end()) {
1093           ConvertNode *proxy = proxy_it->second;
1094
1095           output_map[b_output->ptr.data] = proxy->outputs[0];
1096         }
1097       }
1098     }
1099     else if (b_node->is_a(&RNA_NodeGroupOutput)) {
1100       BL::NodeGroupOutput b_output_node(*b_node);
1101       /* only the active group output is used */
1102       if (b_output_node.is_active_output()) {
1103         /* map each socket to a proxy node */
1104         for (b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) {
1105           ProxyMap::const_iterator proxy_it = proxy_output_map.find(b_input->identifier());
1106           if (proxy_it != proxy_output_map.end()) {
1107             ConvertNode *proxy = proxy_it->second;
1108
1109             input_map[b_input->ptr.data] = proxy->inputs[0];
1110
1111             set_default_value(proxy->inputs[0], *b_input, b_data, b_ntree);
1112           }
1113         }
1114       }
1115     }
1116     else {
1117       ShaderNode *node = NULL;
1118
1119       if (b_node->ptr.data == output_node.ptr.data) {
1120         node = graph->output();
1121       }
1122       else {
1123         BL::ShaderNode b_shader_node(*b_node);
1124         node = add_node(
1125             scene, b_engine, b_data, b_depsgraph, b_scene, graph, b_ntree, b_shader_node);
1126       }
1127
1128       if (node) {
1129         /* map node sockets for linking */
1130         for (b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) {
1131           ShaderInput *input = node_find_input_by_name(node, *b_node, *b_input);
1132           if (!input) {
1133             /* XXX should not happen, report error? */
1134             continue;
1135           }
1136           input_map[b_input->ptr.data] = input;
1137
1138           set_default_value(input, *b_input, b_data, b_ntree);
1139         }
1140         for (b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) {
1141           ShaderOutput *output = node_find_output_by_name(node, *b_node, *b_output);
1142           if (!output) {
1143             /* XXX should not happen, report error? */
1144             continue;
1145           }
1146           output_map[b_output->ptr.data] = output;
1147         }
1148       }
1149     }
1150   }
1151
1152   /* connect nodes */
1153   BL::NodeTree::links_iterator b_link;
1154
1155   for (b_ntree.links.begin(b_link); b_link != b_ntree.links.end(); ++b_link) {
1156     /* Ignore invalid links to avoid unwanted cycles created in graph. */
1157     if (!b_link->is_valid()) {
1158       continue;
1159     }
1160     /* get blender link data */
1161     BL::NodeSocket b_from_sock = b_link->from_socket();
1162     BL::NodeSocket b_to_sock = b_link->to_socket();
1163
1164     ShaderOutput *output = 0;
1165     ShaderInput *input = 0;
1166
1167     PtrOutputMap::iterator output_it = output_map.find(b_from_sock.ptr.data);
1168     if (output_it != output_map.end())
1169       output = output_it->second;
1170     PtrInputMap::iterator input_it = input_map.find(b_to_sock.ptr.data);
1171     if (input_it != input_map.end())
1172       input = input_it->second;
1173
1174     /* either node may be NULL when the node was not exported, typically
1175      * because the node type is not supported */
1176     if (output && input)
1177       graph->connect(output, input);
1178   }
1179 }
1180
1181 static void add_nodes(Scene *scene,
1182                       BL::RenderEngine &b_engine,
1183                       BL::BlendData &b_data,
1184                       BL::Depsgraph &b_depsgraph,
1185                       BL::Scene &b_scene,
1186                       ShaderGraph *graph,
1187                       BL::ShaderNodeTree &b_ntree)
1188 {
1189   static const ProxyMap empty_proxy_map;
1190   add_nodes(scene,
1191             b_engine,
1192             b_data,
1193             b_depsgraph,
1194             b_scene,
1195             graph,
1196             b_ntree,
1197             empty_proxy_map,
1198             empty_proxy_map);
1199 }
1200
1201 /* Sync Materials */
1202
1203 void BlenderSync::sync_materials(BL::Depsgraph &b_depsgraph, bool update_all)
1204 {
1205   shader_map.set_default(scene->default_surface);
1206
1207   TaskPool pool;
1208   set<Shader *> updated_shaders;
1209
1210   BL::Depsgraph::ids_iterator b_id;
1211   for (b_depsgraph.ids.begin(b_id); b_id != b_depsgraph.ids.end(); ++b_id) {
1212     if (!b_id->is_a(&RNA_Material)) {
1213       continue;
1214     }
1215
1216     BL::Material b_mat(*b_id);
1217     Shader *shader;
1218
1219     /* test if we need to sync */
1220     if (shader_map.sync(&shader, b_mat) || shader->need_sync_object || update_all) {
1221       ShaderGraph *graph = new ShaderGraph();
1222
1223       shader->name = b_mat.name().c_str();
1224       shader->pass_id = b_mat.pass_index();
1225       shader->need_sync_object = false;
1226
1227       /* create nodes */
1228       if (b_mat.use_nodes() && b_mat.node_tree()) {
1229         BL::ShaderNodeTree b_ntree(b_mat.node_tree());
1230
1231         add_nodes(scene, b_engine, b_data, b_depsgraph, b_scene, graph, b_ntree);
1232       }
1233       else {
1234         DiffuseBsdfNode *diffuse = new DiffuseBsdfNode();
1235         diffuse->color = get_float3(b_mat.diffuse_color());
1236         graph->add(diffuse);
1237
1238         ShaderNode *out = graph->output();
1239         graph->connect(diffuse->output("BSDF"), out->input("Surface"));
1240       }
1241
1242       /* settings */
1243       PointerRNA cmat = RNA_pointer_get(&b_mat.ptr, "cycles");
1244       shader->use_mis = get_boolean(cmat, "sample_as_light");
1245       shader->use_transparent_shadow = get_boolean(cmat, "use_transparent_shadow");
1246       shader->heterogeneous_volume = !get_boolean(cmat, "homogeneous_volume");
1247       shader->volume_sampling_method = get_volume_sampling(cmat);
1248       shader->volume_interpolation_method = get_volume_interpolation(cmat);
1249       shader->displacement_method = get_displacement_method(cmat);
1250
1251       shader->set_graph(graph);
1252
1253       /* By simplifying the shader graph as soon as possible, some
1254        * redundant shader nodes might be removed which prevents loading
1255        * unnecessary attributes later.
1256        *
1257        * However, since graph simplification also accounts for e.g. mix
1258        * weight, this would cause frequent expensive resyncs in interactive
1259        * sessions, so for those sessions optimization is only performed
1260        * right before compiling.
1261        */
1262       if (!preview) {
1263         pool.push(function_bind(&ShaderGraph::simplify, graph, scene));
1264         /* NOTE: Update shaders out of the threads since those routines
1265          * are accessing and writing to a global context.
1266          */
1267         updated_shaders.insert(shader);
1268       }
1269       else {
1270         /* NOTE: Update tagging can access links which are being
1271          * optimized out.
1272          */
1273         shader->tag_update(scene);
1274       }
1275     }
1276   }
1277
1278   pool.wait_work();
1279
1280   foreach (Shader *shader, updated_shaders) {
1281     shader->tag_update(scene);
1282   }
1283 }
1284
1285 /* Sync World */
1286
1287 void BlenderSync::sync_world(BL::Depsgraph &b_depsgraph, bool update_all)
1288 {
1289   Background *background = scene->background;
1290   Background prevbackground = *background;
1291
1292   BL::World b_world = b_scene.world();
1293
1294   if (world_recalc || update_all || b_world.ptr.data != world_map) {
1295     Shader *shader = scene->default_background;
1296     ShaderGraph *graph = new ShaderGraph();
1297
1298     /* create nodes */
1299     if (b_world && b_world.use_nodes() && b_world.node_tree()) {
1300       BL::ShaderNodeTree b_ntree(b_world.node_tree());
1301
1302       add_nodes(scene, b_engine, b_data, b_depsgraph, b_scene, graph, b_ntree);
1303
1304       /* volume */
1305       PointerRNA cworld = RNA_pointer_get(&b_world.ptr, "cycles");
1306       shader->heterogeneous_volume = !get_boolean(cworld, "homogeneous_volume");
1307       shader->volume_sampling_method = get_volume_sampling(cworld);
1308       shader->volume_interpolation_method = get_volume_interpolation(cworld);
1309     }
1310     else if (b_world) {
1311       BackgroundNode *background = new BackgroundNode();
1312       background->color = get_float3(b_world.color());
1313       graph->add(background);
1314
1315       ShaderNode *out = graph->output();
1316       graph->connect(background->output("Background"), out->input("Surface"));
1317     }
1318
1319     if (b_world) {
1320       /* AO */
1321       BL::WorldLighting b_light = b_world.light_settings();
1322
1323       background->use_ao = b_light.use_ambient_occlusion();
1324       background->ao_factor = b_light.ao_factor();
1325       background->ao_distance = b_light.distance();
1326
1327       /* visibility */
1328       PointerRNA cvisibility = RNA_pointer_get(&b_world.ptr, "cycles_visibility");
1329       uint visibility = 0;
1330
1331       visibility |= get_boolean(cvisibility, "camera") ? PATH_RAY_CAMERA : 0;
1332       visibility |= get_boolean(cvisibility, "diffuse") ? PATH_RAY_DIFFUSE : 0;
1333       visibility |= get_boolean(cvisibility, "glossy") ? PATH_RAY_GLOSSY : 0;
1334       visibility |= get_boolean(cvisibility, "transmission") ? PATH_RAY_TRANSMIT : 0;
1335       visibility |= get_boolean(cvisibility, "scatter") ? PATH_RAY_VOLUME_SCATTER : 0;
1336
1337       background->visibility = visibility;
1338     }
1339     else {
1340       background->use_ao = false;
1341       background->ao_factor = 0.0f;
1342       background->ao_distance = FLT_MAX;
1343     }
1344
1345     shader->set_graph(graph);
1346     shader->tag_update(scene);
1347     background->tag_update(scene);
1348   }
1349
1350   PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
1351
1352   /* when doing preview render check for BI's transparency settings,
1353    * this is so because Blender's preview render routines are not able
1354    * to tweak all cycles's settings depending on different circumstances
1355    */
1356   if (b_engine.is_preview() == false)
1357     background->transparent = get_boolean(cscene, "film_transparent");
1358   else
1359     background->transparent = b_scene.render().alpha_mode() ==
1360                               BL::RenderSettings::alpha_mode_TRANSPARENT;
1361
1362   if (background->transparent) {
1363     background->transparent_glass = get_boolean(cscene, "film_transparent_glass");
1364     background->transparent_roughness_threshold = get_float(cscene, "film_transparent_roughness");
1365   }
1366   else {
1367     background->transparent_glass = false;
1368     background->transparent_roughness_threshold = 0.0f;
1369   }
1370
1371   background->use_shader = view_layer.use_background_shader;
1372   background->use_ao = background->use_ao && view_layer.use_background_ao;
1373
1374   if (background->modified(prevbackground))
1375     background->tag_update(scene);
1376 }
1377
1378 /* Sync Lights */
1379
1380 void BlenderSync::sync_lights(BL::Depsgraph &b_depsgraph, bool update_all)
1381 {
1382   shader_map.set_default(scene->default_light);
1383
1384   BL::Depsgraph::ids_iterator b_id;
1385   for (b_depsgraph.ids.begin(b_id); b_id != b_depsgraph.ids.end(); ++b_id) {
1386     if (!b_id->is_a(&RNA_Light)) {
1387       continue;
1388     }
1389
1390     BL::Light b_light(*b_id);
1391     Shader *shader;
1392
1393     /* test if we need to sync */
1394     if (shader_map.sync(&shader, b_light) || update_all) {
1395       ShaderGraph *graph = new ShaderGraph();
1396
1397       /* create nodes */
1398       if (b_light.use_nodes() && b_light.node_tree()) {
1399         shader->name = b_light.name().c_str();
1400
1401         BL::ShaderNodeTree b_ntree(b_light.node_tree());
1402
1403         add_nodes(scene, b_engine, b_data, b_depsgraph, b_scene, graph, b_ntree);
1404       }
1405       else {
1406         float strength = 1.0f;
1407
1408         if (b_light.type() == BL::Light::type_POINT || b_light.type() == BL::Light::type_SPOT ||
1409             b_light.type() == BL::Light::type_AREA) {
1410           strength = 100.0f;
1411         }
1412
1413         EmissionNode *emission = new EmissionNode();
1414         emission->color = get_float3(b_light.color());
1415         emission->strength = strength;
1416         graph->add(emission);
1417
1418         ShaderNode *out = graph->output();
1419         graph->connect(emission->output("Emission"), out->input("Surface"));
1420       }
1421
1422       shader->set_graph(graph);
1423       shader->tag_update(scene);
1424     }
1425   }
1426 }
1427
1428 void BlenderSync::sync_shaders(BL::Depsgraph &b_depsgraph)
1429 {
1430   /* for auto refresh images */
1431   bool auto_refresh_update = false;
1432
1433   if (preview) {
1434     ImageManager *image_manager = scene->image_manager;
1435     int frame = b_scene.frame_current();
1436     auto_refresh_update = image_manager->set_animation_frame_update(frame);
1437   }
1438
1439   shader_map.pre_sync();
1440
1441   sync_world(b_depsgraph, auto_refresh_update);
1442   sync_lights(b_depsgraph, auto_refresh_update);
1443   sync_materials(b_depsgraph, auto_refresh_update);
1444
1445   /* false = don't delete unused shaders, not supported */
1446   shader_map.post_sync(false);
1447 }
1448
1449 CCL_NAMESPACE_END