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_NODE_DEFINE_TYPEINFO(NodeType, type_, tname_, id_recalc_tag) \
168     const DepsNode::TypeInfo NodeType::typeinfo = \
169         DepsNode::TypeInfo(type_, tname_, id_recalc_tag)
170
171 #define DEG_COMPONENT_NODE_DECLARE DEG_DEPSNODE_DECLARE
172
173 #define DEG_COMPONENT_NODE_DEFINE(name, NAME, id_recalc_tag)            \
174     DEG_COMPONENT_NODE_DEFINE_TYPEINFO(name ## ComponentDepsNode,       \
175                                        DEG_NODE_TYPE_ ## NAME,          \
176                                        #name  " Component",             \
177                                        id_recalc_tag) ;                 \
178     static DepsNodeFactoryImpl<name ## ComponentDepsNode> DNTI_ ## NAME
179
180 #define DEG_COMPONENT_NODE_DECLARE_GENERIC(name)                   \
181         struct name ## ComponentDepsNode : public ComponentDepsNode {  \
182                 DEG_COMPONENT_NODE_DECLARE;                                \
183         }
184
185 DEG_COMPONENT_NODE_DECLARE_GENERIC(Animation);
186 DEG_COMPONENT_NODE_DECLARE_GENERIC(BatchCache);
187 DEG_COMPONENT_NODE_DECLARE_GENERIC(Cache);
188 DEG_COMPONENT_NODE_DECLARE_GENERIC(CopyOnWrite);
189 DEG_COMPONENT_NODE_DECLARE_GENERIC(Geometry);
190 DEG_COMPONENT_NODE_DECLARE_GENERIC(LayerCollections);
191 DEG_COMPONENT_NODE_DECLARE_GENERIC(Parameters);
192 DEG_COMPONENT_NODE_DECLARE_GENERIC(Particles);
193 DEG_COMPONENT_NODE_DECLARE_GENERIC(Proxy);
194 DEG_COMPONENT_NODE_DECLARE_GENERIC(Pose);
195 DEG_COMPONENT_NODE_DECLARE_GENERIC(Sequencer);
196 DEG_COMPONENT_NODE_DECLARE_GENERIC(Shading);
197 DEG_COMPONENT_NODE_DECLARE_GENERIC(ShadingParameters);
198 DEG_COMPONENT_NODE_DECLARE_GENERIC(Transform);
199
200 /* Bone Component */
201 struct BoneComponentDepsNode : public ComponentDepsNode {
202         void init(const ID *id, const char *subdata);
203
204         struct bPoseChannel *pchan;     /* the bone that this component represents */
205
206         DEG_COMPONENT_NODE_DECLARE;
207 };
208
209 void deg_register_component_depsnodes();
210
211 }  // namespace DEG