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