Depsgraph: Copy-on-write component does not depend on itself
[blender.git] / source / blender / depsgraph / intern / nodes / deg_node_component.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) 2013 Blender Foundation.
19  * All rights reserved.
20  *
21  * Original Author: Joshua Leung
22  * Contributor(s): None Yet
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file blender/depsgraph/intern/nodes/deg_node_component.h
28  *  \ingroup depsgraph
29  */
30
31 #pragma once
32
33 #include "intern/nodes/deg_node.h"
34
35 #include "BLI_utildefines.h"
36 #include "BLI_string.h"
37
38 struct ID;
39 struct bPoseChannel;
40 struct GHash;
41
42 struct EvaluationContext;
43
44 namespace DEG {
45
46 struct Depsgraph;
47 struct OperationDepsNode;
48 struct BoneComponentDepsNode;
49
50 /* ID Component - Base type for all components */
51 struct ComponentDepsNode : public DepsNode {
52         /* Key used to look up operations within a component */
53         struct OperationIDKey
54         {
55                 eDepsOperation_Code opcode;
56                 const char *name;
57                 int name_tag;
58
59                 OperationIDKey();
60                 OperationIDKey(eDepsOperation_Code opcode);
61                 OperationIDKey(eDepsOperation_Code opcode,
62                                const char *name,
63                                int name_tag);
64
65                 string identifier() const;
66                 bool operator==(const OperationIDKey &other) const;
67         };
68
69         /* Typedef for container of operations */
70         ComponentDepsNode();
71         ~ComponentDepsNode();
72
73         void init(const ID *id, const char *subdata);
74
75         string identifier() const;
76
77         /* Find an existing operation, will throw an assert() if it does not exist. */
78         OperationDepsNode *find_operation(OperationIDKey key) const;
79         OperationDepsNode *find_operation(eDepsOperation_Code opcode,
80                                           const char *name,
81                                           int name_tag) const;
82
83         /* Check operation exists and return it. */
84         OperationDepsNode *has_operation(OperationIDKey key) const;
85         OperationDepsNode *has_operation(eDepsOperation_Code opcode,
86                                          const char *name,
87                                          int name_tag) const;
88
89         /**
90          * Create a new node for representing an operation and add this to graph
91          * \warning If an existing node is found, it will be modified. This helps
92          * when node may have been partially created earlier (e.g. parent ref before
93          * parent item is added)
94          *
95          * \param type: Operation node type (corresponding to context/component that
96          *              it operates in)
97          * \param optype: Role that operation plays within component
98          *                (i.e. where in eval process)
99          * \param op: The operation to perform
100          * \param name: Identifier for operation - used to find/locate it again
101          */
102         OperationDepsNode *add_operation(const DepsEvalOperationCb& op,
103                                          eDepsOperation_Code opcode,
104                                          const char *name,
105                                          int name_tag);
106
107         /* Entry/exit operations management.
108          *
109          * Use those instead of direct set since this will perform sanity checks.
110          */
111         void set_entry_operation(OperationDepsNode *op_node);
112         void set_exit_operation(OperationDepsNode *op_node);
113
114         void clear_operations();
115
116         void tag_update(Depsgraph *graph);
117
118         /* Evaluation Context Management .................. */
119
120         /* Initialize component's evaluation context used for the specified
121          * purpose.
122          */
123         virtual bool eval_context_init(EvaluationContext * /*eval_ctx*/) { return false; }
124         /* Free data in component's evaluation context which is used for
125          * the specified purpose
126          *
127          * NOTE: this does not free the actual context in question
128          */
129         virtual void eval_context_free(EvaluationContext * /*eval_ctx*/) {}
130
131         OperationDepsNode *get_entry_operation();
132         OperationDepsNode *get_exit_operation();
133
134         void finalize_build(Depsgraph *graph);
135
136         IDDepsNode *owner;
137
138         /* ** Inner nodes for this component ** */
139
140         /* Operations stored as a hash map, for faster build.
141          * This hash map will be freed when graph is fully built.
142          */
143         GHash *operations_map;
144
145         /* This is a "normal" list of operations, used by evaluation
146          * and other routines after construction.
147          */
148         vector<OperationDepsNode *> operations;
149
150         OperationDepsNode *entry_operation;
151         OperationDepsNode *exit_operation;
152
153         // XXX: a poll() callback to check if component's first node can be started?
154         virtual bool depends_on_cow() { return true; }
155 };
156
157 /* ---------------------------------------- */
158
159 struct ParametersComponentDepsNode : public ComponentDepsNode {
160         DEG_DEPSNODE_DECLARE;
161 };
162
163 struct AnimationComponentDepsNode : public ComponentDepsNode {
164         DEG_DEPSNODE_DECLARE;
165 };
166
167 struct TransformComponentDepsNode : public ComponentDepsNode {
168         DEG_DEPSNODE_DECLARE;
169 };
170
171 struct ProxyComponentDepsNode : public ComponentDepsNode {
172         DEG_DEPSNODE_DECLARE;
173 };
174
175 struct GeometryComponentDepsNode : public ComponentDepsNode {
176         DEG_DEPSNODE_DECLARE;
177 };
178
179 struct SequencerComponentDepsNode : public ComponentDepsNode {
180         DEG_DEPSNODE_DECLARE;
181 };
182
183 struct PoseComponentDepsNode : public ComponentDepsNode {
184         DEG_DEPSNODE_DECLARE;
185 };
186
187 /* Bone Component */
188 struct BoneComponentDepsNode : public ComponentDepsNode {
189         void init(const ID *id, const char *subdata);
190
191         struct bPoseChannel *pchan;     /* the bone that this component represents */
192
193         DEG_DEPSNODE_DECLARE;
194 };
195
196 struct ParticlesComponentDepsNode : public ComponentDepsNode {
197         DEG_DEPSNODE_DECLARE;
198 };
199
200 struct ShadingComponentDepsNode : public ComponentDepsNode {
201         DEG_DEPSNODE_DECLARE;
202 };
203
204 struct ShadingParametersComponentDepsNode : public ComponentDepsNode {
205         DEG_DEPSNODE_DECLARE;
206         virtual bool depends_on_cow() { return false; }
207 };
208
209 struct CacheComponentDepsNode : public ComponentDepsNode {
210         DEG_DEPSNODE_DECLARE;
211 };
212
213 struct LayerCollectionsDepsNode : public ComponentDepsNode {
214         DEG_DEPSNODE_DECLARE;
215 };
216
217 struct CopyOnWriteDepsNode : public ComponentDepsNode {
218         DEG_DEPSNODE_DECLARE;
219
220         virtual bool depends_on_cow() { return false; }
221 };
222
223
224 void deg_register_component_depsnodes();
225
226 }  // namespace DEG