godot/scene/resources/visual_shader.cpp

/**************************************************************************/
/*  visual_shader.cpp                                                     */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* Permission is hereby granted, free of charge, to any person obtaining  */
/* a copy of this software and associated documentation files (the        */
/* "Software"), to deal in the Software without restriction, including    */
/* without limitation the rights to use, copy, modify, merge, publish,    */
/* distribute, sublicense, and/or sell copies of the Software, and to     */
/* permit persons to whom the Software is furnished to do so, subject to  */
/* the following conditions:                                              */
/*                                                                        */
/* The above copyright notice and this permission notice shall be         */
/* included in all copies or substantial portions of the Software.        */
/*                                                                        */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
/**************************************************************************/

#include "visual_shader.h"

#include "core/templates/rb_map.h"
#include "core/templates/vmap.h"
#include "core/variant/variant_utility.h"
#include "servers/rendering/shader_types.h"
#include "visual_shader_nodes.h"
#include "visual_shader_particle_nodes.h"
#include "visual_shader_sdf_nodes.h"

String make_unique_id(VisualShader::Type p_type, int p_id, const String &p_name) { … }

bool VisualShaderNode::is_simple_decl() const { … }

int VisualShaderNode::get_default_input_port(PortType p_type) const { … }

void VisualShaderNode::set_output_port_for_preview(int p_index) { … }

int VisualShaderNode::get_output_port_for_preview() const { … }

void VisualShaderNode::set_input_port_default_value(int p_port, const Variant &p_value, const Variant &p_prev_value) { … }

Variant VisualShaderNode::get_input_port_default_value(int p_port) const { … }

void VisualShaderNode::remove_input_port_default_value(int p_port) { … }

void VisualShaderNode::clear_default_input_values() { … }

bool VisualShaderNode::is_port_separator(int p_index) const { … }

bool VisualShaderNode::is_output_port_connected(int p_port) const { … }

void VisualShaderNode::set_output_port_connected(int p_port, bool p_connected) { … }

bool VisualShaderNode::is_input_port_connected(int p_port) const { … }

void VisualShaderNode::set_input_port_connected(int p_port, bool p_connected) { … }

bool VisualShaderNode::is_any_port_connected() const { … }

bool VisualShaderNode::is_generate_input_var(int p_port) const { … }

bool VisualShaderNode::is_output_port_expandable(int p_port) const { … }

bool VisualShaderNode::has_output_port_preview(int p_port) const { … }

void VisualShaderNode::_set_output_ports_expanded(const Array &p_values) { … }

Array VisualShaderNode::_get_output_ports_expanded() const { … }

void VisualShaderNode::_set_output_port_expanded(int p_port, bool p_expanded) { … }

bool VisualShaderNode::_is_output_port_expanded(int p_port) const { … }

int VisualShaderNode::get_expanded_output_port_count() const { … }

bool VisualShaderNode::is_code_generated() const { … }

bool VisualShaderNode::is_show_prop_names() const { … }

bool VisualShaderNode::is_use_prop_slots() const { … }

bool VisualShaderNode::is_disabled() const { … }

void VisualShaderNode::set_disabled(bool p_disabled) { … }

bool VisualShaderNode::is_deletable() const { … }

void VisualShaderNode::set_deletable(bool p_closable) { … }

void VisualShaderNode::set_frame(int p_node) { … }

int VisualShaderNode::get_frame() const { … }

Vector<VisualShader::DefaultTextureParam> VisualShaderNode::get_default_texture_parameters(VisualShader::Type p_type, int p_id) const { … }

String VisualShaderNode::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const { … }

String VisualShaderNode::generate_global_per_node(Shader::Mode p_mode, int p_id) const { … }

String VisualShaderNode::generate_global_per_func(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const { … }

Vector<StringName> VisualShaderNode::get_editable_properties() const { … }

HashMap<StringName, String> VisualShaderNode::get_editable_properties_names() const { … }

Array VisualShaderNode::get_default_input_values() const { … }

void VisualShaderNode::set_default_input_values(const Array &p_values) { … }

String VisualShaderNode::get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const { … }

VisualShaderNode::Category VisualShaderNode::get_category() const { … }

bool VisualShaderNode::is_input_port_default(int p_port, Shader::Mode p_mode) const { … }

void VisualShaderNode::_bind_methods() { … }

VisualShaderNode::VisualShaderNode() { … }

/////////////////////////////////////////////////////////

void VisualShaderNodeCustom::update_property_default_values() { … }

void VisualShaderNodeCustom::update_input_port_default_values() { … }

void VisualShaderNodeCustom::update_ports() { … }

void VisualShaderNodeCustom::update_properties() { … }

String VisualShaderNodeCustom::get_caption() const { … }

int VisualShaderNodeCustom::get_input_port_count() const { … }

VisualShaderNodeCustom::PortType VisualShaderNodeCustom::get_input_port_type(int p_port) const { … }

String VisualShaderNodeCustom::get_input_port_name(int p_port) const { … }

int VisualShaderNodeCustom::get_default_input_port(PortType p_type) const { … }

int VisualShaderNodeCustom::get_output_port_count() const { … }

VisualShaderNodeCustom::PortType VisualShaderNodeCustom::get_output_port_type(int p_port) const { … }

String VisualShaderNodeCustom::get_output_port_name(int p_port) const { … }

String VisualShaderNodeCustom::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const { … }

String VisualShaderNodeCustom::generate_global_per_node(Shader::Mode p_mode, int p_id) const { … }

String VisualShaderNodeCustom::generate_global_per_func(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const { … }

bool VisualShaderNodeCustom::is_available(Shader::Mode p_mode, VisualShader::Type p_type) const { … }

void VisualShaderNodeCustom::set_input_port_default_value(int p_port, const Variant &p_value, const Variant &p_prev_value) { … }

void VisualShaderNodeCustom::set_default_input_values(const Array &p_values) { … }

void VisualShaderNodeCustom::remove_input_port_default_value(int p_port) { … }

void VisualShaderNodeCustom::clear_default_input_values() { … }

void VisualShaderNodeCustom::_set_input_port_default_value(int p_port, const Variant &p_value) { … }

bool VisualShaderNodeCustom::_is_valid_code(const String &p_code) const { … }

bool VisualShaderNodeCustom::_is_initialized() { … }

void VisualShaderNodeCustom::_set_initialized(bool p_enabled) { … }

void VisualShaderNodeCustom::_set_properties(const String &p_properties) { … }

String VisualShaderNodeCustom::_get_properties() const { … }

String VisualShaderNodeCustom::_get_name() const { … }

String VisualShaderNodeCustom::_get_description() const { … }

String VisualShaderNodeCustom::_get_category() const { … }

VisualShaderNodeCustom::PortType VisualShaderNodeCustom::_get_return_icon_type() const { … }

bool VisualShaderNodeCustom::_is_highend() const { … }

void VisualShaderNodeCustom::_set_option_index(int p_option, int p_value) { … }

int VisualShaderNodeCustom::get_option_index(int p_option) const { … }

void VisualShaderNodeCustom::_bind_methods() { … }

VisualShaderNodeCustom::VisualShaderNodeCustom() { … }

/////////////////////////////////////////////////////////

void VisualShader::set_shader_type(Type p_type) { … }

VisualShader::Type VisualShader::get_shader_type() const { … }

void VisualShader::add_varying(const String &p_name, VaryingMode p_mode, VaryingType p_type) { … }

void VisualShader::remove_varying(const String &p_name) { … }

bool VisualShader::has_varying(const String &p_name) const { … }

int VisualShader::get_varyings_count() const { … }

const VisualShader::Varying *VisualShader::get_varying_by_index(int p_idx) const { … }

void VisualShader::set_varying_mode(const String &p_name, VaryingMode p_mode) { … }

VisualShader::VaryingMode VisualShader::get_varying_mode(const String &p_name) { … }

void VisualShader::set_varying_type(const String &p_name, VaryingType p_type) { … }

VisualShader::VaryingType VisualShader::get_varying_type(const String &p_name) { … }

void VisualShader::_set_preview_shader_parameter(const String &p_name, const Variant &p_value) { … }

Variant VisualShader::_get_preview_shader_parameter(const String &p_name) const { … }

bool VisualShader::_has_preview_shader_parameter(const String &p_name) const { … }

void VisualShader::add_node(Type p_type, const Ref<VisualShaderNode> &p_node, const Vector2 &p_position, int p_id) { … }

void VisualShader::set_node_position(Type p_type, int p_id, const Vector2 &p_position) { … }

Vector2 VisualShader::get_node_position(Type p_type, int p_id) const { … }

Ref<VisualShaderNode> VisualShader::get_node(Type p_type, int p_id) const { … }

Vector<int> VisualShader::get_node_list(Type p_type) const { … }

int VisualShader::get_valid_node_id(Type p_type) const { … }

int VisualShader::find_node_id(Type p_type, const Ref<VisualShaderNode> &p_node) const { … }

void VisualShader::remove_node(Type p_type, int p_id) { … }

void VisualShader::replace_node(Type p_type, int p_id, const StringName &p_new_class) { … }

bool VisualShader::is_node_connection(Type p_type, int p_from_node, int p_from_port, int p_to_node, int p_to_port) const { … }

bool VisualShader::is_nodes_connected_relatively(const Graph *p_graph, int p_node, int p_target) const { … }

bool VisualShader::_check_reroute_subgraph(Type p_type, int p_target_port_type, int p_reroute_node, List<int> *r_visited_reroute_nodes) const { … }

bool VisualShader::can_connect_nodes(Type p_type, int p_from_node, int p_from_port, int p_to_node, int p_to_port) const { … }

bool VisualShader::is_port_types_compatible(int p_a, int p_b) const { … }

void VisualShader::attach_node_to_frame(Type p_type, int p_node, int p_frame) { … }

void VisualShader::detach_node_from_frame(Type p_type, int p_node) { … }

String VisualShader::get_reroute_parameter_name(Type p_type, int p_reroute_node) const { … }

void VisualShader::connect_nodes_forced(Type p_type, int p_from_node, int p_from_port, int p_to_node, int p_to_port) { … }

Error VisualShader::connect_nodes(Type p_type, int p_from_node, int p_from_port, int p_to_node, int p_to_port) { … }

void VisualShader::disconnect_nodes(Type p_type, int p_from_node, int p_from_port, int p_to_node, int p_to_port) { … }

TypedArray<Dictionary> VisualShader::_get_node_connections(Type p_type) const { … }

void VisualShader::get_node_connections(Type p_type, List<Connection> *r_connections) const { … }

void VisualShader::set_mode(Mode p_mode) { … }

void VisualShader::set_graph_offset(const Vector2 &p_offset) { … }

Vector2 VisualShader::get_graph_offset() const { … }

Shader::Mode VisualShader::get_mode() const { … }

bool VisualShader::is_text_shader() const { … }

String VisualShader::generate_preview_shader(Type p_type, int p_node, int p_port, Vector<DefaultTextureParam> &default_tex_params) const { … }

String VisualShader::validate_port_name(const String &p_port_name, VisualShaderNode *p_node, int p_port_id, bool p_output) const { … }

String VisualShader::validate_parameter_name(const String &p_name, const Ref<VisualShaderNodeParameter> &p_parameter) const { … }

static const char *type_string[VisualShader::TYPE_MAX] = …;

bool VisualShader::_set(const StringName &p_name, const Variant &p_value) { … }

bool VisualShader::_get(const StringName &p_name, Variant &r_ret) const { … }

void VisualShader::reset_state() { … }

void VisualShader::_get_property_list(List<PropertyInfo> *p_list) const { … }

Error VisualShader::_write_node(Type type, StringBuilder *p_global_code, StringBuilder *p_global_code_per_node, HashMap<Type, StringBuilder> *p_global_code_per_func, StringBuilder &r_code, Vector<VisualShader::DefaultTextureParam> &r_def_tex_params, const VMap<ConnectionKey, const List<Connection>::Element *> &p_input_connections, const VMap<ConnectionKey, const List<Connection>::Element *> &p_output_connections, int p_node, HashSet<int> &r_processed, bool p_for_preview, HashSet<StringName> &r_classes) const { … }

bool VisualShader::has_func_name(RenderingServer::ShaderMode p_mode, const String &p_func_name) const { … }

void VisualShader::_update_shader() const { … }

void VisualShader::_queue_update() { … }

void VisualShader::rebuild() { … }

void VisualShader::_bind_methods() { … }

VisualShader::VisualShader() { … }

///////////////////////////////////////////////////////////

const VisualShaderNodeInput::Port VisualShaderNodeInput::ports[] = …;

const VisualShaderNodeInput::Port VisualShaderNodeInput::preview_ports[] = …;

int VisualShaderNodeInput::get_input_port_count() const { … }

VisualShaderNodeInput::PortType VisualShaderNodeInput::get_input_port_type(int p_port) const { … }

String VisualShaderNodeInput::get_input_port_name(int p_port) const { … }

int VisualShaderNodeInput::get_output_port_count() const { … }

VisualShaderNodeInput::PortType VisualShaderNodeInput::get_output_port_type(int p_port) const { … }

String VisualShaderNodeInput::get_output_port_name(int p_port) const { … }

String VisualShaderNodeInput::get_caption() const { … }

bool VisualShaderNodeInput::is_output_port_expandable(int p_port) const { … }

String VisualShaderNodeInput::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const { … }

void VisualShaderNodeInput::set_input_name(String p_name) { … }

String VisualShaderNodeInput::get_input_name() const { … }

String VisualShaderNodeInput::get_input_real_name() const { … }

VisualShaderNodeInput::PortType VisualShaderNodeInput::get_input_type_by_name(String p_name) const { … }

int VisualShaderNodeInput::get_input_index_count() const { … }

VisualShaderNodeInput::PortType VisualShaderNodeInput::get_input_index_type(int p_index) const { … }

String VisualShaderNodeInput::get_input_index_name(int p_index) const { … }

void VisualShaderNodeInput::_validate_property(PropertyInfo &p_property) const { … }

Vector<StringName> VisualShaderNodeInput::get_editable_properties() const { … }

void VisualShaderNodeInput::set_shader_type(VisualShader::Type p_shader_type) { … }

void VisualShaderNodeInput::set_shader_mode(Shader::Mode p_shader_mode) { … }

void VisualShaderNodeInput::_bind_methods() { … }

VisualShaderNodeInput::VisualShaderNodeInput() { … }

////////////// ParameterRef

RBMap<RID, List<VisualShaderNodeParameterRef::Parameter>> parameters;

void VisualShaderNodeParameterRef::add_parameter(RID p_shader_rid, const String &p_name, ParameterType p_type) { … }

void VisualShaderNodeParameterRef::clear_parameters(RID p_shader_rid) { … }

bool VisualShaderNodeParameterRef::has_parameter(RID p_shader_rid, const String &p_name) { … }

String VisualShaderNodeParameterRef::get_caption() const { … }

int VisualShaderNodeParameterRef::get_input_port_count() const { … }

VisualShaderNodeParameterRef::PortType VisualShaderNodeParameterRef::get_input_port_type(int p_port) const { … }

String VisualShaderNodeParameterRef::get_input_port_name(int p_port) const { … }

int VisualShaderNodeParameterRef::get_output_port_count() const { … }

VisualShaderNodeParameterRef::PortType VisualShaderNodeParameterRef::get_output_port_type(int p_port) const { … }

String VisualShaderNodeParameterRef::get_output_port_name(int p_port) const { … }

bool VisualShaderNodeParameterRef::is_shader_valid() const { … }

void VisualShaderNodeParameterRef::set_shader_rid(const RID &p_shader_rid) { … }

void VisualShaderNodeParameterRef::set_parameter_name(const String &p_name) { … }

void VisualShaderNodeParameterRef::update_parameter_type() { … }

String VisualShaderNodeParameterRef::get_parameter_name() const { … }

int VisualShaderNodeParameterRef::get_parameters_count() const { … }

String VisualShaderNodeParameterRef::get_parameter_name_by_index(int p_idx) const { … }

VisualShaderNodeParameterRef::ParameterType VisualShaderNodeParameterRef::get_parameter_type_by_name(const String &p_name) const { … }

VisualShaderNodeParameterRef::ParameterType VisualShaderNodeParameterRef::get_parameter_type_by_index(int p_idx) const { … }

VisualShaderNodeParameterRef::PortType VisualShaderNodeParameterRef::get_port_type_by_index(int p_idx) const { … }

String VisualShaderNodeParameterRef::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const { … }

void VisualShaderNodeParameterRef::_set_parameter_type(int p_type) { … }

int VisualShaderNodeParameterRef::_get_parameter_type() const { … }

void VisualShaderNodeParameterRef::_bind_methods() { … }

Vector<StringName> VisualShaderNodeParameterRef::get_editable_properties() const { … }

VisualShaderNodeParameterRef::VisualShaderNodeParameterRef() { … }

////////////////////////////////////////////

const VisualShaderNodeOutput::Port VisualShaderNodeOutput::ports[] = …;

int VisualShaderNodeOutput::get_input_port_count() const { … }

VisualShaderNodeOutput::PortType VisualShaderNodeOutput::get_input_port_type(int p_port) const { … }

String VisualShaderNodeOutput::get_input_port_name(int p_port) const { … }

Variant VisualShaderNodeOutput::get_input_port_default_value(int p_port) const { … }

int VisualShaderNodeOutput::get_output_port_count() const { … }

VisualShaderNodeOutput::PortType VisualShaderNodeOutput::get_output_port_type(int p_port) const { … }

String VisualShaderNodeOutput::get_output_port_name(int p_port) const { … }

bool VisualShaderNodeOutput::is_port_separator(int p_index) const { … }

String VisualShaderNodeOutput::get_caption() const { … }

String VisualShaderNodeOutput::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const { … }

VisualShaderNodeOutput::VisualShaderNodeOutput() { … }

///////////////////////////

void VisualShaderNodeParameter::set_parameter_name(const String &p_name) { … }

String VisualShaderNodeParameter::get_parameter_name() const { … }

void VisualShaderNodeParameter::set_qualifier(VisualShaderNodeParameter::Qualifier p_qual) { … }

VisualShaderNodeParameter::Qualifier VisualShaderNodeParameter::get_qualifier() const { … }

void VisualShaderNodeParameter::set_global_code_generated(bool p_enabled) { … }

bool VisualShaderNodeParameter::is_global_code_generated() const { … }

#ifndef DISABLE_DEPRECATED
// Kept for compatibility from 3.x to 4.0.
bool VisualShaderNodeParameter::_set(const StringName &p_name, const Variant &p_value) { … }
#endif

void VisualShaderNodeParameter::_bind_methods() { … }

String VisualShaderNodeParameter::_get_qual_str() const { … }

String VisualShaderNodeParameter::get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const { … }

Vector<StringName> VisualShaderNodeParameter::get_editable_properties() const { … }

VisualShaderNodeParameter::VisualShaderNodeParameter() { … }

////////////// ResizeableBase

void VisualShaderNodeResizableBase::set_size(const Size2 &p_size) { … }

Size2 VisualShaderNodeResizableBase::get_size() const { … }

void VisualShaderNodeResizableBase::set_allow_v_resize(bool p_enabled) { … }

bool VisualShaderNodeResizableBase::is_allow_v_resize() const { … }

void VisualShaderNodeResizableBase::_bind_methods() { … }

VisualShaderNodeResizableBase::VisualShaderNodeResizableBase() { … }

////////////// Frame

String VisualShaderNodeFrame::get_caption() const { … }

int VisualShaderNodeFrame::get_input_port_count() const { … }

VisualShaderNodeFrame::PortType VisualShaderNodeFrame::get_input_port_type(int p_port) const { … }

String VisualShaderNodeFrame::get_input_port_name(int p_port) const { … }

int VisualShaderNodeFrame::get_output_port_count() const { … }

VisualShaderNodeFrame::PortType VisualShaderNodeFrame::get_output_port_type(int p_port) const { … }

String VisualShaderNodeFrame::get_output_port_name(int p_port) const { … }

void VisualShaderNodeFrame::set_title(const String &p_title) { … }

String VisualShaderNodeFrame::get_title() const { … }

void VisualShaderNodeFrame::set_tint_color_enabled(bool p_enabled) { … }

bool VisualShaderNodeFrame::is_tint_color_enabled() const { … }

void VisualShaderNodeFrame::set_tint_color(const Color &p_color) { … }

Color VisualShaderNodeFrame::get_tint_color() const { … }

void VisualShaderNodeFrame::set_autoshrink_enabled(bool p_enable) { … }

bool VisualShaderNodeFrame::is_autoshrink_enabled() const { … }

String VisualShaderNodeFrame::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const { … }

void VisualShaderNodeFrame::add_attached_node(int p_node) { … }

void VisualShaderNodeFrame::remove_attached_node(int p_node) { … }

void VisualShaderNodeFrame::set_attached_nodes(const PackedInt32Array &p_attached_nodes) { … }

PackedInt32Array VisualShaderNodeFrame::get_attached_nodes() const { … }

void VisualShaderNodeFrame::_bind_methods() { … }

VisualShaderNodeFrame::VisualShaderNodeFrame() { … }

////////////// Comment (Deprecated)

#ifndef DISABLE_DEPRECATED
void VisualShaderNodeComment::_bind_methods() { … }

void VisualShaderNodeComment::set_description(const String &p_description) { … }

String VisualShaderNodeComment::get_description() const { … }
#endif

////////////// GroupBase

void VisualShaderNodeGroupBase::set_inputs(const String &p_inputs) { … }

String VisualShaderNodeGroupBase::get_inputs() const { … }

void VisualShaderNodeGroupBase::set_outputs(const String &p_outputs) { … }

String VisualShaderNodeGroupBase::get_outputs() const { … }

bool VisualShaderNodeGroupBase::is_valid_port_name(const String &p_name) const { … }

void VisualShaderNodeGroupBase::add_input_port(int p_id, int p_type, const String &p_name) { … }

void VisualShaderNodeGroupBase::remove_input_port(int p_id) { … }

int VisualShaderNodeGroupBase::get_input_port_count() const { … }

bool VisualShaderNodeGroupBase::has_input_port(int p_id) const { … }

void VisualShaderNodeGroupBase::add_output_port(int p_id, int p_type, const String &p_name) { … }

void VisualShaderNodeGroupBase::remove_output_port(int p_id) { … }

int VisualShaderNodeGroupBase::get_output_port_count() const { … }

bool VisualShaderNodeGroupBase::has_output_port(int p_id) const { … }

void VisualShaderNodeGroupBase::clear_input_ports() { … }

void VisualShaderNodeGroupBase::clear_output_ports() { … }

void VisualShaderNodeGroupBase::set_input_port_type(int p_id, int p_type) { … }

VisualShaderNodeGroupBase::PortType VisualShaderNodeGroupBase::get_input_port_type(int p_id) const { … }

void VisualShaderNodeGroupBase::set_input_port_name(int p_id, const String &p_name) { … }

String VisualShaderNodeGroupBase::get_input_port_name(int p_id) const { … }

void VisualShaderNodeGroupBase::set_output_port_type(int p_id, int p_type) { … }

VisualShaderNodeGroupBase::PortType VisualShaderNodeGroupBase::get_output_port_type(int p_id) const { … }

void VisualShaderNodeGroupBase::set_output_port_name(int p_id, const String &p_name) { … }

String VisualShaderNodeGroupBase::get_output_port_name(int p_id) const { … }

int VisualShaderNodeGroupBase::get_free_input_port_id() const { … }

int VisualShaderNodeGroupBase::get_free_output_port_id() const { … }

void VisualShaderNodeGroupBase::set_ctrl_pressed(Control *p_control, int p_index) { … }

Control *VisualShaderNodeGroupBase::is_ctrl_pressed(int p_index) { … }

void VisualShaderNodeGroupBase::_apply_port_changes() { … }

void VisualShaderNodeGroupBase::set_editable(bool p_enabled) { … }

bool VisualShaderNodeGroupBase::is_editable() const { … }

void VisualShaderNodeGroupBase::_bind_methods() { … }

String VisualShaderNodeGroupBase::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const { … }

VisualShaderNodeGroupBase::VisualShaderNodeGroupBase() { … }

////////////// Expression

String VisualShaderNodeExpression::get_caption() const { … }

void VisualShaderNodeExpression::set_expression(const String &p_expression) { … }

String VisualShaderNodeExpression::get_expression() const { … }

bool VisualShaderNodeExpression::_is_valid_identifier_char(char32_t p_c) const { … }

String VisualShaderNodeExpression::_replace_port_names(const Vector<Pair<String, String>> &p_pairs, const String &p_expression) const { … }

String VisualShaderNodeExpression::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const { … }

bool VisualShaderNodeExpression::is_output_port_expandable(int p_port) const { … }

void VisualShaderNodeExpression::_bind_methods() { … }

VisualShaderNodeExpression::VisualShaderNodeExpression() { … }

////////////// Global Expression

String VisualShaderNodeGlobalExpression::get_caption() const { … }

String VisualShaderNodeGlobalExpression::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const { … }

VisualShaderNodeGlobalExpression::VisualShaderNodeGlobalExpression() { … }

////////////// Varying

RBMap<RID, List<VisualShaderNodeVarying::Varying>> varyings;

void VisualShaderNodeVarying::add_varying(RID p_shader_rid, const String &p_name, VisualShader::VaryingMode p_mode, VisualShader::VaryingType p_type) { … }

void VisualShaderNodeVarying::clear_varyings(RID p_shader_rid) { … }

bool VisualShaderNodeVarying::has_varying(RID p_shader_rid, const String &p_name) { … }

void VisualShaderNodeVarying::set_shader_rid(const RID &p_shader_rid) { … }

int VisualShaderNodeVarying::get_varyings_count() const { … }

String VisualShaderNodeVarying::get_varying_name_by_index(int p_idx) const { … }

VisualShader::VaryingType VisualShaderNodeVarying::get_varying_type_by_name(const String &p_name) const { … }

VisualShader::VaryingType VisualShaderNodeVarying::get_varying_type_by_index(int p_idx) const { … }

VisualShader::VaryingMode VisualShaderNodeVarying::get_varying_mode_by_name(const String &p_name) const { … }

VisualShader::VaryingMode VisualShaderNodeVarying::get_varying_mode_by_index(int p_idx) const { … }

VisualShaderNodeVarying::PortType VisualShaderNodeVarying::get_port_type_by_index(int p_idx) const { … }

//////////////

void VisualShaderNodeVarying::_bind_methods() { … }

String VisualShaderNodeVarying::get_type_str() const { … }

VisualShaderNodeVarying::PortType VisualShaderNodeVarying::get_port_type(VisualShader::VaryingType p_type, int p_port) const { … }

void VisualShaderNodeVarying::set_varying_name(String p_varying_name) { … }

String VisualShaderNodeVarying::get_varying_name() const { … }

void VisualShaderNodeVarying::set_varying_type(VisualShader::VaryingType p_varying_type) { … }

VisualShader::VaryingType VisualShaderNodeVarying::get_varying_type() const { … }

VisualShaderNodeVarying::VisualShaderNodeVarying() { … }

////////////// Varying Setter

String VisualShaderNodeVaryingSetter::get_caption() const { … }

int VisualShaderNodeVaryingSetter::get_input_port_count() const { … }

VisualShaderNodeVaryingSetter::PortType VisualShaderNodeVaryingSetter::get_input_port_type(int p_port) const { … }

String VisualShaderNodeVaryingSetter::get_input_port_name(int p_port) const { … }

int VisualShaderNodeVaryingSetter::get_output_port_count() const { … }

VisualShaderNodeVaryingSetter::PortType VisualShaderNodeVaryingSetter::get_output_port_type(int p_port) const { … }

String VisualShaderNodeVaryingSetter::get_output_port_name(int p_port) const { … }

String VisualShaderNodeVaryingSetter::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const { … }

VisualShaderNodeVaryingSetter::VisualShaderNodeVaryingSetter() { … }

////////////// Varying Getter

String VisualShaderNodeVaryingGetter::get_caption() const { … }

int VisualShaderNodeVaryingGetter::get_input_port_count() const { … }

VisualShaderNodeVaryingGetter::PortType VisualShaderNodeVaryingGetter::get_input_port_type(int p_port) const { … }

String VisualShaderNodeVaryingGetter::get_input_port_name(int p_port) const { … }

int VisualShaderNodeVaryingGetter::get_output_port_count() const { … }

VisualShaderNodeVaryingGetter::PortType VisualShaderNodeVaryingGetter::get_output_port_type(int p_port) const { … }

String VisualShaderNodeVaryingGetter::get_output_port_name(int p_port) const { … }

bool VisualShaderNodeVaryingGetter::has_output_port_preview(int p_port) const { … }

String VisualShaderNodeVaryingGetter::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const { … }

VisualShaderNodeVaryingGetter::VisualShaderNodeVaryingGetter() { … }