← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to source/blender/nodes/shader/node_shader_util.c

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/nodes/shader/node_shader_util.c
46
46
                if (ns->sockettype==SOCK_FLOAT)
47
47
                        *in= *from;
48
48
                else 
49
 
                        *in= 0.333333f*(from[0]+from[1]+from[2]);
 
49
                        *in= (from[0]+from[1]+from[2]) / 3.0f;
50
50
        }
51
51
        else if (type_in==SOCK_VECTOR) {
52
52
                if (ns->sockettype==SOCK_FLOAT) {
53
 
                        in[0]= from[0];
54
 
                        in[1]= from[0];
55
 
                        in[2]= from[0];
 
53
                        in[0] = from[0];
 
54
                        in[1] = from[0];
 
55
                        in[2] = from[0];
56
56
                }
57
57
                else {
58
58
                        copy_v3_v3(in, from);
63
63
                        copy_v4_v4(in, from);
64
64
                }
65
65
                else if (ns->sockettype==SOCK_FLOAT) {
66
 
                        in[0]= from[0];
67
 
                        in[1]= from[0];
68
 
                        in[2]= from[0];
69
 
                        in[3]= 1.0f;
 
66
                        in[0] = from[0];
 
67
                        in[1] = from[0];
 
68
                        in[2] = from[0];
 
69
                        in[3] = 1.0f;
70
70
                }
71
71
                else {
72
72
                        copy_v3_v3(in, from);
73
 
                        in[3]= 1.0f;
 
73
                        in[3] = 1.0f;
74
74
                }
75
75
        }
76
76
}
88
88
                if (node->type==SH_NODE_TEXTURE) {
89
89
                        if ((r_mode & R_OSA) && node->id) {
90
90
                                Tex *tex= (Tex *)node->id;
91
 
                                if (ELEM3(tex->type, TEX_IMAGE, TEX_PLUGIN, TEX_ENVMAP)) {
 
91
                                if (ELEM(tex->type, TEX_IMAGE, TEX_ENVMAP)) {
92
92
                                        *texco |= TEXCO_OSA|NEED_UV;
93
93
                                }
94
94
                        }
101
101
                        /* note; sockets always exist for the given type! */
102
102
                        for (a=0, sock= node->outputs.first; sock; sock= sock->next, a++) {
103
103
                                if (sock->flag & SOCK_IN_USE) {
104
 
                                        switch(a) {
 
104
                                        switch (a) {
105
105
                                                case GEOM_OUT_GLOB: 
106
106
                                                        *texco |= TEXCO_GLOB|NEED_UV; break;
107
107
                                                case GEOM_OUT_VIEW: 
137
137
                for (a=0, sock= node->inputs.first; sock; sock= sock->next, a++) {
138
138
                        if (!nodeSocketIsHidden(sock)) {
139
139
                                if (copyto) {
140
 
                                        switch(a) {
 
140
                                        switch (a) {
141
141
                                                case MAT_IN_COLOR:
142
 
                                                        copy_v3_v3(&ma->r, ((bNodeSocketValueRGBA*)sock->default_value)->value); break;
 
142
                                                        copy_v3_v3(&ma->r, ((bNodeSocketValueRGBA *)sock->default_value)->value); break;
143
143
                                                case MAT_IN_SPEC:
144
 
                                                        copy_v3_v3(&ma->specr, ((bNodeSocketValueRGBA*)sock->default_value)->value); break;
 
144
                                                        copy_v3_v3(&ma->specr, ((bNodeSocketValueRGBA *)sock->default_value)->value); break;
145
145
                                                case MAT_IN_REFL:
146
 
                                                        ma->ref= ((bNodeSocketValueFloat*)sock->default_value)->value; break;
 
146
                                                        ma->ref= ((bNodeSocketValueFloat *)sock->default_value)->value; break;
147
147
                                                case MAT_IN_MIR:
148
 
                                                        copy_v3_v3(&ma->mirr, ((bNodeSocketValueRGBA*)sock->default_value)->value); break;
 
148
                                                        copy_v3_v3(&ma->mirr, ((bNodeSocketValueRGBA *)sock->default_value)->value); break;
149
149
                                                case MAT_IN_AMB:
150
 
                                                        ma->amb= ((bNodeSocketValueFloat*)sock->default_value)->value; break;
 
150
                                                        ma->amb = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
151
151
                                                case MAT_IN_EMIT:
152
 
                                                        ma->emit= ((bNodeSocketValueFloat*)sock->default_value)->value; break;
 
152
                                                        ma->emit = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
153
153
                                                case MAT_IN_SPECTRA:
154
 
                                                        ma->spectra= ((bNodeSocketValueFloat*)sock->default_value)->value; break;
 
154
                                                        ma->spectra = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
155
155
                                                case MAT_IN_RAY_MIRROR:
156
 
                                                        ma->ray_mirror= ((bNodeSocketValueFloat*)sock->default_value)->value; break;
 
156
                                                        ma->ray_mirror = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
157
157
                                                case MAT_IN_ALPHA:
158
 
                                                        ma->alpha= ((bNodeSocketValueFloat*)sock->default_value)->value; break;
 
158
                                                        ma->alpha = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
159
159
                                                case MAT_IN_TRANSLUCENCY:
160
 
                                                        ma->translucency= ((bNodeSocketValueFloat*)sock->default_value)->value; break;
 
160
                                                        ma->translucency = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
161
161
                                        }
162
162
                                }
163
163
                                else {
164
 
                                        switch(a) {
 
164
                                        switch (a) {
165
165
                                                case MAT_IN_COLOR:
166
 
                                                        copy_v3_v3(((bNodeSocketValueRGBA*)sock->default_value)->value, &ma->r); break;
 
166
                                                        copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->r); break;
167
167
                                                case MAT_IN_SPEC:
168
 
                                                        copy_v3_v3(((bNodeSocketValueRGBA*)sock->default_value)->value, &ma->specr); break;
 
168
                                                        copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->specr); break;
169
169
                                                case MAT_IN_REFL:
170
 
                                                        ((bNodeSocketValueFloat*)sock->default_value)->value= ma->ref; break;
 
170
                                                        ((bNodeSocketValueFloat *)sock->default_value)->value= ma->ref; break;
171
171
                                                case MAT_IN_MIR:
172
 
                                                        copy_v3_v3(((bNodeSocketValueRGBA*)sock->default_value)->value, &ma->mirr); break;
 
172
                                                        copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->mirr); break;
173
173
                                                case MAT_IN_AMB:
174
 
                                                        ((bNodeSocketValueFloat*)sock->default_value)->value= ma->amb; break;
 
174
                                                        ((bNodeSocketValueFloat *)sock->default_value)->value = ma->amb; break;
175
175
                                                case MAT_IN_EMIT:
176
 
                                                        ((bNodeSocketValueFloat*)sock->default_value)->value= ma->emit; break;
 
176
                                                        ((bNodeSocketValueFloat *)sock->default_value)->value = ma->emit; break;
177
177
                                                case MAT_IN_SPECTRA:
178
 
                                                        ((bNodeSocketValueFloat*)sock->default_value)->value= ma->spectra; break;
 
178
                                                        ((bNodeSocketValueFloat *)sock->default_value)->value = ma->spectra; break;
179
179
                                                case MAT_IN_RAY_MIRROR:
180
 
                                                        ((bNodeSocketValueFloat*)sock->default_value)->value= ma->ray_mirror; break;
 
180
                                                        ((bNodeSocketValueFloat *)sock->default_value)->value = ma->ray_mirror; break;
181
181
                                                case MAT_IN_ALPHA:
182
 
                                                        ((bNodeSocketValueFloat*)sock->default_value)->value= ma->alpha; break;
 
182
                                                        ((bNodeSocketValueFloat *)sock->default_value)->value = ma->alpha; break;
183
183
                                                case MAT_IN_TRANSLUCENCY:
184
 
                                                        ((bNodeSocketValueFloat*)sock->default_value)->value= ma->translucency; break;
 
184
                                                        ((bNodeSocketValueFloat *)sock->default_value)->value = ma->translucency; break;
185
185
                                        }
186
186
                                }
187
187
                        }
211
211
        
212
212
        gs->name = "";
213
213
        gs->hasinput= ns->hasinput && ns->data;
214
 
        /* XXX Commented out the ns->data check here, as it seems it's not alwas set,
 
214
        /* XXX Commented out the ns->data check here, as it seems it's not always set,
215
215
         *     even though there *is* a valid connection/output... But that might need
216
216
         *     further investigation.
217
217
         */
221
221
 
222
222
void node_data_from_gpu_stack(bNodeStack *ns, GPUNodeStack *gs)
223
223
{
 
224
        copy_v4_v4(ns->vec, gs->vec);
224
225
        ns->data= gs->link;
225
226
        ns->sockettype= gs->sockettype;
226
227
}
259
260
                        break;
260
261
 
261
262
        if (node)
262
 
                ntree= (bNodeTree*)node->id;
 
263
                ntree = (bNodeTree *)node->id;
263
264
 
264
265
        for (node= ntree->nodes.first; node; node= node->next)
265
266
                if (node->flag & NODE_ACTIVE_TEXTURE)
276
277
        bNodeStack *stack;
277
278
        bNodeStack *nsin[MAX_SOCKET];   /* arbitrary... watch this */
278
279
        bNodeStack *nsout[MAX_SOCKET];  /* arbitrary... watch this */
279
 
        GPUNodeStack gpuin[MAX_SOCKET+1], gpuout[MAX_SOCKET+1];
280
 
        int doit;
 
280
        GPUNodeStack gpuin[MAX_SOCKET + 1], gpuout[MAX_SOCKET + 1];
 
281
        int do_it;
281
282
 
282
283
        stack= exec->stack;
283
284
 
284
285
        for (n=0, nodeexec= exec->nodeexec; n < exec->totnodes; ++n, ++nodeexec) {
285
286
                node = nodeexec->node;
286
287
                
287
 
                doit = 0;
 
288
                do_it = FALSE;
288
289
                /* for groups, only execute outputs for edited group */
289
290
                if (node->typeinfo->nclass==NODE_CLASS_OUTPUT) {
290
291
                        if (do_outputs && (node->flag & NODE_DO_OUTPUT))
291
 
                                doit = 1;
 
292
                                do_it = TRUE;
292
293
                }
293
294
                else
294
 
                        doit = 1;
 
295
                        do_it = TRUE;
295
296
 
296
 
                if (doit) {
 
297
                if (do_it) {
297
298
                        if (node->typeinfo->gpufunc) {
298
299
                                node_get_stack(node, stack, nsin, nsout);
299
300
                                gpu_stack_from_data_list(gpuin, &node->inputs, nsin);
320
321
        float domax= (texmap->flag & TEXMAP_CLIP_MAX) != 0;
321
322
 
322
323
        if (domin || domax || !(texmap->flag & TEXMAP_UNIT_MATRIX)) {
323
 
                GPUNodeLink *tmat = GPU_uniform((float*)texmap->mat);
 
324
                GPUNodeLink *tmat = GPU_uniform((float *)texmap->mat);
324
325
                GPUNodeLink *tmin = GPU_uniform(texmap->min);
325
326
                GPUNodeLink *tmax = GPU_uniform(texmap->max);
326
327
                GPUNodeLink *tdomin = GPU_uniform(&domin);