Merge branch 'master' into blender2.8
[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         World wrld;
196         ViewRender view_render;
197         struct Object *camera_override;
198         unsigned int lay, layer_override;
199         
200         ThreadRWMutex partsmutex;
201         ListBase parts;
202         
203         /* render engine */
204         struct RenderEngine *engine;
205         
206         /* octree tables and variables for raytrace */
207         struct RayObject *raytree;
208         struct RayFace *rayfaces;
209         struct VlakPrimitive *rayprimitives;
210         float maxdist; /* needed for keeping an incorrect behavior of SUN and HEMI lights (avoid breaking old scenes) */
211
212         /* occlusion tree */
213         void *occlusiontree;
214         ListBase strandsurface;
215         
216         /* use this instead of R.r.cfra */
217         float mblur_offs, field_offs;
218         
219         /* render database */
220         int totvlak, totvert, tothalo, totstrand, totlamp;
221         struct HaloRen **sortedhalos;
222
223         ListBase lights;        /* GroupObject pointers */
224         ListBase lampren;       /* storage, for free */
225         
226         ListBase objecttable;
227
228         struct ObjectInstanceRen *objectinstance;
229         ListBase instancetable;
230         int totinstance;
231
232         struct Image *bakebuf;
233         
234         struct GHash *orco_hash;
235
236         struct GHash *sss_hash;
237         ListBase *sss_points;
238         struct Material *sss_mat;
239
240         ListBase customdata_names;
241
242         struct Object *excludeob;
243         ListBase render_volumes_inside;
244         ListBase volumes;
245
246 #ifdef WITH_FREESTYLE
247         struct Main *freestyle_bmain;
248         ListBase freestyle_renders;
249 #endif
250
251         /* arena for allocating data for use during render, for
252          * example dynamic TFaces to go in the VlakRen structure.
253          */
254         struct MemArena *memArena;
255         
256         /* callbacks */
257         void (*display_init)(void *handle, RenderResult *rr);
258         void *dih;
259         void (*display_clear)(void *handle, RenderResult *rr);
260         void *dch;
261         void (*display_update)(void *handle, RenderResult *rr, volatile rcti *rect);
262         void *duh;
263         void (*current_scene_update)(void *handle, struct Scene *scene);
264         void *suh;
265         
266         void (*stats_draw)(void *handle, RenderStats *ri);
267         void *sdh;
268         void (*progress)(void *handle, float i);
269         void *prh;
270         
271         void (*draw_lock)(void *handle, int i);
272         void *dlh;
273         int (*test_break)(void *handle);
274         void *tbh;
275         
276         RenderStats i;
277
278         struct ReportList *reports;
279
280         struct ImagePool *pool;
281         struct EvaluationContext *eval_ctx;
282
283         void **movie_ctx_arr;
284         char viewname[MAX_NAME];
285 };
286
287 /* ------------------------------------------------------------------------- */
288
289 struct ISBData;
290
291 typedef struct DeepSample {
292         int z;
293         float v;
294 } DeepSample;
295  
296 typedef struct ShadSampleBuf {
297         struct ShadSampleBuf *next, *prev;
298         intptr_t *zbuf;
299         char *cbuf;
300         DeepSample **deepbuf;
301         int *totbuf;
302 } ShadSampleBuf;
303
304 typedef struct ShadBuf {
305         /* regular shadowbuffer */
306         short samp, shadhalostep, totbuf;
307         float persmat[4][4];
308         float viewmat[4][4];
309         float winmat[4][4];
310         float *jit, *weight;
311         float d, clipend, pixsize, soft, compressthresh;
312         int co[3];
313         int size, bias;
314         ListBase buffers;
315         
316         /* irregular shadowbufer, result stored per thread */
317         struct ISBData *isb_result[BLENDER_MAX_THREADS];
318 } ShadBuf;
319
320 /* ------------------------------------------------------------------------- */
321
322 typedef struct ObjectRen {
323         struct ObjectRen *next, *prev;
324         struct Object *ob, *par;
325         struct Scene *sce;
326         int index, psysindex, flag, lay;
327
328         float boundbox[2][3];
329
330         int totvert, totvlak, totstrand, tothalo;
331         int vertnodeslen, vlaknodeslen, strandnodeslen, blohalen;
332         struct VertTableNode *vertnodes;
333         struct VlakTableNode *vlaknodes;
334         struct StrandTableNode *strandnodes;
335         struct HaloRen **bloha;
336         struct StrandBuffer *strandbuf;
337
338         char (*mtface)[MAX_CUSTOMDATA_LAYER_NAME];
339         char (*mcol)[MAX_CUSTOMDATA_LAYER_NAME];
340         int  actmtface, actmcol, bakemtface;
341
342         short tangent_mask; /* which tangent layer should be calculated */
343
344         float obmat[4][4];      /* only used in convertblender.c, for instancing */
345
346         /* used on makeraytree */
347         struct RayObject *raytree;
348         struct RayFace *rayfaces;
349         struct VlakPrimitive *rayprimitives;
350         struct ObjectInstanceRen *rayobi;
351         
352 } ObjectRen;
353
354 typedef struct ObjectInstanceRen {
355         struct ObjectInstanceRen *next, *prev;
356
357         ObjectRen *obr;
358         Object *ob, *par;
359         int index, psysindex, lay;
360
361         float mat[4][4], imat[4][4];
362         float nmat[3][3]; /* nmat is inverse mat tranposed */
363
364         float obmat[4][4], obinvmat[4][4];
365         float localtoviewmat[4][4], localtoviewinvmat[4][4];
366
367         short flag;
368
369         float dupliorco[3], dupliuv[2];
370         float (*duplitexmat)[4];
371         
372         struct VolumePrecache *volume_precache;
373         
374         float *vectors; /* (RE_WINSPEED_ELEMS * VertRen.index) */
375         int totvector;
376         
377         /* used on makeraytree */
378         struct RayObject *raytree;
379         int transform_primitives;
380
381         /* Particle info */
382         float part_index;
383         float part_age;
384         float part_lifetime;
385         float part_size;
386         float part_co[3];
387         float part_vel[3];
388         float part_avel[3];
389
390         unsigned int random_id;
391 } ObjectInstanceRen;
392
393 /* ------------------------------------------------------------------------- */
394
395 typedef struct VertRen {
396         float co[3];
397         float n[3];
398         float *orco;
399         unsigned int flag;      /* in use for clipping zbuffer parts, temp setting stuff in convertblender.c
400                                                  * only an 'int' because of alignment, could be a char too */
401         float accum;            /* accum for radio weighting, and for strand texco static particles */
402         int index;                      /* index allows extending vertren with any property */
403 } VertRen;
404
405 /* ------------------------------------------------------------------------- */
406
407 struct halosort {
408         struct HaloRen *har;
409         int z;
410 };
411
412 /* ------------------------------------------------------------------------- */
413 struct Material;
414 struct ImagePool;
415
416 typedef struct RadFace {
417         float unshot[3], totrad[3];
418         float norm[3], cent[3], area;
419         int flag;
420 } RadFace;
421
422 typedef struct VlakRen {
423         struct VertRen *v1, *v2, *v3, *v4;      /* keep in order for ** addressing */
424         float n[3];
425         struct Material *mat;
426         char puno;
427         char flag, ec;
428 #ifdef WITH_FREESTYLE
429         char freestyle_edge_mark;
430         char freestyle_face_mark;
431 #endif
432         int index;
433 } VlakRen;
434
435 typedef struct HaloRen {
436         short miny, maxy;
437         float alfa, xs, ys, rad, radsq, sin, cos, co[3], no[3];
438         float hard, b, g, r;
439         int zs, zd;
440         int zBufDist;   /* depth in the z-buffer coordinate system */
441         char starpoints, type, add, tex;
442         char linec, ringc, seed;
443         short flarec; /* used to be a char. why ?*/
444         float hasize;
445         int pixels;
446         unsigned int lay;
447         struct Material *mat;
448         struct ImagePool *pool;
449         bool skip_load_image, texnode_preview;
450 } HaloRen;
451
452 /* ------------------------------------------------------------------------- */
453
454 typedef struct StrandVert {
455         float co[3];
456         float strandco;
457 } StrandVert;
458
459 typedef struct StrandSurface {
460         struct StrandSurface *next, *prev;
461         ObjectRen obr;
462         int (*face)[4];
463         float (*co)[3];
464         /* for occlusion caching */
465         float (*ao)[3];
466         float (*env)[3];
467         float (*indirect)[3];
468         /* for speedvectors */
469         float (*prevco)[3], (*nextco)[3];
470         int totvert, totface;
471 } StrandSurface;
472
473 typedef struct StrandBound {
474         int start, end;
475         float boundbox[2][3];
476 } StrandBound;
477
478 typedef struct StrandBuffer {
479         struct StrandBuffer *next, *prev;
480         struct StrandVert *vert;
481         struct StrandBound *bound;
482         int totvert, totbound;
483
484         struct ObjectRen *obr;
485         struct Material *ma;
486         struct StrandSurface *surface;
487         unsigned int lay;
488         int overrideuv;
489         int flag, maxdepth;
490         float adaptcos, minwidth, widthfade;
491         
492         float maxwidth; /* for cliptest of strands in blender unit */
493         
494         float winmat[4][4];
495         int winx, winy;
496 } StrandBuffer;
497
498 typedef struct StrandRen {
499         StrandVert *vert;
500         StrandBuffer *buffer;
501         int totvert, flag;
502         int clip, index;
503         float orco[3];
504 } StrandRen;
505
506 /* ------------------------------------------------------------------------- */
507
508 typedef struct VolumeOb {
509         struct VolumeOb *next, *prev;
510         struct Material *ma;
511         struct ObjectRen *obr;
512 } VolumeOb;
513
514 typedef struct MatInside {
515         struct MatInside *next, *prev;
516         struct Material *ma;
517         struct ObjectInstanceRen *obi;
518 } MatInside;
519
520 typedef struct VolPrecachePart {
521         struct VolPrecachePart *next, *prev;
522         struct RayObject *tree;
523         struct ShadeInput *shi;
524         struct ObjectInstanceRen *obi;
525         float viewmat[4][4];
526         int num;
527         int minx, maxx;
528         int miny, maxy;
529         int minz, maxz;
530         int res[3];
531         float bbmin[3];
532         float voxel[3];
533         struct Render *re;
534 } VolPrecachePart;
535
536 typedef struct VolumePrecache {
537         int res[3];
538         float *bbmin, *bbmax;
539         float *data_r;
540         float *data_g;
541         float *data_b;
542 } VolumePrecache;
543
544 /* ------------------------------------------------------------------------- */
545
546 struct LampRen;
547 struct MTex;
548
549 /**
550  * For each lamp in a scene, a LampRen is created. It determines the
551  * properties of a lightsource.
552  */
553
554 typedef struct LampShadowSubSample {
555         int samplenr;
556         float shadfac[4];       /* rgba shadow */
557 } LampShadowSubSample;
558
559 typedef struct LampShadowSample {
560         LampShadowSubSample s[16];      /* MAX OSA */
561 } LampShadowSample;
562
563 typedef struct LampRen {
564         struct LampRen *next, *prev;
565         
566         float xs, ys, dist;
567         float co[3];
568         short type;
569         int mode;
570         float r, g, b, k;
571         float shdwr, shdwg, shdwb;
572         float energy, haint;
573         int lay;
574         float spotsi, spotbl;
575         float vec[3];
576         float xsp, ysp, distkw, inpr;
577         float halokw, halo;
578         
579         short falloff_type;
580         float ld1, ld2;
581         float coeff_const, coeff_lin, coeff_quad;
582         struct CurveMapping *curfalloff;
583
584         /* copied from Lamp, to decouple more rendering stuff */
585         /** Size of the shadowbuffer */
586         short bufsize;
587         /** Number of samples for the shadows */
588         short samp;
589         /** Softness factor for shadow */
590         float soft;
591         /** amount of subsample buffers and type of filter for sampling */
592         short buffers, filtertype;
593         /** shadow buffer type (regular, irregular) */
594         short buftype;
595         /** autoclip */
596         short bufflag;
597         /** shadow plus halo: detail level */
598         short shadhalostep;
599         /** Near clip of the lamp */
600         float clipsta;
601         /** Far clip of the lamp */
602         float clipend;
603         /** A small depth offset to prevent self-shadowing. */
604         float bias;
605         /* Compression threshold for deep shadow maps */
606         float compressthresh;
607         
608         short ray_samp, ray_sampy, ray_sampz, ray_samp_method, ray_samp_type, area_shape, ray_totsamp;
609         short xold[BLENDER_MAX_THREADS], yold[BLENDER_MAX_THREADS];     /* last jitter table for area lights */
610         float area_size, area_sizey, area_sizez;
611         float adapt_thresh;
612
613         /* sun/sky */
614         struct SunSky *sunsky;
615         
616         struct ShadBuf *shb;
617         float *jitter;
618         
619         float imat[3][3];
620         float spottexfac;
621         float sh_invcampos[3], sh_zfac; /* sh_= spothalo */
622
623         float lampmat[4][4];    /* worls space lamp matrix, used for scene rotation */
624
625         float mat[3][3];        /* 3x3 part from lampmat x viewmat */
626         float area[8][3], areasize;
627         
628         /* passes & node shader support: all shadow info for a pixel */
629         LampShadowSample *shadsamp;
630         
631         /* ray optim */
632         struct RayObject *last_hit[BLENDER_MAX_THREADS];
633         
634         struct MTex *mtex[MAX_MTEX];
635
636         /* threading */
637         int thread_assigned;
638         int thread_ready;
639 } LampRen;
640
641 /* **************** defines ********************* */
642
643 /* R.r.mode flag is same as for renderdata */
644
645 /* R.flag */
646 #define R_ZTRA                  1
647 #define R_HALO                  2
648 #define R_SEC_FIELD             4
649 #define R_LAMPHALO              8
650 #define R_NEED_TANGENT  16
651 #define R_BAKE_TRACE    32
652 #define R_BAKING                64
653 #define R_ANIMATION             128
654 #define R_NEED_VCOL             256
655
656 /* vlakren->flag (vlak = face in dutch) char!!! */
657 #define R_SMOOTH                1
658 #define R_HIDDEN                2
659 /* strand flag, means special handling */
660 #define R_STRAND                4
661 #define R_FULL_OSA              8
662 #define R_FACE_SPLIT    16
663 /* Tells render to divide face other way. */
664 #define R_DIVIDE_24             32      
665 /* vertex normals are tangent or view-corrected vector, for hair strands */
666 #define R_TANGENT               64              
667 #define R_TRACEBLE              128
668
669 /* vlakren->freestyle_edge_mark */
670 #ifdef WITH_FREESTYLE
671 #  define R_EDGE_V1V2           1
672 #  define R_EDGE_V2V3           2
673 #  define R_EDGE_V3V4           4
674 #  define R_EDGE_V3V1           4
675 #  define R_EDGE_V4V1           8
676 #endif
677
678 /* strandbuffer->flag */
679 #define R_STRAND_BSPLINE        1
680 #define R_STRAND_B_UNITS        2
681
682 /* objectren->flag */
683 #define R_INSTANCEABLE          1
684
685 /* objectinstance->flag */
686 #define R_DUPLI_TRANSFORMED     1
687 #define R_ENV_TRANSFORMED       2
688 #define R_TRANSFORMED           (1|2)
689
690 #endif /* __RENDER_TYPES_H__ */
691