1 /*
2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public License
4 * as published by the Free Software Foundation; either version 2
5 * of the License, or (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software Foundation,
14 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15 *
16 * The Original Code is Copyright (C) 2007 Blender Foundation.
17 * All rights reserved.
18 */
19
20 /** \file
21 * \ingroup nodes
22 */
23
24 #include <string.h>
25
26 #include "DNA_node_types.h"
27 #include "DNA_space_types.h"
28 #include "DNA_texture_types.h"
29
30 #include "BLI_listbase.h"
31 #include "BLI_threads.h"
32 #include "BLI_utildefines.h"
33
34 #include "BLT_translation.h"
35
36 #include "BKE_context.h"
37 #include "BKE_linestyle.h"
38 #include "BKE_node.h"
39 #include "BKE_paint.h"
40
41 #include "NOD_texture.h"
42 #include "node_common.h"
43 #include "node_exec.h"
44 #include "node_texture_util.h"
45 #include "node_util.h"
46
47 #include "DEG_depsgraph.h"
48
49 #include "RNA_access.h"
50
51 #include "RE_shader_ext.h"
52
texture_get_from_context(const bContext * C,bNodeTreeType * UNUSED (treetype),bNodeTree ** r_ntree,ID ** r_id,ID ** r_from)53 static void texture_get_from_context(const bContext *C,
54 bNodeTreeType *UNUSED(treetype),
55 bNodeTree **r_ntree,
56 ID **r_id,
57 ID **r_from)
58 {
59 SpaceNode *snode = CTX_wm_space_node(C);
60 Scene *scene = CTX_data_scene(C);
61 ViewLayer *view_layer = CTX_data_view_layer(C);
62 Object *ob = OBACT(view_layer);
63 Tex *tx = NULL;
64
65 if (snode->texfrom == SNODE_TEX_BRUSH) {
66 struct Brush *brush = NULL;
67
68 if (ob && (ob->mode & OB_MODE_SCULPT)) {
69 brush = BKE_paint_brush(&scene->toolsettings->sculpt->paint);
70 }
71 else {
72 brush = BKE_paint_brush(&scene->toolsettings->imapaint.paint);
73 }
74
75 if (brush) {
76 *r_from = (ID *)brush;
77 tx = give_current_brush_texture(brush);
78 if (tx) {
79 *r_id = &tx->id;
80 *r_ntree = tx->nodetree;
81 }
82 }
83 }
84 else if (snode->texfrom == SNODE_TEX_LINESTYLE) {
85 FreestyleLineStyle *linestyle = BKE_linestyle_active_from_view_layer(view_layer);
86 if (linestyle) {
87 *r_from = (ID *)linestyle;
88 tx = give_current_linestyle_texture(linestyle);
89 if (tx) {
90 *r_id = &tx->id;
91 *r_ntree = tx->nodetree;
92 }
93 }
94 }
95 }
96
foreach_nodeclass(Scene * UNUSED (scene),void * calldata,bNodeClassCallback func)97 static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCallback func)
98 {
99 func(calldata, NODE_CLASS_INPUT, N_("Input"));
100 func(calldata, NODE_CLASS_OUTPUT, N_("Output"));
101 func(calldata, NODE_CLASS_OP_COLOR, N_("Color"));
102 func(calldata, NODE_CLASS_PATTERN, N_("Patterns"));
103 func(calldata, NODE_CLASS_TEXTURE, N_("Textures"));
104 func(calldata, NODE_CLASS_CONVERTOR, N_("Convertor"));
105 func(calldata, NODE_CLASS_DISTORT, N_("Distort"));
106 func(calldata, NODE_CLASS_GROUP, N_("Group"));
107 func(calldata, NODE_CLASS_INTERFACE, N_("Interface"));
108 func(calldata, NODE_CLASS_LAYOUT, N_("Layout"));
109 }
110
111 /* XXX muting disabled in previews because of threading issues with the main execution
112 * it works here, but disabled for consistency
113 */
114 #if 1
localize(bNodeTree * localtree,bNodeTree * UNUSED (ntree))115 static void localize(bNodeTree *localtree, bNodeTree *UNUSED(ntree))
116 {
117 bNode *node, *node_next;
118
119 /* replace muted nodes and reroute nodes by internal links */
120 for (node = localtree->nodes.first; node; node = node_next) {
121 node_next = node->next;
122
123 if (node->flag & NODE_MUTED || node->type == NODE_REROUTE) {
124 nodeInternalRelink(localtree, node);
125 ntreeFreeLocalNode(localtree, node);
126 }
127 }
128 }
129 #else
localize(bNodeTree * UNUSED (localtree),bNodeTree * UNUSED (ntree))130 static void localize(bNodeTree *UNUSED(localtree), bNodeTree *UNUSED(ntree))
131 {
132 }
133 #endif
134
local_sync(bNodeTree * localtree,bNodeTree * ntree)135 static void local_sync(bNodeTree *localtree, bNodeTree *ntree)
136 {
137 BKE_node_preview_sync_tree(ntree, localtree);
138 }
139
local_merge(Main * UNUSED (bmain),bNodeTree * localtree,bNodeTree * ntree)140 static void local_merge(Main *UNUSED(bmain), bNodeTree *localtree, bNodeTree *ntree)
141 {
142 BKE_node_preview_merge_tree(ntree, localtree, true);
143 }
144
update(bNodeTree * ntree)145 static void update(bNodeTree *ntree)
146 {
147 ntree_update_reroute_nodes(ntree);
148
149 if (ntree->update & NTREE_UPDATE_NODES) {
150 /* clean up preview cache, in case nodes have been removed */
151 BKE_node_preview_remove_unused(ntree);
152 }
153 }
154
155 bNodeTreeType *ntreeType_Texture;
156
register_node_tree_type_tex(void)157 void register_node_tree_type_tex(void)
158 {
159 bNodeTreeType *tt = ntreeType_Texture = MEM_callocN(sizeof(bNodeTreeType),
160 "texture node tree type");
161
162 tt->type = NTREE_TEXTURE;
163 strcpy(tt->idname, "TextureNodeTree");
164 strcpy(tt->ui_name, N_("Texture Node Editor"));
165 tt->ui_icon = 0; /* defined in drawnode.c */
166 strcpy(tt->ui_description, N_("Texture nodes"));
167
168 tt->foreach_nodeclass = foreach_nodeclass;
169 tt->update = update;
170 tt->localize = localize;
171 tt->local_sync = local_sync;
172 tt->local_merge = local_merge;
173 tt->get_from_context = texture_get_from_context;
174
175 tt->rna_ext.srna = &RNA_TextureNodeTree;
176
177 ntreeTypeAdd(tt);
178 }
179
ntreeTexBeginExecTree_internal(bNodeExecContext * context,bNodeTree * ntree,bNodeInstanceKey parent_key)180 bNodeTreeExec *ntreeTexBeginExecTree_internal(bNodeExecContext *context,
181 bNodeTree *ntree,
182 bNodeInstanceKey parent_key)
183 {
184 bNodeTreeExec *exec;
185 bNode *node;
186
187 /* common base initialization */
188 exec = ntree_exec_begin(context, ntree, parent_key);
189
190 /* allocate the thread stack listbase array */
191 exec->threadstack = MEM_callocN(BLENDER_MAX_THREADS * sizeof(ListBase), "thread stack array");
192
193 for (node = exec->nodetree->nodes.first; node; node = node->next) {
194 node->need_exec = 1;
195 }
196
197 return exec;
198 }
199
ntreeTexBeginExecTree(bNodeTree * ntree)200 bNodeTreeExec *ntreeTexBeginExecTree(bNodeTree *ntree)
201 {
202 bNodeExecContext context;
203 bNodeTreeExec *exec;
204
205 /* XXX hack: prevent exec data from being generated twice.
206 * this should be handled by the renderer!
207 */
208 if (ntree->execdata) {
209 return ntree->execdata;
210 }
211
212 context.previews = ntree->previews;
213
214 exec = ntreeTexBeginExecTree_internal(&context, ntree, NODE_INSTANCE_KEY_BASE);
215
216 /* XXX this should not be necessary, but is still used for cmp/sha/tex nodes,
217 * which only store the ntree pointer. Should be fixed at some point!
218 */
219 ntree->execdata = exec;
220
221 return exec;
222 }
223
224 /* free texture delegates */
tex_free_delegates(bNodeTreeExec * exec)225 static void tex_free_delegates(bNodeTreeExec *exec)
226 {
227 bNodeThreadStack *nts;
228 bNodeStack *ns;
229 int th, a;
230
231 for (th = 0; th < BLENDER_MAX_THREADS; th++) {
232 for (nts = exec->threadstack[th].first; nts; nts = nts->next) {
233 for (ns = nts->stack, a = 0; a < exec->stacksize; a++, ns++) {
234 if (ns->data && !ns->is_copy) {
235 MEM_freeN(ns->data);
236 }
237 }
238 }
239 }
240 }
241
ntreeTexEndExecTree_internal(bNodeTreeExec * exec)242 void ntreeTexEndExecTree_internal(bNodeTreeExec *exec)
243 {
244 bNodeThreadStack *nts;
245 int a;
246
247 if (exec->threadstack) {
248 tex_free_delegates(exec);
249
250 for (a = 0; a < BLENDER_MAX_THREADS; a++) {
251 for (nts = exec->threadstack[a].first; nts; nts = nts->next) {
252 if (nts->stack) {
253 MEM_freeN(nts->stack);
254 }
255 }
256 BLI_freelistN(&exec->threadstack[a]);
257 }
258
259 MEM_freeN(exec->threadstack);
260 exec->threadstack = NULL;
261 }
262
263 ntree_exec_end(exec);
264 }
265
ntreeTexEndExecTree(bNodeTreeExec * exec)266 void ntreeTexEndExecTree(bNodeTreeExec *exec)
267 {
268 if (exec) {
269 /* exec may get freed, so assign ntree */
270 bNodeTree *ntree = exec->nodetree;
271 ntreeTexEndExecTree_internal(exec);
272
273 /* XXX clear nodetree backpointer to exec data, same problem as noted in ntreeBeginExecTree */
274 ntree->execdata = NULL;
275 }
276 }
277
ntreeTexExecTree(bNodeTree * ntree,TexResult * target,const float co[3],float dxt[3],float dyt[3],int osatex,const short thread,const Tex * UNUSED (tex),short which_output,int cfra,int preview,MTex * mtex)278 int ntreeTexExecTree(bNodeTree *ntree,
279 TexResult *target,
280 const float co[3],
281 float dxt[3],
282 float dyt[3],
283 int osatex,
284 const short thread,
285 const Tex *UNUSED(tex),
286 short which_output,
287 int cfra,
288 int preview,
289 MTex *mtex)
290 {
291 TexCallData data;
292 float *nor = target->nor;
293 int retval = TEX_INT;
294 bNodeThreadStack *nts = NULL;
295 bNodeTreeExec *exec = ntree->execdata;
296
297 data.co = co;
298 data.dxt = dxt;
299 data.dyt = dyt;
300 data.osatex = osatex;
301 data.target = target;
302 data.do_preview = preview;
303 data.do_manage = true;
304 data.thread = thread;
305 data.which_output = which_output;
306 data.cfra = cfra;
307 data.mtex = mtex;
308
309 /* ensure execdata is only initialized once */
310 if (!exec) {
311 BLI_thread_lock(LOCK_NODES);
312 if (!ntree->execdata) {
313 ntreeTexBeginExecTree(ntree);
314 }
315 BLI_thread_unlock(LOCK_NODES);
316
317 exec = ntree->execdata;
318 }
319
320 nts = ntreeGetThreadStack(exec, thread);
321 ntreeExecThreadNodes(exec, nts, &data, thread);
322 ntreeReleaseThreadStack(nts);
323
324 if (target->nor) {
325 retval |= TEX_NOR;
326 }
327 retval |= TEX_RGB;
328 /* confusing stuff; the texture output node sets this to NULL to indicate no normal socket was
329 * set however, the texture code checks this for other reasons
330 * (namely, a normal is required for material). */
331 target->nor = nor;
332
333 return retval;
334 }
335