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