← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty-proposed

« back to all changes in this revision

Viewing changes to intern/cycles/blender/blender_shader.cpp

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2013-08-14 10:43:49 UTC
  • mfrom: (14.2.19 sid)
  • Revision ID: package-import@ubuntu.com-20130814104349-t1d5mtwkphp12dyj
Tags: 2.68a-3
* Upload to unstable
* debian/: python3.3 Depends simplified
  - debian/control: python3.3 Depends dropped
    for blender-data package
  - 0001-blender_thumbnailer.patch refreshed
* debian/control: libavcodec b-dep versioning dropped

Show diffs side-by-side

added added

removed removed

Lines of Context:
intern/cycles/blender/blender_shader.cpp
31
31
 
32
32
CCL_NAMESPACE_BEGIN
33
33
 
34
 
typedef map<void*, ShaderNode*> PtrNodeMap;
35
 
typedef pair<ShaderNode*, std::string> SocketPair;
36
 
typedef map<void*, SocketPair> PtrSockMap;
 
34
typedef map<void*, ShaderInput*> PtrInputMap;
 
35
typedef map<void*, ShaderOutput*> PtrOutputMap;
 
36
typedef map<std::string, ProxyNode*> ProxyMap;
37
37
 
38
38
/* Find */
39
39
 
55
55
static BL::NodeSocket get_node_output(BL::Node b_node, const string& name)
56
56
{
57
57
        BL::Node::outputs_iterator b_out;
58
 
 
 
58
        
59
59
        for(b_node.outputs.begin(b_out); b_out != b_node.outputs.end(); ++b_out)
60
60
                if(b_out->name() == name)
61
61
                        return *b_out;
62
 
 
 
62
        
63
63
        assert(0);
64
 
 
 
64
        
65
65
        return *b_out;
66
66
}
67
67
 
68
68
static float3 get_node_output_rgba(BL::Node b_node, const string& name)
69
69
{
70
 
        BL::NodeSocketRGBA sock(get_node_output(b_node, name));
71
 
        return get_float3(sock.default_value());
 
70
        BL::NodeSocket b_sock = get_node_output(b_node, name);
 
71
        float value[4];
 
72
        RNA_float_get_array(&b_sock.ptr, "default_value", value);
 
73
        return make_float3(value[0], value[1], value[2]);
72
74
}
73
75
 
74
76
static float get_node_output_value(BL::Node b_node, const string& name)
75
77
{
76
 
        BL::NodeSocketFloatNone sock(get_node_output(b_node, name));
77
 
        return sock.default_value();
78
 
}
79
 
 
80
 
static ShaderSocketType convert_socket_type(BL::NodeSocket::type_enum b_type)
81
 
{
82
 
        switch (b_type) {
83
 
        case BL::NodeSocket::type_VALUE:
84
 
                return SHADER_SOCKET_FLOAT;
85
 
        case BL::NodeSocket::type_INT:
86
 
                return SHADER_SOCKET_INT;
87
 
        case BL::NodeSocket::type_VECTOR:
88
 
                return SHADER_SOCKET_VECTOR;
89
 
        case BL::NodeSocket::type_RGBA:
90
 
                return SHADER_SOCKET_COLOR;
91
 
        case BL::NodeSocket::type_SHADER:
92
 
                return SHADER_SOCKET_CLOSURE;
93
 
        case BL::NodeSocket::type_STRING:
94
 
                return SHADER_SOCKET_STRING;
95
 
        
96
 
        case BL::NodeSocket::type_BOOLEAN:
97
 
        case BL::NodeSocket::type_MESH:
98
 
        default:
99
 
                return SHADER_SOCKET_FLOAT;
 
78
        BL::NodeSocket b_sock = get_node_output(b_node, name);
 
79
        return RNA_float_get(&b_sock.ptr, "default_value");
 
80
}
 
81
 
 
82
static float3 get_node_output_vector(BL::Node b_node, const string& name)
 
83
{
 
84
        BL::NodeSocket b_sock = get_node_output(b_node, name);
 
85
        float value[3];
 
86
        RNA_float_get_array(&b_sock.ptr, "default_value", value);
 
87
        return make_float3(value[0], value[1], value[2]);
 
88
}
 
89
 
 
90
static ShaderSocketType convert_socket_type(BL::NodeSocket b_socket)
 
91
{
 
92
        switch (b_socket.type()) {
 
93
                case BL::NodeSocket::type_VALUE:
 
94
                        return SHADER_SOCKET_FLOAT;
 
95
                case BL::NodeSocket::type_INT:
 
96
                        return SHADER_SOCKET_INT;
 
97
                case BL::NodeSocket::type_VECTOR:
 
98
                        return SHADER_SOCKET_VECTOR;
 
99
                case BL::NodeSocket::type_RGBA:
 
100
                        return SHADER_SOCKET_COLOR;
 
101
                case BL::NodeSocket::type_STRING:
 
102
                        return SHADER_SOCKET_STRING;
 
103
                case BL::NodeSocket::type_SHADER:
 
104
                        return SHADER_SOCKET_CLOSURE;
 
105
                
 
106
                default:
 
107
                        return SHADER_SOCKET_UNDEFINED;
100
108
        }
101
109
}
102
110
 
103
 
static void set_default_value(ShaderInput *input, BL::NodeSocket sock, BL::BlendData b_data, BL::ID b_id)
 
111
static void set_default_value(ShaderInput *input, BL::Node b_node, BL::NodeSocket b_sock, BL::BlendData b_data, BL::ID b_id)
104
112
{
105
113
        /* copy values for non linked inputs */
106
114
        switch(input->type) {
107
115
        case SHADER_SOCKET_FLOAT: {
108
 
                BL::NodeSocketFloatNone value_sock(sock);
109
 
                input->set(value_sock.default_value());
 
116
                input->set(get_float(b_sock.ptr, "default_value"));
110
117
                break;
111
118
        }
112
119
        case SHADER_SOCKET_INT: {
113
 
                BL::NodeSocketIntNone value_sock(sock);
114
 
                input->set((float)value_sock.default_value());
 
120
                input->set((float)get_int(b_sock.ptr, "default_value"));
115
121
                break;
116
122
        }
117
123
        case SHADER_SOCKET_COLOR: {
118
 
                BL::NodeSocketRGBA rgba_sock(sock);
119
 
                input->set(get_float3(rgba_sock.default_value()));
 
124
                input->set(float4_to_float3(get_float4(b_sock.ptr, "default_value")));
120
125
                break;
121
126
        }
122
127
        case SHADER_SOCKET_NORMAL:
123
128
        case SHADER_SOCKET_POINT:
124
129
        case SHADER_SOCKET_VECTOR: {
125
 
                BL::NodeSocketVectorNone vec_sock(sock);
126
 
                input->set(get_float3(vec_sock.default_value()));
 
130
                input->set(get_float3(b_sock.ptr, "default_value"));
127
131
                break;
128
132
        }
129
133
        case SHADER_SOCKET_STRING: {
130
 
                BL::NodeSocketStringNone string_sock(sock);
131
 
                input->set((ustring)blender_absolute_path(b_data, b_id, string_sock.default_value()));
 
134
                input->set((ustring)blender_absolute_path(b_data, b_id, get_string(b_sock.ptr, "default_value")));
132
135
                break;
133
136
        }
 
137
        
134
138
        case SHADER_SOCKET_CLOSURE:
 
139
        case SHADER_SOCKET_UNDEFINED:
135
140
                break;
136
141
        }
137
142
}
171
176
{
172
177
        ShaderNode *node = NULL;
173
178
 
174
 
        switch(b_node.type()) {
175
 
                /* not supported */
176
 
                case BL::ShaderNode::type_GEOMETRY: break;
177
 
                case BL::ShaderNode::type_MATERIAL: break;
178
 
                case BL::ShaderNode::type_MATERIAL_EXT: break;
179
 
                case BL::ShaderNode::type_OUTPUT: break;
180
 
                case BL::ShaderNode::type_SQUEEZE: break;
181
 
                case BL::ShaderNode::type_TEXTURE: break;
182
 
                case BL::ShaderNode::type_FRAME: break;
183
 
                /* handled outside this function */
184
 
                case BL::ShaderNode::type_GROUP: break;
185
 
                /* existing blender nodes */
186
 
                case BL::ShaderNode::type_REROUTE: {
187
 
                        BL::Node::inputs_iterator b_input;
188
 
                        b_node.inputs.begin(b_input);
189
 
                        BL::Node::outputs_iterator b_output;
190
 
                        b_node.outputs.begin(b_output);
191
 
                        ProxyNode *proxy = new ProxyNode(convert_socket_type(b_input->type()), convert_socket_type(b_output->type()));
192
 
                        node = proxy;
193
 
                        break;
194
 
                }
195
 
                case BL::ShaderNode::type_CURVE_VEC: {
196
 
                        BL::ShaderNodeVectorCurve b_curve_node(b_node);
197
 
                        VectorCurvesNode *curves = new VectorCurvesNode();
198
 
                        curvemapping_color_to_array(b_curve_node.mapping(), curves->curves, RAMP_TABLE_SIZE, false);
199
 
                        node = curves;
200
 
                        break;
201
 
                }
202
 
                case BL::ShaderNode::type_CURVE_RGB: {
203
 
                        BL::ShaderNodeRGBCurve b_curve_node(b_node);
204
 
                        RGBCurvesNode *curves = new RGBCurvesNode();
205
 
                        curvemapping_color_to_array(b_curve_node.mapping(), curves->curves, RAMP_TABLE_SIZE, true);
206
 
                        node = curves;
207
 
                        break;
208
 
                }
209
 
                case BL::ShaderNode::type_VALTORGB: {
210
 
                        RGBRampNode *ramp = new RGBRampNode();
211
 
                        BL::ShaderNodeValToRGB b_ramp_node(b_node);
212
 
                        colorramp_to_array(b_ramp_node.color_ramp(), ramp->ramp, RAMP_TABLE_SIZE);
213
 
                        node = ramp;
214
 
                        break;
215
 
                }
216
 
                case BL::ShaderNode::type_RGB: {
217
 
                        ColorNode *color = new ColorNode();
218
 
                        color->value = get_node_output_rgba(b_node, "Color");
219
 
                        node = color;
220
 
                        break;
221
 
                }
222
 
                case BL::ShaderNode::type_VALUE: {
223
 
                        ValueNode *value = new ValueNode();
224
 
                        value->value = get_node_output_value(b_node, "Value");
225
 
                        node = value;
226
 
                        break;
227
 
                }
228
 
                case BL::ShaderNode::type_CAMERA: {
229
 
                        node = new CameraNode();
230
 
                        break;
231
 
                }
232
 
                case BL::ShaderNode::type_INVERT: {
233
 
                        node = new InvertNode();
234
 
                        break;
235
 
                }
236
 
                case BL::ShaderNode::type_GAMMA: {
237
 
                        node = new GammaNode();
238
 
                        break;
239
 
                }
240
 
                case BL::ShaderNode::type_BRIGHTCONTRAST: {
241
 
                        node = new BrightContrastNode();
242
 
                        break;
243
 
                }
244
 
                case BL::ShaderNode::type_MIX_RGB: {
245
 
                        BL::ShaderNodeMixRGB b_mix_node(b_node);
246
 
                        MixNode *mix = new MixNode();
247
 
                        mix->type = MixNode::type_enum[b_mix_node.blend_type()];
 
179
        /* existing blender nodes */
 
180
        if (b_node.is_a(&RNA_ShaderNodeRGBCurve)) {
 
181
                BL::ShaderNodeRGBCurve b_curve_node(b_node);
 
182
                RGBCurvesNode *curves = new RGBCurvesNode();
 
183
                curvemapping_color_to_array(b_curve_node.mapping(), curves->curves, RAMP_TABLE_SIZE, true);
 
184
                node = curves;
 
185
        }
 
186
        if (b_node.is_a(&RNA_ShaderNodeVectorCurve)) {
 
187
                BL::ShaderNodeVectorCurve b_curve_node(b_node);
 
188
                VectorCurvesNode *curves = new VectorCurvesNode();
 
189
                curvemapping_color_to_array(b_curve_node.mapping(), curves->curves, RAMP_TABLE_SIZE, false);
 
190
                node = curves;
 
191
        }
 
192
        else if (b_node.is_a(&RNA_ShaderNodeValToRGB)) {
 
193
                RGBRampNode *ramp = new RGBRampNode();
 
194
                BL::ShaderNodeValToRGB b_ramp_node(b_node);
 
195
                colorramp_to_array(b_ramp_node.color_ramp(), ramp->ramp, RAMP_TABLE_SIZE);
 
196
                ramp->interpolate = b_ramp_node.color_ramp().interpolation() != BL::ColorRamp::interpolation_CONSTANT;
 
197
                node = ramp;
 
198
        }
 
199
        else if (b_node.is_a(&RNA_ShaderNodeRGB)) {
 
200
                ColorNode *color = new ColorNode();
 
201
                color->value = get_node_output_rgba(b_node, "Color");
 
202
                node = color;
 
203
        }
 
204
        else if (b_node.is_a(&RNA_ShaderNodeValue)) {
 
205
                ValueNode *value = new ValueNode();
 
206
                value->value = get_node_output_value(b_node, "Value");
 
207
                node = value;
 
208
        }
 
209
        else if (b_node.is_a(&RNA_ShaderNodeCameraData)) {
 
210
                node = new CameraNode();
 
211
        }
 
212
        else if (b_node.is_a(&RNA_ShaderNodeInvert)) {
 
213
                node = new InvertNode();
 
214
        }
 
215
        else if (b_node.is_a(&RNA_ShaderNodeGamma)) {
 
216
                node = new GammaNode();
 
217
        }
 
218
        else if (b_node.is_a(&RNA_ShaderNodeBrightContrast)) {
 
219
                node = new BrightContrastNode();
 
220
        }
 
221
        else if (b_node.is_a(&RNA_ShaderNodeMixRGB)) {
 
222
                BL::ShaderNodeMixRGB b_mix_node(b_node);
 
223
                MixNode *mix = new MixNode();
 
224
                mix->type = MixNode::type_enum[b_mix_node.blend_type()];
248
225
                        mix->use_clamp = b_mix_node.use_clamp();
249
 
                        node = mix;
250
 
                        break;
251
 
                }
252
 
                case BL::ShaderNode::type_SEPRGB: {
253
 
                        node = new SeparateRGBNode();
254
 
                        break;
255
 
                }
256
 
                case BL::ShaderNode::type_COMBRGB: {
257
 
                        node = new CombineRGBNode();
258
 
                        break;
259
 
                }
260
 
                case BL::ShaderNode::type_HUE_SAT: {
261
 
                        node = new HSVNode();
262
 
                        break;
263
 
                }
264
 
                case BL::ShaderNode::type_RGBTOBW: {
265
 
                        node = new ConvertNode(SHADER_SOCKET_COLOR, SHADER_SOCKET_FLOAT);
266
 
                        break;
267
 
                }
268
 
                case BL::ShaderNode::type_MATH: {
269
 
                        BL::ShaderNodeMath b_math_node(b_node);
270
 
                        MathNode *math = new MathNode();
271
 
                        math->type = MathNode::type_enum[b_math_node.operation()];
 
226
                node = mix;
 
227
        }
 
228
        else if (b_node.is_a(&RNA_ShaderNodeSeparateRGB)) {
 
229
                node = new SeparateRGBNode();
 
230
        }
 
231
        else if (b_node.is_a(&RNA_ShaderNodeCombineRGB)) {
 
232
                node = new CombineRGBNode();
 
233
        }
 
234
        else if (b_node.is_a(&RNA_ShaderNodeHueSaturation)) {
 
235
                node = new HSVNode();
 
236
        }
 
237
        else if (b_node.is_a(&RNA_ShaderNodeRGBToBW)) {
 
238
                node = new ConvertNode(SHADER_SOCKET_COLOR, SHADER_SOCKET_FLOAT);
 
239
        }
 
240
        else if (b_node.is_a(&RNA_ShaderNodeMath)) {
 
241
                BL::ShaderNodeMath b_math_node(b_node);
 
242
                MathNode *math = new MathNode();
 
243
                math->type = MathNode::type_enum[b_math_node.operation()];
272
244
                        math->use_clamp = b_math_node.use_clamp();
273
 
                        node = math;
274
 
                        break;
275
 
                }
276
 
                case BL::ShaderNode::type_VECT_MATH: {
277
 
                        BL::ShaderNodeVectorMath b_vector_math_node(b_node);
278
 
                        VectorMathNode *vmath = new VectorMathNode();
279
 
                        vmath->type = VectorMathNode::type_enum[b_vector_math_node.operation()];
280
 
                        node = vmath;
281
 
                        break;
282
 
                }
283
 
                case BL::ShaderNode::type_NORMAL: {
284
 
                        BL::Node::outputs_iterator out_it;
285
 
                        b_node.outputs.begin(out_it);
286
 
                        BL::NodeSocketVectorNone vec_sock(*out_it);
287
 
 
288
 
                        NormalNode *norm = new NormalNode();
289
 
                        norm->direction = get_float3(vec_sock.default_value());
290
 
 
291
 
                        node = norm;
292
 
                        break;
293
 
                }
294
 
                case BL::ShaderNode::type_MAPPING: {
295
 
                        BL::ShaderNodeMapping b_mapping_node(b_node);
296
 
                        MappingNode *mapping = new MappingNode();
297
 
 
298
 
                        get_tex_mapping(&mapping->tex_mapping, b_mapping_node);
299
 
 
300
 
                        node = mapping;
301
 
                        break;
302
 
                }
303
 
 
304
 
                /* new nodes */
305
 
                case BL::ShaderNode::type_OUTPUT_MATERIAL:
306
 
                case BL::ShaderNode::type_OUTPUT_WORLD:
307
 
                case BL::ShaderNode::type_OUTPUT_LAMP: {
308
 
                        node = graph->output();
309
 
                        break;
310
 
                }
311
 
                case BL::ShaderNode::type_FRESNEL: {
312
 
                        node = new FresnelNode();
313
 
                        break;
314
 
                }
315
 
                case BL::ShaderNode::type_LAYER_WEIGHT: {
316
 
                        node = new LayerWeightNode();
317
 
                        break;
318
 
                }
319
 
                case BL::ShaderNode::type_ADD_SHADER: {
320
 
                        node = new AddClosureNode();
321
 
                        break;
322
 
                }
323
 
                case BL::ShaderNode::type_MIX_SHADER: {
324
 
                        node = new MixClosureNode();
325
 
                        break;
326
 
                }
327
 
                case BL::ShaderNode::type_ATTRIBUTE: {
328
 
                        BL::ShaderNodeAttribute b_attr_node(b_node);
329
 
                        AttributeNode *attr = new AttributeNode();
330
 
                        attr->attribute = b_attr_node.attribute_name();
331
 
                        node = attr;
332
 
                        break;
333
 
                }
334
 
                case BL::ShaderNode::type_BACKGROUND: {
335
 
                        node = new BackgroundNode();
336
 
                        break;
337
 
                }
338
 
                case BL::ShaderNode::type_HOLDOUT: {
339
 
                        node = new HoldoutNode();
340
 
                        break;
341
 
                }
342
 
                case BL::ShaderNode::type_BSDF_ANISOTROPIC: {
343
 
                        node = new WardBsdfNode();
344
 
                        break;
345
 
                }
346
 
                case BL::ShaderNode::type_BSDF_DIFFUSE: {
347
 
                        node = new DiffuseBsdfNode();
348
 
                        break;
349
 
                }
350
 
                case BL::ShaderNode::type_BSDF_GLOSSY: {
351
 
                        BL::ShaderNodeBsdfGlossy b_glossy_node(b_node);
352
 
                        GlossyBsdfNode *glossy = new GlossyBsdfNode();
353
 
 
354
 
                        switch(b_glossy_node.distribution()) {
355
 
                                case BL::ShaderNodeBsdfGlossy::distribution_SHARP:
356
 
                                        glossy->distribution = ustring("Sharp");
357
 
                                        break;
358
 
                                case BL::ShaderNodeBsdfGlossy::distribution_BECKMANN:
359
 
                                        glossy->distribution = ustring("Beckmann");
360
 
                                        break;
361
 
                                case BL::ShaderNodeBsdfGlossy::distribution_GGX:
362
 
                                        glossy->distribution = ustring("GGX");
363
 
                                        break;
364
 
                        }
365
 
                        node = glossy;
366
 
                        break;
367
 
                }
368
 
                case BL::ShaderNode::type_BSDF_GLASS: {
369
 
                        BL::ShaderNodeBsdfGlass b_glass_node(b_node);
370
 
                        GlassBsdfNode *glass = new GlassBsdfNode();
371
 
                        switch(b_glass_node.distribution()) {
372
 
                                case BL::ShaderNodeBsdfGlass::distribution_SHARP:
373
 
                                        glass->distribution = ustring("Sharp");
374
 
                                        break;
375
 
                                case BL::ShaderNodeBsdfGlass::distribution_BECKMANN:
376
 
                                        glass->distribution = ustring("Beckmann");
377
 
                                        break;
378
 
                                case BL::ShaderNodeBsdfGlass::distribution_GGX:
379
 
                                        glass->distribution = ustring("GGX");
380
 
                                        break;
381
 
                        }
382
 
                        node = glass;
383
 
                        break;
384
 
                }
385
 
                case BL::ShaderNode::type_BSDF_REFRACTION: {
386
 
                        BL::ShaderNodeBsdfRefraction b_refraction_node(b_node);
387
 
                        RefractionBsdfNode *refraction = new RefractionBsdfNode();
388
 
                        switch(b_refraction_node.distribution()) {
389
 
                                case BL::ShaderNodeBsdfRefraction::distribution_SHARP:
390
 
                                        refraction->distribution = ustring("Sharp");
391
 
                                        break;
392
 
                                case BL::ShaderNodeBsdfRefraction::distribution_BECKMANN:
393
 
                                        refraction->distribution = ustring("Beckmann");
394
 
                                        break;
395
 
                                case BL::ShaderNodeBsdfRefraction::distribution_GGX:
396
 
                                        refraction->distribution = ustring("GGX");
397
 
                                        break;
398
 
                        }
399
 
                        node = refraction;
400
 
                        break;
401
 
                }
402
 
                case BL::ShaderNode::type_BSDF_TRANSLUCENT: {
403
 
                        node = new TranslucentBsdfNode();
404
 
                        break;
405
 
                }
406
 
                case BL::ShaderNode::type_BSDF_TRANSPARENT: {
407
 
                        node = new TransparentBsdfNode();
408
 
                        break;
409
 
                }
410
 
                case BL::ShaderNode::type_BSDF_VELVET: {
411
 
                        node = new VelvetBsdfNode();
412
 
                        break;
413
 
                }
414
 
                case BL::ShaderNode::type_EMISSION: {
415
 
                        node = new EmissionNode();
416
 
                        break;
417
 
                }
418
 
                case BL::ShaderNode::type_AMBIENT_OCCLUSION: {
419
 
                        node = new AmbientOcclusionNode();
420
 
                        break;
421
 
                }
422
 
                case BL::ShaderNode::type_VOLUME_ISOTROPIC: {
423
 
                        node = new IsotropicVolumeNode();
424
 
                        break;
425
 
                }
426
 
                case BL::ShaderNode::type_VOLUME_TRANSPARENT: {
427
 
                        node = new TransparentVolumeNode();
428
 
                        break;
429
 
                }
430
 
                case BL::ShaderNode::type_NEW_GEOMETRY: {
431
 
                        node = new GeometryNode();
432
 
                        break;
433
 
                }
434
 
                case BL::ShaderNode::type_LIGHT_PATH: {
435
 
                        node = new LightPathNode();
436
 
                        break;
437
 
                }
438
 
                case BL::ShaderNode::type_LIGHT_FALLOFF: {
439
 
                        node = new LightFalloffNode();
440
 
                        break;
441
 
                }
442
 
                case BL::ShaderNode::type_OBJECT_INFO: {
443
 
                        node = new ObjectInfoNode();
444
 
                        break;
445
 
                }
446
 
                case BL::ShaderNode::type_PARTICLE_INFO: {
447
 
                        node = new ParticleInfoNode();
448
 
                        break;
449
 
                }
450
 
                case BL::ShaderNode::type_HAIR_INFO: {
451
 
                        node = new HairInfoNode();
452
 
                        break;
453
 
                }
454
 
                case BL::ShaderNode::type_BUMP: {
455
 
                        node = new BumpNode();
456
 
                        break;
457
 
                }
458
 
                case BL::ShaderNode::type_SCRIPT: {
 
245
                node = math;
 
246
        }
 
247
        else if (b_node.is_a(&RNA_ShaderNodeVectorMath)) {
 
248
                BL::ShaderNodeVectorMath b_vector_math_node(b_node);
 
249
                VectorMathNode *vmath = new VectorMathNode();
 
250
                vmath->type = VectorMathNode::type_enum[b_vector_math_node.operation()];
 
251
                node = vmath;
 
252
        }
 
253
        else if (b_node.is_a(&RNA_ShaderNodeNormal)) {
 
254
                BL::Node::outputs_iterator out_it;
 
255
                b_node.outputs.begin(out_it);
 
256
                
 
257
                NormalNode *norm = new NormalNode();
 
258
                norm->direction = get_node_output_vector(b_node, "Normal");
 
259
                node = norm;
 
260
        }
 
261
        else if (b_node.is_a(&RNA_ShaderNodeMapping)) {
 
262
                BL::ShaderNodeMapping b_mapping_node(b_node);
 
263
                MappingNode *mapping = new MappingNode();
 
264
                
 
265
                get_tex_mapping(&mapping->tex_mapping, b_mapping_node);
 
266
                
 
267
                node = mapping;
 
268
        }
 
269
        /* new nodes */
 
270
        else if (b_node.is_a(&RNA_ShaderNodeOutputMaterial)
 
271
              || b_node.is_a(&RNA_ShaderNodeOutputWorld)
 
272
              || b_node.is_a(&RNA_ShaderNodeOutputLamp)) {
 
273
                node = graph->output();
 
274
        }
 
275
        else if (b_node.is_a(&RNA_ShaderNodeFresnel)) {
 
276
                node = new FresnelNode();
 
277
        }
 
278
        else if (b_node.is_a(&RNA_ShaderNodeLayerWeight)) {
 
279
                node = new LayerWeightNode();
 
280
        }
 
281
        else if (b_node.is_a(&RNA_ShaderNodeAddShader)) {
 
282
                node = new AddClosureNode();
 
283
        }
 
284
        else if (b_node.is_a(&RNA_ShaderNodeMixShader)) {
 
285
                node = new MixClosureNode();
 
286
        }
 
287
        else if (b_node.is_a(&RNA_ShaderNodeAttribute)) {
 
288
                BL::ShaderNodeAttribute b_attr_node(b_node);
 
289
                AttributeNode *attr = new AttributeNode();
 
290
                attr->attribute = b_attr_node.attribute_name();
 
291
                node = attr;
 
292
        }
 
293
        else if (b_node.is_a(&RNA_ShaderNodeBackground)) {
 
294
                node = new BackgroundNode();
 
295
        }
 
296
        else if (b_node.is_a(&RNA_ShaderNodeHoldout)) {
 
297
                node = new HoldoutNode();
 
298
        }
 
299
        else if (b_node.is_a(&RNA_ShaderNodeBsdfAnisotropic)) {
 
300
                node = new WardBsdfNode();
 
301
        }
 
302
        else if (b_node.is_a(&RNA_ShaderNodeBsdfDiffuse)) {
 
303
                node = new DiffuseBsdfNode();
 
304
        }
 
305
        else if (b_node.is_a(&RNA_ShaderNodeSubsurfaceScattering)) {
 
306
                node = new SubsurfaceScatteringNode();
 
307
        }
 
308
        else if (b_node.is_a(&RNA_ShaderNodeBsdfGlossy)) {
 
309
                BL::ShaderNodeBsdfGlossy b_glossy_node(b_node);
 
310
                GlossyBsdfNode *glossy = new GlossyBsdfNode();
 
311
                
 
312
                switch(b_glossy_node.distribution()) {
 
313
                case BL::ShaderNodeBsdfGlossy::distribution_SHARP:
 
314
                        glossy->distribution = ustring("Sharp");
 
315
                        break;
 
316
                case BL::ShaderNodeBsdfGlossy::distribution_BECKMANN:
 
317
                        glossy->distribution = ustring("Beckmann");
 
318
                        break;
 
319
                case BL::ShaderNodeBsdfGlossy::distribution_GGX:
 
320
                        glossy->distribution = ustring("GGX");
 
321
                        break;
 
322
                }
 
323
                node = glossy;
 
324
        }
 
325
        else if (b_node.is_a(&RNA_ShaderNodeBsdfGlass)) {
 
326
                BL::ShaderNodeBsdfGlass b_glass_node(b_node);
 
327
                GlassBsdfNode *glass = new GlassBsdfNode();
 
328
                switch(b_glass_node.distribution()) {
 
329
                case BL::ShaderNodeBsdfGlass::distribution_SHARP:
 
330
                        glass->distribution = ustring("Sharp");
 
331
                        break;
 
332
                case BL::ShaderNodeBsdfGlass::distribution_BECKMANN:
 
333
                        glass->distribution = ustring("Beckmann");
 
334
                        break;
 
335
                case BL::ShaderNodeBsdfGlass::distribution_GGX:
 
336
                        glass->distribution = ustring("GGX");
 
337
                        break;
 
338
                }
 
339
                node = glass;
 
340
        }
 
341
        else if (b_node.is_a(&RNA_ShaderNodeBsdfRefraction)) {
 
342
                BL::ShaderNodeBsdfRefraction b_refraction_node(b_node);
 
343
                RefractionBsdfNode *refraction = new RefractionBsdfNode();
 
344
                switch(b_refraction_node.distribution()) {
 
345
                        case BL::ShaderNodeBsdfRefraction::distribution_SHARP:
 
346
                                refraction->distribution = ustring("Sharp");
 
347
                                break;
 
348
                        case BL::ShaderNodeBsdfRefraction::distribution_BECKMANN:
 
349
                                refraction->distribution = ustring("Beckmann");
 
350
                                break;
 
351
                        case BL::ShaderNodeBsdfRefraction::distribution_GGX:
 
352
                                refraction->distribution = ustring("GGX");
 
353
                                break;
 
354
                }
 
355
                node = refraction;
 
356
        }
 
357
        else if (b_node.is_a(&RNA_ShaderNodeBsdfToon)) {
 
358
                BL::ShaderNodeBsdfToon b_toon_node(b_node);
 
359
                ToonBsdfNode *toon = new ToonBsdfNode();
 
360
                switch(b_toon_node.component()) {
 
361
                        case BL::ShaderNodeBsdfToon::component_DIFFUSE:
 
362
                                toon->component = ustring("Diffuse");
 
363
                                break;
 
364
                        case BL::ShaderNodeBsdfToon::component_GLOSSY:
 
365
                                toon->component = ustring("Glossy");
 
366
                                break;
 
367
                }
 
368
                node = toon;
 
369
        }
 
370
        else if (b_node.is_a(&RNA_ShaderNodeBsdfTranslucent)) {
 
371
                node = new TranslucentBsdfNode();
 
372
        }
 
373
        else if (b_node.is_a(&RNA_ShaderNodeBsdfTransparent)) {
 
374
                node = new TransparentBsdfNode();
 
375
        }
 
376
        else if (b_node.is_a(&RNA_ShaderNodeBsdfVelvet)) {
 
377
                node = new VelvetBsdfNode();
 
378
        }
 
379
        else if (b_node.is_a(&RNA_ShaderNodeEmission)) {
 
380
                node = new EmissionNode();
 
381
        }
 
382
        else if (b_node.is_a(&RNA_ShaderNodeAmbientOcclusion)) {
 
383
                node = new AmbientOcclusionNode();
 
384
        }
 
385
        else if (b_node.is_a(&RNA_ShaderNodeVolumeIsotropic)) {
 
386
                node = new IsotropicVolumeNode();
 
387
        }
 
388
        else if (b_node.is_a(&RNA_ShaderNodeVolumeTransparent)) {
 
389
                node = new TransparentVolumeNode();
 
390
        }
 
391
        else if (b_node.is_a(&RNA_ShaderNodeNewGeometry)) {
 
392
                node = new GeometryNode();
 
393
        }
 
394
        else if (b_node.is_a(&RNA_ShaderNodeWireframe)) {
 
395
                BL::ShaderNodeWireframe b_wireframe_node(b_node);
 
396
                WireframeNode *wire = new WireframeNode();
 
397
                wire->use_pixel_size = b_wireframe_node.use_pixel_size();
 
398
                node = wire;
 
399
        }
 
400
        else if (b_node.is_a(&RNA_ShaderNodeWavelength)) {
 
401
                node = new WavelengthNode();
 
402
        }
 
403
        else if (b_node.is_a(&RNA_ShaderNodeLightPath)) {
 
404
                node = new LightPathNode();
 
405
        }
 
406
        else if (b_node.is_a(&RNA_ShaderNodeLightFalloff)) {
 
407
                node = new LightFalloffNode();
 
408
        }
 
409
        else if (b_node.is_a(&RNA_ShaderNodeObjectInfo)) {
 
410
                node = new ObjectInfoNode();
 
411
        }
 
412
        else if (b_node.is_a(&RNA_ShaderNodeParticleInfo)) {
 
413
                node = new ParticleInfoNode();
 
414
        }
 
415
        else if (b_node.is_a(&RNA_ShaderNodeHairInfo)) {
 
416
                node = new HairInfoNode();
 
417
        }
 
418
        else if (b_node.is_a(&RNA_ShaderNodeBump)) {
 
419
                BL::ShaderNodeBump b_bump_node(b_node);
 
420
                BumpNode *bump = new BumpNode();
 
421
                bump->invert = b_bump_node.invert();
 
422
                node = bump;
 
423
        }
 
424
        else if (b_node.is_a(&RNA_ShaderNodeScript)) {
459
425
#ifdef WITH_OSL
460
 
                        if(!scene->shader_manager->use_osl())
461
 
                                break;
462
 
 
 
426
                if(scene->shader_manager->use_osl()) {
463
427
                        /* create script node */
464
428
                        BL::ShaderNodeScript b_script_node(b_node);
465
429
                        OSLScriptNode *script_node = new OSLScriptNode();
472
436
                         * Note 2: ShaderInput/ShaderOutput store shallow string copies only!
473
437
                         * Socket names must be stored in the extra lists instead. */
474
438
                        BL::Node::inputs_iterator b_input;
475
 
 
 
439
                        
476
440
                        for (b_script_node.inputs.begin(b_input); b_input != b_script_node.inputs.end(); ++b_input) {
477
441
                                script_node->input_names.push_back(ustring(b_input->name()));
478
 
                                ShaderInput *input = script_node->add_input(script_node->input_names.back().c_str(), convert_socket_type(b_input->type()));
479
 
                                set_default_value(input, *b_input, b_data, b_ntree);
 
442
                                ShaderInput *input = script_node->add_input(script_node->input_names.back().c_str(),
 
443
                                                                            convert_socket_type(*b_input));
 
444
                                set_default_value(input, b_node, *b_input, b_data, b_ntree);
480
445
                        }
481
 
 
 
446
                        
482
447
                        BL::Node::outputs_iterator b_output;
483
 
 
 
448
                        
484
449
                        for (b_script_node.outputs.begin(b_output); b_output != b_script_node.outputs.end(); ++b_output) {
485
450
                                script_node->output_names.push_back(ustring(b_output->name()));
486
 
                                script_node->add_output(script_node->output_names.back().c_str(), convert_socket_type(b_output->type()));
 
451
                                script_node->add_output(script_node->output_names.back().c_str(),
 
452
                                                        convert_socket_type(*b_output));
487
453
                        }
488
 
 
 
454
                        
489
455
                        /* load bytecode or filepath */
490
456
                        OSLShaderManager *manager = (OSLShaderManager*)scene->shader_manager;
491
457
                        string bytecode_hash = b_script_node.bytecode_hash();
492
 
 
 
458
                        
493
459
                        if(!bytecode_hash.empty()) {
494
460
                                /* loaded bytecode if not already done */
495
461
                                if(!manager->shader_test_loaded(bytecode_hash))
496
462
                                        manager->shader_load_bytecode(bytecode_hash, b_script_node.bytecode());
497
 
 
 
463
                                
498
464
                                script_node->bytecode_hash = bytecode_hash;
499
465
                        }
500
466
                        else {
503
469
                        }
504
470
                        
505
471
                        node = script_node;
 
472
                }
506
473
#endif
 
474
        }
 
475
        else if (b_node.is_a(&RNA_ShaderNodeTexImage)) {
 
476
                BL::ShaderNodeTexImage b_image_node(b_node);
 
477
                BL::Image b_image(b_image_node.image());
 
478
                ImageTextureNode *image = new ImageTextureNode();
 
479
                if(b_image) {
 
480
                        /* builtin images will use callback-based reading because
 
481
                         * they could only be loaded correct from blender side
 
482
                         */
 
483
                        bool is_builtin = b_image.packed_file() ||
 
484
                                          b_image.source() == BL::Image::source_GENERATED ||
 
485
                                          b_image.source() == BL::Image::source_MOVIE;
507
486
 
508
 
                        break;
509
 
                }
510
 
                case BL::ShaderNode::type_TEX_IMAGE: {
511
 
                        BL::ShaderNodeTexImage b_image_node(b_node);
512
 
                        BL::Image b_image(b_image_node.image());
513
 
                        ImageTextureNode *image = new ImageTextureNode();
514
 
                        if(b_image) {
515
 
                                /* builtin images will use callback-based reading because
516
 
                                 * they could only be loaded correct from blender side
 
487
                        if(is_builtin) {
 
488
                                /* for builtin images we're using image datablock name to find an image to
 
489
                                 * read pixels from later
 
490
                                 *
 
491
                                 * also store frame number as well, so there's no differences in handling
 
492
                                 * builtin names for packed images and movies
517
493
                                 */
518
 
                                bool is_builtin = b_image.packed_file() ||
519
 
                                                  b_image.source() == BL::Image::source_GENERATED ||
520
 
                                                  b_image.source() == BL::Image::source_MOVIE;
521
 
 
522
 
                                if(is_builtin) {
523
 
                                        /* for builtin images we're using image datablock name to find an image to
524
 
                                         * read pixels from later
525
 
                                         *
526
 
                                         * also store frame number as well, so there's no differences in handling
527
 
                                         * builtin names for packed images and movies
528
 
                                         */
529
 
                                        int scene_frame = b_scene.frame_current();
530
 
                                        int image_frame = image_user_frame_number(b_image_node.image_user(), scene_frame);
531
 
                                        image->filename = b_image.name() + "@" + string_printf("%d", image_frame);
532
 
                                        image->builtin_data = b_image.ptr.data;
533
 
                                }
534
 
                                else {
535
 
                                        image->filename = image_user_file_path(b_image_node.image_user(), b_image, b_scene.frame_current());
536
 
                                        image->builtin_data = NULL;
537
 
                                }
538
 
 
539
 
                                image->animated = b_image_node.image_user().use_auto_refresh();
540
 
                        }
541
 
                        image->color_space = ImageTextureNode::color_space_enum[(int)b_image_node.color_space()];
542
 
                        image->projection = ImageTextureNode::projection_enum[(int)b_image_node.projection()];
543
 
                        image->projection_blend = b_image_node.projection_blend();
544
 
                        get_tex_mapping(&image->tex_mapping, b_image_node.texture_mapping());
545
 
                        node = image;
546
 
                        break;
547
 
                }
548
 
                case BL::ShaderNode::type_TEX_ENVIRONMENT: {
549
 
                        BL::ShaderNodeTexEnvironment b_env_node(b_node);
550
 
                        BL::Image b_image(b_env_node.image());
551
 
                        EnvironmentTextureNode *env = new EnvironmentTextureNode();
552
 
                        if(b_image) {
553
 
                                bool is_builtin = b_image.packed_file() ||
554
 
                                                  b_image.source() == BL::Image::source_GENERATED ||
555
 
                                                  b_image.source() == BL::Image::source_MOVIE;
556
 
 
557
 
                                if(is_builtin) {
558
 
                                        int scene_frame = b_scene.frame_current();
559
 
                                        int image_frame = image_user_frame_number(b_env_node.image_user(), scene_frame);
560
 
                                        env->filename = b_image.name() + "@" + string_printf("%d", image_frame);
561
 
                                        env->builtin_data = b_image.ptr.data;
562
 
                                }
563
 
                                else {
564
 
                                        env->filename = image_user_file_path(b_env_node.image_user(), b_image, b_scene.frame_current());
565
 
                                        env->animated = b_env_node.image_user().use_auto_refresh();
566
 
                                        env->builtin_data = NULL;
567
 
                                }
568
 
                        }
569
 
                        env->color_space = EnvironmentTextureNode::color_space_enum[(int)b_env_node.color_space()];
570
 
                        env->projection = EnvironmentTextureNode::projection_enum[(int)b_env_node.projection()];
571
 
                        get_tex_mapping(&env->tex_mapping, b_env_node.texture_mapping());
572
 
                        node = env;
573
 
                        break;
574
 
                }
575
 
                case BL::ShaderNode::type_TEX_GRADIENT: {
576
 
                        BL::ShaderNodeTexGradient b_gradient_node(b_node);
577
 
                        GradientTextureNode *gradient = new GradientTextureNode();
578
 
                        gradient->type = GradientTextureNode::type_enum[(int)b_gradient_node.gradient_type()];
579
 
                        get_tex_mapping(&gradient->tex_mapping, b_gradient_node.texture_mapping());
580
 
                        node = gradient;
581
 
                        break;
582
 
                }
583
 
                case BL::ShaderNode::type_TEX_VORONOI: {
584
 
                        BL::ShaderNodeTexVoronoi b_voronoi_node(b_node);
585
 
                        VoronoiTextureNode *voronoi = new VoronoiTextureNode();
586
 
                        voronoi->coloring = VoronoiTextureNode::coloring_enum[(int)b_voronoi_node.coloring()];
587
 
                        get_tex_mapping(&voronoi->tex_mapping, b_voronoi_node.texture_mapping());
588
 
                        node = voronoi;
589
 
                        break;
590
 
                }
591
 
                case BL::ShaderNode::type_TEX_MAGIC: {
592
 
                        BL::ShaderNodeTexMagic b_magic_node(b_node);
593
 
                        MagicTextureNode *magic = new MagicTextureNode();
594
 
                        magic->depth = b_magic_node.turbulence_depth();
595
 
                        get_tex_mapping(&magic->tex_mapping, b_magic_node.texture_mapping());
596
 
                        node = magic;
597
 
                        break;
598
 
                }
599
 
                case BL::ShaderNode::type_TEX_WAVE: {
600
 
                        BL::ShaderNodeTexWave b_wave_node(b_node);
601
 
                        WaveTextureNode *wave = new WaveTextureNode();
602
 
                        wave->type = WaveTextureNode::type_enum[(int)b_wave_node.wave_type()];
603
 
                        get_tex_mapping(&wave->tex_mapping, b_wave_node.texture_mapping());
604
 
                        node = wave;
605
 
                        break;
606
 
                }
607
 
                case BL::ShaderNode::type_TEX_CHECKER: {
608
 
                        BL::ShaderNodeTexChecker b_checker_node(b_node);
609
 
                        CheckerTextureNode *checker = new CheckerTextureNode();
610
 
                        get_tex_mapping(&checker->tex_mapping, b_checker_node.texture_mapping());
611
 
                        node = checker;
612
 
                        break;
613
 
                }
614
 
                case BL::ShaderNode::type_TEX_BRICK: {
615
 
                        BL::ShaderNodeTexBrick b_brick_node(b_node);
616
 
                        BrickTextureNode *brick = new BrickTextureNode();
617
 
                        brick->offset = b_brick_node.offset();
618
 
                        brick->offset_frequency = b_brick_node.offset_frequency();
619
 
                        brick->squash = b_brick_node.squash();
620
 
                        brick->squash_frequency = b_brick_node.squash_frequency();
621
 
                        get_tex_mapping(&brick->tex_mapping, b_brick_node.texture_mapping());
622
 
                        node = brick;
623
 
                        break;
624
 
                }
625
 
                case BL::ShaderNode::type_TEX_NOISE: {
626
 
                        BL::ShaderNodeTexNoise b_noise_node(b_node);
627
 
                        NoiseTextureNode *noise = new NoiseTextureNode();
628
 
                        get_tex_mapping(&noise->tex_mapping, b_noise_node.texture_mapping());
629
 
                        node = noise;
630
 
                        break;
631
 
                }
632
 
                case BL::ShaderNode::type_TEX_MUSGRAVE: {
633
 
                        BL::ShaderNodeTexMusgrave b_musgrave_node(b_node);
634
 
                        MusgraveTextureNode *musgrave = new MusgraveTextureNode();
635
 
                        musgrave->type = MusgraveTextureNode::type_enum[(int)b_musgrave_node.musgrave_type()];
636
 
                        get_tex_mapping(&musgrave->tex_mapping, b_musgrave_node.texture_mapping());
637
 
                        node = musgrave;
638
 
                        break;
639
 
                }
640
 
                case BL::ShaderNode::type_TEX_COORD: {
641
 
                        BL::ShaderNodeTexCoord b_tex_coord_node(b_node);
642
 
                        TextureCoordinateNode *tex_coord = new TextureCoordinateNode();
643
 
                        tex_coord->from_dupli = b_tex_coord_node.from_dupli();
644
 
                        node = tex_coord;
645
 
                        break;
646
 
                }
647
 
                case BL::ShaderNode::type_TEX_SKY: {
648
 
                        BL::ShaderNodeTexSky b_sky_node(b_node);
649
 
                        SkyTextureNode *sky = new SkyTextureNode();
650
 
                        sky->sun_direction = get_float3(b_sky_node.sun_direction());
651
 
                        sky->turbidity = b_sky_node.turbidity();
652
 
                        get_tex_mapping(&sky->tex_mapping, b_sky_node.texture_mapping());
653
 
                        node = sky;
654
 
                        break;
655
 
                }
656
 
                case BL::ShaderNode::type_NORMAL_MAP: {
657
 
                        BL::ShaderNodeNormalMap b_normal_map_node(b_node);
658
 
                        NormalMapNode *nmap = new NormalMapNode();
659
 
                        nmap->space = NormalMapNode::space_enum[(int)b_normal_map_node.space()];
660
 
                        nmap->attribute = b_normal_map_node.uv_map();
661
 
                        node = nmap;
662
 
                        break;
663
 
                }
664
 
                case BL::ShaderNode::type_TANGENT: {
665
 
                        BL::ShaderNodeTangent b_tangent_node(b_node);
666
 
                        TangentNode *tangent = new TangentNode();
667
 
                        tangent->direction_type = TangentNode::direction_type_enum[(int)b_tangent_node.direction_type()];
668
 
                        tangent->axis = TangentNode::axis_enum[(int)b_tangent_node.axis()];
669
 
                        tangent->attribute = b_tangent_node.uv_map();
670
 
                        node = tangent;
671
 
                        break;
672
 
                }
 
494
                                int scene_frame = b_scene.frame_current();
 
495
                                int image_frame = image_user_frame_number(b_image_node.image_user(), scene_frame);
 
496
                                image->filename = b_image.name() + "@" + string_printf("%d", image_frame);
 
497
                                image->builtin_data = b_image.ptr.data;
 
498
                        }
 
499
                        else {
 
500
                                image->filename = image_user_file_path(b_image_node.image_user(), b_image, b_scene.frame_current());
 
501
                                image->builtin_data = NULL;
 
502
                        }
 
503
 
 
504
                        image->animated = b_image_node.image_user().use_auto_refresh();
 
505
                }
 
506
                image->color_space = ImageTextureNode::color_space_enum[(int)b_image_node.color_space()];
 
507
                image->projection = ImageTextureNode::projection_enum[(int)b_image_node.projection()];
 
508
                image->projection_blend = b_image_node.projection_blend();
 
509
                get_tex_mapping(&image->tex_mapping, b_image_node.texture_mapping());
 
510
                node = image;
 
511
        }
 
512
        else if (b_node.is_a(&RNA_ShaderNodeTexEnvironment)) {
 
513
                BL::ShaderNodeTexEnvironment b_env_node(b_node);
 
514
                BL::Image b_image(b_env_node.image());
 
515
                EnvironmentTextureNode *env = new EnvironmentTextureNode();
 
516
                if(b_image) {
 
517
                        bool is_builtin = b_image.packed_file() ||
 
518
                                          b_image.source() == BL::Image::source_GENERATED ||
 
519
                                          b_image.source() == BL::Image::source_MOVIE;
 
520
 
 
521
                        if(is_builtin) {
 
522
                                int scene_frame = b_scene.frame_current();
 
523
                                int image_frame = image_user_frame_number(b_env_node.image_user(), scene_frame);
 
524
                                env->filename = b_image.name() + "@" + string_printf("%d", image_frame);
 
525
                                env->builtin_data = b_image.ptr.data;
 
526
                        }
 
527
                        else {
 
528
                                env->filename = image_user_file_path(b_env_node.image_user(), b_image, b_scene.frame_current());
 
529
                                env->animated = b_env_node.image_user().use_auto_refresh();
 
530
                                env->builtin_data = NULL;
 
531
                        }
 
532
                }
 
533
                env->color_space = EnvironmentTextureNode::color_space_enum[(int)b_env_node.color_space()];
 
534
                env->projection = EnvironmentTextureNode::projection_enum[(int)b_env_node.projection()];
 
535
                get_tex_mapping(&env->tex_mapping, b_env_node.texture_mapping());
 
536
                node = env;
 
537
        }
 
538
        else if (b_node.is_a(&RNA_ShaderNodeTexGradient)) {
 
539
                BL::ShaderNodeTexGradient b_gradient_node(b_node);
 
540
                GradientTextureNode *gradient = new GradientTextureNode();
 
541
                gradient->type = GradientTextureNode::type_enum[(int)b_gradient_node.gradient_type()];
 
542
                get_tex_mapping(&gradient->tex_mapping, b_gradient_node.texture_mapping());
 
543
                node = gradient;
 
544
        }
 
545
        else if (b_node.is_a(&RNA_ShaderNodeTexVoronoi)) {
 
546
                BL::ShaderNodeTexVoronoi b_voronoi_node(b_node);
 
547
                VoronoiTextureNode *voronoi = new VoronoiTextureNode();
 
548
                voronoi->coloring = VoronoiTextureNode::coloring_enum[(int)b_voronoi_node.coloring()];
 
549
                get_tex_mapping(&voronoi->tex_mapping, b_voronoi_node.texture_mapping());
 
550
                node = voronoi;
 
551
        }
 
552
        else if (b_node.is_a(&RNA_ShaderNodeTexMagic)) {
 
553
                BL::ShaderNodeTexMagic b_magic_node(b_node);
 
554
                MagicTextureNode *magic = new MagicTextureNode();
 
555
                magic->depth = b_magic_node.turbulence_depth();
 
556
                get_tex_mapping(&magic->tex_mapping, b_magic_node.texture_mapping());
 
557
                node = magic;
 
558
        }
 
559
        else if (b_node.is_a(&RNA_ShaderNodeTexWave)) {
 
560
                BL::ShaderNodeTexWave b_wave_node(b_node);
 
561
                WaveTextureNode *wave = new WaveTextureNode();
 
562
                wave->type = WaveTextureNode::type_enum[(int)b_wave_node.wave_type()];
 
563
                get_tex_mapping(&wave->tex_mapping, b_wave_node.texture_mapping());
 
564
                node = wave;
 
565
        }
 
566
        else if (b_node.is_a(&RNA_ShaderNodeTexChecker)) {
 
567
                BL::ShaderNodeTexChecker b_checker_node(b_node);
 
568
                CheckerTextureNode *checker = new CheckerTextureNode();
 
569
                get_tex_mapping(&checker->tex_mapping, b_checker_node.texture_mapping());
 
570
                node = checker;
 
571
        }
 
572
        else if (b_node.is_a(&RNA_ShaderNodeTexBrick)) {
 
573
                BL::ShaderNodeTexBrick b_brick_node(b_node);
 
574
                BrickTextureNode *brick = new BrickTextureNode();
 
575
                brick->offset = b_brick_node.offset();
 
576
                brick->offset_frequency = b_brick_node.offset_frequency();
 
577
                brick->squash = b_brick_node.squash();
 
578
                brick->squash_frequency = b_brick_node.squash_frequency();
 
579
                get_tex_mapping(&brick->tex_mapping, b_brick_node.texture_mapping());
 
580
                node = brick;
 
581
        }
 
582
        else if (b_node.is_a(&RNA_ShaderNodeTexNoise)) {
 
583
                BL::ShaderNodeTexNoise b_noise_node(b_node);
 
584
                NoiseTextureNode *noise = new NoiseTextureNode();
 
585
                get_tex_mapping(&noise->tex_mapping, b_noise_node.texture_mapping());
 
586
                node = noise;
 
587
        }
 
588
        else if (b_node.is_a(&RNA_ShaderNodeTexMusgrave)) {
 
589
                BL::ShaderNodeTexMusgrave b_musgrave_node(b_node);
 
590
                MusgraveTextureNode *musgrave = new MusgraveTextureNode();
 
591
                musgrave->type = MusgraveTextureNode::type_enum[(int)b_musgrave_node.musgrave_type()];
 
592
                get_tex_mapping(&musgrave->tex_mapping, b_musgrave_node.texture_mapping());
 
593
                node = musgrave;
 
594
        }
 
595
        else if (b_node.is_a(&RNA_ShaderNodeTexCoord)) {
 
596
                BL::ShaderNodeTexCoord b_tex_coord_node(b_node);
 
597
                TextureCoordinateNode *tex_coord = new TextureCoordinateNode();
 
598
                tex_coord->from_dupli = b_tex_coord_node.from_dupli();
 
599
                node = tex_coord;
 
600
        }
 
601
        else if (b_node.is_a(&RNA_ShaderNodeTexSky)) {
 
602
                BL::ShaderNodeTexSky b_sky_node(b_node);
 
603
                SkyTextureNode *sky = new SkyTextureNode();
 
604
                sky->sun_direction = get_float3(b_sky_node.sun_direction());
 
605
                sky->turbidity = b_sky_node.turbidity();
 
606
                get_tex_mapping(&sky->tex_mapping, b_sky_node.texture_mapping());
 
607
                node = sky;
 
608
        }
 
609
        else if (b_node.is_a(&RNA_ShaderNodeNormalMap)) {
 
610
                BL::ShaderNodeNormalMap b_normal_map_node(b_node);
 
611
                NormalMapNode *nmap = new NormalMapNode();
 
612
                nmap->space = NormalMapNode::space_enum[(int)b_normal_map_node.space()];
 
613
                nmap->attribute = b_normal_map_node.uv_map();
 
614
                node = nmap;
 
615
        }
 
616
        else if (b_node.is_a(&RNA_ShaderNodeTangent)) {
 
617
                BL::ShaderNodeTangent b_tangent_node(b_node);
 
618
                TangentNode *tangent = new TangentNode();
 
619
                tangent->direction_type = TangentNode::direction_type_enum[(int)b_tangent_node.direction_type()];
 
620
                tangent->axis = TangentNode::axis_enum[(int)b_tangent_node.axis()];
 
621
                tangent->attribute = b_tangent_node.uv_map();
 
622
                node = tangent;
673
623
        }
674
624
 
675
625
        if(node && node != graph->output())
678
628
        return node;
679
629
}
680
630
 
681
 
static SocketPair node_socket_map_pair(PtrNodeMap& node_map, BL::Node b_node, BL::NodeSocket b_socket)
 
631
static ShaderInput *node_find_input_by_name(ShaderNode *node, BL::Node b_node, BL::NodeSocket b_socket)
682
632
{
683
633
        BL::Node::inputs_iterator b_input;
684
 
        BL::Node::outputs_iterator b_output;
685
634
        string name = b_socket.name();
686
635
        bool found = false;
687
636
        int counter = 0, total = 0;
688
 
 
689
 
        /* find in inputs */
690
 
        for(b_node.inputs.begin(b_input); b_input != b_node.inputs.end(); ++b_input) {
691
 
                if(b_input->name() == name) {
692
 
                        if(!found)
 
637
        
 
638
        for (b_node.inputs.begin(b_input); b_input != b_node.inputs.end(); ++b_input) {
 
639
                if (b_input->name() == name) {
 
640
                        if (!found)
693
641
                                counter++;
694
642
                        total++;
695
643
                }
697
645
                if(b_input->ptr.data == b_socket.ptr.data)
698
646
                        found = true;
699
647
        }
700
 
 
701
 
        if(!found) {
702
 
                /* find in outputs */
703
 
                found = false;
704
 
                counter = 0;
705
 
                total = 0;
706
 
 
707
 
                for(b_node.outputs.begin(b_output); b_output != b_node.outputs.end(); ++b_output) {
708
 
                        if(b_output->name() == name) {
709
 
                                if(!found)
710
 
                                        counter++;
711
 
                                total++;
712
 
                        }
713
 
 
714
 
                        if(b_output->ptr.data == b_socket.ptr.data)
715
 
                                found = true;
 
648
        
 
649
        /* rename if needed */
 
650
        if (name == "Shader")
 
651
                name = "Closure";
 
652
        
 
653
        if (total > 1)
 
654
                name = string_printf("%s%d", name.c_str(), counter);
 
655
        
 
656
        return node->input(name.c_str());
 
657
}
 
658
 
 
659
static ShaderOutput *node_find_output_by_name(ShaderNode *node, BL::Node b_node, BL::NodeSocket b_socket)
 
660
{
 
661
        BL::Node::outputs_iterator b_output;
 
662
        string name = b_socket.name();
 
663
        bool found = false;
 
664
        int counter = 0, total = 0;
 
665
        
 
666
        for (b_node.outputs.begin(b_output); b_output != b_node.outputs.end(); ++b_output) {
 
667
                if (b_output->name() == name) {
 
668
                        if (!found)
 
669
                                counter++;
 
670
                        total++;
716
671
                }
 
672
 
 
673
                if(b_output->ptr.data == b_socket.ptr.data)
 
674
                        found = true;
717
675
        }
718
 
 
 
676
        
719
677
        /* rename if needed */
720
 
        if(name == "Shader")
 
678
        if (name == "Shader")
721
679
                name = "Closure";
722
 
 
723
 
        if(total > 1)
 
680
        
 
681
        if (total > 1)
724
682
                name = string_printf("%s%d", name.c_str(), counter);
725
 
 
726
 
        return SocketPair(node_map[b_node.ptr.data], name);
 
683
        
 
684
        return node->output(name.c_str());
727
685
}
728
686
 
729
 
static void add_nodes(Scene *scene, BL::BlendData b_data, BL::Scene b_scene, ShaderGraph *graph, BL::ShaderNodeTree b_ntree, PtrSockMap& sockets_map)
 
687
static void add_nodes(Scene *scene, BL::BlendData b_data, BL::Scene b_scene, ShaderGraph *graph, BL::ShaderNodeTree b_ntree,
 
688
                      const ProxyMap &proxy_input_map, const ProxyMap &proxy_output_map)
730
689
{
731
690
        /* add nodes */
732
691
        BL::ShaderNodeTree::nodes_iterator b_node;
733
 
        PtrNodeMap node_map;
734
 
        PtrSockMap proxy_map;
 
692
        PtrInputMap input_map;
 
693
        PtrOutputMap output_map;
 
694
        
 
695
        BL::Node::inputs_iterator b_input;
 
696
        BL::Node::outputs_iterator b_output;
735
697
 
736
698
        for(b_ntree.nodes.begin(b_node); b_node != b_ntree.nodes.end(); ++b_node) {
737
 
                if(b_node->mute()) {
738
 
                        BL::Node::inputs_iterator b_input;
739
 
                        BL::Node::outputs_iterator b_output;
740
 
                        bool found_match = false;
741
 
 
742
 
                        /* this is slightly different than blender logic, we just connect a
743
 
                         * single pair for of input/output, but works ok for the node we have */
 
699
                if (b_node->mute() || b_node->is_a(&RNA_NodeReroute)) {
 
700
                        /* replace muted node with internal links */
 
701
                        BL::Node::internal_links_iterator b_link;
 
702
                        for (b_node->internal_links.begin(b_link); b_link != b_node->internal_links.end(); ++b_link) {
 
703
                                ProxyNode *proxy = new ProxyNode(convert_socket_type(b_link->to_socket()));
 
704
                                
 
705
                                input_map[b_link->from_socket().ptr.data] = proxy->inputs[0];
 
706
                                output_map[b_link->to_socket().ptr.data] = proxy->outputs[0];
 
707
                                
 
708
                                graph->add(proxy);
 
709
                        }
 
710
                }
 
711
                else if (b_node->is_a(&RNA_ShaderNodeGroup) || b_node->is_a(&RNA_NodeCustomGroup)) {
 
712
                        
 
713
                        BL::ShaderNodeTree b_group_ntree(PointerRNA_NULL);
 
714
                        if (b_node->is_a(&RNA_ShaderNodeGroup))
 
715
                                b_group_ntree = BL::ShaderNodeTree(((BL::NodeGroup)(*b_node)).node_tree());
 
716
                        else
 
717
                                b_group_ntree = BL::ShaderNodeTree(((BL::NodeCustomGroup)(*b_node)).node_tree());
 
718
                        ProxyMap group_proxy_input_map, group_proxy_output_map;
 
719
                        
 
720
                        /* Add a proxy node for each socket
 
721
                         * Do this even if the node group has no internal tree,
 
722
                         * so that links have something to connect to and assert won't fail.
 
723
                         */
744
724
                        for(b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) {
745
 
                                if(b_input->is_linked()) {
746
 
                                        for(b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) {
747
 
                                                if(b_output->is_linked() && b_input->type() == b_output->type()) {
748
 
                                                        ProxyNode *proxy = new ProxyNode(convert_socket_type(b_input->type()), convert_socket_type(b_output->type()));
749
 
                                                        graph->add(proxy);
750
 
 
751
 
                                                        proxy_map[b_input->ptr.data] = SocketPair(proxy, proxy->inputs[0]->name);
752
 
                                                        proxy_map[b_output->ptr.data] = SocketPair(proxy, proxy->outputs[0]->name);
753
 
                                                        found_match = true;
754
 
 
755
 
                                                        break;
756
 
                                                }
 
725
                                ProxyNode *proxy = new ProxyNode(convert_socket_type(*b_input));
 
726
                                graph->add(proxy);
 
727
                                
 
728
                                /* register the proxy node for internal binding */
 
729
                                group_proxy_input_map[b_input->identifier()] = proxy;
 
730
                                
 
731
                                input_map[b_input->ptr.data] = proxy->inputs[0];
 
732
                                
 
733
                                set_default_value(proxy->inputs[0], *b_node, *b_input, b_data, b_ntree);
 
734
                        }
 
735
                        for(b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) {
 
736
                                ProxyNode *proxy = new ProxyNode(convert_socket_type(*b_output));
 
737
                                graph->add(proxy);
 
738
                                
 
739
                                /* register the proxy node for internal binding */
 
740
                                group_proxy_output_map[b_output->identifier()] = proxy;
 
741
                                
 
742
                                output_map[b_output->ptr.data] = proxy->outputs[0];
 
743
                        }
 
744
                        
 
745
                        if (b_group_ntree)
 
746
                                add_nodes(scene, b_data, b_scene, graph, b_group_ntree, group_proxy_input_map, group_proxy_output_map);
 
747
                }
 
748
                else if (b_node->is_a(&RNA_NodeGroupInput)) {
 
749
                        /* map each socket to a proxy node */
 
750
                        for(b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) {
 
751
                                ProxyMap::const_iterator proxy_it = proxy_input_map.find(b_output->identifier());
 
752
                                if (proxy_it != proxy_input_map.end()) {
 
753
                                        ProxyNode *proxy = proxy_it->second;
 
754
                                        
 
755
                                        output_map[b_output->ptr.data] = proxy->outputs[0];
 
756
                                }
 
757
                        }
 
758
                }
 
759
                else if (b_node->is_a(&RNA_NodeGroupOutput)) {
 
760
                        BL::NodeGroupOutput b_output_node(*b_node);
 
761
                        /* only the active group output is used */
 
762
                        if (b_output_node.is_active_output()) {
 
763
                                /* map each socket to a proxy node */
 
764
                                for(b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) {
 
765
                                        ProxyMap::const_iterator proxy_it = proxy_output_map.find(b_input->identifier());
 
766
                                        if (proxy_it != proxy_output_map.end()) {
 
767
                                                ProxyNode *proxy = proxy_it->second;
 
768
                                                
 
769
                                                input_map[b_input->ptr.data] = proxy->inputs[0];
 
770
                                                
 
771
                                                set_default_value(proxy->inputs[0], *b_node, *b_input, b_data, b_ntree);
757
772
                                        }
758
773
                                }
759
 
 
760
 
                                if(found_match)
761
 
                                        break;
762
 
                        }
763
 
                }
764
 
                else if(b_node->is_a(&RNA_NodeGroup)) {
765
 
                        /* add proxy converter nodes for inputs and outputs */
766
 
                        BL::NodeGroup b_gnode(*b_node);
767
 
                        BL::ShaderNodeTree b_group_ntree(b_gnode.node_tree());
768
 
                        if (!b_group_ntree)
769
 
                                continue;
770
 
 
771
 
                        BL::Node::inputs_iterator b_input;
772
 
                        BL::Node::outputs_iterator b_output;
773
 
                        
774
 
                        PtrSockMap group_sockmap;
775
 
                        
776
 
                        for(b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) {
777
 
                                ShaderSocketType extern_type = convert_socket_type(b_input->type());
778
 
                                ShaderSocketType intern_type = convert_socket_type(b_input->group_socket().type());
779
 
                                ShaderNode *proxy = graph->add(new ProxyNode(extern_type, intern_type));
780
 
                                
781
 
                                /* map the external node socket to the proxy node socket */
782
 
                                proxy_map[b_input->ptr.data] = SocketPair(proxy, proxy->inputs[0]->name);
783
 
                                /* map the internal group socket to the proxy node socket */
784
 
                                group_sockmap[b_input->group_socket().ptr.data] = SocketPair(proxy, proxy->outputs[0]->name);
785
 
                                
786
 
                                /* default input values of the group node */
787
 
                                set_default_value(proxy->inputs[0], *b_input, b_data, b_group_ntree);
788
 
                        }
789
 
                        
790
 
                        for(b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) {
791
 
                                ShaderSocketType extern_type = convert_socket_type(b_output->type());
792
 
                                ShaderSocketType intern_type = convert_socket_type(b_output->group_socket().type());
793
 
                                ShaderNode *proxy = graph->add(new ProxyNode(intern_type, extern_type));
794
 
                                
795
 
                                /* map the external node socket to the proxy node socket */
796
 
                                proxy_map[b_output->ptr.data] = SocketPair(proxy, proxy->outputs[0]->name);
797
 
                                /* map the internal group socket to the proxy node socket */
798
 
                                group_sockmap[b_output->group_socket().ptr.data] = SocketPair(proxy, proxy->inputs[0]->name);
799
 
                                
800
 
                                /* default input values of internal, unlinked group outputs */
801
 
                                set_default_value(proxy->inputs[0], b_output->group_socket(), b_data, b_group_ntree);
802
 
                        }
803
 
                        
804
 
                        add_nodes(scene, b_data, b_scene, graph, b_group_ntree, group_sockmap);
 
774
                        }
805
775
                }
806
776
                else {
807
777
                        ShaderNode *node = add_node(scene, b_data, b_scene, graph, b_ntree, BL::ShaderNode(*b_node));
808
778
                        
809
779
                        if(node) {
810
 
                                BL::Node::inputs_iterator b_input;
811
 
                                
812
 
                                node_map[b_node->ptr.data] = node;
813
 
                                
 
780
                                /* map node sockets for linking */
814
781
                                for(b_node->inputs.begin(b_input); b_input != b_node->inputs.end(); ++b_input) {
815
 
                                        SocketPair pair = node_socket_map_pair(node_map, *b_node, *b_input);
816
 
                                        ShaderInput *input = pair.first->input(pair.second.c_str());
817
 
                                        
818
 
                                        assert(input);
819
 
                                        
820
 
                                        /* copy values for non linked inputs */
821
 
                                        set_default_value(input, *b_input, b_data, b_ntree);
 
782
                                        ShaderInput *input = node_find_input_by_name(node, *b_node, *b_input);
 
783
                                        input_map[b_input->ptr.data] = input;
 
784
                                        
 
785
                                        set_default_value(input, *b_node, *b_input, b_data, b_ntree);
 
786
                                }
 
787
                                for(b_node->outputs.begin(b_output); b_output != b_node->outputs.end(); ++b_output) {
 
788
                                        ShaderOutput *output = node_find_output_by_name(node, *b_node, *b_output);
 
789
                                        output_map[b_output->ptr.data] = output;
822
790
                                }
823
791
                        }
824
792
                }
829
797
 
830
798
        for(b_ntree.links.begin(b_link); b_link != b_ntree.links.end(); ++b_link) {
831
799
                /* get blender link data */
832
 
                BL::Node b_from_node = b_link->from_node();
833
 
                BL::Node b_to_node = b_link->to_node();
834
 
 
835
800
                BL::NodeSocket b_from_sock = b_link->from_socket();
836
801
                BL::NodeSocket b_to_sock = b_link->to_socket();
837
802
 
838
 
                SocketPair from_pair, to_pair;
839
 
 
840
 
                /* links without a node pointer are connections to group inputs/outputs */
841
 
 
842
 
                /* from sock */
843
 
                if(b_from_node) {
844
 
                        if (b_from_node.mute() || b_from_node.is_a(&RNA_NodeGroup))
845
 
                                from_pair = proxy_map[b_from_sock.ptr.data];
846
 
                        else
847
 
                                from_pair = node_socket_map_pair(node_map, b_from_node, b_from_sock);
848
 
                }
849
 
                else
850
 
                        from_pair = sockets_map[b_from_sock.ptr.data];
851
 
 
852
 
                /* to sock */
853
 
                if(b_to_node) {
854
 
                        if (b_to_node.mute() || b_to_node.is_a(&RNA_NodeGroup))
855
 
                                to_pair = proxy_map[b_to_sock.ptr.data];
856
 
                        else
857
 
                                to_pair = node_socket_map_pair(node_map, b_to_node, b_to_sock);
858
 
                }
859
 
                else
860
 
                        to_pair = sockets_map[b_to_sock.ptr.data];
 
803
                ShaderOutput *output = 0;
 
804
                ShaderInput *input = 0;
 
805
                
 
806
                PtrOutputMap::iterator output_it = output_map.find(b_from_sock.ptr.data);
 
807
                if (output_it != output_map.end())
 
808
                        output = output_it->second;
 
809
                PtrInputMap::iterator input_it = input_map.find(b_to_sock.ptr.data);
 
810
                if (input_it != input_map.end())
 
811
                        input = input_it->second;
861
812
 
862
813
                /* either node may be NULL when the node was not exported, typically
863
814
                 * because the node type is not supported */
864
 
                if(from_pair.first && to_pair.first) {
865
 
                        ShaderOutput *output = from_pair.first->output(from_pair.second.c_str());
866
 
                        ShaderInput *input = to_pair.first->input(to_pair.second.c_str());
867
 
 
 
815
                if(output && input)
868
816
                        graph->connect(output, input);
869
 
                }
870
817
        }
871
818
}
872
819
 
 
820
static void add_nodes(Scene *scene, BL::BlendData b_data, BL::Scene b_scene, ShaderGraph *graph, BL::ShaderNodeTree b_ntree)
 
821
{
 
822
        static const ProxyMap empty_proxy_map;
 
823
        add_nodes(scene, b_data, b_scene, graph, b_ntree, empty_proxy_map, empty_proxy_map);
 
824
}
 
825
 
873
826
/* Sync Materials */
874
827
 
875
828
void BlenderSync::sync_materials(bool update_all)
891
844
 
892
845
                        /* create nodes */
893
846
                        if(b_mat->use_nodes() && b_mat->node_tree()) {
894
 
                                PtrSockMap sock_to_node;
895
847
                                BL::ShaderNodeTree b_ntree(b_mat->node_tree());
896
848
 
897
 
                                add_nodes(scene, b_data, b_scene, graph, b_ntree, sock_to_node);
 
849
                                add_nodes(scene, b_data, b_scene, graph, b_ntree);
898
850
                        }
899
851
                        else {
900
852
                                ShaderNode *closure, *out;
908
860
 
909
861
                        /* settings */
910
862
                        PointerRNA cmat = RNA_pointer_get(&b_mat->ptr, "cycles");
911
 
                        shader->sample_as_light = get_boolean(cmat, "sample_as_light");
 
863
                        shader->use_mis = get_boolean(cmat, "sample_as_light");
 
864
                        shader->use_transparent_shadow = get_boolean(cmat, "use_transparent_shadow");
912
865
                        shader->homogeneous_volume = get_boolean(cmat, "homogeneous_volume");
913
866
 
914
867
                        shader->set_graph(graph);
932
885
 
933
886
                /* create nodes */
934
887
                if(b_world && b_world.use_nodes() && b_world.node_tree()) {
935
 
                        PtrSockMap sock_to_node;
936
888
                        BL::ShaderNodeTree b_ntree(b_world.node_tree());
937
889
 
938
 
                        add_nodes(scene, b_data, b_scene, graph, b_ntree, sock_to_node);
 
890
                        add_nodes(scene, b_data, b_scene, graph, b_ntree);
939
891
                }
940
892
                else if(b_world) {
941
893
                        ShaderNode *closure, *out;
947
899
                        graph->connect(closure->output("Background"), out->input("Surface"));
948
900
                }
949
901
 
950
 
                /* AO */
951
902
                if(b_world) {
 
903
                        /* AO */
952
904
                        BL::WorldLighting b_light = b_world.light_settings();
953
905
 
954
906
                        if(b_light.use_ambient_occlusion())
957
909
                                background->ao_factor = 0.0f;
958
910
 
959
911
                        background->ao_distance = b_light.distance();
 
912
 
 
913
                        /* visibility */
 
914
                        PointerRNA cvisibility = RNA_pointer_get(&b_world.ptr, "cycles_visibility");
 
915
                        uint visibility = 0;
 
916
 
 
917
                        visibility |= get_boolean(cvisibility, "camera")? PATH_RAY_CAMERA: 0;
 
918
                        visibility |= get_boolean(cvisibility, "diffuse")? PATH_RAY_DIFFUSE: 0;
 
919
                        visibility |= get_boolean(cvisibility, "glossy")? PATH_RAY_GLOSSY: 0;
 
920
                        visibility |= get_boolean(cvisibility, "transmission")? PATH_RAY_TRANSMIT: 0;
 
921
 
 
922
                        background->visibility = visibility;
960
923
                }
961
924
 
962
925
                shader->set_graph(graph);
964
927
        }
965
928
 
966
929
        PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
967
 
        background->transparent = get_boolean(cscene, "film_transparent");
 
930
 
 
931
        /* when doing preview render check for BI's transparency settings,
 
932
         * this is so because bledner's preview render routines are not able
 
933
         * to tweak all cycles's settings depending on different circumstances
 
934
         */
 
935
        if(b_engine.is_preview() == false)
 
936
                background->transparent = get_boolean(cscene, "film_transparent");
 
937
        else
 
938
                background->transparent = b_scene.render().alpha_mode() == BL::RenderSettings::alpha_mode_TRANSPARENT;
 
939
 
968
940
        background->use = render_layer.use_background;
969
941
 
970
942
        if(background->modified(prevbackground))
991
963
                        if(b_lamp->use_nodes() && b_lamp->node_tree()) {
992
964
                                shader->name = b_lamp->name().c_str();
993
965
 
994
 
                                PtrSockMap sock_to_node;
995
966
                                BL::ShaderNodeTree b_ntree(b_lamp->node_tree());
996
967
 
997
 
                                add_nodes(scene, b_data, b_scene, graph, b_ntree, sock_to_node);
 
968
                                add_nodes(scene, b_data, b_scene, graph, b_ntree);
998
969
                        }
999
970
                        else {
1000
971
                                ShaderNode *closure, *out;