godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/scene/resources/visual_shader.cpp

4198 lines
156 KiB
C++
Raw Normal View History

Add missing copyright headers
2018-08-29 20:38:13 +00:00
/*************************************************************************/
/* visual_shader.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
Update copyright statements to 2022 Happy new year to the wonderful Godot community!
2022-01-03 20:27:34 +00:00
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
Add missing copyright headers
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. */
/*************************************************************************/
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
#include "visual_shader.h"
Fix GetTypeInfo error due to missing include
2019-05-27 15:33:25 +00:00
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 22:33:38 +00:00
#include "core/templates/vmap.h"
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 18:21:27 +00:00
#include "servers/rendering/shader_types.h"
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
#include "visual_shader_nodes.h"
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
#include "visual_shader_particle_nodes.h"
Added SDF nodes to visual shader
2020-11-27 07:00:23 +00:00
#include "visual_shader_sdf_nodes.h"
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Added `MeshEmitter` node for particles in visual shader
2021-11-05 19:57:24 +00:00
String make_unique_id(VisualShader::Type p_type, int p_id, const String &p_name) {
static const char *typepf[VisualShader::TYPE_MAX] = { "vtx", "frg", "lgt", "start", "process", "collide", "start_custom", "process_custom", "sky", "fog" };
return p_name + "_" + String(typepf[p_type]) + "_" + itos(p_id);
}
Better visual shader code generation
2020-01-27 09:10:51 +00:00
bool VisualShaderNode::is_simple_decl() const {
return simple_decl;
}
Visual Shaders are back.
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;
}
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
void VisualShaderNode::set_input_port_default_value(int p_port, const Variant &p_value, const Variant &p_prev_value) {
Variant value = p_value;
if (p_prev_value.get_type() != Variant::NIL) {
switch (p_value.get_type()) {
case Variant::FLOAT: {
switch (p_prev_value.get_type()) {
case Variant::INT: {
value = (float)p_prev_value;
} break;
case Variant::FLOAT: {
value = p_prev_value;
} break;
case Variant::VECTOR2: {
Vector2 pv = p_prev_value;
value = pv.x;
} break;
case Variant::VECTOR3: {
Vector3 pv = p_prev_value;
value = pv.x;
} break;
default:
break;
}
} break;
case Variant::INT: {
switch (p_prev_value.get_type()) {
case Variant::INT: {
value = p_prev_value;
} break;
case Variant::FLOAT: {
value = (int)p_prev_value;
} break;
case Variant::VECTOR2: {
Vector2 pv = p_prev_value;
value = (int)pv.x;
} break;
case Variant::VECTOR3: {
Vector3 pv = p_prev_value;
value = (int)pv.x;
} break;
default:
break;
}
} break;
case Variant::VECTOR2: {
switch (p_prev_value.get_type()) {
case Variant::INT: {
float pv = (float)(int)p_prev_value;
value = Vector2(pv, pv);
} break;
case Variant::FLOAT: {
float pv = p_prev_value;
value = Vector2(pv, pv);
} break;
case Variant::VECTOR2: {
value = p_prev_value;
} break;
case Variant::VECTOR3: {
Vector3 pv = p_prev_value;
value = Vector2(pv.x, pv.y);
} break;
default:
break;
}
} break;
case Variant::VECTOR3: {
switch (p_prev_value.get_type()) {
case Variant::INT: {
float pv = (float)(int)p_prev_value;
value = Vector3(pv, pv, pv);
} break;
case Variant::FLOAT: {
float pv = p_prev_value;
value = Vector3(pv, pv, pv);
} break;
case Variant::VECTOR2: {
Vector2 pv = p_prev_value;
value = Vector3(pv.x, pv.y, 0.0);
} break;
case Variant::VECTOR3: {
value = p_prev_value;
} break;
default:
break;
}
} break;
default:
break;
}
}
default_input_values[p_port] = value;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
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();
}
Adds `UVFunc` for panning/scaling on UV's to VisualShader's.
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();
}
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
bool VisualShaderNode::is_port_separator(int p_index) const {
return false;
}
Removes redundant code generation in VisualShaderNodeTextureUniform
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)) {
Fix VisualShaderNode::set_output_port_connected
2020-10-02 06:06:13 +00:00
return connected_output_ports[p_port] > 0;
Removes redundant code generation in VisualShaderNodeTextureUniform
2020-07-26 01:04:07 +00:00
}
return false;
}
void VisualShaderNode::set_output_port_connected(int p_port, bool p_connected) {
Fix small reconnection bug in visual shader
2020-07-31 07:40:05 +00:00
if (p_connected) {
Fix VisualShaderNode::set_output_port_connected
2020-10-02 06:06:13 +00:00
connected_output_ports[p_port]++;
Fix small reconnection bug in visual shader
2020-07-31 07:40:05 +00:00
} else {
Fix VisualShaderNode::set_output_port_connected
2020-10-02 06:06:13 +00:00
connected_output_ports[p_port]--;
Fix small reconnection bug in visual shader
2020-07-31 07:40:05 +00:00
}
Removes redundant code generation in VisualShaderNodeTextureUniform
2020-07-26 01:04:07 +00:00
}
Optimize code generation for fresnel node in visual shaders
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;
}
Implements expandable color ports in visual shaders
2020-12-20 15:45:53 +00:00
bool VisualShaderNode::is_output_port_expandable(int p_port) const {
return false;
}
Make port previews in visual shader visible in other shader modes
2021-10-08 19:55:07 +00:00
bool VisualShaderNode::has_output_port_preview(int p_port) const {
return true;
}
Implements expandable color ports in visual shaders
2020-12-20 15:45:53 +00:00
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)) {
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
switch (get_output_port_type(i)) {
case PORT_TYPE_VECTOR_2D: {
count2 += 2;
} break;
case PORT_TYPE_VECTOR: {
count2 += 3;
} break;
default:
break;
Implements expandable color ports in visual shaders
2020-12-20 15:45:53 +00:00
}
}
}
return count2;
}
Removes redundant code generation in VisualShaderNodeTextureUniform
2020-07-26 01:04:07 +00:00
bool VisualShaderNode::is_code_generated() const {
return true;
}
Fix some bugs in visual shader editor
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;
}
Added Billboard Node to Visual Shaders
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;
}
Visual Shaders are back.
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>();
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Visual Shaders are back.
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();
}
Added triplanar uniform texture node to visual shaders
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();
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Vector<StringName> VisualShaderNode::get_editable_properties() const {
return Vector<StringName>();
}
Added 2D boolean hint for particle emitters in visual shaders
2021-11-04 15:42:57 +00:00
Map<StringName, String> VisualShaderNode::get_editable_properties_names() const {
return Map<StringName, String>();
}
Hide "default_input_values" property in VisualShaderNode.
2020-01-23 07:42:35 +00:00
Array VisualShaderNode::get_default_input_values() const {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Array ret;
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<int, Variant> &E : default_input_values) {
ret.push_back(E.key);
ret.push_back(E.value);
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
return ret;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Hide "default_input_values" property in VisualShaderNode.
2020-01-23 07:42:35 +00:00
void VisualShaderNode::set_default_input_values(const Array &p_values) {
Visual Shaders are back.
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();
}
Fix default input port hints for some modes in visual shader
2022-01-22 08:09:16 +00:00
bool VisualShaderNode::is_input_port_default(int p_port, Shader::Mode p_mode) const {
return false;
Makes Texture and TextureUniform in visual shaders to use UV by default
2019-10-03 07:40:26 +00:00
}
Visual Shaders are back.
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);
Implements expandable color ports in visual shaders
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);
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
ClassDB::bind_method(D_METHOD("set_input_port_default_value", "port", "value", "prev_value"), &VisualShaderNode::set_input_port_default_value, DEFVAL(Variant()));
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
ClassDB::bind_method(D_METHOD("get_input_port_default_value", "port"), &VisualShaderNode::get_input_port_default_value);
Adds `UVFunc` for panning/scaling on UV's to VisualShader's.
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);
Hide "default_input_values" property in VisualShaderNode.
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);
Visual Shaders are back.
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");
Rename `PROPERTY_USAGE_NOEDITOR` to `PROPERTY_USAGE_NO_EDITOR` This is consistent with other constants that include `NO`, such as `PROPERTY_HINT_COLOR_NO_ALPHA`.
2021-11-03 22:06:17 +00:00
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "default_input_values", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL), "set_default_input_values", "get_default_input_values");
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "expanded_output_ports", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL), "_set_output_ports_expanded", "_get_output_ports_expanded");
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
ADD_SIGNAL(MethodInfo("editor_refresh_request"));
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
BIND_ENUM_CONSTANT(PORT_TYPE_SCALAR);
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
BIND_ENUM_CONSTANT(PORT_TYPE_SCALAR_INT);
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
BIND_ENUM_CONSTANT(PORT_TYPE_VECTOR_2D);
Plugin support for visual shaders
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);
Added sampler port type for visual shaders
2019-10-01 08:51:50 +00:00
BIND_ENUM_CONSTANT(PORT_TYPE_SAMPLER);
BIND_ENUM_CONSTANT(PORT_TYPE_MAX);
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
VisualShaderNode::VisualShaderNode() {
}
/////////////////////////////////////////////////////////
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
void VisualShaderNodeCustom::update_ports() {
Replace BIND_VMETHOD by new GDVIRTUAL syntax * New syntax is type safe. * New syntax allows for type safe virtuals in native extensions. * New syntax permits extremely fast calling. Note: Everything was replaced where possible except for `_gui_input` `_input` and `_unhandled_input`. These will require API rework on a separate PR as they work different than the rest of the functions. Added a new method flag METHOD_FLAG_OBJECT_CORE, used internally. Allows to not dump the core virtuals like `_notification` to the json API, since each language will implement those as it is best fits.
2021-08-22 01:52:44 +00:00
{
input_ports.clear();
int input_port_count;
if (GDVIRTUAL_CALL(_get_input_port_count, input_port_count)) {
for (int i = 0; i < input_port_count; i++) {
Port port;
if (!GDVIRTUAL_CALL(_get_input_port_name, i, port.name)) {
port.name = "in" + itos(i);
}
if (!GDVIRTUAL_CALL(_get_input_port_type, i, port.type)) {
port.type = (int)PortType::PORT_TYPE_SCALAR;
}
input_ports.push_back(port);
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
}
}
}
Replace BIND_VMETHOD by new GDVIRTUAL syntax * New syntax is type safe. * New syntax allows for type safe virtuals in native extensions. * New syntax permits extremely fast calling. Note: Everything was replaced where possible except for `_gui_input` `_input` and `_unhandled_input`. These will require API rework on a separate PR as they work different than the rest of the functions. Added a new method flag METHOD_FLAG_OBJECT_CORE, used internally. Allows to not dump the core virtuals like `_notification` to the json API, since each language will implement those as it is best fits.
2021-08-22 01:52:44 +00:00
{
output_ports.clear();
int output_port_count;
if (GDVIRTUAL_CALL(_get_output_port_count, output_port_count)) {
for (int i = 0; i < output_port_count; i++) {
Port port;
if (!GDVIRTUAL_CALL(_get_output_port_name, i, port.name)) {
port.name = "out" + itos(i);
}
if (!GDVIRTUAL_CALL(_get_output_port_type, i, port.type)) {
port.type = (int)PortType::PORT_TYPE_SCALAR;
}
output_ports.push_back(port);
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
}
}
}
}
String VisualShaderNodeCustom::get_caption() const {
Replace BIND_VMETHOD by new GDVIRTUAL syntax * New syntax is type safe. * New syntax allows for type safe virtuals in native extensions. * New syntax permits extremely fast calling. Note: Everything was replaced where possible except for `_gui_input` `_input` and `_unhandled_input`. These will require API rework on a separate PR as they work different than the rest of the functions. Added a new method flag METHOD_FLAG_OBJECT_CORE, used internally. Allows to not dump the core virtuals like `_notification` to the json API, since each language will implement those as it is best fits.
2021-08-22 01:52:44 +00:00
String ret;
if (GDVIRTUAL_CALL(_get_name, ret)) {
return ret;
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
}
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 {
Fix misspelled "overriden" In recent GDVIRTUAL PR and SkeletonModification3DJiggle doc.
2021-08-25 17:44:01 +00:00
ERR_FAIL_COND_V(!GDVIRTUAL_IS_OVERRIDDEN(_get_code), "");
Add a GDScript template for `VisualShaderNodeCustom`
2022-01-04 08:30:47 +00:00
TypedArray<String> input_vars;
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
for (int i = 0; i < get_input_port_count(); i++) {
input_vars.push_back(p_input_vars[i]);
}
Add a GDScript template for `VisualShaderNodeCustom`
2022-01-04 08:30:47 +00:00
TypedArray<String> output_vars;
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
for (int i = 0; i < get_output_port_count(); i++) {
output_vars.push_back(p_output_vars[i]);
}
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
String code = " {\n";
Replace BIND_VMETHOD by new GDVIRTUAL syntax * New syntax is type safe. * New syntax allows for type safe virtuals in native extensions. * New syntax permits extremely fast calling. Note: Everything was replaced where possible except for `_gui_input` `_input` and `_unhandled_input`. These will require API rework on a separate PR as they work different than the rest of the functions. Added a new method flag METHOD_FLAG_OBJECT_CORE, used internally. Allows to not dump the core virtuals like `_notification` to the json API, since each language will implement those as it is best fits.
2021-08-22 01:52:44 +00:00
String _code;
VisualShader: Document enum args for virtual methods Fixes #31563.
2021-11-10 12:22:58 +00:00
GDVIRTUAL_CALL(_get_code, input_vars, output_vars, p_mode, p_type, _code);
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
bool nend = _code.ends_with("\n");
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
_code = _code.insert(0, " ");
_code = _code.replace("\n", "\n ");
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
code += _code;
if (!nend) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += "\n }";
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
} else {
Rename `remove()` to `remove_at()` when removing by index
2021-07-03 22:17:03 +00:00
code.remove_at(code.size() - 1);
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
code += "}";
}
Added missing '\n' in visual shader custom node code generation
2020-02-01 13:25:34 +00:00
code += "\n";
Plugin support for visual shaders
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 {
Replace BIND_VMETHOD by new GDVIRTUAL syntax * New syntax is type safe. * New syntax allows for type safe virtuals in native extensions. * New syntax permits extremely fast calling. Note: Everything was replaced where possible except for `_gui_input` `_input` and `_unhandled_input`. These will require API rework on a separate PR as they work different than the rest of the functions. Added a new method flag METHOD_FLAG_OBJECT_CORE, used internally. Allows to not dump the core virtuals like `_notification` to the json API, since each language will implement those as it is best fits.
2021-08-22 01:52:44 +00:00
String ret;
VisualShader: Document enum args for virtual methods Fixes #31563.
2021-11-10 12:22:58 +00:00
if (GDVIRTUAL_CALL(_get_global_code, p_mode, ret)) {
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
String code = "// " + get_caption() + "\n";
Replace BIND_VMETHOD by new GDVIRTUAL syntax * New syntax is type safe. * New syntax allows for type safe virtuals in native extensions. * New syntax permits extremely fast calling. Note: Everything was replaced where possible except for `_gui_input` `_input` and `_unhandled_input`. These will require API rework on a separate PR as they work different than the rest of the functions. Added a new method flag METHOD_FLAG_OBJECT_CORE, used internally. Allows to not dump the core virtuals like `_notification` to the json API, since each language will implement those as it is best fits.
2021-08-22 01:52:44 +00:00
code += ret;
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
code += "\n";
return code;
}
return "";
}
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
void VisualShaderNodeCustom::set_input_port_default_value(int p_port, const Variant &p_value, const Variant &p_prev_value) {
Prevents default values of VSNodeCustom from overriding by a script
2021-04-12 10:47:37 +00:00
if (!is_initialized) {
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
VisualShaderNode::set_input_port_default_value(p_port, p_value, p_prev_value);
Prevents default values of VSNodeCustom from overriding by a script
2021-04-12 10:47:37 +00:00
}
}
void VisualShaderNodeCustom::set_default_input_values(const Array &p_values) {
if (!is_initialized) {
VisualShaderNode::set_default_input_values(p_values);
}
}
Adds `UVFunc` for panning/scaling on UV's to VisualShader's.
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();
}
}
Prevents default values of VSNodeCustom from overriding by a script
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;
}
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
void VisualShaderNodeCustom::_bind_methods() {
Replace BIND_VMETHOD by new GDVIRTUAL syntax * New syntax is type safe. * New syntax allows for type safe virtuals in native extensions. * New syntax permits extremely fast calling. Note: Everything was replaced where possible except for `_gui_input` `_input` and `_unhandled_input`. These will require API rework on a separate PR as they work different than the rest of the functions. Added a new method flag METHOD_FLAG_OBJECT_CORE, used internally. Allows to not dump the core virtuals like `_notification` to the json API, since each language will implement those as it is best fits.
2021-08-22 01:52:44 +00:00
GDVIRTUAL_BIND(_get_name);
GDVIRTUAL_BIND(_get_description);
GDVIRTUAL_BIND(_get_category);
GDVIRTUAL_BIND(_get_return_icon_type);
GDVIRTUAL_BIND(_get_input_port_count);
GDVIRTUAL_BIND(_get_input_port_type, "port");
GDVIRTUAL_BIND(_get_input_port_name, "port");
GDVIRTUAL_BIND(_get_output_port_count);
GDVIRTUAL_BIND(_get_output_port_type, "port");
GDVIRTUAL_BIND(_get_output_port_name, "port");
GDVIRTUAL_BIND(_get_code, "input_vars", "output_vars", "mode", "type");
GDVIRTUAL_BIND(_get_global_code, "mode");
GDVIRTUAL_BIND(_is_highend);
Prevents default values of VSNodeCustom from overriding by a script
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);
Rename `PROPERTY_USAGE_NOEDITOR` to `PROPERTY_USAGE_NO_EDITOR` This is consistent with other constants that include `NO`, such as `PROPERTY_HINT_COLOR_NO_ALPHA`.
2021-11-03 22:06:17 +00:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "initialized", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL), "_set_initialized", "_is_initialized");
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
}
VisualShaderNodeCustom::VisualShaderNodeCustom() {
Better visual shader code generation
2020-01-27 09:10:51 +00:00
simple_decl = false;
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
}
/////////////////////////////////////////////////////////
Improve performance of Undo:change node position in visual shader
2020-09-09 08:21:38 +00:00
void VisualShader::set_shader_type(Type p_type) {
current_type = p_type;
}
Improve performance for Show/Hide port preview in visual shaders
2020-09-09 14:40:27 +00:00
VisualShader::Type VisualShader::get_shader_type() const {
return current_type;
}
Makes dictionary instead of string for visual shader version Update doc/classes/VisualShader.xml Co-authored-by: Hugo Locurcio <hugo.locurcio@hugo.pro>
2021-08-01 15:13:51 +00:00
void VisualShader::set_engine_version(const Dictionary &p_engine_version) {
ERR_FAIL_COND(!p_engine_version.has("major"));
ERR_FAIL_COND(!p_engine_version.has("minor"));
engine_version["major"] = p_engine_version["major"];
engine_version["minor"] = p_engine_version["minor"];
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
}
Makes dictionary instead of string for visual shader version Update doc/classes/VisualShader.xml Co-authored-by: Hugo Locurcio <hugo.locurcio@hugo.pro>
2021-08-01 15:13:51 +00:00
Dictionary VisualShader::get_engine_version() const {
return engine_version;
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
}
Makes dictionary instead of string for visual shader version Update doc/classes/VisualShader.xml Co-authored-by: Hugo Locurcio <hugo.locurcio@hugo.pro>
2021-08-01 15:13:51 +00:00
#ifndef DISABLE_DEPRECATED
void VisualShader::update_engine_version(const Dictionary &p_new_version) {
if (engine_version.is_empty()) { // before 4.0
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
for (int i = 0; i < TYPE_MAX; i++) {
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (KeyValue<int, Node> &E : graph[i].nodes) {
Ref<VisualShaderNodeInput> input = Object::cast_to<VisualShaderNodeInput>(E.value.node.ptr());
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
if (input.is_valid()) {
if (input->get_input_name() == "side") {
input->set_input_name("front_facing");
}
}
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
Ref<VisualShaderNodeExpression> expression = Object::cast_to<VisualShaderNodeExpression>(E.value.node.ptr());
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
if (expression.is_valid()) {
for (int j = 0; j < expression->get_input_port_count(); j++) {
int type = expression->get_input_port_type(j);
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
if (type > 0) { // + PORT_TYPE_SCALAR_INT + PORT_TYPE_VECTOR_2D
type += 2;
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
}
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);
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
if (type > 0) { // + PORT_TYPE_SCALAR_INT + PORT_TYPE_VECTOR_2D
type += 2;
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
}
expression->set_output_port_type(j, type);
}
}
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
Ref<VisualShaderNodeStep> step = Object::cast_to<VisualShaderNodeStep>(E.value.node.ptr());
if (step.is_valid()) {
int op_type = int(step->get_op_type());
if (int(op_type) > 0) { // + OP_TYPE_VECTOR_2D + OP_TYPE_VECTOR_2D_SCALAR
op_type += 2;
}
step->set_op_type(VisualShaderNodeStep::OpType(op_type));
}
Ref<VisualShaderNodeSmoothStep> sstep = Object::cast_to<VisualShaderNodeSmoothStep>(E.value.node.ptr());
if (sstep.is_valid()) {
int op_type = int(sstep->get_op_type());
if (int(op_type) > 0) { // + OP_TYPE_VECTOR_2D + OP_TYPE_VECTOR_2D_SCALAR
op_type += 2;
}
sstep->set_op_type(VisualShaderNodeSmoothStep::OpType(op_type));
}
Ref<VisualShaderNodeMix> mix = Object::cast_to<VisualShaderNodeMix>(E.value.node.ptr());
if (mix.is_valid()) {
int op_type = int(mix->get_op_type());
if (int(op_type) > 0) { // + OP_TYPE_VECTOR_2D + OP_TYPE_VECTOR_2D_SCALAR
op_type += 2;
}
mix->set_op_type(VisualShaderNodeMix::OpType(op_type));
}
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
Ref<VisualShaderNodeCompare> compare = Object::cast_to<VisualShaderNodeCompare>(E.value.node.ptr());
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
if (compare.is_valid()) {
int ctype = int(compare->get_comparison_type());
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
if (int(ctype) > 0) { // + CTYPE_SCALAR_INT + CTYPE_VECTOR_2D
ctype += 2;
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
}
compare->set_comparison_type(VisualShaderNodeCompare::ComparisonType(ctype));
}
}
}
}
Makes dictionary instead of string for visual shader version Update doc/classes/VisualShader.xml Co-authored-by: Hugo Locurcio <hugo.locurcio@hugo.pro>
2021-08-01 15:13:51 +00:00
set_engine_version(p_new_version);
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
}
Makes dictionary instead of string for visual shader version Update doc/classes/VisualShader.xml Co-authored-by: Hugo Locurcio <hugo.locurcio@hugo.pro>
2021-08-01 15:13:51 +00:00
#endif /* DISABLE_DEPRECATED */
Visual Shaders are back.
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;
Signals: Port connect calls to use callable_mp Remove now unnecessary bindings of signal callbacks in the public API. There might be some false positives that need rebinding if they were meant to be public. No regular expressions were harmed in the making of this commit. (Nah, just kidding.)
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));
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
Signals: Port connect calls to use callable_mp Remove now unnecessary bindings of signal callbacks in the public API. There might be some false positives that need rebinding if they were meant to be public. No regular expressions were harmed in the making of this commit. (Nah, just kidding.)
2020-02-21 17:28:45 +00:00
n.node->connect("changed", callable_mp(this, &VisualShader::_queue_update));
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Plugin support for visual shaders
2019-08-09 19:51:48 +00:00
Ref<VisualShaderNodeCustom> custom = n.node;
if (custom.is_valid()) {
custom->update_ports();
}
Visual Shaders are back.
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;
}
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
Visual Shaders are back.
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;
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<int, Node> &E : g->nodes) {
ret.push_back(E.key);
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
return ret;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Visual Shaders are back.
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 {
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<int, Node> &E : graph[p_type].nodes) {
if (E.value.node == p_node) {
return E.key;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Visual Shaders are back.
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()) {
Signals: Port connect calls to use callable_mp Remove now unnecessary bindings of signal callbacks in the public API. There might be some false positives that need rebinding if they were meant to be public. No regular expressions were harmed in the making of this commit. (Nah, just kidding.)
2020-02-21 17:28:45 +00:00
input->disconnect("input_type_changed", callable_mp(this, &VisualShader::_input_type_changed));
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
Signals: Port connect calls to use callable_mp Remove now unnecessary bindings of signal callbacks in the public API. There might be some false positives that need rebinding if they were meant to be public. No regular expressions were harmed in the making of this commit. (Nah, just kidding.)
2020-02-21 17:28:45 +00:00
g->nodes[p_id].node->disconnect("changed", callable_mp(this, &VisualShader::_queue_update));
Visual Shaders are back.
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);
Forbid recursive connections in visual shader
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);
Optimize code generation for fresnel node in visual shaders
2020-07-27 06:18:37 +00:00
g->nodes[E->get().to_node].node->set_input_port_connected(E->get().to_port, false);
Forbid recursive connections in visual shader
2020-01-20 14:46:49 +00:00
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
E = N;
}
_queue_update();
}
Add convert options between constants and uniforms in visual shaders
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;
}
Rename `instance()`->`instantiate()` when it's a verb
2021-06-17 22:03:09 +00:00
VisualShaderNode *vsn = Object::cast_to<VisualShaderNode>(ClassDB::instantiate(p_new_class));
Fix replaced visual shader nodes updating
2021-01-15 18:10:32 +00:00
vsn->connect("changed", callable_mp(this, &VisualShader::_queue_update));
Add convert options between constants and uniforms in visual shaders
2020-12-30 08:45:31 +00:00
g->nodes[p_id].node = Ref<VisualShaderNode>(vsn);
_queue_update();
}
Visual Shaders are back.
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];
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (const Connection &E : g->connections) {
if (E.from_node == p_from_node && E.from_port == p_from_port && E.to_node == p_to_node && E.to_port == p_to_port) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
return true;
}
}
return false;
}
Forbid recursive connections in visual shader
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];
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (const int &E : node.prev_connected_nodes) {
if (E == p_target) {
Forbid recursive connections in visual shader
2020-01-20 14:46:49 +00:00
return true;
}
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
result = is_nodes_connected_relatively(p_graph, E, p_target);
Forbid recursive connections in visual shader
2020-01-20 14:46:49 +00:00
if (result) {
break;
}
}
return result;
}
Visual Shaders are back.
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];
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (!g->nodes.has(p_from_node)) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (p_from_node == p_to_node) {
Disallow loopback connection in visual scripts and visual shaders
2019-04-24 05:44:48 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Disallow loopback connection in visual scripts and visual shaders
2019-04-24 05:44:48 +00:00
Implements expandable color ports in visual shaders
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()) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (!g->nodes.has(p_to_node)) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
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()) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Visual Shaders are back.
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);
Shows menu when dragging connection on empty space in visual shader graph
2019-06-26 18:50:38 +00:00
if (!is_port_types_compatible(from_port_type, to_port_type)) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
return false;
}
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (const Connection &E : g->connections) {
if (E.from_node == p_from_node && E.from_port == p_from_port && E.to_node == p_to_node && E.to_port == p_to_port) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
return false;
}
}
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (is_nodes_connected_relatively(g, p_from_node, p_to_node)) {
Forbid recursive connections in visual shader
2020-01-20 14:46:49 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Forbid recursive connections in visual shader
2020-01-20 14:46:49 +00:00
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
return true;
}
Shows menu when dragging connection on empty space in visual shader graph
2019-06-26 18:50:38 +00:00
bool VisualShader::is_port_types_compatible(int p_a, int p_b) const {
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
return MAX(0, p_a - 4) == (MAX(0, p_b - 4));
Shows menu when dragging connection on empty space in visual shader graph
2019-06-26 18:50:38 +00:00
}
Expression node for visual shaders
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];
Fix crash when calling connect_nodes_forced with invalid params
2021-02-18 21:57:41 +00:00
ERR_FAIL_COND(!g->nodes.has(p_from_node));
Implements expandable color ports in visual shaders
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());
Fix crash when calling connect_nodes_forced with invalid params
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());
Expression node for visual shaders
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);
Forbid recursive connections in visual shader
2020-01-20 14:46:49 +00:00
g->nodes[p_to_node].prev_connected_nodes.push_back(p_from_node);
Removes redundant code generation in VisualShaderNodeTextureUniform
2020-07-26 01:04:07 +00:00
g->nodes[p_from_node].node->set_output_port_connected(p_from_port, true);
Optimize code generation for fresnel node in visual shaders
2020-07-27 06:18:37 +00:00
g->nodes[p_to_node].node->set_input_port_connected(p_to_port, true);
Forbid recursive connections in visual shader
2020-01-20 14:46:49 +00:00
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
_queue_update();
}
Visual Shaders are back.
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);
Implements expandable color ports in visual shaders
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);
Visual Shaders are back.
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);
Remove ERR_EXPLAIN from scene/* code
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.");
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Use const references where possible for List range iterators
2021-07-24 13:46:25 +00:00
for (const Connection &E : g->connections) {
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
if (E.from_node == p_from_node && E.from_port == p_from_port && E.to_node == p_to_node && E.to_port == p_to_port) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
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);
Forbid recursive connections in visual shader
2020-01-20 14:46:49 +00:00
g->nodes[p_to_node].prev_connected_nodes.push_back(p_from_node);
Removes redundant code generation in VisualShaderNodeTextureUniform
2020-07-26 01:04:07 +00:00
g->nodes[p_from_node].node->set_output_port_connected(p_from_port, true);
Optimize code generation for fresnel node in visual shaders
2020-07-27 06:18:37 +00:00
g->nodes[p_to_node].node->set_input_port_connected(p_to_port, true);
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
_queue_update();
return OK;
}
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
Visual Shaders are back.
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];
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (const List<Connection>::Element *E = g->connections.front(); E; E = E->next()) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
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);
Forbid recursive connections in visual shader
2020-01-20 14:46:49 +00:00
g->nodes[p_to_node].prev_connected_nodes.erase(p_from_node);
Removes redundant code generation in VisualShaderNodeTextureUniform
2020-07-26 01:04:07 +00:00
g->nodes[p_from_node].node->set_output_port_connected(p_from_port, false);
Optimize code generation for fresnel node in visual shaders
2020-07-27 06:18:37 +00:00
g->nodes[p_to_node].node->set_input_port_connected(p_to_port, false);
Visual Shaders are back.
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;
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (const Connection &E : g->connections) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Dictionary d;
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
d["from_node"] = E.from_node;
d["from_port"] = E.from_port;
d["to_node"] = E.to_node;
d["to_port"] = E.to_port;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
ret.push_back(d);
}
return ret;
}
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
Visual Shaders are back.
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];
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (const Connection &E : g->connections) {
r_connections->push_back(E);
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
}
void VisualShader::set_mode(Mode p_mode) {
Fixes crash when calling VisualShader::set_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));
Visual Shaders are back.
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++) {
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (KeyValue<int, Node> &E : graph[i].nodes) {
Ref<VisualShaderNodeInput> input = E.value.node;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
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();
Removed _change_notify -For inspector refresh, the inspector now detects if a property change by polling a few times per second and then does update the control if so. This process is very cheap. -For property list refresh, a new signal (property_list_changed) was added to Object. _change_notify() is replaced by notify_property_list_changed() -Changed all objects using the old method to the signal, or just deleted the calls to _change_notify(<property>) since they are unnecesary now.
2021-02-10 20:18:45 +00:00
notify_property_list_changed();
Visual Shaders are back.
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;
}
Don't open VisualShaders in the text shader editor, and don't support saving them with the "shader" extension.
2018-09-15 01:54:59 +00:00
bool VisualShader::is_text_shader() const {
return false;
}
Visual Shaders are back.
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());
Implements expandable color ports in visual shaders
2020-12-20 15:45:53 +00:00
ERR_FAIL_COND_V(p_port < 0 || p_port >= node->get_expanded_output_port_count(), String());
Visual Shaders are back.
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;
Added triplanar uniform texture node to visual shaders
2019-07-12 09:14:34 +00:00
StringBuilder global_code_per_node;
Map<Type, StringBuilder> global_code_per_func;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
StringBuilder code;
Added triplanar uniform texture node to visual shaders
2019-07-12 09:14:34 +00:00
Set<StringName> classes;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
global_code += String() + "shader_type canvas_item;\n";
Fix preview for global expressions in visual shaders
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);
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
expr = expr.replace("\n", "\n ");
Fix preview for global expressions in visual shaders
2019-08-20 16:34:09 +00:00
expr += "\n";
global_expressions += expr;
}
}
}
global_code += "\n";
global_code += global_expressions;
Visual Shaders are back.
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 += "\nvoid fragment() {\n";
Set<int> processed;
Added triplanar uniform texture node to visual shaders
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);
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
ERR_FAIL_COND_V(err != OK, String());
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
switch (node->get_output_port_type(p_port)) {
case VisualShaderNode::PORT_TYPE_SCALAR: {
code += " COLOR.rgb = vec3(n_out" + itos(p_node) + "p" + itos(p_port) + ");\n";
} break;
case VisualShaderNode::PORT_TYPE_SCALAR_INT: {
code += " COLOR.rgb = vec3(float(n_out" + itos(p_node) + "p" + itos(p_port) + "));\n";
} break;
case VisualShaderNode::PORT_TYPE_BOOLEAN: {
code += " COLOR.rgb = vec3(n_out" + itos(p_node) + "p" + itos(p_port) + " ? 1.0 : 0.0);\n";
} break;
case VisualShaderNode::PORT_TYPE_VECTOR_2D: {
code += " COLOR.rgb = vec3(n_out" + itos(p_node) + "p" + itos(p_port) + ", 0.0);\n";
} break;
case VisualShaderNode::PORT_TYPE_VECTOR: {
code += " COLOR.rgb = n_out" + itos(p_node) + "p" + itos(p_port) + ";\n";
} break;
default: {
code += " COLOR.rgb = vec3(0.0);\n";
} break;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
code += "}\n";
//set code secretly
global_code += "\n\n";
String final_code = global_code;
Added triplanar uniform texture node to visual shaders
2019-07-12 09:14:34 +00:00
final_code += global_code_per_node;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
final_code += code;
return final_code;
}
Fixed some errors when changing port name in visual shader expressions
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;
Replace String comparisons with "", String() to is_empty() Also: - Adds two stress tests to test_string.h - Changes to .empty() on std::strings
2021-12-09 09:42:46 +00:00
if (name.is_empty()) {
Fixed some errors when changing port name in visual shader expressions
2020-12-02 09:49:46 +00:00
return String();
}
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
Cleanup and move char functions to the `char_utils.h` header.
2022-02-04 08:32:20 +00:00
while (name.length() && !is_ascii_char(name[0])) {
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
name = name.substr(1, name.length() - 1);
}
Replace String comparisons with "", String() to is_empty() Also: - Adds two stress tests to test_string.h - Changes to .empty() on std::strings
2021-12-09 09:42:46 +00:00
if (!name.is_empty()) {
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
String valid_name;
for (int i = 0; i < name.length(); i++) {
Cleanup and move char functions to the `char_utils.h` header.
2022-02-04 08:32:20 +00:00
if (is_ascii_identifier_char(name[i])) {
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
valid_name += String::chr(name[i]);
} else if (name[i] == ' ') {
valid_name += "_";
}
}
name = valid_name;
Fixed some errors when changing port name in visual shader expressions
2020-12-02 09:49:46 +00:00
} else {
return String();
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
}
Fixed some errors when changing port name in visual shader expressions
2020-12-02 09:49:46 +00:00
List<String> input_names;
List<String> output_names;
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
Fixed some errors when changing port name in visual shader expressions
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;
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
}
Fixed some errors when changing port name in visual shader expressions
2020-12-02 09:49:46 +00:00
if (name == p_node->get_input_port_name(i)) {
return String();
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
}
}
Fixed some errors when changing port name in visual shader expressions
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();
}
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
}
return name;
}
Visual Shaders are back.
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
Cleanup and move char functions to the `char_utils.h` header.
2022-02-04 08:32:20 +00:00
while (name.length() && !is_ascii_char(name[0])) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
name = name.substr(1, name.length() - 1);
}
Replace String comparisons with "", String() to is_empty() Also: - Adds two stress tests to test_string.h - Changes to .empty() on std::strings
2021-12-09 09:42:46 +00:00
if (!name.is_empty()) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
String valid_name;
for (int i = 0; i < name.length(); i++) {
Cleanup and move char functions to the `char_utils.h` header.
2022-02-04 08:32:20 +00:00
if (is_ascii_identifier_char(name[i])) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
valid_name += String::chr(name[i]);
} else if (name[i] == ' ') {
valid_name += "_";
}
}
name = valid_name;
}
Replace String comparisons with "", String() to is_empty() Also: - Adds two stress tests to test_string.h - Changes to .empty() on std::strings
2021-12-09 09:42:46 +00:00
if (name.is_empty()) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
name = p_uniform->get_caption();
}
int attempt = 1;
while (true) {
bool exists = false;
for (int i = 0; i < TYPE_MAX; i++) {
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<int, Node> &E : graph[i].nodes) {
Ref<VisualShaderNodeUniform> node = E.value.node;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
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++;
Cleanup and move char functions to the `char_utils.h` header.
2022-02-04 08:32:20 +00:00
while (name.length() && is_digit(name[name.length() - 1])) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
name = name.substr(0, name.length() - 1);
}
Replace String comparisons with "", String() to is_empty() Also: - Adds two stress tests to test_string.h - Changes to .empty() on std::strings
2021-12-09 09:42:46 +00:00
ERR_FAIL_COND_V(name.is_empty(), String());
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
name += itos(attempt);
} else {
break;
}
}
return name;
}
static const char *type_string[VisualShader::TYPE_MAX] = {
"vertex",
"fragment",
Restore Particles functionality in visual shader
2020-09-02 20:25:54 +00:00
"light",
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
"start",
Remakes particles in visual shaders
2020-09-07 07:28:13 +00:00
"process",
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
"collide",
"start_custom",
"process_custom",
Fix `sky` visual shader mode after last rename
2021-04-17 17:16:03 +00:00
"sky",
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
"fog",
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
};
Remakes particles in visual shaders
2020-09-07 07:28:13 +00:00
Visual Shaders are back.
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) {
Fix typos with codespell Using codespell 1.14.0. Method: ``` $ cat > ../godot-word-whitelist.txt << EOF ang doubleclick lod nd numer que te unselect EOF $ codespell -w -q 3 -I ../godot-word-whitelist.txt --skip="./thirdparty,*.po" $ git diff // undo unwanted changes ```
2019-02-13 08:23:29 +00:00
modes.erase(mode); //means it's default anyway, so don't store it
Visual Shaders are back.
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) {
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
connect_nodes_forced(type, conns[i + 0], conns[i + 1], conns[i + 2], conns[i + 3]);
Visual Shaders are back.
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;
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
} else if (what == "size") {
Added VisualShaderNodeCurve to easy gather data from a CurveTexture
2020-10-04 09:11:58 +00:00
((VisualShaderNodeResizableBase *)get_node(type, id).ptr())->set_size(p_value);
Expression node for visual shaders
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;
Visual Shaders are back.
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;
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (const Connection &E : graph[type].connections) {
conns.push_back(E.from_node);
conns.push_back(E.from_port);
conns.push_back(E.to_node);
conns.push_back(E.to_port);
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
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;
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
} else if (what == "size") {
Added VisualShaderNodeCurve to easy gather data from a CurveTexture
2020-10-04 09:11:58 +00:00
r_ret = ((VisualShaderNodeResizableBase *)get_node(type, id).ptr())->get_size();
Expression node for visual shaders
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;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
}
return false;
}
Improve resource load cache -Added a new method in Resource: reset_state , used for reloading the same resource from disk -Added a new cache mode "replace" in ResourceLoader, which reuses existing loaded sub-resources but resets their data from disk (or replaces them if they chaged type) -Because the correct sub-resource paths are always loaded now, this fixes bugs with subresource folding or subresource ordering when saving.
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();
}
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
void VisualShader::_get_property_list(List<PropertyInfo> *p_list) const {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
//mode
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
p_list->push_back(PropertyInfo(Variant::INT, "mode", PROPERTY_HINT_ENUM, "Node3D,CanvasItem,Particles,Sky,Fog"));
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
//render modes
Map<String, String> blend_mode_enums;
Set<String> toggles;
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 14:21:55 +00:00
const Vector<ShaderLanguage::ModeInfo> &rmodes = ShaderTypes::get_singleton()->get_modes(RenderingServer::ShaderMode(shader_mode));
for (int i = 0; i < rmodes.size(); i++) {
const ShaderLanguage::ModeInfo &info = rmodes[i];
if (!info.options.is_empty()) {
const String begin = String(info.name);
for (int j = 0; j < info.options.size(); j++) {
const String option = String(info.options[j]);
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
if (!blend_mode_enums.has(begin)) {
blend_mode_enums[begin] = option;
} else {
blend_mode_enums[begin] += "," + option;
}
}
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 14:21:55 +00:00
} else {
toggles.insert(String(info.name));
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
}
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<String, String> &E : blend_mode_enums) {
p_list->push_back(PropertyInfo(Variant::INT, "modes/" + E.key, PROPERTY_HINT_ENUM, E.value));
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
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++) {
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<int, Node> &E : graph[i].nodes) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
String prop_name = "nodes/";
prop_name += type_string[i];
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
prop_name += "/" + itos(E.key);
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
if (E.key != NODE_ID_OUTPUT) {
Rename `PROPERTY_USAGE_NOEDITOR` to `PROPERTY_USAGE_NO_EDITOR` This is consistent with other constants that include `NO`, such as `PROPERTY_HINT_COLOR_NO_ALPHA`.
2021-11-03 22:06:17 +00:00
p_list->push_back(PropertyInfo(Variant::OBJECT, prop_name + "/node", PROPERTY_HINT_RESOURCE_TYPE, "VisualShaderNode", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE));
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
Rename `PROPERTY_USAGE_NOEDITOR` to `PROPERTY_USAGE_NO_EDITOR` This is consistent with other constants that include `NO`, such as `PROPERTY_HINT_COLOR_NO_ALPHA`.
2021-11-03 22:06:17 +00:00
p_list->push_back(PropertyInfo(Variant::VECTOR2, prop_name + "/position", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR));
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
if (Object::cast_to<VisualShaderNodeGroupBase>(E.value.node.ptr()) != nullptr) {
Rename `PROPERTY_USAGE_NOEDITOR` to `PROPERTY_USAGE_NO_EDITOR` This is consistent with other constants that include `NO`, such as `PROPERTY_HINT_COLOR_NO_ALPHA`.
2021-11-03 22:06:17 +00:00
p_list->push_back(PropertyInfo(Variant::VECTOR2, prop_name + "/size", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR));
p_list->push_back(PropertyInfo(Variant::STRING, prop_name + "/input_ports", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR));
p_list->push_back(PropertyInfo(Variant::STRING, prop_name + "/output_ports", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR));
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
}
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
if (Object::cast_to<VisualShaderNodeExpression>(E.value.node.ptr()) != nullptr) {
Rename `PROPERTY_USAGE_NOEDITOR` to `PROPERTY_USAGE_NO_EDITOR` This is consistent with other constants that include `NO`, such as `PROPERTY_HINT_COLOR_NO_ALPHA`.
2021-11-03 22:06:17 +00:00
p_list->push_back(PropertyInfo(Variant::STRING, prop_name + "/expression", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR));
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
Rename `PROPERTY_USAGE_NOEDITOR` to `PROPERTY_USAGE_NO_EDITOR` This is consistent with other constants that include `NO`, such as `PROPERTY_HINT_COLOR_NO_ALPHA`.
2021-11-03 22:06:17 +00:00
p_list->push_back(PropertyInfo(Variant::PACKED_INT32_ARRAY, "nodes/" + String(type_string[i]) + "/connections", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR));
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
}
Added triplanar uniform texture node to visual shaders
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 {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
const Ref<VisualShaderNode> vsnode = graph[type].nodes[node].node;
Added Billboard Node to Visual Shaders
2021-05-27 19:17:58 +00:00
if (vsnode->is_disabled()) {
code += "// " + vsnode->get_caption() + ":" + itos(node) + "\n";
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " // Node is disabled and code is not generated.\n";
Added Billboard Node to Visual Shaders
2021-05-27 19:17:58 +00:00
return OK;
}
Visual Shaders are back.
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;
}
Added triplanar uniform texture node to visual shaders
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);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (err) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
return err;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
}
// then this node
Removes redundant code generation in VisualShaderNodeTextureUniform
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) {
Added UniformRef visual shader node
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);
}
Removes redundant code generation in VisualShaderNodeTextureUniform
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;
}
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
String node_name = "// " + vsnode->get_caption() + ":" + itos(node) + "\n";
String node_code;
Visual Shaders are back.
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;
Added Billboard Node to Visual Shaders
2021-05-27 19:17:58 +00:00
if (graph[type].nodes[from_node].node->is_disabled()) {
continue;
}
Visual Shaders are back.
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);
Added sampler port type for visual shaders
2019-10-01 08:51:50 +00:00
if (in_type == VisualShaderNode::PORT_TYPE_SAMPLER && out_type == VisualShaderNode::PORT_TYPE_SAMPLER) {
Fix invalid casting on visual shader 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");
Added sampler port type for visual shaders
2019-10-01 08:51:50 +00:00
} else {
Fix invalid casting on visual shader sampler
2019-11-04 15:50:33 +00:00
inputs[i] = "";
Added sampler port type for visual shaders
2019-10-01 08:51:50 +00:00
}
} else if (in_type == out_type) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
inputs[i] = src_var;
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
} else {
switch (in_type) {
case VisualShaderNode::PORT_TYPE_SCALAR: {
switch (out_type) {
case VisualShaderNode::PORT_TYPE_SCALAR_INT: {
inputs[i] = "float(" + src_var + ")";
} break;
case VisualShaderNode::PORT_TYPE_BOOLEAN: {
inputs[i] = "(" + src_var + " ? 1.0 : 0.0)";
} break;
case VisualShaderNode::PORT_TYPE_VECTOR_2D: {
inputs[i] = "dot(" + src_var + ", vec2(0.333333, 0.333333))";
} break;
case VisualShaderNode::PORT_TYPE_VECTOR: {
inputs[i] = "dot(" + src_var + ", vec3(0.333333, 0.333333, 0.333333))";
} break;
default:
break;
}
} break;
case VisualShaderNode::PORT_TYPE_SCALAR_INT: {
switch (out_type) {
case VisualShaderNode::PORT_TYPE_SCALAR: {
inputs[i] = "int(" + src_var + ")";
} break;
case VisualShaderNode::PORT_TYPE_BOOLEAN: {
inputs[i] = "(" + src_var + " ? 1 : 0)";
} break;
case VisualShaderNode::PORT_TYPE_VECTOR_2D: {
inputs[i] = "dot(float(" + src_var + "), vec2(0.333333, 0.333333))";
} break;
case VisualShaderNode::PORT_TYPE_VECTOR: {
inputs[i] = "dot(float(" + src_var + "), vec3(0.333333, 0.333333, 0.333333))";
} break;
default:
break;
}
} break;
case VisualShaderNode::PORT_TYPE_BOOLEAN: {
switch (out_type) {
case VisualShaderNode::PORT_TYPE_SCALAR: {
inputs[i] = src_var + " > 0.0 ? true : false";
} break;
case VisualShaderNode::PORT_TYPE_SCALAR_INT: {
inputs[i] = src_var + " > 0 ? true : false";
} break;
case VisualShaderNode::PORT_TYPE_VECTOR_2D: {
inputs[i] = "all(bvec2(" + src_var + "))";
} break;
case VisualShaderNode::PORT_TYPE_VECTOR: {
inputs[i] = "all(bvec3(" + src_var + "))";
} break;
default:
break;
}
} break;
case VisualShaderNode::PORT_TYPE_VECTOR_2D: {
switch (out_type) {
case VisualShaderNode::PORT_TYPE_SCALAR: {
inputs[i] = "vec2(" + src_var + ")";
} break;
case VisualShaderNode::PORT_TYPE_SCALAR_INT: {
inputs[i] = "vec2(float(" + src_var + "))";
} break;
case VisualShaderNode::PORT_TYPE_BOOLEAN: {
inputs[i] = "vec2(" + src_var + " ? 1.0 : 0.0)";
} break;
case VisualShaderNode::PORT_TYPE_VECTOR: {
inputs[i] = "vec2(" + src_var + ".xy)";
} break;
default:
break;
}
} break;
case VisualShaderNode::PORT_TYPE_VECTOR: {
switch (out_type) {
case VisualShaderNode::PORT_TYPE_SCALAR: {
inputs[i] = "vec3(" + src_var + ")";
} break;
case VisualShaderNode::PORT_TYPE_SCALAR_INT: {
inputs[i] = "vec3(float(" + src_var + "))";
} break;
case VisualShaderNode::PORT_TYPE_BOOLEAN: {
inputs[i] = "vec3(" + src_var + " ? 1.0 : 0.0)";
} break;
case VisualShaderNode::PORT_TYPE_VECTOR_2D: {
inputs[i] = "vec3(" + src_var + ", 0.0)";
} break;
default:
break;
}
} break;
default:
break;
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
} else {
Optimize code generation for fresnel node in visual shaders
2020-07-27 06:18:37 +00:00
if (!vsnode->is_generate_input_var(i)) {
continue;
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Variant defval = vsnode->get_input_port_default_value(i);
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
if (defval.get_type() == Variant::FLOAT) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
float val = defval;
inputs[i] = "n_in" + itos(node) + "p" + itos(i);
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
node_code += " float " + inputs[i] + " = " + vformat("%.5f", val) + ";\n";
Add support for integer type in visual shaders
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);
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
node_code += " int " + inputs[i] + " = " + itos(val) + ";\n";
Major improvements for visual shader system
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);
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
node_code += " bool " + inputs[i] + " = " + (val ? "true" : "false") + ";\n";
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
} else if (defval.get_type() == Variant::VECTOR2) {
Vector2 val = defval;
inputs[i] = "n_in" + itos(node) + "p" + itos(i);
node_code += " vec2 " + inputs[i] + " = " + vformat("vec2(%.5f, %.5f);\n", val.x, val.y);
Visual Shaders are back.
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);
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
node_code += " vec3 " + inputs[i] + " = " + vformat("vec3(%.5f, %.5f, %.5f);\n", val.x, val.y, val.z);
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 07:36:08 +00:00
} else if (defval.get_type() == Variant::TRANSFORM3D) {
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00:00
Transform3D val = defval;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
val.basis.transpose();
inputs[i] = "n_in" + itos(node) + "p" + itos(i);
Array values;
Fix various warnings: [-Waddress], [-Wpointer-arith], [-Wwrite-strings], [-Wreturn-local-addr] and more Fixes the following GCC 5 warnings: ``` core/os/file_access.cpp:49:19: warning: the address of 'FileAccess::create_func' will always evaluate as 'true' [-Waddress] servers/audio_server.cpp:192:70: warning: comparison with string literal results in unspecified behaviour [-Waddress] drivers/gles2/rasterizer_storage_gles2.cpp:4095:90: warning: NULL used in arithmetic [-Wpointer-arith] modules/gdnative/register_types.cpp:237:3: warning: deprecated conversion from string constant to 'char*' [-Wwrite-strings] platform/android/export/export.cpp:207:1: warning: deprecated conversion from string constant to 'char*' [-Wwrite-strings] modules/gdscript/gdscript.h:150:67: warning: returning reference to temporary [-Wreturn-local-addr] servers/physics_2d/collision_object_2d_sw.h:119:56: warning: returning reference to temporary [-Wreturn-local-addr] servers/physics_2d/collision_object_2d_sw.h:123:56: warning: returning reference to temporary [-Wreturn-local-addr] servers/physics_2d/collision_object_2d_sw.h:127:50: warning: returning reference to temporary [-Wreturn-local-addr] servers/physics_2d/collision_object_2d_sw.h:131:52: warning: returning reference to temporary [-Wreturn-local-addr] editor/plugins/skeleton_editor_plugin.cpp:34:36: warning: extra tokens at end of #include directive modules/bullet/bullet_types_converter.cpp:31:9: warning: #pragma once in main file editor/import/editor_scene_importer_gltf.cpp:1996:51: warning: name lookup of 'i' changed modules/visual_script/visual_script_property_selector.cpp:402:45: warning: name lookup of 'E' changed scene/gui/tree.cpp:1268:25: warning: name lookup of 'i' changed scene/resources/visual_shader.cpp:808:32: warning: name lookup of 'i' changed ```
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);
Visual Shaders are back.
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;
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
node_code += " 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);
Visual Shaders are back.
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();
Implements expandable color ports in visual shaders
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;
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
switch (vsnode->get_output_port_type(i)) {
case VisualShaderNode::PORT_TYPE_VECTOR_2D: {
output_count += 2;
} break;
case VisualShaderNode::PORT_TYPE_VECTOR: {
output_count += 3;
} break;
default:
break;
Implements expandable color ports in visual shaders
2020-12-20 15:45:53 +00:00
}
}
expanded_output_ports.insert(i, expanded);
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Vector<String> output_vars;
Implements expandable color ports in visual shaders
2020-12-20 15:45:53 +00:00
output_vars.resize(output_count);
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
String *outputs = output_vars.ptrw();
Better visual shader code generation
2020-01-27 09:10:51 +00:00
if (vsnode->is_simple_decl()) { // less code to generate for some simple_decl nodes
Implements expandable color ports in visual shaders
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);
Better visual shader code generation
2020-01-27 09:10:51 +00:00
switch (vsnode->get_output_port_type(i)) {
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
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;
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
case VisualShaderNode::PORT_TYPE_VECTOR_2D:
outputs[i] = "vec2 " + var_name;
break;
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 11:00:47 +00:00
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;
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
default:
break;
Better visual shader code generation
2020-01-27 09:10:51 +00:00
}
Implements expandable color ports in visual shaders
2020-12-20 15:45:53 +00:00
if (expanded_output_ports[i]) {
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
switch (vsnode->get_output_port_type(i)) {
case VisualShaderNode::PORT_TYPE_VECTOR_2D: {
j += 2;
} break;
case VisualShaderNode::PORT_TYPE_VECTOR: {
j += 3;
} break;
default:
break;
Implements expandable color ports in visual shaders
2020-12-20 15:45:53 +00:00
}
}
Better visual shader code generation
2020-01-27 09:10:51 +00:00
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Better visual shader code generation
2020-01-27 09:10:51 +00:00
} else {
Implements expandable color ports in visual shaders
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);
Better visual shader code generation
2020-01-27 09:10:51 +00:00
switch (vsnode->get_output_port_type(i)) {
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 11:00:47 +00:00
case VisualShaderNode::PORT_TYPE_SCALAR:
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " float " + outputs[i] + ";\n";
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 11:00:47 +00:00
break;
case VisualShaderNode::PORT_TYPE_SCALAR_INT:
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " int " + outputs[i] + ";\n";
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 11:00:47 +00:00
break;
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
case VisualShaderNode::PORT_TYPE_VECTOR_2D:
code += " vec2 " + outputs[i] + ";\n";
break;
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 11:00:47 +00:00
case VisualShaderNode::PORT_TYPE_VECTOR:
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " vec3 " + outputs[i] + ";\n";
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 11:00:47 +00:00
break;
case VisualShaderNode::PORT_TYPE_BOOLEAN:
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " bool " + outputs[i] + ";\n";
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 11:00:47 +00:00
break;
case VisualShaderNode::PORT_TYPE_TRANSFORM:
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " mat4 " + outputs[i] + ";\n";
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 11:00:47 +00:00
break;
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
default:
break;
Style: Apply new changes from clang-format 8.0 It seems to stay compatible with formatting done by clang-format 6.0 and 7.0, so contributors can keep using those versions for now (they will not undo those changes).
2019-04-09 15:08:36 +00:00
}
Implements expandable color ports in visual shaders
2020-12-20 15:45:53 +00:00
if (expanded_output_ports[i]) {
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
switch (vsnode->get_output_port_type(i)) {
case VisualShaderNode::PORT_TYPE_VECTOR_2D: {
j += 2;
} break;
case VisualShaderNode::PORT_TYPE_VECTOR: {
j += 3;
} break;
default:
break;
Implements expandable color ports in visual shaders
2020-12-20 15:45:53 +00:00
}
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
}
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
node_code += vsnode->generate_code(get_mode(), type, node, inputs, outputs, for_preview);
Replace String comparisons with "", String() to is_empty() Also: - Adds two stress tests to test_string.h - Changes to .empty() on std::strings
2021-12-09 09:42:46 +00:00
if (!node_code.is_empty()) {
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
code += node_name;
code += node_code;
code += "\n";
}
Modified code generation to be more friendly to previews, fixes #25094
2019-01-21 19:07:53 +00:00
Implements expandable color ports in visual shaders
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]) {
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
switch (vsnode->get_output_port_type(i)) {
case VisualShaderNode::PORT_TYPE_VECTOR_2D: {
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 += " float " + r + " = n_out" + itos(node) + "p" + itos(i) + ".r;\n";
outputs[i + 1] = r;
Implements expandable color ports in visual shaders
2020-12-20 15:45:53 +00:00
}
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
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 += " float " + g + " = n_out" + itos(node) + "p" + itos(i) + ".g;\n";
outputs[i + 2] = g;
}
i += 2;
} break;
case 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 += " float " + r + " = n_out" + itos(node) + "p" + itos(i) + ".r;\n";
outputs[i + 1] = r;
Implements expandable color ports in visual shaders
2020-12-20 15:45:53 +00:00
}
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
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 += " float " + g + " = n_out" + itos(node) + "p" + itos(i) + ".g;\n";
outputs[i + 2] = g;
Implements expandable color ports in visual shaders
2020-12-20 15:45:53 +00:00
}
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
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 += " float " + b + " = n_out" + itos(node) + "p" + itos(i) + ".b;\n";
outputs[i + 3] = b;
}
i += 3;
} break;
default:
break;
Implements expandable color ports in visual shaders
2020-12-20 15:45:53 +00:00
}
}
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
code += "\n"; //
processed.insert(node);
return OK;
}
Remakes particles in visual shaders
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) {
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
if (p_func_name == "start_custom" || p_func_name == "process_custom" || p_func_name == "collide") {
Remakes particles in visual shaders
2020-09-07 07:28:13 +00:00
return true;
}
}
return false;
}
return true;
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
void VisualShader::_update_shader() const {
Modernize atomics - Based on C++11's `atomic` - Reworked `SafeRefCount` (based on the rewrite by @hpvb) - Replaced free atomic functions by the new `SafeNumeric<T>` - Replaced wrong cases of `volatile bool` by the new `SafeFlag` - Platform-specific implementations no longer needed Co-authored-by: Hein-Pieter van Braam-Stewart <hp@tmm.cx>
2021-02-10 18:22:13 +00:00
if (!dirty.is_set()) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Modernize atomics - Based on C++11's `atomic` - Reworked `SafeRefCount` (based on the rewrite by @hpvb) - Replaced free atomic functions by the new `SafeNumeric<T>` - Replaced wrong cases of `volatile bool` by the new `SafeFlag` - Platform-specific implementations no longer needed Co-authored-by: Hein-Pieter van Braam-Stewart <hp@tmm.cx>
2021-02-10 18:22:13 +00:00
dirty.clear();
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
StringBuilder global_code;
Added triplanar uniform texture node to visual shaders
2019-07-12 09:14:34 +00:00
StringBuilder global_code_per_node;
Map<Type, StringBuilder> global_code_per_func;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
StringBuilder code;
Vector<VisualShader::DefaultTextureParam> default_tex_params;
Added triplanar uniform texture node to visual shaders
2019-07-12 09:14:34 +00:00
Set<StringName> classes;
Added sky shader mode to visual shaders
2020-03-25 09:22:29 +00:00
Map<int, int> insertion_pos;
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
static const char *shader_mode_str[Shader::MODE_MAX] = { "spatial", "canvas_item", "particles", "sky", "fog" };
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
global_code += String() + "shader_type " + shader_mode_str[shader_mode] + ";\n";
String render_mode;
{
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 14:21:55 +00:00
const Vector<ShaderLanguage::ModeInfo> &rmodes = ShaderTypes::get_singleton()->get_modes(RenderingServer::ShaderMode(shader_mode));
Vector<String> flag_names;
// Add enum modes first.
for (int i = 0; i < rmodes.size(); i++) {
const ShaderLanguage::ModeInfo &info = rmodes[i];
const String temp = String(info.name);
if (!info.options.is_empty()) {
if (modes.has(temp) && modes[temp] < info.options.size()) {
if (!render_mode.is_empty()) {
render_mode += ", ";
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 14:21:55 +00:00
render_mode += temp + "_" + info.options[modes[temp]];
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 14:21:55 +00:00
} else if (flags.has(temp)) {
flag_names.push_back(temp);
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
}
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 14:21:55 +00:00
// Add flags afterward.
for (int i = 0; i < flag_names.size(); i++) {
if (!render_mode.is_empty()) {
render_mode += ", ";
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 14:21:55 +00:00
render_mode += flag_names[i];
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
}
Replace String comparisons with "", String() to is_empty() Also: - Adds two stress tests to test_string.h - Changes to .empty() on std::strings
2021-12-09 09:42:46 +00:00
if (!render_mode.is_empty()) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
global_code += "render_mode " + render_mode + ";\n\n";
}
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
static const char *func_name[TYPE_MAX] = { "vertex", "fragment", "light", "start", "process", "collide", "start_custom", "process_custom", "sky", "fog" };
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Added global expressions to visual shaders
2019-08-18 05:09:05 +00:00
String global_expressions;
Added UniformRef visual shader node
2020-07-28 08:02:57 +00:00
Set<String> used_uniform_names;
List<VisualShaderNodeUniform *> uniforms;
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
Map<int, List<int>> emitters;
Added UniformRef visual shader node
2020-07-28 08:02:57 +00:00
Added global expressions to visual shaders
2019-08-18 05:09:05 +00:00
for (int i = 0, index = 0; i < TYPE_MAX; i++) {
Remakes particles in visual shaders
2020-09-07 07:28:13 +00:00
if (!has_func_name(RenderingServer::ShaderMode(shader_mode), func_name[i])) {
Added sky shader mode to visual shaders
2020-03-25 09:22:29 +00:00
continue;
}
Added global expressions to visual shaders
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);
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
expr = expr.replace("\n", "\n ");
Added global expressions to visual shaders
2019-08-18 05:09:05 +00:00
expr += "\n";
global_expressions += expr;
}
Added UniformRef visual shader node
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());
}
Continuation of work on visual particles system
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>());
}
Use range iterators for `Map`
2021-08-09 20:13:42 +00:00
for (const KeyValue<int, Node> &M : graph[i].nodes) {
if (M.value.node == emit_particle.ptr()) {
emitters[i].push_back(M.key);
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
break;
}
}
}
Added UniformRef visual shader node
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);
Added global expressions to visual shaders
2019-08-18 05:09:05 +00:00
}
}
Remakes particles in visual shaders
2020-09-07 07:28:13 +00:00
Map<int, String> code_map;
Fix function code generation for uniform triplanar node in visual shader
2021-07-21 09:57:11 +00:00
Set<int> empty_funcs;
Remakes particles in visual shaders
2020-09-07 07:28:13 +00:00
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
for (int i = 0; i < TYPE_MAX; i++) {
Remakes particles in visual shaders
2020-09-07 07:28:13 +00:00
if (!has_func_name(RenderingServer::ShaderMode(shader_mode), func_name[i])) {
Added sky shader mode to visual shaders
2020-03-25 09:22:29 +00:00
continue;
}
Visual Shaders are back.
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;
Remakes particles in visual shaders
2020-09-07 07:28:13 +00:00
StringBuilder func_code;
Prevent function gen in visual shader if no out connection is provided
2021-07-17 19:33:19 +00:00
bool is_empty_func = false;
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
if (shader_mode != Shader::MODE_PARTICLES && shader_mode != Shader::MODE_SKY && shader_mode != Shader::MODE_FOG) {
Prevent function gen in visual shader if no out connection is provided
2021-07-17 19:33:19 +00:00
is_empty_func = true;
}
Visual Shaders are back.
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);
Prevent function gen in visual shader if no out connection is provided
2021-07-17 19:33:19 +00:00
if (is_empty_func && to_key.node == NODE_ID_OUTPUT) {
is_empty_func = false;
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
Prevent function gen in visual shader if no out connection is provided
2021-07-17 19:33:19 +00:00
if (is_empty_func) {
Fix function code generation for uniform triplanar node in visual shader
2021-07-21 09:57:11 +00:00
empty_funcs.insert(i);
Prevent function gen in visual shader if no out connection is provided
2021-07-17 19:33:19 +00:00
continue;
}
Remakes particles in visual shaders
2020-09-07 07:28:13 +00:00
if (shader_mode != Shader::MODE_PARTICLES) {
func_code += "\nvoid " + String(func_name[i]) + "() {\n";
}
Fix triplanar texture code generation in visual shaders
2020-09-11 15:06:22 +00:00
insertion_pos.insert(i, code.get_string_length() + func_code.get_string_length());
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Set<int> processed;
Remakes particles in visual shaders
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);
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
ERR_FAIL_COND(err != OK);
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
if (emitters.has(i)) {
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (int &E : emitters[i]) {
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, processed, false, classes);
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
ERR_FAIL_COND(err != OK);
}
}
Remakes particles in visual shaders
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;
}
}
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
String global_compute_code;
Remakes particles in visual shaders
2020-09-07 07:28:13 +00:00
if (shader_mode == Shader::MODE_PARTICLES) {
Continuation of work on visual particles system
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) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " uint __seed = __hash(NUMBER + uint(1) + RANDOM_SEED);\n";
code += " vec3 __diff = TRANSFORM[3].xyz - EMISSION_TRANSFORM[3].xyz;\n";
code += " float __radians;\n";
code += " vec3 __vec3_buff1;\n";
code += " vec3 __vec3_buff2;\n";
code += " float __scalar_buff1;\n";
code += " float __scalar_buff2;\n";
Added `MeshEmitter` node for particles in visual shader
2021-11-05 19:57:24 +00:00
code += " int __scalar_ibuff;\n";
Enchance `VisualShaderNodeMeshEmitter`, add more ports and fix bugs
2021-11-18 10:30:51 +00:00
code += " vec4 __vec4_buff;\n";
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " vec3 __ndiff = normalize(__diff);\n\n";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
}
if (has_start) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " {\n";
code += code_map[TYPE_START].replace("\n ", "\n ");
code += " }\n";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
if (has_start_custom) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " \n";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
}
}
if (has_start_custom) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " {\n";
code += code_map[TYPE_START_CUSTOM].replace("\n ", "\n ");
code += " }\n";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
}
code += "}\n\n";
code += "void process() {\n";
if (has_process || has_process_custom || has_collide) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " uint __seed = __hash(NUMBER + uint(1) + RANDOM_SEED);\n";
code += " vec3 __vec3_buff1;\n";
code += " vec3 __diff = TRANSFORM[3].xyz - EMISSION_TRANSFORM[3].xyz;\n";
code += " vec3 __ndiff = normalize(__diff);\n\n";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
}
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " {\n";
String tab = " ";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
if (has_collide) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " if (COLLIDED) {\n\n";
code += code_map[TYPE_COLLIDE].replace("\n ", "\n ");
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
if (has_process) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " } else {\n\n";
tab += " ";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
}
}
if (has_process) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += code_map[TYPE_PROCESS].replace("\n ", "\n " + tab);
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
}
if (has_collide) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " }\n";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
}
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " }\n";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
if (has_process_custom) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " {\n\n";
code += code_map[TYPE_PROCESS_CUSTOM].replace("\n ", "\n ");
code += " }\n";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
}
code += "}\n\n";
global_compute_code += "float __rand_from_seed(inout uint seed) {\n";
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
global_compute_code += " int k;\n";
global_compute_code += " int s = int(seed);\n";
global_compute_code += " if (s == 0)\n";
global_compute_code += " s = 305420679;\n";
global_compute_code += " k = s / 127773;\n";
global_compute_code += " s = 16807 * (s - k * 127773) - 2836 * k;\n";
global_compute_code += " if (s < 0)\n";
global_compute_code += " s += 2147483647;\n";
global_compute_code += " seed = uint(s);\n";
global_compute_code += " return float(seed % uint(65536)) / 65535.0;\n";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
global_compute_code += "}\n\n";
global_compute_code += "float __rand_from_seed_m1_p1(inout uint seed) {\n";
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
global_compute_code += " return __rand_from_seed(seed) * 2.0 - 1.0;\n";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
global_compute_code += "}\n\n";
global_compute_code += "float __randf_range(inout uint seed, float from, float to) {\n";
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
global_compute_code += " return __rand_from_seed(seed) * (to - from) + from;\n";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
global_compute_code += "}\n\n";
global_compute_code += "vec3 __randv_range(inout uint seed, vec3 from, vec3 to) {\n";
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
global_compute_code += " return vec3(__randf_range(seed, from.x, to.x), __randf_range(seed, from.y, to.y), __randf_range(seed, from.z, to.z));\n";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
global_compute_code += "}\n\n";
global_compute_code += "uint __hash(uint x) {\n";
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
global_compute_code += " x = ((x >> uint(16)) ^ x) * uint(73244475);\n";
global_compute_code += " x = ((x >> uint(16)) ^ x) * uint(73244475);\n";
global_compute_code += " x = (x >> uint(16)) ^ x;\n";
global_compute_code += " return x;\n";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
global_compute_code += "}\n\n";
global_compute_code += "mat3 __build_rotation_mat3(vec3 axis, float angle) {\n";
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
global_compute_code += " axis = normalize(axis);\n";
global_compute_code += " float s = sin(angle);\n";
global_compute_code += " float c = cos(angle);\n";
global_compute_code += " float oc = 1.0 - c;\n";
global_compute_code += " 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";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
global_compute_code += "}\n\n";
global_compute_code += "mat4 __build_rotation_mat4(vec3 axis, float angle) {\n";
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
global_compute_code += " axis = normalize(axis);\n";
global_compute_code += " float s = sin(angle);\n";
global_compute_code += " float c = cos(angle);\n";
global_compute_code += " float oc = 1.0 - c;\n";
global_compute_code += " 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";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
global_compute_code += "}\n\n";
Added 2D boolean hint for particle emitters in visual shaders
2021-11-04 15:42:57 +00:00
global_compute_code += "vec2 __get_random_unit_vec2(inout uint seed) {\n";
global_compute_code += " return normalize(vec2(__rand_from_seed_m1_p1(seed), __rand_from_seed_m1_p1(seed)));\n";
global_compute_code += "}\n\n";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
global_compute_code += "vec3 __get_random_unit_vec3(inout uint seed) {\n";
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
global_compute_code += " return normalize(vec3(__rand_from_seed_m1_p1(seed), __rand_from_seed_m1_p1(seed), __rand_from_seed_m1_p1(seed)));\n";
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
global_compute_code += "}\n\n";
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
//set code secretly
global_code += "\n\n";
String final_code = global_code;
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
final_code += global_compute_code;
Added triplanar uniform texture node to visual shaders
2019-07-12 09:14:34 +00:00
final_code += global_code_per_node;
Added global expressions to visual shaders
2019-08-18 05:09:05 +00:00
final_code += global_expressions;
Added triplanar uniform texture node to visual shaders
2019-07-12 09:14:34 +00:00
String tcode = code;
for (int i = 0; i < TYPE_MAX; i++) {
Remakes particles in visual shaders
2020-09-07 07:28:13 +00:00
if (!has_func_name(RenderingServer::ShaderMode(shader_mode), func_name[i])) {
Added sky shader mode to visual shaders
2020-03-25 09:22:29 +00:00
continue;
}
Fix function code generation for uniform triplanar node in visual shader
2021-07-21 09:57:11 +00:00
String func_code = global_code_per_func[Type(i)].as_string();
if (empty_funcs.has(Type(i)) && !func_code.is_empty()) {
func_code = vformat("%s%s%s", String("\nvoid " + String(func_name[i]) + "() {\n"), func_code, "}\n");
}
tcode = tcode.insert(insertion_pos[i], func_code);
Added triplanar uniform texture node to visual shaders
2019-07-12 09:14:34 +00:00
}
final_code += tcode;
Visual Shaders are back.
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++) {
Fix default_texture_param in shader pipeline to support uniform arrays
2021-10-17 11:38:26 +00:00
for (int j = 0; j < default_tex_params[i].params.size(); j++) {
const_cast<VisualShader *>(this)->set_default_texture_param(default_tex_params[i].name, default_tex_params[i].params[j], j);
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
Added code preview to visual shader
2019-08-18 09:29:22 +00:00
if (previous_code != final_code) {
Optimize StringName usage * Added a new macro SNAME() that constructs and caches a local stringname. * Subsequent usages use the cached version. * Since these use a global static variable, a second refcounter of static usages need to be kept for cleanup time. * Replaced all theme usages by this new macro. * Replace all signal emission usages by this new macro. * Replace all call_deferred usages by this new macro. This is part of ongoing work to optimize GUI and the editor.
2021-07-17 21:22:52 +00:00
const_cast<VisualShader *>(this)->emit_signal(SNAME("changed"));
Added code preview to visual shader
2019-08-18 09:29:22 +00:00
}
previous_code = final_code;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
void VisualShader::_queue_update() {
Modernize atomics - Based on C++11's `atomic` - Reworked `SafeRefCount` (based on the rewrite by @hpvb) - Replaced free atomic functions by the new `SafeNumeric<T>` - Replaced wrong cases of `volatile bool` by the new `SafeFlag` - Platform-specific implementations no longer needed Co-authored-by: Hein-Pieter van Braam-Stewart <hp@tmm.cx>
2021-02-10 18:22:13 +00:00
if (dirty.is_set()) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
return;
}
Modernize atomics - Based on C++11's `atomic` - Reworked `SafeRefCount` (based on the rewrite by @hpvb) - Replaced free atomic functions by the new `SafeNumeric<T>` - Replaced wrong cases of `volatile bool` by the new `SafeFlag` - Platform-specific implementations no longer needed Co-authored-by: Hein-Pieter van Braam-Stewart <hp@tmm.cx>
2021-02-10 18:22:13 +00:00
dirty.set();
Optimize StringName usage * Added a new macro SNAME() that constructs and caches a local stringname. * Subsequent usages use the cached version. * Since these use a global static variable, a second refcounter of static usages need to be kept for cleanup time. * Replaced all theme usages by this new macro. * Replace all signal emission usages by this new macro. * Replace all call_deferred usages by this new macro. This is part of ongoing work to optimize GUI and the editor.
2021-07-17 21:22:52 +00:00
call_deferred(SNAME("_update_shader"));
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
void VisualShader::_input_type_changed(Type p_type, int p_id) {
VisualShader::_input_type_changed Fix index out of bounds crash.
2021-02-14 14:26:33 +00:00
ERR_FAIL_INDEX(p_type, TYPE_MAX);
Visual Shaders are back.
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);
Forbid recursive connections in visual shader
2020-01-20 14:46:49 +00:00
g->nodes[E->get().to_node].prev_connected_nodes.erase(p_id);
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
E = N;
}
}
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
void VisualShader::rebuild() {
Modernize atomics - Based on C++11's `atomic` - Reworked `SafeRefCount` (based on the rewrite by @hpvb) - Replaced free atomic functions by the new `SafeNumeric<T>` - Replaced wrong cases of `volatile bool` by the new `SafeFlag` - Platform-specific implementations no longer needed Co-authored-by: Hein-Pieter van Braam-Stewart <hp@tmm.cx>
2021-02-10 18:22:13 +00:00
dirty.set();
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
_update_shader();
}
Visual Shaders are back.
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);
doc: Sync classref with current source Fix various missing arguments in bindings.
2018-07-26 09:56:21 +00:00
ClassDB::bind_method(D_METHOD("get_node", "type", "id"), &VisualShader::get_node);
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
ClassDB::bind_method(D_METHOD("set_node_position", "type", "id", "position"), &VisualShader::set_node_position);
Visual Shaders are back.
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);
Add convert options between constants and uniforms in visual shaders
2020-12-30 08:45:31 +00:00
ClassDB::bind_method(D_METHOD("replace_node", "type", "id", "new_class"), &VisualShader::replace_node);
Visual Shaders are back.
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);
some typo in method binds fixed
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);
Visual Shaders are back.
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);
Expression node for visual shaders
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);
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
ClassDB::bind_method(D_METHOD("get_node_connections", "type"), &VisualShader::_get_node_connections);
Makes dictionary instead of string for visual shader version Update doc/classes/VisualShader.xml Co-authored-by: Hugo Locurcio <hugo.locurcio@hugo.pro>
2021-08-01 15:13:51 +00:00
ClassDB::bind_method(D_METHOD("set_engine_version", "version"), &VisualShader::set_engine_version);
ClassDB::bind_method(D_METHOD("get_engine_version"), &VisualShader::get_engine_version);
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
Visual Shaders are back.
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);
Rename `PROPERTY_USAGE_NOEDITOR` to `PROPERTY_USAGE_NO_EDITOR` This is consistent with other constants that include `NO`, such as `PROPERTY_HINT_COLOR_NO_ALPHA`.
2021-11-03 22:06:17 +00:00
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "graph_offset", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR), "set_graph_offset", "get_graph_offset");
Fixed incorrect property types
2022-01-11 04:17:42 +00:00
ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY, "engine_version", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR), "set_engine_version", "get_engine_version");
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
doc: Sync classref with current source
2020-09-04 08:43:11 +00:00
ADD_PROPERTY_DEFAULT("code", ""); // Inherited from Shader, prevents showing default code as override in docs.
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
BIND_ENUM_CONSTANT(TYPE_VERTEX);
BIND_ENUM_CONSTANT(TYPE_FRAGMENT);
BIND_ENUM_CONSTANT(TYPE_LIGHT);
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
BIND_ENUM_CONSTANT(TYPE_START);
doc: Sync classref with current source Bind missing enums.
2020-09-11 10:22:10 +00:00
BIND_ENUM_CONSTANT(TYPE_PROCESS);
Continuation of work on visual particles system
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);
doc: Sync classref with current source
2021-04-19 10:26:37 +00:00
BIND_ENUM_CONSTANT(TYPE_SKY);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
BIND_ENUM_CONSTANT(TYPE_FOG);
Visual Shaders are back.
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() {
Modernize atomics - Based on C++11's `atomic` - Reworked `SafeRefCount` (based on the rewrite by @hpvb) - Replaced free atomic functions by the new `SafeNumeric<T>` - Replaced wrong cases of `volatile bool` by the new `SafeFlag` - Platform-specific implementations no longer needed Co-authored-by: Hein-Pieter van Braam-Stewart <hp@tmm.cx>
2021-02-10 18:22:13 +00:00
dirty.set();
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
for (int i = 0; i < TYPE_MAX; i++) {
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
if (i > (int)TYPE_LIGHT && i < (int)TYPE_SKY) {
Ref<VisualShaderNodeParticleOutput> output;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-17 22:03:09 +00:00
output.instantiate();
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
output->shader_type = Type(i);
output->shader_mode = shader_mode;
graph[i].nodes[NODE_ID_OUTPUT].node = output;
} else {
Ref<VisualShaderNodeOutput> output;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-17 22:03:09 +00:00
output.instantiate();
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
output->shader_type = Type(i);
output->shader_mode = shader_mode;
graph[i].nodes[NODE_ID_OUTPUT].node = output;
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
graph[i].nodes[NODE_ID_OUTPUT].position = Vector2(400, 150);
}
}
///////////////////////////////////////////////////////////
const VisualShaderNodeInput::Port VisualShaderNodeInput::ports[] = {
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
// Node3D
// Node3D, Vertex
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ 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" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv", "UV" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv2", "UV2" },
Visual Shaders are back.
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" },
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR_INT, "instance_id", "INSTANCE_ID" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "instance_custom", "INSTANCE_CUSTOM.rgb" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "instance_custom_alpha", "INSTANCE_CUSTOM.a" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "roughness", "ROUGHNESS" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_TRANSFORM, "world", "WORLD_MATRIX" },
updated visual shader builtins
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" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_TRANSFORM, "inv_camera", "INV_CAMERA_MATRIX" },
updated visual shader builtins
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" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR_2D, "viewport_size", "VIEWPORT_SIZE" },
Added missing OUTPUT_IS_SRGB and FRONT_FACING to visual shaders
2019-09-04 15:24:44 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_BOOLEAN, "output_is_srgb", "OUTPUT_IS_SRGB" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
// Node3D, Fragment
updated visual shader builtins
2019-01-27 09:16:37 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "fragcoord", "FRAGCOORD.xyz" },
Visual Shaders are back.
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" },
updated visual shader builtins
2019-01-27 09:16:37 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "view", "VIEW" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv", "UV" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv2", "UV2" },
Visual Shaders are back.
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" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "point_coord", "POINT_COORD" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "screen_uv", "SCREEN_UV" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ 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" },
updated visual shader builtins
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" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "viewport_size", "VIEWPORT_SIZE" },
Added missing OUTPUT_IS_SRGB and FRONT_FACING to visual shaders
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" },
Added sampler inputs for visual shaders
2019-11-03 13:38:03 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SAMPLER, "screen_texture", "SCREEN_TEXTURE" },
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SAMPLER, "normal_roughness_texture", "NORMAL_ROUGHNESS_TEXTURE" },
Added sampler inputs for visual shaders
2019-11-03 13:38:03 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SAMPLER, "depth_texture", "DEPTH_TEXTURE" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
// Node3D, Light
updated visual shader builtins
2019-01-27 09:16:37 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "fragcoord", "FRAGCOORD.xyz" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "normal", "NORMAL" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv", "UV" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv2", "UV2" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ 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" },
Fixed several visual shader inputs Fixed several inputs in visual shaders
2020-11-29 11:16:18 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "attenuation", "ATTENUATION" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "albedo", "ALBEDO" },
Fixed invalid visual shader outputs (TRANSMISSION, ALPHA_SCISSOR)
2020-11-28 17:14:30 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "backlight", "BACKLIGHT" },
added diffuse and specular as inputs to visual shader
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" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "roughness", "ROUGHNESS" },
Adds Metallic to spatial light input of visual shaders
2020-10-10 13:55:36 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "metallic", "METALLIC" },
Visual Shaders are back.
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" },
updated visual shader builtins
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" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "viewport_size", "VIEWPORT_SIZE" },
Added missing OUTPUT_IS_SRGB and FRONT_FACING to visual shaders
2019-09-04 15:24:44 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_BOOLEAN, "output_is_srgb", "OUTPUT_IS_SRGB" },
Fix `sky` visual shader mode after last rename
2021-04-17 17:16:03 +00:00
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
// Canvas Item
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
// Canvas Item, Vertex
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR_2D, "vertex", "VERTEX" },
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv", "UV" },
Visual Shaders are back.
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" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR_2D, "texture_pixel_size", "TEXTURE_PIXEL_SIZE" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_TRANSFORM, "world", "WORLD_MATRIX" },
Fixed several visual shader inputs Fixed several inputs in visual shaders
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" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
Fixed several visual shader inputs Fixed several inputs in visual shaders
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" },
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "instance_custom", "INSTANCE_CUSTOM.rgb" },
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "instance_custom_alpha", "INSTANCE_CUSTOM.a" },
Fix `sky` visual shader mode after last rename
2021-04-17 17:16:03 +00:00
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
// Canvas Item, Fragment
updated visual shader builtins
2019-01-27 09:16:37 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "fragcoord", "FRAGCOORD.xyz" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv", "UV" },
Visual Shaders are back.
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" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "screen_uv", "SCREEN_UV" },
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "texture_pixel_size", "TEXTURE_PIXEL_SIZE" },
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "screen_pixel_size", "SCREEN_PIXEL_SIZE" },
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "point_coord", "POINT_COORD" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
Fixed several visual shader inputs Fixed several inputs in visual shaders
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" },
Added sampler inputs for visual shaders
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" },
Fixed several visual shader inputs Fixed several inputs in visual shaders
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" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "vertex", "VERTEX" },
Fix `sky` visual shader mode after last rename
2021-04-17 17:16:03 +00:00
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
// Canvas Item, Light
updated visual shader builtins
2019-01-27 09:16:37 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "fragcoord", "FRAGCOORD.xyz" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv", "UV" },
Visual Shaders are back.
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" },
Fixed several visual shader inputs Fixed several inputs in visual shaders
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" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "light_color", "LIGHT_COLOR.rgb" },
Fixed several visual shader inputs Fixed several inputs in visual shaders
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" },
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "shadow", "SHADOW_MODULATE.rgb" },
Fixed several visual shader inputs Fixed several inputs in visual shaders
2020-11-29 11:16:18 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "shadow_alpha", "SHADOW_MODULATE.a" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "screen_uv", "SCREEN_UV" },
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "texture_pixel_size", "TEXTURE_PIXEL_SIZE" },
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "point_coord", "POINT_COORD" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
Added sampler inputs for visual shaders
2019-11-03 13:38:03 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SAMPLER, "texture", "TEXTURE" },
Fixed several visual shader inputs Fixed several inputs in visual shaders
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" },
updated visual shader builtins
2019-01-27 09:16:37 +00:00
Continuation of work on visual particles system
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" },
Remakes particles in visual shaders
2020-09-07 07:28:13 +00:00
// Particles, Process
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
{ Shader::MODE_PARTICLES, VisualShader::TYPE_PROCESS, VisualShaderNode::PORT_TYPE_VECTOR, "attractor_force", "ATTRACTOR_FORCE" },
Remakes particles in visual shaders
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" },
Continuation of work on visual particles system
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" },
Remakes particles in visual shaders
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" },
Continuation of work on visual particles system
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" },
Added sky shader mode to visual shaders
2020-03-25 09:22:29 +00:00
Fix `sky` visual shader mode after last rename
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" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_SKY, VisualShader::TYPE_SKY, VisualShaderNode::PORT_TYPE_VECTOR_2D, "screen_uv", "SCREEN_UV" },
{ Shader::MODE_SKY, VisualShader::TYPE_SKY, VisualShaderNode::PORT_TYPE_VECTOR_2D, "sky_coords", "SKY_COORDS" },
Fix `sky` visual shader mode after last rename
2021-04-17 17:16:03 +00:00
{ Shader::MODE_SKY, VisualShader::TYPE_SKY, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
Added sky shader mode to visual shaders
2020-03-25 09:22:29 +00:00
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
// Fog, Fog
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_VECTOR, "world_position", "WORLD_POSITION" },
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_VECTOR, "object_position", "OBJECT_POSITION" },
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_VECTOR, "uvw", "UVW" },
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_VECTOR, "extents", "EXTENTS" },
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_SCALAR, "sdf", "SDF" },
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
{ Shader::MODE_MAX, VisualShader::TYPE_MAX, VisualShaderNode::PORT_TYPE_TRANSFORM, nullptr, nullptr },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
};
const VisualShaderNodeInput::Port VisualShaderNodeInput::preview_ports[] = {
Make port previews in visual shader visible in other shader modes
2021-10-08 19:55:07 +00:00
// Spatial, Vertex
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "normal", "vec3(0.0, 0.0, 1.0)" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "tangent", "vec3(0.0, 1.0, 0.0)" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "binormal", "vec3(1.0, 0.0, 0.0)" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv", "UV" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv2", "UV" },
Make port previews in visual shader visible in other shader modes
2021-10-08 19:55:07 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR, "color", "vec3(1.0)" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "1.0" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR_2D, "viewport_size", "vec2(1.0)" },
Make port previews in visual shader visible in other shader modes
2021-10-08 19:55:07 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
// Spatial, Fragment
Make port previews in visual shader visible in other shader modes
2021-10-08 19:55:07 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "fragcoord", "FRAGCOORD.rgb" },
Better visual shader code generation
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)" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv", "UV" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv2", "UV" },
Visual Shaders are back.
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" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "screen_uv", "SCREEN_UV" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "viewport_size", "vec2(1.0)" },
Make port previews in visual shader visible in other shader modes
2021-10-08 19:55:07 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
// Spatial, Light
Make port previews in visual shader visible in other shader modes
2021-10-08 19:55:07 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "fragcoord", "FRAGCOORD.rgb" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "normal", "vec3(0.0, 0.0, 1.0)" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv", "UV" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv2", "UV" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "viewport_size", "vec2(1.0)" },
Make port previews in visual shader visible in other shader modes
2021-10-08 19:55:07 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
// Canvas Item, Vertex
Make port previews in visual shader visible in other shader modes
2021-10-08 19:55:07 +00:00
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR_2D, "vertex", "VERTEX" },
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv", "UV" },
Visual Shaders are back.
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" },
Make port previews in visual shader visible in other shader modes
2021-10-08 19:55:07 +00:00
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
// Canvas Item, Fragment
Make port previews in visual shader visible in other shader modes
2021-10-08 19:55:07 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "fragcoord", "FRAGCOORD.rgb" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv", "UV" },
Visual Shaders are back.
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" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "screen_uv", "SCREEN_UV" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
Make port previews in visual shader visible in other shader modes
2021-10-08 19:55:07 +00:00
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
// Canvas Item, Light
Make port previews in visual shader visible in other shader modes
2021-10-08 19:55:07 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "fragcoord", "FRAGCOORD.rgb" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv", "UV" },
Better visual shader code generation
2020-01-27 09:10:51 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "normal", "vec3(0.0, 0.0, 1.0)" },
Visual Shaders are back.
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" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "screen_uv", "SCREEN_UV" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
// Particles
Make port previews in visual shader visible in other shader modes
2021-10-08 19:55:07 +00:00
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
{ 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" },
Make port previews in visual shader visible in other shader modes
2021-10-08 19:55:07 +00:00
Repair Fog mode in visual shaders
2021-10-29 13:42:33 +00:00
// Sky
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_SKY, VisualShader::TYPE_SKY, VisualShaderNode::PORT_TYPE_VECTOR_2D, "screen_uv", "SCREEN_UV" },
Repair Fog mode in visual shaders
2021-10-29 13:42:33 +00:00
{ Shader::MODE_SKY, VisualShader::TYPE_SKY, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
// Fog
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
{ Shader::MODE_MAX, VisualShader::TYPE_MAX, VisualShaderNode::PORT_TYPE_TRANSFORM, nullptr, nullptr },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
};
int VisualShaderNodeInput::get_input_port_count() const {
return 0;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
VisualShaderNodeInput::PortType VisualShaderNodeInput::get_input_port_type(int p_port) const {
return PORT_TYPE_SCALAR;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Visual Shaders are back.
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;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Visual Shaders are back.
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);
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
String VisualShaderNodeInput::get_output_port_name(int p_port) const {
return "";
}
String VisualShaderNodeInput::get_caption() const {
Removes translations from generated visual shader code
2019-10-29 06:26:05 +00:00
return "Input";
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
Modified code generation to be more friendly to previews, fixes #25094
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 {
Added sampler inputs for visual shaders
2019-11-03 13:38:03 +00:00
if (get_output_port_type(0) == PORT_TYPE_SAMPLER) {
return "";
}
Modified code generation to be more friendly to previews, fixes #25094
2019-01-21 19:07:53 +00:00
if (p_for_preview) {
int idx = 0;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Modified code generation to be more friendly to previews, fixes #25094
2019-01-21 19:07:53 +00:00
String code;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Modified code generation to be more friendly to previews, fixes #25094
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) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code = " " + p_output_vars[0] + " = " + preview_ports[idx].string + ";\n";
Modified code generation to be more friendly to previews, fixes #25094
2019-01-21 19:07:53 +00:00
break;
}
idx++;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
Replace String comparisons with "", String() to is_empty() Also: - Adds two stress tests to test_string.h - Changes to .empty() on std::strings
2021-12-09 09:42:46 +00:00
if (code.is_empty()) {
Modified code generation to be more friendly to previews, fixes #25094
2019-01-21 19:07:53 +00:00
switch (get_output_port_type(0)) {
case PORT_TYPE_SCALAR: {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code = " " + p_output_vars[0] + " = 0.0;\n";
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
} break;
case PORT_TYPE_SCALAR_INT: {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code = " " + p_output_vars[0] + " = 0;\n";
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
} break;
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
case PORT_TYPE_VECTOR_2D: {
code = " " + p_output_vars[0] + " = vec2(0.0);\n";
} break;
Modified code generation to be more friendly to previews, fixes #25094
2019-01-21 19:07:53 +00:00
case PORT_TYPE_VECTOR: {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code = " " + p_output_vars[0] + " = vec3(0.0);\n";
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
} break;
Major improvements for visual shader system
2019-02-22 17:38:58 +00:00
case PORT_TYPE_BOOLEAN: {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code = " " + p_output_vars[0] + " = false;\n";
Major improvements for visual shader system
2019-02-22 17:38:58 +00:00
} break;
Make port previews in visual shader visible in other shader modes
2021-10-08 19:55:07 +00:00
default:
Major improvements for visual shader system
2019-02-22 17:38:58 +00:00
break;
Modified code generation to be more friendly to previews, fixes #25094
2019-01-21 19:07:53 +00:00
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
Modified code generation to be more friendly to previews, fixes #25094
2019-01-21 19:07:53 +00:00
return code;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Modified code generation to be more friendly to previews, fixes #25094
2019-01-21 19:07:53 +00:00
} else {
int idx = 0;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Modified code generation to be more friendly to previews, fixes #25094
2019-01-21 19:07:53 +00:00
String code;
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Modified code generation to be more friendly to previews, fixes #25094
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) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code = " " + p_output_vars[0] + " = " + ports[idx].string + ";\n";
Modified code generation to be more friendly to previews, fixes #25094
2019-01-21 19:07:53 +00:00
break;
}
idx++;
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Replace String comparisons with "", String() to is_empty() Also: - Adds two stress tests to test_string.h - Changes to .empty() on std::strings
2021-12-09 09:42:46 +00:00
if (code.is_empty()) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code = " " + p_output_vars[0] + " = 0.0;\n"; //default (none found) is scalar
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
Modified code generation to be more friendly to previews, fixes #25094
2019-01-21 19:07:53 +00:00
return code;
Visual Shaders are back.
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) {
Optimize StringName usage * Added a new macro SNAME() that constructs and caches a local stringname. * Subsequent usages use the cached version. * Since these use a global static variable, a second refcounter of static usages need to be kept for cleanup time. * Replaced all theme usages by this new macro. * Replace all signal emission usages by this new macro. * Replace all call_deferred usages by this new macro. This is part of ongoing work to optimize GUI and the editor.
2021-07-17 21:22:52 +00:00
emit_signal(SNAME("input_type_changed"));
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
}
String VisualShaderNodeInput::get_input_name() const {
return input_name;
}
Added sampler inputs for visual shaders
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 "";
}
Visual Shaders are back.
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) {
Replace String comparisons with "", String() to is_empty() Also: - Adds two stress tests to test_string.h - Changes to .empty() on std::strings
2021-12-09 09:42:46 +00:00
if (!port_list.is_empty()) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
port_list += ",";
}
port_list += ports[idx].name;
}
idx++;
}
Replace String comparisons with "", String() to is_empty() Also: - Adds two stress tests to test_string.h - Changes to .empty() on std::strings
2021-12-09 09:42:46 +00:00
if (port_list.is_empty()) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
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;
}
Fix auto-connection from output node to input (VisualShaders)
2021-06-17 15:03:07 +00:00
void VisualShaderNodeInput::set_shader_type(VisualShader::Type p_shader_type) {
shader_type = p_shader_type;
}
void VisualShaderNodeInput::set_shader_mode(Shader::Mode p_shader_mode) {
shader_mode = p_shader_mode;
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
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);
Fix invalid casting on visual shader sampler
2019-11-04 15:50:33 +00:00
ClassDB::bind_method(D_METHOD("get_input_real_name"), &VisualShaderNodeInput::get_input_real_name);
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Added StringName as a variant type. Also changed all relevant properties defined manually to StringName.
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");
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
ADD_SIGNAL(MethodInfo("input_type_changed"));
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
VisualShaderNodeInput::VisualShaderNodeInput() {
}
Added UniformRef visual shader node
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();
}
Fix some bugs in visual shader editor
2020-09-21 11:32:59 +00:00
bool VisualShaderNodeUniformRef::has_uniform(const String &p_name) {
Use const references where possible for List range iterators
2021-07-24 13:46:25 +00:00
for (const VisualShaderNodeUniformRef::Uniform &E : uniforms) {
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
if (E.name == p_name) {
Fix some bugs in visual shader editor
2020-09-21 11:32:59 +00:00
return true;
}
}
return false;
}
Added UniformRef visual shader node
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;
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
case UniformType::UNIFORM_TYPE_VECTOR2:
return 1;
case UniformType::UNIFORM_TYPE_VECTOR3:
Added UniformRef visual shader node
2020-07-28 08:02:57 +00:00
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;
}
Fix some bugs in visual shader editor
2020-09-21 11:32:59 +00:00
return 1;
Added UniformRef visual shader node
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;
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
case UniformType::UNIFORM_TYPE_VECTOR2:
return PortType::PORT_TYPE_VECTOR_2D;
case UniformType::UNIFORM_TYPE_VECTOR3:
Added UniformRef visual shader node
2020-07-28 08:02:57 +00:00
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 "";
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
case UniformType::UNIFORM_TYPE_VECTOR2:
return "";
case UniformType::UNIFORM_TYPE_VECTOR3:
Added UniformRef visual shader node
2020-07-28 08:02:57 +00:00
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;
Fix some bugs in visual shader editor
2020-09-21 11:32:59 +00:00
if (uniform_name != "[None]") {
uniform_type = get_uniform_type_by_name(uniform_name);
Added UniformRef visual shader node
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;
}
Auto-set a first compatible uniform on dragging to create a UniformRef
2021-07-12 07:34:40 +00:00
VisualShaderNodeUniformRef::PortType VisualShaderNodeUniformRef::get_port_type_by_index(int p_idx) const {
if (p_idx >= 0 && p_idx < uniforms.size()) {
switch (uniforms[p_idx].type) {
case UniformType::UNIFORM_TYPE_FLOAT:
return PORT_TYPE_SCALAR;
case UniformType::UNIFORM_TYPE_INT:
return PORT_TYPE_SCALAR_INT;
case UniformType::UNIFORM_TYPE_SAMPLER:
return PORT_TYPE_SAMPLER;
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
case UniformType::UNIFORM_TYPE_VECTOR2:
return PORT_TYPE_VECTOR_2D;
case UniformType::UNIFORM_TYPE_VECTOR3:
Auto-set a first compatible uniform on dragging to create a UniformRef
2021-07-12 07:34:40 +00:00
return PORT_TYPE_VECTOR;
case UniformType::UNIFORM_TYPE_TRANSFORM:
return PORT_TYPE_TRANSFORM;
case UniformType::UNIFORM_TYPE_COLOR:
return PORT_TYPE_VECTOR;
default:
break;
}
}
return PORT_TYPE_SCALAR;
}
Added UniformRef visual shader node
2020-07-28 08:02:57 +00:00
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:
Fix some bugs in visual shader editor
2020-09-21 11:32:59 +00:00
if (uniform_name == "[None]") {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
return " " + p_output_vars[0] + " = 0.0;\n";
Fix some bugs in visual shader editor
2020-09-21 11:32:59 +00:00
}
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
break;
Added UniformRef visual shader node
2020-07-28 08:02:57 +00:00
case UniformType::UNIFORM_TYPE_COLOR: {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
String code = " " + p_output_vars[0] + " = " + get_uniform_name() + ".rgb;\n";
code += " " + p_output_vars[1] + " = " + get_uniform_name() + ".a;\n";
Added UniformRef visual shader node
2020-07-28 08:02:57 +00:00
return code;
} break;
case UniformType::UNIFORM_TYPE_SAMPLER:
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
return String();
Added UniformRef visual shader node
2020-07-28 08:02:57 +00:00
default:
break;
}
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
return " " + p_output_vars[0] + " = " + get_uniform_name() + ";\n";
Added UniformRef visual shader node
2020-07-28 08:02:57 +00:00
}
Fix some bugs in visual shader editor
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;
}
Added UniformRef visual shader node
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);
Fix some bugs in visual shader editor
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);
Added UniformRef visual shader node
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");
Rename `PROPERTY_USAGE_NOEDITOR` to `PROPERTY_USAGE_NO_EDITOR` This is consistent with other constants that include `NO`, such as `PROPERTY_HINT_COLOR_NO_ALPHA`.
2021-11-03 22:06:17 +00:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "uniform_type", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL), "_set_uniform_type", "_get_uniform_type");
Added UniformRef visual shader node
2020-07-28 08:02:57 +00:00
}
Vector<StringName> VisualShaderNodeUniformRef::get_editable_properties() const {
Vector<StringName> props;
props.push_back("uniform_name");
Fix some bugs in visual shader editor
2020-09-21 11:32:59 +00:00
props.push_back("uniform_type");
Added UniformRef visual shader node
2020-07-28 08:02:57 +00:00
return props;
}
VisualShaderNodeUniformRef::VisualShaderNodeUniformRef() {
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
////////////////////////////////////////////
const VisualShaderNodeOutput::Port VisualShaderNodeOutput::ports[] = {
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
////////////////////////////////////////////////////////////////////////
// Node3D.
////////////////////////////////////////////////////////////////////////
// Node3D, Vertex.
////////////////////////////////////////////////////////////////////////
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ 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" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv", "UV" },
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv2", "UV2" },
Visual Shaders are back.
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, "roughness", "ROUGHNESS" },
Added Billboard Node to Visual Shaders
2021-05-27 19:17:58 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_TRANSFORM, "model_view_matrix", "MODELVIEW_MATRIX" },
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
////////////////////////////////////////////////////////////////////////
// Node3D, Fragment.
////////////////////////////////////////////////////////////////////////
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ 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" },
Consistently use normal_map
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" },
Visual Shaders are back.
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" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "anisotropy_flow", "ANISOTROPY_FLOW" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "subsurf_scatter", "SSS_STRENGTH" },
Fixed invalid visual shader outputs (TRANSMISSION, ALPHA_SCISSOR)
2020-11-28 17:14:30 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "backlight", "BACKLIGHT" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
Fixed invalid visual shader outputs (TRANSMISSION, ALPHA_SCISSOR)
2020-11-28 17:14:30 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "alpha_scissor_threshold", "ALPHA_SCISSOR_THRESHOLD" },
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_SCALAR, "ao_light_affect", "AO_LIGHT_AFFECT" },
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
////////////////////////////////////////////////////////////////////////
// Node3D, Light.
////////////////////////////////////////////////////////////////////////
Visual Shaders are back.
2018-07-14 21:15:42 +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" },
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
{ Shader::MODE_SPATIAL, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "ALPHA" },
////////////////////////////////////////////////////////////////////////
// Canvas Item.
////////////////////////////////////////////////////////////////////////
// Canvas Item, Vertex.
////////////////////////////////////////////////////////////////////////
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR_2D, "vertex", "VERTEX" },
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_VECTOR_2D, "uv", "UV" },
Visual Shaders are back.
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" },
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_VERTEX, VisualShaderNode::PORT_TYPE_SCALAR, "point_size", "POINT_SIZE" },
////////////////////////////////////////////////////////////////////////
// Canvas Item, Fragment.
////////////////////////////////////////////////////////////////////////
Visual Shaders are back.
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" },
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "normal", "NORMAL" },
Consistently use normal_map
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" },
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR, "light_vertex", "LIGHT_VERTEX" },
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_FRAGMENT, VisualShaderNode::PORT_TYPE_VECTOR_2D, "shadow_vertex", "SHADOW_VERTEX" },
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
////////////////////////////////////////////////////////////////////////
// Canvas Item, Light.
////////////////////////////////////////////////////////////////////////
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_VECTOR, "light", "LIGHT.rgb" },
Fix canvas_item light alpha output in visual shaders
2020-01-31 16:34:34 +00:00
{ Shader::MODE_CANVAS_ITEM, VisualShader::TYPE_LIGHT, VisualShaderNode::PORT_TYPE_SCALAR, "light_alpha", "LIGHT.a" },
Continuation of work on visual particles system
2020-09-15 07:57:40 +00:00
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
////////////////////////////////////////////////////////////////////////
// Sky, Sky.
////////////////////////////////////////////////////////////////////////
Fix `sky` visual shader mode after last rename
2021-04-17 17:16:03 +00:00
{ Shader::MODE_SKY, VisualShader::TYPE_SKY, VisualShaderNode::PORT_TYPE_VECTOR, "color", "COLOR" },
{ Shader::MODE_SKY, VisualShader::TYPE_SKY, VisualShaderNode::PORT_TYPE_SCALAR, "alpha", "ALPHA" },
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
{ Shader::MODE_SKY, VisualShader::TYPE_SKY, VisualShaderNode::PORT_TYPE_VECTOR, "fog", "FOG.rgb" },
{ Shader::MODE_SKY, VisualShader::TYPE_SKY, VisualShaderNode::PORT_TYPE_SCALAR, "fog_alpha", "FOG.a" },
Added sky shader mode to visual shaders
2020-03-25 09:22:29 +00:00
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
////////////////////////////////////////////////////////////////////////
// Fog, Fog.
////////////////////////////////////////////////////////////////////////
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_SCALAR, "density", "DENSITY" },
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_VECTOR, "albedo", "ALBEDO" },
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_VECTOR, "emission", "EMISSION" },
Added more input/output built-ins to visual shaders
2021-07-18 12:05:25 +00:00
////////////////////////////////////////////////////////////////////////
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
{ Shader::MODE_MAX, VisualShader::TYPE_MAX, VisualShaderNode::PORT_TYPE_TRANSFORM, nullptr, nullptr },
Visual Shaders are back.
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;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
VisualShaderNodeOutput::PortType VisualShaderNodeOutput::get_output_port_type(int p_port) const {
return PORT_TYPE_SCALAR;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Visual Shaders are back.
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 {
Added Billboard Node to Visual Shaders
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");
}
Visual Shaders are back.
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);
Added Billboard Node to Visual Shaders
2021-05-27 19:17:58 +00:00
return bool(name == "Normal" || name == "Rim" || name == "Alpha Scissor Threshold");
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
return false;
}
String VisualShaderNodeOutput::get_caption() const {
Removes translations from generated visual shader code
2019-10-29 06:26:05 +00:00
return "Output";
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
Modified code generation to be more friendly to previews, fixes #25094
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 {
Visual Shaders are back.
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) {
Replace String comparisons with "", String() to is_empty() Also: - Adds two stress tests to test_string.h - Changes to .empty() on std::strings
2021-12-09 09:42:46 +00:00
if (!p_input_vars[count].is_empty()) {
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
String s = ports[idx].string;
String: Add contains().
2022-02-03 16:03:38 +00:00
if (s.contains(":")) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " " + s.get_slicec(':', 0) + " = " + p_input_vars[count] + "." + s.get_slicec(':', 1) + ";\n";
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
} else {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " " + s + " = " + p_input_vars[count] + ";\n";
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
}
count++;
}
idx++;
}
return code;
}
VisualShaderNodeOutput::VisualShaderNodeOutput() {
}
///////////////////////////
void VisualShaderNodeUniform::set_uniform_name(const String &p_name) {
uniform_name = p_name;
Optimize StringName usage * Added a new macro SNAME() that constructs and caches a local stringname. * Subsequent usages use the cached version. * Since these use a global static variable, a second refcounter of static usages need to be kept for cleanup time. * Replaced all theme usages by this new macro. * Replace all signal emission usages by this new macro. * Replace all call_deferred usages by this new macro. This is part of ongoing work to optimize GUI and the editor.
2021-07-17 21:22:52 +00:00
emit_signal(SNAME("name_changed"));
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
emit_changed();
}
String VisualShaderNodeUniform::get_uniform_name() const {
return uniform_name;
}
Added uniform qualifiers to visual shaders
2020-05-05 08:25:48 +00:00
void VisualShaderNodeUniform::set_qualifier(VisualShaderNodeUniform::Qualifier p_qual) {
Added missed limiters for Visual Shader node enums
2021-08-14 10:38:22 +00:00
ERR_FAIL_INDEX(int(p_qual), int(QUAL_MAX));
if (qualifier == p_qual) {
return;
}
Added uniform qualifiers to visual shaders
2020-05-05 08:25:48 +00:00
qualifier = p_qual;
emit_changed();
}
VisualShaderNodeUniform::Qualifier VisualShaderNodeUniform::get_qualifier() const {
return qualifier;
}
Added UniformRef visual shader node
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;
}
Visual Shaders are back.
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);
Added uniform qualifiers to visual shaders
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);
Added StringName as a variant type. Also changed all relevant properties defined manually to StringName.
2020-02-20 21:58:05 +00:00
ADD_PROPERTY(PropertyInfo(Variant::STRING_NAME, "uniform_name"), "set_uniform_name", "get_uniform_name");
Added uniform qualifiers to visual shaders
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);
Added missed limiters for Visual Shader node enums
2021-08-14 10:38:22 +00:00
BIND_ENUM_CONSTANT(QUAL_MAX);
Added uniform qualifiers to visual shaders
2020-05-05 08:25:48 +00:00
}
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 ";
Added missed limiters for Visual Shader node enums
2021-08-14 10:38:22 +00:00
default:
break;
Added uniform qualifiers to visual shaders
2020-05-05 08:25:48 +00:00
}
}
return String();
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
}
Adds warning to the uniform name in visual shader if its equal to keyword
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)) {
Fix printing error about unsupported modifier on `TransformUniform`
2021-08-12 13:55:14 +00:00
return TTR("Shader keywords cannot be used as uniform names.\nChoose another name.");
Adds warning to the uniform name in visual shader if its equal to keyword
2020-04-06 07:25:05 +00:00
}
Added uniform qualifiers to visual shaders
2020-05-05 08:25:48 +00:00
if (!is_qualifier_supported(qualifier)) {
Fix printing error about unsupported modifier on `TransformUniform`
2021-08-12 13:55:14 +00:00
String qualifier_str;
switch (qualifier) {
case QUAL_NONE:
break;
case QUAL_GLOBAL:
qualifier_str = "global";
break;
case QUAL_INSTANCE:
qualifier_str = "instance";
break;
Added missed limiters for Visual Shader node enums
2021-08-14 10:38:22 +00:00
default:
break;
Fix printing error about unsupported modifier on `TransformUniform`
2021-08-12 13:55:14 +00:00
}
return vformat(TTR("This uniform type does not support the '%s' qualifier."), qualifier_str);
} else if (qualifier == Qualifier::QUAL_GLOBAL) {
RS::GlobalVariableType gvt = RS::get_singleton()->global_variable_get_type(uniform_name);
if (gvt == RS::GLOBAL_VAR_TYPE_MAX) {
return vformat(TTR("Global uniform '%s' does not exist.\nCreate it in the Project Settings."), uniform_name);
}
bool incompatible_type = false;
switch (gvt) {
case RS::GLOBAL_VAR_TYPE_FLOAT: {
if (!Object::cast_to<VisualShaderNodeFloatUniform>(this)) {
incompatible_type = true;
}
} break;
case RS::GLOBAL_VAR_TYPE_INT: {
if (!Object::cast_to<VisualShaderNodeIntUniform>(this)) {
incompatible_type = true;
}
} break;
case RS::GLOBAL_VAR_TYPE_BOOL: {
if (!Object::cast_to<VisualShaderNodeBooleanUniform>(this)) {
incompatible_type = true;
}
} break;
case RS::GLOBAL_VAR_TYPE_COLOR: {
if (!Object::cast_to<VisualShaderNodeColorUniform>(this)) {
incompatible_type = true;
}
} break;
case RS::GLOBAL_VAR_TYPE_VEC3: {
if (!Object::cast_to<VisualShaderNodeVec3Uniform>(this)) {
incompatible_type = true;
}
} break;
case RS::GLOBAL_VAR_TYPE_TRANSFORM: {
if (!Object::cast_to<VisualShaderNodeTransformUniform>(this)) {
incompatible_type = true;
}
} break;
case RS::GLOBAL_VAR_TYPE_SAMPLER2D: {
if (!Object::cast_to<VisualShaderNodeTextureUniform>(this)) {
incompatible_type = true;
}
} break;
case RS::GLOBAL_VAR_TYPE_SAMPLER3D: {
if (!Object::cast_to<VisualShaderNodeTexture3DUniform>(this)) {
incompatible_type = true;
}
} break;
case RS::GLOBAL_VAR_TYPE_SAMPLER2DARRAY: {
if (!Object::cast_to<VisualShaderNodeTexture2DArrayUniform>(this)) {
incompatible_type = true;
}
} break;
case RS::GLOBAL_VAR_TYPE_SAMPLERCUBE: {
if (!Object::cast_to<VisualShaderNodeCubemapUniform>(this)) {
incompatible_type = true;
}
} break;
default:
break;
}
if (incompatible_type) {
return vformat(TTR("Global uniform '%s' has an incompatible type for this kind of node.\nChange it in the Project Settings."), uniform_name);
}
Added uniform qualifiers to visual shaders
2020-05-05 08:25:48 +00:00
}
Adds warning to the uniform name in visual shader if its equal to keyword
2020-04-06 07:25:05 +00:00
return String();
}
Added uniform qualifiers to visual shaders
2020-05-05 08:25:48 +00:00
Vector<StringName> VisualShaderNodeUniform::get_editable_properties() const {
Vector<StringName> props;
props.push_back("qualifier");
return props;
}
Visual Shaders are back.
2018-07-14 21:15:42 +00:00
VisualShaderNodeUniform::VisualShaderNodeUniform() {
}
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
Added VisualShaderNodeCurve to easy gather data from a CurveTexture
2020-10-04 09:11:58 +00:00
////////////// ResizeableBase
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
Added VisualShaderNodeCurve to easy gather data from a CurveTexture
2020-10-04 09:11:58 +00:00
void VisualShaderNodeResizableBase::set_size(const Vector2 &p_size) {
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
size = p_size;
}
Added VisualShaderNodeCurve to easy gather data from a CurveTexture
2020-10-04 09:11:58 +00:00
Vector2 VisualShaderNodeResizableBase::get_size() const {
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
return size;
}
Added VisualShaderNodeCurve to easy gather data from a CurveTexture
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);
}
Added Comment node to Visual Shaders
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() {
}
Added VisualShaderNodeCurve to easy gather data from a CurveTexture
2020-10-04 09:11:58 +00:00
////////////// GroupBase
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
void VisualShaderNodeGroupBase::set_inputs(const String &p_inputs) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (inputs == p_inputs) {
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Expression node for visual shaders
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(",");
Fix expression node crashes
2019-06-22 14:41:51 +00:00
ERR_FAIL_COND(arr.size() != 3);
Expression node for visual shaders
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) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (outputs == p_outputs) {
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Expression node for visual shaders
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(",");
Fix expression node crashes
2019-06-22 14:41:51 +00:00
ERR_FAIL_COND(arr.size() != 3);
Expression node for visual shaders
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;
}
Fix expression node crashes
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;
}
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
void VisualShaderNodeGroupBase::add_input_port(int p_id, int p_type, const String &p_name) {
Added missed limiters for Visual Shader node enums
2021-08-14 10:38:22 +00:00
ERR_FAIL_INDEX(p_type, int(PORT_TYPE_MAX));
ERR_FAIL_COND(!is_valid_port_name(p_name));
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
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++;
}
String: Remove `erase` method, bindings can't mutate String
2021-11-11 08:08:08 +00:00
inputs = inputs.left(index) + inputs.substr(index + count);
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
inputs = inputs.insert(index, itos(i));
index += inputs_strings[i].size();
}
_apply_port_changes();
Fix expressions nodes in visual shaders
2020-09-22 19:54:30 +00:00
emit_changed();
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
}
void VisualShaderNodeGroupBase::remove_input_port(int p_id) {
Fix expression node crashes
2019-06-22 14:41:51 +00:00
ERR_FAIL_COND(!has_input_port(p_id));
Expression node for visual shaders
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();
}
String: Remove `erase` method, bindings can't mutate String
2021-11-11 08:08:08 +00:00
inputs = inputs.left(index) + inputs.substr(index + count);
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
inputs_strings = inputs.split(";", false);
Fix few bugs in visual shader expressions Fixed few bugs in visual shader expressions
2020-12-01 13:24:06 +00:00
inputs = inputs.substr(0, index);
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
for (int i = p_id; i < inputs_strings.size(); i++) {
Fix few bugs in visual shader expressions Fixed few bugs in visual shader expressions
2020-12-01 13:24:06 +00:00
inputs += inputs_strings[i].replace_first(inputs_strings[i].split(",")[0], itos(i)) + ";";
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
}
_apply_port_changes();
Fix expressions nodes in visual shaders
2020-09-22 19:54:30 +00:00
emit_changed();
Expression node for visual shaders
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) {
Added missed limiters for Visual Shader node enums
2021-08-14 10:38:22 +00:00
ERR_FAIL_INDEX(p_type, int(PORT_TYPE_MAX));
ERR_FAIL_COND(!is_valid_port_name(p_name));
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
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++;
}
String: Remove `erase` method, bindings can't mutate String
2021-11-11 08:08:08 +00:00
outputs = outputs.left(index) + outputs.substr(index + count);
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
outputs = outputs.insert(index, itos(i));
index += outputs_strings[i].size();
}
_apply_port_changes();
Fix expressions nodes in visual shaders
2020-09-22 19:54:30 +00:00
emit_changed();
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
}
void VisualShaderNodeGroupBase::remove_output_port(int p_id) {
Fix expression node crashes
2019-06-22 14:41:51 +00:00
ERR_FAIL_COND(!has_output_port(p_id));
Expression node for visual shaders
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();
}
String: Remove `erase` method, bindings can't mutate String
2021-11-11 08:08:08 +00:00
outputs = outputs.left(index) + outputs.substr(index + count);
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
outputs_strings = outputs.split(";", false);
Fix few bugs in visual shader expressions Fixed few bugs in visual shader expressions
2020-12-01 13:24:06 +00:00
outputs = outputs.substr(0, index);
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
for (int i = p_id; i < outputs_strings.size(); i++) {
Fix few bugs in visual shader expressions Fixed few bugs in visual shader expressions
2020-12-01 13:24:06 +00:00
outputs += outputs_strings[i].replace_first(outputs_strings[i].split(",")[0], itos(i)) + ";";
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
}
_apply_port_changes();
Fix expressions nodes in visual shaders
2020-09-22 19:54:30 +00:00
emit_changed();
Expression node for visual shaders
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) {
Fix expression node crashes
2019-06-22 14:41:51 +00:00
ERR_FAIL_COND(!has_input_port(p_id));
Added missed limiters for Visual Shader node enums
2021-08-14 10:38:22 +00:00
ERR_FAIL_INDEX(p_type, int(PORT_TYPE_MAX));
Fix expression node crashes
2019-06-22 14:41:51 +00:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (input_ports[p_id].type == p_type) {
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Expression node for visual shaders
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(",");
Fixes crash when shader inputs/outputs is invalid string
2019-12-10 09:03:27 +00:00
ERR_FAIL_COND(arr.size() != 3);
Expression node for visual shaders
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();
}
String: Remove `erase` method, bindings can't mutate String
2021-11-11 08:08:08 +00:00
inputs = inputs.left(index) + inputs.substr(index + count);
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
inputs = inputs.insert(index, itos(p_type));
_apply_port_changes();
Fix expressions nodes in visual shaders
2020-09-22 19:54:30 +00:00
emit_changed();
Expression node for visual shaders
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) {
Fix expression node crashes
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));
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (input_ports[p_id].name == p_name) {
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Expression node for visual shaders
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(",");
Fixes crash when shader inputs/outputs is invalid string
2019-12-10 09:03:27 +00:00
ERR_FAIL_COND(arr.size() != 3);
Expression node for visual shaders
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();
}
String: Remove `erase` method, bindings can't mutate String
2021-11-11 08:08:08 +00:00
inputs = inputs.left(index) + inputs.substr(index + count);
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
inputs = inputs.insert(index, p_name);
_apply_port_changes();
Fix expressions nodes in visual shaders
2020-09-22 19:54:30 +00:00
emit_changed();
Expression node for visual shaders
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) {
Fix expression node crashes
2019-06-22 14:41:51 +00:00
ERR_FAIL_COND(!has_output_port(p_id));
Added missed limiters for Visual Shader node enums
2021-08-14 10:38:22 +00:00
ERR_FAIL_INDEX(p_type, int(PORT_TYPE_MAX));
Fix expression node crashes
2019-06-22 14:41:51 +00:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (output_ports[p_id].type == p_type) {
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Expression node for visual shaders
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(",");
Fixes crash when shader inputs/outputs is invalid string
2019-12-10 09:03:27 +00:00
ERR_FAIL_COND(arr.size() != 3);
Expression node for visual shaders
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();
}
String: Remove `erase` method, bindings can't mutate String
2021-11-11 08:08:08 +00:00
outputs = outputs.left(index) + outputs.substr(index + count);
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
outputs = outputs.insert(index, itos(p_type));
_apply_port_changes();
Fix expressions nodes in visual shaders
2020-09-22 19:54:30 +00:00
emit_changed();
Expression node for visual shaders
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) {
Fix expression node crashes
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));
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (output_ports[p_id].name == p_name) {
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Expression node for visual shaders
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(",");
Fixes crash when shader inputs/outputs is invalid string
2019-12-10 09:03:27 +00:00
ERR_FAIL_COND(arr.size() != 3);
Expression node for visual shaders
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();
}
String: Remove `erase` method, bindings can't mutate String
2021-11-11 08:08:08 +00:00
outputs = outputs.left(index) + outputs.substr(index + count);
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
outputs = outputs.insert(index, p_name);
_apply_port_changes();
Fix expressions nodes in visual shaders
2020-09-22 19:54:30 +00:00
emit_changed();
Expression node for visual shaders
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();
}
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
void VisualShaderNodeGroupBase::set_ctrl_pressed(Control *p_control, int p_index) {
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
controls[p_index] = p_control;
}
Rename "Control" key to "Ctrl" and add "_pressed" suffix to all InputEventWithModifiers properties/methods
2021-04-24 20:33:50 +00:00
Control *VisualShaderNodeGroupBase::is_ctrl_pressed(int p_index) {
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
ERR_FAIL_COND_V(!controls.has(p_index), nullptr);
Expression node for visual shaders
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(",");
Fixes crash when shader inputs/outputs is invalid string
2019-12-10 09:03:27 +00:00
ERR_FAIL_COND(arr.size() != 3);
Expression node for visual shaders
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(",");
Fixes crash when shader inputs/outputs is invalid string
2019-12-10 09:03:27 +00:00
ERR_FAIL_COND(arr.size() != 3);
Expression node for visual shaders
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;
}
}
Added global expressions to visual shaders
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;
}
Expression node for visual shaders
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);
Fix expression node crashes
2019-06-22 14:41:51 +00:00
ClassDB::bind_method(D_METHOD("is_valid_port_name", "name"), &VisualShaderNodeGroupBase::is_valid_port_name);
Expression node for visual shaders
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);
doc: Sync classref with current source Fix a few missing bindings or unspecified argument names and default values.
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);
Expression node for visual shaders
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() {
Fix some broken visual shader nodes
2020-09-07 09:29:44 +00:00
simple_decl = false;
Expression node for visual shaders
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;
Fix expressions nodes in visual shaders
2020-09-22 19:54:30 +00:00
emit_changed();
Expression node for visual shaders
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");
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
_expression = _expression.replace("\n", "\n ");
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
static Vector<String> pre_symbols;
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
if (pre_symbols.is_empty()) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
pre_symbols.push_back(" ");
Allow comma prefix to visual shader's expression parser
2019-08-07 10:48:36 +00:00
pre_symbols.push_back(",");
Fix semicolon parsing in visual shader expression
2019-09-01 10:12:33 +00:00
pre_symbols.push_back(";");
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
pre_symbols.push_back("{");
pre_symbols.push_back("[");
Fix parsing array indexing symbol in visual shader expression
2019-09-04 13:00:18 +00:00
pre_symbols.push_back("]");
Expression node for visual shaders
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;
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
if (post_symbols.is_empty()) {
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
post_symbols.push_back(" ");
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
post_symbols.push_back("\n");
Fix visual shader expression parsing
2019-09-01 08:18:29 +00:00
post_symbols.push_back(",");
Fix few bugs in expression node
2019-05-21 15:37:31 +00:00
post_symbols.push_back(";");
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
post_symbols.push_back("}");
Fix parsing array indexing symbol in visual shader expression
2019-09-04 13:00:18 +00:00
post_symbols.push_back("[");
Expression node for visual shaders
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;
Add support for integer type in visual shaders
2020-02-25 14:50:49 +00:00
case PORT_TYPE_SCALAR_INT:
tk = "0";
break;
Add support for 2D vector type to visual shaders
2022-02-01 08:32:01 +00:00
case PORT_TYPE_VECTOR_2D:
tk = "vec2(0.0, 0.0)";
break;
Expression node for visual shaders
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;
}
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
output_initializer += " " + p_output_vars[i] + " = " + tk + ";\n";
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
}
String code;
code += output_initializer;
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += " {";
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
code += _expression;
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 06:06:51 +00:00
code += "\n }\n";
Expression node for visual shaders
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() {
Added global expressions to visual shaders
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);
Expression node for visual shaders
2019-05-12 12:09:39 +00:00
}