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