15#include <pxr/imaging/hd/material.h>
16#include <pxr/imaging/hd/materialConnectionSchema.h>
17#include <pxr/imaging/hd/materialNetworkSchema.h>
18#include <pxr/imaging/hd/materialNodeParameterSchema.h>
19#include <pxr/imaging/hd/materialNodeSchema.h>
20#include <pxr/imaging/hd/materialSchema.h>
21#include <pxr/imaging/hd/sceneDelegate.h>
29 const std::string &s = nodeName.GetString();
31 return SdfPath::EmptyPath();
33 if (s[0] ==
'/' && SdfPath::IsValidPathString(s)) {
36 return SdfPath::AbsoluteRootPath().AppendChild(nodeName);
42 ((cyclesSurface,
"cycles:surface"))
43 ((cyclesDisplacement,
"cycles:displacement"))
44 ((cyclesVolume,
"cycles:volume"))
47 (UsdPrimvarReader_float)
48 (UsdPrimvarReader_float2)
49 (UsdPrimvarReader_float3)
50 (UsdPrimvarReader_float4)
51 (UsdPrimvarReader_int)
69 using ParamMap = std::unordered_map<TfToken, ustring, TfToken::HashFunctor>;
73 : _nodeType(
nodeType), _paramMap(std::move(paramMap))
84 return _paramMap.find(name) != _paramMap.end();
89 VtValue * =
nullptr)
const
93 if (inputConnection) {
94 if (name == CyclesMaterialTokens->a) {
97 if (name == CyclesMaterialTokens->rgb) {
101 if (name == CyclesMaterialTokens->r || name == CyclesMaterialTokens->g ||
102 name == CyclesMaterialTokens->b)
107 if (name == CyclesMaterialTokens->result) {
125 const auto it = _paramMap.find(name);
126 return it != _paramMap.end() ? it->second.string() : name.GetString();
130 const ustring _nodeType;
140 VtValue *value)
const override
144 if (name == CyclesMaterialTokens->wrapS || name == CyclesMaterialTokens->wrapT) {
145 const std::string valueString = VtValue::Cast<std::string>(*value).Get<std::string>();
148 if (valueString ==
"repeat") {
149 *value = VtValue(CyclesMaterialTokens->periodic);
163 const UsdToCyclesMapping UsdPreviewSurface = {
166 {TfToken(
"diffuseColor"), ustring(
"base_color")},
167 {TfToken(
"emissiveColor"), ustring(
"emission")},
168 {TfToken(
"specularColor"), ustring(
"specular")},
169 {TfToken(
"clearcoatRoughness"), ustring(
"coat_roughness")},
170 {TfToken(
"opacity"), ustring(
"alpha")},
175 const UsdToCyclesTexture UsdUVTexture = {
178 {CyclesMaterialTokens->st, ustring(
"vector")},
179 {CyclesMaterialTokens->wrapS, ustring(
"extension")},
180 {CyclesMaterialTokens->wrapT, ustring(
"extension")},
181 {TfToken(
"file"), ustring(
"filename")},
182 {TfToken(
"sourceColorSpace"), ustring(
"colorspace")},
184 const UsdToCyclesMapping UsdPrimvarReader = {
"attribute",
185 {{TfToken(
"varname"), ustring(
"attribute")}}};
188 const UsdToCyclesMapping *findUsd(
const TfToken &usdNodeType)
190 if (usdNodeType == CyclesMaterialTokens->UsdPreviewSurface) {
191 return &UsdPreviewSurface;
193 if (usdNodeType == CyclesMaterialTokens->UsdUVTexture) {
194 return &UsdUVTexture;
196 if (usdNodeType == CyclesMaterialTokens->UsdPrimvarReader_float ||
197 usdNodeType == CyclesMaterialTokens->UsdPrimvarReader_float2 ||
198 usdNodeType == CyclesMaterialTokens->UsdPrimvarReader_float3 ||
199 usdNodeType == CyclesMaterialTokens->UsdPrimvarReader_float4 ||
200 usdNodeType == CyclesMaterialTokens->UsdPrimvarReader_int)
202 return &UsdPrimvarReader;
207 const UsdToCyclesMapping *findCycles(
const ustring & )
212TfStaticData<UsdToCycles> sUsdToCyles;
219 const ustring instanceId(HdAovTokens->instanceId.GetString());
222 aovNode->set_name(instanceId);
225 instanceIdNode->set_attribute(instanceId);
236 return DirtyBits::DirtyResource | DirtyBits::DirtyParams;
240 HdRenderParam *renderParam,
241 HdDirtyBits *dirtyBits)
243 if (*dirtyBits == DirtyBits::Clean) {
247 const bool dirtyParams = (*dirtyBits & DirtyBits::DirtyParams);
248 const bool dirtyResource = (*dirtyBits & DirtyBits::DirtyResource);
250 const SdfPath &
id = GetId();
252 if (dirtyResource || dirtyParams) {
253 const HdSceneIndexPrim prim =
GetPrim(sceneDelegate,
id);
254 const HdContainerDataSourceHandle &primDs = prim.dataSource;
256 HdMaterialSchema matSchema = HdMaterialSchema::GetFromParent(primDs);
258 HdMaterialNetworkSchema network = matSchema.GetMaterialNetwork(CyclesMaterialTokens->cycles);
260 network = matSchema.GetMaterialNetwork();
265 if (network && !_nodes.empty() && !dirtyResource) {
266 UpdateParameters(network);
267 _shader->tag_update(
lock.scene);
272 TF_WARN(
"Could not get a material network for %s.",
id.GetText());
275 graph = BuildShaderGraph(network);
277 TF_WARN(
"Could not build a shader graph for %s.",
id.GetText());
283 graph = make_unique<ShaderGraph>();
285 graph->connect(bsdf->
output(
"BSDF"), graph->output()->input(
"Surface"));
294 _shader->set_graph(std::move(graph));
295 _shader->tag_update(
lock.scene);
299 *dirtyBits = DirtyBits::Clean;
302void HdCyclesMaterial::UpdateParameters(NodeDesc &nodeDesc,
303 HdMaterialNodeParameterContainerSchema params,
304 const SdfPath &nodePath)
306 for (
const TfToken ¶mName : params.GetNames()) {
307 auto valueDs = params.Get(paramName).GetValue();
311 VtValue value = valueDs->GetValue(0.0f);
314 const UsdToCyclesMapping *inputMapping = nodeDesc.mapping;
315 const std::string inputName = inputMapping ?
317 paramName.GetString();
320 const SocketType *input =
nullptr;
321 for (
const SocketType &socket : nodeDesc.node->type->inputs) {
331 TF_WARN(
"USD input '%s' on node '%s' maps to unavailable Cycles input '%s' on '%s'",
335 nodeDesc.node->name.c_str());
338 TF_WARN(
"Unsupported USD input '%s' on node '%s' ('%s'); value ignored",
341 nodeDesc.node->name.c_str());
345 TF_WARN(
"Could not find parameter '%s' on node '%s' ('%s')",
348 nodeDesc.node->name.c_str());
357void HdCyclesMaterial::UpdateParameters(HdMaterialNetworkSchema network)
359 HdMaterialNodeContainerSchema nodes = network.GetNodes();
360 for (
const TfToken &nodeName : nodes.GetNames()) {
363 const auto nodeIt = _nodes.find(nodePath);
364 if (nodeIt == _nodes.end()) {
365 TF_RUNTIME_ERROR(
"Could not update parameters on missing node '%s'", nodePath.GetText());
369 UpdateParameters(nodeIt->second, nodes.Get(nodeName).GetParameters(), nodePath);
373void HdCyclesMaterial::UpdateConnections(NodeDesc &nodeDesc,
374 HdMaterialNodeSchema nodeSchema,
375 const SdfPath &nodePath,
378 HdMaterialConnectionVectorContainerSchema conns = nodeSchema.GetInputConnections();
379 for (
const TfToken &dstSocketName : conns.GetNames()) {
380 HdMaterialConnectionVectorSchema connVec = conns.Get(dstSocketName);
381 const size_t count = connVec.GetNumElements();
386 const UsdToCyclesMapping *inputMapping = nodeDesc.mapping;
387 const std::string inputName = inputMapping ?
389 dstSocketName.GetString();
392 ShaderInput *input =
nullptr;
393 for (ShaderInput *
in : nodeDesc.node->inputs) {
401 TF_WARN(
"Ignoring connection on '%s.%s', input '%s' was not found",
403 dstSocketName.GetText(),
404 dstSocketName.GetText());
413 "Ignoring multiple connections to '%s.%s'", nodePath.GetText(), dstSocketName.GetText());
416 HdMaterialConnectionSchema connSchema = connVec.GetElement(0);
417 const SdfPath upstreamNodePath =
418 connSchema.GetUpstreamNodePath() ?
421 const TfToken upstreamOutputName = connSchema.GetUpstreamNodeOutputName() ?
422 connSchema.GetUpstreamNodeOutputName()->GetTypedValue(
426 const auto srcNodeIt = _nodes.find(upstreamNodePath);
427 if (srcNodeIt == _nodes.end()) {
428 TF_WARN(
"Ignoring connection from '%s.%s' to '%s.%s', node '%s' was not found",
429 upstreamNodePath.GetText(),
430 upstreamOutputName.GetText(),
432 dstSocketName.GetText(),
433 upstreamNodePath.GetText());
437 const UsdToCyclesMapping *outputMapping = srcNodeIt->second.mapping;
438 const std::string outputName = outputMapping ?
439 outputMapping->parameterName(upstreamOutputName, input) :
440 upstreamOutputName.GetString();
442 ShaderOutput *
output =
nullptr;
443 for (ShaderOutput *
out : srcNodeIt->second.node->outputs) {
444 if (string_iequals(out->socket_type.name.string(), outputName)) {
451 TF_WARN(
"Ignoring connection from '%s.%s' to '%s.%s', output '%s' was not found",
452 upstreamNodePath.GetText(),
453 upstreamOutputName.GetText(),
455 dstSocketName.GetText(),
456 upstreamOutputName.GetText());
468 unique_ptr<ShaderGraph> graph = make_unique<ShaderGraph>();
470 HdMaterialNodeContainerSchema nodes = network.GetNodes();
473 for (
const TfToken &nodeName : nodes.GetNames()) {
474 HdMaterialNodeSchema nodeSchema = nodes.Get(nodeName);
477 NodeDesc nodeDesc = {};
479 const auto nodeIt = _nodes.find(nodePath);
481 if (nodeIt != _nodes.end()) {
482 nodeDesc = nodeIt->second;
486 const TfToken nodeTypeIdToken = nodeSchema.GetNodeIdentifier() ?
487 nodeSchema.GetNodeIdentifier()->GetTypedValue(0.0f) :
489 const std::string &nodeTypeId = nodeTypeIdToken.GetString();
491 ustring cyclesType(nodeTypeId);
492 if (nodeTypeId.starts_with(
"cycles_") || nodeTypeId.starts_with(
"cycles:")) {
494 cyclesType = nodeTypeId.substr(strlen(
"cycles_"));
495 nodeDesc.mapping = sUsdToCyles->findCycles(cyclesType);
499 nodeDesc.mapping = sUsdToCyles->findUsd(nodeTypeIdToken);
500 if (nodeDesc.mapping) {
501 cyclesType = nodeDesc.mapping->nodeType();
507 nodeDesc.node = graph->create_node(nodeType);
508 _nodes.emplace(nodePath, nodeDesc);
511 TF_RUNTIME_ERROR(
"Could not create node '%s'", nodePath.GetText());
516 UpdateParameters(nodeDesc, nodeSchema.GetParameters(), nodePath);
521 for (
const TfToken &nodeName : nodes.GetNames()) {
524 const auto nodeIt = _nodes.find(nodePath);
525 if (nodeIt == _nodes.end()) {
526 TF_RUNTIME_ERROR(
"Could not find node '%s' to connect", nodePath.GetText());
530 UpdateConnections(nodeIt->second, nodes.Get(nodeName), nodePath, graph.get());
534 HdMaterialConnectionContainerSchema terminals = network.GetTerminals();
535 for (
const TfToken &terminalName : terminals.GetNames()) {
536 HdMaterialConnectionSchema termSchema = terminals.Get(terminalName);
537 const SdfPath upstreamNodePath =
538 termSchema.GetUpstreamNodePath() ?
541 const TfToken upstreamOutputName = termSchema.GetUpstreamNodeOutputName() ?
542 termSchema.GetUpstreamNodeOutputName()->GetTypedValue(
546 const auto nodeIt = _nodes.find(upstreamNodePath);
547 if (nodeIt == _nodes.end()) {
548 TF_RUNTIME_ERROR(
"Could not find terminal node '%s'", upstreamNodePath.GetText());
552 ShaderNode *
const node = nodeIt->second.node;
554 const char *inputName =
nullptr;
555 const char *outputName =
nullptr;
556 if (terminalName == HdMaterialTerminalTokens->surface ||
557 terminalName == CyclesMaterialTokens->cyclesSurface)
559 inputName =
"Surface";
561 if (node->type->name ==
"add_closure" || node->type->name ==
"mix_closure") {
562 outputName =
"Closure";
564 else if (
node->type->name ==
"emission") {
565 outputName =
"Emission";
571 else if (terminalName == HdMaterialTerminalTokens->displacement ||
572 terminalName == CyclesMaterialTokens->cyclesDisplacement)
574 inputName = outputName =
"Displacement";
576 else if (terminalName == HdMaterialTerminalTokens->volume ||
577 terminalName == CyclesMaterialTokens->cyclesVolume)
579 inputName = outputName =
"Volume";
585 if (!upstreamOutputName.IsEmpty() && nodeIt->second.mapping ==
nullptr) {
586 outputName = upstreamOutputName.GetText();
589 ShaderInput *
const input = inputName ? graph->output()->input(inputName) :
nullptr;
591 TF_RUNTIME_ERROR(
"Could not find terminal input '%s.%s'",
592 upstreamNodePath.GetText(),
593 inputName ? inputName :
"<null>");
597 ShaderOutput *
const output = outputName ?
node->output(outputName) :
nullptr;
599 TF_RUNTIME_ERROR(
"Could not find terminal output '%s.%s'",
600 upstreamNodePath.GetText(),
601 outputName ? outputName :
"<null>");
605 graph->connect(
output, input);
610 bool any_output_linked =
false;
611 for (
ShaderInput *input : graph->output()->inputs) {
612 any_output_linked |= input->
link !=
nullptr;
614 if (!any_output_linked) {
629 const bool keep_nodes =
static_cast<const HdCyclesSession *
>(renderParam)->keep_nodes;
634 lock.scene->delete_node(_shader);
PXR_NS::HdDirtyBits GetInitialDirtyBitsMask() const override
void Finalize(PXR_NS::HdRenderParam *renderParam) override
HdCyclesMaterial(const PXR_NS::SdfPath &sprimId)
~HdCyclesMaterial() override
void Sync(PXR_NS::HdSceneDelegate *sceneDelegate, PXR_NS::HdRenderParam *renderParam, PXR_NS::HdDirtyBits *dirtyBits) override
T * create_node(Args &&...args)
void connect(ShaderOutput *from, ShaderInput *to)
const SocketType & socket_type
ShaderInput * input(const char *name)
ShaderOutput * output(const char *name)
UsdToCyclesMapping(const char *nodeType, ParamMap paramMap)
bool hasParameterMapping(const TfToken &name) const
virtual std::string parameterName(const TfToken &name, const ShaderInput *inputConnection, VtValue *=nullptr) const
UsdToCyclesMapping(const char *nodeType, ParamMap paramMap)
std::string parameterName(const TfToken &name, const ShaderInput *inputConnection, VtValue *value) const override
#define HDCYCLES_NAMESPACE_CLOSE_SCOPE
TF_DEFINE_PRIVATE_TOKENS(_tokens,(visibleInPrimaryRay)(treatAsPoint)(falloff))
HDCYCLES_NAMESPACE_OPEN_SCOPE HdSceneIndexPrim GetPrim(HdSceneDelegate *delegate, const SdfPath &id)
static void AddInstanceIdAOV(ShaderGraph *graph)
static HDCYCLES_NAMESPACE_OPEN_SCOPE SdfPath MaterialNodeNameToSdfPath(const TfToken &nodeName)
void SetNodeValue(Node *node, const SocketType &socket, const VtValue &value)
bool string_iequals(const string &a, const string &b)
static const NodeType * find(ustring name)