* crash fix in volume render, less reliance on global R
[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 ShadSampleBuf {
249         struct ShadSampleBuf *next, *prev;
250         intptr_t *zbuf;
251         char *cbuf;
252 } ShadSampleBuf;
253
254 typedef struct ShadBuf {
255         /* regular shadowbuffer */
256         short samp, shadhalostep, totbuf;
257         float persmat[4][4];
258         float viewmat[4][4];
259         float winmat[4][4];
260         float *jit, *weight;
261         float d, clipend, pixsize, soft;
262         int co[3];
263         int size, bias;
264         ListBase buffers;
265         
266         /* irregular shadowbufer, result stored per thread */
267         struct ISBData *isb_result[BLENDER_MAX_THREADS];
268 } ShadBuf;
269
270 /* ------------------------------------------------------------------------- */
271
272 typedef struct ObjectRen {
273         struct ObjectRen *next, *prev;
274         struct Object *ob, *par;
275         struct Scene *sce;
276         int index, psysindex, flag, lay;
277
278         float boundbox[2][3];
279
280         int totvert, totvlak, totstrand, tothalo;
281         int vertnodeslen, vlaknodeslen, strandnodeslen, blohalen;
282         struct VertTableNode *vertnodes;
283         struct VlakTableNode *vlaknodes;
284         struct StrandTableNode *strandnodes;
285         struct HaloRen **bloha;
286         struct StrandBuffer *strandbuf;
287
288         char (*mtface)[32];
289         char (*mcol)[32];
290         int  actmtface, actmcol, bakemtface;
291
292         float obmat[4][4];      /* only used in convertblender.c, for instancing */
293
294         /* used on makeraytree */
295         struct RayObject *raytree;
296         struct RayFace *rayfaces;
297         struct VlakPrimitive *rayprimitives;
298         struct ObjectInstanceRen *rayobi;
299         
300 } ObjectRen;
301
302 typedef struct ObjectInstanceRen {
303         struct ObjectInstanceRen *next, *prev;
304
305         ObjectRen *obr;
306         Object *ob, *par;
307         int index, psysindex, lay;
308
309         float mat[4][4], nmat[3][3]; /* nmat is inverse mat tranposed */
310         short flag;
311
312         float dupliorco[3], dupliuv[2];
313         float (*duplitexmat)[4];
314         
315         struct VolumePrecache *volume_precache;
316         
317         float *vectors;
318         int totvector;
319         
320         /* used on makeraytree */
321         struct RayObject *raytree;
322         int transform_primitives;
323
324 } ObjectInstanceRen;
325
326 /* ------------------------------------------------------------------------- */
327
328 typedef struct VertRen
329 {
330         float co[3];
331         float n[3];
332         float *orco;
333         short clip;
334         unsigned short flag;            /* in use for clipping zbuffer parts, temp setting stuff in convertblender.c */
335         float accum;            /* accum for radio weighting, and for strand texco static particles */
336         int index;                      /* index allows extending vertren with any property */
337 } VertRen;
338
339 /* ------------------------------------------------------------------------- */
340
341 struct halosort {
342         struct HaloRen *har;
343         int z;
344 };
345
346 /* ------------------------------------------------------------------------- */
347 struct Material;
348 struct MTFace;
349
350 typedef struct RadFace {
351         float unshot[3], totrad[3];
352         float norm[3], cent[3], area;
353         int flag;
354 } RadFace;
355
356 typedef struct VlakRen {
357         struct VertRen *v1, *v2, *v3, *v4;      /* keep in order for ** addressing */
358         float n[3];
359         struct Material *mat;
360         char puno;
361         char flag, ec;
362         int index;
363 } VlakRen;
364
365 typedef struct HaloRen
366 {       
367     short miny, maxy;
368     float alfa, xs, ys, rad, radsq, sin, cos, co[3], no[3];
369         float hard, b, g, r;
370     int zs, zd;
371     int zBufDist;       /* depth in the z-buffer coordinate system */
372     char starpoints, type, add, tex;
373     char linec, ringc, seed;
374         short flarec; /* used to be a char. why ?*/
375     float hasize;
376     int pixels;
377     unsigned int lay;
378     struct Material *mat;
379 } HaloRen;
380
381 /* ------------------------------------------------------------------------- */
382
383 typedef struct StrandVert {
384         float co[3];
385         float strandco;
386 } StrandVert;
387
388 typedef struct StrandSurface {
389         struct StrandSurface *next, *prev;
390         ObjectRen obr;
391         int (*face)[4];
392         float (*co)[3];
393         /* for occlusion caching */
394         float (*col)[3];
395         /* for speedvectors */
396         float (*prevco)[3], (*nextco)[3];
397         int totvert, totface;
398 } StrandSurface;
399
400 typedef struct StrandBound {
401         int start, end;
402         float boundbox[2][3];
403 } StrandBound;
404
405 typedef struct StrandBuffer {
406         struct StrandBuffer *next, *prev;
407         struct StrandVert *vert;
408         struct StrandBound *bound;
409         int totvert, totbound;
410
411         struct ObjectRen *obr;
412         struct Material *ma;
413         struct StrandSurface *surface;
414         unsigned int lay;
415         int overrideuv;
416         int flag, maxdepth;
417         float adaptcos, minwidth, widthfade;
418
419         float winmat[4][4];
420         int winx, winy;
421 } StrandBuffer;
422
423 typedef struct StrandRen {
424         StrandVert *vert;
425         StrandBuffer *buffer;
426         int totvert, flag;
427         int clip, index;
428         float orco[3];
429 } StrandRen;
430
431 /* ------------------------------------------------------------------------- */
432
433 typedef struct VolumeOb
434 {
435         struct VolumeOb *next, *prev;
436         struct Material *ma;
437         struct ObjectRen *obr;
438 } VolumeOb;
439
440 typedef struct MatInside {
441         struct MatInside *next, *prev;
442         struct Material *ma;
443         struct ObjectInstanceRen *obi;
444 } MatInside;
445
446 typedef struct VolPrecachePart
447 {
448         struct VolPrecachePart *next, *prev;
449         struct RayObject *tree;
450         struct ShadeInput *shi;
451         struct ObjectInstanceRen *obi;
452         int num;
453         int minx, maxx;
454         int miny, maxy;
455         int minz, maxz;
456         int res[3];
457         float bbmin[3];
458         float voxel[3];
459         int working, done;
460 } VolPrecachePart;
461
462 typedef struct VolumePrecache
463 {
464         int res[3];
465         float *data_r;
466         float *data_g;
467         float *data_b;
468 } VolumePrecache;
469
470 /* ------------------------------------------------------------------------- */
471
472 struct LampRen;
473 struct MTex;
474
475 /**
476  * For each lamp in a scene, a LampRen is created. It determines the
477  * properties of a lightsource.
478  */
479
480 typedef struct LampShadowSubSample {
481         int samplenr;
482         float shadfac[4];       /* rgba shadow */
483 } LampShadowSubSample;
484
485 typedef struct LampShadowSample {
486         LampShadowSubSample s[16];      /* MAX OSA */
487 } LampShadowSample;
488
489 typedef struct LampRen {
490         struct LampRen *next, *prev;
491         
492         float xs, ys, dist;
493         float co[3];
494         short type;
495         int mode;
496         float r, g, b, k;
497         float shdwr, shdwg, shdwb;
498         float energy, haint;
499         int lay;
500         float spotsi,spotbl;
501         float vec[3];
502         float xsp, ysp, distkw, inpr;
503         float halokw, halo;
504         
505         short falloff_type;
506         float ld1,ld2;
507         struct CurveMapping *curfalloff;
508
509         /* copied from Lamp, to decouple more rendering stuff */
510         /** Size of the shadowbuffer */
511         short bufsize;
512         /** Number of samples for the shadows */
513         short samp;
514         /** Softness factor for shadow */
515         float soft;
516         /** amount of subsample buffers and type of filter for sampling */
517         short buffers, filtertype;
518         /** shadow buffer type (regular, irregular) */
519         short buftype;
520         /** autoclip */
521         short bufflag;
522         /** shadow plus halo: detail level */
523         short shadhalostep;
524         /** Near clip of the lamp */
525         float clipsta;
526         /** Far clip of the lamp */
527         float clipend;
528         /** A small depth offset to prevent self-shadowing. */
529         float bias;
530         
531         short ray_samp, ray_sampy, ray_sampz, ray_samp_method, ray_samp_type, area_shape, ray_totsamp;
532         short xold[BLENDER_MAX_THREADS], yold[BLENDER_MAX_THREADS];     /* last jitter table for area lights */
533         float area_size, area_sizey, area_sizez;
534         float adapt_thresh;
535
536         /* sun/sky */
537         struct SunSky *sunsky;
538         
539         struct ShadBuf *shb;
540         float *jitter;
541         
542         float imat[3][3];
543         float spottexfac;
544         float sh_invcampos[3], sh_zfac; /* sh_= spothalo */
545         
546         float mat[3][3];        /* 3x3 part from lampmat x viewmat */
547         float area[8][3], areasize;
548         
549         /* passes & node shader support: all shadow info for a pixel */
550         LampShadowSample *shadsamp;
551                 
552         /* yafray: photonlight params */
553         int YF_numphotons, YF_numsearch;
554         short YF_phdepth, YF_useqmc, YF_bufsize;
555         float YF_causticblur, YF_ltradius;
556         float YF_glowint, YF_glowofs;
557         short YF_glowtype;
558         
559         /* ray optim */
560         struct RayObject *last_hit[BLENDER_MAX_THREADS];
561         
562         struct MTex *mtex[MAX_MTEX];
563
564         /* threading */
565         int thread_assigned;
566         int thread_ready;
567 } LampRen;
568
569 /* **************** defines ********************* */
570
571 /* R.r.mode flag is same as for renderdata */
572
573 /* R.flag */
574 #define R_ZTRA                  1
575 #define R_HALO                  2
576 #define R_SEC_FIELD             4
577 #define R_LAMPHALO              8
578 #define R_GLOB_NOPUNOFLIP       16
579 #define R_NEED_TANGENT  32
580 #define R_BAKE_TRACE    128
581 #define R_BAKING                256
582
583 /* vlakren->flag (vlak = face in dutch) char!!! */
584 #define R_SMOOTH                1
585 #define R_HIDDEN                2
586 /* strand flag, means special handling */
587 #define R_STRAND                4
588 #define R_NOPUNOFLIP    8
589 #define R_FULL_OSA              16
590 #define R_FACE_SPLIT    32
591 /* Tells render to divide face other way. */
592 #define R_DIVIDE_24             64      
593 /* vertex normals are tangent or view-corrected vector, for hair strands */
594 #define R_TANGENT               128             
595
596 /* strandbuffer->flag */
597 #define R_STRAND_BSPLINE        1
598 #define R_STRAND_B_UNITS        2
599
600 /* objectren->flag */
601 #define R_INSTANCEABLE          1
602
603 /* objectinstance->flag */
604 #define R_DUPLI_TRANSFORMED     1
605 #define R_ENV_TRANSFORMED       2
606 #define R_TRANSFORMED           (1|2)
607 #define R_NEED_VECTORS          4
608
609 #endif /* RENDER_TYPES_H */
610