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