Mesh Remap: Face Corner Data: Do not use large epsilon values to create bvhtrees.
[blender.git] / source / blender / blenkernel / BKE_depsgraph.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2004 Blender Foundation.
19  * All rights reserved.
20  *
21  * Contributor(s): none yet.
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 #ifndef __BKE_DEPSGRAPH_H__
27 #define __BKE_DEPSGRAPH_H__
28
29 /** \file BKE_depsgraph.h
30  *  \ingroup bke
31  */
32
33 /* Dependency Graph
34  *
35  * The dependency graph tracks relations between datablocks, and is used to
36  * determine which datablocks need to be update based on dependencies and
37  * visibility.
38  *
39  * It does not itself execute changes in objects, but rather sorts the objects
40  * in the appropriate order and sets flags indicating they should be updated.
41  */
42
43 #ifdef __cplusplus
44 extern "C" {
45 #endif
46
47 struct ID;
48 struct Main;
49 struct Object;
50 struct Scene;
51
52 /* Dependency graph evaluation context
53  *
54  * This structure stores all the local dependency graph data,
55  * which is needed for it's evaluation,
56  */
57 typedef struct EvaluationContext {
58         int mode;               /* evaluation mode */
59         float ctime;            /* evaluation time */
60 } EvaluationContext;
61
62 typedef enum eEvaluationMode {
63         DAG_EVAL_VIEWPORT       = 0,    /* evaluate for OpenGL viewport */
64         DAG_EVAL_PREVIEW        = 1,    /* evaluate for render with preview settings */
65         DAG_EVAL_RENDER         = 2,    /* evaluate for render purposes */
66 } eEvaluationMode;
67
68 /* DagNode->eval_flags */
69 enum {
70         /* Regardless to curve->path animation flag path is to be evaluated anyway,
71          * to meet dependencies with such a things as curve modifier and other guys
72          * who're using curve deform, where_on_path and so.
73          */
74         DAG_EVAL_NEED_CURVE_PATH = 1,
75         /* Scene evaluation would need to have object's data on CPU,
76          * meaning no GPU shortcuts is allowed.
77          */
78         DAG_EVAL_NEED_CPU        = 2,
79 };
80
81 /* Global initialization/deinitialization */
82 void DAG_init(void);
83 void DAG_exit(void);
84
85 /* Build and Update
86  *
87  * DAG_scene_relations_update will rebuild the dependency graph for a given
88  * scene if needed, and sort objects in the scene.
89  *
90  * DAG_relations_tag_update will clear all dependency graphs and mark them to
91  * be rebuilt later. The graph is not rebuilt immediately to avoid slowdowns
92  * when this function is call multiple times from different operators.
93  *
94  * DAG_scene_relations_rebuild forces an immediaterebuild of the dependency
95  * graph, this is only needed in rare cases
96  */
97
98 void DAG_scene_relations_update(struct Main *bmain, struct Scene *sce);
99 void DAG_scene_relations_validate(struct Main *bmain, struct Scene *sce);
100 void DAG_relations_tag_update(struct Main *bmain);
101 void DAG_scene_relations_rebuild(struct Main *bmain, struct Scene *scene);
102 void DAG_scene_free(struct Scene *sce);
103
104 /* Update Tagging
105  *
106  * DAG_scene_update_flags will mark all objects that depend on time (animation,
107  * physics, ..) to be recalculated, used when changing the current frame.
108  * 
109  * DAG_on_visible_update will mark all objects that are visible for the first
110  * time to be updated, for example on file load or changing layer visibility.
111  *
112  * DAG_id_tag_update will mark a given datablock to be updated. The flag indicates
113  * a specific subset to be update (only object transform and data for now).
114  *
115  * DAG_id_type_tag marks a particular datablock type as having changing. This does
116  * not cause any updates but is used by external render engines to detect if for
117  * example a datablock was removed. */
118
119 void DAG_scene_update_flags(struct Main *bmain, struct Scene *sce, unsigned int lay, const bool do_time, const bool do_invisible_flush);
120 void DAG_on_visible_update(struct Main *bmain, const bool do_time);
121
122 void DAG_id_tag_update(struct ID *id, short flag);
123 void DAG_id_tag_update_ex(struct Main *bmain, struct ID *id, short flag);
124 void DAG_id_type_tag(struct Main *bmain, short idtype);
125 int  DAG_id_type_tagged(struct Main *bmain, short idtype);
126
127 /* Flushing Tags
128  *
129  * DAG_scene_flush_update flushes object recalculation flags immediately to other
130  * dependencies. Do not use outside of depsgraph.c, this will be removed.
131  *
132  * DAG_ids_flush_tagged will flush datablock update flags flags to dependencies,
133  * use this right before updating to mark all the needed datablocks for update.
134  *
135  * DAG_ids_check_recalc and DAG_ids_clear_recalc are used for external render
136  * engines to detect changes. */
137
138 void DAG_scene_flush_update(struct Main *bmain, struct Scene *sce, unsigned int lay, const short do_time);
139 void DAG_ids_flush_tagged(struct Main *bmain);
140 void DAG_ids_check_recalc(struct Main *bmain, struct Scene *scene, bool time);
141 void DAG_ids_clear_recalc(struct Main *bmain);
142
143 /* Armature: sorts the bones according to dependencies between them */
144
145 void DAG_pose_sort(struct Object *ob);
146
147 /* Editors: callbacks to notify editors of datablock changes */
148
149 void DAG_editors_update_cb(void (*id_func)(struct Main *bmain, struct ID *id),
150                            void (*scene_func)(struct Main *bmain, struct Scene *scene, int updated),
151                            void (*scene_pre_func)(struct Main *bmain, struct Scene *scene, bool time));
152
153 void DAG_editors_update_pre(struct Main *bmain, struct Scene *scene, bool time);
154
155 /* ** Threaded update ** */
156
157 /* Initialize the DAG for threaded update. */
158 void DAG_threaded_update_begin(struct Scene *scene,
159                                void (*func)(void *node, void *user_data),
160                                void *user_data);
161
162 void DAG_threaded_update_handle_node_updated(void *node_v,
163                                              void (*func)(void *node, void *user_data),
164                                              void *user_data);
165
166 /* Debugging: print dependency graph for scene or armature object to console */
167
168 void DAG_print_dependencies(struct Main *bmain, struct Scene *scene, struct Object *ob);
169
170 /* ************************ DAG querying ********************* */
171
172 struct Object *DAG_get_node_object(void *node_v);
173 const char *DAG_get_node_name(struct Scene *scene, void *node_v);
174 short DAG_get_eval_flags_for_object(struct Scene *scene, void *object);
175 bool DAG_is_acyclic(struct Scene *scene);
176
177 #ifdef __cplusplus
178 }
179 #endif
180                 
181 #endif