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