Enable compilation of the SVM backend for Cycles even when OSL is enabled. The switch...
[blender.git] / intern / cycles / kernel / kernel_types.h
1 /*
2  * Copyright 2011, Blender Foundation.
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
19 #ifndef __KERNEL_TYPES_H__
20 #define __KERNEL_TYPES_H__
21
22 #include "kernel_math.h"
23 #include "svm/svm_types.h"
24
25 #ifndef __KERNEL_GPU__
26 #define __KERNEL_CPU__
27 #endif
28
29 CCL_NAMESPACE_BEGIN
30
31 /* constants */
32 #define OBJECT_SIZE             16
33 #define LIGHT_SIZE                      4
34 #define FILTER_TABLE_SIZE       256
35 #define RAMP_TABLE_SIZE         256
36 #define PARTICLE_SIZE           5
37 #define TIME_INVALID            FLT_MAX
38
39 /* device capabilities */
40 #ifdef __KERNEL_CPU__
41 #define __KERNEL_SHADING__
42 #define __KERNEL_ADV_SHADING__
43 #ifdef WITH_OSL
44 #define __OSL__
45 #endif
46 #define __NON_PROGRESSIVE__
47 #endif
48
49 #ifdef __KERNEL_CUDA__
50 #define __KERNEL_SHADING__
51 #if __CUDA_ARCH__ >= 200
52 #define __KERNEL_ADV_SHADING__
53 #endif
54 #endif
55
56 #ifdef __KERNEL_OPENCL__
57
58 #ifdef __KERNEL_OPENCL_NVIDIA__
59 #define __KERNEL_SHADING__
60 #define __MULTI_CLOSURE__
61 #endif
62
63 #ifdef __KERNEL_OPENCL_APPLE__
64 //#define __SVM__
65 //#define __EMISSION__
66 //#define __IMAGE_TEXTURES__
67 //#define __HOLDOUT__
68 //#define __PROCEDURAL_TEXTURES__
69 //#define __EXTRA_NODES__
70 #endif
71
72 #ifdef __KERNEL_OPENCL_AMD__
73 #define __SVM__
74 #define __EMISSION__
75 #define __IMAGE_TEXTURES__
76 #define __HOLDOUT__
77 #define __PROCEDURAL_TEXTURES__
78 #define __EXTRA_NODES__
79 #endif
80
81 #endif
82
83 /* kernel features */
84 #define __SOBOL__
85 #define __INSTANCING__
86 #define __DPDU__
87 #define __UV__
88 #define __BACKGROUND__
89 #define __CAUSTICS_TRICKS__
90 #define __VISIBILITY_FLAG__
91 #define __RAY_DIFFERENTIALS__
92 #define __CAMERA_CLIPPING__
93 #define __INTERSECTION_REFINE__
94 #define __CLAMP_SAMPLE__
95
96 #ifdef __KERNEL_SHADING__
97 #define __SVM__
98 #define __EMISSION__
99 #define __PROCEDURAL_TEXTURES__
100 #define __IMAGE_TEXTURES__
101 #define __EXTRA_NODES__
102 #define __HOLDOUT__
103 #endif
104
105 #ifdef __KERNEL_ADV_SHADING__
106 #define __MULTI_CLOSURE__
107 #define __TRANSPARENT_SHADOWS__
108 #define __PASSES__
109 #define __BACKGROUND_MIS__
110 #define __AO__
111 //#define __MOTION__
112 #endif
113
114 //#define __SOBOL_FULL_SCREEN__
115 //#define __QBVH__
116
117 /* Shader Evaluation */
118
119 enum ShaderEvalType {
120         SHADER_EVAL_DISPLACE,
121         SHADER_EVAL_BACKGROUND
122 };
123
124 /* Path Tracing
125  * note we need to keep the u/v pairs at even values */
126
127 enum PathTraceDimension {
128         PRNG_FILTER_U = 0,
129         PRNG_FILTER_V = 1,
130         PRNG_LENS_U = 2,
131         PRNG_LENS_V = 3,
132 #ifdef __MOTION__
133         PRNG_TIME = 4,
134         PRNG_UNUSED = 5,
135         PRNG_BASE_NUM = 6,
136 #else
137         PRNG_BASE_NUM = 4,
138 #endif
139
140         PRNG_BSDF_U = 0,
141         PRNG_BSDF_V = 1,
142         PRNG_BSDF = 2,
143         PRNG_LIGHT = 3,
144         PRNG_LIGHT_U = 4,
145         PRNG_LIGHT_V = 5,
146         PRNG_LIGHT_F = 6,
147         PRNG_TERMINATE = 7,
148         PRNG_BOUNCE_NUM = 8
149 };
150
151 /* these flag values correspond exactly to OSL defaults, so be careful not to
152  * change this, or if you do, set the "raytypes" shading system attribute with
153  * your own new ray types and bitflag values.
154  *
155  * for ray visibility tests in BVH traversal, the upper 20 bits are used for
156  * layer visibility tests. */
157
158 enum PathRayFlag {
159         PATH_RAY_CAMERA = 1,
160         PATH_RAY_REFLECT = 2,
161         PATH_RAY_TRANSMIT = 4,
162         PATH_RAY_DIFFUSE = 8,
163         PATH_RAY_GLOSSY = 16,
164         PATH_RAY_SINGULAR = 32,
165         PATH_RAY_TRANSPARENT = 64,
166
167         PATH_RAY_SHADOW_OPAQUE = 128,
168         PATH_RAY_SHADOW_TRANSPARENT = 256,
169         PATH_RAY_SHADOW = (PATH_RAY_SHADOW_OPAQUE|PATH_RAY_SHADOW_TRANSPARENT),
170
171         PATH_RAY_MIS_SKIP = 512,
172
173         PATH_RAY_ALL = (1|2|4|8|16|32|64|128|256|512),
174
175         /* this gives collisions with localview bits
176          * see: CYCLES_LOCAL_LAYER_HACK(), grr - Campbell */
177         PATH_RAY_LAYER_SHIFT = (32-20)
178 };
179
180 /* Closure Label */
181
182 typedef enum ClosureLabel {
183         LABEL_NONE = 0,
184         LABEL_CAMERA = 1,
185         LABEL_LIGHT = 2,
186         LABEL_BACKGROUND = 4,
187         LABEL_TRANSMIT = 8,
188         LABEL_REFLECT = 16,
189         LABEL_VOLUME = 32,
190         LABEL_OBJECT = 64,
191         LABEL_DIFFUSE = 128,
192         LABEL_GLOSSY = 256,
193         LABEL_SINGULAR = 512,
194         LABEL_TRANSPARENT = 1024,
195         LABEL_STOP = 2048
196 } ClosureLabel;
197
198 /* Render Passes */
199
200 typedef enum PassType {
201         PASS_NONE = 0,
202         PASS_COMBINED = 1,
203         PASS_DEPTH = 2,
204         PASS_NORMAL = 4,
205         PASS_UV = 8,
206         PASS_OBJECT_ID = 16,
207         PASS_MATERIAL_ID = 32,
208         PASS_DIFFUSE_COLOR = 64,
209         PASS_GLOSSY_COLOR = 128,
210         PASS_TRANSMISSION_COLOR = 256,
211         PASS_DIFFUSE_INDIRECT = 512,
212         PASS_GLOSSY_INDIRECT = 1024,
213         PASS_TRANSMISSION_INDIRECT = 2048,
214         PASS_DIFFUSE_DIRECT = 4096,
215         PASS_GLOSSY_DIRECT = 8192,
216         PASS_TRANSMISSION_DIRECT = 16384,
217         PASS_EMISSION = 32768,
218         PASS_BACKGROUND = 65536,
219         PASS_AO = 131072,
220         PASS_SHADOW = 262144,
221         PASS_MOTION = 524288,
222         PASS_MOTION_WEIGHT = 1048576
223 } PassType;
224
225 #define PASS_ALL (~0)
226
227 #ifdef __PASSES__
228
229 typedef float3 PathThroughput;
230
231 typedef struct PathRadiance {
232         int use_light_pass;
233
234         float3 emission;
235         float3 background;
236         float3 ao;
237
238         float3 indirect;
239         float3 direct_throughput;
240         float3 direct_emission;
241
242         float3 color_diffuse;
243         float3 color_glossy;
244         float3 color_transmission;
245
246         float3 direct_diffuse;
247         float3 direct_glossy;
248         float3 direct_transmission;
249
250         float3 indirect_diffuse;
251         float3 indirect_glossy;
252         float3 indirect_transmission;
253
254         float4 shadow;
255 } PathRadiance;
256
257 typedef struct BsdfEval {
258         int use_light_pass;
259
260         float3 diffuse;
261         float3 glossy;
262         float3 transmission;
263         float3 transparent;
264 } BsdfEval;
265
266 #else
267
268 typedef float3 PathThroughput;
269 typedef float3 PathRadiance;
270 typedef float3 BsdfEval;
271
272 #endif
273
274 /* Shader Flag */
275
276 typedef enum ShaderFlag {
277         SHADER_SMOOTH_NORMAL = (1 << 31),
278         SHADER_CAST_SHADOW = (1 << 30),
279         SHADER_AREA_LIGHT = (1 << 29),
280
281         SHADER_MASK = ~(SHADER_SMOOTH_NORMAL|SHADER_CAST_SHADOW|SHADER_AREA_LIGHT)
282 } ShaderFlag;
283
284 /* Light Type */
285
286 typedef enum LightType {
287         LIGHT_POINT,
288         LIGHT_DISTANT,
289         LIGHT_BACKGROUND,
290         LIGHT_AREA,
291         LIGHT_AO,
292         LIGHT_SPOT
293 } LightType;
294
295 /* Camera Type */
296
297 enum CameraType {
298         CAMERA_PERSPECTIVE,
299         CAMERA_ORTHOGRAPHIC,
300         CAMERA_PANORAMA
301 };
302
303 /* Panorama Type */
304
305 enum PanoramaType {
306         PANORAMA_EQUIRECTANGULAR,
307         PANORAMA_FISHEYE_EQUIDISTANT,
308         PANORAMA_FISHEYE_EQUISOLID
309 };
310
311 /* Differential */
312
313 typedef struct differential3 {
314         float3 dx;
315         float3 dy;
316 } differential3;
317
318 typedef struct differential {
319         float dx;
320         float dy;
321 } differential;
322
323 /* Ray */
324
325 typedef struct Ray {
326         float3 P;
327         float3 D;
328         float t;
329         float time;
330
331 #ifdef __RAY_DIFFERENTIALS__
332         differential3 dP;
333         differential3 dD;
334 #endif
335 } Ray;
336
337 /* Intersection */
338
339 typedef struct Intersection {
340         float t, u, v;
341         int prim;
342         int object;
343 } Intersection;
344
345 /* Attributes */
346
347 typedef enum AttributeElement {
348         ATTR_ELEMENT_FACE,
349         ATTR_ELEMENT_VERTEX,
350         ATTR_ELEMENT_CORNER,
351         ATTR_ELEMENT_VALUE,
352         ATTR_ELEMENT_NONE
353 } AttributeElement;
354
355 typedef enum AttributeStandard {
356         ATTR_STD_NONE = 0,
357         ATTR_STD_VERTEX_NORMAL,
358         ATTR_STD_FACE_NORMAL,
359         ATTR_STD_UV,
360         ATTR_STD_GENERATED,
361         ATTR_STD_POSITION_UNDEFORMED,
362         ATTR_STD_POSITION_UNDISPLACED,
363         ATTR_STD_MOTION_PRE,
364         ATTR_STD_MOTION_POST,
365         ATTR_STD_PARTICLE,
366         ATTR_STD_NUM,
367
368         ATTR_STD_NOT_FOUND = ~0
369 } AttributeStandard;
370
371 /* Closure data */
372
373 #define MAX_CLOSURE 8
374
375 typedef struct ShaderClosure {
376         ClosureType type;
377         float3 weight;
378
379 #ifdef __MULTI_CLOSURE__
380         float sample_weight;
381 #endif
382
383 #ifdef __OSL__
384         void *prim;
385 #endif
386         float data0;
387         float data1;
388
389 } ShaderClosure;
390
391 /* Shader Data
392  *
393  * Main shader state at a point on the surface or in a volume. All coordinates
394  * are in world space. */
395
396 enum ShaderDataFlag {
397         /* runtime flags */
398         SD_BACKFACING = 1,              /* backside of surface? */
399         SD_EMISSION = 2,                /* have emissive closure? */
400         SD_BSDF = 4,                    /* have bsdf closure? */
401         SD_BSDF_HAS_EVAL = 8,   /* have non-singular bsdf closure? */
402         SD_BSDF_GLOSSY = 16,    /* have glossy bsdf */
403         SD_HOLDOUT = 32,                /* have holdout closure? */
404         SD_VOLUME = 64,                 /* have volume closure? */
405
406         /* shader flags */
407         SD_SAMPLE_AS_LIGHT = 128,                       /* direct light sample */
408         SD_HAS_SURFACE_TRANSPARENT = 256,       /* has surface transparency */
409         SD_HAS_VOLUME = 512,                            /* has volume shader */
410         SD_HOMOGENEOUS_VOLUME = 1024,           /* has homogeneous volume */
411
412         /* object flags */
413         SD_HOLDOUT_MASK = 2048,                         /* holdout for camera rays */
414         SD_OBJECT_MOTION = 4096                         /* has object motion blur */
415 };
416
417 typedef struct ShaderData {
418         /* position */
419         float3 P;
420         /* smooth normal for shading */
421         float3 N;
422         /* true geometric normal */
423         float3 Ng;
424         /* view/incoming direction */
425         float3 I;
426         /* shader id */
427         int shader;     
428         /* booleans describing shader, see ShaderDataFlag */
429         int flag;
430
431         /* primitive id if there is one, ~0 otherwise */
432         int prim;
433         /* parametric coordinates
434          * - barycentric weights for triangles */
435         float u, v;
436         /* object id if there is one, ~0 otherwise */
437         int object;
438
439         /* motion blur sample time */
440         float time;
441         
442         /* length of the ray being shaded */
443         float ray_length;
444
445 #ifdef __MOTION__
446         /* object <-> world space transformations, cached to avoid
447          * re-interpolating them constantly for shading */
448         Transform ob_tfm;
449         Transform ob_itfm;
450 #endif
451
452 #ifdef __RAY_DIFFERENTIALS__
453         /* differential of P. these are orthogonal to Ng, not N */
454         differential3 dP;
455         /* differential of I */
456         differential3 dI;
457         /* differential of u, v */
458         differential du;
459         differential dv;
460 #endif
461 #ifdef __DPDU__
462         /* differential of P w.r.t. parametric coordinates. note that dPdu is
463          * not readily suitable as a tangent for shading on triangles. */
464         float3 dPdu, dPdv;
465 #endif
466
467 #ifdef __MULTI_CLOSURE__
468         /* Closure data, we store a fixed array of closures */
469         ShaderClosure closure[MAX_CLOSURE];
470         int num_closure;
471         float randb_closure;
472 #else
473         /* Closure data, with a single sampled closure for low memory usage */
474         ShaderClosure closure;
475 #endif
476
477 #ifdef __OSL__
478         /* OSL context */
479         void *osl_ctx;
480 #endif
481 } ShaderData;
482
483 /* Constrant Kernel Data
484  *
485  * These structs are passed from CPU to various devices, and the struct layout
486  * must match exactly. Structs are padded to ensure 16 byte alignment, and we
487  * do not use float3 because its size may not be the same on all devices. */
488
489 typedef struct KernelCamera {
490         /* type */
491         int type;
492
493         /* panorama */
494         int panorama_type;
495         float fisheye_fov;
496         float fisheye_lens;
497
498         /* matrices */
499         Transform cameratoworld;
500         Transform rastertocamera;
501
502         /* differentials */
503         float4 dx;
504         float4 dy;
505
506         /* depth of field */
507         float aperturesize;
508         float blades;
509         float bladesrotation;
510         float focaldistance;
511
512         /* motion blur */
513         float shuttertime;
514         int have_motion;
515
516         /* clipping */
517         float nearclip;
518         float cliplength;
519
520         /* sensor size */
521         float sensorwidth;
522         float sensorheight;
523
524         /* render size */
525         float width, height;
526
527         /* more matrices */
528         Transform screentoworld;
529         Transform rastertoworld;
530         Transform ndctoworld;
531         Transform worldtoscreen;
532         Transform worldtoraster;
533         Transform worldtondc;
534         Transform worldtocamera;
535
536         MotionTransform motion;
537 } KernelCamera;
538
539 typedef struct KernelFilm {
540         float exposure;
541         int pass_flag;
542         int pass_stride;
543         int use_light_pass;
544
545         int pass_combined;
546         int pass_depth;
547         int pass_normal;
548         int pass_motion;
549
550         int pass_motion_weight;
551         int pass_uv;
552         int pass_object_id;
553         int pass_material_id;
554
555         int pass_diffuse_color;
556         int pass_glossy_color;
557         int pass_transmission_color;
558         int pass_diffuse_indirect;
559
560         int pass_glossy_indirect;
561         int pass_transmission_indirect;
562         int pass_diffuse_direct;
563         int pass_glossy_direct;
564
565         int pass_transmission_direct;
566         int pass_emission;
567         int pass_background;
568         int pass_ao;
569
570         int pass_shadow;
571         int pass_pad1;
572         int pass_pad2;
573         int pass_pad3;
574 } KernelFilm;
575
576 typedef struct KernelBackground {
577         /* only shader index */
578         int shader;
579         int transparent;
580
581         /* ambient occlusion */
582         float ao_factor;
583         float ao_distance;
584 } KernelBackground;
585
586 typedef struct KernelSunSky {
587         /* sun direction in spherical and cartesian */
588         float theta, phi, pad3, pad4;
589
590         /* perez function parameters */
591         float zenith_Y, zenith_x, zenith_y, pad2;
592         float perez_Y[5], perez_x[5], perez_y[5];
593         float pad5;
594 } KernelSunSky;
595
596 typedef struct KernelIntegrator {
597         /* emission */
598         int use_direct_light;
599         int use_ambient_occlusion;
600         int num_distribution;
601         int num_all_lights;
602         float pdf_triangles;
603         float pdf_lights;
604         int pdf_background_res;
605
606         /* bounces */
607         int min_bounce;
608         int max_bounce;
609
610         int max_diffuse_bounce;
611         int max_glossy_bounce;
612         int max_transmission_bounce;
613
614         /* transparent */
615         int transparent_min_bounce;
616         int transparent_max_bounce;
617         int transparent_shadows;
618
619         /* caustics */
620         int no_caustics;
621         float filter_glossy;
622
623         /* seed */
624         int seed;
625
626         /* render layer */
627         int layer_flag;
628
629         /* clamp */
630         float sample_clamp;
631
632         /* non-progressive */
633         int progressive;
634         int diffuse_samples;
635         int glossy_samples;
636         int transmission_samples;
637         int ao_samples;
638         int mesh_light_samples;
639         int pad1, pad2;
640 } KernelIntegrator;
641
642 typedef struct KernelBVH {
643         /* root node */
644         int root;
645         int attributes_map_stride;
646         int pad1, pad2;
647 } KernelBVH;
648
649 typedef struct KernelData {
650         KernelCamera cam;
651         KernelFilm film;
652         KernelBackground background;
653         KernelSunSky sunsky;
654         KernelIntegrator integrator;
655         KernelBVH bvh;
656 } KernelData;
657
658 CCL_NAMESPACE_END
659
660 #endif /*  __KERNEL_TYPES_H__ */
661