struct bNodeSocket *node_add_input_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp)
{
bNodeSocket *sock;
switch (stemp->type) {
case SOCK_INT:
sock = nodeAddInputInt(ntree, node, stemp->name, stemp->subtype, (int)stemp->val1, (int)stemp->min, (int)stemp->max);
break;
case SOCK_FLOAT:
sock = nodeAddInputFloat(ntree, node, stemp->name, stemp->subtype, stemp->val1, stemp->min, stemp->max);
break;
case SOCK_BOOLEAN:
sock = nodeAddInputBoolean(ntree, node, stemp->name, (char)stemp->val1);
break;
case SOCK_VECTOR:
sock = nodeAddInputVector(ntree, node, stemp->name, stemp->subtype, stemp->val1, stemp->val2, stemp->val3, stemp->min, stemp->max);
break;
case SOCK_RGBA:
sock = nodeAddInputRGBA(ntree, node, stemp->name, stemp->val1, stemp->val2, stemp->val3, stemp->val4);
break;
case SOCK_MESH:
sock = nodeAddInputMesh(ntree, node, stemp->name);
break;
default:
sock = nodeAddSocket(ntree, node, SOCK_IN, stemp->name, stemp->type);
}
return sock;
}
struct bNodeSocket *node_add_output_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp)
{
bNodeSocket *sock;
switch (stemp->type) {
case SOCK_INT:
sock = nodeAddOutputInt(ntree, node, stemp->name);
break;
case SOCK_FLOAT:
sock = nodeAddOutputFloat(ntree, node, stemp->name);
break;
case SOCK_BOOLEAN:
sock = nodeAddOutputBoolean(ntree, node, stemp->name);
break;
case SOCK_VECTOR:
sock = nodeAddOutputVector(ntree, node, stemp->name);
break;
case SOCK_RGBA:
sock = nodeAddOutputRGBA(ntree, node, stemp->name);
break;
case SOCK_MESH:
sock = nodeAddOutputMesh(ntree, node, stemp->name);
break;
default:
sock = nodeAddSocket(ntree, node, SOCK_OUT, stemp->name, stemp->type);
}
return sock;
}
struct bNodeSocket *nodeAddInputBoolean(struct bNodeTree *ntree, struct bNode *node, const char *name, char value)
{
bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_IN, name, SOCK_BOOLEAN);
bNodeSocketValueBoolean *dval= (bNodeSocketValueBoolean*)sock->default_value;
dval->value = value;
return sock;
}
/* used for both group nodes and interface nodes */
static bNodeSocket *group_verify_socket(bNodeTree *ntree, bNode *gnode, bNodeSocket *iosock, ListBase *verify_lb, int in_out)
{
bNodeSocket *sock;
for (sock = verify_lb->first; sock; sock = sock->next) {
if (STREQ(sock->identifier, iosock->identifier))
break;
}
if (sock) {
strcpy(sock->name, iosock->name);
if (iosock->typeinfo->interface_verify_socket)
iosock->typeinfo->interface_verify_socket(ntree, iosock, gnode, sock, "interface");
}
else {
sock = nodeAddSocket(ntree, gnode, in_out, iosock->idname, iosock->identifier, iosock->name);
if (iosock->typeinfo->interface_init_socket)
iosock->typeinfo->interface_init_socket(ntree, iosock, gnode, sock, "interface");
}
/* remove from list temporarily, to distinguish from orphaned sockets */
BLI_remlink(verify_lb, sock);
return sock;
}
bNodeSocket *ntreeCompositOutputFileAddSocket(bNodeTree *ntree, bNode *node, const char *name, ImageFormatData *im_format)
{
NodeImageMultiFile *nimf = node->storage;
bNodeSocket *sock = nodeAddSocket(ntree, node, SOCK_IN, "", SOCK_RGBA);
/* create format data for the input socket */
NodeImageMultiFileSocket *sockdata = MEM_callocN(sizeof(NodeImageMultiFileSocket), "socket image format");
sock->storage = sockdata;
BLI_strncpy_utf8(sockdata->path, name, sizeof(sockdata->path));
ntreeCompositOutputFileUniquePath(&node->inputs, sock, name, '_');
BLI_strncpy_utf8(sockdata->layer, name, sizeof(sockdata->layer));
ntreeCompositOutputFileUniqueLayer(&node->inputs, sock, name, '_');
if (im_format) {
sockdata->format= *im_format;
if (BKE_imtype_is_movie(sockdata->format.imtype)) {
sockdata->format.imtype= R_IMF_IMTYPE_OPENEXR;
}
}
else
BKE_imformat_defaults(&sockdata->format);
/* use node data format by default */
sockdata->use_node_format = TRUE;
nimf->active_input = BLI_findindex(&node->inputs, sock);
return sock;
}
struct bNodeSocket *nodeAddInputRGBA(struct bNodeTree *ntree, struct bNode *node, const char *name,
float r, float g, float b, float a)
{
bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_IN, name, SOCK_RGBA);
bNodeSocketValueRGBA *dval= (bNodeSocketValueRGBA*)sock->default_value;
dval->value[0] = r;
dval->value[1] = g;
dval->value[2] = b;
dval->value[3] = a;
return sock;
}
struct bNodeSocket *nodeAddInputFloat(struct bNodeTree *ntree, struct bNode *node, const char *name, PropertySubType subtype,
float value, float min, float max)
{
bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_IN, name, SOCK_FLOAT);
bNodeSocketValueFloat *dval= (bNodeSocketValueFloat*)sock->default_value;
dval->subtype = subtype;
dval->value = value;
dval->min = min;
dval->max = max;
return sock;
}
void node_group_output_verify(bNodeTree *ntree, bNode *node, ID *id)
{
/* check inputs and outputs, and remove or insert them */
if (id == (ID *)ntree) {
/* value_in_out inverted for interface nodes to get correct socket value_property */
group_verify_socket_list(ntree, node, &ntree->outputs, &node->inputs, SOCK_IN);
/* add virtual extension socket */
nodeAddSocket(ntree, node, SOCK_IN, "NodeSocketVirtual", "__extend__", "");
}
}
struct bNodeSocket *nodeAddInputVector(struct bNodeTree *ntree, struct bNode *node, const char *name, PropertySubType subtype,
float x, float y, float z, float min, float max)
{
bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_IN, name, SOCK_VECTOR);
bNodeSocketValueVector *dval= (bNodeSocketValueVector*)sock->default_value;
dval->subtype = subtype;
dval->value[0] = x;
dval->value[1] = y;
dval->value[2] = z;
dval->min = min;
dval->max = max;
return sock;
}
void node_forloop_init(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp)
{
bNodeSocket *sock;
node->id = (ID*)ntemp->ngroup;
sock = nodeAddSocket(ntree, node, SOCK_IN, "Iterations", SOCK_FLOAT);
node_socket_set_default_value_float(sock->default_value, PROP_UNSIGNED, 1, 0, 10000);
/* NB: group socket input/output roles are inverted internally!
* Group "inputs" work as outputs in links and vice versa.
*/
if (ntemp->ngroup) {
bNodeSocket *gsock;
for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next)
node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock);
for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next)
node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock);
}
}
struct bNodeSocket *nodeAddOutputMesh(struct bNodeTree *ntree, struct bNode *node, const char *name)
{
bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_OUT, name, SOCK_MESH);
return sock;
}
struct bNodeSocket *nodeAddOutputVector(struct bNodeTree *ntree, struct bNode *node, const char *name)
{
bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_OUT, name, SOCK_VECTOR);
return sock;
}
struct bNodeSocket *nodeAddOutputBoolean(struct bNodeTree *ntree, struct bNode *node, const char *name)
{
bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_OUT, name, SOCK_BOOLEAN);
return sock;
}
struct bNodeSocket *nodeAddOutputFloat(struct bNodeTree *ntree, struct bNode *node, const char *name)
{
bNodeSocket *sock= nodeAddSocket(ntree, node, SOCK_OUT, name, SOCK_FLOAT);
return sock;
}
static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node, int flag)
{
bNodeSocket *input = node->inputs.first;
bNodeSocket *output = node->outputs.first;
bNodeLink *link;
int type = SOCK_FLOAT;
const char *type_idname = nodeStaticSocketType(type, PROP_NONE);
/* XXX it would be a little bit more efficient to restrict actual updates
* to rerout nodes connected to an updated node, but there's no reliable flag
* to indicate updated nodes (node->update is not set on linking).
*/
node->done = 1;
/* recursive update */
for (link = ntree->links.first; link; link = link->next) {
bNode *fromnode = link->fromnode;
bNode *tonode = link->tonode;
if (!tonode || !fromnode)
continue;
if (nodeLinkIsHidden(link))
continue;
if (flag & REFINE_FORWARD) {
if (tonode == node && fromnode->type == NODE_REROUTE && !fromnode->done)
node_reroute_inherit_type_recursive(ntree, fromnode, REFINE_FORWARD);
}
if (flag & REFINE_BACKWARD) {
if (fromnode == node && tonode->type == NODE_REROUTE && !tonode->done)
node_reroute_inherit_type_recursive(ntree, tonode, REFINE_BACKWARD);
}
}
/* determine socket type from unambiguous input/output connection if possible */
if (input->limit == 1 && input->link) {
type = input->link->fromsock->type;
type_idname = nodeStaticSocketType(type, PROP_NONE);
}
else if (output->limit == 1 && output->link) {
type = output->link->tosock->type;
type_idname = nodeStaticSocketType(type, PROP_NONE);
}
if (input->type != type) {
bNodeSocket *ninput = nodeAddSocket(ntree, node, SOCK_IN, type_idname, "input", "Input");
for (link = ntree->links.first; link; link = link->next) {
if (link->tosock == input) {
link->tosock = ninput;
ninput->link = link;
}
}
nodeRemoveSocket(ntree, node, input);
}
if (output->type != type) {
bNodeSocket *noutput = nodeAddSocket(ntree, node, SOCK_OUT, type_idname, "output", "Output");
for (link = ntree->links.first; link; link = link->next) {
if (link->fromsock == output) {
link->fromsock = noutput;
}
}
nodeRemoveSocket(ntree, node, output);
}
nodeUpdateInternalLinks(ntree, node);
}
