← Back to branch summary

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

« back to all changes in this revision

Viewing changes to intern/cycles/kernel/kernel_shader.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/kernel_shader.h
26
26
 *
27
27
 */
28
28
 
29
 
#ifdef __OSL__
30
 
 
31
 
#include "osl_shader.h"
32
 
 
33
 
#else
34
 
 
35
 
#include "svm/bsdf.h"
36
 
#include "svm/emissive.h"
37
 
#include "svm/volume.h"
38
 
#include "svm/svm_bsdf.h"
 
29
#include "closure/bsdf_util.h"
 
30
#include "closure/bsdf.h"
 
31
#include "closure/emissive.h"
 
32
#include "closure/volume.h"
 
33
 
39
34
#include "svm/svm.h"
40
35
 
41
 
#endif
42
 
 
43
36
CCL_NAMESPACE_BEGIN
44
37
 
45
38
/* ShaderData setup from incoming ray */
46
39
 
47
 
__device_inline void shader_setup_from_ray(KernelGlobals *kg, ShaderData *sd,
 
40
#ifdef __OBJECT_MOTION__
 
41
__device_noinline void shader_setup_object_transforms(KernelGlobals *kg, ShaderData *sd, float time)
 
42
{
 
43
        /* note that this is a separate non-inlined function to work around crash
 
44
         * on CUDA sm 2.0, otherwise kernel execution crashes (compiler bug?) */
 
45
        if(sd->flag & SD_OBJECT_MOTION) {
 
46
                sd->ob_tfm = object_fetch_transform_motion(kg, sd->object, time);
 
47
                sd->ob_itfm= transform_quick_inverse(sd->ob_tfm);
 
48
        }
 
49
        else {
 
50
                sd->ob_tfm = object_fetch_transform(kg, sd->object, OBJECT_TRANSFORM);
 
51
                sd->ob_itfm = object_fetch_transform(kg, sd->object, OBJECT_INVERSE_TRANSFORM);
 
52
        }
 
53
}
 
54
#endif
 
55
 
 
56
__device_noinline void shader_setup_from_ray(KernelGlobals *kg, ShaderData *sd,
48
57
        const Intersection *isect, const Ray *ray)
49
58
{
50
 
        /* fetch triangle data */
51
 
        int prim = kernel_tex_fetch(__prim_index, isect->prim);
52
 
        float4 Ns = kernel_tex_fetch(__tri_normal, prim);
53
 
        float3 Ng = make_float3(Ns.x, Ns.y, Ns.z);
54
 
        int shader = __float_as_int(Ns.w);
55
 
 
56
 
        /* vectors */
57
 
        sd->P = bvh_triangle_refine(kg, isect, ray);
58
 
        sd->Ng = Ng;
59
 
        sd->N = Ng;
 
59
#ifdef __INSTANCING__
 
60
        sd->object = (isect->object == ~0)? kernel_tex_fetch(__prim_object, isect->prim): isect->object;
 
61
#endif
 
62
 
 
63
        sd->flag = kernel_tex_fetch(__object_flag, sd->object);
 
64
 
 
65
        /* matrices and time */
 
66
#ifdef __OBJECT_MOTION__
 
67
        shader_setup_object_transforms(kg, sd, ray->time);
 
68
        sd->time = ray->time;
 
69
#endif
 
70
 
 
71
        sd->prim = kernel_tex_fetch(__prim_index, isect->prim);
 
72
        sd->ray_length = isect->t;
 
73
 
 
74
#ifdef __HAIR__
 
75
        if(kernel_tex_fetch(__prim_segment, isect->prim) != ~0) {
 
76
                /* Strand Shader setting*/
 
77
                float4 curvedata = kernel_tex_fetch(__curves, sd->prim);
 
78
 
 
79
                sd->shader = __float_as_int(curvedata.z);
 
80
                sd->segment = isect->segment;
 
81
 
 
82
                float tcorr = isect->t;
 
83
                if(kernel_data.curve_kernel_data.curveflags & CURVE_KN_POSTINTERSECTCORRECTION) {
 
84
                        tcorr = (isect->u < 0)? tcorr + sqrtf(isect->v) : tcorr - sqrtf(isect->v);
 
85
                        sd->ray_length = tcorr;
 
86
                }
 
87
 
 
88
                sd->P = bvh_curve_refine(kg, sd, isect, ray, tcorr);
 
89
        }
 
90
        else {
 
91
#endif
 
92
                /* fetch triangle data */
 
93
                float4 Ns = kernel_tex_fetch(__tri_normal, sd->prim);
 
94
                float3 Ng = make_float3(Ns.x, Ns.y, Ns.z);
 
95
                sd->shader = __float_as_int(Ns.w);
 
96
 
 
97
#ifdef __HAIR__
 
98
                sd->segment = ~0;
 
99
#endif
 
100
 
 
101
#ifdef __UV__
 
102
                sd->u = isect->u;
 
103
                sd->v = isect->v;
 
104
#endif
 
105
 
 
106
                /* vectors */
 
107
                sd->P = bvh_triangle_refine(kg, sd, isect, ray);
 
108
                sd->Ng = Ng;
 
109
                sd->N = Ng;
 
110
                
 
111
                /* smooth normal */
 
112
                if(sd->shader & SHADER_SMOOTH_NORMAL)
 
113
                        sd->N = triangle_smooth_normal(kg, sd->prim, sd->u, sd->v);
 
114
 
 
115
#ifdef __DPDU__
 
116
                /* dPdu/dPdv */
 
117
                triangle_dPdudv(kg, &sd->dPdu, &sd->dPdv, sd->prim);
 
118
#endif
 
119
 
 
120
#ifdef __HAIR__
 
121
        }
 
122
#endif
 
123
 
60
124
        sd->I = -ray->D;
61
 
        sd->shader = shader;
62
 
 
63
 
        /* triangle */
64
 
#ifdef __INSTANCING__
65
 
        sd->object = isect->object;
66
 
#endif
67
 
        sd->prim = prim;
68
 
#ifdef __UV__
69
 
        sd->u = isect->u;
70
 
        sd->v = isect->v;
71
 
#endif
72
 
 
73
 
        /* smooth normal */
74
 
        if(sd->shader & SHADER_SMOOTH_NORMAL)
75
 
                sd->N = triangle_smooth_normal(kg, sd->prim, sd->u, sd->v);
76
 
 
77
 
        sd->flag = kernel_tex_fetch(__shader_flag, (sd->shader & SHADER_MASK)*2);
78
 
 
79
 
#ifdef __DPDU__
80
 
        /* dPdu/dPdv */
81
 
        triangle_dPdudv(kg, &sd->dPdu, &sd->dPdv, sd->prim);
82
 
#endif
83
 
 
84
 
#ifdef __INSTANCING__
85
 
        if(sd->object != ~0) {
 
125
 
 
126
        sd->flag |= kernel_tex_fetch(__shader_flag, (sd->shader & SHADER_MASK)*2);
 
127
 
 
128
#ifdef __INSTANCING__
 
129
        if(isect->object != ~0) {
86
130
                /* instance transform */
87
 
                object_normal_transform(kg, sd->object, &sd->N);
88
 
                object_normal_transform(kg, sd->object, &sd->Ng);
 
131
                object_normal_transform(kg, sd, &sd->N);
 
132
                object_normal_transform(kg, sd, &sd->Ng);
89
133
#ifdef __DPDU__
90
 
                object_dir_transform(kg, sd->object, &sd->dPdu);
91
 
                object_dir_transform(kg, sd->object, &sd->dPdv);
 
134
                object_dir_transform(kg, sd, &sd->dPdu);
 
135
                object_dir_transform(kg, sd, &sd->dPdv);
92
136
#endif
93
 
        }
94
 
        else {
95
 
                /* non-instanced object index */
96
 
                sd->object = kernel_tex_fetch(__prim_object, isect->prim);
97
137
        }
98
138
#endif
99
139
 
120
160
 
121
161
/* ShaderData setup from position sampled on mesh */
122
162
 
123
 
__device void shader_setup_from_sample(KernelGlobals *kg, ShaderData *sd,
 
163
__device_noinline void shader_setup_from_sample(KernelGlobals *kg, ShaderData *sd,
124
164
        const float3 P, const float3 Ng, const float3 I,
125
 
        int shader, int object, int prim,  float u, float v)
 
165
        int shader, int object, int prim, float u, float v, float t, float time, int segment = ~0)
126
166
{
127
167
        /* vectors */
128
168
        sd->P = P;
130
170
        sd->Ng = Ng;
131
171
        sd->I = I;
132
172
        sd->shader = shader;
 
173
#ifdef __HAIR__
 
174
        sd->segment = segment;
 
175
#endif
133
176
 
134
177
        /* primitive */
135
178
#ifdef __INSTANCING__
136
179
        sd->object = object;
137
180
#endif
 
181
        /* currently no access to bvh prim index for strand sd->prim - this will cause errors with needs fixing*/
138
182
        sd->prim = prim;
139
183
#ifdef __UV__
140
184
        sd->u = u;
141
185
        sd->v = v;
142
186
#endif
 
187
        sd->ray_length = t;
143
188
 
144
189
        /* detect instancing, for non-instanced the object index is -object-1 */
145
190
#ifdef __INSTANCING__
155
200
        }
156
201
#endif
157
202
 
 
203
        sd->flag = kernel_tex_fetch(__shader_flag, (sd->shader & SHADER_MASK)*2);
 
204
        if(sd->object != -1) {
 
205
                sd->flag |= kernel_tex_fetch(__object_flag, sd->object);
 
206
 
 
207
#ifdef __OBJECT_MOTION__
 
208
                shader_setup_object_transforms(kg, sd, time);
 
209
        }
 
210
 
 
211
        sd->time = time;
 
212
#else
 
213
        }
 
214
#endif
 
215
 
158
216
        /* smooth normal */
 
217
#ifdef __HAIR__
 
218
        if(sd->shader & SHADER_SMOOTH_NORMAL && sd->segment == ~0) {
 
219
                sd->N = triangle_smooth_normal(kg, sd->prim, sd->u, sd->v);
 
220
#else
159
221
        if(sd->shader & SHADER_SMOOTH_NORMAL) {
160
222
                sd->N = triangle_smooth_normal(kg, sd->prim, sd->u, sd->v);
 
223
#endif
161
224
 
162
225
#ifdef __INSTANCING__
163
226
                if(instanced)
164
 
                        object_normal_transform(kg, sd->object, &sd->N);
 
227
                        object_normal_transform(kg, sd, &sd->N);
165
228
#endif
166
229
        }
167
230
 
168
 
        sd->flag = kernel_tex_fetch(__shader_flag, (sd->shader & SHADER_MASK)*2);
169
 
 
170
231
#ifdef __DPDU__
171
232
        /* dPdu/dPdv */
 
233
#ifdef __HAIR__
 
234
        if(sd->prim == ~0 || sd->segment != ~0) {
 
235
                sd->dPdu = make_float3(0.0f, 0.0f, 0.0f);
 
236
                sd->dPdv = make_float3(0.0f, 0.0f, 0.0f);
 
237
        }
 
238
#else
172
239
        if(sd->prim == ~0) {
173
240
                sd->dPdu = make_float3(0.0f, 0.0f, 0.0f);
174
241
                sd->dPdv = make_float3(0.0f, 0.0f, 0.0f);
175
242
        }
 
243
#endif
176
244
        else {
177
245
                triangle_dPdudv(kg, &sd->dPdu, &sd->dPdv, sd->prim);
178
246
 
179
247
#ifdef __INSTANCING__
180
248
                if(instanced) {
181
 
                        object_dir_transform(kg, sd->object, &sd->dPdu);
182
 
                        object_dir_transform(kg, sd->object, &sd->dPdv);
 
249
                        object_dir_transform(kg, sd, &sd->dPdu);
 
250
                        object_dir_transform(kg, sd, &sd->dPdv);
183
251
                }
184
252
#endif
185
253
        }
215
283
 
216
284
/* ShaderData setup for displacement */
217
285
 
218
 
__device void shader_setup_from_displace(KernelGlobals *kg, ShaderData *sd,
 
286
__device_noinline void shader_setup_from_displace(KernelGlobals *kg, ShaderData *sd,
219
287
        int object, int prim, float u, float v)
220
288
{
 
289
        /* Note: no OSLShader::init call here, this is done in shader_setup_from_sample! */
 
290
 
221
291
        float3 P, Ng, I = make_float3(0.0f, 0.0f, 0.0f);
222
292
        int shader;
223
293
 
229
299
 
230
300
        /* watch out: no instance transform currently */
231
301
 
232
 
        shader_setup_from_sample(kg, sd, P, Ng, I, shader, object, prim, u, v);
 
302
        shader_setup_from_sample(kg, sd, P, Ng, I, shader, object, prim, u, v, 0.0f, TIME_INVALID);
233
303
}
234
304
 
235
305
/* ShaderData setup from ray into background */
243
313
        sd->I = -sd->P;
244
314
        sd->shader = kernel_data.background.shader;
245
315
        sd->flag = kernel_tex_fetch(__shader_flag, (sd->shader & SHADER_MASK)*2);
 
316
#ifdef __OBJECT_MOTION__
 
317
        sd->time = ray->time;
 
318
#endif
 
319
        sd->ray_length = 0.0f;
246
320
 
247
321
#ifdef __INSTANCING__
248
322
        sd->object = ~0;
249
323
#endif
250
324
        sd->prim = ~0;
 
325
#ifdef __HAIR__
 
326
        sd->segment = ~0;
 
327
#endif
251
328
#ifdef __UV__
252
329
        sd->u = 0.0f;
253
330
        sd->v = 0.0f;
274
351
 
275
352
#ifdef __MULTI_CLOSURE__
276
353
 
277
 
__device_inline void _shader_bsdf_multi_eval(const ShaderData *sd, const float3 omega_in, float *pdf,
278
 
        int skip_bsdf, BsdfEval *bsdf_eval, float sum_pdf, float sum_sample_weight)
 
354
__device_inline void _shader_bsdf_multi_eval(KernelGlobals *kg, const ShaderData *sd, const float3 omega_in, float *pdf,
 
355
        int skip_bsdf, BsdfEval *result_eval, float sum_pdf, float sum_sample_weight)
279
356
{
280
357
        for(int i = 0; i< sd->num_closure; i++) {
281
358
                if(i == skip_bsdf)
285
362
 
286
363
                if(CLOSURE_IS_BSDF(sc->type)) {
287
364
                        float bsdf_pdf = 0.0f;
288
 
#ifdef __OSL__
289
 
                        float3 eval = OSLShader::bsdf_eval(sd, sc, omega_in, bsdf_pdf);
290
 
#else
291
 
                        float3 eval = svm_bsdf_eval(sd, sc, omega_in, &bsdf_pdf);
292
 
#endif
 
365
                        float3 eval = bsdf_eval(kg, sd, sc, omega_in, &bsdf_pdf);
293
366
 
294
367
                        if(bsdf_pdf != 0.0f) {
295
 
                                bsdf_eval_accum(bsdf_eval, sc->type, eval*sc->weight);
 
368
                                bsdf_eval_accum(result_eval, sc->type, eval*sc->weight);
296
369
                                sum_pdf += bsdf_pdf*sc->sample_weight;
297
370
                        }
298
371
 
311
384
#ifdef __MULTI_CLOSURE__
312
385
        bsdf_eval_init(eval, NBUILTIN_CLOSURES, make_float3(0.0f, 0.0f, 0.0f), kernel_data.film.use_light_pass);
313
386
 
314
 
        return _shader_bsdf_multi_eval(sd, omega_in, pdf, -1, eval, 0.0f, 0.0f);
 
387
        return _shader_bsdf_multi_eval(kg, sd, omega_in, pdf, -1, eval, 0.0f, 0.0f);
315
388
#else
316
389
        const ShaderClosure *sc = &sd->closure;
317
390
 
318
391
        *pdf = 0.0f;
319
 
        *eval = svm_bsdf_eval(sd, sc, omega_in, pdf)*sc->weight;
 
392
        *eval = bsdf_eval(kg, sd, sc, omega_in, pdf)*sc->weight;
320
393
#endif
321
394
}
322
395
 
363
436
        float3 eval;
364
437
 
365
438
        *pdf = 0.0f;
366
 
#ifdef __OSL__
367
 
        label = OSLShader::bsdf_sample(sd, sc, randu, randv, eval, *omega_in, *domega_in, *pdf);
368
 
#else
369
 
        label = svm_bsdf_sample(sd, sc, randu, randv, &eval, omega_in, domega_in, pdf);
370
 
#endif
 
439
        label = bsdf_sample(kg, sd, sc, randu, randv, &eval, omega_in, domega_in, pdf);
 
440
 
371
441
        if(*pdf != 0.0f) {
372
442
                bsdf_eval_init(bsdf_eval, sc->type, eval*sc->weight, kernel_data.film.use_light_pass);
373
443
 
374
444
                if(sd->num_closure > 1) {
375
445
                        float sweight = sc->sample_weight;
376
 
                        _shader_bsdf_multi_eval(sd, *omega_in, pdf, sampled, bsdf_eval, *pdf*sweight, sweight);
 
446
                        _shader_bsdf_multi_eval(kg, sd, *omega_in, pdf, sampled, bsdf_eval, *pdf*sweight, sweight);
377
447
                }
378
448
        }
379
449
 
381
451
#else
382
452
        /* sample the single closure that we picked */
383
453
        *pdf = 0.0f;
384
 
        int label = svm_bsdf_sample(sd, &sd->closure, randu, randv, bsdf_eval, omega_in, domega_in, pdf);
 
454
        int label = bsdf_sample(kg, sd, &sd->closure, randu, randv, bsdf_eval, omega_in, domega_in, pdf);
385
455
        *bsdf_eval *= sd->closure.weight;
386
456
        return label;
387
457
#endif
388
458
}
389
459
 
 
460
__device int shader_bsdf_sample_closure(KernelGlobals *kg, const ShaderData *sd,
 
461
        const ShaderClosure *sc, float randu, float randv, BsdfEval *bsdf_eval,
 
462
        float3 *omega_in, differential3 *domega_in, float *pdf)
 
463
{
 
464
        int label;
 
465
        float3 eval;
 
466
 
 
467
        *pdf = 0.0f;
 
468
        label = bsdf_sample(kg, sd, sc, randu, randv, &eval, omega_in, domega_in, pdf);
 
469
 
 
470
        if(*pdf != 0.0f)
 
471
                bsdf_eval_init(bsdf_eval, sc->type, eval*sc->weight, kernel_data.film.use_light_pass);
 
472
 
 
473
        return label;
 
474
}
 
475
 
390
476
__device void shader_bsdf_blur(KernelGlobals *kg, ShaderData *sd, float roughness)
391
477
{
392
 
#ifndef __OSL__
393
478
#ifdef __MULTI_CLOSURE__
394
479
        for(int i = 0; i< sd->num_closure; i++) {
395
480
                ShaderClosure *sc = &sd->closure[i];
396
481
 
397
482
                if(CLOSURE_IS_BSDF(sc->type))
398
 
                        svm_bsdf_blur(sc, roughness);
 
483
                        bsdf_blur(kg, sc, roughness);
399
484
        }
400
485
#else
401
 
        svm_bsdf_blur(&sd->closure, roughness);
402
 
#endif
 
486
        bsdf_blur(kg, &sd->closure, roughness);
403
487
#endif
404
488
}
405
489
 
487
571
#endif
488
572
}
489
573
 
 
574
__device float3 shader_bsdf_ao(KernelGlobals *kg, ShaderData *sd, float ao_factor, float3 *N)
 
575
{
 
576
#ifdef __MULTI_CLOSURE__
 
577
        float3 eval = make_float3(0.0f, 0.0f, 0.0f);
 
578
 
 
579
        *N = make_float3(0.0f, 0.0f, 0.0f);
 
580
 
 
581
        for(int i = 0; i< sd->num_closure; i++) {
 
582
                ShaderClosure *sc = &sd->closure[i];
 
583
 
 
584
                if(CLOSURE_IS_BSDF_DIFFUSE(sc->type)) {
 
585
                        eval += sc->weight*ao_factor;
 
586
                        *N += sc->N*average(sc->weight);
 
587
                }
 
588
                if(CLOSURE_IS_AMBIENT_OCCLUSION(sc->type)) {
 
589
                        eval += sc->weight;
 
590
                        *N += sd->N*average(sc->weight);
 
591
                }
 
592
        }
 
593
 
 
594
        if(is_zero(*N))
 
595
                *N = sd->N;
 
596
        else
 
597
                *N = normalize(*N);
 
598
 
 
599
        return eval;
 
600
#else
 
601
        *N = sd->N;
 
602
 
 
603
        if(CLOSURE_IS_BSDF_DIFFUSE(sd->closure.type))
 
604
                return sd->closure.weight*ao_factor;
 
605
        else if(CLOSURE_IS_AMBIENT_OCCLUSION(sd->closure.type))
 
606
                return sd->closure.weight;
 
607
        else
 
608
                return make_float3(0.0f, 0.0f, 0.0f);
 
609
#endif
 
610
}
 
611
 
490
612
/* Emission */
491
613
 
 
614
__device float3 emissive_eval(KernelGlobals *kg, ShaderData *sd, ShaderClosure *sc)
 
615
{
 
616
#ifdef __OSL__
 
617
        if(kg->osl && sc->prim)
 
618
                return OSLShader::emissive_eval(sd, sc);
 
619
#endif
 
620
 
 
621
        return emissive_simple_eval(sd->Ng, sd->I);
 
622
}
 
623
 
492
624
__device float3 shader_emissive_eval(KernelGlobals *kg, ShaderData *sd)
493
625
{
494
626
        float3 eval;
498
630
        for(int i = 0; i < sd->num_closure; i++) {
499
631
                ShaderClosure *sc = &sd->closure[i];
500
632
 
501
 
                if(CLOSURE_IS_EMISSION(sc->type)) {
502
 
#ifdef __OSL__
503
 
                        eval += OSLShader::emissive_eval(sd)*sc->weight;
504
 
#else
505
 
                        eval += svm_emissive_eval(sd, sc)*sc->weight;
506
 
#endif
507
 
                }
 
633
                if(CLOSURE_IS_EMISSION(sc->type))
 
634
                        eval += emissive_eval(kg, sd, sc)*sc->weight;
508
635
        }
509
636
#else
510
 
        eval = svm_emissive_eval(sd, &sd->closure)*sd->closure.weight;
 
637
        eval = emissive_eval(kg, sd, &sd->closure)*sd->closure.weight;
511
638
#endif
512
639
 
513
640
        return eval;
539
666
/* Surface Evaluation */
540
667
 
541
668
__device void shader_eval_surface(KernelGlobals *kg, ShaderData *sd,
542
 
        float randb, int path_flag)
 
669
        float randb, int path_flag, ShaderContext ctx)
543
670
{
544
671
#ifdef __OSL__
545
 
        OSLShader::eval_surface(kg, sd, randb, path_flag);
546
 
#else
547
 
 
 
672
        if (kg->osl)
 
673
                OSLShader::eval_surface(kg, sd, randb, path_flag, ctx);
 
674
        else
 
675
#endif
 
676
        {
548
677
#ifdef __SVM__
549
 
        svm_eval_nodes(kg, sd, SHADER_TYPE_SURFACE, randb, path_flag);
 
678
                svm_eval_nodes(kg, sd, SHADER_TYPE_SURFACE, randb, path_flag);
550
679
#else
551
 
        bsdf_diffuse_setup(sd, &sd->closure);
552
 
        sd->closure.weight = make_float3(0.8f, 0.8f, 0.8f);
553
 
#endif
554
 
 
555
 
#endif
 
680
                bsdf_diffuse_setup(&sd->closure);
 
681
                sd->closure.weight = make_float3(0.8f, 0.8f, 0.8f);
 
682
#endif
 
683
        }
556
684
}
557
685
 
558
686
/* Background Evaluation */
559
687
 
560
 
__device float3 shader_eval_background(KernelGlobals *kg, ShaderData *sd, int path_flag)
 
688
__device float3 shader_eval_background(KernelGlobals *kg, ShaderData *sd, int path_flag, ShaderContext ctx)
561
689
{
562
690
#ifdef __OSL__
563
 
        return OSLShader::eval_background(kg, sd, path_flag);
564
 
#else
 
691
        if (kg->osl)
 
692
                return OSLShader::eval_background(kg, sd, path_flag, ctx);
 
693
        else
 
694
#endif
565
695
 
 
696
        {
566
697
#ifdef __SVM__
567
 
        svm_eval_nodes(kg, sd, SHADER_TYPE_SURFACE, 0.0f, path_flag);
 
698
                svm_eval_nodes(kg, sd, SHADER_TYPE_SURFACE, 0.0f, path_flag);
568
699
 
569
700
#ifdef __MULTI_CLOSURE__
570
 
        float3 eval = make_float3(0.0f, 0.0f, 0.0f);
571
 
 
572
 
        for(int i = 0; i< sd->num_closure; i++) {
573
 
                const ShaderClosure *sc = &sd->closure[i];
574
 
 
575
 
                if(CLOSURE_IS_BACKGROUND(sc->type))
576
 
                        eval += sc->weight;
 
701
                float3 eval = make_float3(0.0f, 0.0f, 0.0f);
 
702
 
 
703
                for(int i = 0; i< sd->num_closure; i++) {
 
704
                        const ShaderClosure *sc = &sd->closure[i];
 
705
 
 
706
                        if(CLOSURE_IS_BACKGROUND(sc->type))
 
707
                                eval += sc->weight;
 
708
                }
 
709
 
 
710
                return eval;
 
711
#else
 
712
                if(sd->closure.type == CLOSURE_BACKGROUND_ID)
 
713
                        return sd->closure.weight;
 
714
                else
 
715
                        return make_float3(0.0f, 0.0f, 0.0f);
 
716
#endif
 
717
 
 
718
#else
 
719
                return make_float3(0.8f, 0.8f, 0.8f);
 
720
#endif
577
721
        }
578
 
 
579
 
        return eval;
580
 
#else
581
 
        if(sd->closure.type == CLOSURE_BACKGROUND_ID)
582
 
                return sd->closure.weight;
583
 
        else
584
 
                return make_float3(0.0f, 0.0f, 0.0f);
585
 
#endif
586
 
 
587
 
#else
588
 
        return make_float3(0.8f, 0.8f, 0.8f);
589
 
#endif
590
 
 
591
 
#endif
592
722
}
593
723
 
594
724
/* Volume */
602
732
        for(int i = 0; i< sd->num_closure; i++) {
603
733
                const ShaderClosure *sc = &sd->closure[i];
604
734
 
605
 
                if(CLOSURE_IS_VOLUME(sc->type)) {
606
 
#ifdef __OSL__
607
 
                        eval += OSLShader::volume_eval_phase(sd, omega_in, omega_out);
608
 
#else
609
 
                        eval += volume_eval_phase(sd, sc, omega_in, omega_out);
610
 
#endif
611
 
                }
 
735
                if(CLOSURE_IS_VOLUME(sc->type))
 
736
                        eval += volume_eval_phase(kg, sc, omega_in, omega_out);
612
737
        }
613
738
 
614
739
        return eval;
615
740
#else
616
 
        return volume_eval_phase(sd, &sd->closure, omega_in, omega_out);
 
741
        return volume_eval_phase(kg, &sd->closure, omega_in, omega_out);
617
742
#endif
618
743
}
619
744
 
620
745
/* Volume Evaluation */
621
746
 
622
747
__device void shader_eval_volume(KernelGlobals *kg, ShaderData *sd,
623
 
        float randb, int path_flag)
 
748
        float randb, int path_flag, ShaderContext ctx)
624
749
{
625
750
#ifdef __SVM__
626
751
#ifdef __OSL__
627
 
        OSLShader::eval_volume(kg, sd, randb, path_flag);
628
 
#else
629
 
        svm_eval_nodes(kg, sd, SHADER_TYPE_VOLUME, randb, path_flag);
 
752
        if (kg->osl)
 
753
                OSLShader::eval_volume(kg, sd, randb, path_flag, ctx);
 
754
        else
630
755
#endif
 
756
                svm_eval_nodes(kg, sd, SHADER_TYPE_VOLUME, randb, path_flag);
631
757
#endif
632
758
}
633
759
 
634
760
/* Displacement Evaluation */
635
761
 
636
 
__device void shader_eval_displacement(KernelGlobals *kg, ShaderData *sd)
 
762
__device void shader_eval_displacement(KernelGlobals *kg, ShaderData *sd, ShaderContext ctx)
637
763
{
638
764
        /* this will modify sd->P */
639
765
#ifdef __SVM__
640
766
#ifdef __OSL__
641
 
        OSLShader::eval_displacement(kg, sd);
642
 
#else
643
 
        svm_eval_nodes(kg, sd, SHADER_TYPE_DISPLACEMENT, 0.0f, 0);
 
767
        if (kg->osl)
 
768
                OSLShader::eval_displacement(kg, sd, ctx);
 
769
        else
644
770
#endif
 
771
                svm_eval_nodes(kg, sd, SHADER_TYPE_DISPLACEMENT, 0.0f, 0);
645
772
#endif
646
773
}
647
774
 
651
778
__device bool shader_transparent_shadow(KernelGlobals *kg, Intersection *isect)
652
779
{
653
780
        int prim = kernel_tex_fetch(__prim_index, isect->prim);
654
 
        float4 Ns = kernel_tex_fetch(__tri_normal, prim);
655
 
        int shader = __float_as_int(Ns.w);
 
781
        int shader = 0;
 
782
 
 
783
#ifdef __HAIR__
 
784
        if(kernel_tex_fetch(__prim_segment, isect->prim) == ~0) {
 
785
#endif
 
786
                float4 Ns = kernel_tex_fetch(__tri_normal, prim);
 
787
                shader = __float_as_int(Ns.w);
 
788
#ifdef __HAIR__
 
789
        }
 
790
        else {
 
791
                float4 str = kernel_tex_fetch(__curves, prim);
 
792
                shader = __float_as_int(str.z);
 
793
        }
 
794
#endif
656
795
        int flag = kernel_tex_fetch(__shader_flag, (shader & SHADER_MASK)*2);
657
796
 
658
797
        return (flag & SD_HAS_SURFACE_TRANSPARENT) != 0;
659
798
}
660
799
#endif
661
800
 
662
 
__device int shader_pass_id(KernelGlobals *kg, ShaderData *sd)
 
801
/* Merging */
 
802
 
 
803
#ifdef __NON_PROGRESSIVE__
 
804
__device void shader_merge_closures(KernelGlobals *kg, ShaderData *sd)
663
805
{
664
 
        return kernel_tex_fetch(__shader_flag, (sd->shader & SHADER_MASK)*2 + 1);
 
806
        /* merge identical closures, better when we sample a single closure at a time */
 
807
        for(int i = 0; i < sd->num_closure; i++) {
 
808
                ShaderClosure *sci = &sd->closure[i];
 
809
 
 
810
                for(int j = i + 1; j < sd->num_closure; j++) {
 
811
                        ShaderClosure *scj = &sd->closure[j];
 
812
 
 
813
#ifdef __OSL__
 
814
                        if(!sci->prim && sci->type == scj->type && sci->data0 == scj->data0 && sci->data1 == scj->data1) {
 
815
#else
 
816
                        if(sci->type == scj->type && sci->data0 == scj->data0 && sci->data1 == scj->data1) {
 
817
#endif
 
818
                                sci->weight += scj->weight;
 
819
                                sci->sample_weight += scj->sample_weight;
 
820
 
 
821
                                int size = sd->num_closure - (j+1);
 
822
                                if(size > 0)
 
823
                                        memmove(scj, scj+1, size*sizeof(ShaderClosure));
 
824
 
 
825
                                sd->num_closure--;
 
826
                        }
 
827
                }
 
828
        }
665
829
}
 
830
#endif
666
831
 
667
832
/* Free ShaderData */
668
833
 
669
834
__device void shader_release(KernelGlobals *kg, ShaderData *sd)
670
835
{
671
 
#ifdef __OSL__
672
 
        OSLShader::release(kg, sd);
673
 
#endif
 
836
        /* nothing to do currently */
674
837
}
675
838
 
676
839
CCL_NAMESPACE_END