2018-08-29 20:38:13 +00:00
/*************************************************************************/
/* visual_shader.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
2021-01-01 19:13:46 +00:00
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 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
# include "visual_shader.h"
2019-05-27 15:33:25 +00:00
2020-11-07 22:33:38 +00:00
# include "core/templates/vmap.h"
2020-03-27 18:21:27 +00:00
# include "servers/rendering/shader_types.h"
2020-02-25 14:50:49 +00:00
# include "visual_shader_nodes.h"
2020-09-15 07:57:40 +00:00
# include "visual_shader_particle_nodes.h"
2020-11-27 07:00:23 +00:00
# include "visual_shader_sdf_nodes.h"
2018-07-14 21:15:42 +00:00
2020-01-27 09:10:51 +00:00
bool VisualShaderNode : : is_simple_decl ( ) const {
return simple_decl ;
}
2018-07-14 21:15:42 +00:00
void VisualShaderNode : : set_output_port_for_preview ( int p_index ) {
port_preview = p_index ;
}
int VisualShaderNode : : get_output_port_for_preview ( ) const {
return port_preview ;
}
void VisualShaderNode : : set_input_port_default_value ( int p_port , const Variant & p_value ) {
default_input_values [ p_port ] = p_value ;
emit_changed ( ) ;
}
Variant VisualShaderNode : : get_input_port_default_value ( int p_port ) const {
if ( default_input_values . has ( p_port ) ) {
return default_input_values [ p_port ] ;
}
return Variant ( ) ;
}
2021-06-05 12:53:53 +00:00
void VisualShaderNode : : remove_input_port_default_value ( int p_port ) {
if ( default_input_values . has ( p_port ) ) {
default_input_values . erase ( p_port ) ;
emit_changed ( ) ;
}
}
void VisualShaderNode : : clear_default_input_values ( ) {
if ( ! default_input_values . is_empty ( ) ) {
default_input_values . clear ( ) ;
emit_changed ( ) ;
}
}
2018-07-14 21:15:42 +00:00
bool VisualShaderNode : : is_port_separator ( int p_index ) const {
return false ;
}
2020-07-26 01:04:07 +00:00
bool VisualShaderNode : : is_output_port_connected ( int p_port ) const {
if ( connected_output_ports . has ( p_port ) ) {
2020-10-02 06:06:13 +00:00
return connected_output_ports [ p_port ] > 0 ;
2020-07-26 01:04:07 +00:00
}
return false ;
}
void VisualShaderNode : : set_output_port_connected ( int p_port , bool p_connected ) {
2020-07-31 07:40:05 +00:00
if ( p_connected ) {
2020-10-02 06:06:13 +00:00
connected_output_ports [ p_port ] + + ;
2020-07-31 07:40:05 +00:00
} else {
2020-10-02 06:06:13 +00:00
connected_output_ports [ p_port ] - - ;
2020-07-31 07:40:05 +00:00
}
2020-07-26 01:04:07 +00:00
}
2020-07-27 06:18:37 +00:00
bool VisualShaderNode : : is_input_port_connected ( int p_port ) const {
if ( connected_input_ports . has ( p_port ) ) {
return connected_input_ports [ p_port ] ;
}
return false ;
}
void VisualShaderNode : : set_input_port_connected ( int p_port , bool p_connected ) {
connected_input_ports [ p_port ] = p_connected ;
}
bool VisualShaderNode : : is_generate_input_var ( int p_port ) const {
return true ;
}
2020-12-20 15:45:53 +00:00
bool VisualShaderNode : : is_output_port_expandable ( int p_port ) const {
return false ;
}
void VisualShaderNode : : _set_output_ports_expanded ( const Array & p_values ) {
for ( int i = 0 ; i < p_values . size ( ) ; i + + ) {
expanded_output_ports [ p_values [ i ] ] = true ;
}
emit_changed ( ) ;
}
Array VisualShaderNode : : _get_output_ports_expanded ( ) const {
Array arr ;
for ( int i = 0 ; i < get_output_port_count ( ) ; i + + ) {
if ( _is_output_port_expanded ( i ) ) {
arr . push_back ( i ) ;
}
}
return arr ;
}
void VisualShaderNode : : _set_output_port_expanded ( int p_port , bool p_expanded ) {
expanded_output_ports [ p_port ] = p_expanded ;
emit_changed ( ) ;
}
bool VisualShaderNode : : _is_output_port_expanded ( int p_port ) const {
if ( expanded_output_ports . has ( p_port ) ) {
return expanded_output_ports [ p_port ] ;
}
return false ;
}
int VisualShaderNode : : get_expanded_output_port_count ( ) const {
int count = get_output_port_count ( ) ;
int count2 = count ;
for ( int i = 0 ; i < count ; i + + ) {
if ( is_output_port_expandable ( i ) & & _is_output_port_expanded ( i ) ) {
if ( get_output_port_type ( i ) = = PORT_TYPE_VECTOR ) {
count2 + = 3 ;
}
}
}
return count2 ;
}
2020-07-26 01:04:07 +00:00
bool VisualShaderNode : : is_code_generated ( ) const {
return true ;
}
2020-09-21 11:32:59 +00:00
bool VisualShaderNode : : is_show_prop_names ( ) const {
return false ;
}
bool VisualShaderNode : : is_use_prop_slots ( ) const {
return false ;
}
2021-05-27 19:17:58 +00:00
bool VisualShaderNode : : is_disabled ( ) const {
return disabled ;
}
void VisualShaderNode : : set_disabled ( bool p_disabled ) {
disabled = p_disabled ;
}
2018-07-14 21:15:42 +00:00
Vector < VisualShader : : DefaultTextureParam > VisualShaderNode : : get_default_texture_parameters ( VisualShader : : Type p_type , int p_id ) const {
return Vector < VisualShader : : DefaultTextureParam > ( ) ;
}
2020-05-14 12:29:06 +00:00
2018-07-14 21:15:42 +00:00
String VisualShaderNode : : generate_global ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const {
return String ( ) ;
}
2019-07-12 09:14:34 +00:00
String VisualShaderNode : : generate_global_per_node ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const {
return String ( ) ;
}
String VisualShaderNode : : generate_global_per_func ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const {
return String ( ) ;
}
2018-07-14 21:15:42 +00:00
Vector < StringName > VisualShaderNode : : get_editable_properties ( ) const {
return Vector < StringName > ( ) ;
}
2020-01-23 07:42:35 +00:00
Array VisualShaderNode : : get_default_input_values ( ) const {
2018-07-14 21:15:42 +00:00
Array ret ;
for ( Map < int , Variant > : : Element * E = default_input_values . front ( ) ; E ; E = E - > next ( ) ) {
ret . push_back ( E - > key ( ) ) ;
ret . push_back ( E - > get ( ) ) ;
}
return ret ;
}
2020-05-14 12:29:06 +00:00
2020-01-23 07:42:35 +00:00
void VisualShaderNode : : set_default_input_values ( const Array & p_values ) {
2018-07-14 21:15:42 +00:00
if ( p_values . size ( ) % 2 = = 0 ) {
for ( int i = 0 ; i < p_values . size ( ) ; i + = 2 ) {
default_input_values [ p_values [ i + 0 ] ] = p_values [ i + 1 ] ;
}
}
emit_changed ( ) ;
}
String VisualShaderNode : : get_warning ( Shader : : Mode p_mode , VisualShader : : Type p_type ) const {
return String ( ) ;
}
2019-10-03 07:40:26 +00:00
String VisualShaderNode : : get_input_port_default_hint ( int p_port ) const {
return " " ;
}
2018-07-14 21:15:42 +00:00
void VisualShaderNode : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " set_output_port_for_preview " , " port " ) , & VisualShaderNode : : set_output_port_for_preview ) ;
ClassDB : : bind_method ( D_METHOD ( " get_output_port_for_preview " ) , & VisualShaderNode : : get_output_port_for_preview ) ;
2020-12-20 15:45:53 +00:00
ClassDB : : bind_method ( D_METHOD ( " _set_output_port_expanded " , " port " ) , & VisualShaderNode : : _set_output_port_expanded ) ;
ClassDB : : bind_method ( D_METHOD ( " _is_output_port_expanded " ) , & VisualShaderNode : : _is_output_port_expanded ) ;
ClassDB : : bind_method ( D_METHOD ( " _set_output_ports_expanded " , " values " ) , & VisualShaderNode : : _set_output_ports_expanded ) ;
ClassDB : : bind_method ( D_METHOD ( " _get_output_ports_expanded " ) , & VisualShaderNode : : _get_output_ports_expanded ) ;
2018-07-14 21:15:42 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_input_port_default_value " , " port " , " value " ) , & VisualShaderNode : : set_input_port_default_value ) ;
ClassDB : : bind_method ( D_METHOD ( " get_input_port_default_value " , " port " ) , & VisualShaderNode : : get_input_port_default_value ) ;
2021-06-05 12:53:53 +00:00
ClassDB : : bind_method ( D_METHOD ( " remove_input_port_default_value " , " port " ) , & VisualShaderNode : : remove_input_port_default_value ) ;
ClassDB : : bind_method ( D_METHOD ( " clear_default_input_values " ) , & VisualShaderNode : : clear_default_input_values ) ;
2020-01-23 07:42:35 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_default_input_values " , " values " ) , & VisualShaderNode : : set_default_input_values ) ;
ClassDB : : bind_method ( D_METHOD ( " get_default_input_values " ) , & VisualShaderNode : : get_default_input_values ) ;
2018-07-14 21:15:42 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " output_port_for_preview " ) , " set_output_port_for_preview " , " get_output_port_for_preview " ) ;
2020-01-23 07:42:35 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : ARRAY , " default_input_values " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL ) , " set_default_input_values " , " get_default_input_values " ) ;
2020-12-20 15:45:53 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : ARRAY , " expanded_output_ports " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL ) , " _set_output_ports_expanded " , " _get_output_ports_expanded " ) ;
2018-07-14 21:15:42 +00:00
ADD_SIGNAL ( MethodInfo ( " editor_refresh_request " ) ) ;
2019-08-09 19:51:48 +00:00
BIND_ENUM_CONSTANT ( PORT_TYPE_SCALAR ) ;
2020-02-25 14:50:49 +00:00
BIND_ENUM_CONSTANT ( PORT_TYPE_SCALAR_INT ) ;
2019-08-09 19:51:48 +00:00
BIND_ENUM_CONSTANT ( PORT_TYPE_VECTOR ) ;
BIND_ENUM_CONSTANT ( PORT_TYPE_BOOLEAN ) ;
BIND_ENUM_CONSTANT ( PORT_TYPE_TRANSFORM ) ;
2019-10-01 08:51:50 +00:00
BIND_ENUM_CONSTANT ( PORT_TYPE_SAMPLER ) ;
BIND_ENUM_CONSTANT ( PORT_TYPE_MAX ) ;
2018-07-14 21:15:42 +00:00
}
VisualShaderNode : : VisualShaderNode ( ) {
}
/////////////////////////////////////////////////////////
2019-08-09 19:51:48 +00:00
void VisualShaderNodeCustom : : update_ports ( ) {
ERR_FAIL_COND ( ! get_script_instance ( ) ) ;
input_ports . clear ( ) ;
if ( get_script_instance ( ) - > has_method ( " _get_input_port_count " ) ) {
int input_port_count = ( int ) get_script_instance ( ) - > call ( " _get_input_port_count " ) ;
bool has_name = get_script_instance ( ) - > has_method ( " _get_input_port_name " ) ;
bool has_type = get_script_instance ( ) - > has_method ( " _get_input_port_type " ) ;
for ( int i = 0 ; i < input_port_count ; i + + ) {
Port port ;
if ( has_name ) {
port . name = ( String ) get_script_instance ( ) - > call ( " _get_input_port_name " , i ) ;
} else {
port . name = " in " + itos ( i ) ;
}
if ( has_type ) {
port . type = ( int ) get_script_instance ( ) - > call ( " _get_input_port_type " , i ) ;
} else {
port . type = ( int ) PortType : : PORT_TYPE_SCALAR ;
}
input_ports . push_back ( port ) ;
}
}
output_ports . clear ( ) ;
if ( get_script_instance ( ) - > has_method ( " _get_output_port_count " ) ) {
int output_port_count = ( int ) get_script_instance ( ) - > call ( " _get_output_port_count " ) ;
bool has_name = get_script_instance ( ) - > has_method ( " _get_output_port_name " ) ;
bool has_type = get_script_instance ( ) - > has_method ( " _get_output_port_type " ) ;
for ( int i = 0 ; i < output_port_count ; i + + ) {
Port port ;
if ( has_name ) {
port . name = ( String ) get_script_instance ( ) - > call ( " _get_output_port_name " , i ) ;
} else {
port . name = " out " + itos ( i ) ;
}
if ( has_type ) {
port . type = ( int ) get_script_instance ( ) - > call ( " _get_output_port_type " , i ) ;
} else {
port . type = ( int ) PortType : : PORT_TYPE_SCALAR ;
}
output_ports . push_back ( port ) ;
}
}
}
String VisualShaderNodeCustom : : get_caption ( ) const {
ERR_FAIL_COND_V ( ! get_script_instance ( ) , " " ) ;
if ( get_script_instance ( ) - > has_method ( " _get_name " ) ) {
return ( String ) get_script_instance ( ) - > call ( " _get_name " ) ;
}
return " Unnamed " ;
}
int VisualShaderNodeCustom : : get_input_port_count ( ) const {
return input_ports . size ( ) ;
}
VisualShaderNodeCustom : : PortType VisualShaderNodeCustom : : get_input_port_type ( int p_port ) const {
ERR_FAIL_INDEX_V ( p_port , input_ports . size ( ) , PORT_TYPE_SCALAR ) ;
return ( PortType ) input_ports [ p_port ] . type ;
}
String VisualShaderNodeCustom : : get_input_port_name ( int p_port ) const {
ERR_FAIL_INDEX_V ( p_port , input_ports . size ( ) , " " ) ;
return input_ports [ p_port ] . name ;
}
int VisualShaderNodeCustom : : get_output_port_count ( ) const {
return output_ports . size ( ) ;
}
VisualShaderNodeCustom : : PortType VisualShaderNodeCustom : : get_output_port_type ( int p_port ) const {
ERR_FAIL_INDEX_V ( p_port , output_ports . size ( ) , PORT_TYPE_SCALAR ) ;
return ( PortType ) output_ports [ p_port ] . type ;
}
String VisualShaderNodeCustom : : get_output_port_name ( int p_port ) const {
ERR_FAIL_INDEX_V ( p_port , output_ports . size ( ) , " " ) ;
return output_ports [ p_port ] . name ;
}
String VisualShaderNodeCustom : : generate_code ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id , const String * p_input_vars , const String * p_output_vars , bool p_for_preview ) const {
ERR_FAIL_COND_V ( ! get_script_instance ( ) , " " ) ;
ERR_FAIL_COND_V ( ! get_script_instance ( ) - > has_method ( " _get_code " ) , " " ) ;
Array input_vars ;
for ( int i = 0 ; i < get_input_port_count ( ) ; i + + ) {
input_vars . push_back ( p_input_vars [ i ] ) ;
}
Array output_vars ;
for ( int i = 0 ; i < get_output_port_count ( ) ; i + + ) {
output_vars . push_back ( p_output_vars [ i ] ) ;
}
String code = " \t { \n " ;
String _code = ( String ) get_script_instance ( ) - > call ( " _get_code " , input_vars , output_vars , ( int ) p_mode , ( int ) p_type ) ;
bool nend = _code . ends_with ( " \n " ) ;
_code = _code . insert ( 0 , " \t \t " ) ;
_code = _code . replace ( " \n " , " \n \t \t " ) ;
code + = _code ;
if ( ! nend ) {
code + = " \n \t } " ;
} else {
code . remove ( code . size ( ) - 1 ) ;
code + = " } " ;
}
2020-02-01 13:25:34 +00:00
code + = " \n " ;
2019-08-09 19:51:48 +00:00
return code ;
}
String VisualShaderNodeCustom : : generate_global_per_node ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const {
ERR_FAIL_COND_V ( ! get_script_instance ( ) , " " ) ;
if ( get_script_instance ( ) - > has_method ( " _get_global_code " ) ) {
String code = " // " + get_caption ( ) + " \n " ;
code + = ( String ) get_script_instance ( ) - > call ( " _get_global_code " , ( int ) p_mode ) ;
code + = " \n " ;
return code ;
}
return " " ;
}
2021-04-12 10:47:37 +00:00
void VisualShaderNodeCustom : : set_input_port_default_value ( int p_port , const Variant & p_value ) {
if ( ! is_initialized ) {
VisualShaderNode : : set_input_port_default_value ( p_port , p_value ) ;
}
}
void VisualShaderNodeCustom : : set_default_input_values ( const Array & p_values ) {
if ( ! is_initialized ) {
VisualShaderNode : : set_default_input_values ( p_values ) ;
}
}
2021-06-05 12:53:53 +00:00
void VisualShaderNodeCustom : : remove_input_port_default_value ( int p_port ) {
if ( ! is_initialized ) {
VisualShaderNode : : remove_input_port_default_value ( p_port ) ;
}
}
void VisualShaderNodeCustom : : clear_default_input_values ( ) {
if ( ! is_initialized ) {
VisualShaderNode : : clear_default_input_values ( ) ;
}
}
2021-04-12 10:47:37 +00:00
void VisualShaderNodeCustom : : _set_input_port_default_value ( int p_port , const Variant & p_value ) {
VisualShaderNode : : set_input_port_default_value ( p_port , p_value ) ;
}
bool VisualShaderNodeCustom : : _is_initialized ( ) {
return is_initialized ;
}
void VisualShaderNodeCustom : : _set_initialized ( bool p_enabled ) {
is_initialized = p_enabled ;
}
2019-08-09 19:51:48 +00:00
void VisualShaderNodeCustom : : _bind_methods ( ) {
BIND_VMETHOD ( MethodInfo ( Variant : : STRING , " _get_name " ) ) ;
BIND_VMETHOD ( MethodInfo ( Variant : : STRING , " _get_description " ) ) ;
BIND_VMETHOD ( MethodInfo ( Variant : : STRING , " _get_category " ) ) ;
BIND_VMETHOD ( MethodInfo ( Variant : : INT , " _get_return_icon_type " ) ) ;
BIND_VMETHOD ( MethodInfo ( Variant : : INT , " _get_input_port_count " ) ) ;
BIND_VMETHOD ( MethodInfo ( Variant : : INT , " _get_input_port_type " , PropertyInfo ( Variant : : INT , " port " ) ) ) ;
2020-02-20 21:58:05 +00:00
BIND_VMETHOD ( MethodInfo ( Variant : : STRING_NAME , " _get_input_port_name " , PropertyInfo ( Variant : : INT , " port " ) ) ) ;
2019-08-09 19:51:48 +00:00
BIND_VMETHOD ( MethodInfo ( Variant : : INT , " _get_output_port_count " ) ) ;
BIND_VMETHOD ( MethodInfo ( Variant : : INT , " _get_output_port_type " , PropertyInfo ( Variant : : INT , " port " ) ) ) ;
2020-02-20 21:58:05 +00:00
BIND_VMETHOD ( MethodInfo ( Variant : : STRING_NAME , " _get_output_port_name " , PropertyInfo ( Variant : : INT , " port " ) ) ) ;
2019-08-09 19:51:48 +00:00
BIND_VMETHOD ( MethodInfo ( Variant : : STRING , " _get_code " , PropertyInfo ( Variant : : ARRAY , " input_vars " ) , PropertyInfo ( Variant : : ARRAY , " output_vars " ) , PropertyInfo ( Variant : : INT , " mode " ) , PropertyInfo ( Variant : : INT , " type " ) ) ) ;
BIND_VMETHOD ( MethodInfo ( Variant : : STRING , " _get_global_code " , PropertyInfo ( Variant : : INT , " mode " ) ) ) ;
2020-02-13 06:43:43 +00:00
BIND_VMETHOD ( MethodInfo ( Variant : : BOOL , " _is_highend " ) ) ;
2021-04-12 10:47:37 +00:00
ClassDB : : bind_method ( D_METHOD ( " _set_initialized " , " enabled " ) , & VisualShaderNodeCustom : : _set_initialized ) ;
ClassDB : : bind_method ( D_METHOD ( " _is_initialized " ) , & VisualShaderNodeCustom : : _is_initialized ) ;
ClassDB : : bind_method ( D_METHOD ( " _set_input_port_default_value " , " port " , " value " ) , & VisualShaderNodeCustom : : _set_input_port_default_value ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : BOOL , " initialized " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL ) , " _set_initialized " , " _is_initialized " ) ;
2019-08-09 19:51:48 +00:00
}
VisualShaderNodeCustom : : VisualShaderNodeCustom ( ) {
2020-01-27 09:10:51 +00:00
simple_decl = false ;
2019-08-09 19:51:48 +00:00
}
/////////////////////////////////////////////////////////
2020-09-09 08:21:38 +00:00
void VisualShader : : set_shader_type ( Type p_type ) {
current_type = p_type ;
}
2020-09-09 14:40:27 +00:00
VisualShader : : Type VisualShader : : get_shader_type ( ) const {
return current_type ;
}
2020-02-25 14:50:49 +00:00
void VisualShader : : set_version ( const String & p_version ) {
version = p_version ;
}
String VisualShader : : get_version ( ) const {
return version ;
}
void VisualShader : : update_version ( const String & p_new_version ) {
if ( version = = " " ) {
for ( int i = 0 ; i < TYPE_MAX ; i + + ) {
for ( Map < int , Node > : : Element * E = graph [ i ] . nodes . front ( ) ; E ; E = E - > next ( ) ) {
Ref < VisualShaderNodeExpression > expression = Object : : cast_to < VisualShaderNodeExpression > ( E - > get ( ) . node . ptr ( ) ) ;
if ( expression . is_valid ( ) ) {
for ( int j = 0 ; j < expression - > get_input_port_count ( ) ; j + + ) {
int type = expression - > get_input_port_type ( j ) ;
if ( type > 0 ) { // + PORT_TYPE_SCALAR_INT
type + = 1 ;
}
expression - > set_input_port_type ( j , type ) ;
}
for ( int j = 0 ; j < expression - > get_output_port_count ( ) ; j + + ) {
int type = expression - > get_output_port_type ( j ) ;
if ( type > 0 ) { // + PORT_TYPE_SCALAR_INT
type + = 1 ;
}
expression - > set_output_port_type ( j , type ) ;
}
}
Ref < VisualShaderNodeCompare > compare = Object : : cast_to < VisualShaderNodeCompare > ( E - > get ( ) . node . ptr ( ) ) ;
if ( compare . is_valid ( ) ) {
int ctype = int ( compare - > get_comparison_type ( ) ) ;
if ( int ( ctype ) > 0 ) { // + PORT_TYPE_SCALAR_INT
ctype + = 1 ;
}
compare - > set_comparison_type ( VisualShaderNodeCompare : : ComparisonType ( ctype ) ) ;
}
}
}
}
set_version ( p_new_version ) ;
}
2018-07-14 21:15:42 +00:00
void VisualShader : : add_node ( Type p_type , const Ref < VisualShaderNode > & p_node , const Vector2 & p_position , int p_id ) {
ERR_FAIL_COND ( p_node . is_null ( ) ) ;
ERR_FAIL_COND ( p_id < 2 ) ;
ERR_FAIL_INDEX ( p_type , TYPE_MAX ) ;
Graph * g = & graph [ p_type ] ;
ERR_FAIL_COND ( g - > nodes . has ( p_id ) ) ;
Node n ;
n . node = p_node ;
n . position = p_position ;
Ref < VisualShaderNodeUniform > uniform = n . node ;
if ( uniform . is_valid ( ) ) {
String valid_name = validate_uniform_name ( uniform - > get_uniform_name ( ) , uniform ) ;
uniform - > set_uniform_name ( valid_name ) ;
}
Ref < VisualShaderNodeInput > input = n . node ;
if ( input . is_valid ( ) ) {
input - > shader_mode = shader_mode ;
input - > shader_type = p_type ;
2020-02-21 17:28:45 +00:00
input - > connect ( " input_type_changed " , callable_mp ( this , & VisualShader : : _input_type_changed ) , varray ( p_type , p_id ) ) ;
2018-07-14 21:15:42 +00:00
}
2020-02-21 17:28:45 +00:00
n . node - > connect ( " changed " , callable_mp ( this , & VisualShader : : _queue_update ) ) ;
2018-07-14 21:15:42 +00:00
2019-08-09 19:51:48 +00:00
Ref < VisualShaderNodeCustom > custom = n . node ;
if ( custom . is_valid ( ) ) {
custom - > update_ports ( ) ;
}
2018-07-14 21:15:42 +00:00
g - > nodes [ p_id ] = n ;
_queue_update ( ) ;
}
void VisualShader : : set_node_position ( Type p_type , int p_id , const Vector2 & p_position ) {
ERR_FAIL_INDEX ( p_type , TYPE_MAX ) ;
Graph * g = & graph [ p_type ] ;
ERR_FAIL_COND ( ! g - > nodes . has ( p_id ) ) ;
g - > nodes [ p_id ] . position = p_position ;
}
Vector2 VisualShader : : get_node_position ( Type p_type , int p_id ) const {
ERR_FAIL_INDEX_V ( p_type , TYPE_MAX , Vector2 ( ) ) ;
const Graph * g = & graph [ p_type ] ;
ERR_FAIL_COND_V ( ! g - > nodes . has ( p_id ) , Vector2 ( ) ) ;
return g - > nodes [ p_id ] . position ;
}
2019-05-12 12:09:39 +00:00
2018-07-14 21:15:42 +00:00
Ref < VisualShaderNode > VisualShader : : get_node ( Type p_type , int p_id ) const {
ERR_FAIL_INDEX_V ( p_type , TYPE_MAX , Ref < VisualShaderNode > ( ) ) ;
const Graph * g = & graph [ p_type ] ;
ERR_FAIL_COND_V ( ! g - > nodes . has ( p_id ) , Ref < VisualShaderNode > ( ) ) ;
return g - > nodes [ p_id ] . node ;
}
Vector < int > VisualShader : : get_node_list ( Type p_type ) const {
ERR_FAIL_INDEX_V ( p_type , TYPE_MAX , Vector < int > ( ) ) ;
const Graph * g = & graph [ p_type ] ;
Vector < int > ret ;
for ( Map < int , Node > : : Element * E = g - > nodes . front ( ) ; E ; E = E - > next ( ) ) {
ret . push_back ( E - > key ( ) ) ;
}
return ret ;
}
2020-05-14 12:29:06 +00:00
2018-07-14 21:15:42 +00:00
int VisualShader : : get_valid_node_id ( Type p_type ) const {
ERR_FAIL_INDEX_V ( p_type , TYPE_MAX , NODE_ID_INVALID ) ;
const Graph * g = & graph [ p_type ] ;
return g - > nodes . size ( ) ? MAX ( 2 , g - > nodes . back ( ) - > key ( ) + 1 ) : 2 ;
}
int VisualShader : : find_node_id ( Type p_type , const Ref < VisualShaderNode > & p_node ) const {
for ( const Map < int , Node > : : Element * E = graph [ p_type ] . nodes . front ( ) ; E ; E = E - > next ( ) ) {
2020-05-14 14:41:43 +00:00
if ( E - > get ( ) . node = = p_node ) {
2018-07-14 21:15:42 +00:00
return E - > key ( ) ;
2020-05-14 14:41:43 +00:00
}
2018-07-14 21:15:42 +00:00
}
return NODE_ID_INVALID ;
}
void VisualShader : : remove_node ( Type p_type , int p_id ) {
ERR_FAIL_INDEX ( p_type , TYPE_MAX ) ;
ERR_FAIL_COND ( p_id < 2 ) ;
Graph * g = & graph [ p_type ] ;
ERR_FAIL_COND ( ! g - > nodes . has ( p_id ) ) ;
Ref < VisualShaderNodeInput > input = g - > nodes [ p_id ] . node ;
if ( input . is_valid ( ) ) {
2020-02-21 17:28:45 +00:00
input - > disconnect ( " input_type_changed " , callable_mp ( this , & VisualShader : : _input_type_changed ) ) ;
2018-07-14 21:15:42 +00:00
}
2020-02-21 17:28:45 +00:00
g - > nodes [ p_id ] . node - > disconnect ( " changed " , callable_mp ( this , & VisualShader : : _queue_update ) ) ;
2018-07-14 21:15:42 +00:00
g - > nodes . erase ( p_id ) ;
for ( List < Connection > : : Element * E = g - > connections . front ( ) ; E ; ) {
List < Connection > : : Element * N = E - > next ( ) ;
if ( E - > get ( ) . from_node = = p_id | | E - > get ( ) . to_node = = p_id ) {
g - > connections . erase ( E ) ;
2020-01-20 14:46:49 +00:00
if ( E - > get ( ) . from_node = = p_id ) {
g - > nodes [ E - > get ( ) . to_node ] . prev_connected_nodes . erase ( p_id ) ;
2020-07-27 06:18:37 +00:00
g - > nodes [ E - > get ( ) . to_node ] . node - > set_input_port_connected ( E - > get ( ) . to_port , false ) ;
2020-01-20 14:46:49 +00:00
}
2018-07-14 21:15:42 +00:00
}
E = N ;
}
_queue_update ( ) ;
}
2020-12-30 08:45:31 +00:00
void VisualShader : : replace_node ( Type p_type , int p_id , const StringName & p_new_class ) {
ERR_FAIL_INDEX ( p_type , TYPE_MAX ) ;
ERR_FAIL_COND ( p_id < 2 ) ;
Graph * g = & graph [ p_type ] ;
ERR_FAIL_COND ( ! g - > nodes . has ( p_id ) ) ;
if ( g - > nodes [ p_id ] . node - > get_class_name ( ) = = p_new_class ) {
return ;
}
VisualShaderNode * vsn = Object : : cast_to < VisualShaderNode > ( ClassDB : : instance ( p_new_class ) ) ;
2021-01-15 18:10:32 +00:00
vsn - > connect ( " changed " , callable_mp ( this , & VisualShader : : _queue_update ) ) ;
2020-12-30 08:45:31 +00:00
g - > nodes [ p_id ] . node = Ref < VisualShaderNode > ( vsn ) ;
_queue_update ( ) ;
}
2018-07-14 21:15:42 +00:00
bool VisualShader : : is_node_connection ( Type p_type , int p_from_node , int p_from_port , int p_to_node , int p_to_port ) const {
ERR_FAIL_INDEX_V ( p_type , TYPE_MAX , false ) ;
const Graph * g = & graph [ p_type ] ;
for ( const List < Connection > : : Element * E = g - > connections . front ( ) ; E ; E = E - > next ( ) ) {
if ( E - > get ( ) . from_node = = p_from_node & & E - > get ( ) . from_port = = p_from_port & & E - > get ( ) . to_node = = p_to_node & & E - > get ( ) . to_port = = p_to_port ) {
return true ;
}
}
return false ;
}
2020-01-20 14:46:49 +00:00
bool VisualShader : : is_nodes_connected_relatively ( const Graph * p_graph , int p_node , int p_target ) const {
bool result = false ;
const VisualShader : : Node & node = p_graph - > nodes [ p_node ] ;
for ( const List < int > : : Element * E = node . prev_connected_nodes . front ( ) ; E ; E = E - > next ( ) ) {
if ( E - > get ( ) = = p_target ) {
return true ;
}
result = is_nodes_connected_relatively ( p_graph , E - > get ( ) , p_target ) ;
if ( result ) {
break ;
}
}
return result ;
}
2018-07-14 21:15:42 +00:00
bool VisualShader : : can_connect_nodes ( Type p_type , int p_from_node , int p_from_port , int p_to_node , int p_to_port ) const {
ERR_FAIL_INDEX_V ( p_type , TYPE_MAX , false ) ;
const Graph * g = & graph [ p_type ] ;
2020-05-14 14:41:43 +00:00
if ( ! g - > nodes . has ( p_from_node ) ) {
2018-07-14 21:15:42 +00:00
return false ;
2020-05-14 14:41:43 +00:00
}
2018-07-14 21:15:42 +00:00
2020-05-14 14:41:43 +00:00
if ( p_from_node = = p_to_node ) {
2019-04-24 05:44:48 +00:00
return false ;
2020-05-14 14:41:43 +00:00
}
2019-04-24 05:44:48 +00:00
2020-12-20 15:45:53 +00:00
if ( p_from_port < 0 | | p_from_port > = g - > nodes [ p_from_node ] . node - > get_expanded_output_port_count ( ) ) {
2018-07-14 21:15:42 +00:00
return false ;
2020-05-14 14:41:43 +00:00
}
2018-07-14 21:15:42 +00:00
2020-05-14 14:41:43 +00:00
if ( ! g - > nodes . has ( p_to_node ) ) {
2018-07-14 21:15:42 +00:00
return false ;
2020-05-14 14:41:43 +00:00
}
2018-07-14 21:15:42 +00:00
2020-05-14 14:41:43 +00:00
if ( p_to_port < 0 | | p_to_port > = g - > nodes [ p_to_node ] . node - > get_input_port_count ( ) ) {
2018-07-14 21:15:42 +00:00
return false ;
2020-05-14 14:41:43 +00:00
}
2018-07-14 21:15:42 +00:00
VisualShaderNode : : PortType from_port_type = g - > nodes [ p_from_node ] . node - > get_output_port_type ( p_from_port ) ;
VisualShaderNode : : PortType to_port_type = g - > nodes [ p_to_node ] . node - > get_input_port_type ( p_to_port ) ;
2019-06-26 18:50:38 +00:00
if ( ! is_port_types_compatible ( from_port_type , to_port_type ) ) {
2018-07-14 21:15:42 +00:00
return false ;
}
for ( const List < Connection > : : Element * E = g - > connections . front ( ) ; E ; E = E - > next ( ) ) {
if ( E - > get ( ) . from_node = = p_from_node & & E - > get ( ) . from_port = = p_from_port & & E - > get ( ) . to_node = = p_to_node & & E - > get ( ) . to_port = = p_to_port ) {
return false ;
}
}
2020-05-14 14:41:43 +00:00
if ( is_nodes_connected_relatively ( g , p_from_node , p_to_node ) ) {
2020-01-20 14:46:49 +00:00
return false ;
2020-05-14 14:41:43 +00:00
}
2020-01-20 14:46:49 +00:00
2018-07-14 21:15:42 +00:00
return true ;
}
2019-06-26 18:50:38 +00:00
bool VisualShader : : is_port_types_compatible ( int p_a , int p_b ) const {
2020-02-25 14:50:49 +00:00
return MAX ( 0 , p_a - 3 ) = = ( MAX ( 0 , p_b - 3 ) ) ;
2019-06-26 18:50:38 +00:00
}
2019-05-12 12:09:39 +00:00
void VisualShader : : connect_nodes_forced ( Type p_type , int p_from_node , int p_from_port , int p_to_node , int p_to_port ) {
ERR_FAIL_INDEX ( p_type , TYPE_MAX ) ;
Graph * g = & graph [ p_type ] ;
2021-02-18 21:57:41 +00:00
ERR_FAIL_COND ( ! g - > nodes . has ( p_from_node ) ) ;
2020-12-20 15:45:53 +00:00
ERR_FAIL_INDEX ( p_from_port , g - > nodes [ p_from_node ] . node - > get_expanded_output_port_count ( ) ) ;
2021-02-18 21:57:41 +00:00
ERR_FAIL_COND ( ! g - > nodes . has ( p_to_node ) ) ;
ERR_FAIL_INDEX ( p_to_port , g - > nodes [ p_to_node ] . node - > get_input_port_count ( ) ) ;
2019-05-12 12:09:39 +00:00
Connection c ;
c . from_node = p_from_node ;
c . from_port = p_from_port ;
c . to_node = p_to_node ;
c . to_port = p_to_port ;
g - > connections . push_back ( c ) ;
2020-01-20 14:46:49 +00:00
g - > nodes [ p_to_node ] . prev_connected_nodes . push_back ( p_from_node ) ;
2020-07-26 01:04:07 +00:00
g - > nodes [ p_from_node ] . node - > set_output_port_connected ( p_from_port , true ) ;
2020-07-27 06:18:37 +00:00
g - > nodes [ p_to_node ] . node - > set_input_port_connected ( p_to_port , true ) ;
2020-01-20 14:46:49 +00:00
2019-05-12 12:09:39 +00:00
_queue_update ( ) ;
}
2018-07-14 21:15:42 +00:00
Error VisualShader : : connect_nodes ( Type p_type , int p_from_node , int p_from_port , int p_to_node , int p_to_port ) {
ERR_FAIL_INDEX_V ( p_type , TYPE_MAX , ERR_CANT_CONNECT ) ;
Graph * g = & graph [ p_type ] ;
ERR_FAIL_COND_V ( ! g - > nodes . has ( p_from_node ) , ERR_INVALID_PARAMETER ) ;
2020-12-20 15:45:53 +00:00
ERR_FAIL_INDEX_V ( p_from_port , g - > nodes [ p_from_node ] . node - > get_expanded_output_port_count ( ) , ERR_INVALID_PARAMETER ) ;
2018-07-14 21:15:42 +00:00
ERR_FAIL_COND_V ( ! g - > nodes . has ( p_to_node ) , ERR_INVALID_PARAMETER ) ;
ERR_FAIL_INDEX_V ( p_to_port , g - > nodes [ p_to_node ] . node - > get_input_port_count ( ) , ERR_INVALID_PARAMETER ) ;
VisualShaderNode : : PortType from_port_type = g - > nodes [ p_from_node ] . node - > get_output_port_type ( p_from_port ) ;
VisualShaderNode : : PortType to_port_type = g - > nodes [ p_to_node ] . node - > get_input_port_type ( p_to_port ) ;
2019-08-08 20:11:48 +00:00
ERR_FAIL_COND_V_MSG ( ! is_port_types_compatible ( from_port_type , to_port_type ) , ERR_INVALID_PARAMETER , " Incompatible port types (scalar/vec/bool) with transform. " ) ;
2018-07-14 21:15:42 +00:00
for ( List < Connection > : : Element * E = g - > connections . front ( ) ; E ; E = E - > next ( ) ) {
if ( E - > get ( ) . from_node = = p_from_node & & E - > get ( ) . from_port = = p_from_port & & E - > get ( ) . to_node = = p_to_node & & E - > get ( ) . to_port = = p_to_port ) {
ERR_FAIL_V ( ERR_ALREADY_EXISTS ) ;
}
}
Connection c ;
c . from_node = p_from_node ;
c . from_port = p_from_port ;
c . to_node = p_to_node ;
c . to_port = p_to_port ;
g - > connections . push_back ( c ) ;
2020-01-20 14:46:49 +00:00
g - > nodes [ p_to_node ] . prev_connected_nodes . push_back ( p_from_node ) ;
2020-07-26 01:04:07 +00:00
g - > nodes [ p_from_node ] . node - > set_output_port_connected ( p_from_port , true ) ;
2020-07-27 06:18:37 +00:00
g - > nodes [ p_to_node ] . node - > set_input_port_connected ( p_to_port , true ) ;
2018-07-14 21:15:42 +00:00
_queue_update ( ) ;
return OK ;
}
2019-05-12 12:09:39 +00:00
2018-07-14 21:15:42 +00:00
void VisualShader : : disconnect_nodes ( Type p_type , int p_from_node , int p_from_port , int p_to_node , int p_to_port ) {
ERR_FAIL_INDEX ( p_type , TYPE_MAX ) ;
Graph * g = & graph [ p_type ] ;
for ( List < Connection > : : Element * E = g - > connections . front ( ) ; E ; E = E - > next ( ) ) {
if ( E - > get ( ) . from_node = = p_from_node & & E - > get ( ) . from_port = = p_from_port & & E - > get ( ) . to_node = = p_to_node & & E - > get ( ) . to_port = = p_to_port ) {
g - > connections . erase ( E ) ;
2020-01-20 14:46:49 +00:00
g - > nodes [ p_to_node ] . prev_connected_nodes . erase ( p_from_node ) ;
2020-07-26 01:04:07 +00:00
g - > nodes [ p_from_node ] . node - > set_output_port_connected ( p_from_port , false ) ;
2020-07-27 06:18:37 +00:00
g - > nodes [ p_to_node ] . node - > set_input_port_connected ( p_to_port , false ) ;
2018-07-14 21:15:42 +00:00
_queue_update ( ) ;
return ;
}
}
}
Array VisualShader : : _get_node_connections ( Type p_type ) const {
ERR_FAIL_INDEX_V ( p_type , TYPE_MAX , Array ( ) ) ;
const Graph * g = & graph [ p_type ] ;
Array ret ;
for ( const List < Connection > : : Element * E = g - > connections . front ( ) ; E ; E = E - > next ( ) ) {
Dictionary d ;
d [ " from_node " ] = E - > get ( ) . from_node ;
d [ " from_port " ] = E - > get ( ) . from_port ;
d [ " to_node " ] = E - > get ( ) . to_node ;
d [ " to_port " ] = E - > get ( ) . to_port ;
ret . push_back ( d ) ;
}
return ret ;
}
2019-05-12 12:09:39 +00:00
2018-07-14 21:15:42 +00:00
void VisualShader : : get_node_connections ( Type p_type , List < Connection > * r_connections ) const {
ERR_FAIL_INDEX ( p_type , TYPE_MAX ) ;
const Graph * g = & graph [ p_type ] ;
for ( const List < Connection > : : Element * E = g - > connections . front ( ) ; E ; E = E - > next ( ) ) {
r_connections - > push_back ( E - > get ( ) ) ;
}
}
void VisualShader : : set_mode ( Mode p_mode ) {
2021-02-16 13:46:20 +00:00
ERR_FAIL_INDEX_MSG ( p_mode , Mode : : MODE_MAX , vformat ( " Invalid shader mode: %d. " , p_mode ) ) ;
2018-07-14 21:15:42 +00:00
if ( shader_mode = = p_mode ) {
return ;
}
//erase input/output connections
modes . clear ( ) ;
flags . clear ( ) ;
shader_mode = p_mode ;
for ( int i = 0 ; i < TYPE_MAX ; i + + ) {
for ( Map < int , Node > : : Element * E = graph [ i ] . nodes . front ( ) ; E ; E = E - > next ( ) ) {
Ref < VisualShaderNodeInput > input = E - > get ( ) . node ;
if ( input . is_valid ( ) ) {
input - > shader_mode = shader_mode ;
//input->input_index = 0;
}
}
Ref < VisualShaderNodeOutput > output = graph [ i ] . nodes [ NODE_ID_OUTPUT ] . node ;
output - > shader_mode = shader_mode ;
// clear connections since they are no longer valid
for ( List < Connection > : : Element * E = graph [ i ] . connections . front ( ) ; E ; ) {
bool keep = true ;
List < Connection > : : Element * N = E - > next ( ) ;
int from = E - > get ( ) . from_node ;
int to = E - > get ( ) . to_node ;
if ( ! graph [ i ] . nodes . has ( from ) ) {
keep = false ;
} else {
Ref < VisualShaderNode > from_node = graph [ i ] . nodes [ from ] . node ;
if ( from_node - > is_class ( " VisualShaderNodeOutput " ) | | from_node - > is_class ( " VisualShaderNodeInput " ) ) {
keep = false ;
}
}
if ( ! graph [ i ] . nodes . has ( to ) ) {
keep = false ;
} else {
Ref < VisualShaderNode > to_node = graph [ i ] . nodes [ to ] . node ;
if ( to_node - > is_class ( " VisualShaderNodeOutput " ) | | to_node - > is_class ( " VisualShaderNodeInput " ) ) {
keep = false ;
}
}
if ( ! keep ) {
graph [ i ] . connections . erase ( E ) ;
}
E = N ;
}
}
_queue_update ( ) ;
2021-02-10 20:18:45 +00:00
notify_property_list_changed ( ) ;
2018-07-14 21:15:42 +00:00
}
void VisualShader : : set_graph_offset ( const Vector2 & p_offset ) {
graph_offset = p_offset ;
}
Vector2 VisualShader : : get_graph_offset ( ) const {
return graph_offset ;
}
Shader : : Mode VisualShader : : get_mode ( ) const {
return shader_mode ;
}
2018-09-15 01:54:59 +00:00
bool VisualShader : : is_text_shader ( ) const {
return false ;
}
2018-07-14 21:15:42 +00:00
String VisualShader : : generate_preview_shader ( Type p_type , int p_node , int p_port , Vector < DefaultTextureParam > & default_tex_params ) const {
Ref < VisualShaderNode > node = get_node ( p_type , p_node ) ;
ERR_FAIL_COND_V ( ! node . is_valid ( ) , String ( ) ) ;
2020-12-20 15:45:53 +00:00
ERR_FAIL_COND_V ( p_port < 0 | | p_port > = node - > get_expanded_output_port_count ( ) , String ( ) ) ;
2018-07-14 21:15:42 +00:00
ERR_FAIL_COND_V ( node - > get_output_port_type ( p_port ) = = VisualShaderNode : : PORT_TYPE_TRANSFORM , String ( ) ) ;
StringBuilder global_code ;
2019-07-12 09:14:34 +00:00
StringBuilder global_code_per_node ;
Map < Type , StringBuilder > global_code_per_func ;
2018-07-14 21:15:42 +00:00
StringBuilder code ;
2019-07-12 09:14:34 +00:00
Set < StringName > classes ;
2018-07-14 21:15:42 +00:00
global_code + = String ( ) + " shader_type canvas_item; \n " ;
2019-08-20 16:34:09 +00:00
String global_expressions ;
for ( int i = 0 , index = 0 ; i < TYPE_MAX ; i + + ) {
for ( Map < int , Node > : : Element * E = graph [ i ] . nodes . front ( ) ; E ; E = E - > next ( ) ) {
Ref < VisualShaderNodeGlobalExpression > global_expression = Object : : cast_to < VisualShaderNodeGlobalExpression > ( E - > get ( ) . node . ptr ( ) ) ;
if ( global_expression . is_valid ( ) ) {
String expr = " " ;
expr + = " // " + global_expression - > get_caption ( ) + " : " + itos ( index + + ) + " \n " ;
expr + = global_expression - > generate_global ( get_mode ( ) , Type ( i ) , - 1 ) ;
expr = expr . replace ( " \n " , " \n \t " ) ;
expr + = " \n " ;
global_expressions + = expr ;
}
}
}
global_code + = " \n " ;
global_code + = global_expressions ;
2018-07-14 21:15:42 +00:00
//make it faster to go around through shader
VMap < ConnectionKey , const List < Connection > : : Element * > input_connections ;
VMap < ConnectionKey , const List < Connection > : : Element * > output_connections ;
for ( const List < Connection > : : Element * E = graph [ p_type ] . connections . front ( ) ; E ; E = E - > next ( ) ) {
ConnectionKey from_key ;
from_key . node = E - > get ( ) . from_node ;
from_key . port = E - > get ( ) . from_port ;
output_connections . insert ( from_key , E ) ;
ConnectionKey to_key ;
to_key . node = E - > get ( ) . to_node ;
to_key . port = E - > get ( ) . to_port ;
input_connections . insert ( to_key , E ) ;
}
code + = " \n void fragment() { \n " ;
Set < int > processed ;
2019-07-12 09:14:34 +00:00
Error err = _write_node ( p_type , global_code , global_code_per_node , global_code_per_func , code , default_tex_params , input_connections , output_connections , p_node , processed , true , classes ) ;
2018-07-14 21:15:42 +00:00
ERR_FAIL_COND_V ( err ! = OK , String ( ) ) ;
if ( node - > get_output_port_type ( p_port ) = = VisualShaderNode : : PORT_TYPE_SCALAR ) {
2020-02-25 14:50:49 +00:00
code + = " \t COLOR.rgb = vec3(n_out " + itos ( p_node ) + " p " + itos ( p_port ) + " ); \n " ;
} else if ( node - > get_output_port_type ( p_port ) = = VisualShaderNode : : PORT_TYPE_SCALAR_INT ) {
code + = " \t COLOR.rgb = vec3(float(n_out " + itos ( p_node ) + " p " + itos ( p_port ) + " )); \n " ;
2019-02-22 17:38:58 +00:00
} else if ( node - > get_output_port_type ( p_port ) = = VisualShaderNode : : PORT_TYPE_BOOLEAN ) {
2020-02-25 14:50:49 +00:00
code + = " \t COLOR.rgb = vec3(n_out " + itos ( p_node ) + " p " + itos ( p_port ) + " ? 1.0 : 0.0); \n " ;
2018-07-14 21:15:42 +00:00
} else {
code + = " \t COLOR.rgb = n_out " + itos ( p_node ) + " p " + itos ( p_port ) + " ; \n " ;
}
code + = " } \n " ;
//set code secretly
global_code + = " \n \n " ;
String final_code = global_code ;
2019-07-12 09:14:34 +00:00
final_code + = global_code_per_node ;
2018-07-14 21:15:42 +00:00
final_code + = code ;
return final_code ;
}
# define IS_INITIAL_CHAR(m_d) (((m_d) >= 'a' && (m_d) <= 'z') || ((m_d) >= 'A' && (m_d) <= 'Z'))
# define IS_SYMBOL_CHAR(m_d) (((m_d) >= 'a' && (m_d) <= 'z') || ((m_d) >= 'A' && (m_d) <= 'Z') || ((m_d) >= '0' && (m_d) <= '9') || (m_d) == '_')
2020-12-02 09:49:46 +00:00
String VisualShader : : validate_port_name ( const String & p_port_name , VisualShaderNode * p_node , int p_port_id , bool p_output ) const {
String name = p_port_name ;
if ( name = = String ( ) ) {
return String ( ) ;
}
2019-05-12 12:09:39 +00:00
while ( name . length ( ) & & ! IS_INITIAL_CHAR ( name [ 0 ] ) ) {
name = name . substr ( 1 , name . length ( ) - 1 ) ;
}
if ( name ! = String ( ) ) {
String valid_name ;
for ( int i = 0 ; i < name . length ( ) ; i + + ) {
if ( IS_SYMBOL_CHAR ( name [ i ] ) ) {
valid_name + = String : : chr ( name [ i ] ) ;
} else if ( name [ i ] = = ' ' ) {
valid_name + = " _ " ;
}
}
name = valid_name ;
2020-12-02 09:49:46 +00:00
} else {
return String ( ) ;
2019-05-12 12:09:39 +00:00
}
2020-12-02 09:49:46 +00:00
List < String > input_names ;
List < String > output_names ;
2019-05-12 12:09:39 +00:00
2020-12-02 09:49:46 +00:00
for ( int i = 0 ; i < p_node - > get_input_port_count ( ) ; i + + ) {
if ( ! p_output & & i = = p_port_id ) {
continue ;
2019-05-12 12:09:39 +00:00
}
2020-12-02 09:49:46 +00:00
if ( name = = p_node - > get_input_port_name ( i ) ) {
return String ( ) ;
2019-05-12 12:09:39 +00:00
}
}
2020-12-02 09:49:46 +00:00
for ( int i = 0 ; i < p_node - > get_output_port_count ( ) ; i + + ) {
if ( p_output & & i = = p_port_id ) {
continue ;
}
if ( name = = p_node - > get_output_port_name ( i ) ) {
return String ( ) ;
}
2019-05-12 12:09:39 +00:00
}
return name ;
}
2018-07-14 21:15:42 +00:00
String VisualShader : : validate_uniform_name ( const String & p_name , const Ref < VisualShaderNodeUniform > & p_uniform ) const {
String name = p_name ; //validate name first
while ( name . length ( ) & & ! IS_INITIAL_CHAR ( name [ 0 ] ) ) {
name = name . substr ( 1 , name . length ( ) - 1 ) ;
}
if ( name ! = String ( ) ) {
String valid_name ;
for ( int i = 0 ; i < name . length ( ) ; i + + ) {
if ( IS_SYMBOL_CHAR ( name [ i ] ) ) {
valid_name + = String : : chr ( name [ i ] ) ;
} else if ( name [ i ] = = ' ' ) {
valid_name + = " _ " ;
}
}
name = valid_name ;
}
if ( name = = String ( ) ) {
name = p_uniform - > get_caption ( ) ;
}
int attempt = 1 ;
while ( true ) {
bool exists = false ;
for ( int i = 0 ; i < TYPE_MAX ; i + + ) {
for ( const Map < int , Node > : : Element * E = graph [ i ] . nodes . front ( ) ; E ; E = E - > next ( ) ) {
Ref < VisualShaderNodeUniform > node = E - > get ( ) . node ;
if ( node = = p_uniform ) { //do not test on self
continue ;
}
if ( node . is_valid ( ) & & node - > get_uniform_name ( ) = = name ) {
exists = true ;
break ;
}
}
if ( exists ) {
break ;
}
}
if ( exists ) {
//remove numbers, put new and try again
attempt + + ;
while ( name . length ( ) & & name [ name . length ( ) - 1 ] > = ' 0 ' & & name [ name . length ( ) - 1 ] < = ' 9 ' ) {
name = name . substr ( 0 , name . length ( ) - 1 ) ;
}
ERR_FAIL_COND_V ( name = = String ( ) , String ( ) ) ;
name + = itos ( attempt ) ;
} else {
break ;
}
}
return name ;
}
VisualShader : : RenderModeEnums VisualShader : : render_mode_enums [ ] = {
{ Shader : : MODE_SPATIAL , " blend " } ,
{ Shader : : MODE_SPATIAL , " depth_draw " } ,
{ Shader : : MODE_SPATIAL , " cull " } ,
{ Shader : : MODE_SPATIAL , " diffuse " } ,
{ Shader : : MODE_SPATIAL , " specular " } ,
{ Shader : : MODE_CANVAS_ITEM , " blend " } ,
2020-04-01 23:20:12 +00:00
{ Shader : : MODE_CANVAS_ITEM , nullptr }
2018-07-14 21:15:42 +00:00
} ;
static const char * type_string [ VisualShader : : TYPE_MAX ] = {
" vertex " ,
" fragment " ,
2020-09-02 20:25:54 +00:00
" light " ,
2020-09-15 07:57:40 +00:00
" start " ,
2020-09-07 07:28:13 +00:00
" process " ,
2020-09-15 07:57:40 +00:00
" collide " ,
" start_custom " ,
" process_custom " ,
2021-04-17 17:16:03 +00:00
" sky " ,
2018-07-14 21:15:42 +00:00
} ;
2020-09-07 07:28:13 +00:00
2018-07-14 21:15:42 +00:00
bool VisualShader : : _set ( const StringName & p_name , const Variant & p_value ) {
String name = p_name ;
if ( name = = " mode " ) {
set_mode ( Shader : : Mode ( int ( p_value ) ) ) ;
return true ;
} else if ( name . begins_with ( " flags/ " ) ) {
StringName flag = name . get_slicec ( ' / ' , 1 ) ;
bool enable = p_value ;
if ( enable ) {
flags . insert ( flag ) ;
} else {
flags . erase ( flag ) ;
}
_queue_update ( ) ;
return true ;
} else if ( name . begins_with ( " modes/ " ) ) {
String mode = name . get_slicec ( ' / ' , 1 ) ;
int value = p_value ;
if ( value = = 0 ) {
2019-02-13 08:23:29 +00:00
modes . erase ( mode ) ; //means it's default anyway, so don't store it
2018-07-14 21:15:42 +00:00
} else {
modes [ mode ] = value ;
}
_queue_update ( ) ;
return true ;
} else if ( name . begins_with ( " nodes/ " ) ) {
String typestr = name . get_slicec ( ' / ' , 1 ) ;
Type type = TYPE_VERTEX ;
for ( int i = 0 ; i < TYPE_MAX ; i + + ) {
if ( typestr = = type_string [ i ] ) {
type = Type ( i ) ;
break ;
}
}
String index = name . get_slicec ( ' / ' , 2 ) ;
if ( index = = " connections " ) {
Vector < int > conns = p_value ;
if ( conns . size ( ) % 4 = = 0 ) {
for ( int i = 0 ; i < conns . size ( ) ; i + = 4 ) {
2019-05-12 12:09:39 +00:00
connect_nodes_forced ( type , conns [ i + 0 ] , conns [ i + 1 ] , conns [ i + 2 ] , conns [ i + 3 ] ) ;
2018-07-14 21:15:42 +00:00
}
}
return true ;
}
int id = index . to_int ( ) ;
String what = name . get_slicec ( ' / ' , 3 ) ;
if ( what = = " node " ) {
add_node ( type , p_value , Vector2 ( ) , id ) ;
return true ;
} else if ( what = = " position " ) {
set_node_position ( type , id , p_value ) ;
return true ;
2019-05-12 12:09:39 +00:00
} else if ( what = = " size " ) {
2020-10-04 09:11:58 +00:00
( ( VisualShaderNodeResizableBase * ) get_node ( type , id ) . ptr ( ) ) - > set_size ( p_value ) ;
2019-05-12 12:09:39 +00:00
return true ;
} else if ( what = = " input_ports " ) {
( ( VisualShaderNodeGroupBase * ) get_node ( type , id ) . ptr ( ) ) - > set_inputs ( p_value ) ;
return true ;
} else if ( what = = " output_ports " ) {
( ( VisualShaderNodeGroupBase * ) get_node ( type , id ) . ptr ( ) ) - > set_outputs ( p_value ) ;
return true ;
} else if ( what = = " expression " ) {
( ( VisualShaderNodeExpression * ) get_node ( type , id ) . ptr ( ) ) - > set_expression ( p_value ) ;
return true ;
2018-07-14 21:15:42 +00:00
}
}
return false ;
}
bool VisualShader : : _get ( const StringName & p_name , Variant & r_ret ) const {
String name = p_name ;
if ( name = = " mode " ) {
r_ret = get_mode ( ) ;
return true ;
} else if ( name . begins_with ( " flags/ " ) ) {
StringName flag = name . get_slicec ( ' / ' , 1 ) ;
r_ret = flags . has ( flag ) ;
return true ;
} else if ( name . begins_with ( " modes/ " ) ) {
String mode = name . get_slicec ( ' / ' , 1 ) ;
if ( modes . has ( mode ) ) {
r_ret = modes [ mode ] ;
} else {
r_ret = 0 ;
}
return true ;
} else if ( name . begins_with ( " nodes/ " ) ) {
String typestr = name . get_slicec ( ' / ' , 1 ) ;
Type type = TYPE_VERTEX ;
for ( int i = 0 ; i < TYPE_MAX ; i + + ) {
if ( typestr = = type_string [ i ] ) {
type = Type ( i ) ;
break ;
}
}
String index = name . get_slicec ( ' / ' , 2 ) ;
if ( index = = " connections " ) {
Vector < int > conns ;
for ( const List < Connection > : : Element * E = graph [ type ] . connections . front ( ) ; E ; E = E - > next ( ) ) {
conns . push_back ( E - > get ( ) . from_node ) ;
conns . push_back ( E - > get ( ) . from_port ) ;
conns . push_back ( E - > get ( ) . to_node ) ;
conns . push_back ( E - > get ( ) . to_port ) ;
}
r_ret = conns ;
return true ;
}
int id = index . to_int ( ) ;
String what = name . get_slicec ( ' / ' , 3 ) ;
if ( what = = " node " ) {
r_ret = get_node ( type , id ) ;
return true ;
} else if ( what = = " position " ) {
r_ret = get_node_position ( type , id ) ;
return true ;
2019-05-12 12:09:39 +00:00
} else if ( what = = " size " ) {
2020-10-04 09:11:58 +00:00
r_ret = ( ( VisualShaderNodeResizableBase * ) get_node ( type , id ) . ptr ( ) ) - > get_size ( ) ;
2019-05-12 12:09:39 +00:00
return true ;
} else if ( what = = " input_ports " ) {
r_ret = ( ( VisualShaderNodeGroupBase * ) get_node ( type , id ) . ptr ( ) ) - > get_inputs ( ) ;
return true ;
} else if ( what = = " output_ports " ) {
r_ret = ( ( VisualShaderNodeGroupBase * ) get_node ( type , id ) . ptr ( ) ) - > get_outputs ( ) ;
return true ;
} else if ( what = = " expression " ) {
r_ret = ( ( VisualShaderNodeExpression * ) get_node ( type , id ) . ptr ( ) ) - > get_expression ( ) ;
return true ;
2018-07-14 21:15:42 +00:00
}
}
return false ;
}
2021-02-11 17:18:45 +00:00
void VisualShader : : reset_state ( ) {
# ifndef _MSC_VER
# warning everything needs to be cleared here
# endif
emit_changed ( ) ;
}
2020-02-25 14:50:49 +00:00
void VisualShader : : _get_property_list ( List < PropertyInfo > * p_list ) const {
2018-07-14 21:15:42 +00:00
//mode
2020-03-26 21:49:16 +00:00
p_list - > push_back ( PropertyInfo ( Variant : : INT , " mode " , PROPERTY_HINT_ENUM , " Node3D,CanvasItem,Particles,Sky " ) ) ;
2018-07-14 21:15:42 +00:00
//render modes
Map < String , String > blend_mode_enums ;
Set < String > toggles ;
2020-03-27 18:21:27 +00:00
for ( int i = 0 ; i < ShaderTypes : : get_singleton ( ) - > get_modes ( RenderingServer : : ShaderMode ( shader_mode ) ) . size ( ) ; i + + ) {
String mode = ShaderTypes : : get_singleton ( ) - > get_modes ( RenderingServer : : ShaderMode ( shader_mode ) ) [ i ] ;
2018-07-14 21:15:42 +00:00
int idx = 0 ;
bool in_enum = false ;
while ( render_mode_enums [ idx ] . string ) {
if ( mode . begins_with ( render_mode_enums [ idx ] . string ) ) {
String begin = render_mode_enums [ idx ] . string ;
String option = mode . replace_first ( begin + " _ " , " " ) ;
if ( ! blend_mode_enums . has ( begin ) ) {
blend_mode_enums [ begin ] = option ;
} else {
blend_mode_enums [ begin ] + = " , " + option ;
}
in_enum = true ;
break ;
}
idx + + ;
}
if ( ! in_enum ) {
toggles . insert ( mode ) ;
}
}
for ( Map < String , String > : : Element * E = blend_mode_enums . front ( ) ; E ; E = E - > next ( ) ) {
p_list - > push_back ( PropertyInfo ( Variant : : INT , " modes/ " + E - > key ( ) , PROPERTY_HINT_ENUM , E - > get ( ) ) ) ;
}
for ( Set < String > : : Element * E = toggles . front ( ) ; E ; E = E - > next ( ) ) {
p_list - > push_back ( PropertyInfo ( Variant : : BOOL , " flags/ " + E - > get ( ) ) ) ;
}
for ( int i = 0 ; i < TYPE_MAX ; i + + ) {
for ( Map < int , Node > : : Element * E = graph [ i ] . nodes . front ( ) ; E ; E = E - > next ( ) ) {
String prop_name = " nodes/ " ;
prop_name + = type_string [ i ] ;
prop_name + = " / " + itos ( E - > key ( ) ) ;
if ( E - > key ( ) ! = NODE_ID_OUTPUT ) {
p_list - > push_back ( PropertyInfo ( Variant : : OBJECT , prop_name + " /node " , PROPERTY_HINT_RESOURCE_TYPE , " VisualShaderNode " , PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE ) ) ;
}
p_list - > push_back ( PropertyInfo ( Variant : : VECTOR2 , prop_name + " /position " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR ) ) ;
2019-05-12 12:09:39 +00:00
2020-04-01 23:20:12 +00:00
if ( Object : : cast_to < VisualShaderNodeGroupBase > ( E - > get ( ) . node . ptr ( ) ) ! = nullptr ) {
2019-05-12 12:09:39 +00:00
p_list - > push_back ( PropertyInfo ( Variant : : VECTOR2 , prop_name + " /size " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : STRING , prop_name + " /input_ports " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR ) ) ;
p_list - > push_back ( PropertyInfo ( Variant : : STRING , prop_name + " /output_ports " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR ) ) ;
}
2020-04-01 23:20:12 +00:00
if ( Object : : cast_to < VisualShaderNodeExpression > ( E - > get ( ) . node . ptr ( ) ) ! = nullptr ) {
2019-05-12 12:09:39 +00:00
p_list - > push_back ( PropertyInfo ( Variant : : STRING , prop_name + " /expression " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR ) ) ;
}
2018-07-14 21:15:42 +00:00
}
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
p_list - > push_back ( PropertyInfo ( Variant : : PACKED_INT32_ARRAY , " nodes/ " + String ( type_string [ i ] ) + " /connections " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR ) ) ;
2018-07-14 21:15:42 +00:00
}
}
2019-07-12 09:14:34 +00:00
Error VisualShader : : _write_node ( Type type , StringBuilder & global_code , StringBuilder & global_code_per_node , Map < Type , StringBuilder > & global_code_per_func , StringBuilder & code , Vector < VisualShader : : DefaultTextureParam > & def_tex_params , const VMap < ConnectionKey , const List < Connection > : : Element * > & input_connections , const VMap < ConnectionKey , const List < Connection > : : Element * > & output_connections , int node , Set < int > & processed , bool for_preview , Set < StringName > & r_classes ) const {
2018-07-14 21:15:42 +00:00
const Ref < VisualShaderNode > vsnode = graph [ type ] . nodes [ node ] . node ;
2021-05-27 19:17:58 +00:00
if ( vsnode - > is_disabled ( ) ) {
code + = " // " + vsnode - > get_caption ( ) + " : " + itos ( node ) + " \n " ;
code + = " \t // Node is disabled and code is not generated. \n " ;
return OK ;
}
2018-07-14 21:15:42 +00:00
//check inputs recursively first
int input_count = vsnode - > get_input_port_count ( ) ;
for ( int i = 0 ; i < input_count ; i + + ) {
ConnectionKey ck ;
ck . node = node ;
ck . port = i ;
if ( input_connections . has ( ck ) ) {
int from_node = input_connections [ ck ] - > get ( ) . from_node ;
if ( processed . has ( from_node ) ) {
continue ;
}
2019-07-12 09:14:34 +00:00
Error err = _write_node ( type , global_code , global_code_per_node , global_code_per_func , code , def_tex_params , input_connections , output_connections , from_node , processed , for_preview , r_classes ) ;
2020-05-14 14:41:43 +00:00
if ( err ) {
2018-07-14 21:15:42 +00:00
return err ;
2020-05-14 14:41:43 +00:00
}
2018-07-14 21:15:42 +00:00
}
}
// then this node
2020-07-26 01:04:07 +00:00
Vector < VisualShader : : DefaultTextureParam > params = vsnode - > get_default_texture_parameters ( type , node ) ;
for ( int i = 0 ; i < params . size ( ) ; i + + ) {
def_tex_params . push_back ( params [ i ] ) ;
}
Ref < VisualShaderNodeInput > input = vsnode ;
bool skip_global = input . is_valid ( ) & & for_preview ;
if ( ! skip_global ) {
2020-07-28 08:02:57 +00:00
Ref < VisualShaderNodeUniform > uniform = vsnode ;
if ( ! uniform . is_valid ( ) | | ! uniform - > is_global_code_generated ( ) ) {
global_code + = vsnode - > generate_global ( get_mode ( ) , type , node ) ;
}
2020-07-26 01:04:07 +00:00
String class_name = vsnode - > get_class_name ( ) ;
if ( class_name = = " VisualShaderNodeCustom " ) {
class_name = vsnode - > get_script_instance ( ) - > get_script ( ) - > get_path ( ) ;
}
if ( ! r_classes . has ( class_name ) ) {
global_code_per_node + = vsnode - > generate_global_per_node ( get_mode ( ) , type , node ) ;
for ( int i = 0 ; i < TYPE_MAX ; i + + ) {
global_code_per_func [ Type ( i ) ] + = vsnode - > generate_global_per_func ( get_mode ( ) , Type ( i ) , node ) ;
}
r_classes . insert ( class_name ) ;
}
}
if ( ! vsnode - > is_code_generated ( ) ) { // just generate globals and ignore locals
processed . insert ( node ) ;
return OK ;
}
2020-09-15 07:57:40 +00:00
String node_name = " // " + vsnode - > get_caption ( ) + " : " + itos ( node ) + " \n " ;
String node_code ;
2018-07-14 21:15:42 +00:00
Vector < String > input_vars ;
input_vars . resize ( vsnode - > get_input_port_count ( ) ) ;
String * inputs = input_vars . ptrw ( ) ;
for ( int i = 0 ; i < input_count ; i + + ) {
ConnectionKey ck ;
ck . node = node ;
ck . port = i ;
if ( input_connections . has ( ck ) ) {
//connected to something, use that output
int from_node = input_connections [ ck ] - > get ( ) . from_node ;
2021-05-27 19:17:58 +00:00
if ( graph [ type ] . nodes [ from_node ] . node - > is_disabled ( ) ) {
continue ;
}
2018-07-14 21:15:42 +00:00
int from_port = input_connections [ ck ] - > get ( ) . from_port ;
VisualShaderNode : : PortType in_type = vsnode - > get_input_port_type ( i ) ;
VisualShaderNode : : PortType out_type = graph [ type ] . nodes [ from_node ] . node - > get_output_port_type ( from_port ) ;
String src_var = " n_out " + itos ( from_node ) + " p " + itos ( from_port ) ;
2019-10-01 08:51:50 +00:00
if ( in_type = = VisualShaderNode : : PORT_TYPE_SAMPLER & & out_type = = VisualShaderNode : : PORT_TYPE_SAMPLER ) {
2019-11-04 15:50:33 +00:00
VisualShaderNode * ptr = const_cast < VisualShaderNode * > ( graph [ type ] . nodes [ from_node ] . node . ptr ( ) ) ;
if ( ptr - > has_method ( " get_input_real_name " ) ) {
inputs [ i ] = ptr - > call ( " get_input_real_name " ) ;
} else if ( ptr - > has_method ( " get_uniform_name " ) ) {
inputs [ i ] = ptr - > call ( " get_uniform_name " ) ;
2019-10-01 08:51:50 +00:00
} else {
2019-11-04 15:50:33 +00:00
inputs [ i ] = " " ;
2019-10-01 08:51:50 +00:00
}
} else if ( in_type = = out_type ) {
2018-07-14 21:15:42 +00:00
inputs [ i ] = src_var ;
} else if ( in_type = = VisualShaderNode : : PORT_TYPE_SCALAR & & out_type = = VisualShaderNode : : PORT_TYPE_VECTOR ) {
2020-01-27 09:10:51 +00:00
inputs [ i ] = " dot( " + src_var + " , vec3(0.333333, 0.333333, 0.333333)) " ;
2020-02-25 14:50:49 +00:00
} else if ( in_type = = VisualShaderNode : : PORT_TYPE_SCALAR_INT & & out_type = = VisualShaderNode : : PORT_TYPE_VECTOR ) {
inputs [ i ] = " dot(float( " + src_var + " ), vec3(0.333333, 0.333333, 0.333333)) " ;
2018-07-14 21:15:42 +00:00
} else if ( in_type = = VisualShaderNode : : PORT_TYPE_VECTOR & & out_type = = VisualShaderNode : : PORT_TYPE_SCALAR ) {
inputs [ i ] = " vec3( " + src_var + " ) " ;
2020-02-25 14:50:49 +00:00
} else if ( in_type = = VisualShaderNode : : PORT_TYPE_VECTOR & & out_type = = VisualShaderNode : : PORT_TYPE_SCALAR_INT ) {
inputs [ i ] = " vec3(float( " + src_var + " )) " ;
2019-02-22 17:38:58 +00:00
} else if ( in_type = = VisualShaderNode : : PORT_TYPE_BOOLEAN & & out_type = = VisualShaderNode : : PORT_TYPE_VECTOR ) {
2019-04-13 12:24:04 +00:00
inputs [ i ] = " all(bvec3( " + src_var + " )) " ;
2019-02-22 17:38:58 +00:00
} else if ( in_type = = VisualShaderNode : : PORT_TYPE_BOOLEAN & & out_type = = VisualShaderNode : : PORT_TYPE_SCALAR ) {
2020-01-27 09:10:51 +00:00
inputs [ i ] = src_var + " > 0.0 ? true : false " ;
2020-02-25 14:50:49 +00:00
} else if ( in_type = = VisualShaderNode : : PORT_TYPE_BOOLEAN & & out_type = = VisualShaderNode : : PORT_TYPE_SCALAR_INT ) {
inputs [ i ] = src_var + " > 0 ? true : false " ;
2019-02-22 17:38:58 +00:00
} else if ( in_type = = VisualShaderNode : : PORT_TYPE_SCALAR & & out_type = = VisualShaderNode : : PORT_TYPE_BOOLEAN ) {
2020-10-27 07:19:11 +00:00
inputs [ i ] = " ( " + src_var + " ? 1.0 : 0.0) " ;
2020-02-25 14:50:49 +00:00
} else if ( in_type = = VisualShaderNode : : PORT_TYPE_SCALAR_INT & & out_type = = VisualShaderNode : : PORT_TYPE_BOOLEAN ) {
2020-10-27 07:19:11 +00:00
inputs [ i ] = " ( " + src_var + " ? 1 : 0) " ;
2019-02-22 17:38:58 +00:00
} else if ( in_type = = VisualShaderNode : : PORT_TYPE_VECTOR & & out_type = = VisualShaderNode : : PORT_TYPE_BOOLEAN ) {
2020-01-27 09:10:51 +00:00
inputs [ i ] = " vec3( " + src_var + " ? 1.0 : 0.0) " ;
2020-02-25 14:50:49 +00:00
} else if ( in_type = = VisualShaderNode : : PORT_TYPE_SCALAR & & out_type = = VisualShaderNode : : PORT_TYPE_SCALAR_INT ) {
inputs [ i ] = " float( " + src_var + " ) " ;
} else if ( in_type = = VisualShaderNode : : PORT_TYPE_SCALAR_INT & & out_type = = VisualShaderNode : : PORT_TYPE_SCALAR ) {
inputs [ i ] = " int( " + src_var + " ) " ;
2018-07-14 21:15:42 +00:00
}
} else {
2020-07-27 06:18:37 +00:00
if ( ! vsnode - > is_generate_input_var ( i ) ) {
continue ;
}
2018-07-14 21:15:42 +00:00
Variant defval = vsnode - > get_input_port_default_value ( i ) ;
2020-02-25 14:50:49 +00:00
if ( defval . get_type ( ) = = Variant : : FLOAT ) {
2018-07-14 21:15:42 +00:00
float val = defval ;
inputs [ i ] = " n_in " + itos ( node ) + " p " + itos ( i ) ;
2020-09-15 07:57:40 +00:00
node_code + = " \t float " + inputs [ i ] + " = " + vformat ( " %.5f " , val ) + " ; \n " ;
2020-02-25 14:50:49 +00:00
} else if ( defval . get_type ( ) = = Variant : : INT ) {
int val = defval ;
inputs [ i ] = " n_in " + itos ( node ) + " p " + itos ( i ) ;
2020-09-15 07:57:40 +00:00
node_code + = " \t int " + inputs [ i ] + " = " + itos ( val ) + " ; \n " ;
2019-02-22 17:38:58 +00:00
} else if ( defval . get_type ( ) = = Variant : : BOOL ) {
bool val = defval ;
inputs [ i ] = " n_in " + itos ( node ) + " p " + itos ( i ) ;
2020-09-15 07:57:40 +00:00
node_code + = " \t bool " + inputs [ i ] + " = " + ( val ? " true " : " false " ) + " ; \n " ;
2018-07-14 21:15:42 +00:00
} else if ( defval . get_type ( ) = = Variant : : VECTOR3 ) {
Vector3 val = defval ;
inputs [ i ] = " n_in " + itos ( node ) + " p " + itos ( i ) ;
2020-09-15 07:57:40 +00:00
node_code + = " \t vec3 " + inputs [ i ] + " = " + vformat ( " vec3(%.5f, %.5f, %.5f); \n " , val . x , val . y , val . z ) ;
2021-04-28 07:36:08 +00:00
} else if ( defval . get_type ( ) = = Variant : : TRANSFORM3D ) {
2020-10-17 05:08:21 +00:00
Transform3D val = defval ;
2018-07-14 21:15:42 +00:00
val . basis . transpose ( ) ;
inputs [ i ] = " n_in " + itos ( node ) + " p " + itos ( i ) ;
Array values ;
2018-09-27 11:11:41 +00:00
for ( int j = 0 ; j < 3 ; j + + ) {
values . push_back ( val . basis [ j ] . x ) ;
values . push_back ( val . basis [ j ] . y ) ;
values . push_back ( val . basis [ j ] . z ) ;
2018-07-14 21:15:42 +00:00
}
values . push_back ( val . origin . x ) ;
values . push_back ( val . origin . y ) ;
values . push_back ( val . origin . z ) ;
bool err = false ;
2020-09-15 07:57:40 +00:00
node_code + = " \t mat4 " + inputs [ i ] + " = " + String ( " mat4(vec4(%.5f, %.5f, %.5f, 0.0), vec4(%.5f, %.5f, %.5f, 0.0), vec4(%.5f, %.5f, %.5f, 0.0), vec4(%.5f, %.5f, %.5f, 1.0)); \n " ) . sprintf ( values , & err ) ;
2018-07-14 21:15:42 +00:00
} else {
//will go empty, node is expected to know what it is doing at this point and handle it
}
}
}
int output_count = vsnode - > get_output_port_count ( ) ;
2020-12-20 15:45:53 +00:00
int initial_output_count = output_count ;
Map < int , bool > expanded_output_ports ;
for ( int i = 0 ; i < initial_output_count ; i + + ) {
bool expanded = false ;
if ( vsnode - > is_output_port_expandable ( i ) & & vsnode - > _is_output_port_expanded ( i ) ) {
expanded = true ;
if ( vsnode - > get_output_port_type ( i ) = = VisualShaderNode : : PORT_TYPE_VECTOR ) {
output_count + = 3 ;
}
}
expanded_output_ports . insert ( i , expanded ) ;
}
2018-07-14 21:15:42 +00:00
Vector < String > output_vars ;
2020-12-20 15:45:53 +00:00
output_vars . resize ( output_count ) ;
2018-07-14 21:15:42 +00:00
String * outputs = output_vars . ptrw ( ) ;
2020-01-27 09:10:51 +00:00
if ( vsnode - > is_simple_decl ( ) ) { // less code to generate for some simple_decl nodes
2020-12-20 15:45:53 +00:00
for ( int i = 0 , j = 0 ; i < initial_output_count ; i + + , j + + ) {
String var_name = " n_out " + itos ( node ) + " p " + itos ( j ) ;
2020-01-27 09:10:51 +00:00
switch ( vsnode - > get_output_port_type ( i ) ) {
2020-05-10 11:00:47 +00:00
case VisualShaderNode : : PORT_TYPE_SCALAR :
outputs [ i ] = " float " + var_name ;
break ;
case VisualShaderNode : : PORT_TYPE_SCALAR_INT :
outputs [ i ] = " int " + var_name ;
break ;
case VisualShaderNode : : PORT_TYPE_VECTOR :
outputs [ i ] = " vec3 " + var_name ;
break ;
case VisualShaderNode : : PORT_TYPE_BOOLEAN :
outputs [ i ] = " bool " + var_name ;
break ;
case VisualShaderNode : : PORT_TYPE_TRANSFORM :
outputs [ i ] = " mat4 " + var_name ;
break ;
2020-01-27 09:10:51 +00:00
default : {
}
}
2020-12-20 15:45:53 +00:00
if ( expanded_output_ports [ i ] ) {
if ( vsnode - > get_output_port_type ( i ) = = VisualShaderNode : : PORT_TYPE_VECTOR ) {
j + = 3 ;
}
}
2020-01-27 09:10:51 +00:00
}
2018-07-14 21:15:42 +00:00
2020-01-27 09:10:51 +00:00
} else {
2020-12-20 15:45:53 +00:00
for ( int i = 0 , j = 0 ; i < initial_output_count ; i + + , j + + ) {
outputs [ i ] = " n_out " + itos ( node ) + " p " + itos ( j ) ;
2020-01-27 09:10:51 +00:00
switch ( vsnode - > get_output_port_type ( i ) ) {
2020-05-10 11:00:47 +00:00
case VisualShaderNode : : PORT_TYPE_SCALAR :
2020-12-20 15:45:53 +00:00
code + = " \t float " + outputs [ i ] + " ; \n " ;
2020-05-10 11:00:47 +00:00
break ;
case VisualShaderNode : : PORT_TYPE_SCALAR_INT :
2020-12-20 15:45:53 +00:00
code + = " \t int " + outputs [ i ] + " ; \n " ;
2020-05-10 11:00:47 +00:00
break ;
case VisualShaderNode : : PORT_TYPE_VECTOR :
2020-12-20 15:45:53 +00:00
code + = " \t vec3 " + outputs [ i ] + " ; \n " ;
2020-05-10 11:00:47 +00:00
break ;
case VisualShaderNode : : PORT_TYPE_BOOLEAN :
2020-12-20 15:45:53 +00:00
code + = " \t bool " + outputs [ i ] + " ; \n " ;
2020-05-10 11:00:47 +00:00
break ;
case VisualShaderNode : : PORT_TYPE_TRANSFORM :
2020-12-20 15:45:53 +00:00
code + = " \t mat4 " + outputs [ i ] + " ; \n " ;
2020-05-10 11:00:47 +00:00
break ;
2020-01-27 09:10:51 +00:00
default : {
}
2019-04-09 15:08:36 +00:00
}
2020-12-20 15:45:53 +00:00
if ( expanded_output_ports [ i ] ) {
if ( vsnode - > get_output_port_type ( i ) = = VisualShaderNode : : PORT_TYPE_VECTOR ) {
j + = 3 ;
}
}
2018-07-14 21:15:42 +00:00
}
}
2020-09-15 07:57:40 +00:00
node_code + = vsnode - > generate_code ( get_mode ( ) , type , node , inputs , outputs , for_preview ) ;
if ( node_code ! = String ( ) ) {
code + = node_name ;
code + = node_code ;
code + = " \n " ;
}
2019-01-21 19:07:53 +00:00
2020-12-20 15:45:53 +00:00
for ( int i = 0 ; i < output_count ; i + + ) {
bool new_line_inserted = false ;
if ( expanded_output_ports [ i ] ) {
if ( vsnode - > get_output_port_type ( i ) = = VisualShaderNode : : PORT_TYPE_VECTOR ) {
if ( vsnode - > is_output_port_connected ( i + 1 ) | | ( for_preview & & vsnode - > get_output_port_for_preview ( ) = = ( i + 1 ) ) ) { // red-component
if ( ! new_line_inserted ) {
code + = " \n " ;
new_line_inserted = true ;
}
String r = " n_out " + itos ( node ) + " p " + itos ( i + 1 ) ;
code + = " \t float " + r + " = n_out " + itos ( node ) + " p " + itos ( i ) + " .r; \n " ;
outputs [ i + 1 ] = r ;
}
if ( vsnode - > is_output_port_connected ( i + 2 ) | | ( for_preview & & vsnode - > get_output_port_for_preview ( ) = = ( i + 2 ) ) ) { // green-component
if ( ! new_line_inserted ) {
code + = " \n " ;
new_line_inserted = true ;
}
String g = " n_out " + itos ( node ) + " p " + itos ( i + 2 ) ;
code + = " \t float " + g + " = n_out " + itos ( node ) + " p " + itos ( i ) + " .g; \n " ;
outputs [ i + 2 ] = g ;
}
if ( vsnode - > is_output_port_connected ( i + 3 ) | | ( for_preview & & vsnode - > get_output_port_for_preview ( ) = = ( i + 3 ) ) ) { // blue-component
if ( ! new_line_inserted ) {
code + = " \n " ;
new_line_inserted = true ;
}
String b = " n_out " + itos ( node ) + " p " + itos ( i + 3 ) ;
code + = " \t float " + b + " = n_out " + itos ( node ) + " p " + itos ( i ) + " .b; \n " ;
outputs [ i + 3 ] = b ;
}
i + = 3 ;
}
}
}
2018-07-14 21:15:42 +00:00
code + = " \n " ; //
processed . insert ( node ) ;
return OK ;
}
2020-09-07 07:28:13 +00:00
bool VisualShader : : has_func_name ( RenderingServer : : ShaderMode p_mode , const String & p_func_name ) const {
if ( ! ShaderTypes : : get_singleton ( ) - > get_functions ( p_mode ) . has ( p_func_name ) ) {
if ( p_mode = = RenderingServer : : ShaderMode : : SHADER_PARTICLES ) {
2020-09-15 07:57:40 +00:00
if ( p_func_name = = " start_custom " | | p_func_name = = " process_custom " | | p_func_name = = " collide " ) {
2020-09-07 07:28:13 +00:00
return true ;
}
}
return false ;
}
return true ;
}
2018-07-14 21:15:42 +00:00
void VisualShader : : _update_shader ( ) const {
2021-02-10 18:22:13 +00:00
if ( ! dirty . is_set ( ) ) {
2018-07-14 21:15:42 +00:00
return ;
2020-05-14 14:41:43 +00:00
}
2018-07-14 21:15:42 +00:00
2021-02-10 18:22:13 +00:00
dirty . clear ( ) ;
2018-07-14 21:15:42 +00:00
StringBuilder global_code ;
2019-07-12 09:14:34 +00:00
StringBuilder global_code_per_node ;
Map < Type , StringBuilder > global_code_per_func ;
2018-07-14 21:15:42 +00:00
StringBuilder code ;
Vector < VisualShader : : DefaultTextureParam > default_tex_params ;
2019-07-12 09:14:34 +00:00
Set < StringName > classes ;
2020-03-25 09:22:29 +00:00
Map < int , int > insertion_pos ;
static const char * shader_mode_str [ Shader : : MODE_MAX ] = { " spatial " , " canvas_item " , " particles " , " sky " } ;
2018-07-14 21:15:42 +00:00
global_code + = String ( ) + " shader_type " + shader_mode_str [ shader_mode ] + " ; \n " ;
String render_mode ;
{
//fill render mode enums
int idx = 0 ;
2020-08-26 10:23:16 +00:00
bool specular = false ;
2018-07-14 21:15:42 +00:00
while ( render_mode_enums [ idx ] . string ) {
if ( shader_mode = = render_mode_enums [ idx ] . mode ) {
2020-08-26 10:23:16 +00:00
if ( shader_mode = = Shader : : MODE_SPATIAL ) {
if ( String ( render_mode_enums [ idx ] . string ) = = " specular " ) {
specular = true ;
}
}
if ( modes . has ( render_mode_enums [ idx ] . string ) | | specular ) {
int which = 0 ;
if ( modes . has ( render_mode_enums [ idx ] . string ) ) {
which = modes [ render_mode_enums [ idx ] . string ] ;
}
2018-07-14 21:15:42 +00:00
int count = 0 ;
2020-03-27 18:21:27 +00:00
for ( int i = 0 ; i < ShaderTypes : : get_singleton ( ) - > get_modes ( RenderingServer : : ShaderMode ( shader_mode ) ) . size ( ) ; i + + ) {
String mode = ShaderTypes : : get_singleton ( ) - > get_modes ( RenderingServer : : ShaderMode ( shader_mode ) ) [ i ] ;
2018-07-14 21:15:42 +00:00
if ( mode . begins_with ( render_mode_enums [ idx ] . string ) ) {
if ( count = = which ) {
if ( render_mode ! = String ( ) ) {
render_mode + = " , " ;
}
render_mode + = mode ;
break ;
}
count + + ;
}
}
}
}
idx + + ;
}
//fill render mode flags
2020-03-27 18:21:27 +00:00
for ( int i = 0 ; i < ShaderTypes : : get_singleton ( ) - > get_modes ( RenderingServer : : ShaderMode ( shader_mode ) ) . size ( ) ; i + + ) {
String mode = ShaderTypes : : get_singleton ( ) - > get_modes ( RenderingServer : : ShaderMode ( shader_mode ) ) [ i ] ;
2018-07-14 21:15:42 +00:00
if ( flags . has ( mode ) ) {
if ( render_mode ! = String ( ) ) {
render_mode + = " , " ;
}
render_mode + = mode ;
}
}
}
if ( render_mode ! = String ( ) ) {
global_code + = " render_mode " + render_mode + " ; \n \n " ;
}
2020-09-15 07:57:40 +00:00
static const char * func_name [ TYPE_MAX ] = { " vertex " , " fragment " , " light " , " start " , " process " , " collide " , " start_custom " , " process_custom " , " sky " } ;
2018-07-14 21:15:42 +00:00
2019-08-18 05:09:05 +00:00
String global_expressions ;
2020-07-28 08:02:57 +00:00
Set < String > used_uniform_names ;
List < VisualShaderNodeUniform * > uniforms ;
2020-09-15 07:57:40 +00:00
Map < int , List < int > > emitters ;
2020-07-28 08:02:57 +00:00
2019-08-18 05:09:05 +00:00
for ( int i = 0 , index = 0 ; i < TYPE_MAX ; i + + ) {
2020-09-07 07:28:13 +00:00
if ( ! has_func_name ( RenderingServer : : ShaderMode ( shader_mode ) , func_name [ i ] ) ) {
2020-03-25 09:22:29 +00:00
continue ;
}
2019-08-18 05:09:05 +00:00
for ( Map < int , Node > : : Element * E = graph [ i ] . nodes . front ( ) ; E ; E = E - > next ( ) ) {
Ref < VisualShaderNodeGlobalExpression > global_expression = Object : : cast_to < VisualShaderNodeGlobalExpression > ( E - > get ( ) . node . ptr ( ) ) ;
if ( global_expression . is_valid ( ) ) {
String expr = " " ;
expr + = " // " + global_expression - > get_caption ( ) + " : " + itos ( index + + ) + " \n " ;
expr + = global_expression - > generate_global ( get_mode ( ) , Type ( i ) , - 1 ) ;
expr = expr . replace ( " \n " , " \n \t " ) ;
expr + = " \n " ;
global_expressions + = expr ;
}
2020-07-28 08:02:57 +00:00
Ref < VisualShaderNodeUniformRef > uniform_ref = Object : : cast_to < VisualShaderNodeUniformRef > ( E - > get ( ) . node . ptr ( ) ) ;
if ( uniform_ref . is_valid ( ) ) {
used_uniform_names . insert ( uniform_ref - > get_uniform_name ( ) ) ;
}
Ref < VisualShaderNodeUniform > uniform = Object : : cast_to < VisualShaderNodeUniform > ( E - > get ( ) . node . ptr ( ) ) ;
if ( uniform . is_valid ( ) ) {
uniforms . push_back ( uniform . ptr ( ) ) ;
}
2020-09-15 07:57:40 +00:00
Ref < VisualShaderNodeParticleEmit > emit_particle = Object : : cast_to < VisualShaderNodeParticleEmit > ( E - > get ( ) . node . ptr ( ) ) ;
if ( emit_particle . is_valid ( ) ) {
if ( ! emitters . has ( i ) ) {
emitters . insert ( i , List < int > ( ) ) ;
}
for ( Map < int , Node > : : Element * M = graph [ i ] . nodes . front ( ) ; M ; M = M - > next ( ) ) {
if ( M - > get ( ) . node = = emit_particle . ptr ( ) ) {
emitters [ i ] . push_back ( M - > key ( ) ) ;
break ;
}
}
}
2020-07-28 08:02:57 +00:00
}
}
for ( int i = 0 ; i < uniforms . size ( ) ; i + + ) {
VisualShaderNodeUniform * uniform = uniforms [ i ] ;
if ( used_uniform_names . has ( uniform - > get_uniform_name ( ) ) ) {
global_code + = uniform - > generate_global ( get_mode ( ) , Type ( i ) , - 1 ) ;
const_cast < VisualShaderNodeUniform * > ( uniform ) - > set_global_code_generated ( true ) ;
} else {
const_cast < VisualShaderNodeUniform * > ( uniform ) - > set_global_code_generated ( false ) ;
2019-08-18 05:09:05 +00:00
}
}
2020-09-07 07:28:13 +00:00
Map < int , String > code_map ;
2018-07-14 21:15:42 +00:00
for ( int i = 0 ; i < TYPE_MAX ; i + + ) {
2020-09-07 07:28:13 +00:00
if ( ! has_func_name ( RenderingServer : : ShaderMode ( shader_mode ) , func_name [ i ] ) ) {
2020-03-25 09:22:29 +00:00
continue ;
}
2018-07-14 21:15:42 +00:00
//make it faster to go around through shader
VMap < ConnectionKey , const List < Connection > : : Element * > input_connections ;
VMap < ConnectionKey , const List < Connection > : : Element * > output_connections ;
2020-09-07 07:28:13 +00:00
StringBuilder func_code ;
2018-07-14 21:15:42 +00:00
for ( const List < Connection > : : Element * E = graph [ i ] . connections . front ( ) ; E ; E = E - > next ( ) ) {
ConnectionKey from_key ;
from_key . node = E - > get ( ) . from_node ;
from_key . port = E - > get ( ) . from_port ;
output_connections . insert ( from_key , E ) ;
ConnectionKey to_key ;
to_key . node = E - > get ( ) . to_node ;
to_key . port = E - > get ( ) . to_port ;
input_connections . insert ( to_key , E ) ;
}
2020-09-07 07:28:13 +00:00
if ( shader_mode ! = Shader : : MODE_PARTICLES ) {
func_code + = " \n void " + String ( func_name [ i ] ) + " () { \n " ;
}
2020-09-11 15:06:22 +00:00
insertion_pos . insert ( i , code . get_string_length ( ) + func_code . get_string_length ( ) ) ;
2018-07-14 21:15:42 +00:00
Set < int > processed ;
2020-09-07 07:28:13 +00:00
Error err = _write_node ( Type ( i ) , global_code , global_code_per_node , global_code_per_func , func_code , default_tex_params , input_connections , output_connections , NODE_ID_OUTPUT , processed , false , classes ) ;
2018-07-14 21:15:42 +00:00
ERR_FAIL_COND ( err ! = OK ) ;
2020-09-15 07:57:40 +00:00
if ( emitters . has ( i ) ) {
for ( List < int > : : Element * E = emitters [ i ] . front ( ) ; E ; E = E - > next ( ) ) {
err = _write_node ( Type ( i ) , global_code , global_code_per_node , global_code_per_func , func_code , default_tex_params , input_connections , output_connections , E - > get ( ) , processed , false , classes ) ;
ERR_FAIL_COND ( err ! = OK ) ;
}
}
2020-09-07 07:28:13 +00:00
if ( shader_mode = = Shader : : MODE_PARTICLES ) {
code_map . insert ( i , func_code ) ;
} else {
func_code + = " } \n " ;
code + = func_code ;
}
}
2020-09-15 07:57:40 +00:00
String global_compute_code ;
2020-09-07 07:28:13 +00:00
if ( shader_mode = = Shader : : MODE_PARTICLES ) {
2020-09-15 07:57:40 +00:00
bool has_start = ! code_map [ TYPE_START ] . is_empty ( ) ;
bool has_start_custom = ! code_map [ TYPE_START_CUSTOM ] . is_empty ( ) ;
bool has_process = ! code_map [ TYPE_PROCESS ] . is_empty ( ) ;
bool has_process_custom = ! code_map [ TYPE_PROCESS_CUSTOM ] . is_empty ( ) ;
bool has_collide = ! code_map [ TYPE_COLLIDE ] . is_empty ( ) ;
code + = " void start() { \n " ;
if ( has_start | | has_start_custom ) {
code + = " \t uint __seed = __hash(NUMBER + uint(1) + RANDOM_SEED); \n " ;
code + = " \t vec3 __diff = TRANSFORM[3].xyz - EMISSION_TRANSFORM[3].xyz; \n " ;
code + = " \t float __radians; \n " ;
code + = " \t vec3 __vec3_buff1; \n " ;
code + = " \t vec3 __vec3_buff2; \n " ;
code + = " \t float __scalar_buff1; \n " ;
code + = " \t float __scalar_buff2; \n " ;
code + = " \t vec3 __ndiff = normalize(__diff); \n \n " ;
}
if ( has_start ) {
code + = " \t { \n " ;
code + = code_map [ TYPE_START ] . replace ( " \n \t " , " \n \t \t " ) ;
code + = " \t } \n " ;
if ( has_start_custom ) {
code + = " \t \n " ;
}
}
if ( has_start_custom ) {
code + = " \t { \n " ;
code + = code_map [ TYPE_START_CUSTOM ] . replace ( " \n \t " , " \n \t \t " ) ;
code + = " \t } \n " ;
}
code + = " } \n \n " ;
code + = " void process() { \n " ;
if ( has_process | | has_process_custom | | has_collide ) {
code + = " \t uint __seed = __hash(NUMBER + uint(1) + RANDOM_SEED); \n " ;
code + = " \t vec3 __vec3_buff1; \n " ;
code + = " \t vec3 __diff = TRANSFORM[3].xyz - EMISSION_TRANSFORM[3].xyz; \n " ;
code + = " \t vec3 __ndiff = normalize(__diff); \n \n " ;
}
code + = " \t { \n " ;
String tab = " \t " ;
if ( has_collide ) {
code + = " \t \t if (COLLIDED) { \n \n " ;
code + = code_map [ TYPE_COLLIDE ] . replace ( " \n \t " , " \n \t \t \t " ) ;
if ( has_process ) {
code + = " \t \t } else { \n \n " ;
tab + = " \t " ;
}
}
if ( has_process ) {
code + = code_map [ TYPE_PROCESS ] . replace ( " \n \t " , " \n \t " + tab ) ;
}
if ( has_collide ) {
code + = " \t \t } \n " ;
}
2020-09-07 07:28:13 +00:00
code + = " \t } \n " ;
2020-09-15 07:57:40 +00:00
if ( has_process_custom ) {
code + = " \t { \n \n " ;
code + = code_map [ TYPE_PROCESS_CUSTOM ] . replace ( " \n \t " , " \n \t \t " ) ;
code + = " \t } \n " ;
}
code + = " } \n \n " ;
global_compute_code + = " float __rand_from_seed(inout uint seed) { \n " ;
global_compute_code + = " \t int k; \n " ;
global_compute_code + = " \t int s = int(seed); \n " ;
global_compute_code + = " \t if (s == 0) \n " ;
global_compute_code + = " \t s = 305420679; \n " ;
global_compute_code + = " \t k = s / 127773; \n " ;
global_compute_code + = " \t s = 16807 * (s - k * 127773) - 2836 * k; \n " ;
global_compute_code + = " \t if (s < 0) \n " ;
global_compute_code + = " \t \t s += 2147483647; \n " ;
global_compute_code + = " \t seed = uint(s); \n " ;
global_compute_code + = " \t return float(seed % uint(65536)) / 65535.0; \n " ;
global_compute_code + = " } \n \n " ;
global_compute_code + = " float __rand_from_seed_m1_p1(inout uint seed) { \n " ;
global_compute_code + = " \t return __rand_from_seed(seed) * 2.0 - 1.0; \n " ;
global_compute_code + = " } \n \n " ;
global_compute_code + = " float __randf_range(inout uint seed, float from, float to) { \n " ;
global_compute_code + = " \t return __rand_from_seed(seed) * (to - from) + from; \n " ;
global_compute_code + = " } \n \n " ;
global_compute_code + = " vec3 __randv_range(inout uint seed, vec3 from, vec3 to) { \n " ;
global_compute_code + = " \t return vec3(__randf_range(seed, from.x, to.x), __randf_range(seed, from.y, to.y), __randf_range(seed, from.z, to.z)); \n " ;
global_compute_code + = " } \n \n " ;
global_compute_code + = " uint __hash(uint x) { \n " ;
global_compute_code + = " \t x = ((x >> uint(16)) ^ x) * uint(73244475); \n " ;
global_compute_code + = " \t x = ((x >> uint(16)) ^ x) * uint(73244475); \n " ;
global_compute_code + = " \t x = (x >> uint(16)) ^ x; \n " ;
global_compute_code + = " \t return x; \n " ;
global_compute_code + = " } \n \n " ;
global_compute_code + = " mat3 __build_rotation_mat3(vec3 axis, float angle) { \n " ;
global_compute_code + = " \t axis = normalize(axis); \n " ;
global_compute_code + = " \t float s = sin(angle); \n " ;
global_compute_code + = " \t float c = cos(angle); \n " ;
global_compute_code + = " \t float oc = 1.0 - c; \n " ;
global_compute_code + = " \t return mat3(vec3(oc * axis.x * axis.x + c, oc * axis.x * axis.y - axis.z * s, oc * axis.z * axis.x + axis.y * s), vec3(oc * axis.x * axis.y + axis.z * s, oc * axis.y * axis.y + c, oc * axis.y * axis.z - axis.x * s), vec3(oc * axis.z * axis.x - axis.y * s, oc * axis.y * axis.z + axis.x * s, oc * axis.z * axis.z + c)); \n " ;
global_compute_code + = " } \n \n " ;
global_compute_code + = " mat4 __build_rotation_mat4(vec3 axis, float angle) { \n " ;
global_compute_code + = " \t axis = normalize(axis); \n " ;
global_compute_code + = " \t float s = sin(angle); \n " ;
global_compute_code + = " \t float c = cos(angle); \n " ;
global_compute_code + = " \t float oc = 1.0 - c; \n " ;
global_compute_code + = " \t return mat4(vec4(oc * axis.x * axis.x + c, oc * axis.x * axis.y - axis.z * s, oc * axis.z * axis.x + axis.y * s, 0), vec4(oc * axis.x * axis.y + axis.z * s, oc * axis.y * axis.y + c, oc * axis.y * axis.z - axis.x * s, 0), vec4(oc * axis.z * axis.x - axis.y * s, oc * axis.y * axis.z + axis.x * s, oc * axis.z * axis.z + c, 0), vec4(0, 0, 0, 1)); \n " ;
global_compute_code + = " } \n \n " ;
global_compute_code + = " vec3 __get_random_unit_vec3(inout uint seed) { \n " ;
global_compute_code + = " \t return normalize(vec3(__rand_from_seed_m1_p1(seed), __rand_from_seed_m1_p1(seed), __rand_from_seed_m1_p1(seed))); \n " ;
global_compute_code + = " } \n \n " ;
2018-07-14 21:15:42 +00:00
}
//set code secretly
global_code + = " \n \n " ;
String final_code = global_code ;
2020-09-15 07:57:40 +00:00
final_code + = global_compute_code ;
2019-07-12 09:14:34 +00:00
final_code + = global_code_per_node ;
2019-08-18 05:09:05 +00:00
final_code + = global_expressions ;
2019-07-12 09:14:34 +00:00
String tcode = code ;
for ( int i = 0 ; i < TYPE_MAX ; i + + ) {
2020-09-07 07:28:13 +00:00
if ( ! has_func_name ( RenderingServer : : ShaderMode ( shader_mode ) , func_name [ i ] ) ) {
2020-03-25 09:22:29 +00:00
continue ;
}
2019-07-12 09:14:34 +00:00
tcode = tcode . insert ( insertion_pos [ i ] , global_code_per_func [ Type ( i ) ] ) ;
}
final_code + = tcode ;
2018-07-14 21:15:42 +00:00
const_cast < VisualShader * > ( this ) - > set_code ( final_code ) ;
for ( int i = 0 ; i < default_tex_params . size ( ) ; i + + ) {
const_cast < VisualShader * > ( this ) - > set_default_texture_param ( default_tex_params [ i ] . name , default_tex_params [ i ] . param ) ;
}
2019-08-18 09:29:22 +00:00
if ( previous_code ! = final_code ) {
const_cast < VisualShader * > ( this ) - > emit_signal ( " changed " ) ;
}
previous_code = final_code ;
2018-07-14 21:15:42 +00:00
}
void VisualShader : : _queue_update ( ) {
2021-02-10 18:22:13 +00:00
if ( dirty . is_set ( ) ) {
2018-07-14 21:15:42 +00:00
return ;
}
2021-02-10 18:22:13 +00:00
dirty . set ( ) ;
2018-07-14 21:15:42 +00:00
call_deferred ( " _update_shader " ) ;
}
void VisualShader : : _input_type_changed ( Type p_type , int p_id ) {
2021-02-14 14:26:33 +00:00
ERR_FAIL_INDEX ( p_type , TYPE_MAX ) ;
2018-07-14 21:15:42 +00:00
//erase connections using this input, as type changed
Graph * g = & graph [ p_type ] ;
for ( List < Connection > : : Element * E = g - > connections . front ( ) ; E ; ) {
List < Connection > : : Element * N = E - > next ( ) ;
if ( E - > get ( ) . from_node = = p_id ) {
g - > connections . erase ( E ) ;
2020-01-20 14:46:49 +00:00
g - > nodes [ E - > get ( ) . to_node ] . prev_connected_nodes . erase ( p_id ) ;
2018-07-14 21:15:42 +00:00
}
E = N ;
}
}
2019-05-12 12:09:39 +00:00
void VisualShader : : rebuild ( ) {
2021-02-10 18:22:13 +00:00
dirty . set ( ) ;
2019-05-12 12:09:39 +00:00
_update_shader ( ) ;
}
2018-07-14 21:15:42 +00:00
void VisualShader : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " set_mode " , " mode " ) , & VisualShader : : set_mode ) ;
ClassDB : : bind_method ( D_METHOD ( " add_node " , " type " , " node " , " position " , " id " ) , & VisualShader : : add_node ) ;
2018-07-26 09:56:21 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_node " , " type " , " id " ) , & VisualShader : : get_node ) ;
2019-05-12 12:09:39 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_node_position " , " type " , " id " , " position " ) , & VisualShader : : set_node_position ) ;
2018-07-14 21:15:42 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_node_position " , " type " , " id " ) , & VisualShader : : get_node_position ) ;
ClassDB : : bind_method ( D_METHOD ( " get_node_list " , " type " ) , & VisualShader : : get_node_list ) ;
ClassDB : : bind_method ( D_METHOD ( " get_valid_node_id " , " type " ) , & VisualShader : : get_valid_node_id ) ;
ClassDB : : bind_method ( D_METHOD ( " remove_node " , " type " , " id " ) , & VisualShader : : remove_node ) ;
2020-12-30 08:45:31 +00:00
ClassDB : : bind_method ( D_METHOD ( " replace_node " , " type " , " id " , " new_class " ) , & VisualShader : : replace_node ) ;
2018-07-14 21:15:42 +00:00
ClassDB : : bind_method ( D_METHOD ( " is_node_connection " , " type " , " from_node " , " from_port " , " to_node " , " to_port " ) , & VisualShader : : is_node_connection ) ;
2020-04-01 01:49:23 +00:00
ClassDB : : bind_method ( D_METHOD ( " can_connect_nodes " , " type " , " from_node " , " from_port " , " to_node " , " to_port " ) , & VisualShader : : can_connect_nodes ) ;
2018-07-14 21:15:42 +00:00
ClassDB : : bind_method ( D_METHOD ( " connect_nodes " , " type " , " from_node " , " from_port " , " to_node " , " to_port " ) , & VisualShader : : connect_nodes ) ;
ClassDB : : bind_method ( D_METHOD ( " disconnect_nodes " , " type " , " from_node " , " from_port " , " to_node " , " to_port " ) , & VisualShader : : disconnect_nodes ) ;
2019-05-12 12:09:39 +00:00
ClassDB : : bind_method ( D_METHOD ( " connect_nodes_forced " , " type " , " from_node " , " from_port " , " to_node " , " to_port " ) , & VisualShader : : connect_nodes_forced ) ;
2018-07-14 21:15:42 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_node_connections " , " type " ) , & VisualShader : : _get_node_connections ) ;
2020-02-25 14:50:49 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_version " , " version " ) , & VisualShader : : set_version ) ;
ClassDB : : bind_method ( D_METHOD ( " get_version " ) , & VisualShader : : get_version ) ;
2018-07-14 21:15:42 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_graph_offset " , " offset " ) , & VisualShader : : set_graph_offset ) ;
ClassDB : : bind_method ( D_METHOD ( " get_graph_offset " ) , & VisualShader : : get_graph_offset ) ;
ClassDB : : bind_method ( D_METHOD ( " _update_shader " ) , & VisualShader : : _update_shader ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " graph_offset " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR ) , " set_graph_offset " , " get_graph_offset " ) ;
2020-02-25 14:50:49 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : STRING , " version " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR ) , " set_version " , " get_version " ) ;
2018-07-14 21:15:42 +00:00
2020-09-04 08:43:11 +00:00
ADD_PROPERTY_DEFAULT ( " code " , " " ) ; // Inherited from Shader, prevents showing default code as override in docs.
2018-07-14 21:15:42 +00:00
BIND_ENUM_CONSTANT ( TYPE_VERTEX ) ;
BIND_ENUM_CONSTANT ( TYPE_FRAGMENT ) ;
BIND_ENUM_CONSTANT ( TYPE_LIGHT ) ;
2020-09-15 07:57:40 +00:00
BIND_ENUM_CONSTANT ( TYPE_START ) ;
2020-09-11 10:22:10 +00:00
BIND_ENUM_CONSTANT ( TYPE_PROCESS ) ;
2020-09-15 07:57:40 +00:00
BIND_ENUM_CONSTANT ( TYPE_COLLIDE ) ;
BIND_ENUM_CONSTANT ( TYPE_START_CUSTOM ) ;
BIND_ENUM_CONSTANT ( TYPE_PROCESS_CUSTOM ) ;
2021-04-19 10:26:37 +00:00
BIND_ENUM_CONSTANT ( TYPE_SKY ) ;
2018-07-14 21:15:42 +00:00
BIND_ENUM_CONSTANT ( TYPE_MAX ) ;
BIND_CONSTANT ( NODE_ID_INVALID ) ;
BIND_CONSTANT ( NODE_ID_OUTPUT ) ;
}
VisualShader : : VisualShader ( ) {
2021-02-10 18:22:13 +00:00
dirty . set ( ) ;
2018-07-14 21:15:42 +00:00
for ( int i = 0 ; i < TYPE_MAX ; i + + ) {
2020-09-15 07:57:40 +00:00
if ( i > ( int ) TYPE_LIGHT & & i < ( int ) TYPE_SKY ) {
Ref < VisualShaderNodeParticleOutput > output ;
output . instance ( ) ;
output - > shader_type = Type ( i ) ;
output - > shader_mode = shader_mode ;
graph [ i ] . nodes [ NODE_ID_OUTPUT ] . node = output ;
} else {
Ref < VisualShaderNodeOutput > output ;
output . instance ( ) ;
output - > shader_type = Type ( i ) ;
output - > shader_mode = shader_mode ;
graph [ i ] . nodes [ NODE_ID_OUTPUT ] . node = output ;
}
2018-07-14 21:15:42 +00:00
graph [ i ] . nodes [ NODE_ID_OUTPUT ] . position = Vector2 ( 400 , 150 ) ;
}
}
///////////////////////////////////////////////////////////
const VisualShaderNodeInput : : Port VisualShaderNodeInput : : ports [ ] = {
// Spatial, Vertex
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " vertex " , " VERTEX " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " normal " , " NORMAL " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " tangent " , " TANGENT " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " binormal " , " BINORMAL " } ,
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " uv " , " vec3(UV, 0.0) " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " uv2 " , " vec3(UV2, 0.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " COLOR.rgb " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " COLOR.a " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_SCALAR , " point_size " , " POINT_SIZE " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_TRANSFORM , " world " , " WORLD_MATRIX " } ,
2019-01-27 09:16:37 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_TRANSFORM , " modelview " , " MODELVIEW_MATRIX " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_TRANSFORM , " camera " , " CAMERA_MATRIX " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_TRANSFORM , " inv_camera " , " INV_CAMERA_MATRIX " } ,
2019-01-27 09:16:37 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_TRANSFORM , " projection " , " PROJECTION_MATRIX " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_TRANSFORM , " inv_projection " , " INV_PROJECTION_MATRIX " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
2019-01-27 09:16:37 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " viewport_size " , " vec3(VIEWPORT_SIZE, 0) " } ,
2019-09-04 15:24:44 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_BOOLEAN , " output_is_srgb " , " OUTPUT_IS_SRGB " } ,
2018-07-14 21:15:42 +00:00
// Spatial, Fragment
2019-01-27 09:16:37 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " fragcoord " , " FRAGCOORD.xyz " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " vertex " , " VERTEX " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " normal " , " NORMAL " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " tangent " , " TANGENT " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " binormal " , " BINORMAL " } ,
2019-01-27 09:16:37 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " view " , " VIEW " } ,
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " uv " , " vec3(UV, 0.0) " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " uv2 " , " vec3(UV2, 0.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " COLOR.rgb " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " COLOR.a " } ,
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " point_coord " , " vec3(POINT_COORD, 0.0) " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " screen_uv " , " vec3(SCREEN_UV, 0.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " side " , " float(FRONT_FACING ? 1.0 : 0.0) " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_TRANSFORM , " world " , " WORLD_MATRIX " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_TRANSFORM , " inv_camera " , " INV_CAMERA_MATRIX " } ,
2019-01-27 09:16:37 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_TRANSFORM , " camera " , " CAMERA_MATRIX " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_TRANSFORM , " projection " , " PROJECTION_MATRIX " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_TRANSFORM , " inv_projection " , " INV_PROJECTION_MATRIX " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
2019-01-27 09:16:37 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " viewport_size " , " vec3(VIEWPORT_SIZE, 0.0) " } ,
2019-09-04 15:24:44 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_BOOLEAN , " output_is_srgb " , " OUTPUT_IS_SRGB " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_BOOLEAN , " front_facing " , " FRONT_FACING " } ,
2019-11-03 13:38:03 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SAMPLER , " screen_texture " , " SCREEN_TEXTURE " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SAMPLER , " depth_texture " , " DEPTH_TEXTURE " } ,
2018-07-14 21:15:42 +00:00
// Spatial, Light
2019-01-27 09:16:37 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " fragcoord " , " FRAGCOORD.xyz " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " normal " , " NORMAL " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " view " , " VIEW " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " light " , " LIGHT " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " light_color " , " LIGHT_COLOR " } ,
2020-11-29 11:16:18 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_SCALAR , " attenuation " , " ATTENUATION " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " albedo " , " ALBEDO " } ,
2020-11-28 17:14:30 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " backlight " , " BACKLIGHT " } ,
2019-03-01 06:02:06 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " diffuse " , " DIFFUSE_LIGHT " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " specular " , " SPECULAR_LIGHT " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_SCALAR , " roughness " , " ROUGHNESS " } ,
2020-10-10 13:55:36 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_SCALAR , " metallic " , " METALLIC " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_TRANSFORM , " world " , " WORLD_MATRIX " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_TRANSFORM , " inv_camera " , " INV_CAMERA_MATRIX " } ,
2019-01-27 09:16:37 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_TRANSFORM , " camera " , " CAMERA_MATRIX " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_TRANSFORM , " projection " , " PROJECTION_MATRIX " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_TRANSFORM , " inv_projection " , " INV_PROJECTION_MATRIX " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
2019-01-27 09:16:37 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " viewport_size " , " vec3(VIEWPORT_SIZE, 0.0) " } ,
2019-09-04 15:24:44 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_BOOLEAN , " output_is_srgb " , " OUTPUT_IS_SRGB " } ,
2021-04-17 17:16:03 +00:00
2018-07-14 21:15:42 +00:00
// Canvas Item, Vertex
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " vertex " , " vec3(VERTEX, 0.0) " } ,
2020-11-29 11:16:18 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " uv " , " vec3(UV, 0.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " COLOR.rgb " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " COLOR.a " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_SCALAR , " point_size " , " POINT_SIZE " } ,
2019-01-27 09:16:37 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " texture_pixel_size " , " vec3(TEXTURE_PIXEL_SIZE, 1.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_TRANSFORM , " world " , " WORLD_MATRIX " } ,
2020-11-29 11:16:18 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_TRANSFORM , " canvas " , " CANVAS_MATRIX " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_TRANSFORM , " screen " , " SCREEN_MATRIX " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
2020-11-29 11:16:18 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_BOOLEAN , " at_light_pass " , " AT_LIGHT_PASS " } ,
2021-04-17 17:16:03 +00:00
2018-07-14 21:15:42 +00:00
// Canvas Item, Fragment
2019-01-27 09:16:37 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " fragcoord " , " FRAGCOORD.xyz " } ,
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " uv " , " vec3(UV, 0.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " COLOR.rgb " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " COLOR.a " } ,
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " screen_uv " , " vec3(SCREEN_UV, 0.0) " } ,
2019-01-27 09:16:37 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " texture_pixel_size " , " vec3(TEXTURE_PIXEL_SIZE, 1.0) " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " screen_pixel_size " , " vec3(SCREEN_PIXEL_SIZE, 1.0) " } ,
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " point_coord " , " vec3(POINT_COORD, 0.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
2020-11-29 11:16:18 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_BOOLEAN , " at_light_pass " , " AT_LIGHT_PASS " } ,
2019-11-03 13:38:03 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SAMPLER , " texture " , " TEXTURE " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SAMPLER , " normal_texture " , " NORMAL_TEXTURE " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SAMPLER , " screen_texture " , " SCREEN_TEXTURE " } ,
2020-11-29 11:16:18 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " specular_shininess " , " SPECULAR_SHININESS.rgb " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " specular_shininess_alpha " , " SPECULAR_SHININESS.a " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SAMPLER , " specular_shininess_texture " , " SPECULAR_SHININESS_TEXTURE " } ,
2021-04-17 17:16:03 +00:00
2018-07-14 21:15:42 +00:00
// Canvas Item, Light
2019-01-27 09:16:37 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " fragcoord " , " FRAGCOORD.xyz " } ,
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " uv " , " vec3(UV, 0.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " normal " , " NORMAL " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " COLOR.rgb " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " COLOR.a " } ,
2020-11-29 11:16:18 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " light " , " LIGHT.rgb " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_SCALAR , " light_alpha " , " LIGHT.a " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " light_color " , " LIGHT_COLOR.rgb " } ,
2020-11-29 11:16:18 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_SCALAR , " light_color_alpha " , " LIGHT_COLOR.a " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " light_position " , " LIGHT_POSITION " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " light_vertex " , " LIGHT_VERTEX " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " shadow_color " , " SHADOW_MODULATE.rgb " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_SCALAR , " shadow_alpha " , " SHADOW_MODULATE.a " } ,
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " screen_uv " , " vec3(SCREEN_UV, 0.0) " } ,
2019-01-27 09:16:37 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " texture_pixel_size " , " vec3(TEXTURE_PIXEL_SIZE, 1.0) " } ,
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " point_coord " , " vec3(POINT_COORD, 0.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
2019-11-03 13:38:03 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_SAMPLER , " texture " , " TEXTURE " } ,
2020-11-29 11:16:18 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " specular_shininess " , " SPECULAR_SHININESS.rgb " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_SCALAR , " specular_shininess_alpha " , " SPECULAR_SHININESS.a " } ,
2019-01-27 09:16:37 +00:00
2020-09-15 07:57:40 +00:00
// Particles, Start
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START , VisualShaderNode : : PORT_TYPE_VECTOR , " attractor_force " , " ATTRACTOR_FORCE " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " COLOR.rgb " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " COLOR.a " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START , VisualShaderNode : : PORT_TYPE_VECTOR , " velocity " , " VELOCITY " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START , VisualShaderNode : : PORT_TYPE_BOOLEAN , " restart " , " RESTART " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START , VisualShaderNode : : PORT_TYPE_BOOLEAN , " active " , " ACTIVE " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START , VisualShaderNode : : PORT_TYPE_VECTOR , " custom " , " CUSTOM.rgb " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START , VisualShaderNode : : PORT_TYPE_SCALAR , " custom_alpha " , " CUSTOM.a " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START , VisualShaderNode : : PORT_TYPE_TRANSFORM , " transform " , " TRANSFORM " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START , VisualShaderNode : : PORT_TYPE_SCALAR , " delta " , " DELTA " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START , VisualShaderNode : : PORT_TYPE_SCALAR , " lifetime " , " LIFETIME " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START , VisualShaderNode : : PORT_TYPE_SCALAR_INT , " index " , " INDEX " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START , VisualShaderNode : : PORT_TYPE_TRANSFORM , " emission_transform " , " EMISSION_TRANSFORM " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
// Particles, Start (Custom)
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START_CUSTOM , VisualShaderNode : : PORT_TYPE_VECTOR , " attractor_force " , " ATTRACTOR_FORCE " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START_CUSTOM , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " COLOR.rgb " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START_CUSTOM , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " COLOR.a " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START_CUSTOM , VisualShaderNode : : PORT_TYPE_VECTOR , " velocity " , " VELOCITY " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START_CUSTOM , VisualShaderNode : : PORT_TYPE_BOOLEAN , " restart " , " RESTART " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START_CUSTOM , VisualShaderNode : : PORT_TYPE_BOOLEAN , " active " , " ACTIVE " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START_CUSTOM , VisualShaderNode : : PORT_TYPE_VECTOR , " custom " , " CUSTOM.rgb " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START_CUSTOM , VisualShaderNode : : PORT_TYPE_SCALAR , " custom_alpha " , " CUSTOM.a " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START_CUSTOM , VisualShaderNode : : PORT_TYPE_TRANSFORM , " transform " , " TRANSFORM " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START_CUSTOM , VisualShaderNode : : PORT_TYPE_SCALAR , " delta " , " DELTA " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START_CUSTOM , VisualShaderNode : : PORT_TYPE_SCALAR , " lifetime " , " LIFETIME " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START_CUSTOM , VisualShaderNode : : PORT_TYPE_SCALAR_INT , " index " , " INDEX " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START_CUSTOM , VisualShaderNode : : PORT_TYPE_TRANSFORM , " emission_transform " , " EMISSION_TRANSFORM " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START_CUSTOM , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
2020-09-07 07:28:13 +00:00
// Particles, Process
2020-09-15 07:57:40 +00:00
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS , VisualShaderNode : : PORT_TYPE_VECTOR , " attractor_force " , " ATTRACTOR_FORCE " } ,
2020-09-07 07:28:13 +00:00
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " COLOR.rgb " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " COLOR.a " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS , VisualShaderNode : : PORT_TYPE_VECTOR , " velocity " , " VELOCITY " } ,
2020-09-15 07:57:40 +00:00
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS , VisualShaderNode : : PORT_TYPE_BOOLEAN , " restart " , " RESTART " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS , VisualShaderNode : : PORT_TYPE_BOOLEAN , " active " , " ACTIVE " } ,
2020-09-07 07:28:13 +00:00
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS , VisualShaderNode : : PORT_TYPE_VECTOR , " custom " , " CUSTOM.rgb " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS , VisualShaderNode : : PORT_TYPE_SCALAR , " custom_alpha " , " CUSTOM.a " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS , VisualShaderNode : : PORT_TYPE_TRANSFORM , " transform " , " TRANSFORM " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS , VisualShaderNode : : PORT_TYPE_SCALAR , " delta " , " DELTA " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS , VisualShaderNode : : PORT_TYPE_SCALAR , " lifetime " , " LIFETIME " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS , VisualShaderNode : : PORT_TYPE_SCALAR_INT , " index " , " INDEX " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS , VisualShaderNode : : PORT_TYPE_TRANSFORM , " emission_transform " , " EMISSION_TRANSFORM " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
2020-09-15 07:57:40 +00:00
// Particles, Process (Custom)
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS_CUSTOM , VisualShaderNode : : PORT_TYPE_VECTOR , " attractor_force " , " ATTRACTOR_FORCE " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS_CUSTOM , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " COLOR.rgb " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS_CUSTOM , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " COLOR.a " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS_CUSTOM , VisualShaderNode : : PORT_TYPE_VECTOR , " velocity " , " VELOCITY " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS_CUSTOM , VisualShaderNode : : PORT_TYPE_BOOLEAN , " restart " , " RESTART " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS_CUSTOM , VisualShaderNode : : PORT_TYPE_BOOLEAN , " active " , " ACTIVE " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS_CUSTOM , VisualShaderNode : : PORT_TYPE_VECTOR , " custom " , " CUSTOM.rgb " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS_CUSTOM , VisualShaderNode : : PORT_TYPE_SCALAR , " custom_alpha " , " CUSTOM.a " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS_CUSTOM , VisualShaderNode : : PORT_TYPE_TRANSFORM , " transform " , " TRANSFORM " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS_CUSTOM , VisualShaderNode : : PORT_TYPE_SCALAR , " delta " , " DELTA " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS_CUSTOM , VisualShaderNode : : PORT_TYPE_SCALAR , " lifetime " , " LIFETIME " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS_CUSTOM , VisualShaderNode : : PORT_TYPE_SCALAR_INT , " index " , " INDEX " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS_CUSTOM , VisualShaderNode : : PORT_TYPE_TRANSFORM , " emission_transform " , " EMISSION_TRANSFORM " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS_CUSTOM , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
// Particles, Collide
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_VECTOR , " attractor_force " , " ATTRACTOR_FORCE " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_SCALAR , " collision_depth " , " COLLISION_DEPTH " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_VECTOR , " collision_normal " , " COLLISION_NORMAL " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " COLOR.rgb " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " COLOR.a " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_VECTOR , " velocity " , " VELOCITY " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_BOOLEAN , " restart " , " RESTART " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_BOOLEAN , " active " , " ACTIVE " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_VECTOR , " custom " , " CUSTOM.rgb " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_SCALAR , " custom_alpha " , " CUSTOM.a " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_TRANSFORM , " transform " , " TRANSFORM " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_SCALAR , " delta " , " DELTA " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_SCALAR , " lifetime " , " LIFETIME " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_SCALAR_INT , " index " , " INDEX " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_TRANSFORM , " emission_transform " , " EMISSION_TRANSFORM " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
2020-03-25 09:22:29 +00:00
2021-04-17 17:16:03 +00:00
// Sky, Sky
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_BOOLEAN , " at_cubemap_pass " , " AT_CUBEMAP_PASS " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_BOOLEAN , " at_half_res_pass " , " AT_HALF_RES_PASS " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_BOOLEAN , " at_quarter_res_pass " , " AT_QUARTER_RES_PASS " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_VECTOR , " eyedir " , " EYEDIR " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_VECTOR , " half_res_color " , " HALF_RES_COLOR.rgb " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_SCALAR , " half_res_alpha " , " HALF_RES_COLOR.a " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_VECTOR , " light0_color " , " LIGHT0_COLOR " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_VECTOR , " light0_direction " , " LIGHT0_DIRECTION " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_BOOLEAN , " light0_enabled " , " LIGHT0_ENABLED " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_SCALAR , " light0_energy " , " LIGHT0_ENERGY " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_VECTOR , " light1_color " , " LIGHT1_COLOR " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_VECTOR , " light1_direction " , " LIGHT1_DIRECTION " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_BOOLEAN , " light1_enabled " , " LIGHT1_ENABLED " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_SCALAR , " light1_energy " , " LIGHT1_ENERGY " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_VECTOR , " light2_color " , " LIGHT2_COLOR " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_VECTOR , " light2_direction " , " LIGHT2_DIRECTION " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_BOOLEAN , " light2_enabled " , " LIGHT2_ENABLED " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_SCALAR , " light2_energy " , " LIGHT2_ENERGY " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_VECTOR , " light3_color " , " LIGHT3_COLOR " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_VECTOR , " light3_direction " , " LIGHT3_DIRECTION " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_BOOLEAN , " light3_enabled " , " LIGHT3_ENABLED " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_SCALAR , " light3_energy " , " LIGHT3_ENERGY " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_VECTOR , " position " , " POSITION " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_VECTOR , " quarter_res_color " , " QUARTER_RES_COLOR.rgb " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_SCALAR , " quarter_res_alpha " , " QUARTER_RES_COLOR.a " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_SAMPLER , " radiance " , " RADIANCE " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_VECTOR , " screen_uv " , " vec3(SCREEN_UV, 0.0) " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_VECTOR , " sky_coords " , " vec3(SKY_COORDS, 0.0) " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
2020-03-25 09:22:29 +00:00
2020-04-01 23:20:12 +00:00
{ Shader : : MODE_MAX , VisualShader : : TYPE_MAX , VisualShaderNode : : PORT_TYPE_TRANSFORM , nullptr , nullptr } ,
2018-07-14 21:15:42 +00:00
} ;
const VisualShaderNodeInput : : Port VisualShaderNodeInput : : preview_ports [ ] = {
// Spatial, Fragment
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " normal " , " vec3(0.0, 0.0, 1.0) " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " tangent " , " vec3(0.0, 1.0, 0.0) " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " binormal " , " vec3(1.0, 0.0, 0.0) " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " uv " , " vec3(UV, 0.0) " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " uv2 " , " vec3(UV, 0.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " vec3(1.0) " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " 1.0 " } ,
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " screen_uv " , " vec3(SCREEN_UV, 0.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " side " , " 1.0 " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
2020-11-29 11:16:18 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " viewport_size " , " vec3(1.0, 1.0, 0.0) " } ,
2018-07-14 21:15:42 +00:00
// Spatial, Light
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " normal " , " vec3(0.0, 0.0, 1.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
2019-01-27 09:16:37 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " viewport_size " , " vec3(1.0, 1.0, 0.0) " } ,
2018-07-14 21:15:42 +00:00
// Canvas Item, Vertex
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " vertex " , " vec3(VERTEX, 0.0) " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " uv " , " vec3(UV, 0.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " vec3(1.0) " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " 1.0 " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
// Canvas Item, Fragment
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " uv " , " vec3(UV, 0.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " vec3(1.0) " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " 1.0 " } ,
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " screen_uv " , " vec3(SCREEN_UV, 0.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
// Canvas Item, Light
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " uv " , " vec3(UV, 0.0) " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " normal " , " vec3(0.0, 0.0, 1.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " vec3(1.0) " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " 1.0 " } ,
2020-01-27 09:10:51 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " screen_uv " , " vec3(SCREEN_UV, 0.0) " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
2020-09-15 07:57:40 +00:00
// Particles
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_COLLIDE , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_START_CUSTOM , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
{ Shader : : MODE_PARTICLES , VisualShader : : TYPE_PROCESS_CUSTOM , VisualShaderNode : : PORT_TYPE_SCALAR , " time " , " TIME " } ,
2020-04-01 23:20:12 +00:00
{ Shader : : MODE_MAX , VisualShader : : TYPE_MAX , VisualShaderNode : : PORT_TYPE_TRANSFORM , nullptr , nullptr } ,
2018-07-14 21:15:42 +00:00
} ;
int VisualShaderNodeInput : : get_input_port_count ( ) const {
return 0 ;
}
2020-05-14 12:29:06 +00:00
2018-07-14 21:15:42 +00:00
VisualShaderNodeInput : : PortType VisualShaderNodeInput : : get_input_port_type ( int p_port ) const {
return PORT_TYPE_SCALAR ;
}
2020-05-14 12:29:06 +00:00
2018-07-14 21:15:42 +00:00
String VisualShaderNodeInput : : get_input_port_name ( int p_port ) const {
return " " ;
}
int VisualShaderNodeInput : : get_output_port_count ( ) const {
return 1 ;
}
2020-05-14 12:29:06 +00:00
2018-07-14 21:15:42 +00:00
VisualShaderNodeInput : : PortType VisualShaderNodeInput : : get_output_port_type ( int p_port ) const {
return get_input_type_by_name ( input_name ) ;
}
2020-05-14 12:29:06 +00:00
2018-07-14 21:15:42 +00:00
String VisualShaderNodeInput : : get_output_port_name ( int p_port ) const {
return " " ;
}
String VisualShaderNodeInput : : get_caption ( ) const {
2019-10-29 06:26:05 +00:00
return " Input " ;
2018-07-14 21:15:42 +00:00
}
2019-01-21 19:07:53 +00:00
String VisualShaderNodeInput : : generate_code ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id , const String * p_input_vars , const String * p_output_vars , bool p_for_preview ) const {
2019-11-03 13:38:03 +00:00
if ( get_output_port_type ( 0 ) = = PORT_TYPE_SAMPLER ) {
return " " ;
}
2019-01-21 19:07:53 +00:00
if ( p_for_preview ) {
int idx = 0 ;
2018-07-14 21:15:42 +00:00
2019-01-21 19:07:53 +00:00
String code ;
2018-07-14 21:15:42 +00:00
2019-01-21 19:07:53 +00:00
while ( preview_ports [ idx ] . mode ! = Shader : : MODE_MAX ) {
if ( preview_ports [ idx ] . mode = = shader_mode & & preview_ports [ idx ] . shader_type = = shader_type & & preview_ports [ idx ] . name = = input_name ) {
code = " \t " + p_output_vars [ 0 ] + " = " + preview_ports [ idx ] . string + " ; \n " ;
break ;
}
idx + + ;
2018-07-14 21:15:42 +00:00
}
2019-01-21 19:07:53 +00:00
if ( code = = String ( ) ) {
switch ( get_output_port_type ( 0 ) ) {
case PORT_TYPE_SCALAR : {
code = " \t " + p_output_vars [ 0 ] + " = 0.0; \n " ;
2020-02-25 14:50:49 +00:00
} break ;
case PORT_TYPE_SCALAR_INT : {
code = " \t " + p_output_vars [ 0 ] + " = 0; \n " ;
} break ;
2019-01-21 19:07:53 +00:00
case PORT_TYPE_VECTOR : {
code = " \t " + p_output_vars [ 0 ] + " = vec3(0.0); \n " ;
2020-02-25 14:50:49 +00:00
} break ;
2019-01-21 19:07:53 +00:00
case PORT_TYPE_TRANSFORM : {
2020-11-29 11:16:18 +00:00
code = " \t " + p_output_vars [ 0 ] + " = mat4(vec4(1.0, 0.0, 0.0, 0.0), vec4(0.0, 1.0, 0.0, 0.0), vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0)); \n " ;
2020-02-25 14:50:49 +00:00
} break ;
2019-02-22 17:38:58 +00:00
case PORT_TYPE_BOOLEAN : {
code = " \t " + p_output_vars [ 0 ] + " = false; \n " ;
} break ;
2020-02-25 14:50:49 +00:00
default : //default (none found) is scalar
2019-02-22 17:38:58 +00:00
break ;
2019-01-21 19:07:53 +00:00
}
2018-07-14 21:15:42 +00:00
}
2019-01-21 19:07:53 +00:00
return code ;
2018-07-14 21:15:42 +00:00
2019-01-21 19:07:53 +00:00
} else {
int idx = 0 ;
2018-07-14 21:15:42 +00:00
2019-01-21 19:07:53 +00:00
String code ;
2018-07-14 21:15:42 +00:00
2019-01-21 19:07:53 +00:00
while ( ports [ idx ] . mode ! = Shader : : MODE_MAX ) {
if ( ports [ idx ] . mode = = shader_mode & & ports [ idx ] . shader_type = = shader_type & & ports [ idx ] . name = = input_name ) {
code = " \t " + p_output_vars [ 0 ] + " = " + ports [ idx ] . string + " ; \n " ;
break ;
}
idx + + ;
}
2018-07-14 21:15:42 +00:00
2019-01-21 19:07:53 +00:00
if ( code = = String ( ) ) {
code = " \t " + p_output_vars [ 0 ] + " = 0.0; \n " ; //default (none found) is scalar
2018-07-14 21:15:42 +00:00
}
2019-01-21 19:07:53 +00:00
return code ;
2018-07-14 21:15:42 +00:00
}
}
void VisualShaderNodeInput : : set_input_name ( String p_name ) {
PortType prev_type = get_input_type_by_name ( input_name ) ;
input_name = p_name ;
emit_changed ( ) ;
if ( get_input_type_by_name ( input_name ) ! = prev_type ) {
emit_signal ( " input_type_changed " ) ;
}
}
String VisualShaderNodeInput : : get_input_name ( ) const {
return input_name ;
}
2019-11-03 13:38:03 +00:00
String VisualShaderNodeInput : : get_input_real_name ( ) const {
int idx = 0 ;
while ( ports [ idx ] . mode ! = Shader : : MODE_MAX ) {
if ( ports [ idx ] . mode = = shader_mode & & ports [ idx ] . shader_type = = shader_type & & ports [ idx ] . name = = input_name ) {
return String ( ports [ idx ] . string ) ;
}
idx + + ;
}
return " " ;
}
2018-07-14 21:15:42 +00:00
VisualShaderNodeInput : : PortType VisualShaderNodeInput : : get_input_type_by_name ( String p_name ) const {
int idx = 0 ;
while ( ports [ idx ] . mode ! = Shader : : MODE_MAX ) {
if ( ports [ idx ] . mode = = shader_mode & & ports [ idx ] . shader_type = = shader_type & & ports [ idx ] . name = = p_name ) {
return ports [ idx ] . type ;
}
idx + + ;
}
return PORT_TYPE_SCALAR ;
}
int VisualShaderNodeInput : : get_input_index_count ( ) const {
int idx = 0 ;
int count = 0 ;
while ( ports [ idx ] . mode ! = Shader : : MODE_MAX ) {
if ( ports [ idx ] . mode = = shader_mode & & ports [ idx ] . shader_type = = shader_type ) {
count + + ;
}
idx + + ;
}
return count ;
}
VisualShaderNodeInput : : PortType VisualShaderNodeInput : : get_input_index_type ( int p_index ) const {
int idx = 0 ;
int count = 0 ;
while ( ports [ idx ] . mode ! = Shader : : MODE_MAX ) {
if ( ports [ idx ] . mode = = shader_mode & & ports [ idx ] . shader_type = = shader_type ) {
if ( count = = p_index ) {
return ports [ idx ] . type ;
}
count + + ;
}
idx + + ;
}
return PORT_TYPE_SCALAR ;
}
String VisualShaderNodeInput : : get_input_index_name ( int p_index ) const {
int idx = 0 ;
int count = 0 ;
while ( ports [ idx ] . mode ! = Shader : : MODE_MAX ) {
if ( ports [ idx ] . mode = = shader_mode & & ports [ idx ] . shader_type = = shader_type ) {
if ( count = = p_index ) {
return ports [ idx ] . name ;
}
count + + ;
}
idx + + ;
}
return " " ;
}
void VisualShaderNodeInput : : _validate_property ( PropertyInfo & property ) const {
if ( property . name = = " input_name " ) {
String port_list ;
int idx = 0 ;
while ( ports [ idx ] . mode ! = Shader : : MODE_MAX ) {
if ( ports [ idx ] . mode = = shader_mode & & ports [ idx ] . shader_type = = shader_type ) {
if ( port_list ! = String ( ) ) {
port_list + = " , " ;
}
port_list + = ports [ idx ] . name ;
}
idx + + ;
}
if ( port_list = = " " ) {
port_list = TTR ( " None " ) ;
}
property . hint_string = port_list ;
}
}
Vector < StringName > VisualShaderNodeInput : : get_editable_properties ( ) const {
Vector < StringName > props ;
props . push_back ( " input_name " ) ;
return props ;
}
void VisualShaderNodeInput : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " set_input_name " , " name " ) , & VisualShaderNodeInput : : set_input_name ) ;
ClassDB : : bind_method ( D_METHOD ( " get_input_name " ) , & VisualShaderNodeInput : : get_input_name ) ;
2019-11-04 15:50:33 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_input_real_name " ) , & VisualShaderNodeInput : : get_input_real_name ) ;
2018-07-14 21:15:42 +00:00
2020-02-20 21:58:05 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : STRING_NAME , " input_name " , PROPERTY_HINT_ENUM , " " ) , " set_input_name " , " get_input_name " ) ;
2018-07-14 21:15:42 +00:00
ADD_SIGNAL ( MethodInfo ( " input_type_changed " ) ) ;
}
2020-05-14 12:29:06 +00:00
2018-07-14 21:15:42 +00:00
VisualShaderNodeInput : : VisualShaderNodeInput ( ) {
}
2020-07-28 08:02:57 +00:00
////////////// UniformRef
List < VisualShaderNodeUniformRef : : Uniform > uniforms ;
void VisualShaderNodeUniformRef : : add_uniform ( const String & p_name , UniformType p_type ) {
uniforms . push_back ( { p_name , p_type } ) ;
}
void VisualShaderNodeUniformRef : : clear_uniforms ( ) {
uniforms . clear ( ) ;
}
2020-09-21 11:32:59 +00:00
bool VisualShaderNodeUniformRef : : has_uniform ( const String & p_name ) {
for ( List < VisualShaderNodeUniformRef : : Uniform > : : Element * E = uniforms . front ( ) ; E ; E = E - > next ( ) ) {
if ( E - > get ( ) . name = = p_name ) {
return true ;
}
}
return false ;
}
2020-07-28 08:02:57 +00:00
String VisualShaderNodeUniformRef : : get_caption ( ) const {
return " UniformRef " ;
}
int VisualShaderNodeUniformRef : : get_input_port_count ( ) const {
return 0 ;
}
VisualShaderNodeUniformRef : : PortType VisualShaderNodeUniformRef : : get_input_port_type ( int p_port ) const {
return PortType : : PORT_TYPE_SCALAR ;
}
String VisualShaderNodeUniformRef : : get_input_port_name ( int p_port ) const {
return " " ;
}
int VisualShaderNodeUniformRef : : get_output_port_count ( ) const {
switch ( uniform_type ) {
case UniformType : : UNIFORM_TYPE_FLOAT :
return 1 ;
case UniformType : : UNIFORM_TYPE_INT :
return 1 ;
case UniformType : : UNIFORM_TYPE_BOOLEAN :
return 1 ;
case UniformType : : UNIFORM_TYPE_VECTOR :
return 1 ;
case UniformType : : UNIFORM_TYPE_TRANSFORM :
return 1 ;
case UniformType : : UNIFORM_TYPE_COLOR :
return 2 ;
case UniformType : : UNIFORM_TYPE_SAMPLER :
return 1 ;
default :
break ;
}
2020-09-21 11:32:59 +00:00
return 1 ;
2020-07-28 08:02:57 +00:00
}
VisualShaderNodeUniformRef : : PortType VisualShaderNodeUniformRef : : get_output_port_type ( int p_port ) const {
switch ( uniform_type ) {
case UniformType : : UNIFORM_TYPE_FLOAT :
return PortType : : PORT_TYPE_SCALAR ;
case UniformType : : UNIFORM_TYPE_INT :
return PortType : : PORT_TYPE_SCALAR_INT ;
case UniformType : : UNIFORM_TYPE_BOOLEAN :
return PortType : : PORT_TYPE_BOOLEAN ;
case UniformType : : UNIFORM_TYPE_VECTOR :
return PortType : : PORT_TYPE_VECTOR ;
case UniformType : : UNIFORM_TYPE_TRANSFORM :
return PortType : : PORT_TYPE_TRANSFORM ;
case UniformType : : UNIFORM_TYPE_COLOR :
if ( p_port = = 0 ) {
return PortType : : PORT_TYPE_VECTOR ;
} else if ( p_port = = 1 ) {
return PORT_TYPE_SCALAR ;
}
break ;
case UniformType : : UNIFORM_TYPE_SAMPLER :
return PortType : : PORT_TYPE_SAMPLER ;
default :
break ;
}
return PORT_TYPE_SCALAR ;
}
String VisualShaderNodeUniformRef : : get_output_port_name ( int p_port ) const {
switch ( uniform_type ) {
case UniformType : : UNIFORM_TYPE_FLOAT :
return " " ;
case UniformType : : UNIFORM_TYPE_INT :
return " " ;
case UniformType : : UNIFORM_TYPE_BOOLEAN :
return " " ;
case UniformType : : UNIFORM_TYPE_VECTOR :
return " " ;
case UniformType : : UNIFORM_TYPE_TRANSFORM :
return " " ;
case UniformType : : UNIFORM_TYPE_COLOR :
if ( p_port = = 0 ) {
return " rgb " ;
} else if ( p_port = = 1 ) {
return " alpha " ;
}
break ;
case UniformType : : UNIFORM_TYPE_SAMPLER :
return " " ;
break ;
default :
break ;
}
return " " ;
}
void VisualShaderNodeUniformRef : : set_uniform_name ( const String & p_name ) {
uniform_name = p_name ;
2020-09-21 11:32:59 +00:00
if ( uniform_name ! = " [None] " ) {
uniform_type = get_uniform_type_by_name ( uniform_name ) ;
2020-07-28 08:02:57 +00:00
} else {
uniform_type = UniformType : : UNIFORM_TYPE_FLOAT ;
}
emit_changed ( ) ;
}
String VisualShaderNodeUniformRef : : get_uniform_name ( ) const {
return uniform_name ;
}
int VisualShaderNodeUniformRef : : get_uniforms_count ( ) const {
return uniforms . size ( ) ;
}
String VisualShaderNodeUniformRef : : get_uniform_name_by_index ( int p_idx ) const {
if ( p_idx > = 0 & & p_idx < uniforms . size ( ) ) {
return uniforms [ p_idx ] . name ;
}
return " " ;
}
VisualShaderNodeUniformRef : : UniformType VisualShaderNodeUniformRef : : get_uniform_type_by_name ( const String & p_name ) const {
for ( int i = 0 ; i < uniforms . size ( ) ; i + + ) {
if ( uniforms [ i ] . name = = p_name ) {
return uniforms [ i ] . type ;
}
}
return UniformType : : UNIFORM_TYPE_FLOAT ;
}
VisualShaderNodeUniformRef : : UniformType VisualShaderNodeUniformRef : : get_uniform_type_by_index ( int p_idx ) const {
if ( p_idx > = 0 & & p_idx < uniforms . size ( ) ) {
return uniforms [ p_idx ] . type ;
}
return UniformType : : UNIFORM_TYPE_FLOAT ;
}
String VisualShaderNodeUniformRef : : generate_code ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id , const String * p_input_vars , const String * p_output_vars , bool p_for_preview ) const {
switch ( uniform_type ) {
case UniformType : : UNIFORM_TYPE_FLOAT :
2020-09-21 11:32:59 +00:00
if ( uniform_name = = " [None] " ) {
return " \t " + p_output_vars [ 0 ] + " = 0.0; \n " ;
}
2020-07-28 08:02:57 +00:00
return " \t " + p_output_vars [ 0 ] + " = " + get_uniform_name ( ) + " ; \n " ;
case UniformType : : UNIFORM_TYPE_INT :
return " \t " + p_output_vars [ 0 ] + " = " + get_uniform_name ( ) + " ; \n " ;
case UniformType : : UNIFORM_TYPE_BOOLEAN :
return " \t " + p_output_vars [ 0 ] + " = " + get_uniform_name ( ) + " ; \n " ;
case UniformType : : UNIFORM_TYPE_VECTOR :
return " \t " + p_output_vars [ 0 ] + " = " + get_uniform_name ( ) + " ; \n " ;
case UniformType : : UNIFORM_TYPE_TRANSFORM :
return " \t " + p_output_vars [ 0 ] + " = " + get_uniform_name ( ) + " ; \n " ;
case UniformType : : UNIFORM_TYPE_COLOR : {
String code = " \t " + p_output_vars [ 0 ] + " = " + get_uniform_name ( ) + " .rgb; \n " ;
code + = " \t " + p_output_vars [ 1 ] + " = " + get_uniform_name ( ) + " .a; \n " ;
return code ;
} break ;
case UniformType : : UNIFORM_TYPE_SAMPLER :
break ;
default :
break ;
}
return " " ;
}
2020-09-21 11:32:59 +00:00
void VisualShaderNodeUniformRef : : _set_uniform_type ( int p_uniform_type ) {
uniform_type = ( UniformType ) p_uniform_type ;
}
int VisualShaderNodeUniformRef : : _get_uniform_type ( ) const {
return ( int ) uniform_type ;
}
2020-07-28 08:02:57 +00:00
void VisualShaderNodeUniformRef : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " set_uniform_name " , " name " ) , & VisualShaderNodeUniformRef : : set_uniform_name ) ;
ClassDB : : bind_method ( D_METHOD ( " get_uniform_name " ) , & VisualShaderNodeUniformRef : : get_uniform_name ) ;
2020-09-21 11:32:59 +00:00
ClassDB : : bind_method ( D_METHOD ( " _set_uniform_type " , " type " ) , & VisualShaderNodeUniformRef : : _set_uniform_type ) ;
ClassDB : : bind_method ( D_METHOD ( " _get_uniform_type " ) , & VisualShaderNodeUniformRef : : _get_uniform_type ) ;
2020-07-28 08:02:57 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : STRING_NAME , " uniform_name " , PROPERTY_HINT_ENUM , " " ) , " set_uniform_name " , " get_uniform_name " ) ;
2020-09-21 11:32:59 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " uniform_type " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL ) , " _set_uniform_type " , " _get_uniform_type " ) ;
2020-07-28 08:02:57 +00:00
}
Vector < StringName > VisualShaderNodeUniformRef : : get_editable_properties ( ) const {
Vector < StringName > props ;
props . push_back ( " uniform_name " ) ;
2020-09-21 11:32:59 +00:00
props . push_back ( " uniform_type " ) ;
2020-07-28 08:02:57 +00:00
return props ;
}
VisualShaderNodeUniformRef : : VisualShaderNodeUniformRef ( ) {
}
2018-07-14 21:15:42 +00:00
////////////////////////////////////////////
const VisualShaderNodeOutput : : Port VisualShaderNodeOutput : : ports [ ] = {
// Spatial, Vertex
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " vertex " , " VERTEX " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " normal " , " NORMAL " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " tangent " , " TANGENT " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " binormal " , " BINORMAL " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " uv " , " UV:xy " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " uv2 " , " UV2:xy " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " COLOR.rgb " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " COLOR.a " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_SCALAR , " roughness " , " ROUGHNESS " } ,
2021-05-27 19:17:58 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_TRANSFORM , " model_view_matrix " , " MODELVIEW_MATRIX " } ,
2018-07-14 21:15:42 +00:00
// Spatial, Fragment
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " albedo " , " ALBEDO " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " ALPHA " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " metallic " , " METALLIC " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " roughness " , " ROUGHNESS " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " specular " , " SPECULAR " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " emission " , " EMISSION " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " ao " , " AO " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " normal " , " NORMAL " } ,
2020-12-23 09:34:26 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " normal_map " , " NORMAL_MAP " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " normal_map_depth " , " NORMAL_MAP_DEPTH " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " rim " , " RIM " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " rim_tint " , " RIM_TINT " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " clearcoat " , " CLEARCOAT " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " clearcoat_gloss " , " CLEARCOAT_GLOSS " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " anisotropy " , " ANISOTROPY " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " anisotropy_flow " , " ANISOTROPY_FLOW:xy " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " subsurf_scatter " , " SSS_STRENGTH " } ,
2020-11-28 17:14:30 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " backlight " , " BACKLIGHT " } ,
2018-07-14 21:15:42 +00:00
2020-11-28 17:14:30 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha_scissor_threshold " , " ALPHA_SCISSOR_THRESHOLD " } ,
2018-07-14 21:15:42 +00:00
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " ao_light_affect " , " AO_LIGHT_AFFECT " } ,
// Spatial, Light
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " diffuse " , " DIFFUSE_LIGHT " } ,
{ Shader : : MODE_SPATIAL , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " specular " , " SPECULAR_LIGHT " } ,
// Canvas Item, Vertex
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " vertex " , " VERTEX:xy " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " uv " , " UV:xy " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " COLOR.rgb " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_VERTEX , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " COLOR.a " } ,
// Canvas Item, Fragment
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " COLOR.rgb " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " COLOR.a " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " normal " , " NORMAL " } ,
2020-12-23 09:34:26 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_VECTOR , " normal_map " , " NORMAL_MAP " } ,
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_FRAGMENT , VisualShaderNode : : PORT_TYPE_SCALAR , " normal_map_depth " , " NORMAL_MAP_DEPTH " } ,
2018-07-14 21:15:42 +00:00
// Canvas Item, Light
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_VECTOR , " light " , " LIGHT.rgb " } ,
2020-01-31 16:34:34 +00:00
{ Shader : : MODE_CANVAS_ITEM , VisualShader : : TYPE_LIGHT , VisualShaderNode : : PORT_TYPE_SCALAR , " light_alpha " , " LIGHT.a " } ,
2020-09-15 07:57:40 +00:00
2021-04-17 17:16:03 +00:00
// Sky, Sky
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_VECTOR , " color " , " COLOR " } ,
{ Shader : : MODE_SKY , VisualShader : : TYPE_SKY , VisualShaderNode : : PORT_TYPE_SCALAR , " alpha " , " ALPHA " } ,
2020-03-25 09:22:29 +00:00
2020-04-01 23:20:12 +00:00
{ Shader : : MODE_MAX , VisualShader : : TYPE_MAX , VisualShaderNode : : PORT_TYPE_TRANSFORM , nullptr , nullptr } ,
2018-07-14 21:15:42 +00:00
} ;
int VisualShaderNodeOutput : : get_input_port_count ( ) const {
int idx = 0 ;
int count = 0 ;
while ( ports [ idx ] . mode ! = Shader : : MODE_MAX ) {
if ( ports [ idx ] . mode = = shader_mode & & ports [ idx ] . shader_type = = shader_type ) {
count + + ;
}
idx + + ;
}
return count ;
}
VisualShaderNodeOutput : : PortType VisualShaderNodeOutput : : get_input_port_type ( int p_port ) const {
int idx = 0 ;
int count = 0 ;
while ( ports [ idx ] . mode ! = Shader : : MODE_MAX ) {
if ( ports [ idx ] . mode = = shader_mode & & ports [ idx ] . shader_type = = shader_type ) {
if ( count = = p_port ) {
return ports [ idx ] . type ;
}
count + + ;
}
idx + + ;
}
return PORT_TYPE_SCALAR ;
}
String VisualShaderNodeOutput : : get_input_port_name ( int p_port ) const {
int idx = 0 ;
int count = 0 ;
while ( ports [ idx ] . mode ! = Shader : : MODE_MAX ) {
if ( ports [ idx ] . mode = = shader_mode & & ports [ idx ] . shader_type = = shader_type ) {
if ( count = = p_port ) {
return String ( ports [ idx ] . name ) . capitalize ( ) ;
}
count + + ;
}
idx + + ;
}
return String ( ) ;
}
Variant VisualShaderNodeOutput : : get_input_port_default_value ( int p_port ) const {
return Variant ( ) ;
}
int VisualShaderNodeOutput : : get_output_port_count ( ) const {
return 0 ;
}
2020-05-14 12:29:06 +00:00
2018-07-14 21:15:42 +00:00
VisualShaderNodeOutput : : PortType VisualShaderNodeOutput : : get_output_port_type ( int p_port ) const {
return PORT_TYPE_SCALAR ;
}
2020-05-14 12:29:06 +00:00
2018-07-14 21:15:42 +00:00
String VisualShaderNodeOutput : : get_output_port_name ( int p_port ) const {
return String ( ) ;
}
bool VisualShaderNodeOutput : : is_port_separator ( int p_index ) const {
2021-05-27 19:17:58 +00:00
if ( shader_mode = = Shader : : MODE_SPATIAL & & shader_type = = VisualShader : : TYPE_VERTEX ) {
String name = get_input_port_name ( p_index ) ;
return bool ( name = = " Model View Matrix " ) ;
}
2018-07-14 21:15:42 +00:00
if ( shader_mode = = Shader : : MODE_SPATIAL & & shader_type = = VisualShader : : TYPE_FRAGMENT ) {
String name = get_input_port_name ( p_index ) ;
2021-05-27 19:17:58 +00:00
return bool ( name = = " Normal " | | name = = " Rim " | | name = = " Alpha Scissor Threshold " ) ;
2018-07-14 21:15:42 +00:00
}
return false ;
}
String VisualShaderNodeOutput : : get_caption ( ) const {
2019-10-29 06:26:05 +00:00
return " Output " ;
2018-07-14 21:15:42 +00:00
}
2019-01-21 19:07:53 +00:00
String VisualShaderNodeOutput : : generate_code ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id , const String * p_input_vars , const String * p_output_vars , bool p_for_preview ) const {
2018-07-14 21:15:42 +00:00
int idx = 0 ;
int count = 0 ;
String code ;
while ( ports [ idx ] . mode ! = Shader : : MODE_MAX ) {
if ( ports [ idx ] . mode = = shader_mode & & ports [ idx ] . shader_type = = shader_type ) {
if ( p_input_vars [ count ] ! = String ( ) ) {
String s = ports [ idx ] . string ;
if ( s . find ( " : " ) ! = - 1 ) {
code + = " \t " + s . get_slicec ( ' : ' , 0 ) + " = " + p_input_vars [ count ] + " . " + s . get_slicec ( ' : ' , 1 ) + " ; \n " ;
} else {
code + = " \t " + s + " = " + p_input_vars [ count ] + " ; \n " ;
}
}
count + + ;
}
idx + + ;
}
return code ;
}
VisualShaderNodeOutput : : VisualShaderNodeOutput ( ) {
}
///////////////////////////
void VisualShaderNodeUniform : : set_uniform_name ( const String & p_name ) {
uniform_name = p_name ;
emit_signal ( " name_changed " ) ;
emit_changed ( ) ;
}
String VisualShaderNodeUniform : : get_uniform_name ( ) const {
return uniform_name ;
}
2020-05-05 08:25:48 +00:00
void VisualShaderNodeUniform : : set_qualifier ( VisualShaderNodeUniform : : Qualifier p_qual ) {
qualifier = p_qual ;
emit_changed ( ) ;
}
VisualShaderNodeUniform : : Qualifier VisualShaderNodeUniform : : get_qualifier ( ) const {
return qualifier ;
}
2020-07-28 08:02:57 +00:00
void VisualShaderNodeUniform : : set_global_code_generated ( bool p_enabled ) {
global_code_generated = p_enabled ;
}
bool VisualShaderNodeUniform : : is_global_code_generated ( ) const {
return global_code_generated ;
}
2018-07-14 21:15:42 +00:00
void VisualShaderNodeUniform : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " set_uniform_name " , " name " ) , & VisualShaderNodeUniform : : set_uniform_name ) ;
ClassDB : : bind_method ( D_METHOD ( " get_uniform_name " ) , & VisualShaderNodeUniform : : get_uniform_name ) ;
2020-05-05 08:25:48 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_qualifier " , " qualifier " ) , & VisualShaderNodeUniform : : set_qualifier ) ;
ClassDB : : bind_method ( D_METHOD ( " get_qualifier " ) , & VisualShaderNodeUniform : : get_qualifier ) ;
2020-02-20 21:58:05 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : STRING_NAME , " uniform_name " ) , " set_uniform_name " , " get_uniform_name " ) ;
2020-05-05 08:25:48 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : INT , " qualifier " , PROPERTY_HINT_ENUM , " None,Global,Instance " ) , " set_qualifier " , " get_qualifier " ) ;
BIND_ENUM_CONSTANT ( QUAL_NONE ) ;
BIND_ENUM_CONSTANT ( QUAL_GLOBAL ) ;
BIND_ENUM_CONSTANT ( QUAL_INSTANCE ) ;
}
String VisualShaderNodeUniform : : _get_qual_str ( ) const {
if ( is_qualifier_supported ( qualifier ) ) {
switch ( qualifier ) {
case QUAL_NONE :
break ;
case QUAL_GLOBAL :
return " global " ;
case QUAL_INSTANCE :
return " instance " ;
}
}
return String ( ) ;
2018-07-14 21:15:42 +00:00
}
2020-04-06 07:25:05 +00:00
String VisualShaderNodeUniform : : get_warning ( Shader : : Mode p_mode , VisualShader : : Type p_type ) const {
List < String > keyword_list ;
ShaderLanguage : : get_keyword_list ( & keyword_list ) ;
if ( keyword_list . find ( uniform_name ) ) {
return TTR ( " Uniform name cannot be equal to a shader keyword. Choose another name. " ) ;
}
2020-05-05 08:25:48 +00:00
if ( ! is_qualifier_supported ( qualifier ) ) {
return " This uniform type does not support that qualifier. " ;
}
2020-04-06 07:25:05 +00:00
return String ( ) ;
}
2020-05-05 08:25:48 +00:00
Vector < StringName > VisualShaderNodeUniform : : get_editable_properties ( ) const {
Vector < StringName > props ;
props . push_back ( " qualifier " ) ;
return props ;
}
2018-07-14 21:15:42 +00:00
VisualShaderNodeUniform : : VisualShaderNodeUniform ( ) {
}
2019-05-12 12:09:39 +00:00
2020-10-04 09:11:58 +00:00
////////////// ResizeableBase
2019-05-12 12:09:39 +00:00
2020-10-04 09:11:58 +00:00
void VisualShaderNodeResizableBase : : set_size ( const Vector2 & p_size ) {
2019-05-12 12:09:39 +00:00
size = p_size ;
}
2020-10-04 09:11:58 +00:00
Vector2 VisualShaderNodeResizableBase : : get_size ( ) const {
2019-05-12 12:09:39 +00:00
return size ;
}
2020-10-04 09:11:58 +00:00
void VisualShaderNodeResizableBase : : set_allow_v_resize ( bool p_enabled ) {
allow_v_resize = p_enabled ;
}
bool VisualShaderNodeResizableBase : : is_allow_v_resize ( ) const {
return allow_v_resize ;
}
void VisualShaderNodeResizableBase : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " set_size " , " size " ) , & VisualShaderNodeResizableBase : : set_size ) ;
ClassDB : : bind_method ( D_METHOD ( " get_size " ) , & VisualShaderNodeResizableBase : : get_size ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : VECTOR2 , " size " ) , " set_size " , " get_size " ) ;
}
VisualShaderNodeResizableBase : : VisualShaderNodeResizableBase ( ) {
set_allow_v_resize ( true ) ;
}
2021-02-21 08:33:55 +00:00
////////////// Comment
String VisualShaderNodeComment : : get_caption ( ) const {
return title ;
}
int VisualShaderNodeComment : : get_input_port_count ( ) const {
return 0 ;
}
VisualShaderNodeComment : : PortType VisualShaderNodeComment : : get_input_port_type ( int p_port ) const {
return PortType : : PORT_TYPE_SCALAR ;
}
String VisualShaderNodeComment : : get_input_port_name ( int p_port ) const {
return String ( ) ;
}
int VisualShaderNodeComment : : get_output_port_count ( ) const {
return 0 ;
}
VisualShaderNodeComment : : PortType VisualShaderNodeComment : : get_output_port_type ( int p_port ) const {
return PortType : : PORT_TYPE_SCALAR ;
}
String VisualShaderNodeComment : : get_output_port_name ( int p_port ) const {
return String ( ) ;
}
void VisualShaderNodeComment : : set_title ( const String & p_title ) {
title = p_title ;
}
String VisualShaderNodeComment : : get_title ( ) const {
return title ;
}
void VisualShaderNodeComment : : set_description ( const String & p_description ) {
description = p_description ;
}
String VisualShaderNodeComment : : get_description ( ) const {
return description ;
}
String VisualShaderNodeComment : : generate_code ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id , const String * p_input_vars , const String * p_output_vars , bool p_for_preview ) const {
return String ( ) ;
}
void VisualShaderNodeComment : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " set_title " , " title " ) , & VisualShaderNodeComment : : set_title ) ;
ClassDB : : bind_method ( D_METHOD ( " get_title " ) , & VisualShaderNodeComment : : get_title ) ;
ClassDB : : bind_method ( D_METHOD ( " set_description " , " description " ) , & VisualShaderNodeComment : : set_description ) ;
ClassDB : : bind_method ( D_METHOD ( " get_description " ) , & VisualShaderNodeComment : : get_description ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : STRING , " title " ) , " set_title " , " get_title " ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : STRING , " description " ) , " set_description " , " get_description " ) ;
}
VisualShaderNodeComment : : VisualShaderNodeComment ( ) {
}
2020-10-04 09:11:58 +00:00
////////////// GroupBase
2019-05-12 12:09:39 +00:00
void VisualShaderNodeGroupBase : : set_inputs ( const String & p_inputs ) {
2020-05-14 14:41:43 +00:00
if ( inputs = = p_inputs ) {
2019-05-12 12:09:39 +00:00
return ;
2020-05-14 14:41:43 +00:00
}
2019-05-12 12:09:39 +00:00
clear_input_ports ( ) ;
inputs = p_inputs ;
Vector < String > input_strings = inputs . split ( " ; " , false ) ;
int input_port_count = input_strings . size ( ) ;
for ( int i = 0 ; i < input_port_count ; i + + ) {
Vector < String > arr = input_strings [ i ] . split ( " , " ) ;
2019-06-22 14:41:51 +00:00
ERR_FAIL_COND ( arr . size ( ) ! = 3 ) ;
2019-05-12 12:09:39 +00:00
int port_idx = arr [ 0 ] . to_int ( ) ;
int port_type = arr [ 1 ] . to_int ( ) ;
String port_name = arr [ 2 ] ;
Port port ;
port . type = ( PortType ) port_type ;
port . name = port_name ;
input_ports [ port_idx ] = port ;
}
}
String VisualShaderNodeGroupBase : : get_inputs ( ) const {
return inputs ;
}
void VisualShaderNodeGroupBase : : set_outputs ( const String & p_outputs ) {
2020-05-14 14:41:43 +00:00
if ( outputs = = p_outputs ) {
2019-05-12 12:09:39 +00:00
return ;
2020-05-14 14:41:43 +00:00
}
2019-05-12 12:09:39 +00:00
clear_output_ports ( ) ;
outputs = p_outputs ;
Vector < String > output_strings = outputs . split ( " ; " , false ) ;
int output_port_count = output_strings . size ( ) ;
for ( int i = 0 ; i < output_port_count ; i + + ) {
Vector < String > arr = output_strings [ i ] . split ( " , " ) ;
2019-06-22 14:41:51 +00:00
ERR_FAIL_COND ( arr . size ( ) ! = 3 ) ;
2019-05-12 12:09:39 +00:00
int port_idx = arr [ 0 ] . to_int ( ) ;
int port_type = arr [ 1 ] . to_int ( ) ;
String port_name = arr [ 2 ] ;
Port port ;
port . type = ( PortType ) port_type ;
port . name = port_name ;
output_ports [ port_idx ] = port ;
}
}
String VisualShaderNodeGroupBase : : get_outputs ( ) const {
return outputs ;
}
2019-06-22 14:41:51 +00:00
bool VisualShaderNodeGroupBase : : is_valid_port_name ( const String & p_name ) const {
if ( ! p_name . is_valid_identifier ( ) ) {
return false ;
}
for ( int i = 0 ; i < get_input_port_count ( ) ; i + + ) {
if ( get_input_port_name ( i ) = = p_name ) {
return false ;
}
}
for ( int i = 0 ; i < get_output_port_count ( ) ; i + + ) {
if ( get_output_port_name ( i ) = = p_name ) {
return false ;
}
}
return true ;
}
2019-05-12 12:09:39 +00:00
void VisualShaderNodeGroupBase : : add_input_port ( int p_id , int p_type , const String & p_name ) {
String str = itos ( p_id ) + " , " + itos ( p_type ) + " , " + p_name + " ; " ;
Vector < String > inputs_strings = inputs . split ( " ; " , false ) ;
int index = 0 ;
if ( p_id < inputs_strings . size ( ) ) {
for ( int i = 0 ; i < inputs_strings . size ( ) ; i + + ) {
if ( i = = p_id ) {
inputs = inputs . insert ( index , str ) ;
break ;
}
index + = inputs_strings [ i ] . size ( ) ;
}
} else {
inputs + = str ;
}
inputs_strings = inputs . split ( " ; " , false ) ;
index = 0 ;
for ( int i = 0 ; i < inputs_strings . size ( ) ; i + + ) {
int count = 0 ;
for ( int j = 0 ; j < inputs_strings [ i ] . size ( ) ; j + + ) {
if ( inputs_strings [ i ] [ j ] = = ' , ' ) {
break ;
}
count + + ;
}
inputs . erase ( index , count ) ;
inputs = inputs . insert ( index , itos ( i ) ) ;
index + = inputs_strings [ i ] . size ( ) ;
}
_apply_port_changes ( ) ;
2020-09-22 19:54:30 +00:00
emit_changed ( ) ;
2019-05-12 12:09:39 +00:00
}
void VisualShaderNodeGroupBase : : remove_input_port ( int p_id ) {
2019-06-22 14:41:51 +00:00
ERR_FAIL_COND ( ! has_input_port ( p_id ) ) ;
2019-05-12 12:09:39 +00:00
Vector < String > inputs_strings = inputs . split ( " ; " , false ) ;
int count = 0 ;
int index = 0 ;
for ( int i = 0 ; i < inputs_strings . size ( ) ; i + + ) {
Vector < String > arr = inputs_strings [ i ] . split ( " , " ) ;
if ( arr [ 0 ] . to_int ( ) = = p_id ) {
count = inputs_strings [ i ] . size ( ) ;
break ;
}
index + = inputs_strings [ i ] . size ( ) ;
}
inputs . erase ( index , count ) ;
inputs_strings = inputs . split ( " ; " , false ) ;
2020-12-01 13:24:06 +00:00
inputs = inputs . substr ( 0 , index ) ;
2019-05-12 12:09:39 +00:00
for ( int i = p_id ; i < inputs_strings . size ( ) ; i + + ) {
2020-12-01 13:24:06 +00:00
inputs + = inputs_strings [ i ] . replace_first ( inputs_strings [ i ] . split ( " , " ) [ 0 ] , itos ( i ) ) + " ; " ;
2019-05-12 12:09:39 +00:00
}
_apply_port_changes ( ) ;
2020-09-22 19:54:30 +00:00
emit_changed ( ) ;
2019-05-12 12:09:39 +00:00
}
int VisualShaderNodeGroupBase : : get_input_port_count ( ) const {
return input_ports . size ( ) ;
}
bool VisualShaderNodeGroupBase : : has_input_port ( int p_id ) const {
return input_ports . has ( p_id ) ;
}
void VisualShaderNodeGroupBase : : add_output_port ( int p_id , int p_type , const String & p_name ) {
String str = itos ( p_id ) + " , " + itos ( p_type ) + " , " + p_name + " ; " ;
Vector < String > outputs_strings = outputs . split ( " ; " , false ) ;
int index = 0 ;
if ( p_id < outputs_strings . size ( ) ) {
for ( int i = 0 ; i < outputs_strings . size ( ) ; i + + ) {
if ( i = = p_id ) {
outputs = outputs . insert ( index , str ) ;
break ;
}
index + = outputs_strings [ i ] . size ( ) ;
}
} else {
outputs + = str ;
}
outputs_strings = outputs . split ( " ; " , false ) ;
index = 0 ;
for ( int i = 0 ; i < outputs_strings . size ( ) ; i + + ) {
int count = 0 ;
for ( int j = 0 ; j < outputs_strings [ i ] . size ( ) ; j + + ) {
if ( outputs_strings [ i ] [ j ] = = ' , ' ) {
break ;
}
count + + ;
}
outputs . erase ( index , count ) ;
outputs = outputs . insert ( index , itos ( i ) ) ;
index + = outputs_strings [ i ] . size ( ) ;
}
_apply_port_changes ( ) ;
2020-09-22 19:54:30 +00:00
emit_changed ( ) ;
2019-05-12 12:09:39 +00:00
}
void VisualShaderNodeGroupBase : : remove_output_port ( int p_id ) {
2019-06-22 14:41:51 +00:00
ERR_FAIL_COND ( ! has_output_port ( p_id ) ) ;
2019-05-12 12:09:39 +00:00
Vector < String > outputs_strings = outputs . split ( " ; " , false ) ;
int count = 0 ;
int index = 0 ;
for ( int i = 0 ; i < outputs_strings . size ( ) ; i + + ) {
Vector < String > arr = outputs_strings [ i ] . split ( " , " ) ;
if ( arr [ 0 ] . to_int ( ) = = p_id ) {
count = outputs_strings [ i ] . size ( ) ;
break ;
}
index + = outputs_strings [ i ] . size ( ) ;
}
outputs . erase ( index , count ) ;
outputs_strings = outputs . split ( " ; " , false ) ;
2020-12-01 13:24:06 +00:00
outputs = outputs . substr ( 0 , index ) ;
2019-05-12 12:09:39 +00:00
for ( int i = p_id ; i < outputs_strings . size ( ) ; i + + ) {
2020-12-01 13:24:06 +00:00
outputs + = outputs_strings [ i ] . replace_first ( outputs_strings [ i ] . split ( " , " ) [ 0 ] , itos ( i ) ) + " ; " ;
2019-05-12 12:09:39 +00:00
}
_apply_port_changes ( ) ;
2020-09-22 19:54:30 +00:00
emit_changed ( ) ;
2019-05-12 12:09:39 +00:00
}
int VisualShaderNodeGroupBase : : get_output_port_count ( ) const {
return output_ports . size ( ) ;
}
bool VisualShaderNodeGroupBase : : has_output_port ( int p_id ) const {
return output_ports . has ( p_id ) ;
}
void VisualShaderNodeGroupBase : : clear_input_ports ( ) {
input_ports . clear ( ) ;
}
void VisualShaderNodeGroupBase : : clear_output_ports ( ) {
output_ports . clear ( ) ;
}
void VisualShaderNodeGroupBase : : set_input_port_type ( int p_id , int p_type ) {
2019-06-22 14:41:51 +00:00
ERR_FAIL_COND ( ! has_input_port ( p_id ) ) ;
2019-10-01 08:51:50 +00:00
ERR_FAIL_COND ( p_type < 0 | | p_type > = PORT_TYPE_MAX ) ;
2019-06-22 14:41:51 +00:00
2020-05-14 14:41:43 +00:00
if ( input_ports [ p_id ] . type = = p_type ) {
2019-05-12 12:09:39 +00:00
return ;
2020-05-14 14:41:43 +00:00
}
2019-05-12 12:09:39 +00:00
Vector < String > inputs_strings = inputs . split ( " ; " , false ) ;
int count = 0 ;
int index = 0 ;
for ( int i = 0 ; i < inputs_strings . size ( ) ; i + + ) {
Vector < String > arr = inputs_strings [ i ] . split ( " , " ) ;
2019-12-10 09:03:27 +00:00
ERR_FAIL_COND ( arr . size ( ) ! = 3 ) ;
2019-05-12 12:09:39 +00:00
if ( arr [ 0 ] . to_int ( ) = = p_id ) {
index + = arr [ 0 ] . size ( ) ;
count = arr [ 1 ] . size ( ) - 1 ;
break ;
}
index + = inputs_strings [ i ] . size ( ) ;
}
inputs . erase ( index , count ) ;
inputs = inputs . insert ( index , itos ( p_type ) ) ;
_apply_port_changes ( ) ;
2020-09-22 19:54:30 +00:00
emit_changed ( ) ;
2019-05-12 12:09:39 +00:00
}
VisualShaderNodeGroupBase : : PortType VisualShaderNodeGroupBase : : get_input_port_type ( int p_id ) const {
ERR_FAIL_COND_V ( ! input_ports . has ( p_id ) , ( PortType ) 0 ) ;
return input_ports [ p_id ] . type ;
}
void VisualShaderNodeGroupBase : : set_input_port_name ( int p_id , const String & p_name ) {
2019-06-22 14:41:51 +00:00
ERR_FAIL_COND ( ! has_input_port ( p_id ) ) ;
ERR_FAIL_COND ( ! is_valid_port_name ( p_name ) ) ;
2020-05-14 14:41:43 +00:00
if ( input_ports [ p_id ] . name = = p_name ) {
2019-05-12 12:09:39 +00:00
return ;
2020-05-14 14:41:43 +00:00
}
2019-05-12 12:09:39 +00:00
Vector < String > inputs_strings = inputs . split ( " ; " , false ) ;
int count = 0 ;
int index = 0 ;
for ( int i = 0 ; i < inputs_strings . size ( ) ; i + + ) {
Vector < String > arr = inputs_strings [ i ] . split ( " , " ) ;
2019-12-10 09:03:27 +00:00
ERR_FAIL_COND ( arr . size ( ) ! = 3 ) ;
2019-05-12 12:09:39 +00:00
if ( arr [ 0 ] . to_int ( ) = = p_id ) {
index + = arr [ 0 ] . size ( ) + arr [ 1 ] . size ( ) ;
count = arr [ 2 ] . size ( ) - 1 ;
break ;
}
index + = inputs_strings [ i ] . size ( ) ;
}
inputs . erase ( index , count ) ;
inputs = inputs . insert ( index , p_name ) ;
_apply_port_changes ( ) ;
2020-09-22 19:54:30 +00:00
emit_changed ( ) ;
2019-05-12 12:09:39 +00:00
}
String VisualShaderNodeGroupBase : : get_input_port_name ( int p_id ) const {
ERR_FAIL_COND_V ( ! input_ports . has ( p_id ) , " " ) ;
return input_ports [ p_id ] . name ;
}
void VisualShaderNodeGroupBase : : set_output_port_type ( int p_id , int p_type ) {
2019-06-22 14:41:51 +00:00
ERR_FAIL_COND ( ! has_output_port ( p_id ) ) ;
2019-10-01 08:51:50 +00:00
ERR_FAIL_COND ( p_type < 0 | | p_type > = PORT_TYPE_MAX ) ;
2019-06-22 14:41:51 +00:00
2020-05-14 14:41:43 +00:00
if ( output_ports [ p_id ] . type = = p_type ) {
2019-05-12 12:09:39 +00:00
return ;
2020-05-14 14:41:43 +00:00
}
2019-05-12 12:09:39 +00:00
Vector < String > output_strings = outputs . split ( " ; " , false ) ;
int count = 0 ;
int index = 0 ;
for ( int i = 0 ; i < output_strings . size ( ) ; i + + ) {
Vector < String > arr = output_strings [ i ] . split ( " , " ) ;
2019-12-10 09:03:27 +00:00
ERR_FAIL_COND ( arr . size ( ) ! = 3 ) ;
2019-05-12 12:09:39 +00:00
if ( arr [ 0 ] . to_int ( ) = = p_id ) {
index + = arr [ 0 ] . size ( ) ;
count = arr [ 1 ] . size ( ) - 1 ;
break ;
}
index + = output_strings [ i ] . size ( ) ;
}
outputs . erase ( index , count ) ;
outputs = outputs . insert ( index , itos ( p_type ) ) ;
_apply_port_changes ( ) ;
2020-09-22 19:54:30 +00:00
emit_changed ( ) ;
2019-05-12 12:09:39 +00:00
}
VisualShaderNodeGroupBase : : PortType VisualShaderNodeGroupBase : : get_output_port_type ( int p_id ) const {
ERR_FAIL_COND_V ( ! output_ports . has ( p_id ) , ( PortType ) 0 ) ;
return output_ports [ p_id ] . type ;
}
void VisualShaderNodeGroupBase : : set_output_port_name ( int p_id , const String & p_name ) {
2019-06-22 14:41:51 +00:00
ERR_FAIL_COND ( ! has_output_port ( p_id ) ) ;
ERR_FAIL_COND ( ! is_valid_port_name ( p_name ) ) ;
2020-05-14 14:41:43 +00:00
if ( output_ports [ p_id ] . name = = p_name ) {
2019-05-12 12:09:39 +00:00
return ;
2020-05-14 14:41:43 +00:00
}
2019-05-12 12:09:39 +00:00
Vector < String > output_strings = outputs . split ( " ; " , false ) ;
int count = 0 ;
int index = 0 ;
for ( int i = 0 ; i < output_strings . size ( ) ; i + + ) {
Vector < String > arr = output_strings [ i ] . split ( " , " ) ;
2019-12-10 09:03:27 +00:00
ERR_FAIL_COND ( arr . size ( ) ! = 3 ) ;
2019-05-12 12:09:39 +00:00
if ( arr [ 0 ] . to_int ( ) = = p_id ) {
index + = arr [ 0 ] . size ( ) + arr [ 1 ] . size ( ) ;
count = arr [ 2 ] . size ( ) - 1 ;
break ;
}
index + = output_strings [ i ] . size ( ) ;
}
outputs . erase ( index , count ) ;
outputs = outputs . insert ( index , p_name ) ;
_apply_port_changes ( ) ;
2020-09-22 19:54:30 +00:00
emit_changed ( ) ;
2019-05-12 12:09:39 +00:00
}
String VisualShaderNodeGroupBase : : get_output_port_name ( int p_id ) const {
ERR_FAIL_COND_V ( ! output_ports . has ( p_id ) , " " ) ;
return output_ports [ p_id ] . name ;
}
int VisualShaderNodeGroupBase : : get_free_input_port_id ( ) const {
return input_ports . size ( ) ;
}
int VisualShaderNodeGroupBase : : get_free_output_port_id ( ) const {
return output_ports . size ( ) ;
}
2021-04-24 20:33:50 +00:00
void VisualShaderNodeGroupBase : : set_ctrl_pressed ( Control * p_control , int p_index ) {
2019-05-12 12:09:39 +00:00
controls [ p_index ] = p_control ;
}
2021-04-24 20:33:50 +00:00
Control * VisualShaderNodeGroupBase : : is_ctrl_pressed ( int p_index ) {
2020-04-01 23:20:12 +00:00
ERR_FAIL_COND_V ( ! controls . has ( p_index ) , nullptr ) ;
2019-05-12 12:09:39 +00:00
return controls [ p_index ] ;
}
void VisualShaderNodeGroupBase : : _apply_port_changes ( ) {
Vector < String > inputs_strings = inputs . split ( " ; " , false ) ;
Vector < String > outputs_strings = outputs . split ( " ; " , false ) ;
clear_input_ports ( ) ;
clear_output_ports ( ) ;
for ( int i = 0 ; i < inputs_strings . size ( ) ; i + + ) {
Vector < String > arr = inputs_strings [ i ] . split ( " , " ) ;
2019-12-10 09:03:27 +00:00
ERR_FAIL_COND ( arr . size ( ) ! = 3 ) ;
2019-05-12 12:09:39 +00:00
Port port ;
port . type = ( PortType ) arr [ 1 ] . to_int ( ) ;
port . name = arr [ 2 ] ;
input_ports [ i ] = port ;
}
for ( int i = 0 ; i < outputs_strings . size ( ) ; i + + ) {
Vector < String > arr = outputs_strings [ i ] . split ( " , " ) ;
2019-12-10 09:03:27 +00:00
ERR_FAIL_COND ( arr . size ( ) ! = 3 ) ;
2019-05-12 12:09:39 +00:00
Port port ;
port . type = ( PortType ) arr [ 1 ] . to_int ( ) ;
port . name = arr [ 2 ] ;
output_ports [ i ] = port ;
}
}
2019-08-18 05:09:05 +00:00
void VisualShaderNodeGroupBase : : set_editable ( bool p_enabled ) {
editable = p_enabled ;
}
bool VisualShaderNodeGroupBase : : is_editable ( ) const {
return editable ;
}
2019-05-12 12:09:39 +00:00
void VisualShaderNodeGroupBase : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " set_inputs " , " inputs " ) , & VisualShaderNodeGroupBase : : set_inputs ) ;
ClassDB : : bind_method ( D_METHOD ( " get_inputs " ) , & VisualShaderNodeGroupBase : : get_inputs ) ;
ClassDB : : bind_method ( D_METHOD ( " set_outputs " , " outputs " ) , & VisualShaderNodeGroupBase : : set_outputs ) ;
ClassDB : : bind_method ( D_METHOD ( " get_outputs " ) , & VisualShaderNodeGroupBase : : get_outputs ) ;
2019-06-22 14:41:51 +00:00
ClassDB : : bind_method ( D_METHOD ( " is_valid_port_name " , " name " ) , & VisualShaderNodeGroupBase : : is_valid_port_name ) ;
2019-05-12 12:09:39 +00:00
ClassDB : : bind_method ( D_METHOD ( " add_input_port " , " id " , " type " , " name " ) , & VisualShaderNodeGroupBase : : add_input_port ) ;
ClassDB : : bind_method ( D_METHOD ( " remove_input_port " , " id " ) , & VisualShaderNodeGroupBase : : remove_input_port ) ;
ClassDB : : bind_method ( D_METHOD ( " get_input_port_count " ) , & VisualShaderNodeGroupBase : : get_input_port_count ) ;
ClassDB : : bind_method ( D_METHOD ( " has_input_port " , " id " ) , & VisualShaderNodeGroupBase : : has_input_port ) ;
ClassDB : : bind_method ( D_METHOD ( " clear_input_ports " ) , & VisualShaderNodeGroupBase : : clear_input_ports ) ;
ClassDB : : bind_method ( D_METHOD ( " add_output_port " , " id " , " type " , " name " ) , & VisualShaderNodeGroupBase : : add_output_port ) ;
ClassDB : : bind_method ( D_METHOD ( " remove_output_port " , " id " ) , & VisualShaderNodeGroupBase : : remove_output_port ) ;
ClassDB : : bind_method ( D_METHOD ( " get_output_port_count " ) , & VisualShaderNodeGroupBase : : get_output_port_count ) ;
ClassDB : : bind_method ( D_METHOD ( " has_output_port " , " id " ) , & VisualShaderNodeGroupBase : : has_output_port ) ;
ClassDB : : bind_method ( D_METHOD ( " clear_output_ports " ) , & VisualShaderNodeGroupBase : : clear_output_ports ) ;
2019-09-24 09:44:48 +00:00
ClassDB : : bind_method ( D_METHOD ( " set_input_port_name " , " id " , " name " ) , & VisualShaderNodeGroupBase : : set_input_port_name ) ;
ClassDB : : bind_method ( D_METHOD ( " set_input_port_type " , " id " , " type " ) , & VisualShaderNodeGroupBase : : set_input_port_type ) ;
ClassDB : : bind_method ( D_METHOD ( " set_output_port_name " , " id " , " name " ) , & VisualShaderNodeGroupBase : : set_output_port_name ) ;
ClassDB : : bind_method ( D_METHOD ( " set_output_port_type " , " id " , " type " ) , & VisualShaderNodeGroupBase : : set_output_port_type ) ;
2019-05-12 12:09:39 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_free_input_port_id " ) , & VisualShaderNodeGroupBase : : get_free_input_port_id ) ;
ClassDB : : bind_method ( D_METHOD ( " get_free_output_port_id " ) , & VisualShaderNodeGroupBase : : get_free_output_port_id ) ;
}
String VisualShaderNodeGroupBase : : generate_code ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id , const String * p_input_vars , const String * p_output_vars , bool p_for_preview ) const {
return " " ;
}
VisualShaderNodeGroupBase : : VisualShaderNodeGroupBase ( ) {
2020-09-07 09:29:44 +00:00
simple_decl = false ;
2019-05-12 12:09:39 +00:00
}
////////////// Expression
String VisualShaderNodeExpression : : get_caption ( ) const {
return " Expression " ;
}
void VisualShaderNodeExpression : : set_expression ( const String & p_expression ) {
expression = p_expression ;
2020-09-22 19:54:30 +00:00
emit_changed ( ) ;
2019-05-12 12:09:39 +00:00
}
String VisualShaderNodeExpression : : get_expression ( ) const {
return expression ;
}
String VisualShaderNodeExpression : : generate_code ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id , const String * p_input_vars , const String * p_output_vars , bool p_for_preview ) const {
String _expression = expression ;
_expression = _expression . insert ( 0 , " \n " ) ;
_expression = _expression . replace ( " \n " , " \n \t \t " ) ;
static Vector < String > pre_symbols ;
2020-12-15 12:04:21 +00:00
if ( pre_symbols . is_empty ( ) ) {
2019-05-12 12:09:39 +00:00
pre_symbols . push_back ( " \t " ) ;
2019-08-07 10:48:36 +00:00
pre_symbols . push_back ( " , " ) ;
2019-09-01 10:12:33 +00:00
pre_symbols . push_back ( " ; " ) ;
2019-05-12 12:09:39 +00:00
pre_symbols . push_back ( " { " ) ;
pre_symbols . push_back ( " [ " ) ;
2019-09-04 13:00:18 +00:00
pre_symbols . push_back ( " ] " ) ;
2019-05-12 12:09:39 +00:00
pre_symbols . push_back ( " ( " ) ;
pre_symbols . push_back ( " " ) ;
pre_symbols . push_back ( " - " ) ;
pre_symbols . push_back ( " * " ) ;
pre_symbols . push_back ( " / " ) ;
pre_symbols . push_back ( " + " ) ;
pre_symbols . push_back ( " = " ) ;
pre_symbols . push_back ( " & " ) ;
pre_symbols . push_back ( " | " ) ;
pre_symbols . push_back ( " ! " ) ;
}
static Vector < String > post_symbols ;
2020-12-15 12:04:21 +00:00
if ( post_symbols . is_empty ( ) ) {
2019-05-12 12:09:39 +00:00
post_symbols . push_back ( " \t " ) ;
post_symbols . push_back ( " \n " ) ;
2019-09-01 08:18:29 +00:00
post_symbols . push_back ( " , " ) ;
2019-05-21 15:37:31 +00:00
post_symbols . push_back ( " ; " ) ;
2019-05-12 12:09:39 +00:00
post_symbols . push_back ( " } " ) ;
2019-09-04 13:00:18 +00:00
post_symbols . push_back ( " [ " ) ;
2019-05-12 12:09:39 +00:00
post_symbols . push_back ( " ] " ) ;
post_symbols . push_back ( " ) " ) ;
post_symbols . push_back ( " " ) ;
post_symbols . push_back ( " . " ) ;
post_symbols . push_back ( " - " ) ;
post_symbols . push_back ( " * " ) ;
post_symbols . push_back ( " / " ) ;
post_symbols . push_back ( " + " ) ;
post_symbols . push_back ( " = " ) ;
post_symbols . push_back ( " & " ) ;
post_symbols . push_back ( " | " ) ;
post_symbols . push_back ( " ! " ) ;
}
for ( int i = 0 ; i < get_input_port_count ( ) ; i + + ) {
for ( int j = 0 ; j < pre_symbols . size ( ) ; j + + ) {
for ( int k = 0 ; k < post_symbols . size ( ) ; k + + ) {
_expression = _expression . replace ( pre_symbols [ j ] + get_input_port_name ( i ) + post_symbols [ k ] , pre_symbols [ j ] + p_input_vars [ i ] + post_symbols [ k ] ) ;
}
}
}
for ( int i = 0 ; i < get_output_port_count ( ) ; i + + ) {
for ( int j = 0 ; j < pre_symbols . size ( ) ; j + + ) {
for ( int k = 0 ; k < post_symbols . size ( ) ; k + + ) {
_expression = _expression . replace ( pre_symbols [ j ] + get_output_port_name ( i ) + post_symbols [ k ] , pre_symbols [ j ] + p_output_vars [ i ] + post_symbols [ k ] ) ;
}
}
}
String output_initializer ;
for ( int i = 0 ; i < get_output_port_count ( ) ; i + + ) {
int port_type = get_output_port_type ( i ) ;
String tk = " " ;
switch ( port_type ) {
case PORT_TYPE_SCALAR :
tk = " 0.0 " ;
break ;
2020-02-25 14:50:49 +00:00
case PORT_TYPE_SCALAR_INT :
tk = " 0 " ;
break ;
2019-05-12 12:09:39 +00:00
case PORT_TYPE_VECTOR :
tk = " vec3(0.0, 0.0, 0.0) " ;
break ;
case PORT_TYPE_BOOLEAN :
tk = " false " ;
break ;
case PORT_TYPE_TRANSFORM :
tk = " mat4(1.0) " ;
break ;
default :
continue ;
}
2020-01-27 09:10:51 +00:00
output_initializer + = " \t " + p_output_vars [ i ] + " = " + tk + " ; \n " ;
2019-05-12 12:09:39 +00:00
}
String code ;
code + = output_initializer ;
code + = " \t { " ;
code + = _expression ;
2020-02-03 12:58:58 +00:00
code + = " \n \t } \n " ;
2019-05-12 12:09:39 +00:00
return code ;
}
void VisualShaderNodeExpression : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " set_expression " , " expression " ) , & VisualShaderNodeExpression : : set_expression ) ;
ClassDB : : bind_method ( D_METHOD ( " get_expression " ) , & VisualShaderNodeExpression : : get_expression ) ;
ADD_PROPERTY ( PropertyInfo ( Variant : : STRING , " expression " ) , " set_expression " , " get_expression " ) ;
}
VisualShaderNodeExpression : : VisualShaderNodeExpression ( ) {
2019-08-18 05:09:05 +00:00
set_editable ( true ) ;
}
////////////// Global Expression
String VisualShaderNodeGlobalExpression : : get_caption ( ) const {
return " GlobalExpression " ;
}
String VisualShaderNodeGlobalExpression : : generate_global ( Shader : : Mode p_mode , VisualShader : : Type p_type , int p_id ) const {
return expression ;
}
VisualShaderNodeGlobalExpression : : VisualShaderNodeGlobalExpression ( ) {
set_editable ( false ) ;
2019-05-12 12:09:39 +00:00
}