Merge branch 'master' into blender2.8
[blender.git] / source / blender / nodes / texture / node_texture_tree.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) 2007 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s):
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/nodes/texture/node_texture_tree.c
29  *  \ingroup nodes
30  */
31
32
33 #include <string.h>
34
35 #include "DNA_texture_types.h"
36 #include "DNA_node_types.h"
37 #include "DNA_space_types.h"
38
39 #include "BLI_listbase.h"
40 #include "BLI_threads.h"
41 #include "BLI_utildefines.h"
42
43 #include "BLT_translation.h"
44
45 #include "BKE_context.h"
46 #include "BKE_linestyle.h"
47 #include "BKE_node.h"
48 #include "BKE_paint.h"
49
50 #include "node_common.h"
51 #include "node_exec.h"
52 #include "node_util.h"
53 #include "NOD_texture.h"
54 #include "node_texture_util.h"
55
56 #include "RNA_access.h"
57
58 #include "RE_shader_ext.h"
59
60
61 static void texture_get_from_context(const bContext *C, bNodeTreeType *UNUSED(treetype), bNodeTree **r_ntree, ID **r_id, ID **r_from)
62 {
63         SpaceNode *snode = CTX_wm_space_node(C);
64         Scene *scene = CTX_data_scene(C);
65         SceneLayer *sl = CTX_data_scene_layer(C);
66         Object *ob = OBACT_NEW(sl);
67         Tex *tx = NULL;
68
69         if (snode->texfrom == SNODE_TEX_OBJECT) {
70                 if (ob) {
71                         tx = give_current_object_texture(ob);
72                         if (tx) {
73                                 if (ob->type == OB_LAMP)
74                                         *r_from = (ID *)ob->data;
75                                 else
76                                         *r_from = (ID *)give_current_material(ob, ob->actcol);
77                                 
78                                 /* from is not set fully for material nodes, should be ID + Node then */
79                                 *r_id = &tx->id;
80                                 *r_ntree = tx->nodetree;
81                         }
82                 }
83         }
84         else if (snode->texfrom == SNODE_TEX_WORLD) {
85                 if (scene->world) {
86                         *r_from = (ID *)scene->world;
87                         tx = give_current_world_texture(scene->world);
88                         if (tx) {
89                                 *r_id = &tx->id;
90                                 *r_ntree = tx->nodetree;
91                         }
92                 }
93         }
94         else if (snode->texfrom == SNODE_TEX_BRUSH) {
95                 struct Brush *brush = NULL;
96                 
97                 if (ob && (ob->mode & OB_MODE_SCULPT))
98                         brush = BKE_paint_brush(&scene->toolsettings->sculpt->paint);
99                 else
100                         brush = BKE_paint_brush(&scene->toolsettings->imapaint.paint);
101
102                 if (brush) {
103                         *r_from = (ID *)brush;
104                         tx = give_current_brush_texture(brush);
105                         if (tx) {
106                                 *r_id = &tx->id;
107                                 *r_ntree = tx->nodetree;
108                         }
109                 }
110         }
111         else if (snode->texfrom == SNODE_TEX_LINESTYLE) {
112                 FreestyleLineStyle *linestyle = BKE_linestyle_active_from_scene(scene);
113                 if (linestyle) {
114                         *r_from = (ID *)linestyle;
115                         tx = give_current_linestyle_texture(linestyle);
116                         if (tx) {
117                                 *r_id = &tx->id;
118                                 *r_ntree = tx->nodetree;
119                         }
120                 }
121         }
122 }
123
124 static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCallback func)
125 {
126         func(calldata, NODE_CLASS_INPUT, N_("Input"));
127         func(calldata, NODE_CLASS_OUTPUT, N_("Output"));
128         func(calldata, NODE_CLASS_OP_COLOR, N_("Color"));
129         func(calldata, NODE_CLASS_PATTERN, N_("Patterns"));
130         func(calldata, NODE_CLASS_TEXTURE, N_("Textures"));
131         func(calldata, NODE_CLASS_CONVERTOR, N_("Convertor"));
132         func(calldata, NODE_CLASS_DISTORT, N_("Distort"));
133         func(calldata, NODE_CLASS_GROUP, N_("Group"));
134         func(calldata, NODE_CLASS_INTERFACE, N_("Interface"));
135         func(calldata, NODE_CLASS_LAYOUT, N_("Layout"));
136 }
137
138 /* XXX muting disabled in previews because of threading issues with the main execution
139  * it works here, but disabled for consistency
140  */
141 #if 1
142 static void localize(bNodeTree *localtree, bNodeTree *UNUSED(ntree))
143 {
144         bNode *node, *node_next;
145         
146         /* replace muted nodes and reroute nodes by internal links */
147         for (node = localtree->nodes.first; node; node = node_next) {
148                 node_next = node->next;
149                 
150                 if (node->flag & NODE_MUTED || node->type == NODE_REROUTE) {
151                         nodeInternalRelink(localtree, node);
152                         nodeFreeNode(localtree, node);
153                 }
154         }
155 }
156 #else
157 static void localize(bNodeTree *UNUSED(localtree), bNodeTree *UNUSED(ntree))
158 {
159 }
160 #endif
161
162 static void local_sync(bNodeTree *localtree, bNodeTree *ntree)
163 {
164         BKE_node_preview_sync_tree(ntree, localtree);
165 }
166
167 static void local_merge(bNodeTree *localtree, bNodeTree *ntree)
168 {
169         BKE_node_preview_merge_tree(ntree, localtree, true);
170 }
171
172 static void update(bNodeTree *ntree)
173 {
174         ntree_update_reroute_nodes(ntree);
175         
176         if (ntree->update & NTREE_UPDATE_NODES) {
177                 /* clean up preview cache, in case nodes have been removed */
178                 BKE_node_preview_remove_unused(ntree);
179         }
180 }
181
182 bNodeTreeType *ntreeType_Texture;
183
184 void register_node_tree_type_tex(void)
185 {
186         bNodeTreeType *tt = ntreeType_Texture = MEM_callocN(sizeof(bNodeTreeType), "texture node tree type");
187         
188         tt->type = NTREE_TEXTURE;
189         strcpy(tt->idname, "TextureNodeTree");
190         strcpy(tt->ui_name, "Texture");
191         tt->ui_icon = 0;    /* defined in drawnode.c */
192         strcpy(tt->ui_description, "Texture nodes");
193         
194         tt->foreach_nodeclass = foreach_nodeclass;
195         tt->update = update;
196         tt->localize = localize;
197         tt->local_sync = local_sync;
198         tt->local_merge = local_merge;
199         tt->get_from_context = texture_get_from_context;
200         
201         tt->ext.srna = &RNA_TextureNodeTree;
202         
203         ntreeTypeAdd(tt);
204 }
205
206 int ntreeTexTagAnimated(bNodeTree *ntree)
207 {
208         bNode *node;
209         
210         if (ntree == NULL) return 0;
211         
212         for (node = ntree->nodes.first; node; node = node->next) {
213                 if (node->type == TEX_NODE_CURVE_TIME) {
214                         nodeUpdate(ntree, node);
215                         return 1;
216                 }
217                 else if (node->type == NODE_GROUP) {
218                         if (ntreeTexTagAnimated((bNodeTree *)node->id) ) {
219                                 return 1;
220                         }
221                 }
222         }
223         
224         return 0;
225 }
226
227 bNodeTreeExec *ntreeTexBeginExecTree_internal(bNodeExecContext *context, bNodeTree *ntree, bNodeInstanceKey parent_key)
228 {
229         bNodeTreeExec *exec;
230         bNode *node;
231         
232         /* common base initialization */
233         exec = ntree_exec_begin(context, ntree, parent_key);
234         
235         /* allocate the thread stack listbase array */
236         exec->threadstack = MEM_callocN(BLENDER_MAX_THREADS * sizeof(ListBase), "thread stack array");
237         
238         for (node = exec->nodetree->nodes.first; node; node = node->next)
239                 node->need_exec = 1;
240         
241         return exec;
242 }
243
244 bNodeTreeExec *ntreeTexBeginExecTree(bNodeTree *ntree)
245 {
246         bNodeExecContext context;
247         bNodeTreeExec *exec;
248         
249         /* XXX hack: prevent exec data from being generated twice.
250          * this should be handled by the renderer!
251          */
252         if (ntree->execdata)
253                 return ntree->execdata;
254         
255         context.previews = ntree->previews;
256         
257         exec = ntreeTexBeginExecTree_internal(&context, ntree, NODE_INSTANCE_KEY_BASE);
258         
259         /* XXX this should not be necessary, but is still used for cmp/sha/tex nodes,
260          * which only store the ntree pointer. Should be fixed at some point!
261          */
262         ntree->execdata = exec;
263         
264         return exec;
265 }
266
267 /* free texture delegates */
268 static void tex_free_delegates(bNodeTreeExec *exec)
269 {
270         bNodeThreadStack *nts;
271         bNodeStack *ns;
272         int th, a;
273         
274         for (th = 0; th < BLENDER_MAX_THREADS; th++)
275                 for (nts = exec->threadstack[th].first; nts; nts = nts->next)
276                         for (ns = nts->stack, a = 0; a < exec->stacksize; a++, ns++)
277                                 if (ns->data && !ns->is_copy)
278                                         MEM_freeN(ns->data);
279 }
280
281 void ntreeTexEndExecTree_internal(bNodeTreeExec *exec)
282 {
283         bNodeThreadStack *nts;
284         int a;
285         
286         if (exec->threadstack) {
287                 tex_free_delegates(exec);
288                 
289                 for (a = 0; a < BLENDER_MAX_THREADS; a++) {
290                         for (nts = exec->threadstack[a].first; nts; nts = nts->next)
291                                 if (nts->stack) MEM_freeN(nts->stack);
292                         BLI_freelistN(&exec->threadstack[a]);
293                 }
294                 
295                 MEM_freeN(exec->threadstack);
296                 exec->threadstack = NULL;
297         }
298         
299         ntree_exec_end(exec);
300 }
301
302 void ntreeTexEndExecTree(bNodeTreeExec *exec)
303 {
304         if (exec) {
305                 /* exec may get freed, so assign ntree */
306                 bNodeTree *ntree = exec->nodetree;
307                 ntreeTexEndExecTree_internal(exec);
308                 
309                 /* XXX clear nodetree backpointer to exec data, same problem as noted in ntreeBeginExecTree */
310                 ntree->execdata = NULL;
311         }
312 }
313
314 int ntreeTexExecTree(
315         bNodeTree *nodes,
316         TexResult *texres,
317         float co[3],
318         float dxt[3], float dyt[3],
319         int osatex,
320         const short thread,
321         Tex *UNUSED(tex),
322         short which_output,
323         int cfra,
324         int preview,
325         ShadeInput *shi,
326         MTex *mtex)
327 {
328         TexCallData data;
329         float *nor = texres->nor;
330         int retval = TEX_INT;
331         bNodeThreadStack *nts = NULL;
332         bNodeTreeExec *exec = nodes->execdata;
333
334         data.co = co;
335         data.dxt = dxt;
336         data.dyt = dyt;
337         data.osatex = osatex;
338         data.target = texres;
339         data.do_preview = preview;
340         data.do_manage = (shi) ? shi->do_manage : true;
341         data.thread = thread;
342         data.which_output = which_output;
343         data.cfra = cfra;
344         data.mtex = mtex;
345         data.shi = shi;
346         
347         /* ensure execdata is only initialized once */
348         if (!exec) {
349                 BLI_lock_thread(LOCK_NODES);
350                 if (!nodes->execdata)
351                         ntreeTexBeginExecTree(nodes);
352                 BLI_unlock_thread(LOCK_NODES);
353
354                 exec = nodes->execdata;
355         }
356         
357         nts = ntreeGetThreadStack(exec, thread);
358         ntreeExecThreadNodes(exec, nts, &data, thread);
359         ntreeReleaseThreadStack(nts);
360
361         if (texres->nor) retval |= TEX_NOR;
362         retval |= TEX_RGB;
363         /* confusing stuff; the texture output node sets this to NULL to indicate no normal socket was set
364          * however, the texture code checks this for other reasons (namely, a normal is required for material) */
365         texres->nor = nor;
366
367         return retval;
368 }