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
554024e08e7855685446b33d8bdbde5cacc196a5
blender-archive/intern/cycles/blender/blender_session.cpp

1356 lines
41 KiB
C++
Raw Normal View History

Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
/*
Cycles: relicense GNU GPL source code to Apache version 2.0. More information in this post: http://code.blender.org/ Thanks to all contributes for giving their permission!
2013-08-18 14:16:15 +00:00
* Copyright 2011-2013 Blender Foundation
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
*
Cycles: relicense GNU GPL source code to Apache version 2.0. More information in this post: http://code.blender.org/ Thanks to all contributes for giving their permission!
2013-08-18 14:16:15 +00:00
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
*
Cycles: relicense GNU GPL source code to Apache version 2.0. More information in this post: http://code.blender.org/ Thanks to all contributes for giving their permission!
2013-08-18 14:16:15 +00:00
* http://www.apache.org/licenses/LICENSE-2.0
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
*
Cycles: relicense GNU GPL source code to Apache version 2.0. More information in this post: http://code.blender.org/ Thanks to all contributes for giving their permission!
2013-08-18 14:16:15 +00:00
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
Cleanup: Fix Cycles Apache header. This was already mixed a bit, but the dot belongs there.
2014-12-25 02:50:24 +01:00
* limitations under the License.
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
*/
Cycles Bake Expand Cycles to use the new baking API in Blender. It works on the selected object, and the panel can be accessed in the Render panel (similar to where it is for the Blender Internal). It bakes for the active texture of each material of the object. The active texture is currently defined as the active Image Texture node present in the material nodetree. If you don't want the baking to override an existent material, make sure the active Image Texture node is not connected to the nodetree. The active texture is also the texture shown in the viewport in the rendered mode. Remember to save your images after the baking is complete. Note: Bake currently only works in the CPU Note: This is not supported by Cycles standalone because a lot of the work is done in Blender as part of the operator only, not the engine (Cycles). Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Bake Supported Passes: ----------------- Data Passes * Normal * UV * Diffuse/Glossy/Transmission/Subsurface/Emit Color Light Passes * AO * Combined * Shadow * Diffuse/Glossy/Transmission/Subsurface/Emit Direct/Indirect * Environment Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge 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 <stdlib.h>
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
#include "background.h"
#include "buffers.h"
#include "camera.h"
#include "device.h"
#include "integrator.h"
Cycles: * Add alpha pass output, to use set Transparent option in Film panel. * Add Holdout closure (OSL terminology), this is like the Sky option in the internal renderer, objects with this closure show the background / zero alpha. * Add option to use Gaussian instead of Box pixel filter in the UI. * Remove camera response curves for now, they don't really belong here in the pipeline, should be moved to compositor. * Output full float values for rendering now, previously was only byte precision. * Add a patch from Thomas to get a preview passes option, but still disabled because it isn't quite working right yet. * CUDA: don't compile shader graph evaluation inline. * Convert tabs to spaces in python files.
2011-08-28 13:55:59 +00:00
#include "film.h"
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
#include "light.h"
Cycles Bake Expand Cycles to use the new baking API in Blender. It works on the selected object, and the panel can be accessed in the Render panel (similar to where it is for the Blender Internal). It bakes for the active texture of each material of the object. The active texture is currently defined as the active Image Texture node present in the material nodetree. If you don't want the baking to override an existent material, make sure the active Image Texture node is not connected to the nodetree. The active texture is also the texture shown in the viewport in the rendered mode. Remember to save your images after the baking is complete. Note: Bake currently only works in the CPU Note: This is not supported by Cycles standalone because a lot of the work is done in Blender as part of the operator only, not the engine (Cycles). Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Bake Supported Passes: ----------------- Data Passes * Normal * UV * Diffuse/Glossy/Transmission/Subsurface/Emit Color Light Passes * AO * Combined * Shadow * Diffuse/Glossy/Transmission/Subsurface/Emit Direct/Indirect * Environment Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge 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 "mesh.h"
#include "object.h"
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
#include "scene.h"
#include "session.h"
#include "shader.h"
#include "util_color.h"
#include "util_foreach.h"
#include "util_function.h"
Cycles: Different noise seed for stereoscopic rendering (Fix #T50024) Patch by Sergey Sharybin.
2016-11-18 18:23:45 +01:00
#include "util_hash.h"
Cycles: Report total and render time to the log This includes total render time spent on rendering since render() was invoked and also prints time of actual rendering (without synchronization step).
2015-06-17 11:56:19 +02:00
#include "util_logging.h"
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
#include "util_progress.h"
#include "util_time.h"
#include "blender_sync.h"
#include "blender_session.h"
#include "blender_util.h"
CCL_NAMESPACE_BEGIN
Cycles: Initialize "headless" flags on engine initialization This flag is global for all the sessions and never changes. so it doesn't really make sense to pass it around to all sessions and synchronization routines. Switched to a static member of BlenderSession now, but it's probably more logical to introduce some sort of BlenderGlobals. Doesn't currently worth a hassle for a single boolean flag tho.
2015-02-18 21:16:52 +05:00
bool BlenderSession::headless = false;
Cycles: Resumable render implementation for Cycles This feature is also known by the name Samples Offset, which allows artists to render animation with given amount of samples N, but then render more samples, starting from N and ending with M (where M > N) and merge renders together as if they rendered exactly M samples. Surely such effect could be achieved by changing Seed variable, but that has possible issues with correlation artifacts and requiring to manually deal with per render layer samples and such. While we can't support all possible renderfarm-related features in Cycles it's nice to support really commonly used stuff. Here's a command how to run Blender with the new feature enabled: blender -- --cycles-resumable-num-chunks 24 --cycles-resumable-current-chunk 2 This command will divide samples range in 24 parts and render range #2 (chunk number is 1-based). This feature might be changed a bit after we'll do some tests here in the studio with it.
2016-03-30 15:55:12 +02:00
int BlenderSession::num_resumable_chunks = 0;
int BlenderSession::current_resumable_chunk = 0;
Cycles: Initialize "headless" flags on engine initialization This flag is global for all the sessions and never changes. so it doesn't really make sense to pass it around to all sessions and synchronization routines. Switched to a static member of BlenderSession now, but it's probably more logical to introduce some sort of BlenderGlobals. Doesn't currently worth a hassle for a single boolean flag tho.
2015-02-18 21:16:52 +05:00
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
BlenderSession::BlenderSession(BL::RenderEngine& b_engine,
BL::UserPreferences& b_userpref,
BL::BlendData& b_data,
BL::Scene& b_scene)
: b_engine(b_engine),
b_userpref(b_userpref),
b_data(b_data),
b_render(b_engine.render()),
b_scene(b_scene),
b_v3d(PointerRNA_NULL),
b_rv3d(PointerRNA_NULL),
python_thread_state(NULL)
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
{
/* offline render */
Code cleanup / Cycles: * Put render resolution x/y into a function.
2013-05-16 21:53:21 +00:00
width = render_resolution_x(b_render);
height = render_resolution_y(b_render);
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
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
background = true;
Fix #34714: cycles viewport render would restart when minimizing and unminimizing a maximized Blender window in Ubuntu Unity. The window size would slightly change as part of the unminimize effect. Now cycles waits 0.2 seconds before restarting rendering after a viewport resize, also a bit less flickery when changing the 3d view size in Blender itself.
2013-04-24 20:12:12 +00:00
last_redraw_time = 0.0;
start_resize_time = 0.0;
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
}
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
BlenderSession::BlenderSession(BL::RenderEngine& b_engine,
BL::UserPreferences& b_userpref,
BL::BlendData& b_data,
BL::Scene& b_scene,
BL::SpaceView3D& b_v3d,
BL::RegionView3D& b_rv3d,
int width, int height)
: b_engine(b_engine),
b_userpref(b_userpref),
b_data(b_data),
b_render(b_scene.render()),
b_scene(b_scene),
b_v3d(b_v3d),
b_rv3d(b_rv3d),
width(width),
height(height),
python_thread_state(NULL)
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
{
/* 3d view 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
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
background = false;
Fix #34714: cycles viewport render would restart when minimizing and unminimizing a maximized Blender window in Ubuntu Unity. The window size would slightly change as part of the unminimize effect. Now cycles waits 0.2 seconds before restarting rendering after a viewport resize, also a bit less flickery when changing the 3d view size in Blender itself.
2013-04-24 20:12:12 +00:00
last_redraw_time = 0.0;
start_resize_time = 0.0;
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
}
BlenderSession::~BlenderSession()
{
free_session();
}
Fix issue in recent bugfix, did not work with multiple sessions (preview render).
2014-02-12 23:13:45 +01:00
void BlenderSession::create()
{
create_session();
if(b_v3d)
session->start();
}
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
void BlenderSession::create_session()
{
Cycles: Initialize "headless" flags on engine initialization This flag is global for all the sessions and never changes. so it doesn't really make sense to pass it around to all sessions and synchronization routines. Switched to a static member of BlenderSession now, but it's probably more logical to introduce some sort of BlenderGlobals. Doesn't currently worth a hassle for a single boolean flag tho.
2015-02-18 21:16:52 +05:00
SessionParams session_params = BlenderSync::get_session_params(b_engine, b_userpref, b_scene, background);
Cycles: Enable QBVH optimization structure for SSE2 CPUs This commit enables QBVH optimization structure automatically if rendering with CPU and SSE2 support is detected. This brings render time of agent shot back to the speed it used to be before the watertight intersections commit, single koro and sponza scenes are about 7% faster here.
2014-12-25 00:53:26 +05:00
bool is_cpu = session_params.device.type == DEVICE_CPU;
SceneParams scene_params = BlenderSync::get_scene_params(b_scene, background, is_cpu);
Fix T41197: Blender freezes to infinite loop when switching to PAUSED Cycles rendered viewport
2014-08-01 16:39:05 +06:00
bool session_pause = BlenderSync::get_session_pause(b_scene, background);
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
Cycles: progress printing in background mode, print finished at the end and avoid duplicate prints.
2011-10-30 10:12:34 +00:00
/* reset status/progress */
style cleanup: assignment & indentation.
2012-06-09 18:56:12 +00:00
last_status = "";
Cycles: Report error to the blender using report API This way when something goes wrong in Cycles (for example out of VRAM, timelimit launching the kernel etc) we'll have a nice report in the Info space header. Sure it'll be nice to have mention of error in the image editor's information line, but that's for the future. This fixes T42747: "CUDA error" appears only momentarily, then disappears
2014-12-05 21:27:52 +05:00
last_error = "";
style cleanup: assignment & indentation.
2012-06-09 18:56:12 +00:00
last_progress = -1.0f;
Fix #34714: cycles viewport render would restart when minimizing and unminimizing a maximized Blender window in Ubuntu Unity. The window size would slightly change as part of the unminimize effect. Now cycles waits 0.2 seconds before restarting rendering after a viewport resize, also a bit less flickery when changing the 3d view size in Blender itself.
2013-04-24 20:12:12 +00:00
start_resize_time = 0.0;
Cycles: progress printing in background mode, print finished at the end and avoid duplicate prints.
2011-10-30 10:12:34 +00:00
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
/* create scene */
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
scene = new Scene(scene_params, session_params.device);
Cycles code internals: add CPU kernel support for 3D image textures.
2014-03-29 13:03:48 +01:00
/* setup callbacks for builtin image support */
scene->image_manager->builtin_image_info_cb = function_bind(&BlenderSession::builtin_image_info, this, _1, _2, _3, _4, _5, _6, _7);
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
scene->image_manager->builtin_image_pixels_cb = function_bind(&BlenderSession::builtin_image_pixels, this, _1, _2, _3, _4);
scene->image_manager->builtin_image_float_pixels_cb = function_bind(&BlenderSession::builtin_image_float_pixels, this, _1, _2, _3, _4);
Cycles code internals: add CPU kernel support for 3D image textures.
2014-03-29 13:03:48 +01: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
/* create session */
session = new Session(session_params);
session->scene = scene;
session->progress.set_update_callback(function_bind(&BlenderSession::tag_redraw, this));
session->progress.set_cancel_callback(function_bind(&BlenderSession::test_cancel, this));
Fix T41197: Blender freezes to infinite loop when switching to PAUSED Cycles rendered viewport
2014-08-01 16:39:05 +06:00
session->set_pause(session_pause);
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
/* create sync */
Cycles: Enable QBVH optimization structure for SSE2 CPUs This commit enables QBVH optimization structure automatically if rendering with CPU and SSE2 support is detected. This brings render time of agent shot back to the speed it used to be before the watertight intersections commit, single koro and sponza scenes are about 7% faster here.
2014-12-25 00:53:26 +05:00
sync = new BlenderSync(b_engine, b_data, b_scene, scene, !background, session->progress, is_cpu);
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
BL::Object b_camera_override(b_engine.camera_override());
Fix related to #35681: avoid some unnecessary cycles updated when using exclude render layers.
2013-06-09 11:57:51 +00:00
if(b_v3d) {
Fix T41197: Blender freezes to infinite loop when switching to PAUSED Cycles rendered viewport
2014-08-01 16:39:05 +06:00
if(session_pause == false) {
/* full data sync */
sync->sync_view(b_v3d, b_rv3d, width, height);
Cycles: Implement camera zoom motion blur Works totally similar to camera motion blur and majority of the changes are related on just passing extra arguments to sync() functions. Couple of things still to look into: - Motion pass will not include motion caused by the zoom. - Only perspective cameras are supported currently. - Motion is being interpolated on projected coordinates, which might give different results from constructing projection matrix from interpolated field of view. This could be good enough for us, but we need to consider improving this at some point. Reviewers: juicyfruit, dingto Reviewed By: dingto Differential Revision: https://developer.blender.org/D1383
2015-07-21 15:36:35 +02:00
sync->sync_data(b_render,
b_v3d,
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
b_camera_override,
Cycles: Implement camera zoom motion blur Works totally similar to camera motion blur and majority of the changes are related on just passing extra arguments to sync() functions. Couple of things still to look into: - Motion pass will not include motion caused by the zoom. - Only perspective cameras are supported currently. - Motion is being interpolated on projected coordinates, which might give different results from constructing projection matrix from interpolated field of view. This could be good enough for us, but we need to consider improving this at some point. Reviewers: juicyfruit, dingto Reviewed By: dingto Differential Revision: https://developer.blender.org/D1383
2015-07-21 15:36:35 +02:00
width, height,
&python_thread_state,
b_rlay_name.c_str());
Fix T41197: Blender freezes to infinite loop when switching to PAUSED Cycles rendered viewport
2014-08-01 16:39:05 +06:00
}
Fix related to #35681: avoid some unnecessary cycles updated when using exclude render layers.
2013-06-09 11:57:51 +00:00
}
Fix #35711: cycles border render issue after recent changes.
2013-06-11 14:15:46 +00:00
else {
Fix #35723: cycles motion blur rendering issue after recent optimizations to skip some unneeded object syncing.
2013-06-12 20:47:48 +00:00
/* for final render we will do full data sync per render layer, only
* do some basic syncing here, no objects or materials for speed */
sync->sync_render_layers(b_v3d, NULL);
sync->sync_integrator();
Cycles: Fix border render after spherical stereo commit Buffer params needs to know camera's border, otherwise it'll create full buffer. There might be some issues with stereo camera still, but in worst case it'll only update camera twice as far as i can tell. Not ideal, but better than no border render at all.
2016-03-11 12:57:02 +05:00
sync->sync_camera(b_render, b_camera_override, width, height, "");
Fix #35711: cycles border render issue after recent changes.
2013-06-11 14:15:46 +00:00
}
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
Cycles: support for multiple render layers. It currently renders each layer entirely before moving on to the next.
2011-12-21 20:51:55 +00:00
/* set buffer parameters */
Cycles: Code cleanup, prepare for strict C++ flags
2015-03-27 15:47:55 +05:00
BufferParams buffer_params = BlenderSync::get_buffer_params(b_render, b_v3d, b_rv3d, scene->camera, width, height);
Cycles: border rendering support, includes some refactoring in how pixels are accessed on devices.
2011-12-20 12:25:37 +00:00
session->reset(buffer_params, session_params.samples);
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
b_engine.use_highlight_tiles(session_params.progressive_refine == false);
Cycles: Resumable render implementation for Cycles This feature is also known by the name Samples Offset, which allows artists to render animation with given amount of samples N, but then render more samples, starting from N and ending with M (where M > N) and merge renders together as if they rendered exactly M samples. Surely such effect could be achieved by changing Seed variable, but that has possible issues with correlation artifacts and requiring to manually deal with per render layer samples and such. While we can't support all possible renderfarm-related features in Cycles it's nice to support really commonly used stuff. Here's a command how to run Blender with the new feature enabled: blender -- --cycles-resumable-num-chunks 24 --cycles-resumable-current-chunk 2 This command will divide samples range in 24 parts and render range #2 (chunk number is 1-based). This feature might be changed a bit after we'll do some tests here in the studio with it.
2016-03-30 15:55:12 +02:00
update_resumable_tile_manager(session_params.samples);
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
}
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
void BlenderSession::reset_session(BL::BlendData& b_data_, BL::Scene& b_scene_)
Cycles: persistent images option This option enables keeping loaded images in the memory in-between of rendering. Implemented by keeping render engine alive for until Render structure is being freed. Cycles will free all data when render finishes, optionally keeping image manager untouched. All shaders, meshes, objects will be re-allocated next time rendering happens. Cycles cession and scene will be re-created from scratch if render/ scene parameters were changed. This will also allow to keep compiled OSL shaders in memory without need to re-compile them again. P.S. Performance panel could be cleaned up a bit, not so much happy with it's vertical alignment currently but not sure how to make it look better. P.P.S. Currently the only way to free images from the device is to disable Persistent Images option and start rendering.
2012-11-09 08:46:53 +00:00
{
b_data = b_data_;
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
b_render = b_engine.render();
Cycles: persistent images option This option enables keeping loaded images in the memory in-between of rendering. Implemented by keeping render engine alive for until Render structure is being freed. Cycles will free all data when render finishes, optionally keeping image manager untouched. All shaders, meshes, objects will be re-allocated next time rendering happens. Cycles cession and scene will be re-created from scratch if render/ scene parameters were changed. This will also allow to keep compiled OSL shaders in memory without need to re-compile them again. P.S. Performance panel could be cleaned up a bit, not so much happy with it's vertical alignment currently but not sure how to make it look better. P.P.S. Currently the only way to free images from the device is to disable Persistent Images option and start rendering.
2012-11-09 08:46:53 +00:00
b_scene = b_scene_;
Cycles: Initialize "headless" flags on engine initialization This flag is global for all the sessions and never changes. so it doesn't really make sense to pass it around to all sessions and synchronization routines. Switched to a static member of BlenderSession now, but it's probably more logical to introduce some sort of BlenderGlobals. Doesn't currently worth a hassle for a single boolean flag tho.
2015-02-18 21:16:52 +05:00
SessionParams session_params = BlenderSync::get_session_params(b_engine, b_userpref, b_scene, background);
Cycles: Enable QBVH optimization structure for SSE2 CPUs This commit enables QBVH optimization structure automatically if rendering with CPU and SSE2 support is detected. This brings render time of agent shot back to the speed it used to be before the watertight intersections commit, single koro and sponza scenes are about 7% faster here.
2014-12-25 00:53:26 +05:00
const bool is_cpu = session_params.device.type == DEVICE_CPU;
SceneParams scene_params = BlenderSync::get_scene_params(b_scene, background, is_cpu);
Cycles: persistent images option This option enables keeping loaded images in the memory in-between of rendering. Implemented by keeping render engine alive for until Render structure is being freed. Cycles will free all data when render finishes, optionally keeping image manager untouched. All shaders, meshes, objects will be re-allocated next time rendering happens. Cycles cession and scene will be re-created from scratch if render/ scene parameters were changed. This will also allow to keep compiled OSL shaders in memory without need to re-compile them again. P.S. Performance panel could be cleaned up a bit, not so much happy with it's vertical alignment currently but not sure how to make it look better. P.P.S. Currently the only way to free images from the device is to disable Persistent Images option and start rendering.
2012-11-09 08:46:53 +00:00
Code cleanup / Cycles: * Put render resolution x/y into a function.
2013-05-16 21:53:21 +00:00
width = render_resolution_x(b_render);
height = render_resolution_y(b_render);
Fix #33132: Incorrect render session update when using persistent images issue and changing resolution
2012-11-10 08:13:13 +00:00
Cycles: persistent images option This option enables keeping loaded images in the memory in-between of rendering. Implemented by keeping render engine alive for until Render structure is being freed. Cycles will free all data when render finishes, optionally keeping image manager untouched. All shaders, meshes, objects will be re-allocated next time rendering happens. Cycles cession and scene will be re-created from scratch if render/ scene parameters were changed. This will also allow to keep compiled OSL shaders in memory without need to re-compile them again. P.S. Performance panel could be cleaned up a bit, not so much happy with it's vertical alignment currently but not sure how to make it look better. P.P.S. Currently the only way to free images from the device is to disable Persistent Images option and start rendering.
2012-11-09 08:46:53 +00:00
if(scene->params.modified(scene_params) ||
Further fix for #34121: OSL + persistent images could crash in some cases still.
2013-02-14 16:48:43 +00:00
session->params.modified(session_params) ||
!scene_params.persistent_data)
Cycles: persistent images option This option enables keeping loaded images in the memory in-between of rendering. Implemented by keeping render engine alive for until Render structure is being freed. Cycles will free all data when render finishes, optionally keeping image manager untouched. All shaders, meshes, objects will be re-allocated next time rendering happens. Cycles cession and scene will be re-created from scratch if render/ scene parameters were changed. This will also allow to keep compiled OSL shaders in memory without need to re-compile them again. P.S. Performance panel could be cleaned up a bit, not so much happy with it's vertical alignment currently but not sure how to make it look better. P.P.S. Currently the only way to free images from the device is to disable Persistent Images option and start rendering.
2012-11-09 08:46:53 +00:00
{
/* if scene or session parameters changed, it's easier to simply re-create
* them rather than trying to distinguish which settings need to be updated
*/
delete session;
create_session();
return;
}
session->progress.reset();
scene->reset();
Fix for recent tile_order feature not working properly with persistent data
2013-01-08 16:56:04 +00:00
session->tile_manager.set_tile_order(session_params.tile_order);
Cycles: persistent images option This option enables keeping loaded images in the memory in-between of rendering. Implemented by keeping render engine alive for until Render structure is being freed. Cycles will free all data when render finishes, optionally keeping image manager untouched. All shaders, meshes, objects will be re-allocated next time rendering happens. Cycles cession and scene will be re-created from scratch if render/ scene parameters were changed. This will also allow to keep compiled OSL shaders in memory without need to re-compile them again. P.S. Performance panel could be cleaned up a bit, not so much happy with it's vertical alignment currently but not sure how to make it look better. P.P.S. Currently the only way to free images from the device is to disable Persistent Images option and start rendering.
2012-11-09 08:46:53 +00:00
/* peak memory usage should show current render peak, not peak for all renders
* made by this render session
*/
session->stats.mem_peak = session->stats.mem_used;
/* sync object should be re-created */
Cycles: Enable QBVH optimization structure for SSE2 CPUs This commit enables QBVH optimization structure automatically if rendering with CPU and SSE2 support is detected. This brings render time of agent shot back to the speed it used to be before the watertight intersections commit, single koro and sponza scenes are about 7% faster here.
2014-12-25 00:53:26 +05:00
sync = new BlenderSync(b_engine, b_data, b_scene, scene, !background, session->progress, is_cpu);
Fix related to #35681: avoid some unnecessary cycles updated when using exclude render layers.
2013-06-09 11:57:51 +00:00
Fix #36731: border render not updating properly with persistent images setting enabled in cycles.
2013-09-16 21:20:21 +00:00
/* for final render we will do full data sync per render layer, only
* do some basic syncing here, no objects or materials for speed */
Cycles: Fix border render after spherical stereo commit Buffer params needs to know camera's border, otherwise it'll create full buffer. There might be some issues with stereo camera still, but in worst case it'll only update camera twice as far as i can tell. Not ideal, but better than no border render at all.
2016-03-11 12:57:02 +05:00
BL::Object b_camera_override(b_engine.camera_override());
Fix #36731: border render not updating properly with persistent images setting enabled in cycles.
2013-09-16 21:20:21 +00:00
sync->sync_render_layers(b_v3d, NULL);
sync->sync_integrator();
Cycles: Fix border render after spherical stereo commit Buffer params needs to know camera's border, otherwise it'll create full buffer. There might be some issues with stereo camera still, but in worst case it'll only update camera twice as far as i can tell. Not ideal, but better than no border render at all.
2016-03-11 12:57:02 +05:00
sync->sync_camera(b_render, b_camera_override, width, height, "");
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
BL::SpaceView3D b_null_space_view3d(PointerRNA_NULL);
BL::RegionView3D b_null_region_view3d(PointerRNA_NULL);
BufferParams buffer_params = BlenderSync::get_buffer_params(b_render,
b_null_space_view3d,
b_null_region_view3d,
scene->camera,
width, height);
Cycles: persistent images option This option enables keeping loaded images in the memory in-between of rendering. Implemented by keeping render engine alive for until Render structure is being freed. Cycles will free all data when render finishes, optionally keeping image manager untouched. All shaders, meshes, objects will be re-allocated next time rendering happens. Cycles cession and scene will be re-created from scratch if render/ scene parameters were changed. This will also allow to keep compiled OSL shaders in memory without need to re-compile them again. P.S. Performance panel could be cleaned up a bit, not so much happy with it's vertical alignment currently but not sure how to make it look better. P.P.S. Currently the only way to free images from the device is to disable Persistent Images option and start rendering.
2012-11-09 08:46:53 +00:00
session->reset(buffer_params, session_params.samples);
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
b_engine.use_highlight_tiles(session_params.progressive_refine == false);
Fix #34714: cycles viewport render would restart when minimizing and unminimizing a maximized Blender window in Ubuntu Unity. The window size would slightly change as part of the unminimize effect. Now cycles waits 0.2 seconds before restarting rendering after a viewport resize, also a bit less flickery when changing the 3d view size in Blender itself.
2013-04-24 20:12:12 +00:00
/* reset time */
start_resize_time = 0.0;
Cycles: persistent images option This option enables keeping loaded images in the memory in-between of rendering. Implemented by keeping render engine alive for until Render structure is being freed. Cycles will free all data when render finishes, optionally keeping image manager untouched. All shaders, meshes, objects will be re-allocated next time rendering happens. Cycles cession and scene will be re-created from scratch if render/ scene parameters were changed. This will also allow to keep compiled OSL shaders in memory without need to re-compile them again. P.S. Performance panel could be cleaned up a bit, not so much happy with it's vertical alignment currently but not sure how to make it look better. P.P.S. Currently the only way to free images from the device is to disable Persistent Images option and start rendering.
2012-11-09 08:46:53 +00:00
}
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
void BlenderSession::free_session()
{
Cycles: persistent images option This option enables keeping loaded images in the memory in-between of rendering. Implemented by keeping render engine alive for until Render structure is being freed. Cycles will free all data when render finishes, optionally keeping image manager untouched. All shaders, meshes, objects will be re-allocated next time rendering happens. Cycles cession and scene will be re-created from scratch if render/ scene parameters were changed. This will also allow to keep compiled OSL shaders in memory without need to re-compile them again. P.S. Performance panel could be cleaned up a bit, not so much happy with it's vertical alignment currently but not sure how to make it look better. P.P.S. Currently the only way to free images from the device is to disable Persistent Images option and start rendering.
2012-11-09 08:46:53 +00:00
if(sync)
delete sync;
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
delete session;
}
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
static PassType get_pass_type(BL::RenderPass& b_pass)
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
{
switch(b_pass.type()) {
case BL::RenderPass::type_COMBINED:
return PASS_COMBINED;
case BL::RenderPass::type_Z:
return PASS_DEPTH;
Cycles: mist pass added, with start/depth/falloff control. If the pass is enabled in a render layer a Mist Pass panel will be shown in the world properties.
2013-06-07 12:45:26 +00:00
case BL::RenderPass::type_MIST:
return PASS_MIST;
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
case BL::RenderPass::type_NORMAL:
return PASS_NORMAL;
case BL::RenderPass::type_OBJECT_INDEX:
return PASS_OBJECT_ID;
case BL::RenderPass::type_UV:
return PASS_UV;
Cycles: support for motion vector and UV passes. Most of the changes are related to adding support for motion data throughout the code. There's some code for actual camera/object motion blur raytracing but it's unfinished (it badly slows down the raytracing kernel even when the option is turned off), so that code it disabled still. Motion vector export from Blender tries to avoid computing derived meshes when the mesh does not have a deforming modifier, and it also won't store motion vectors for every vertex if only the object or camera is moving.
2012-04-30 12:49:26 +00:00
case BL::RenderPass::type_VECTOR:
return PASS_MOTION;
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
case BL::RenderPass::type_MATERIAL_INDEX:
return PASS_MATERIAL_ID;
case BL::RenderPass::type_DIFFUSE_DIRECT:
return PASS_DIFFUSE_DIRECT;
case BL::RenderPass::type_GLOSSY_DIRECT:
return PASS_GLOSSY_DIRECT;
case BL::RenderPass::type_TRANSMISSION_DIRECT:
return PASS_TRANSMISSION_DIRECT;
Cycles / SSS: * Render Passes are now available for Subsurface Scattering (Direct, Indirect and Color pass). This is part of my GSoC project, SVN merge of r58587, r58828 and r58835.
2013-08-03 13:12:09 +00:00
case BL::RenderPass::type_SUBSURFACE_DIRECT:
return PASS_SUBSURFACE_DIRECT;
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
case BL::RenderPass::type_DIFFUSE_INDIRECT:
return PASS_DIFFUSE_INDIRECT;
case BL::RenderPass::type_GLOSSY_INDIRECT:
return PASS_GLOSSY_INDIRECT;
case BL::RenderPass::type_TRANSMISSION_INDIRECT:
return PASS_TRANSMISSION_INDIRECT;
Cycles / SSS: * Render Passes are now available for Subsurface Scattering (Direct, Indirect and Color pass). This is part of my GSoC project, SVN merge of r58587, r58828 and r58835.
2013-08-03 13:12:09 +00:00
case BL::RenderPass::type_SUBSURFACE_INDIRECT:
return PASS_SUBSURFACE_INDIRECT;
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
case BL::RenderPass::type_DIFFUSE_COLOR:
return PASS_DIFFUSE_COLOR;
case BL::RenderPass::type_GLOSSY_COLOR:
return PASS_GLOSSY_COLOR;
case BL::RenderPass::type_TRANSMISSION_COLOR:
return PASS_TRANSMISSION_COLOR;
Cycles / SSS: * Render Passes are now available for Subsurface Scattering (Direct, Indirect and Color pass). This is part of my GSoC project, SVN merge of r58587, r58828 and r58835.
2013-08-03 13:12:09 +00:00
case BL::RenderPass::type_SUBSURFACE_COLOR:
return PASS_SUBSURFACE_COLOR;
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
case BL::RenderPass::type_EMIT:
return PASS_EMISSION;
case BL::RenderPass::type_ENVIRONMENT:
return PASS_BACKGROUND;
Cycles: ambient occlusion support, with AO factor and distance, and a render pass. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/World#Ambient_Occlusion http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes#Lighting_Passes
2012-02-28 16:45:08 +00:00
case BL::RenderPass::type_AO:
return PASS_AO;
Cycles: shadow pass support. Note that this only takes into account lamps, emitting objects or world lighting do not contribute to the shadow pass. Consider this more as a pass useful for some compositing tricks, unlike other lighting passes this pass can't be used to exactly reconstruct the combined pass.
2012-03-28 10:39:21 +00:00
case BL::RenderPass::type_SHADOW:
return PASS_SHADOW;
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
case BL::RenderPass::type_DIFFUSE:
case BL::RenderPass::type_COLOR:
case BL::RenderPass::type_REFRACTION:
case BL::RenderPass::type_SPECULAR:
case BL::RenderPass::type_REFLECTION:
return PASS_NONE;
Cycles: Add support for debug passes Currently only summed number of traversal steps and intersections used by the camera ray intersection pass is implemented, but in the future we will support more debug passes which would help checking what things makes the scene slow. Example of such extra passes could be number of bounces, time spent on the shader tree evaluation and so. Implementation from the Cycles side is pretty much straightforward, could only mention here that it's a build-time option disabled by default. From the blender side it's implemented as a PASS_DEBUG with several subtypes possible. This way we don't need to create an extra DNA pass type for each of the debug passes, saving us a bits. Reviewers: campbellbarton Reviewed By: campbellbarton Differential Revision: https://developer.blender.org/D813
2014-10-04 19:00:26 +06:00
#ifdef WITH_CYCLES_DEBUG
case BL::RenderPass::type_DEBUG:
{
if(b_pass.debug_type() == BL::RenderPass::debug_type_BVH_TRAVERSAL_STEPS)
return PASS_BVH_TRAVERSAL_STEPS;
Cycles: Add debug pass which shows number of instance pushes during camera ray intersection TODO: We might want to refactor debug passes into PASS_DEBUG and some debug_type (similar to Blender's side passes) to avoid issue of running out of bits.
2015-06-12 00:12:03 +02:00
if(b_pass.debug_type() == BL::RenderPass::debug_type_BVH_TRAVERSED_INSTANCES)
return PASS_BVH_TRAVERSED_INSTANCES;
Cycles: Add debug pass showing average number of ray bounces per pixel Quite straightforward implementation, but still needs some work for the split kernel. Includes both regular and split kernel implementation for that. The pass is not exposed to the interface yet because it's currently not really easy to have same pass listed in the menu multiple times.
2015-06-11 10:42:38 +02:00
if(b_pass.debug_type() == BL::RenderPass::debug_type_RAY_BOUNCES)
return PASS_RAY_BOUNCES;
Cycles: Add support for debug passes Currently only summed number of traversal steps and intersections used by the camera ray intersection pass is implemented, but in the future we will support more debug passes which would help checking what things makes the scene slow. Example of such extra passes could be number of bounces, time spent on the shader tree evaluation and so. Implementation from the Cycles side is pretty much straightforward, could only mention here that it's a build-time option disabled by default. From the blender side it's implemented as a PASS_DEBUG with several subtypes possible. This way we don't need to create an extra DNA pass type for each of the debug passes, saving us a bits. Reviewers: campbellbarton Reviewed By: campbellbarton Differential Revision: https://developer.blender.org/D813
2014-10-04 19:00:26 +06:00
break;
}
#endif
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
}
return PASS_NONE;
}
Cycles Bake Expand Cycles to use the new baking API in Blender. It works on the selected object, and the panel can be accessed in the Render panel (similar to where it is for the Blender Internal). It bakes for the active texture of each material of the object. The active texture is currently defined as the active Image Texture node present in the material nodetree. If you don't want the baking to override an existent material, make sure the active Image Texture node is not connected to the nodetree. The active texture is also the texture shown in the viewport in the rendered mode. Remember to save your images after the baking is complete. Note: Bake currently only works in the CPU Note: This is not supported by Cycles standalone because a lot of the work is done in Blender as part of the operator only, not the engine (Cycles). Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Bake Supported Passes: ----------------- Data Passes * Normal * UV * Diffuse/Glossy/Transmission/Subsurface/Emit Color Light Passes * AO * Combined * Shadow * Diffuse/Glossy/Transmission/Subsurface/Emit Direct/Indirect * Environment Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge 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
static ShaderEvalType get_shader_type(const string& pass_type)
{
const char *shader_type = pass_type.c_str();
/* data passes */
if(strcmp(shader_type, "NORMAL")==0)
return SHADER_EVAL_NORMAL;
else if(strcmp(shader_type, "UV")==0)
return SHADER_EVAL_UV;
else if(strcmp(shader_type, "DIFFUSE_COLOR")==0)
return SHADER_EVAL_DIFFUSE_COLOR;
else if(strcmp(shader_type, "GLOSSY_COLOR")==0)
return SHADER_EVAL_GLOSSY_COLOR;
else if(strcmp(shader_type, "TRANSMISSION_COLOR")==0)
return SHADER_EVAL_TRANSMISSION_COLOR;
else if(strcmp(shader_type, "SUBSURFACE_COLOR")==0)
return SHADER_EVAL_SUBSURFACE_COLOR;
else if(strcmp(shader_type, "EMIT")==0)
return SHADER_EVAL_EMISSION;
/* light passes */
else if(strcmp(shader_type, "AO")==0)
return SHADER_EVAL_AO;
else if(strcmp(shader_type, "COMBINED")==0)
return SHADER_EVAL_COMBINED;
else if(strcmp(shader_type, "SHADOW")==0)
return SHADER_EVAL_SHADOW;
Cycles-Bake: Custom Baking passes The combined pass is built with the contributions the user finds fit. It is useful for lightmap baking, as well as non-view dependent effects baking. The manual will be updated once we get closer to the 2.77 release. Meanwhile the new page can be found here: http://dalaifelinto.com/blender-manual/render/cycles/baking.html Reviewers: sergey, brecht Differential Revision: https://developer.blender.org/D1674
2016-01-15 13:00:56 -02:00
else if(strcmp(shader_type, "DIFFUSE")==0)
return SHADER_EVAL_DIFFUSE;
else if(strcmp(shader_type, "GLOSSY")==0)
return SHADER_EVAL_GLOSSY;
else if(strcmp(shader_type, "TRANSMISSION")==0)
return SHADER_EVAL_TRANSMISSION;
else if(strcmp(shader_type, "SUBSURFACE")==0)
return SHADER_EVAL_SUBSURFACE;
Cycles Bake Expand Cycles to use the new baking API in Blender. It works on the selected object, and the panel can be accessed in the Render panel (similar to where it is for the Blender Internal). It bakes for the active texture of each material of the object. The active texture is currently defined as the active Image Texture node present in the material nodetree. If you don't want the baking to override an existent material, make sure the active Image Texture node is not connected to the nodetree. The active texture is also the texture shown in the viewport in the rendered mode. Remember to save your images after the baking is complete. Note: Bake currently only works in the CPU Note: This is not supported by Cycles standalone because a lot of the work is done in Blender as part of the operator only, not the engine (Cycles). Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Bake Supported Passes: ----------------- Data Passes * Normal * UV * Diffuse/Glossy/Transmission/Subsurface/Emit Color Light Passes * AO * Combined * Shadow * Diffuse/Glossy/Transmission/Subsurface/Emit Direct/Indirect * Environment Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge 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
/* extra */
else if(strcmp(shader_type, "ENVIRONMENT")==0)
return SHADER_EVAL_ENVIRONMENT;
else
return SHADER_EVAL_BAKE;
}
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
static BL::RenderResult begin_render_result(BL::RenderEngine& b_engine,
int x, int y,
int w, int h,
const char *layername,
const char *viewname)
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
{
Multi-View and Stereo 3D Official Documentation: http://www.blender.org/manual/render/workflows/multiview.html Implemented Features ==================== Builtin Stereo Camera * Convergence Mode * Interocular Distance * Convergence Distance * Pivot Mode Viewport * Cameras * Plane * Volume Compositor * View Switch Node * Image Node Multi-View OpenEXR support Sequencer * Image/Movie Strips 'Use Multiview' UV/Image Editor * Option to see Multi-View images in Stereo-3D or its individual images * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images I/O * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images Scene Render Views * Ability to have an arbitrary number of views in the scene Missing Bits ============ First rule of Multi-View bug report: If something is not working as it should *when Views is off* this is a severe bug, do mention this in the report. Second rule is, if something works *when Views is off* but doesn't (or crashes) when *Views is on*, this is a important bug. Do mention this in the report. Everything else is likely small todos, and may wait until we are sure none of the above is happening. Apart from that there are those known issues: * Compositor Image Node poorly working for Multi-View OpenEXR (this was working prefectly before the 'Use Multi-View' functionality) * Selecting camera from Multi-View when looking from camera is problematic * Animation Playback (ctrl+F11) doesn't support stereo formats * Wrong filepath when trying to play back animated scene * Viewport Rendering doesn't support Multi-View * Overscan Rendering * Fullscreen display modes need to warn the user * Object copy should be aware of views suffix Acknowledgments =============== * Francesco Siddi for the help with the original feature specs and design * Brecht Van Lommel for the original review of the code and design early on * Blender Foundation for the Development Fund to support the project wrap up Final patch reviewers: * Antony Riakiotakis (psy-fi) * Campbell Barton (ideasman42) * Julian Eisel (Severin) * Sergey Sharybin (nazgul) * Thomas Dinged (dingto) Code contributors of the original branch in github: * Alexey Akishin * Gabriel Caraballo
2015-04-06 10:40:12 -03:00
return b_engine.begin_result(x, y, w, h, layername, viewname);
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
}
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
static void end_render_result(BL::RenderEngine& b_engine,
BL::RenderResult& b_rr,
bool cancel,
bool do_merge_results)
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
{
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
b_engine.end_result(b_rr, (int)cancel, (int)do_merge_results);
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
}
void BlenderSession::do_write_update_render_tile(RenderTile& rtile, bool do_update_only)
{
BufferParams& params = rtile.buffers->params;
int x = params.full_x - session->tile_manager.params.full_x;
int y = params.full_y - session->tile_manager.params.full_y;
int w = params.width;
int h = params.height;
/* get render result */
Multi-View and Stereo 3D Official Documentation: http://www.blender.org/manual/render/workflows/multiview.html Implemented Features ==================== Builtin Stereo Camera * Convergence Mode * Interocular Distance * Convergence Distance * Pivot Mode Viewport * Cameras * Plane * Volume Compositor * View Switch Node * Image Node Multi-View OpenEXR support Sequencer * Image/Movie Strips 'Use Multiview' UV/Image Editor * Option to see Multi-View images in Stereo-3D or its individual images * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images I/O * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images Scene Render Views * Ability to have an arbitrary number of views in the scene Missing Bits ============ First rule of Multi-View bug report: If something is not working as it should *when Views is off* this is a severe bug, do mention this in the report. Second rule is, if something works *when Views is off* but doesn't (or crashes) when *Views is on*, this is a important bug. Do mention this in the report. Everything else is likely small todos, and may wait until we are sure none of the above is happening. Apart from that there are those known issues: * Compositor Image Node poorly working for Multi-View OpenEXR (this was working prefectly before the 'Use Multi-View' functionality) * Selecting camera from Multi-View when looking from camera is problematic * Animation Playback (ctrl+F11) doesn't support stereo formats * Wrong filepath when trying to play back animated scene * Viewport Rendering doesn't support Multi-View * Overscan Rendering * Fullscreen display modes need to warn the user * Object copy should be aware of views suffix Acknowledgments =============== * Francesco Siddi for the help with the original feature specs and design * Brecht Van Lommel for the original review of the code and design early on * Blender Foundation for the Development Fund to support the project wrap up Final patch reviewers: * Antony Riakiotakis (psy-fi) * Campbell Barton (ideasman42) * Julian Eisel (Severin) * Sergey Sharybin (nazgul) * Thomas Dinged (dingto) Code contributors of the original branch in github: * Alexey Akishin * Gabriel Caraballo
2015-04-06 10:40:12 -03:00
BL::RenderResult b_rr = begin_render_result(b_engine, x, y, w, h, b_rlay_name.c_str(), b_rview_name.c_str());
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
/* can happen if the intersected rectangle gives 0 width or height */
Cycles: Code cleanup, spaces around keywords This inconsistency drove me totally crazy, it's really confusing when it's inconsistent especially when you work on both Cycles and Blender sides. Shouldn;t cause merge PITA, it's whitespace changes only, Git should be able to merge it nicely.
2015-03-28 00:15:15 +05:00
if(b_rr.ptr.data == NULL) {
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
return;
}
BL::RenderResult::layers_iterator b_single_rlay;
b_rr.layers.begin(b_single_rlay);
Fix #36235: cycles crash deactivating render layer during rendering.
2013-07-29 15:32:24 +00:00
/* layer will be missing if it was disabled in the UI */
if(b_single_rlay == b_rr.layers.end())
return;
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
BL::RenderLayer b_rlay = *b_single_rlay;
Cycles: Code cleanup, spaces around keywords This inconsistency drove me totally crazy, it's really confusing when it's inconsistent especially when you work on both Cycles and Blender sides. Shouldn;t cause merge PITA, it's whitespace changes only, Git should be able to merge it nicely.
2015-03-28 00:15:15 +05:00
if(do_update_only) {
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
/* update only needed */
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
Cycles: Code cleanup, spaces around keywords This inconsistency drove me totally crazy, it's really confusing when it's inconsistent especially when you work on both Cycles and Blender sides. Shouldn;t cause merge PITA, it's whitespace changes only, Git should be able to merge it nicely.
2015-03-28 00:15:15 +05:00
if(rtile.sample != 0) {
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
/* sample would be zero at initial tile update, which is only needed
* to tag tile form blender side as IN PROGRESS for proper highlight
* no buffers should be sent to blender yet
*/
update_render_result(b_rr, b_rlay, rtile);
}
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
end_render_result(b_engine, b_rr, true, true);
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
}
else {
/* write result */
write_render_result(b_rr, b_rlay, rtile);
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
end_render_result(b_engine, b_rr, false, true);
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
}
}
void BlenderSession::write_render_tile(RenderTile& rtile)
{
do_write_update_render_tile(rtile, false);
}
void BlenderSession::update_render_tile(RenderTile& rtile)
{
Cycles: preview rendering support for world/material/lamp. Patch by Sergey, .blend by Thomas and some further tweaks by me. Still to solve later: allow external engines to specify own preview .blend, for now the code here is doing too much magic hacking on the preview scene still.
2013-01-28 17:37:51 +00:00
/* use final write for preview renders, otherwise render result wouldn't be
* be updated in blender side
* would need to be investigated a bit further, but for now shall be fine
*/
Cycles: Code cleanup, spaces around keywords This inconsistency drove me totally crazy, it's really confusing when it's inconsistent especially when you work on both Cycles and Blender sides. Shouldn;t cause merge PITA, it's whitespace changes only, Git should be able to merge it nicely.
2015-03-28 00:15:15 +05:00
if(!b_engine.is_preview())
Cycles: preview rendering support for world/material/lamp. Patch by Sergey, .blend by Thomas and some further tweaks by me. Still to solve later: allow external engines to specify own preview .blend, for now the code here is doing too much magic hacking on the preview scene still.
2013-01-28 17:37:51 +00:00
do_write_update_render_tile(rtile, true);
else
do_write_update_render_tile(rtile, false);
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
}
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
void BlenderSession::render()
{
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
/* set callback to write out render results */
session->write_render_tile_cb = function_bind(&BlenderSession::write_render_tile, this, _1);
session->update_render_tile_cb = function_bind(&BlenderSession::update_render_tile, this, _1);
Cycles: support for multiple render layers. It currently renders each layer entirely before moving on to the next.
2011-12-21 20:51:55 +00:00
/* get buffer parameters */
Cycles: Initialize "headless" flags on engine initialization This flag is global for all the sessions and never changes. so it doesn't really make sense to pass it around to all sessions and synchronization routines. Switched to a static member of BlenderSession now, but it's probably more logical to introduce some sort of BlenderGlobals. Doesn't currently worth a hassle for a single boolean flag tho.
2015-02-18 21:16:52 +05:00
SessionParams session_params = BlenderSync::get_session_params(b_engine, b_userpref, b_scene, background);
Cycles: Code cleanup, prepare for strict C++ flags
2015-03-27 15:47:55 +05:00
BufferParams buffer_params = BlenderSync::get_buffer_params(b_render, b_v3d, b_rv3d, scene->camera, width, height);
Cycles: support for multiple render layers. It currently renders each layer entirely before moving on to the next.
2011-12-21 20:51:55 +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
/* render each layer */
Cycles: support for multiple render layers. It currently renders each layer entirely before moving on to the next.
2011-12-21 20:51:55 +00:00
BL::RenderSettings r = b_scene.render();
Multi-View and Stereo 3D Official Documentation: http://www.blender.org/manual/render/workflows/multiview.html Implemented Features ==================== Builtin Stereo Camera * Convergence Mode * Interocular Distance * Convergence Distance * Pivot Mode Viewport * Cameras * Plane * Volume Compositor * View Switch Node * Image Node Multi-View OpenEXR support Sequencer * Image/Movie Strips 'Use Multiview' UV/Image Editor * Option to see Multi-View images in Stereo-3D or its individual images * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images I/O * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images Scene Render Views * Ability to have an arbitrary number of views in the scene Missing Bits ============ First rule of Multi-View bug report: If something is not working as it should *when Views is off* this is a severe bug, do mention this in the report. Second rule is, if something works *when Views is off* but doesn't (or crashes) when *Views is on*, this is a important bug. Do mention this in the report. Everything else is likely small todos, and may wait until we are sure none of the above is happening. Apart from that there are those known issues: * Compositor Image Node poorly working for Multi-View OpenEXR (this was working prefectly before the 'Use Multi-View' functionality) * Selecting camera from Multi-View when looking from camera is problematic * Animation Playback (ctrl+F11) doesn't support stereo formats * Wrong filepath when trying to play back animated scene * Viewport Rendering doesn't support Multi-View * Overscan Rendering * Fullscreen display modes need to warn the user * Object copy should be aware of views suffix Acknowledgments =============== * Francesco Siddi for the help with the original feature specs and design * Brecht Van Lommel for the original review of the code and design early on * Blender Foundation for the Development Fund to support the project wrap up Final patch reviewers: * Antony Riakiotakis (psy-fi) * Campbell Barton (ideasman42) * Julian Eisel (Severin) * Sergey Sharybin (nazgul) * Thomas Dinged (dingto) Code contributors of the original branch in github: * Alexey Akishin * Gabriel Caraballo
2015-04-06 10:40:12 -03:00
BL::RenderSettings::layers_iterator b_layer_iter;
BL::RenderResult::views_iterator b_view_iter;
Cycles: support for multiple render layers. It currently renders each layer entirely before moving on to the next.
2011-12-21 20:51:55 +00:00
Multi-View and Stereo 3D Official Documentation: http://www.blender.org/manual/render/workflows/multiview.html Implemented Features ==================== Builtin Stereo Camera * Convergence Mode * Interocular Distance * Convergence Distance * Pivot Mode Viewport * Cameras * Plane * Volume Compositor * View Switch Node * Image Node Multi-View OpenEXR support Sequencer * Image/Movie Strips 'Use Multiview' UV/Image Editor * Option to see Multi-View images in Stereo-3D or its individual images * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images I/O * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images Scene Render Views * Ability to have an arbitrary number of views in the scene Missing Bits ============ First rule of Multi-View bug report: If something is not working as it should *when Views is off* this is a severe bug, do mention this in the report. Second rule is, if something works *when Views is off* but doesn't (or crashes) when *Views is on*, this is a important bug. Do mention this in the report. Everything else is likely small todos, and may wait until we are sure none of the above is happening. Apart from that there are those known issues: * Compositor Image Node poorly working for Multi-View OpenEXR (this was working prefectly before the 'Use Multi-View' functionality) * Selecting camera from Multi-View when looking from camera is problematic * Animation Playback (ctrl+F11) doesn't support stereo formats * Wrong filepath when trying to play back animated scene * Viewport Rendering doesn't support Multi-View * Overscan Rendering * Fullscreen display modes need to warn the user * Object copy should be aware of views suffix Acknowledgments =============== * Francesco Siddi for the help with the original feature specs and design * Brecht Van Lommel for the original review of the code and design early on * Blender Foundation for the Development Fund to support the project wrap up Final patch reviewers: * Antony Riakiotakis (psy-fi) * Campbell Barton (ideasman42) * Julian Eisel (Severin) * Sergey Sharybin (nazgul) * Thomas Dinged (dingto) Code contributors of the original branch in github: * Alexey Akishin * Gabriel Caraballo
2015-04-06 10:40:12 -03:00
for(r.layers.begin(b_layer_iter); b_layer_iter != r.layers.end(); ++b_layer_iter) {
b_rlay_name = b_layer_iter->name();
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
Multi-View and Stereo 3D Official Documentation: http://www.blender.org/manual/render/workflows/multiview.html Implemented Features ==================== Builtin Stereo Camera * Convergence Mode * Interocular Distance * Convergence Distance * Pivot Mode Viewport * Cameras * Plane * Volume Compositor * View Switch Node * Image Node Multi-View OpenEXR support Sequencer * Image/Movie Strips 'Use Multiview' UV/Image Editor * Option to see Multi-View images in Stereo-3D or its individual images * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images I/O * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images Scene Render Views * Ability to have an arbitrary number of views in the scene Missing Bits ============ First rule of Multi-View bug report: If something is not working as it should *when Views is off* this is a severe bug, do mention this in the report. Second rule is, if something works *when Views is off* but doesn't (or crashes) when *Views is on*, this is a important bug. Do mention this in the report. Everything else is likely small todos, and may wait until we are sure none of the above is happening. Apart from that there are those known issues: * Compositor Image Node poorly working for Multi-View OpenEXR (this was working prefectly before the 'Use Multi-View' functionality) * Selecting camera from Multi-View when looking from camera is problematic * Animation Playback (ctrl+F11) doesn't support stereo formats * Wrong filepath when trying to play back animated scene * Viewport Rendering doesn't support Multi-View * Overscan Rendering * Fullscreen display modes need to warn the user * Object copy should be aware of views suffix Acknowledgments =============== * Francesco Siddi for the help with the original feature specs and design * Brecht Van Lommel for the original review of the code and design early on * Blender Foundation for the Development Fund to support the project wrap up Final patch reviewers: * Antony Riakiotakis (psy-fi) * Campbell Barton (ideasman42) * Julian Eisel (Severin) * Sergey Sharybin (nazgul) * Thomas Dinged (dingto) Code contributors of the original branch in github: * Alexey Akishin * Gabriel Caraballo
2015-04-06 10:40:12 -03:00
/* temporary render result to find needed passes and views */
BL::RenderResult b_rr = begin_render_result(b_engine, 0, 0, 1, 1, b_rlay_name.c_str(), NULL);
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
BL::RenderResult::layers_iterator b_single_rlay;
b_rr.layers.begin(b_single_rlay);
/* layer will be missing if it was disabled in the UI */
if(b_single_rlay == b_rr.layers.end()) {
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
end_render_result(b_engine, b_rr, true, false);
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
continue;
}
BL::RenderLayer b_rlay = *b_single_rlay;
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
/* add passes */
Code refactor: nodify Cycles background and film. Differential Revision: https://developer.blender.org/D2016
2016-05-07 20:30:16 +02:00
array<Pass> passes;
Cycles: fix issues rendering second render layer passes, and avoid unnecessary clear of buffer.
2012-01-26 14:55:25 +00:00
Pass::add(PASS_COMBINED, passes);
Cycles: render passes for CUDA cards with compute model >= 2.x.
2012-01-26 19:07:01 +00:00
if(session_params.device.advanced_shading) {
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
/* loop over passes */
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
BL::RenderLayer::passes_iterator b_pass_iter;
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
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
for(b_rlay.passes.begin(b_pass_iter); b_pass_iter != b_rlay.passes.end(); ++b_pass_iter) {
BL::RenderPass b_pass(*b_pass_iter);
PassType pass_type = get_pass_type(b_pass);
Cycles: support for motion vector and UV passes. Most of the changes are related to adding support for motion data throughout the code. There's some code for actual camera/object motion blur raytracing but it's unfinished (it badly slows down the raytracing kernel even when the option is turned off), so that code it disabled still. Motion vector export from Blender tries to avoid computing derived meshes when the mesh does not have a deforming modifier, and it also won't store motion vectors for every vertex if only the object or camera is moving.
2012-04-30 12:49:26 +00:00
if(pass_type == PASS_MOTION && scene->integrator->motion_blur)
continue;
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
if(pass_type != PASS_NONE)
Cycles: fix issues rendering second render layer passes, and avoid unnecessary clear of buffer.
2012-01-26 14:55:25 +00:00
Pass::add(pass_type, passes);
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
}
}
Cycles: fix issues rendering second render layer passes, and avoid unnecessary clear of buffer.
2012-01-26 14:55:25 +00:00
buffer_params.passes = passes;
Multi-View and Stereo 3D Official Documentation: http://www.blender.org/manual/render/workflows/multiview.html Implemented Features ==================== Builtin Stereo Camera * Convergence Mode * Interocular Distance * Convergence Distance * Pivot Mode Viewport * Cameras * Plane * Volume Compositor * View Switch Node * Image Node Multi-View OpenEXR support Sequencer * Image/Movie Strips 'Use Multiview' UV/Image Editor * Option to see Multi-View images in Stereo-3D or its individual images * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images I/O * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images Scene Render Views * Ability to have an arbitrary number of views in the scene Missing Bits ============ First rule of Multi-View bug report: If something is not working as it should *when Views is off* this is a severe bug, do mention this in the report. Second rule is, if something works *when Views is off* but doesn't (or crashes) when *Views is on*, this is a important bug. Do mention this in the report. Everything else is likely small todos, and may wait until we are sure none of the above is happening. Apart from that there are those known issues: * Compositor Image Node poorly working for Multi-View OpenEXR (this was working prefectly before the 'Use Multi-View' functionality) * Selecting camera from Multi-View when looking from camera is problematic * Animation Playback (ctrl+F11) doesn't support stereo formats * Wrong filepath when trying to play back animated scene * Viewport Rendering doesn't support Multi-View * Overscan Rendering * Fullscreen display modes need to warn the user * Object copy should be aware of views suffix Acknowledgments =============== * Francesco Siddi for the help with the original feature specs and design * Brecht Van Lommel for the original review of the code and design early on * Blender Foundation for the Development Fund to support the project wrap up Final patch reviewers: * Antony Riakiotakis (psy-fi) * Campbell Barton (ideasman42) * Julian Eisel (Severin) * Sergey Sharybin (nazgul) * Thomas Dinged (dingto) Code contributors of the original branch in github: * Alexey Akishin * Gabriel Caraballo
2015-04-06 10:40:12 -03:00
scene->film->pass_alpha_threshold = b_layer_iter->pass_alpha_threshold();
Fix #31883: cycles vectors pass rendering crash with some render layers using it and others not.
2012-06-20 14:24:52 +00:00
scene->film->tag_passes_update(scene, passes);
Cycles: fix issues rendering second render layer passes, and avoid unnecessary clear of buffer.
2012-01-26 14:55:25 +00:00
scene->film->tag_update(scene);
Fix #31518: changing cycles exposure did unnecessary rerender in viewport.
2012-05-18 14:06:53 +00:00
scene->integrator->tag_update(scene);
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
Cycles: Different noise seed for stereoscopic rendering (Fix #T50024) Patch by Sergey Sharybin.
2016-11-18 18:23:45 +01:00
int view_index = 0;
for(b_rr.views.begin(b_view_iter); b_view_iter != b_rr.views.end(); ++b_view_iter, ++view_index) {
Multi-View and Stereo 3D Official Documentation: http://www.blender.org/manual/render/workflows/multiview.html Implemented Features ==================== Builtin Stereo Camera * Convergence Mode * Interocular Distance * Convergence Distance * Pivot Mode Viewport * Cameras * Plane * Volume Compositor * View Switch Node * Image Node Multi-View OpenEXR support Sequencer * Image/Movie Strips 'Use Multiview' UV/Image Editor * Option to see Multi-View images in Stereo-3D or its individual images * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images I/O * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images Scene Render Views * Ability to have an arbitrary number of views in the scene Missing Bits ============ First rule of Multi-View bug report: If something is not working as it should *when Views is off* this is a severe bug, do mention this in the report. Second rule is, if something works *when Views is off* but doesn't (or crashes) when *Views is on*, this is a important bug. Do mention this in the report. Everything else is likely small todos, and may wait until we are sure none of the above is happening. Apart from that there are those known issues: * Compositor Image Node poorly working for Multi-View OpenEXR (this was working prefectly before the 'Use Multi-View' functionality) * Selecting camera from Multi-View when looking from camera is problematic * Animation Playback (ctrl+F11) doesn't support stereo formats * Wrong filepath when trying to play back animated scene * Viewport Rendering doesn't support Multi-View * Overscan Rendering * Fullscreen display modes need to warn the user * Object copy should be aware of views suffix Acknowledgments =============== * Francesco Siddi for the help with the original feature specs and design * Brecht Van Lommel for the original review of the code and design early on * Blender Foundation for the Development Fund to support the project wrap up Final patch reviewers: * Antony Riakiotakis (psy-fi) * Campbell Barton (ideasman42) * Julian Eisel (Severin) * Sergey Sharybin (nazgul) * Thomas Dinged (dingto) Code contributors of the original branch in github: * Alexey Akishin * Gabriel Caraballo
2015-04-06 10:40:12 -03:00
b_rview_name = b_view_iter->name();
Cycles: support for multiple render layers. It currently renders each layer entirely before moving on to the next.
2011-12-21 20:51:55 +00:00
Multi-View and Stereo 3D Official Documentation: http://www.blender.org/manual/render/workflows/multiview.html Implemented Features ==================== Builtin Stereo Camera * Convergence Mode * Interocular Distance * Convergence Distance * Pivot Mode Viewport * Cameras * Plane * Volume Compositor * View Switch Node * Image Node Multi-View OpenEXR support Sequencer * Image/Movie Strips 'Use Multiview' UV/Image Editor * Option to see Multi-View images in Stereo-3D or its individual images * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images I/O * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images Scene Render Views * Ability to have an arbitrary number of views in the scene Missing Bits ============ First rule of Multi-View bug report: If something is not working as it should *when Views is off* this is a severe bug, do mention this in the report. Second rule is, if something works *when Views is off* but doesn't (or crashes) when *Views is on*, this is a important bug. Do mention this in the report. Everything else is likely small todos, and may wait until we are sure none of the above is happening. Apart from that there are those known issues: * Compositor Image Node poorly working for Multi-View OpenEXR (this was working prefectly before the 'Use Multi-View' functionality) * Selecting camera from Multi-View when looking from camera is problematic * Animation Playback (ctrl+F11) doesn't support stereo formats * Wrong filepath when trying to play back animated scene * Viewport Rendering doesn't support Multi-View * Overscan Rendering * Fullscreen display modes need to warn the user * Object copy should be aware of views suffix Acknowledgments =============== * Francesco Siddi for the help with the original feature specs and design * Brecht Van Lommel for the original review of the code and design early on * Blender Foundation for the Development Fund to support the project wrap up Final patch reviewers: * Antony Riakiotakis (psy-fi) * Campbell Barton (ideasman42) * Julian Eisel (Severin) * Sergey Sharybin (nazgul) * Thomas Dinged (dingto) Code contributors of the original branch in github: * Alexey Akishin * Gabriel Caraballo
2015-04-06 10:40:12 -03:00
/* set the current view */
b_engine.active_view_set(b_rview_name.c_str());
Cycles: when render layers have per layer number of samples set, the Sampling panel now has an option to specify how to use them. There's three options: * Use: render layer samples override scene samples * Bounded: bound render layer samples by scene samples * Ignore: ignore render layer sample settings
2013-04-16 16:18:14 +00:00
Multi-View and Stereo 3D Official Documentation: http://www.blender.org/manual/render/workflows/multiview.html Implemented Features ==================== Builtin Stereo Camera * Convergence Mode * Interocular Distance * Convergence Distance * Pivot Mode Viewport * Cameras * Plane * Volume Compositor * View Switch Node * Image Node Multi-View OpenEXR support Sequencer * Image/Movie Strips 'Use Multiview' UV/Image Editor * Option to see Multi-View images in Stereo-3D or its individual images * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images I/O * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images Scene Render Views * Ability to have an arbitrary number of views in the scene Missing Bits ============ First rule of Multi-View bug report: If something is not working as it should *when Views is off* this is a severe bug, do mention this in the report. Second rule is, if something works *when Views is off* but doesn't (or crashes) when *Views is on*, this is a important bug. Do mention this in the report. Everything else is likely small todos, and may wait until we are sure none of the above is happening. Apart from that there are those known issues: * Compositor Image Node poorly working for Multi-View OpenEXR (this was working prefectly before the 'Use Multi-View' functionality) * Selecting camera from Multi-View when looking from camera is problematic * Animation Playback (ctrl+F11) doesn't support stereo formats * Wrong filepath when trying to play back animated scene * Viewport Rendering doesn't support Multi-View * Overscan Rendering * Fullscreen display modes need to warn the user * Object copy should be aware of views suffix Acknowledgments =============== * Francesco Siddi for the help with the original feature specs and design * Brecht Van Lommel for the original review of the code and design early on * Blender Foundation for the Development Fund to support the project wrap up Final patch reviewers: * Antony Riakiotakis (psy-fi) * Campbell Barton (ideasman42) * Julian Eisel (Severin) * Sergey Sharybin (nazgul) * Thomas Dinged (dingto) Code contributors of the original branch in github: * Alexey Akishin * Gabriel Caraballo
2015-04-06 10:40:12 -03:00
/* update scene */
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
BL::Object b_camera_override(b_engine.camera_override());
Multi-View: Cycles - Spherical Stereo support (VR Panoramas) This is a new option for panorama cameras to render stereo that can be used in virtual reality devices The option is available under the camera panel when Multi-View is enabled (Views option in the Render Layers panel) Known limitations: ------------------ * Parallel convergence is not supported (you need to set a convergence distance really high to simulate this effect). * Pivot was not supposed to affect the render but it does, this has to be looked at, but for now set it to CENTER * Derivatives in perspective camera need to be pre-computed or we shuld get rid of kcam->dx/dy (Sergey words, I don't fully grasp the implication shere) * This works in perspective mode and in panorama mode. However, for fully benefit from this effect in perspective mode you need to render a cube map. (there is an addon for this, developed separately, perhaps we could include it in master). * We have no support for "neck distance" at the moment. This is supposed to help with objects at short distances. * We have no support to rotate the "Up Axis" of the stereo plane. Meaning, we hardcode 0,0,1 as UP, and create the stereo pair related to that. (although we could take the camera local UP when rendering panoramas, this wouldn't work for perspective cameras. * We have no support for interocular distance attenuation based on the proximity of the poles (which helps to reduce the pole rotation effect/artifact). THIS NEEDS DOCS - both in 2.78 release log and the Blender manual. Meanwhile you can read about it here: http://code.blender.org/2015/03/1451 This patch specifically dates from March 2015, as you can see in the code.blender.org post. Many thanks to all the reviewers, testers and minor sponsors who helped me maintain spherical-stereo for 1 year. All that said, have fun with this. This feature was what got me started with Multi-View development (at the time what I was looking for was Fulldome stereo support, but the implementation is the same). In order to make this into Blender I had to make it aiming at a less-specic user-case Thus Multi-View started. (this was December 2012, during Siggraph Asia and a chat I had with Paul Bourke during the conference). I don't have the original patch anymore, but you can find a re-based version of it from March 2013, right before I start with the Multi-View project https://developer.blender.org/P332 Reviewers: sergey, dingto Subscribers: #cycles Differential Revision: https://developer.blender.org/D1223
2016-03-10 09:28:29 -03:00
sync->sync_camera(b_render, b_camera_override, width, height, b_rview_name.c_str());
Cycles: Implement camera zoom motion blur Works totally similar to camera motion blur and majority of the changes are related on just passing extra arguments to sync() functions. Couple of things still to look into: - Motion pass will not include motion caused by the zoom. - Only perspective cameras are supported currently. - Motion is being interpolated on projected coordinates, which might give different results from constructing projection matrix from interpolated field of view. This could be good enough for us, but we need to consider improving this at some point. Reviewers: juicyfruit, dingto Reviewed By: dingto Differential Revision: https://developer.blender.org/D1383
2015-07-21 15:36:35 +02:00
sync->sync_data(b_render,
b_v3d,
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
b_camera_override,
Cycles: Implement camera zoom motion blur Works totally similar to camera motion blur and majority of the changes are related on just passing extra arguments to sync() functions. Couple of things still to look into: - Motion pass will not include motion caused by the zoom. - Only perspective cameras are supported currently. - Motion is being interpolated on projected coordinates, which might give different results from constructing projection matrix from interpolated field of view. This could be good enough for us, but we need to consider improving this at some point. Reviewers: juicyfruit, dingto Reviewed By: dingto Differential Revision: https://developer.blender.org/D1383
2015-07-21 15:36:35 +02:00
width, height,
&python_thread_state,
b_rlay_name.c_str());
Cycles: merging features from tomato branch. === BVH build time optimizations === * BVH building was multithreaded. Not all building is multithreaded, packing and the initial bounding/splitting is still single threaded, but recursive splitting is, which was the main bottleneck. * Object splitting now uses binning rather than sorting of all elements, using code from the Embree raytracer from Intel. http://software.intel.com/en-us/articles/embree-photo-realistic-ray-tracing-kernels/ * Other small changes to avoid allocations, pack memory more tightly, avoid some unnecessary operations, ... These optimizations do not work yet when Spatial Splits are enabled, for that more work is needed. There's also other optimizations still needed, in particular for the case of many low poly objects, the packing step and node memory allocation. BVH raytracing time should remain about the same, but BVH build time should be significantly reduced, test here show speedup of about 5x to 10x on a dual core and 5x to 25x on an 8-core machine, depending on the scene. === Threads === Centralized task scheduler for multithreading, which is basically the CPU device threading code wrapped into something reusable. Basic idea is that there is a single TaskScheduler that keeps a pool of threads, one for each core. Other places in the code can then create a TaskPool that they can drop Tasks in to be executed by the scheduler, and wait for them to complete or cancel them early. === Normal ==== Added a Normal output to the texture coordinate node. This currently gives the object space normal, which is the same under object animation. In the future this might become a "generated" normal so it's also stable for deforming objects, but for now it's already useful for non-deforming objects. === Render Layers === Per render layer Samples control, leaving it to 0 will use the common scene setting. Environment pass will now render environment even if film is set to transparent. Exclude Layers" added. Scene layers (all object that influence the render, directly or indirectly) are shared between all render layers. However sometimes it's useful to leave out some object influence for a particular render layer. That's what this option allows you to do. === Filter Glossy === When using a value higher than 0.0, this will blur glossy reflections after blurry bounces, to reduce noise at the cost of accuracy. 1.0 is a good starting value to tweak. Some light paths have a low probability of being found while contributing much light to the pixel. As a result these light paths will be found in some pixels and not in others, causing fireflies. An example of such a difficult path might be a small light that is causing a small specular highlight on a sharp glossy material, which we are seeing through a rough glossy material. With path tracing it is difficult to find the specular highlight, but if we increase the roughness on the material the highlight gets bigger and softer, and so easier to find. Often this blurring will be hardly noticeable, because we are seeing it through a blurry material anyway, but there are also cases where this will lead to a loss of detail in lighting.
2012-04-28 08:53:59 +00:00
Cycles: Different noise seed for stereoscopic rendering (Fix #T50024) Patch by Sergey Sharybin.
2016-11-18 18:23:45 +01:00
/* Make sure all views have different noise patterns. - hardcoded value just to make it random */
if(view_index != 0) {
scene->integrator->seed += hash_int_2d(scene->integrator->seed, hash_int(view_index * 0xdeadbeef));
scene->integrator->tag_update(scene);
}
Cycles: Resumable render implementation for Cycles This feature is also known by the name Samples Offset, which allows artists to render animation with given amount of samples N, but then render more samples, starting from N and ending with M (where M > N) and merge renders together as if they rendered exactly M samples. Surely such effect could be achieved by changing Seed variable, but that has possible issues with correlation artifacts and requiring to manually deal with per render layer samples and such. While we can't support all possible renderfarm-related features in Cycles it's nice to support really commonly used stuff. Here's a command how to run Blender with the new feature enabled: blender -- --cycles-resumable-num-chunks 24 --cycles-resumable-current-chunk 2 This command will divide samples range in 24 parts and render range #2 (chunk number is 1-based). This feature might be changed a bit after we'll do some tests here in the studio with it.
2016-03-30 15:55:12 +02:00
/* Update number of samples per layer. */
Multi-View and Stereo 3D Official Documentation: http://www.blender.org/manual/render/workflows/multiview.html Implemented Features ==================== Builtin Stereo Camera * Convergence Mode * Interocular Distance * Convergence Distance * Pivot Mode Viewport * Cameras * Plane * Volume Compositor * View Switch Node * Image Node Multi-View OpenEXR support Sequencer * Image/Movie Strips 'Use Multiview' UV/Image Editor * Option to see Multi-View images in Stereo-3D or its individual images * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images I/O * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images Scene Render Views * Ability to have an arbitrary number of views in the scene Missing Bits ============ First rule of Multi-View bug report: If something is not working as it should *when Views is off* this is a severe bug, do mention this in the report. Second rule is, if something works *when Views is off* but doesn't (or crashes) when *Views is on*, this is a important bug. Do mention this in the report. Everything else is likely small todos, and may wait until we are sure none of the above is happening. Apart from that there are those known issues: * Compositor Image Node poorly working for Multi-View OpenEXR (this was working prefectly before the 'Use Multi-View' functionality) * Selecting camera from Multi-View when looking from camera is problematic * Animation Playback (ctrl+F11) doesn't support stereo formats * Wrong filepath when trying to play back animated scene * Viewport Rendering doesn't support Multi-View * Overscan Rendering * Fullscreen display modes need to warn the user * Object copy should be aware of views suffix Acknowledgments =============== * Francesco Siddi for the help with the original feature specs and design * Brecht Van Lommel for the original review of the code and design early on * Blender Foundation for the Development Fund to support the project wrap up Final patch reviewers: * Antony Riakiotakis (psy-fi) * Campbell Barton (ideasman42) * Julian Eisel (Severin) * Sergey Sharybin (nazgul) * Thomas Dinged (dingto) Code contributors of the original branch in github: * Alexey Akishin * Gabriel Caraballo
2015-04-06 10:40:12 -03:00
int samples = sync->get_layer_samples();
bool bound_samples = sync->get_layer_bound_samples();
Cycles: Resumable render implementation for Cycles This feature is also known by the name Samples Offset, which allows artists to render animation with given amount of samples N, but then render more samples, starting from N and ending with M (where M > N) and merge renders together as if they rendered exactly M samples. Surely such effect could be achieved by changing Seed variable, but that has possible issues with correlation artifacts and requiring to manually deal with per render layer samples and such. While we can't support all possible renderfarm-related features in Cycles it's nice to support really commonly used stuff. Here's a command how to run Blender with the new feature enabled: blender -- --cycles-resumable-num-chunks 24 --cycles-resumable-current-chunk 2 This command will divide samples range in 24 parts and render range #2 (chunk number is 1-based). This feature might be changed a bit after we'll do some tests here in the studio with it.
2016-03-30 15:55:12 +02:00
int effective_layer_samples;
Multi-View and Stereo 3D Official Documentation: http://www.blender.org/manual/render/workflows/multiview.html Implemented Features ==================== Builtin Stereo Camera * Convergence Mode * Interocular Distance * Convergence Distance * Pivot Mode Viewport * Cameras * Plane * Volume Compositor * View Switch Node * Image Node Multi-View OpenEXR support Sequencer * Image/Movie Strips 'Use Multiview' UV/Image Editor * Option to see Multi-View images in Stereo-3D or its individual images * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images I/O * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images Scene Render Views * Ability to have an arbitrary number of views in the scene Missing Bits ============ First rule of Multi-View bug report: If something is not working as it should *when Views is off* this is a severe bug, do mention this in the report. Second rule is, if something works *when Views is off* but doesn't (or crashes) when *Views is on*, this is a important bug. Do mention this in the report. Everything else is likely small todos, and may wait until we are sure none of the above is happening. Apart from that there are those known issues: * Compositor Image Node poorly working for Multi-View OpenEXR (this was working prefectly before the 'Use Multi-View' functionality) * Selecting camera from Multi-View when looking from camera is problematic * Animation Playback (ctrl+F11) doesn't support stereo formats * Wrong filepath when trying to play back animated scene * Viewport Rendering doesn't support Multi-View * Overscan Rendering * Fullscreen display modes need to warn the user * Object copy should be aware of views suffix Acknowledgments =============== * Francesco Siddi for the help with the original feature specs and design * Brecht Van Lommel for the original review of the code and design early on * Blender Foundation for the Development Fund to support the project wrap up Final patch reviewers: * Antony Riakiotakis (psy-fi) * Campbell Barton (ideasman42) * Julian Eisel (Severin) * Sergey Sharybin (nazgul) * Thomas Dinged (dingto) Code contributors of the original branch in github: * Alexey Akishin * Gabriel Caraballo
2015-04-06 10:40:12 -03:00
if(samples != 0 && (!bound_samples || (samples < session_params.samples)))
Cycles: Resumable render implementation for Cycles This feature is also known by the name Samples Offset, which allows artists to render animation with given amount of samples N, but then render more samples, starting from N and ending with M (where M > N) and merge renders together as if they rendered exactly M samples. Surely such effect could be achieved by changing Seed variable, but that has possible issues with correlation artifacts and requiring to manually deal with per render layer samples and such. While we can't support all possible renderfarm-related features in Cycles it's nice to support really commonly used stuff. Here's a command how to run Blender with the new feature enabled: blender -- --cycles-resumable-num-chunks 24 --cycles-resumable-current-chunk 2 This command will divide samples range in 24 parts and render range #2 (chunk number is 1-based). This feature might be changed a bit after we'll do some tests here in the studio with it.
2016-03-30 15:55:12 +02:00
effective_layer_samples = samples;
Multi-View and Stereo 3D Official Documentation: http://www.blender.org/manual/render/workflows/multiview.html Implemented Features ==================== Builtin Stereo Camera * Convergence Mode * Interocular Distance * Convergence Distance * Pivot Mode Viewport * Cameras * Plane * Volume Compositor * View Switch Node * Image Node Multi-View OpenEXR support Sequencer * Image/Movie Strips 'Use Multiview' UV/Image Editor * Option to see Multi-View images in Stereo-3D or its individual images * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images I/O * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images Scene Render Views * Ability to have an arbitrary number of views in the scene Missing Bits ============ First rule of Multi-View bug report: If something is not working as it should *when Views is off* this is a severe bug, do mention this in the report. Second rule is, if something works *when Views is off* but doesn't (or crashes) when *Views is on*, this is a important bug. Do mention this in the report. Everything else is likely small todos, and may wait until we are sure none of the above is happening. Apart from that there are those known issues: * Compositor Image Node poorly working for Multi-View OpenEXR (this was working prefectly before the 'Use Multi-View' functionality) * Selecting camera from Multi-View when looking from camera is problematic * Animation Playback (ctrl+F11) doesn't support stereo formats * Wrong filepath when trying to play back animated scene * Viewport Rendering doesn't support Multi-View * Overscan Rendering * Fullscreen display modes need to warn the user * Object copy should be aware of views suffix Acknowledgments =============== * Francesco Siddi for the help with the original feature specs and design * Brecht Van Lommel for the original review of the code and design early on * Blender Foundation for the Development Fund to support the project wrap up Final patch reviewers: * Antony Riakiotakis (psy-fi) * Campbell Barton (ideasman42) * Julian Eisel (Severin) * Sergey Sharybin (nazgul) * Thomas Dinged (dingto) Code contributors of the original branch in github: * Alexey Akishin * Gabriel Caraballo
2015-04-06 10:40:12 -03:00
else
Cycles: Resumable render implementation for Cycles This feature is also known by the name Samples Offset, which allows artists to render animation with given amount of samples N, but then render more samples, starting from N and ending with M (where M > N) and merge renders together as if they rendered exactly M samples. Surely such effect could be achieved by changing Seed variable, but that has possible issues with correlation artifacts and requiring to manually deal with per render layer samples and such. While we can't support all possible renderfarm-related features in Cycles it's nice to support really commonly used stuff. Here's a command how to run Blender with the new feature enabled: blender -- --cycles-resumable-num-chunks 24 --cycles-resumable-current-chunk 2 This command will divide samples range in 24 parts and render range #2 (chunk number is 1-based). This feature might be changed a bit after we'll do some tests here in the studio with it.
2016-03-30 15:55:12 +02:00
effective_layer_samples = session_params.samples;
/* Update tile manager if we're doing resumable render. */
update_resumable_tile_manager(effective_layer_samples);
/* Update session itself. */
session->reset(buffer_params, effective_layer_samples);
Multi-View and Stereo 3D Official Documentation: http://www.blender.org/manual/render/workflows/multiview.html Implemented Features ==================== Builtin Stereo Camera * Convergence Mode * Interocular Distance * Convergence Distance * Pivot Mode Viewport * Cameras * Plane * Volume Compositor * View Switch Node * Image Node Multi-View OpenEXR support Sequencer * Image/Movie Strips 'Use Multiview' UV/Image Editor * Option to see Multi-View images in Stereo-3D or its individual images * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images I/O * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images Scene Render Views * Ability to have an arbitrary number of views in the scene Missing Bits ============ First rule of Multi-View bug report: If something is not working as it should *when Views is off* this is a severe bug, do mention this in the report. Second rule is, if something works *when Views is off* but doesn't (or crashes) when *Views is on*, this is a important bug. Do mention this in the report. Everything else is likely small todos, and may wait until we are sure none of the above is happening. Apart from that there are those known issues: * Compositor Image Node poorly working for Multi-View OpenEXR (this was working prefectly before the 'Use Multi-View' functionality) * Selecting camera from Multi-View when looking from camera is problematic * Animation Playback (ctrl+F11) doesn't support stereo formats * Wrong filepath when trying to play back animated scene * Viewport Rendering doesn't support Multi-View * Overscan Rendering * Fullscreen display modes need to warn the user * Object copy should be aware of views suffix Acknowledgments =============== * Francesco Siddi for the help with the original feature specs and design * Brecht Van Lommel for the original review of the code and design early on * Blender Foundation for the Development Fund to support the project wrap up Final patch reviewers: * Antony Riakiotakis (psy-fi) * Campbell Barton (ideasman42) * Julian Eisel (Severin) * Sergey Sharybin (nazgul) * Thomas Dinged (dingto) Code contributors of the original branch in github: * Alexey Akishin * Gabriel Caraballo
2015-04-06 10:40:12 -03:00
/* render */
session->start();
session->wait();
if(session->progress.get_cancel())
break;
}
/* free result without merging */
end_render_result(b_engine, b_rr, true, false);
Cycles: support for multiple render layers. It currently renders each layer entirely before moving on to the next.
2011-12-21 20:51:55 +00:00
if(session->progress.get_cancel())
break;
}
Cycles: Report total and render time to the log This includes total render time spent on rendering since render() was invoked and also prints time of actual rendering (without synchronization step).
2015-06-17 11:56:19 +02:00
double total_time, render_time;
session->progress.get_time(total_time, render_time);
VLOG(1) << "Total render time: " << total_time;
VLOG(1) << "Render time (without synchronization): " << render_time;
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
/* clear callback */
Cycles: Fix compilation error with MSVC after recent C++11 changes
2015-03-30 15:06:20 +05:00
session->write_render_tile_cb = function_null;
session->update_render_tile_cb = function_null;
Cycles: persistent images option This option enables keeping loaded images in the memory in-between of rendering. Implemented by keeping render engine alive for until Render structure is being freed. Cycles will free all data when render finishes, optionally keeping image manager untouched. All shaders, meshes, objects will be re-allocated next time rendering happens. Cycles cession and scene will be re-created from scratch if render/ scene parameters were changed. This will also allow to keep compiled OSL shaders in memory without need to re-compile them again. P.S. Performance panel could be cleaned up a bit, not so much happy with it's vertical alignment currently but not sure how to make it look better. P.P.S. Currently the only way to free images from the device is to disable Persistent Images option and start rendering.
2012-11-09 08:46:53 +00:00
/* free all memory used (host and device), so we wouldn't leave render
* engine with extra memory allocated
*/
session->device_free();
delete sync;
sync = NULL;
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
}
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
static void populate_bake_data(BakeData *data, const
int object_id,
BL::BakePixel& pixel_array,
const int num_pixels)
Cycles Bake Expand Cycles to use the new baking API in Blender. It works on the selected object, and the panel can be accessed in the Render panel (similar to where it is for the Blender Internal). It bakes for the active texture of each material of the object. The active texture is currently defined as the active Image Texture node present in the material nodetree. If you don't want the baking to override an existent material, make sure the active Image Texture node is not connected to the nodetree. The active texture is also the texture shown in the viewport in the rendered mode. Remember to save your images after the baking is complete. Note: Bake currently only works in the CPU Note: This is not supported by Cycles standalone because a lot of the work is done in Blender as part of the operator only, not the engine (Cycles). Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Bake Supported Passes: ----------------- Data Passes * Normal * UV * Diffuse/Glossy/Transmission/Subsurface/Emit Color Light Passes * AO * Combined * Shadow * Diffuse/Glossy/Transmission/Subsurface/Emit Direct/Indirect * Environment Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge 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
{
BL::BakePixel bp = pixel_array;
int i;
Cycles: Cleanup, whitespace around operator
2017-01-11 15:16:22 +01:00
for(i = 0; i < num_pixels; i++) {
Bake-API: reduce memory footprint when baking more than one object (Fix T41092) Combine all the highpoly pixel arrays into a single array with a lookup object_id for each of the highpoly objects. Note: This changes the Bake API, external engines should refer to the bake_api.c for the latest API. Many thanks for Sergey Sharybin for the complete review, changes suggestion and feedback. (you rock!) Reviewers: sergey Subscribers: pildanovak, marcclintdion, monio, metalliandy, brecht Maniphest Tasks: T41092 Differential Revision: https://developer.blender.org/D772
2015-04-17 12:25:37 -03:00
if(bp.object_id() == object_id) {
data->set(i, bp.primitive_id(), bp.uv(), bp.du_dx(), bp.du_dy(), bp.dv_dx(), bp.dv_dy());
} else {
data->set_null(i);
}
Cycles Bake Expand Cycles to use the new baking API in Blender. It works on the selected object, and the panel can be accessed in the Render panel (similar to where it is for the Blender Internal). It bakes for the active texture of each material of the object. The active texture is currently defined as the active Image Texture node present in the material nodetree. If you don't want the baking to override an existent material, make sure the active Image Texture node is not connected to the nodetree. The active texture is also the texture shown in the viewport in the rendered mode. Remember to save your images after the baking is complete. Note: Bake currently only works in the CPU Note: This is not supported by Cycles standalone because a lot of the work is done in Blender as part of the operator only, not the engine (Cycles). Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Bake Supported Passes: ----------------- Data Passes * Normal * UV * Diffuse/Glossy/Transmission/Subsurface/Emit Color Light Passes * AO * Combined * Shadow * Diffuse/Glossy/Transmission/Subsurface/Emit Direct/Indirect * Environment Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge 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
bp = bp.next();
}
}
Cycles-Bake: Custom Baking passes The combined pass is built with the contributions the user finds fit. It is useful for lightmap baking, as well as non-view dependent effects baking. The manual will be updated once we get closer to the 2.77 release. Meanwhile the new page can be found here: http://dalaifelinto.com/blender-manual/render/cycles/baking.html Reviewers: sergey, brecht Differential Revision: https://developer.blender.org/D1674
2016-01-15 13:00:56 -02:00
static int bake_pass_filter_get(const int pass_filter)
{
int flag = BAKE_FILTER_NONE;
if((pass_filter & BL::BakeSettings::pass_filter_DIRECT) != 0)
flag |= BAKE_FILTER_DIRECT;
if((pass_filter & BL::BakeSettings::pass_filter_INDIRECT) != 0)
flag |= BAKE_FILTER_INDIRECT;
if((pass_filter & BL::BakeSettings::pass_filter_COLOR) != 0)
flag |= BAKE_FILTER_COLOR;
if((pass_filter & BL::BakeSettings::pass_filter_DIFFUSE) != 0)
flag |= BAKE_FILTER_DIFFUSE;
if((pass_filter & BL::BakeSettings::pass_filter_GLOSSY) != 0)
flag |= BAKE_FILTER_GLOSSY;
if((pass_filter & BL::BakeSettings::pass_filter_TRANSMISSION) != 0)
flag |= BAKE_FILTER_TRANSMISSION;
if((pass_filter & BL::BakeSettings::pass_filter_SUBSURFACE) != 0)
flag |= BAKE_FILTER_SUBSURFACE;
if((pass_filter & BL::BakeSettings::pass_filter_EMIT) != 0)
flag |= BAKE_FILTER_EMISSION;
if((pass_filter & BL::BakeSettings::pass_filter_AO) != 0)
flag |= BAKE_FILTER_AO;
return flag;
}
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
void BlenderSession::bake(BL::Object& b_object,
Cycles-Bake: Custom Baking passes The combined pass is built with the contributions the user finds fit. It is useful for lightmap baking, as well as non-view dependent effects baking. The manual will be updated once we get closer to the 2.77 release. Meanwhile the new page can be found here: http://dalaifelinto.com/blender-manual/render/cycles/baking.html Reviewers: sergey, brecht Differential Revision: https://developer.blender.org/D1674
2016-01-15 13:00:56 -02:00
const string& pass_type,
const int pass_filter,
const int object_id,
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
BL::BakePixel& pixel_array,
Cycles-Bake: Custom Baking passes The combined pass is built with the contributions the user finds fit. It is useful for lightmap baking, as well as non-view dependent effects baking. The manual will be updated once we get closer to the 2.77 release. Meanwhile the new page can be found here: http://dalaifelinto.com/blender-manual/render/cycles/baking.html Reviewers: sergey, brecht Differential Revision: https://developer.blender.org/D1674
2016-01-15 13:00:56 -02:00
const size_t num_pixels,
const int /*depth*/,
float result[])
Cycles Bake Expand Cycles to use the new baking API in Blender. It works on the selected object, and the panel can be accessed in the Render panel (similar to where it is for the Blender Internal). It bakes for the active texture of each material of the object. The active texture is currently defined as the active Image Texture node present in the material nodetree. If you don't want the baking to override an existent material, make sure the active Image Texture node is not connected to the nodetree. The active texture is also the texture shown in the viewport in the rendered mode. Remember to save your images after the baking is complete. Note: Bake currently only works in the CPU Note: This is not supported by Cycles standalone because a lot of the work is done in Blender as part of the operator only, not the engine (Cycles). Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Bake Supported Passes: ----------------- Data Passes * Normal * UV * Diffuse/Glossy/Transmission/Subsurface/Emit Color Light Passes * AO * Combined * Shadow * Diffuse/Glossy/Transmission/Subsurface/Emit Direct/Indirect * Environment Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge 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
{
ShaderEvalType shader_type = get_shader_type(pass_type);
size_t object_index = OBJECT_NONE;
int tri_offset = 0;
Cycles; Make baking a feature-specific option This means render devices now might skip building baking kernels in cases when only actual render-related functionality is used. For now it's only implemented for OpenCL split kernel device and mainly needed to work around some compiler-specific bugs which crashes on building the kernel. Using OpenCL for baking might still crash the driver, but at least there is now higher probability of that GPU will be usable to render the scene. Real fix should actually be done in the driver side.
2015-07-18 15:34:32 +02:00
/* Set baking flag in advance, so kernel loading can check if we need
* any baking capabilities.
*/
scene->bake_manager->set_baking(true);
Fix T40262: cycles GPU bake crash due to kernels not loaded, randomly due to thread timing.
2014-05-19 19:17:57 +02:00
/* ensure kernels are loaded before we do any scene updates */
session->load_kernels();
if(session->progress.get_cancel())
return;
Cycles Bake Expand Cycles to use the new baking API in Blender. It works on the selected object, and the panel can be accessed in the Render panel (similar to where it is for the Blender Internal). It bakes for the active texture of each material of the object. The active texture is currently defined as the active Image Texture node present in the material nodetree. If you don't want the baking to override an existent material, make sure the active Image Texture node is not connected to the nodetree. The active texture is also the texture shown in the viewport in the rendered mode. Remember to save your images after the baking is complete. Note: Bake currently only works in the CPU Note: This is not supported by Cycles standalone because a lot of the work is done in Blender as part of the operator only, not the engine (Cycles). Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Bake Supported Passes: ----------------- Data Passes * Normal * UV * Diffuse/Glossy/Transmission/Subsurface/Emit Color Light Passes * AO * Combined * Shadow * Diffuse/Glossy/Transmission/Subsurface/Emit Direct/Indirect * Environment Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge 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
if(shader_type == SHADER_EVAL_UV) {
/* force UV to be available */
Pass::add(PASS_UV, scene->film->passes);
}
Fix T46550: Cycles combined baking black in some cases. Now pass_filter is modified to have exactly the flags for the light components that need to be baked, based on the shader type. This simplifies the logic.
2016-02-06 20:35:36 +01:00
int bake_pass_filter = bake_pass_filter_get(pass_filter);
bake_pass_filter = BakeManager::shader_type_to_pass_filter(shader_type, bake_pass_filter);
/* force use_light_pass to be true if we bake more than just colors */
Cycles: Minor cleanup, whitespace around keyword and preprocessor indent
2016-04-13 08:58:52 +02:00
if(bake_pass_filter & ~BAKE_FILTER_COLOR) {
Cycles Bake Expand Cycles to use the new baking API in Blender. It works on the selected object, and the panel can be accessed in the Render panel (similar to where it is for the Blender Internal). It bakes for the active texture of each material of the object. The active texture is currently defined as the active Image Texture node present in the material nodetree. If you don't want the baking to override an existent material, make sure the active Image Texture node is not connected to the nodetree. The active texture is also the texture shown in the viewport in the rendered mode. Remember to save your images after the baking is complete. Note: Bake currently only works in the CPU Note: This is not supported by Cycles standalone because a lot of the work is done in Blender as part of the operator only, not the engine (Cycles). Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Bake Supported Passes: ----------------- Data Passes * Normal * UV * Diffuse/Glossy/Transmission/Subsurface/Emit Color Light Passes * AO * Combined * Shadow * Diffuse/Glossy/Transmission/Subsurface/Emit Direct/Indirect * Environment Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge 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
Pass::add(PASS_LIGHT, scene->film->passes);
}
/* create device and update scene */
scene->film->tag_update(scene);
scene->integrator->tag_update(scene);
/* update scene */
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
BL::Object b_camera_override(b_engine.camera_override());
Multi-View: Cycles - Spherical Stereo support (VR Panoramas) This is a new option for panorama cameras to render stereo that can be used in virtual reality devices The option is available under the camera panel when Multi-View is enabled (Views option in the Render Layers panel) Known limitations: ------------------ * Parallel convergence is not supported (you need to set a convergence distance really high to simulate this effect). * Pivot was not supposed to affect the render but it does, this has to be looked at, but for now set it to CENTER * Derivatives in perspective camera need to be pre-computed or we shuld get rid of kcam->dx/dy (Sergey words, I don't fully grasp the implication shere) * This works in perspective mode and in panorama mode. However, for fully benefit from this effect in perspective mode you need to render a cube map. (there is an addon for this, developed separately, perhaps we could include it in master). * We have no support for "neck distance" at the moment. This is supposed to help with objects at short distances. * We have no support to rotate the "Up Axis" of the stereo plane. Meaning, we hardcode 0,0,1 as UP, and create the stereo pair related to that. (although we could take the camera local UP when rendering panoramas, this wouldn't work for perspective cameras. * We have no support for interocular distance attenuation based on the proximity of the poles (which helps to reduce the pole rotation effect/artifact). THIS NEEDS DOCS - both in 2.78 release log and the Blender manual. Meanwhile you can read about it here: http://code.blender.org/2015/03/1451 This patch specifically dates from March 2015, as you can see in the code.blender.org post. Many thanks to all the reviewers, testers and minor sponsors who helped me maintain spherical-stereo for 1 year. All that said, have fun with this. This feature was what got me started with Multi-View development (at the time what I was looking for was Fulldome stereo support, but the implementation is the same). In order to make this into Blender I had to make it aiming at a less-specic user-case Thus Multi-View started. (this was December 2012, during Siggraph Asia and a chat I had with Paul Bourke during the conference). I don't have the original patch anymore, but you can find a re-based version of it from March 2013, right before I start with the Multi-View project https://developer.blender.org/P332 Reviewers: sergey, dingto Subscribers: #cycles Differential Revision: https://developer.blender.org/D1223
2016-03-10 09:28:29 -03:00
sync->sync_camera(b_render, b_camera_override, width, height, "");
Cycles: Implement camera zoom motion blur Works totally similar to camera motion blur and majority of the changes are related on just passing extra arguments to sync() functions. Couple of things still to look into: - Motion pass will not include motion caused by the zoom. - Only perspective cameras are supported currently. - Motion is being interpolated on projected coordinates, which might give different results from constructing projection matrix from interpolated field of view. This could be good enough for us, but we need to consider improving this at some point. Reviewers: juicyfruit, dingto Reviewed By: dingto Differential Revision: https://developer.blender.org/D1383
2015-07-21 15:36:35 +02:00
sync->sync_data(b_render,
b_v3d,
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
b_camera_override,
Cycles: Implement camera zoom motion blur Works totally similar to camera motion blur and majority of the changes are related on just passing extra arguments to sync() functions. Couple of things still to look into: - Motion pass will not include motion caused by the zoom. - Only perspective cameras are supported currently. - Motion is being interpolated on projected coordinates, which might give different results from constructing projection matrix from interpolated field of view. This could be good enough for us, but we need to consider improving this at some point. Reviewers: juicyfruit, dingto Reviewed By: dingto Differential Revision: https://developer.blender.org/D1383
2015-07-21 15:36:35 +02:00
width, height,
&python_thread_state,
b_rlay_name.c_str());
Cycles Bake Expand Cycles to use the new baking API in Blender. It works on the selected object, and the panel can be accessed in the Render panel (similar to where it is for the Blender Internal). It bakes for the active texture of each material of the object. The active texture is currently defined as the active Image Texture node present in the material nodetree. If you don't want the baking to override an existent material, make sure the active Image Texture node is not connected to the nodetree. The active texture is also the texture shown in the viewport in the rendered mode. Remember to save your images after the baking is complete. Note: Bake currently only works in the CPU Note: This is not supported by Cycles standalone because a lot of the work is done in Blender as part of the operator only, not the engine (Cycles). Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Bake Supported Passes: ----------------- Data Passes * Normal * UV * Diffuse/Glossy/Transmission/Subsurface/Emit Color Light Passes * AO * Combined * Shadow * Diffuse/Glossy/Transmission/Subsurface/Emit Direct/Indirect * Environment Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge 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
/* get buffer parameters */
Cycles: Initialize "headless" flags on engine initialization This flag is global for all the sessions and never changes. so it doesn't really make sense to pass it around to all sessions and synchronization routines. Switched to a static member of BlenderSession now, but it's probably more logical to introduce some sort of BlenderGlobals. Doesn't currently worth a hassle for a single boolean flag tho.
2015-02-18 21:16:52 +05:00
SessionParams session_params = BlenderSync::get_session_params(b_engine, b_userpref, b_scene, background);
Cycles: Code cleanup, prepare for strict C++ flags
2015-03-27 15:47:55 +05:00
BufferParams buffer_params = BlenderSync::get_buffer_params(b_render, b_v3d, b_rv3d, scene->camera, width, height);
Cycles Bake Expand Cycles to use the new baking API in Blender. It works on the selected object, and the panel can be accessed in the Render panel (similar to where it is for the Blender Internal). It bakes for the active texture of each material of the object. The active texture is currently defined as the active Image Texture node present in the material nodetree. If you don't want the baking to override an existent material, make sure the active Image Texture node is not connected to the nodetree. The active texture is also the texture shown in the viewport in the rendered mode. Remember to save your images after the baking is complete. Note: Bake currently only works in the CPU Note: This is not supported by Cycles standalone because a lot of the work is done in Blender as part of the operator only, not the engine (Cycles). Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Bake Supported Passes: ----------------- Data Passes * Normal * UV * Diffuse/Glossy/Transmission/Subsurface/Emit Color Light Passes * AO * Combined * Shadow * Diffuse/Glossy/Transmission/Subsurface/Emit Direct/Indirect * Environment Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge 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
Final Fix T41222 Blender gives weird ouput when baking (4096*4096) resolution on GPU It now uses the tile size to split the job. For CPU this may add overhead, but for GPU this is highly needed. Reviewers: sergey Differential Revision: https://developer.blender.org/D690
2014-07-31 20:04:57 -03:00
scene->bake_manager->set_shader_limit((size_t)b_engine.tile_x(), (size_t)b_engine.tile_y());
Cycles Bake Expand Cycles to use the new baking API in Blender. It works on the selected object, and the panel can be accessed in the Render panel (similar to where it is for the Blender Internal). It bakes for the active texture of each material of the object. The active texture is currently defined as the active Image Texture node present in the material nodetree. If you don't want the baking to override an existent material, make sure the active Image Texture node is not connected to the nodetree. The active texture is also the texture shown in the viewport in the rendered mode. Remember to save your images after the baking is complete. Note: Bake currently only works in the CPU Note: This is not supported by Cycles standalone because a lot of the work is done in Blender as part of the operator only, not the engine (Cycles). Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Bake Supported Passes: ----------------- Data Passes * Normal * UV * Diffuse/Glossy/Transmission/Subsurface/Emit Color Light Passes * AO * Combined * Shadow * Diffuse/Glossy/Transmission/Subsurface/Emit Direct/Indirect * Environment Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge 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
/* set number of samples */
session->tile_manager.set_samples(session_params.samples);
session->reset(buffer_params, session_params.samples);
session->update_scene();
/* find object index. todo: is arbitrary - copied from mesh_displace.cpp */
for(size_t i = 0; i < scene->objects.size(); i++) {
if(strcmp(scene->objects[i]->name.c_str(), b_object.name().c_str()) == 0) {
object_index = i;
tri_offset = scene->objects[i]->mesh->tri_offset;
break;
}
}
Cycles: Replace object index hack with actual checks for SD_TRANSFORM_APPLIED Using ones complement for detecting if transform has been applied was confusing and led to several bugs. With this proper checks are made. Also added a few transforms where they were missing, mostly affecting baking and displacement when `P` is used in the shader (previously `P` was in the wrong space for these shaders) Also removed `TIME_INVALID` as this may have resulted in incorrect transforms in some cases. Reviewed By: brecht Differential Revision: https://developer.blender.org/D2192
2016-09-02 21:37:17 -04:00
int object = object_index;
Cycles Bake Expand Cycles to use the new baking API in Blender. It works on the selected object, and the panel can be accessed in the Render panel (similar to where it is for the Blender Internal). It bakes for the active texture of each material of the object. The active texture is currently defined as the active Image Texture node present in the material nodetree. If you don't want the baking to override an existent material, make sure the active Image Texture node is not connected to the nodetree. The active texture is also the texture shown in the viewport in the rendered mode. Remember to save your images after the baking is complete. Note: Bake currently only works in the CPU Note: This is not supported by Cycles standalone because a lot of the work is done in Blender as part of the operator only, not the engine (Cycles). Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Bake Supported Passes: ----------------- Data Passes * Normal * UV * Diffuse/Glossy/Transmission/Subsurface/Emit Color Light Passes * AO * Combined * Shadow * Diffuse/Glossy/Transmission/Subsurface/Emit Direct/Indirect * Environment Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge 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
BakeData *bake_data = scene->bake_manager->init(object, tri_offset, num_pixels);
Bake-API: reduce memory footprint when baking more than one object (Fix T41092) Combine all the highpoly pixel arrays into a single array with a lookup object_id for each of the highpoly objects. Note: This changes the Bake API, external engines should refer to the bake_api.c for the latest API. Many thanks for Sergey Sharybin for the complete review, changes suggestion and feedback. (you rock!) Reviewers: sergey Subscribers: pildanovak, marcclintdion, monio, metalliandy, brecht Maniphest Tasks: T41092 Differential Revision: https://developer.blender.org/D772
2015-04-17 12:25:37 -03:00
populate_bake_data(bake_data, object_id, pixel_array, num_pixels);
Cycles Bake Expand Cycles to use the new baking API in Blender. It works on the selected object, and the panel can be accessed in the Render panel (similar to where it is for the Blender Internal). It bakes for the active texture of each material of the object. The active texture is currently defined as the active Image Texture node present in the material nodetree. If you don't want the baking to override an existent material, make sure the active Image Texture node is not connected to the nodetree. The active texture is also the texture shown in the viewport in the rendered mode. Remember to save your images after the baking is complete. Note: Bake currently only works in the CPU Note: This is not supported by Cycles standalone because a lot of the work is done in Blender as part of the operator only, not the engine (Cycles). Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Bake Supported Passes: ----------------- Data Passes * Normal * UV * Diffuse/Glossy/Transmission/Subsurface/Emit Color Light Passes * AO * Combined * Shadow * Diffuse/Glossy/Transmission/Subsurface/Emit Direct/Indirect * Environment Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge 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
/* set number of samples */
session->tile_manager.set_samples(session_params.samples);
session->reset(buffer_params, session_params.samples);
session->update_scene();
Cycles Bake: show progress bar during bake Baking progress preview is not possible, in parts due to the way the API was designed. But at least you get to see the progress bar while baking. Reviewers: sergey Differential Revision: https://developer.blender.org/D656
2014-07-22 18:41:01 -03:00
session->progress.set_update_callback(function_bind(&BlenderSession::update_bake_progress, this));
Cycles-Bake: Custom Baking passes The combined pass is built with the contributions the user finds fit. It is useful for lightmap baking, as well as non-view dependent effects baking. The manual will be updated once we get closer to the 2.77 release. Meanwhile the new page can be found here: http://dalaifelinto.com/blender-manual/render/cycles/baking.html Reviewers: sergey, brecht Differential Revision: https://developer.blender.org/D1674
2016-01-15 13:00:56 -02:00
scene->bake_manager->bake(scene->device, &scene->dscene, scene, session->progress, shader_type, bake_pass_filter, bake_data, result);
Cycles Bake Expand Cycles to use the new baking API in Blender. It works on the selected object, and the panel can be accessed in the Render panel (similar to where it is for the Blender Internal). It bakes for the active texture of each material of the object. The active texture is currently defined as the active Image Texture node present in the material nodetree. If you don't want the baking to override an existent material, make sure the active Image Texture node is not connected to the nodetree. The active texture is also the texture shown in the viewport in the rendered mode. Remember to save your images after the baking is complete. Note: Bake currently only works in the CPU Note: This is not supported by Cycles standalone because a lot of the work is done in Blender as part of the operator only, not the engine (Cycles). Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Bake Supported Passes: ----------------- Data Passes * Normal * UV * Diffuse/Glossy/Transmission/Subsurface/Emit Color Light Passes * AO * Combined * Shadow * Diffuse/Glossy/Transmission/Subsurface/Emit Direct/Indirect * Environment Review: D421 Reviewed by: Campbell Barton, Brecht van Lommel, Sergey Sharybin, Thomas Dinge 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
/* free all memory used (host and device), so we wouldn't leave render
* engine with extra memory allocated
*/
session->device_free();
delete sync;
sync = NULL;
}
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
void BlenderSession::do_write_update_render_result(BL::RenderResult& b_rr,
BL::RenderLayer& b_rlay,
RenderTile& rtile,
bool do_update_only)
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +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
RenderBuffers *buffers = rtile.buffers;
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
/* copy data from device */
if(!buffers->copy_from_device())
return;
BufferParams& params = buffers->params;
Cycles: * Add alpha pass output, to use set Transparent option in Film panel. * Add Holdout closure (OSL terminology), this is like the Sky option in the internal renderer, objects with this closure show the background / zero alpha. * Add option to use Gaussian instead of Box pixel filter in the UI. * Remove camera response curves for now, they don't really belong here in the pipeline, should be moved to compositor. * Output full float values for rendering now, previously was only byte precision. * Add a patch from Thomas to get a preview passes option, but still disabled because it isn't quite working right yet. * CUDA: don't compile shader graph evaluation inline. * Convert tabs to spaces in python files.
2011-08-28 13:55:59 +00:00
float exposure = scene->film->exposure;
Cycles: fix color difference between render / 3d view with color management disabled.
2011-05-09 09:03:08 +00:00
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
vector<float> pixels(params.width*params.height*4);
Cycles: fix color difference between render / 3d view with color management disabled.
2011-05-09 09:03:08 +00:00
Cycles: Resumable render implementation for Cycles This feature is also known by the name Samples Offset, which allows artists to render animation with given amount of samples N, but then render more samples, starting from N and ending with M (where M > N) and merge renders together as if they rendered exactly M samples. Surely such effect could be achieved by changing Seed variable, but that has possible issues with correlation artifacts and requiring to manually deal with per render layer samples and such. While we can't support all possible renderfarm-related features in Cycles it's nice to support really commonly used stuff. Here's a command how to run Blender with the new feature enabled: blender -- --cycles-resumable-num-chunks 24 --cycles-resumable-current-chunk 2 This command will divide samples range in 24 parts and render range #2 (chunk number is 1-based). This feature might be changed a bit after we'll do some tests here in the studio with it.
2016-03-30 15:55:12 +02:00
/* Adjust absolute sample number to the range. */
int sample = rtile.sample;
const int range_start_sample = session->tile_manager.range_start_sample;
if(range_start_sample != -1) {
sample -= range_start_sample;
}
Cycles: Code cleanup, spaces around keywords This inconsistency drove me totally crazy, it's really confusing when it's inconsistent especially when you work on both Cycles and Blender sides. Shouldn;t cause merge PITA, it's whitespace changes only, Git should be able to merge it nicely.
2015-03-28 00:15:15 +05:00
if(!do_update_only) {
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
/* copy each pass */
BL::RenderLayer::passes_iterator b_iter;
for(b_rlay.passes.begin(b_iter); b_iter != b_rlay.passes.end(); ++b_iter) {
BL::RenderPass b_pass(*b_iter);
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +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
/* find matching pass type */
PassType pass_type = get_pass_type(b_pass);
int components = b_pass.channels();
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +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
/* copy pixels */
Cycles: Resumable render implementation for Cycles This feature is also known by the name Samples Offset, which allows artists to render animation with given amount of samples N, but then render more samples, starting from N and ending with M (where M > N) and merge renders together as if they rendered exactly M samples. Surely such effect could be achieved by changing Seed variable, but that has possible issues with correlation artifacts and requiring to manually deal with per render layer samples and such. While we can't support all possible renderfarm-related features in Cycles it's nice to support really commonly used stuff. Here's a command how to run Blender with the new feature enabled: blender -- --cycles-resumable-num-chunks 24 --cycles-resumable-current-chunk 2 This command will divide samples range in 24 parts and render range #2 (chunk number is 1-based). This feature might be changed a bit after we'll do some tests here in the studio with it.
2016-03-30 15:55:12 +02:00
if(!buffers->get_pass_rect(pass_type, exposure, sample, components, &pixels[0]))
Fix #34184: cycles speed vector pass should be zero when using motion blur, instead it had value 10000.
2013-02-10 18:02:59 +00:00
memset(&pixels[0], 0, pixels.size()*sizeof(float));
b_pass.rect(&pixels[0]);
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
}
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
}
Multi-View and Stereo 3D Official Documentation: http://www.blender.org/manual/render/workflows/multiview.html Implemented Features ==================== Builtin Stereo Camera * Convergence Mode * Interocular Distance * Convergence Distance * Pivot Mode Viewport * Cameras * Plane * Volume Compositor * View Switch Node * Image Node Multi-View OpenEXR support Sequencer * Image/Movie Strips 'Use Multiview' UV/Image Editor * Option to see Multi-View images in Stereo-3D or its individual images * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images I/O * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images Scene Render Views * Ability to have an arbitrary number of views in the scene Missing Bits ============ First rule of Multi-View bug report: If something is not working as it should *when Views is off* this is a severe bug, do mention this in the report. Second rule is, if something works *when Views is off* but doesn't (or crashes) when *Views is on*, this is a important bug. Do mention this in the report. Everything else is likely small todos, and may wait until we are sure none of the above is happening. Apart from that there are those known issues: * Compositor Image Node poorly working for Multi-View OpenEXR (this was working prefectly before the 'Use Multi-View' functionality) * Selecting camera from Multi-View when looking from camera is problematic * Animation Playback (ctrl+F11) doesn't support stereo formats * Wrong filepath when trying to play back animated scene * Viewport Rendering doesn't support Multi-View * Overscan Rendering * Fullscreen display modes need to warn the user * Object copy should be aware of views suffix Acknowledgments =============== * Francesco Siddi for the help with the original feature specs and design * Brecht Van Lommel for the original review of the code and design early on * Blender Foundation for the Development Fund to support the project wrap up Final patch reviewers: * Antony Riakiotakis (psy-fi) * Campbell Barton (ideasman42) * Julian Eisel (Severin) * Sergey Sharybin (nazgul) * Thomas Dinged (dingto) Code contributors of the original branch in github: * Alexey Akishin * Gabriel Caraballo
2015-04-06 10:40:12 -03:00
else {
/* copy combined pass */
Cycles: Code cleanup, indentation. Was wrong in the multiview commit
2015-04-08 15:35:01 +05:00
BL::RenderPass b_combined_pass(b_rlay.passes.find_by_type(BL::RenderPass::type_COMBINED, b_rview_name.c_str()));
Cycles: Resumable render implementation for Cycles This feature is also known by the name Samples Offset, which allows artists to render animation with given amount of samples N, but then render more samples, starting from N and ending with M (where M > N) and merge renders together as if they rendered exactly M samples. Surely such effect could be achieved by changing Seed variable, but that has possible issues with correlation artifacts and requiring to manually deal with per render layer samples and such. While we can't support all possible renderfarm-related features in Cycles it's nice to support really commonly used stuff. Here's a command how to run Blender with the new feature enabled: blender -- --cycles-resumable-num-chunks 24 --cycles-resumable-current-chunk 2 This command will divide samples range in 24 parts and render range #2 (chunk number is 1-based). This feature might be changed a bit after we'll do some tests here in the studio with it.
2016-03-30 15:55:12 +02:00
if(buffers->get_pass_rect(PASS_COMBINED, exposure, sample, 4, &pixels[0]))
Multi-View and Stereo 3D Official Documentation: http://www.blender.org/manual/render/workflows/multiview.html Implemented Features ==================== Builtin Stereo Camera * Convergence Mode * Interocular Distance * Convergence Distance * Pivot Mode Viewport * Cameras * Plane * Volume Compositor * View Switch Node * Image Node Multi-View OpenEXR support Sequencer * Image/Movie Strips 'Use Multiview' UV/Image Editor * Option to see Multi-View images in Stereo-3D or its individual images * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images I/O * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images Scene Render Views * Ability to have an arbitrary number of views in the scene Missing Bits ============ First rule of Multi-View bug report: If something is not working as it should *when Views is off* this is a severe bug, do mention this in the report. Second rule is, if something works *when Views is off* but doesn't (or crashes) when *Views is on*, this is a important bug. Do mention this in the report. Everything else is likely small todos, and may wait until we are sure none of the above is happening. Apart from that there are those known issues: * Compositor Image Node poorly working for Multi-View OpenEXR (this was working prefectly before the 'Use Multi-View' functionality) * Selecting camera from Multi-View when looking from camera is problematic * Animation Playback (ctrl+F11) doesn't support stereo formats * Wrong filepath when trying to play back animated scene * Viewport Rendering doesn't support Multi-View * Overscan Rendering * Fullscreen display modes need to warn the user * Object copy should be aware of views suffix Acknowledgments =============== * Francesco Siddi for the help with the original feature specs and design * Brecht Van Lommel for the original review of the code and design early on * Blender Foundation for the Development Fund to support the project wrap up Final patch reviewers: * Antony Riakiotakis (psy-fi) * Campbell Barton (ideasman42) * Julian Eisel (Severin) * Sergey Sharybin (nazgul) * Thomas Dinged (dingto) Code contributors of the original branch in github: * Alexey Akishin * Gabriel Caraballo
2015-04-06 10:40:12 -03:00
b_combined_pass.rect(&pixels[0]);
}
Cycles: Render Passes Currently supported passes: * Combined, Z, Normal, Object Index, Material Index, Emission, Environment, Diffuse/Glossy/Transmission x Direct/Indirect/Color Not supported yet: * UV, Vector, Mist Only enabled for CPU devices at the moment, will do GPU tweaks tommorrow, also for environment importance sampling. Documentation: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes
2012-01-25 17:23:52 +00:00
/* tag result as updated */
RNA C++ API improvements Added support of such features, as: - Ability to call RNA functions using C++ classes For example RenderEngine.tag_update - Property setters (for scalars and arrays) Used Qt/jQuery-like getters/setters style, meaning Class.prop() is a getter, Class.prop(value) is a setter. Still to come: Collection functions are not currently registering inside a property Meaning BlendData.meshes wouldn't be a subclass of BlendDataMeshes result you'll need to explicitly create BlendDataMeshes for now instead of doing BlendData.meshes.remove()
2012-10-22 17:34:16 +00:00
b_engine.update_result(b_rr);
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
}
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
void BlenderSession::write_render_result(BL::RenderResult& b_rr,
BL::RenderLayer& b_rlay,
RenderTile& rtile)
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
{
do_write_update_render_result(b_rr, b_rlay, rtile, false);
}
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
void BlenderSession::update_render_result(BL::RenderResult& b_rr,
BL::RenderLayer& b_rlay,
RenderTile& rtile)
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
{
do_write_update_render_result(b_rr, b_rlay, rtile, true);
}
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
void BlenderSession::synchronize()
{
Fix related to #35681: avoid some unnecessary cycles updated when using exclude render layers.
2013-06-09 11:57:51 +00:00
/* only used for viewport render */
if(!b_v3d)
return;
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
/* on session/scene parameter changes, we recreate session entirely */
Cycles: Initialize "headless" flags on engine initialization This flag is global for all the sessions and never changes. so it doesn't really make sense to pass it around to all sessions and synchronization routines. Switched to a static member of BlenderSession now, but it's probably more logical to introduce some sort of BlenderGlobals. Doesn't currently worth a hassle for a single boolean flag tho.
2015-02-18 21:16:52 +05:00
SessionParams session_params = BlenderSync::get_session_params(b_engine, b_userpref, b_scene, background);
Cycles: Enable QBVH optimization structure for SSE2 CPUs This commit enables QBVH optimization structure automatically if rendering with CPU and SSE2 support is detected. This brings render time of agent shot back to the speed it used to be before the watertight intersections commit, single koro and sponza scenes are about 7% faster here.
2014-12-25 00:53:26 +05:00
const bool is_cpu = session_params.device.type == DEVICE_CPU;
SceneParams scene_params = BlenderSync::get_scene_params(b_scene, background, is_cpu);
Fix T41197: Blender freezes to infinite loop when switching to PAUSED Cycles rendered viewport
2014-08-01 16:39:05 +06:00
bool session_pause = BlenderSync::get_session_pause(b_scene, background);
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
if(session->params.modified(session_params) ||
style cleanup: assignment & indentation.
2012-06-09 18:56:12 +00:00
scene->params.modified(scene_params))
{
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
free_session();
create_session();
Cycles: support for multiple render layers. It currently renders each layer entirely before moving on to the next.
2011-12-21 20:51:55 +00:00
session->start();
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
return;
}
Cycles: tweaks to properties and nodes * Passes renamed to samples * Camera lens radius renamed to aperature size/blades/rotation * Glass and fresnel nodes input is now index of refraction * Glossy and velvet fresnel socket removed * Mix/add closure node renamed to mix/add shader node * Blend weight node added for shader mixing weights There is some version patching code for reading existing files, but it's not perfect, so shaders may work a bit different.
2011-09-16 13:14:02 +00:00
/* increase samples, but never decrease */
session->set_samples(session_params.samples);
Fix T41197: Blender freezes to infinite loop when switching to PAUSED Cycles rendered viewport
2014-08-01 16:39:05 +06:00
session->set_pause(session_pause);
Cycles: * Add alpha pass output, to use set Transparent option in Film panel. * Add Holdout closure (OSL terminology), this is like the Sky option in the internal renderer, objects with this closure show the background / zero alpha. * Add option to use Gaussian instead of Box pixel filter in the UI. * Remove camera response curves for now, they don't really belong here in the pipeline, should be moved to compositor. * Output full float values for rendering now, previously was only byte precision. * Add a patch from Thomas to get a preview passes option, but still disabled because it isn't quite working right yet. * CUDA: don't compile shader graph evaluation inline. * Convert tabs to spaces in python files.
2011-08-28 13:55:59 +00:00
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
/* copy recalc flags, outside of mutex so we can decide to do the real
style cleanup: block comments
2012-06-09 17:22:52 +00:00
* synchronization at a later time to not block on running updates */
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
sync->sync_recalc();
Fix T41197: Blender freezes to infinite loop when switching to PAUSED Cycles rendered viewport
2014-08-01 16:39:05 +06:00
/* don't do synchronization if on pause */
if(session_pause) {
tag_update();
return;
}
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
/* try to acquire mutex. if we don't want to or can't, come back later */
if(!session->ready_to_reset() || !session->scene->mutex.try_lock()) {
tag_update();
return;
}
/* data and camera synchronize */
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
BL::Object b_camera_override(b_engine.camera_override());
Cycles: Implement camera zoom motion blur Works totally similar to camera motion blur and majority of the changes are related on just passing extra arguments to sync() functions. Couple of things still to look into: - Motion pass will not include motion caused by the zoom. - Only perspective cameras are supported currently. - Motion is being interpolated on projected coordinates, which might give different results from constructing projection matrix from interpolated field of view. This could be good enough for us, but we need to consider improving this at some point. Reviewers: juicyfruit, dingto Reviewed By: dingto Differential Revision: https://developer.blender.org/D1383
2015-07-21 15:36:35 +02:00
sync->sync_data(b_render,
b_v3d,
Cycles: Pass Blender's C++ RNA structures by reference This way we avoid passing structures which could be up to few hundred bytes by value to the utility functions. Ideally we'll also have to add `const` qualifier in majority of the calls, but C++ RNA does not allow us to do that because it does not know if some function modifies contents or not.
2016-01-30 14:18:29 +01:00
b_camera_override,
Cycles: Implement camera zoom motion blur Works totally similar to camera motion blur and majority of the changes are related on just passing extra arguments to sync() functions. Couple of things still to look into: - Motion pass will not include motion caused by the zoom. - Only perspective cameras are supported currently. - Motion is being interpolated on projected coordinates, which might give different results from constructing projection matrix from interpolated field of view. This could be good enough for us, but we need to consider improving this at some point. Reviewers: juicyfruit, dingto Reviewed By: dingto Differential Revision: https://developer.blender.org/D1383
2015-07-21 15:36:35 +02:00
width, height,
&python_thread_state,
b_rlay_name.c_str());
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
if(b_rv3d)
sync->sync_view(b_v3d, b_rv3d, width, height);
else
Multi-View: Cycles - Spherical Stereo support (VR Panoramas) This is a new option for panorama cameras to render stereo that can be used in virtual reality devices The option is available under the camera panel when Multi-View is enabled (Views option in the Render Layers panel) Known limitations: ------------------ * Parallel convergence is not supported (you need to set a convergence distance really high to simulate this effect). * Pivot was not supposed to affect the render but it does, this has to be looked at, but for now set it to CENTER * Derivatives in perspective camera need to be pre-computed or we shuld get rid of kcam->dx/dy (Sergey words, I don't fully grasp the implication shere) * This works in perspective mode and in panorama mode. However, for fully benefit from this effect in perspective mode you need to render a cube map. (there is an addon for this, developed separately, perhaps we could include it in master). * We have no support for "neck distance" at the moment. This is supposed to help with objects at short distances. * We have no support to rotate the "Up Axis" of the stereo plane. Meaning, we hardcode 0,0,1 as UP, and create the stereo pair related to that. (although we could take the camera local UP when rendering panoramas, this wouldn't work for perspective cameras. * We have no support for interocular distance attenuation based on the proximity of the poles (which helps to reduce the pole rotation effect/artifact). THIS NEEDS DOCS - both in 2.78 release log and the Blender manual. Meanwhile you can read about it here: http://code.blender.org/2015/03/1451 This patch specifically dates from March 2015, as you can see in the code.blender.org post. Many thanks to all the reviewers, testers and minor sponsors who helped me maintain spherical-stereo for 1 year. All that said, have fun with this. This feature was what got me started with Multi-View development (at the time what I was looking for was Fulldome stereo support, but the implementation is the same). In order to make this into Blender I had to make it aiming at a less-specic user-case Thus Multi-View started. (this was December 2012, during Siggraph Asia and a chat I had with Paul Bourke during the conference). I don't have the original patch anymore, but you can find a re-based version of it from March 2013, right before I start with the Multi-View project https://developer.blender.org/P332 Reviewers: sergey, dingto Subscribers: #cycles Differential Revision: https://developer.blender.org/D1223
2016-03-10 09:28:29 -03:00
sync->sync_camera(b_render, b_camera_override, width, height, "");
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
Cycles: pause button to interrupt viewport renders, in the 3d view header.
2011-08-29 16:54:13 +00:00
/* unlock */
session->scene->mutex.unlock();
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
/* reset if needed */
Cycles: border rendering support, includes some refactoring in how pixels are accessed on devices.
2011-12-20 12:25:37 +00:00
if(scene->need_reset()) {
Cycles: Code cleanup, prepare for strict C++ flags
2015-03-27 15:47:55 +05:00
BufferParams buffer_params = BlenderSync::get_buffer_params(b_render, b_v3d, b_rv3d, scene->camera, width, height);
Cycles: border rendering support, includes some refactoring in how pixels are accessed on devices.
2011-12-20 12:25:37 +00:00
session->reset(buffer_params, session_params.samples);
Fix #34714: cycles viewport render would restart when minimizing and unminimizing a maximized Blender window in Ubuntu Unity. The window size would slightly change as part of the unminimize effect. Now cycles waits 0.2 seconds before restarting rendering after a viewport resize, also a bit less flickery when changing the 3d view size in Blender itself.
2013-04-24 20:12:12 +00:00
/* reset time */
start_resize_time = 0.0;
Cycles: border rendering support, includes some refactoring in how pixels are accessed on devices.
2011-12-20 12:25:37 +00:00
}
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
}
bool BlenderSession::draw(int w, int h)
{
Fix #35121: cycles 3D viewport render pause button not working during render.
2013-04-28 12:31:24 +00:00
/* pause in redraw in case update is not being called due to final render */
session->set_pause(BlenderSync::get_session_pause(b_scene, background));
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
/* before drawing, we verify camera and viewport size changes, because
style cleanup: block comments
2012-06-09 17:22:52 +00:00
* we do not get update callbacks for those, we must detect them here */
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
if(session->ready_to_reset()) {
bool reset = false;
Fix #34714: cycles viewport render would restart when minimizing and unminimizing a maximized Blender window in Ubuntu Unity. The window size would slightly change as part of the unminimize effect. Now cycles waits 0.2 seconds before restarting rendering after a viewport resize, also a bit less flickery when changing the 3d view size in Blender itself.
2013-04-24 20:12:12 +00:00
/* if dimensions changed, reset */
if(width != w || height != h) {
if(start_resize_time == 0.0) {
/* don't react immediately to resizes to avoid flickery resizing
* of the viewport, and some window managers changing the window
* size temporarily on unminimize */
start_resize_time = time_dt();
tag_redraw();
}
code cleanup: double promotion warnings.
2013-05-16 17:20:56 +00:00
else if(time_dt() - start_resize_time < 0.2) {
Fix #34714: cycles viewport render would restart when minimizing and unminimizing a maximized Blender window in Ubuntu Unity. The window size would slightly change as part of the unminimize effect. Now cycles waits 0.2 seconds before restarting rendering after a viewport resize, also a bit less flickery when changing the 3d view size in Blender itself.
2013-04-24 20:12:12 +00:00
tag_redraw();
}
else {
width = w;
height = h;
reset = true;
}
}
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
/* try to acquire mutex. if we can't, come back later */
if(!session->scene->mutex.try_lock()) {
tag_update();
}
else {
/* update camera from 3d view */
Fix #34714: cycles viewport render would restart when minimizing and unminimizing a maximized Blender window in Ubuntu Unity. The window size would slightly change as part of the unminimize effect. Now cycles waits 0.2 seconds before restarting rendering after a viewport resize, also a bit less flickery when changing the 3d view size in Blender itself.
2013-04-24 20:12:12 +00:00
sync->sync_view(b_v3d, b_rv3d, width, height);
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
Fix #34041: rendered view + border Issue was caused by rare cases when camera move happens just after last sample was finished, this would lead to missing delay reset because render cycle will go to pause_cond.wait(). No reset will happen at this point because of some kind of optimization which checks whether camera is tagged for update and wouldn't do reset in this case. Talked to Brecht and seems this optimization is not actually needed and removing it will solve issue with frozen preview.
2013-02-05 14:16:19 +00:00
if(scene->camera->need_update)
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
reset = true;
session->scene->mutex.unlock();
}
/* reset if requested */
Cycles: * Add alpha pass output, to use set Transparent option in Film panel. * Add Holdout closure (OSL terminology), this is like the Sky option in the internal renderer, objects with this closure show the background / zero alpha. * Add option to use Gaussian instead of Box pixel filter in the UI. * Remove camera response curves for now, they don't really belong here in the pipeline, should be moved to compositor. * Output full float values for rendering now, previously was only byte precision. * Add a patch from Thomas to get a preview passes option, but still disabled because it isn't quite working right yet. * CUDA: don't compile shader graph evaluation inline. * Convert tabs to spaces in python files.
2011-08-28 13:55:59 +00:00
if(reset) {
Cycles: Initialize "headless" flags on engine initialization This flag is global for all the sessions and never changes. so it doesn't really make sense to pass it around to all sessions and synchronization routines. Switched to a static member of BlenderSession now, but it's probably more logical to introduce some sort of BlenderGlobals. Doesn't currently worth a hassle for a single boolean flag tho.
2015-02-18 21:16:52 +05:00
SessionParams session_params = BlenderSync::get_session_params(b_engine, b_userpref, b_scene, background);
Cycles: Code cleanup, prepare for strict C++ flags
2015-03-27 15:47:55 +05:00
BufferParams buffer_params = BlenderSync::get_buffer_params(b_render, b_v3d, b_rv3d, scene->camera, width, height);
Fix T41197: Blender freezes to infinite loop when switching to PAUSED Cycles rendered viewport
2014-08-01 16:39:05 +06:00
bool session_pause = BlenderSync::get_session_pause(b_scene, background);
Cycles: border rendering support, includes some refactoring in how pixels are accessed on devices.
2011-12-20 12:25:37 +00:00
Fix T41197: Blender freezes to infinite loop when switching to PAUSED Cycles rendered viewport
2014-08-01 16:39:05 +06:00
if(session_pause == false) {
session->reset(buffer_params, session_params.samples);
start_resize_time = 0.0;
}
Cycles: * Add alpha pass output, to use set Transparent option in Film panel. * Add Holdout closure (OSL terminology), this is like the Sky option in the internal renderer, objects with this closure show the background / zero alpha. * Add option to use Gaussian instead of Box pixel filter in the UI. * Remove camera response curves for now, they don't really belong here in the pipeline, should be moved to compositor. * Output full float values for rendering now, previously was only byte precision. * Add a patch from Thomas to get a preview passes option, but still disabled because it isn't quite working right yet. * CUDA: don't compile shader graph evaluation inline. * Convert tabs to spaces in python files.
2011-08-28 13:55:59 +00:00
}
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
}
Fix #34205: Zooming in rendered mode during update out of sync with intended zoom Yes, again. There's some t within which reset is not allowed. This is so no reset happens too often for performance issues. If camera changes too often, some reset could be missed because of this timeout. For now tag engine for update, which will update viewport from blender side. Proper solution could be to detect such a changes from blender side and tag cycles for refresh instead of trying to detect changes form cycles, but that's for later.
2013-02-15 09:15:14 +00:00
else {
tag_update();
}
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
Cycles: fix crash in 3d view status text display.
2011-08-23 12:20:11 +00:00
/* update status and progress for 3d view draw */
update_status_progress();
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
Cycles: fix crash in 3d view status text display.
2011-08-23 12:20:11 +00:00
/* draw */
Cycles: Code cleanup, prepare for strict C++ flags
2015-03-27 15:47:55 +05:00
BufferParams buffer_params = BlenderSync::get_buffer_params(b_render, b_v3d, b_rv3d, scene->camera, width, height);
Fix T39420: Cycles viewport/preview flickers, when moving mouse across editors Issue was caused by the wrong usage of OCIO GLSL binding API. To make it work properly on pre-GLSL-1.3 drivers shader is to be enabled after the texture is binded to the opengl context. Otherwise it wouldn't know the proper texture size. This is actually a regression in 2.70 and to be ported to 'a'.
2014-03-26 14:57:30 +06:00
DeviceDrawParams draw_params;
Cycles: border rendering support, includes some refactoring in how pixels are accessed on devices.
2011-12-20 12:25:37 +00:00
Fix T39420: Cycles viewport/preview flickers, when moving mouse across editors Issue was caused by the wrong usage of OCIO GLSL binding API. To make it work properly on pre-GLSL-1.3 drivers shader is to be enabled after the texture is binded to the opengl context. Otherwise it wouldn't know the proper texture size. This is actually a regression in 2.70 and to be ported to 'a'.
2014-03-26 14:57:30 +06:00
if(session->params.display_buffer_linear) {
draw_params.bind_display_space_shader_cb = function_bind(&BL::RenderEngine::bind_display_space_shader, &b_engine, b_scene);
draw_params.unbind_display_space_shader_cb = function_bind(&BL::RenderEngine::unbind_display_space_shader, &b_engine);
}
Cycles: viewport render now takes scene color management settings into account, except for curves, that's still missing from the OpenColorIO GLSL shader. The pixels are stored in a half float texture, converterd from full float with native GPU instructions and SIMD on the CPU, so it should be pretty quick. Using a GLSL shader is useful for GPU render because it avoids a copy through CPU memory.
2013-08-30 23:49:38 +00:00
Fix T39420: Cycles viewport/preview flickers, when moving mouse across editors Issue was caused by the wrong usage of OCIO GLSL binding API. To make it work properly on pre-GLSL-1.3 drivers shader is to be enabled after the texture is binded to the opengl context. Otherwise it wouldn't know the proper texture size. This is actually a regression in 2.70 and to be ported to 'a'.
2014-03-26 14:57:30 +06:00
return !session->draw(buffer_params, draw_params);
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
}
void BlenderSession::get_status(string& status, string& substatus)
{
session->progress.get_status(status, substatus);
}
Cycles: Ignore preprocessing time in ETA calculation This patch makes Cycles ignore the time spent in BVH construction etc. when estimating the remaining time. Considering that the remaining time is calculated based on the average time per tile so far, as far as I understand it makes no sense to include the preprocessing time. Reviewers: sergey, #cycles Reviewed By: sergey, #cycles Subscribers: sergey Projects: #cycles Differential Revision: https://developer.blender.org/D895
2015-01-14 23:06:10 +05:00
void BlenderSession::get_progress(float& progress, double& total_time, double& render_time)
Cycles: * Update progress bar during render (patch by Thomas) * Show status/pass/time during render in 3d view
2011-08-22 13:17:43 +00:00
{
Cycles: Refactor Progress system to provide better estimates The Progress system in Cycles had two limitations so far: - It just counted tiles, but ignored their size. For example, when rendering a 600x500 image with 512x512 tiles, the right 88x500 tile would count for 50% of the progress, although it only covers 15% of the image. - Scene update time was incorrectly counted as rendering time - therefore, the remaining time started very long and gradually decreased. This patch fixes both problems: First of all, the Progress now has a function to ignore time spans, and that is used to ignore scene update time. The larger change is the tile size: Instead of counting samples per tile, so that the final value is num_samples*num_tiles, the code now counts every sample for every pixel, so that the final value is num_samples*num_pixels. Along with that, some unused variables were removed from the Progress and Session classes. Reviewers: brecht, sergey, #cycles Subscribers: brecht, candreacchio, sergey Differential Revision: https://developer.blender.org/D2214
2016-11-26 04:22:34 +01:00
session->progress.get_time(total_time, render_time);
progress = session->progress.get_progress();
Cycles: * Update progress bar during render (patch by Thomas) * Show status/pass/time during render in 3d view
2011-08-22 13:17:43 +00:00
}
Cycles Bake: show progress bar during bake Baking progress preview is not possible, in parts due to the way the API was designed. But at least you get to see the progress bar while baking. Reviewers: sergey Differential Revision: https://developer.blender.org/D656
2014-07-22 18:41:01 -03:00
void BlenderSession::update_bake_progress()
{
Cycles: Refactor Progress system to provide better estimates The Progress system in Cycles had two limitations so far: - It just counted tiles, but ignored their size. For example, when rendering a 600x500 image with 512x512 tiles, the right 88x500 tile would count for 50% of the progress, although it only covers 15% of the image. - Scene update time was incorrectly counted as rendering time - therefore, the remaining time started very long and gradually decreased. This patch fixes both problems: First of all, the Progress now has a function to ignore time spans, and that is used to ignore scene update time. The larger change is the tile size: Instead of counting samples per tile, so that the final value is num_samples*num_tiles, the code now counts every sample for every pixel, so that the final value is num_samples*num_pixels. Along with that, some unused variables were removed from the Progress and Session classes. Reviewers: brecht, sergey, #cycles Subscribers: brecht, candreacchio, sergey Differential Revision: https://developer.blender.org/D2214
2016-11-26 04:22:34 +01:00
float progress = session->progress.get_progress();
Cycles Bake: show progress bar during bake Baking progress preview is not possible, in parts due to the way the API was designed. But at least you get to see the progress bar while baking. Reviewers: sergey Differential Revision: https://developer.blender.org/D656
2014-07-22 18:41:01 -03:00
if(progress != last_progress) {
b_engine.update_progress(progress);
last_progress = progress;
}
}
Cycles: fix crash in 3d view status text display.
2011-08-23 12:20:11 +00:00
void BlenderSession::update_status_progress()
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
{
Fix #30086: cycles background render printing same status text twice.
2012-02-07 17:22:47 +00:00
string timestatus, status, substatus;
Cycles: show remaining render time in render info text It's a simple estimate, not very precise but that isn't really possible always. For progressive render it will become more accurate the longer you render. Reviewed By: brecht Differential Revision: http://developer.blender.org/D67
2013-12-07 02:22:35 +01:00
string scene = "";
Cycles: * Update progress bar during render (patch by Thomas) * Show status/pass/time during render in 3d view
2011-08-22 13:17:43 +00:00
float progress;
Cycles: Ignore preprocessing time in ETA calculation This patch makes Cycles ignore the time spent in BVH construction etc. when estimating the remaining time. Considering that the remaining time is calculated based on the average time per tile so far, as far as I understand it makes no sense to include the preprocessing time. Reviewers: sergey, #cycles Reviewed By: sergey, #cycles Subscribers: sergey Projects: #cycles Differential Revision: https://developer.blender.org/D895
2015-01-14 23:06:10 +05:00
double total_time, remaining_time = 0, render_time;
Cycles: * Update progress bar during render (patch by Thomas) * Show status/pass/time during render in 3d view
2011-08-22 13:17:43 +00:00
char time_str[128];
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
float mem_used = (float)session->stats.mem_used / 1024.0f / 1024.0f;
float mem_peak = (float)session->stats.mem_peak / 1024.0f / 1024.0f;
Cycles: * Update progress bar during render (patch by Thomas) * Show status/pass/time during render in 3d view
2011-08-22 13:17:43 +00:00
get_status(status, substatus);
Cycles: Ignore preprocessing time in ETA calculation This patch makes Cycles ignore the time spent in BVH construction etc. when estimating the remaining time. Considering that the remaining time is calculated based on the average time per tile so far, as far as I understand it makes no sense to include the preprocessing time. Reviewers: sergey, #cycles Reviewed By: sergey, #cycles Subscribers: sergey Projects: #cycles Differential Revision: https://developer.blender.org/D895
2015-01-14 23:06:10 +05:00
get_progress(progress, total_time, render_time);
Cycles: * Update progress bar during render (patch by Thomas) * Show status/pass/time during render in 3d view
2011-08-22 13:17:43 +00:00
Cycles: Ignore preprocessing time in ETA calculation This patch makes Cycles ignore the time spent in BVH construction etc. when estimating the remaining time. Considering that the remaining time is calculated based on the average time per tile so far, as far as I understand it makes no sense to include the preprocessing time. Reviewers: sergey, #cycles Reviewed By: sergey, #cycles Subscribers: sergey Projects: #cycles Differential Revision: https://developer.blender.org/D895
2015-01-14 23:06:10 +05:00
if(progress > 0)
remaining_time = (1.0 - (double)progress) * (render_time / (double)progress);
Cycles: show remaining render time in render info text It's a simple estimate, not very precise but that isn't really possible always. For progressive render it will become more accurate the longer you render. Reviewed By: brecht Differential Revision: http://developer.blender.org/D67
2013-12-07 02:22:35 +01:00
Cycles: Ignore preprocessing time in ETA calculation This patch makes Cycles ignore the time spent in BVH construction etc. when estimating the remaining time. Considering that the remaining time is calculated based on the average time per tile so far, as far as I understand it makes no sense to include the preprocessing time. Reviewers: sergey, #cycles Reviewed By: sergey, #cycles Subscribers: sergey Projects: #cycles Differential Revision: https://developer.blender.org/D895
2015-01-14 23:06:10 +05:00
if(background) {
Cycles: show remaining render time in render info text It's a simple estimate, not very precise but that isn't really possible always. For progressive render it will become more accurate the longer you render. Reviewed By: brecht Differential Revision: http://developer.blender.org/D67
2013-12-07 02:22:35 +01:00
scene += " | " + b_scene.name();
Render stats text: show elapsed time for blender internal, hide useless "Single Layer" at the start, more clearly indicate what the render time of the last frame was, some other tweaks for consistency.
2013-06-24 22:41:24 +00:00
if(b_rlay_name != "")
Cycles: show remaining render time in render info text It's a simple estimate, not very precise but that isn't really possible always. For progressive render it will become more accurate the longer you render. Reviewed By: brecht Differential Revision: http://developer.blender.org/D67
2013-12-07 02:22:35 +01:00
scene += ", " + b_rlay_name;
Multi-View and Stereo 3D Official Documentation: http://www.blender.org/manual/render/workflows/multiview.html Implemented Features ==================== Builtin Stereo Camera * Convergence Mode * Interocular Distance * Convergence Distance * Pivot Mode Viewport * Cameras * Plane * Volume Compositor * View Switch Node * Image Node Multi-View OpenEXR support Sequencer * Image/Movie Strips 'Use Multiview' UV/Image Editor * Option to see Multi-View images in Stereo-3D or its individual images * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images I/O * Save/Open Multi-View (OpenEXR, Stereo3D, individual views) images Scene Render Views * Ability to have an arbitrary number of views in the scene Missing Bits ============ First rule of Multi-View bug report: If something is not working as it should *when Views is off* this is a severe bug, do mention this in the report. Second rule is, if something works *when Views is off* but doesn't (or crashes) when *Views is on*, this is a important bug. Do mention this in the report. Everything else is likely small todos, and may wait until we are sure none of the above is happening. Apart from that there are those known issues: * Compositor Image Node poorly working for Multi-View OpenEXR (this was working prefectly before the 'Use Multi-View' functionality) * Selecting camera from Multi-View when looking from camera is problematic * Animation Playback (ctrl+F11) doesn't support stereo formats * Wrong filepath when trying to play back animated scene * Viewport Rendering doesn't support Multi-View * Overscan Rendering * Fullscreen display modes need to warn the user * Object copy should be aware of views suffix Acknowledgments =============== * Francesco Siddi for the help with the original feature specs and design * Brecht Van Lommel for the original review of the code and design early on * Blender Foundation for the Development Fund to support the project wrap up Final patch reviewers: * Antony Riakiotakis (psy-fi) * Campbell Barton (ideasman42) * Julian Eisel (Severin) * Sergey Sharybin (nazgul) * Thomas Dinged (dingto) Code contributors of the original branch in github: * Alexey Akishin * Gabriel Caraballo
2015-04-06 10:40:12 -03:00
if(b_rview_name != "")
scene += ", " + b_rview_name;
Render stats text: show elapsed time for blender internal, hide useless "Single Layer" at the start, more clearly indicate what the render time of the last frame was, some other tweaks for consistency.
2013-06-24 22:41:24 +00:00
}
else {
Cleanup: move BLI_timestr to BLI_timecode
2015-06-30 14:47:31 +10:00
BLI_timecode_string_from_time_simple(time_str, sizeof(time_str), total_time);
Cycles: show remaining render time in render info text It's a simple estimate, not very precise but that isn't really possible always. For progressive render it will become more accurate the longer you render. Reviewed By: brecht Differential Revision: http://developer.blender.org/D67
2013-12-07 02:22:35 +01:00
timestatus = "Time:" + string(time_str) + " | ";
Render stats text: show elapsed time for blender internal, hide useless "Single Layer" at the start, more clearly indicate what the render time of the last frame was, some other tweaks for consistency.
2013-06-24 22:41:24 +00:00
}
Cycles: Code cleanup, whitespace
2014-12-05 19:28:09 +05:00
if(remaining_time > 0) {
Cleanup: move BLI_timestr to BLI_timecode
2015-06-30 14:47:31 +10:00
BLI_timecode_string_from_time_simple(time_str, sizeof(time_str), remaining_time);
Cycles: show remaining render time in render info text It's a simple estimate, not very precise but that isn't really possible always. For progressive render it will become more accurate the longer you render. Reviewed By: brecht Differential Revision: http://developer.blender.org/D67
2013-12-07 02:22:35 +01:00
timestatus += "Remaining:" + string(time_str) + " | ";
}
Cycles: Code cleanup, whitespace
2014-12-05 19:28:09 +05:00
Cycles: reduce float/double conversions
2014-10-08 00:09:36 +02:00
timestatus += string_printf("Mem:%.2fM, Peak:%.2fM", (double)mem_used, (double)mem_peak);
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
Render stats text: show elapsed time for blender internal, hide useless "Single Layer" at the start, more clearly indicate what the render time of the last frame was, some other tweaks for consistency.
2013-06-24 22:41:24 +00:00
if(status.size() > 0)
status = " | " + status;
Cycles: * Update progress bar during render (patch by Thomas) * Show status/pass/time during render in 3d view
2011-08-22 13:17:43 +00:00
if(substatus.size() > 0)
status += " | " + substatus;
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
Cycles: progress printing in background mode, print finished at the end and avoid duplicate prints.
2011-10-30 10:12:34 +00:00
if(status != last_status) {
Fix T38597: cycles status bar missing some updates.
2014-02-11 16:26:08 +01:00
b_engine.update_stats("", (timestatus + scene + status).c_str());
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
b_engine.update_memory_stats(mem_used, mem_peak);
Cycles: progress printing in background mode, print finished at the end and avoid duplicate prints.
2011-10-30 10:12:34 +00:00
last_status = status;
}
if(progress != last_progress) {
RNA C++ API improvements Added support of such features, as: - Ability to call RNA functions using C++ classes For example RenderEngine.tag_update - Property setters (for scalars and arrays) Used Qt/jQuery-like getters/setters style, meaning Class.prop() is a getter, Class.prop(value) is a setter. Still to come: Collection functions are not currently registering inside a property Meaning BlendData.meshes wouldn't be a subclass of BlendDataMeshes result you'll need to explicitly create BlendDataMeshes for now instead of doing BlendData.meshes.remove()
2012-10-22 17:34:16 +00:00
b_engine.update_progress(progress);
Cycles: progress printing in background mode, print finished at the end and avoid duplicate prints.
2011-10-30 10:12:34 +00:00
last_progress = progress;
}
Cycles: Report error to the blender using report API This way when something goes wrong in Cycles (for example out of VRAM, timelimit launching the kernel etc) we'll have a nice report in the Info space header. Sure it'll be nice to have mention of error in the image editor's information line, but that's for the future. This fixes T42747: "CUDA error" appears only momentarily, then disappears
2014-12-05 21:27:52 +05:00
Cycles: Code cleanup, spaces around keywords This inconsistency drove me totally crazy, it's really confusing when it's inconsistent especially when you work on both Cycles and Blender sides. Shouldn;t cause merge PITA, it's whitespace changes only, Git should be able to merge it nicely.
2015-03-28 00:15:15 +05:00
if(session->progress.get_error()) {
Cycles: Report error to the blender using report API This way when something goes wrong in Cycles (for example out of VRAM, timelimit launching the kernel etc) we'll have a nice report in the Info space header. Sure it'll be nice to have mention of error in the image editor's information line, but that's for the future. This fixes T42747: "CUDA error" appears only momentarily, then disappears
2014-12-05 21:27:52 +05:00
string error = session->progress.get_error_message();
if(error != last_error) {
/* TODO(sergey): Currently C++ RNA API doesn't let us to
* use mnemonic name for the variable. Would be nice to
* have this figured out.
*
* For until then, 1 << 5 means RPT_ERROR.
*/
b_engine.report(1 << 5, error.c_str());
Cycles: Report error via the new engine API This way CUDA errors are visible in the image info line, which makes things to behave the same across viewport and final rendering. That's right, we've got error reported via reports and info line now. This is based on the feedback from our gooseberry team.
2014-12-05 22:00:39 +05:00
b_engine.error_set(error.c_str());
Cycles: Report error to the blender using report API This way when something goes wrong in Cycles (for example out of VRAM, timelimit launching the kernel etc) we'll have a nice report in the Info space header. Sure it'll be nice to have mention of error in the image editor's information line, but that's for the future. This fixes T42747: "CUDA error" appears only momentarily, then disappears
2014-12-05 21:27:52 +05:00
last_error = error;
}
}
Cycles: fix crash in 3d view status text display.
2011-08-23 12:20:11 +00:00
}
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
Cycles: fix crash in 3d view status text display.
2011-08-23 12:20:11 +00:00
void BlenderSession::tag_update()
{
/* tell blender that we want to get another update callback */
RNA C++ API improvements Added support of such features, as: - Ability to call RNA functions using C++ classes For example RenderEngine.tag_update - Property setters (for scalars and arrays) Used Qt/jQuery-like getters/setters style, meaning Class.prop() is a getter, Class.prop(value) is a setter. Still to come: Collection functions are not currently registering inside a property Meaning BlendData.meshes wouldn't be a subclass of BlendDataMeshes result you'll need to explicitly create BlendDataMeshes for now instead of doing BlendData.meshes.remove()
2012-10-22 17:34:16 +00:00
b_engine.tag_update();
Cycles: fix crash in 3d view status text display.
2011-08-23 12:20:11 +00:00
}
void BlenderSession::tag_redraw()
{
Cycles: * Update progress bar during render (patch by Thomas) * Show status/pass/time during render in 3d view
2011-08-22 13:17:43 +00:00
if(background) {
Cycles: fix crash in 3d view status text display.
2011-08-23 12:20:11 +00:00
/* update stats and progress, only for background here because
style cleanup: block comments
2012-06-09 17:22:52 +00:00
* in 3d view we do it in draw for thread safety reasons */
Cycles: fix crash in 3d view status text display.
2011-08-23 12:20:11 +00:00
update_status_progress();
Cycles: * Update progress bar during render (patch by Thomas) * Show status/pass/time during render in 3d view
2011-08-22 13:17:43 +00:00
/* offline render, redraw if timeout passed */
code cleanup: quiet all warnings about double promotion (either by changing the type or explicitly casting).
2012-06-09 17:45:22 +00:00
if(time_dt() - last_redraw_time > 1.0) {
RNA C++ API improvements Added support of such features, as: - Ability to call RNA functions using C++ classes For example RenderEngine.tag_update - Property setters (for scalars and arrays) Used Qt/jQuery-like getters/setters style, meaning Class.prop() is a getter, Class.prop(value) is a setter. Still to come: Collection functions are not currently registering inside a property Meaning BlendData.meshes wouldn't be a subclass of BlendDataMeshes result you'll need to explicitly create BlendDataMeshes for now instead of doing BlendData.meshes.remove()
2012-10-22 17:34:16 +00:00
b_engine.tag_redraw();
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
last_redraw_time = time_dt();
}
}
else {
/* tell blender that we want to redraw */
RNA C++ API improvements Added support of such features, as: - Ability to call RNA functions using C++ classes For example RenderEngine.tag_update - Property setters (for scalars and arrays) Used Qt/jQuery-like getters/setters style, meaning Class.prop() is a getter, Class.prop(value) is a setter. Still to come: Collection functions are not currently registering inside a property Meaning BlendData.meshes wouldn't be a subclass of BlendDataMeshes result you'll need to explicitly create BlendDataMeshes for now instead of doing BlendData.meshes.remove()
2012-10-22 17:34:16 +00:00
b_engine.tag_redraw();
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
}
}
void BlenderSession::test_cancel()
{
/* test if we need to cancel rendering */
if(background)
RNA C++ API improvements Added support of such features, as: - Ability to call RNA functions using C++ classes For example RenderEngine.tag_update - Property setters (for scalars and arrays) Used Qt/jQuery-like getters/setters style, meaning Class.prop() is a getter, Class.prop(value) is a setter. Still to come: Collection functions are not currently registering inside a property Meaning BlendData.meshes wouldn't be a subclass of BlendDataMeshes result you'll need to explicitly create BlendDataMeshes for now instead of doing BlendData.meshes.remove()
2012-10-22 17:34:16 +00:00
if(b_engine.test_break())
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
session->progress.set_cancel("Cancelled");
}
Movies support for Cycles This adds support of movie textures for Cycles rendering. Uses the same builtin images routines as packed/generated images, but with some extra non-rna hookups from blender_session side. Basically, it's not so clear how to give access to video frames via C++ RNA -- it'll require exposing ImBuf to API, doing some threading locks and so. Ended up adding two more functions which are actually bad level call, but don't consider it's so much bad -- we have few bad calls already, which are actually related. Changed a bit how builtin images names are passing to image manager. Now it's not just an ID datablock name, but also a frame number concatenated via '@' character, which makes itpossible to easily know frame number to be used for movie images, without adding extra descriptors to image manager. Decoding of builtin name is a bit slower now, but it should be still nothing in comparison with rendering complexity. Also exposed image user's frame_current to python API, which is needed to get absolute frame number of movie from node's image user. P.S. Generated/packed images are also using bad level call but only does it to make things more clear here. Either all images are using C++ RNA here or no images does. That's the most clear for now.
2013-01-16 17:07:25 +00:00
/* builtin image file name is actually an image datablock name with
* absolute sequence frame number concatenated via '@' character
*
Cycles material preview: fix for generated/packed/movie files Issue was caused by cycles trying to find builtin images in a main database and in case of preview render images are not in database, they're just referenced by shader node tree. Now builtin images in cycles have got void* pointer to store data needed to load builtin images. In case ob blender session, this pointer will store pointer from PointerRNA for image datablock and used later to construct Image class based on this pointer. This also saves database lookup for final render which is nice :) Reviewed by Brecht.
2013-01-30 13:42:12 +00:00
* this function splits frame from builtin name
Movies support for Cycles This adds support of movie textures for Cycles rendering. Uses the same builtin images routines as packed/generated images, but with some extra non-rna hookups from blender_session side. Basically, it's not so clear how to give access to video frames via C++ RNA -- it'll require exposing ImBuf to API, doing some threading locks and so. Ended up adding two more functions which are actually bad level call, but don't consider it's so much bad -- we have few bad calls already, which are actually related. Changed a bit how builtin images names are passing to image manager. Now it's not just an ID datablock name, but also a frame number concatenated via '@' character, which makes itpossible to easily know frame number to be used for movie images, without adding extra descriptors to image manager. Decoding of builtin name is a bit slower now, but it should be still nothing in comparison with rendering complexity. Also exposed image user's frame_current to python API, which is needed to get absolute frame number of movie from node's image user. P.S. Generated/packed images are also using bad level call but only does it to make things more clear here. Either all images are using C++ RNA here or no images does. That's the most clear for now.
2013-01-16 17:07:25 +00:00
*/
Cycles material preview: fix for generated/packed/movie files Issue was caused by cycles trying to find builtin images in a main database and in case of preview render images are not in database, they're just referenced by shader node tree. Now builtin images in cycles have got void* pointer to store data needed to load builtin images. In case ob blender session, this pointer will store pointer from PointerRNA for image datablock and used later to construct Image class based on this pointer. This also saves database lookup for final render which is nice :) Reviewed by Brecht.
2013-01-30 13:42:12 +00:00
int BlenderSession::builtin_image_frame(const string &builtin_name)
Movies support for Cycles This adds support of movie textures for Cycles rendering. Uses the same builtin images routines as packed/generated images, but with some extra non-rna hookups from blender_session side. Basically, it's not so clear how to give access to video frames via C++ RNA -- it'll require exposing ImBuf to API, doing some threading locks and so. Ended up adding two more functions which are actually bad level call, but don't consider it's so much bad -- we have few bad calls already, which are actually related. Changed a bit how builtin images names are passing to image manager. Now it's not just an ID datablock name, but also a frame number concatenated via '@' character, which makes itpossible to easily know frame number to be used for movie images, without adding extra descriptors to image manager. Decoding of builtin name is a bit slower now, but it should be still nothing in comparison with rendering complexity. Also exposed image user's frame_current to python API, which is needed to get absolute frame number of movie from node's image user. P.S. Generated/packed images are also using bad level call but only does it to make things more clear here. Either all images are using C++ RNA here or no images does. That's the most clear for now.
2013-01-16 17:07:25 +00:00
{
int last = builtin_name.find_last_of('@');
Cycles material preview: fix for generated/packed/movie files Issue was caused by cycles trying to find builtin images in a main database and in case of preview render images are not in database, they're just referenced by shader node tree. Now builtin images in cycles have got void* pointer to store data needed to load builtin images. In case ob blender session, this pointer will store pointer from PointerRNA for image datablock and used later to construct Image class based on this pointer. This also saves database lookup for final render which is nice :) Reviewed by Brecht.
2013-01-30 13:42:12 +00:00
return atoi(builtin_name.substr(last + 1, builtin_name.size() - last - 1).c_str());
Movies support for Cycles This adds support of movie textures for Cycles rendering. Uses the same builtin images routines as packed/generated images, but with some extra non-rna hookups from blender_session side. Basically, it's not so clear how to give access to video frames via C++ RNA -- it'll require exposing ImBuf to API, doing some threading locks and so. Ended up adding two more functions which are actually bad level call, but don't consider it's so much bad -- we have few bad calls already, which are actually related. Changed a bit how builtin images names are passing to image manager. Now it's not just an ID datablock name, but also a frame number concatenated via '@' character, which makes itpossible to easily know frame number to be used for movie images, without adding extra descriptors to image manager. Decoding of builtin name is a bit slower now, but it should be still nothing in comparison with rendering complexity. Also exposed image user's frame_current to python API, which is needed to get absolute frame number of movie from node's image user. P.S. Generated/packed images are also using bad level call but only does it to make things more clear here. Either all images are using C++ RNA here or no images does. That's the most clear for now.
2013-01-16 17:07:25 +00:00
}
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
void BlenderSession::builtin_image_info(const string &builtin_name,
void *builtin_data,
bool &is_float,
int &width,
int &height,
int &depth,
int &channels)
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
{
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
/* empty image */
is_float = false;
Cycles: Avoid crash when accessing non-existing volume attribute
2016-04-12 13:02:05 +02:00
width = 1;
height = 1;
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
depth = 0;
channels = 0;
if(!builtin_data)
return;
/* recover ID pointer */
Cycles material preview: fix for generated/packed/movie files Issue was caused by cycles trying to find builtin images in a main database and in case of preview render images are not in database, they're just referenced by shader node tree. Now builtin images in cycles have got void* pointer to store data needed to load builtin images. In case ob blender session, this pointer will store pointer from PointerRNA for image datablock and used later to construct Image class based on this pointer. This also saves database lookup for final render which is nice :) Reviewed by Brecht.
2013-01-30 13:42:12 +00:00
PointerRNA ptr;
RNA_id_pointer_create((ID*)builtin_data, &ptr);
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
BL::ID b_id(ptr);
if(b_id.is_a(&RNA_Image)) {
/* image data */
BL::Image b_image(b_id);
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
is_float = b_image.is_float();
width = b_image.size()[0];
height = b_image.size()[1];
Cycles code internals: add CPU kernel support for 3D image textures.
2014-03-29 13:03:48 +01:00
depth = 1;
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
channels = b_image.channels();
}
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
else if(b_id.is_a(&RNA_Object)) {
/* smoke volume data */
BL::Object b_ob(b_id);
BL::SmokeDomainSettings b_domain = object_smoke_domain_find(b_ob);
Cycles: Avoid crash when accessing non-existing volume attribute
2016-04-12 13:02:05 +02:00
is_float = true;
depth = 1;
channels = 1;
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
if(!b_domain)
return;
if(builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_DENSITY) ||
Cycles: Support heat volume attribute Similar to velocity, it was kind of supported by the mesh manager but was missing a code in BlenderSession to get actual values. In Cycles Heat is an attribute which goes from -1 to 1, where -1 is the coldest ever temperature, 1 is the hottest ever one.
2016-04-15 12:02:31 +02:00
builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_FLAME) ||
builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_HEAT))
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
channels = 1;
else if(builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_COLOR))
channels = 4;
Cycles: Add missing velocity attribute to builtin image loader For some reason other parts of blender importer were assuming velocity is supported, but actual loader was not aware of that. Fixes T48064: Adding velocity attribute crashes render
2016-04-12 13:25:20 +02:00
else if(builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_VELOCITY))
channels = 3;
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
else
return;
int3 resolution = get_int3(b_domain.domain_resolution());
int amplify = (b_domain.use_high_resolution())? b_domain.amplify() + 1: 1;
Cycles: Support heat volume attribute Similar to velocity, it was kind of supported by the mesh manager but was missing a code in BlenderSession to get actual values. In Cycles Heat is an attribute which goes from -1 to 1, where -1 is the coldest ever temperature, 1 is the hottest ever one.
2016-04-15 12:02:31 +02:00
/* Velocity and heat data is always low-resolution. */
if(builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_VELOCITY) ||
builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_HEAT))
{
amplify = 1;
}
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
width = resolution.x * amplify;
height = resolution.y * amplify;
depth = resolution.z * amplify;
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
}
Cycles: Point density texture support This commit implements point density texture for Cycles shading nodes. It's done via creating voxel texture at shader compilation time, Not totally memory efficient, but avoids adding sampling code to kernel (which keeps render time as low as possible), In the future this will be compensated by using OpenVDB for more efficient storage of sparse volume data. Sampling of the voxel texture is happening at blender side and the same code is used as for Blender Internal's renderer. This texture is controlled by only object, particle system and radius. Linear falloff is used and there's no turbulence. This is because falloff is expected to happen using Curve Mapping node. Turbulence will be done as a distortion on the input coordinate. It's already possible to fake it using nose textures and in the future we can add more proper turbulence distortion node, which then could also be used for 2D texture mapping. Particle color support is done by Lukas, thanks!
2015-07-18 22:36:09 +02:00
else {
/* TODO(sergey): Check we're indeed in shader node tree. */
PointerRNA ptr;
RNA_pointer_create(NULL, &RNA_Node, builtin_data, &ptr);
BL::Node b_node(ptr);
if(b_node.is_a(&RNA_ShaderNodeTexPointDensity)) {
BL::ShaderNodeTexPointDensity b_point_density_node(b_node);
channels = 4;
width = height = depth = b_point_density_node.resolution();
is_float = true;
}
}
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
}
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
bool BlenderSession::builtin_image_pixels(const string &builtin_name,
void *builtin_data,
unsigned char *pixels,
const size_t pixels_size)
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
{
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
if(!builtin_data) {
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
return false;
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
}
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
const int frame = builtin_image_frame(builtin_name);
Movies support for Cycles This adds support of movie textures for Cycles rendering. Uses the same builtin images routines as packed/generated images, but with some extra non-rna hookups from blender_session side. Basically, it's not so clear how to give access to video frames via C++ RNA -- it'll require exposing ImBuf to API, doing some threading locks and so. Ended up adding two more functions which are actually bad level call, but don't consider it's so much bad -- we have few bad calls already, which are actually related. Changed a bit how builtin images names are passing to image manager. Now it's not just an ID datablock name, but also a frame number concatenated via '@' character, which makes itpossible to easily know frame number to be used for movie images, without adding extra descriptors to image manager. Decoding of builtin name is a bit slower now, but it should be still nothing in comparison with rendering complexity. Also exposed image user's frame_current to python API, which is needed to get absolute frame number of movie from node's image user. P.S. Generated/packed images are also using bad level call but only does it to make things more clear here. Either all images are using C++ RNA here or no images does. That's the most clear for now.
2013-01-16 17:07:25 +00:00
Cycles material preview: fix for generated/packed/movie files Issue was caused by cycles trying to find builtin images in a main database and in case of preview render images are not in database, they're just referenced by shader node tree. Now builtin images in cycles have got void* pointer to store data needed to load builtin images. In case ob blender session, this pointer will store pointer from PointerRNA for image datablock and used later to construct Image class based on this pointer. This also saves database lookup for final render which is nice :) Reviewed by Brecht.
2013-01-30 13:42:12 +00:00
PointerRNA ptr;
RNA_id_pointer_create((ID*)builtin_data, &ptr);
BL::Image b_image(ptr);
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
const int width = b_image.size()[0];
const int height = b_image.size()[1];
const int channels = b_image.channels();
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
unsigned char *image_pixels = image_get_pixels_for_frame(b_image, frame);
const size_t num_pixels = ((size_t)width) * height;
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
if(image_pixels && num_pixels * channels == pixels_size) {
memcpy(pixels, image_pixels, pixels_size * sizeof(unsigned char));
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
MEM_freeN(image_pixels);
}
else {
if(channels == 1) {
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
memset(pixels, 0, pixels_size * sizeof(unsigned char));
Movies support for Cycles This adds support of movie textures for Cycles rendering. Uses the same builtin images routines as packed/generated images, but with some extra non-rna hookups from blender_session side. Basically, it's not so clear how to give access to video frames via C++ RNA -- it'll require exposing ImBuf to API, doing some threading locks and so. Ended up adding two more functions which are actually bad level call, but don't consider it's so much bad -- we have few bad calls already, which are actually related. Changed a bit how builtin images names are passing to image manager. Now it's not just an ID datablock name, but also a frame number concatenated via '@' character, which makes itpossible to easily know frame number to be used for movie images, without adding extra descriptors to image manager. Decoding of builtin name is a bit slower now, but it should be still nothing in comparison with rendering complexity. Also exposed image user's frame_current to python API, which is needed to get absolute frame number of movie from node's image user. P.S. Generated/packed images are also using bad level call but only does it to make things more clear here. Either all images are using C++ RNA here or no images does. That's the most clear for now.
2013-01-16 17:07:25 +00:00
}
else {
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
const size_t num_pixels_safe = pixels_size / channels;
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
unsigned char *cp = pixels;
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
for(size_t i = 0; i < num_pixels_safe; i++, cp += channels) {
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
cp[0] = 255;
cp[1] = 0;
cp[2] = 255;
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
if(channels == 4) {
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
cp[3] = 255;
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
}
Movies support for Cycles This adds support of movie textures for Cycles rendering. Uses the same builtin images routines as packed/generated images, but with some extra non-rna hookups from blender_session side. Basically, it's not so clear how to give access to video frames via C++ RNA -- it'll require exposing ImBuf to API, doing some threading locks and so. Ended up adding two more functions which are actually bad level call, but don't consider it's so much bad -- we have few bad calls already, which are actually related. Changed a bit how builtin images names are passing to image manager. Now it's not just an ID datablock name, but also a frame number concatenated via '@' character, which makes itpossible to easily know frame number to be used for movie images, without adding extra descriptors to image manager. Decoding of builtin name is a bit slower now, but it should be still nothing in comparison with rendering complexity. Also exposed image user's frame_current to python API, which is needed to get absolute frame number of movie from node's image user. P.S. Generated/packed images are also using bad level call but only does it to make things more clear here. Either all images are using C++ RNA here or no images does. That's the most clear for now.
2013-01-16 17:07:25 +00:00
}
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
}
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
}
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
/* Premultiply, byte images are always straight for Blender. */
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
unsigned char *cp = pixels;
Fix T44616: Cycles crashes loading 42k by 21k textures Simple integer overflow issue. TODO(sergey): Check on CPU cubic sampling, it might also need size_t.
2015-05-12 18:33:31 +05:00
for(size_t i = 0; i < num_pixels; i++, cp += channels) {
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
cp[0] = (cp[0] * cp[3]) >> 8;
cp[1] = (cp[1] * cp[3]) >> 8;
cp[2] = (cp[2] * cp[3]) >> 8;
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
}
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
return true;
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
}
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
bool BlenderSession::builtin_image_float_pixels(const string &builtin_name,
void *builtin_data,
float *pixels,
const size_t pixels_size)
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
{
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
if(!builtin_data) {
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
return false;
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
}
Movies support for Cycles This adds support of movie textures for Cycles rendering. Uses the same builtin images routines as packed/generated images, but with some extra non-rna hookups from blender_session side. Basically, it's not so clear how to give access to video frames via C++ RNA -- it'll require exposing ImBuf to API, doing some threading locks and so. Ended up adding two more functions which are actually bad level call, but don't consider it's so much bad -- we have few bad calls already, which are actually related. Changed a bit how builtin images names are passing to image manager. Now it's not just an ID datablock name, but also a frame number concatenated via '@' character, which makes itpossible to easily know frame number to be used for movie images, without adding extra descriptors to image manager. Decoding of builtin name is a bit slower now, but it should be still nothing in comparison with rendering complexity. Also exposed image user's frame_current to python API, which is needed to get absolute frame number of movie from node's image user. P.S. Generated/packed images are also using bad level call but only does it to make things more clear here. Either all images are using C++ RNA here or no images does. That's the most clear for now.
2013-01-16 17:07:25 +00:00
Cycles material preview: fix for generated/packed/movie files Issue was caused by cycles trying to find builtin images in a main database and in case of preview render images are not in database, they're just referenced by shader node tree. Now builtin images in cycles have got void* pointer to store data needed to load builtin images. In case ob blender session, this pointer will store pointer from PointerRNA for image datablock and used later to construct Image class based on this pointer. This also saves database lookup for final render which is nice :) Reviewed by Brecht.
2013-01-30 13:42:12 +00:00
PointerRNA ptr;
RNA_id_pointer_create((ID*)builtin_data, &ptr);
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
BL::ID b_id(ptr);
if(b_id.is_a(&RNA_Image)) {
/* image data */
BL::Image b_image(b_id);
int frame = builtin_image_frame(builtin_name);
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
const int width = b_image.size()[0];
const int height = b_image.size()[1];
const int channels = b_image.channels();
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
Movies support for Cycles This adds support of movie textures for Cycles rendering. Uses the same builtin images routines as packed/generated images, but with some extra non-rna hookups from blender_session side. Basically, it's not so clear how to give access to video frames via C++ RNA -- it'll require exposing ImBuf to API, doing some threading locks and so. Ended up adding two more functions which are actually bad level call, but don't consider it's so much bad -- we have few bad calls already, which are actually related. Changed a bit how builtin images names are passing to image manager. Now it's not just an ID datablock name, but also a frame number concatenated via '@' character, which makes itpossible to easily know frame number to be used for movie images, without adding extra descriptors to image manager. Decoding of builtin name is a bit slower now, but it should be still nothing in comparison with rendering complexity. Also exposed image user's frame_current to python API, which is needed to get absolute frame number of movie from node's image user. P.S. Generated/packed images are also using bad level call but only does it to make things more clear here. Either all images are using C++ RNA here or no images does. That's the most clear for now.
2013-01-16 17:07:25 +00:00
float *image_pixels;
image_pixels = image_get_float_pixels_for_frame(b_image, frame);
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
const size_t num_pixels = ((size_t)width) * height;
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
if(image_pixels && num_pixels * channels == pixels_size) {
memcpy(pixels, image_pixels, pixels_size * sizeof(float));
Movies support for Cycles This adds support of movie textures for Cycles rendering. Uses the same builtin images routines as packed/generated images, but with some extra non-rna hookups from blender_session side. Basically, it's not so clear how to give access to video frames via C++ RNA -- it'll require exposing ImBuf to API, doing some threading locks and so. Ended up adding two more functions which are actually bad level call, but don't consider it's so much bad -- we have few bad calls already, which are actually related. Changed a bit how builtin images names are passing to image manager. Now it's not just an ID datablock name, but also a frame number concatenated via '@' character, which makes itpossible to easily know frame number to be used for movie images, without adding extra descriptors to image manager. Decoding of builtin name is a bit slower now, but it should be still nothing in comparison with rendering complexity. Also exposed image user's frame_current to python API, which is needed to get absolute frame number of movie from node's image user. P.S. Generated/packed images are also using bad level call but only does it to make things more clear here. Either all images are using C++ RNA here or no images does. That's the most clear for now.
2013-01-16 17:07:25 +00:00
MEM_freeN(image_pixels);
}
else {
if(channels == 1) {
Fix T44616: Cycles crashes loading 42k by 21k textures Simple integer overflow issue. TODO(sergey): Check on CPU cubic sampling, it might also need size_t.
2015-05-12 18:33:31 +05:00
memset(pixels, 0, num_pixels * sizeof(float));
Movies support for Cycles This adds support of movie textures for Cycles rendering. Uses the same builtin images routines as packed/generated images, but with some extra non-rna hookups from blender_session side. Basically, it's not so clear how to give access to video frames via C++ RNA -- it'll require exposing ImBuf to API, doing some threading locks and so. Ended up adding two more functions which are actually bad level call, but don't consider it's so much bad -- we have few bad calls already, which are actually related. Changed a bit how builtin images names are passing to image manager. Now it's not just an ID datablock name, but also a frame number concatenated via '@' character, which makes itpossible to easily know frame number to be used for movie images, without adding extra descriptors to image manager. Decoding of builtin name is a bit slower now, but it should be still nothing in comparison with rendering complexity. Also exposed image user's frame_current to python API, which is needed to get absolute frame number of movie from node's image user. P.S. Generated/packed images are also using bad level call but only does it to make things more clear here. Either all images are using C++ RNA here or no images does. That's the most clear for now.
2013-01-16 17:07:25 +00:00
}
else {
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
const size_t num_pixels_safe = pixels_size / channels;
Movies support for Cycles This adds support of movie textures for Cycles rendering. Uses the same builtin images routines as packed/generated images, but with some extra non-rna hookups from blender_session side. Basically, it's not so clear how to give access to video frames via C++ RNA -- it'll require exposing ImBuf to API, doing some threading locks and so. Ended up adding two more functions which are actually bad level call, but don't consider it's so much bad -- we have few bad calls already, which are actually related. Changed a bit how builtin images names are passing to image manager. Now it's not just an ID datablock name, but also a frame number concatenated via '@' character, which makes itpossible to easily know frame number to be used for movie images, without adding extra descriptors to image manager. Decoding of builtin name is a bit slower now, but it should be still nothing in comparison with rendering complexity. Also exposed image user's frame_current to python API, which is needed to get absolute frame number of movie from node's image user. P.S. Generated/packed images are also using bad level call but only does it to make things more clear here. Either all images are using C++ RNA here or no images does. That's the most clear for now.
2013-01-16 17:07:25 +00:00
float *fp = pixels;
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
for(int i = 0; i < num_pixels_safe; i++, fp += channels) {
Movies support for Cycles This adds support of movie textures for Cycles rendering. Uses the same builtin images routines as packed/generated images, but with some extra non-rna hookups from blender_session side. Basically, it's not so clear how to give access to video frames via C++ RNA -- it'll require exposing ImBuf to API, doing some threading locks and so. Ended up adding two more functions which are actually bad level call, but don't consider it's so much bad -- we have few bad calls already, which are actually related. Changed a bit how builtin images names are passing to image manager. Now it's not just an ID datablock name, but also a frame number concatenated via '@' character, which makes itpossible to easily know frame number to be used for movie images, without adding extra descriptors to image manager. Decoding of builtin name is a bit slower now, but it should be still nothing in comparison with rendering complexity. Also exposed image user's frame_current to python API, which is needed to get absolute frame number of movie from node's image user. P.S. Generated/packed images are also using bad level call but only does it to make things more clear here. Either all images are using C++ RNA here or no images does. That's the most clear for now.
2013-01-16 17:07:25 +00:00
fp[0] = 1.0f;
fp[1] = 0.0f;
fp[2] = 1.0f;
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
if(channels == 4) {
Movies support for Cycles This adds support of movie textures for Cycles rendering. Uses the same builtin images routines as packed/generated images, but with some extra non-rna hookups from blender_session side. Basically, it's not so clear how to give access to video frames via C++ RNA -- it'll require exposing ImBuf to API, doing some threading locks and so. Ended up adding two more functions which are actually bad level call, but don't consider it's so much bad -- we have few bad calls already, which are actually related. Changed a bit how builtin images names are passing to image manager. Now it's not just an ID datablock name, but also a frame number concatenated via '@' character, which makes itpossible to easily know frame number to be used for movie images, without adding extra descriptors to image manager. Decoding of builtin name is a bit slower now, but it should be still nothing in comparison with rendering complexity. Also exposed image user's frame_current to python API, which is needed to get absolute frame number of movie from node's image user. P.S. Generated/packed images are also using bad level call but only does it to make things more clear here. Either all images are using C++ RNA here or no images does. That's the most clear for now.
2013-01-16 17:07:25 +00:00
fp[3] = 1.0f;
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
}
Movies support for Cycles This adds support of movie textures for Cycles rendering. Uses the same builtin images routines as packed/generated images, but with some extra non-rna hookups from blender_session side. Basically, it's not so clear how to give access to video frames via C++ RNA -- it'll require exposing ImBuf to API, doing some threading locks and so. Ended up adding two more functions which are actually bad level call, but don't consider it's so much bad -- we have few bad calls already, which are actually related. Changed a bit how builtin images names are passing to image manager. Now it's not just an ID datablock name, but also a frame number concatenated via '@' character, which makes itpossible to easily know frame number to be used for movie images, without adding extra descriptors to image manager. Decoding of builtin name is a bit slower now, but it should be still nothing in comparison with rendering complexity. Also exposed image user's frame_current to python API, which is needed to get absolute frame number of movie from node's image user. P.S. Generated/packed images are also using bad level call but only does it to make things more clear here. Either all images are using C++ RNA here or no images does. That's the most clear for now.
2013-01-16 17:07:25 +00:00
}
}
}
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
return true;
}
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
else if(b_id.is_a(&RNA_Object)) {
/* smoke volume data */
BL::Object b_ob(b_id);
BL::SmokeDomainSettings b_domain = object_smoke_domain_find(b_ob);
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
if(!b_domain) {
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
return false;
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
}
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
int3 resolution = get_int3(b_domain.domain_resolution());
int length, amplify = (b_domain.use_high_resolution())? b_domain.amplify() + 1: 1;
Cycles: Support heat volume attribute Similar to velocity, it was kind of supported by the mesh manager but was missing a code in BlenderSession to get actual values. In Cycles Heat is an attribute which goes from -1 to 1, where -1 is the coldest ever temperature, 1 is the hottest ever one.
2016-04-15 12:02:31 +02:00
/* Velocity and heat data is always low-resolution. */
if(builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_VELOCITY) ||
builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_HEAT))
{
Cycles: Add missing velocity attribute to builtin image loader For some reason other parts of blender importer were assuming velocity is supported, but actual loader was not aware of that. Fixes T48064: Adding velocity attribute crashes render
2016-04-12 13:25:20 +02:00
amplify = 1;
}
Cycles: Pass extra array size argument to builtin image pixels functions This is a way to avoid possible memory corruption when render threads works in parallel with UI thread. Not guarantees complete safe, but makes things easier to check anyway.
2016-11-29 11:03:11 +01:00
const int width = resolution.x * amplify;
const int height = resolution.y * amplify;
const int depth = resolution.z * amplify;
const size_t num_pixels = ((size_t)width) * height * depth;
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
if(builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_DENSITY)) {
SmokeDomainSettings_density_grid_get_length(&b_domain.ptr, &length);
Fix T44616: Cycles crashes loading 42k by 21k textures Simple integer overflow issue. TODO(sergey): Check on CPU cubic sampling, it might also need size_t.
2015-05-12 18:33:31 +05:00
if(length == num_pixels) {
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
SmokeDomainSettings_density_grid_get(&b_domain.ptr, pixels);
return true;
}
}
else if(builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_FLAME)) {
/* this is in range 0..1, and interpreted by the OpenGL smoke viewer
* as 1500..3000 K with the first part faded to zero density */
SmokeDomainSettings_flame_grid_get_length(&b_domain.ptr, &length);
Fix T44616: Cycles crashes loading 42k by 21k textures Simple integer overflow issue. TODO(sergey): Check on CPU cubic sampling, it might also need size_t.
2015-05-12 18:33:31 +05:00
if(length == num_pixels) {
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
SmokeDomainSettings_flame_grid_get(&b_domain.ptr, pixels);
return true;
}
}
else if(builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_COLOR)) {
/* the RGB is "premultiplied" by density for better interpolation results */
SmokeDomainSettings_color_grid_get_length(&b_domain.ptr, &length);
Fix T44616: Cycles crashes loading 42k by 21k textures Simple integer overflow issue. TODO(sergey): Check on CPU cubic sampling, it might also need size_t.
2015-05-12 18:33:31 +05:00
if(length == num_pixels*4) {
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
SmokeDomainSettings_color_grid_get(&b_domain.ptr, pixels);
return true;
}
}
Cycles: Add missing velocity attribute to builtin image loader For some reason other parts of blender importer were assuming velocity is supported, but actual loader was not aware of that. Fixes T48064: Adding velocity attribute crashes render
2016-04-12 13:25:20 +02:00
else if(builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_VELOCITY)) {
SmokeDomainSettings_velocity_grid_get_length(&b_domain.ptr, &length);
if(length == num_pixels*3) {
SmokeDomainSettings_velocity_grid_get(&b_domain.ptr, pixels);
return true;
}
}
Cycles: Support heat volume attribute Similar to velocity, it was kind of supported by the mesh manager but was missing a code in BlenderSession to get actual values. In Cycles Heat is an attribute which goes from -1 to 1, where -1 is the coldest ever temperature, 1 is the hottest ever one.
2016-04-15 12:02:31 +02:00
else if(builtin_name == Attribute::standard_name(ATTR_STD_VOLUME_HEAT)) {
SmokeDomainSettings_heat_grid_get_length(&b_domain.ptr, &length);
if(length == num_pixels) {
SmokeDomainSettings_heat_grid_get(&b_domain.ptr, pixels);
return true;
}
}
Cycles: Avoid crash when accessing non-existing volume attribute
2016-04-12 13:02:05 +02:00
else {
Cycles: Improve error print a bit
2016-04-15 11:24:59 +02:00
fprintf(stderr,
"Cycles error: unknown volume attribute %s, skipping\n",
builtin_name.c_str());
Cycles: Avoid crash when accessing non-existing volume attribute
2016-04-12 13:02:05 +02:00
pixels[0] = 0.0f;
return false;
}
Cycles: add "density", "flame" and "color" attributes for smoke domains. These can currently be accessed by adding an Attribute node and specifying one of those three names. A Smoke/Fire node should be added at some point to make this more convenient. These values might change still before the release, in particular for flame the meaning seems unclear, it's just values in the 0..1 range. This is useful for color ramps, but it might be good if this was also available as temperature in kelvin so it can be plugged into the blackbody node. But I couldn't figure out from the smoke code if or how this corresponds to a physical unit. Here's a (quite poor) example file for a fire + smoke setup: http://www.pasteall.org/blend/27990
2014-03-29 13:03:48 +01:00
fprintf(stderr, "Cycles error: unexpected smoke volume resolution, skipping\n");
}
Cycles: Point density texture support This commit implements point density texture for Cycles shading nodes. It's done via creating voxel texture at shader compilation time, Not totally memory efficient, but avoids adding sampling code to kernel (which keeps render time as low as possible), In the future this will be compensated by using OpenVDB for more efficient storage of sparse volume data. Sampling of the voxel texture is happening at blender side and the same code is used as for Blender Internal's renderer. This texture is controlled by only object, particle system and radius. Linear falloff is used and there's no turbulence. This is because falloff is expected to happen using Curve Mapping node. Turbulence will be done as a distortion on the input coordinate. It's already possible to fake it using nose textures and in the future we can add more proper turbulence distortion node, which then could also be used for 2D texture mapping. Particle color support is done by Lukas, thanks!
2015-07-18 22:36:09 +02:00
else {
/* TODO(sergey): Check we're indeed in shader node tree. */
PointerRNA ptr;
RNA_pointer_create(NULL, &RNA_Node, builtin_data, &ptr);
BL::Node b_node(ptr);
if(b_node.is_a(&RNA_ShaderNodeTexPointDensity)) {
BL::ShaderNodeTexPointDensity b_point_density_node(b_node);
int length;
Cycles: Fix for point density always using render settings for modifiers
2015-10-08 12:09:28 +05:00
int settings = background ? 1 : 0; /* 1 - render settings, 0 - vewport settings. */
b_point_density_node.calc_point_density(b_scene, settings, &length, &pixels);
Cycles: Point density texture support This commit implements point density texture for Cycles shading nodes. It's done via creating voxel texture at shader compilation time, Not totally memory efficient, but avoids adding sampling code to kernel (which keeps render time as low as possible), In the future this will be compensated by using OpenVDB for more efficient storage of sparse volume data. Sampling of the voxel texture is happening at blender side and the same code is used as for Blender Internal's renderer. This texture is controlled by only object, particle system and radius. Linear falloff is used and there's no turbulence. This is because falloff is expected to happen using Curve Mapping node. Turbulence will be done as a distortion on the input coordinate. It's already possible to fake it using nose textures and in the future we can add more proper turbulence distortion node, which then could also be used for 2D texture mapping. Particle color support is done by Lukas, thanks!
2015-07-18 22:36:09 +02:00
}
}
Packed and generated images support for Cycles This commit adds support of packed and generated images for Cycles when using SVM backend. Movies are still not supported. This changes also doesn't touch OSL which is much less trivial to adopt for any images which are not saved to disk. Implementation details: - When adding images to Image Manager is now possible to mark image as builtin. Builtin images will bypass OIIO loader and will use special loading callbacks. - Callbacks are set by Blender Session and they're using C++ RNA interface to obtain needed data (pixels, dimensions, is_float flag). - Image Manager assumes file path is used as reference to a builtin images, but in fact currently image datablock name is used for reference. This makes it easy to find an image in BlendData database. - Added some extra properties to Image RNA: * channels, which denotes actual number of channels in ImBuf. This is needed to treat image's pixels correct (before it wasn't possible because API used internal number of channels for pixels which is in fact doesn't correlate with image depth) * is_float, which is truth if image is stored in float buffer of ImBuf. - Implemented string lookup for C++ RNA collections for cases there's no manual lookup function. OSL is not supported because it used own image loading and filtering routines and there's seems to be no API to feed pre-loaded pixels directly to the library. Think we'll either need to add some API to support such kind of feeding or consider OSL does not have support of packed images at all. Movies are not supported at this moment because of lack of RNA API to load specified frame. It's not difficult to solve, just need to consider what to best here: * Either write some general python interface for ImBuf and use it via C++ API, or * Write a PY API function which will return pixels for given frame, or * Use bad-level BKE_* call Anyway, small steps, further improvements later. Reviewed by Brecht, thanks!
2013-01-12 10:59:13 +00:00
return false;
}
Cycles: Resumable render implementation for Cycles This feature is also known by the name Samples Offset, which allows artists to render animation with given amount of samples N, but then render more samples, starting from N and ending with M (where M > N) and merge renders together as if they rendered exactly M samples. Surely such effect could be achieved by changing Seed variable, but that has possible issues with correlation artifacts and requiring to manually deal with per render layer samples and such. While we can't support all possible renderfarm-related features in Cycles it's nice to support really commonly used stuff. Here's a command how to run Blender with the new feature enabled: blender -- --cycles-resumable-num-chunks 24 --cycles-resumable-current-chunk 2 This command will divide samples range in 24 parts and render range #2 (chunk number is 1-based). This feature might be changed a bit after we'll do some tests here in the studio with it.
2016-03-30 15:55:12 +02:00
void BlenderSession::update_resumable_tile_manager(int num_samples)
{
const int num_resumable_chunks = BlenderSession::num_resumable_chunks,
current_resumable_chunk = BlenderSession::current_resumable_chunk;
if(num_resumable_chunks == 0) {
return;
}
int num_samples_per_chunk = (int)ceilf((float)num_samples / num_resumable_chunks);
int range_start_sample = num_samples_per_chunk * (current_resumable_chunk - 1);
int range_num_samples = num_samples_per_chunk;
if(range_start_sample + range_num_samples > num_samples) {
range_num_samples = num_samples - range_num_samples;
}
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
Cycles: Resumable render implementation for Cycles This feature is also known by the name Samples Offset, which allows artists to render animation with given amount of samples N, but then render more samples, starting from N and ending with M (where M > N) and merge renders together as if they rendered exactly M samples. Surely such effect could be achieved by changing Seed variable, but that has possible issues with correlation artifacts and requiring to manually deal with per render layer samples and such. While we can't support all possible renderfarm-related features in Cycles it's nice to support really commonly used stuff. Here's a command how to run Blender with the new feature enabled: blender -- --cycles-resumable-num-chunks 24 --cycles-resumable-current-chunk 2 This command will divide samples range in 24 parts and render range #2 (chunk number is 1-based). This feature might be changed a bit after we'll do some tests here in the studio with it.
2016-03-30 15:55:12 +02:00
VLOG(1) << "Samples range start is " << range_start_sample << ", "
<< "number of samples to render is " << range_num_samples;
session->tile_manager.range_start_sample = range_start_sample;
session->tile_manager.range_num_samples = range_num_samples;
}
CCL_NAMESPACE_END
Copy Permalink