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