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