← Back to branch summary

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

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/nodes/intern/node_socket.c
41
41
#include "BLI_listbase.h"
42
42
#include "BLI_math.h"
43
43
#include "BLI_utildefines.h"
 
44
#include "BLI_string.h"
44
45
 
45
46
#include "BKE_DerivedMesh.h"
46
47
#include "BKE_node.h"
59
60
        /* ui_name */                   "Float",
60
61
        /* ui_description */    "Floating Point",
61
62
        /* ui_icon */                   0,
62
 
        /* ui_color */                  {160,160,160,255},
 
63
        /* ui_color */                  {160, 160, 160, 255},
63
64
 
64
65
        /* value_structname */  "bNodeSocketValueFloat",
65
66
        /* value_structsize */  sizeof(bNodeSocketValueFloat),
74
75
        /* ui_name */                   "Vector",
75
76
        /* ui_description */    "3-dimensional floating point vector",
76
77
        /* ui_icon */                   0,
77
 
        /* ui_color */                  {100,100,200,255},
 
78
        /* ui_color */                  {100, 100, 200, 255},
78
79
 
79
80
        /* value_structname */  "bNodeSocketValueVector",
80
81
        /* value_structsize */  sizeof(bNodeSocketValueVector),
89
90
        /* ui_name */                   "RGBA",
90
91
        /* ui_description */    "RGBA color",
91
92
        /* ui_icon */                   0,
92
 
        /* ui_color */                  {200,200,40,255},
 
93
        /* ui_color */                  {200, 200, 40, 255},
93
94
 
94
95
        /* value_structname */  "bNodeSocketValueRGBA",
95
96
        /* value_structsize */  sizeof(bNodeSocketValueRGBA),
104
105
        /* ui_name */                   "Int",
105
106
        /* ui_description */    "Integer",
106
107
        /* ui_icon */                   0,
107
 
        /* ui_color */                  {17,133,37,255},
 
108
        /* ui_color */                  {17, 133, 37, 255},
108
109
 
109
110
        /* value_structname */  "bNodeSocketValueInt",
110
111
        /* value_structsize */  sizeof(bNodeSocketValueInt),
119
120
        /* ui_name */                   "Boolean",
120
121
        /* ui_description */    "Boolean",
121
122
        /* ui_icon */                   0,
122
 
        /* ui_color */                  {158,139,63,255},
 
123
        /* ui_color */                  {158, 139, 63, 255},
123
124
 
124
125
        /* value_structname */  "bNodeSocketValueBoolean",
125
126
        /* value_structsize */  sizeof(bNodeSocketValueBoolean),
134
135
        /* ui_name */                   "Shader",
135
136
        /* ui_description */    "Shader",
136
137
        /* ui_icon */                   0,
137
 
        /* ui_color */                  {100,200,100,255},
 
138
        /* ui_color */                  {100, 200, 100, 255},
138
139
 
139
140
        /* value_structname */  NULL,
140
141
        /* value_structsize */  0,
149
150
        /* ui_name */                   "Mesh",
150
151
        /* ui_description */    "Mesh geometry data",
151
152
        /* ui_icon */                   0,
152
 
        /* ui_color */                  {255,133,7,255},
 
153
        /* ui_color */                  {255, 133, 7, 255},
153
154
 
154
155
        /* value_structname */  NULL,
155
156
        /* value_structsize */  0,
157
158
        /* buttonfunc */                NULL,
158
159
};
159
160
 
 
161
/****************** STRING ******************/
 
162
 
 
163
static bNodeSocketType node_socket_type_string = {
 
164
        /* type */                              SOCK_STRING,
 
165
        /* ui_name */                   "String",
 
166
        /* ui_description */    "String",
 
167
        /* ui_icon */                   0,
 
168
        /* ui_color */                  {255, 255, 255, 255},
 
169
        
 
170
        /* value_structname */  "bNodeSocketValueString",
 
171
        /* value_structsize */  sizeof(bNodeSocketValueString),
 
172
        
 
173
        /* buttonfunc */                NULL,
 
174
};
160
175
 
161
176
void node_socket_type_init(bNodeSocketType *types[])
162
177
{
169
184
        INIT_TYPE(boolean);
170
185
        INIT_TYPE(shader);
171
186
        INIT_TYPE(mesh);
 
187
        INIT_TYPE(string);
172
188
        
173
189
        #undef INIT_TYPE
174
190
}
218
234
        case SOCK_MESH:
219
235
                node_socket_set_default_value_mesh(default_value);
220
236
                break;
 
237
        case SOCK_STRING:
 
238
                node_socket_set_default_value_string(default_value, PROP_NONE, (char *)"");
 
239
                break;
221
240
        }
222
241
}
223
242
 
265
284
        val->value[3] = a;
266
285
}
267
286
 
 
287
void node_socket_set_default_value_string(void *default_value, PropertySubType subtype, const char *value)
 
288
{
 
289
        bNodeSocketValueString *val = default_value;
 
290
        val->subtype = subtype;
 
291
        BLI_strncpy(val->value, value, 1024);//FILE_MAX
 
292
}
 
293
 
268
294
void node_socket_set_default_value_shader(void *UNUSED(default_value))
269
295
{
270
296
}
282
308
        bNodeSocketValueBoolean *frombool= (bNodeSocketValueBoolean*)from_default_value;
283
309
        bNodeSocketValueVector *fromvector= (bNodeSocketValueVector*)from_default_value;
284
310
        bNodeSocketValueRGBA *fromrgba= (bNodeSocketValueRGBA*)from_default_value;
 
311
        bNodeSocketValueString *fromstring= (bNodeSocketValueString*)from_default_value;
285
312
 
286
313
        bNodeSocketValueFloat *tofloat= (bNodeSocketValueFloat*)to_default_value;
287
314
        bNodeSocketValueInt *toint= (bNodeSocketValueInt*)to_default_value;
288
315
        bNodeSocketValueBoolean *tobool= (bNodeSocketValueBoolean*)to_default_value;
289
316
        bNodeSocketValueVector *tovector= (bNodeSocketValueVector*)to_default_value;
290
317
        bNodeSocketValueRGBA *torgba= (bNodeSocketValueRGBA*)to_default_value;
 
318
        bNodeSocketValueString *tostring= (bNodeSocketValueString*)to_default_value;
291
319
 
292
320
        switch (type) {
293
321
        case SOCK_FLOAT:
305
333
        case SOCK_RGBA:
306
334
                *torgba = *fromrgba;
307
335
                break;
 
336
        case SOCK_STRING:
 
337
                *tostring = *fromstring;
 
338
                break;
308
339
        }
309
340
}
310
341
 
319
350
 * In the interface this could be implemented by a pseudo-script textbox on linked inputs,
320
351
 * with quick selection from a predefined list of conversion options. Some Examples:
321
352
 * - vector component 'z' (vector->float):                                              "z"
322
 
 * - greyscale color (float->color):                                                    "grey"
 
353
 * - grayscale color (float->color):                                                    "gray"
323
354
 * - color luminance (color->float):                                                    "lum"
324
355
 * - matrix column 2 length (matrix->vector->float):                    "col[1].len"
325
356
 * - mesh vertex coordinate 'y' (mesh->vertex->vector->float):  "vertex.co.y"
442
473
        }
443
474
}
444
475
 
 
476
static void node_socket_set_minmax_subtype(bNodeSocket *sock, struct bNodeSocketTemplate *stemp)
 
477
{
 
478
        switch (sock->type) {
 
479
                case SOCK_FLOAT:
 
480
                {
 
481
                        bNodeSocketValueFloat *dval= sock->default_value;
 
482
                        dval->min = stemp->min;
 
483
                        dval->max = stemp->max;
 
484
                        dval->subtype = stemp->subtype;
 
485
                        break;
 
486
                }
 
487
                case SOCK_INT:
 
488
                {
 
489
                        bNodeSocketValueInt *dval= sock->default_value;
 
490
                        dval->min = stemp->min;
 
491
                        dval->max = stemp->max;
 
492
                        dval->subtype = stemp->subtype;
 
493
                        break;
 
494
                }
 
495
                case SOCK_VECTOR:
 
496
                {
 
497
                        bNodeSocketValueVector *dval= sock->default_value;
 
498
                        dval->min = stemp->min;
 
499
                        dval->max = stemp->max;
 
500
                        dval->subtype = stemp->subtype;
 
501
                        break;
 
502
                }
 
503
        }
 
504
}
445
505
 
446
506
struct bNodeSocket *node_add_input_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp)
447
507
{
470
530
        case SOCK_MESH:
471
531
                node_socket_set_default_value_mesh(sock->default_value);
472
532
                break;
 
533
        case SOCK_STRING:
 
534
                node_socket_set_default_value_string(sock->default_value, stemp->subtype, (char *)"");
 
535
                break;
473
536
        }
474
537
        
475
538
        return sock;
478
541
struct bNodeSocket *node_add_output_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp)
479
542
{
480
543
        bNodeSocket *sock = nodeAddSocket(ntree, node, SOCK_OUT, stemp->name, stemp->type);
 
544
        node_socket_set_minmax_subtype(sock, stemp);
481
545
        return sock;
482
546
}
483
547
 
490
554
                        break;
491
555
        }
492
556
        if (sock) {
493
 
                sock->type= stemp->type;                /* in future, read this from tydefs! */
494
 
                if (stemp->limit==0) sock->limit= 0xFFF;
495
 
                else sock->limit= stemp->limit;
 
557
                sock->type = stemp->type;  /* in future, read this from tydefs! */
 
558
                if (stemp->limit == 0) sock->limit= 0xFFF;
 
559
                else sock->limit = stemp->limit;
496
560
                sock->flag |= stemp->flag;
497
561
                
498
562
                /* Copy the property range and subtype parameters in case the template changed.
499
563
                 * NOT copying the actual value here, only button behavior changes!
500
564
                 */
501
 
                switch (sock->type) {
502
 
                case SOCK_FLOAT:
503
 
                        {
504
 
                                bNodeSocketValueFloat *dval= sock->default_value;
505
 
                                dval->min = stemp->min;
506
 
                                dval->max = stemp->max;
507
 
                                dval->subtype = stemp->subtype;
508
 
                        }
509
 
                        break;
510
 
                case SOCK_INT:
511
 
                        {
512
 
                                bNodeSocketValueInt *dval= sock->default_value;
513
 
                                dval->min = stemp->min;
514
 
                                dval->max = stemp->max;
515
 
                                dval->subtype = stemp->subtype;
516
 
                        }
517
 
                        break;
518
 
                case SOCK_VECTOR:
519
 
                        {
520
 
                                bNodeSocketValueVector *dval= sock->default_value;
521
 
                                dval->min = stemp->min;
522
 
                                dval->max = stemp->max;
523
 
                                dval->subtype = stemp->subtype;
524
 
                        }
525
 
                        break;
526
 
                }
 
565
                node_socket_set_minmax_subtype(sock, stemp);
527
566
                
528
567
                BLI_remlink(socklist, sock);
529
568
                
600
639
         * This also prevents group node sockets from being removed, without the need to explicitly
601
640
         * check the node type here.
602
641
         */
603
 
        if (ntype && ((ntype->inputs && ntype->inputs[0].type>=0) || (ntype->outputs && ntype->outputs[0].type>=0))) {
 
642
        if (ntype && ((ntype->inputs && ntype->inputs[0].type >= 0) ||
 
643
                      (ntype->outputs && ntype->outputs[0].type >= 0)))
 
644
        {
604
645
                verify_socket_template_list(ntree, node, SOCK_IN, &node->inputs, ntype->inputs);
605
646
                verify_socket_template_list(ntree, node, SOCK_OUT, &node->outputs, ntype->outputs);
606
647
        }