New feature: "Stress" texture input channel
[blender-staging.git] / source / blender / render / extern / include / render.h
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL 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. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  * Interface to transform the Blender scene into renderable data.
32  */
33
34 #ifndef RENDER_H
35 #define RENDER_H
36
37 /* ------------------------------------------------------------------------- */
38 /* This little preamble might be moved to a separate include. It contains    */
39 /* some defines that should become functions, and some platform dependency   */
40 /* fixes. I think it is risky to always include it...                        */
41 /* ------------------------------------------------------------------------- */
42
43
44 #ifdef __cplusplus
45 extern "C" { 
46 #endif
47
48 /* ------------------------------------------------------------------------- */
49 /* Types                                                                     */
50 /* Both external and internal types can be placed here. Make sure there are  */
51 /* no dirty extras in the type files so they can be included without         */
52 /* problems. If possible, make a note why the include is needed.             */
53 /* ------------------------------------------------------------------------- */
54
55 #include "render_types.h"
56
57 /* ------------------------------------------------------------------------- */
58 /* Global variables                                                          */
59 /* These variable are global to the render module, and also externally       */
60 /* visible. The file where they are defined must be added.                   */
61 /* ------------------------------------------------------------------------- */
62
63 extern RE_Render         R;           /* rendercore.c */
64 extern unsigned short   *igamtab1;    /* initrender.c */
65 extern unsigned short   *gamtab;      /* initrender.c */
66
67 struct View3D;
68
69 /* ------------------------------------------------------------------------- */
70 /* Function definitions                                                      */
71 /*                                                                           */
72 /* All functions that need to be externally visible must be declared here.   */
73 /* Currently, this interface contains 38 functions and 11 callbacks.         */
74 /* ------------------------------------------------------------------------- */
75
76
77 /* ------------------------------------------------------------------------- */
78 /* shadbuf.c (1)                                                           */
79 /* ------------------------------------------------------------------------- */
80
81 /* only for renderconvertor */
82 void RE_initshadowbuf(struct LampRen *lar, float mat[][4]);
83
84
85 /* ------------------------------------------------------------------------- */
86 /* initrender (9)                                                           */
87 /* ------------------------------------------------------------------------- */
88
89 struct View3D;
90
91 /**
92  * Guarded call to frame renderer? Tests several limits and boundary
93  * conditions. 
94  * 
95  * @param ogl_render_area The View3D area to use for OpenGL rendering
96  * (can be NULL unless render R_OGL flag is set)
97  */
98 void    RE_initrender(struct View3D *ogl_render_view3d);
99
100 /**
101  * only for renderconvertor
102  */
103 void    RE_setwindowclip(int mode, int jmode);
104
105 /*
106  * @param ogl_render_area The View3D area to use for OpenGL rendering
107  * (can be NULL unless render R_OGL flag is set)
108  */
109 void    RE_animrender(struct View3D *ogl_render_view3d);
110 void    RE_free_render_data(void);
111 void    RE_init_render_data(void);
112                 /* jitterate is used by blenkernel effect */
113 void    RE_jitterate1(float *jit1, float *jit2, int num, float rad1);
114 void    RE_jitterate2(float *jit1, float *jit2, int num, float rad2);
115 void    RE_make_existing_file(char *name);
116 void    RE_floatbuffer_to_output(void);
117
118 /* ------------------------------------------------------------------------- */
119 /* zbuf (2)                                                                  */
120 /* ------------------------------------------------------------------------- */
121
122 /**
123  * Converts a world coordinate into a homogenous coordinate in view
124  * coordinates. (WCS -> HCS)
125  * Also called in: shadbuf.c render.c radfactors.c
126  *                 initrender.c envmap.c editmesh.c
127  * @param v1  [3 floats] the world coordinate
128  * @param adr [4 floats] the homogenous view coordinate
129  */
130 void    RE_projectverto(float *v1,float *adr);
131
132 /**
133  * Something about doing radiosity z buffering?
134  * (called in radfactors.c), hope the RadView is defined already... 
135  * Also called in: radfactors.c
136  * Note: Uses globals.
137  * @param radview radiosity view definition
138  */
139         struct RadView;
140         struct RNode;
141 void    RE_zbufferall_radio(struct RadView *vw, struct RNode **rg_elem, int rg_totelem);
142
143
144 /* ------------------------------------------------------------------------- */
145 /* texture  (9)                                                                  */
146 /* ------------------------------------------------------------------------- */
147 struct MTex;
148 struct Tex;
149
150 void init_render_textures(void);
151 void init_render_texture(struct Tex *tex);
152
153 void do_material_tex(ShadeInput *shi);
154 void do_lamp_tex(struct LampRen *la, float *lavec, ShadeInput *shi, float *fcol);
155
156 int multitex_ext(struct Tex *tex, float *texvec, float *tin, float *tr, float *tg, float *tb, float *ta);
157 void externtex(struct MTex *mtex, float *vec, float *tin, float *tr, float *tg, float *tb, float *ta);
158
159 /* ------------------------------------------------------------------------- */
160 /* envmap (4)                                                                   */
161 /* ------------------------------------------------------------------------- */
162 struct EnvMap;
163
164 void    RE_free_envmapdata(struct EnvMap *env);
165 void    RE_free_envmap(struct EnvMap *env);
166 struct EnvMap *RE_add_envmap(void);
167 /* these two maybe not external? yes, they are, for texture.c */
168 struct EnvMap *RE_copy_envmap(struct EnvMap *env);
169
170 /* --------------------------------------------------------------------- */
171 /* rendercore (12)                                                        */
172 /* --------------------------------------------------------------------- */
173 struct MaterialLayer;
174 struct ShadeResult;
175
176 float Phong_Spec(float *n, float *l, float *v, int hard, int tangent);
177 float CookTorr_Spec(float *n, float *l, float *v, int hard, int tangent);
178 float Blinn_Spec(float *n, float *l, float *v, float refrac, float spec_power, int tangent);
179 float Toon_Spec( float *n, float *l, float *v, float size, float smooth, int tangent);
180 float WardIso_Spec(float *n, float *l, float *v, float rms, int tangent);
181
182 float OrenNayar_Diff(float *n, float *l, float *v, float rough);
183 float Toon_Diff( float *n, float *l, float *v, float size, float smooth);
184 float Minnaert_Diff( float nl, float *n, float *v, float darkness);
185 float Fresnel_Diff(float *vn, float *lv, float *view, float ior, float fac);
186
187 void add_to_diffuse(float *diff, ShadeInput *shi, float is, float r, float g, float b);
188 void ramp_diffuse_result(float *diff, ShadeInput *shi);
189 void do_specular_ramp(ShadeInput *shi, float is, float t, float *spec);
190 void ramp_spec_result(float *specr, float *specg, float *specb, ShadeInput *shi);
191
192 void matlayer_blend(struct MaterialLayer *ml, float blendfac, struct ShadeResult *target, struct ShadeResult *src);
193
194 /* --------------------------------------------------------------------- */
195 /* ray.c (2)                                                        */
196 /* --------------------------------------------------------------------- */
197 void init_jitter_plane(LampRen *lar);
198 void init_ao_sphere(float *sphere, int tot, int iter);
199
200
201 /* --------------------------------------------------------------------- */
202 /* renderdatabase ()                                                    */
203 /* --------------------------------------------------------------------- */
204 struct VlakRen *RE_findOrAddVlak(int nr);
205 struct VertRen *RE_findOrAddVert(int nr);
206 struct HaloRen *RE_findOrAddHalo(int nr);
207 HaloRen *RE_inithalo(struct Material *ma, float *vec, float *vec1, float *orco, float hasize, 
208                                         float vectsize, int seed);
209
210 float *RE_vertren_get_sticky(struct VertRen *ver, int verify);
211 float *RE_vertren_get_stress(struct VertRen *ver, int verify);
212 float *RE_vertren_get_rad(struct VertRen *ver, int verify);
213 float *RE_vertren_get_strand(struct VertRen *ver, int verify);
214 float *RE_vertren_get_tangent(struct VertRen *ver, int verify);
215
216 void RE_free_vertex_tables(void);
217 void RE_init_vertex_tables(void);
218
219 /**
220         * callbacks (11):
221         *
222         * If the callbacks aren't set, rendering will still proceed as
223         * desired, but the concerning functionality will not be enabled.
224         *
225         * There need to be better uncoupling between the renderer and
226         * these functions still!
227         * */
228
229 void RE_set_test_break_callback(int (*f)(void));
230
231 void RE_set_timecursor_callback(void (*f)(int));
232
233 void RE_set_renderdisplay_callback(void (*f)(int, int, int, int, unsigned int *));
234 void RE_set_initrenderdisplay_callback(void (*f)(void));
235 void RE_set_clearrenderdisplay_callback(void (*f)(short));
236
237 void RE_set_printrenderinfo_callback(void (*f)(double,int));
238
239 void RE_set_getrenderdata_callback(void (*f)(void));
240 void RE_set_freerenderdata_callback(void (*f)(void));
241
242
243 /*from renderhelp, should disappear!!! */ 
244 /** Recalculate all normals on renderdata. */
245 void set_normalflags(void);
246 /**
247         * On loan from zbuf.h:
248         * Tests whether the first three coordinates should be clipped
249         * wrt. the fourth component. Bits 1 and 2 test on x, 3 and 4 test on
250         * y, 5 and 6 test on z:
251         * xyz >  test => set first bit   (01),
252         * xyz < -test => set second bit  (10),
253         * xyz == test => reset both bits (00).
254         * Note: functionality is duplicated from an internal function
255         * Also called in: initrender.c, radfactors.c
256         * @param  v [4 floats] a coordinate 
257         * @return a vector of bitfields
258         */
259 int RE_testclip(float *v); 
260
261 /* patch for the external if, to support the split for the ui */
262 void RE_addalphaAddfac(char *doel, char *bron, char addfac);
263 void RE_sky_char(float *view, char *col); 
264 void RE_renderflare(struct HaloRen *har); 
265 /**
266         * Shade the pixel at xn, yn for halo har, and write the result to col. 
267         * Also called in: previewrender.c
268         * @param har    The halo to be rendered on this location
269         * @param col    [char 4] The destination colour vector 
270         * @param colf   [float 4] destination colour vector (need both)
271         * @param zz     Some kind of distance
272         * @param dist   Square of the distance of this coordinate to the halo's center
273         * @param x      [f] Pixel x relative to center
274         * @param y      [f] Pixel y relative to center
275         * @param flarec Flare counter? Always har->flarec...
276         */
277 void RE_shadehalo(struct HaloRen *har,
278                                 char *col, float *colf, 
279                                 int zz,
280                                 float dist,
281                                 float x,
282                                 float y,
283                                 short flarec); 
284
285 /***/
286
287 /* haloren->type: flags */
288
289 #define HA_ONLYSKY              1
290 #define HA_VECT                 2
291 #define HA_XALPHA               4
292 #define HA_FLARECIRC    8
293
294 #ifdef __cplusplus
295 }
296 #endif
297
298 #endif /* RENDER_H */
299