usd_reader_material.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2021 NVIDIA Corporation. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once
 
#include "usd.hh"
 
#include "WM_types.hh"
 
#include "BLI_map.hh"
#include "BLI_vector.hh"
 
#include <pxr/usd/usdShade/material.h>
 
#include <string>
 
struct Main;
struct Material;
struct bNode;
struct bNodeTree;
 
namespace blender::io::usd {
 
using ShaderToNodeMap = blender::Map<std::string, bNode *>;
 
/* Helper struct used when arranging nodes in columns, keeping track the
 * occupancy information for a given column.  I.e., for column n,
 * column_offsets[n] is the y-offset (from top to bottom) of the occupied
 * region in that column. */
struct NodePlacementContext {
  float origx;
  float origy;
  blender::Vector<float, 0> column_offsets;
  const float horizontal_step;
  const float vertical_step;
 
  /* Map a USD shader prim path to the Blender node converted
   * from that shader.  This map is updated during shader
   * conversion and is used to avoid creating duplicate nodes
   * for a given shader. */
  ShaderToNodeMap node_cache;
 
  NodePlacementContext(float in_origx,
                       float in_origy,
                       float in_horizontal_step = 300.0f,
                       float in_vertical_step = 300.0f)
      : origx(in_origx),
        origy(in_origy),
        column_offsets(64, 0.0f),
        horizontal_step(in_horizontal_step),
        vertical_step(in_vertical_step)
  {
  }
};
 
/* Helper struct which carries an assortment of optional
 * information that is sometimes required when linking
 * nodes together. */
struct ExtraLinkInfo {
  bool is_color_corrected = false;
 
  float opacity_threshold = 0.0f;
};
 
/* Converts USD materials to Blender representation. */
 
class USDMaterialReader {
 protected:
  USDImportParams params_;
 
  Main *bmain_;
 
 public:
  USDMaterialReader(const USDImportParams &params, Main *bmain);
 
  Material *add_material(const pxr::UsdShadeMaterial &usd_material) const;
 
  ReportList *reports() const
  {
    return params_.worker_status ? params_.worker_status->reports : nullptr;
  }
 
 protected:
  void import_usd_preview(Material *mtl, const pxr::UsdShadeShader &usd_shader) const;
 
  void set_principled_node_inputs(bNode *principled_node,
                                  bNodeTree *ntree,
                                  const pxr::UsdShadeShader &usd_shader) const;
 
  bool set_node_input(const pxr::UsdShadeInput &usd_input,
                      bNode *dest_node,
                      const char *dest_socket_name,
                      bNodeTree *ntree,
                      int column,
                      NodePlacementContext *r_ctx,
                      const ExtraLinkInfo &extra = {}) const;
 
  bool follow_connection(const pxr::UsdShadeInput &usd_input,
                         bNode *dest_node,
                         const char *dest_socket_name,
                         bNodeTree *ntree,
                         int column,
                         NodePlacementContext *r_ctx,
                         const ExtraLinkInfo &extra = {}) const;
 
  void convert_usd_uv_texture(const pxr::UsdShadeShader &usd_shader,
                              const pxr::TfToken &usd_source_name,
                              bNode *dest_node,
                              const char *dest_socket_name,
                              bNodeTree *ntree,
                              int column,
                              NodePlacementContext *r_ctx,
                              const ExtraLinkInfo &extra = {}) const;
 
  void convert_usd_transform_2d(const pxr::UsdShadeShader &usd_shader,
                                bNode *dest_node,
                                const char *dest_socket_name,
                                bNodeTree *ntree,
                                int column,
                                NodePlacementContext *r_ctx) const;
 
  void load_tex_image(const pxr::UsdShadeShader &usd_shader,
                      bNode *tex_image,
                      const ExtraLinkInfo &extra = {}) const;
 
  void convert_usd_primvar_reader_float2(const pxr::UsdShadeShader &usd_shader,
                                         const pxr::TfToken &usd_source_name,
                                         bNode *dest_node,
                                         const char *dest_socket_name,
                                         bNodeTree *ntree,
                                         int column,
                                         NodePlacementContext *r_ctx) const;
};
 
/* Utility functions. */
 
void build_material_map(const Main *bmain, blender::Map<std::string, Material *> *r_mat_map);
 
Material *find_existing_material(
    const pxr::SdfPath &usd_mat_path,
    const USDImportParams &params,
    const blender::Map<std::string, Material *> &mat_map,
    const blender::Map<std::string, std::string> &usd_path_to_mat_name);
 
}  // namespace blender::io::usd