MaterialX 1.38.2
ShaderGraph.h
Go to the documentation of this file.
1//
2// TM & (c) 2017 Lucasfilm Entertainment Company Ltd. and Lucasfilm Ltd.
3// All rights reserved. See LICENSE.txt for license.
4//
5
6#ifndef MATERIALX_SHADERGRAPH_H
7#define MATERIALX_SHADERGRAPH_H
8
11
13
19
21#include <MaterialXCore/Node.h>
22
23namespace MaterialX
24{
25
26class Syntax;
27class ShaderGraphEdge;
28class ShaderGraphEdgeIterator;
29class GenOptions;
30
34
38
40using ShaderGraphPtr = shared_ptr<class ShaderGraph>;
41
44class MX_GENSHADER_API ShaderGraph : public ShaderNode
45{
46 public:
48 ShaderGraph(const ShaderGraph* parent, const string& name, ConstDocumentPtr document, const StringSet& reservedWords);
49
51 virtual ~ShaderGraph() { }
52
55 static ShaderGraphPtr create(const ShaderGraph* parent, const string& name, ElementPtr element,
56 GenContext& context);
57
59 static ShaderGraphPtr create(const ShaderGraph* parent, const NodeGraph& nodeGraph,
60 GenContext& context);
61
63 bool isAGraph() const override { return true; }
64
66 ShaderNode* getNode(const string& name);
67
69 const ShaderNode* getNode(const string& name) const;
70
72 const vector<ShaderNode*>& getNodes() const { return _nodeOrder; }
73
75 size_t numInputSockets() const { return numOutputs(); }
76
78 size_t numOutputSockets() const { return numInputs(); }
79
81 ShaderGraphInputSocket* getInputSocket(size_t index) { return getOutput(index); }
82 ShaderGraphOutputSocket* getOutputSocket(size_t index = 0) { return getInput(index); }
83 const ShaderGraphInputSocket* getInputSocket(size_t index) const { return getOutput(index); }
84 const ShaderGraphOutputSocket* getOutputSocket(size_t index = 0) const { return getInput(index); }
85
87 ShaderGraphInputSocket* getInputSocket(const string& name) { return getOutput(name); }
88 ShaderGraphOutputSocket* getOutputSocket(const string& name) { return getInput(name); }
89 const ShaderGraphInputSocket* getInputSocket(const string& name) const { return getOutput(name); }
90 const ShaderGraphOutputSocket* getOutputSocket(const string& name) const { return getInput(name); }
91
93 const vector<ShaderGraphInputSocket*>& getInputSockets() const { return _outputOrder; }
94 const vector<ShaderGraphOutputSocket*>& getOutputSockets() const { return _inputOrder; }
95
97 ShaderNode* createNode(const Node& node, GenContext& context);
98
100 ShaderGraphInputSocket* addInputSocket(const string& name, const TypeDesc* type);
101 ShaderGraphOutputSocket* addOutputSocket(const string& name, const TypeDesc* type);
102
104 static ShaderGraphEdgeIterator traverseUpstream(ShaderOutput* output);
105
107 IdentifierMap& getIdentifierMap() { return _identifiers; }
108
109 protected:
110 static ShaderGraphPtr createSurfaceShader(
111 const string& name,
112 const ShaderGraph* parent,
113 NodePtr node,
114 GenContext& context,
115 ElementPtr& root);
116
122 void createConnectedNodes(const ElementPtr& downstreamElement,
123 const ElementPtr& upstreamElement,
124 ElementPtr connectingElement,
125 GenContext& context);
126
128 void addNode(ShaderNodePtr node);
129
131 void addInputSockets(const InterfaceElement& elem, GenContext& context);
132
134 void addOutputSockets(const InterfaceElement& elem);
135
139 void addUpstreamDependencies(const Element& root, GenContext& context);
140
142 void addDefaultGeomNode(ShaderInput* input, const GeomPropDef& geomprop, GenContext& context);
143
145 void addColorTransformNode(ShaderInput* input, const ColorSpaceTransform& transform, GenContext& context);
146
148 void addColorTransformNode(ShaderOutput* output, const ColorSpaceTransform& transform, GenContext& context);
149
151 void addUnitTransformNode(ShaderInput* input, const UnitTransform& transform, GenContext& context);
152
154 void addUnitTransformNode(ShaderOutput* output, const UnitTransform& transform, GenContext& context);
155
157 void finalize(GenContext& context);
158
160 void optimize(GenContext& context);
161
165 void bypass(GenContext& context, ShaderNode* node, size_t inputIndex, size_t outputIndex = 0);
166
169 void topologicalSort();
170
172 void calculateScopes();
173
177 void setVariableNames(GenContext& context);
178
181 void populateColorTransformMap(ColorManagementSystemPtr colorManagementSystem, ShaderPort* shaderPort, ValueElementPtr element, const string& targetColorSpace, bool asInput);
182
185 void populateUnitTransformMap(UnitSystemPtr unitSystem, ShaderPort* shaderPort, ValueElementPtr element, const string& targetUnitSpace, bool asInput);
186
188 void disconnect(ShaderNode* node) const;
189
190 ConstDocumentPtr _document;
191 std::unordered_map<string, ShaderNodePtr> _nodeMap;
192 std::vector<ShaderNode*> _nodeOrder;
193 IdentifierMap _identifiers;
194
195 // Temporary storage for inputs that require color transformations
196 std::unordered_map<ShaderInput*, ColorSpaceTransform> _inputColorTransformMap;
197 // Temporary storage for inputs that require unit transformations
198 std::unordered_map<ShaderInput*, UnitTransform> _inputUnitTransformMap;
199
200 // Temporary storage for outputs that require color transformations
201 std::unordered_map<ShaderOutput*, ColorSpaceTransform> _outputColorTransformMap;
202 // Temporary storage for outputs that require unit transformations
203 std::unordered_map<ShaderOutput*, UnitTransform> _outputUnitTransformMap;
204};
205
208class MX_GENSHADER_API ShaderGraphEdge
209{
210 public:
212 upstream(up),
213 downstream(down)
214 {}
215 ShaderOutput* upstream;
216 ShaderInput* downstream;
217};
218
221class MX_GENSHADER_API ShaderGraphEdgeIterator
222{
223 public:
226
227 bool operator==(const ShaderGraphEdgeIterator& rhs) const
228 {
229 return _upstream == rhs._upstream &&
230 _downstream == rhs._downstream &&
231 _stack == rhs._stack;
232 }
233 bool operator!=(const ShaderGraphEdgeIterator& rhs) const
234 {
235 return !(*this == rhs);
236 }
237
240 {
241 return ShaderGraphEdge(_upstream, _downstream);
242 }
243
246 ShaderGraphEdgeIterator& operator++();
247
250 {
251 return *this;
252 }
253
255 static const ShaderGraphEdgeIterator& end();
256
257 private:
258 void extendPathUpstream(ShaderOutput* upstream, ShaderInput* downstream);
259 void returnPathDownstream(ShaderOutput* upstream);
260
261 ShaderOutput* _upstream;
262 ShaderInput* _downstream;
263 using StackFrame = std::pair<ShaderOutput*, size_t>;
264 std::vector<StackFrame> _stack;
265 std::set<ShaderOutput*> _path;
266};
267
268} // namespace MaterialX
269
270#endif
Color management system classes.
shared_ptr< class ColorManagementSystem > ColorManagementSystemPtr
A shared pointer to a ColorManagementSystem.
Definition: ColorManagementSystem.h:26
The top-level Document class.
shared_ptr< const Document > ConstDocumentPtr
A shared pointer to a const Document.
Definition: Document.h:25
shared_ptr< Element > ElementPtr
A shared pointer to an Element.
Definition: Element.h:31
shared_ptr< ValueElement > ValueElementPtr
A shared pointer to a ValueElement.
Definition: Element.h:41
std::set< string > StringSet
A set of strings.
Definition: Library.h:60
Macros for declaring imported and exported symbols.
Node element subclasses.
shared_ptr< Node > NodePtr
A shared pointer to a Node.
Definition: Node.h:25
ShaderInput ShaderGraphOutputSocket
An internal output socket in a shader graph, used for connecting internal nodes to the outside.
Definition: ShaderGraph.h:37
shared_ptr< class ShaderGraph > ShaderGraphPtr
A shared pointer to a shader graph.
Definition: ShaderGraph.h:40
Classes for nodes created during shader generation.
shared_ptr< class ShaderNode > ShaderNodePtr
Shared pointer to a ShaderNode.
Definition: ShaderNode.h:36
Base class for syntax handling for shader generators.
std::unordered_map< string, size_t > IdentifierMap
Map holding identifier names and a counter for creating unique names from them.
Definition: Syntax.h:34
Type descriptor for a MaterialX data type.
Unit system classes.
shared_ptr< class UnitSystem > UnitSystemPtr
A shared pointer to a UnitSystem.
Definition: UnitSystem.h:27
The base class for MaterialX elements.
Definition: Element.h:75
A context class for shader generation.
Definition: GenContext.h:27
An element representing a declaration of geometric property data.
Definition: Geom.h:361
The base class for interface elements such as Node, NodeDef, and NodeGraph.
Definition: Interface.h:317
A node graph element within a Document.
Definition: Node.h:316
An edge returned during shader graph traversal.
Definition: ShaderGraph.h:209
Iterator class for traversing edges between nodes in a shader graph.
Definition: ShaderGraph.h:222
ShaderGraphEdge operator*() const
Dereference this iterator, returning the current output in the traversal.
Definition: ShaderGraph.h:239
ShaderGraphEdgeIterator & begin()
Return a reference to this iterator to begin traversal.
Definition: ShaderGraph.h:249
Class representing a graph (DAG) for shader generation.
Definition: ShaderGraph.h:45
virtual ~ShaderGraph()
Desctructor.
Definition: ShaderGraph.h:51
bool isAGraph() const override
Return true if this node is a graph.
Definition: ShaderGraph.h:63
size_t numInputSockets() const
Get number of input sockets.
Definition: ShaderGraph.h:75
const vector< ShaderGraphInputSocket * > & getInputSockets() const
Get vector of sockets.
Definition: ShaderGraph.h:93
ShaderGraphInputSocket * getInputSocket(size_t index)
Get socket by index.
Definition: ShaderGraph.h:81
IdentifierMap & getIdentifierMap()
Return the map of unique identifiers used in the scope of this graph.
Definition: ShaderGraph.h:107
size_t numOutputSockets() const
Get number of output sockets.
Definition: ShaderGraph.h:78
const vector< ShaderNode * > & getNodes() const
Get a vector of all nodes in order.
Definition: ShaderGraph.h:72
ShaderGraphInputSocket * getInputSocket(const string &name)
Get socket by name.
Definition: ShaderGraph.h:87
An input on a ShaderNode.
Definition: ShaderNode.h:256
Class representing a node in the shader generation DAG.
Definition: ShaderNode.h:326
An output on a ShaderNode.
Definition: ShaderNode.h:289
An input or output port on a ShaderNode.
Definition: ShaderNode.h:125
Structure that represents color space transform information.
Definition: ColorManagementSystem.h:31
Structure that represents unit transform information.
Definition: UnitSystem.h:32