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