2018-08-29 20:38:13 +00:00
|
|
|
/*************************************************************************/
|
|
|
|
/* visual_shader_nodes.h */
|
|
|
|
/*************************************************************************/
|
|
|
|
/* This file is part of: */
|
|
|
|
/* GODOT ENGINE */
|
|
|
|
/* https://godotengine.org */
|
|
|
|
/*************************************************************************/
|
2022-01-03 20:27:34 +00:00
|
|
|
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
|
|
|
|
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
|
2018-08-29 20:38:13 +00:00
|
|
|
/* */
|
|
|
|
/* 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. */
|
|
|
|
/*************************************************************************/
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
#ifndef VISUAL_SHADER_NODES_H
|
|
|
|
#define VISUAL_SHADER_NODES_H
|
|
|
|
|
|
|
|
#include "scene/resources/visual_shader.h"
|
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// Vector Base Node
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeVectorBase : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeVectorBase, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
|
|
|
enum OpType {
|
|
|
|
OP_TYPE_VECTOR_2D,
|
|
|
|
OP_TYPE_VECTOR_3D,
|
2022-04-12 17:09:29 +00:00
|
|
|
OP_TYPE_VECTOR_4D,
|
2022-02-01 08:32:01 +00:00
|
|
|
OP_TYPE_MAX,
|
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
|
|
|
OpType op_type = OP_TYPE_VECTOR_3D;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override = 0;
|
|
|
|
|
|
|
|
virtual int get_input_port_count() const override = 0;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override = 0;
|
|
|
|
|
|
|
|
virtual int get_output_port_count() const override = 0;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override = 0;
|
|
|
|
|
|
|
|
virtual String 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 = false) const override = 0;
|
|
|
|
|
|
|
|
virtual void set_op_type(OpType p_op_type);
|
|
|
|
OpType get_op_type() const;
|
|
|
|
|
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
|
|
|
|
VisualShaderNodeVectorBase();
|
|
|
|
};
|
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeVectorBase::OpType)
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// CONSTANTS
|
|
|
|
///////////////////////////////////////
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-12-30 08:45:31 +00:00
|
|
|
class VisualShaderNodeConstant : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeConstant, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override = 0;
|
|
|
|
|
|
|
|
virtual int get_input_port_count() const override = 0;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override = 0;
|
|
|
|
virtual String get_input_port_name(int p_port) const override = 0;
|
|
|
|
|
|
|
|
virtual int get_output_port_count() const override = 0;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override = 0;
|
|
|
|
virtual String get_output_port_name(int p_port) const override = 0;
|
|
|
|
|
|
|
|
virtual String 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 = false) const override = 0;
|
|
|
|
|
|
|
|
VisualShaderNodeConstant();
|
|
|
|
};
|
|
|
|
|
|
|
|
class VisualShaderNodeFloatConstant : public VisualShaderNodeConstant {
|
|
|
|
GDCLASS(VisualShaderNodeFloatConstant, VisualShaderNodeConstant);
|
2020-09-05 12:46:12 +00:00
|
|
|
float constant = 0.0f;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_constant(float p_constant);
|
2018-07-14 21:15:42 +00:00
|
|
|
float get_constant() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-02-25 14:50:49 +00:00
|
|
|
VisualShaderNodeFloatConstant();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2020-12-30 08:45:31 +00:00
|
|
|
class VisualShaderNodeIntConstant : public VisualShaderNodeConstant {
|
|
|
|
GDCLASS(VisualShaderNodeIntConstant, VisualShaderNodeConstant);
|
2020-09-05 12:46:12 +00:00
|
|
|
int constant = 0;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_constant(int p_constant);
|
2020-02-25 14:50:49 +00:00
|
|
|
int get_constant() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
|
|
|
VisualShaderNodeIntConstant();
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
2020-12-30 08:45:31 +00:00
|
|
|
class VisualShaderNodeBooleanConstant : public VisualShaderNodeConstant {
|
|
|
|
GDCLASS(VisualShaderNodeBooleanConstant, VisualShaderNodeConstant);
|
2020-09-05 12:46:12 +00:00
|
|
|
bool constant = false;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_constant(bool p_constant);
|
2019-02-22 17:38:58 +00:00
|
|
|
bool get_constant() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
VisualShaderNodeBooleanConstant();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2020-12-30 08:45:31 +00:00
|
|
|
class VisualShaderNodeColorConstant : public VisualShaderNodeConstant {
|
|
|
|
GDCLASS(VisualShaderNodeColorConstant, VisualShaderNodeConstant);
|
2020-09-05 12:46:12 +00:00
|
|
|
Color constant = Color(1, 1, 1, 1);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2020-12-20 15:45:53 +00:00
|
|
|
virtual bool is_output_port_expandable(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_constant(const Color &p_constant);
|
2018-07-14 21:15:42 +00:00
|
|
|
Color get_constant() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
VisualShaderNodeColorConstant();
|
|
|
|
};
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
class VisualShaderNodeVec2Constant : public VisualShaderNodeConstant {
|
|
|
|
GDCLASS(VisualShaderNodeVec2Constant, VisualShaderNodeConstant);
|
|
|
|
Vector2 constant;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override;
|
|
|
|
|
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual String 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 = false) const override;
|
|
|
|
|
|
|
|
void set_constant(const Vector2 &p_constant);
|
|
|
|
Vector2 get_constant() const;
|
|
|
|
|
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
|
|
|
|
VisualShaderNodeVec2Constant();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2020-12-30 08:45:31 +00:00
|
|
|
class VisualShaderNodeVec3Constant : public VisualShaderNodeConstant {
|
|
|
|
GDCLASS(VisualShaderNodeVec3Constant, VisualShaderNodeConstant);
|
2018-07-14 21:15:42 +00:00
|
|
|
Vector3 constant;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_constant(const Vector3 &p_constant);
|
2018-07-14 21:15:42 +00:00
|
|
|
Vector3 get_constant() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
VisualShaderNodeVec3Constant();
|
|
|
|
};
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
2022-04-12 17:09:29 +00:00
|
|
|
class VisualShaderNodeVec4Constant : public VisualShaderNodeConstant {
|
|
|
|
GDCLASS(VisualShaderNodeVec4Constant, VisualShaderNodeConstant);
|
|
|
|
Quaternion constant;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override;
|
|
|
|
|
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual String 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 = false) const override;
|
|
|
|
|
|
|
|
void set_constant(const Quaternion &p_constant);
|
|
|
|
Quaternion get_constant() const;
|
|
|
|
|
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
|
|
|
|
VisualShaderNodeVec4Constant();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2020-12-30 08:45:31 +00:00
|
|
|
class VisualShaderNodeTransformConstant : public VisualShaderNodeConstant {
|
|
|
|
GDCLASS(VisualShaderNodeTransformConstant, VisualShaderNodeConstant);
|
2020-10-17 05:08:21 +00:00
|
|
|
Transform3D constant;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_constant(const Transform3D &p_constant);
|
2020-10-17 05:08:21 +00:00
|
|
|
Transform3D get_constant() const;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
VisualShaderNodeTransformConstant();
|
|
|
|
};
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// TEXTURES
|
|
|
|
///////////////////////////////////////
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
class VisualShaderNodeTexture : public VisualShaderNode {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeTexture, VisualShaderNode);
|
2019-06-11 18:43:37 +00:00
|
|
|
Ref<Texture2D> texture;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
enum Source {
|
|
|
|
SOURCE_TEXTURE,
|
|
|
|
SOURCE_SCREEN,
|
|
|
|
SOURCE_2D_TEXTURE,
|
2019-07-05 08:48:31 +00:00
|
|
|
SOURCE_2D_NORMAL,
|
2019-10-01 08:51:50 +00:00
|
|
|
SOURCE_DEPTH,
|
|
|
|
SOURCE_PORT,
|
2021-08-14 10:38:22 +00:00
|
|
|
SOURCE_MAX,
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
enum TextureType {
|
|
|
|
TYPE_DATA,
|
|
|
|
TYPE_COLOR,
|
2020-12-23 09:34:26 +00:00
|
|
|
TYPE_NORMAL_MAP,
|
2021-08-14 10:38:22 +00:00
|
|
|
TYPE_MAX,
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
2020-09-05 12:46:12 +00:00
|
|
|
Source source = SOURCE_TEXTURE;
|
|
|
|
TextureType texture_type = TYPE_DATA;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2020-12-20 15:45:53 +00:00
|
|
|
virtual bool is_output_port_expandable(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2022-01-22 08:09:16 +00:00
|
|
|
virtual bool is_input_port_default(int p_port, Shader::Mode p_mode) const override;
|
2019-10-03 07:40:26 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<VisualShader::DefaultTextureParam> get_default_texture_parameters(VisualShader::Type p_type, int p_id) const override;
|
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
void set_source(Source p_source);
|
|
|
|
Source get_source() const;
|
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_texture(Ref<Texture2D> p_texture);
|
2019-06-11 18:43:37 +00:00
|
|
|
Ref<Texture2D> get_texture() const;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_texture_type(TextureType p_texture_type);
|
2018-07-14 21:15:42 +00:00
|
|
|
TextureType get_texture_type() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
VisualShaderNodeTexture();
|
|
|
|
};
|
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeTexture::TextureType)
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeTexture::Source)
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-10-04 09:11:58 +00:00
|
|
|
class VisualShaderNodeCurveTexture : public VisualShaderNodeResizableBase {
|
|
|
|
GDCLASS(VisualShaderNodeCurveTexture, VisualShaderNodeResizableBase);
|
|
|
|
Ref<CurveTexture> texture;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override;
|
|
|
|
|
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual Vector<VisualShader::DefaultTextureParam> get_default_texture_parameters(VisualShader::Type p_type, int p_id) const override;
|
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2020-10-04 09:11:58 +00:00
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_texture(Ref<CurveTexture> p_texture);
|
2020-10-04 09:11:58 +00:00
|
|
|
Ref<CurveTexture> get_texture() const;
|
|
|
|
|
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
virtual bool is_use_prop_slots() const override;
|
|
|
|
|
|
|
|
VisualShaderNodeCurveTexture();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2021-07-13 22:06:44 +00:00
|
|
|
class VisualShaderNodeCurveXYZTexture : public VisualShaderNodeResizableBase {
|
|
|
|
GDCLASS(VisualShaderNodeCurveXYZTexture, VisualShaderNodeResizableBase);
|
|
|
|
Ref<CurveXYZTexture> texture;
|
2021-07-04 08:56:21 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override;
|
|
|
|
|
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual Vector<VisualShader::DefaultTextureParam> get_default_texture_parameters(VisualShader::Type p_type, int p_id) const override;
|
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
|
|
|
virtual String 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 = false) const override;
|
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_texture(Ref<CurveXYZTexture> p_texture);
|
2021-07-13 22:06:44 +00:00
|
|
|
Ref<CurveXYZTexture> get_texture() const;
|
2021-07-04 08:56:21 +00:00
|
|
|
|
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
virtual bool is_use_prop_slots() const override;
|
|
|
|
|
2021-07-13 22:06:44 +00:00
|
|
|
VisualShaderNodeCurveXYZTexture();
|
2021-07-04 08:56:21 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2020-02-18 11:45:23 +00:00
|
|
|
class VisualShaderNodeSample3D : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeSample3D, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
|
|
|
enum Source {
|
|
|
|
SOURCE_TEXTURE,
|
|
|
|
SOURCE_PORT,
|
2021-08-14 10:38:22 +00:00
|
|
|
SOURCE_MAX,
|
2020-02-18 11:45:23 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
2020-09-05 12:46:12 +00:00
|
|
|
Source source = SOURCE_TEXTURE;
|
2020-02-18 11:45:23 +00:00
|
|
|
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2022-01-22 08:09:16 +00:00
|
|
|
virtual bool is_input_port_default(int p_port, Shader::Mode p_mode) const override;
|
2020-02-18 11:45:23 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2020-12-20 15:45:53 +00:00
|
|
|
virtual bool is_output_port_expandable(int p_port) const override;
|
2020-02-18 11:45:23 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2020-02-18 11:45:23 +00:00
|
|
|
|
|
|
|
void set_source(Source p_source);
|
|
|
|
Source get_source() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const override;
|
2020-02-18 11:45:23 +00:00
|
|
|
|
|
|
|
VisualShaderNodeSample3D();
|
|
|
|
};
|
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeSample3D::Source)
|
|
|
|
|
|
|
|
class VisualShaderNodeTexture2DArray : public VisualShaderNodeSample3D {
|
|
|
|
GDCLASS(VisualShaderNodeTexture2DArray, VisualShaderNodeSample3D);
|
2021-08-14 10:38:22 +00:00
|
|
|
Ref<Texture2DArray> texture_array;
|
2020-02-18 11:45:23 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2020-02-18 11:45:23 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2020-02-18 11:45:23 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<VisualShader::DefaultTextureParam> get_default_texture_parameters(VisualShader::Type p_type, int p_id) const override;
|
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
2020-02-18 11:45:23 +00:00
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_texture_array(Ref<Texture2DArray> p_texture_array);
|
2020-02-18 11:45:23 +00:00
|
|
|
Ref<Texture2DArray> get_texture_array() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2020-02-18 11:45:23 +00:00
|
|
|
|
|
|
|
VisualShaderNodeTexture2DArray();
|
|
|
|
};
|
|
|
|
|
2020-09-10 03:47:09 +00:00
|
|
|
class VisualShaderNodeTexture3D : public VisualShaderNodeSample3D {
|
|
|
|
GDCLASS(VisualShaderNodeTexture3D, VisualShaderNodeSample3D);
|
|
|
|
Ref<Texture3D> texture;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override;
|
|
|
|
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual Vector<VisualShader::DefaultTextureParam> get_default_texture_parameters(VisualShader::Type p_type, int p_id) const override;
|
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_texture(Ref<Texture3D> p_texture);
|
2020-09-10 03:47:09 +00:00
|
|
|
Ref<Texture3D> get_texture() const;
|
|
|
|
|
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
|
|
|
|
VisualShaderNodeTexture3D();
|
|
|
|
};
|
|
|
|
|
2019-06-11 18:43:37 +00:00
|
|
|
class VisualShaderNodeCubemap : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeCubemap, VisualShaderNode);
|
|
|
|
Ref<Cubemap> cube_map;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
2019-10-11 07:26:57 +00:00
|
|
|
enum Source {
|
|
|
|
SOURCE_TEXTURE,
|
2021-08-14 10:38:22 +00:00
|
|
|
SOURCE_PORT,
|
|
|
|
SOURCE_MAX,
|
2019-10-11 07:26:57 +00:00
|
|
|
};
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
enum TextureType {
|
|
|
|
TYPE_DATA,
|
|
|
|
TYPE_COLOR,
|
2021-08-14 10:38:22 +00:00
|
|
|
TYPE_NORMAL_MAP,
|
|
|
|
TYPE_MAX,
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
2020-09-05 12:46:12 +00:00
|
|
|
Source source = SOURCE_TEXTURE;
|
|
|
|
TextureType texture_type = TYPE_DATA;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2022-01-22 08:09:16 +00:00
|
|
|
virtual bool is_input_port_default(int p_port, Shader::Mode p_mode) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2020-12-20 15:45:53 +00:00
|
|
|
virtual bool is_output_port_expandable(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<VisualShader::DefaultTextureParam> get_default_texture_parameters(VisualShader::Type p_type, int p_id) const override;
|
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2019-10-11 07:26:57 +00:00
|
|
|
void set_source(Source p_source);
|
|
|
|
Source get_source() const;
|
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_cube_map(Ref<Cubemap> p_cube_map);
|
2019-06-11 18:43:37 +00:00
|
|
|
Ref<Cubemap> get_cube_map() const;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_texture_type(TextureType p_texture_type);
|
2018-07-14 21:15:42 +00:00
|
|
|
TextureType get_texture_type() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2020-11-26 11:25:35 +00:00
|
|
|
virtual String get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2019-06-11 18:43:37 +00:00
|
|
|
VisualShaderNodeCubemap();
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
2019-06-11 18:43:37 +00:00
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeCubemap::TextureType)
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeCubemap::Source)
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2022-08-10 22:39:11 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeLinearSceneDepth : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeLinearSceneDepth, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override;
|
|
|
|
|
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual String 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 = false) const override;
|
|
|
|
|
|
|
|
VisualShaderNodeLinearSceneDepth();
|
|
|
|
};
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// OPS
|
2018-07-14 21:15:42 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
2020-02-25 14:50:49 +00:00
|
|
|
class VisualShaderNodeFloatOp : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeFloatOp, VisualShaderNode);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
enum Operator {
|
|
|
|
OP_ADD,
|
|
|
|
OP_SUB,
|
|
|
|
OP_MUL,
|
|
|
|
OP_DIV,
|
|
|
|
OP_MOD,
|
|
|
|
OP_POW,
|
|
|
|
OP_MAX,
|
|
|
|
OP_MIN,
|
2019-02-22 17:38:58 +00:00
|
|
|
OP_ATAN2,
|
2021-08-14 10:38:22 +00:00
|
|
|
OP_STEP,
|
|
|
|
OP_ENUM_SIZE,
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
2020-09-05 12:46:12 +00:00
|
|
|
Operator op = OP_ADD;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
void set_operator(Operator p_op);
|
|
|
|
Operator get_operator() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-02-25 14:50:49 +00:00
|
|
|
VisualShaderNodeFloatOp();
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
2020-02-25 14:50:49 +00:00
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeFloatOp::Operator)
|
|
|
|
|
|
|
|
class VisualShaderNodeIntOp : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeIntOp, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
|
|
|
enum Operator {
|
|
|
|
OP_ADD,
|
|
|
|
OP_SUB,
|
|
|
|
OP_MUL,
|
|
|
|
OP_DIV,
|
|
|
|
OP_MOD,
|
|
|
|
OP_MAX,
|
|
|
|
OP_MIN,
|
2021-12-03 08:35:38 +00:00
|
|
|
OP_BITWISE_AND,
|
|
|
|
OP_BITWISE_OR,
|
|
|
|
OP_BITWISE_XOR,
|
|
|
|
OP_BITWISE_LEFT_SHIFT,
|
|
|
|
OP_BITWISE_RIGHT_SHIFT,
|
2021-08-14 10:38:22 +00:00
|
|
|
OP_ENUM_SIZE,
|
2020-02-25 14:50:49 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
2020-09-05 12:46:12 +00:00
|
|
|
Operator op = OP_ADD;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
|
|
|
void set_operator(Operator p_op);
|
|
|
|
Operator get_operator() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
|
|
|
VisualShaderNodeIntOp();
|
|
|
|
};
|
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeIntOp::Operator)
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
class VisualShaderNodeVectorOp : public VisualShaderNodeVectorBase {
|
|
|
|
GDCLASS(VisualShaderNodeVectorOp, VisualShaderNodeVectorBase);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
enum Operator {
|
|
|
|
OP_ADD,
|
|
|
|
OP_SUB,
|
|
|
|
OP_MUL,
|
|
|
|
OP_DIV,
|
|
|
|
OP_MOD,
|
|
|
|
OP_POW,
|
|
|
|
OP_MAX,
|
|
|
|
OP_MIN,
|
2019-02-22 17:38:58 +00:00
|
|
|
OP_CROSS,
|
|
|
|
OP_ATAN2,
|
|
|
|
OP_REFLECT,
|
2021-08-14 10:38:22 +00:00
|
|
|
OP_STEP,
|
|
|
|
OP_ENUM_SIZE,
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
2020-09-05 12:46:12 +00:00
|
|
|
Operator op = OP_ADD;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
virtual void set_op_type(OpType p_op_type) override;
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
void set_operator(Operator p_op);
|
|
|
|
Operator get_operator() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2022-02-01 08:32:01 +00:00
|
|
|
String get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
VisualShaderNodeVectorOp();
|
|
|
|
};
|
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeVectorOp::Operator)
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
class VisualShaderNodeColorOp : public VisualShaderNode {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeColorOp, VisualShaderNode);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
enum Operator {
|
|
|
|
OP_SCREEN,
|
|
|
|
OP_DIFFERENCE,
|
|
|
|
OP_DARKEN,
|
|
|
|
OP_LIGHTEN,
|
|
|
|
OP_OVERLAY,
|
|
|
|
OP_DODGE,
|
|
|
|
OP_BURN,
|
|
|
|
OP_SOFT_LIGHT,
|
2021-08-14 10:38:22 +00:00
|
|
|
OP_HARD_LIGHT,
|
|
|
|
OP_MAX,
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
2020-09-05 12:46:12 +00:00
|
|
|
Operator op = OP_SCREEN;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
void set_operator(Operator p_op);
|
|
|
|
Operator get_operator() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
VisualShaderNodeColorOp();
|
|
|
|
};
|
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeColorOp::Operator)
|
|
|
|
|
2021-08-11 16:08:37 +00:00
|
|
|
////////////////////////////////
|
|
|
|
/// TRANSFORM-TRANSFORM OPERATOR
|
|
|
|
////////////////////////////////
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-08-11 16:08:37 +00:00
|
|
|
class VisualShaderNodeTransformOp : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeTransformOp, VisualShaderNode);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
enum Operator {
|
|
|
|
OP_AxB,
|
|
|
|
OP_BxA,
|
2019-02-22 17:38:58 +00:00
|
|
|
OP_AxB_COMP,
|
2021-08-11 16:08:37 +00:00
|
|
|
OP_BxA_COMP,
|
|
|
|
OP_ADD,
|
|
|
|
OP_A_MINUS_B,
|
|
|
|
OP_B_MINUS_A,
|
|
|
|
OP_A_DIV_B,
|
|
|
|
OP_B_DIV_A,
|
2021-08-14 10:38:22 +00:00
|
|
|
OP_MAX,
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
2020-09-05 12:46:12 +00:00
|
|
|
Operator op = OP_AxB;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
void set_operator(Operator p_op);
|
|
|
|
Operator get_operator() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-08-11 16:08:37 +00:00
|
|
|
VisualShaderNodeTransformOp();
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
2021-08-11 16:08:37 +00:00
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeTransformOp::Operator)
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// TRANSFORM-VECTOR MULTIPLICATION
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
class VisualShaderNodeTransformVecMult : public VisualShaderNode {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeTransformVecMult, VisualShaderNode);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
enum Operator {
|
|
|
|
OP_AxB,
|
|
|
|
OP_BxA,
|
|
|
|
OP_3x3_AxB,
|
|
|
|
OP_3x3_BxA,
|
2021-08-14 10:38:22 +00:00
|
|
|
OP_MAX,
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
2020-09-05 12:46:12 +00:00
|
|
|
Operator op = OP_AxB;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
void set_operator(Operator p_op);
|
|
|
|
Operator get_operator() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
VisualShaderNodeTransformVecMult();
|
|
|
|
};
|
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeTransformVecMult::Operator)
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
2020-02-25 14:50:49 +00:00
|
|
|
/// FLOAT FUNC
|
2018-07-14 21:15:42 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
2020-02-25 14:50:49 +00:00
|
|
|
class VisualShaderNodeFloatFunc : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeFloatFunc, VisualShaderNode);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
enum Function {
|
|
|
|
FUNC_SIN,
|
|
|
|
FUNC_COS,
|
|
|
|
FUNC_TAN,
|
|
|
|
FUNC_ASIN,
|
|
|
|
FUNC_ACOS,
|
|
|
|
FUNC_ATAN,
|
|
|
|
FUNC_SINH,
|
|
|
|
FUNC_COSH,
|
|
|
|
FUNC_TANH,
|
|
|
|
FUNC_LOG,
|
|
|
|
FUNC_EXP,
|
|
|
|
FUNC_SQRT,
|
|
|
|
FUNC_ABS,
|
|
|
|
FUNC_SIGN,
|
|
|
|
FUNC_FLOOR,
|
|
|
|
FUNC_ROUND,
|
|
|
|
FUNC_CEIL,
|
2022-06-06 00:15:10 +00:00
|
|
|
FUNC_FRACT,
|
2018-07-14 21:15:42 +00:00
|
|
|
FUNC_SATURATE,
|
|
|
|
FUNC_NEGATE,
|
2019-02-22 17:38:58 +00:00
|
|
|
FUNC_ACOSH,
|
|
|
|
FUNC_ASINH,
|
|
|
|
FUNC_ATANH,
|
|
|
|
FUNC_DEGREES,
|
|
|
|
FUNC_EXP2,
|
|
|
|
FUNC_INVERSE_SQRT,
|
|
|
|
FUNC_LOG2,
|
|
|
|
FUNC_RADIANS,
|
|
|
|
FUNC_RECIPROCAL,
|
|
|
|
FUNC_ROUNDEVEN,
|
2019-05-19 10:07:00 +00:00
|
|
|
FUNC_TRUNC,
|
2021-08-14 10:38:22 +00:00
|
|
|
FUNC_ONEMINUS,
|
|
|
|
FUNC_MAX,
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
2020-09-05 12:46:12 +00:00
|
|
|
Function func = FUNC_SIGN;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
void set_function(Function p_func);
|
|
|
|
Function get_function() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-02-25 14:50:49 +00:00
|
|
|
VisualShaderNodeFloatFunc();
|
|
|
|
};
|
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeFloatFunc::Function)
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
/// INT FUNC
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeIntFunc : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeIntFunc, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
|
|
|
enum Function {
|
|
|
|
FUNC_ABS,
|
|
|
|
FUNC_NEGATE,
|
|
|
|
FUNC_SIGN,
|
2021-12-03 08:35:38 +00:00
|
|
|
FUNC_BITWISE_NOT,
|
2021-08-14 10:38:22 +00:00
|
|
|
FUNC_MAX,
|
2020-02-25 14:50:49 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
2020-09-05 12:46:12 +00:00
|
|
|
Function func = FUNC_SIGN;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
|
|
|
void set_function(Function p_func);
|
|
|
|
Function get_function() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
|
|
|
VisualShaderNodeIntFunc();
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
2020-02-25 14:50:49 +00:00
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeIntFunc::Function)
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// VECTOR FUNC
|
2018-07-14 21:15:42 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
class VisualShaderNodeVectorFunc : public VisualShaderNodeVectorBase {
|
|
|
|
GDCLASS(VisualShaderNodeVectorFunc, VisualShaderNodeVectorBase);
|
|
|
|
|
|
|
|
void _update_default_input_values();
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
enum Function {
|
|
|
|
FUNC_NORMALIZE,
|
|
|
|
FUNC_SATURATE,
|
|
|
|
FUNC_NEGATE,
|
|
|
|
FUNC_RECIPROCAL,
|
2019-02-22 17:38:58 +00:00
|
|
|
FUNC_ABS,
|
|
|
|
FUNC_ACOS,
|
|
|
|
FUNC_ACOSH,
|
|
|
|
FUNC_ASIN,
|
|
|
|
FUNC_ASINH,
|
|
|
|
FUNC_ATAN,
|
|
|
|
FUNC_ATANH,
|
|
|
|
FUNC_CEIL,
|
|
|
|
FUNC_COS,
|
|
|
|
FUNC_COSH,
|
|
|
|
FUNC_DEGREES,
|
|
|
|
FUNC_EXP,
|
|
|
|
FUNC_EXP2,
|
|
|
|
FUNC_FLOOR,
|
2022-06-06 00:15:10 +00:00
|
|
|
FUNC_FRACT,
|
2019-02-22 17:38:58 +00:00
|
|
|
FUNC_INVERSE_SQRT,
|
|
|
|
FUNC_LOG,
|
|
|
|
FUNC_LOG2,
|
|
|
|
FUNC_RADIANS,
|
|
|
|
FUNC_ROUND,
|
|
|
|
FUNC_ROUNDEVEN,
|
|
|
|
FUNC_SIGN,
|
|
|
|
FUNC_SIN,
|
|
|
|
FUNC_SINH,
|
|
|
|
FUNC_SQRT,
|
|
|
|
FUNC_TAN,
|
|
|
|
FUNC_TANH,
|
2019-05-19 10:07:00 +00:00
|
|
|
FUNC_TRUNC,
|
2021-08-14 10:38:22 +00:00
|
|
|
FUNC_ONEMINUS,
|
|
|
|
FUNC_MAX,
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
2020-09-05 12:46:12 +00:00
|
|
|
Function func = FUNC_NORMALIZE;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
virtual void set_op_type(OpType p_op_type) override;
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
void set_function(Function p_func);
|
|
|
|
Function get_function() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
VisualShaderNodeVectorFunc();
|
|
|
|
};
|
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeVectorFunc::Function)
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// COLOR FUNC
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeColorFunc : public VisualShaderNode {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeColorFunc, VisualShaderNode);
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
enum Function {
|
|
|
|
FUNC_GRAYSCALE,
|
2022-05-07 06:49:12 +00:00
|
|
|
FUNC_HSV2RGB,
|
|
|
|
FUNC_RGB2HSV,
|
2021-08-14 10:38:22 +00:00
|
|
|
FUNC_SEPIA,
|
|
|
|
FUNC_MAX,
|
2019-02-22 17:38:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
2020-09-05 12:46:12 +00:00
|
|
|
Function func = FUNC_GRAYSCALE;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2019-06-26 13:08:25 +00:00
|
|
|
void set_function(Function p_func);
|
2019-02-22 17:38:58 +00:00
|
|
|
Function get_function() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
VisualShaderNodeColorFunc();
|
|
|
|
};
|
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeColorFunc::Function)
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
/// TRANSFORM FUNC
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeTransformFunc : public VisualShaderNode {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeTransformFunc, VisualShaderNode);
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
enum Function {
|
|
|
|
FUNC_INVERSE,
|
2021-08-14 10:38:22 +00:00
|
|
|
FUNC_TRANSPOSE,
|
|
|
|
FUNC_MAX,
|
2019-02-22 17:38:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
2020-09-05 12:46:12 +00:00
|
|
|
Function func = FUNC_INVERSE;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2019-06-26 13:08:25 +00:00
|
|
|
void set_function(Function p_func);
|
2019-02-22 17:38:58 +00:00
|
|
|
Function get_function() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
VisualShaderNodeTransformFunc();
|
|
|
|
};
|
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeTransformFunc::Function)
|
|
|
|
|
2021-06-05 12:53:53 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// UV FUNC
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeUVFunc : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeUVFunc, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
|
|
|
enum Function {
|
|
|
|
FUNC_PANNING,
|
|
|
|
FUNC_SCALING,
|
|
|
|
FUNC_MAX,
|
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
|
|
|
Function func = FUNC_PANNING;
|
|
|
|
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override;
|
|
|
|
|
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2022-01-22 08:09:16 +00:00
|
|
|
virtual bool is_input_port_default(int p_port, Shader::Mode p_mode) const override;
|
2021-06-05 12:53:53 +00:00
|
|
|
|
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual bool is_show_prop_names() const override;
|
|
|
|
|
|
|
|
virtual String 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 = false) const override;
|
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_function(Function p_func);
|
2021-06-05 12:53:53 +00:00
|
|
|
Function get_function() const;
|
|
|
|
|
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
|
|
|
|
VisualShaderNodeUVFunc();
|
|
|
|
};
|
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeUVFunc::Function)
|
|
|
|
|
2022-08-10 22:39:11 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// UV POLARCOORD
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeUVPolarCoord : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeUVPolarCoord, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override;
|
|
|
|
|
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
|
|
|
virtual bool is_input_port_default(int p_port, Shader::Mode p_mode) const override;
|
|
|
|
|
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual String 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 = false) const override;
|
|
|
|
|
|
|
|
VisualShaderNodeUVPolarCoord();
|
|
|
|
};
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// DOT
|
2018-07-14 21:15:42 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeDotProduct : public VisualShaderNode {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeDotProduct, VisualShaderNode);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
VisualShaderNodeDotProduct();
|
|
|
|
};
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// LENGTH
|
2018-07-14 21:15:42 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
class VisualShaderNodeVectorLen : public VisualShaderNodeVectorBase {
|
|
|
|
GDCLASS(VisualShaderNodeVectorLen, VisualShaderNodeVectorBase);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
virtual void set_op_type(OpType p_op_type) override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
VisualShaderNodeVectorLen();
|
|
|
|
};
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// DETERMINANT
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeDeterminant : public VisualShaderNode {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeDeterminant, VisualShaderNode);
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
VisualShaderNodeDeterminant();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
/// CLAMP
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
class VisualShaderNodeClamp : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeClamp, VisualShaderNode);
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
public:
|
2021-01-18 09:23:04 +00:00
|
|
|
enum OpType {
|
|
|
|
OP_TYPE_FLOAT,
|
|
|
|
OP_TYPE_INT,
|
2022-02-01 08:32:01 +00:00
|
|
|
OP_TYPE_VECTOR_2D,
|
|
|
|
OP_TYPE_VECTOR_3D,
|
2022-04-12 17:09:29 +00:00
|
|
|
OP_TYPE_VECTOR_4D,
|
2021-01-18 09:23:04 +00:00
|
|
|
OP_TYPE_MAX,
|
|
|
|
};
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
protected:
|
|
|
|
OpType op_type = OP_TYPE_FLOAT;
|
|
|
|
static void _bind_methods();
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_op_type(OpType p_op_type);
|
2021-01-18 09:23:04 +00:00
|
|
|
OpType get_op_type() const;
|
|
|
|
|
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
VisualShaderNodeClamp();
|
2019-02-22 17:38:58 +00:00
|
|
|
};
|
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeClamp::OpType)
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
2022-01-28 18:36:10 +00:00
|
|
|
/// DERIVATIVE FUNCTION
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
2022-01-28 18:36:10 +00:00
|
|
|
class VisualShaderNodeDerivativeFunc : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeDerivativeFunc, VisualShaderNode);
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
public:
|
2022-01-28 18:36:10 +00:00
|
|
|
enum OpType {
|
|
|
|
OP_TYPE_SCALAR,
|
2022-02-01 08:32:01 +00:00
|
|
|
OP_TYPE_VECTOR_2D,
|
|
|
|
OP_TYPE_VECTOR_3D,
|
2022-04-12 17:09:29 +00:00
|
|
|
OP_TYPE_VECTOR_4D,
|
2022-01-28 18:36:10 +00:00
|
|
|
OP_TYPE_MAX,
|
2019-02-22 17:38:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
enum Function {
|
|
|
|
FUNC_SUM,
|
|
|
|
FUNC_X,
|
2021-08-14 10:38:22 +00:00
|
|
|
FUNC_Y,
|
|
|
|
FUNC_MAX,
|
2019-02-22 17:38:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
2022-01-28 18:36:10 +00:00
|
|
|
OpType op_type = OP_TYPE_SCALAR;
|
2020-09-05 12:46:12 +00:00
|
|
|
Function func = FUNC_SUM;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2022-01-28 18:36:10 +00:00
|
|
|
protected:
|
2019-02-22 17:38:58 +00:00
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2022-01-28 18:36:10 +00:00
|
|
|
void set_op_type(OpType p_op_type);
|
|
|
|
OpType get_op_type() const;
|
|
|
|
|
2019-06-26 13:08:25 +00:00
|
|
|
void set_function(Function p_func);
|
2019-02-22 17:38:58 +00:00
|
|
|
Function get_function() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2022-01-28 18:36:10 +00:00
|
|
|
VisualShaderNodeDerivativeFunc();
|
2019-02-22 17:38:58 +00:00
|
|
|
};
|
|
|
|
|
2022-01-28 18:36:10 +00:00
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeDerivativeFunc::OpType)
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeDerivativeFunc::Function)
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
/// FACEFORWARD
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
class VisualShaderNodeFaceForward : public VisualShaderNodeVectorBase {
|
|
|
|
GDCLASS(VisualShaderNodeFaceForward, VisualShaderNodeVectorBase);
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
virtual void set_op_type(OpType p_op_type) override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
VisualShaderNodeFaceForward();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
/// OUTER PRODUCT
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeOuterProduct : public VisualShaderNode {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeOuterProduct, VisualShaderNode);
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
VisualShaderNodeOuterProduct();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
/// STEP
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
class VisualShaderNodeStep : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeStep, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
|
|
|
enum OpType {
|
|
|
|
OP_TYPE_SCALAR,
|
2022-02-01 08:32:01 +00:00
|
|
|
OP_TYPE_VECTOR_2D,
|
|
|
|
OP_TYPE_VECTOR_2D_SCALAR,
|
|
|
|
OP_TYPE_VECTOR_3D,
|
|
|
|
OP_TYPE_VECTOR_3D_SCALAR,
|
2022-04-12 17:09:29 +00:00
|
|
|
OP_TYPE_VECTOR_4D,
|
|
|
|
OP_TYPE_VECTOR_4D_SCALAR,
|
2021-01-18 09:23:04 +00:00
|
|
|
OP_TYPE_MAX,
|
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
|
|
|
OpType op_type = OP_TYPE_SCALAR;
|
|
|
|
static void _bind_methods();
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_op_type(OpType p_op_type);
|
2021-01-18 09:23:04 +00:00
|
|
|
OpType get_op_type() const;
|
|
|
|
|
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
VisualShaderNodeStep();
|
2019-02-22 17:38:58 +00:00
|
|
|
};
|
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeStep::OpType)
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// SMOOTHSTEP
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
class VisualShaderNodeSmoothStep : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeSmoothStep, VisualShaderNode);
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
public:
|
2021-01-18 09:23:04 +00:00
|
|
|
enum OpType {
|
|
|
|
OP_TYPE_SCALAR,
|
2022-02-01 08:32:01 +00:00
|
|
|
OP_TYPE_VECTOR_2D,
|
|
|
|
OP_TYPE_VECTOR_2D_SCALAR,
|
|
|
|
OP_TYPE_VECTOR_3D,
|
|
|
|
OP_TYPE_VECTOR_3D_SCALAR,
|
2022-04-12 17:09:29 +00:00
|
|
|
OP_TYPE_VECTOR_4D,
|
|
|
|
OP_TYPE_VECTOR_4D_SCALAR,
|
2021-01-18 09:23:04 +00:00
|
|
|
OP_TYPE_MAX,
|
|
|
|
};
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
protected:
|
|
|
|
OpType op_type = OP_TYPE_SCALAR;
|
|
|
|
static void _bind_methods();
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_op_type(OpType p_op_type);
|
2021-01-18 09:23:04 +00:00
|
|
|
OpType get_op_type() const;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
VisualShaderNodeSmoothStep();
|
2019-02-22 17:38:58 +00:00
|
|
|
};
|
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeSmoothStep::OpType)
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// DISTANCE
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
class VisualShaderNodeVectorDistance : public VisualShaderNodeVectorBase {
|
|
|
|
GDCLASS(VisualShaderNodeVectorDistance, VisualShaderNodeVectorBase);
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
virtual void set_op_type(OpType p_op_type) override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
VisualShaderNodeVectorDistance();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
/// REFRACT
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2022-08-07 16:03:16 +00:00
|
|
|
class VisualShaderNodeVectorRefract : public VisualShaderNodeVectorBase {
|
|
|
|
GDCLASS(VisualShaderNodeVectorRefract, VisualShaderNodeVectorBase);
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2022-08-07 16:03:16 +00:00
|
|
|
virtual void set_op_type(OpType p_op_type) override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
|
|
|
VisualShaderNodeVectorRefract();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
/// MIX
|
2018-07-14 21:15:42 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
class VisualShaderNodeMix : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeMix, VisualShaderNode);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
2021-01-18 09:23:04 +00:00
|
|
|
enum OpType {
|
|
|
|
OP_TYPE_SCALAR,
|
2022-02-01 08:32:01 +00:00
|
|
|
OP_TYPE_VECTOR_2D,
|
|
|
|
OP_TYPE_VECTOR_2D_SCALAR,
|
|
|
|
OP_TYPE_VECTOR_3D,
|
|
|
|
OP_TYPE_VECTOR_3D_SCALAR,
|
2022-04-12 17:09:29 +00:00
|
|
|
OP_TYPE_VECTOR_4D,
|
|
|
|
OP_TYPE_VECTOR_4D_SCALAR,
|
2021-01-18 09:23:04 +00:00
|
|
|
OP_TYPE_MAX,
|
|
|
|
};
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
protected:
|
|
|
|
OpType op_type = OP_TYPE_SCALAR;
|
|
|
|
static void _bind_methods();
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_op_type(OpType p_op_type);
|
2021-01-18 09:23:04 +00:00
|
|
|
OpType get_op_type() const;
|
2019-08-03 15:12:33 +00:00
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2019-08-03 15:12:33 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-08-03 15:12:33 +00:00
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
VisualShaderNodeMix();
|
2019-08-03 15:12:33 +00:00
|
|
|
};
|
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeMix::OpType)
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// COMPOSE
|
2018-07-14 21:15:42 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
class VisualShaderNodeVectorCompose : public VisualShaderNodeVectorBase {
|
|
|
|
GDCLASS(VisualShaderNodeVectorCompose, VisualShaderNodeVectorBase);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
virtual void set_op_type(OpType p_op_type) override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2018-07-15 14:28:06 +00:00
|
|
|
VisualShaderNodeVectorCompose();
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2018-07-15 14:28:06 +00:00
|
|
|
class VisualShaderNodeTransformCompose : public VisualShaderNode {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeTransformCompose, VisualShaderNode);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2018-07-15 14:28:06 +00:00
|
|
|
VisualShaderNodeTransformCompose();
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// DECOMPOSE
|
2018-07-14 21:15:42 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
class VisualShaderNodeVectorDecompose : public VisualShaderNodeVectorBase {
|
|
|
|
GDCLASS(VisualShaderNodeVectorDecompose, VisualShaderNodeVectorBase);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
virtual void set_op_type(OpType p_op_type) override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2018-07-15 14:28:06 +00:00
|
|
|
VisualShaderNodeVectorDecompose();
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2018-07-15 14:28:06 +00:00
|
|
|
class VisualShaderNodeTransformDecompose : public VisualShaderNode {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeTransformDecompose, VisualShaderNode);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2018-07-15 14:28:06 +00:00
|
|
|
VisualShaderNodeTransformDecompose();
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// UNIFORMS
|
2018-07-14 21:15:42 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
2020-02-25 14:50:49 +00:00
|
|
|
class VisualShaderNodeFloatUniform : public VisualShaderNodeUniform {
|
|
|
|
GDCLASS(VisualShaderNodeFloatUniform, VisualShaderNodeUniform);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-02-06 12:11:03 +00:00
|
|
|
public:
|
|
|
|
enum Hint {
|
|
|
|
HINT_NONE,
|
|
|
|
HINT_RANGE,
|
|
|
|
HINT_RANGE_STEP,
|
2021-08-14 10:38:22 +00:00
|
|
|
HINT_MAX,
|
2020-02-06 12:11:03 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
2020-09-05 12:46:12 +00:00
|
|
|
Hint hint = HINT_NONE;
|
|
|
|
float hint_range_min = 0.0f;
|
|
|
|
float hint_range_max = 1.0f;
|
|
|
|
float hint_range_step = 0.1f;
|
|
|
|
bool default_value_enabled = false;
|
|
|
|
float default_value = 0.0f;
|
2020-02-06 12:11:03 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-09-21 11:32:59 +00:00
|
|
|
virtual bool is_show_prop_names() const override;
|
|
|
|
virtual bool is_use_prop_slots() const override;
|
|
|
|
|
2020-02-06 12:11:03 +00:00
|
|
|
void set_hint(Hint p_hint);
|
|
|
|
Hint get_hint() const;
|
|
|
|
|
|
|
|
void set_min(float p_value);
|
|
|
|
float get_min() const;
|
|
|
|
|
|
|
|
void set_max(float p_value);
|
|
|
|
float get_max() const;
|
|
|
|
|
|
|
|
void set_step(float p_value);
|
|
|
|
float get_step() const;
|
|
|
|
|
2020-07-27 11:33:27 +00:00
|
|
|
void set_default_value_enabled(bool p_enabled);
|
|
|
|
bool is_default_value_enabled() const;
|
|
|
|
|
|
|
|
void set_default_value(float p_value);
|
|
|
|
float get_default_value() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
bool is_qualifier_supported(Qualifier p_qual) const override;
|
2021-04-04 12:09:29 +00:00
|
|
|
bool is_convertible_to_constant() const override;
|
2020-05-05 08:25:48 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2020-02-06 12:11:03 +00:00
|
|
|
|
2020-02-25 14:50:49 +00:00
|
|
|
VisualShaderNodeFloatUniform();
|
|
|
|
};
|
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeFloatUniform::Hint)
|
|
|
|
|
|
|
|
class VisualShaderNodeIntUniform : public VisualShaderNodeUniform {
|
|
|
|
GDCLASS(VisualShaderNodeIntUniform, VisualShaderNodeUniform);
|
|
|
|
|
|
|
|
public:
|
|
|
|
enum Hint {
|
|
|
|
HINT_NONE,
|
|
|
|
HINT_RANGE,
|
|
|
|
HINT_RANGE_STEP,
|
2021-08-14 10:38:22 +00:00
|
|
|
HINT_MAX,
|
2020-02-25 14:50:49 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
2020-09-05 12:46:12 +00:00
|
|
|
Hint hint = HINT_NONE;
|
|
|
|
int hint_range_min = 0;
|
|
|
|
int hint_range_max = 100;
|
|
|
|
int hint_range_step = 1;
|
|
|
|
bool default_value_enabled = false;
|
|
|
|
int default_value = 0;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
2020-09-21 11:32:59 +00:00
|
|
|
virtual bool is_show_prop_names() const override;
|
|
|
|
virtual bool is_use_prop_slots() const override;
|
|
|
|
|
2020-02-25 14:50:49 +00:00
|
|
|
void set_hint(Hint p_hint);
|
|
|
|
Hint get_hint() const;
|
|
|
|
|
|
|
|
void set_min(int p_value);
|
|
|
|
int get_min() const;
|
|
|
|
|
|
|
|
void set_max(int p_value);
|
|
|
|
int get_max() const;
|
|
|
|
|
|
|
|
void set_step(int p_value);
|
|
|
|
int get_step() const;
|
|
|
|
|
2020-07-27 11:33:27 +00:00
|
|
|
void set_default_value_enabled(bool p_enabled);
|
|
|
|
bool is_default_value_enabled() const;
|
|
|
|
|
|
|
|
void set_default_value(int p_value);
|
|
|
|
int get_default_value() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
bool is_qualifier_supported(Qualifier p_qual) const override;
|
2021-04-04 12:09:29 +00:00
|
|
|
bool is_convertible_to_constant() const override;
|
2020-05-05 08:25:48 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2020-02-25 14:50:49 +00:00
|
|
|
|
|
|
|
VisualShaderNodeIntUniform();
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
2020-02-25 14:50:49 +00:00
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeIntUniform::Hint)
|
2020-02-06 12:11:03 +00:00
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeBooleanUniform : public VisualShaderNodeUniform {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeBooleanUniform, VisualShaderNodeUniform);
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-27 11:33:27 +00:00
|
|
|
private:
|
2020-09-05 12:46:12 +00:00
|
|
|
bool default_value_enabled = false;
|
|
|
|
bool default_value = false;
|
2020-07-27 11:33:27 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-02-22 17:38:58 +00:00
|
|
|
|
2020-09-21 11:32:59 +00:00
|
|
|
virtual bool is_show_prop_names() const override;
|
|
|
|
virtual bool is_use_prop_slots() const override;
|
|
|
|
|
2020-07-27 11:33:27 +00:00
|
|
|
void set_default_value_enabled(bool p_enabled);
|
|
|
|
bool is_default_value_enabled() const;
|
|
|
|
|
|
|
|
void set_default_value(bool p_value);
|
|
|
|
bool get_default_value() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
bool is_qualifier_supported(Qualifier p_qual) const override;
|
2021-04-04 12:09:29 +00:00
|
|
|
bool is_convertible_to_constant() const override;
|
2020-05-05 08:25:48 +00:00
|
|
|
|
2020-07-27 11:33:27 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
VisualShaderNodeBooleanUniform();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
class VisualShaderNodeColorUniform : public VisualShaderNodeUniform {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeColorUniform, VisualShaderNodeUniform);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-27 11:33:27 +00:00
|
|
|
private:
|
2020-09-05 12:46:12 +00:00
|
|
|
bool default_value_enabled = false;
|
|
|
|
Color default_value = Color(1.0, 1.0, 1.0, 1.0);
|
2020-07-27 11:33:27 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2022-05-07 05:40:19 +00:00
|
|
|
bool is_output_port_expandable(int p_port) const override;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-09-21 11:32:59 +00:00
|
|
|
virtual bool is_show_prop_names() const override;
|
|
|
|
|
2020-07-27 11:33:27 +00:00
|
|
|
void set_default_value_enabled(bool p_enabled);
|
|
|
|
bool is_default_value_enabled() const;
|
|
|
|
|
|
|
|
void set_default_value(const Color &p_value);
|
|
|
|
Color get_default_value() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
bool is_qualifier_supported(Qualifier p_qual) const override;
|
2021-04-04 12:09:29 +00:00
|
|
|
bool is_convertible_to_constant() const override;
|
2020-05-05 08:25:48 +00:00
|
|
|
|
2020-07-27 11:33:27 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
VisualShaderNodeColorUniform();
|
|
|
|
};
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
2022-02-01 08:32:01 +00:00
|
|
|
class VisualShaderNodeVec2Uniform : public VisualShaderNodeUniform {
|
|
|
|
GDCLASS(VisualShaderNodeVec2Uniform, VisualShaderNodeUniform);
|
|
|
|
|
|
|
|
private:
|
|
|
|
bool default_value_enabled = false;
|
|
|
|
Vector2 default_value;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override;
|
|
|
|
|
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
|
|
|
virtual String 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 = false) const override;
|
|
|
|
|
|
|
|
virtual bool is_show_prop_names() const override;
|
|
|
|
virtual bool is_use_prop_slots() const override;
|
|
|
|
|
|
|
|
void set_default_value_enabled(bool p_enabled);
|
|
|
|
bool is_default_value_enabled() const;
|
|
|
|
|
|
|
|
void set_default_value(const Vector2 &p_value);
|
|
|
|
Vector2 get_default_value() const;
|
|
|
|
|
|
|
|
bool is_qualifier_supported(Qualifier p_qual) const override;
|
|
|
|
bool is_convertible_to_constant() const override;
|
|
|
|
|
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
|
|
|
|
VisualShaderNodeVec2Uniform();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
class VisualShaderNodeVec3Uniform : public VisualShaderNodeUniform {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeVec3Uniform, VisualShaderNodeUniform);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-27 11:33:27 +00:00
|
|
|
private:
|
2020-09-05 12:46:12 +00:00
|
|
|
bool default_value_enabled = false;
|
2020-07-27 11:33:27 +00:00
|
|
|
Vector3 default_value;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-09-21 11:32:59 +00:00
|
|
|
virtual bool is_show_prop_names() const override;
|
|
|
|
virtual bool is_use_prop_slots() const override;
|
|
|
|
|
2020-07-27 11:33:27 +00:00
|
|
|
void set_default_value_enabled(bool p_enabled);
|
|
|
|
bool is_default_value_enabled() const;
|
|
|
|
|
|
|
|
void set_default_value(const Vector3 &p_value);
|
|
|
|
Vector3 get_default_value() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
bool is_qualifier_supported(Qualifier p_qual) const override;
|
2021-04-04 12:09:29 +00:00
|
|
|
bool is_convertible_to_constant() const override;
|
2020-05-05 08:25:48 +00:00
|
|
|
|
2020-07-27 11:33:27 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
VisualShaderNodeVec3Uniform();
|
|
|
|
};
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
|
2022-04-12 17:09:29 +00:00
|
|
|
class VisualShaderNodeVec4Uniform : public VisualShaderNodeUniform {
|
|
|
|
GDCLASS(VisualShaderNodeVec4Uniform, VisualShaderNodeUniform);
|
|
|
|
|
|
|
|
private:
|
|
|
|
bool default_value_enabled = false;
|
|
|
|
Quaternion default_value;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override;
|
|
|
|
|
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
|
|
|
virtual String 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 = false) const override;
|
|
|
|
|
|
|
|
virtual bool is_show_prop_names() const override;
|
|
|
|
virtual bool is_use_prop_slots() const override;
|
|
|
|
|
|
|
|
void set_default_value_enabled(bool p_enabled);
|
|
|
|
bool is_default_value_enabled() const;
|
|
|
|
|
|
|
|
void set_default_value(const Quaternion &p_value);
|
|
|
|
Quaternion get_default_value() const;
|
|
|
|
|
|
|
|
bool is_qualifier_supported(Qualifier p_qual) const override;
|
|
|
|
bool is_convertible_to_constant() const override;
|
|
|
|
|
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
|
|
|
|
VisualShaderNodeVec4Uniform();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
class VisualShaderNodeTransformUniform : public VisualShaderNodeUniform {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeTransformUniform, VisualShaderNodeUniform);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-27 11:33:27 +00:00
|
|
|
private:
|
2020-09-05 12:46:12 +00:00
|
|
|
bool default_value_enabled = false;
|
2020-10-17 05:08:21 +00:00
|
|
|
Transform3D default_value = Transform3D(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
|
2020-07-27 11:33:27 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-09-21 11:32:59 +00:00
|
|
|
virtual bool is_show_prop_names() const override;
|
|
|
|
virtual bool is_use_prop_slots() const override;
|
|
|
|
|
2020-07-27 11:33:27 +00:00
|
|
|
void set_default_value_enabled(bool p_enabled);
|
|
|
|
bool is_default_value_enabled() const;
|
|
|
|
|
2020-10-17 05:08:21 +00:00
|
|
|
void set_default_value(const Transform3D &p_value);
|
|
|
|
Transform3D get_default_value() const;
|
2020-07-27 11:33:27 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
bool is_qualifier_supported(Qualifier p_qual) const override;
|
2021-04-04 12:09:29 +00:00
|
|
|
bool is_convertible_to_constant() const override;
|
2020-05-05 08:25:48 +00:00
|
|
|
|
2020-07-27 11:33:27 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
VisualShaderNodeTransformUniform();
|
|
|
|
};
|
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
class VisualShaderNodeTextureUniform : public VisualShaderNodeUniform {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeTextureUniform, VisualShaderNodeUniform);
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
public:
|
|
|
|
enum TextureType {
|
|
|
|
TYPE_DATA,
|
|
|
|
TYPE_COLOR,
|
2020-12-23 09:34:26 +00:00
|
|
|
TYPE_NORMAL_MAP,
|
2021-12-09 19:29:06 +00:00
|
|
|
TYPE_ANISOTROPY,
|
2021-08-14 10:38:22 +00:00
|
|
|
TYPE_MAX,
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
enum ColorDefault {
|
|
|
|
COLOR_DEFAULT_WHITE,
|
2021-08-14 10:38:22 +00:00
|
|
|
COLOR_DEFAULT_BLACK,
|
2021-08-14 16:29:52 +00:00
|
|
|
COLOR_DEFAULT_TRANSPARENT,
|
2021-08-14 10:38:22 +00:00
|
|
|
COLOR_DEFAULT_MAX,
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
2021-12-16 08:41:29 +00:00
|
|
|
enum TextureFilter {
|
|
|
|
FILTER_DEFAULT,
|
|
|
|
FILTER_NEAREST,
|
|
|
|
FILTER_LINEAR,
|
|
|
|
FILTER_NEAREST_MIPMAP,
|
|
|
|
FILTER_LINEAR_MIPMAP,
|
|
|
|
FILTER_NEAREST_MIPMAP_ANISOTROPIC,
|
|
|
|
FILTER_LINEAR_MIPMAP_ANISOTROPIC,
|
|
|
|
FILTER_MAX,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum TextureRepeat {
|
|
|
|
REPEAT_DEFAULT,
|
|
|
|
REPEAT_ENABLED,
|
|
|
|
REPEAT_DISABLED,
|
|
|
|
REPEAT_MAX,
|
|
|
|
};
|
|
|
|
|
2019-10-09 08:29:23 +00:00
|
|
|
protected:
|
2020-09-05 12:46:12 +00:00
|
|
|
TextureType texture_type = TYPE_DATA;
|
|
|
|
ColorDefault color_default = COLOR_DEFAULT_WHITE;
|
2021-12-16 08:41:29 +00:00
|
|
|
TextureFilter texture_filter = FILTER_DEFAULT;
|
|
|
|
TextureRepeat texture_repeat = REPEAT_DEFAULT;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2022-05-13 13:04:37 +00:00
|
|
|
virtual HashMap<StringName, String> get_editable_properties_names() const override;
|
2021-12-16 08:41:29 +00:00
|
|
|
virtual bool is_show_prop_names() const override;
|
2020-07-26 01:04:07 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
Vector<StringName> get_editable_properties() const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
void set_texture_type(TextureType p_type);
|
|
|
|
TextureType get_texture_type() const;
|
|
|
|
|
|
|
|
void set_color_default(ColorDefault p_default);
|
|
|
|
ColorDefault get_color_default() const;
|
|
|
|
|
2021-12-16 08:41:29 +00:00
|
|
|
void set_texture_filter(TextureFilter p_filter);
|
|
|
|
TextureFilter get_texture_filter() const;
|
|
|
|
|
|
|
|
void set_texture_repeat(TextureRepeat p_repeat);
|
|
|
|
TextureRepeat get_texture_repeat() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
bool is_qualifier_supported(Qualifier p_qual) const override;
|
2021-04-04 12:09:29 +00:00
|
|
|
bool is_convertible_to_constant() const override;
|
2020-05-05 08:25:48 +00:00
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
VisualShaderNodeTextureUniform();
|
|
|
|
};
|
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeTextureUniform::TextureType)
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeTextureUniform::ColorDefault)
|
2021-12-16 08:41:29 +00:00
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeTextureUniform::TextureFilter)
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeTextureUniform::TextureRepeat)
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2019-02-22 17:38:58 +00:00
|
|
|
///////////////////////////////////////
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2019-07-12 09:14:34 +00:00
|
|
|
class VisualShaderNodeTextureUniformTriplanar : public VisualShaderNodeTextureUniform {
|
|
|
|
GDCLASS(VisualShaderNodeTextureUniformTriplanar, VisualShaderNodeTextureUniform);
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-07-12 09:14:34 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-07-12 09:14:34 +00:00
|
|
|
|
2022-04-22 17:31:23 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
|
|
|
|
2022-01-22 08:09:16 +00:00
|
|
|
virtual bool is_input_port_default(int p_port, Shader::Mode p_mode) const override;
|
2019-10-03 07:40:26 +00:00
|
|
|
|
2022-02-07 05:46:51 +00:00
|
|
|
virtual String generate_global_per_node(Shader::Mode p_mode, int p_id) const override;
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String generate_global_per_func(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-07-12 09:14:34 +00:00
|
|
|
|
|
|
|
VisualShaderNodeTextureUniformTriplanar();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2020-02-18 11:45:23 +00:00
|
|
|
class VisualShaderNodeTexture2DArrayUniform : public VisualShaderNodeTextureUniform {
|
|
|
|
GDCLASS(VisualShaderNodeTexture2DArrayUniform, VisualShaderNodeTextureUniform);
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2020-02-18 11:45:23 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2020-02-18 11:45:23 +00:00
|
|
|
|
|
|
|
VisualShaderNodeTexture2DArrayUniform();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2020-09-10 03:47:09 +00:00
|
|
|
class VisualShaderNodeTexture3DUniform : public VisualShaderNodeTextureUniform {
|
|
|
|
GDCLASS(VisualShaderNodeTexture3DUniform, VisualShaderNodeTextureUniform);
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2020-09-10 03:47:09 +00:00
|
|
|
|
|
|
|
VisualShaderNodeTexture3DUniform();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
2019-06-11 18:43:37 +00:00
|
|
|
class VisualShaderNodeCubemapUniform : public VisualShaderNodeTextureUniform {
|
|
|
|
GDCLASS(VisualShaderNodeCubemapUniform, VisualShaderNodeTextureUniform);
|
2018-07-14 21:15:42 +00:00
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2018-07-14 21:15:42 +00:00
|
|
|
|
2019-06-11 18:43:37 +00:00
|
|
|
VisualShaderNodeCubemapUniform();
|
2018-07-14 21:15:42 +00:00
|
|
|
};
|
|
|
|
|
2019-04-13 12:24:04 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// IF
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeIf : public VisualShaderNode {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeIf, VisualShaderNode);
|
|
|
|
|
2019-04-13 12:24:04 +00:00
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-04-13 12:24:04 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-04-13 12:24:04 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-04-13 12:24:04 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-04-13 12:24:04 +00:00
|
|
|
|
|
|
|
VisualShaderNodeIf();
|
|
|
|
};
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
/// SWITCH
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeSwitch : public VisualShaderNode {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeSwitch, VisualShaderNode);
|
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
public:
|
|
|
|
enum OpType {
|
|
|
|
OP_TYPE_FLOAT,
|
|
|
|
OP_TYPE_INT,
|
2022-02-01 08:32:01 +00:00
|
|
|
OP_TYPE_VECTOR_2D,
|
|
|
|
OP_TYPE_VECTOR_3D,
|
2022-04-12 17:09:29 +00:00
|
|
|
OP_TYPE_VECTOR_4D,
|
2021-01-18 09:23:04 +00:00
|
|
|
OP_TYPE_BOOLEAN,
|
|
|
|
OP_TYPE_TRANSFORM,
|
|
|
|
OP_TYPE_MAX,
|
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
|
|
|
OpType op_type = OP_TYPE_FLOAT;
|
|
|
|
|
|
|
|
static void _bind_methods();
|
|
|
|
|
2019-04-13 12:24:04 +00:00
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-04-13 12:24:04 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-04-13 12:24:04 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-04-13 12:24:04 +00:00
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_op_type(OpType p_op_type);
|
2021-01-18 09:23:04 +00:00
|
|
|
OpType get_op_type() const;
|
|
|
|
|
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-04-13 12:24:04 +00:00
|
|
|
|
|
|
|
VisualShaderNodeSwitch();
|
|
|
|
};
|
|
|
|
|
2021-01-18 09:23:04 +00:00
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeSwitch::OpType)
|
2019-09-03 11:46:31 +00:00
|
|
|
|
2019-05-19 10:07:00 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// FRESNEL
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeFresnel : public VisualShaderNode {
|
2019-03-19 18:35:57 +00:00
|
|
|
GDCLASS(VisualShaderNodeFresnel, VisualShaderNode);
|
|
|
|
|
2019-05-19 10:07:00 +00:00
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-05-19 10:07:00 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-05-19 10:07:00 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-05-19 10:07:00 +00:00
|
|
|
|
2022-01-22 08:09:16 +00:00
|
|
|
virtual bool is_input_port_default(int p_port, Shader::Mode p_mode) const override;
|
2020-07-27 06:18:37 +00:00
|
|
|
virtual bool is_generate_input_var(int p_port) const override;
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-05-19 10:07:00 +00:00
|
|
|
|
|
|
|
VisualShaderNodeFresnel();
|
|
|
|
};
|
|
|
|
|
2019-07-08 07:05:33 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// Is
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeIs : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeIs, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
|
|
|
enum Function {
|
|
|
|
FUNC_IS_INF,
|
|
|
|
FUNC_IS_NAN,
|
2021-08-14 10:38:22 +00:00
|
|
|
FUNC_MAX,
|
2019-07-08 07:05:33 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
2020-09-05 12:46:12 +00:00
|
|
|
Function func = FUNC_IS_INF;
|
2019-07-08 07:05:33 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-07-08 07:05:33 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-07-08 07:05:33 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-07-08 07:05:33 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-07-08 07:05:33 +00:00
|
|
|
|
|
|
|
void set_function(Function p_func);
|
|
|
|
Function get_function() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2019-07-08 07:05:33 +00:00
|
|
|
|
|
|
|
VisualShaderNodeIs();
|
|
|
|
};
|
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeIs::Function)
|
|
|
|
|
|
|
|
///////////////////////////////////////
|
|
|
|
/// Compare
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeCompare : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeCompare, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
2020-01-23 07:31:45 +00:00
|
|
|
enum ComparisonType {
|
2019-07-08 07:05:33 +00:00
|
|
|
CTYPE_SCALAR,
|
2020-02-25 14:50:49 +00:00
|
|
|
CTYPE_SCALAR_INT,
|
2022-02-01 08:32:01 +00:00
|
|
|
CTYPE_VECTOR_2D,
|
|
|
|
CTYPE_VECTOR_3D,
|
2022-04-12 17:09:29 +00:00
|
|
|
CTYPE_VECTOR_4D,
|
2019-07-08 07:05:33 +00:00
|
|
|
CTYPE_BOOLEAN,
|
2020-02-25 14:50:49 +00:00
|
|
|
CTYPE_TRANSFORM,
|
2021-08-14 10:38:22 +00:00
|
|
|
CTYPE_MAX,
|
2019-07-08 07:05:33 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
enum Function {
|
|
|
|
FUNC_EQUAL,
|
|
|
|
FUNC_NOT_EQUAL,
|
|
|
|
FUNC_GREATER_THAN,
|
|
|
|
FUNC_GREATER_THAN_EQUAL,
|
|
|
|
FUNC_LESS_THAN,
|
|
|
|
FUNC_LESS_THAN_EQUAL,
|
2021-08-14 10:38:22 +00:00
|
|
|
FUNC_MAX,
|
2019-07-08 07:05:33 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
enum Condition {
|
|
|
|
COND_ALL,
|
|
|
|
COND_ANY,
|
2021-08-14 10:38:22 +00:00
|
|
|
COND_MAX,
|
2019-07-08 07:05:33 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
2021-08-14 10:38:22 +00:00
|
|
|
ComparisonType comparison_type = CTYPE_SCALAR;
|
2020-09-05 12:46:12 +00:00
|
|
|
Function func = FUNC_EQUAL;
|
|
|
|
Condition condition = COND_ALL;
|
2019-07-08 07:05:33 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual String get_caption() const override;
|
2019-07-08 07:05:33 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2019-07-08 07:05:33 +00:00
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2019-07-08 07:05:33 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2019-07-08 07:05:33 +00:00
|
|
|
|
2020-01-23 07:31:45 +00:00
|
|
|
void set_comparison_type(ComparisonType p_type);
|
|
|
|
ComparisonType get_comparison_type() const;
|
2019-07-08 07:05:33 +00:00
|
|
|
|
|
|
|
void set_function(Function p_func);
|
|
|
|
Function get_function() const;
|
|
|
|
|
2019-07-23 07:14:31 +00:00
|
|
|
void set_condition(Condition p_cond);
|
2019-07-08 07:05:33 +00:00
|
|
|
Condition get_condition() const;
|
|
|
|
|
2020-07-10 10:34:39 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
virtual String get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const override;
|
2019-07-08 07:05:33 +00:00
|
|
|
|
|
|
|
VisualShaderNodeCompare();
|
|
|
|
};
|
|
|
|
|
2020-01-23 07:31:45 +00:00
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeCompare::ComparisonType)
|
2019-07-08 07:05:33 +00:00
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeCompare::Function)
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeCompare::Condition)
|
|
|
|
|
2020-02-14 20:09:53 +00:00
|
|
|
class VisualShaderNodeMultiplyAdd : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeMultiplyAdd, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
2020-09-15 08:06:18 +00:00
|
|
|
enum OpType {
|
|
|
|
OP_TYPE_SCALAR,
|
2022-02-01 08:32:01 +00:00
|
|
|
OP_TYPE_VECTOR_2D,
|
|
|
|
OP_TYPE_VECTOR_3D,
|
2022-04-12 17:09:29 +00:00
|
|
|
OP_TYPE_VECTOR_4D,
|
2020-09-15 08:06:18 +00:00
|
|
|
OP_TYPE_MAX,
|
2020-02-14 20:09:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
2020-09-15 08:06:18 +00:00
|
|
|
OpType op_type = OP_TYPE_SCALAR;
|
2020-02-14 20:09:53 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
2020-07-10 20:25:37 +00:00
|
|
|
virtual String get_caption() const override;
|
2020-02-14 20:09:53 +00:00
|
|
|
|
2020-07-10 20:25:37 +00:00
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
2020-02-14 20:09:53 +00:00
|
|
|
|
2020-07-10 20:25:37 +00:00
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
2020-02-14 20:09:53 +00:00
|
|
|
|
2021-05-20 10:07:26 +00:00
|
|
|
virtual String 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 = false) const override;
|
2020-02-14 20:09:53 +00:00
|
|
|
|
2021-08-14 10:38:22 +00:00
|
|
|
void set_op_type(OpType p_op_type);
|
2020-09-15 08:06:18 +00:00
|
|
|
OpType get_op_type() const;
|
2020-02-14 20:09:53 +00:00
|
|
|
|
2020-07-10 20:25:37 +00:00
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
2020-02-14 20:09:53 +00:00
|
|
|
|
|
|
|
VisualShaderNodeMultiplyAdd();
|
|
|
|
};
|
|
|
|
|
2020-09-15 08:06:18 +00:00
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeMultiplyAdd::OpType)
|
2020-02-14 20:09:53 +00:00
|
|
|
|
2021-05-27 19:17:58 +00:00
|
|
|
class VisualShaderNodeBillboard : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeBillboard, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
|
|
|
enum BillboardType {
|
|
|
|
BILLBOARD_TYPE_DISABLED,
|
|
|
|
BILLBOARD_TYPE_ENABLED,
|
|
|
|
BILLBOARD_TYPE_FIXED_Y,
|
|
|
|
BILLBOARD_TYPE_PARTICLES,
|
|
|
|
BILLBOARD_TYPE_MAX,
|
|
|
|
};
|
|
|
|
|
|
|
|
protected:
|
|
|
|
BillboardType billboard_type = BILLBOARD_TYPE_ENABLED;
|
|
|
|
bool keep_scale = false;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
static void _bind_methods();
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override;
|
|
|
|
|
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual String 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 = false) const override;
|
|
|
|
|
|
|
|
virtual bool is_show_prop_names() const override;
|
|
|
|
|
|
|
|
void set_billboard_type(BillboardType p_billboard_type);
|
|
|
|
BillboardType get_billboard_type() const;
|
|
|
|
|
|
|
|
void set_keep_scale_enabled(bool p_enabled);
|
|
|
|
bool is_keep_scale_enabled() const;
|
|
|
|
|
|
|
|
virtual Vector<StringName> get_editable_properties() const override;
|
|
|
|
|
|
|
|
VisualShaderNodeBillboard();
|
|
|
|
};
|
|
|
|
|
|
|
|
VARIANT_ENUM_CAST(VisualShaderNodeBillboard::BillboardType)
|
|
|
|
|
2022-08-10 22:39:11 +00:00
|
|
|
///////////////////////////////////////
|
|
|
|
/// DistanceFade
|
|
|
|
///////////////////////////////////////
|
|
|
|
|
|
|
|
class VisualShaderNodeDistanceFade : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeDistanceFade, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override;
|
|
|
|
|
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual String 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 = false) const override;
|
|
|
|
|
|
|
|
VisualShaderNodeDistanceFade();
|
|
|
|
};
|
|
|
|
|
|
|
|
class VisualShaderNodeProximityFade : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeProximityFade, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override;
|
|
|
|
|
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual String 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 = false) const override;
|
|
|
|
|
|
|
|
VisualShaderNodeProximityFade();
|
|
|
|
};
|
|
|
|
|
|
|
|
class VisualShaderNodeRandomRange : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeRandomRange, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override;
|
|
|
|
|
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual String generate_global_per_node(Shader::Mode p_mode, int p_id) const override;
|
|
|
|
virtual String 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 = false) const override;
|
|
|
|
|
|
|
|
VisualShaderNodeRandomRange();
|
|
|
|
};
|
|
|
|
|
|
|
|
class VisualShaderNodeRemap : public VisualShaderNode {
|
|
|
|
GDCLASS(VisualShaderNodeRemap, VisualShaderNode);
|
|
|
|
|
|
|
|
public:
|
|
|
|
virtual String get_caption() const override;
|
|
|
|
|
|
|
|
virtual int get_input_port_count() const override;
|
|
|
|
virtual PortType get_input_port_type(int p_port) const override;
|
|
|
|
virtual String get_input_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual int get_output_port_count() const override;
|
|
|
|
virtual PortType get_output_port_type(int p_port) const override;
|
|
|
|
virtual String get_output_port_name(int p_port) const override;
|
|
|
|
|
|
|
|
virtual String 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 = false) const override;
|
|
|
|
|
|
|
|
VisualShaderNodeRemap();
|
|
|
|
};
|
|
|
|
|
2018-07-14 21:15:42 +00:00
|
|
|
#endif // VISUAL_SHADER_NODES_H
|