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
0c51010c67f70fa901b74d941c041f06df50201a
blender-archive/source/blender/blenkernel/BKE_depsgraph.h

169 lines
6.1 KiB
C++
Raw Normal View History

doxygen: blenkernel under core as module.
2011-02-18 13:05:18 +00:00
/*
Patch from GSR that a) fixes a whole bunch of GPL/BL license blocks that were previously missed; and b) greatly increase my ohloh stats!
2008-04-16 22:40:48 +00:00
* ***** BEGIN GPL LICENSE BLOCK *****
Dependency graph patch, provided by Jean-Luc Peuriere. Works like a charm... well it now replaces the old base-sorting hack. :) Next stage will be to define how to further integrate it. Plus some minor code cleanups... static/internal functions versus external, etc.
2005-04-30 21:27:05 +00:00
*
* 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
Patch from GSR that a) fixes a whole bunch of GPL/BL license blocks that were previously missed; and b) greatly increase my ohloh stats!
2008-04-16 22:40:48 +00:00
* of the License, or (at your option) any later version.
Dependency graph patch, provided by Jean-Luc Peuriere. Works like a charm... well it now replaces the old base-sorting hack. :) Next stage will be to define how to further integrate it. Plus some minor code cleanups... static/internal functions versus external, etc.
2005-04-30 21:27:05 +00:00
*
* 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,
correct fsf address
2010-02-12 13:34:04 +00:00
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
Dependency graph patch, provided by Jean-Luc Peuriere. Works like a charm... well it now replaces the old base-sorting hack. :) Next stage will be to define how to further integrate it. Plus some minor code cleanups... static/internal functions versus external, etc.
2005-04-30 21:27:05 +00:00
*
* The Original Code is Copyright (C) 2004 Blender Foundation.
* All rights reserved.
*
* Contributor(s): none yet.
*
Patch from GSR that a) fixes a whole bunch of GPL/BL license blocks that were previously missed; and b) greatly increase my ohloh stats!
2008-04-16 22:40:48 +00:00
* ***** END GPL LICENSE BLOCK *****
Dependency graph patch, provided by Jean-Luc Peuriere. Works like a charm... well it now replaces the old base-sorting hack. :) Next stage will be to define how to further integrate it. Plus some minor code cleanups... static/internal functions versus external, etc.
2005-04-30 21:27:05 +00:00
*/
unify include guard defines, __$FILENAME__ without the underscores these clogged up the namespace for autocompleation which was annoying.
2012-02-17 18:59:41 +00:00
#ifndef __BKE_DEPSGRAPH_H__
#define __BKE_DEPSGRAPH_H__
Dependency graph patch, provided by Jean-Luc Peuriere. Works like a charm... well it now replaces the old base-sorting hack. :) Next stage will be to define how to further integrate it. Plus some minor code cleanups... static/internal functions versus external, etc.
2005-04-30 21:27:05 +00:00
doxygen: blenkernel under core as module.
2011-02-18 13:05:18 +00:00
/** \file BKE_depsgraph.h
* \ingroup bke
*/
Dependency Graph: refactoring to move private functions to the private header, and add more documentation about the public functions. Also removed unused graph traversal code and other minor unused functions.
2013-02-26 18:15:51 +00:00
/* Dependency Graph
*
* The dependency graph tracks relations between datablocks, and is used to
* determine which datablocks need to be update based on dependencies and
* visibility.
*
* It does not itself execute changes in objects, but rather sorts the objects
* in the appropriate order and sets flags indicating they should be updated.
*/
Reorganisation of COLLADA import code. Classes have been split into their own files. No functional changes. Where necessary extern "C" {} blocks have been added.
2010-10-05 00:05:14 +00:00
#ifdef __cplusplus
extern "C" {
#endif
Code cleanup: move render baking code into own file.
2013-01-23 13:13:16 +00:00
struct ID;
struct Main;
struct Object;
struct Scene;
Threaded object update and EvaluationContext Summary: Made objects update happening from multiple threads. It is a task-based scheduling system which uses current dependency graph for spawning new tasks. This means threading happens on object level, but the system is flexible enough for higher granularity. Technical details: - Uses task scheduler which was recently committed to trunk (that one which Brecht ported from Cycles). - Added two utility functions to dependency graph: * DAG_threaded_update_begin, which is called to initialize threaded objects update. It will also schedule root DAG node to the queue, hence starting evaluation process. Initialization will calculate how much parents are to be evaluation before current DAG node can be scheduled. This value is used by task threads for faster detecting which nodes might be scheduled. * DAG_threaded_update_handle_node_updated which is called from task thread function when node was fully handled. This function decreases num_pending_parents of node children and schedules children with zero valency. As it might have become clear, task thread receives DAG nodes and decides which callback to call for it. Currently only BKE_object_handle_update is called for object nodes. In the future it'll call node->callback() from Ali's new DAG. - This required adding some workarounds to the render pipeline. Mainly to stop using get_object_dm() from modifiers' apply callback. Such a call was only a workaround for dependency graph glitch when rendering scene with, say, boolean modifiers before displaying this scene. Such change moves workaround from one place to another, so overall hackentropy remains the same. - Added paradigm of EvaluaitonContext. Currently it's more like just a more reliable replacement for G.is_rendering which fails in some circumstances. Future idea of this context is to also store all the local data needed for objects evaluation such as local time, Copy-on-Write data and so. There're two types of EvaluationContext: * Context used for viewport updated and owned by Main. In the future this context might be easily moved to Window or Screen to allo per-window/per-screen local time. * Context used by render engines to evaluate objects for render purposes. Render engine is an owner of this context. This context is passed to all object update routines. Reviewers: brecht, campbellbarton Reviewed By: brecht CC: lukastoenne Differential Revision: https://developer.blender.org/D94
2013-12-26 17:24:42 +06:00
struct ListBase;
/* Dependency graph evaluation context
*
* This structure stores all the local dependency graph data,
* which is needed for it's evaluation,
*/
typedef struct EvaluationContext {
bool for_render; /* Set to true if evaluation shall be performed for render purposes,
keep at false if update shall happen for the viewport. */
} EvaluationContext;
Remove direct displist creation from curve deform This solves threading conflict which happens when having multiple objects using Curve Deform modifier with the same curve datablock. This conflict was caused by the fact that curve_deform_verts() used to temporary override curve's flags to make it path is there. Actually, it was setting CU_FOLLOW flag temporary which was only used where_on_path() (only in terms that this temporary assignment only affected this function) but it is now commented out for a while, so no reason to set this flag temporary, If it's ever to be done, we'll need to pass flags as an additional function argument. For the path creation i've extended DegNode structure which now holds extra bits which indicates what additional data depending on the graph topology is to be evaluated. Currently this is only used to indicate that curve needs path to be evaluated regardless to cu->flag state. This is so Curve Deform modifier is always happy. In the future this flag might also be used to indicate whether bmesh verts are to update (see recent commit to 3-vertex parent crash fix) or to indicate that the object is the motherball etc.
2014-01-10 01:45:53 +06:00
/* DagNode->eval_flags */
enum {
/* Regardless to curve->path animation flag path is to be evaluated anyway,
* to meet dependencies with such a things as curve modifier and other guys
* who're using curve deform, where_on_path and so.
*/
DAG_EVAL_NEED_CURVE_PATH = 1,
};
Threaded object update and EvaluationContext Summary: Made objects update happening from multiple threads. It is a task-based scheduling system which uses current dependency graph for spawning new tasks. This means threading happens on object level, but the system is flexible enough for higher granularity. Technical details: - Uses task scheduler which was recently committed to trunk (that one which Brecht ported from Cycles). - Added two utility functions to dependency graph: * DAG_threaded_update_begin, which is called to initialize threaded objects update. It will also schedule root DAG node to the queue, hence starting evaluation process. Initialization will calculate how much parents are to be evaluation before current DAG node can be scheduled. This value is used by task threads for faster detecting which nodes might be scheduled. * DAG_threaded_update_handle_node_updated which is called from task thread function when node was fully handled. This function decreases num_pending_parents of node children and schedules children with zero valency. As it might have become clear, task thread receives DAG nodes and decides which callback to call for it. Currently only BKE_object_handle_update is called for object nodes. In the future it'll call node->callback() from Ali's new DAG. - This required adding some workarounds to the render pipeline. Mainly to stop using get_object_dm() from modifiers' apply callback. Such a call was only a workaround for dependency graph glitch when rendering scene with, say, boolean modifiers before displaying this scene. Such change moves workaround from one place to another, so overall hackentropy remains the same. - Added paradigm of EvaluaitonContext. Currently it's more like just a more reliable replacement for G.is_rendering which fails in some circumstances. Future idea of this context is to also store all the local data needed for objects evaluation such as local time, Copy-on-Write data and so. There're two types of EvaluationContext: * Context used for viewport updated and owned by Main. In the future this context might be easily moved to Window or Screen to allo per-window/per-screen local time. * Context used by render engines to evaluate objects for render purposes. Render engine is an owner of this context. This context is passed to all object update routines. Reviewers: brecht, campbellbarton Reviewed By: brecht CC: lukastoenne Differential Revision: https://developer.blender.org/D94
2013-12-26 17:24:42 +06:00
/* Global initialization/deinitialization */
void DAG_init(void);
void DAG_exit(void);
Dependency graph patch, provided by Jean-Luc Peuriere. Works like a charm... well it now replaces the old base-sorting hack. :) Next stage will be to define how to further integrate it. Plus some minor code cleanups... static/internal functions versus external, etc.
2005-04-30 21:27:05 +00:00
Dependency Graph: refactoring to move private functions to the private header, and add more documentation about the public functions. Also removed unused graph traversal code and other minor unused functions.
2013-02-26 18:15:51 +00:00
/* Build and Update
*
* DAG_scene_relations_update will rebuild the dependency graph for a given
* scene if needed, and sort objects in the scene.
*
* DAG_relations_tag_update will clear all dependency graphs and mark them to
* be rebuilt later. The graph is not rebuilt immediately to avoid slowdowns
* when this function is call multiple times from different operators.
*
* DAG_scene_relations_rebuild forces an immediaterebuild of the dependency
* graph, this is only needed in rare cases
*/
void DAG_scene_relations_update(struct Main *bmain, struct Scene *sce);
void DAG_relations_tag_update(struct Main *bmain);
void DAG_scene_relations_rebuild(struct Main *bmain, struct Scene *scene);
Fix build error in depsgraph refactoring commit.
2013-02-26 20:34:37 +00:00
void DAG_scene_free(struct Scene *sce);
Dependency Graph: refactoring to move private functions to the private header, and add more documentation about the public functions. Also removed unused graph traversal code and other minor unused functions.
2013-02-26 18:15:51 +00:00
/* Update Tagging
*
* DAG_scene_update_flags will mark all objects that depend on time (animation,
* physics, ..) to be recalculated, used when changing the current frame.
*
* DAG_on_visible_update will mark all objects that are visible for the first
* time to be updated, for example on file load or changing layer visibility.
*
* DAG_id_tag_update will mark a given datablock to be updated. The flag indicates
* a specific subset to be update (only object transform and data for now).
*
* DAG_id_type_tag marks a particular datablock type as having changing. This does
* not cause any updates but is used by external render engines to detect if for
* example a datablock was removed. */
Fix T38824: curve which is constrained on a hidden layer causes cycles crash Issue was caused by cycles setting scene frame which will update scene for all the layers (not just visible ones) which confuses depsgraph making objects which are needed as dependency are not really evaluated. Made it so setting frame via scene.frame_set() which check whether update need to be flushed to an invisible objects and do this if so. Not ideal solution but seems to be safest at this point.
2014-02-25 15:44:39 +06:00
void DAG_scene_update_flags(struct Main *bmain, struct Scene *sce, unsigned int lay, const bool do_time, const bool do_invisible_flush);
Code cleanup: use bools where possible
2014-02-03 18:55:59 +11:00
void DAG_on_visible_update(struct Main *bmain, const bool do_time);
Dependency Graph: refactoring to move private functions to the private header, and add more documentation about the public functions. Also removed unused graph traversal code and other minor unused functions.
2013-02-26 18:15:51 +00:00
void DAG_id_tag_update(struct ID *id, short flag);
void DAG_id_tag_update_ex(struct Main *bmain, struct ID *id, short flag);
void DAG_id_type_tag(struct Main *bmain, short idtype);
int DAG_id_type_tagged(struct Main *bmain, short idtype);
/* Flushing Tags
*
* DAG_scene_flush_update flushes object recalculation flags immediately to other
* dependencies. Do not use outside of depsgraph.c, this will be removed.
*
* DAG_ids_flush_tagged will flush datablock update flags flags to dependencies,
* use this right before updating to mark all the needed datablocks for update.
*
* DAG_ids_check_recalc and DAG_ids_clear_recalc are used for external render
* engines to detect changes. */
void DAG_scene_flush_update(struct Main *bmain, struct Scene *sce, unsigned int lay, const short do_time);
void DAG_ids_flush_tagged(struct Main *bmain);
Code cleanup: remove TRUE/FALSE & WITH_BOOL_COMPAT define
2014-04-01 11:34:00 +11:00
void DAG_ids_check_recalc(struct Main *bmain, struct Scene *scene, bool time);
Fix T38260: Missing object update with two visible scenes It was an issue with early object update check which was screwing up for second scene because of first one reset ID recalc flags. From the comment in the code about this: We need to check all visible scenes, otherwise resetting OB_ID changed flag will only work fine for first scene of multiple visible and all the rest will skip update. This could also lead to wrong behavior scene update handlers because of missing ID datablock changed flags. This is a bit of a bummer to allocate list here, but likely it wouldn't become too much bad because it only happens when objects were actually changed.
2014-01-17 18:51:31 +06:00
void DAG_ids_clear_recalc(struct Main *bmain);
Dependency Graph: refactoring to move private functions to the private header, and add more documentation about the public functions. Also removed unused graph traversal code and other minor unused functions.
2013-02-26 18:15:51 +00:00
/* Armature: sorts the bones according to dependencies between them */
void DAG_pose_sort(struct Object *ob);
/* Editors: callbacks to notify editors of datablock changes */
void DAG_editors_update_cb(void (*id_func)(struct Main *bmain, struct ID *id),
void (*scene_func)(struct Main *bmain, struct Scene *scene, int updated));
Threaded object update and EvaluationContext Summary: Made objects update happening from multiple threads. It is a task-based scheduling system which uses current dependency graph for spawning new tasks. This means threading happens on object level, but the system is flexible enough for higher granularity. Technical details: - Uses task scheduler which was recently committed to trunk (that one which Brecht ported from Cycles). - Added two utility functions to dependency graph: * DAG_threaded_update_begin, which is called to initialize threaded objects update. It will also schedule root DAG node to the queue, hence starting evaluation process. Initialization will calculate how much parents are to be evaluation before current DAG node can be scheduled. This value is used by task threads for faster detecting which nodes might be scheduled. * DAG_threaded_update_handle_node_updated which is called from task thread function when node was fully handled. This function decreases num_pending_parents of node children and schedules children with zero valency. As it might have become clear, task thread receives DAG nodes and decides which callback to call for it. Currently only BKE_object_handle_update is called for object nodes. In the future it'll call node->callback() from Ali's new DAG. - This required adding some workarounds to the render pipeline. Mainly to stop using get_object_dm() from modifiers' apply callback. Such a call was only a workaround for dependency graph glitch when rendering scene with, say, boolean modifiers before displaying this scene. Such change moves workaround from one place to another, so overall hackentropy remains the same. - Added paradigm of EvaluaitonContext. Currently it's more like just a more reliable replacement for G.is_rendering which fails in some circumstances. Future idea of this context is to also store all the local data needed for objects evaluation such as local time, Copy-on-Write data and so. There're two types of EvaluationContext: * Context used for viewport updated and owned by Main. In the future this context might be easily moved to Window or Screen to allo per-window/per-screen local time. * Context used by render engines to evaluate objects for render purposes. Render engine is an owner of this context. This context is passed to all object update routines. Reviewers: brecht, campbellbarton Reviewed By: brecht CC: lukastoenne Differential Revision: https://developer.blender.org/D94
2013-12-26 17:24:42 +06:00
/* ** Threaded update ** */
/* Initialize the DAG for threaded update. */
void DAG_threaded_update_begin(struct Scene *scene,
void (*func)(void *node, void *user_data),
void *user_data);
void DAG_threaded_update_handle_node_updated(void *node_v,
void (*func)(void *node, void *user_data),
void *user_data);
Dependency Graph: refactoring to move private functions to the private header, and add more documentation about the public functions. Also removed unused graph traversal code and other minor unused functions.
2013-02-26 18:15:51 +00:00
/* Debugging: print dependency graph for scene or armature object to console */
void DAG_print_dependencies(struct Main *bmain, struct Scene *scene, struct Object *ob);
Depsgraph: add "Dependency Relations" operator to print the dependency graph to the console, useful for debugging and understanding the relations.
2011-11-04 13:17:35 +00:00
Code cleanup: remove WIP code came from the GSoC branch DAG node tagging was rather an experiment to make derived render working. However, it ended up in a whole can of worms and need to be re-considered. It is likely that regular object update tagging and scene update routines are to be used for this. Meanwhile no need to keep extra field in dag node. Would save us the whole byte of the struct which we can use for other purposes meanwhile.
2014-01-10 01:23:49 +06:00
/* ************************ DAG querying ********************* */
Threaded object update and EvaluationContext Summary: Made objects update happening from multiple threads. It is a task-based scheduling system which uses current dependency graph for spawning new tasks. This means threading happens on object level, but the system is flexible enough for higher granularity. Technical details: - Uses task scheduler which was recently committed to trunk (that one which Brecht ported from Cycles). - Added two utility functions to dependency graph: * DAG_threaded_update_begin, which is called to initialize threaded objects update. It will also schedule root DAG node to the queue, hence starting evaluation process. Initialization will calculate how much parents are to be evaluation before current DAG node can be scheduled. This value is used by task threads for faster detecting which nodes might be scheduled. * DAG_threaded_update_handle_node_updated which is called from task thread function when node was fully handled. This function decreases num_pending_parents of node children and schedules children with zero valency. As it might have become clear, task thread receives DAG nodes and decides which callback to call for it. Currently only BKE_object_handle_update is called for object nodes. In the future it'll call node->callback() from Ali's new DAG. - This required adding some workarounds to the render pipeline. Mainly to stop using get_object_dm() from modifiers' apply callback. Such a call was only a workaround for dependency graph glitch when rendering scene with, say, boolean modifiers before displaying this scene. Such change moves workaround from one place to another, so overall hackentropy remains the same. - Added paradigm of EvaluaitonContext. Currently it's more like just a more reliable replacement for G.is_rendering which fails in some circumstances. Future idea of this context is to also store all the local data needed for objects evaluation such as local time, Copy-on-Write data and so. There're two types of EvaluationContext: * Context used for viewport updated and owned by Main. In the future this context might be easily moved to Window or Screen to allo per-window/per-screen local time. * Context used by render engines to evaluate objects for render purposes. Render engine is an owner of this context. This context is passed to all object update routines. Reviewers: brecht, campbellbarton Reviewed By: brecht CC: lukastoenne Differential Revision: https://developer.blender.org/D94
2013-12-26 17:24:42 +06:00
struct Object *DAG_get_node_object(void *node_v);
Fix crash happening in DAG_pose_sort() due to threading issues This function used ugly hack with static variable which was preventing some type checks in DAG nodes. Using this variable form multiple threads is not considered safe, apparently. Solved by moving this variable inside the DAGForest structure. so it's global for the graph now, but different graphs does not run into conflicts. This required passing the forest to some functions, which doesn't look so much nice, but don't want to spend time on making this code look beautiful because it is really to be replaced by the new dependency graph. This is really bad bug actually which is must go to 'a'.
2014-04-04 12:42:35 +06:00
const char *DAG_get_node_name(struct Scene *scene, void *node_v);
Remove direct displist creation from curve deform This solves threading conflict which happens when having multiple objects using Curve Deform modifier with the same curve datablock. This conflict was caused by the fact that curve_deform_verts() used to temporary override curve's flags to make it path is there. Actually, it was setting CU_FOLLOW flag temporary which was only used where_on_path() (only in terms that this temporary assignment only affected this function) but it is now commented out for a while, so no reason to set this flag temporary, If it's ever to be done, we'll need to pass flags as an additional function argument. For the path creation i've extended DegNode structure which now holds extra bits which indicates what additional data depending on the graph topology is to be evaluated. Currently this is only used to indicate that curve needs path to be evaluated regardless to cu->flag state. This is so Curve Deform modifier is always happy. In the future this flag might also be used to indicate whether bmesh verts are to update (see recent commit to 3-vertex parent crash fix) or to indicate that the object is the motherball etc.
2014-01-10 01:45:53 +06:00
short DAG_get_eval_flags_for_object(struct Scene *scene, void *object);
Fix T38139: Objects which are in cyclic dependency are not updated Graph traversal which is based on counting parents which are still to be updated fails in cases there are cycles in the graph. If there are cyclic dependencies in the scene all the objects from the cycles will be updated in a single thread now one by one. This makes blender behave the same way as it was before multi-threaded DAG landed to master. This needed to tweak depsgraph a bit so now dag_check_cycle() sets is_acyclic field of DAG forest if there are cycles in the graph. TODO: It might be possible to save some time on evaluation when all the tagged objects were updated in multi-threaded DAG traversal.
2014-01-10 15:39:06 +06:00
bool DAG_is_acyclic(struct Scene *scene);
Threaded object update and EvaluationContext Summary: Made objects update happening from multiple threads. It is a task-based scheduling system which uses current dependency graph for spawning new tasks. This means threading happens on object level, but the system is flexible enough for higher granularity. Technical details: - Uses task scheduler which was recently committed to trunk (that one which Brecht ported from Cycles). - Added two utility functions to dependency graph: * DAG_threaded_update_begin, which is called to initialize threaded objects update. It will also schedule root DAG node to the queue, hence starting evaluation process. Initialization will calculate how much parents are to be evaluation before current DAG node can be scheduled. This value is used by task threads for faster detecting which nodes might be scheduled. * DAG_threaded_update_handle_node_updated which is called from task thread function when node was fully handled. This function decreases num_pending_parents of node children and schedules children with zero valency. As it might have become clear, task thread receives DAG nodes and decides which callback to call for it. Currently only BKE_object_handle_update is called for object nodes. In the future it'll call node->callback() from Ali's new DAG. - This required adding some workarounds to the render pipeline. Mainly to stop using get_object_dm() from modifiers' apply callback. Such a call was only a workaround for dependency graph glitch when rendering scene with, say, boolean modifiers before displaying this scene. Such change moves workaround from one place to another, so overall hackentropy remains the same. - Added paradigm of EvaluaitonContext. Currently it's more like just a more reliable replacement for G.is_rendering which fails in some circumstances. Future idea of this context is to also store all the local data needed for objects evaluation such as local time, Copy-on-Write data and so. There're two types of EvaluationContext: * Context used for viewport updated and owned by Main. In the future this context might be easily moved to Window or Screen to allo per-window/per-screen local time. * Context used by render engines to evaluate objects for render purposes. Render engine is an owner of this context. This context is passed to all object update routines. Reviewers: brecht, campbellbarton Reviewed By: brecht CC: lukastoenne Differential Revision: https://developer.blender.org/D94
2013-12-26 17:24:42 +06:00
Reorganisation of COLLADA import code. Classes have been split into their own files. No functional changes. Where necessary extern "C" {} blocks have been added.
2010-10-05 00:05:14 +00:00
#ifdef __cplusplus
}
#endif
Big commit with work on Groups & Libraries: -> Any Group Duplicate now can get local timing and local NLA override. This enables to control the entire animation system of the Group. Two methods for this have been implemented. 1) The quick way: just give the duplicator a "Startframe" offset. 2) Advanced: in the NLA Editor you can add ActionStrips to the duplicator to override NLA/action of any Grouped Object. For "Group NLA" to work, an ActionStrip needs to know which Object in a group it controls. On adding a strip, the code checks if an Action was already used by an Object in the Group, and assigns it automatic to that Object. You can also set this in the Nkey "Properties" panel for the strip. Change in NLA: the SHIFT+A "Add strip" command now always adds strips to the active Object. (It used to check where mouse was). This allows to add NLA strips to Objects that didn't have actions/nla yet. Important note: In Blender, duplicates are fully procedural and generated on the fly for each redraw. This means that redraw speed equals to stepping through frames, when using animated Duplicated Groups. -> Recoded entire duplicator system The old method was antique and clumsy, using globals and full temporal copies of Object. The new system is nicer in control, faster, and since it doesn't use temporal object copies anymore, it works better with Derived Mesh and DisplayList and rendering. By centralizing the code for duplicating, more options can be easier added. Features to note: - Duplicates now draw selected/unselected based on its Duplicator setting. - Same goes for the drawtype (wire, solid, selection outline, etc) - Duplicated Groups can be normally selected too Bonus goodie: SHIFT+A (Toolbox) now has entry "Add group" too, with a listing of all groups, allowing to add Group instances immediate. -> Library System - SHIFT+F4 data browse now shows the entire path for linked data - Outliner draws Library Icons to denote linked data - Outliner operation added: "Make Local" for library data. - Outliner now also draws Groups in regular view, allowing to unlink too. -> Fixes - depsgraph missed signal update for bone-parented Objects - on reading file, the entire database was tagged to "recalc" fully, causing unnecessary slowdown on reading. Might have missed stuff... :)
2005-12-11 13:23:30 +00:00
fix 'no newline at end of file' warnings
2005-04-30 23:29:10 +00:00
#endif
Copy Permalink