archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
006b550f6f103e9d9b5d9cb2f4b0e8bdb21f7d35
blender-archive/source/blender/render/extern/include/RE_engine.h

165 lines
5.0 KiB
C++
Raw Normal View History

Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2006 Blender Foundation.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file RE_engine.h
* \ingroup render
*/
unify include guard defines, __$FILENAME__ without the underscores these clogged up the namespace for autocompleation which was annoying.
2012-02-17 18:59:41 +00:00
#ifndef __RE_ENGINE_H__
#define __RE_ENGINE_H__
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
#include "DNA_listBase.h"
Border rendering now works for all scenes used in compositor, before this only active scene would be rendered with border. When do_render_fields_blur_3d() is finished, it'll modify render's display rect so it'll correspond bordered render result placed on black backgrund. Actual border is stored nowhere, which makes it only way to re-calculate disprect for all other renders used in compo based on source. Not so big deal actually. Also needed to modify Cycles a bit, because before this patch it used border settings from scene being rendered. Now made it so render data is passing to external engines. Using a property inside RenderEngine structure for this. Not best ever design for passing render data, but this would prevent API breakage. So now external engines could access engine.render to access active rendering settings. Reviewed by Brecht, thanks!
2013-03-14 07:38:37 +00:00
#include "DNA_scene_types.h"
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
#include "RNA_types.h"
Bake API - bpy.ops.object.bake() New operator that can calls a bake function to the current render engine when available. This commit provides no feature for the users, but allows external engines to be accessed by the operator and be integrated with the baking api. The API itself is simple. Blender sends a populated array of BakePixels to the renderer, and gets back an array of floats with the result. The Blender Internal (and multires) system is still running independent, but we eventually will pipe it through the API as well. Cycles baking will come next as a separated commit Python Operator: ---------------- The operator can be called with some arguments, or a user interface can be created for it. In that case the arguments can be ommited and the interface can expose the settings from bpy.context.scene.render.bake bpy.ops.object.bake(type='COMBINED', filepath="", width=512, height=512, margin=16, use_selected_to_active=False, cage_extrusion=0, cage="", normal_space='TANGENT', normal_r='POS_X', normal_g='POS_Y', normal_b='POS_Z', save_mode='INTERNAL', use_clear=False, use_split_materials=False, use_automatic_name=False) Note: external save mode is currently disabled. Supported Features: ------------------ * Margin - Baked result is extended this many pixels beyond the border of each UV "island," to soften seams in the texture. * Selected to Active - bake shading on the surface of selected object to the active object. The rays are cast from the lowpoly object inwards towards the highpoly object. If the highpoly object is not entirely involved by the lowpoly object, you can tweak the rays start point with Cage Extrusion. For even more control of the cage you can use a Cage object. * Cage Extrusion - distance to use for the inward ray cast when using selected to active * Custom Cage - object to use as cage (instead of the lowpoly object). * Normal swizzle - change the axis that gets mapped to RGB * Normal space - save as tangent or object normal spaces Supported Passes: ----------------- Any pass that is supported by Blender renderlayer system. Though it's up to the external engine to provide a valid enum with its supported passes. Normal passes get a special treatment since we post-process them to converted and "swizzled" Development Notes for External Engines: --------------------------------------- (read them in bake_api.c) * For a complete implementation example look at the Cycles Bake commit (next). Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge Normal map pipeline "consulting" by Andy Davies (metalliandy) Original design by Brecht van Lommel. The entire commit history can be found on the branch: bake-cycles
2014-01-02 19:05:07 -02:00
#include "RE_bake.h"
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
Render API: shader script node for custom shaders. * Shader script node added, which stores either a link to a text datablock or file on disk, and has functions to add and remove sockets. * Callback RenderEngine.update_script_node(self, node) added for render engines to compile the shader and update the node with new sockets. Thanks to Thomas, Lukas and Dalai for the implementation.
2012-11-03 14:32:26 +00:00
struct bNode;
struct bNodeTree;
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
struct Object;
struct Render;
Border rendering now works for all scenes used in compositor, before this only active scene would be rendered with border. When do_render_fields_blur_3d() is finished, it'll modify render's display rect so it'll correspond bordered render result placed on black backgrund. Actual border is stored nowhere, which makes it only way to re-calculate disprect for all other renders used in compo based on source. Not so big deal actually. Also needed to modify Cycles a bit, because before this patch it used border settings from scene being rendered. Now made it so render data is passing to external engines. Using a property inside RenderEngine structure for this. Not best ever design for passing render data, but this would prevent API breakage. So now external engines could access engine.render to access active rendering settings. Reviewed by Brecht, thanks!
2013-03-14 07:38:37 +00:00
struct RenderData;
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
struct RenderEngine;
struct RenderEngineType;
struct RenderLayer;
struct RenderResult;
struct ReportList;
struct Scene;
Bake API - bpy.ops.object.bake() New operator that can calls a bake function to the current render engine when available. This commit provides no feature for the users, but allows external engines to be accessed by the operator and be integrated with the baking api. The API itself is simple. Blender sends a populated array of BakePixels to the renderer, and gets back an array of floats with the result. The Blender Internal (and multires) system is still running independent, but we eventually will pipe it through the API as well. Cycles baking will come next as a separated commit Python Operator: ---------------- The operator can be called with some arguments, or a user interface can be created for it. In that case the arguments can be ommited and the interface can expose the settings from bpy.context.scene.render.bake bpy.ops.object.bake(type='COMBINED', filepath="", width=512, height=512, margin=16, use_selected_to_active=False, cage_extrusion=0, cage="", normal_space='TANGENT', normal_r='POS_X', normal_g='POS_Y', normal_b='POS_Z', save_mode='INTERNAL', use_clear=False, use_split_materials=False, use_automatic_name=False) Note: external save mode is currently disabled. Supported Features: ------------------ * Margin - Baked result is extended this many pixels beyond the border of each UV "island," to soften seams in the texture. * Selected to Active - bake shading on the surface of selected object to the active object. The rays are cast from the lowpoly object inwards towards the highpoly object. If the highpoly object is not entirely involved by the lowpoly object, you can tweak the rays start point with Cage Extrusion. For even more control of the cage you can use a Cage object. * Cage Extrusion - distance to use for the inward ray cast when using selected to active * Custom Cage - object to use as cage (instead of the lowpoly object). * Normal swizzle - change the axis that gets mapped to RGB * Normal space - save as tangent or object normal spaces Supported Passes: ----------------- Any pass that is supported by Blender renderlayer system. Though it's up to the external engine to provide a valid enum with its supported passes. Normal passes get a special treatment since we post-process them to converted and "swizzled" Development Notes for External Engines: --------------------------------------- (read them in bake_api.c) * For a complete implementation example look at the Cycles Bake commit (next). Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge Normal map pipeline "consulting" by Andy Davies (metalliandy) Original design by Brecht van Lommel. The entire commit history can be found on the branch: bake-cycles
2014-01-02 19:05:07 -02:00
struct BakePixel;
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
/* External Engine */
RenderEngine: add .is_animation and .is_preview properties to detect if it's an animation or preview render that is being done.
2011-11-02 13:36:28 +00:00
/* RenderEngineType.flag */
Render API: add update_progress() function to update progress bar progress from external render engines. Also refactoring to move some render engine registration stuff out of RNA and into render module.
2011-10-22 17:01:54 +00:00
#define RE_INTERNAL 1
#define RE_GAME 2
#define RE_USE_PREVIEW 4
#define RE_USE_POSTPROCESS 8
RenderEngine/Nodes: system to check for shading nodes compatibility * Scene.use_shading_nodes property to check if RenderEngine is using new shading nodes system, and RenderEngine.bl_use_shading_nodes to set this. * Add mechanism for tagging nodes as being compatible with the old/new system.
2011-11-02 19:24:30 +00:00
#define RE_USE_SHADING_NODES 16
Fix #35681: cycles excluded layers still got evaluated before and after rendering even if they were not used on any render layers.
2013-06-10 13:53:38 +00:00
#define RE_USE_EXCLUDE_LAYERS 32
Fix #36091: external render engines like Luxrender don't work well with the save buffers option, it requires specific tile sizes and if they don't match what OpenEXR expects file saving can get stuck. Now I've made support for his optional, with a bl_use_save_buffers property for RenderEngine, set to False by default.
2013-07-11 12:22:29 +00:00
#define RE_USE_SAVE_BUFFERS 64
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
RenderEngine: add .is_animation and .is_preview properties to detect if it's an animation or preview render that is being done.
2011-11-02 13:36:28 +00:00
/* RenderEngine.flag */
#define RE_ENGINE_ANIMATION 1
#define RE_ENGINE_PREVIEW 2
RenderEngine: steps towards implementation of this proposal: http://wiki.blender.org/index.php/Dev:2.6/Source/Render/RenderEngineAPI * RenderEngine is now a persistent python object that exists and retains properties as long as a frame is being rendered. This is mostly useful now that more than one callback will be added. * Added update() callback that should ideally be used to export the scene, leaving only the rendering to the render() callback. This is not required to be used at this point, but separating this will make things more thread safe later on. * Added tag_redraw() and tag_update() functions that will be used for viewport rendering. * Internal change: status text is now retained after update_status calls.
2011-11-02 14:33:14 +00:00
#define RE_ENGINE_DO_DRAW 4
#define RE_ENGINE_DO_UPDATE 8
Render Engines: fix crash when changing render engine during rendering Crash would have been happen when changing render ending at the same time rendering happens. It could be final Cycles render or even preview LUX render.
2012-11-13 11:00:46 +00:00
#define RE_ENGINE_RENDERING 16
Highlight currently rendering tiles This commit implements highlight of tiles which are being currently rendered for both Blender Internal and Cycles (and should be possible to use it for other external engines as well). Couple of implementation details: - Added one extra boolean flag to render engine which should be set to truth if render engine wants to highlight tiles. If so, property use_highlight_tiles should be set to True. - Render Part's ready boolena was changed by status enum, which could be NONE, IN_PROGRESS and READY. All render part with IN_PROGRESS status will be highlighted in image editor. - For external engines render part's status is filling in automatically. Initially all render parts has got NONE status, then one external engine acquire render result, corresponding part will change status to IN_PROGRESS. As soon as render result is finished, corresponding render part will change status to FINISHED This should make it easy to highlight tiles for other engines as well.
2013-01-01 16:15:13 +00:00
#define RE_ENGINE_HIGHLIGHT_TILES 32
Fix threading issues of viewport rendering when using movies/generated images Issue was caused by the fact that guarded allocator is not thread-safe and generated images/movies could allocate memory when loading pixels to Cycles. Currently solved by switching memory allocator to using mutex lock (the same as sued for jobs) when viewport rendering is used. Nicer solution would be to make guarded allocator thread-safe by using atomic operations and lock-free lists, but that's more serious change.
2013-01-24 08:14:20 +00:00
#define RE_ENGINE_USED_FOR_VIEWPORT 64
RenderEngine: add .is_animation and .is_preview properties to detect if it's an animation or preview render that is being done.
2011-11-02 13:36:28 +00:00
Blender Internal Render in viewport Because of our release soon, feature has been added behind the Debug Menu. CTRL+ALT+D and set it to -1. Or commandline --debug-value -1. When debug set to -1, you can put the viewport to 'render' mode, just like for Cycles. Notes for testers: (and please no bugs in tracker for this :) - It renders without AA, MBlur, Panorama, Sequence, Composite - Only active render layer gets rendered. Select another layer will re-render. - But yes: it works for FreeStyle renders! - Also does great for local view. - BI is not well suited for incremental renders on view changes. This only works for non-raytrace scenes, or zoom in ortho or camera mode, or for Material changes. In most cases a full re-render is being done. - ESC works to stop the preview render. - Borders render as well. (CTRL+B) - Force a refresh with arrow key left/right. A lot of settings don't trigger re-render yet. Tech notes: - FreeStyle is adding a lot of temp objects/meshes in the Main database. This caused DepsGraph to trigger changes (and redraws). I've prepended the names for these temp objects with char number 27 (ESC), and made these names be ignored for tag update checking. - Fixed some bugs that were noticable with such excessive re-renders, like for opening file window, quit during renders.
2013-04-16 17:39:20 +00:00
/* RenderEngine.update_flag, used by internal now */
#define RE_ENGINE_UPDATE_MA 1
#define RE_ENGINE_UPDATE_OTHER 2
Fix #35979, #35937, #35739: undo crashes and missing updates with blender internal viewport rendering. Lots of tweaks here, mainly: * Stop 3D viewport render and free database before undo. * Accumulate update flags rather than replace them each time it rerenders, to avoid previous updates getting lost. * Don't check against Render struct view parameters for changes, those are set in the job thread which might not run before the next update call.
2013-07-08 22:26:10 +00:00
#define RE_ENGINE_UPDATE_DATABASE 4
Blender Internal Render in viewport Because of our release soon, feature has been added behind the Debug Menu. CTRL+ALT+D and set it to -1. Or commandline --debug-value -1. When debug set to -1, you can put the viewport to 'render' mode, just like for Cycles. Notes for testers: (and please no bugs in tracker for this :) - It renders without AA, MBlur, Panorama, Sequence, Composite - Only active render layer gets rendered. Select another layer will re-render. - But yes: it works for FreeStyle renders! - Also does great for local view. - BI is not well suited for incremental renders on view changes. This only works for non-raytrace scenes, or zoom in ortho or camera mode, or for Material changes. In most cases a full re-render is being done. - ESC works to stop the preview render. - Borders render as well. (CTRL+B) - Force a refresh with arrow key left/right. A lot of settings don't trigger re-render yet. Tech notes: - FreeStyle is adding a lot of temp objects/meshes in the Main database. This caused DepsGraph to trigger changes (and redraws). I've prepended the names for these temp objects with char number 27 (ESC), and made these names be ignored for tag update checking. - Fixed some bugs that were noticable with such excessive re-renders, like for opening file window, quit during renders.
2013-04-16 17:39:20 +00:00
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
extern ListBase R_engines;
typedef struct RenderEngineType {
struct RenderEngineType *next, *prev;
/* type info */
char idname[64]; // best keep the same size as BKE_ST_MAXNAME
char name[64];
int flag;
RenderEngine: steps towards implementation of this proposal: http://wiki.blender.org/index.php/Dev:2.6/Source/Render/RenderEngineAPI * RenderEngine is now a persistent python object that exists and retains properties as long as a frame is being rendered. This is mostly useful now that more than one callback will be added. * Added update() callback that should ideally be used to export the scene, leaving only the rendering to the render() callback. This is not required to be used at this point, but separating this will make things more thread safe later on. * Added tag_redraw() and tag_update() functions that will be used for viewport rendering. * Internal change: status text is now retained after update_status calls.
2011-11-02 14:33:14 +00:00
void (*update)(struct RenderEngine *engine, struct Main *bmain, struct Scene *scene);
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
void (*render)(struct RenderEngine *engine, struct Scene *scene);
Bake API - bpy.ops.object.bake() New operator that can calls a bake function to the current render engine when available. This commit provides no feature for the users, but allows external engines to be accessed by the operator and be integrated with the baking api. The API itself is simple. Blender sends a populated array of BakePixels to the renderer, and gets back an array of floats with the result. The Blender Internal (and multires) system is still running independent, but we eventually will pipe it through the API as well. Cycles baking will come next as a separated commit Python Operator: ---------------- The operator can be called with some arguments, or a user interface can be created for it. In that case the arguments can be ommited and the interface can expose the settings from bpy.context.scene.render.bake bpy.ops.object.bake(type='COMBINED', filepath="", width=512, height=512, margin=16, use_selected_to_active=False, cage_extrusion=0, cage="", normal_space='TANGENT', normal_r='POS_X', normal_g='POS_Y', normal_b='POS_Z', save_mode='INTERNAL', use_clear=False, use_split_materials=False, use_automatic_name=False) Note: external save mode is currently disabled. Supported Features: ------------------ * Margin - Baked result is extended this many pixels beyond the border of each UV "island," to soften seams in the texture. * Selected to Active - bake shading on the surface of selected object to the active object. The rays are cast from the lowpoly object inwards towards the highpoly object. If the highpoly object is not entirely involved by the lowpoly object, you can tweak the rays start point with Cage Extrusion. For even more control of the cage you can use a Cage object. * Cage Extrusion - distance to use for the inward ray cast when using selected to active * Custom Cage - object to use as cage (instead of the lowpoly object). * Normal swizzle - change the axis that gets mapped to RGB * Normal space - save as tangent or object normal spaces Supported Passes: ----------------- Any pass that is supported by Blender renderlayer system. Though it's up to the external engine to provide a valid enum with its supported passes. Normal passes get a special treatment since we post-process them to converted and "swizzled" Development Notes for External Engines: --------------------------------------- (read them in bake_api.c) * For a complete implementation example look at the Cycles Bake commit (next). Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge Normal map pipeline "consulting" by Andy Davies (metalliandy) Original design by Brecht van Lommel. The entire commit history can be found on the branch: bake-cycles
2014-01-02 19:05:07 -02:00
void (*bake)(struct RenderEngine *engine, struct Scene *scene, struct Object *object, const int pass_type, const struct BakePixel *pixel_array, const int num_pixels, const int depth, void *result);
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
RenderEngine api: support for viewport rendering, details here: http://wiki.blender.org/index.php/Dev:2.6/Source/Render/RenderEngineAPI * This adds a Rendered draw type in the 3D view, only available when the render engine implements the view_draw callback. * 3D view now stores a pointer to a RenderEngine. * view_draw() callback will do OpenGL drawing instead of the viewport. * view_update() callback is called after depsgraph updates.
2011-11-02 18:20:53 +00:00
void (*view_update)(struct RenderEngine *engine, const struct bContext *context);
void (*view_draw)(struct RenderEngine *engine, const struct bContext *context);
Render API: shader script node for custom shaders. * Shader script node added, which stores either a link to a text datablock or file on disk, and has functions to add and remove sockets. * Callback RenderEngine.update_script_node(self, node) added for render engines to compile the shader and update the node with new sockets. Thanks to Thomas, Lukas and Dalai for the implementation.
2012-11-03 14:32:26 +00:00
void (*update_script_node)(struct RenderEngine *engine, struct bNodeTree *ntree, struct bNode *node);
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
/* RNA integration */
ExtensionRNA ext;
} RenderEngineType;
typedef struct RenderEngine {
RenderEngineType *type;
RenderEngine: steps towards implementation of this proposal: http://wiki.blender.org/index.php/Dev:2.6/Source/Render/RenderEngineAPI * RenderEngine is now a persistent python object that exists and retains properties as long as a frame is being rendered. This is mostly useful now that more than one callback will be added. * Added update() callback that should ideally be used to export the scene, leaving only the rendering to the render() callback. This is not required to be used at this point, but separating this will make things more thread safe later on. * Added tag_redraw() and tag_update() functions that will be used for viewport rendering. * Internal change: status text is now retained after update_status calls.
2011-11-02 14:33:14 +00:00
void *py_instance;
Render API: add update_progress() function to update progress bar progress from external render engines. Also refactoring to move some render engine registration stuff out of RNA and into render module.
2011-10-22 17:01:54 +00:00
Fix #35979, #35937, #35739: undo crashes and missing updates with blender internal viewport rendering. Lots of tweaks here, mainly: * Stop 3D viewport render and free database before undo. * Accumulate update flags rather than replace them each time it rerenders, to avoid previous updates getting lost. * Don't check against Render struct view parameters for changes, those are set in the job thread which might not run before the next update call.
2013-07-08 22:26:10 +00:00
int flag;
Fix #30376: cycles ignores camera override from sequencer.
2012-04-13 17:42:03 +00:00
struct Object *camera_override;
RenderEngine: add .is_animation and .is_preview properties to detect if it's an animation or preview render that is being done.
2011-11-02 13:36:28 +00:00
Cycles: merge of changes from tomato branch. Regular rendering now works tiled, and supports save buffers to save memory during render and cache render results. Brick texture node by Thomas. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Textures#Brick_Texture Image texture Blended Box Mapping. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Textures#Image_Texture http://mango.blender.org/production/blended_box/ Various bug fixes by Sergey and Campbell. * Fix for reading freed memory in some node setups. * Fix incorrect memory read when synchronizing mesh motion. * Fix crash appearing when direct light usage is different on different layers. * Fix for vector pass gives wrong result in some circumstances. * Fix for wrong resolution used for rendering Render Layer node. * Option to cancel rendering when doing initial synchronization. * No more texture limit when using CPU render. * Many fixes for new tiled rendering.
2012-09-04 13:29:07 +00:00
int tile_x;
int tile_y;
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
struct Render *re;
ListBase fullresult;
Fix #35470: crash rendering from the terminal in some cases due to render info text threading issue.
2013-07-12 20:31:30 +00:00
char text[512]; /* IMA_MAX_RENDER_TEXT */
Cycles: merge of changes from tomato branch. Regular rendering now works tiled, and supports save buffers to save memory during render and cache render results. Brick texture node by Thomas. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Textures#Brick_Texture Image texture Blended Box Mapping. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Textures#Image_Texture http://mango.blender.org/production/blended_box/ Various bug fixes by Sergey and Campbell. * Fix for reading freed memory in some node setups. * Fix incorrect memory read when synchronizing mesh motion. * Fix crash appearing when direct light usage is different on different layers. * Fix for vector pass gives wrong result in some circumstances. * Fix for wrong resolution used for rendering Render Layer node. * Option to cancel rendering when doing initial synchronization. * No more texture limit when using CPU render. * Many fixes for new tiled rendering.
2012-09-04 13:29:07 +00:00
int resolution_x, resolution_y;
Render API: shader script node for custom shaders. * Shader script node added, which stores either a link to a text datablock or file on disk, and has functions to add and remove sockets. * Callback RenderEngine.update_script_node(self, node) added for render engines to compile the shader and update the node with new sockets. Thanks to Thomas, Lukas and Dalai for the implementation.
2012-11-03 14:32:26 +00:00
struct ReportList *reports;
Fix #35979, #35937, #35739: undo crashes and missing updates with blender internal viewport rendering. Lots of tweaks here, mainly: * Stop 3D viewport render and free database before undo. * Accumulate update flags rather than replace them each time it rerenders, to avoid previous updates getting lost. * Don't check against Render struct view parameters for changes, those are set in the job thread which might not run before the next update call.
2013-07-08 22:26:10 +00:00
/* for blender internal only */
int update_flag;
int job_update_flag;
rctf last_viewplane;
rcti last_disprect;
float last_viewmat[4][4];
int last_winx, last_winy;
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
} RenderEngine;
Render API: add update_progress() function to update progress bar progress from external render engines. Also refactoring to move some render engine registration stuff out of RNA and into render module.
2011-10-22 17:01:54 +00:00
RenderEngine *RE_engine_create(RenderEngineType *type);
code cleanup: use bool where values are true/false, for view3d and related functions.
2013-03-20 23:14:18 +00:00
RenderEngine *RE_engine_create_ex(RenderEngineType *type, bool use_for_viewport);
Render API: add update_progress() function to update progress bar progress from external render engines. Also refactoring to move some render engine registration stuff out of RNA and into render module.
2011-10-22 17:01:54 +00:00
void RE_engine_free(RenderEngine *engine);
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
void RE_layer_load_from_file(struct RenderLayer *layer, struct ReportList *reports, const char *filename, int x, int y);
void RE_result_load_from_file(struct RenderResult *result, struct ReportList *reports, const char *filename);
Cycles: merge of changes from tomato branch. Regular rendering now works tiled, and supports save buffers to save memory during render and cache render results. Brick texture node by Thomas. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Textures#Brick_Texture Image texture Blended Box Mapping. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Textures#Image_Texture http://mango.blender.org/production/blended_box/ Various bug fixes by Sergey and Campbell. * Fix for reading freed memory in some node setups. * Fix incorrect memory read when synchronizing mesh motion. * Fix crash appearing when direct light usage is different on different layers. * Fix for vector pass gives wrong result in some circumstances. * Fix for wrong resolution used for rendering Render Layer node. * Option to cancel rendering when doing initial synchronization. * No more texture limit when using CPU render. * Many fixes for new tiled rendering.
2012-09-04 13:29:07 +00:00
struct RenderResult *RE_engine_begin_result(RenderEngine *engine, int x, int y, int w, int h, const char *layername);
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
void RE_engine_update_result(RenderEngine *engine, struct RenderResult *result);
Changes to partial update during rendering Summary: Mainly addressed to solve old TODO with color managed fallback to CPU mode when displaying render result during rendering. That fallback was caused by the fact that partial image update was always acquiring image buffer for composite output and was only modifying display buffer directly. This was a big issue for Cycles rendering which renders layers one by one and wanted to display progress of each individual layer. This lead to situations when display buffer was based on what Cycles passes via RenderResult and didn't take layer/pass from image editor header into account. Now made it so image buffer which partial update is operating with always corresponds to what is set in image editor header. To make Cycles displaying progress of all the layers one by one made it so image_rect_update switches image editor user to newly rendering render layer. It happens only once when render engine starts rendering next render layer, so should not be annoying for navigation during rendering. Additional change to render engines was done to make it so they're able to merge composite output to final result without marking tile as done. This is done via do_merge_result argument to end_result() callback. This argument is optional so should not break script compatibility. Additional changes: - Partial display update for Blender Internal now happens from the same thread as tile rendering. This makes it so display conversion (which could be pretty heavy actually) is done in separate threads. Also gives better UI feedback when rendering easy scene with small tiles. - Avoid freeing/allocating byte buffer for render result if it's owned by the image buffer. Only mark it as invalid for color management. Saves loads of buffer re-allocations in cases when having several image editors opened with render result. This change in conjunction with the rest of the patch gave around 50%-100% speedup of render time when displaying non-combined pass during rendering on my laptop. - Partial display buffer update was wrong for buffers with number of channels different from 4. - Remove unused window from RenderJob. - Made image_buffer_rect_update static since it's only used in single file. Reviewers: brecht Reviewed By: brecht CC: dingto Differential Revision: http://developer.blender.org/D98
2013-12-17 23:42:38 +06:00
void RE_engine_end_result(RenderEngine *engine, struct RenderResult *result, int cancel, int merge_results);
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
int RE_engine_test_break(RenderEngine *engine);
void RE_engine_update_stats(RenderEngine *engine, const char *stats, const char *info);
Render API: add update_progress() function to update progress bar progress from external render engines. Also refactoring to move some render engine registration stuff out of RNA and into render module.
2011-10-22 17:01:54 +00:00
void RE_engine_update_progress(RenderEngine *engine, float progress);
Cycles: memory usage report This commit adds memory usage information while rendering. It reports memory used by device, meaning: - For CPU it'll report real memory consumption - For GPU rendering it'll report GPU memory consumption, but it'll also mean the same memory is used from host side. This information displays information about memory requested by Cycles, not memory really allocated on a device. Real memory usage might be higher because of memory fragmentation or optimistic memory allocator. There's really nothing we can do against this. Also in contrast with blender internal's render cycles memory usage does not include memory used by scene, only memory needed by cycles itself will be displayed. So don't freak out if memory usage reported by cycles would be much lower than blender internal's. This commit also adds RenderEngine.update_memory_stats callback which is used to tell memory consumption from external engine to blender. This information is used to generate information line after rendering is finished.
2012-11-05 08:04:57 +00:00
void RE_engine_update_memory_stats(RenderEngine *engine, float mem_used, float mem_peak);
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
void RE_engine_report(RenderEngine *engine, int type, const char *msg);
int RE_engine_render(struct Render *re, int do_all);
Code cleanup: use bools where possible
2014-02-03 18:55:59 +11:00
bool RE_engine_is_external(struct Render *re);
Fix #29406: show Sequence as render layer when rendering from sequencer, to make it more clear what was rendered. Fix #29407: external engine api doesn't support full sample yet, would give too dark render result.
2011-11-26 18:33:31 +00:00
Fix T39711: cycles particle motion blur affected by viewport draw method.
2014-05-21 15:47:11 +02:00
void RE_engine_frame_set(struct RenderEngine *engine, int frame, float subframe);
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
/* Engine Types */
void RE_engines_init(void);
void RE_engines_exit(void);
Render API: add update_progress() function to update progress bar progress from external render engines. Also refactoring to move some render engine registration stuff out of RNA and into render module.
2011-10-22 17:01:54 +00:00
RenderEngineType *RE_engines_find(const char *idname);
Highlight currently rendering tiles This commit implements highlight of tiles which are being currently rendered for both Blender Internal and Cycles (and should be possible to use it for other external engines as well). Couple of implementation details: - Added one extra boolean flag to render engine which should be set to truth if render engine wants to highlight tiles. If so, property use_highlight_tiles should be set to True. - Render Part's ready boolena was changed by status enum, which could be NONE, IN_PROGRESS and READY. All render part with IN_PROGRESS status will be highlighted in image editor. - For external engines render part's status is filling in automatically. Initially all render parts has got NONE status, then one external engine acquire render result, corresponding part will change status to IN_PROGRESS. As soon as render result is finished, corresponding render part will change status to FINISHED This should make it easy to highlight tiles for other engines as well.
2013-01-01 16:15:13 +00:00
void RE_engine_get_current_tiles(struct Render *re, int *total_tiles_r, rcti **tiles_r);
Border rendering now works for all scenes used in compositor, before this only active scene would be rendered with border. When do_render_fields_blur_3d() is finished, it'll modify render's display rect so it'll correspond bordered render result placed on black backgrund. Actual border is stored nowhere, which makes it only way to re-calculate disprect for all other renders used in compo based on source. Not so big deal actually. Also needed to modify Cycles a bit, because before this patch it used border settings from scene being rendered. Now made it so render data is passing to external engines. Using a property inside RenderEngine structure for this. Not best ever design for passing render data, but this would prevent API breakage. So now external engines could access engine.render to access active rendering settings. Reviewed by Brecht, thanks!
2013-03-14 07:38:37 +00:00
struct RenderData *RE_engine_get_render_data(struct Render *re);
Bake API - bpy.ops.object.bake() New operator that can calls a bake function to the current render engine when available. This commit provides no feature for the users, but allows external engines to be accessed by the operator and be integrated with the baking api. The API itself is simple. Blender sends a populated array of BakePixels to the renderer, and gets back an array of floats with the result. The Blender Internal (and multires) system is still running independent, but we eventually will pipe it through the API as well. Cycles baking will come next as a separated commit Python Operator: ---------------- The operator can be called with some arguments, or a user interface can be created for it. In that case the arguments can be ommited and the interface can expose the settings from bpy.context.scene.render.bake bpy.ops.object.bake(type='COMBINED', filepath="", width=512, height=512, margin=16, use_selected_to_active=False, cage_extrusion=0, cage="", normal_space='TANGENT', normal_r='POS_X', normal_g='POS_Y', normal_b='POS_Z', save_mode='INTERNAL', use_clear=False, use_split_materials=False, use_automatic_name=False) Note: external save mode is currently disabled. Supported Features: ------------------ * Margin - Baked result is extended this many pixels beyond the border of each UV "island," to soften seams in the texture. * Selected to Active - bake shading on the surface of selected object to the active object. The rays are cast from the lowpoly object inwards towards the highpoly object. If the highpoly object is not entirely involved by the lowpoly object, you can tweak the rays start point with Cage Extrusion. For even more control of the cage you can use a Cage object. * Cage Extrusion - distance to use for the inward ray cast when using selected to active * Custom Cage - object to use as cage (instead of the lowpoly object). * Normal swizzle - change the axis that gets mapped to RGB * Normal space - save as tangent or object normal spaces Supported Passes: ----------------- Any pass that is supported by Blender renderlayer system. Though it's up to the external engine to provide a valid enum with its supported passes. Normal passes get a special treatment since we post-process them to converted and "swizzled" Development Notes for External Engines: --------------------------------------- (read them in bake_api.c) * For a complete implementation example look at the Cycles Bake commit (next). Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge Normal map pipeline "consulting" by Andy Davies (metalliandy) Original design by Brecht van Lommel. The entire commit history can be found on the branch: bake-cycles
2014-01-02 19:05:07 -02:00
void RE_bake_engine_set_engine_parameters(struct Render *re, struct Main *bmain, struct Scene *scene);
Highlight currently rendering tiles This commit implements highlight of tiles which are being currently rendered for both Blender Internal and Cycles (and should be possible to use it for other external engines as well). Couple of implementation details: - Added one extra boolean flag to render engine which should be set to truth if render engine wants to highlight tiles. If so, property use_highlight_tiles should be set to True. - Render Part's ready boolena was changed by status enum, which could be NONE, IN_PROGRESS and READY. All render part with IN_PROGRESS status will be highlighted in image editor. - For external engines render part's status is filling in automatically. Initially all render parts has got NONE status, then one external engine acquire render result, corresponding part will change status to IN_PROGRESS. As soon as render result is finished, corresponding render part will change status to FINISHED This should make it easy to highlight tiles for other engines as well.
2013-01-01 16:15:13 +00:00
unify include guard defines, __$FILENAME__ without the underscores these clogged up the namespace for autocompleation which was annoying.
2012-02-17 18:59:41 +00:00
#endif /* __RE_ENGINE_H__ */
Code refactoring: move external engine functions into own file.
2011-10-22 16:24:28 +00:00
Copy Permalink