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