Cleanup: remove redundant, invalid info from headers
[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  * Original Author: Joshua Leung
20  */
21
22 /** \file blender/depsgraph/intern/node/deg_node_component.h
23  *  \ingroup depsgraph
24  */
25
26 #pragma once
27
28 #include "intern/node/deg_node.h"
29 #include "intern/node/deg_node_operation.h"
30
31 #include "BLI_utildefines.h"
32 #include "BLI_string.h"
33
34 struct GHash;
35 struct ID;
36 struct bPoseChannel;
37
38 namespace DEG {
39
40 struct BoneComponentNode;
41 struct Depsgraph;
42 struct IDNode;
43 struct OperationNode;
44
45 /* ID Component - Base type for all components */
46 struct ComponentNode : public Node {
47         /* Key used to look up operations within a component */
48         struct OperationIDKey
49         {
50                 OperationCode opcode;
51                 const char *name;
52                 int name_tag;
53
54                 OperationIDKey();
55                 OperationIDKey(OperationCode opcode);
56                 OperationIDKey(OperationCode opcode,
57                                const char *name,
58                                int name_tag);
59
60                 string identifier() const;
61                 bool operator==(const OperationIDKey &other) const;
62         };
63
64         /* Typedef for container of operations */
65         ComponentNode();
66         ~ComponentNode();
67
68         void init(const ID *id, const char *subdata) override;
69
70         virtual string identifier() const override;
71
72         /* Find an existing operation, if requested operation does not exist
73          * NULL will be returned. */
74         OperationNode *find_operation(OperationIDKey key) const;
75         OperationNode *find_operation(OperationCode opcode,
76                                          const char *name,
77                                          int name_tag) const;
78
79         /* Find an existing operation, will throw an assert() if it does not exist. */
80         OperationNode *get_operation(OperationIDKey key) const;
81         OperationNode *get_operation(OperationCode opcode,
82                                          const char *name,
83                                          int name_tag) const;
84
85         /* Check operation exists and return it. */
86         bool has_operation(OperationIDKey key) const;
87         bool has_operation(OperationCode opcode,
88                            const char *name,
89                            int name_tag) const;
90
91         /**
92          * Create a new node for representing an operation and add this to graph
93          * \warning If an existing node is found, it will be modified. This helps
94          * when node may have been partially created earlier (e.g. parent ref before
95          * parent item is added)
96          *
97          * \param type: Operation node type (corresponding to context/component that
98          *              it operates in)
99          * \param optype: Role that operation plays within component
100          *                (i.e. where in eval process)
101          * \param op: The operation to perform
102          * \param name: Identifier for operation - used to find/locate it again */
103         OperationNode *add_operation(const DepsEvalOperationCb& op,
104                                          OperationCode opcode,
105                                          const char *name,
106                                          int name_tag);
107
108         /* Entry/exit operations management.
109          *
110          * Use those instead of direct set since this will perform sanity checks. */
111         void set_entry_operation(OperationNode *op_node);
112         void set_exit_operation(OperationNode *op_node);
113
114         void clear_operations();
115
116         virtual void tag_update(Depsgraph *graph, eUpdateSource source) override;
117
118         virtual OperationNode *get_entry_operation() override;
119         virtual OperationNode *get_exit_operation() override;
120
121         void finalize_build(Depsgraph *graph);
122
123         IDNode *owner;
124
125         /* ** Inner nodes for this component ** */
126
127         /* Operations stored as a hash map, for faster build.
128          * This hash map will be freed when graph is fully built. */
129         GHash *operations_map;
130
131         /* This is a "normal" list of operations, used by evaluation
132          * and other routines after construction. */
133         vector<OperationNode *> operations;
134
135         OperationNode *entry_operation;
136         OperationNode *exit_operation;
137
138         virtual bool depends_on_cow() { return true; }
139
140         /* Denotes whether COW component is to be tagged when this component
141          * is tagged for update. */
142         virtual bool need_tag_cow_before_update() { return true; }
143
144         /* Denotes whether this component affects (possibly indirectly) on a
145          * directly visible object. */
146         bool affects_directly_visible;
147 };
148
149 /* ---------------------------------------- */
150
151 #define DEG_COMPONENT_NODE_DEFINE_TYPEINFO(\
152         NodeType, type_, type_name_, id_recalc_tag) \
153     const Node::TypeInfo NodeType::typeinfo = \
154         Node::TypeInfo(type_, type_name_, id_recalc_tag)
155
156 #define DEG_COMPONENT_NODE_DECLARE DEG_DEPSNODE_DECLARE
157
158 #define DEG_COMPONENT_NODE_DEFINE(name, NAME, id_recalc_tag)            \
159     DEG_COMPONENT_NODE_DEFINE_TYPEINFO(name ## ComponentNode,       \
160                                        NodeType:: NAME,                 \
161                                        #name  " Component",             \
162                                        id_recalc_tag) ;                 \
163     static DepsNodeFactoryImpl<name ## ComponentNode> DNTI_ ## NAME
164
165 #define DEG_COMPONENT_NODE_DECLARE_GENERIC(name)                   \
166         struct name ## ComponentNode : public ComponentNode {  \
167                 DEG_COMPONENT_NODE_DECLARE;                                \
168         }
169
170 #define DEG_COMPONENT_NODE_DECLARE_NO_COW_TAG_ON_UPDATE(name)        \
171         struct name ## ComponentNode : public ComponentNode {    \
172                 DEG_COMPONENT_NODE_DECLARE;                                  \
173                 virtual bool need_tag_cow_before_update() { return false; }  \
174         }
175
176 DEG_COMPONENT_NODE_DECLARE_GENERIC(Animation);
177 DEG_COMPONENT_NODE_DECLARE_NO_COW_TAG_ON_UPDATE(BatchCache);
178 DEG_COMPONENT_NODE_DECLARE_GENERIC(Cache);
179 DEG_COMPONENT_NODE_DECLARE_GENERIC(CopyOnWrite);
180 DEG_COMPONENT_NODE_DECLARE_GENERIC(Geometry);
181 DEG_COMPONENT_NODE_DECLARE_GENERIC(LayerCollections);
182 DEG_COMPONENT_NODE_DECLARE_GENERIC(Parameters);
183 DEG_COMPONENT_NODE_DECLARE_GENERIC(Particles);
184 DEG_COMPONENT_NODE_DECLARE_GENERIC(ParticleSettings);
185 DEG_COMPONENT_NODE_DECLARE_GENERIC(Pose);
186 DEG_COMPONENT_NODE_DECLARE_GENERIC(PointCache);
187 DEG_COMPONENT_NODE_DECLARE_GENERIC(Proxy);
188 DEG_COMPONENT_NODE_DECLARE_GENERIC(Sequencer);
189 DEG_COMPONENT_NODE_DECLARE_NO_COW_TAG_ON_UPDATE(Shading);
190 DEG_COMPONENT_NODE_DECLARE_GENERIC(ShadingParameters);
191 DEG_COMPONENT_NODE_DECLARE_GENERIC(Transform);
192 DEG_COMPONENT_NODE_DECLARE_NO_COW_TAG_ON_UPDATE(ObjectFromLayer);
193 DEG_COMPONENT_NODE_DECLARE_GENERIC(Dupli);
194 DEG_COMPONENT_NODE_DECLARE_GENERIC(Synchronization);
195 DEG_COMPONENT_NODE_DECLARE_GENERIC(GenericDatablock);
196
197 /* Bone Component */
198 struct BoneComponentNode : public ComponentNode {
199         void init(const ID *id, const char *subdata);
200
201         struct bPoseChannel *pchan;     /* the bone that this component represents */
202
203         DEG_COMPONENT_NODE_DECLARE;
204 };
205
206 void deg_register_component_depsnodes();
207
208 }  // namespace DEG