651608f83c3d32642467ea0b6b7a9a1647d6954a
[blender-staging.git] / source / blender / render / intern / include / render_types.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * Contributor(s): (c) 2006 Blender Foundation, full refactor
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file blender/render/intern/include/render_types.h
27  *  \ingroup render
28  */
29
30
31 #ifndef RENDER_TYPES_H
32 #define RENDER_TYPES_H
33
34 /* ------------------------------------------------------------------------- */
35 /* exposed internal in render module only! */
36 /* ------------------------------------------------------------------------- */
37
38 #include "DNA_color_types.h"
39 #include "DNA_scene_types.h"
40 #include "DNA_world_types.h"
41 #include "DNA_object_types.h"
42 #include "DNA_vec_types.h"
43
44 #include "BLI_threads.h"
45
46 #include "RE_pipeline.h"
47 #include "RE_shader_ext.h"      /* TexResult, ShadeResult, ShadeInput */
48 #include "sunsky.h"
49
50 #include "BLO_sys_types.h" // for intptr_t support
51
52 struct Object;
53 struct MemArena;
54 struct VertTableNode;
55 struct VlakTableNode;
56 struct GHash;
57 struct RenderBuckets;
58 struct ObjectInstanceRen;
59 struct RayObject;
60 struct RayFace;
61 struct ReportList;
62 struct Main;
63
64 #define TABLEINITSIZE 1024
65 #define LAMPINITSIZE 256
66
67 typedef struct SampleTables
68 {
69         float centLut[16];
70         float *fmask1[9], *fmask2[9];
71         char cmask[256], *centmask;
72         
73 } SampleTables;
74
75 typedef struct QMCSampler
76 {
77         struct QMCSampler *next, *prev;
78         int type;
79         int tot;
80         int used;
81         double *samp2d;
82         double offs[BLENDER_MAX_THREADS][2];
83 } QMCSampler;
84
85 #define SAMP_TYPE_JITTERED              0
86 #define SAMP_TYPE_HALTON                1
87 #define SAMP_TYPE_HAMMERSLEY    2
88
89 /* this is handed over to threaded hiding/passes/shading engine */
90 typedef struct RenderPart
91 {
92         struct RenderPart *next, *prev;
93         
94         RenderResult *result;                   /* result of part rendering */
95         ListBase fullresult;                    /* optional full sample buffers */
96         
97         int *recto;                                             /* object table for objects */
98         int *rectp;                                             /* polygon index table */
99         int *rectz;                                             /* zbuffer */
100         int *rectmask;                                  /* negative zmask */
101         intptr_t *rectdaps;                                     /* delta acum buffer for pixel structs */
102         int *rectbacko;                                 /* object table for backside sss */
103         int *rectbackp;                                 /* polygon index table for backside sss */
104         int *rectbackz;                                 /* zbuffer for backside sss */
105         intptr_t *rectall;                                      /* buffer for all faces for sss */
106
107         rcti disprect;                                  /* part coordinates within total picture */
108         int rectx, recty;                               /* the size */
109         short crop, ready;                              /* crop is amount of pixels we crop, for filter */
110         short sample, nr;                               /* sample can be used by zbuffers, nr is partnr */
111         short thread;                                   /* thread id */
112         
113         char *clipflag;                                 /* clipflags for part zbuffering */
114 } RenderPart;
115
116 /* controls state of render, everything that's read-only during render stage */
117 struct Render
118 {
119         struct Render *next, *prev;
120         char name[RE_MAXNAME];
121         int slot;
122         
123         /* state settings */
124         short flag, osa, ok, result_ok;
125         
126         /* result of rendering */
127         RenderResult *result;
128         /* if render with single-layer option, other rendered layers are stored here */
129         RenderResult *pushedresult;
130         /* a list of RenderResults, for fullsample */
131         ListBase fullresult;    
132         /* read/write mutex, all internal code that writes to re->result must use a
133            write lock, all external code must use a read lock. internal code is assumed
134            to not conflict with writes, so no lock used for that */
135         ThreadRWMutex resultmutex;
136         
137         /* window size, display rect, viewplane */
138         int winx, winy;                 /* buffer width and height with percentage applied
139                                                          * without border & crop. convert to long before multiplying together to avoid overflow. */
140         rcti disprect;                  /* part within winx winy */
141         rctf viewplane;                 /* mapped on winx winy */
142         float viewdx, viewdy;   /* size of 1 pixel */
143         float clipcrop;                 /* 2 pixel boundary to prevent clip when filter used */
144         
145         /* final picture width and height (within disprect) */
146         int rectx, recty;
147         
148         /* real maximum amount of xparts/yparts after correction for minimum */
149         int xparts, yparts;
150         /* real maximum size of parts after correction for minimum 
151            partx*xparts can be larger than rectx, in that case last part is smaller */
152         int partx, party;
153         
154         /* values for viewing */
155         float lens;
156         float sensor_x; /* image sensor size, same variable in camera */
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 *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         /* arena for allocating data for use during render, for
233                 * example dynamic TFaces to go in the VlakRen structure.
234                 */
235         struct MemArena *memArena;
236         
237         /* callbacks */
238         void (*display_init)(void *handle, RenderResult *rr);
239         void *dih;
240         void (*display_clear)(void *handle, RenderResult *rr);
241         void *dch;
242         void (*display_draw)(void *handle, RenderResult *rr, volatile rcti *rect);
243         void *ddh;
244         
245         void (*stats_draw)(void *handle, RenderStats *ri);
246         void *sdh;
247         void (*progress)(void *handle, float i);
248         void *prh;
249         
250         void (*draw_lock)(void *handle, int i);
251         void *dlh;
252         int (*test_break)(void *handle);
253         void *tbh;
254         
255         RenderStats i;
256
257         struct ReportList *reports;
258 };
259
260 /* ------------------------------------------------------------------------- */
261
262 struct ISBData;
263
264 typedef struct DeepSample {
265         int z;
266         float v;
267 } DeepSample;
268  
269 typedef struct ShadSampleBuf {
270         struct ShadSampleBuf *next, *prev;
271         intptr_t *zbuf;
272         char *cbuf;
273         DeepSample **deepbuf;
274         int *totbuf;
275 } ShadSampleBuf;
276
277 typedef struct ShadBuf {
278         /* regular shadowbuffer */
279         short samp, shadhalostep, totbuf;
280         float persmat[4][4];
281         float viewmat[4][4];
282         float winmat[4][4];
283         float *jit, *weight;
284         float d, clipend, pixsize, soft, compressthresh;
285         int co[3];
286         int size, bias;
287         ListBase buffers;
288         
289         /* irregular shadowbufer, result stored per thread */
290         struct ISBData *isb_result[BLENDER_MAX_THREADS];
291 } ShadBuf;
292
293 /* ------------------------------------------------------------------------- */
294
295 typedef struct ObjectRen {
296         struct ObjectRen *next, *prev;
297         struct Object *ob, *par;
298         struct Scene *sce;
299         int index, psysindex, flag, lay;
300
301         float boundbox[2][3];
302
303         int totvert, totvlak, totstrand, tothalo;
304         int vertnodeslen, vlaknodeslen, strandnodeslen, blohalen;
305         struct VertTableNode *vertnodes;
306         struct VlakTableNode *vlaknodes;
307         struct StrandTableNode *strandnodes;
308         struct HaloRen **bloha;
309         struct StrandBuffer *strandbuf;
310
311         char (*mtface)[32];
312         char (*mcol)[32];
313         int  actmtface, actmcol, bakemtface;
314
315         float obmat[4][4];      /* only used in convertblender.c, for instancing */
316
317         /* used on makeraytree */
318         struct RayObject *raytree;
319         struct RayFace *rayfaces;
320         struct VlakPrimitive *rayprimitives;
321         struct ObjectInstanceRen *rayobi;
322         
323 } ObjectRen;
324
325 typedef struct ObjectInstanceRen {
326         struct ObjectInstanceRen *next, *prev;
327
328         ObjectRen *obr;
329         Object *ob, *par;
330         int index, psysindex, lay;
331
332         float mat[4][4], nmat[3][3]; /* nmat is inverse mat tranposed */
333         short flag;
334
335         float dupliorco[3], dupliuv[2];
336         float (*duplitexmat)[4];
337         
338         struct VolumePrecache *volume_precache;
339         
340         float *vectors; /* (RE_WINSPEED_ELEMS * VertRen.index) */
341         int totvector;
342         
343         /* used on makeraytree */
344         struct RayObject *raytree;
345         int transform_primitives;
346
347 } ObjectInstanceRen;
348
349 /* ------------------------------------------------------------------------- */
350
351 typedef struct VertRen
352 {
353         float co[3];
354         float n[3];
355         float *orco;
356         unsigned int flag;      /* in use for clipping zbuffer parts, temp setting stuff in convertblender.c
357                                                  * only an 'int' because of alignment, could be a char too */
358         float accum;            /* accum for radio weighting, and for strand texco static particles */
359         int index;                      /* index allows extending vertren with any property */
360 } VertRen;
361
362 /* ------------------------------------------------------------------------- */
363
364 struct halosort {
365         struct HaloRen *har;
366         int z;
367 };
368
369 /* ------------------------------------------------------------------------- */
370 struct Material;
371 struct MTFace;
372
373 typedef struct RadFace {
374         float unshot[3], totrad[3];
375         float norm[3], cent[3], area;
376         int flag;
377 } RadFace;
378
379 typedef struct VlakRen {
380         struct VertRen *v1, *v2, *v3, *v4;      /* keep in order for ** addressing */
381         float n[3];
382         struct Material *mat;
383         char puno;
384         char flag, ec;
385         int index;
386 } VlakRen;
387
388 typedef struct HaloRen
389 {       
390         short miny, maxy;
391         float alfa, xs, ys, rad, radsq, sin, cos, co[3], no[3];
392         float hard, b, g, r;
393         int zs, zd;
394         int zBufDist;   /* depth in the z-buffer coordinate system */
395         char starpoints, type, add, tex;
396         char linec, ringc, seed;
397         short flarec; /* used to be a char. why ?*/
398         float hasize;
399         int pixels;
400         unsigned int lay;
401         struct Material *mat;
402 } HaloRen;
403
404 /* ------------------------------------------------------------------------- */
405
406 typedef struct StrandVert {
407         float co[3];
408         float strandco;
409 } StrandVert;
410
411 typedef struct StrandSurface {
412         struct StrandSurface *next, *prev;
413         ObjectRen obr;
414         int (*face)[4];
415         float (*co)[3];
416         /* for occlusion caching */
417         float (*ao)[3];
418         float (*env)[3];
419         float (*indirect)[3];
420         /* for speedvectors */
421         float (*prevco)[3], (*nextco)[3];
422         int totvert, totface;
423 } StrandSurface;
424
425 typedef struct StrandBound {
426         int start, end;
427         float boundbox[2][3];
428 } StrandBound;
429
430 typedef struct StrandBuffer {
431         struct StrandBuffer *next, *prev;
432         struct StrandVert *vert;
433         struct StrandBound *bound;
434         int totvert, totbound;
435
436         struct ObjectRen *obr;
437         struct Material *ma;
438         struct StrandSurface *surface;
439         unsigned int lay;
440         int overrideuv;
441         int flag, maxdepth;
442         float adaptcos, minwidth, widthfade;
443         
444         float maxwidth; /* for cliptest of strands in blender unit */
445         
446         float winmat[4][4];
447         int winx, winy;
448 } StrandBuffer;
449
450 typedef struct StrandRen {
451         StrandVert *vert;
452         StrandBuffer *buffer;
453         int totvert, flag;
454         int clip, index;
455         float orco[3];
456 } StrandRen;
457
458 /* ------------------------------------------------------------------------- */
459
460 typedef struct VolumeOb
461 {
462         struct VolumeOb *next, *prev;
463         struct Material *ma;
464         struct ObjectRen *obr;
465 } VolumeOb;
466
467 typedef struct MatInside {
468         struct MatInside *next, *prev;
469         struct Material *ma;
470         struct ObjectInstanceRen *obi;
471 } MatInside;
472
473 typedef struct VolPrecachePart
474 {
475         struct VolPrecachePart *next, *prev;
476         struct RayObject *tree;
477         struct ShadeInput *shi;
478         struct ObjectInstanceRen *obi;
479         float viewmat[4][4];
480         int num;
481         int minx, maxx;
482         int miny, maxy;
483         int minz, maxz;
484         int res[3];
485         float bbmin[3];
486         float voxel[3];
487         struct Render *re;
488 } VolPrecachePart;
489
490 typedef struct VolumePrecache
491 {
492         int res[3];
493         float *bbmin, *bbmax;
494         float *data_r;
495         float *data_g;
496         float *data_b;
497 } VolumePrecache;
498
499 /* ------------------------------------------------------------------------- */
500
501 struct LampRen;
502 struct MTex;
503
504 /**
505  * For each lamp in a scene, a LampRen is created. It determines the
506  * properties of a lightsource.
507  */
508
509 typedef struct LampShadowSubSample {
510         int samplenr;
511         float shadfac[4];       /* rgba shadow */
512 } LampShadowSubSample;
513
514 typedef struct LampShadowSample {
515         LampShadowSubSample s[16];      /* MAX OSA */
516 } LampShadowSample;
517
518 typedef struct LampRen {
519         struct LampRen *next, *prev;
520         
521         float xs, ys, dist;
522         float co[3];
523         short type;
524         int mode;
525         float r, g, b, k;
526         float shdwr, shdwg, shdwb;
527         float energy, haint;
528         int lay;
529         float spotsi,spotbl;
530         float vec[3];
531         float xsp, ysp, distkw, inpr;
532         float halokw, halo;
533         
534         short falloff_type;
535         float ld1,ld2;
536         struct CurveMapping *curfalloff;
537
538         /* copied from Lamp, to decouple more rendering stuff */
539         /** Size of the shadowbuffer */
540         short bufsize;
541         /** Number of samples for the shadows */
542         short samp;
543         /** Softness factor for shadow */
544         float soft;
545         /** amount of subsample buffers and type of filter for sampling */
546         short buffers, filtertype;
547         /** shadow buffer type (regular, irregular) */
548         short buftype;
549         /** autoclip */
550         short bufflag;
551         /** shadow plus halo: detail level */
552         short shadhalostep;
553         /** Near clip of the lamp */
554         float clipsta;
555         /** Far clip of the lamp */
556         float clipend;
557         /** A small depth offset to prevent self-shadowing. */
558         float bias;
559         /* Compression threshold for deep shadow maps */
560         float compressthresh;
561         
562         short ray_samp, ray_sampy, ray_sampz, ray_samp_method, ray_samp_type, area_shape, ray_totsamp;
563         short xold[BLENDER_MAX_THREADS], yold[BLENDER_MAX_THREADS];     /* last jitter table for area lights */
564         float area_size, area_sizey, area_sizez;
565         float adapt_thresh;
566
567         /* sun/sky */
568         struct SunSky *sunsky;
569         
570         struct ShadBuf *shb;
571         float *jitter;
572         
573         float imat[3][3];
574         float spottexfac;
575         float sh_invcampos[3], sh_zfac; /* sh_= spothalo */
576         
577         float mat[3][3];        /* 3x3 part from lampmat x viewmat */
578         float area[8][3], areasize;
579         
580         /* passes & node shader support: all shadow info for a pixel */
581         LampShadowSample *shadsamp;
582         
583         /* ray optim */
584         struct RayObject *last_hit[BLENDER_MAX_THREADS];
585         
586         struct MTex *mtex[MAX_MTEX];
587
588         /* threading */
589         int thread_assigned;
590         int thread_ready;
591 } LampRen;
592
593 /* **************** defines ********************* */
594
595 /* R.r.mode flag is same as for renderdata */
596
597 /* R.flag */
598 #define R_ZTRA                  1
599 #define R_HALO                  2
600 #define R_SEC_FIELD             4
601 #define R_LAMPHALO              8
602 #define R_NEED_TANGENT  16
603 #define R_BAKE_TRACE    32
604 #define R_BAKING                64
605
606 /* vlakren->flag (vlak = face in dutch) char!!! */
607 #define R_SMOOTH                1
608 #define R_HIDDEN                2
609 /* strand flag, means special handling */
610 #define R_STRAND                4
611 #define R_FULL_OSA              8
612 #define R_FACE_SPLIT    16
613 /* Tells render to divide face other way. */
614 #define R_DIVIDE_24             32      
615 /* vertex normals are tangent or view-corrected vector, for hair strands */
616 #define R_TANGENT               64              
617 #define R_TRACEBLE              128
618
619 /* strandbuffer->flag */
620 #define R_STRAND_BSPLINE        1
621 #define R_STRAND_B_UNITS        2
622
623 /* objectren->flag */
624 #define R_INSTANCEABLE          1
625
626 /* objectinstance->flag */
627 #define R_DUPLI_TRANSFORMED     1
628 #define R_ENV_TRANSFORMED       2
629 #define R_TRANSFORMED           (1|2)
630 #define R_NEED_VECTORS          4
631
632 #endif /* RENDER_TYPES_H */
633