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