← Back to branch summary

~siretart/ubuntu/utopic/blender/libav10

« back to all changes in this revision

Viewing changes to source/blender/nodes/texture/node_texture_tree.c

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2012-07-23 08:54:18 UTC
  • mfrom: (14.2.16 sid)
  • mto: (14.2.19 sid)
  • mto: This revision was merged to the branch mainline in revision 42.
  • Revision ID: package-import@ubuntu.com-20120723085418-9foz30v6afaf5ffs
Tags: 2.63a-2
http://bugs.debian.org/658075
* debian/: Cycles support added (Closes: #658075)
  For now, this top feature has been enabled only
  on [any-amd64 any-i386] architectures because
  of OpenImageIO failing on all others
* debian/: scripts installation path changed
  from /usr/lib to /usr/share:
  + debian/patches/: patchset re-worked for path changing
  + debian/control: "Breaks" field added on yafaray-exporter

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
 
38
#include "BLI_listbase.h"
 
39
#include "BLI_threads.h"
 
40
#include "BLI_utildefines.h"
 
41
 
 
42
#include "BLF_translation.h"
 
43
 
 
44
#include "BKE_global.h"
 
45
#include "BKE_main.h"
 
46
#include "BKE_node.h"
 
47
 
 
48
#include "node_exec.h"
 
49
#include "node_util.h"
 
50
#include "NOD_texture.h"
 
51
#include "node_texture_util.h"
 
52
 
 
53
#include "RE_pipeline.h"
 
54
#include "RE_shader_ext.h"
 
55
 
 
56
 
 
57
static void foreach_nodetree(Main *main, void *calldata, bNodeTreeCallback func)
 
58
{
 
59
        Tex *tx;
 
60
        for (tx= main->tex.first; tx; tx= tx->id.next) {
 
61
                if (tx->nodetree) {
 
62
                        func(calldata, &tx->id, tx->nodetree);
 
63
                }
 
64
        }
 
65
}
 
66
 
 
67
static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCallback func)
 
68
{
 
69
        func(calldata, NODE_CLASS_INPUT, IFACE_("Input"));
 
70
        func(calldata, NODE_CLASS_OUTPUT, IFACE_("Output"));
 
71
        func(calldata, NODE_CLASS_OP_COLOR, IFACE_("Color"));
 
72
        func(calldata, NODE_CLASS_PATTERN, IFACE_("Patterns"));
 
73
        func(calldata, NODE_CLASS_TEXTURE, IFACE_("Textures"));
 
74
        func(calldata, NODE_CLASS_CONVERTOR, IFACE_("Convertor"));
 
75
        func(calldata, NODE_CLASS_DISTORT, IFACE_("Distort"));
 
76
        func(calldata, NODE_CLASS_GROUP, IFACE_("Group"));
 
77
        func(calldata, NODE_CLASS_LAYOUT, IFACE_("Layout"));
 
78
}
 
79
 
 
80
static void localize(bNodeTree *localtree, bNodeTree *UNUSED(ntree))
 
81
{
 
82
        bNode *node, *node_next;
 
83
        
 
84
        /* replace muted nodes by internal links */
 
85
        for (node= localtree->nodes.first; node; node= node_next) {
 
86
                node_next = node->next;
 
87
                
 
88
                if (node->flag & NODE_MUTED) {
 
89
                        nodeInternalRelink(localtree, node);
 
90
                        nodeFreeNode(localtree, node);
 
91
                }
 
92
        }
 
93
}
 
94
 
 
95
static void local_sync(bNodeTree *localtree, bNodeTree *ntree)
 
96
{
 
97
        bNode *lnode;
 
98
        
 
99
        /* copy over contents of previews */
 
100
        for (lnode= localtree->nodes.first; lnode; lnode= lnode->next) {
 
101
                if (ntreeNodeExists(ntree, lnode->new_node)) {
 
102
                        bNode *node= lnode->new_node;
 
103
                        
 
104
                        if (node->preview && node->preview->rect) {
 
105
                                if (lnode->preview && lnode->preview->rect) {
 
106
                                        int xsize= node->preview->xsize;
 
107
                                        int ysize= node->preview->ysize;
 
108
                                        memcpy(node->preview->rect, lnode->preview->rect, 4*xsize + xsize*ysize*sizeof(char)*4);
 
109
                                }
 
110
                        }
 
111
                }
 
112
        }
 
113
}
 
114
 
 
115
bNodeTreeType ntreeType_Texture = {
 
116
        /* type */                              NTREE_TEXTURE,
 
117
        /* id_name */                   "NTTexture Nodetree",
 
118
        
 
119
        /* node_types */                { NULL, NULL },
 
120
        
 
121
        /* free_cache */                        NULL,
 
122
        /* free_node_cache */           NULL,
 
123
        /* foreach_nodetree */  foreach_nodetree,
 
124
        /* foreach_nodeclass */ foreach_nodeclass,
 
125
        /* localize */                  localize,
 
126
        /* local_sync */                local_sync,
 
127
        /* local_merge */               NULL,
 
128
        /* update */                    NULL,
 
129
        /* update_node */               NULL,
 
130
        /* validate_link */             NULL,
 
131
        /* internal_connect */  node_internal_connect_default
 
132
};
 
133
 
 
134
int ntreeTexTagAnimated(bNodeTree *ntree)
 
135
{
 
136
        bNode *node;
 
137
        
 
138
        if (ntree==NULL) return 0;
 
139
        
 
140
        for (node= ntree->nodes.first; node; node= node->next) {
 
141
                if (node->type==TEX_NODE_CURVE_TIME) {
 
142
                        nodeUpdate(ntree, node);
 
143
                        return 1;
 
144
                }
 
145
                else if (node->type==NODE_GROUP) {
 
146
                        if ( ntreeTexTagAnimated((bNodeTree *)node->id) ) {
 
147
                                return 1;
 
148
                        }
 
149
                }
 
150
        }
 
151
        
 
152
        return 0;
 
153
}
 
154
 
 
155
/* XXX Group nodes must set use_tree_data to false, since their trees can be shared by multiple nodes.
 
156
 * If use_tree_data is true, the ntree->execdata pointer is checked to avoid multiple execution of top-level trees.
 
157
 */
 
158
bNodeTreeExec *ntreeTexBeginExecTree(bNodeTree *ntree, int use_tree_data)
 
159
{
 
160
        bNodeTreeExec *exec;
 
161
        bNode *node;
 
162
        
 
163
        if (use_tree_data) {
 
164
                /* XXX hack: prevent exec data from being generated twice.
 
165
                 * this should be handled by the renderer!
 
166
                 */
 
167
                if (ntree->execdata)
 
168
                        return ntree->execdata;
 
169
        }
 
170
        
 
171
        /* common base initialization */
 
172
        exec = ntree_exec_begin(ntree);
 
173
        
 
174
        /* allocate the thread stack listbase array */
 
175
        exec->threadstack= MEM_callocN(BLENDER_MAX_THREADS*sizeof(ListBase), "thread stack array");
 
176
        
 
177
        for (node= exec->nodetree->nodes.first; node; node= node->next)
 
178
                node->need_exec= 1;
 
179
        
 
180
        if (use_tree_data) {
 
181
                /* XXX this should not be necessary, but is still used for cmp/sha/tex nodes,
 
182
                 * which only store the ntree pointer. Should be fixed at some point!
 
183
                 */
 
184
                ntree->execdata = exec;
 
185
        }
 
186
        
 
187
        return exec;
 
188
}
 
189
 
 
190
/* free texture delegates */
 
191
static void tex_free_delegates(bNodeTreeExec *exec)
 
192
{
 
193
        bNodeThreadStack *nts;
 
194
        bNodeStack *ns;
 
195
        int th, a;
 
196
        
 
197
        for (th=0; th<BLENDER_MAX_THREADS; th++)
 
198
                for (nts=exec->threadstack[th].first; nts; nts=nts->next)
 
199
                        for (ns= nts->stack, a=0; a<exec->stacksize; a++, ns++)
 
200
                                if (ns->data && !ns->is_copy)
 
201
                                        MEM_freeN(ns->data);
 
202
}
 
203
 
 
204
/* XXX Group nodes must set use_tree_data to false, since their trees can be shared by multiple nodes.
 
205
 * If use_tree_data is true, the ntree->execdata pointer is checked to avoid multiple execution of top-level trees.
 
206
 */
 
207
void ntreeTexEndExecTree(bNodeTreeExec *exec, int use_tree_data)
 
208
{
 
209
        if (exec) {
 
210
                bNodeTree *ntree= exec->nodetree;
 
211
                bNodeThreadStack *nts;
 
212
                int a;
 
213
                
 
214
                if (exec->threadstack) {
 
215
                        tex_free_delegates(exec);
 
216
                        
 
217
                        for (a=0; a<BLENDER_MAX_THREADS; a++) {
 
218
                                for (nts=exec->threadstack[a].first; nts; nts=nts->next)
 
219
                                        if (nts->stack) MEM_freeN(nts->stack);
 
220
                                BLI_freelistN(&exec->threadstack[a]);
 
221
                        }
 
222
                        
 
223
                        MEM_freeN(exec->threadstack);
 
224
                        exec->threadstack= NULL;
 
225
                }
 
226
                
 
227
                ntree_exec_end(exec);
 
228
                
 
229
                if (use_tree_data) {
 
230
                        /* XXX clear nodetree backpointer to exec data, same problem as noted in ntreeBeginExecTree */
 
231
                        ntree->execdata = NULL;
 
232
                }
 
233
        }
 
234
}
 
235
 
 
236
int ntreeTexExecTree(
 
237
        bNodeTree *nodes,
 
238
        TexResult *texres,
 
239
        float *co,
 
240
        float *dxt, float *dyt,
 
241
        int osatex,
 
242
        short thread, 
 
243
        Tex *UNUSED(tex), 
 
244
        short which_output, 
 
245
        int cfra,
 
246
        int preview,
 
247
        ShadeInput *shi,
 
248
        MTex *mtex
 
249
) {
 
250
        TexCallData data;
 
251
        float *nor= texres->nor;
 
252
        int retval = TEX_INT;
 
253
        bNodeThreadStack *nts = NULL;
 
254
        bNodeTreeExec *exec= nodes->execdata;
 
255
 
 
256
        data.co = co;
 
257
        data.dxt = dxt;
 
258
        data.dyt = dyt;
 
259
        data.osatex = osatex;
 
260
        data.target = texres;
 
261
        data.do_preview = preview;
 
262
        data.thread = thread;
 
263
        data.which_output = which_output;
 
264
        data.cfra= cfra;
 
265
        data.mtex= mtex;
 
266
        data.shi= shi;
 
267
        
 
268
        /* ensure execdata is only initialized once */
 
269
        if (!exec) {
 
270
                BLI_lock_thread(LOCK_NODES);
 
271
                if (!nodes->execdata)
 
272
                        ntreeTexBeginExecTree(nodes, 1);
 
273
                BLI_unlock_thread(LOCK_NODES);
 
274
 
 
275
                exec= nodes->execdata;
 
276
        }
 
277
        
 
278
        nts= ntreeGetThreadStack(exec, thread);
 
279
        ntreeExecThreadNodes(exec, nts, &data, thread);
 
280
        ntreeReleaseThreadStack(nts);
 
281
 
 
282
        if (texres->nor) retval |= TEX_NOR;
 
283
        retval |= TEX_RGB;
 
284
        /* confusing stuff; the texture output node sets this to NULL to indicate no normal socket was set
 
285
           however, the texture code checks this for other reasons (namely, a normal is required for material) */
 
286
        texres->nor= nor;
 
287
 
 
288
        return retval;
 
289
}