UI: Refactor timecode functions into BLI_timecode
[blender.git] / source / blender / nodes / shader / node_shader_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/shader/node_shader_tree.c
29  *  \ingroup nodes
30  */
31
32
33 #include <string.h>
34
35 #include "DNA_lamp_types.h"
36 #include "DNA_material_types.h"
37 #include "DNA_node_types.h"
38 #include "DNA_scene_types.h"
39 #include "DNA_space_types.h"
40 #include "DNA_world_types.h"
41
42 #include "BLI_listbase.h"
43 #include "BLI_math.h"
44 #include "BLI_threads.h"
45 #include "BLI_utildefines.h"
46
47 #include "BLF_translation.h"
48
49 #include "BKE_context.h"
50 #include "BKE_global.h"
51 #include "BKE_main.h"
52 #include "BKE_node.h"
53 #include "BKE_scene.h"
54
55 #include "RNA_access.h"
56
57 #include "GPU_material.h"
58
59 #include "RE_shader_ext.h"
60
61 #include "node_common.h"
62 #include "node_exec.h"
63 #include "node_util.h"
64 #include "node_shader_util.h"
65
66 static int shader_tree_poll(const bContext *C, bNodeTreeType *UNUSED(treetype))
67 {
68         Scene *scene = CTX_data_scene(C);
69         /* allow empty engine string too, this is from older versions that didn't have registerable engines yet */
70         return (scene->r.engine[0] == '\0' ||
71                 STREQ(scene->r.engine, "BLENDER_RENDER") ||
72                 STREQ(scene->r.engine, "BLENDER_GAME") ||
73                 STREQ(scene->r.engine, "CYCLES"));
74 }
75
76 static void shader_get_from_context(const bContext *C, bNodeTreeType *UNUSED(treetype), bNodeTree **r_ntree, ID **r_id, ID **r_from)
77 {
78         SpaceNode *snode = CTX_wm_space_node(C);
79         Scene *scene = CTX_data_scene(C);
80         Object *ob = OBACT;
81         
82         if (snode->shaderfrom == SNODE_SHADER_OBJECT) {
83                 if (ob) {
84                         *r_from = &ob->id;
85                         if (ob->type == OB_LAMP) {
86                                 *r_id = ob->data;
87                                 *r_ntree = ((Lamp *)ob->data)->nodetree;
88                         }
89                         else {
90                                 Material *ma = give_current_material(ob, ob->actcol);
91                                 if (ma) {
92                                         *r_id = &ma->id;
93                                         *r_ntree = ma->nodetree;
94                                 }
95                         }
96                 }
97         }
98         else { /* SNODE_SHADER_WORLD */
99                 if (scene->world) {
100                         *r_from = NULL;
101                         *r_id = &scene->world->id;
102                         *r_ntree = scene->world->nodetree;
103                 }
104         }
105 }
106
107 static void foreach_nodeclass(Scene *scene, void *calldata, bNodeClassCallback func)
108 {
109         func(calldata, NODE_CLASS_INPUT, N_("Input"));
110         func(calldata, NODE_CLASS_OUTPUT, N_("Output"));
111
112         if (BKE_scene_use_new_shading_nodes(scene)) {
113                 func(calldata, NODE_CLASS_SHADER, N_("Shader"));
114                 func(calldata, NODE_CLASS_TEXTURE, N_("Texture"));
115         }
116         
117         func(calldata, NODE_CLASS_OP_COLOR, N_("Color"));
118         func(calldata, NODE_CLASS_OP_VECTOR, N_("Vector"));
119         func(calldata, NODE_CLASS_CONVERTOR, N_("Convertor"));
120         func(calldata, NODE_CLASS_SCRIPT, N_("Script"));
121         func(calldata, NODE_CLASS_GROUP, N_("Group"));
122         func(calldata, NODE_CLASS_INTERFACE, N_("Interface"));
123         func(calldata, NODE_CLASS_LAYOUT, N_("Layout"));
124 }
125
126 static void localize(bNodeTree *localtree, bNodeTree *UNUSED(ntree))
127 {
128         bNode *node, *node_next;
129         
130         /* replace muted nodes and reroute nodes by internal links */
131         for (node = localtree->nodes.first; node; node = node_next) {
132                 node_next = node->next;
133                 
134                 if (node->flag & NODE_MUTED || node->type == NODE_REROUTE) {
135                         nodeInternalRelink(localtree, node);
136                         nodeFreeNode(localtree, node);
137                 }
138         }
139 }
140
141 static void local_sync(bNodeTree *localtree, bNodeTree *ntree)
142 {
143         BKE_node_preview_sync_tree(ntree, localtree);
144 }
145
146 static void local_merge(bNodeTree *localtree, bNodeTree *ntree)
147 {
148         BKE_node_preview_merge_tree(ntree, localtree, true);
149 }
150
151 static void update(bNodeTree *ntree)
152 {
153         ntreeSetOutput(ntree);
154         
155         ntree_update_reroute_nodes(ntree);
156         
157         if (ntree->update & NTREE_UPDATE_NODES) {
158                 /* clean up preview cache, in case nodes have been removed */
159                 BKE_node_preview_remove_unused(ntree);
160         }
161 }
162
163 bNodeTreeType *ntreeType_Shader;
164
165 void register_node_tree_type_sh(void)
166 {
167         bNodeTreeType *tt = ntreeType_Shader = MEM_callocN(sizeof(bNodeTreeType), "shader node tree type");
168         
169         tt->type = NTREE_SHADER;
170         strcpy(tt->idname, "ShaderNodeTree");
171         strcpy(tt->ui_name, "Shader");
172         tt->ui_icon = 0;    /* defined in drawnode.c */
173         strcpy(tt->ui_description, "Shader nodes");
174         
175         tt->foreach_nodeclass = foreach_nodeclass;
176         tt->localize = localize;
177         tt->local_sync = local_sync;
178         tt->local_merge = local_merge;
179         tt->update = update;
180         tt->poll = shader_tree_poll;
181         tt->get_from_context = shader_get_from_context;
182         
183         tt->ext.srna = &RNA_ShaderNodeTree;
184         
185         ntreeTypeAdd(tt);
186 }
187
188 /* GPU material from shader nodes */
189
190 void ntreeGPUMaterialNodes(bNodeTree *ntree, GPUMaterial *mat)
191 {
192         /* localize tree to create links for reroute and mute */
193         bNodeTree *localtree = ntreeLocalize(ntree);
194         bNodeTreeExec *exec;
195
196         exec = ntreeShaderBeginExecTree(localtree);
197         ntreeExecGPUNodes(exec, mat, 1);
198         ntreeShaderEndExecTree(exec);
199
200         ntreeFreeTree_ex(localtree, false);
201         MEM_freeN(localtree);
202 }
203
204 /* **************** call to switch lamploop for material node ************ */
205
206 void (*node_shader_lamp_loop)(struct ShadeInput *, struct ShadeResult *);
207
208 void set_node_shader_lamp_loop(void (*lamp_loop_func)(ShadeInput *, ShadeResult *))
209 {
210         node_shader_lamp_loop = lamp_loop_func;
211 }
212
213
214 bNodeTreeExec *ntreeShaderBeginExecTree_internal(bNodeExecContext *context, bNodeTree *ntree, bNodeInstanceKey parent_key)
215 {
216         bNodeTreeExec *exec;
217         bNode *node;
218         
219         /* ensures only a single output node is enabled */
220         ntreeSetOutput(ntree);
221         
222         /* common base initialization */
223         exec = ntree_exec_begin(context, ntree, parent_key);
224         
225         /* allocate the thread stack listbase array */
226         exec->threadstack = MEM_callocN(BLENDER_MAX_THREADS * sizeof(ListBase), "thread stack array");
227         
228         for (node = exec->nodetree->nodes.first; node; node = node->next)
229                 node->need_exec = 1;
230         
231         return exec;
232 }
233
234 bNodeTreeExec *ntreeShaderBeginExecTree(bNodeTree *ntree)
235 {
236         bNodeExecContext context;
237         bNodeTreeExec *exec;
238         
239         /* XXX hack: prevent exec data from being generated twice.
240          * this should be handled by the renderer!
241          */
242         if (ntree->execdata)
243                 return ntree->execdata;
244         
245         context.previews = ntree->previews;
246         
247         exec = ntreeShaderBeginExecTree_internal(&context, ntree, NODE_INSTANCE_KEY_BASE);
248         
249         /* XXX this should not be necessary, but is still used for cmp/sha/tex nodes,
250          * which only store the ntree pointer. Should be fixed at some point!
251          */
252         ntree->execdata = exec;
253         
254         return exec;
255 }
256
257 void ntreeShaderEndExecTree_internal(bNodeTreeExec *exec)
258 {
259         bNodeThreadStack *nts;
260         int a;
261         
262         if (exec->threadstack) {
263                 for (a = 0; a < BLENDER_MAX_THREADS; a++) {
264                         for (nts = exec->threadstack[a].first; nts; nts = nts->next)
265                                 if (nts->stack) MEM_freeN(nts->stack);
266                         BLI_freelistN(&exec->threadstack[a]);
267                 }
268                 
269                 MEM_freeN(exec->threadstack);
270                 exec->threadstack = NULL;
271         }
272         
273         ntree_exec_end(exec);
274 }
275
276 void ntreeShaderEndExecTree(bNodeTreeExec *exec)
277 {
278         if (exec) {
279                 /* exec may get freed, so assign ntree */
280                 bNodeTree *ntree = exec->nodetree;
281                 ntreeShaderEndExecTree_internal(exec);
282                 
283                 /* XXX clear nodetree backpointer to exec data, same problem as noted in ntreeBeginExecTree */
284                 ntree->execdata = NULL;
285         }
286 }
287
288 /* only for Blender internal */
289 bool ntreeShaderExecTree(bNodeTree *ntree, ShadeInput *shi, ShadeResult *shr)
290 {
291         ShaderCallData scd;
292         /**
293          * \note: preserve material from ShadeInput for material id, nodetree execs change it
294          * fix for bug "[#28012] Mat ID messy with shader nodes"
295          */
296         Material *mat = shi->mat;
297         bNodeThreadStack *nts = NULL;
298         bNodeTreeExec *exec = ntree->execdata;
299         int compat;
300         
301         /* convert caller data to struct */
302         scd.shi = shi;
303         scd.shr = shr;
304         
305         /* each material node has own local shaderesult, with optional copying */
306         memset(shr, 0, sizeof(ShadeResult));
307         
308         /* ensure execdata is only initialized once */
309         if (!exec) {
310                 BLI_lock_thread(LOCK_NODES);
311                 if (!ntree->execdata)
312                         ntree->execdata = ntreeShaderBeginExecTree(ntree);
313                 BLI_unlock_thread(LOCK_NODES);
314
315                 exec = ntree->execdata;
316         }
317         
318         nts = ntreeGetThreadStack(exec, shi->thread);
319         compat = ntreeExecThreadNodes(exec, nts, &scd, shi->thread);
320         ntreeReleaseThreadStack(nts);
321         
322         // \note: set material back to preserved material
323         shi->mat = mat;
324                 
325         /* better not allow negative for now */
326         if (shr->combined[0] < 0.0f) shr->combined[0] = 0.0f;
327         if (shr->combined[1] < 0.0f) shr->combined[1] = 0.0f;
328         if (shr->combined[2] < 0.0f) shr->combined[2] = 0.0f;
329         
330         /* if compat is zero, it has been using non-compatible nodes */
331         return compat;
332 }