source/blender/render/extern/include/RE_pipeline.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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  *
  20  * The Original Code is Copyright (C) 2006 Blender Foundation.
  21  * All rights reserved.
  22  *
  23  * The Original Code is: all of this file.
  24  *
  25  * Contributor(s): none yet.
  26  *
  27  * ***** END GPL LICENSE BLOCK *****
  28  */
  29
  30 /** \file RE_pipeline.h
  31  *  \ingroup render
  32  */
  33
  34 #ifndef RE_PIPELINE_H
  35 #define RE_PIPELINE_H
  36
  37 #include "DNA_listBase.h"
  38 #include "DNA_vec_types.h"
  39 #include "RNA_types.h"
  40
  41 struct bNodeTree;
  42 struct Image;
  43 struct Main;
  44 struct NodeBlurData;
  45 struct Object;
  46 struct RenderData;
  47 struct RenderEngine;
  48 struct RenderEngineType;
  49 struct RenderResult;
  50 struct ReportList;
  51 struct ReportList;
  52 struct Scene;
  53 struct SceneRenderLayer;
  54 struct EnvMap;
  55
  56 /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  57 /* this include is what is exposed of render to outside world */
  58 /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  59
  60
  61 #define RE_MAXNAME      32
  62
  63 /* only used as handle */
  64 typedef struct Render Render;
  65
  66 /* Render Result usage:
  67
  68 - render engine allocates/frees and delivers raw floating point rects
  69 - right now it's full rects, but might become tiles or file
  70 - the display client has to allocate display rects, sort out what to display,
  71   and how it's converted
  72 */
  73
  74 typedef struct RenderPass {
  75         struct RenderPass *next, *prev;
  76         int passtype, channels;
  77         char name[16];          /* amount defined in openexr_multi.h */
  78         char chan_id[8];        /* amount defined in openexr_multi.h */
  79         float *rect;
  80         int rectx, recty;
  81 } RenderPass;
  82
  83 /* a renderlayer is a full image, but with all passes and samples */
  84 /* size of the rects is defined in RenderResult */
  85 /* after render, the Combined pass is in rectf, for renderlayers read from files it is a real pass */
  86 typedef struct RenderLayer {
  87         struct RenderLayer *next, *prev;
  88
  89         /* copy of RenderData */
  90         char name[RE_MAXNAME];
  91         unsigned int lay, lay_zmask;
  92         int layflag, passflag, pass_xor;
  93
  94         struct Material *mat_override;
  95         struct Group *light_override;
  96
  97         float *rectf;           /* 4 float, standard rgba buffer (read not above!) */
  98         float *acolrect;        /* 4 float, optional transparent buffer, needs storage for display updates */
  99         float *scolrect;        /* 4 float, optional strand buffer, needs storage for display updates */
 100         int rectx, recty;
 101
 102         ListBase passes;
 103
 104 } RenderLayer;
 105
 106 typedef struct RenderResult {
 107         struct RenderResult *next, *prev;
 108
 109         /* target image size */
 110         int rectx, recty;
 111         short crop, sample_nr;
 112
 113         /* optional, 32 bits version of picture, used for ogl render and image curves */
 114         int *rect32;
 115         /* if this exists, a copy of one of layers, or result of composited layers */
 116         float *rectf;
 117         /* if this exists, a copy of one of layers, or result of composited layers */
 118         float *rectz;
 119
 120         /* coordinates within final image (after cropping) */
 121         rcti tilerect;
 122         /* offset to apply to get a border render in full image */
 123         int xof, yof;
 124
 125         /* the main buffers */
 126         ListBase layers;
 127
 128         /* allowing live updates: */
 129         volatile rcti renrect;
 130         volatile RenderLayer *renlay;
 131
 132         /* optional saved endresult on disk */
 133         void *exrhandle;
 134
 135         /* for render results in Image, verify validity for sequences */
 136         int framenr;
 137
 138         /* for acquire image, to indicate if it there is a combined layer */
 139         int have_combined;
 140
 141         /* render info text */
 142         char *text;
 143
 144 } RenderResult;
 145
 146
 147 typedef struct RenderStats {
 148         int cfra;
 149         int totface, totvert, totstrand, tothalo, totlamp, totpart;
 150         short curfield, curblur, curpart, partsdone, convertdone, curfsa;
 151         double starttime, lastframetime;
 152         const char *infostr, *statstr;
 153         char scenename[32];
 154
 155 } RenderStats;
 156
 157 /* *********************** API ******************** */
 158
 159 /* the name is used as identifier, so elsewhere in blender the result can retrieved */
 160 /* calling a new render with same name, frees automatic existing render */
 161 struct Render *RE_NewRender (const char *name);
 162 struct Render *RE_GetRender(const char *name);
 163
 164 /* returns 1 while render is working (or renders called from within render) */
 165 int RE_RenderInProgress(struct Render *re);
 166
 167 /* assign default dummy callbacks */
 168 void RE_InitRenderCB(struct Render *re);
 169
 170 /* use free render as signal to do everything over (previews) */
 171 void RE_FreeRender (struct Render *re);
 172 /* only called on exit */
 173 void RE_FreeAllRender (void);
 174
 175 /* get results and statistics */
 176 void RE_FreeRenderResult(struct RenderResult *rr);
 177 struct RenderResult *RE_AcquireResultRead(struct Render *re);
 178 struct RenderResult *RE_AcquireResultWrite(struct Render *re);
 179 void RE_ReleaseResult(struct Render *re);
 180 void RE_AcquireResultImage(struct Render *re, struct RenderResult *rr);
 181 void RE_ReleaseResultImage(struct Render *re);
 182 void RE_SwapResult(struct Render *re, struct RenderResult **rr);
 183 struct RenderStats *RE_GetStats(struct Render *re);
 184 void RE_ResultGet32(struct Render *re, unsigned int *rect);
 185 struct RenderLayer *RE_GetRenderLayer(struct RenderResult *rr, const char *name);
 186 float *RE_RenderLayerGetPass(struct RenderLayer *rl, int passtype);
 187
 188 /* obligatory initialize call, disprect is optional */
 189 void RE_InitState (struct Render *re, struct Render *source, struct RenderData *rd, struct SceneRenderLayer *srl, int winx, int winy, rcti *disprect);
 190
 191 /* use this to change disprect of active render */
 192 void RE_SetDispRect (struct Render *re, rcti *disprect);
 193
 194 /* set up the viewplane/perspective matrix, three choices */
 195 struct Object *RE_GetCamera(struct Render *re); /* return camera override if set */
 196 void RE_SetCamera(struct Render *re, struct Object *camera);
 197 void RE_SetWindow (struct Render *re, rctf *viewplane, float clipsta, float clipend);
 198 void RE_SetOrtho (struct Render *re, rctf *viewplane, float clipsta, float clipend);
 199 void RE_SetPixelSize(struct Render *re, float pixsize);
 200
 201 /* option to set viewmatrix before making dbase */
 202 void RE_SetView (struct Render *re, float mat[][4]);
 203
 204 /* make or free the dbase */
 205 void RE_Database_FromScene(struct Render *re, struct Main *bmain, struct Scene *scene, unsigned int lay, int use_camera_view);
 206 void RE_Database_Free (struct Render *re);
 207
 208 /* project dbase again, when viewplane/perspective changed */
 209 void RE_DataBase_ApplyWindow(struct Render *re);
 210
 211 /* override the scene setting for amount threads, commandline */
 212 void RE_set_max_threads(int threads);
 213
 214 /* set the render threads based on the commandline and autothreads setting */
 215 void RE_init_threadcount(Render *re);
 216
 217 /* the main processor, assumes all was set OK! */
 218 void RE_TileProcessor(struct Render *re);
 219
 220 /* only RE_NewRender() needed, main Blender render calls */
 221 void RE_BlenderFrame(struct Render *re, struct Main *bmain, struct Scene *scene, struct SceneRenderLayer *srl, struct Object *camera_override, unsigned int lay, int frame, const short write_still);
 222 void RE_BlenderAnim(struct Render *re, struct Main *bmain, struct Scene *scene, struct Object *camera_override, unsigned int lay, int sfra, int efra, int tfra);
 223
 224 /* error reporting */
 225 void RE_SetReports(struct Render *re, struct ReportList *reports);
 226
 227 /* main preview render call */
 228 void RE_PreviewRender(struct Render *re, struct Main *bmain, struct Scene *scene);
 229
 230 int RE_ReadRenderResult(struct Scene *scene, struct Scene *scenode);
 231 int RE_WriteRenderResult(struct ReportList *reports, RenderResult *rr, const char *filename, int compress);
 232 struct RenderResult *RE_MultilayerConvert(void *exrhandle, int rectx, int recty);
 233
 234 extern const float default_envmap_layout[];
 235 int RE_WriteEnvmapResult(struct ReportList *reports, struct Scene *scene, struct EnvMap *env, const char *relpath, int imtype, float layout[12]);
 236
 237 /* do a full sample buffer compo */
 238 void RE_MergeFullSample(struct Render *re, struct Main *bmain, struct Scene *sce, struct bNodeTree *ntree);
 239
 240 /* ancient stars function... go away! */
 241 void RE_make_stars(struct Render *re, struct Scene *scenev3d, void (*initfunc)(void),
 242                                    void (*vertexfunc)(float*),  void (*termfunc)(void));
 243
 244 /* display and event callbacks */
 245 void RE_display_init_cb (struct Render *re, void *handle, void (*f)(void *handle, RenderResult *rr));
 246 void RE_display_clear_cb(struct Render *re, void *handle, void (*f)(void *handle, RenderResult *rr));
 247 void RE_display_draw_cb (struct Render *re, void *handle, void (*f)(void *handle, RenderResult *rr, volatile struct rcti *rect));
 248 void RE_stats_draw_cb   (struct Render *re, void *handle, void (*f)(void *handle, RenderStats *rs));
 249 void RE_progress_cb     (struct Render *re, void *handle, void (*f)(void *handle, float));
 250 void RE_draw_lock_cb            (struct Render *re, void *handle, void (*f)(void *handle, int));
 251 void RE_test_break_cb   (struct Render *re, void *handle, int (*f)(void *handle));
 252
 253 /* should move to kernel once... still unsure on how/where */
 254 float RE_filter_value(int type, float x);
 255 /* vector blur zbuffer method */
 256 void RE_zbuf_accumulate_vecblur(struct NodeBlurData *nbd, int xsize, int ysize, float *newrect, float *imgrect, float *vecbufrect, float *zbufrect);
 257
 258 /* shaded view or baking options */
 259 #define RE_BAKE_LIGHT                           0       /* not listed in rna_scene.c -> can't be enabled! */
 260 #define RE_BAKE_ALL                                     1
 261 #define RE_BAKE_AO                                      2
 262 #define RE_BAKE_NORMALS                         3
 263 #define RE_BAKE_TEXTURE                         4
 264 #define RE_BAKE_DISPLACEMENT            5
 265 #define RE_BAKE_SHADOW                          6
 266 #define RE_BAKE_SPEC_COLOR                      7
 267 #define RE_BAKE_SPEC_INTENSITY          8
 268 #define RE_BAKE_MIRROR_COLOR            9
 269 #define RE_BAKE_MIRROR_INTENSITY        10
 270 #define RE_BAKE_ALPHA                           11
 271 #define RE_BAKE_EMIT                            12
 272
 273 void RE_Database_Baking(struct Render *re, struct Main *bmain, struct Scene *scene, unsigned int lay, const int type, struct Object *actob);
 274
 275 void RE_DataBase_GetView(struct Render *re, float mat[][4]);
 276 void RE_GetCameraWindow(struct Render *re, struct Object *camera, int frame, float mat[][4]);
 277 struct Scene *RE_GetScene(struct Render *re);
 278
 279 /* External Engine */
 280
 281 #define RE_INTERNAL                     1
 282 #define RE_GAME                         2
 283 #define RE_DO_PREVIEW           4
 284 #define RE_DO_ALL                       8
 285
 286 extern ListBase R_engines;
 287
 288 typedef struct RenderEngineType {
 289         struct RenderEngineType *next, *prev;
 290
 291         /* type info */
 292         char idname[64]; // best keep the same size as BKE_ST_MAXNAME
 293         char name[64];
 294         int flag;
 295
 296         void (*render)(struct RenderEngine *engine, struct Scene *scene);
 297
 298         /* RNA integration */
 299         ExtensionRNA ext;
 300 } RenderEngineType;
 301
 302 typedef struct RenderEngine {
 303         RenderEngineType *type;
 304         struct Render *re;
 305         ListBase fullresult;
 306 } RenderEngine;
 307
 308 void RE_layer_load_from_file(RenderLayer *layer, struct ReportList *reports, const char *filename, int x, int y);
 309 void RE_result_load_from_file(RenderResult *result, struct ReportList *reports, const char *filename);
 310
 311 struct RenderResult *RE_engine_begin_result(RenderEngine *engine, int x, int y, int w, int h);
 312 void RE_engine_update_result(RenderEngine *engine, struct RenderResult *result);
 313 void RE_engine_end_result(RenderEngine *engine, struct RenderResult *result);
 314
 315 int RE_engine_test_break(RenderEngine *engine);
 316 void RE_engine_update_stats(RenderEngine *engine, const char *stats, const char *info);
 317 void RE_engine_report(RenderEngine *engine, int type, const char *msg);
 318
 319 void RE_engines_init(void);
 320 void RE_engines_exit(void);
 321
 322 int RE_is_rendering_allowed(struct Scene *scene, struct Object *camera_override, struct ReportList *reports);
 323
 324 #endif /* RE_PIPELINE_H */
 325