Cleanup: remove redundant doxygen \file argument
[blender.git] / source / blender / depsgraph / intern / node / deg_node_component.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2013 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file \ingroup depsgraph
21  */
22
23 #pragma once
24
25 #include "intern/node/deg_node.h"
26 #include "intern/node/deg_node_operation.h"
27
28 #include "BLI_utildefines.h"
29 #include "BLI_string.h"
30
31 struct GHash;
32 struct ID;
33 struct bPoseChannel;
34
35 namespace DEG {
36
37 struct BoneComponentNode;
38 struct Depsgraph;
39 struct IDNode;
40 struct OperationNode;
41
42 /* ID Component - Base type for all components */
43 struct ComponentNode : public Node {
44         /* Key used to look up operations within a component */
45         struct OperationIDKey
46         {
47                 OperationCode opcode;
48                 const char *name;
49                 int name_tag;
50
51                 OperationIDKey();
52                 OperationIDKey(OperationCode opcode);
53                 OperationIDKey(OperationCode opcode,
54                                const char *name,
55                                int name_tag);
56
57                 string identifier() const;
58                 bool operator==(const OperationIDKey &other) const;
59         };
60
61         /* Typedef for container of operations */
62         ComponentNode();
63         ~ComponentNode();
64
65         void init(const ID *id, const char *subdata) override;
66
67         virtual string identifier() const override;
68
69         /* Find an existing operation, if requested operation does not exist
70          * NULL will be returned. */
71         OperationNode *find_operation(OperationIDKey key) const;
72         OperationNode *find_operation(OperationCode opcode,
73                                          const char *name,
74                                          int name_tag) const;
75
76         /* Find an existing operation, will throw an assert() if it does not exist. */
77         OperationNode *get_operation(OperationIDKey key) const;
78         OperationNode *get_operation(OperationCode opcode,
79                                          const char *name,
80                                          int name_tag) const;
81
82         /* Check operation exists and return it. */
83         bool has_operation(OperationIDKey key) const;
84         bool has_operation(OperationCode opcode,
85                            const char *name,
86                            int name_tag) const;
87
88         /**
89          * Create a new node for representing an operation and add this to graph
90          * \warning If an existing node is found, it will be modified. This helps
91          * when node may have been partially created earlier (e.g. parent ref before
92          * parent item is added)
93          *
94          * \param type: Operation node type (corresponding to context/component that
95          *              it operates in)
96          * \param optype: Role that operation plays within component
97          *                (i.e. where in eval process)
98          * \param op: The operation to perform
99          * \param name: Identifier for operation - used to find/locate it again */
100         OperationNode *add_operation(const DepsEvalOperationCb& op,
101                                          OperationCode opcode,
102                                          const char *name,
103                                          int name_tag);
104
105         /* Entry/exit operations management.
106          *
107          * Use those instead of direct set since this will perform sanity checks. */
108         void set_entry_operation(OperationNode *op_node);
109         void set_exit_operation(OperationNode *op_node);
110
111         void clear_operations();
112
113         virtual void tag_update(Depsgraph *graph, eUpdateSource source) override;
114
115         virtual OperationNode *get_entry_operation() override;
116         virtual OperationNode *get_exit_operation() override;
117
118         void finalize_build(Depsgraph *graph);
119
120         IDNode *owner;
121
122         /* ** Inner nodes for this component ** */
123
124         /* Operations stored as a hash map, for faster build.
125          * This hash map will be freed when graph is fully built. */
126         GHash *operations_map;
127
128         /* This is a "normal" list of operations, used by evaluation
129          * and other routines after construction. */
130         vector<OperationNode *> operations;
131
132         OperationNode *entry_operation;
133         OperationNode *exit_operation;
134
135         virtual bool depends_on_cow() { return true; }
136
137         /* Denotes whether COW component is to be tagged when this component
138          * is tagged for update. */
139         virtual bool need_tag_cow_before_update() { return true; }
140
141         /* Denotes whether this component affects (possibly indirectly) on a
142          * directly visible object. */
143         bool affects_directly_visible;
144 };
145
146 /* ---------------------------------------- */
147
148 #define DEG_COMPONENT_NODE_DEFINE_TYPEINFO(\
149         NodeType, type_, type_name_, id_recalc_tag) \
150     const Node::TypeInfo NodeType::typeinfo = \
151         Node::TypeInfo(type_, type_name_, id_recalc_tag)
152
153 #define DEG_COMPONENT_NODE_DECLARE DEG_DEPSNODE_DECLARE
154
155 #define DEG_COMPONENT_NODE_DEFINE(name, NAME, id_recalc_tag)            \
156     DEG_COMPONENT_NODE_DEFINE_TYPEINFO(name ## ComponentNode,       \
157                                        NodeType:: NAME,                 \
158                                        #name  " Component",             \
159                                        id_recalc_tag) ;                 \
160     static DepsNodeFactoryImpl<name ## ComponentNode> DNTI_ ## NAME
161
162 #define DEG_COMPONENT_NODE_DECLARE_GENERIC(name)                   \
163         struct name ## ComponentNode : public ComponentNode {  \
164                 DEG_COMPONENT_NODE_DECLARE;                                \
165         }
166
167 #define DEG_COMPONENT_NODE_DECLARE_NO_COW_TAG_ON_UPDATE(name)        \
168         struct name ## ComponentNode : public ComponentNode {    \
169                 DEG_COMPONENT_NODE_DECLARE;                                  \
170                 virtual bool need_tag_cow_before_update() { return false; }  \
171         }
172
173 DEG_COMPONENT_NODE_DECLARE_GENERIC(Animation);
174 DEG_COMPONENT_NODE_DECLARE_NO_COW_TAG_ON_UPDATE(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(ParticleSettings);
182 DEG_COMPONENT_NODE_DECLARE_GENERIC(Pose);
183 DEG_COMPONENT_NODE_DECLARE_GENERIC(PointCache);
184 DEG_COMPONENT_NODE_DECLARE_GENERIC(Proxy);
185 DEG_COMPONENT_NODE_DECLARE_GENERIC(Sequencer);
186 DEG_COMPONENT_NODE_DECLARE_NO_COW_TAG_ON_UPDATE(Shading);
187 DEG_COMPONENT_NODE_DECLARE_GENERIC(ShadingParameters);
188 DEG_COMPONENT_NODE_DECLARE_GENERIC(Transform);
189 DEG_COMPONENT_NODE_DECLARE_NO_COW_TAG_ON_UPDATE(ObjectFromLayer);
190 DEG_COMPONENT_NODE_DECLARE_GENERIC(Dupli);
191 DEG_COMPONENT_NODE_DECLARE_GENERIC(Synchronization);
192 DEG_COMPONENT_NODE_DECLARE_GENERIC(GenericDatablock);
193
194 /* Bone Component */
195 struct BoneComponentNode : public ComponentNode {
196         void init(const ID *id, const char *subdata);
197
198         struct bPoseChannel *pchan;     /* the bone that this component represents */
199
200         DEG_COMPONENT_NODE_DECLARE;
201 };
202
203 void deg_register_component_depsnodes();
204
205 }  // namespace DEG