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