38#include <pxr/base/gf/vec3f.h>
39#include <pxr/usd/ar/packageUtils.h>
40#include <pxr/usd/usdShade/material.h>
41#include <pxr/usd/usdShade/shader.h>
52static const pxr::TfToken
a(
"a", pxr::TfToken::Immortal);
53static const pxr::TfToken
b(
"b", pxr::TfToken::Immortal);
54static const pxr::TfToken
bias(
"bias", pxr::TfToken::Immortal);
55static const pxr::TfToken
clearcoat(
"clearcoat", pxr::TfToken::Immortal);
57static const pxr::TfToken
diffuseColor(
"diffuseColor", pxr::TfToken::Immortal);
58static const pxr::TfToken
displacement(
"displacement", pxr::TfToken::Immortal);
59static const pxr::TfToken
emissiveColor(
"emissiveColor", pxr::TfToken::Immortal);
60static const pxr::TfToken
file(
"file", pxr::TfToken::Immortal);
61static const pxr::TfToken
g(
"g", pxr::TfToken::Immortal);
62static const pxr::TfToken
ior(
"ior", pxr::TfToken::Immortal);
63static const pxr::TfToken
in(
"in", pxr::TfToken::Immortal);
64static const pxr::TfToken
metallic(
"metallic", pxr::TfToken::Immortal);
65static const pxr::TfToken
normal(
"normal", pxr::TfToken::Immortal);
66static const pxr::TfToken
occlusion(
"occlusion", pxr::TfToken::Immortal);
67static const pxr::TfToken
opacity(
"opacity", pxr::TfToken::Immortal);
69static const pxr::TfToken
r(
"r", pxr::TfToken::Immortal);
70static const pxr::TfToken
rgb(
"rgb", pxr::TfToken::Immortal);
71static const pxr::TfToken
rgba(
"rgba", pxr::TfToken::Immortal);
72static const pxr::TfToken
roughness(
"roughness", pxr::TfToken::Immortal);
73static const pxr::TfToken
scale(
"scale", pxr::TfToken::Immortal);
74static const pxr::TfToken
specularColor(
"specularColor", pxr::TfToken::Immortal);
75static const pxr::TfToken
st(
"st", pxr::TfToken::Immortal);
76static const pxr::TfToken
varname(
"varname", pxr::TfToken::Immortal);
79static const pxr::TfToken
black(
"black", pxr::TfToken::Immortal);
80static const pxr::TfToken
clamp(
"clamp", pxr::TfToken::Immortal);
81static const pxr::TfToken
repeat(
"repeat", pxr::TfToken::Immortal);
82static const pxr::TfToken
mirror(
"mirror", pxr::TfToken::Immortal);
83static const pxr::TfToken
wrapS(
"wrapS", pxr::TfToken::Immortal);
84static const pxr::TfToken
wrapT(
"wrapT", pxr::TfToken::Immortal);
87static const pxr::TfToken
rotation(
"rotation", pxr::TfToken::Immortal);
88static const pxr::TfToken
translation(
"translation", pxr::TfToken::Immortal);
93 pxr::TfToken::Immortal);
94static const pxr::TfToken
UsdUVTexture(
"UsdUVTexture", pxr::TfToken::Immortal);
95static const pxr::TfToken
UsdTransform2d(
"UsdTransform2d", pxr::TfToken::Immortal);
118 if (!source_socket) {
139 for (
const auto &PropertySpec :
attribute.GetPropertyStack(pxr::UsdTimeCode::EarliestTime())) {
140 if (PropertySpec->HasDefaultValue() ||
141 PropertySpec->GetLayer()->GetNumTimeSamplesForPath(PropertySpec->GetPath()) > 0)
143 return PropertySpec->GetLayer();
147 return pxr::SdfLayerHandle();
155 STRNCPY(base_udim_path, file_path.c_str());
160 ListBaseT<LinkData>
tiles = {
nullptr,
nullptr};
161 int tile_start, tile_range;
166 udim_tiles.
append(tile_number);
170 tiles.free_no_destruct();
183 bool remove_first =
true;
185 for (
int tile_number : indices) {
188 remove_first =
false;
209 if (opacity_input.HasConnectedSource()) {
214 if (opacity_input.GetAttr().HasAuthoredValue() && opacity_input.GetAttr().Get(&val)) {
215 float opacity = val.Get<
float>();
227 float default_value = 0.0f)
230 return default_value;
235 if (!opacity_threshold_input) {
236 return default_value;
240 if (opacity_threshold_input.GetAttr().HasAuthoredValue() &&
241 opacity_threshold_input.GetAttr().Get(&val))
243 return val.Get<
float>();
246 return default_value;
258 return default_value;
261 pxr::VtValue wrap_input_val;
262 if (!(wrap_input.Get(&wrap_input_val) && wrap_input_val.IsHolding<pxr::TfToken>())) {
263 return default_value;
266 pxr::TfToken wrap_val = wrap_input_val.UncheckedGet<pxr::TfToken>();
284 return default_value;
291 pxr::UsdShadeShader &r_preview_surface)
297 if (pxr::UsdShadeShader surf_shader = usd_material.ComputeSurfaceSource()) {
299 pxr::TfToken shader_id;
301 r_preview_surface = surf_shader;
313 if (!(mtl && usd_preview)) {
318 const pxr::UsdShadeAttributeVector attrs = diffuse_color_input.GetValueProducingAttributes();
319 if (!attrs.empty()) {
321 if (attrs[0].Get(&val) && val.IsHolding<pxr::GfVec3f>()) {
322 pxr::GfVec3f
color = val.UncheckedGet<pxr::GfVec3f>();
334 const pxr::UsdShadeAttributeVector attrs = metallic_input.GetValueProducingAttributes();
335 if (!attrs.empty()) {
337 if (attrs[0].Get(&val) && val.IsHolding<
float>()) {
338 mtl->metallic = val.UncheckedGet<
float>();
344 const pxr::UsdShadeAttributeVector attrs = roughness_input.GetValueProducingAttributes();
345 if (!attrs.empty()) {
347 if (attrs[0].Get(&val) && val.IsHolding<
float>()) {
348 mtl->roughness = val.UncheckedGet<
float>();
354static pxr::UsdShadeInput
get_input(
const pxr::UsdShadeShader &usd_shader,
355 const pxr::TfToken &input_name)
357 pxr::UsdShadeInput input = usd_shader.GetInput(input_name);
362 for (
const pxr::UsdShadeConnectionSourceInfo &source_info : input.GetConnectedSources()) {
363 pxr::UsdShadeShader
shader = pxr::UsdShadeShader(source_info.source.GetPrim());
364 pxr::UsdShadeInput secondary_input =
shader.GetInput(source_info.sourceName);
365 if (secondary_input) {
366 input = secondary_input;
383 "%s: Error: Couldn't get input socket %s for node %s",
416 std::string key = usd_shader.GetPath().GetAsString();
438 : params_(params), bmain_(bmain)
444 return params_.worker_status ? params_.worker_status->reports :
nullptr;
448 const bool read_usd_preview)
const
454 std::string mtl_name = usd_material.GetPrim().GetName().GetString();
460 if (read_usd_preview) {
471 const pxr::UsdShadeMaterial &usd_material)
const
475 pxr::UsdShadeShader usd_preview;
481 if (params_.import_usd_preview) {
488 const pxr::UsdShadeMaterial &usd_material,
489 const pxr::UsdShadeShader &usd_shader)
const
491 if (!(mtl && usd_shader)) {
513 if (pxr::UsdShadeShader disp_shader = usd_material.ComputeDisplacementSource()) {
524 if (params_.set_material_blend) {
533 const pxr::UsdShadeShader &usd_shader)
const
548 set_node_input(diffuse_input, principled,
"Base Color", ntree, column, context, extra);
551 float emission_strength = 0.0f;
556 emissive_input, principled,
"Emission Color", ntree, column, context, extra))
558 emission_strength = 1.0f;
563 *principled,
SOCK_IN,
"Emission Strength"_ustr);
567 set_node_input(specular_input, principled,
"Specular Tint", ntree, column, context);
571 set_node_input(metallic_input, principled,
"Metallic", ntree, column, context);
575 set_node_input(roughness_input, principled,
"Roughness", ntree, column, context);
579 set_node_input(coat_input, principled,
"Coat Weight", ntree, column, context);
584 set_node_input(coat_roughness_input, principled,
"Coat Roughness", ntree, column, context);
590 bool is_alpha_exception =
false;
591 if (opacity_input.HasConnectedSource()) {
592 for (
const pxr::UsdShadeConnectionSourceInfo &source_info :
593 opacity_input.GetConnectedSources())
596 is_alpha_exception =
true;
603 if (opacity_threshold == 0.0f && !is_alpha_exception) {
606 opacity_input, principled,
"Transmission Weight", ntree, column, context, extra);
610 set_node_input(opacity_input, principled,
"Alpha", ntree, column, context, extra);
614 if (pxr::UsdShadeInput ior_input = usd_shader.GetInput(
usdtokens::ior)) {
615 set_node_input(ior_input, principled,
"IOR", ntree, column, context);
619 set_node_input(normal_input, principled,
"Normal", ntree, column, context);
625 const pxr::UsdShadeShader &usd_shader)
const
629 if (!displacement_input) {
645 set_node_input(displacement_input, displacement_node, height, ntree, column, context, extra);
650 if (!displacement_input.HasConnectedSource()) {
661 link_nodes(ntree, displacement_node,
"Displacement",
output,
"Displacement");
673 if (!(usd_input && dest_node)) {
677 const pxr::UsdShadeSourceInfoVector sources = usd_input.GetConnectedSources();
678 const bool needs_follow = !sources.empty() &&
679 sources[0].sourceType == pxr::UsdShadeAttributeType::Output;
684 return follow_connection(usd_input, dest_node, dest_socket_name, ntree, column, ctx, extra);
690 CLOG_ERROR(&
LOG,
"Couldn't get destination node socket %s", dest_socket_name.
c_str());
695 const pxr::UsdShadeAttributeVector attrs = usd_input.GetValueProducingAttributes();
696 if (attrs.empty() || !attrs[0].Get(&val)) {
698 "Couldn't get value for usd shader input %s",
699 usd_input.GetPrim().GetPath().GetAsString().c_str());
703 switch (sock->
type) {
705 if (val.IsHolding<
float>()) {
707 sock_val->
value = val.UncheckedGet<
float>();
713 else if (val.IsHolding<pxr::GfVec3f>()) {
714 pxr::GfVec3f v3f = val.UncheckedGet<pxr::GfVec3f>();
715 float average = (v3f[0] + v3f[1] + v3f[2]) / 3.0f;
721 if (val.IsHolding<pxr::GfVec3f>()) {
722 pxr::GfVec3f v3f = val.UncheckedGet<pxr::GfVec3f>();
729 if (val.IsHolding<pxr::GfVec3f>()) {
730 pxr::GfVec3f v3f = val.UncheckedGet<pxr::GfVec3f>();
734 else if (val.IsHolding<pxr::GfVec2f>()) {
735 pxr::GfVec2f v2f = val.UncheckedGet<pxr::GfVec2f>();
742 "Unexpected type %s for destination node socket %s",
744 dest_socket_name.
c_str());
774 bool feeds_normal_map,
780 pxr::GfVec4f
scale(1.0f, 1.0f, 1.0f, 1.0f);
781 pxr::GfVec4f bias(0.0f, 0.0f, 0.0f, 0.0f);
784 if (scale_input.Get(&val) && val.CanCast<pxr::GfVec4f>()) {
785 scale = pxr::VtValue::Cast<pxr::GfVec4f>(val).UncheckedGet<pxr::GfVec4f>();
787 if (bias_input.Get(&val) && val.CanCast<pxr::GfVec4f>()) {
788 bias = pxr::VtValue::Cast<pxr::GfVec4f>(val).UncheckedGet<pxr::GfVec4f>();
792 if (
scale == pxr::GfVec4f{1.0f, 1.0f, 1.0f, 1.0f} &&
793 bias == pxr::GfVec4f{0.0f, 0.0f, 0.0f, 0.0f})
799 if (feeds_normal_map && (
scale[0] == 2.0f &&
scale[1] == 2.0f &&
scale[2] == 2.0f) &&
800 (bias[0] == -1.0f && bias[1] == -1.0f && bias[2] == -1.0f))
853 const pxr::TfToken &usd_source_name,
887 return separate_color;
932 pxr::GfVec4f
scale(1.0f, 1.0f, 1.0f, 1.0f);
933 pxr::GfVec4f bias(0.0f, 0.0f, 0.0f, 0.0f);
936 if (scale_input.Get(&val) && val.CanCast<pxr::GfVec4f>()) {
937 scale = pxr::VtValue::Cast<pxr::GfVec4f>(val).UncheckedGet<pxr::GfVec4f>();
939 if (bias_input.Get(&val) && val.CanCast<pxr::GfVec4f>()) {
940 bias = pxr::VtValue::Cast<pxr::GfVec4f>(val).UncheckedGet<pxr::GfVec4f>();
944 const float bias_avg = (bias[0] + bias[1] + bias[2]) / 3.0f;
953 const pxr::TfToken &output_name)
956 pxr::UsdShadeOutput
output = node_graph.GetOutput(output_name);
958 return pxr::UsdShadeShader();
961 pxr::UsdShadeAttributeVector attrs = pxr::UsdShadeUtils::GetValueProducingAttributes(
output);
963 return pxr::UsdShadeShader();
966 pxr::UsdAttribute attr = attrs[0];
968 std::pair<pxr::TfToken, pxr::UsdShadeAttributeType> name_and_type =
969 pxr::UsdShadeUtils::GetBaseNameAndType(attr.GetName());
971 pxr::UsdShadeShader
shader(attr.GetPrim());
972 if (name_and_type.second != pxr::UsdShadeAttributeType::Output || !
shader) {
973 return pxr::UsdShadeShader();
987 if (!(usd_input && dest_node && !dest_socket_name.
is_empty() && ntree)) {
991 pxr::UsdShadeConnectableAPI source;
992 pxr::TfToken source_name;
993 pxr::UsdShadeAttributeType source_type;
995 usd_input.GetConnectedSource(&source, &source_name, &source_type);
1001 const pxr::UsdPrim source_prim = source.GetPrim();
1002 pxr::UsdShadeShader source_shader;
1003 if (source_prim.IsA<pxr::UsdShadeShader>()) {
1004 source_shader = pxr::UsdShadeShader(source_prim);
1006 else if (source_prim.IsA<pxr::UsdShadeNodeGraph>()) {
1007 pxr::UsdShadeNodeGraph node_graph(source_prim);
1011 if (!source_shader) {
1015 pxr::TfToken shader_id;
1016 if (!source_shader.GetShaderId(&shader_id)) {
1018 "Couldn't get shader id for source shader %s",
1019 source_shader.GetPath().GetAsString().c_str());
1029 const bool is_normal_map = dest_socket_name ==
"Normal";
1030 if (is_normal_map) {
1037 source_shader, source_name, ntree, column + shift, ctx);
1038 if (separate_color.
node) {
1044 if (dest_socket_name ==
"Height") {
1048 scale_bias =
add_scale_bias(source_shader, ntree, column + shift, is_normal_map, ctx);
1053 bNode *target_node = dest_node;
1060 target_node =
invert.node;
1061 target_sock_name =
invert.sock_input_name;
1064 if (normal_map.
node) {
1067 if (scale_bias.
node) {
1080 target_node = scale_bias.
node;
1085 target_node = normal_map.
node;
1091 else if (scale_bias.
node) {
1092 if (separate_color.
node) {
1094 separate_color.
node,
1101 separate_color.
node,
1108 target_node = scale_bias.
node;
1112 else if (separate_color.
node) {
1115 separate_color.
node,
1120 target_node = separate_color.
node;
1133 if (separate_color.
node) {
1135 separate_color.
node,
1141 target_node = lessthan.
node;
1157 source_shader, source_name, dest_node, dest_socket_name, ntree, column + 1, ctx);
1164 StringRef shader_id_name(shader_id.GetString());
1165 if (shader_id_name.
startswith(
"UsdPrimvarReader_")) {
1167 if (type_offset >= 0) {
1170 source_shader, output_type, dest_node, dest_socket_name, ntree, column + 1, ctx);
1179 const pxr::TfToken &usd_source_name,
1187 if (!usd_shader || !dest_node || !ntree || dest_socket_name.
is_empty()) {
1193 if (tex_image ==
nullptr) {
1211 link_nodes(ntree, tex_image, source_socket_name, dest_node, dest_socket_name);
1214 if (pxr::UsdShadeInput st_input = usd_shader.GetInput(
usdtokens::st)) {
1215 set_node_input(st_input, tex_image,
"Vector", ntree, column, ctx);
1226 if (!usd_shader || !dest_node || !ntree || dest_socket_name.
is_empty()) {
1232 if (mapping ==
nullptr) {
1246 if (scale_input.Get(&val) && val.CanCast<pxr::GfVec2f>()) {
1247 pxr::GfVec2f scale_val = val.Cast<pxr::GfVec2f>().UncheckedGet<pxr::GfVec2f>();
1248 float scale[3] = {scale_val[0], scale_val[1], 1.0f};
1257 if (trans_input.Get(&val) && val.CanCast<pxr::GfVec2f>()) {
1258 pxr::GfVec2f trans_val = val.Cast<pxr::GfVec2f>().UncheckedGet<pxr::GfVec2f>();
1259 float location[3] = {trans_val[0], trans_val[1], 0.0f};
1268 if (rot_input.Get(&val) && val.CanCast<
float>()) {
1269 float rot_val = val.Cast<
float>().UncheckedGet<float>() *
M_PI / 180.0f;
1270 float rot[3] = {0.0f, 0.0f, rot_val};
1278 link_nodes(ntree, mapping,
"Vector", dest_node, dest_socket_name);
1281 if (pxr::UsdShadeInput in_input = usd_shader.GetInput(
usdtokens::in)) {
1299 "Couldn't get file input property for USD shader %s",
1300 usd_shader.GetPath().GetAsString().c_str());
1306 if (file_input.HasConnectedSource()) {
1307 pxr::UsdShadeConnectableAPI source;
1308 pxr::TfToken source_name;
1309 pxr::UsdShadeAttributeType source_type;
1311 if (file_input.GetConnectedSource(&source, &source_name, &source_type)) {
1312 file_input = source.GetInput(source_name);
1316 "Couldn't get connected source for file input %s (%s)\n",
1317 file_input.GetPrim().GetPath().GetText(),
1318 file_input.GetFullName().GetText());
1322 pxr::VtValue file_val;
1323 if (!file_input.Get(&file_val) || !file_val.IsHolding<pxr::SdfAssetPath>()) {
1325 "Couldn't get file input value for USD shader %s",
1326 usd_shader.GetPath().GetAsString().c_str());
1330 const pxr::SdfAssetPath &asset_path = file_val.UncheckedGet<pxr::SdfAssetPath>();
1331 std::string file_path = asset_path.GetResolvedPath();
1333 if (file_path.empty()) {
1335 file_path = asset_path.GetAssetPath();
1339 if (pxr::SdfLayerHandle layer_handle =
get_layer_handle(file_input.GetAttr())) {
1340 file_path = layer_handle->ComputeAbsolutePath(file_path);
1345 if (file_path.empty()) {
1347 "Couldn't resolve image asset '%s' for Texture Image node",
1348 asset_path.GetAssetPath().c_str());
1353 const bool is_relative = pxr::ArIsPackageRelativePath(file_path);
1354 const bool import_textures = params_.import_textures_mode !=
TexImportMode::None && is_relative;
1356 std::string imported_file_source_path;
1358 if (import_textures) {
1359 imported_file_source_path = file_path;
1365 params_.import_textures_dir;
1370 params_.tex_name_collision_mode;
1378 bool check_open =
true;
1388 const char *im_file = file_path.c_str();
1391 CLOG_WARN(&
LOG,
"Couldn't open image file '%s' for Texture Image node", im_file);
1406 if (import_textures && imported_file_source_path != file_path) {
1421 const pxr::TfToken & ,
1428 if (!usd_shader || !dest_node || !ntree || dest_socket_name.
is_empty()) {
1434 if (uv_map ==
nullptr) {
1448 if (varname_input) {
1449 for (
const pxr::UsdShadeConnectionSourceInfo &source_info :
1450 varname_input.GetConnectedSources())
1452 pxr::UsdShadeShader
shader = pxr::UsdShadeShader(source_info.source.GetPrim());
1453 pxr::UsdShadeInput secondary_varname_input =
shader.GetInput(source_info.sourceName);
1454 if (secondary_varname_input) {
1455 varname_input = secondary_varname_input;
1461 if (varname_input) {
1462 pxr::VtValue varname_val;
1465 if (varname_input.Get(&varname_val) && varname_val.CanCastToTypeid(
typeid(std::string))) {
1466 std::string varname = varname_val.Cast<std::string>().Get<std::string>();
1467 if (!varname.empty()) {
1476 link_nodes(ntree, uv_map,
"UV", dest_node, dest_socket_name);
1487 if (!usd_shader || !dest_node || !ntree) {
1507 if (varname_input) {
1508 for (
const pxr::UsdShadeConnectionSourceInfo &source_info :
1509 varname_input.GetConnectedSources())
1511 pxr::UsdShadeShader
shader = pxr::UsdShadeShader(source_info.source.GetPrim());
1512 pxr::UsdShadeInput secondary_varname_input =
shader.GetInput(source_info.sourceName);
1513 if (secondary_varname_input) {
1514 varname_input = secondary_varname_input;
1520 if (varname_input) {
1521 pxr::VtValue varname_val;
1524 if (varname_input.Get(&varname_val) && varname_val.CanCastToTypeid(
typeid(std::string))) {
1525 std::string varname = varname_val.Cast<std::string>().Get<std::string>();
1526 if (!varname.empty()) {
1535 if (
ELEM(output_type,
"float",
"int")) {
1538 else if (
ELEM(output_type,
"float3",
"float4")) {
1541 else if (
ELEM(output_type,
"vector",
"normal",
"point")) {
1551 r_mat_map.
add_new(material.id.name + 2, &material);
General operations, lookup, etc. for materials.
#define SH_NODE_TEX_IMAGE
#define SH_NODE_BSDF_PRINCIPLED
#define SH_NODE_SEPARATE_COLOR
#define SH_NODE_VECTOR_MATH
#define SH_NODE_NORMAL_MAP
#define SH_NODE_OUTPUT_MATERIAL
#define SH_NODE_DISPLACEMENT
#define SH_NODE_ATTRIBUTE
File and directory operations.
#define CLOG_ERROR(clg_ref,...)
#define CLOG_WARN(clg_ref,...)
#define ID_BLEND_PATH(_bmain, _id)
These structs are the foundation for all linked lists in the library system.
#define POINTER_AS_INT(i)
#define BLI_assert_msg(a, msg)
Value lookup_default(const Key &key, const Value &default_value) const
void add_new(const Key &key, const Value &value)
constexpr const char * c_str() const
constexpr StringRef drop_prefix(int64_t n) const
void append(const T &value)
constexpr int64_t rfind(char c, int64_t pos=INT64_MAX) const
constexpr bool startswith(StringRef prefix) const
constexpr bool is_empty() const
bool follow_connection(const pxr::UsdShadeInput &usd_input, bNode *dest_node, const StringRefNull dest_socket_name, bNodeTree *ntree, int column, NodePlacementContext &ctx, const ExtraLinkInfo &extra={}) const
void convert_usd_transform_2d(const pxr::UsdShadeShader &usd_shader, bNode *dest_node, const StringRefNull dest_socket_name, bNodeTree *ntree, int column, NodePlacementContext &ctx) const
Material * add_material(const pxr::UsdShadeMaterial &usd_material, bool read_usd_preview=true) const
void import_usd_preview_nodes(Material *mtl, const pxr::UsdShadeMaterial &usd_material, const pxr::UsdShadeShader &usd_shader) const
USDMaterialReader(const USDImportParams ¶ms, Main &bmain)
bool set_displacement_node_inputs(bNodeTree *ntree, bNode *output, const pxr::UsdShadeShader &usd_shader) const
bool set_node_input(const pxr::UsdShadeInput &usd_input, bNode *dest_node, const StringRefNull dest_socket_name, bNodeTree *ntree, int column, NodePlacementContext &ctx, const ExtraLinkInfo &extra={}) const
void convert_usd_primvar_reader_generic(const pxr::UsdShadeShader &usd_shader, StringRef output_type, bNode *dest_node, const StringRefNull dest_socket_name, bNodeTree *ntree, int column, NodePlacementContext &ctx) const
void convert_usd_primvar_reader_float2(const pxr::UsdShadeShader &usd_shader, const pxr::TfToken &usd_source_name, bNode *dest_node, const StringRefNull dest_socket_name, bNodeTree *ntree, int column, NodePlacementContext &ctx) const
ReportList * reports() const
void convert_usd_uv_texture(const pxr::UsdShadeShader &usd_shader, const pxr::TfToken &usd_source_name, bNode *dest_node, const StringRefNull dest_socket_name, bNodeTree *ntree, int column, NodePlacementContext &ctx, const ExtraLinkInfo &extra={}) const
void set_principled_node_inputs(bNode *principled_node, bNodeTree *ntree, const pxr::UsdShadeShader &usd_shader) const
void import_usd_preview(Material *mtl, const pxr::UsdShadeMaterial &usd_material) const
void load_tex_image(const pxr::UsdShadeShader &usd_shader, bNode *tex_image, const ExtraLinkInfo &extra={}) const
#define storage(slot, qualifiers)
float2x2 invert(float2x2 mat)
float3x3 scale(float3x3 mat, float2 scale)
ccl_gpu_kernel_postfix ccl_global KernelWorkTile * tiles
const ccl_global KernelWorkTile * tile
int node_count_socket_links(const bNodeTree &ntree, const bNodeSocket &sock)
bNode * node_add_static_node(const bContext *C, bNodeTree &ntree, int type)
bNodeLink & node_add_link(bNodeTree &ntree, bNode &fromnode, bNodeSocket &fromsock, bNode &tonode, bNodeSocket &tosock)
bNodeSocket * node_find_socket(bNode &node, eNodeSocketInOut in_out, UString identifier)
void node_set_active(bNodeTree &ntree, bNode &node)
const char * temp_textures_dir()
static IntermediateNode add_separate_color(const pxr::UsdShadeShader &usd_shader, const pxr::TfToken &usd_source_name, bNodeTree *ntree, int column, NodePlacementContext &ctx)
Map< std::string, bNode * > ShaderToNodeMap
bool is_udim_path(const std::string &path)
static IntermediateNode add_scale_bias_adjust(bNodeTree *ntree, int column, NodePlacementContext &ctx)
void colorspace_attr_to_scene_linear(const pxr::UsdAttribute &attr, pxr::GfVec3f &color)
static IntermediateNode add_scale_bias(const pxr::UsdShadeShader &usd_shader, bNodeTree *ntree, int column, bool feeds_normal_map, NodePlacementContext &ctx)
void set_id_props_from_prim(ID *id, const pxr::UsdPrim &prim, const PropertyImportMode property_import_mode, const pxr::UsdTimeCode time_code)
static pxr::UsdShadeShader node_graph_output_source(const pxr::UsdShadeNodeGraph &node_graph, const pxr::TfToken &output_name)
static IntermediateNode add_oneminus(bNodeTree *ntree, int column, NodePlacementContext &ctx)
void colorspace_to_image_texture(const pxr::UsdShadeShader &usd_shader, const pxr::UsdShadeInput &file_input, const bool is_data, Image *image)
std::string import_asset(const std::string &src, const char *import_dir, TexNameCollisionMode name_collision_mode, ReportList *reports)
static IntermediateNode add_normal_map(bNodeTree *ntree, int column, NodePlacementContext &ctx)
void ensure_usd_source_path_prop(const std::string &path, ID *id)
Material * find_existing_material(const pxr::SdfPath &usd_mat_path, const USDImportParams ¶ms, const Map< std::string, Material * > &mat_map, const Map< pxr::SdfPath, Material * > &usd_path_to_mat)
static void configure_displacement(const pxr::UsdShadeShader &usd_shader, bNode *displacement_node)
void build_material_map(const Main *bmain, Map< std::string, Material * > &r_mat_map)
static IntermediateNode add_lessthan(bNodeTree *ntree, float threshold, int column, NodePlacementContext &ctx)
static const pxr::TfToken rgba("rgba", pxr::TfToken::Immortal)
static const pxr::TfToken UsdPrimvarReader_float2("UsdPrimvarReader_float2", pxr::TfToken::Immortal)
static const pxr::TfToken varname("varname", pxr::TfToken::Immortal)
static const pxr::TfToken rotation("rotation", pxr::TfToken::Immortal)
static const pxr::TfToken mirror("mirror", pxr::TfToken::Immortal)
static const pxr::TfToken opacity("opacity", pxr::TfToken::Immortal)
static const pxr::TfToken rgb("rgb", pxr::TfToken::Immortal)
static const pxr::TfToken roughness("roughness", pxr::TfToken::Immortal)
static const pxr::TfToken wrapS("wrapS", pxr::TfToken::Immortal)
static const pxr::TfToken UsdUVTexture("UsdUVTexture", pxr::TfToken::Immortal)
static const pxr::TfToken clearcoatRoughness("clearcoatRoughness", pxr::TfToken::Immortal)
static const pxr::TfToken opacityThreshold("opacityThreshold", pxr::TfToken::Immortal)
static const pxr::TfToken clamp("clamp", pxr::TfToken::Immortal)
static const pxr::TfToken g("g", pxr::TfToken::Immortal)
static const pxr::TfToken clearcoat("clearcoat", pxr::TfToken::Immortal)
static const pxr::TfToken metallic("metallic", pxr::TfToken::Immortal)
static const pxr::TfToken bias("bias", pxr::TfToken::Immortal)
static const pxr::TfToken b("b", pxr::TfToken::Immortal)
static const pxr::TfToken black("black", pxr::TfToken::Immortal)
static const pxr::TfToken diffuseColor("diffuseColor", pxr::TfToken::Immortal)
static const pxr::TfToken a("a", pxr::TfToken::Immortal)
static const pxr::TfToken file("file", pxr::TfToken::Immortal)
static const pxr::TfToken in("in", pxr::TfToken::Immortal)
static const pxr::TfToken scale("scale", pxr::TfToken::Immortal)
static const pxr::TfToken emissiveColor("emissiveColor", pxr::TfToken::Immortal)
static const pxr::TfToken occlusion("occlusion", pxr::TfToken::Immortal)
static const pxr::TfToken r("r", pxr::TfToken::Immortal)
static const pxr::TfToken UsdTransform2d("UsdTransform2d", pxr::TfToken::Immortal)
static const pxr::TfToken specularColor("specularColor", pxr::TfToken::Immortal)
static const pxr::TfToken ior("ior", pxr::TfToken::Immortal)
static const pxr::TfToken displacement("displacement", pxr::TfToken::Immortal)
static const pxr::TfToken st("st", pxr::TfToken::Immortal)
static const pxr::TfToken translation("translation", pxr::TfToken::Immortal)
static const pxr::TfToken normal("normal", pxr::TfToken::Immortal)
static const pxr::TfToken wrapT("wrapT", pxr::TfToken::Immortal)
static const pxr::TfToken repeat("repeat", pxr::TfToken::Immortal)
static const pxr::TfToken UsdPreviewSurface("UsdPreviewSurface", pxr::TfToken::Immortal)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static Vector< int > get_udim_tiles(const std::string &file_path)
char * STRNCPY(char(&dst)[N], const char *src)
MINLINE void copy_v3_v3(float r[3], const float a[3])
@ SHD_IMAGE_EXTENSION_EXTEND
@ SHD_IMAGE_EXTENSION_CLIP
@ SHD_IMAGE_EXTENSION_MIRROR
@ SHD_IMAGE_EXTENSION_REPEAT
static bNodeSocket * get_input_socket(bNode *node, const StringRefNull identifier, ReportList *reports)
static void add_udim_tiles(Image *image, const Vector< int > &indices)
MINLINE void copy_v2_v2(float r[2], const float a[2])
@ MA_SURFACE_METHOD_FORWARD
ImageTile * BKE_image_get_tile(Image *ima, int tile_number)
ImageTile * BKE_image_add_tile(Image *ima, int tile_number, const char *label)
static void link_nodes(bNodeTree *ntree, bNode *source, const StringRefNull sock_out, bNode *dest, const StringRefNull sock_in)
bool BKE_image_remove_tile(Image *ima, ImageTile *tile)
VecBase< float, 2 > float2
Image * BKE_image_load_exists(Main *bmain, const char *filepath, bool check_open=true, bool *r_exists=nullptr)
static pxr::SdfLayerHandle get_layer_handle(const pxr::UsdAttribute &attribute)
int BLI_delete(const char *path, bool dir, bool recursive) ATTR_NONNULL()
void BKE_image_packfiles(ReportList *reports, Image *ima, const char *basepath)
void BKE_ntree_update_after_single_tree_change(Main &bmain, bNodeTree &modified_tree, const NodeTreeUpdateExtraParams ¶ms={})
static bool get_usd_preview_surface(const pxr::UsdShadeMaterial &usd_material, pxr::UsdShadeShader &r_preview_surface)
static bool needs_blend(const pxr::UsdShadeShader &usd_shader)
bool BLI_is_dir(const char *path) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
static float get_opacity_threshold(const pxr::UsdShadeShader &usd_shader, float default_value=0.0f)
bool BKE_image_get_tile_info(char *filepath, ListBaseT< LinkData > *tiles, int *r_tile_start, int *r_tile_range)
static void set_viewport_material_props(Material *mtl, const pxr::UsdShadeShader &usd_preview)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
MINLINE void copy_v3_fl3(float v[3], float x, float y, float z)
static bNode * add_node(bNodeTree *ntree, const int type, const float2 loc)
@ NODE_VECTOR_MATH_MULTIPLY_ADD
static int get_image_extension(const pxr::UsdShadeShader &usd_shader, const int default_value)
Material * BKE_material_add(Main *bmain, const char *name)
bool BKE_image_has_packedfile(const Image *image)
static pxr::UsdShadeInput get_input(const pxr::UsdShadeShader &usd_shader, const pxr::TfToken &input_name)
ListBaseT< Material > materials
const float horizontal_step_
const float vertical_step_
float2 compute_node_loc(int column)
void cache_node(const pxr::UsdShadeShader &usd_shader, bNode *node, const StringRef tag={})
std::string get_key(const pxr::UsdShadeShader &usd_shader, const StringRef tag) const
Vector< float, 8 > column_offsets_
bNode * get_cached_node(const pxr::UsdShadeShader &usd_shader, const StringRef tag={}) const
ShaderToNodeMap node_cache_
MtlNameCollisionMode mtl_name_collision_mode