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