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