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