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