609c391d599d0ad1d10a02c446c62ed290b4eaeb
[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_scene_types.h"
36 #include "DNA_world_types.h"
37 #include "DNA_object_types.h"
38 #include "DNA_vec_types.h"
39
40 #include "BLI_threads.h"
41
42 #include "RE_pipeline.h"
43 #include "RE_shader_ext.h"      /* TexResult, ShadeResult, ShadeInput */
44
45 struct Object;
46 struct MemArena;
47 struct VertTableNode;
48 struct VlakTableNode;
49 struct Octree;
50 struct GHash;
51
52 #define TABLEINITSIZE 1024
53 #define LAMPINITSIZE 256
54
55 typedef struct SampleTables
56 {
57         float centLut[16];
58         float *fmask1[9], *fmask2[9];
59         char cmask[256], *centmask;
60         
61 } SampleTables;
62
63 /* this is handed over to threaded hiding/passes/shading engine */
64 typedef struct RenderPart
65 {
66         struct RenderPart *next, *prev;
67         
68         /* result of part rendering */
69         RenderResult *result;
70         
71         int *rectp;                     /* polygon index table */
72         int *rectz;                                             /* zbuffer */
73         long *rectdaps;                                 /* delta acum buffer for pixel structs */
74         
75         rcti disprect;                                  /* part coordinates within total picture */
76         int rectx, recty;                               /* the size */
77         short crop, ready;                              /* crop is amount of pixels we crop, for filter */
78         short sample, nr;                               /* sample can be used by zbuffers, nr is partnr */
79         short thread;                                   /* thread id */
80         
81         char *clipflag;                                 /* clipflags for part zbuffering */
82 } RenderPart;
83
84 typedef struct Octree {
85         struct Branch **adrbranch;
86         struct Node **adrnode;
87         float ocsize;   /* ocsize: mult factor,  max size octree */
88         float ocfacx,ocfacy,ocfacz;
89         float min[3], max[3];
90         int ocres;
91         int branchcount, nodecount;
92 } Octree;
93
94 /* controls state of render, everything that's read-only during render stage */
95 struct Render
96 {
97         struct Render *next, *prev;
98         char name[RE_MAXNAME];
99         
100         /* state settings */
101         short flag, osa, ok, do_gamma;
102         
103         /* result of rendering */
104         RenderResult *result;
105         /* if render with single-layer option, other rendered layers are stored here */
106         RenderResult *pushedresult;
107         
108         /* window size, display rect, viewplane */
109         int winx, winy;
110         rcti disprect;                  /* part within winx winy */
111         rctf viewplane;                 /* mapped on winx winy */
112         float viewdx, viewdy;   /* size of 1 pixel */
113         float clipcrop;                 /* 2 pixel boundary to prevent clip when filter used */
114         
115         /* final picture width and height (within disprect) */
116         int rectx, recty;
117         
118         /* real maximum amount of xparts/yparts after correction for minimum */
119         int xparts, yparts;
120         /* real maximum size of parts after correction for minimum 
121            partx*xparts can be larger than rectx, in that case last part is smaller */
122         int partx, party;
123         
124         /* values for viewing */
125         float lens, ycor, viewfac;
126         float panophi, panosi, panoco, panodxp, panodxv;
127         
128         /* Matrices */
129         float grvec[3];                 /* for world */
130         float imat[3][3];               /* copy of viewinv */
131         float viewmat[4][4], viewinv[4][4];
132         float winmat[4][4];
133         
134         /* clippping */
135         float clipsta;
136         float clipend;
137         
138         /* samples */
139         SampleTables *samples;
140         float jit[32][2];
141         
142         /* scene, and its full copy of renderdata and world */
143         Scene *scene;
144         RenderData r;
145         World wrld;
146         
147         ListBase parts;
148         
149         /* octree tables and variables for raytrace */
150         Octree oc;
151         
152         /* use this instead of R.r.cfra */
153         float cfra;     
154         
155         /* render database */
156         int totvlak, totvert, tothalo, totlamp;
157         ListBase lights;        /* GroupObject pointers */
158         ListBase lampren;       /* storage, for free */
159         
160         int vertnodeslen;
161         struct VertTableNode *vertnodes;
162         int vlaknodeslen;
163         struct VlakTableNode *vlaknodes;
164         int blohalen;
165         struct HaloRen **bloha;
166         ListBase objecttable;
167
168         struct Image *backbuf, *bakebuf;
169         
170         struct GHash *orco_hash;
171
172         ListBase customdata_names;
173
174         /* arena for allocating data for use during render, for
175                 * example dynamic TFaces to go in the VlakRen structure.
176                 */
177         struct MemArena *memArena;
178         
179         /* callbacks */
180         void (*display_init)(RenderResult *rr);
181         void (*display_clear)(RenderResult *rr);
182         void (*display_draw)(RenderResult *rr, volatile rcti *rect);
183         
184         void (*stats_draw)(RenderStats *ri);
185         void (*timecursor)(int i);
186         
187         int (*test_break)(void);
188         int (*test_return)(void);
189         void (*error)(char *str);
190         
191         RenderStats i;
192 };
193
194 /* ------------------------------------------------------------------------- */
195
196 struct ISBData;
197
198 typedef struct ShadSampleBuf {
199         struct ShadSampleBuf *next, *prev;
200         long *zbuf;
201         char *cbuf;
202 } ShadSampleBuf;
203
204 typedef struct ShadBuf {
205         /* regular shadowbuffer */
206         short samp, shadhalostep, totbuf;
207         float persmat[4][4];
208         float viewmat[4][4];
209         float winmat[4][4];
210         float *jit, *weight;
211         float d, clipend, pixsize, soft;
212         int co[3];
213         int size, bias;
214         ListBase buffers;
215         
216         /* irregular shadowbufer, result stored per thread */
217         struct ISBData *isb_result[BLENDER_MAX_THREADS];
218 } ShadBuf;
219
220 /* ------------------------------------------------------------------------- */
221 /* lookup of objects in database */
222 typedef struct ObjectRen {
223         struct ObjectRen *next, *prev;
224         struct Object *ob, *par;
225         int index, startvert, endvert, startface, endface;
226         float *vectors;
227 } ObjectRen;
228
229 /* ------------------------------------------------------------------------- */
230
231 typedef struct VertRen
232 {
233         float co[3];
234         float n[3];
235         float ho[4];
236         float *orco;
237         short clip;     
238         unsigned short flag;            /* in use for clipping zbuffer parts, temp setting stuff in convertblender.c */
239         float accum;            /* accum for radio weighting, and for strand texco static particles */
240         int index;                      /* index allows extending vertren with any property */
241 } VertRen;
242
243 /* ------------------------------------------------------------------------- */
244
245 struct halosort {
246         struct HaloRen *har;
247         int z;
248 };
249
250 /* ------------------------------------------------------------------------- */
251 struct Material;
252 struct MTFace;
253
254 typedef struct RadFace {
255         float unshot[3], totrad[3];
256         float norm[3], cent[3], area;
257         int flag;
258 } RadFace;
259
260 typedef struct VlakRen {
261         struct VertRen *v1, *v2, *v3, *v4;      /* keep in order for ** addressing */
262         unsigned int lay;
263         float n[3];
264         struct Material *mat;
265         char snproj, puno;
266         char flag, ec;
267         RadFace *radface;
268         Object *ob;
269         int index;
270 } VlakRen;
271
272 typedef struct HaloRen
273 {       
274     short miny, maxy;
275     float alfa, xs, ys, rad, radsq, sin, cos, co[3], no[3];
276         float hard, b, g, r;
277     int zs, zd;
278     int zBufDist;       /* depth in the z-buffer coordinate system */
279     char starpoints, type, add, tex;
280     char linec, ringc, seed;
281         short flarec; /* used to be a char. why ?*/
282     float hasize;
283     int pixels;
284     unsigned int lay;
285     struct Material *mat;
286 } HaloRen;
287
288 struct LampRen;
289 struct MTex;
290
291 /**
292  * For each lamp in a scene, a LampRen is created. It determines the
293  * properties of a lightsource.
294  */
295
296 typedef struct LampShadowSubSample {
297         int samplenr;
298         float shadfac[4];       /* rgba shadow */
299 } LampShadowSubSample;
300
301 typedef struct LampShadowSample {
302         LampShadowSubSample s[16];      /* MAX OSA */
303 } LampShadowSample;
304
305 typedef struct LampRen {
306         struct LampRen *next, *prev;
307         
308         float xs, ys, dist;
309         float co[3];
310         short type, mode;
311         float r, g, b, k;
312         float energy, haint;
313         int lay;
314         float spotsi,spotbl;
315         float vec[3];
316         float xsp, ysp, distkw, inpr;
317         float halokw, halo;
318         float ld1,ld2;
319
320         /* copied from Lamp, to decouple more rendering stuff */
321         /** Size of the shadowbuffer */
322         short bufsize;
323         /** Number of samples for the shadows */
324         short samp;
325         /** Softness factor for shadow */
326         float soft;
327         /** amount of subsample buffers and type of filter for sampling */
328         short buffers, filtertype;
329         /** shadow buffer type (regular, irregular) */
330         short buftype;
331         /** autoclip */
332         short bufflag;
333         /** shadow plus halo: detail level */
334         short shadhalostep;
335         /** Near clip of the lamp */
336         float clipsta;
337         /** Far clip of the lamp */
338         float clipend;
339         /** A small depth offset to prevent self-shadowing. */
340         float bias;
341         
342         short ray_samp, ray_sampy, ray_sampz, ray_samp_type, area_shape, ray_totsamp;
343         short xold[BLENDER_MAX_THREADS], yold[BLENDER_MAX_THREADS];     /* last jitter table for area lights */
344         float area_size, area_sizey, area_sizez;
345         
346         struct ShadBuf *shb;
347         float *jitter;
348         
349         float imat[3][3];
350         float spottexfac;
351         float sh_invcampos[3], sh_zfac; /* sh_= spothalo */
352         
353         float mat[3][3];        /* 3x3 part from lampmat x viewmat */
354         float area[8][3], areasize;
355         
356         /* passes & node shader support: all shadow info for a pixel */
357         LampShadowSample *shadsamp;
358         
359         /* yafray: photonlight params */
360         int YF_numphotons, YF_numsearch;
361         short YF_phdepth, YF_useqmc, YF_bufsize;
362         float YF_causticblur, YF_ltradius;
363         float YF_glowint, YF_glowofs;
364         short YF_glowtype;
365         
366         /* ray optim */
367         VlakRen *vlr_last[BLENDER_MAX_THREADS];
368         
369         struct MTex *mtex[MAX_MTEX];
370 } LampRen;
371
372 /* **************** defines ********************* */
373
374 /* R.r.mode flag is same as for renderdata */
375
376 /* R.flag */
377 #define R_ZTRA                  1
378 #define R_HALO                  2
379 #define R_SEC_FIELD             4
380 #define R_LAMPHALO              8
381 #define R_GLOB_NOPUNOFLIP       16
382
383 /* vlakren->flag (vlak = face in dutch) char!!! */
384 #define R_SMOOTH                1
385 #define R_VISIBLE               2
386 /* strand flag, means special handling */
387 #define R_STRAND                4
388 #define R_NOPUNOFLIP    8
389 #define R_FULL_OSA              16
390 #define R_FACE_SPLIT    32
391 /* Tells render to divide face other way. */
392 #define R_DIVIDE_24             64      
393 /* vertex normals are tangent or view-corrected vector, for hair strands */
394 #define R_TANGENT               128             
395
396
397
398
399
400 #endif /* RENDER_TYPES_H */
401