← Back to branch summary

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

« back to all changes in this revision

Viewing changes to intern/cycles/kernel/svm/svm.h

  • 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:
intern/cycles/kernel/svm/svm.h
82
82
        stack[a] = f;
83
83
}
84
84
 
 
85
__device_inline int stack_load_int(float *stack, uint a)
 
86
{
 
87
        kernel_assert(a < SVM_STACK_SIZE);
 
88
 
 
89
        return __float_as_int(stack[a]);
 
90
}
 
91
 
 
92
__device_inline float stack_load_int_default(float *stack, uint a, uint value)
 
93
{
 
94
        return (a == (uint)SVM_STACK_INVALID)? (int)value: stack_load_int(stack, a);
 
95
}
 
96
 
 
97
__device_inline void stack_store_int(float *stack, uint a, int i)
 
98
{
 
99
        kernel_assert(a < SVM_STACK_SIZE);
 
100
 
 
101
        stack[a] = __int_as_float(i);
 
102
}
 
103
 
85
104
__device_inline bool stack_valid(uint a)
86
105
{
87
106
        return a != (uint)SVM_STACK_INVALID;
154
173
#include "svm_value.h"
155
174
#include "svm_voronoi.h"
156
175
#include "svm_checker.h"
 
176
#include "svm_brick.h"
157
177
 
158
178
CCL_NAMESPACE_BEGIN
159
179
 
184
204
                                break;
185
205
                        }
186
206
                        case NODE_CLOSURE_BSDF:
187
 
                                svm_node_closure_bsdf(kg, sd, stack, node, randb, path_flag);
 
207
                                svm_node_closure_bsdf(kg, sd, stack, node, randb, path_flag, &offset);
188
208
                                break;
189
209
                        case NODE_CLOSURE_EMISSION:
190
210
                                svm_node_closure_emission(sd, stack, node);
195
215
                        case NODE_CLOSURE_HOLDOUT:
196
216
                                svm_node_closure_holdout(sd, stack, node);
197
217
                                break;
 
218
                        case NODE_CLOSURE_AMBIENT_OCCLUSION:
 
219
                                svm_node_closure_ambient_occlusion(sd, stack, node);
 
220
                                break;
198
221
                        case NODE_CLOSURE_VOLUME:
199
222
                                svm_node_closure_volume(kg, sd, stack, node, path_flag);
200
223
                                break;
216
239
                        case NODE_JUMP:
217
240
                                offset = node.y;
218
241
                                break;
219
 
#ifdef __TEXTURES__
 
242
#ifdef __IMAGE_TEXTURES__
220
243
                        case NODE_TEX_IMAGE:
221
244
                                svm_node_tex_image(kg, sd, stack, node);
222
245
                                break;
 
246
                        case NODE_TEX_IMAGE_BOX:
 
247
                                svm_node_tex_image_box(kg, sd, stack, node);
 
248
                                break;
223
249
                        case NODE_TEX_ENVIRONMENT:
224
250
                                svm_node_tex_environment(kg, sd, stack, node);
225
251
                                break;
 
252
#endif
 
253
#ifdef __PROCEDURAL_TEXTURES__
226
254
                        case NODE_TEX_SKY:
227
255
                                svm_node_tex_sky(kg, sd, stack, node.y, node.z);
228
256
                                break;
247
275
                        case NODE_TEX_CHECKER:
248
276
                                svm_node_tex_checker(kg, sd, stack, node, &offset);
249
277
                                break;
 
278
                        case NODE_TEX_BRICK:
 
279
                                svm_node_tex_brick(kg, sd, stack, node, &offset);
 
280
                                break;
250
281
#endif
251
282
                        case NODE_CAMERA:
252
283
                                svm_node_camera(kg, sd, stack, node.y, node.z, node.w);
253
284
                                break;
254
285
                        case NODE_GEOMETRY:
255
 
                                svm_node_geometry(sd, stack, node.y, node.z);
 
286
                                svm_node_geometry(kg, sd, stack, node.y, node.z);
256
287
                                break;
 
288
#ifdef __EXTRA_NODES__
257
289
                        case NODE_GEOMETRY_BUMP_DX:
258
 
                                svm_node_geometry_bump_dx(sd, stack, node.y, node.z);
 
290
                                svm_node_geometry_bump_dx(kg, sd, stack, node.y, node.z);
259
291
                                break;
260
292
                        case NODE_GEOMETRY_BUMP_DY:
261
 
                                svm_node_geometry_bump_dy(sd, stack, node.y, node.z);
 
293
                                svm_node_geometry_bump_dy(kg, sd, stack, node.y, node.z);
262
294
                                break;
263
295
                        case NODE_LIGHT_PATH:
264
296
                                svm_node_light_path(sd, stack, node.y, node.z, path_flag);
265
297
                                break;
 
298
                        case NODE_OBJECT_INFO:
 
299
                                svm_node_object_info(kg, sd, stack, node.y, node.z);
 
300
                                break;
 
301
                        case NODE_PARTICLE_INFO:
 
302
                                svm_node_particle_info(kg, sd, stack, node.y, node.z);
 
303
                                break;
 
304
#ifdef __HAIR__
 
305
                        case NODE_HAIR_INFO:
 
306
                                svm_node_hair_info(kg, sd, stack, node.y, node.z);
 
307
                                break;
 
308
#endif
 
309
 
 
310
#endif
266
311
                        case NODE_CONVERT:
267
312
                                svm_node_convert(sd, stack, node.y, node.z, node.w);
268
313
                                break;
272
317
                        case NODE_VALUE_V:
273
318
                                svm_node_value_v(kg, sd, stack, node.y, &offset);
274
319
                                break;
 
320
#ifdef __EXTRA_NODES__
275
321
                        case NODE_INVERT:
276
322
                                svm_node_invert(sd, stack, node.y, node.z, node.w);
277
323
                                break;
293
339
                        case NODE_HSV:
294
340
                                svm_node_hsv(kg, sd, stack, node.y, node.z, node.w, &offset);
295
341
                                break;
 
342
#endif
296
343
                        case NODE_ATTR:
297
344
                                svm_node_attr(kg, sd, stack, node);
298
345
                                break;
 
346
#ifdef __EXTRA_NODES__
299
347
                        case NODE_ATTR_BUMP_DX:
300
348
                                svm_node_attr_bump_dx(kg, sd, stack, node);
301
349
                                break;
302
350
                        case NODE_ATTR_BUMP_DY:
303
351
                                svm_node_attr_bump_dy(kg, sd, stack, node);
304
352
                                break;
 
353
#endif
305
354
                        case NODE_FRESNEL:
306
355
                                svm_node_fresnel(sd, stack, node.y, node.z, node.w);
307
356
                                break;
308
357
                        case NODE_LAYER_WEIGHT:
309
358
                                svm_node_layer_weight(sd, stack, node);
310
359
                                break;
 
360
#ifdef __EXTRA_NODES__
311
361
                        case NODE_SET_DISPLACEMENT:
312
362
                                svm_node_set_displacement(sd, stack, node.y);
313
363
                                break;
314
364
                        case NODE_SET_BUMP:
315
 
                                svm_node_set_bump(sd, stack, node.y, node.z, node.w);
 
365
                                svm_node_set_bump(kg, sd, stack, node);
316
366
                                break;
317
367
                        case NODE_MATH:
318
368
                                svm_node_math(kg, sd, stack, node.y, node.z, node.w, &offset);
323
373
                        case NODE_NORMAL:
324
374
                                svm_node_normal(kg, sd, stack, node.y, node.z, node.w, &offset);
325
375
                                break;
 
376
#endif
326
377
                        case NODE_MAPPING:
327
378
                                svm_node_mapping(kg, sd, stack, node.y, node.z, &offset);
328
379
                                break;
 
380
                        case NODE_MIN_MAX:
 
381
                                svm_node_min_max(kg, sd, stack, node.y, node.z, &offset);
 
382
                                break;
329
383
                        case NODE_TEX_COORD:
330
384
                                svm_node_tex_coord(kg, sd, stack, node.y, node.z);
331
385
                                break;
 
386
#ifdef __EXTRA_NODES__
332
387
                        case NODE_TEX_COORD_BUMP_DX:
333
388
                                svm_node_tex_coord_bump_dx(kg, sd, stack, node.y, node.z);
334
389
                                break;
335
390
                        case NODE_TEX_COORD_BUMP_DY:
336
391
                                svm_node_tex_coord_bump_dy(kg, sd, stack, node.y, node.z);
337
392
                                break;
 
393
                        case NODE_CLOSURE_SET_NORMAL:
 
394
                                svm_node_set_normal(kg, sd, stack, node.y, node.z );
 
395
                                break;                  
 
396
#endif
338
397
                        case NODE_EMISSION_SET_WEIGHT_TOTAL:
339
398
                                svm_node_emission_set_weight_total(kg, sd, node.y, node.z, node.w);
340
399
                                break;
 
400
#ifdef __EXTRA_NODES__
341
401
                        case NODE_RGB_RAMP:
342
402
                                svm_node_rgb_ramp(kg, sd, stack, node, &offset);
343
403
                                break;
344
404
                        case NODE_RGB_CURVES:
345
405
                                svm_node_rgb_curves(kg, sd, stack, node, &offset);
346
406
                                break;
 
407
                        case NODE_VECTOR_CURVES:
 
408
                                svm_node_vector_curves(kg, sd, stack, node, &offset);
 
409
                                break;
 
410
                        case NODE_LIGHT_FALLOFF:
 
411
                                svm_node_light_falloff(sd, stack, node);
 
412
                                break;
 
413
#endif                  
 
414
#ifdef __ANISOTROPIC__
 
415
                        case NODE_TANGENT:
 
416
                                svm_node_tangent(kg, sd, stack, node);
 
417
                                break;
 
418
#endif                  
 
419
#ifdef __NORMAL_MAP__
 
420
                        case NODE_NORMAL_MAP:
 
421
                                svm_node_normal_map(kg, sd, stack, node);
 
422
                                break;
 
423
#endif                  
347
424
                        case NODE_END:
348
425
                        default:
349
426
#ifndef __MULTI_CLOSURE__