static void do_node_add_group(bContext *C, void *UNUSED(arg), int event)
{
SpaceNode *snode= CTX_wm_space_node(C);
bNodeTemplate ntemp;
if (event>=0) {
ntemp.ngroup= BLI_findlink(&G.main->nodetree, event);
ntemp.type = ntemp.ngroup->nodetype;
}
else {
ntemp.type = -event;
switch (ntemp.type) {
case NODE_GROUP:
ntemp.ngroup = ntreeAddTree("Group", snode->treetype, ntemp.type);
break;
case NODE_FORLOOP:
ntemp.ngroup = ntreeAddTree("For Loop", snode->treetype, ntemp.type);
break;
case NODE_WHILELOOP:
ntemp.ngroup = ntreeAddTree("While Loop", snode->treetype, ntemp.type);
break;
default:
ntemp.ngroup = NULL;
}
}
if (!ntemp.ngroup)
return;
do_node_add(C, &ntemp);
}
static bNode *node_group_make_from_selected(const bContext *C, bNodeTree *ntree, const char *ntype, const char *ntreetype)
{
Main *bmain = CTX_data_main(C);
bNode *gnode;
bNodeTree *ngroup;
float min[2], max[2];
int totselect;
totselect = node_get_selected_minmax(ntree, NULL, min, max);
/* don't make empty group */
if (totselect == 0)
return NULL;
/* new nodetree */
ngroup = ntreeAddTree(bmain, "NodeGroup", ntreetype);
/* make group node */
gnode = nodeAddNode(C, ntree, ntype);
gnode->id = (ID *)ngroup;
gnode->locx = 0.5f * (min[0] + max[0]);
gnode->locy = 0.5f * (min[1] + max[1]);
node_group_make_insert_selected(C, ntree, gnode);
/* update of the tree containing the group instance node */
ntree->update |= NTREE_UPDATE_NODES;
return gnode;
}
struct bNodeTree *rna_Main_nodetree_new(Main *UNUSED(bmain), const char *name, int type)
{
bNodeTree *tree = ntreeAddTree(name, type, NODE_GROUP);
id_us_min(&tree->id);
return tree;
}
static void do_node_add_group(bContext *C, void *UNUSED(arg), int event)
{
SpaceNode *snode = CTX_wm_space_node(C);
Main *bmain = CTX_data_main(C);
Scene *scene = CTX_data_scene(C);
bNodeTemplate ntemp;
if (event >= 0) {
ntemp.ngroup = BLI_findlink(&G.main->nodetree, event);
ntemp.type = ntemp.ngroup->nodetype;
}
else {
ntemp.type = -event;
switch (ntemp.type) {
case NODE_GROUP:
ntemp.ngroup = ntreeAddTree("Group", snode->treetype, ntemp.type);
break;
default:
ntemp.ngroup = NULL;
}
}
if (!ntemp.ngroup)
return;
ntemp.main = bmain;
ntemp.scene = scene;
do_node_add(C, &ntemp);
}
static bool node_group_make_test_selected(bNodeTree *ntree, bNode *gnode, const char *ntree_idname, struct ReportList *reports)
{
bNodeTree *ngroup;
bNode *node;
bNodeLink *link;
int ok = true;
/* make a local pseudo node tree to pass to the node poll functions */
ngroup = ntreeAddTree(NULL, "Pseudo Node Group", ntree_idname);
/* check poll functions for selected nodes */
for (node = ntree->nodes.first; node; node = node->next) {
if (node_group_make_use_node(node, gnode)) {
if (node->typeinfo->poll_instance && !node->typeinfo->poll_instance(node, ngroup)) {
BKE_reportf(reports, RPT_WARNING, "Can not add node '%s' in a group", node->name);
ok = false;
break;
}
}
node->done = 0;
}
/* free local pseudo node tree again */
ntreeFreeTree(ngroup);
MEM_freeN(ngroup);
if (!ok)
return false;
/* check if all connections are OK, no unselected node has both
* inputs and outputs to a selection */
for (link = ntree->links.first; link; link = link->next) {
if (node_group_make_use_node(link->fromnode, gnode))
link->tonode->done |= 1;
if (node_group_make_use_node(link->tonode, gnode))
link->fromnode->done |= 2;
}
for (node = ntree->nodes.first; node; node = node->next) {
if (!(node->flag & NODE_SELECT) &&
node != gnode &&
node->done == 3)
{
return false;
}
}
return true;
}
/* /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// */
static void get_material_cb(bContext *C, void *poin, void *poin2)
{
Scene *scene = CTX_data_scene(C);
Main *bmain = CTX_data_main(C);
bool not_set = true;
Object *cur_object;
Object *ob;
Material *ma;
cur_object = scene->basact ? scene->basact->object : 0;
if(cur_object->actcol > 0) {
ob = (Object*)cur_object;
if(cur_object->totcol >= cur_object->actcol && ob->mat[cur_object->actcol - 1]) {
bNodeTree *ntree = ob->mat[cur_object->actcol - 1]->nodetree;
if(!ob->mat[cur_object->actcol - 1]->use_nodes) ob->mat[cur_object->actcol - 1]->use_nodes = true;
if (ntree) {
get_material(bmain, C, scene, ntree, (char*)poin, (int)poin2);
not_set = false;
}
}
if(not_set) {
ID *id_me = cur_object->data;
if (GS(id_me->name) == ID_ME) {
Mesh *me = (Mesh*)id_me;
if(me->totcol >= cur_object->actcol && me->mat[cur_object->actcol - 1]) {
bNodeTree *ntree = me->mat[cur_object->actcol - 1]->nodetree;
if(!me->mat[cur_object->actcol - 1]->use_nodes) me->mat[cur_object->actcol - 1]->use_nodes = true;
if (ntree) {
get_material(bmain, C, scene, ntree, (char*)poin, (int)poin2);
not_set = false;
}
}
}
}
}
if(not_set) {
ob = (Object*)cur_object;
ma = BKE_material_add(bmain, DATA_("LDB Material"));
ma->use_nodes = true;
ma->nodetree = ntreeAddTree(NULL, "Shader Nodetree", ntreeType_Shader->idname);
assign_material(ob, ma, ob->totcol + 1, BKE_MAT_ASSIGN_USERPREF);
WM_event_add_notifier(C, NC_MATERIAL | NA_ADDED, ma);
get_material(bmain, C, scene, ma->nodetree, (char*)poin, (int)poin2);
}
} /* get_material_cb() */
void BKE_linestyle_default_shader(const bContext *C, FreestyleLineStyle *linestyle)
{
bNode *uv_along_stroke, *input_texure, *output_linestyle;
bNodeSocket *fromsock, *tosock;
bNodeTree *ntree;
BLI_assert(linestyle->nodetree == NULL);
ntree = ntreeAddTree(NULL, "stroke_shader", "ShaderNodeTree");
linestyle->nodetree = ntree;
uv_along_stroke = nodeAddStaticNode(C, ntree, SH_NODE_UVALONGSTROKE);
uv_along_stroke->locx = 0.0f;
uv_along_stroke->locy = 300.0f;
uv_along_stroke->custom1 = 0; // use_tips
input_texure = nodeAddStaticNode(C, ntree, SH_NODE_TEX_IMAGE);
input_texure->locx = 200.0f;
input_texure->locy = 300.0f;
output_linestyle = nodeAddStaticNode(C, ntree, SH_NODE_OUTPUT_LINESTYLE);
output_linestyle->locx = 400.0f;
output_linestyle->locy = 300.0f;
output_linestyle->custom1 = MA_RAMP_BLEND;
output_linestyle->custom2 = 0; // use_clamp
nodeSetActive(ntree, input_texure);
fromsock = BLI_findlink(&uv_along_stroke->outputs, 0); // UV
tosock = BLI_findlink(&input_texure->inputs, 0); // UV
nodeAddLink(ntree, uv_along_stroke, fromsock, input_texure, tosock);
fromsock = BLI_findlink(&input_texure->outputs, 0); // Color
tosock = BLI_findlink(&output_linestyle->inputs, 0); // Color
nodeAddLink(ntree, input_texure, fromsock, output_linestyle, tosock);
ntreeUpdateTree(CTX_data_main(C), ntree);
}
bNode *node_group_make_from_selected(bNodeTree *ntree)
{
bNodeLink *link, *linkn;
bNode *node, *gnode, *nextn;
bNodeTree *ngroup;
bNodeSocket *gsock;
ListBase anim_basepaths = {NULL, NULL};
float min[2], max[2];
int totnode=0;
bNodeTemplate ntemp;
INIT_MINMAX2(min, max);
/* is there something to group? also do some clearing */
for(node= ntree->nodes.first; node; node= node->next) {
if(node->flag & NODE_SELECT) {
/* no groups in groups */
if(node->type==NODE_GROUP)
return NULL;
DO_MINMAX2( (&node->locx), min, max);
totnode++;
}
node->done= 0;
}
if(totnode==0) return NULL;
/* check if all connections are OK, no unselected node has both
inputs and outputs to a selection */
for(link= ntree->links.first; link; link= link->next) {
if(link->fromnode && link->tonode && link->fromnode->flag & NODE_SELECT)
link->tonode->done |= 1;
if(link->fromnode && link->tonode && link->tonode->flag & NODE_SELECT)
link->fromnode->done |= 2;
}
for(node= ntree->nodes.first; node; node= node->next) {
if((node->flag & NODE_SELECT)==0)
if(node->done==3)
break;
}
if(node)
return NULL;
/* OK! new nodetree */
ngroup= ntreeAddTree("NodeGroup", ntree->type, NODE_GROUP);
/* move nodes over */
for(node= ntree->nodes.first; node; node= nextn) {
nextn= node->next;
if(node->flag & NODE_SELECT) {
/* keep track of this node's RNA "base" path (the part of the pat identifying the node)
* if the old nodetree has animation data which potentially covers this node
*/
if (ntree->adt) {
PointerRNA ptr;
char *path;
RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr);
path = RNA_path_from_ID_to_struct(&ptr);
if (path)
BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
}
/* change node-collection membership */
BLI_remlink(&ntree->nodes, node);
BLI_addtail(&ngroup->nodes, node);
node->locx-= 0.5f*(min[0]+max[0]);
node->locy-= 0.5f*(min[1]+max[1]);
}
}
/* move animation data over */
if (ntree->adt) {
LinkData *ld, *ldn=NULL;
BKE_animdata_separate_by_basepath(&ntree->id, &ngroup->id, &anim_basepaths);
/* paths + their wrappers need to be freed */
for (ld = anim_basepaths.first; ld; ld = ldn) {
ldn = ld->next;
MEM_freeN(ld->data);
BLI_freelinkN(&anim_basepaths, ld);
}
}
/* make group node */
ntemp.type = NODE_GROUP;
ntemp.ngroup = ngroup;
gnode= nodeAddNode(ntree, &ntemp);
gnode->locx= 0.5f*(min[0]+max[0]);
gnode->locy= 0.5f*(min[1]+max[1]);
/* relink external sockets */
for(link= ntree->links.first; link; link= linkn) {
linkn= link->next;
if(link->fromnode && link->tonode && (link->fromnode->flag & link->tonode->flag & NODE_SELECT)) {
BLI_remlink(&ntree->links, link);
BLI_addtail(&ngroup->links, link);
}
else if(link->tonode && (link->tonode->flag & NODE_SELECT)) {
gsock = node_group_expose_socket(ngroup, link->tosock, SOCK_IN);
link->tosock->link = nodeAddLink(ngroup, NULL, gsock, link->tonode, link->tosock);
link->tosock = node_group_add_extern_socket(ntree, &gnode->inputs, SOCK_IN, gsock);
link->tonode = gnode;
}
else if(link->fromnode && (link->fromnode->flag & NODE_SELECT)) {
/* search for existing group node socket */
for (gsock=ngroup->outputs.first; gsock; gsock=gsock->next)
if (gsock->link && gsock->link->fromsock==link->fromsock)
break;
if (!gsock) {
gsock = node_group_expose_socket(ngroup, link->fromsock, SOCK_OUT);
gsock->link = nodeAddLink(ngroup, link->fromnode, link->fromsock, NULL, gsock);
link->fromsock = node_group_add_extern_socket(ntree, &gnode->outputs, SOCK_OUT, gsock);
}
else
link->fromsock = node_group_find_output(gnode, gsock);
link->fromnode = gnode;
}
}
ngroup->update |= NTREE_UPDATE;
ntreeUpdateTree(ngroup);
ntree->update |= NTREE_UPDATE_NODES|NTREE_UPDATE_LINKS;
ntreeUpdateTree(ntree);
return gnode;
}
