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