source/blender/nodes/shader/nodes/node_shader_common.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * The Original Code is Copyright (C) 2006 Blender Foundation.
  19  * All rights reserved.
  20  *
  21  * The Original Code is: all of this file.
  22  *
  23  * Contributor(s): Campbell Barton, Alfredo de Greef, David Millan Escriva,
  24  * Juho Vepsäläinen
  25  *
  26  * ***** END GPL LICENSE BLOCK *****
  27  */
  28
  29 /** \file blender/nodes/shader/nodes/node_shader_common.c
  30  *  \ingroup shdnodes
  31  */
  32
  33
  34 #include "DNA_node_types.h"
  35
  36 #include "BKE_node.h"
  37
  38 #include "node_shader_util.h"
  39 #include "node_common.h"
  40 #include "node_exec.h"
  41
  42 static void copy_stack(bNodeStack *to, bNodeStack *from)
  43 {
  44         if (to != from) {
  45                 copy_v4_v4(to->vec, from->vec);
  46                 to->data = from->data;
  47                 to->datatype = from->datatype;
  48
  49                 /* tag as copy to prevent freeing */
  50                 to->is_copy = 1;
  51         }
  52 }
  53
  54 static void move_stack(bNodeStack *to, bNodeStack *from)
  55 {
  56         if (to != from) {
  57                 copy_v4_v4(to->vec, from->vec);
  58                 to->data = from->data;
  59                 to->datatype = from->datatype;
  60                 to->is_copy = from->is_copy;
  61
  62                 zero_v4(from->vec);
  63                 from->data = NULL;
  64                 from->datatype = 0;
  65                 from->is_copy = 0;
  66         }
  67 }
  68
  69 /**** GROUP ****/
  70
  71 static void *group_initexec(bNode *node)
  72 {
  73         bNodeTree *ngroup= (bNodeTree*)node->id;
  74         bNodeTreeExec *exec;
  75
  76         if (!ngroup)
  77                 return NULL;
  78
  79         /* initialize the internal node tree execution */
  80         exec = ntreeShaderBeginExecTree(ngroup, 0);
  81
  82         return exec;
  83 }
  84
  85 static void group_freeexec(bNode *UNUSED(node), void *nodedata)
  86 {
  87         bNodeTreeExec*gexec= (bNodeTreeExec*)nodedata;
  88
  89         ntreeShaderEndExecTree(gexec, 0);
  90 }
  91
  92 /* Copy inputs to the internal stack.
  93  */
  94 static void group_copy_inputs(bNode *node, bNodeStack **in, bNodeStack *gstack)
  95 {
  96         bNodeSocket *sock;
  97         bNodeStack *ns;
  98         int a;
  99         for (sock=node->inputs.first, a=0; sock; sock=sock->next, ++a) {
 100                 if (sock->groupsock) {
 101                         ns = node_get_socket_stack(gstack, sock->groupsock);
 102                         copy_stack(ns, in[a]);
 103                 }
 104         }
 105 }
 106
 107 /* Copy internal results to the external outputs.
 108  */
 109 static void group_move_outputs(bNode *node, bNodeStack **out, bNodeStack *gstack)
 110 {
 111         bNodeSocket *sock;
 112         bNodeStack *ns;
 113         int a;
 114         for (sock=node->outputs.first, a=0; sock; sock=sock->next, ++a) {
 115                 if (sock->groupsock) {
 116                         ns = node_get_socket_stack(gstack, sock->groupsock);
 117                         move_stack(out[a], ns);
 118                 }
 119         }
 120 }
 121
 122 static void group_execute(void *data, int thread, struct bNode *node, void *nodedata, struct bNodeStack **in, struct bNodeStack **out)
 123 {
 124         bNodeTreeExec *exec= (bNodeTreeExec*)nodedata;
 125         bNodeThreadStack *nts;
 126
 127         if (!exec)
 128                 return;
 129
 130         /* XXX same behavior as trunk: all nodes inside group are executed.
 131          * it's stupid, but just makes it work. compo redesign will do this better.
 132          */
 133         {
 134                 bNode *inode;
 135                 for (inode=exec->nodetree->nodes.first; inode; inode=inode->next)
 136                         inode->need_exec = 1;
 137         }
 138
 139         nts = ntreeGetThreadStack(exec, thread);
 140
 141         group_copy_inputs(node, in, nts->stack);
 142         ntreeExecThreadNodes(exec, nts, data, thread);
 143         group_move_outputs(node, out, nts->stack);
 144
 145         ntreeReleaseThreadStack(nts);
 146 }
 147
 148 static void group_gpu_copy_inputs(bNode *node, GPUNodeStack *in, bNodeStack *gstack)
 149 {
 150         bNodeSocket *sock;
 151         bNodeStack *ns;
 152         int a;
 153         for (sock=node->inputs.first, a=0; sock; sock=sock->next, ++a) {
 154                 if (sock->groupsock) {
 155                         ns = node_get_socket_stack(gstack, sock->groupsock);
 156                         /* convert the external gpu stack back to internal node stack data */
 157                         node_data_from_gpu_stack(ns, &in[a]);
 158                 }
 159         }
 160 }
 161
 162 /* Copy internal results to the external outputs.
 163  */
 164 static void group_gpu_move_outputs(bNode *node, GPUNodeStack *out, bNodeStack *gstack)
 165 {
 166         bNodeSocket *sock;
 167         bNodeStack *ns;
 168         int a;
 169         for (sock=node->outputs.first, a=0; sock; sock=sock->next, ++a) {
 170                 if (sock->groupsock) {
 171                         ns = node_get_socket_stack(gstack, sock->groupsock);
 172                         /* convert the node stack data result back to gpu stack */
 173                         node_gpu_stack_from_data(&out[a], sock->type, ns);
 174                 }
 175         }
 176 }
 177
 178 static int gpu_group_execute(GPUMaterial *mat, bNode *node, void *nodedata, GPUNodeStack *in, GPUNodeStack *out)
 179 {
 180         bNodeTreeExec *exec= (bNodeTreeExec*)nodedata;
 181
 182         group_gpu_copy_inputs(node, in, exec->stack);
 183         ntreeExecGPUNodes(exec, mat, (node->flag & NODE_GROUP_EDIT));
 184         group_gpu_move_outputs(node, out, exec->stack);
 185
 186         return 1;
 187 }
 188
 189 void register_node_type_sh_group(bNodeTreeType *ttype)
 190 {
 191         static bNodeType ntype;
 192
 193         node_type_base(ttype, &ntype, NODE_GROUP, "Group", NODE_CLASS_GROUP, NODE_OPTIONS|NODE_CONST_OUTPUT);
 194         node_type_socket_templates(&ntype, NULL, NULL);
 195         node_type_size(&ntype, 120, 60, 200);
 196         node_type_label(&ntype, node_group_label);
 197         node_type_init(&ntype, node_group_init);
 198         node_type_valid(&ntype, node_group_valid);
 199         node_type_template(&ntype, node_group_template);
 200         node_type_update(&ntype, NULL, node_group_verify);
 201         node_type_group_edit(&ntype, node_group_edit_get, node_group_edit_set, node_group_edit_clear);
 202         node_type_exec_new(&ntype, group_initexec, group_freeexec, group_execute);
 203         node_type_gpu_ext(&ntype, gpu_group_execute);
 204
 205         nodeRegisterType(ttype, &ntype);
 206 }
 207
 208
 209 /**** FOR LOOP ****/
 210
 211 #if 0 /* XXX loop nodes don't work nicely with current trees */
 212 static void forloop_execute(void *data, int thread, struct bNode *node, void *nodedata, struct bNodeStack **in, struct bNodeStack **out)
 213 {
 214         bNodeTreeExec *exec= (bNodeTreeExec*)nodedata;
 215         bNodeThreadStack *nts;
 216         int iterations= (int)in[0]->vec[0];
 217         bNodeSocket *sock;
 218         bNodeStack *ns;
 219         int iteration;
 220
 221         /* XXX same behavior as trunk: all nodes inside group are executed.
 222          * it's stupid, but just makes it work. compo redesign will do this better.
 223          */
 224         {
 225                 bNode *inode;
 226                 for (inode=exec->nodetree->nodes.first; inode; inode=inode->next)
 227                         inode->need_exec = 1;
 228         }
 229
 230         nts = ntreeGetThreadStack(exec, thread);
 231
 232         /* "Iteration" socket */
 233         sock = exec->nodetree->inputs.first;
 234         ns = node_get_socket_stack(nts->stack, sock);
 235
 236 //      group_copy_inputs(node, in, nts->stack);
 237         for (iteration=0; iteration < iterations; ++iteration) {
 238                 /* first input contains current iteration counter */
 239                 ns->vec[0] = (float)iteration;
 240                 ns->vec[1]=ns->vec[2]=ns->vec[3] = 0.0f;
 241
 242 //              if (iteration > 0)
 243 //                      loop_init_iteration(exec->nodetree, nts->stack);
 244 //              ntreeExecThreadNodes(exec, nts, data, thread);
 245         }
 246 //      loop_copy_outputs(node, in, out, exec->stack);
 247
 248         ntreeReleaseThreadStack(nts);
 249 }
 250
 251 void register_node_type_sh_forloop(bNodeTreeType *ttype)
 252 {
 253         static bNodeType ntype;
 254
 255         node_type_base(ttype, &ntype, NODE_FORLOOP, "For", NODE_CLASS_GROUP, NODE_OPTIONS);
 256         node_type_socket_templates(&ntype, NULL, NULL);
 257         node_type_size(&ntype, 120, 60, 200);
 258         node_type_label(&ntype, node_group_label);
 259         node_type_init(&ntype, node_forloop_init);
 260         node_type_valid(&ntype, node_group_valid);
 261         node_type_template(&ntype, node_forloop_template);
 262         node_type_update(&ntype, NULL, node_group_verify);
 263         node_type_tree(&ntype, node_forloop_init_tree, node_loop_update_tree);
 264         node_type_group_edit(&ntype, node_group_edit_get, node_group_edit_set, node_group_edit_clear);
 265         node_type_exec_new(&ntype, group_initexec, group_freeexec, forloop_execute);
 266
 267         nodeRegisterType(ttype, &ntype);
 268 }
 269 #endif
 270
 271 /**** WHILE LOOP ****/
 272
 273 #if 0 /* XXX loop nodes don't work nicely with current trees */
 274 static void whileloop_execute(void *data, int thread, struct bNode *node, void *nodedata, struct bNodeStack **in, struct bNodeStack **out)
 275 {
 276         bNodeTreeExec *exec= (bNodeTreeExec*)nodedata;
 277         bNodeThreadStack *nts;
 278         int condition= (in[0]->vec[0] > 0.0f);
 279         bNodeSocket *sock;
 280         bNodeStack *ns;
 281         int iteration;
 282
 283         /* XXX same behavior as trunk: all nodes inside group are executed.
 284          * it's stupid, but just makes it work. compo redesign will do this better.
 285          */
 286         {
 287                 bNode *inode;
 288                 for (inode=exec->nodetree->nodes.first; inode; inode=inode->next)
 289                         inode->need_exec = 1;
 290         }
 291
 292         nts = ntreeGetThreadStack(exec, thread);
 293
 294         /* "Condition" socket */
 295         sock = exec->nodetree->outputs.first;
 296         ns = node_get_socket_stack(nts->stack, sock);
 297
 298         iteration = 0;
 299 //      group_copy_inputs(node, in, nts->stack);
 300         while (condition && iteration < node->custom1) {
 301 //              if (iteration > 0)
 302 //                      loop_init_iteration(exec->nodetree, nts->stack);
 303 //              ntreeExecThreadNodes(exec, nts, data, thread);
 304
 305                 condition = (ns->vec[0] > 0.0f);
 306                 ++iteration;
 307         }
 308 //      loop_copy_outputs(node, in, out, exec->stack);
 309
 310         ntreeReleaseThreadStack(nts);
 311 }
 312
 313 void register_node_type_sh_whileloop(bNodeTreeType *ttype)
 314 {
 315         static bNodeType ntype;
 316
 317         node_type_base(ttype, &ntype, NODE_WHILELOOP, "While", NODE_CLASS_GROUP, NODE_OPTIONS);
 318         node_type_socket_templates(&ntype, NULL, NULL);
 319         node_type_size(&ntype, 120, 60, 200);
 320         node_type_label(&ntype, node_group_label);
 321         node_type_init(&ntype, node_whileloop_init);
 322         node_type_valid(&ntype, node_group_valid);
 323         node_type_template(&ntype, node_whileloop_template);
 324         node_type_update(&ntype, NULL, node_group_verify);
 325         node_type_tree(&ntype, node_whileloop_init_tree, node_loop_update_tree);
 326         node_type_group_edit(&ntype, node_group_edit_get, node_group_edit_set, node_group_edit_clear);
 327         node_type_exec_new(&ntype, group_initexec, group_freeexec, whileloop_execute);
 328
 329         nodeRegisterType(ttype, &ntype);
 330 }
 331 #endif