Merge branch 'master' into blender2.8
[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, if requested operation does not exist
78          * NULL will be returned.
79          */
80         OperationDepsNode *find_operation(OperationIDKey key) const;
81         OperationDepsNode *find_operation(eDepsOperation_Code opcode,
82                                          const char *name,
83                                          int name_tag) const;
84
85         /* Find an existing operation, will throw an assert() if it does not exist. */
86         OperationDepsNode *get_operation(OperationIDKey key) const;
87         OperationDepsNode *get_operation(eDepsOperation_Code opcode,
88                                          const char *name,
89                                          int name_tag) const;
90
91         /* Check operation exists and return it. */
92         bool has_operation(OperationIDKey key) const;
93         bool has_operation(eDepsOperation_Code opcode,
94                            const char *name,
95                            int name_tag) const;
96
97         /**
98          * Create a new node for representing an operation and add this to graph
99          * \warning If an existing node is found, it will be modified. This helps
100          * when node may have been partially created earlier (e.g. parent ref before
101          * parent item is added)
102          *
103          * \param type: Operation node type (corresponding to context/component that
104          *              it operates in)
105          * \param optype: Role that operation plays within component
106          *                (i.e. where in eval process)
107          * \param op: The operation to perform
108          * \param name: Identifier for operation - used to find/locate it again
109          */
110         OperationDepsNode *add_operation(const DepsEvalOperationCb& op,
111                                          eDepsOperation_Code opcode,
112                                          const char *name,
113                                          int name_tag);
114
115         /* Entry/exit operations management.
116          *
117          * Use those instead of direct set since this will perform sanity checks.
118          */
119         void set_entry_operation(OperationDepsNode *op_node);
120         void set_exit_operation(OperationDepsNode *op_node);
121
122         void clear_operations();
123
124         void tag_update(Depsgraph *graph);
125
126         /* Evaluation Context Management .................. */
127
128         /* Initialize component's evaluation context used for the specified
129          * purpose.
130          */
131         virtual bool eval_context_init(EvaluationContext * /*eval_ctx*/) { return false; }
132         /* Free data in component's evaluation context which is used for
133          * the specified purpose
134          *
135          * NOTE: this does not free the actual context in question
136          */
137         virtual void eval_context_free(EvaluationContext * /*eval_ctx*/) {}
138
139         OperationDepsNode *get_entry_operation();
140         OperationDepsNode *get_exit_operation();
141
142         void finalize_build(Depsgraph *graph);
143
144         IDDepsNode *owner;
145
146         /* ** Inner nodes for this component ** */
147
148         /* Operations stored as a hash map, for faster build.
149          * This hash map will be freed when graph is fully built.
150          */
151         GHash *operations_map;
152
153         /* This is a "normal" list of operations, used by evaluation
154          * and other routines after construction.
155          */
156         vector<OperationDepsNode *> operations;
157
158         OperationDepsNode *entry_operation;
159         OperationDepsNode *exit_operation;
160
161         // XXX: a poll() callback to check if component's first node can be started?
162         virtual bool depends_on_cow() { return true; }
163 };
164
165 /* ---------------------------------------- */
166
167 #define DEG_COMPONENT_DECLARE_GENERIC(name)                        \
168         struct name ## ComponentDepsNode : public ComponentDepsNode {  \
169                 DEG_DEPSNODE_DECLARE;                                      \
170         }
171
172 DEG_COMPONENT_DECLARE_GENERIC(Animation);
173 DEG_COMPONENT_DECLARE_GENERIC(BatchCache);
174 DEG_COMPONENT_DECLARE_GENERIC(Cache);
175 DEG_COMPONENT_DECLARE_GENERIC(CopyOnWrite);
176 DEG_COMPONENT_DECLARE_GENERIC(Geometry);
177 DEG_COMPONENT_DECLARE_GENERIC(LayerCollections);
178 DEG_COMPONENT_DECLARE_GENERIC(Parameters);
179 DEG_COMPONENT_DECLARE_GENERIC(Particles);
180 DEG_COMPONENT_DECLARE_GENERIC(Proxy);
181 DEG_COMPONENT_DECLARE_GENERIC(Pose);
182 DEG_COMPONENT_DECLARE_GENERIC(Sequencer);
183 DEG_COMPONENT_DECLARE_GENERIC(Shading);
184 DEG_COMPONENT_DECLARE_GENERIC(ShadingParameters);
185 DEG_COMPONENT_DECLARE_GENERIC(Transform);
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 void deg_register_component_depsnodes();
197
198 }  // namespace DEG