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