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