godot/scene/resources/visual_shader_nodes.cpp

/**************************************************************************/
/*  visual_shader_nodes.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_nodes.h"
#include "visual_shader_nodes.compat.inc"

#include "scene/resources/image_texture.h"

////////////// Vector Base

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

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

void VisualShaderNodeVectorBase::set_op_type(OpType p_op_type) { … }

VisualShaderNodeVectorBase::OpType VisualShaderNodeVectorBase::get_op_type() const { … }

void VisualShaderNodeVectorBase::_bind_methods() { … }

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

VisualShaderNodeVectorBase::VisualShaderNodeVectorBase() { … }

////////////// Constants Base

VisualShaderNodeConstant::VisualShaderNodeConstant() { … }

////////////// Scalar(Float)

String VisualShaderNodeFloatConstant::get_caption() const { … }

int VisualShaderNodeFloatConstant::get_input_port_count() const { … }

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

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

int VisualShaderNodeFloatConstant::get_output_port_count() const { … }

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

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

String VisualShaderNodeFloatConstant::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 VisualShaderNodeFloatConstant::set_constant(float p_constant) { … }

float VisualShaderNodeFloatConstant::get_constant() const { … }

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

void VisualShaderNodeFloatConstant::_bind_methods() { … }

VisualShaderNodeFloatConstant::VisualShaderNodeFloatConstant() { … }

////////////// Scalar(Int)

String VisualShaderNodeIntConstant::get_caption() const { … }

int VisualShaderNodeIntConstant::get_input_port_count() const { … }

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

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

int VisualShaderNodeIntConstant::get_output_port_count() const { … }

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

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

String VisualShaderNodeIntConstant::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 VisualShaderNodeIntConstant::set_constant(int p_constant) { … }

int VisualShaderNodeIntConstant::get_constant() const { … }

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

void VisualShaderNodeIntConstant::_bind_methods() { … }

VisualShaderNodeIntConstant::VisualShaderNodeIntConstant() { … }

////////////// Scalar(UInt)

String VisualShaderNodeUIntConstant::get_caption() const { … }

int VisualShaderNodeUIntConstant::get_input_port_count() const { … }

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

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

int VisualShaderNodeUIntConstant::get_output_port_count() const { … }

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

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

String VisualShaderNodeUIntConstant::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 VisualShaderNodeUIntConstant::set_constant(int p_constant) { … }

int VisualShaderNodeUIntConstant::get_constant() const { … }

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

void VisualShaderNodeUIntConstant::_bind_methods() { … }

VisualShaderNodeUIntConstant::VisualShaderNodeUIntConstant() { … }

////////////// Boolean

String VisualShaderNodeBooleanConstant::get_caption() const { … }

int VisualShaderNodeBooleanConstant::get_input_port_count() const { … }

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

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

int VisualShaderNodeBooleanConstant::get_output_port_count() const { … }

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

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

String VisualShaderNodeBooleanConstant::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 VisualShaderNodeBooleanConstant::set_constant(bool p_constant) { … }

bool VisualShaderNodeBooleanConstant::get_constant() const { … }

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

void VisualShaderNodeBooleanConstant::_bind_methods() { … }

VisualShaderNodeBooleanConstant::VisualShaderNodeBooleanConstant() { … }

////////////// Color

String VisualShaderNodeColorConstant::get_caption() const { … }

int VisualShaderNodeColorConstant::get_input_port_count() const { … }

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

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

int VisualShaderNodeColorConstant::get_output_port_count() const { … }

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

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

String VisualShaderNodeColorConstant::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 VisualShaderNodeColorConstant::set_constant(const Color &p_constant) { … }

Color VisualShaderNodeColorConstant::get_constant() const { … }

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

void VisualShaderNodeColorConstant::_bind_methods() { … }

VisualShaderNodeColorConstant::VisualShaderNodeColorConstant() { … }

////////////// Vector2

String VisualShaderNodeVec2Constant::get_caption() const { … }

int VisualShaderNodeVec2Constant::get_input_port_count() const { … }

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

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

int VisualShaderNodeVec2Constant::get_output_port_count() const { … }

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

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

String VisualShaderNodeVec2Constant::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 VisualShaderNodeVec2Constant::set_constant(const Vector2 &p_constant) { … }

Vector2 VisualShaderNodeVec2Constant::get_constant() const { … }

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

void VisualShaderNodeVec2Constant::_bind_methods() { … }

VisualShaderNodeVec2Constant::VisualShaderNodeVec2Constant() { … }

////////////// Vector3

String VisualShaderNodeVec3Constant::get_caption() const { … }

int VisualShaderNodeVec3Constant::get_input_port_count() const { … }

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

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

int VisualShaderNodeVec3Constant::get_output_port_count() const { … }

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

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

String VisualShaderNodeVec3Constant::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 VisualShaderNodeVec3Constant::set_constant(const Vector3 &p_constant) { … }

Vector3 VisualShaderNodeVec3Constant::get_constant() const { … }

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

void VisualShaderNodeVec3Constant::_bind_methods() { … }

VisualShaderNodeVec3Constant::VisualShaderNodeVec3Constant() { … }

////////////// Vector4

String VisualShaderNodeVec4Constant::get_caption() const { … }

int VisualShaderNodeVec4Constant::get_input_port_count() const { … }

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

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

int VisualShaderNodeVec4Constant::get_output_port_count() const { … }

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

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

String VisualShaderNodeVec4Constant::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 VisualShaderNodeVec4Constant::set_constant(const Quaternion &p_constant) { … }

Quaternion VisualShaderNodeVec4Constant::get_constant() const { … }

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

void VisualShaderNodeVec4Constant::_bind_methods() { … }

VisualShaderNodeVec4Constant::VisualShaderNodeVec4Constant() { … }

////////////// Transform3D

String VisualShaderNodeTransformConstant::get_caption() const { … }

int VisualShaderNodeTransformConstant::get_input_port_count() const { … }

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

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

int VisualShaderNodeTransformConstant::get_output_port_count() const { … }

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

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

String VisualShaderNodeTransformConstant::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 VisualShaderNodeTransformConstant::set_constant(const Transform3D &p_constant) { … }

Transform3D VisualShaderNodeTransformConstant::get_constant() const { … }

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

void VisualShaderNodeTransformConstant::_bind_methods() { … }

VisualShaderNodeTransformConstant::VisualShaderNodeTransformConstant() { … }

////////////// Texture

String VisualShaderNodeTexture::get_caption() const { … }

int VisualShaderNodeTexture::get_input_port_count() const { … }

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

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

int VisualShaderNodeTexture::get_output_port_count() const { … }

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

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

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

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

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

String VisualShaderNodeTexture::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 VisualShaderNodeTexture::set_source(Source p_source) { … }

VisualShaderNodeTexture::Source VisualShaderNodeTexture::get_source() const { … }

void VisualShaderNodeTexture::set_texture(Ref<Texture2D> p_texture) { … }

Ref<Texture2D> VisualShaderNodeTexture::get_texture() const { … }

void VisualShaderNodeTexture::set_texture_type(TextureType p_texture_type) { … }

VisualShaderNodeTexture::TextureType VisualShaderNodeTexture::get_texture_type() const { … }

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

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

void VisualShaderNodeTexture::_bind_methods() { … }

VisualShaderNodeTexture::VisualShaderNodeTexture() { … }

////////////// CurveTexture

String VisualShaderNodeCurveTexture::get_caption() const { … }

int VisualShaderNodeCurveTexture::get_input_port_count() const { … }

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

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

int VisualShaderNodeCurveTexture::get_output_port_count() const { … }

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

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

void VisualShaderNodeCurveTexture::set_texture(Ref<CurveTexture> p_texture) { … }

Ref<CurveTexture> VisualShaderNodeCurveTexture::get_texture() const { … }

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

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

String VisualShaderNodeCurveTexture::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 { … }

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

void VisualShaderNodeCurveTexture::_bind_methods() { … }

bool VisualShaderNodeCurveTexture::is_use_prop_slots() const { … }

VisualShaderNodeCurveTexture::VisualShaderNodeCurveTexture() { … }

////////////// CurveXYZTexture

String VisualShaderNodeCurveXYZTexture::get_caption() const { … }

int VisualShaderNodeCurveXYZTexture::get_input_port_count() const { … }

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

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

int VisualShaderNodeCurveXYZTexture::get_output_port_count() const { … }

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

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

void VisualShaderNodeCurveXYZTexture::set_texture(Ref<CurveXYZTexture> p_texture) { … }

Ref<CurveXYZTexture> VisualShaderNodeCurveXYZTexture::get_texture() const { … }

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

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

String VisualShaderNodeCurveXYZTexture::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 { … }

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

void VisualShaderNodeCurveXYZTexture::_bind_methods() { … }

bool VisualShaderNodeCurveXYZTexture::is_use_prop_slots() const { … }

VisualShaderNodeCurveXYZTexture::VisualShaderNodeCurveXYZTexture() { … }

////////////// Sample3D

int VisualShaderNodeSample3D::get_input_port_count() const { … }

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

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

int VisualShaderNodeSample3D::get_output_port_count() const { … }

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

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

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

String VisualShaderNodeSample3D::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 VisualShaderNodeSample3D::set_source(Source p_source) { … }

VisualShaderNodeSample3D::Source VisualShaderNodeSample3D::get_source() const { … }

void VisualShaderNodeSample3D::_bind_methods() { … }

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

VisualShaderNodeSample3D::VisualShaderNodeSample3D() { … }

////////////// Texture2DArray

String VisualShaderNodeTexture2DArray::get_caption() const { … }

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

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

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

void VisualShaderNodeTexture2DArray::set_texture_array(Ref<TextureLayered> p_texture_array) { … }

Ref<TextureLayered> VisualShaderNodeTexture2DArray::get_texture_array() const { … }

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

void VisualShaderNodeTexture2DArray::_bind_methods() { … }

VisualShaderNodeTexture2DArray::VisualShaderNodeTexture2DArray() { … }

////////////// Texture3D

String VisualShaderNodeTexture3D::get_caption() const { … }

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

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

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

void VisualShaderNodeTexture3D::set_texture(Ref<Texture3D> p_texture) { … }

Ref<Texture3D> VisualShaderNodeTexture3D::get_texture() const { … }

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

void VisualShaderNodeTexture3D::_bind_methods() { … }

VisualShaderNodeTexture3D::VisualShaderNodeTexture3D() { … }

////////////// Cubemap

String VisualShaderNodeCubemap::get_caption() const { … }

int VisualShaderNodeCubemap::get_input_port_count() const { … }

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

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

int VisualShaderNodeCubemap::get_output_port_count() const { … }

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

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

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

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

String VisualShaderNodeCubemap::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 VisualShaderNodeCubemap::is_input_port_default(int p_port, Shader::Mode p_mode) const { … }

void VisualShaderNodeCubemap::set_source(Source p_source) { … }

VisualShaderNodeCubemap::Source VisualShaderNodeCubemap::get_source() const { … }

void VisualShaderNodeCubemap::set_cube_map(Ref<TextureLayered> p_cube_map) { … }

Ref<TextureLayered> VisualShaderNodeCubemap::get_cube_map() const { … }

void VisualShaderNodeCubemap::set_texture_type(TextureType p_texture_type) { … }

VisualShaderNodeCubemap::TextureType VisualShaderNodeCubemap::get_texture_type() const { … }

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

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

void VisualShaderNodeCubemap::_bind_methods() { … }

VisualShaderNodeCubemap::VisualShaderNodeCubemap() { … }

////////////// Linear Depth

String VisualShaderNodeLinearSceneDepth::get_caption() const { … }

int VisualShaderNodeLinearSceneDepth::get_input_port_count() const { … }

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

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

int VisualShaderNodeLinearSceneDepth::get_output_port_count() const { … }

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

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

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

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

String VisualShaderNodeLinearSceneDepth::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 { … }

VisualShaderNodeLinearSceneDepth::VisualShaderNodeLinearSceneDepth() { … }

////////////// World Position from Depth

String VisualShaderNodeWorldPositionFromDepth::get_caption() const { … }

int VisualShaderNodeWorldPositionFromDepth::get_input_port_count() const { … }

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

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

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

int VisualShaderNodeWorldPositionFromDepth::get_output_port_count() const { … }

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

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

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

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

String VisualShaderNodeWorldPositionFromDepth::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 { … }

VisualShaderNodeWorldPositionFromDepth::VisualShaderNodeWorldPositionFromDepth() { … }

////////////// Unpack Normals in World Space

String VisualShaderNodeScreenNormalWorldSpace::get_caption() const { … }

int VisualShaderNodeScreenNormalWorldSpace::get_input_port_count() const { … }

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

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

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

int VisualShaderNodeScreenNormalWorldSpace::get_output_port_count() const { … }

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

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

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

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

String VisualShaderNodeScreenNormalWorldSpace::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 { … }

VisualShaderNodeScreenNormalWorldSpace::VisualShaderNodeScreenNormalWorldSpace() { … }

////////////// Float Op

String VisualShaderNodeFloatOp::get_caption() const { … }

int VisualShaderNodeFloatOp::get_input_port_count() const { … }

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

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

int VisualShaderNodeFloatOp::get_output_port_count() const { … }

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

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

String VisualShaderNodeFloatOp::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 VisualShaderNodeFloatOp::set_operator(Operator p_op) { … }

VisualShaderNodeFloatOp::Operator VisualShaderNodeFloatOp::get_operator() const { … }

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

void VisualShaderNodeFloatOp::_bind_methods() { … }

VisualShaderNodeFloatOp::VisualShaderNodeFloatOp() { … }

////////////// Integer Op

String VisualShaderNodeIntOp::get_caption() const { … }

int VisualShaderNodeIntOp::get_input_port_count() const { … }

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

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

int VisualShaderNodeIntOp::get_output_port_count() const { … }

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

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

String VisualShaderNodeIntOp::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 VisualShaderNodeIntOp::set_operator(Operator p_op) { … }

VisualShaderNodeIntOp::Operator VisualShaderNodeIntOp::get_operator() const { … }

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

void VisualShaderNodeIntOp::_bind_methods() { … }

VisualShaderNodeIntOp::VisualShaderNodeIntOp() { … }

////////////// Unsigned Integer Op

String VisualShaderNodeUIntOp::get_caption() const { … }

int VisualShaderNodeUIntOp::get_input_port_count() const { … }

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

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

int VisualShaderNodeUIntOp::get_output_port_count() const { … }

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

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

String VisualShaderNodeUIntOp::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 VisualShaderNodeUIntOp::set_operator(Operator p_op) { … }

VisualShaderNodeUIntOp::Operator VisualShaderNodeUIntOp::get_operator() const { … }

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

void VisualShaderNodeUIntOp::_bind_methods() { … }

VisualShaderNodeUIntOp::VisualShaderNodeUIntOp() { … }

////////////// Vector Op

String VisualShaderNodeVectorOp::get_caption() const { … }

int VisualShaderNodeVectorOp::get_input_port_count() const { … }

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

int VisualShaderNodeVectorOp::get_output_port_count() const { … }

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

String VisualShaderNodeVectorOp::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 VisualShaderNodeVectorOp::set_op_type(OpType p_op_type) { … }

void VisualShaderNodeVectorOp::set_operator(Operator p_op) { … }

VisualShaderNodeVectorOp::Operator VisualShaderNodeVectorOp::get_operator() const { … }

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

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

void VisualShaderNodeVectorOp::_bind_methods() { … }

VisualShaderNodeVectorOp::VisualShaderNodeVectorOp() { … }

////////////// Color Op

String VisualShaderNodeColorOp::get_caption() const { … }

int VisualShaderNodeColorOp::get_input_port_count() const { … }

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

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

int VisualShaderNodeColorOp::get_output_port_count() const { … }

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

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

String VisualShaderNodeColorOp::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 VisualShaderNodeColorOp::set_operator(Operator p_op) { … }

VisualShaderNodeColorOp::Operator VisualShaderNodeColorOp::get_operator() const { … }

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

void VisualShaderNodeColorOp::_bind_methods() { … }

VisualShaderNodeColorOp::VisualShaderNodeColorOp() { … }

////////////// Transform Op

String VisualShaderNodeTransformOp::get_caption() const { … }

int VisualShaderNodeTransformOp::get_input_port_count() const { … }

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

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

int VisualShaderNodeTransformOp::get_output_port_count() const { … }

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

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

String VisualShaderNodeTransformOp::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 VisualShaderNodeTransformOp::set_operator(Operator p_op) { … }

VisualShaderNodeTransformOp::Operator VisualShaderNodeTransformOp::get_operator() const { … }

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

void VisualShaderNodeTransformOp::_bind_methods() { … }

VisualShaderNodeTransformOp::VisualShaderNodeTransformOp() { … }

////////////// TransformVec Mult

String VisualShaderNodeTransformVecMult::get_caption() const { … }

int VisualShaderNodeTransformVecMult::get_input_port_count() const { … }

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

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

int VisualShaderNodeTransformVecMult::get_output_port_count() const { … }

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

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

String VisualShaderNodeTransformVecMult::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 VisualShaderNodeTransformVecMult::set_operator(Operator p_op) { … }

VisualShaderNodeTransformVecMult::Operator VisualShaderNodeTransformVecMult::get_operator() const { … }

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

void VisualShaderNodeTransformVecMult::_bind_methods() { … }

VisualShaderNodeTransformVecMult::VisualShaderNodeTransformVecMult() { … }

////////////// Float Func

String VisualShaderNodeFloatFunc::get_caption() const { … }

int VisualShaderNodeFloatFunc::get_input_port_count() const { … }

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

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

int VisualShaderNodeFloatFunc::get_output_port_count() const { … }

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

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

String VisualShaderNodeFloatFunc::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 VisualShaderNodeFloatFunc::set_function(Function p_func) { … }

VisualShaderNodeFloatFunc::Function VisualShaderNodeFloatFunc::get_function() const { … }

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

void VisualShaderNodeFloatFunc::_bind_methods() { … }

VisualShaderNodeFloatFunc::VisualShaderNodeFloatFunc() { … }

////////////// Int Func

String VisualShaderNodeIntFunc::get_caption() const { … }

int VisualShaderNodeIntFunc::get_input_port_count() const { … }

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

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

int VisualShaderNodeIntFunc::get_output_port_count() const { … }

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

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

String VisualShaderNodeIntFunc::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 VisualShaderNodeIntFunc::set_function(Function p_func) { … }

VisualShaderNodeIntFunc::Function VisualShaderNodeIntFunc::get_function() const { … }

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

void VisualShaderNodeIntFunc::_bind_methods() { … }

VisualShaderNodeIntFunc::VisualShaderNodeIntFunc() { … }

////////////// Unsigned Int Func

String VisualShaderNodeUIntFunc::get_caption() const { … }

int VisualShaderNodeUIntFunc::get_input_port_count() const { … }

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

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

int VisualShaderNodeUIntFunc::get_output_port_count() const { … }

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

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

String VisualShaderNodeUIntFunc::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 VisualShaderNodeUIntFunc::set_function(Function p_func) { … }

VisualShaderNodeUIntFunc::Function VisualShaderNodeUIntFunc::get_function() const { … }

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

void VisualShaderNodeUIntFunc::_bind_methods() { … }

VisualShaderNodeUIntFunc::VisualShaderNodeUIntFunc() { … }

////////////// Vector Func

String VisualShaderNodeVectorFunc::get_caption() const { … }

int VisualShaderNodeVectorFunc::get_input_port_count() const { … }

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

int VisualShaderNodeVectorFunc::get_output_port_count() const { … }

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

String VisualShaderNodeVectorFunc::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 VisualShaderNodeVectorFunc::set_op_type(OpType p_op_type) { … }

void VisualShaderNodeVectorFunc::set_function(Function p_func) { … }

VisualShaderNodeVectorFunc::Function VisualShaderNodeVectorFunc::get_function() const { … }

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

void VisualShaderNodeVectorFunc::_bind_methods() { … }

VisualShaderNodeVectorFunc::VisualShaderNodeVectorFunc() { … }

////////////// ColorFunc

String VisualShaderNodeColorFunc::get_caption() const { … }

int VisualShaderNodeColorFunc::get_input_port_count() const { … }

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

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

int VisualShaderNodeColorFunc::get_output_port_count() const { … }

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

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

String VisualShaderNodeColorFunc::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 VisualShaderNodeColorFunc::set_function(Function p_func) { … }

VisualShaderNodeColorFunc::Function VisualShaderNodeColorFunc::get_function() const { … }

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

void VisualShaderNodeColorFunc::_bind_methods() { … }

VisualShaderNodeColorFunc::VisualShaderNodeColorFunc() { … }

////////////// Transform Func

String VisualShaderNodeTransformFunc::get_caption() const { … }

int VisualShaderNodeTransformFunc::get_input_port_count() const { … }

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

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

int VisualShaderNodeTransformFunc::get_output_port_count() const { … }

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

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

String VisualShaderNodeTransformFunc::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 VisualShaderNodeTransformFunc::set_function(Function p_func) { … }

VisualShaderNodeTransformFunc::Function VisualShaderNodeTransformFunc::get_function() const { … }

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

void VisualShaderNodeTransformFunc::_bind_methods() { … }

VisualShaderNodeTransformFunc::VisualShaderNodeTransformFunc() { … }

////////////// UV Func

String VisualShaderNodeUVFunc::get_caption() const { … }

int VisualShaderNodeUVFunc::get_input_port_count() const { … }

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

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

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

int VisualShaderNodeUVFunc::get_output_port_count() const { … }

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

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

bool VisualShaderNodeUVFunc::is_show_prop_names() const { … }

String VisualShaderNodeUVFunc::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 VisualShaderNodeUVFunc::set_function(VisualShaderNodeUVFunc::Function p_func) { … }

VisualShaderNodeUVFunc::Function VisualShaderNodeUVFunc::get_function() const { … }

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

void VisualShaderNodeUVFunc::_bind_methods() { … }

VisualShaderNodeUVFunc::VisualShaderNodeUVFunc() { … }

////////////// UV PolarCoord

String VisualShaderNodeUVPolarCoord::get_caption() const { … }

int VisualShaderNodeUVPolarCoord::get_input_port_count() const { … }

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

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

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

int VisualShaderNodeUVPolarCoord::get_output_port_count() const { … }

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

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

String VisualShaderNodeUVPolarCoord::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 { … }

VisualShaderNodeUVPolarCoord::VisualShaderNodeUVPolarCoord() { … }

////////////// Dot Product

String VisualShaderNodeDotProduct::get_caption() const { … }

int VisualShaderNodeDotProduct::get_input_port_count() const { … }

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

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

int VisualShaderNodeDotProduct::get_output_port_count() const { … }

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

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

String VisualShaderNodeDotProduct::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 { … }

VisualShaderNodeDotProduct::VisualShaderNodeDotProduct() { … }

////////////// Vector Len

String VisualShaderNodeVectorLen::get_caption() const { … }

int VisualShaderNodeVectorLen::get_input_port_count() const { … }

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

int VisualShaderNodeVectorLen::get_output_port_count() const { … }

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

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

void VisualShaderNodeVectorLen::set_op_type(OpType p_op_type) { … }

String VisualShaderNodeVectorLen::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 { … }

VisualShaderNodeVectorLen::VisualShaderNodeVectorLen() { … }

////////////// Determinant

String VisualShaderNodeDeterminant::get_caption() const { … }

int VisualShaderNodeDeterminant::get_input_port_count() const { … }

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

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

int VisualShaderNodeDeterminant::get_output_port_count() const { … }

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

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

String VisualShaderNodeDeterminant::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 { … }

VisualShaderNodeDeterminant::VisualShaderNodeDeterminant() { … }

////////////// Derivative Function

String VisualShaderNodeDerivativeFunc::get_caption() const { … }

int VisualShaderNodeDerivativeFunc::get_input_port_count() const { … }

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

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

int VisualShaderNodeDerivativeFunc::get_output_port_count() const { … }

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

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

String VisualShaderNodeDerivativeFunc::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 VisualShaderNodeDerivativeFunc::get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const { … }

void VisualShaderNodeDerivativeFunc::set_op_type(OpType p_op_type) { … }

VisualShaderNodeDerivativeFunc::OpType VisualShaderNodeDerivativeFunc::get_op_type() const { … }

void VisualShaderNodeDerivativeFunc::set_function(Function p_func) { … }

VisualShaderNodeDerivativeFunc::Function VisualShaderNodeDerivativeFunc::get_function() const { … }

void VisualShaderNodeDerivativeFunc::set_precision(Precision p_precision) { … }

VisualShaderNodeDerivativeFunc::Precision VisualShaderNodeDerivativeFunc::get_precision() const { … }

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

void VisualShaderNodeDerivativeFunc::_bind_methods() { … }

VisualShaderNodeDerivativeFunc::VisualShaderNodeDerivativeFunc() { … }

////////////// Clamp

String VisualShaderNodeClamp::get_caption() const { … }

int VisualShaderNodeClamp::get_input_port_count() const { … }

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

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

int VisualShaderNodeClamp::get_output_port_count() const { … }

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

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

String VisualShaderNodeClamp::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 VisualShaderNodeClamp::set_op_type(OpType p_op_type) { … }

VisualShaderNodeClamp::OpType VisualShaderNodeClamp::get_op_type() const { … }

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

void VisualShaderNodeClamp::_bind_methods() { … }

VisualShaderNodeClamp::VisualShaderNodeClamp() { … }

////////////// FaceForward

String VisualShaderNodeFaceForward::get_caption() const { … }

int VisualShaderNodeFaceForward::get_input_port_count() const { … }

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

int VisualShaderNodeFaceForward::get_output_port_count() const { … }

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

void VisualShaderNodeFaceForward::set_op_type(OpType p_op_type) { … }

String VisualShaderNodeFaceForward::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 { … }

VisualShaderNodeFaceForward::VisualShaderNodeFaceForward() { … }

////////////// Outer Product

String VisualShaderNodeOuterProduct::get_caption() const { … }

int VisualShaderNodeOuterProduct::get_input_port_count() const { … }

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

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

int VisualShaderNodeOuterProduct::get_output_port_count() const { … }

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

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

String VisualShaderNodeOuterProduct::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 { … }

VisualShaderNodeOuterProduct::VisualShaderNodeOuterProduct() { … }

////////////// Step

String VisualShaderNodeStep::get_caption() const { … }

int VisualShaderNodeStep::get_input_port_count() const { … }

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

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

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

int VisualShaderNodeStep::get_output_port_count() const { … }

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

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

void VisualShaderNodeStep::set_op_type(OpType p_op_type) { … }

VisualShaderNodeStep::OpType VisualShaderNodeStep::get_op_type() const { … }

String VisualShaderNodeStep::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 { … }

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

void VisualShaderNodeStep::_bind_methods() { … }

VisualShaderNodeStep::VisualShaderNodeStep() { … }

////////////// SmoothStep

String VisualShaderNodeSmoothStep::get_caption() const { … }

int VisualShaderNodeSmoothStep::get_input_port_count() const { … }

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

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

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

int VisualShaderNodeSmoothStep::get_output_port_count() const { … }

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

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

void VisualShaderNodeSmoothStep::set_op_type(OpType p_op_type) { … }

VisualShaderNodeSmoothStep::OpType VisualShaderNodeSmoothStep::get_op_type() const { … }

String VisualShaderNodeSmoothStep::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 { … }

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

void VisualShaderNodeSmoothStep::_bind_methods() { … }

VisualShaderNodeSmoothStep::VisualShaderNodeSmoothStep() { … }

////////////// Distance

String VisualShaderNodeVectorDistance::get_caption() const { … }

int VisualShaderNodeVectorDistance::get_input_port_count() const { … }

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

int VisualShaderNodeVectorDistance::get_output_port_count() const { … }

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

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

void VisualShaderNodeVectorDistance::set_op_type(OpType p_op_type) { … }

String VisualShaderNodeVectorDistance::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 { … }

VisualShaderNodeVectorDistance::VisualShaderNodeVectorDistance() { … }

////////////// Refract Vector

String VisualShaderNodeVectorRefract::get_caption() const { … }

int VisualShaderNodeVectorRefract::get_input_port_count() const { … }

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

int VisualShaderNodeVectorRefract::get_output_port_count() const { … }

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

String VisualShaderNodeVectorRefract::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 VisualShaderNodeVectorRefract::set_op_type(OpType p_op_type) { … }

VisualShaderNodeVectorRefract::VisualShaderNodeVectorRefract() { … }

////////////// Mix

String VisualShaderNodeMix::get_caption() const { … }

int VisualShaderNodeMix::get_input_port_count() const { … }

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

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

int VisualShaderNodeMix::get_output_port_count() const { … }

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

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

void VisualShaderNodeMix::set_op_type(OpType p_op_type) { … }

VisualShaderNodeMix::OpType VisualShaderNodeMix::get_op_type() const { … }

String VisualShaderNodeMix::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 { … }

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

void VisualShaderNodeMix::_bind_methods() { … }

VisualShaderNodeMix::VisualShaderNodeMix() { … }

////////////// Vector Compose

String VisualShaderNodeVectorCompose::get_caption() const { … }

int VisualShaderNodeVectorCompose::get_input_port_count() const { … }

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

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

int VisualShaderNodeVectorCompose::get_output_port_count() const { … }

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

void VisualShaderNodeVectorCompose::set_op_type(OpType p_op_type) { … }

String VisualShaderNodeVectorCompose::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 { … }

VisualShaderNodeVectorCompose::VisualShaderNodeVectorCompose() { … }

////////////// Transform Compose

String VisualShaderNodeTransformCompose::get_caption() const { … }

int VisualShaderNodeTransformCompose::get_input_port_count() const { … }

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

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

int VisualShaderNodeTransformCompose::get_output_port_count() const { … }

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

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

String VisualShaderNodeTransformCompose::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 { … }

VisualShaderNodeTransformCompose::VisualShaderNodeTransformCompose() { … }

////////////// Vector Decompose
String VisualShaderNodeVectorDecompose::get_caption() const { … }

int VisualShaderNodeVectorDecompose::get_input_port_count() const { … }

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

int VisualShaderNodeVectorDecompose::get_output_port_count() const { … }

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

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

void VisualShaderNodeVectorDecompose::set_op_type(OpType p_op_type) { … }

String VisualShaderNodeVectorDecompose::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 { … }

VisualShaderNodeVectorDecompose::VisualShaderNodeVectorDecompose() { … }

////////////// Transform Decompose

String VisualShaderNodeTransformDecompose::get_caption() const { … }

int VisualShaderNodeTransformDecompose::get_input_port_count() const { … }

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

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

int VisualShaderNodeTransformDecompose::get_output_port_count() const { … }

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

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

String VisualShaderNodeTransformDecompose::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 { … }

VisualShaderNodeTransformDecompose::VisualShaderNodeTransformDecompose() { … }

////////////// Float Parameter

String VisualShaderNodeFloatParameter::get_caption() const { … }

int VisualShaderNodeFloatParameter::get_input_port_count() const { … }

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

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

int VisualShaderNodeFloatParameter::get_output_port_count() const { … }

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

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

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

String VisualShaderNodeFloatParameter::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 VisualShaderNodeFloatParameter::is_show_prop_names() const { … }

bool VisualShaderNodeFloatParameter::is_use_prop_slots() const { … }

void VisualShaderNodeFloatParameter::set_hint(Hint p_hint) { … }

VisualShaderNodeFloatParameter::Hint VisualShaderNodeFloatParameter::get_hint() const { … }

void VisualShaderNodeFloatParameter::set_min(float p_value) { … }

float VisualShaderNodeFloatParameter::get_min() const { … }

void VisualShaderNodeFloatParameter::set_max(float p_value) { … }

float VisualShaderNodeFloatParameter::get_max() const { … }

void VisualShaderNodeFloatParameter::set_step(float p_value) { … }

float VisualShaderNodeFloatParameter::get_step() const { … }

void VisualShaderNodeFloatParameter::set_default_value_enabled(bool p_enabled) { … }

bool VisualShaderNodeFloatParameter::is_default_value_enabled() const { … }

void VisualShaderNodeFloatParameter::set_default_value(float p_value) { … }

float VisualShaderNodeFloatParameter::get_default_value() const { … }

void VisualShaderNodeFloatParameter::_bind_methods() { … }

bool VisualShaderNodeFloatParameter::is_qualifier_supported(Qualifier p_qual) const { … }

bool VisualShaderNodeFloatParameter::is_convertible_to_constant() const { … }

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

VisualShaderNodeFloatParameter::VisualShaderNodeFloatParameter() { … }

////////////// Integer Parameter

String VisualShaderNodeIntParameter::get_caption() const { … }

int VisualShaderNodeIntParameter::get_input_port_count() const { … }

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

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

int VisualShaderNodeIntParameter::get_output_port_count() const { … }

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

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

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

String VisualShaderNodeIntParameter::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 VisualShaderNodeIntParameter::is_show_prop_names() const { … }

bool VisualShaderNodeIntParameter::is_use_prop_slots() const { … }

void VisualShaderNodeIntParameter::set_hint(Hint p_hint) { … }

VisualShaderNodeIntParameter::Hint VisualShaderNodeIntParameter::get_hint() const { … }

void VisualShaderNodeIntParameter::set_min(int p_value) { … }

int VisualShaderNodeIntParameter::get_min() const { … }

void VisualShaderNodeIntParameter::set_max(int p_value) { … }

int VisualShaderNodeIntParameter::get_max() const { … }

void VisualShaderNodeIntParameter::set_step(int p_value) { … }

int VisualShaderNodeIntParameter::get_step() const { … }

void VisualShaderNodeIntParameter::set_enum_names(const PackedStringArray &p_names) { … }

PackedStringArray VisualShaderNodeIntParameter::get_enum_names() const { … }

void VisualShaderNodeIntParameter::set_default_value_enabled(bool p_default_value_enabled) { … }

bool VisualShaderNodeIntParameter::is_default_value_enabled() const { … }

void VisualShaderNodeIntParameter::set_default_value(int p_default_value) { … }

int VisualShaderNodeIntParameter::get_default_value() const { … }

void VisualShaderNodeIntParameter::_bind_methods() { … }

bool VisualShaderNodeIntParameter::is_qualifier_supported(Qualifier p_qual) const { … }

bool VisualShaderNodeIntParameter::is_convertible_to_constant() const { … }

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

VisualShaderNodeIntParameter::VisualShaderNodeIntParameter() { … }

////////////// Unsigned Integer Parameter

String VisualShaderNodeUIntParameter::get_caption() const { … }

int VisualShaderNodeUIntParameter::get_input_port_count() const { … }

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

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

int VisualShaderNodeUIntParameter::get_output_port_count() const { … }

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

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

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

String VisualShaderNodeUIntParameter::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 VisualShaderNodeUIntParameter::is_show_prop_names() const { … }

bool VisualShaderNodeUIntParameter::is_use_prop_slots() const { … }

void VisualShaderNodeUIntParameter::set_default_value_enabled(bool p_default_value_enabled) { … }

bool VisualShaderNodeUIntParameter::is_default_value_enabled() const { … }

void VisualShaderNodeUIntParameter::set_default_value(int p_default_value) { … }

int VisualShaderNodeUIntParameter::get_default_value() const { … }

void VisualShaderNodeUIntParameter::_bind_methods() { … }

bool VisualShaderNodeUIntParameter::is_qualifier_supported(Qualifier p_qual) const { … }

bool VisualShaderNodeUIntParameter::is_convertible_to_constant() const { … }

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

VisualShaderNodeUIntParameter::VisualShaderNodeUIntParameter() { … }

////////////// Boolean Parameter

String VisualShaderNodeBooleanParameter::get_caption() const { … }

int VisualShaderNodeBooleanParameter::get_input_port_count() const { … }

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

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

int VisualShaderNodeBooleanParameter::get_output_port_count() const { … }

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

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

void VisualShaderNodeBooleanParameter::set_default_value_enabled(bool p_default_value_enabled) { … }

bool VisualShaderNodeBooleanParameter::is_default_value_enabled() const { … }

void VisualShaderNodeBooleanParameter::set_default_value(bool p_default_value) { … }

bool VisualShaderNodeBooleanParameter::get_default_value() const { … }

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

String VisualShaderNodeBooleanParameter::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 VisualShaderNodeBooleanParameter::is_show_prop_names() const { … }

bool VisualShaderNodeBooleanParameter::is_use_prop_slots() const { … }

void VisualShaderNodeBooleanParameter::_bind_methods() { … }

bool VisualShaderNodeBooleanParameter::is_qualifier_supported(Qualifier p_qual) const { … }

bool VisualShaderNodeBooleanParameter::is_convertible_to_constant() const { … }

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

VisualShaderNodeBooleanParameter::VisualShaderNodeBooleanParameter() { … }

////////////// Color Parameter

String VisualShaderNodeColorParameter::get_caption() const { … }

int VisualShaderNodeColorParameter::get_input_port_count() const { … }

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

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

int VisualShaderNodeColorParameter::get_output_port_count() const { … }

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

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

void VisualShaderNodeColorParameter::set_default_value_enabled(bool p_enabled) { … }

bool VisualShaderNodeColorParameter::is_default_value_enabled() const { … }

void VisualShaderNodeColorParameter::set_default_value(const Color &p_value) { … }

Color VisualShaderNodeColorParameter::get_default_value() const { … }

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

String VisualShaderNodeColorParameter::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 VisualShaderNodeColorParameter::is_show_prop_names() const { … }

void VisualShaderNodeColorParameter::_bind_methods() { … }

bool VisualShaderNodeColorParameter::is_qualifier_supported(Qualifier p_qual) const { … }

bool VisualShaderNodeColorParameter::is_convertible_to_constant() const { … }

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

VisualShaderNodeColorParameter::VisualShaderNodeColorParameter() { … }

////////////// Vector2 Parameter

String VisualShaderNodeVec2Parameter::get_caption() const { … }

int VisualShaderNodeVec2Parameter::get_input_port_count() const { … }

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

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

int VisualShaderNodeVec2Parameter::get_output_port_count() const { … }

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

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

void VisualShaderNodeVec2Parameter::set_default_value_enabled(bool p_enabled) { … }

bool VisualShaderNodeVec2Parameter::is_default_value_enabled() const { … }

void VisualShaderNodeVec2Parameter::set_default_value(const Vector2 &p_value) { … }

Vector2 VisualShaderNodeVec2Parameter::get_default_value() const { … }

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

String VisualShaderNodeVec2Parameter::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 VisualShaderNodeVec2Parameter::_bind_methods() { … }

bool VisualShaderNodeVec2Parameter::is_show_prop_names() const { … }

bool VisualShaderNodeVec2Parameter::is_use_prop_slots() const { … }

bool VisualShaderNodeVec2Parameter::is_qualifier_supported(Qualifier p_qual) const { … }

bool VisualShaderNodeVec2Parameter::is_convertible_to_constant() const { … }

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

VisualShaderNodeVec2Parameter::VisualShaderNodeVec2Parameter() { … }

////////////// Vector3 Parameter

String VisualShaderNodeVec3Parameter::get_caption() const { … }

int VisualShaderNodeVec3Parameter::get_input_port_count() const { … }

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

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

int VisualShaderNodeVec3Parameter::get_output_port_count() const { … }

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

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

void VisualShaderNodeVec3Parameter::set_default_value_enabled(bool p_enabled) { … }

bool VisualShaderNodeVec3Parameter::is_default_value_enabled() const { … }

void VisualShaderNodeVec3Parameter::set_default_value(const Vector3 &p_value) { … }

Vector3 VisualShaderNodeVec3Parameter::get_default_value() const { … }

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

String VisualShaderNodeVec3Parameter::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 VisualShaderNodeVec3Parameter::_bind_methods() { … }

bool VisualShaderNodeVec3Parameter::is_show_prop_names() const { … }

bool VisualShaderNodeVec3Parameter::is_use_prop_slots() const { … }

bool VisualShaderNodeVec3Parameter::is_qualifier_supported(Qualifier p_qual) const { … }

bool VisualShaderNodeVec3Parameter::is_convertible_to_constant() const { … }

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

VisualShaderNodeVec3Parameter::VisualShaderNodeVec3Parameter() { … }

////////////// Vector4 Parameter

String VisualShaderNodeVec4Parameter::get_caption() const { … }

int VisualShaderNodeVec4Parameter::get_input_port_count() const { … }

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

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

int VisualShaderNodeVec4Parameter::get_output_port_count() const { … }

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

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

void VisualShaderNodeVec4Parameter::set_default_value_enabled(bool p_enabled) { … }

bool VisualShaderNodeVec4Parameter::is_default_value_enabled() const { … }

void VisualShaderNodeVec4Parameter::set_default_value(const Vector4 &p_value) { … }

Vector4 VisualShaderNodeVec4Parameter::get_default_value() const { … }

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

String VisualShaderNodeVec4Parameter::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 VisualShaderNodeVec4Parameter::_bind_methods() { … }

bool VisualShaderNodeVec4Parameter::is_show_prop_names() const { … }

bool VisualShaderNodeVec4Parameter::is_use_prop_slots() const { … }

bool VisualShaderNodeVec4Parameter::is_qualifier_supported(Qualifier p_qual) const { … }

bool VisualShaderNodeVec4Parameter::is_convertible_to_constant() const { … }

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

VisualShaderNodeVec4Parameter::VisualShaderNodeVec4Parameter() { … }

////////////// Transform Parameter

String VisualShaderNodeTransformParameter::get_caption() const { … }

int VisualShaderNodeTransformParameter::get_input_port_count() const { … }

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

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

int VisualShaderNodeTransformParameter::get_output_port_count() const { … }

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

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

void VisualShaderNodeTransformParameter::set_default_value_enabled(bool p_enabled) { … }

bool VisualShaderNodeTransformParameter::is_default_value_enabled() const { … }

void VisualShaderNodeTransformParameter::set_default_value(const Transform3D &p_value) { … }

Transform3D VisualShaderNodeTransformParameter::get_default_value() const { … }

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

String VisualShaderNodeTransformParameter::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 VisualShaderNodeTransformParameter::_bind_methods() { … }

bool VisualShaderNodeTransformParameter::is_show_prop_names() const { … }

bool VisualShaderNodeTransformParameter::is_use_prop_slots() const { … }

bool VisualShaderNodeTransformParameter::is_qualifier_supported(Qualifier p_qual) const { … }

bool VisualShaderNodeTransformParameter::is_convertible_to_constant() const { … }

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

VisualShaderNodeTransformParameter::VisualShaderNodeTransformParameter() { … }

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

String get_sampler_hint(VisualShaderNodeTextureParameter::TextureType p_texture_type, VisualShaderNodeTextureParameter::ColorDefault p_color_default, VisualShaderNodeTextureParameter::TextureFilter p_texture_filter, VisualShaderNodeTextureParameter::TextureRepeat p_texture_repeat, VisualShaderNodeTextureParameter::TextureSource p_texture_source) { … }

////////////// Texture Parameter

int VisualShaderNodeTextureParameter::get_input_port_count() const { … }

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

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

int VisualShaderNodeTextureParameter::get_output_port_count() const { … }

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

String VisualShaderNodeTextureParameter::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 VisualShaderNodeTextureParameter::set_texture_type(TextureType p_texture_type) { … }

VisualShaderNodeTextureParameter::TextureType VisualShaderNodeTextureParameter::get_texture_type() const { … }

void VisualShaderNodeTextureParameter::set_color_default(ColorDefault p_color_default) { … }

VisualShaderNodeTextureParameter::ColorDefault VisualShaderNodeTextureParameter::get_color_default() const { … }

void VisualShaderNodeTextureParameter::set_texture_filter(TextureFilter p_filter) { … }

VisualShaderNodeTextureParameter::TextureFilter VisualShaderNodeTextureParameter::get_texture_filter() const { … }

void VisualShaderNodeTextureParameter::set_texture_repeat(TextureRepeat p_repeat) { … }

VisualShaderNodeTextureParameter::TextureRepeat VisualShaderNodeTextureParameter::get_texture_repeat() const { … }

void VisualShaderNodeTextureParameter::set_texture_source(TextureSource p_source) { … }

VisualShaderNodeTextureParameter::TextureSource VisualShaderNodeTextureParameter::get_texture_source() const { … }

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

bool VisualShaderNodeTextureParameter::is_show_prop_names() const { … }

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

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

void VisualShaderNodeTextureParameter::_bind_methods() { … }

bool VisualShaderNodeTextureParameter::is_qualifier_supported(Qualifier p_qual) const { … }

bool VisualShaderNodeTextureParameter::is_convertible_to_constant() const { … }

VisualShaderNodeTextureParameter::VisualShaderNodeTextureParameter() { … }

////////////// Texture2D Parameter

String VisualShaderNodeTexture2DParameter::get_caption() const { … }

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

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

VisualShaderNodeTexture2DParameter::VisualShaderNodeTexture2DParameter() { … }

////////////// Texture Parameter (Triplanar)

String VisualShaderNodeTextureParameterTriplanar::get_caption() const { … }

int VisualShaderNodeTextureParameterTriplanar::get_input_port_count() const { … }

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

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

int VisualShaderNodeTextureParameterTriplanar::get_output_port_count() const { … }

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

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

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

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

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

String VisualShaderNodeTextureParameterTriplanar::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 VisualShaderNodeTextureParameterTriplanar::is_input_port_default(int p_port, Shader::Mode p_mode) const { … }

VisualShaderNodeTextureParameterTriplanar::VisualShaderNodeTextureParameterTriplanar() { … }

////////////// Texture2DArray Parameter

String VisualShaderNodeTexture2DArrayParameter::get_caption() const { … }

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

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

VisualShaderNodeTexture2DArrayParameter::VisualShaderNodeTexture2DArrayParameter() { … }

////////////// Texture3D Parameter

String VisualShaderNodeTexture3DParameter::get_caption() const { … }

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

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

VisualShaderNodeTexture3DParameter::VisualShaderNodeTexture3DParameter() { … }

////////////// Cubemap Parameter

String VisualShaderNodeCubemapParameter::get_caption() const { … }

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

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

VisualShaderNodeCubemapParameter::VisualShaderNodeCubemapParameter() { … }

////////////// If

String VisualShaderNodeIf::get_caption() const { … }

int VisualShaderNodeIf::get_input_port_count() const { … }

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

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

int VisualShaderNodeIf::get_output_port_count() const { … }

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

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

String VisualShaderNodeIf::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 { … }

VisualShaderNodeIf::VisualShaderNodeIf() { … }

////////////// Switch

String VisualShaderNodeSwitch::get_caption() const { … }

int VisualShaderNodeSwitch::get_input_port_count() const { … }

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

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

int VisualShaderNodeSwitch::get_output_port_count() const { … }

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

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

void VisualShaderNodeSwitch::set_op_type(OpType p_op_type) { … }

VisualShaderNodeSwitch::OpType VisualShaderNodeSwitch::get_op_type() const { … }

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

void VisualShaderNodeSwitch::_bind_methods() { … }

String VisualShaderNodeSwitch::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 { … }

VisualShaderNodeSwitch::VisualShaderNodeSwitch() { … }

////////////// Fresnel

String VisualShaderNodeFresnel::get_caption() const { … }

int VisualShaderNodeFresnel::get_input_port_count() const { … }

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

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

int VisualShaderNodeFresnel::get_output_port_count() const { … }

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

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

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

String VisualShaderNodeFresnel::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 VisualShaderNodeFresnel::is_input_port_default(int p_port, Shader::Mode p_mode) const { … }

VisualShaderNodeFresnel::VisualShaderNodeFresnel() { … }

////////////// Is

String VisualShaderNodeIs::get_caption() const { … }

int VisualShaderNodeIs::get_input_port_count() const { … }

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

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

int VisualShaderNodeIs::get_output_port_count() const { … }

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

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

String VisualShaderNodeIs::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 VisualShaderNodeIs::set_function(Function p_func) { … }

VisualShaderNodeIs::Function VisualShaderNodeIs::get_function() const { … }

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

void VisualShaderNodeIs::_bind_methods() { … }

VisualShaderNodeIs::VisualShaderNodeIs() { … }

////////////// Compare

String VisualShaderNodeCompare::get_caption() const { … }

int VisualShaderNodeCompare::get_input_port_count() const { … }

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

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

int VisualShaderNodeCompare::get_output_port_count() const { … }

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

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

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

String VisualShaderNodeCompare::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 VisualShaderNodeCompare::set_comparison_type(ComparisonType p_comparison_type) { … }

VisualShaderNodeCompare::ComparisonType VisualShaderNodeCompare::get_comparison_type() const { … }

void VisualShaderNodeCompare::set_function(Function p_func) { … }

VisualShaderNodeCompare::Function VisualShaderNodeCompare::get_function() const { … }

void VisualShaderNodeCompare::set_condition(Condition p_condition) { … }

VisualShaderNodeCompare::Condition VisualShaderNodeCompare::get_condition() const { … }

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

void VisualShaderNodeCompare::_bind_methods() { … }

VisualShaderNodeCompare::VisualShaderNodeCompare() { … }

////////////// Fma

String VisualShaderNodeMultiplyAdd::get_caption() const { … }

int VisualShaderNodeMultiplyAdd::get_input_port_count() const { … }

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

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

int VisualShaderNodeMultiplyAdd::get_output_port_count() const { … }

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

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

String VisualShaderNodeMultiplyAdd::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 VisualShaderNodeMultiplyAdd::set_op_type(OpType p_op_type) { … }

VisualShaderNodeMultiplyAdd::OpType VisualShaderNodeMultiplyAdd::get_op_type() const { … }

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

void VisualShaderNodeMultiplyAdd::_bind_methods() { … }

VisualShaderNodeMultiplyAdd::VisualShaderNodeMultiplyAdd() { … }

////////////// Billboard

String VisualShaderNodeBillboard::get_caption() const { … }

int VisualShaderNodeBillboard::get_input_port_count() const { … }

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

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

int VisualShaderNodeBillboard::get_output_port_count() const { … }

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

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

String VisualShaderNodeBillboard::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 VisualShaderNodeBillboard::is_show_prop_names() const { … }

void VisualShaderNodeBillboard::set_billboard_type(BillboardType p_billboard_type) { … }

VisualShaderNodeBillboard::BillboardType VisualShaderNodeBillboard::get_billboard_type() const { … }

void VisualShaderNodeBillboard::set_keep_scale_enabled(bool p_enabled) { … }

bool VisualShaderNodeBillboard::is_keep_scale_enabled() const { … }

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

void VisualShaderNodeBillboard::_bind_methods() { … }

VisualShaderNodeBillboard::VisualShaderNodeBillboard() { … }

////////////// DistanceFade

String VisualShaderNodeDistanceFade::get_caption() const { … }

int VisualShaderNodeDistanceFade::get_input_port_count() const { … }

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

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

int VisualShaderNodeDistanceFade::get_output_port_count() const { … }

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

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

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

String VisualShaderNodeDistanceFade::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 { … }

VisualShaderNodeDistanceFade::VisualShaderNodeDistanceFade() { … }

////////////// ProximityFade

String VisualShaderNodeProximityFade::get_caption() const { … }

int VisualShaderNodeProximityFade::get_input_port_count() const { … }

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

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

int VisualShaderNodeProximityFade::get_output_port_count() const { … }

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

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

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

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

String VisualShaderNodeProximityFade::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 { … }

VisualShaderNodeProximityFade::VisualShaderNodeProximityFade() { … }

////////////// Random Range

String VisualShaderNodeRandomRange::get_caption() const { … }

int VisualShaderNodeRandomRange::get_input_port_count() const { … }

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

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

int VisualShaderNodeRandomRange::get_output_port_count() const { … }

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

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

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

String VisualShaderNodeRandomRange::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 { … }

VisualShaderNodeRandomRange::VisualShaderNodeRandomRange() { … }

////////////// Remap

String VisualShaderNodeRemap::get_caption() const { … }

int VisualShaderNodeRemap::get_input_port_count() const { … }

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

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

int VisualShaderNodeRemap::get_output_port_count() const { … }

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

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

String VisualShaderNodeRemap::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 { … }

VisualShaderNodeRemap::VisualShaderNodeRemap() { … }

////////////// RotationByAxis

String VisualShaderNodeRotationByAxis::get_caption() const { … }

int VisualShaderNodeRotationByAxis::get_input_port_count() const { … }

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

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

int VisualShaderNodeRotationByAxis::get_output_port_count() const { … }

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

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

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

String VisualShaderNodeRotationByAxis::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 { … }

VisualShaderNodeRotationByAxis::VisualShaderNodeRotationByAxis() { … }

String VisualShaderNodeReroute::get_caption() const { … }

int VisualShaderNodeReroute::get_input_port_count() const { … }

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

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

int VisualShaderNodeReroute::get_output_port_count() const { … }

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

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

String VisualShaderNodeReroute::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 VisualShaderNodeReroute::_set_port_type(PortType p_type) { … }

void VisualShaderNodeReroute::_bind_methods() { … }

VisualShaderNodeReroute::VisualShaderNodeReroute() { … }