Rename any instance of scene layer or render layer in code with view layer
[blender.git] / source / blender / render / intern / include / render_types.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
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  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * Contributor(s): (c) 2006 Blender Foundation, full refactor
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file blender/render/intern/include/render_types.h
27  *  \ingroup render
28  */
29
30
31 #ifndef __RENDER_TYPES_H__
32 #define __RENDER_TYPES_H__
33
34 /* ------------------------------------------------------------------------- */
35 /* exposed internal in render module only! */
36 /* ------------------------------------------------------------------------- */
37
38 #include "DNA_color_types.h"
39 #include "DNA_customdata_types.h"
40 #include "DNA_scene_types.h"
41 #include "DNA_world_types.h"
42 #include "DNA_object_types.h"
43 #include "DNA_vec_types.h"
44
45 #include "BLI_threads.h"
46
47 #include "BKE_main.h"
48
49 #include "RE_pipeline.h"
50 #include "RE_shader_ext.h"      /* TexResult, ShadeResult, ShadeInput */
51 #include "sunsky.h"
52
53 #include "BLI_sys_types.h" // for intptr_t support
54
55 struct EvaluationContext;
56 struct Object;
57 struct MemArena;
58 struct VertTableNode;
59 struct VlakTableNode;
60 struct GHash;
61 struct ObjectInstanceRen;
62 struct RayObject;
63 struct RayFace;
64 struct RenderEngine;
65 struct ReportList;
66 struct Main;
67 struct ImagePool;
68
69 #define TABLEINITSIZE 1024
70
71 typedef struct SampleTables {
72         float centLut[16];
73         float *fmask1[9], *fmask2[9];
74         char cmask[256], *centmask;
75         
76 } SampleTables;
77
78 typedef struct QMCSampler {
79         struct QMCSampler *next, *prev;
80         int type;
81         int tot;
82         int used;
83         double *samp2d;
84         double offs[BLENDER_MAX_THREADS][2];
85 } QMCSampler;
86
87 // #define SAMP_TYPE_JITTERED           0  // UNUSED
88 #define SAMP_TYPE_HALTON                1
89 #define SAMP_TYPE_HAMMERSLEY    2
90
91 /* this is handed over to threaded hiding/passes/shading engine */
92 typedef struct RenderPart {
93         struct RenderPart *next, *prev;
94         
95         RenderResult *result;                   /* result of part rendering */
96         ListBase fullresult;                    /* optional full sample buffers */
97         
98         int *recto;                                             /* object table for objects */
99         int *rectp;                                             /* polygon index table */
100         int *rectz;                                             /* zbuffer */
101         int *rectmask;                                  /* negative zmask */
102         intptr_t *rectdaps;                                     /* delta acum buffer for pixel structs */
103         int *rectbacko;                                 /* object table for backside sss */
104         int *rectbackp;                                 /* polygon index table for backside sss */
105         int *rectbackz;                                 /* zbuffer for backside sss */
106         intptr_t *rectall;                                      /* buffer for all faces for sss */
107
108         rcti disprect;                                  /* part coordinates within total picture */
109         int rectx, recty;                               /* the size */
110         int nr;                                                 /* nr is partnr */
111         short crop, status;                             /* crop is amount of pixels we crop, for filter */
112         short sample;                                   /* sample can be used by zbuffers */
113         short thread;                                   /* thread id */
114         
115         char *clipflag;                                 /* clipflags for part zbuffering */
116 } RenderPart;
117
118 enum {
119         PART_STATUS_NONE        = 0,
120         PART_STATUS_IN_PROGRESS = 1,
121         PART_STATUS_RENDERED    = 2,
122         PART_STATUS_MERGED      = 3
123 };
124
125 /* controls state of render, everything that's read-only during render stage */
126 struct Render {
127         struct Render *next, *prev;
128         char name[RE_MAXNAME];
129         int slot;
130         
131         /* state settings */
132         short flag, osa, ok, result_ok;
133         
134         /* due to performance issues, getting initialized from color management settings once on Render initialization */
135         bool scene_color_manage;
136         
137         /* result of rendering */
138         RenderResult *result;
139         /* if render with single-layer option, other rendered layers are stored here */
140         RenderResult *pushedresult;
141         /* a list of RenderResults, for fullsample */
142         ListBase fullresult;
143         /* read/write mutex, all internal code that writes to re->result must use a
144          * write lock, all external code must use a read lock. internal code is assumed
145          * to not conflict with writes, so no lock used for that */
146         ThreadRWMutex resultmutex;
147         
148         /* window size, display rect, viewplane */
149         int winx, winy;                 /* buffer width and height with percentage applied
150                                                          * without border & crop. convert to long before multiplying together to avoid overflow. */
151         rcti disprect;                  /* part within winx winy */
152         rctf viewplane;                 /* mapped on winx winy */
153         float viewdx, viewdy;   /* size of 1 pixel */
154         float clipcrop;                 /* 2 pixel boundary to prevent clip when filter used */
155         
156         /* final picture width and height (within disprect) */
157         int rectx, recty;
158         
159         /* real maximum size of parts after correction for minimum 
160          * partx*xparts can be larger than rectx, in that case last part is smaller */
161         int partx, party;
162         
163         /* values for viewing */
164         float ycor; /* (scene->xasp / scene->yasp), multiplied with 'winy' */
165         
166         float panophi, panosi, panoco, panodxp, panodxv;
167         
168         /* Matrices */
169         float grvec[3];                 /* for world */
170         float imat[3][3];               /* copy of viewinv */
171         float viewmat[4][4], viewinv[4][4];
172         float viewmat_orig[4][4];       /* for incremental render */
173         float winmat[4][4];
174         
175         /* clippping */
176         float clipsta;
177         float clipend;
178         
179         /* samples */
180         SampleTables *samples;
181         float jit[32][2];
182         float mblur_jit[32][2];
183         ListBase *qmcsamplers;
184         int num_qmc_samplers;
185         
186         /* shadow counter, detect shadow-reuse for shaders */
187         int shadowsamplenr[BLENDER_MAX_THREADS];
188         
189         struct Depsgraph *depsgraph;
190
191         /* main, scene, and its full copy of renderdata and world */
192         struct Main *main;
193         Scene *scene;
194         RenderData r;
195         ListBase view_layers;
196         int active_view_layer;
197         World wrld;
198         ViewRender view_render;
199         struct Object *camera_override;
200         unsigned int lay, layer_override;
201         
202         ThreadRWMutex partsmutex;
203         ListBase parts;
204         
205         /* render engine */
206         struct RenderEngine *engine;
207         
208         /* octree tables and variables for raytrace */
209         struct RayObject *raytree;
210         struct RayFace *rayfaces;
211         struct VlakPrimitive *rayprimitives;
212         float maxdist; /* needed for keeping an incorrect behavior of SUN and HEMI lights (avoid breaking old scenes) */
213
214         /* occlusion tree */
215         void *occlusiontree;
216         ListBase strandsurface;
217         
218         /* use this instead of R.r.cfra */
219         float mblur_offs, field_offs;
220         
221         /* render database */
222         int totvlak, totvert, tothalo, totstrand, totlamp;
223         struct HaloRen **sortedhalos;
224
225         ListBase lights;        /* GroupObject pointers */
226         ListBase lampren;       /* storage, for free */
227         
228         ListBase objecttable;
229
230         struct ObjectInstanceRen *objectinstance;
231         ListBase instancetable;
232         int totinstance;
233
234         struct Image *bakebuf;
235         
236         struct GHash *orco_hash;
237
238         struct GHash *sss_hash;
239         ListBase *sss_points;
240         struct Material *sss_mat;
241
242         ListBase customdata_names;
243
244         struct Object *excludeob;
245         ListBase render_volumes_inside;
246         ListBase volumes;
247
248 #ifdef WITH_FREESTYLE
249         struct Main *freestyle_bmain;
250         ListBase freestyle_renders;
251 #endif
252
253         /* arena for allocating data for use during render, for
254          * example dynamic TFaces to go in the VlakRen structure.
255          */
256         struct MemArena *memArena;
257         
258         /* callbacks */
259         void (*display_init)(void *handle, RenderResult *rr);
260         void *dih;
261         void (*display_clear)(void *handle, RenderResult *rr);
262         void *dch;
263         void (*display_update)(void *handle, RenderResult *rr, volatile rcti *rect);
264         void *duh;
265         void (*current_scene_update)(void *handle, struct Scene *scene);
266         void *suh;
267         
268         void (*stats_draw)(void *handle, RenderStats *ri);
269         void *sdh;
270         void (*progress)(void *handle, float i);
271         void *prh;
272         
273         void (*draw_lock)(void *handle, int i);
274         void *dlh;
275         int (*test_break)(void *handle);
276         void *tbh;
277         
278         RenderStats i;
279
280         struct ReportList *reports;
281
282         struct ImagePool *pool;
283         struct EvaluationContext *eval_ctx;
284
285         void **movie_ctx_arr;
286         char viewname[MAX_NAME];
287 };
288
289 /* ------------------------------------------------------------------------- */
290
291 struct ISBData;
292
293 typedef struct DeepSample {
294         int z;
295         float v;
296 } DeepSample;
297  
298 typedef struct ShadSampleBuf {
299         struct ShadSampleBuf *next, *prev;
300         intptr_t *zbuf;
301         char *cbuf;
302         DeepSample **deepbuf;
303         int *totbuf;
304 } ShadSampleBuf;
305
306 typedef struct ShadBuf {
307         /* regular shadowbuffer */
308         short samp, shadhalostep, totbuf;
309         float persmat[4][4];
310         float viewmat[4][4];
311         float winmat[4][4];
312         float *jit, *weight;
313         float d, clipend, pixsize, soft, compressthresh;
314         int co[3];
315         int size, bias;
316         ListBase buffers;
317         
318         /* irregular shadowbufer, result stored per thread */
319         struct ISBData *isb_result[BLENDER_MAX_THREADS];
320 } ShadBuf;
321
322 /* ------------------------------------------------------------------------- */
323
324 typedef struct ObjectRen {
325         struct ObjectRen *next, *prev;
326         struct Object *ob, *par;
327         struct Scene *sce;
328         int index, psysindex, flag, lay;
329
330         float boundbox[2][3];
331
332         int totvert, totvlak, totstrand, tothalo;
333         int vertnodeslen, vlaknodeslen, strandnodeslen, blohalen;
334         struct VertTableNode *vertnodes;
335         struct VlakTableNode *vlaknodes;
336         struct StrandTableNode *strandnodes;
337         struct HaloRen **bloha;
338         struct StrandBuffer *strandbuf;
339
340         char (*mtface)[MAX_CUSTOMDATA_LAYER_NAME];
341         char (*mcol)[MAX_CUSTOMDATA_LAYER_NAME];
342         int  actmtface, actmcol, bakemtface;
343
344         short tangent_mask; /* which tangent layer should be calculated */
345
346         float obmat[4][4];      /* only used in convertblender.c, for instancing */
347
348         /* used on makeraytree */
349         struct RayObject *raytree;
350         struct RayFace *rayfaces;
351         struct VlakPrimitive *rayprimitives;
352         struct ObjectInstanceRen *rayobi;
353         
354 } ObjectRen;
355
356 typedef struct ObjectInstanceRen {
357         struct ObjectInstanceRen *next, *prev;
358
359         ObjectRen *obr;
360         Object *ob, *par;
361         int index, psysindex, lay;
362
363         float mat[4][4], imat[4][4];
364         float nmat[3][3]; /* nmat is inverse mat tranposed */
365
366         float obmat[4][4], obinvmat[4][4];
367         float localtoviewmat[4][4], localtoviewinvmat[4][4];
368
369         short flag;
370
371         float dupliorco[3], dupliuv[2];
372         float (*duplitexmat)[4];
373         
374         struct VolumePrecache *volume_precache;
375         
376         float *vectors; /* (RE_WINSPEED_ELEMS * VertRen.index) */
377         int totvector;
378         
379         /* used on makeraytree */
380         struct RayObject *raytree;
381         int transform_primitives;
382
383         /* Particle info */
384         float part_index;
385         float part_age;
386         float part_lifetime;
387         float part_size;
388         float part_co[3];
389         float part_vel[3];
390         float part_avel[3];
391
392         unsigned int random_id;
393 } ObjectInstanceRen;
394
395 /* ------------------------------------------------------------------------- */
396
397 typedef struct VertRen {
398         float co[3];
399         float n[3];
400         float *orco;
401         unsigned int flag;      /* in use for clipping zbuffer parts, temp setting stuff in convertblender.c
402                                                  * only an 'int' because of alignment, could be a char too */
403         float accum;            /* accum for radio weighting, and for strand texco static particles */
404         int index;                      /* index allows extending vertren with any property */
405 } VertRen;
406
407 /* ------------------------------------------------------------------------- */
408
409 struct halosort {
410         struct HaloRen *har;
411         int z;
412 };
413
414 /* ------------------------------------------------------------------------- */
415 struct Material;
416 struct ImagePool;
417
418 typedef struct RadFace {
419         float unshot[3], totrad[3];
420         float norm[3], cent[3], area;
421         int flag;
422 } RadFace;
423
424 typedef struct VlakRen {
425         struct VertRen *v1, *v2, *v3, *v4;      /* keep in order for ** addressing */
426         float n[3];
427         struct Material *mat;
428         char puno;
429         char flag, ec;
430 #ifdef WITH_FREESTYLE
431         char freestyle_edge_mark;
432         char freestyle_face_mark;
433 #endif
434         int index;
435 } VlakRen;
436
437 typedef struct HaloRen {
438         short miny, maxy;
439         float alfa, xs, ys, rad, radsq, sin, cos, co[3], no[3];
440         float hard, b, g, r;
441         int zs, zd;
442         int zBufDist;   /* depth in the z-buffer coordinate system */
443         char starpoints, type, add, tex;
444         char linec, ringc, seed;
445         short flarec; /* used to be a char. why ?*/
446         float hasize;
447         int pixels;
448         unsigned int lay;
449         struct Material *mat;
450         struct ImagePool *pool;
451         bool skip_load_image, texnode_preview;
452 } HaloRen;
453
454 /* ------------------------------------------------------------------------- */
455
456 typedef struct StrandVert {
457         float co[3];
458         float strandco;
459 } StrandVert;
460
461 typedef struct StrandSurface {
462         struct StrandSurface *next, *prev;
463         ObjectRen obr;
464         int (*face)[4];
465         float (*co)[3];
466         /* for occlusion caching */
467         float (*ao)[3];
468         float (*env)[3];
469         float (*indirect)[3];
470         /* for speedvectors */
471         float (*prevco)[3], (*nextco)[3];
472         int totvert, totface;
473 } StrandSurface;
474
475 typedef struct StrandBound {
476         int start, end;
477         float boundbox[2][3];
478 } StrandBound;
479
480 typedef struct StrandBuffer {
481         struct StrandBuffer *next, *prev;
482         struct StrandVert *vert;
483         struct StrandBound *bound;
484         int totvert, totbound;
485
486         struct ObjectRen *obr;
487         struct Material *ma;
488         struct StrandSurface *surface;
489         unsigned int lay;
490         int overrideuv;
491         int flag, maxdepth;
492         float adaptcos, minwidth, widthfade;
493         
494         float maxwidth; /* for cliptest of strands in blender unit */
495         
496         float winmat[4][4];
497         int winx, winy;
498 } StrandBuffer;
499
500 typedef struct StrandRen {
501         StrandVert *vert;
502         StrandBuffer *buffer;
503         int totvert, flag;
504         int clip, index;
505         float orco[3];
506 } StrandRen;
507
508 /* ------------------------------------------------------------------------- */
509
510 typedef struct VolumeOb {
511         struct VolumeOb *next, *prev;
512         struct Material *ma;
513         struct ObjectRen *obr;
514 } VolumeOb;
515
516 typedef struct MatInside {
517         struct MatInside *next, *prev;
518         struct Material *ma;
519         struct ObjectInstanceRen *obi;
520 } MatInside;
521
522 typedef struct VolPrecachePart {
523         struct VolPrecachePart *next, *prev;
524         struct RayObject *tree;
525         struct ShadeInput *shi;
526         struct ObjectInstanceRen *obi;
527         float viewmat[4][4];
528         int num;
529         int minx, maxx;
530         int miny, maxy;
531         int minz, maxz;
532         int res[3];
533         float bbmin[3];
534         float voxel[3];
535         struct Render *re;
536 } VolPrecachePart;
537
538 typedef struct VolumePrecache {
539         int res[3];
540         float *bbmin, *bbmax;
541         float *data_r;
542         float *data_g;
543         float *data_b;
544 } VolumePrecache;
545
546 /* ------------------------------------------------------------------------- */
547
548 struct LampRen;
549 struct MTex;
550
551 /**
552  * For each lamp in a scene, a LampRen is created. It determines the
553  * properties of a lightsource.
554  */
555
556 typedef struct LampShadowSubSample {
557         int samplenr;
558         float shadfac[4];       /* rgba shadow */
559 } LampShadowSubSample;
560
561 typedef struct LampShadowSample {
562         LampShadowSubSample s[16];      /* MAX OSA */
563 } LampShadowSample;
564
565 typedef struct LampRen {
566         struct LampRen *next, *prev;
567         
568         float xs, ys, dist;
569         float co[3];
570         short type;
571         int mode;
572         float r, g, b, k;
573         float shdwr, shdwg, shdwb;
574         float energy, haint;
575         int lay;
576         float spotsi, spotbl;
577         float vec[3];
578         float xsp, ysp, distkw, inpr;
579         float halokw, halo;
580         
581         short falloff_type;
582         float ld1, ld2;
583         float coeff_const, coeff_lin, coeff_quad;
584         struct CurveMapping *curfalloff;
585
586         /* copied from Lamp, to decouple more rendering stuff */
587         /** Size of the shadowbuffer */
588         short bufsize;
589         /** Number of samples for the shadows */
590         short samp;
591         /** Softness factor for shadow */
592         float soft;
593         /** amount of subsample buffers and type of filter for sampling */
594         short buffers, filtertype;
595         /** shadow buffer type (regular, irregular) */
596         short buftype;
597         /** autoclip */
598         short bufflag;
599         /** shadow plus halo: detail level */
600         short shadhalostep;
601         /** Near clip of the lamp */
602         float clipsta;
603         /** Far clip of the lamp */
604         float clipend;
605         /** A small depth offset to prevent self-shadowing. */
606         float bias;
607         /* Compression threshold for deep shadow maps */
608         float compressthresh;
609         
610         short ray_samp, ray_sampy, ray_sampz, ray_samp_method, ray_samp_type, area_shape, ray_totsamp;
611         short xold[BLENDER_MAX_THREADS], yold[BLENDER_MAX_THREADS];     /* last jitter table for area lights */
612         float area_size, area_sizey, area_sizez;
613         float adapt_thresh;
614
615         /* sun/sky */
616         struct SunSky *sunsky;
617         
618         struct ShadBuf *shb;
619         float *jitter;
620         
621         float imat[3][3];
622         float spottexfac;
623         float sh_invcampos[3], sh_zfac; /* sh_= spothalo */
624
625         float lampmat[4][4];    /* worls space lamp matrix, used for scene rotation */
626
627         float mat[3][3];        /* 3x3 part from lampmat x viewmat */
628         float area[8][3], areasize;
629         
630         /* passes & node shader support: all shadow info for a pixel */
631         LampShadowSample *shadsamp;
632         
633         /* ray optim */
634         struct RayObject *last_hit[BLENDER_MAX_THREADS];
635         
636         struct MTex *mtex[MAX_MTEX];
637
638         /* threading */
639         int thread_assigned;
640         int thread_ready;
641 } LampRen;
642
643 /* **************** defines ********************* */
644
645 /* R.r.mode flag is same as for renderdata */
646
647 /* R.flag */
648 #define R_ZTRA                  1
649 #define R_HALO                  2
650 #define R_SEC_FIELD             4
651 #define R_LAMPHALO              8
652 #define R_NEED_TANGENT  16
653 #define R_BAKE_TRACE    32
654 #define R_BAKING                64
655 #define R_ANIMATION             128
656 #define R_NEED_VCOL             256
657
658 /* vlakren->flag (vlak = face in dutch) char!!! */
659 #define R_SMOOTH                1
660 #define R_HIDDEN                2
661 /* strand flag, means special handling */
662 #define R_STRAND                4
663 #define R_FULL_OSA              8
664 #define R_FACE_SPLIT    16
665 /* Tells render to divide face other way. */
666 #define R_DIVIDE_24             32      
667 /* vertex normals are tangent or view-corrected vector, for hair strands */
668 #define R_TANGENT               64              
669 #define R_TRACEBLE              128
670
671 /* vlakren->freestyle_edge_mark */
672 #ifdef WITH_FREESTYLE
673 #  define R_EDGE_V1V2           1
674 #  define R_EDGE_V2V3           2
675 #  define R_EDGE_V3V4           4
676 #  define R_EDGE_V3V1           4
677 #  define R_EDGE_V4V1           8
678 #endif
679
680 /* strandbuffer->flag */
681 #define R_STRAND_BSPLINE        1
682 #define R_STRAND_B_UNITS        2
683
684 /* objectren->flag */
685 #define R_INSTANCEABLE          1
686
687 /* objectinstance->flag */
688 #define R_DUPLI_TRANSFORMED     1
689 #define R_ENV_TRANSFORMED       2
690 #define R_TRANSFORMED           (1|2)
691
692 #endif /* __RENDER_TYPES_H__ */
693