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
74f7cdcf6bb8032b6bf8881007e0344366849859
blender-archive/intern/cycles/blender/blender_object.cpp

758 lines
22 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: Make all #include statements relative to cycles source directory The idea is to make include statements more explicit and obvious where the file is coming from, additionally reducing chance of wrong header being picked up. For example, it was not obvious whether bvh.h was refferring to builder or traversal, whenter node.h is a generic graph node or a shader node and cases like that. Surely this might look obvious for the active developers, but after some time of not touching the code it becomes less obvious where file is coming from. This was briefly mentioned in T50824 and seems @brecht is fine with such explicitness, but need to agree with all active developers before committing this. Please note that this patch is lacking changes related on GPU/OpenCL support. This will be solved if/when we all agree this is a good idea to move forward. Reviewers: brecht, lukasstockner97, maiself, nirved, dingto, juicyfruit, swerner Reviewed By: lukasstockner97, maiself, nirved, dingto Subscribers: brecht Differential Revision: https://developer.blender.org/D2586
2017-03-28 20:39:14 +02:00
#include "render/camera.h"
#include "render/integrator.h"
#include "render/graph.h"
#include "render/light.h"
#include "render/mesh.h"
#include "render/object.h"
#include "render/scene.h"
#include "render/nodes.h"
#include "render/particles.h"
#include "render/shader.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
Cycles: Make all #include statements relative to cycles source directory The idea is to make include statements more explicit and obvious where the file is coming from, additionally reducing chance of wrong header being picked up. For example, it was not obvious whether bvh.h was refferring to builder or traversal, whenter node.h is a generic graph node or a shader node and cases like that. Surely this might look obvious for the active developers, but after some time of not touching the code it becomes less obvious where file is coming from. This was briefly mentioned in T50824 and seems @brecht is fine with such explicitness, but need to agree with all active developers before committing this. Please note that this patch is lacking changes related on GPU/OpenCL support. This will be solved if/when we all agree this is a good idea to move forward. Reviewers: brecht, lukasstockner97, maiself, nirved, dingto, juicyfruit, swerner Reviewed By: lukasstockner97, maiself, nirved, dingto Subscribers: brecht Differential Revision: https://developer.blender.org/D2586
2017-03-28 20:39:14 +02:00
#include "blender/blender_object_cull.h"
#include "blender/blender_sync.h"
#include "blender/blender_util.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
Cycles: Make all #include statements relative to cycles source directory The idea is to make include statements more explicit and obvious where the file is coming from, additionally reducing chance of wrong header being picked up. For example, it was not obvious whether bvh.h was refferring to builder or traversal, whenter node.h is a generic graph node or a shader node and cases like that. Surely this might look obvious for the active developers, but after some time of not touching the code it becomes less obvious where file is coming from. This was briefly mentioned in T50824 and seems @brecht is fine with such explicitness, but need to agree with all active developers before committing this. Please note that this patch is lacking changes related on GPU/OpenCL support. This will be solved if/when we all agree this is a good idea to move forward. Reviewers: brecht, lukasstockner97, maiself, nirved, dingto, juicyfruit, swerner Reviewed By: lukasstockner97, maiself, nirved, dingto Subscribers: brecht Differential Revision: https://developer.blender.org/D2586
2017-03-28 20:39:14 +02:00
#include "util/util_foreach.h"
#include "util/util_hash.h"
#include "util/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
CCL_NAMESPACE_BEGIN
/* Utilities */
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
bool BlenderSync::BKE_object_is_modified(BL::Object& b_ob)
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
{
/* test if we can instance or if the object is modified */
Fix T38740: multi-user metaballs not rendering in Cycles.
2014-02-21 15:03:24 +01:00
if(b_ob.type() == BL::Object::type_META) {
/* multi-user and dupli metaballs are fused, can't instance */
return true;
}
else if(ccl::BKE_object_is_modified(b_ob, b_scene, preview)) {
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
/* modifiers */
return true;
}
else {
/* object level material links */
BL::Object::material_slots_iterator slot;
Cycles: fix some invalid memory access problems found by running the windows build in debug mode.
2011-08-21 10:32:15 +00:00
for(b_ob.material_slots.begin(slot); slot != b_ob.material_slots.end(); ++slot)
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(slot->link() == BL::MaterialSlot::link_OBJECT)
return true;
}
return 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
bool BlenderSync::object_is_mesh(BL::Object& b_ob)
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
{
BL::ID b_ob_data = b_ob.data();
Fix T52943: don't export curves objects with no faces to Cycles. Also skip any objects with zero ray visibility and meshes with zero faces.
2017-09-29 03:56:14 +02:00
if(!b_ob_data) {
return false;
}
if(b_ob.type() == BL::Object::type_CURVE) {
/* Skip exporting curves without faces, overhead can be
* significant if there are many for path animation. */
BL::Curve b_curve(b_ob.data());
return (b_curve.bevel_object() ||
b_curve.extrude() != 0.0f ||
b_curve.bevel_depth() != 0.0f ||
Fix T52981: 2D Curve shapes do not render untill extruded Regression since 9298c53.
2017-10-03 15:28:57 +05:00
b_curve.dimensions() == BL::Curve::dimensions_2D ||
Fix T52943: don't export curves objects with no faces to Cycles. Also skip any objects with zero ray visibility and meshes with zero faces.
2017-09-29 03:56:14 +02:00
b_ob.modifiers.length());
}
else {
return (b_ob_data.is_a(&RNA_Mesh) ||
b_ob_data.is_a(&RNA_Curve) ||
b_ob_data.is_a(&RNA_MetaBall));
}
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
bool BlenderSync::object_is_light(BL::Object& b_ob)
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
{
BL::ID b_ob_data = b_ob.data();
return (b_ob_data && b_ob_data.is_a(&RNA_Lamp));
}
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 uint object_ray_visibility(BL::Object& b_ob)
Cycles: * Add max diffuse/glossy/transmission bounces * Add separate min/max for transparent depth * Updated/added some presets that use these options * Add ray visibility options for objects, to hide them from camera/diffuse/glossy/transmission/shadow rays * Is singular ray output for light path node Details here: http://wiki.blender.org/index.php/Dev:2.5/Source/Render/Cycles/LightPaths
2011-09-01 15:53:36 +00:00
{
PointerRNA cvisibility = RNA_pointer_get(&b_ob.ptr, "cycles_visibility");
uint flag = 0;
flag |= get_boolean(cvisibility, "camera")? PATH_RAY_CAMERA: 0;
flag |= get_boolean(cvisibility, "diffuse")? PATH_RAY_DIFFUSE: 0;
flag |= get_boolean(cvisibility, "glossy")? PATH_RAY_GLOSSY: 0;
flag |= get_boolean(cvisibility, "transmission")? PATH_RAY_TRANSMIT: 0;
flag |= get_boolean(cvisibility, "shadow")? PATH_RAY_SHADOW: 0;
Cycles: Initial support for volume ray visibility. This adds a new "Volume Scatter" option to the "Ray Visibility" panels and can be used to e.g. exclude lamps from having an influence on the volume. See release logs for an example: http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.72/Cycles Differential revision: https://developer.blender.org/D771
2014-09-05 16:17:24 +02:00
flag |= get_boolean(cvisibility, "scatter")? PATH_RAY_VOLUME_SCATTER: 0;
Cycles: * Add max diffuse/glossy/transmission bounces * Add separate min/max for transparent depth * Updated/added some presets that use these options * Add ray visibility options for objects, to hide them from camera/diffuse/glossy/transmission/shadow rays * Is singular ray output for light path node Details here: http://wiki.blender.org/index.php/Dev:2.5/Source/Render/Cycles/LightPaths
2011-09-01 15:53:36 +00:00
return flag;
}
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
/* Light */
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 BlenderSync::sync_light(BL::Object& b_parent,
int persistent_id[OBJECT_PERSISTENT_ID_SIZE],
BL::Object& b_ob,
Cycles: Make per-object random value output also work for Lamps
2017-11-05 21:59:17 +01:00
BL::DupliObject& b_dupli_ob,
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
Transform& tfm,
bool *use_portal)
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
{
/* test if we need to sync */
Light *light;
Fix #33113: cycles not rendering motion blur correct with dying particles. There were a bunch of other issues with dupli motion blur and syncing, the problem being that there was no proper way to detect corresponding duplis between frames or updates. As a solution, a persistent_id was added to the DupliObject. It's an extension of the previous index value, with one index for each dupli level. This can be used to reliably find matching dupli objects between frames. Works with nested duplis, multiple particle systems, etc.
2012-11-08 16:35:28 +00:00
ObjectKey key(b_parent, persistent_id, b_ob);
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: Added support for light portals This patch adds support for light portals: objects that help sampling the environment light, therefore improving convergence. Using them tor other lights in a unidirectional pathtracer is virtually useless. The sampling is done with the area-preserving code already used for area lamps. MIS is used both for combination of different portals and for combining portal- and envmap-sampling. The direction of portals is considered, they aren't used if the sampling point is behind them. Reviewers: sergey, dingto, #cycles Reviewed By: dingto, #cycles Subscribers: Lapineige, nutel, jtheninja, dsisco11, januz, vitorbalbio, candreacchio, TARDISMaker, lichtwerk, ace_dragon, marcog, mib2berlin, Tunge, lopataasdf, lordodin, sergey, dingto Differential Revision: https://developer.blender.org/D1133
2015-04-28 00:51:55 +05:00
if(!light_map.sync(&light, b_ob, b_parent, key)) {
if(light->is_portal)
*use_portal = 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
return;
Cycles: Added support for light portals This patch adds support for light portals: objects that help sampling the environment light, therefore improving convergence. Using them tor other lights in a unidirectional pathtracer is virtually useless. The sampling is done with the area-preserving code already used for area lamps. MIS is used both for combination of different portals and for combining portal- and envmap-sampling. The direction of portals is considered, they aren't used if the sampling point is behind them. Reviewers: sergey, dingto, #cycles Reviewed By: dingto, #cycles Subscribers: Lapineige, nutel, jtheninja, dsisco11, januz, vitorbalbio, candreacchio, TARDISMaker, lichtwerk, ace_dragon, marcog, mib2berlin, Tunge, lopataasdf, lordodin, sergey, dingto Differential Revision: https://developer.blender.org/D1133
2015-04-28 00:51:55 +05:00
}
Cleanup: strip trailing space for cycles
2018-07-06 10:17:58 +02:00
Cycles: internal changes that should have no effect on user level yet, added shader flags for various purposes, and some code for light types other than points.
2011-09-27 20:37:24 +00:00
BL::Lamp b_lamp(b_ob.data());
/* type */
switch(b_lamp.type()) {
case BL::Lamp::type_POINT: {
BL::PointLamp b_point_lamp(b_lamp);
light->size = b_point_lamp.shadow_soft_size();
light->type = LIGHT_POINT;
break;
}
case BL::Lamp::type_SPOT: {
BL::SpotLamp b_spot_lamp(b_lamp);
light->size = b_spot_lamp.shadow_soft_size();
Cycles: spot lamp support.
2012-06-04 17:17:10 +00:00
light->type = LIGHT_SPOT;
light->spot_angle = b_spot_lamp.spot_size();
light->spot_smooth = b_spot_lamp.spot_blend();
Cycles: internal changes that should have no effect on user level yet, added shader flags for various purposes, and some code for light types other than points.
2011-09-27 20:37:24 +00:00
break;
}
case BL::Lamp::type_HEMI: {
light->type = LIGHT_DISTANT;
light->size = 0.0f;
break;
}
case BL::Lamp::type_SUN: {
BL::SunLamp b_sun_lamp(b_lamp);
light->size = b_sun_lamp.shadow_soft_size();
light->type = LIGHT_DISTANT;
break;
}
case BL::Lamp::type_AREA: {
BL::AreaLamp b_area_lamp(b_lamp);
light->size = 1.0f;
Cycles: multiple importance sampling for lamps, which helps reduce noise for big lamps and sharp glossy reflections. This was already supported for mesh lights and the background, so lamps should do it too. This is not for free and it's a bit slower than I hoped even though there is no extra BVH ray intersection. I'll try to optimize it more later. * Area lights look a bit different now, they had the wrong shape before. * Also fixes a sampling issue in the non-progressive integrator. * Only enabled for the CPU, will test on the GPU later. * An option to disable this will be added for situations where it does not help. Same time comparison before/after: http://www.pasteall.org/pic/show.php?id=43313 http://www.pasteall.org/pic/show.php?id=43314
2013-01-09 21:09:20 +00:00
light->axisu = transform_get_column(&tfm, 0);
light->axisv = transform_get_column(&tfm, 1);
Cycles: internal changes that should have no effect on user level yet, added shader flags for various purposes, and some code for light types other than points.
2011-09-27 20:37:24 +00:00
light->sizeu = b_area_lamp.size();
if(b_area_lamp.shape() == BL::AreaLamp::shape_RECTANGLE)
light->sizev = b_area_lamp.size_y();
else
light->sizev = light->sizeu;
light->type = LIGHT_AREA;
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
Cycles: * Sun, area and point lights with size now supported * Cast shadow option to disable shadow casting for lamps * Emission strength of materials tweaked such that setting strength to 1.0 basically makes the material "shadeless" in that the value of the color input will be the resulting color in the image.
2011-10-15 23:49:01 +00:00
/* location and (inverted!) direction */
Cycles: multiple importance sampling for lamps, which helps reduce noise for big lamps and sharp glossy reflections. This was already supported for mesh lights and the background, so lamps should do it too. This is not for free and it's a bit slower than I hoped even though there is no extra BVH ray intersection. I'll try to optimize it more later. * Area lights look a bit different now, they had the wrong shape before. * Also fixes a sampling issue in the non-progressive integrator. * Only enabled for the CPU, will test on the GPU later. * An option to disable this will be added for situations where it does not help. Same time comparison before/after: http://www.pasteall.org/pic/show.php?id=43313 http://www.pasteall.org/pic/show.php?id=43314
2013-01-09 21:09:20 +00:00
light->co = transform_get_column(&tfm, 3);
light->dir = -transform_get_column(&tfm, 2);
Cycles: Implement texture coordinates for Point, Spot and Area Lamps When using the Normal output of the Texture Coordinate node on Point and Spot lamps, the coordinates now depend on the rotation of the lamp. On Area lamps, the Parametric output of the Geometry node now returns UV coordinates on the area lamp. Credit for the Area lamp part goes to Stefan Werner (from D1995).
2016-10-29 18:54:42 +02:00
light->tfm = tfm;
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
/* shader */
Code refactor: use shader pointers rather than shader indexes.
2016-05-14 14:50:03 +02:00
vector<Shader*> used_shaders;
Fix #29555: cycles crash rendering with no material in material slot.
2011-12-09 00:24:48 +00:00
find_shader(b_lamp, used_shaders, scene->default_light);
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
light->shader = used_shaders[0];
Cycles: internal changes that should have no effect on user level yet, added shader flags for various purposes, and some code for light types other than points.
2011-09-27 20:37:24 +00:00
/* shadow */
Revert "Cycles: remove square samples option." This reverts commit 757c24b6bceaeeae95f743b72b6a7040880a0ebf. We'll revisit this when doing deeper sampling changes.
2017-08-20 23:46:05 +02:00
PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
Cycles: * Sun, area and point lights with size now supported * Cast shadow option to disable shadow casting for lamps * Emission strength of materials tweaked such that setting strength to 1.0 basically makes the material "shadeless" in that the value of the color input will be the resulting color in the image.
2011-10-15 23:49:01 +00:00
PointerRNA clamp = RNA_pointer_get(&b_lamp.ptr, "cycles");
light->cast_shadow = get_boolean(clamp, "cast_shadow");
Cycles: make multiple importance sampling for lamps an option per lamp now, disabled by default for backwards compatibility. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Integrator
2013-01-30 15:57:15 +00:00
light->use_mis = get_boolean(clamp, "use_multiple_importance_sampling");
Cleanup: strip trailing space for cycles
2018-07-06 10:17:58 +02:00
Revert "Cycles: remove square samples option." This reverts commit 757c24b6bceaeeae95f743b72b6a7040880a0ebf. We'll revisit this when doing deeper sampling changes.
2017-08-20 23:46:05 +02:00
int samples = get_int(clamp, "samples");
if(get_boolean(cscene, "use_square_samples"))
light->samples = samples * samples;
else
light->samples = samples;
Cycles: internal changes that should have no effect on user level yet, added shader flags for various purposes, and some code for light types other than points.
2011-09-27 20:37:24 +00:00
Cycles: Add "Max Bounce" control for lamps With this setting, we can limit the influence of a lamp to a certain amount of bounces. 0 = Only direct light contribution 1 = 1 light bounce ... Differential revision: https://developer.blender.org/D860 You can find an example render in the release logs: http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.73/Cycles
2014-11-05 22:48:45 +01:00
light->max_bounces = get_int(clamp, "max_bounces");
Cycles: Make per-object random value output also work for Lamps
2017-11-05 21:59:17 +01:00
if(b_dupli_ob) {
light->random_id = b_dupli_ob.random_id();
}
else {
light->random_id = hash_int_2d(hash_string(b_ob.name().c_str()), 0);
}
Cycles: Added support for light portals This patch adds support for light portals: objects that help sampling the environment light, therefore improving convergence. Using them tor other lights in a unidirectional pathtracer is virtually useless. The sampling is done with the area-preserving code already used for area lamps. MIS is used both for combination of different portals and for combining portal- and envmap-sampling. The direction of portals is considered, they aren't used if the sampling point is behind them. Reviewers: sergey, dingto, #cycles Reviewed By: dingto, #cycles Subscribers: Lapineige, nutel, jtheninja, dsisco11, januz, vitorbalbio, candreacchio, TARDISMaker, lichtwerk, ace_dragon, marcog, mib2berlin, Tunge, lopataasdf, lordodin, sergey, dingto Differential Revision: https://developer.blender.org/D1133
2015-04-28 00:51:55 +05:00
if(light->type == LIGHT_AREA)
light->is_portal = get_boolean(clamp, "is_portal");
else
light->is_portal = false;
if(light->is_portal)
*use_portal = true;
Cycles: ray visibility options now work for lamps and mesh lights, with and without multiple importance sampling, so you can disable them for diffuse/glossy/transmission. The Light Path node here is still weak and does not give this info. To make that work we'd need to evaluate the shader multiple times which is slow and we can't detect well enough when it is actually needed.
2013-06-07 18:59:23 +00:00
/* visibility */
uint visibility = object_ray_visibility(b_ob);
light->use_diffuse = (visibility & PATH_RAY_DIFFUSE) != 0;
light->use_glossy = (visibility & PATH_RAY_GLOSSY) != 0;
light->use_transmission = (visibility & PATH_RAY_TRANSMIT) != 0;
Cycles: Initial support for volume ray visibility. This adds a new "Volume Scatter" option to the "Ray Visibility" panels and can be used to e.g. exclude lamps from having an influence on the volume. See release logs for an example: http://wiki.blender.org/index.php/Dev:Ref/Release_Notes/2.72/Cycles Differential revision: https://developer.blender.org/D771
2014-09-05 16:17:24 +02:00
light->use_scatter = (visibility & PATH_RAY_VOLUME_SCATTER) != 0;
Cycles: ray visibility options now work for lamps and mesh lights, with and without multiple importance sampling, so you can disable them for diffuse/glossy/transmission. The Light Path node here is still weak and does not give this info. To make that work we'd need to evaluate the shader multiple times which is slow and we can't detect well enough when it is actually needed.
2013-06-07 18:59:23 +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
/* tag */
light->tag_update(scene);
}
Cycles: Added support for light portals This patch adds support for light portals: objects that help sampling the environment light, therefore improving convergence. Using them tor other lights in a unidirectional pathtracer is virtually useless. The sampling is done with the area-preserving code already used for area lamps. MIS is used both for combination of different portals and for combining portal- and envmap-sampling. The direction of portals is considered, they aren't used if the sampling point is behind them. Reviewers: sergey, dingto, #cycles Reviewed By: dingto, #cycles Subscribers: Lapineige, nutel, jtheninja, dsisco11, januz, vitorbalbio, candreacchio, TARDISMaker, lichtwerk, ace_dragon, marcog, mib2berlin, Tunge, lopataasdf, lordodin, sergey, dingto Differential Revision: https://developer.blender.org/D1133
2015-04-28 00:51:55 +05:00
void BlenderSync::sync_background_light(bool use_portal)
Sample as Lamp option for world shaders, to enable multiple importance sampling. By default lighting from the world is computed solely with indirect light sampling. However for more complex environment maps this can be too noisy, as sampling the BSDF may not easily find the highlights in the environment map image. By enabling this option, the world background will be sampled as a lamp, with lighter parts automatically given more samples. Map Resolution specifies the size of the importance map (res x res). Before rendering starts, an importance map is generated by "baking" a grayscale image from the world shader. This will then be used to determine which parts of the background are light and so should receive more samples than darker parts. Higher resolutions will result in more accurate sampling but take more setup time and memory. Patch by Mike Farnsworth, thanks!
2012-01-20 17:49:17 +00:00
{
BL::World b_world = b_scene.world();
Fix #29935: missing cycles update/crash when removing world datablock form scene.
2012-01-22 13:56:39 +00:00
if(b_world) {
Revert "Cycles: remove square samples option." This reverts commit 757c24b6bceaeeae95f743b72b6a7040880a0ebf. We'll revisit this when doing deeper sampling changes.
2017-08-20 23:46:05 +02:00
PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
Fix #29935: missing cycles update/crash when removing world datablock form scene.
2012-01-22 13:56:39 +00:00
PointerRNA cworld = RNA_pointer_get(&b_world.ptr, "cycles");
Cycles: Automatically detect HDRI resolution by default and use non-square sampling map The automatic mode checks all Enviroment Texture nodes and picks the largest image's resolution. If there are no Enviroment Textures, it just uses the old default. Also, the sampling map now isn't limited to square shapes. The automatic detection uses the exact image size, the manual UI option now halves the value to get the height. A default aspect ratio of 2:1 makes sense since this is what most HDRIs use. Reviewers: brecht, sergey Differential Revision: https://developer.blender.org/D3477
2018-06-14 16:18:34 +02:00
enum SamplingMethod {
SAMPLING_NONE = 0,
SAMPLING_AUTOMATIC,
SAMPLING_MANUAL,
SAMPLING_NUM
};
int sampling_method = get_enum(cworld, "sampling_method", SAMPLING_NUM, SAMPLING_AUTOMATIC);
bool sample_as_light = (sampling_method != SAMPLING_NONE);
Fix #29935: missing cycles update/crash when removing world datablock form scene.
2012-01-22 13:56:39 +00:00
Cycles: Added support for light portals This patch adds support for light portals: objects that help sampling the environment light, therefore improving convergence. Using them tor other lights in a unidirectional pathtracer is virtually useless. The sampling is done with the area-preserving code already used for area lamps. MIS is used both for combination of different portals and for combining portal- and envmap-sampling. The direction of portals is considered, they aren't used if the sampling point is behind them. Reviewers: sergey, dingto, #cycles Reviewed By: dingto, #cycles Subscribers: Lapineige, nutel, jtheninja, dsisco11, januz, vitorbalbio, candreacchio, TARDISMaker, lichtwerk, ace_dragon, marcog, mib2berlin, Tunge, lopataasdf, lordodin, sergey, dingto Differential Revision: https://developer.blender.org/D1133
2015-04-28 00:51:55 +05:00
if(sample_as_light || use_portal) {
Fix #29935: missing cycles update/crash when removing world datablock form scene.
2012-01-22 13:56:39 +00:00
/* test if we need to sync */
Light *light;
ObjectKey key(b_world, 0, b_world);
if(light_map.sync(&light, b_world, b_world, key) ||
Cycles: Cleanup, indentation and braces
2016-02-03 15:00:55 +01:00
world_recalc ||
b_world.ptr.data != world_map)
Fix #29935: missing cycles update/crash when removing world datablock form scene.
2012-01-22 13:56:39 +00:00
{
light->type = LIGHT_BACKGROUND;
Cycles: Automatically detect HDRI resolution by default and use non-square sampling map The automatic mode checks all Enviroment Texture nodes and picks the largest image's resolution. If there are no Enviroment Textures, it just uses the old default. Also, the sampling map now isn't limited to square shapes. The automatic detection uses the exact image size, the manual UI option now halves the value to get the height. A default aspect ratio of 2:1 makes sense since this is what most HDRIs use. Reviewers: brecht, sergey Differential Revision: https://developer.blender.org/D3477
2018-06-14 16:18:34 +02:00
if(sampling_method == SAMPLING_MANUAL) {
light->map_resolution = get_int(cworld, "sample_map_resolution");
}
else {
light->map_resolution = 0;
}
Fix #29935: missing cycles update/crash when removing world datablock form scene.
2012-01-22 13:56:39 +00:00
light->shader = scene->default_background;
Cycles: Added support for light portals This patch adds support for light portals: objects that help sampling the environment light, therefore improving convergence. Using them tor other lights in a unidirectional pathtracer is virtually useless. The sampling is done with the area-preserving code already used for area lamps. MIS is used both for combination of different portals and for combining portal- and envmap-sampling. The direction of portals is considered, they aren't used if the sampling point is behind them. Reviewers: sergey, dingto, #cycles Reviewed By: dingto, #cycles Subscribers: Lapineige, nutel, jtheninja, dsisco11, januz, vitorbalbio, candreacchio, TARDISMaker, lichtwerk, ace_dragon, marcog, mib2berlin, Tunge, lopataasdf, lordodin, sergey, dingto Differential Revision: https://developer.blender.org/D1133
2015-04-28 00:51:55 +05:00
light->use_mis = sample_as_light;
Cycles: Expose "Max Bounces" for the world light. When using MIS, the world is treated as regular light and in this case we can now also limit the maximum amount of bounces, the background light will contribute to the scene. This can improve performance in some cases, where it's e.g. sufficient to only have a contribution on first 1-2 bounces. Examples can be found in the differential. Differential revision: https://developer.blender.org/D1399
2015-07-12 17:56:54 +02:00
light->max_bounces = get_int(cworld, "max_bounces");
Cycles: Added support for light portals This patch adds support for light portals: objects that help sampling the environment light, therefore improving convergence. Using them tor other lights in a unidirectional pathtracer is virtually useless. The sampling is done with the area-preserving code already used for area lamps. MIS is used both for combination of different portals and for combining portal- and envmap-sampling. The direction of portals is considered, they aren't used if the sampling point is behind them. Reviewers: sergey, dingto, #cycles Reviewed By: dingto, #cycles Subscribers: Lapineige, nutel, jtheninja, dsisco11, januz, vitorbalbio, candreacchio, TARDISMaker, lichtwerk, ace_dragon, marcog, mib2berlin, Tunge, lopataasdf, lordodin, sergey, dingto Differential Revision: https://developer.blender.org/D1133
2015-04-28 00:51:55 +05:00
Revert "Cycles: remove square samples option." This reverts commit 757c24b6bceaeeae95f743b72b6a7040880a0ebf. We'll revisit this when doing deeper sampling changes.
2017-08-20 23:46:05 +02:00
int samples = get_int(cworld, "samples");
if(get_boolean(cscene, "use_square_samples"))
light->samples = samples * samples;
else
light->samples = samples;
Fix #29935: missing cycles update/crash when removing world datablock form scene.
2012-01-22 13:56:39 +00:00
light->tag_update(scene);
light_map.set_recalc(b_world);
}
Sample as Lamp option for world shaders, to enable multiple importance sampling. By default lighting from the world is computed solely with indirect light sampling. However for more complex environment maps this can be too noisy, as sampling the BSDF may not easily find the highlights in the environment map image. By enabling this option, the world background will be sampled as a lamp, with lighter parts automatically given more samples. Map Resolution specifies the size of the importance map (res x res). Before rendering starts, an importance map is generated by "baking" a grayscale image from the world shader. This will then be used to determine which parts of the background are light and so should receive more samples than darker parts. Higher resolutions will result in more accurate sampling but take more setup time and memory. Patch by Mike Farnsworth, thanks!
2012-01-20 17:49:17 +00:00
}
}
world_map = b_world.ptr.data;
world_recalc = false;
}
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
/* Object */
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
Object *BlenderSync::sync_object(BL::Object& b_parent,
Cycles: Camera frustum space object culling scene simplification The idea is to give artists a simplier way to control memory usage in such scenes as grass fields by doing automatic object culling based on whether object is visible in the frame or not. This is controlled on per-object level. In order to use this option few steps are required: - Enable Simplify in scene settings - Enable Camera Cull option in the Simplify panel - Set camera cull margin (measured in relative value to the render resolution) This setting is used to avoid possible flickering caused by changes in shadow which are cast by objects outside of the frame. - Enable Camera Cull for objects which are desired to be culled (object culling option could be found in Option panel in object buttons). There is still room for improvements, but this worked quite well during Gooseberry open movie project, so think it's useful feature even in it's current non-ideal state.
2015-04-10 18:09:58 +05:00
int persistent_id[OBJECT_PERSISTENT_ID_SIZE],
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::DupliObject& b_dupli_ob,
Cycles: Camera frustum space object culling scene simplification The idea is to give artists a simplier way to control memory usage in such scenes as grass fields by doing automatic object culling based on whether object is visible in the frame or not. This is controlled on per-object level. In order to use this option few steps are required: - Enable Simplify in scene settings - Enable Camera Cull option in the Simplify panel - Set camera cull margin (measured in relative value to the render resolution) This setting is used to avoid possible flickering caused by changes in shadow which are cast by objects outside of the frame. - Enable Camera Cull for objects which are desired to be culled (object culling option could be found in Option panel in object buttons). There is still room for improvements, but this worked quite well during Gooseberry open movie project, so think it's useful feature even in it's current non-ideal state.
2015-04-10 18:09:58 +05:00
Transform& tfm,
uint layer_flag,
float motion_time,
bool hide_tris,
Cycles: refactor culling code into utility class.
2016-11-13 00:45:16 +01:00
BlenderObjectCulling& culling,
Cycles: Camera frustum space object culling scene simplification The idea is to give artists a simplier way to control memory usage in such scenes as grass fields by doing automatic object culling based on whether object is visible in the frame or not. This is controlled on per-object level. In order to use this option few steps are required: - Enable Simplify in scene settings - Enable Camera Cull option in the Simplify panel - Set camera cull margin (measured in relative value to the render resolution) This setting is used to avoid possible flickering caused by changes in shadow which are cast by objects outside of the frame. - Enable Camera Cull for objects which are desired to be culled (object culling option could be found in Option panel in object buttons). There is still room for improvements, but this worked quite well during Gooseberry open movie project, so think it's useful feature even in it's current non-ideal state.
2015-04-10 18:09:58 +05:00
bool *use_portal)
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: add "From Dupli" option for texture coordinate node. This gets the Generated and UV coordinates from the duplicator of instance instead of the object itself. This was used in e.g. Big Buck Bunny for texturing instanced feathers with a UV map on the bird. Many files changed, mainly to do some refactoring to get rid of G.rendering global in duplilist code.
2012-10-04 21:40:39 +00:00
BL::Object b_ob = (b_dupli_ob ? b_dupli_ob.object() : b_parent);
Cycles code refactor: improve vertex motion attribute storage and export. This now supports multiple steps and subframe sampling of motion. There is one difference for object and camera transform motion blur. It still only supports two steps there, but the transforms are now sampled at subframe times instead of the previous and next frame and then interpolated/extrapolated. This will give different render results in some cases but it's more accurate. Part of the code is from the summer of code project by Gavin Howard, but it has been significantly rewritten and extended.
2014-03-29 13:03:46 +01:00
bool motion = motion_time != 0.0f;
Cleanup: strip trailing space for cycles
2018-07-06 10:17:58 +02: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
/* light is handled separately */
if(object_is_light(b_ob)) {
Fix #35733: lamps on render layers that are both excluded and used for masking should not be used, same as emissive meshes.
2013-06-13 13:09:32 +00:00
/* don't use lamps for excluded layers used as mask layer */
if(!motion && !((layer_flag & render_layer.holdout_layer) && (layer_flag & render_layer.exclude_layer)))
Cycles: Make per-object random value output also work for Lamps
2017-11-05 21:59:17 +01:00
sync_light(b_parent, persistent_id, b_ob, b_dupli_ob, tfm, use_portal);
Fix #33113: cycles not rendering motion blur correct with dying particles. There were a bunch of other issues with dupli motion blur and syncing, the problem being that there was no proper way to detect corresponding duplis between frames or updates. As a solution, a persistent_id was added to the DupliObject. It's an extension of the previous index value, with one index for each dupli level. This can be used to reliably find matching dupli objects between frames. Works with nested duplis, multiple particle systems, etc.
2012-11-08 16:35:28 +00:00
return 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
}
/* only interested in object that we can create meshes from */
Cycles: refactor culling code into utility class.
2016-11-13 00:45:16 +01:00
if(!object_is_mesh(b_ob)) {
Fix #33113: cycles not rendering motion blur correct with dying particles. There were a bunch of other issues with dupli motion blur and syncing, the problem being that there was no proper way to detect corresponding duplis between frames or updates. As a solution, a persistent_id was added to the DupliObject. It's an extension of the previous index value, with one index for each dupli level. This can be used to reliably find matching dupli objects between frames. Works with nested duplis, multiple particle systems, etc.
2012-11-08 16:35:28 +00:00
return NULL;
Cycles: refactor culling code into utility class.
2016-11-13 00:45:16 +01: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: distance culling for objects. This can be used together with camera culling to keep nearby objects visible in reflections, using a minimum distance within which objects are visible. It is also useful to cull small objects far from the camera. Reviewed By: brecht Differential Revision: https://developer.blender.org/D2332
2016-11-13 00:16:50 +01:00
/* Perform object culling. */
Cycles: refactor culling code into utility class.
2016-11-13 00:45:16 +01:00
if(culling.test(scene, b_ob, tfm)) {
Cycles: Camera frustum space object culling scene simplification The idea is to give artists a simplier way to control memory usage in such scenes as grass fields by doing automatic object culling based on whether object is visible in the frame or not. This is controlled on per-object level. In order to use this option few steps are required: - Enable Simplify in scene settings - Enable Camera Cull option in the Simplify panel - Set camera cull margin (measured in relative value to the render resolution) This setting is used to avoid possible flickering caused by changes in shadow which are cast by objects outside of the frame. - Enable Camera Cull for objects which are desired to be culled (object culling option could be found in Option panel in object buttons). There is still room for improvements, but this worked quite well during Gooseberry open movie project, so think it's useful feature even in it's current non-ideal state.
2015-04-10 18:09:58 +05:00
return NULL;
}
Fix T52943: don't export curves objects with no faces to Cycles. Also skip any objects with zero ray visibility and meshes with zero faces.
2017-09-29 03:56:14 +02:00
/* Visibility flags for both parent and child. */
Cycles: add object level holdout property. This works the same as the holdout shader and Z mask layer. Combined with overrides in 2.8 this is intended to replace the Z mask layer bits.
2017-11-18 06:06:27 +01:00
PointerRNA cobject = RNA_pointer_get(&b_ob.ptr, "cycles");
bool use_holdout = (layer_flag & render_layer.holdout_layer) != 0 ||
get_boolean(cobject, "is_holdout");
Fix T52943: don't export curves objects with no faces to Cycles. Also skip any objects with zero ray visibility and meshes with zero faces.
2017-09-29 03:56:14 +02:00
uint visibility = object_ray_visibility(b_ob) & PATH_RAY_ALL_VISIBILITY;
if(b_parent.ptr.data != b_ob.ptr.data) {
visibility &= object_ray_visibility(b_parent);
}
/* Make holdout objects on excluded layer invisible for non-camera rays. */
if(use_holdout && (layer_flag & render_layer.exclude_layer)) {
visibility &= ~(PATH_RAY_ALL_VISIBILITY - PATH_RAY_CAMERA);
}
/* Hide objects not on render layer from camera rays. */
if(!(layer_flag & render_layer.layer)) {
visibility &= ~PATH_RAY_CAMERA;
}
/* Don't export completely invisible objects. */
if(visibility == 0) {
return NULL;
}
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
/* key to lookup object */
Fix #33113: cycles not rendering motion blur correct with dying particles. There were a bunch of other issues with dupli motion blur and syncing, the problem being that there was no proper way to detect corresponding duplis between frames or updates. As a solution, a persistent_id was added to the DupliObject. It's an extension of the previous index value, with one index for each dupli level. This can be used to reliably find matching dupli objects between frames. Works with nested duplis, multiple particle systems, etc.
2012-11-08 16:35:28 +00:00
ObjectKey key(b_parent, persistent_id, b_ob);
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
Object *object;
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
/* motion vector case */
if(motion) {
object = object_map.find(key);
Cycles: support arbitrary number of motion blur steps for objects.
2018-03-08 04:04:52 +01:00
if(object && object->use_motion()) {
/* Set transform at matching motion time step. */
int time_index = object->motion_step(motion_time);
if(time_index >= 0) {
object->motion[time_index] = tfm;
Cycles: fix objects disappearing when starting or stopping movement. Another issue with the modified particle motion blur fix: since pre and post are used as validity markers, they must be set even if there is no actual motion, like the original bool flags were. Otherwise an object starting to move or stopping is interpreted as having invalid blur data and hidden.
2016-08-07 22:41:35 +03:00
}
Cycles code refactor: improve vertex motion attribute storage and export. This now supports multiple steps and subframe sampling of motion. There is one difference for object and camera transform motion blur. It still only supports two steps there, but the transforms are now sampled at subframe times instead of the previous and next frame and then interpolated/extrapolated. This will give different render results in some cases but it's more accurate. Part of the code is from the summer of code project by Gavin Howard, but it has been significantly rewritten and extended.
2014-03-29 13:03:46 +01:00
/* mesh deformation */
if(object->mesh)
sync_mesh_motion(b_ob, object, motion_time);
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
}
Fix #33113: cycles not rendering motion blur correct with dying particles. There were a bunch of other issues with dupli motion blur and syncing, the problem being that there was no proper way to detect corresponding duplis between frames or updates. As a solution, a persistent_id was added to the DupliObject. It's an extension of the previous index value, with one index for each dupli level. This can be used to reliably find matching dupli objects between frames. Works with nested duplis, multiple particle systems, etc.
2012-11-08 16:35:28 +00:00
return object;
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
}
/* test if we need to 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
bool object_updated = false;
Cycles: * Fix object scaling update issue with interactive rendering + static BVH. * Fix negative scaling issue with static BVH. * Fix #29217: excessive fireflies in first sample.
2011-11-12 14:29:52 +00:00
if(object_map.sync(&object, b_ob, b_parent, key))
object_updated = true;
Cleanup: strip trailing space for cycles
2018-07-06 10:17:58 +02:00
Cycles: * Fix object scaling update issue with interactive rendering + static BVH. * Fix negative scaling issue with static BVH. * Fix #29217: excessive fireflies in first sample.
2011-11-12 14:29:52 +00:00
/* mesh sync */
New feature Patch [#33445] - Experimental Cycles Hair Rendering (CPU only) This patch allows hair data to be exported to cycles and introduces a new line segment primitive to render with. The UI appears under the particle tab and there is a new hair info node available. It is only available under the experimental feature set and for cpu rendering.
2012-12-28 14:21:30 +00:00
object->mesh = sync_mesh(b_ob, object_updated, hide_tris);
Fix #31168: cycles mask layer should only affect objects for camera rays. Fix: texture coordinate normal output was not correct, still changed under object transform.
2012-05-02 09:33:45 +00:00
Fix T37303, Fix T37163: cycles mask layers that are also excluded not rendering correct with multiple render layers. This case is somewhat weak, we now do a few more checks on sync than I would like, but it's not too bad.
2013-11-26 20:34:29 +01:00
/* special case not tracked by object update flags */
/* holdout */
Fix #31168: cycles mask layer should only affect objects for camera rays. Fix: texture coordinate normal output was not correct, still changed under object transform.
2012-05-02 09:33:45 +00:00
if(use_holdout != object->use_holdout) {
object->use_holdout = use_holdout;
scene->object_manager->tag_update(scene);
Fix #33131: more useful cycles behavior for layers that are both marked excluded and as mask layer. Now it will still use the mask, and have no further influence rather than just being excluded entirely.
2012-11-09 23:28:51 +00:00
object_updated = true;
Fix #31168: cycles mask layer should only affect objects for camera rays. Fix: texture coordinate normal output was not correct, still changed under object transform.
2012-05-02 09:33:45 +00:00
}
Cycles: * Fix object scaling update issue with interactive rendering + static BVH. * Fix negative scaling issue with static BVH. * Fix #29217: excessive fireflies in first sample.
2011-11-12 14:29:52 +00:00
Fix T37303, Fix T37163: cycles mask layers that are also excluded not rendering correct with multiple render layers. This case is somewhat weak, we now do a few more checks on sync than I would like, but it's not too bad.
2013-11-26 20:34:29 +01:00
if(visibility != object->visibility) {
object->visibility = visibility;
object_updated = true;
}
Cycles: First implementation of shadow catcher It uses an idea of accumulating all possible light reachable across the light path (without taking shadow blocked into account) and accumulating total shaded light across the path. Dividing second figure by first one seems to be giving good estimate of the shadow. In fact, to my knowledge, it's something really similar to what is happening in the denoising branch, so we are aligned here which is good. The workflow is following: - Create an object which matches real-life object on which shadow is to be catched. - Create approximate similar material on that object. This is needed to make indirect light properly affecting CG objects in the scene. - Mark object as Shadow Catcher in the Object properties. Ideally, after doing that it will be possible to render the image and simply alpha-over it on top of real footage.
2017-02-09 14:19:01 +01:00
bool is_shadow_catcher = get_boolean(cobject, "is_shadow_catcher");
if(is_shadow_catcher != object->is_shadow_catcher) {
object->is_shadow_catcher = is_shadow_catcher;
object_updated = true;
}
Fix #33113: cycles not rendering motion blur correct with dying particles. There were a bunch of other issues with dupli motion blur and syncing, the problem being that there was no proper way to detect corresponding duplis between frames or updates. As a solution, a persistent_id was added to the DupliObject. It's an extension of the previous index value, with one index for each dupli level. This can be used to reliably find matching dupli objects between frames. Works with nested duplis, multiple particle systems, etc.
2012-11-08 16:35:28 +00:00
/* object sync
* transform comparison should not be needed, but duplis don't work perfect
Fix #32144: cycles viewport missing update with dupliverts. Ideally this would be fixed in the dependency graph so it gives a proper signal but that would need a bigger refactor.
2012-09-03 13:18:23 +00:00
* in the depsgraph and may not signal changes, so this is a workaround */
if(object_updated || (object->mesh && object->mesh->need_update) || tfm != object->tfm) {
Cycles: fix a few more msvc issues with empty scenes and ustring setting.
2011-10-03 17:42:24 +00:00
object->name = b_ob.name().c_str();
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
object->pass_id = b_ob.pass_index();
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
object->tfm = tfm;
Cycles: support arbitrary number of motion blur steps for objects.
2018-03-08 04:04:52 +01:00
object->motion.clear();
Cycles: code refactoring, to do render layer visibility test a bit different, replacing the camera visibility flag with object layer flags.
2011-12-21 20:51:43 +00:00
Cycles code refactor: improve vertex motion attribute storage and export. This now supports multiple steps and subframe sampling of motion. There is one difference for object and camera transform motion blur. It still only supports two steps there, but the transforms are now sampled at subframe times instead of the previous and next frame and then interpolated/extrapolated. This will give different render results in some cases but it's more accurate. Part of the code is from the summer of code project by Gavin Howard, but it has been significantly rewritten and extended.
2014-03-29 13:03:46 +01:00
/* motion blur */
Cycles: support arbitrary number of motion blur steps for objects.
2018-03-08 04:04:52 +01:00
Scene::MotionType need_motion = scene->need_motion();
if(need_motion != Scene::MOTION_NONE && object->mesh) {
Cycles code refactor: improve vertex motion attribute storage and export. This now supports multiple steps and subframe sampling of motion. There is one difference for object and camera transform motion blur. It still only supports two steps there, but the transforms are now sampled at subframe times instead of the previous and next frame and then interpolated/extrapolated. This will give different render results in some cases but it's more accurate. Part of the code is from the summer of code project by Gavin Howard, but it has been significantly rewritten and extended.
2014-03-29 13:03:46 +01:00
Mesh *mesh = object->mesh;
Cycles: add per object options to disable motion blur and set deformation motion steps. Notes: * The motion steps only affect deformation motion blur. * The actual number of steps is 2^(steps - 1). This avoids having to sample at many different times for object with more/fewer steps, now the times overlap. * Deformation motion blur is enabled by default in existing files that have motion blur enabled. If the object is not deforming, this will be detected at export time, so raytracing performance will not be affected. Part of the code is from the summer of code project by Gavin Howard.
2014-03-29 13:03:47 +01:00
mesh->use_motion_blur = false;
Cycles: support arbitrary number of motion blur steps for objects.
2018-03-08 04:04:52 +01:00
mesh->motion_steps = 0;
uint motion_steps;
Cycles: add per object options to disable motion blur and set deformation motion steps. Notes: * The motion steps only affect deformation motion blur. * The actual number of steps is 2^(steps - 1). This avoids having to sample at many different times for object with more/fewer steps, now the times overlap. * Deformation motion blur is enabled by default in existing files that have motion blur enabled. If the object is not deforming, this will be detected at export time, so raytracing performance will not be affected. Part of the code is from the summer of code project by Gavin Howard.
2014-03-29 13:03:47 +01:00
Cycles: support arbitrary number of motion blur steps for objects.
2018-03-08 04:04:52 +01:00
if(scene->need_motion() == Scene::MOTION_BLUR) {
motion_steps = object_motion_steps(b_parent, b_ob);
Fix T54299: crash rendering objects with motion blur disabled, after recent changes.
2018-03-12 17:33:46 +01:00
if(motion_steps && object_use_deform_motion(b_parent, b_ob)) {
Cycles: support arbitrary number of motion blur steps for objects.
2018-03-08 04:04:52 +01:00
mesh->motion_steps = motion_steps;
Cycles: add support for mesh deformation motion blur.
2014-03-29 13:03:47 +01:00
mesh->use_motion_blur = true;
}
Cycles: support arbitrary number of motion blur steps for objects.
2018-03-08 04:04:52 +01:00
}
else {
motion_steps = 3;
mesh->motion_steps = motion_steps;
}
Cycles code refactor: improve vertex motion attribute storage and export. This now supports multiple steps and subframe sampling of motion. There is one difference for object and camera transform motion blur. It still only supports two steps there, but the transforms are now sampled at subframe times instead of the previous and next frame and then interpolated/extrapolated. This will give different render results in some cases but it's more accurate. Part of the code is from the summer of code project by Gavin Howard, but it has been significantly rewritten and extended.
2014-03-29 13:03:46 +01:00
Fix T55626, fix T55106: Cycles motion blur + persistent images bug.
2018-07-01 16:31:46 +02:00
object->motion.clear();
Cycles: support arbitrary number of motion blur steps for objects.
2018-03-08 04:04:52 +01:00
object->motion.resize(motion_steps, transform_empty());
Fix T54299: crash rendering objects with motion blur disabled, after recent changes.
2018-03-12 17:33:46 +01:00
if(motion_steps) {
object->motion[motion_steps/2] = tfm;
for(size_t step = 0; step < motion_steps; step++) {
motion_times.insert(object->motion_time(step));
}
Cycles code refactor: improve vertex motion attribute storage and export. This now supports multiple steps and subframe sampling of motion. There is one difference for object and camera transform motion blur. It still only supports two steps there, but the transforms are now sampled at subframe times instead of the previous and next frame and then interpolated/extrapolated. This will give different render results in some cases but it's more accurate. Part of the code is from the summer of code project by Gavin Howard, but it has been significantly rewritten and extended.
2014-03-29 13:03:46 +01:00
}
}
Object Info node support for GLSL mode and the internal render Object Info node can be useful to give some variation to a single material assigned to multiple instances. This patch adds support for Viewport and BI. {F499530} Example: {F499528} Reviewers: merwin, brecht, dfelinto Reviewed By: brecht Subscribers: duarteframos, fclem, homyachetser, Evgeny_Rodygin, AlexKowel, yurikovelenov Differential Revision: https://developer.blender.org/D2425
2017-04-14 18:13:44 +03:00
/* dupli texture coordinates and random_id */
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_dupli_ob) {
Fix #36037: cycles from dupli generated texture coordinates were wrong, should have been normalized to 0..1 range.
2013-07-07 10:39:56 +00:00
object->dupli_generated = 0.5f*get_float3(b_dupli_ob.orco()) - make_float3(0.5f, 0.5f, 0.5f);
Cycles: add "From Dupli" option for texture coordinate node. This gets the Generated and UV coordinates from the duplicator of instance instead of the object itself. This was used in e.g. Big Buck Bunny for texturing instanced feathers with a UV map on the bird. Many files changed, mainly to do some refactoring to get rid of G.rendering global in duplilist code.
2012-10-04 21:40:39 +00:00
object->dupli_uv = get_float2(b_dupli_ob.uv());
Object Info node support for GLSL mode and the internal render Object Info node can be useful to give some variation to a single material assigned to multiple instances. This patch adds support for Viewport and BI. {F499530} Example: {F499528} Reviewers: merwin, brecht, dfelinto Reviewed By: brecht Subscribers: duarteframos, fclem, homyachetser, Evgeny_Rodygin, AlexKowel, yurikovelenov Differential Revision: https://developer.blender.org/D2425
2017-04-14 18:13:44 +03:00
object->random_id = b_dupli_ob.random_id();
Cycles: add "From Dupli" option for texture coordinate node. This gets the Generated and UV coordinates from the duplicator of instance instead of the object itself. This was used in e.g. Big Buck Bunny for texturing instanced feathers with a UV map on the bird. Many files changed, mainly to do some refactoring to get rid of G.rendering global in duplilist code.
2012-10-04 21:40:39 +00:00
}
else {
object->dupli_generated = make_float3(0.0f, 0.0f, 0.0f);
object->dupli_uv = make_float2(0.0f, 0.0f);
Object Info node support for GLSL mode and the internal render Object Info node can be useful to give some variation to a single material assigned to multiple instances. This patch adds support for Viewport and BI. {F499530} Example: {F499528} Reviewers: merwin, brecht, dfelinto Reviewed By: brecht Subscribers: duarteframos, fclem, homyachetser, Evgeny_Rodygin, AlexKowel, yurikovelenov Differential Revision: https://developer.blender.org/D2425
2017-04-14 18:13:44 +03:00
object->random_id = hash_int_2d(hash_string(object->name.c_str()), 0);
Cycles: add "From Dupli" option for texture coordinate node. This gets the Generated and UV coordinates from the duplicator of instance instead of the object itself. This was used in e.g. Big Buck Bunny for texturing instanced feathers with a UV map on the bird. Many files changed, mainly to do some refactoring to get rid of G.rendering global in duplilist code.
2012-10-04 21:40:39 +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
object->tag_update(scene);
}
Fix #33113: cycles not rendering motion blur correct with dying particles. There were a bunch of other issues with dupli motion blur and syncing, the problem being that there was no proper way to detect corresponding duplis between frames or updates. As a solution, a persistent_id was added to the DupliObject. It's an extension of the previous index value, with one index for each dupli level. This can be used to reliably find matching dupli objects between frames. Works with nested duplis, multiple particle systems, etc.
2012-11-08 16:35:28 +00:00
return object;
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 bool object_render_hide_original(BL::Object::type_enum ob_type,
BL::Object::dupli_type_enum dupli_type)
Fix #33454: cycles wasn't hiding the original object used for dupliverts or duplifaces like blender internal.
2012-12-09 12:43:40 +00:00
{
Fix #35730: cycles not rendering dupliverted metaball, needs another special exception.
2013-06-13 14:33:18 +00:00
/* metaball exception, they duplicate self */
if(ob_type == BL::Object::type_META)
return false;
Fix #33454: cycles wasn't hiding the original object used for dupliverts or duplifaces like blender internal.
2012-12-09 12:43:40 +00:00
return (dupli_type == BL::Object::dupli_type_VERTS ||
dupli_type == BL::Object::dupli_type_FACES ||
dupli_type == BL::Object::dupli_type_FRAMES);
}
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 bool object_render_hide(BL::Object& b_ob,
bool top_level,
bool parent_hide,
bool& hide_triangles)
Fix #34480: cycles hair render in dupligroup did hide the emitter properly in some cases.
2013-03-01 14:55:30 +00:00
{
/* check if we should render or hide particle emitter */
BL::Object::particle_systems_iterator b_psys;
bool hair_present = false;
bool show_emitter = false;
Fix T37159: cycles rendering particle emitter mesh incorrectly when using non-hair particles.
2013-11-27 17:14:53 +01:00
bool hide_emitter = false;
Fix #36355: cycles render of objects with both duplis and hair would not render the hair in some cases.
2013-08-07 19:02:15 +00:00
bool hide_as_dupli_parent = false;
bool hide_as_dupli_child_original = false;
Fix #34480: cycles hair render in dupligroup did hide the emitter properly in some cases.
2013-03-01 14:55:30 +00:00
for(b_ob.particle_systems.begin(b_psys); b_psys != b_ob.particle_systems.end(); ++b_psys) {
if((b_psys->settings().render_type() == BL::ParticleSettings::render_type_PATH) &&
(b_psys->settings().type()==BL::ParticleSettings::type_HAIR))
hair_present = true;
Fix #36355: cycles render of objects with both duplis and hair would not render the hair in some cases.
2013-08-07 19:02:15 +00:00
if(b_psys->settings().use_render_emitter())
Fix #34480: cycles hair render in dupligroup did hide the emitter properly in some cases.
2013-03-01 14:55:30 +00:00
show_emitter = true;
Fix T37159: cycles rendering particle emitter mesh incorrectly when using non-hair particles.
2013-11-27 17:14:53 +01:00
else
hide_emitter = true;
Fix #34480: cycles hair render in dupligroup did hide the emitter properly in some cases.
2013-03-01 14:55:30 +00:00
}
Fix T37159: cycles rendering particle emitter mesh incorrectly when using non-hair particles.
2013-11-27 17:14:53 +01:00
if(show_emitter)
hide_emitter = false;
Fix #34480: cycles hair render in dupligroup did hide the emitter properly in some cases.
2013-03-01 14:55:30 +00:00
/* duplicators hidden by default, except dupliframes which duplicate self */
if(b_ob.is_duplicator())
if(top_level || b_ob.dupli_type() != BL::Object::dupli_type_FRAMES)
Fix #36355: cycles render of objects with both duplis and hair would not render the hair in some cases.
2013-08-07 19:02:15 +00:00
hide_as_dupli_parent = true;
Fix #34480: cycles hair render in dupligroup did hide the emitter properly in some cases.
2013-03-01 14:55:30 +00:00
/* hide original object for duplis */
BL::Object parent = b_ob.parent();
Fix T43019: Child of objectes used by duplis are visible in Cycles Seems the parent check didn't go deep enough and only checked single parent. Now it checks the chain of parents which seems to be correct but requires much more intense testing.
2014-12-26 13:34:48 +05:00
while(parent) {
if(object_render_hide_original(b_ob.type(),
parent.dupli_type()))
{
if(parent_hide) {
hide_as_dupli_child_original = true;
break;
}
}
parent = parent.parent();
}
Cleanup: strip trailing space for cycles
2018-07-06 10:17:58 +02:00
Fix T37694: cycles particles emitter object rendering when it shouldn't. This was broken by a recent bugfix for T37159.
2013-12-09 21:57:30 +01:00
hide_triangles = hide_emitter;
Fix #36355: cycles render of objects with both duplis and hair would not render the hair in some cases.
2013-08-07 19:02:15 +00:00
if(show_emitter) {
Fix #36437 Cycles no longer rendering Emitter object (Particle Systems). The change r58999 was ignoring the "show_emitter" setting by particles (the result would be the same as long as hair was not used). If particle emitters are forced to show all other of the usual duplicator hiding should be disabled.
2013-08-12 06:53:17 +00:00
return false;
Fix #36355: cycles render of objects with both duplis and hair would not render the hair in some cases.
2013-08-07 19:02:15 +00:00
}
else if(hair_present) {
Fix T37694: cycles particles emitter object rendering when it shouldn't. This was broken by a recent bugfix for T37159.
2013-12-09 21:57:30 +01:00
return hide_as_dupli_child_original;
Fix #36355: cycles render of objects with both duplis and hair would not render the hair in some cases.
2013-08-07 19:02:15 +00:00
}
else {
Fix T37694: cycles particles emitter object rendering when it shouldn't. This was broken by a recent bugfix for T37159.
2013-12-09 21:57:30 +01:00
return (hide_as_dupli_parent || hide_as_dupli_child_original);
Fix #36355: cycles render of objects with both duplis and hair would not render the hair in some cases.
2013-08-07 19:02:15 +00:00
}
Fix #34480: cycles hair render in dupligroup did hide the emitter properly in some cases.
2013-03-01 14:55:30 +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 bool object_render_hide_duplis(BL::Object& b_ob)
Fix #35077: cycles incorrectly rendered an empty with dupligroup that was dupliverted by its parent.
2013-04-25 14:16:24 +00:00
{
BL::Object parent = b_ob.parent();
Fix #35730: cycles not rendering dupliverted metaball, needs another special exception.
2013-06-13 14:33:18 +00:00
return (parent && object_render_hide_original(b_ob.type(), parent.dupli_type()));
Fix #35077: cycles incorrectly rendered an empty with dupligroup that was dupliverted by its parent.
2013-04-25 14:16:24 +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
/* Object Loop */
Cycles: Use render visibility for duplis when Render Layer option in viewport is used Previously the logic was different for duplis and regular objects: regular objects were using render visibility when Render Layer option is enabled which duplis were always using viewport visibility when rendering from the viewport. This was quite confusing because caused different results in viewport and render when artists were expecting them to match 1:1.
2017-05-03 12:05:52 +02:00
void BlenderSync::sync_objects(float motion_time)
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
{
/* layer data */
Cycles: support for mask layers in render layer, this has the same effect as assigning holdout shaders to every object in the specified layers. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Passes#Layers
2012-02-28 16:44:45 +00:00
uint scene_layer = render_layer.scene_layer;
Cycles code refactor: improve vertex motion attribute storage and export. This now supports multiple steps and subframe sampling of motion. There is one difference for object and camera transform motion blur. It still only supports two steps there, but the transforms are now sampled at subframe times instead of the previous and next frame and then interpolated/extrapolated. This will give different render results in some cases but it's more accurate. Part of the code is from the summer of code project by Gavin Howard, but it has been significantly rewritten and extended.
2014-03-29 13:03:46 +01:00
bool motion = motion_time != 0.0f;
Cleanup: strip trailing space for cycles
2018-07-06 10:17:58 +02:00
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(!motion) {
/* prepare for sync */
light_map.pre_sync();
mesh_map.pre_sync();
object_map.pre_sync();
Fix #32912: cycles crash with dead particles, actual crash was caused by an inconsistency in the particle system code, using <= and <. Also tightened up checks on cycles side to avoid other potential crashes.
2012-10-18 15:00:32 +00:00
particle_system_map.pre_sync();
Cycles code refactor: improve vertex motion attribute storage and export. This now supports multiple steps and subframe sampling of motion. There is one difference for object and camera transform motion blur. It still only supports two steps there, but the transforms are now sampled at subframe times instead of the previous and next frame and then interpolated/extrapolated. This will give different render results in some cases but it's more accurate. Part of the code is from the summer of code project by Gavin Howard, but it has been significantly rewritten and extended.
2014-03-29 13:03:46 +01:00
motion_times.clear();
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
}
Fix cycles mesh synchronization being too slow with vector blur and duplis.
2013-10-17 16:05:57 +00:00
else {
mesh_motion_synced.clear();
}
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: refactor culling code into utility class.
2016-11-13 00:45:16 +01:00
/* initialize culling */
BlenderObjectCulling culling(scene, b_scene);
Cycles: Camera frustum space object culling scene simplification The idea is to give artists a simplier way to control memory usage in such scenes as grass fields by doing automatic object culling based on whether object is visible in the frame or not. This is controlled on per-object level. In order to use this option few steps are required: - Enable Simplify in scene settings - Enable Camera Cull option in the Simplify panel - Set camera cull margin (measured in relative value to the render resolution) This setting is used to avoid possible flickering caused by changes in shadow which are cast by objects outside of the frame. - Enable Camera Cull for objects which are desired to be culled (object culling option could be found in Option panel in object buttons). There is still room for improvements, but this worked quite well during Gooseberry open movie project, so think it's useful feature even in it's current non-ideal state.
2015-04-10 18:09:58 +05: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
/* object loop */
Fix T39965: Sequencer do not sync cycles strips The was actually caused by the way how Cycles uses objects layers. It's not possible to rely on the fact that layers are flushed from Base to Object. It's only valid when rendering active scene. Now made it so layers are used from the base.
2014-04-30 21:03:57 +06:00
BL::Scene::object_bases_iterator b_base;
Fix: cycles not supporting scene background sets.
2012-05-23 09:46:33 +00:00
BL::Scene b_sce = b_scene;
Fix T39341: Cycles Rendered view laggy while using particles. There are a couple of bugs that come together here: * Particle hacks: extra modifier stack evaluation just for particles in rna_Object_create_duplilist. This is where the primary issue stems from, the "for_render" setting replaced the G.is_rendering flag in threaded depsgraph. This causes particles to recalculate the entire modifier stack with _render_ settings instead of viewport settings now. Fixed by taking the 'preview' parameter in Cycles into account. * Buggy skin modifier: The skin modifier generates a different amount of vertices and faces **on every execution**. This must be looked at separately, but it could be another reason why cycles constantly restarted the sync process. * Particles get re-distributed randomly every time (changing seed). This could be caused just by the broken skin modifier, but might still be an issue when simply rendering with cycles, since the psys will be evaluated for render settings, if just temporarily.
2014-03-24 12:53:36 +01:00
/* modifier result type (not exposed as enum in C++ API)
Cleanup: cycles whitespace
2014-11-08 13:28:40 +01:00
* 1 : DAG_EVAL_PREVIEW
* 2 : DAG_EVAL_RENDER
*/
Cycles: Use render visibility for duplis when Render Layer option in viewport is used Previously the logic was different for duplis and regular objects: regular objects were using render visibility when Render Layer option is enabled which duplis were always using viewport visibility when rendering from the viewport. This was quite confusing because caused different results in viewport and render when artists were expecting them to match 1:1.
2017-05-03 12:05:52 +02:00
int dupli_settings = (render_layer.use_viewport_visibility) ? 1 : 2;
Fix #33113: cycles not rendering motion blur correct with dying particles. There were a bunch of other issues with dupli motion blur and syncing, the problem being that there was no proper way to detect corresponding duplis between frames or updates. As a solution, a persistent_id was added to the DupliObject. It's an extension of the previous index value, with one index for each dupli level. This can be used to reliably find matching dupli objects between frames. Works with nested duplis, multiple particle systems, etc.
2012-11-08 16:35:28 +00:00
Cycles: merge of changes from tomato branch. Regular rendering now works tiled, and supports save buffers to save memory during render and cache render results. Brick texture node by Thomas. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Textures#Brick_Texture Image texture Blended Box Mapping. http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/Textures#Image_Texture http://mango.blender.org/production/blended_box/ Various bug fixes by Sergey and Campbell. * Fix for reading freed memory in some node setups. * Fix incorrect memory read when synchronizing mesh motion. * Fix crash appearing when direct light usage is different on different layers. * Fix for vector pass gives wrong result in some circumstances. * Fix for wrong resolution used for rendering Render Layer node. * Option to cancel rendering when doing initial synchronization. * No more texture limit when using CPU render. * Many fixes for new tiled rendering.
2012-09-04 13:29:07 +00:00
bool cancel = false;
Cycles: Added support for light portals This patch adds support for light portals: objects that help sampling the environment light, therefore improving convergence. Using them tor other lights in a unidirectional pathtracer is virtually useless. The sampling is done with the area-preserving code already used for area lamps. MIS is used both for combination of different portals and for combining portal- and envmap-sampling. The direction of portals is considered, they aren't used if the sampling point is behind them. Reviewers: sergey, dingto, #cycles Reviewed By: dingto, #cycles Subscribers: Lapineige, nutel, jtheninja, dsisco11, januz, vitorbalbio, candreacchio, TARDISMaker, lichtwerk, ace_dragon, marcog, mib2berlin, Tunge, lopataasdf, lordodin, sergey, dingto Differential Revision: https://developer.blender.org/D1133
2015-04-28 00:51:55 +05:00
bool use_portal = 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: Make light behavior in local view matching BI Title says it all, based on feedback of artists from gooseberry team. This mainly affects cases when going to a local view from layers setup when some lamps were on invisible layers. Those lights are no longer becoming visible to the object in local view. Reviewers: brecht, juicyfruit, dingto Reviewed By: juicyfruit, dingto Subscribers: maxon, eyecandy, venomgfx Differential Revision: https://developer.blender.org/D1326
2015-10-11 19:59:51 +05:00
uint layer_override = get_layer(b_engine.layer_override());
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
for(; b_sce && !cancel; b_sce = b_sce.background_set()) {
Cycles: Make light behavior in local view matching BI Title says it all, based on feedback of artists from gooseberry team. This mainly affects cases when going to a local view from layers setup when some lamps were on invisible layers. Those lights are no longer becoming visible to the object in local view. Reviewers: brecht, juicyfruit, dingto Reviewed By: juicyfruit, dingto Subscribers: maxon, eyecandy, venomgfx Differential Revision: https://developer.blender.org/D1326
2015-10-11 19:59:51 +05:00
/* Render layer's scene_layer is affected by local view already,
* which is not a desired behavior here.
*/
uint scene_layers = layer_override ? layer_override : get_layer(b_scene.layers());
Fix T39965: Sequencer do not sync cycles strips The was actually caused by the way how Cycles uses objects layers. It's not possible to rely on the fact that layers are flushed from Base to Object. It's only valid when rendering active scene. Now made it so layers are used from the base.
2014-04-30 21:03:57 +06:00
for(b_sce.object_bases.begin(b_base); b_base != b_sce.object_bases.end() && !cancel; ++b_base) {
BL::Object b_ob = b_base->object();
bool hide = (render_layer.use_viewport_visibility)? b_ob.hide(): b_ob.hide_render();
Cycles: Make light behavior in local view matching BI Title says it all, based on feedback of artists from gooseberry team. This mainly affects cases when going to a local view from layers setup when some lamps were on invisible layers. Those lights are no longer becoming visible to the object in local view. Reviewers: brecht, juicyfruit, dingto Reviewed By: juicyfruit, dingto Subscribers: maxon, eyecandy, venomgfx Differential Revision: https://developer.blender.org/D1326
2015-10-11 19:59:51 +05:00
uint ob_layer = get_layer(b_base->layers(),
b_base->layers_local_view(),
object_is_light(b_ob),
scene_layers);
Particle Info node for Cycles. This can be used to access particle information in material shaders for dupli objects. For now only the particle Age and individual Lifetime (in frames) are supported, more attributes can be added when needed. The particle data is stored in a separate texture if any of the dupli objects uses particle info nodes in shaders. To map dupli objects onto particles the store an additional particle_index value, which is different from the simple dupli object index (only visible particles, also works for particle dupli groups mode). Some simple use cases on the code.blender.org blog: http://code.blender.org/index.php/2012/05/particle-info-node/
2012-06-08 16:17:57 +00:00
hide = hide || !(ob_layer & scene_layer);
if(!hide) {
Fix T39965: Sequencer do not sync cycles strips The was actually caused by the way how Cycles uses objects layers. It's not possible to rely on the fact that layers are flushed from Base to Object. It's only valid when rendering active scene. Now made it so layers are used from the base.
2014-04-30 21:03:57 +06:00
progress.set_sync_status("Synchronizing object", b_ob.name());
Particle Info node for Cycles. This can be used to access particle information in material shaders for dupli objects. For now only the particle Age and individual Lifetime (in frames) are supported, more attributes can be added when needed. The particle data is stored in a separate texture if any of the dupli objects uses particle info nodes in shaders. To map dupli objects onto particles the store an additional particle_index value, which is different from the simple dupli object index (only visible particles, also works for particle dupli groups mode). Some simple use cases on the code.blender.org blog: http://code.blender.org/index.php/2012/05/particle-info-node/
2012-06-08 16:17:57 +00:00
Cycles: refactor culling code into utility class.
2016-11-13 00:45:16 +01:00
/* load per-object culling data */
culling.init_object(scene, b_ob);
Fix T39965: Sequencer do not sync cycles strips The was actually caused by the way how Cycles uses objects layers. It's not possible to rely on the fact that layers are flushed from Base to Object. It's only valid when rendering active scene. Now made it so layers are used from the base.
2014-04-30 21:03:57 +06:00
if(b_ob.is_duplicator() && !object_render_hide_duplis(b_ob)) {
Fix: cycles not supporting scene background sets.
2012-05-23 09:46:33 +00:00
/* dupli objects */
Cleanup: Moar G.main removal of Hell. This commit actually adds some G.main... but at much, much higher level than the ones it removes, so should still be better ;)
2018-06-11 12:14:18 +02:00
b_ob.dupli_list_create(b_data, b_scene, dupli_settings);
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: cycles not supporting scene background sets.
2012-05-23 09:46:33 +00:00
BL::Object::dupli_list_iterator b_dup;
Fix #31780, cycles nested group rendering broken. Was using the dupli object 'index' member to identify dupli objects, but this is not unique and in fact just 0 in most cases. Needs to use a simple dupli list counter instead.
2012-06-13 08:10:59 +00:00
Fix T39965: Sequencer do not sync cycles strips The was actually caused by the way how Cycles uses objects layers. It's not possible to rely on the fact that layers are flushed from Base to Object. It's only valid when rendering active scene. Now made it so layers are used from the base.
2014-04-30 21:03:57 +06:00
for(b_ob.dupli_list.begin(b_dup); b_dup != b_ob.dupli_list.end(); ++b_dup) {
Fix: cycles not supporting scene background sets.
2012-05-23 09:46:33 +00:00
Transform tfm = get_transform(b_dup->matrix());
BL::Object b_dup_ob = b_dup->object();
Cycles: Use render visibility for duplis when Render Layer option in viewport is used Previously the logic was different for duplis and regular objects: regular objects were using render visibility when Render Layer option is enabled which duplis were always using viewport visibility when rendering from the viewport. This was quite confusing because caused different results in viewport and render when artists were expecting them to match 1:1.
2017-05-03 12:05:52 +02:00
bool dup_hide = (render_layer.use_viewport_visibility)? b_dup_ob.hide(): b_dup_ob.hide_render();
Fix #34480: cycles hair render in dupligroup did hide the emitter properly in some cases.
2013-03-01 14:55:30 +00:00
bool in_dupli_group = (b_dup->type() == BL::DupliObject::type_GROUP);
bool hide_tris;
Fix #33454: cycles wasn't hiding the original object used for dupliverts or duplifaces like blender internal.
2012-12-09 12:43:40 +00:00
Fix #34480: cycles hair render in dupligroup did hide the emitter properly in some cases.
2013-03-01 14:55:30 +00:00
if(!(b_dup->hide() || dup_hide || object_render_hide(b_dup_ob, false, in_dupli_group, hide_tris))) {
Fix #33113: cycles not rendering motion blur correct with dying particles. There were a bunch of other issues with dupli motion blur and syncing, the problem being that there was no proper way to detect corresponding duplis between frames or updates. As a solution, a persistent_id was added to the DupliObject. It's an extension of the previous index value, with one index for each dupli level. This can be used to reliably find matching dupli objects between frames. Works with nested duplis, multiple particle systems, etc.
2012-11-08 16:35:28 +00:00
/* the persistent_id allows us to match dupli objects
* between frames and updates */
BL::Array<int, OBJECT_PERSISTENT_ID_SIZE> persistent_id = b_dup->persistent_id();
/* sync object and mesh or light data */
Cycles: Camera frustum space object culling scene simplification The idea is to give artists a simplier way to control memory usage in such scenes as grass fields by doing automatic object culling based on whether object is visible in the frame or not. This is controlled on per-object level. In order to use this option few steps are required: - Enable Simplify in scene settings - Enable Camera Cull option in the Simplify panel - Set camera cull margin (measured in relative value to the render resolution) This setting is used to avoid possible flickering caused by changes in shadow which are cast by objects outside of the frame. - Enable Camera Cull for objects which are desired to be culled (object culling option could be found in Option panel in object buttons). There is still room for improvements, but this worked quite well during Gooseberry open movie project, so think it's useful feature even in it's current non-ideal state.
2015-04-10 18:09:58 +05:00
Object *object = sync_object(b_ob,
persistent_id.data,
*b_dup,
tfm,
ob_layer,
motion_time,
hide_tris,
Cycles: refactor culling code into utility class.
2016-11-13 00:45:16 +01:00
culling,
Cycles: Camera frustum space object culling scene simplification The idea is to give artists a simplier way to control memory usage in such scenes as grass fields by doing automatic object culling based on whether object is visible in the frame or not. This is controlled on per-object level. In order to use this option few steps are required: - Enable Simplify in scene settings - Enable Camera Cull option in the Simplify panel - Set camera cull margin (measured in relative value to the render resolution) This setting is used to avoid possible flickering caused by changes in shadow which are cast by objects outside of the frame. - Enable Camera Cull for objects which are desired to be culled (object culling option could be found in Option panel in object buttons). There is still room for improvements, but this worked quite well during Gooseberry open movie project, so think it's useful feature even in it's current non-ideal state.
2015-04-10 18:09:58 +05:00
&use_portal);
Fix #33113: cycles not rendering motion blur correct with dying particles. There were a bunch of other issues with dupli motion blur and syncing, the problem being that there was no proper way to detect corresponding duplis between frames or updates. As a solution, a persistent_id was added to the DupliObject. It's an extension of the previous index value, with one index for each dupli level. This can be used to reliably find matching dupli objects between frames. Works with nested duplis, multiple particle systems, etc.
2012-11-08 16:35:28 +00:00
/* sync possible particle data, note particle_id
* starts counting at 1, first is dummy particle */
Fix T38811: Cycles particle ids are inconsistent when using multiple particle systems. Problem is that the particle systems in the cycles database are not stored in a well-defined order. This means the particle_id for dupli objects can not simply be assigned using a global running index during sync. Now the particle index is assigned locally for each particle system. When transferring particle data to the device as a single texture, the particle indices are offset based on the final order of particle systems in the database. Reviewers: brecht Reviewed By: brecht CC: Andreas80 Differential Revision: https://developer.blender.org/D352
2014-02-25 18:29:11 +01:00
if(!motion && object) {
Fix T39965: Sequencer do not sync cycles strips The was actually caused by the way how Cycles uses objects layers. It's not possible to rely on the fact that layers are flushed from Base to Object. It's only valid when rendering active scene. Now made it so layers are used from the base.
2014-04-30 21:03:57 +06:00
sync_dupli_particle(b_ob, *b_dup, object);
Fix #33113: cycles not rendering motion blur correct with dying particles. There were a bunch of other issues with dupli motion blur and syncing, the problem being that there was no proper way to detect corresponding duplis between frames or updates. As a solution, a persistent_id was added to the DupliObject. It's an extension of the previous index value, with one index for each dupli level. This can be used to reliably find matching dupli objects between frames. Works with nested duplis, multiple particle systems, etc.
2012-11-08 16:35:28 +00:00
}
Particle Info node for Cycles. This can be used to access particle information in material shaders for dupli objects. For now only the particle Age and individual Lifetime (in frames) are supported, more attributes can be added when needed. The particle data is stored in a separate texture if any of the dupli objects uses particle info nodes in shaders. To map dupli objects onto particles the store an additional particle_index value, which is different from the simple dupli object index (only visible particles, also works for particle dupli groups mode). Some simple use cases on the code.blender.org blog: http://code.blender.org/index.php/2012/05/particle-info-node/
2012-06-08 16:17:57 +00:00
}
Fix: cycles not supporting scene background sets.
2012-05-23 09:46:33 +00:00
}
Cycles: fix missing particle panels and show emitter option not being respected.
2011-11-10 16:02:46 +00:00
Fix T39965: Sequencer do not sync cycles strips The was actually caused by the way how Cycles uses objects layers. It's not possible to rely on the fact that layers are flushed from Base to Object. It's only valid when rendering active scene. Now made it so layers are used from the base.
2014-04-30 21:03:57 +06:00
b_ob.dupli_list_clear();
Fix: cycles not supporting scene background sets.
2012-05-23 09:46:33 +00:00
}
Cycles: fix missing particle panels and show emitter option not being respected.
2011-11-10 16:02:46 +00:00
Fix #34480: cycles hair render in dupligroup did hide the emitter properly in some cases.
2013-03-01 14:55:30 +00:00
/* test if object needs to be hidden */
bool hide_tris;
Cycles: fix missing particle panels and show emitter option not being respected.
2011-11-10 16:02:46 +00:00
Fix T39965: Sequencer do not sync cycles strips The was actually caused by the way how Cycles uses objects layers. It's not possible to rely on the fact that layers are flushed from Base to Object. It's only valid when rendering active scene. Now made it so layers are used from the base.
2014-04-30 21:03:57 +06:00
if(!object_render_hide(b_ob, true, true, hide_tris)) {
Fix: cycles not supporting scene background sets.
2012-05-23 09:46:33 +00:00
/* object itself */
Fix T39965: Sequencer do not sync cycles strips The was actually caused by the way how Cycles uses objects layers. It's not possible to rely on the fact that layers are flushed from Base to Object. It's only valid when rendering active scene. Now made it so layers are used from the base.
2014-04-30 21:03:57 +06:00
Transform tfm = get_transform(b_ob.matrix_world());
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::DupliObject b_empty_dupli_ob(PointerRNA_NULL);
Cycles: Camera frustum space object culling scene simplification The idea is to give artists a simplier way to control memory usage in such scenes as grass fields by doing automatic object culling based on whether object is visible in the frame or not. This is controlled on per-object level. In order to use this option few steps are required: - Enable Simplify in scene settings - Enable Camera Cull option in the Simplify panel - Set camera cull margin (measured in relative value to the render resolution) This setting is used to avoid possible flickering caused by changes in shadow which are cast by objects outside of the frame. - Enable Camera Cull for objects which are desired to be culled (object culling option could be found in Option panel in object buttons). There is still room for improvements, but this worked quite well during Gooseberry open movie project, so think it's useful feature even in it's current non-ideal state.
2015-04-10 18:09:58 +05:00
sync_object(b_ob,
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
b_empty_dupli_ob,
Cycles: Camera frustum space object culling scene simplification The idea is to give artists a simplier way to control memory usage in such scenes as grass fields by doing automatic object culling based on whether object is visible in the frame or not. This is controlled on per-object level. In order to use this option few steps are required: - Enable Simplify in scene settings - Enable Camera Cull option in the Simplify panel - Set camera cull margin (measured in relative value to the render resolution) This setting is used to avoid possible flickering caused by changes in shadow which are cast by objects outside of the frame. - Enable Camera Cull for objects which are desired to be culled (object culling option could be found in Option panel in object buttons). There is still room for improvements, but this worked quite well during Gooseberry open movie project, so think it's useful feature even in it's current non-ideal state.
2015-04-10 18:09:58 +05:00
tfm,
ob_layer,
motion_time,
hide_tris,
Cycles: refactor culling code into utility class.
2016-11-13 00:45:16 +01:00
culling,
Cycles: Camera frustum space object culling scene simplification The idea is to give artists a simplier way to control memory usage in such scenes as grass fields by doing automatic object culling based on whether object is visible in the frame or not. This is controlled on per-object level. In order to use this option few steps are required: - Enable Simplify in scene settings - Enable Camera Cull option in the Simplify panel - Set camera cull margin (measured in relative value to the render resolution) This setting is used to avoid possible flickering caused by changes in shadow which are cast by objects outside of the frame. - Enable Camera Cull for objects which are desired to be culled (object culling option could be found in Option panel in object buttons). There is still room for improvements, but this worked quite well during Gooseberry open movie project, so think it's useful feature even in it's current non-ideal state.
2015-04-10 18:09:58 +05:00
&use_portal);
Fix: cycles not supporting scene background sets.
2012-05-23 09:46:33 +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: 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
cancel = progress.get_cancel();
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 cycles "synchronizing object" status being shown when it was already finished.
2012-09-28 12:37:20 +00:00
progress.set_sync_status("");
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
if(!cancel && !motion) {
Cycles: Added support for light portals This patch adds support for light portals: objects that help sampling the environment light, therefore improving convergence. Using them tor other lights in a unidirectional pathtracer is virtually useless. The sampling is done with the area-preserving code already used for area lamps. MIS is used both for combination of different portals and for combining portal- and envmap-sampling. The direction of portals is considered, they aren't used if the sampling point is behind them. Reviewers: sergey, dingto, #cycles Reviewed By: dingto, #cycles Subscribers: Lapineige, nutel, jtheninja, dsisco11, januz, vitorbalbio, candreacchio, TARDISMaker, lichtwerk, ace_dragon, marcog, mib2berlin, Tunge, lopataasdf, lordodin, sergey, dingto Differential Revision: https://developer.blender.org/D1133
2015-04-28 00:51:55 +05:00
sync_background_light(use_portal);
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
/* handle removed data and modified pointers */
if(light_map.post_sync())
scene->light_manager->tag_update(scene);
if(mesh_map.post_sync())
scene->mesh_manager->tag_update(scene);
if(object_map.post_sync())
scene->object_manager->tag_update(scene);
Fix #32912: cycles crash with dead particles, actual crash was caused by an inconsistency in the particle system code, using <= and <. Also tightened up checks on cycles side to avoid other potential crashes.
2012-10-18 15:00:32 +00:00
if(particle_system_map.post_sync())
scene->particle_system_manager->tag_update(scene);
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
}
Fix cycles mesh synchronization being too slow with vector blur and duplis.
2013-10-17 16:05:57 +00:00
if(motion)
mesh_motion_synced.clear();
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
}
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 BlenderSync::sync_motion(BL::RenderSettings& b_render,
BL::Object& b_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
int width, int height,
void **python_thread_state)
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(scene->need_motion() == Scene::MOTION_NONE)
return;
/* get camera object here to deal with camera switch */
BL::Object b_cam = b_scene.camera();
if(b_override)
b_cam = b_override;
Cycles: fix some update issues with camera motion blur, and do some more work for getting object motion blur ready.
2012-10-15 21:12:58 +00:00
Camera prevcam = *(scene->camera);
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
Cycles code refactor: improve vertex motion attribute storage and export. This now supports multiple steps and subframe sampling of motion. There is one difference for object and camera transform motion blur. It still only supports two steps there, but the transforms are now sampled at subframe times instead of the previous and next frame and then interpolated/extrapolated. This will give different render results in some cases but it's more accurate. Part of the code is from the summer of code project by Gavin Howard, but it has been significantly rewritten and extended.
2014-03-29 13:03:46 +01:00
int frame_center = b_scene.frame_current();
Fix T49341: Bad motion blur behavior in Cycles when using Speed effect in Sequencer Cycles was thinking it always rendering integer frame, which is not correct.
2016-09-14 14:58:55 +02:00
float subframe_center = b_scene.frame_subframe();
Cycles: Add support for motion blur position This adds an option to control at what time relative to the current frame the shutter is fully opened. Supported options are: - Shutter is starting to open at the current frame - Shutter is fully opened at the current frame - Shutter is fully closed at the current frame Custom shutter time offset is possible, same as custom curve for shutter openness but those are considered nice things to have rather than something crucial. Reviewers: juicyfruit, dingto Subscribers: venomgfx, hjalti Differential Revision: https://developer.blender.org/D1380
2015-06-29 17:40:13 +02:00
float frame_center_delta = 0.0f;
if(scene->need_motion() != Scene::MOTION_PASS &&
scene->camera->motion_position != Camera::MOTION_POSITION_CENTER)
{
float shuttertime = scene->camera->shuttertime;
if(scene->camera->motion_position == Camera::MOTION_POSITION_END) {
frame_center_delta = -shuttertime * 0.5f;
}
else {
assert(scene->camera->motion_position == Camera::MOTION_POSITION_START);
frame_center_delta = shuttertime * 0.5f;
}
Fix T49341: Bad motion blur behavior in Cycles when using Speed effect in Sequencer Cycles was thinking it always rendering integer frame, which is not correct.
2016-09-14 14:58:55 +02:00
float time = frame_center + subframe_center + frame_center_delta;
Cycles: Add support for motion blur position This adds an option to control at what time relative to the current frame the shutter is fully opened. Supported options are: - Shutter is starting to open at the current frame - Shutter is fully opened at the current frame - Shutter is fully closed at the current frame Custom shutter time offset is possible, same as custom curve for shutter openness but those are considered nice things to have rather than something crucial. Reviewers: juicyfruit, dingto Subscribers: venomgfx, hjalti Differential Revision: https://developer.blender.org/D1380
2015-06-29 17:40:13 +02:00
int frame = (int)floorf(time);
float subframe = time - frame;
python_thread_state_restore(python_thread_state);
b_engine.frame_set(frame, subframe);
python_thread_state_save(python_thread_state);
sync_camera_motion(b_render, b_cam, width, height, 0.0f);
Cycles: Use render visibility for duplis when Render Layer option in viewport is used Previously the logic was different for duplis and regular objects: regular objects were using render visibility when Render Layer option is enabled which duplis were always using viewport visibility when rendering from the viewport. This was quite confusing because caused different results in viewport and render when artists were expecting them to match 1:1.
2017-05-03 12:05:52 +02:00
sync_objects(0.0f);
Cycles: Add support for motion blur position This adds an option to control at what time relative to the current frame the shutter is fully opened. Supported options are: - Shutter is starting to open at the current frame - Shutter is fully opened at the current frame - Shutter is fully closed at the current frame Custom shutter time offset is possible, same as custom curve for shutter openness but those are considered nice things to have rather than something crucial. Reviewers: juicyfruit, dingto Subscribers: venomgfx, hjalti Differential Revision: https://developer.blender.org/D1380
2015-06-29 17:40:13 +02:00
}
Cycles code refactor: improve vertex motion attribute storage and export. This now supports multiple steps and subframe sampling of motion. There is one difference for object and camera transform motion blur. It still only supports two steps there, but the transforms are now sampled at subframe times instead of the previous and next frame and then interpolated/extrapolated. This will give different render results in some cases but it's more accurate. Part of the code is from the summer of code project by Gavin Howard, but it has been significantly rewritten and extended.
2014-03-29 13:03:46 +01:00
/* always sample these times for camera motion */
motion_times.insert(-1.0f);
motion_times.insert(1.0f);
/* note iteration over motion_times set happens in sorted order */
foreach(float relative_time, motion_times) {
Code refactor: motion blur cleanups, preparing for next commit.
2018-03-10 00:37:07 +01:00
/* center time is already handled. */
if(relative_time == 0.0f) {
continue;
}
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
VLOG(1) << "Synchronizing motion for the relative time "
<< relative_time << ".";
Cycles code refactor: improve vertex motion attribute storage and export. This now supports multiple steps and subframe sampling of motion. There is one difference for object and camera transform motion blur. It still only supports two steps there, but the transforms are now sampled at subframe times instead of the previous and next frame and then interpolated/extrapolated. This will give different render results in some cases but it's more accurate. Part of the code is from the summer of code project by Gavin Howard, but it has been significantly rewritten and extended.
2014-03-29 13:03:46 +01:00
/* fixed shutter time to get previous and next frame for motion pass */
Cycles: add support for motion blurring of fluid meshes. Reviewed By: brecht Differential Revision: https://developer.blender.org/D2063
2016-07-16 18:56:59 +02:00
float shuttertime = scene->motion_shutter_time();
Cycles code refactor: improve vertex motion attribute storage and export. This now supports multiple steps and subframe sampling of motion. There is one difference for object and camera transform motion blur. It still only supports two steps there, but the transforms are now sampled at subframe times instead of the previous and next frame and then interpolated/extrapolated. This will give different render results in some cases but it's more accurate. Part of the code is from the summer of code project by Gavin Howard, but it has been significantly rewritten and extended.
2014-03-29 13:03:46 +01:00
/* compute frame and subframe time */
Fix T49341: Bad motion blur behavior in Cycles when using Speed effect in Sequencer Cycles was thinking it always rendering integer frame, which is not correct.
2016-09-14 14:58:55 +02:00
float time = frame_center + subframe_center + frame_center_delta + relative_time * shuttertime * 0.5f;
Cycles code refactor: improve vertex motion attribute storage and export. This now supports multiple steps and subframe sampling of motion. There is one difference for object and camera transform motion blur. It still only supports two steps there, but the transforms are now sampled at subframe times instead of the previous and next frame and then interpolated/extrapolated. This will give different render results in some cases but it's more accurate. Part of the code is from the summer of code project by Gavin Howard, but it has been significantly rewritten and extended.
2014-03-29 13:03:46 +01:00
int frame = (int)floorf(time);
float subframe = time - frame;
/* change frame */
Fix issue in recent bugfix, did not work with multiple sessions (preview render).
2014-02-12 23:13:45 +01:00
python_thread_state_restore(python_thread_state);
Fix T39711: cycles particle motion blur affected by viewport draw method.
2014-05-21 15:47:11 +02:00
b_engine.frame_set(frame, subframe);
Fix issue in recent bugfix, did not work with multiple sessions (preview render).
2014-02-12 23:13:45 +01:00
python_thread_state_save(python_thread_state);
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
Fix T39510, Fix T39523: camera motion blur not working correct after recent changes.
2014-03-31 13:36:51 +02:00
/* sync camera, only supports two times at the moment */
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
if(relative_time == -1.0f || relative_time == 1.0f) {
sync_camera_motion(b_render,
b_cam,
width, height,
relative_time);
}
Fix T39510, Fix T39523: camera motion blur not working correct after recent changes.
2014-03-31 13:36:51 +02:00
Cycles code refactor: improve vertex motion attribute storage and export. This now supports multiple steps and subframe sampling of motion. There is one difference for object and camera transform motion blur. It still only supports two steps there, but the transforms are now sampled at subframe times instead of the previous and next frame and then interpolated/extrapolated. This will give different render results in some cases but it's more accurate. Part of the code is from the summer of code project by Gavin Howard, but it has been significantly rewritten and extended.
2014-03-29 13:03:46 +01:00
/* sync object */
Cycles: Use render visibility for duplis when Render Layer option in viewport is used Previously the logic was different for duplis and regular objects: regular objects were using render visibility when Render Layer option is enabled which duplis were always using viewport visibility when rendering from the viewport. This was quite confusing because caused different results in viewport and render when artists were expecting them to match 1:1.
2017-05-03 12:05:52 +02:00
sync_objects(relative_time);
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
}
Sample as Lamp option for world shaders, to enable multiple importance sampling. By default lighting from the world is computed solely with indirect light sampling. However for more complex environment maps this can be too noisy, as sampling the BSDF may not easily find the highlights in the environment map image. By enabling this option, the world background will be sampled as a lamp, with lighter parts automatically given more samples. Map Resolution specifies the size of the importance map (res x res). Before rendering starts, an importance map is generated by "baking" a grayscale image from the world shader. This will then be used to determine which parts of the background are light and so should receive more samples than darker parts. Higher resolutions will result in more accurate sampling but take more setup time and memory. Patch by Mike Farnsworth, thanks!
2012-01-20 17:49:17 +00:00
Fix T38332, Fix T38607: cycles render crash with motion blur. It wasn't working together well with the python thread state changes after the depsgraph multithreading.
2014-02-12 21:49:34 +01:00
/* we need to set the python thread state again because this
* function assumes it is being executed from python and will
* try to save the thread state */
Fix issue in recent bugfix, did not work with multiple sessions (preview render).
2014-02-12 23:13:45 +01:00
python_thread_state_restore(python_thread_state);
Fix T49341: Bad motion blur behavior in Cycles when using Speed effect in Sequencer Cycles was thinking it always rendering integer frame, which is not correct.
2016-09-14 14:58:55 +02:00
b_engine.frame_set(frame_center, subframe_center);
Fix issue in recent bugfix, did not work with multiple sessions (preview render).
2014-02-12 23:13:45 +01:00
python_thread_state_save(python_thread_state);
Cycles: fix some update issues with camera motion blur, and do some more work for getting object motion blur ready.
2012-10-15 21:12:58 +00:00
/* tag camera for motion update */
if(scene->camera->motion_modified(prevcam))
scene->camera->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
}
CCL_NAMESPACE_END
Copy Permalink