2018-08-29 22:38:13 +02:00
/*************************************************************************/
/* visual_shader_nodes.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
2020-01-01 11:16:22 +01:00
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
2018-08-29 22:38:13 +02: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 23:15:42 +02:00
# ifndef VISUAL_SHADER_NODES_H
# define VISUAL_SHADER_NODES_H
# include "scene/resources/visual_shader.h"
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
/// CONSTANTS
///////////////////////////////////////
2018-07-14 23:15:42 +02:00
2020-02-25 15:50:49 +01:00
class VisualShaderNodeFloatConstant : public VisualShaderNode {
GDCLASS ( VisualShaderNodeFloatConstant , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
float constant ;
protected :
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
void set_constant ( float p_value ) ;
float get_constant ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
2020-02-25 15:50:49 +01:00
VisualShaderNodeFloatConstant ( ) ;
} ;
///////////////////////////////////////
class VisualShaderNodeIntConstant : public VisualShaderNode {
GDCLASS ( VisualShaderNodeIntConstant , VisualShaderNode ) ;
int constant ;
protected :
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
void set_constant ( int p_value ) ;
int get_constant ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeIntConstant ( ) ;
2018-07-14 23:15:42 +02:00
} ;
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
class VisualShaderNodeBooleanConstant : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeBooleanConstant , VisualShaderNode ) ;
2019-02-22 18:38:58 +01:00
bool constant ;
protected :
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
void set_constant ( bool p_value ) ;
bool get_constant ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeBooleanConstant ( ) ;
} ;
///////////////////////////////////////
2018-07-14 23:15:42 +02:00
class VisualShaderNodeColorConstant : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeColorConstant , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
Color constant ;
protected :
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
void set_constant ( Color p_value ) ;
Color get_constant ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeColorConstant ( ) ;
} ;
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
2018-07-14 23:15:42 +02:00
class VisualShaderNodeVec3Constant : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeVec3Constant , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
Vector3 constant ;
protected :
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
void set_constant ( Vector3 p_value ) ;
Vector3 get_constant ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeVec3Constant ( ) ;
} ;
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
2018-07-14 23:15:42 +02:00
class VisualShaderNodeTransformConstant : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeTransformConstant , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
Transform constant ;
protected :
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
void set_constant ( Transform p_value ) ;
Transform get_constant ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeTransformConstant ( ) ;
} ;
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
/// TEXTURES
///////////////////////////////////////
2018-07-14 23:15:42 +02:00
class VisualShaderNodeTexture : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeTexture , VisualShaderNode ) ;
2019-06-11 20:43:37 +02:00
Ref < Texture2D > texture ;
2018-07-14 23:15:42 +02:00
public :
enum Source {
SOURCE_TEXTURE ,
SOURCE_SCREEN ,
SOURCE_2D_TEXTURE ,
2019-07-05 10:48:31 +02:00
SOURCE_2D_NORMAL ,
2019-10-01 10:51:50 +02:00
SOURCE_DEPTH ,
SOURCE_PORT ,
2018-07-14 23:15:42 +02:00
} ;
enum TextureType {
TYPE_DATA ,
TYPE_COLOR ,
TYPE_NORMALMAP
} ;
private :
Source source ;
TextureType texture_type ;
protected :
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-10-03 09:40:26 +02:00
virtual String get_input_port_default_hint ( int p_port ) const ;
2018-07-14 23:15:42 +02:00
virtual Vector < VisualShader : : DefaultTextureParam > get_default_texture_parameters ( VisualShader : : Type p_type , int p_id ) const ;
virtual String generate_global ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
void set_source ( Source p_source ) ;
Source get_source ( ) const ;
2019-06-11 20:43:37 +02:00
void set_texture ( Ref < Texture2D > p_value ) ;
Ref < Texture2D > get_texture ( ) const ;
2018-07-14 23:15:42 +02:00
void set_texture_type ( TextureType p_type ) ;
TextureType get_texture_type ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
virtual String get_warning ( Shader : : Mode p_mode , VisualShader : : Type p_type ) const ;
VisualShaderNodeTexture ( ) ;
} ;
VARIANT_ENUM_CAST ( VisualShaderNodeTexture : : TextureType )
VARIANT_ENUM_CAST ( VisualShaderNodeTexture : : Source )
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
2018-07-14 23:15:42 +02:00
2019-06-11 20:43:37 +02:00
class VisualShaderNodeCubemap : public VisualShaderNode {
GDCLASS ( VisualShaderNodeCubemap , VisualShaderNode ) ;
Ref < Cubemap > cube_map ;
2018-07-14 23:15:42 +02:00
public :
2019-10-11 09:26:57 +02:00
enum Source {
SOURCE_TEXTURE ,
SOURCE_PORT
} ;
2018-07-14 23:15:42 +02:00
enum TextureType {
TYPE_DATA ,
TYPE_COLOR ,
TYPE_NORMALMAP
} ;
private :
2019-10-11 09:26:57 +02:00
Source source ;
2018-07-14 23:15:42 +02:00
TextureType texture_type ;
protected :
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
2019-10-09 10:29:23 +02:00
virtual String get_input_port_default_hint ( int p_port ) const ;
2018-07-14 23:15:42 +02:00
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
virtual Vector < VisualShader : : DefaultTextureParam > get_default_texture_parameters ( VisualShader : : Type p_type , int p_id ) const ;
virtual String generate_global ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
2019-10-11 09:26:57 +02:00
void set_source ( Source p_source ) ;
Source get_source ( ) const ;
2019-06-11 20:43:37 +02:00
void set_cube_map ( Ref < Cubemap > p_value ) ;
Ref < Cubemap > get_cube_map ( ) const ;
2018-07-14 23:15:42 +02:00
void set_texture_type ( TextureType p_type ) ;
TextureType get_texture_type ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
2019-06-11 20:43:37 +02:00
VisualShaderNodeCubemap ( ) ;
2018-07-14 23:15:42 +02:00
} ;
2019-06-11 20:43:37 +02:00
VARIANT_ENUM_CAST ( VisualShaderNodeCubemap : : TextureType )
VARIANT_ENUM_CAST ( VisualShaderNodeCubemap : : Source )
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
/// OPS
2018-07-14 23:15:42 +02:00
///////////////////////////////////////
2020-02-25 15:50:49 +01:00
class VisualShaderNodeFloatOp : public VisualShaderNode {
GDCLASS ( VisualShaderNodeFloatOp , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
public :
enum Operator {
OP_ADD ,
OP_SUB ,
OP_MUL ,
OP_DIV ,
OP_MOD ,
OP_POW ,
OP_MAX ,
OP_MIN ,
2019-02-22 18:38:58 +01:00
OP_ATAN2 ,
OP_STEP
2018-07-14 23:15:42 +02:00
} ;
protected :
Operator op ;
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
void set_operator ( Operator p_op ) ;
Operator get_operator ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
2020-02-25 15:50:49 +01:00
VisualShaderNodeFloatOp ( ) ;
2018-07-14 23:15:42 +02:00
} ;
2020-02-25 15:50:49 +01: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 ,
} ;
protected :
Operator op ;
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
void set_operator ( Operator p_op ) ;
Operator get_operator ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeIntOp ( ) ;
} ;
VARIANT_ENUM_CAST ( VisualShaderNodeIntOp : : Operator )
2018-07-14 23:15:42 +02:00
class VisualShaderNodeVectorOp : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeVectorOp , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
public :
enum Operator {
OP_ADD ,
OP_SUB ,
OP_MUL ,
OP_DIV ,
OP_MOD ,
OP_POW ,
OP_MAX ,
OP_MIN ,
2019-02-22 18:38:58 +01:00
OP_CROSS ,
OP_ATAN2 ,
OP_REFLECT ,
OP_STEP
2018-07-14 23:15:42 +02:00
} ;
protected :
Operator op ;
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
void set_operator ( Operator p_op ) ;
Operator get_operator ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeVectorOp ( ) ;
} ;
VARIANT_ENUM_CAST ( VisualShaderNodeVectorOp : : Operator )
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
2018-07-14 23:15:42 +02:00
class VisualShaderNodeColorOp : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeColorOp , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
public :
enum Operator {
OP_SCREEN ,
OP_DIFFERENCE ,
OP_DARKEN ,
OP_LIGHTEN ,
OP_OVERLAY ,
OP_DODGE ,
OP_BURN ,
OP_SOFT_LIGHT ,
2019-02-22 18:38:58 +01:00
OP_HARD_LIGHT
2018-07-14 23:15:42 +02:00
} ;
protected :
Operator op ;
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
void set_operator ( Operator p_op ) ;
Operator get_operator ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeColorOp ( ) ;
} ;
VARIANT_ENUM_CAST ( VisualShaderNodeColorOp : : Operator )
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
/// TRANSFORM-TRANSFORM MULTIPLICATION
///////////////////////////////////////
2018-07-14 23:15:42 +02:00
class VisualShaderNodeTransformMult : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeTransformMult , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
public :
enum Operator {
OP_AxB ,
OP_BxA ,
2019-02-22 18:38:58 +01:00
OP_AxB_COMP ,
OP_BxA_COMP
2018-07-14 23:15:42 +02:00
} ;
protected :
Operator op ;
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
void set_operator ( Operator p_op ) ;
Operator get_operator ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeTransformMult ( ) ;
} ;
VARIANT_ENUM_CAST ( VisualShaderNodeTransformMult : : Operator )
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
/// TRANSFORM-VECTOR MULTIPLICATION
///////////////////////////////////////
2018-07-14 23:15:42 +02:00
class VisualShaderNodeTransformVecMult : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeTransformVecMult , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
public :
enum Operator {
OP_AxB ,
OP_BxA ,
OP_3x3_AxB ,
OP_3x3_BxA ,
} ;
protected :
Operator op ;
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
void set_operator ( Operator p_op ) ;
Operator get_operator ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeTransformVecMult ( ) ;
} ;
VARIANT_ENUM_CAST ( VisualShaderNodeTransformVecMult : : Operator )
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
2020-02-25 15:50:49 +01:00
/// FLOAT FUNC
2018-07-14 23:15:42 +02:00
///////////////////////////////////////
2020-02-25 15:50:49 +01:00
class VisualShaderNodeFloatFunc : public VisualShaderNode {
GDCLASS ( VisualShaderNodeFloatFunc , VisualShaderNode ) ;
2018-07-14 23:15:42 +02: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 ,
FUNC_FRAC ,
FUNC_SATURATE ,
FUNC_NEGATE ,
2019-02-22 18:38:58 +01: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 12:07:00 +02:00
FUNC_TRUNC ,
FUNC_ONEMINUS
2018-07-14 23:15:42 +02:00
} ;
protected :
Function func ;
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
void set_function ( Function p_func ) ;
Function get_function ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
2020-02-25 15:50:49 +01:00
VisualShaderNodeFloatFunc ( ) ;
} ;
VARIANT_ENUM_CAST ( VisualShaderNodeFloatFunc : : Function )
///////////////////////////////////////
/// INT FUNC
///////////////////////////////////////
class VisualShaderNodeIntFunc : public VisualShaderNode {
GDCLASS ( VisualShaderNodeIntFunc , VisualShaderNode ) ;
public :
enum Function {
FUNC_ABS ,
FUNC_CLAMP ,
FUNC_NEGATE ,
FUNC_SIGN ,
} ;
protected :
Function func ;
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
void set_function ( Function p_func ) ;
Function get_function ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeIntFunc ( ) ;
2018-07-14 23:15:42 +02:00
} ;
2020-02-25 15:50:49 +01:00
VARIANT_ENUM_CAST ( VisualShaderNodeIntFunc : : Function )
2018-07-14 23:15:42 +02:00
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
/// VECTOR FUNC
2018-07-14 23:15:42 +02:00
///////////////////////////////////////
class VisualShaderNodeVectorFunc : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeVectorFunc , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
public :
enum Function {
FUNC_NORMALIZE ,
FUNC_SATURATE ,
FUNC_NEGATE ,
FUNC_RECIPROCAL ,
FUNC_RGB2HSV ,
FUNC_HSV2RGB ,
2019-02-22 18:38:58 +01: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 ,
FUNC_FRAC ,
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 12:07:00 +02:00
FUNC_TRUNC ,
FUNC_ONEMINUS
2018-07-14 23:15:42 +02:00
} ;
protected :
Function func ;
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
void set_function ( Function p_func ) ;
Function get_function ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeVectorFunc ( ) ;
} ;
VARIANT_ENUM_CAST ( VisualShaderNodeVectorFunc : : Function )
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
/// COLOR FUNC
///////////////////////////////////////
class VisualShaderNodeColorFunc : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeColorFunc , VisualShaderNode ) ;
2019-02-22 18:38:58 +01:00
public :
enum Function {
FUNC_GRAYSCALE ,
FUNC_SEPIA
} ;
protected :
Function func ;
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2019-06-26 15:08:25 +02:00
void set_function ( Function p_func ) ;
2019-02-22 18:38:58 +01:00
Function get_function ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeColorFunc ( ) ;
} ;
VARIANT_ENUM_CAST ( VisualShaderNodeColorFunc : : Function )
///////////////////////////////////////
/// TRANSFORM FUNC
///////////////////////////////////////
class VisualShaderNodeTransformFunc : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeTransformFunc , VisualShaderNode ) ;
2019-02-22 18:38:58 +01:00
public :
enum Function {
FUNC_INVERSE ,
FUNC_TRANSPOSE
} ;
protected :
Function func ;
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2019-06-26 15:08:25 +02:00
void set_function ( Function p_func ) ;
2019-02-22 18:38:58 +01:00
Function get_function ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeTransformFunc ( ) ;
} ;
VARIANT_ENUM_CAST ( VisualShaderNodeTransformFunc : : Function )
///////////////////////////////////////
/// DOT
2018-07-14 23:15:42 +02:00
///////////////////////////////////////
class VisualShaderNodeDotProduct : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeDotProduct , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
VisualShaderNodeDotProduct ( ) ;
} ;
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
/// LENGTH
2018-07-14 23:15:42 +02:00
///////////////////////////////////////
class VisualShaderNodeVectorLen : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeVectorLen , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
VisualShaderNodeVectorLen ( ) ;
} ;
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
/// DETERMINANT
///////////////////////////////////////
class VisualShaderNodeDeterminant : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeDeterminant , VisualShaderNode ) ;
2019-02-22 18:38:58 +01:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
VisualShaderNodeDeterminant ( ) ;
} ;
///////////////////////////////////////
/// CLAMP
///////////////////////////////////////
class VisualShaderNodeScalarClamp : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeScalarClamp , VisualShaderNode ) ;
2019-02-22 18:38:58 +01:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
VisualShaderNodeScalarClamp ( ) ;
} ;
///////////////////////////////////////
class VisualShaderNodeVectorClamp : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeVectorClamp , VisualShaderNode ) ;
2019-02-22 18:38:58 +01:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
VisualShaderNodeVectorClamp ( ) ;
} ;
///////////////////////////////////////
/// DERIVATIVE FUNCTIONS
///////////////////////////////////////
class VisualShaderNodeScalarDerivativeFunc : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeScalarDerivativeFunc , VisualShaderNode ) ;
2019-02-22 18:38:58 +01:00
public :
enum Function {
FUNC_SUM ,
FUNC_X ,
FUNC_Y
} ;
protected :
Function func ;
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2019-06-26 15:08:25 +02:00
void set_function ( Function p_func ) ;
2019-02-22 18:38:58 +01:00
Function get_function ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeScalarDerivativeFunc ( ) ;
} ;
VARIANT_ENUM_CAST ( VisualShaderNodeScalarDerivativeFunc : : Function )
///////////////////////////////////////
class VisualShaderNodeVectorDerivativeFunc : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeVectorDerivativeFunc , VisualShaderNode ) ;
2019-02-22 18:38:58 +01:00
public :
enum Function {
FUNC_SUM ,
FUNC_X ,
FUNC_Y
} ;
protected :
Function func ;
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2019-06-26 15:08:25 +02:00
void set_function ( Function p_func ) ;
2019-02-22 18:38:58 +01:00
Function get_function ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeVectorDerivativeFunc ( ) ;
} ;
VARIANT_ENUM_CAST ( VisualShaderNodeVectorDerivativeFunc : : Function )
///////////////////////////////////////
/// FACEFORWARD
///////////////////////////////////////
class VisualShaderNodeFaceForward : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeFaceForward , VisualShaderNode ) ;
2019-02-22 18:38:58 +01:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
VisualShaderNodeFaceForward ( ) ;
} ;
///////////////////////////////////////
/// OUTER PRODUCT
///////////////////////////////////////
class VisualShaderNodeOuterProduct : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeOuterProduct , VisualShaderNode ) ;
2019-02-22 18:38:58 +01:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
VisualShaderNodeOuterProduct ( ) ;
} ;
///////////////////////////////////////
/// STEP
///////////////////////////////////////
class VisualShaderNodeVectorScalarStep : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeVectorScalarStep , VisualShaderNode ) ;
2019-02-22 18:38:58 +01:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
VisualShaderNodeVectorScalarStep ( ) ;
} ;
///////////////////////////////////////
/// SMOOTHSTEP
///////////////////////////////////////
class VisualShaderNodeScalarSmoothStep : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeScalarSmoothStep , VisualShaderNode ) ;
2019-02-22 18:38:58 +01:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
VisualShaderNodeScalarSmoothStep ( ) ;
} ;
///////////////////////////////////////
class VisualShaderNodeVectorSmoothStep : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeVectorSmoothStep , VisualShaderNode ) ;
2019-02-22 18:38:58 +01:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
VisualShaderNodeVectorSmoothStep ( ) ;
} ;
///////////////////////////////////////
class VisualShaderNodeVectorScalarSmoothStep : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeVectorScalarSmoothStep , VisualShaderNode ) ;
2019-02-22 18:38:58 +01:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
VisualShaderNodeVectorScalarSmoothStep ( ) ;
} ;
///////////////////////////////////////
/// DISTANCE
///////////////////////////////////////
class VisualShaderNodeVectorDistance : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeVectorDistance , VisualShaderNode ) ;
2019-02-22 18:38:58 +01:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
VisualShaderNodeVectorDistance ( ) ;
} ;
///////////////////////////////////////
/// REFRACT
///////////////////////////////////////
class VisualShaderNodeVectorRefract : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeVectorRefract , VisualShaderNode ) ;
2019-02-22 18:38:58 +01:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
VisualShaderNodeVectorRefract ( ) ;
} ;
///////////////////////////////////////
/// MIX
2018-07-14 23:15:42 +02:00
///////////////////////////////////////
class VisualShaderNodeScalarInterp : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeScalarInterp , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
VisualShaderNodeScalarInterp ( ) ;
} ;
///////////////////////////////////////
class VisualShaderNodeVectorInterp : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeVectorInterp , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
VisualShaderNodeVectorInterp ( ) ;
} ;
2019-08-03 17:12:33 +02:00
///////////////////////////////////////
class VisualShaderNodeVectorScalarMix : public VisualShaderNode {
GDCLASS ( VisualShaderNodeVectorScalarMix , VisualShaderNode ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
VisualShaderNodeVectorScalarMix ( ) ;
} ;
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
/// COMPOSE
2018-07-14 23:15:42 +02:00
///////////////////////////////////////
2018-07-15 16:28:06 +02:00
class VisualShaderNodeVectorCompose : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeVectorCompose , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
2018-07-15 16:28:06 +02:00
VisualShaderNodeVectorCompose ( ) ;
2018-07-14 23:15:42 +02:00
} ;
///////////////////////////////////////
2018-07-15 16:28:06 +02:00
class VisualShaderNodeTransformCompose : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeTransformCompose , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
2018-07-15 16:28:06 +02:00
VisualShaderNodeTransformCompose ( ) ;
2018-07-14 23:15:42 +02:00
} ;
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
/// DECOMPOSE
2018-07-14 23:15:42 +02:00
///////////////////////////////////////
2018-07-15 16:28:06 +02:00
class VisualShaderNodeVectorDecompose : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeVectorDecompose , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
2018-07-15 16:28:06 +02:00
VisualShaderNodeVectorDecompose ( ) ;
2018-07-14 23:15:42 +02:00
} ;
///////////////////////////////////////
2018-07-15 16:28:06 +02:00
class VisualShaderNodeTransformDecompose : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeTransformDecompose , VisualShaderNode ) ;
2018-07-14 23:15:42 +02:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
2018-07-15 16:28:06 +02:00
VisualShaderNodeTransformDecompose ( ) ;
2018-07-14 23:15:42 +02:00
} ;
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
/// UNIFORMS
2018-07-14 23:15:42 +02:00
///////////////////////////////////////
2020-02-25 15:50:49 +01:00
class VisualShaderNodeFloatUniform : public VisualShaderNodeUniform {
GDCLASS ( VisualShaderNodeFloatUniform , VisualShaderNodeUniform ) ;
2018-07-14 23:15:42 +02:00
2020-02-06 13:11:03 +01:00
public :
enum Hint {
HINT_NONE ,
HINT_RANGE ,
HINT_RANGE_STEP ,
} ;
private :
Hint hint ;
float hint_range_min ;
float hint_range_max ;
float hint_range_step ;
protected :
static void _bind_methods ( ) ;
2018-07-14 23:15:42 +02:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
virtual String generate_global ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
2020-02-06 13:11:03 +01: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 ;
virtual Vector < StringName > get_editable_properties ( ) const ;
2020-02-25 15:50:49 +01:00
VisualShaderNodeFloatUniform ( ) ;
} ;
VARIANT_ENUM_CAST ( VisualShaderNodeFloatUniform : : Hint )
class VisualShaderNodeIntUniform : public VisualShaderNodeUniform {
GDCLASS ( VisualShaderNodeIntUniform , VisualShaderNodeUniform ) ;
public :
enum Hint {
HINT_NONE ,
HINT_RANGE ,
HINT_RANGE_STEP ,
} ;
private :
Hint hint ;
int hint_range_min ;
int hint_range_max ;
int hint_range_step ;
protected :
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
virtual String generate_global ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
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 ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeIntUniform ( ) ;
2018-07-14 23:15:42 +02:00
} ;
2020-02-25 15:50:49 +01:00
VARIANT_ENUM_CAST ( VisualShaderNodeIntUniform : : Hint )
2020-02-06 13:11:03 +01:00
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
class VisualShaderNodeBooleanUniform : public VisualShaderNodeUniform {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeBooleanUniform , VisualShaderNodeUniform ) ;
2019-02-22 18:38:58 +01:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
virtual String generate_global ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
VisualShaderNodeBooleanUniform ( ) ;
} ;
///////////////////////////////////////
2018-07-14 23:15:42 +02:00
class VisualShaderNodeColorUniform : public VisualShaderNodeUniform {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeColorUniform , VisualShaderNodeUniform ) ;
2018-07-14 23:15:42 +02:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
virtual String generate_global ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
VisualShaderNodeColorUniform ( ) ;
} ;
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
2018-07-14 23:15:42 +02:00
class VisualShaderNodeVec3Uniform : public VisualShaderNodeUniform {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeVec3Uniform , VisualShaderNodeUniform ) ;
2018-07-14 23:15:42 +02:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
virtual String generate_global ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
VisualShaderNodeVec3Uniform ( ) ;
} ;
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
2018-07-14 23:15:42 +02:00
class VisualShaderNodeTransformUniform : public VisualShaderNodeUniform {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeTransformUniform , VisualShaderNodeUniform ) ;
2018-07-14 23:15:42 +02:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
virtual String generate_global ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
VisualShaderNodeTransformUniform ( ) ;
} ;
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
2018-07-14 23:15:42 +02:00
class VisualShaderNodeTextureUniform : public VisualShaderNodeUniform {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeTextureUniform , VisualShaderNodeUniform ) ;
2018-07-14 23:15:42 +02:00
public :
enum TextureType {
TYPE_DATA ,
TYPE_COLOR ,
TYPE_NORMALMAP ,
TYPE_ANISO ,
} ;
enum ColorDefault {
COLOR_DEFAULT_WHITE ,
COLOR_DEFAULT_BLACK
} ;
2019-10-09 10:29:23 +02:00
protected :
2018-07-14 23:15:42 +02:00
TextureType texture_type ;
ColorDefault color_default ;
protected :
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
2019-10-03 09:40:26 +02:00
virtual String get_input_port_default_hint ( int p_port ) const ;
2018-07-14 23:15:42 +02:00
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
virtual String generate_global ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
Vector < StringName > get_editable_properties ( ) const ;
void set_texture_type ( TextureType p_type ) ;
TextureType get_texture_type ( ) const ;
void set_color_default ( ColorDefault p_default ) ;
ColorDefault get_color_default ( ) const ;
VisualShaderNodeTextureUniform ( ) ;
} ;
VARIANT_ENUM_CAST ( VisualShaderNodeTextureUniform : : TextureType )
VARIANT_ENUM_CAST ( VisualShaderNodeTextureUniform : : ColorDefault )
2019-02-22 18:38:58 +01:00
///////////////////////////////////////
2018-07-14 23:15:42 +02:00
2019-07-12 11:14:34 +02:00
class VisualShaderNodeTextureUniformTriplanar : public VisualShaderNodeTextureUniform {
GDCLASS ( VisualShaderNodeTextureUniformTriplanar , VisualShaderNodeTextureUniform ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
2019-10-03 09:40:26 +02:00
virtual String get_input_port_default_hint ( int p_port ) const ;
2019-07-12 11:14:34 +02:00
virtual String generate_global_per_node ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const ;
virtual String generate_global_per_func ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
VisualShaderNodeTextureUniformTriplanar ( ) ;
} ;
///////////////////////////////////////
2019-06-11 20:43:37 +02:00
class VisualShaderNodeCubemapUniform : public VisualShaderNodeTextureUniform {
GDCLASS ( VisualShaderNodeCubemapUniform , VisualShaderNodeTextureUniform ) ;
2018-07-14 23:15:42 +02:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-10-09 10:29:23 +02:00
virtual String get_input_port_default_hint ( int p_port ) const ;
virtual String generate_global ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const ;
2019-01-21 20:07:53 +01: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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2018-07-14 23:15:42 +02:00
2019-06-11 20:43:37 +02:00
VisualShaderNodeCubemapUniform ( ) ;
2018-07-14 23:15:42 +02:00
} ;
2019-04-13 14:24:04 +02:00
///////////////////////////////////////
/// IF
///////////////////////////////////////
class VisualShaderNodeIf : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeIf , VisualShaderNode ) ;
2019-04-13 14:24:04 +02:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ;
VisualShaderNodeIf ( ) ;
} ;
///////////////////////////////////////
/// SWITCH
///////////////////////////////////////
class VisualShaderNodeSwitch : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeSwitch , VisualShaderNode ) ;
2019-04-13 14:24:04 +02:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ;
VisualShaderNodeSwitch ( ) ;
} ;
2019-09-03 13:46:31 +02:00
class VisualShaderNodeScalarSwitch : public VisualShaderNodeSwitch {
GDCLASS ( VisualShaderNodeScalarSwitch , VisualShaderNodeSwitch ) ;
public :
virtual String get_caption ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
VisualShaderNodeScalarSwitch ( ) ;
} ;
2019-05-19 12:07:00 +02:00
///////////////////////////////////////
/// FRESNEL
///////////////////////////////////////
class VisualShaderNodeFresnel : public VisualShaderNode {
2019-03-19 19:35:57 +01:00
GDCLASS ( VisualShaderNodeFresnel , VisualShaderNode ) ;
2019-05-19 12:07:00 +02:00
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
2019-11-22 16:28:59 +01:00
virtual String get_input_port_default_hint ( int p_port ) const ;
2019-05-19 12:07:00 +02: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 ;
VisualShaderNodeFresnel ( ) ;
} ;
2019-07-08 09:05:33 +02:00
///////////////////////////////////////
/// Is
///////////////////////////////////////
class VisualShaderNodeIs : public VisualShaderNode {
GDCLASS ( VisualShaderNodeIs , VisualShaderNode ) ;
public :
enum Function {
FUNC_IS_INF ,
FUNC_IS_NAN ,
} ;
protected :
Function func ;
protected :
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
void set_function ( Function p_func ) ;
Function get_function ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
VisualShaderNodeIs ( ) ;
} ;
VARIANT_ENUM_CAST ( VisualShaderNodeIs : : Function )
///////////////////////////////////////
/// Compare
///////////////////////////////////////
class VisualShaderNodeCompare : public VisualShaderNode {
GDCLASS ( VisualShaderNodeCompare , VisualShaderNode ) ;
public :
2020-01-23 08:31:45 +01:00
enum ComparisonType {
2019-07-08 09:05:33 +02:00
CTYPE_SCALAR ,
2020-02-25 15:50:49 +01:00
CTYPE_SCALAR_INT ,
2019-07-08 09:05:33 +02:00
CTYPE_VECTOR ,
CTYPE_BOOLEAN ,
2020-02-25 15:50:49 +01:00
CTYPE_TRANSFORM ,
2019-07-08 09:05:33 +02:00
} ;
enum Function {
FUNC_EQUAL ,
FUNC_NOT_EQUAL ,
FUNC_GREATER_THAN ,
FUNC_GREATER_THAN_EQUAL ,
FUNC_LESS_THAN ,
FUNC_LESS_THAN_EQUAL ,
} ;
enum Condition {
COND_ALL ,
COND_ANY ,
} ;
protected :
2020-01-23 08:31:45 +01:00
ComparisonType ctype ;
2019-07-08 09:05:33 +02:00
Function func ;
Condition condition ;
protected :
static void _bind_methods ( ) ;
public :
virtual String get_caption ( ) const ;
virtual int get_input_port_count ( ) const ;
virtual PortType get_input_port_type ( int p_port ) const ;
virtual String get_input_port_name ( int p_port ) const ;
virtual int get_output_port_count ( ) const ;
virtual PortType get_output_port_type ( int p_port ) const ;
virtual String get_output_port_name ( int p_port ) const ;
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 ; //if no output is connected, the output var passed will be empty. if no input is connected and input is NIL, the input var passed will be empty
2020-01-23 08:31:45 +01:00
void set_comparison_type ( ComparisonType p_type ) ;
ComparisonType get_comparison_type ( ) const ;
2019-07-08 09:05:33 +02:00
void set_function ( Function p_func ) ;
Function get_function ( ) const ;
2019-07-23 09:14:31 +02:00
void set_condition ( Condition p_cond ) ;
2019-07-08 09:05:33 +02:00
Condition get_condition ( ) const ;
virtual Vector < StringName > get_editable_properties ( ) const ;
virtual String get_warning ( Shader : : Mode p_mode , VisualShader : : Type p_type ) const ;
VisualShaderNodeCompare ( ) ;
} ;
2020-01-23 08:31:45 +01:00
VARIANT_ENUM_CAST ( VisualShaderNodeCompare : : ComparisonType )
2019-07-08 09:05:33 +02:00
VARIANT_ENUM_CAST ( VisualShaderNodeCompare : : Function )
VARIANT_ENUM_CAST ( VisualShaderNodeCompare : : Condition )
2018-07-14 23:15:42 +02:00
# endif // VISUAL_SHADER_NODES_H
