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