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