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