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