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
7ccef23c4d010d4b4f83efe2cd6c82ff26824a10
blender-archive/source/blender/depsgraph/intern/eval/deg_eval_flush.cc

447 lines
13 KiB
C++
Raw Normal View History

Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2013 Blender Foundation.
* All rights reserved.
*
* Original Author: Joshua Leung
* Contributor(s): None Yet
*
* ***** END GPL LICENSE BLOCK *****
*/
Cleanup: style, whitespace, doxy filepaths
2016-06-19 06:25:54 +10:00
/** \file blender/depsgraph/intern/eval/deg_eval_flush.cc
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
* \ingroup depsgraph
*
* Core routines for how the Depsgraph works.
*/
#include "intern/eval/deg_eval_flush.h"
// TODO(sergey): Use some sort of wrapper.
Depsgrpah: Use deque for the flush queue The idea of the change is to avoid queue growing too long and handle all the operations as quick as possible. Gives about 3% speedup on one of the barber shots here.
2016-08-25 15:12:21 +02:00
#include <deque>
Depsgraph: Add debug option to invalidate data tagged for update See comment for INVALIDATE_ON_FLUSH.
2018-06-12 09:59:30 +02:00
#include <cmath>
#include "BKE_object.h"
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
#include "BLI_utildefines.h"
Fix T53598: OpenGL Render Animation does not update shadows General idea of the fix: skip the whole draw manager callback madness which was used to tag object's engine specific data as dirty. Use generic recalc flag in ObjectEngineData structure instead. This gives us the following benefits; - Sovles mentioned bug report. - Avoids whole interface lookup for opened viewports for EVERY changed ID. - Fixes missing updates when viewport is temporarily invisible. Reviewers: dfelinto, fclem Differential Revision: https://developer.blender.org/D3028
2018-01-29 16:42:04 +01:00
#include "BLI_listbase.h"
Depsgraph: Add debug option to invalidate data tagged for update See comment for INVALIDATE_ON_FLUSH.
2018-06-12 09:59:30 +02:00
#include "BLI_math_vector.h"
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
#include "BLI_task.h"
#include "BLI_ghash.h"
Depsgraph: Only use extern "C" when really needed
2017-06-06 12:14:39 +02:00
extern "C" {
#include "DNA_object_types.h"
DrawData: Change drawdata to a generic struct shared accross ID types This makes tagging much more generic and make the world updates more in line with the new tagging system (Depsgraph).
2018-07-10 14:14:55 +02:00
#include "DRW_engine.h"
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
} /* extern "C" */
Depsgraph: Only use extern "C" when really needed
2017-06-06 12:14:39 +02:00
#include "DEG_depsgraph.h"
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
#include "intern/nodes/deg_node.h"
#include "intern/nodes/deg_node_component.h"
Depsgraph: Move ID node to own file
2017-12-20 16:35:48 +01:00
#include "intern/nodes/deg_node_id.h"
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
#include "intern/nodes/deg_node_operation.h"
#include "intern/depsgraph_intern.h"
Depsgraph: Fix missing updates when changing node tree topology There were two issues here: 1. material_update did not do anything, because DEG_id_tag_update was storing update tags in original IDs, which had nothing evaluated. Even more, material update should have been called with evaluated version of material, Solved this by copying update tag from original ID to a copied one. However, perhaps DEG_id_tag_update should tag both original and copied ID, so updates are never gets lots if some depsgraph is not visible. 2. Tagging material for update should ensure it's copied version of node tree is up to date, otherwise material will still use old node tree. This solves missing material updates when changing topology. Tweaking values is still broken, because of GPUMaterial using pointer to original node's socket value, which gets broken after copy-on-write of the node tree (pointers of nodes are changing).
2017-08-29 11:26:57 +02:00
#include "intern/eval/deg_eval_copy_on_write.h"
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
#include "util/deg_util_foreach.h"
Depsgraph: Add debug option to invalidate data tagged for update See comment for INVALIDATE_ON_FLUSH.
2018-06-12 09:59:30 +02:00
// Invalidate datablock data when update is flushed on it.
//
// The idea of this is to help catching cases when area is accessing data which
// is not yet evaluated, which could happen due to missing relations. The issue
// is that usually that data will be kept from previous frame, and it looks to
// be plausible.
//
// This ensures that data does not look plausible, making it much easier to
// catch usage of invalid state.
#undef INVALIDATE_ON_FLUSH
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
namespace DEG {
Depsgraph: Call editors update after everything was flushed This way we can inform editors about all edits at once. Currently this is not used, but in the next commits we will inform editors about what exactly has changed.
2017-12-01 17:56:52 +01:00
enum {
ID_STATE_NONE = 0,
ID_STATE_MODIFIED = 1,
};
Fix T52432: Blender crashes while using Ghost (new depsgraph)
2017-09-18 15:50:27 +05:00
enum {
COMPONENT_STATE_NONE = 0,
COMPONENT_STATE_SCHEDULED = 1,
COMPONENT_STATE_DONE = 2,
};
Depsgrpah: Use deque for the flush queue The idea of the change is to avoid queue growing too long and handle all the operations as quick as possible. Gives about 3% speedup on one of the barber shots here.
2016-08-25 15:12:21 +02:00
typedef std::deque<OperationDepsNode *> FlushQueue;
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
namespace {
Task scheduler: Use restrict pointer qualifier Those pointers are never to be aliased, so let's be explicit about this and hope compiler does save some CPU ticks.
2018-01-10 12:49:51 +01:00
void flush_init_operation_node_func(
void *__restrict data_v,
Task scheduler: Use const qualifier in callbacks for parallel range
2018-01-10 12:53:59 +01:00
const int i,
Task scheduler: Use restrict pointer qualifier Those pointers are never to be aliased, so let's be explicit about this and hope compiler does save some CPU ticks.
2018-01-10 12:49:51 +01:00
const ParallelRangeTLS *__restrict /*tls*/)
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
{
Depsgraph *graph = (Depsgraph *)data_v;
OperationDepsNode *node = graph->operations[i];
node->scheduled = false;
}
Task scheduler: Use restrict pointer qualifier Those pointers are never to be aliased, so let's be explicit about this and hope compiler does save some CPU ticks.
2018-01-10 12:49:51 +01:00
void flush_init_id_node_func(
void *__restrict data_v,
Task scheduler: Use const qualifier in callbacks for parallel range
2018-01-10 12:53:59 +01:00
const int i,
Task scheduler: Use restrict pointer qualifier Those pointers are never to be aliased, so let's be explicit about this and hope compiler does save some CPU ticks.
2018-01-10 12:49:51 +01:00
const ParallelRangeTLS *__restrict /*tls*/)
Depsgraph: Separate loop for ID node flags clear This ends up in less number of memory writes, which should have positive effect on performance.
2017-12-01 17:30:36 +01:00
{
Depsgraph *graph = (Depsgraph *)data_v;
IDDepsNode *id_node = graph->id_nodes[i];
Depsgraph: Use more meaningful name for flags storage
2018-09-03 14:35:42 +02:00
id_node->custom_flags = ID_STATE_NONE;
Depsgraph: Separate loop for ID node flags clear This ends up in less number of memory writes, which should have positive effect on performance.
2017-12-01 17:30:36 +01:00
GHASH_FOREACH_BEGIN(ComponentDepsNode *, comp_node, id_node->components)
Depsgraph: Use more meaningful name for flags storage
2018-09-03 14:35:42 +02:00
comp_node->custom_flags = COMPONENT_STATE_NONE;
Depsgraph: Separate loop for ID node flags clear This ends up in less number of memory writes, which should have positive effect on performance.
2017-12-01 17:30:36 +01:00
GHASH_FOREACH_END();
}
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
BLI_INLINE void flush_prepare(Depsgraph *graph)
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
{
Task scheduler: Use single parallel range function with more flexible function Now all the fine-tuning is happening using parallel range settings structure, which avoid passing long lists of arguments, allows extend fine-tuning further, avoid having lots of various functions which basically does the same thing.
2018-01-08 11:35:48 +01:00
{
const int num_operations = graph->operations.size();
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
Depsgraph: Make eval initialization more friendly for threading Helps in cases of not very complex scenes and lots of system threads available. A bit hard to measure change on it's own, it works best with the upcoming changes and gives measurable improvements.
2018-01-11 14:47:12 +01:00
settings.min_iter_per_thread = 1024;
Task scheduler: Use single parallel range function with more flexible function Now all the fine-tuning is happening using parallel range settings structure, which avoid passing long lists of arguments, allows extend fine-tuning further, avoid having lots of various functions which basically does the same thing.
2018-01-08 11:35:48 +01:00
BLI_task_parallel_range(0, num_operations,
graph,
flush_init_operation_node_func,
&settings);
}
{
const int num_id_nodes = graph->id_nodes.size();
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
Depsgraph: Make eval initialization more friendly for threading Helps in cases of not very complex scenes and lots of system threads available. A bit hard to measure change on it's own, it works best with the upcoming changes and gives measurable improvements.
2018-01-11 14:47:12 +01:00
settings.min_iter_per_thread = 1024;
Task scheduler: Use single parallel range function with more flexible function Now all the fine-tuning is happening using parallel range settings structure, which avoid passing long lists of arguments, allows extend fine-tuning further, avoid having lots of various functions which basically does the same thing.
2018-01-08 11:35:48 +01:00
BLI_task_parallel_range(0, num_id_nodes,
graph,
flush_init_id_node_func,
&settings);
}
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
}
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
BLI_INLINE void flush_schedule_entrypoints(Depsgraph *graph, FlushQueue *queue)
{
Depsgraph: Initial groundwork for copy-on-write support < Dependency graph Copy-on-Write > -------------------------------- \ ^__^ \ (oo)\_______ (__)\ )\/\ ||----w | || || This is an initial commit of Copy-on-write support added to dependency graph. Main priority for now: get playback (Alt-A) and all operators (selection, transform etc) to work with the new concept of clear separation between evaluated data coming from dependency graph and original data coming from .blend file (and stored in bmain). = How does this work? = The idea is to support Copy-on-Write on the ID level. This means, we duplicate the whole ID before we cann it's evaluaiton function. This is currently done in the following way: - At the depsgraph construction time we create "shallow" copy of the ID datablock, just so we know it's pointer in memory and can use for function bindings. - At the evaluaiton time, the copy of ID get's "expanded" (needs a better name internally, so it does not conflict with expanding datablocks during library linking), which means the content of the datablock is being copied over and all IDs are getting remapped to the copied ones. Currently we do the whole copy, in the future we will support some tricks here to prevent duplicating geometry arrays (verts, edges, loops, faces and polys) when we don't need that. - Evaluation functions are operating on copied datablocks and never touching original datablock. - There are some cases when we need to know non-ID pointers for function bindings. This mainly applies to scene collections and armatures. The idea of dealing with this is to "expand" copy-on-write datablock at the dependency graph build time. This might introduce some slowdown to the dependency graph construction time, but allows us to have minimal changes in the code and avoid any hash look-up from evaluation function (one of the ideas to avoid using pointers as function bindings is to pass name of layer or a bone to the evaluation function and look up actual data based on that name). Currently there is a special function in depsgraph which does such a synchronization, in the future we might want to make it more generic. At some point we need to synchronize copy-on-write version of datablock with the original version. This happens, i.e., when we change active object or change selection. We don't want any actual evaluation of update flush happening for such thins, so now we have a special update tag: DEG_id_tag_update((id, DEG_TAG_COPY_ON_WRITE) - For the render engines we now have special call for the dependency graph to give evaluated datablock for the given original one. This isn't fully ideal but allows to have Cycles viewport render. This is definitely a subject for further investigation / improvement. This call will tag copy-on-write component tagged for update without causing updates to be flushed to any other objects, causing chain reaction of updates. This tag is handy when selection in the scene changes. This basically summarizes ideas underneath this commit. The code should be reasonably documented. Here is a demo of dependency graph with all copy-on-write stuff in it: https://developer.blender.org/F635468 = What to expect to (not) work? = - Only meshes are properly-ish aware of copy-on-write currently, Non-mesh geometry will probably crash or will not work at all. - Armatures will need similar depsgraph built-time expansion of the copied datablock. - There are some extra tags / relations added, to keep things demo-able but which are slowing things down for evaluation. - Edit mode works for until click selection is used (due to the selection code using EditDerivedMesh created ad-hoc). - Lots of tools will lack tagging synchronization of copied datablock for sync with original ID. = How to move forward? = There is some tedious work related on going over all the tools, checking whether they need to work with original or final evaluated object and make the required changes. Additionally, there need synchronization tag done in fair amount of tools and operators as well. For example, currently it's not possible to change render engine without re-opening the file or forcing dependency graph for re-build via python console. There is also now some thoughts required about copying evaluated properties between objects or from collection to a new object. Perhaps easiest way would be to move base flag flush to Object ID node and tag new objects for update instead of doing manual copy. here is some WIP patch which moves such evaluaiton / flush: https://developer.blender.org/F635479 Lots of TODOs in the code, with possible optimization. = How to test? = This is a feature under heavy development, so obviously it is disabled by default. The only reason it goes to 2.8 branch is to avoid possible merge hell. In order to enable this feature use WITH_DEPSGRAPH_COPY_ON_WRITE CMake configuration option.
2017-06-14 10:26:24 +02:00
GSET_FOREACH_BEGIN(OperationDepsNode *, op_node, graph->entry_tags)
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
{
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
queue->push_back(op_node);
Depsgraph: Remove hacky workaround for copy-on-write tagging flushing updates to everything Wasn't working reliably,m and it's somewhat dangerous anyway. Seed something smarter.
2017-07-19 09:40:34 +02:00
op_node->scheduled = true;
Depsgraph: Log entry operations which are directly modified and tagged
2018-07-04 16:41:37 +02:00
DEG_DEBUG_PRINTF((::Depsgraph *)graph,
EVAL, "Operation is entry point for update: %s\n",
op_node->identifier().c_str());
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
}
GSET_FOREACH_END();
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
}
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
Depsgraph: Call editors update after everything was flushed This way we can inform editors about all edits at once. Currently this is not used, but in the next commits we will inform editors about what exactly has changed.
2017-12-01 17:56:52 +01:00
BLI_INLINE void flush_handle_id_node(IDDepsNode *id_node)
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
{
Depsgraph: Use more meaningful name for flags storage
2018-09-03 14:35:42 +02:00
id_node->custom_flags = ID_STATE_MODIFIED;
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
}
Depsgraph: Initial groundwork for copy-on-write support < Dependency graph Copy-on-Write > -------------------------------- \ ^__^ \ (oo)\_______ (__)\ )\/\ ||----w | || || This is an initial commit of Copy-on-write support added to dependency graph. Main priority for now: get playback (Alt-A) and all operators (selection, transform etc) to work with the new concept of clear separation between evaluated data coming from dependency graph and original data coming from .blend file (and stored in bmain). = How does this work? = The idea is to support Copy-on-Write on the ID level. This means, we duplicate the whole ID before we cann it's evaluaiton function. This is currently done in the following way: - At the depsgraph construction time we create "shallow" copy of the ID datablock, just so we know it's pointer in memory and can use for function bindings. - At the evaluaiton time, the copy of ID get's "expanded" (needs a better name internally, so it does not conflict with expanding datablocks during library linking), which means the content of the datablock is being copied over and all IDs are getting remapped to the copied ones. Currently we do the whole copy, in the future we will support some tricks here to prevent duplicating geometry arrays (verts, edges, loops, faces and polys) when we don't need that. - Evaluation functions are operating on copied datablocks and never touching original datablock. - There are some cases when we need to know non-ID pointers for function bindings. This mainly applies to scene collections and armatures. The idea of dealing with this is to "expand" copy-on-write datablock at the dependency graph build time. This might introduce some slowdown to the dependency graph construction time, but allows us to have minimal changes in the code and avoid any hash look-up from evaluation function (one of the ideas to avoid using pointers as function bindings is to pass name of layer or a bone to the evaluation function and look up actual data based on that name). Currently there is a special function in depsgraph which does such a synchronization, in the future we might want to make it more generic. At some point we need to synchronize copy-on-write version of datablock with the original version. This happens, i.e., when we change active object or change selection. We don't want any actual evaluation of update flush happening for such thins, so now we have a special update tag: DEG_id_tag_update((id, DEG_TAG_COPY_ON_WRITE) - For the render engines we now have special call for the dependency graph to give evaluated datablock for the given original one. This isn't fully ideal but allows to have Cycles viewport render. This is definitely a subject for further investigation / improvement. This call will tag copy-on-write component tagged for update without causing updates to be flushed to any other objects, causing chain reaction of updates. This tag is handy when selection in the scene changes. This basically summarizes ideas underneath this commit. The code should be reasonably documented. Here is a demo of dependency graph with all copy-on-write stuff in it: https://developer.blender.org/F635468 = What to expect to (not) work? = - Only meshes are properly-ish aware of copy-on-write currently, Non-mesh geometry will probably crash or will not work at all. - Armatures will need similar depsgraph built-time expansion of the copied datablock. - There are some extra tags / relations added, to keep things demo-able but which are slowing things down for evaluation. - Edit mode works for until click selection is used (due to the selection code using EditDerivedMesh created ad-hoc). - Lots of tools will lack tagging synchronization of copied datablock for sync with original ID. = How to move forward? = There is some tedious work related on going over all the tools, checking whether they need to work with original or final evaluated object and make the required changes. Additionally, there need synchronization tag done in fair amount of tools and operators as well. For example, currently it's not possible to change render engine without re-opening the file or forcing dependency graph for re-build via python console. There is also now some thoughts required about copying evaluated properties between objects or from collection to a new object. Perhaps easiest way would be to move base flag flush to Object ID node and tag new objects for update instead of doing manual copy. here is some WIP patch which moves such evaluaiton / flush: https://developer.blender.org/F635479 Lots of TODOs in the code, with possible optimization. = How to test? = This is a feature under heavy development, so obviously it is disabled by default. The only reason it goes to 2.8 branch is to avoid possible merge hell. In order to enable this feature use WITH_DEPSGRAPH_COPY_ON_WRITE CMake configuration option.
2017-06-14 10:26:24 +02:00
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
/* TODO(sergey): We can reduce number of arguments here. */
Depsgraph: Move CoW tag to ID datablock tag Unless there is an external action from an user, there should not be need in re-copying original datablock to a copied one. This brings performance up from 5fps to 11fps with Spring runcycle (performance in master is 14fps).
2018-04-12 11:03:24 +02:00
BLI_INLINE void flush_handle_component_node(IDDepsNode *id_node,
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
ComponentDepsNode *comp_node,
FlushQueue *queue)
{
/* We only handle component once. */
Depsgraph: Use more meaningful name for flags storage
2018-09-03 14:35:42 +02:00
if (comp_node->custom_flags == COMPONENT_STATE_DONE) {
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
return;
}
Depsgraph: Use more meaningful name for flags storage
2018-09-03 14:35:42 +02:00
comp_node->custom_flags = COMPONENT_STATE_DONE;
Fix T58932: Impossible to influence the particle system
2018-12-10 17:37:30 +01:00
/* Tag all required operations in component for update, unless this is a
* special component where we don't want all operations to be tagged.
*
* TODO(sergey): Make this a more generic solution. */
if (comp_node->type != DEG_NODE_TYPE_PARTICLE_SETTINGS &&
comp_node->type != DEG_NODE_TYPE_PARTICLE_SYSTEM)
{
foreach (OperationDepsNode *op, comp_node->operations) {
op->flag |= DEPSOP_FLAG_NEEDS_UPDATE;
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
}
}
Depsgraph: Introduce ID recalc flag for COW component Currently unused, but will become handy to check whether ID needs to have COW update to be run.
2018-04-11 17:29:00 +02:00
/* when some target changes bone, we might need to re-run the
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
* whole IK solver, otherwise result might be unpredictable.
*/
if (comp_node->type == DEG_NODE_TYPE_BONE) {
ComponentDepsNode *pose_comp =
id_node->find_component(DEG_NODE_TYPE_EVAL_POSE);
BLI_assert(pose_comp != NULL);
Depsgraph: Use more meaningful name for flags storage
2018-09-03 14:35:42 +02:00
if (pose_comp->custom_flags == COMPONENT_STATE_NONE) {
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
queue->push_front(pose_comp->get_entry_operation());
Depsgraph: Use more meaningful name for flags storage
2018-09-03 14:35:42 +02:00
pose_comp->custom_flags = COMPONENT_STATE_SCHEDULED;
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
}
}
}
Depsgraph: Merge some traversal back on After previous commit there is no longer measurable difference in speed and doing all stuff in one go is preferrable here anyway.
2016-08-25 15:51:19 +02:00
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
/* Schedule children of the given operation node for traversal.
*
* One of the children will by-pass the queue and will be returned as a function
* return value, so it can start being handled right away, without building too
* much of a queue.
*/
BLI_INLINE OperationDepsNode *flush_schedule_children(
OperationDepsNode *op_node,
FlushQueue *queue)
{
OperationDepsNode *result = NULL;
foreach (DepsRelation *rel, op_node->outlinks) {
Depsgraph: Fix missing point cache reset when physics changes Among all the lines moved around, the general idea is quite simple. Actually, there are two ideas implemented there. First one, is when object itself is tagged for update, we tag its point cache component for evaluation, which makes it so point cache is properly reset. We do it implicitly because otherwise we'll need to go everywhere and add explicit tag in almost all the properties. Second thing is, we link all collider and force fields to a point cache component using special type of link. This type of link only allows flush if change is caused by a user update. This way reset does not happen when change is caused due to animation, but will properly happen when user causes indirect change to the objects which are part of physics simulation.
2018-11-14 11:24:54 +01:00
/* Flush is forbidden, completely. */
Depsgraph: Add relation flag to avoid flush across it This way we can avoid re-evaluation of certain parts of datablock when something unrelated has changed.
2018-04-23 16:42:37 +02:00
if (rel->flag & DEPSREL_FLAG_NO_FLUSH) {
continue;
}
Depsgraph: Fix missing point cache reset when physics changes Among all the lines moved around, the general idea is quite simple. Actually, there are two ideas implemented there. First one, is when object itself is tagged for update, we tag its point cache component for evaluation, which makes it so point cache is properly reset. We do it implicitly because otherwise we'll need to go everywhere and add explicit tag in almost all the properties. Second thing is, we link all collider and force fields to a point cache component using special type of link. This type of link only allows flush if change is caused by a user update. This way reset does not happen when change is caused due to animation, but will properly happen when user causes indirect change to the objects which are part of physics simulation.
2018-11-14 11:24:54 +01:00
/* Relation only allows flushes on user changes, but the node was not
* affected by user. */
if ((rel->flag & DEPSREL_FLAG_FLUSH_USER_EDIT_ONLY) &&
(op_node->flag & DEPSOP_FLAG_USER_MODIFIED) == 0)
{
continue;
}
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
OperationDepsNode *to_node = (OperationDepsNode *)rel->to;
Depsgraph: Fix missing point cache reset when physics changes Among all the lines moved around, the general idea is quite simple. Actually, there are two ideas implemented there. First one, is when object itself is tagged for update, we tag its point cache component for evaluation, which makes it so point cache is properly reset. We do it implicitly because otherwise we'll need to go everywhere and add explicit tag in almost all the properties. Second thing is, we link all collider and force fields to a point cache component using special type of link. This type of link only allows flush if change is caused by a user update. This way reset does not happen when change is caused due to animation, but will properly happen when user causes indirect change to the objects which are part of physics simulation.
2018-11-14 11:24:54 +01:00
/* Always flush flushable flags, so children always know what happened
* to their parents. */
to_node->flag |= (op_node->flag & DEPSOP_FLAG_FLUSH);
/* Flush update over the relation, if it was not flushed yet. */
if (to_node->scheduled) {
continue;
}
if (result != NULL) {
queue->push_front(to_node);
}
else {
result = to_node;
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
}
Depsgraph: Fix missing point cache reset when physics changes Among all the lines moved around, the general idea is quite simple. Actually, there are two ideas implemented there. First one, is when object itself is tagged for update, we tag its point cache component for evaluation, which makes it so point cache is properly reset. We do it implicitly because otherwise we'll need to go everywhere and add explicit tag in almost all the properties. Second thing is, we link all collider and force fields to a point cache component using special type of link. This type of link only allows flush if change is caused by a user update. This way reset does not happen when change is caused due to animation, but will properly happen when user causes indirect change to the objects which are part of physics simulation.
2018-11-14 11:24:54 +01:00
to_node->scheduled = true;
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
}
return result;
}
Fix T53598: OpenGL Render Animation does not update shadows General idea of the fix: skip the whole draw manager callback madness which was used to tag object's engine specific data as dirty. Use generic recalc flag in ObjectEngineData structure instead. This gives us the following benefits; - Sovles mentioned bug report. - Avoids whole interface lookup for opened viewports for EVERY changed ID. - Fixes missing updates when viewport is temporarily invisible. Reviewers: dfelinto, fclem Differential Revision: https://developer.blender.org/D3028
2018-01-29 16:42:04 +01:00
void flush_engine_data_update(ID *id)
{
Depsgraph: Cleanup, naming If something is a list of data, it is to be called list, and data is to be called data. No need to call list a data and data a weird two letter abbreviation. Clarity is our friend!
2018-09-07 15:09:14 +02:00
DrawDataList *draw_data_list = DRW_drawdatalist_from_id(id);
if (draw_data_list == NULL) {
Fix T53598: OpenGL Render Animation does not update shadows General idea of the fix: skip the whole draw manager callback madness which was used to tag object's engine specific data as dirty. Use generic recalc flag in ObjectEngineData structure instead. This gives us the following benefits; - Sovles mentioned bug report. - Avoids whole interface lookup for opened viewports for EVERY changed ID. - Fixes missing updates when viewport is temporarily invisible. Reviewers: dfelinto, fclem Differential Revision: https://developer.blender.org/D3028
2018-01-29 16:42:04 +01:00
return;
}
Depsgraph: Cleanup, naming If something is a list of data, it is to be called list, and data is to be called data. No need to call list a data and data a weird two letter abbreviation. Clarity is our friend!
2018-09-07 15:09:14 +02:00
LISTBASE_FOREACH(DrawData *, draw_data, draw_data_list) {
draw_data->recalc |= id->recalc;
Fix T53598: OpenGL Render Animation does not update shadows General idea of the fix: skip the whole draw manager callback madness which was used to tag object's engine specific data as dirty. Use generic recalc flag in ObjectEngineData structure instead. This gives us the following benefits; - Sovles mentioned bug report. - Avoids whole interface lookup for opened viewports for EVERY changed ID. - Fixes missing updates when viewport is temporarily invisible. Reviewers: dfelinto, fclem Differential Revision: https://developer.blender.org/D3028
2018-01-29 16:42:04 +01:00
}
}
Depsgraph: Rework tagging and flushing routines The goal is: have id->recalc flags set to components which got changed. To make it possible for render engines to check on a more granular basis what changed in the object. For example, is it a transform which changed or is it just some ID property changed which has nothing to do with rendering. The tricky part is: we don't want duplicated logic in tagging and flushing. In order to avoid this duplication, we store ID recalc flag in the component node type information. That type information could easily be accessed by both tagging and flushing routines. Remaining part of the changes are related on changing the way how tagging works. The new idea here is to have utility function which maps update tag to a component. This way we can easily set ID recalc flags right away. Without any duplication of ID recalc flags set in multiple flag handler functions. With all this being said, there should be no user measurable difference for now, it's a gigantic basement for some upcoming work and fixes.
2017-12-19 11:24:34 +01:00
/* NOTE: It will also accumulate flags from changed components. */
Fix T53598: OpenGL Render Animation does not update shadows General idea of the fix: skip the whole draw manager callback madness which was used to tag object's engine specific data as dirty. Use generic recalc flag in ObjectEngineData structure instead. This gives us the following benefits; - Sovles mentioned bug report. - Avoids whole interface lookup for opened viewports for EVERY changed ID. - Fixes missing updates when viewport is temporarily invisible. Reviewers: dfelinto, fclem Differential Revision: https://developer.blender.org/D3028
2018-01-29 16:42:04 +01:00
void flush_editors_id_update(Main *bmain,
Depsgraph *graph,
const DEGEditorUpdateContext *update_ctx)
Depsgraph: Call editors update after everything was flushed This way we can inform editors about all edits at once. Currently this is not used, but in the next commits we will inform editors about what exactly has changed.
2017-12-01 17:56:52 +01:00
{
foreach (IDDepsNode *id_node, graph->id_nodes) {
Depsgraph: Use more meaningful name for flags storage
2018-09-03 14:35:42 +02:00
if (id_node->custom_flags != ID_STATE_MODIFIED) {
Depsgraph: Call editors update after everything was flushed This way we can inform editors about all edits at once. Currently this is not used, but in the next commits we will inform editors about what exactly has changed.
2017-12-01 17:56:52 +01:00
continue;
}
Depsgraph: Rework tagging and flushing routines The goal is: have id->recalc flags set to components which got changed. To make it possible for render engines to check on a more granular basis what changed in the object. For example, is it a transform which changed or is it just some ID property changed which has nothing to do with rendering. The tricky part is: we don't want duplicated logic in tagging and flushing. In order to avoid this duplication, we store ID recalc flag in the component node type information. That type information could easily be accessed by both tagging and flushing routines. Remaining part of the changes are related on changing the way how tagging works. The new idea here is to have utility function which maps update tag to a component. This way we can easily set ID recalc flags right away. Without any duplication of ID recalc flags set in multiple flag handler functions. With all this being said, there should be no user measurable difference for now, it's a gigantic basement for some upcoming work and fixes.
2017-12-19 11:24:34 +01:00
DEG_id_type_tag(bmain, GS(id_node->id_orig->name));
Depsgraph: Call editors update after everything was flushed This way we can inform editors about all edits at once. Currently this is not used, but in the next commits we will inform editors about what exactly has changed.
2017-12-01 17:56:52 +01:00
/* TODO(sergey): Do we need to pass original or evaluated ID here? */
ID *id_orig = id_node->id_orig;
ID *id_cow = id_node->id_cow;
/* Copy tag from original data to CoW storage.
* This is because DEG_id_tag_update() sets tags on original
* data.
*/
Depsgraph: Fix assignment to wrong flags
2017-12-15 14:42:42 +01:00
id_cow->recalc |= (id_orig->recalc & ID_RECALC_ALL);
Depsgraph: Rework tagging and flushing routines The goal is: have id->recalc flags set to components which got changed. To make it possible for render engines to check on a more granular basis what changed in the object. For example, is it a transform which changed or is it just some ID property changed which has nothing to do with rendering. The tricky part is: we don't want duplicated logic in tagging and flushing. In order to avoid this duplication, we store ID recalc flag in the component node type information. That type information could easily be accessed by both tagging and flushing routines. Remaining part of the changes are related on changing the way how tagging works. The new idea here is to have utility function which maps update tag to a component. This way we can easily set ID recalc flags right away. Without any duplication of ID recalc flags set in multiple flag handler functions. With all this being said, there should be no user measurable difference for now, it's a gigantic basement for some upcoming work and fixes.
2017-12-19 11:24:34 +01:00
/* Gather recalc flags from all changed components. */
GHASH_FOREACH_BEGIN(ComponentDepsNode *, comp_node, id_node->components)
{
Depsgraph: Use more meaningful name for flags storage
2018-09-03 14:35:42 +02:00
if (comp_node->custom_flags != COMPONENT_STATE_DONE) {
Depsgraph: Rework tagging and flushing routines The goal is: have id->recalc flags set to components which got changed. To make it possible for render engines to check on a more granular basis what changed in the object. For example, is it a transform which changed or is it just some ID property changed which has nothing to do with rendering. The tricky part is: we don't want duplicated logic in tagging and flushing. In order to avoid this duplication, we store ID recalc flag in the component node type information. That type information could easily be accessed by both tagging and flushing routines. Remaining part of the changes are related on changing the way how tagging works. The new idea here is to have utility function which maps update tag to a component. This way we can easily set ID recalc flags right away. Without any duplication of ID recalc flags set in multiple flag handler functions. With all this being said, there should be no user measurable difference for now, it's a gigantic basement for some upcoming work and fixes.
2017-12-19 11:24:34 +01:00
continue;
}
DepsNodeFactory *factory = deg_type_get_factory(comp_node->type);
BLI_assert(factory != NULL);
id_cow->recalc |= factory->id_recalc_tag();
}
GHASH_FOREACH_END();
Depsgraph: Make all print messages to respect per-depsgraph debug flags
2018-05-02 11:52:49 +02:00
DEG_DEBUG_PRINTF((::Depsgraph *)graph,
EVAL, "Accumulated recalc bits for %s: %u\n",
Depsgraph: Rework tagging and flushing routines The goal is: have id->recalc flags set to components which got changed. To make it possible for render engines to check on a more granular basis what changed in the object. For example, is it a transform which changed or is it just some ID property changed which has nothing to do with rendering. The tricky part is: we don't want duplicated logic in tagging and flushing. In order to avoid this duplication, we store ID recalc flag in the component node type information. That type information could easily be accessed by both tagging and flushing routines. Remaining part of the changes are related on changing the way how tagging works. The new idea here is to have utility function which maps update tag to a component. This way we can easily set ID recalc flags right away. Without any duplication of ID recalc flags set in multiple flag handler functions. With all this being said, there should be no user measurable difference for now, it's a gigantic basement for some upcoming work and fixes.
2017-12-19 11:24:34 +01:00
id_orig->name, (unsigned int)id_cow->recalc);
Fix T57316: material preview icons not updating. The editors update callback was getting the COW datablock, it should be the original where the preview icons are stored.
2018-11-02 16:02:46 +01:00
/* Inform editors. Only if the datablock is being evaluated a second
* time, to distinguish between user edits and initial evaluation when
* the datablock becomes visible.
*
* TODO: image datablocks do not use COW, so might not be detected
* correctly. */
Depsgraph: Call editors update after everything was flushed This way we can inform editors about all edits at once. Currently this is not used, but in the next commits we will inform editors about what exactly has changed.
2017-12-01 17:56:52 +01:00
if (deg_copy_on_write_is_expanded(id_cow)) {
Fix T57689: world nodes / texture not updating for Eevee. Only do GPU material updates through depsgraph evaluation now. This was already happening for material, just missing for the world.
2018-11-08 15:56:56 +01:00
if (graph->is_active) {
deg_editors_id_update(update_ctx, id_orig);
}
Make depsgraph tag for auto-override IDs it updates. This will reduce amount of needless auto-override checks, at least when not touching anything related to overriding IDs...
2018-04-18 11:25:31 +02:00
/* ID may need to get its auto-override operations refreshed. */
if (ID_IS_STATIC_OVERRIDE_AUTO(id_orig)) {
id_orig->tag |= LIB_TAG_OVERRIDESTATIC_AUTOREFRESH;
}
Fix T53598: OpenGL Render Animation does not update shadows General idea of the fix: skip the whole draw manager callback madness which was used to tag object's engine specific data as dirty. Use generic recalc flag in ObjectEngineData structure instead. This gives us the following benefits; - Sovles mentioned bug report. - Avoids whole interface lookup for opened viewports for EVERY changed ID. - Fixes missing updates when viewport is temporarily invisible. Reviewers: dfelinto, fclem Differential Revision: https://developer.blender.org/D3028
2018-01-29 16:42:04 +01:00
/* Inform draw engines that something was changed. */
flush_engine_data_update(id_cow);
Depsgraph: Call editors update after everything was flushed This way we can inform editors about all edits at once. Currently this is not used, but in the next commits we will inform editors about what exactly has changed.
2017-12-01 17:56:52 +01:00
}
}
}
Depsgraph: Add debug option to invalidate data tagged for update See comment for INVALIDATE_ON_FLUSH.
2018-06-12 09:59:30 +02:00
#ifdef INVALIDATE_ON_FLUSH
void invalidate_tagged_evaluated_transform(ID *id)
{
const ID_Type id_type = GS(id->name);
switch (id_type) {
case ID_OB:
{
Object *object = (Object *)id;
copy_vn_fl((float *)object->obmat, 16, NAN);
break;
}
default:
break;
}
}
void invalidate_tagged_evaluated_geometry(ID *id)
{
const ID_Type id_type = GS(id->name);
switch (id_type) {
case ID_OB:
{
Object *object = (Object *)id;
BKE_object_free_derived_caches(object);
break;
}
default:
break;
}
}
#endif
void invalidate_tagged_evaluated_data(Depsgraph *graph)
{
#ifdef INVALIDATE_ON_FLUSH
foreach (IDDepsNode *id_node, graph->id_nodes) {
Depsgraph: Use more meaningful name for flags storage
2018-09-03 14:35:42 +02:00
if (id_node->custom_flags != ID_STATE_MODIFIED) {
Depsgraph: Add debug option to invalidate data tagged for update See comment for INVALIDATE_ON_FLUSH.
2018-06-12 09:59:30 +02:00
continue;
}
ID *id_cow = id_node->id_cow;
if (!deg_copy_on_write_is_expanded(id_cow)) {
continue;
}
GHASH_FOREACH_BEGIN(ComponentDepsNode *, comp_node, id_node->components)
{
Depsgraph: Use more meaningful name for flags storage
2018-09-03 14:35:42 +02:00
if (comp_node->custom_flags != COMPONENT_STATE_DONE) {
Depsgraph: Add debug option to invalidate data tagged for update See comment for INVALIDATE_ON_FLUSH.
2018-06-12 09:59:30 +02:00
continue;
}
switch (comp_node->type) {
Depsgraph: Remove duplicated sets of recalc/update flags There were at least three copies of those: - OB_RECALC* family of flags, which are rudiment of an old dependency graph system. - PSYS_RECALC* which were used by old dependency graph system as a separate set since the graph itself did not handle particle systems. - DEG_TAG_* which was used to tag IDs. Now there is a single set, which defines what can be tagged and queried for an update. It also has some aggregate flags to make queries simpler. Lets once and for all solve the madness of those flags, stick to a single set, which will not overlap with anything or require any extra conversion. Technically, shouldn't be measurable user difference, but some of the agregate flags for few dependency graph components did change. Fixes T58632: Particle don't update rotation settings
2018-12-06 17:52:37 +01:00
case ID_RECALC_TRANSFORM:
Depsgraph: Add debug option to invalidate data tagged for update See comment for INVALIDATE_ON_FLUSH.
2018-06-12 09:59:30 +02:00
invalidate_tagged_evaluated_transform(id_cow);
break;
Depsgraph: Remove duplicated sets of recalc/update flags There were at least three copies of those: - OB_RECALC* family of flags, which are rudiment of an old dependency graph system. - PSYS_RECALC* which were used by old dependency graph system as a separate set since the graph itself did not handle particle systems. - DEG_TAG_* which was used to tag IDs. Now there is a single set, which defines what can be tagged and queried for an update. It also has some aggregate flags to make queries simpler. Lets once and for all solve the madness of those flags, stick to a single set, which will not overlap with anything or require any extra conversion. Technically, shouldn't be measurable user difference, but some of the agregate flags for few dependency graph components did change. Fixes T58632: Particle don't update rotation settings
2018-12-06 17:52:37 +01:00
case ID_RECALC_GEOMETRY:
Depsgraph: Add debug option to invalidate data tagged for update See comment for INVALIDATE_ON_FLUSH.
2018-06-12 09:59:30 +02:00
invalidate_tagged_evaluated_geometry(id_cow);
break;
default:
break;
}
}
GHASH_FOREACH_END();
}
#else
(void) graph;
#endif
}
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
} // namespace
/* Flush updates from tagged nodes outwards until all affected nodes
* are tagged.
*/
void deg_graph_flush_updates(Main *bmain, Depsgraph *graph)
{
/* Sanity checks. */
BLI_assert(bmain != NULL);
BLI_assert(graph != NULL);
/* Nothing to update, early out. */
Cleanup: use '_len' instead of '_size' w/ BLI API - When returning the number of items in a collection use BLI_*_len() - Keep _size() for size in bytes. - Keep _count() for data structures that don't store length (hint this isn't a simple getter). See P611 to apply instead of manually resolving conflicts.
2018-02-15 23:36:11 +11:00
if (BLI_gset_len(graph->entry_tags) == 0) {
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
return;
}
/* Reset all flags, get ready for the flush. */
flush_prepare(graph);
/* Starting from the tagged "entry" nodes, flush outwards. */
FlushQueue queue;
flush_schedule_entrypoints(graph, &queue);
/* Prepare update context for editors. */
Depsgraph: Cleanup, use more explicit way to fill in a structure The possible issue with just listing arguments is that it might not be clear what particular value is used for. For example, is it a scene itself, or is it a parent scene? Not as if it's not very clear now, but better be explicit for the future, and me reading code in 10 years.
2017-12-14 11:09:18 +01:00
DEGEditorUpdateContext update_ctx;
update_ctx.bmain = bmain;
Depsgraph: pass depsgraph to editors update context struct This way callbacks will know which depsgraph is being changed, and where evaluated data is coming from.
2018-01-16 15:37:52 +01:00
update_ctx.depsgraph = (::Depsgraph *)graph;
Depsgraph: Cleanup, use more explicit way to fill in a structure The possible issue with just listing arguments is that it might not be clear what particular value is used for. For example, is it a scene itself, or is it a parent scene? Not as if it's not very clear now, but better be explicit for the future, and me reading code in 10 years.
2017-12-14 11:09:18 +01:00
update_ctx.scene = graph->scene;
update_ctx.view_layer = graph->view_layer;
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
/* Do actual flush. */
while (!queue.empty()) {
OperationDepsNode *op_node = queue.front();
queue.pop_front();
while (op_node != NULL) {
/* Tag operation as required for update. */
op_node->flag |= DEPSOP_FLAG_NEEDS_UPDATE;
/* Inform corresponding ID and component nodes about the change. */
ComponentDepsNode *comp_node = op_node->owner;
IDDepsNode *id_node = comp_node->owner;
Depsgraph: Call editors update after everything was flushed This way we can inform editors about all edits at once. Currently this is not used, but in the next commits we will inform editors about what exactly has changed.
2017-12-01 17:56:52 +01:00
flush_handle_id_node(id_node);
Depsgraph: Move CoW tag to ID datablock tag Unless there is an external action from an user, there should not be need in re-copying original datablock to a copied one. This brings performance up from 5fps to 11fps with Spring runcycle (performance in master is 14fps).
2018-04-12 11:03:24 +02:00
flush_handle_component_node(id_node,
Depsgraph: Cleanup, simplify evaluation flush function Also avoid once queue push for cases when current operation has multiple outgoing relations.
2017-12-01 16:02:10 +01:00
comp_node,
&queue);
/* Flush to nodes along links. */
op_node = flush_schedule_children(op_node, &queue);
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
}
}
Depsgraph: Call editors update after everything was flushed This way we can inform editors about all edits at once. Currently this is not used, but in the next commits we will inform editors about what exactly has changed.
2017-12-01 17:56:52 +01:00
/* Inform editors about all changes. */
flush_editors_id_update(bmain, graph, &update_ctx);
Depsgraph: Add debug option to invalidate data tagged for update See comment for INVALIDATE_ON_FLUSH.
2018-06-12 09:59:30 +02:00
/* Reset evaluation result tagged which is tagged for update to some state
* which is obvious to catch.
*/
invalidate_tagged_evaluated_data(graph);
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
}
Depsgraph: Preserve CoW ID recalc flags Previously they would have been replaced with flag from original datablock, which is not what we want.
2018-04-25 15:04:25 +02:00
static void graph_clear_operation_func(
Task scheduler: Use restrict pointer qualifier Those pointers are never to be aliased, so let's be explicit about this and hope compiler does save some CPU ticks.
2018-01-10 12:49:51 +01:00
void *__restrict data_v,
Task scheduler: Use const qualifier in callbacks for parallel range
2018-01-10 12:53:59 +01:00
const int i,
Task scheduler: Use restrict pointer qualifier Those pointers are never to be aliased, so let's be explicit about this and hope compiler does save some CPU ticks.
2018-01-10 12:49:51 +01:00
const ParallelRangeTLS *__restrict /*tls*/)
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
{
Depsgraph *graph = (Depsgraph *)data_v;
OperationDepsNode *node = graph->operations[i];
/* Clear node's "pending update" settings. */
Depsgraph: Fix missing point cache reset when physics changes Among all the lines moved around, the general idea is quite simple. Actually, there are two ideas implemented there. First one, is when object itself is tagged for update, we tag its point cache component for evaluation, which makes it so point cache is properly reset. We do it implicitly because otherwise we'll need to go everywhere and add explicit tag in almost all the properties. Second thing is, we link all collider and force fields to a point cache component using special type of link. This type of link only allows flush if change is caused by a user update. This way reset does not happen when change is caused due to animation, but will properly happen when user causes indirect change to the objects which are part of physics simulation.
2018-11-14 11:24:54 +01:00
node->flag &= ~(DEPSOP_FLAG_DIRECTLY_MODIFIED |
DEPSOP_FLAG_NEEDS_UPDATE |
DEPSOP_FLAG_USER_MODIFIED);
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
}
/* Clear tags from all operation nodes. */
void deg_graph_clear_tags(Depsgraph *graph)
{
/* Go over all operation nodes, clearing tags. */
Depsgraph: Preserve CoW ID recalc flags Previously they would have been replaced with flag from original datablock, which is not what we want.
2018-04-25 15:04:25 +02:00
{
const int num_operations = graph->operations.size();
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.min_iter_per_thread = 1024;
BLI_task_parallel_range(0, num_operations,
graph,
graph_clear_operation_func,
&settings);
}
Depsgraph: Cleanup and code simplification This is mainly a maintenance commit which was aimed to make work with this module more pleasant and solve such issues as: - Annoyance with looong files, which had craftload in them - Usage of STL for the data structures we've got in BLI - Possible symbol conflicts - Not real clear layout of what is located where So in this commit the following changes are done: - STL is prohibited, it's not really predictable on various compilers, with our BLI algorithms we can predict things much better. There are still few usages of std::vector, but that we'll be solving later once we've got similar thing in BLI. - Simplify foreach loops, avoid using const_iterator all over the place. - New directory layout, which is hopefully easier to follow. - Some files were split, some of them will be split soon. The idea of this is to split huge functions into own files with good documentation and everything. - Removed stuff which was planned for use in the future but was never finished, tested or anything. Let's wipe it out for now, and bring back once we really start using it, so it'll be more clear if it solves our needs. - All the internal routines were moved to DEG namespace to separate them better from rest of blender. Some places now annoyingly using DEG::foo, but that we can olve by moving some utility functions inside of the namespace. While working on this we've found some hotspot in updates flush, so now playback of blenrig is few percent faster (something like 96fps with previous master and around 99-100fps after this change). Not saying it's something final, there is still room for cleanup and API simplification, but those might happen as a regular development now without doing any global changes.
2016-05-27 18:01:18 +02:00
/* Clear any entry tags which haven't been flushed. */
BLI_gset_clear(graph->entry_tags, NULL);
}
} // namespace DEG
Copy Permalink