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