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 struct IDDepsNode;
50
51 /* ID Component - Base type for all components */
52 struct ComponentDepsNode : public DepsNode {
53         /* Key used to look up operations within a component */
54         struct OperationIDKey
55         {
56                 eDepsOperation_Code opcode;
57                 const char *name;
58                 int name_tag;
59
60                 OperationIDKey();
61                 OperationIDKey(eDepsOperation_Code opcode);
62                 OperationIDKey(eDepsOperation_Code opcode,
63                                const char *name,
64                                int name_tag);
65
66                 string identifier() const;
67                 bool operator==(const OperationIDKey &other) const;
68         };
69
70         /* Typedef for container of operations */
71         ComponentDepsNode();
72         ~ComponentDepsNode();
73
74         void init(const ID *id, const char *subdata);
75
76         string identifier() const;
77
78         /* Find an existing operation, if requested operation does not exist
79          * NULL will be returned.
80          */
81         OperationDepsNode *find_operation(OperationIDKey key) const;
82         OperationDepsNode *find_operation(eDepsOperation_Code opcode,
83                                          const char *name,
84                                          int name_tag) const;
85
86         /* Find an existing operation, will throw an assert() if it does not exist. */
87         OperationDepsNode *get_operation(OperationIDKey key) const;
88         OperationDepsNode *get_operation(eDepsOperation_Code opcode,
89                                          const char *name,
90                                          int name_tag) const;
91
92         /* Check operation exists and return it. */
93         bool has_operation(OperationIDKey key) const;
94         bool has_operation(eDepsOperation_Code opcode,
95                            const char *name,
96                            int name_tag) const;
97
98         /**
99          * Create a new node for representing an operation and add this to graph
100          * \warning If an existing node is found, it will be modified. This helps
101          * when node may have been partially created earlier (e.g. parent ref before
102          * parent item is added)
103          *
104          * \param type: Operation node type (corresponding to context/component that
105          *              it operates in)
106          * \param optype: Role that operation plays within component
107          *                (i.e. where in eval process)
108          * \param op: The operation to perform
109          * \param name: Identifier for operation - used to find/locate it again
110          */
111         OperationDepsNode *add_operation(const DepsEvalOperationCb& op,
112                                          eDepsOperation_Code opcode,
113                                          const char *name,
114                                          int name_tag);
115
116         /* Entry/exit operations management.
117          *
118          * Use those instead of direct set since this will perform sanity checks.
119          */
120         void set_entry_operation(OperationDepsNode *op_node);
121         void set_exit_operation(OperationDepsNode *op_node);
122
123         void clear_operations();
124
125         void tag_update(Depsgraph *graph);
126
127         OperationDepsNode *get_entry_operation();
128         OperationDepsNode *get_exit_operation();
129
130         void finalize_build(Depsgraph *graph);
131
132         IDDepsNode *owner;
133
134         /* ** Inner nodes for this component ** */
135
136         /* Operations stored as a hash map, for faster build.
137          * This hash map will be freed when graph is fully built.
138          */
139         GHash *operations_map;
140
141         /* This is a "normal" list of operations, used by evaluation
142          * and other routines after construction.
143          */
144         vector<OperationDepsNode *> operations;
145
146         OperationDepsNode *entry_operation;
147         OperationDepsNode *exit_operation;
148
149         // XXX: a poll() callback to check if component's first node can be started?
150         virtual bool depends_on_cow() { return true; }
151 };
152
153 /* ---------------------------------------- */
154
155 #define DEG_COMPONENT_NODE_DEFINE_TYPEINFO(NodeType, type_, tname_, id_recalc_tag) \
156     const DepsNode::TypeInfo NodeType::typeinfo = \
157         DepsNode::TypeInfo(type_, tname_, id_recalc_tag)
158
159 #define DEG_COMPONENT_NODE_DECLARE DEG_DEPSNODE_DECLARE
160
161 #define DEG_COMPONENT_NODE_DEFINE(name, NAME, id_recalc_tag)            \
162     DEG_COMPONENT_NODE_DEFINE_TYPEINFO(name ## ComponentDepsNode,       \
163                                        DEG_NODE_TYPE_ ## NAME,          \
164                                        #name  " Component",             \
165                                        id_recalc_tag) ;                 \
166     static DepsNodeFactoryImpl<name ## ComponentDepsNode> DNTI_ ## NAME
167
168 #define DEG_COMPONENT_NODE_DECLARE_GENERIC(name)                   \
169         struct name ## ComponentDepsNode : public ComponentDepsNode {  \
170                 DEG_COMPONENT_NODE_DECLARE;                                \
171         }
172
173 DEG_COMPONENT_NODE_DECLARE_GENERIC(Animation);
174 DEG_COMPONENT_NODE_DECLARE_GENERIC(BatchCache);
175 DEG_COMPONENT_NODE_DECLARE_GENERIC(Cache);
176 DEG_COMPONENT_NODE_DECLARE_GENERIC(CopyOnWrite);
177 DEG_COMPONENT_NODE_DECLARE_GENERIC(Geometry);
178 DEG_COMPONENT_NODE_DECLARE_GENERIC(LayerCollections);
179 DEG_COMPONENT_NODE_DECLARE_GENERIC(Parameters);
180 DEG_COMPONENT_NODE_DECLARE_GENERIC(Particles);
181 DEG_COMPONENT_NODE_DECLARE_GENERIC(Proxy);
182 DEG_COMPONENT_NODE_DECLARE_GENERIC(Pose);
183 DEG_COMPONENT_NODE_DECLARE_GENERIC(Sequencer);
184 DEG_COMPONENT_NODE_DECLARE_GENERIC(Shading);
185 DEG_COMPONENT_NODE_DECLARE_GENERIC(ShadingParameters);
186 DEG_COMPONENT_NODE_DECLARE_GENERIC(Transform);
187
188 /* Bone Component */
189 struct BoneComponentDepsNode : public ComponentDepsNode {
190         void init(const ID *id, const char *subdata);
191
192         struct bPoseChannel *pchan;     /* the bone that this component represents */
193
194         DEG_COMPONENT_NODE_DECLARE;
195 };
196
197 void deg_register_component_depsnodes();
198
199 }  // namespace DEG