node_parser.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2011-2022 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "material.h"
#include "node_graph.h"
#include "node_item.h"
 
#include "DNA_node_types.h"
 
#include "CLG_log.h"
 
namespace blender::nodes::materialx {
 
extern struct CLG_LogRef *LOG_MATERIALX_SHADER;
 
class GroupNodeParser;

class NodeParser {
 protected:
  NodeGraph &graph_;
  const bNode *node_;
  const bNodeSocket *socket_out_;
  NodeItem::Type to_type_;
  GroupNodeParser *group_parser_;
 
 public:
  NodeParser(NodeGraph &graph,
             const bNode *node,
             const bNodeSocket *socket_out,
             NodeItem::Type to_type,
             GroupNodeParser *group_parser);
  virtual ~NodeParser() = default;
 
  virtual NodeItem compute() = 0;
  virtual NodeItem compute_full();
 
 protected:
  std::string node_name(const char *override_output_name = nullptr) const;
  NodeItem create_node(const std::string &category, NodeItem::Type type);
  NodeItem create_node(const std::string &category,
                       NodeItem::Type type,
                       const NodeItem::Inputs &inputs);
  NodeItem create_input(const std::string &name, const NodeItem &item);
  NodeItem create_output(const std::string &name, const NodeItem &item);
  NodeItem get_input_default(const std::string &name, NodeItem::Type to_type);
  NodeItem get_input_default(int index, NodeItem::Type to_type);
  NodeItem get_output_default(const std::string &name, NodeItem::Type to_type);
  NodeItem get_output_default(int index, NodeItem::Type to_type);
  NodeItem get_input_link(const std::string &name, NodeItem::Type to_type);
  NodeItem get_input_link(int index, NodeItem::Type to_type);
  NodeItem get_input_value(const std::string &name, NodeItem::Type to_type);
  NodeItem get_input_value(int index, NodeItem::Type to_type);
  NodeItem empty() const;
  template<class T> NodeItem val(const T &data) const;
  NodeItem texcoord_node(NodeItem::Type type = NodeItem::Type::Vector2,
                         const std::string &attribute_name = "");
 
 private:
  NodeItem get_default(const bNodeSocket &socket, NodeItem::Type to_type);
  NodeItem get_input_link(const bNodeSocket &socket,
                          NodeItem::Type to_type,
                          bool use_group_default);
  NodeItem get_input_value(const bNodeSocket &socket, NodeItem::Type to_type);
};
 
template<class T> NodeItem NodeParser::val(const T &data) const
{
  return empty().val(data);
}

struct NodeParserData {
  NodeGraph &graph;
  NodeItem::Type to_type;
  GroupNodeParser *group_parser;
  NodeItem result;
  ExportParams export_params;
};
 
#define NODE_SHADER_MATERIALX_BEGIN \
  class MaterialXNodeParser : public materialx::NodeParser { \
   public: \
    using materialx::NodeParser::NodeParser; \
    materialx::NodeItem compute() override; \
  }; \
\
  materialx::NodeItem MaterialXNodeParser::compute() \
  { \
    using NodeItem = materialx::NodeItem;
 
#define NODE_SHADER_MATERIALX_END \
  } \
\
  static void node_shader_materialx(void *data, struct bNode *node, struct bNodeSocket *out) \
  { \
    materialx::NodeParserData *d = reinterpret_cast<materialx::NodeParserData *>(data); \
    d->result = \
        MaterialXNodeParser(d->graph, node, out, d->to_type, d->group_parser).compute_full(); \
  }
 
}  // namespace blender::nodes::materialx