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