Cycles: ambient occlusion support, with AO factor and distance, and a render pass.
[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 #define __PASSES__
74 #define __BACKGROUND_MIS__
75 #define __AO__
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         PASS_AO = 262144
178 } PassType;
179
180 #define PASS_ALL (~0)
181
182 #ifdef __PASSES__
183
184 typedef float3 PathThroughput;
185
186 typedef struct PathRadiance {
187         int use_light_pass;
188
189         float3 emission;
190         float3 background;
191         float3 ao;
192
193         float3 indirect;
194         float3 direct_throughput;
195         float3 direct_emission;
196
197         float3 color_diffuse;
198         float3 color_glossy;
199         float3 color_transmission;
200
201         float3 direct_diffuse;
202         float3 direct_glossy;
203         float3 direct_transmission;
204
205         float3 indirect_diffuse;
206         float3 indirect_glossy;
207         float3 indirect_transmission;
208 } PathRadiance;
209
210 typedef struct BsdfEval {
211         int use_light_pass;
212
213         float3 diffuse;
214         float3 glossy;
215         float3 transmission;
216         float3 transparent;
217 } BsdfEval;
218
219 #else
220
221 typedef float3 PathThroughput;
222 typedef float3 PathRadiance;
223 typedef float3 BsdfEval;
224
225 #endif
226
227 /* Shader Flag */
228
229 typedef enum ShaderFlag {
230         SHADER_SMOOTH_NORMAL = (1 << 31),
231         SHADER_CAST_SHADOW = (1 << 30),
232         SHADER_AREA_LIGHT = (1 << 29),
233
234         SHADER_MASK = ~(SHADER_SMOOTH_NORMAL|SHADER_CAST_SHADOW|SHADER_AREA_LIGHT)
235 } ShaderFlag;
236
237 /* Light Type */
238
239 typedef enum LightType {
240         LIGHT_POINT,
241         LIGHT_DISTANT,
242         LIGHT_BACKGROUND,
243         LIGHT_AREA,
244         LIGHT_AO
245 } LightType;
246
247 /* Camera Type */
248
249 enum CameraType {
250         CAMERA_PERSPECTIVE,
251         CAMERA_ORTHOGRAPHIC,
252         CAMERA_ENVIRONMENT
253 };
254
255 /* Differential */
256
257 typedef struct differential3 {
258         float3 dx;
259         float3 dy;
260 } differential3;
261
262 typedef struct differential {
263         float dx;
264         float dy;
265 } differential;
266
267 /* Ray */
268
269 typedef struct Ray {
270         float3 P;
271         float3 D;
272         float t;
273
274 #ifdef __RAY_DIFFERENTIALS__
275         differential3 dP;
276         differential3 dD;
277 #endif
278 } Ray;
279
280 /* Intersection */
281
282 typedef struct Intersection {
283         float t, u, v;
284         int prim;
285         int object;
286 } Intersection;
287
288 /* Attributes */
289
290 typedef enum AttributeElement {
291         ATTR_ELEMENT_FACE,
292         ATTR_ELEMENT_VERTEX,
293         ATTR_ELEMENT_CORNER,
294         ATTR_ELEMENT_VALUE,
295         ATTR_ELEMENT_NONE
296 } AttributeElement;
297
298 /* Closure data */
299
300 #define MAX_CLOSURE 8
301
302 typedef struct ShaderClosure {
303         ClosureType type;
304         float3 weight;
305
306 #ifdef __MULTI_CLOSURE__
307         float sample_weight;
308 #endif
309
310 #ifdef __OSL__
311         void *prim;
312 #else
313         float data0;
314         float data1;
315 #endif
316
317 } ShaderClosure;
318
319 /* Shader Data
320  *
321  * Main shader state at a point on the surface or in a volume. All coordinates
322  * are in world space. */
323
324 enum ShaderDataFlag {
325         /* runtime flags */
326         SD_BACKFACING = 1,              /* backside of surface? */
327         SD_EMISSION = 2,                /* have emissive closure? */
328         SD_BSDF = 4,                    /* have bsdf closure? */
329         SD_BSDF_HAS_EVAL = 8,   /* have non-singular bsdf closure? */
330         SD_BSDF_GLOSSY = 16,    /* have glossy bsdf */
331         SD_HOLDOUT = 32,                /* have holdout closure? */
332         SD_VOLUME = 64,                 /* have volume closure? */
333
334         /* shader flags */
335         SD_SAMPLE_AS_LIGHT = 128,                       /* direct light sample */
336         SD_HAS_SURFACE_TRANSPARENT = 256,       /* has surface transparency */
337         SD_HAS_VOLUME = 512,                            /* has volume shader */
338         SD_HOMOGENEOUS_VOLUME = 1024            /* has homogeneous volume */
339 };
340
341 typedef struct ShaderData {
342         /* position */
343         float3 P;
344         /* smooth normal for shading */
345         float3 N;
346         /* true geometric normal */
347         float3 Ng;
348         /* view/incoming direction */
349         float3 I;
350         /* shader id */
351         int shader;     
352         /* booleans describing shader, see ShaderDataFlag */
353         int flag;
354
355         /* primitive id if there is one, ~0 otherwise */
356         int prim;
357         /* parametric coordinates
358          * - barycentric weights for triangles */
359         float u, v;
360         /* object id if there is one, ~0 otherwise */
361         int object;
362
363 #ifdef __RAY_DIFFERENTIALS__
364         /* differential of P. these are orthogonal to Ng, not N */
365         differential3 dP;
366         /* differential of I */
367         differential3 dI;
368         /* differential of u, v */
369         differential du;
370         differential dv;
371 #endif
372 #ifdef __DPDU__
373         /* differential of P w.r.t. parametric coordinates. note that dPdu is
374          * not readily suitable as a tangent for shading on triangles. */
375         float3 dPdu, dPdv;
376 #endif
377
378 #ifdef __MULTI_CLOSURE__
379         /* Closure data, we store a fixed array of closures */
380         ShaderClosure closure[MAX_CLOSURE];
381         int num_closure;
382         float randb_closure;
383 #else
384         /* Closure data, with a single sampled closure for low memory usage */
385         ShaderClosure closure;
386 #endif
387
388 #ifdef __OSL__
389         /* OSL context */
390         void *osl_ctx;
391 #endif
392 } ShaderData;
393
394 /* Constrant Kernel Data
395  *
396  * These structs are passed from CPU to various devices, and the struct layout
397  * must match exactly. Structs are padded to ensure 16 byte alignment, and we
398  * do not use float3 because its size may not be the same on all devices. */
399
400 typedef struct KernelCamera {
401         /* type */
402         int type;
403         int pad1, pad2, pad3;
404
405         /* matrices */
406         Transform cameratoworld;
407         Transform rastertocamera;
408
409         /* differentials */
410         float4 dx;
411         float4 dy;
412
413         /* depth of field */
414         float aperturesize;
415         float blades;
416         float bladesrotation;
417         float focaldistance;
418
419         /* motion blur */
420         float shutteropen;
421         float shutterclose;
422
423         /* clipping */
424         float nearclip;
425         float cliplength;
426
427         /* more matrices */
428         Transform screentoworld;
429         Transform rastertoworld;
430         Transform ndctoworld;
431         Transform worldtoscreen;
432         Transform worldtoraster;
433         Transform worldtondc;
434         Transform worldtocamera;
435 } KernelCamera;
436
437 typedef struct KernelFilm {
438         float exposure;
439         int pass_flag;
440         int pass_stride;
441         int use_light_pass;
442
443         int pass_combined;
444         int pass_depth;
445         int pass_normal;
446         int pass_pad;
447
448         int pass_uv;
449         int pass_object_id;
450         int pass_material_id;
451         int pass_diffuse_color;
452
453         int pass_glossy_color;
454         int pass_transmission_color;
455         int pass_diffuse_indirect;
456         int pass_glossy_indirect;
457
458         int pass_transmission_indirect;
459         int pass_diffuse_direct;
460         int pass_glossy_direct;
461         int pass_transmission_direct;
462
463         int pass_emission;
464         int pass_background;
465         int pass_ao;
466         int pass_pad2;
467 } KernelFilm;
468
469 typedef struct KernelBackground {
470         /* only shader index */
471         int shader;
472         int transparent;
473
474         /* ambient occlusion */
475         float ao_factor;
476         float ao_distance;
477 } KernelBackground;
478
479 typedef struct KernelSunSky {
480         /* sun direction in spherical and cartesian */
481         float theta, phi, pad3, pad4;
482
483         /* perez function parameters */
484         float zenith_Y, zenith_x, zenith_y, pad2;
485         float perez_Y[5], perez_x[5], perez_y[5];
486         float pad5;
487 } KernelSunSky;
488
489 typedef struct KernelIntegrator {
490         /* emission */
491         int use_direct_light;
492         int use_ambient_occlusion;
493         int num_distribution;
494         int num_all_lights;
495         float pdf_triangles;
496         float pdf_lights;
497         int pdf_background_res;
498
499         /* bounces */
500         int min_bounce;
501         int max_bounce;
502
503         int max_diffuse_bounce;
504         int max_glossy_bounce;
505         int max_transmission_bounce;
506
507         /* transparent */
508         int transparent_min_bounce;
509         int transparent_max_bounce;
510         int transparent_shadows;
511
512         /* caustics */
513         int no_caustics;
514
515         /* seed */
516         int seed;
517
518         /* render layer */
519         int layer_flag;
520         int pad1, pad2;
521 } KernelIntegrator;
522
523 typedef struct KernelBVH {
524         /* root node */
525         int root;
526         int attributes_map_stride;
527         int pad1, pad2;
528 } KernelBVH;
529
530 typedef struct KernelData {
531         KernelCamera cam;
532         KernelFilm film;
533         KernelBackground background;
534         KernelSunSky sunsky;
535         KernelIntegrator integrator;
536         KernelBVH bvh;
537 } KernelData;
538
539 CCL_NAMESPACE_END
540
541 #endif /*  __KERNEL_TYPES_H__ */
542