1 //
2 // Copyright 2016 Pixar
3 //
4 // Licensed under the Apache License, Version 2.0 (the "Apache License")
5 // with the following modification; you may not use this file except in
6 // compliance with the Apache License and the following modification to it:
7 // Section 6. Trademarks. is deleted and replaced with:
8 //
9 // 6. Trademarks. This License does not grant permission to use the trade
10 //    names, trademarks, service marks, or product names of the Licensor
11 //    and its affiliates, except as required to comply with Section 4(c) of
12 //    the License and to reproduce the content of the NOTICE file.
13 //
14 // You may obtain a copy of the Apache License at
15 //
16 //     http://www.apache.org/licenses/LICENSE-2.0
17 //
18 // Unless required by applicable law or agreed to in writing, software
19 // distributed under the Apache License with the above modification is
20 // distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
21 // KIND, either express or implied. See the Apache License for the specific
22 // language governing permissions and limitations under the Apache License.
23 //
24 #ifndef PXR_IMAGING_HD_MATERIAL_H
25 #define PXR_IMAGING_HD_MATERIAL_H
26 
27 #include "pxr/pxr.h"
28 #include "pxr/imaging/hd/api.h"
29 #include "pxr/imaging/hd/sprim.h"
30 #include "pxr/imaging/hd/sceneDelegate.h"
31 
32 PXR_NAMESPACE_OPEN_SCOPE
33 
34 ///
35 /// Hydra Schema for a material object.
36 ///
37 class HdMaterial : public HdSprim {
38 public:
39     // change tracking for HdMaterial prim
40     enum DirtyBits : HdDirtyBits {
41         Clean                 = 0,
42         // XXX: Got to skip varying and force sync bits for now
43         DirtyParams           = 1 << 2,
44         DirtyResource         = 1 << 3,
45         AllDirty              = (DirtyParams | DirtyResource)
46     };
47 
48     HD_API
49     virtual ~HdMaterial();
50 
51 protected:
52     HD_API
53     HdMaterial(SdfPath const& id);
54 
55 private:
56     // Class can not be default constructed or copied.
57     HdMaterial()                             = delete;
58     HdMaterial(const HdMaterial &)             = delete;
59     HdMaterial &operator =(const HdMaterial &) = delete;
60 };
61 
62 
63 /// \struct HdMaterialRelationship
64 ///
65 /// Describes a connection between two nodes in a material.
66 ///
67 /// A brief discussion of terminology follows:
68 ///
69 /// * Shading nodes have inputs and outputs.
70 /// * Shading nodes consume input values and produce output values.
71 /// * Connections also have inputs and outputs.
72 /// * Connections consume a value from the (\em inputId, \em inputName)
73 ///   and pass that value to the (\em outputId, \em outputName).
74 ///
75 /// Note that a connection's input is considered an output on the
76 /// upstream shading node, and the connection's output is an input
77 /// on the downstream shading node.
78 ///
79 /// A guideline to remember this terminology is that inputs
80 /// are always upstream of outputs in the dataflow.
81 ///
82 struct HdMaterialRelationship {
83     SdfPath inputId;
84     TfToken inputName;
85     SdfPath outputId;
86     TfToken outputName;
87 };
88 
89 // VtValue requirements
90 HD_API
91 bool operator==(const HdMaterialRelationship& lhs,
92                 const HdMaterialRelationship& rhs);
93 
94 
95 /// \struct HdMaterialNode
96 ///
97 /// Describes a material node which is made of a path, an identifier and
98 /// a list of parameters.
99 struct HdMaterialNode {
100     SdfPath path;
101     TfToken identifier;
102     std::map<TfToken, VtValue> parameters;
103 };
104 
105 // VtValue requirements
106 HD_API
107 bool operator==(const HdMaterialNode& lhs, const HdMaterialNode& rhs);
108 
109 
110 /// \struct HdMaterialNetwork
111 ///
112 /// Describes a material network composed of nodes, primvars, and relationships
113 /// between the nodes and terminals of those nodes.
114 struct HdMaterialNetwork {
115     std::vector<HdMaterialRelationship> relationships;
116     std::vector<HdMaterialNode> nodes;
117     TfTokenVector primvars;
118 };
119 
120 /// \struct HdMaterialNetworkMap
121 ///
122 /// Describes a map from network type to network.
123 struct HdMaterialNetworkMap {
124     std::map<TfToken, HdMaterialNetwork> map;
125     std::vector<SdfPath> terminals;
126 };
127 
128 
129 ///
130 /// HdMaterialNetwork2
131 ///
132 /// This struct replaces the previously used MatfiltNetwork and
133 /// HdSt_MaterialNetwork.
134 /// In the furuture this HdMaterialNetwork2 will replace the current
135 /// HdMaterialNetwork defined above.
136 ///
137 
138 /// \struct HdMaterialConnection2
139 ///
140 /// Describes a single connection to an upsream node and output port
141 /// Replacement for HdRelationship.
142 struct HdMaterialConnection2 {
143     SdfPath upstreamNode;
144     TfToken upstreamOutputName;
145 
146     bool operator==(const HdMaterialConnection2 & rhs) const {
147         return upstreamNode == rhs.upstreamNode
148             && upstreamOutputName == rhs.upstreamOutputName;
149     }
150 };
151 
152 /// \struct HdMaterialNode2
153 ///
154 /// Describes an instance of a node within a network
155 /// A node contains a (shader) type identifier, parameter values, and
156 /// connections to upstream nodes. A single input (mapped by TfToken) may have
157 /// multiple upstream connections to describe connected array elements.
158 struct HdMaterialNode2 {
159     TfToken nodeTypeId;
160     std::map<TfToken, VtValue> parameters;
161     std::map<TfToken, std::vector<HdMaterialConnection2>> inputConnections;
162 
163     bool operator==(const HdMaterialNode2 & rhs) const {
164         return nodeTypeId == rhs.nodeTypeId
165             && parameters == rhs.parameters
166             && inputConnections == rhs.inputConnections;
167     }
168 };
169 
170 /// \struct HdMaterialNetwork2
171 ///
172 /// Container of nodes and top-level terminal connections. This is the mutable
173 /// representation of a shading network sent to filtering functions by a
174 /// MatfiltFilterChain.
175 struct HdMaterialNetwork2 {
176     std::map<SdfPath, HdMaterialNode2> nodes;
177     std::map<TfToken, HdMaterialConnection2> terminals;
178     TfTokenVector primvars;
179 
180     bool operator==(const HdMaterialNetwork2 & rhs) const {
181         return nodes == rhs.nodes
182             && terminals == rhs.terminals
183             && primvars == rhs.primvars;
184     }
185 };
186 
187 /// Converts a HdMaterialNetworkMap to a HdMaterialNetwork2
188 HD_API
189 void HdMaterialNetwork2ConvertFromHdMaterialNetworkMap(
190     const HdMaterialNetworkMap & hdNetworkMap,
191     HdMaterialNetwork2 *result,
192     bool *isVolume = nullptr);
193 
194 
195 // VtValue requirements
196 HD_API
197 std::ostream& operator<<(std::ostream& out, const HdMaterialNetwork& pv);
198 HD_API
199 bool operator==(const HdMaterialNetwork& lhs, const HdMaterialNetwork& rhs);
200 HD_API
201 bool operator!=(const HdMaterialNetwork& lhs, const HdMaterialNetwork& rhs);
202 
203 HD_API
204 std::ostream& operator<<(std::ostream& out,
205                          const HdMaterialNetworkMap& pv);
206 HD_API
207 bool operator==(const HdMaterialNetworkMap& lhs,
208                 const HdMaterialNetworkMap& rhs);
209 HD_API
210 bool operator!=(const HdMaterialNetworkMap& lhs,
211                 const HdMaterialNetworkMap& rhs);
212 
213 
214 PXR_NAMESPACE_CLOSE_SCOPE
215 
216 #endif // PXR_IMAGING_HD_MATERIAL_H
217