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