← Back to branch summary

~siretart/ubuntu/utopic/blender/libav10

« back to all changes in this revision

Viewing changes to source/blender/nodes/intern/node_socket.c

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2014-02-19 11:24:23 UTC
  • mfrom: (14.2.23 sid)
  • Revision ID: package-import@ubuntu.com-20140219112423-rkmaz2m7ha06d4tk
Tags: 2.69-3ubuntu1
* Merge with Debian; remaining changes:
  - Configure without OpenImageIO on armhf, as it is not available on
    Ubuntu.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/nodes/intern/node_socket.c
60
60
        
61
61
        /* initialize default_value */
62
62
        switch (stemp->type) {
63
 
                case SOCK_FLOAT: {
 
63
                case SOCK_FLOAT:
 
64
                {
64
65
                        bNodeSocketValueFloat *dval = sock->default_value;
65
66
                        dval->value = stemp->val1;
66
67
                        dval->min = stemp->min;
67
68
                        dval->max = stemp->max;
68
69
                        break;
69
70
                }
70
 
                case SOCK_INT: {
 
71
                case SOCK_INT:
 
72
                {
71
73
                        bNodeSocketValueInt *dval = sock->default_value;
72
74
                        dval->value = (int)stemp->val1;
73
75
                        dval->min = (int)stemp->min;
74
76
                        dval->max = (int)stemp->max;
75
77
                        break;
76
78
                }
77
 
                case SOCK_BOOLEAN: {
 
79
                case SOCK_BOOLEAN:
 
80
                {
78
81
                        bNodeSocketValueBoolean *dval = sock->default_value;
79
82
                        dval->value = (int)stemp->val1;
80
83
                        break;
81
84
                }
82
 
                case SOCK_VECTOR: {
 
85
                case SOCK_VECTOR:
 
86
                {
83
87
                        bNodeSocketValueVector *dval = sock->default_value;
84
88
                        dval->value[0] = stemp->val1;
85
89
                        dval->value[1] = stemp->val2;
88
92
                        dval->max = stemp->max;
89
93
                        break;
90
94
                }
91
 
                case SOCK_RGBA: {
 
95
                case SOCK_RGBA:
 
96
                {
92
97
                        bNodeSocketValueRGBA *dval = sock->default_value;
93
98
                        dval->value[0] = stemp->val1;
94
99
                        dval->value[1] = stemp->val2;
202
207
                return; /* already initialized */
203
208
        
204
209
        switch (type) {
205
 
                case SOCK_FLOAT: {
 
210
                case SOCK_FLOAT:
 
211
                {
206
212
                        bNodeSocketValueFloat *dval = MEM_callocN(sizeof(bNodeSocketValueFloat), "node socket value float");
207
213
                        dval->subtype = subtype;
208
214
                        dval->value = 0.0f;
212
218
                        sock->default_value = dval;
213
219
                        break;
214
220
                }
215
 
                case SOCK_INT: {
 
221
                case SOCK_INT:
 
222
                {
216
223
                        bNodeSocketValueInt *dval = MEM_callocN(sizeof(bNodeSocketValueInt), "node socket value int");
217
224
                        dval->subtype = subtype;
218
225
                        dval->value = 0;
222
229
                        sock->default_value = dval;
223
230
                        break;
224
231
                }
225
 
                case SOCK_BOOLEAN: {
 
232
                case SOCK_BOOLEAN:
 
233
                {
226
234
                        bNodeSocketValueBoolean *dval = MEM_callocN(sizeof(bNodeSocketValueBoolean), "node socket value bool");
227
235
                        dval->value = false;
228
236
                
229
237
                        sock->default_value = dval;
230
238
                        break;
231
239
                }
232
 
                case SOCK_VECTOR: {
 
240
                case SOCK_VECTOR:
 
241
                {
233
242
                        static float default_value[] = { 0.0f, 0.0f, 0.0f };
234
243
                        bNodeSocketValueVector *dval = MEM_callocN(sizeof(bNodeSocketValueVector), "node socket value vector");
235
244
                        dval->subtype = subtype;
240
249
                        sock->default_value = dval;
241
250
                        break;
242
251
                }
243
 
                case SOCK_RGBA: {
 
252
                case SOCK_RGBA:
 
253
                {
244
254
                        static float default_value[] = { 0.0f, 0.0f, 0.0f, 1.0f };
245
255
                        bNodeSocketValueRGBA *dval = MEM_callocN(sizeof(bNodeSocketValueRGBA), "node socket value color");
246
256
                        copy_v4_v4(dval->value, default_value);
248
258
                        sock->default_value = dval;
249
259
                        break;
250
260
                }
251
 
                case SOCK_STRING: {
 
261
                case SOCK_STRING:
 
262
                {
252
263
                        bNodeSocketValueString *dval = MEM_callocN(sizeof(bNodeSocketValueString), "node socket value string");
253
264
                        dval->subtype = subtype;
254
265
                        dval->value[0] = '\0';
271
282
        node_socket_init_default_value(to);
272
283
        
273
284
        switch (from->typeinfo->type) {
274
 
                case SOCK_FLOAT: {
 
285
                case SOCK_FLOAT:
 
286
                {
275
287
                        bNodeSocketValueFloat *toval = to->default_value;
276
288
                        bNodeSocketValueFloat *fromval = from->default_value;
277
289
                        *toval = *fromval;
278
290
                        break;
279
291
                }
280
 
                case SOCK_INT: {
 
292
                case SOCK_INT:
 
293
                {
281
294
                        bNodeSocketValueInt *toval = to->default_value;
282
295
                        bNodeSocketValueInt *fromval = from->default_value;
283
296
                        *toval = *fromval;
284
297
                        break;
285
298
                }
286
 
                case SOCK_BOOLEAN: {
 
299
                case SOCK_BOOLEAN:
 
300
                {
287
301
                        bNodeSocketValueBoolean *toval = to->default_value;
288
302
                        bNodeSocketValueBoolean *fromval = from->default_value;
289
303
                        *toval = *fromval;
290
304
                        break;
291
305
                }
292
 
                case SOCK_VECTOR: {
 
306
                case SOCK_VECTOR:
 
307
                {
293
308
                        bNodeSocketValueVector *toval = to->default_value;
294
309
                        bNodeSocketValueVector *fromval = from->default_value;
295
310
                        *toval = *fromval;
296
311
                        break;
297
312
                }
298
 
                case SOCK_RGBA: {
 
313
                case SOCK_RGBA:
 
314
                {
299
315
                        bNodeSocketValueRGBA *toval = to->default_value;
300
316
                        bNodeSocketValueRGBA *fromval = from->default_value;
301
317
                        *toval = *fromval;
302
318
                        break;
303
319
                }
304
 
                case SOCK_STRING: {
 
320
                case SOCK_STRING:
 
321
                {
305
322
                        bNodeSocketValueString *toval = to->default_value;
306
323
                        bNodeSocketValueString *fromval = from->default_value;
307
324
                        *toval = *fromval;
334
351
        node_socket_init_default_value(sock);
335
352
        
336
353
        switch (stemp->typeinfo->type) {
337
 
                case SOCK_FLOAT: {
 
354
                case SOCK_FLOAT:
 
355
                {
338
356
                        bNodeSocketValueFloat *toval = sock->default_value;
339
357
                        bNodeSocketValueFloat *fromval = stemp->default_value;
340
358
                        toval->min = fromval->min;
341
359
                        toval->max = fromval->max;
342
360
                        break;
343
361
                }
344
 
                case SOCK_INT: {
 
362
                case SOCK_INT:
 
363
                {
345
364
                        bNodeSocketValueInt *toval = sock->default_value;
346
365
                        bNodeSocketValueInt *fromval = stemp->default_value;
347
366
                        toval->min = fromval->min;
348
367
                        toval->max = fromval->max;
349
368
                        break;
350
369
                }
351
 
                case SOCK_VECTOR: {
 
370
                case SOCK_VECTOR:
 
371
                {
352
372
                        bNodeSocketValueVector *toval = sock->default_value;
353
373
                        bNodeSocketValueVector *fromval = stemp->default_value;
354
374
                        toval->min = fromval->min;