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