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