Stowage/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-11-04 07:31:16 +00:00
Code Issues Projects Releases Packages Wiki Activity
godot/servers/rendering/shader_language.cpp

9577 lines
308 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
/*************************************************************************/
/* shader_language.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 14:16:55 +02:00
/* https://godotengine.org */
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
/*************************************************************************/
Update copyright statements to 2022 Happy new year to the wonderful Godot community!
2022-01-03 21:27:34 +01:00
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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. */
/*************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-05 00:50:27 +01:00
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
#include "shader_language.h"
Make core/ includes absolute, remove subfolders from include path This allows more consistency in the manner we include core headers, where previously there would be a mix of absolute, relative and include path-dependent includes.
2018-09-11 18:13:45 +02:00
#include "core/os/os.h"
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 19:33:38 -03:00
#include "core/string/print_string.h"
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
#include "servers/rendering_server.h"
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 12:38:35 +03:00
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
#define HAS_WARNING(flag) (warning_flags & flag)
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
String ShaderLanguage::get_operator_text(Operator p_op) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
static const char *op_names[OP_MAX] = { "==",
"!=",
"<",
"<=",
">",
">=",
"&&",
"||",
"!",
"-",
"+",
"-",
"*",
"/",
"%",
"<<",
">>",
"=",
"+=",
"-=",
"*=",
"/=",
"%=",
"<<=",
">>=",
"&=",
"|=",
"^=",
"&",
"|",
"^",
"~",
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
"++",
"--",
"?",
":",
"++",
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
"--",
"()",
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
"construct",
Fix `^=` operator in shaders
2021-12-03 10:20:44 +03:00
"index",
"empty" };
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return op_names[p_op];
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
const char *ShaderLanguage::token_names[TK_MAX] = {
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
"EMPTY",
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
"IDENTIFIER",
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
"TRUE",
"FALSE",
"REAL_CONSTANT",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
"INT_CONSTANT",
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
"TYPE_VOID",
"TYPE_BOOL",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
"TYPE_BVEC2",
"TYPE_BVEC3",
"TYPE_BVEC4",
"TYPE_INT",
"TYPE_IVEC2",
"TYPE_IVEC3",
"TYPE_IVEC4",
"TYPE_UINT",
"TYPE_UVEC2",
"TYPE_UVEC3",
"TYPE_UVEC4",
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
"TYPE_FLOAT",
"TYPE_VEC2",
"TYPE_VEC3",
"TYPE_VEC4",
New Demo, Screen Space Shaders -Fixes to screen space shaders. -Fixes to isometric light demo.
2015-03-10 00:53:09 -03:00
"TYPE_MAT2",
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
"TYPE_MAT3",
"TYPE_MAT4",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
"TYPE_SAMPLER2D",
"TYPE_ISAMPLER2D",
"TYPE_USAMPLER2D",
add 3D textures
2018-06-26 13:59:26 +02:00
"TYPE_SAMPLER2DARRAY",
"TYPE_ISAMPLER2DARRAY",
"TYPE_USAMPLER2DARRAY",
"TYPE_SAMPLER3D",
"TYPE_ISAMPLER3D",
"TYPE_USAMPLER3D",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
"TYPE_SAMPLERCUBE",
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 09:34:23 -03:00
"TYPE_SAMPLERCUBEARRAY",
Make the shader token names consistent.
2018-03-07 23:56:47 +00:00
"INTERPOLATION_FLAT",
"INTERPOLATION_SMOOTH",
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
"CONST",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
"PRECISION_LOW",
"PRECISION_MID",
"PRECISION_HIGH",
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
"OP_EQUAL",
"OP_NOT_EQUAL",
"OP_LESS",
"OP_LESS_EQUAL",
"OP_GREATER",
"OP_GREATER_EQUAL",
"OP_AND",
"OP_OR",
"OP_NOT",
"OP_ADD",
"OP_SUB",
"OP_MUL",
"OP_DIV",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
"OP_MOD",
"OP_SHIFT_LEFT",
"OP_SHIFT_RIGHT",
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
"OP_ASSIGN",
"OP_ASSIGN_ADD",
"OP_ASSIGN_SUB",
"OP_ASSIGN_MUL",
"OP_ASSIGN_DIV",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
"OP_ASSIGN_MOD",
"OP_ASSIGN_SHIFT_LEFT",
"OP_ASSIGN_SHIFT_RIGHT",
"OP_ASSIGN_BIT_AND",
"OP_ASSIGN_BIT_OR",
"OP_ASSIGN_BIT_XOR",
"OP_BIT_AND",
"OP_BIT_OR",
"OP_BIT_XOR",
"OP_BIT_INVERT",
"OP_INCREMENT",
"OP_DECREMENT",
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
"CF_IF",
"CF_ELSE",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
"CF_FOR",
"CF_WHILE",
"CF_DO",
"CF_SWITCH",
"CF_CASE",
"CF_BREAK",
"CF_CONTINUE",
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
"CF_RETURN",
removed DISCARD built in variable, replaced by actual discard GLSL instruction, fixes #9677
2017-08-29 10:14:07 -03:00
"CF_DISCARD",
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
"BRACKET_OPEN",
"BRACKET_CLOSE",
"CURLY_BRACKET_OPEN",
"CURLY_BRACKET_CLOSE",
"PARENTHESIS_OPEN",
"PARENTHESIS_CLOSE",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
"QUESTION",
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
"COMMA",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
"COLON",
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
"SEMICOLON",
"PERIOD",
"UNIFORM",
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
"INSTANCE",
"GLOBAL",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
"VARYING",
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
"IN",
"OUT",
"INOUT",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
"RENDER_MODE",
"HINT_WHITE_TEXTURE",
"HINT_BLACK_TEXTURE",
"HINT_NORMAL_TEXTURE",
Rename `hint_aniso` to `hint_anisotropy` in the shader language The word "anisotropy" is used in full form in BaseMaterial3D's anisotropy-related properties.
2021-12-09 20:29:06 +01:00
"HINT_ANISOTROPY_TEXTURE",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
"HINT_ALBEDO_TEXTURE",
Huge amount of improvement in the material system. Materials should be a lot more complete and usable now.
2016-11-20 22:49:53 -03:00
"HINT_BLACK_ALBEDO_TEXTURE",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
"HINT_COLOR",
"HINT_RANGE",
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
"HINT_INSTANCE_INDEX",
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
"FILTER_NEAREST",
"FILTER_LINEAR",
"FILTER_NEAREST_MIPMAP",
"FILTER_LINEAR_MIPMAP",
Rename shader hint `filter_anisotropy` to `filter_anisotropic`
2021-12-15 22:12:38 +03:00
"FILTER_NEAREST_MIPMAP_ANISOTROPIC",
"FILTER_LINEAR_MIPMAP_ANISOTROPIC",
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
"REPEAT_ENABLE",
"REPEAT_DISABLE",
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
"SHADER_TYPE",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
"CURSOR",
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
"ERROR",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
"EOF",
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
};
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
String ShaderLanguage::get_token_text(Token p_token) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
String name = token_names[p_token.type];
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
if (p_token.is_integer_constant() || p_token.type == TK_FLOAT_CONSTANT) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
name += "(" + rtos(p_token.constant) + ")";
} else if (p_token.type == TK_IDENTIFIER) {
name += "(" + String(p_token.text) + ")";
} else if (p_token.type == TK_ERROR) {
name += "(" + String(p_token.text) + ")";
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return name;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ShaderLanguage::Token ShaderLanguage::_make_token(TokenType p_type, const StringName &p_text) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Token tk;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
tk.type = p_type;
tk.text = p_text;
tk.line = tk_line;
if (tk.type == TK_ERROR) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
_set_error(p_text);
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return tk;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
const ShaderLanguage::KeyWord ShaderLanguage::keyword_list[] = {
{ TK_TRUE, "true" },
{ TK_FALSE, "false" },
{ TK_TYPE_VOID, "void" },
{ TK_TYPE_BOOL, "bool" },
{ TK_TYPE_BVEC2, "bvec2" },
{ TK_TYPE_BVEC3, "bvec3" },
{ TK_TYPE_BVEC4, "bvec4" },
{ TK_TYPE_INT, "int" },
{ TK_TYPE_IVEC2, "ivec2" },
{ TK_TYPE_IVEC3, "ivec3" },
{ TK_TYPE_IVEC4, "ivec4" },
{ TK_TYPE_UINT, "uint" },
{ TK_TYPE_UVEC2, "uvec2" },
{ TK_TYPE_UVEC3, "uvec3" },
{ TK_TYPE_UVEC4, "uvec4" },
{ TK_TYPE_FLOAT, "float" },
{ TK_TYPE_VEC2, "vec2" },
{ TK_TYPE_VEC3, "vec3" },
{ TK_TYPE_VEC4, "vec4" },
{ TK_TYPE_MAT2, "mat2" },
{ TK_TYPE_MAT3, "mat3" },
{ TK_TYPE_MAT4, "mat4" },
{ TK_TYPE_SAMPLER2D, "sampler2D" },
{ TK_TYPE_ISAMPLER2D, "isampler2D" },
{ TK_TYPE_USAMPLER2D, "usampler2D" },
add 3D textures
2018-06-26 13:59:26 +02:00
{ TK_TYPE_SAMPLER2DARRAY, "sampler2DArray" },
{ TK_TYPE_ISAMPLER2DARRAY, "isampler2DArray" },
{ TK_TYPE_USAMPLER2DARRAY, "usampler2DArray" },
{ TK_TYPE_SAMPLER3D, "sampler3D" },
{ TK_TYPE_ISAMPLER3D, "isampler3D" },
{ TK_TYPE_USAMPLER3D, "usampler3D" },
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
{ TK_TYPE_SAMPLERCUBE, "samplerCube" },
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 09:34:23 -03:00
{ TK_TYPE_SAMPLERCUBEARRAY, "samplerCubeArray" },
Added interpolation modifiers to shaderlang
2017-11-27 16:47:46 +01:00
{ TK_INTERPOLATION_FLAT, "flat" },
{ TK_INTERPOLATION_SMOOTH, "smooth" },
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
{ TK_CONST, "const" },
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
{ TK_STRUCT, "struct" },
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
{ TK_PRECISION_LOW, "lowp" },
{ TK_PRECISION_MID, "mediump" },
{ TK_PRECISION_HIGH, "highp" },
{ TK_CF_IF, "if" },
{ TK_CF_ELSE, "else" },
{ TK_CF_FOR, "for" },
{ TK_CF_WHILE, "while" },
{ TK_CF_DO, "do" },
{ TK_CF_SWITCH, "switch" },
{ TK_CF_CASE, "case" },
Implements switch to shaders
2019-08-14 14:22:25 +03:00
{ TK_CF_DEFAULT, "default" },
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
{ TK_CF_BREAK, "break" },
{ TK_CF_CONTINUE, "continue" },
{ TK_CF_RETURN, "return" },
Discarding now works in shaders "discard" has been added to the list of recognised keywords. A flag specifing when discarding is allowed is now set correctly.
2017-09-24 01:27:12 -06:00
{ TK_CF_DISCARD, "discard" },
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
{ TK_UNIFORM, "uniform" },
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
{ TK_INSTANCE, "instance" },
{ TK_GLOBAL, "global" },
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
{ TK_VARYING, "varying" },
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
{ TK_ARG_IN, "in" },
{ TK_ARG_OUT, "out" },
{ TK_ARG_INOUT, "inout" },
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
{ TK_RENDER_MODE, "render_mode" },
{ TK_HINT_WHITE_TEXTURE, "hint_white" },
{ TK_HINT_BLACK_TEXTURE, "hint_black" },
{ TK_HINT_NORMAL_TEXTURE, "hint_normal" },
Several fixes to 3D rendering, and multimesh implementation.
2019-09-14 00:37:42 -03:00
{ TK_HINT_ROUGHNESS_NORMAL_TEXTURE, "hint_roughness_normal" },
{ TK_HINT_ROUGHNESS_R, "hint_roughness_r" },
{ TK_HINT_ROUGHNESS_G, "hint_roughness_g" },
{ TK_HINT_ROUGHNESS_B, "hint_roughness_b" },
{ TK_HINT_ROUGHNESS_A, "hint_roughness_a" },
{ TK_HINT_ROUGHNESS_GRAY, "hint_roughness_gray" },
Rename `hint_aniso` to `hint_anisotropy` in the shader language The word "anisotropy" is used in full form in BaseMaterial3D's anisotropy-related properties.
2021-12-09 20:29:06 +01:00
{ TK_HINT_ANISOTROPY_TEXTURE, "hint_anisotropy" },
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
{ TK_HINT_ALBEDO_TEXTURE, "hint_albedo" },
{ TK_HINT_BLACK_ALBEDO_TEXTURE, "hint_black_albedo" },
{ TK_HINT_COLOR, "hint_color" },
{ TK_HINT_RANGE, "hint_range" },
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
{ TK_HINT_INSTANCE_INDEX, "instance_index" },
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
{ TK_FILTER_NEAREST, "filter_nearest" },
{ TK_FILTER_LINEAR, "filter_linear" },
{ TK_FILTER_NEAREST_MIPMAP, "filter_nearest_mipmap" },
{ TK_FILTER_LINEAR_MIPMAP, "filter_linear_mipmap" },
Rename shader hint `filter_anisotropy` to `filter_anisotropic`
2021-12-15 22:12:38 +03:00
{ TK_FILTER_NEAREST_MIPMAP_ANISOTROPIC, "filter_nearest_mipmap_anisotropic" },
{ TK_FILTER_LINEAR_MIPMAP_ANISOTROPIC, "filter_linear_mipmap_anisotropic" },
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
{ TK_REPEAT_ENABLE, "repeat_enable" },
{ TK_REPEAT_DISABLE, "repeat_disable" },
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
{ TK_SHADER_TYPE, "shader_type" },
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
{ TK_ERROR, nullptr }
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
};
-Fixed shader commets, /* */ works well and crash is solved, fixes #1711
2015-04-26 12:34:42 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
ShaderLanguage::Token ShaderLanguage::_get_token() {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
#define GETCHAR(m_idx) (((char_idx + m_idx) < code.length()) ? code[char_idx + m_idx] : char32_t(0))
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (true) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
switch (GETCHAR(-1)) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
case 0:
return _make_token(TK_EOF);
case 0xFFFF:
return _make_token(TK_CURSOR); //for completion
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
case '\t':
case '\r':
case ' ':
continue;
case '\n':
tk_line++;
continue;
case '/': {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
switch (GETCHAR(0)) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
case '*': { // block comment
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (true) {
if (GETCHAR(0) == 0) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return _make_token(TK_EOF);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
}
if (GETCHAR(0) == '*' && GETCHAR(1) == '/') {
char_idx += 2;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
break;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (GETCHAR(0) == '\n') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk_line++;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
case '/': { // line comment skip
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (true) {
if (GETCHAR(0) == '\n') {
Fixed wrong highlighted line when erroring and using single-line comments, fixes #15167
2017-12-29 19:32:21 +01:00
tk_line++;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
break;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (GETCHAR(0) == 0) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return _make_token(TK_EOF);
}
char_idx++;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
case '=': { // diveq
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_ASSIGN_DIV);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
default:
return _make_token(TK_OP_DIV);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
continue; //a comment, continue to next token
} break;
case '=': {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (GETCHAR(0) == '=') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_EQUAL);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return _make_token(TK_OP_ASSIGN);
} break;
case '<': {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (GETCHAR(0) == '=') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_LESS_EQUAL);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (GETCHAR(0) == '<') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (GETCHAR(0) == '=') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_ASSIGN_SHIFT_LEFT);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return _make_token(TK_OP_SHIFT_LEFT);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return _make_token(TK_OP_LESS);
} break;
case '>': {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (GETCHAR(0) == '=') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_GREATER_EQUAL);
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
} else if (GETCHAR(0) == '>') {
Style: Fix statements ending with ';;'
2017-01-14 18:03:38 +01:00
char_idx++;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (GETCHAR(0) == '=') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_ASSIGN_SHIFT_RIGHT);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return _make_token(TK_OP_SHIFT_RIGHT);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return _make_token(TK_OP_GREATER);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
case '!': {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (GETCHAR(0) == '=') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_NOT_EQUAL);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return _make_token(TK_OP_NOT);
} break;
//case '"' //string - no strings in shader
//case '\'' //string - no strings in shader
case '{':
return _make_token(TK_CURLY_BRACKET_OPEN);
case '}':
return _make_token(TK_CURLY_BRACKET_CLOSE);
case '[':
return _make_token(TK_BRACKET_OPEN);
case ']':
return _make_token(TK_BRACKET_CLOSE);
case '(':
return _make_token(TK_PARENTHESIS_OPEN);
case ')':
return _make_token(TK_PARENTHESIS_CLOSE);
case ',':
return _make_token(TK_COMMA);
case ';':
return _make_token(TK_SEMICOLON);
case '?':
return _make_token(TK_QUESTION);
case ':':
return _make_token(TK_COLON);
case '^':
Fix `^=` operator in shaders
2021-12-03 10:20:44 +03:00
if (GETCHAR(0) == '=') {
char_idx++;
return _make_token(TK_OP_ASSIGN_BIT_XOR);
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return _make_token(TK_OP_BIT_XOR);
case '~':
return _make_token(TK_OP_BIT_INVERT);
case '&': {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (GETCHAR(0) == '=') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_ASSIGN_BIT_AND);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (GETCHAR(0) == '&') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_AND);
}
return _make_token(TK_OP_BIT_AND);
} break;
case '|': {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (GETCHAR(0) == '=') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_ASSIGN_BIT_OR);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (GETCHAR(0) == '|') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_OR);
}
return _make_token(TK_OP_BIT_OR);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
case '*': {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (GETCHAR(0) == '=') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_ASSIGN_MUL);
}
return _make_token(TK_OP_MUL);
} break;
case '+': {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (GETCHAR(0) == '=') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_ASSIGN_ADD);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (GETCHAR(0) == '+') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_INCREMENT);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return _make_token(TK_OP_ADD);
} break;
case '-': {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (GETCHAR(0) == '=') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_ASSIGN_SUB);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (GETCHAR(0) == '-') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_DECREMENT);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return _make_token(TK_OP_SUB);
} break;
case '%': {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (GETCHAR(0) == '=') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
return _make_token(TK_OP_ASSIGN_MOD);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return _make_token(TK_OP_MOD);
} break;
default: {
char_idx--; //go back one, since we have no idea what this is
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Cleanup and move char functions to the `char_utils.h` header.
2022-02-04 10:32:20 +02:00
if (is_digit(GETCHAR(0)) || (GETCHAR(0) == '.' && is_digit(GETCHAR(1)))) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
// parse number
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
bool hexa_found = false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool period_found = false;
bool exponent_found = false;
* Small hex/float/integer parsing refactoring * Potential bug fix on hex (cannot be used atm) * Added optional typing for floats, eg: "1f" -> "1.0" "1.f" -> "1.0" "1.99f" -> "1.99" "1." -> "1.0"
2018-07-14 13:28:43 +02:00
bool float_suffix_found = false;
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
bool uint_suffix_found = false;
bool end_suffix_found = false;
enum {
CASE_ALL,
CASE_HEXA_PERIOD,
CASE_EXPONENT,
CASE_SIGN_AFTER_EXPONENT,
CASE_NONE,
CASE_MAX,
} lut_case = CASE_ALL;
static bool suffix_lut[CASE_MAX][127];
if (!is_const_suffix_lut_initialized) {
is_const_suffix_lut_initialized = true;
for (int i = 0; i < 127; i++) {
char t = char(i);
suffix_lut[CASE_ALL][i] = t == '.' || t == 'x' || t == 'e' || t == 'f' || t == 'u' || t == '-' || t == '+';
suffix_lut[CASE_HEXA_PERIOD][i] = t == 'e' || t == 'f';
suffix_lut[CASE_EXPONENT][i] = t == 'f' || t == '-' || t == '+';
suffix_lut[CASE_SIGN_AFTER_EXPONENT][i] = t == 'f';
suffix_lut[CASE_NONE][i] = false;
}
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
String str;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
int i = 0;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (true) {
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
const char32_t symbol = String::char_lowercase(GETCHAR(i));
bool error = false;
Cleanup and move char functions to the `char_utils.h` header.
2022-02-04 10:32:20 +02:00
if (is_digit(symbol)) {
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
if (end_suffix_found) {
error = true;
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 16:41:43 +02:00
}
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
} else {
if (symbol < 0x7F && suffix_lut[lut_case][symbol]) {
if (symbol == 'x') {
hexa_found = true;
lut_case = CASE_HEXA_PERIOD;
} else if (symbol == '.') {
period_found = true;
lut_case = CASE_HEXA_PERIOD;
} else if (symbol == 'e' && !hexa_found) {
exponent_found = true;
lut_case = CASE_EXPONENT;
} else if (symbol == 'f' && !hexa_found) {
if (!period_found && !exponent_found) {
error = true;
}
float_suffix_found = true;
end_suffix_found = true;
lut_case = CASE_NONE;
} else if (symbol == 'u') {
uint_suffix_found = true;
end_suffix_found = true;
lut_case = CASE_NONE;
} else if (symbol == '-' || symbol == '+') {
if (exponent_found) {
lut_case = CASE_SIGN_AFTER_EXPONENT;
} else {
break;
}
}
Cleanup and move char functions to the `char_utils.h` header.
2022-02-04 10:32:20 +02:00
} else if (!hexa_found || !is_hex_digit(symbol)) {
if (is_ascii_identifier_char(symbol)) {
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
error = true;
} else {
break;
}
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 16:41:43 +02:00
}
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
}
if (error) {
if (hexa_found) {
return _make_token(TK_ERROR, "Invalid (hexadecimal) numeric constant");
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 16:41:43 +02:00
}
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
if (period_found || exponent_found || float_suffix_found) {
return _make_token(TK_ERROR, "Invalid (float) numeric constant");
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 16:41:43 +02:00
}
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
if (uint_suffix_found) {
return _make_token(TK_ERROR, "Invalid (unsigned integer) numeric constant");
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 16:41:43 +02:00
}
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
return _make_token(TK_ERROR, "Invalid (integer) numeric constant");
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 16:41:43 +02:00
}
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
str += symbol;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
i++;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
char32_t last_char = str[str.length() - 1];
* Small hex/float/integer parsing refactoring * Potential bug fix on hex (cannot be used atm) * Added optional typing for floats, eg: "1f" -> "1.0" "1.f" -> "1.0" "1.99f" -> "1.99" "1." -> "1.0"
2018-07-14 13:28:43 +02:00
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
if (hexa_found) { // Integer(hex)
Support for hex numbers in shaders
2019-12-29 12:19:10 +03:00
if (str.size() > 11 || !str.is_valid_hex_number(true)) { // > 0xFFFFFFFF
return _make_token(TK_ERROR, "Invalid (hexadecimal) numeric constant");
}
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
} else if (period_found || exponent_found || float_suffix_found) { // Float
Cleanup and move char functions to the `char_utils.h` header.
2022-02-04 10:32:20 +02:00
if (exponent_found && (!is_digit(last_char) && last_char != 'f')) { // checks for eg: "2E", "2E-", "2E+"
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
return _make_token(TK_ERROR, "Invalid (float) numeric constant");
}
* Small hex/float/integer parsing refactoring * Potential bug fix on hex (cannot be used atm) * Added optional typing for floats, eg: "1f" -> "1.0" "1.f" -> "1.0" "1.99f" -> "1.99" "1." -> "1.0"
2018-07-14 13:28:43 +02:00
if (period_found) {
if (float_suffix_found) {
//checks for eg "1.f" or "1.99f" notations
if (last_char != 'f') {
return _make_token(TK_ERROR, "Invalid (float) numeric constant");
}
} else {
//checks for eg. "1." or "1.99" notations
Cleanup and move char functions to the `char_utils.h` header.
2022-02-04 10:32:20 +02:00
if (last_char != '.' && !is_digit(last_char)) {
* Small hex/float/integer parsing refactoring * Potential bug fix on hex (cannot be used atm) * Added optional typing for floats, eg: "1f" -> "1.0" "1.f" -> "1.0" "1.99f" -> "1.99" "1." -> "1.0"
2018-07-14 13:28:43 +02:00
return _make_token(TK_ERROR, "Invalid (float) numeric constant");
}
}
} else if (float_suffix_found) {
// if no period found the float suffix must be the last character, like in "2f" for "2.0"
if (last_char != 'f') {
return _make_token(TK_ERROR, "Invalid (float) numeric constant");
}
}
if (float_suffix_found) {
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
// Strip the suffix.
* Small hex/float/integer parsing refactoring * Potential bug fix on hex (cannot be used atm) * Added optional typing for floats, eg: "1f" -> "1.0" "1.f" -> "1.0" "1.99f" -> "1.99" "1." -> "1.0"
2018-07-14 13:28:43 +02:00
str = str.left(str.length() - 1);
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
// Compensate reading cursor position.
* Small hex/float/integer parsing refactoring * Potential bug fix on hex (cannot be used atm) * Added optional typing for floats, eg: "1f" -> "1.0" "1.f" -> "1.0" "1.99f" -> "1.99" "1." -> "1.0"
2018-07-14 13:28:43 +02:00
char_idx += 1;
}
if (!str.is_valid_float()) {
return _make_token(TK_ERROR, "Invalid (float) numeric constant");
}
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
} else { // Integer
if (uint_suffix_found) {
// Strip the suffix.
str = str.left(str.length() - 1);
// Compensate reading cursor position.
char_idx += 1;
* Small hex/float/integer parsing refactoring * Potential bug fix on hex (cannot be used atm) * Added optional typing for floats, eg: "1f" -> "1.0" "1.f" -> "1.0" "1.99f" -> "1.99" "1." -> "1.0"
2018-07-14 13:28:43 +02:00
}
Rename `is_valid_integer()` to `is_valid_int()` Method from `String`
2021-06-16 10:24:34 -06:00
if (!str.is_valid_int()) {
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
if (uint_suffix_found) {
Fix various typos Found via ` codespell -q 3 -S ./thirdparty,*.po,./DONORS.md -L ackward,ang,ans,ba,beng,cas,childs,childrens,dof,doubleclick,expct,fave,findn,gird,hist,inout,leapyear,lod,nd,numer,ois,ony,paket,seeked,sinc,switchs,te,uint,varn` Update editor/import/resource_importer_layered_texture.cpp Co-authored-by: Raul Santos <raulsntos@gmail.com> Update doc/classes/TileSetScenesCollectionSource.xml Co-authored-by: Raul Santos <raulsntos@gmail.com> Update scene/gui/graph_edit.cpp Co-authored-by: Raul Santos <raulsntos@gmail.com> Update scene/resources/animation.cpp Co-authored-by: Raul Santos <raulsntos@gmail.com> Update scene/resources/animation.cpp Co-authored-by: Raul Santos <raulsntos@gmail.com> Update scene/resources/animation.cpp Co-authored-by: Raul Santos <raulsntos@gmail.com> Update scene/gui/rich_text_label.cpp Co-authored-by: Raul Santos <raulsntos@gmail.com> Revert previously committed change
2022-01-02 01:03:58 -05:00
return _make_token(TK_ERROR, "Invalid (unsigned integer) numeric constant");
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
} else {
return _make_token(TK_ERROR, "Invalid (integer) numeric constant");
}
* Small hex/float/integer parsing refactoring * Potential bug fix on hex (cannot be used atm) * Added optional typing for floats, eg: "1f" -> "1.0" "1.f" -> "1.0" "1.99f" -> "1.99" "1." -> "1.0"
2018-07-14 13:28:43 +02:00
}
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
char_idx += str.length();
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Token tk;
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 16:41:43 +02:00
if (period_found || exponent_found || float_suffix_found) {
Rename TYPE_REAL to TYPE_FLOAT To be consistent with the naming everywhere else.
2020-12-04 09:25:14 -03:00
tk.type = TK_FLOAT_CONSTANT;
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
} else if (uint_suffix_found) {
tk.type = TK_UINT_CONSTANT;
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 16:41:43 +02:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
tk.type = TK_INT_CONSTANT;
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 16:41:43 +02:00
}
New Demo, Screen Space Shaders -Fixes to screen space shaders. -Fixes to isometric light demo.
2015-03-10 00:53:09 -03:00
Support for hex numbers in shaders
2019-12-29 12:19:10 +03:00
if (hexa_found) {
Make hex_to_int and bin_to_int handle the prefix automatically Also add BinToInt to C#
2021-01-28 07:39:05 -05:00
tk.constant = (double)str.hex_to_int();
Support for hex numbers in shaders
2019-12-29 12:19:10 +03:00
} else {
Make all String float conversion methods be 64-bit
2020-07-24 14:07:57 -04:00
tk.constant = str.to_float();
Support for hex numbers in shaders
2019-12-29 12:19:10 +03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
tk.line = tk_line;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return tk;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (GETCHAR(0) == '.') {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
//parse period
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
char_idx++;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return _make_token(TK_PERIOD);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Cleanup and move char functions to the `char_utils.h` header.
2022-02-04 10:32:20 +02:00
if (is_ascii_identifier_char(GETCHAR(0))) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
// parse identifier
String str;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Cleanup and move char functions to the `char_utils.h` header.
2022-02-04 10:32:20 +02:00
while (is_ascii_identifier_char(GETCHAR(0))) {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
str += char32_t(GETCHAR(0));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
char_idx++;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
//see if keyword
//should be converted to a static map
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
int idx = 0;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (keyword_list[idx].text) {
if (str == keyword_list[idx].text) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return _make_token(keyword_list[idx].token);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
idx++;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Prevent shader crash when name conflict with "dus" and "__" occured
2020-02-01 12:34:02 +03:00
str = str.replace("dus_", "_");
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
return _make_token(TK_IDENTIFIER, str);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 16:41:43 +02:00
if (GETCHAR(0) > 32) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
return _make_token(TK_ERROR, "Tokenizer: Unknown character #" + itos(GETCHAR(0)) + ": '" + String::chr(GETCHAR(0)) + "'");
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 16:41:43 +02:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
return _make_token(TK_ERROR, "Tokenizer: Unknown character #" + itos(GETCHAR(0)));
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 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
ERR_PRINT("BUG");
return Token();
allow comments and whitespace before shader_type declaration
2018-01-24 19:00:51 -06:00
#undef GETCHAR
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
String ShaderLanguage::token_debug(const String &p_code) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
clear();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
code = p_code;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
String output;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
Token tk = _get_token();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (tk.type != TK_EOF && tk.type != TK_ERROR) {
output += itos(tk_line) + ": " + get_token_text(tk) + "\n";
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return output;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Do not allow samplers where they dont belong (variables/return types), fixes #15133
2018-11-12 08:36:26 -03:00
bool ShaderLanguage::is_token_variable_datatype(TokenType p_type) {
return (
p_type == TK_TYPE_VOID ||
p_type == TK_TYPE_BOOL ||
p_type == TK_TYPE_BVEC2 ||
p_type == TK_TYPE_BVEC3 ||
p_type == TK_TYPE_BVEC4 ||
p_type == TK_TYPE_INT ||
p_type == TK_TYPE_IVEC2 ||
p_type == TK_TYPE_IVEC3 ||
p_type == TK_TYPE_IVEC4 ||
p_type == TK_TYPE_UINT ||
p_type == TK_TYPE_UVEC2 ||
p_type == TK_TYPE_UVEC3 ||
p_type == TK_TYPE_UVEC4 ||
p_type == TK_TYPE_FLOAT ||
p_type == TK_TYPE_VEC2 ||
p_type == TK_TYPE_VEC3 ||
p_type == TK_TYPE_VEC4 ||
p_type == TK_TYPE_MAT2 ||
p_type == TK_TYPE_MAT3 ||
p_type == TK_TYPE_MAT4);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
bool ShaderLanguage::is_token_datatype(TokenType p_type) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return (
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
p_type == TK_TYPE_VOID ||
p_type == TK_TYPE_BOOL ||
p_type == TK_TYPE_BVEC2 ||
p_type == TK_TYPE_BVEC3 ||
p_type == TK_TYPE_BVEC4 ||
p_type == TK_TYPE_INT ||
p_type == TK_TYPE_IVEC2 ||
p_type == TK_TYPE_IVEC3 ||
p_type == TK_TYPE_IVEC4 ||
p_type == TK_TYPE_UINT ||
p_type == TK_TYPE_UVEC2 ||
p_type == TK_TYPE_UVEC3 ||
p_type == TK_TYPE_UVEC4 ||
p_type == TK_TYPE_FLOAT ||
p_type == TK_TYPE_VEC2 ||
p_type == TK_TYPE_VEC3 ||
p_type == TK_TYPE_VEC4 ||
p_type == TK_TYPE_MAT2 ||
p_type == TK_TYPE_MAT3 ||
p_type == TK_TYPE_MAT4 ||
p_type == TK_TYPE_SAMPLER2D ||
p_type == TK_TYPE_ISAMPLER2D ||
p_type == TK_TYPE_USAMPLER2D ||
add 3D textures
2018-06-26 13:59:26 +02:00
p_type == TK_TYPE_SAMPLER2DARRAY ||
p_type == TK_TYPE_ISAMPLER2DARRAY ||
p_type == TK_TYPE_USAMPLER2DARRAY ||
p_type == TK_TYPE_SAMPLER3D ||
p_type == TK_TYPE_ISAMPLER3D ||
p_type == TK_TYPE_USAMPLER3D ||
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 09:34:23 -03:00
p_type == TK_TYPE_SAMPLERCUBE ||
p_type == TK_TYPE_SAMPLERCUBEARRAY);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
ShaderLanguage::DataType ShaderLanguage::get_token_datatype(TokenType p_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
return DataType(p_type - TK_TYPE_VOID);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Added interpolation modifiers to shaderlang
2017-11-27 16:47:46 +01:00
bool ShaderLanguage::is_token_interpolation(TokenType p_type) {
return (
p_type == TK_INTERPOLATION_FLAT ||
p_type == TK_INTERPOLATION_SMOOTH);
}
ShaderLanguage::DataInterpolation ShaderLanguage::get_token_interpolation(TokenType 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 16:41:43 +02:00
if (p_type == TK_INTERPOLATION_FLAT) {
Added interpolation modifiers to shaderlang
2017-11-27 16:47:46 +01:00
return INTERPOLATION_FLAT;
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 16:41:43 +02:00
} else {
Added interpolation modifiers to shaderlang
2017-11-27 16:47:46 +01:00
return INTERPOLATION_SMOOTH;
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 16:41:43 +02:00
}
Added interpolation modifiers to shaderlang
2017-11-27 16:47:46 +01:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
bool ShaderLanguage::is_token_precision(TokenType p_type) {
return (
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
p_type == TK_PRECISION_LOW ||
p_type == TK_PRECISION_MID ||
p_type == TK_PRECISION_HIGH);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
ShaderLanguage::DataPrecision ShaderLanguage::get_token_precision(TokenType 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 16:41:43 +02:00
if (p_type == TK_PRECISION_LOW) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return PRECISION_LOWP;
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 16:41:43 +02:00
} else if (p_type == TK_PRECISION_HIGH) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return PRECISION_HIGHP;
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 16:41:43 +02:00
} else {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return PRECISION_MEDIUMP;
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 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Added local array initializer
2019-07-15 18:47:22 +03:00
String ShaderLanguage::get_precision_name(DataPrecision p_type) {
switch (p_type) {
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
case PRECISION_LOWP:
return "lowp";
case PRECISION_MEDIUMP:
return "mediump";
case PRECISION_HIGHP:
return "highp";
Added local array initializer
2019-07-15 18:47:22 +03:00
default:
break;
}
return "";
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
String ShaderLanguage::get_datatype_name(DataType p_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
switch (p_type) {
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
case TYPE_VOID:
return "void";
case TYPE_BOOL:
return "bool";
case TYPE_BVEC2:
return "bvec2";
case TYPE_BVEC3:
return "bvec3";
case TYPE_BVEC4:
return "bvec4";
case TYPE_INT:
return "int";
case TYPE_IVEC2:
return "ivec2";
case TYPE_IVEC3:
return "ivec3";
case TYPE_IVEC4:
return "ivec4";
case TYPE_UINT:
return "uint";
case TYPE_UVEC2:
return "uvec2";
case TYPE_UVEC3:
return "uvec3";
case TYPE_UVEC4:
return "uvec4";
case TYPE_FLOAT:
return "float";
case TYPE_VEC2:
return "vec2";
case TYPE_VEC3:
return "vec3";
case TYPE_VEC4:
return "vec4";
case TYPE_MAT2:
return "mat2";
case TYPE_MAT3:
return "mat3";
case TYPE_MAT4:
return "mat4";
case TYPE_SAMPLER2D:
return "sampler2D";
case TYPE_ISAMPLER2D:
return "isampler2D";
case TYPE_USAMPLER2D:
return "usampler2D";
case TYPE_SAMPLER2DARRAY:
return "sampler2DArray";
case TYPE_ISAMPLER2DARRAY:
return "isampler2DArray";
case TYPE_USAMPLER2DARRAY:
return "usampler2DArray";
case TYPE_SAMPLER3D:
return "sampler3D";
case TYPE_ISAMPLER3D:
return "isampler3D";
case TYPE_USAMPLER3D:
return "usampler3D";
case TYPE_SAMPLERCUBE:
return "samplerCube";
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 09:34:23 -03:00
case TYPE_SAMPLERCUBEARRAY:
return "samplerCubeArray";
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
case TYPE_STRUCT:
return "struct";
case TYPE_MAX:
return "invalid";
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
return "";
}
bool ShaderLanguage::is_token_nonvoid_datatype(TokenType p_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
return is_token_datatype(p_type) && p_type != TK_TYPE_VOID;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
void ShaderLanguage::clear() {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
current_function = StringName();
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
last_name = StringName();
last_type = IDENTIFIER_MAX;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
completion_type = COMPLETION_NONE;
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
completion_block = nullptr;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
completion_function = StringName();
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
completion_class = TAG_GLOBAL;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
completion_struct = StringName();
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
completion_base = TYPE_VOID;
completion_base_array = false;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
#ifdef DEBUG_ENABLED
used_constants.clear();
used_varyings.clear();
used_uniforms.clear();
used_functions.clear();
used_structs.clear();
Added a shader warning about unused local variable
2021-06-29 14:34:54 +03:00
used_local_vars.clear();
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
warnings.clear();
#endif // DEBUG_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
error_line = 0;
tk_line = 1;
char_idx = 0;
error_set = false;
error_str = "";
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
last_const = false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (nodes) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Node *n = nodes;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
nodes = nodes->next;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
memdelete(n);
}
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
#ifdef DEBUG_ENABLED
Added a shader warning about unused local variable
2021-06-29 14:34:54 +03:00
void ShaderLanguage::_parse_used_identifier(const StringName &p_identifier, IdentifierType p_type, const StringName &p_function) {
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
switch (p_type) {
case IdentifierType::IDENTIFIER_CONSTANT:
if (HAS_WARNING(ShaderWarning::UNUSED_CONSTANT_FLAG) && used_constants.has(p_identifier)) {
used_constants[p_identifier].used = true;
}
break;
case IdentifierType::IDENTIFIER_VARYING:
if (HAS_WARNING(ShaderWarning::UNUSED_VARYING_FLAG) && used_varyings.has(p_identifier)) {
Prevent error if varying assigned but not used (push warning instead)
2021-07-15 18:05:41 +03:00
if (shader->varyings[p_identifier].stage != ShaderNode::Varying::STAGE_VERTEX && shader->varyings[p_identifier].stage != ShaderNode::Varying::STAGE_FRAGMENT) {
used_varyings[p_identifier].used = true;
}
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
}
break;
case IdentifierType::IDENTIFIER_UNIFORM:
if (HAS_WARNING(ShaderWarning::UNUSED_UNIFORM_FLAG) && used_uniforms.has(p_identifier)) {
used_uniforms[p_identifier].used = true;
}
break;
case IdentifierType::IDENTIFIER_FUNCTION:
if (HAS_WARNING(ShaderWarning::UNUSED_FUNCTION_FLAG) && used_functions.has(p_identifier)) {
used_functions[p_identifier].used = true;
}
break;
Added a shader warning about unused local variable
2021-06-29 14:34:54 +03:00
case IdentifierType::IDENTIFIER_LOCAL_VAR:
if (HAS_WARNING(ShaderWarning::UNUSED_LOCAL_VARIABLE_FLAG) && used_local_vars.has(p_function) && used_local_vars[p_function].has(p_identifier)) {
used_local_vars[p_function][p_identifier].used = true;
}
break;
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
default:
break;
}
}
#endif // DEBUG_ENABLED
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
bool ShaderLanguage::_find_identifier(const BlockNode *p_block, bool p_allow_reassign, const FunctionInfo &p_function_info, const StringName &p_identifier, DataType *r_data_type, IdentifierType *r_type, bool *r_is_const, int *r_array_size, StringName *r_struct_name, ConstantNode::Value *r_constant_value) {
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
if (p_function_info.built_ins.has(p_identifier)) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (r_data_type) {
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
*r_data_type = p_function_info.built_ins[p_identifier].type;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
if (r_is_const) {
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
*r_is_const = p_function_info.built_ins[p_identifier].constant;
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (r_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
*r_type = IDENTIFIER_BUILTIN_VAR;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return true;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
if (p_function_info.stage_functions.has(p_identifier)) {
if (r_data_type) {
*r_data_type = p_function_info.stage_functions[p_identifier].return_type;
}
if (r_is_const) {
*r_is_const = true;
}
if (r_type) {
*r_type = IDENTIFIER_FUNCTION;
}
return true;
}
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
FunctionNode *function = nullptr;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (p_block) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (p_block->variables.has(p_identifier)) {
if (r_data_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
*r_data_type = p_block->variables[p_identifier].type;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Implemented local shader constants
2019-08-05 10:35:53 +03:00
if (r_is_const) {
*r_is_const = p_block->variables[p_identifier].is_const;
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
if (r_array_size) {
*r_array_size = p_block->variables[p_identifier].array_size;
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (r_struct_name) {
*r_struct_name = p_block->variables[p_identifier].struct_name;
}
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
if (r_constant_value) {
*r_constant_value = p_block->variables[p_identifier].value;
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (r_type) {
*r_type = IDENTIFIER_LOCAL_VAR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
return true;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (p_block->parent_function) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
function = p_block->parent_function;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
break;
} else {
Allow to reassign local variables in shaders
2020-03-20 14:09:43 +03:00
if (p_allow_reassign) {
break;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ERR_FAIL_COND_V(!p_block->parent_block, false);
p_block = p_block->parent_block;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (function) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < function->arguments.size(); i++) {
if (function->arguments[i].name == p_identifier) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (r_data_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
*r_data_type = function->arguments[i].type;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (r_struct_name) {
*r_struct_name = function->arguments[i].type_str;
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (r_array_size) {
*r_array_size = function->arguments[i].array_size;
}
Added const qualifier support for function arguments in shaders
2020-07-01 11:55:49 +03:00
if (r_is_const) {
*r_is_const = function->arguments[i].is_const;
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (r_type) {
*r_type = IDENTIFIER_FUNCTION_ARGUMENT;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return true;
}
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (shader->varyings.has(p_identifier)) {
if (r_data_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
*r_data_type = shader->varyings[p_identifier].type;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
Implement shader array support for varyings
2019-07-29 17:08:25 +03:00
if (r_array_size) {
*r_array_size = shader->varyings[p_identifier].array_size;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (r_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
*r_type = IDENTIFIER_VARYING;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
return true;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (shader->uniforms.has(p_identifier)) {
if (r_data_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
*r_data_type = shader->uniforms[p_identifier].type;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (r_array_size) {
*r_array_size = shader->uniforms[p_identifier].array_size;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (r_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
*r_type = IDENTIFIER_UNIFORM;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
return true;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
if (shader->constants.has(p_identifier)) {
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
if (r_is_const) {
*r_is_const = true;
}
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
if (r_data_type) {
*r_data_type = shader->constants[p_identifier].type;
}
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
if (r_array_size) {
*r_array_size = shader->constants[p_identifier].array_size;
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (r_struct_name) {
*r_struct_name = shader->constants[p_identifier].type_str;
}
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
if (r_constant_value) {
if (shader->constants[p_identifier].initializer && shader->constants[p_identifier].initializer->values.size() == 1) {
*r_constant_value = shader->constants[p_identifier].initializer->values[0];
}
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (r_type) {
*r_type = IDENTIFIER_CONSTANT;
}
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
return true;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < shader->functions.size(); i++) {
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 16:41:43 +02:00
if (!shader->functions[i].callable) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
continue;
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 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (shader->functions[i].name == p_identifier) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (r_data_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
*r_data_type = shader->functions[i].function->return_type;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (r_array_size) {
*r_array_size = shader->functions[i].function->return_array_size;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (r_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
*r_type = IDENTIFIER_FUNCTION;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
Show that identifier found in function names
2019-08-09 21:15:33 -07:00
return true;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return false;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
bool ShaderLanguage::_validate_operator(OperatorNode *p_op, DataType *r_ret_type, int *r_ret_size) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool valid = false;
Fix some code found by Coverity Scan and PVS Studio
2019-07-23 09:14:31 +02:00
DataType ret_type = TYPE_VOID;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
int ret_size = 0;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
switch (p_op->op) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
case OP_EQUAL:
case OP_NOT_EQUAL: {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if ((!p_op->arguments[0]->is_indexed() && p_op->arguments[0]->get_array_size() > 0) || (!p_op->arguments[1]->is_indexed() && p_op->arguments[1]->get_array_size() > 0)) {
break; // don't accept arrays
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
valid = na == nb;
ret_type = TYPE_BOOL;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
case OP_LESS:
case OP_LESS_EQUAL:
case OP_GREATER:
case OP_GREATER_EQUAL: {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if ((!p_op->arguments[0]->is_indexed() && p_op->arguments[0]->get_array_size() > 0) || (!p_op->arguments[1]->is_indexed() && p_op->arguments[1]->get_array_size() > 0)) {
break; // don't accept arrays
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
valid = na == nb && (na == TYPE_UINT || na == TYPE_INT || na == TYPE_FLOAT);
ret_type = TYPE_BOOL;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
case OP_AND:
case OP_OR: {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if ((!p_op->arguments[0]->is_indexed() && p_op->arguments[0]->get_array_size() > 0) || (!p_op->arguments[1]->is_indexed() && p_op->arguments[1]->get_array_size() > 0)) {
break; // don't accept arrays
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
valid = na == nb && na == TYPE_BOOL;
ret_type = TYPE_BOOL;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
case OP_NOT: {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!p_op->arguments[0]->is_indexed() && p_op->arguments[0]->get_array_size() > 0) {
break; // don't accept arrays
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataType na = p_op->arguments[0]->get_datatype();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
valid = na == TYPE_BOOL;
ret_type = TYPE_BOOL;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
case OP_INCREMENT:
case OP_DECREMENT:
case OP_POST_INCREMENT:
case OP_POST_DECREMENT:
case OP_NEGATE: {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!p_op->arguments[0]->is_indexed() && p_op->arguments[0]->get_array_size() > 0) {
break; // don't accept arrays
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataType na = p_op->arguments[0]->get_datatype();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
valid = na > TYPE_BOOL && na < TYPE_MAT2;
ret_type = na;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
case OP_ADD:
case OP_SUB:
case OP_MUL:
case OP_DIV: {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if ((!p_op->arguments[0]->is_indexed() && p_op->arguments[0]->get_array_size() > 0) || (!p_op->arguments[1]->is_indexed() && p_op->arguments[1]->get_array_size() > 0)) {
break; // don't accept arrays
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (na > nb) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
//make things easier;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
SWAP(na, nb);
}
if (na == nb) {
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
valid = (na > TYPE_BOOL && na <= TYPE_MAT4);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ret_type = na;
} else if (na == TYPE_INT && nb == TYPE_IVEC2) {
valid = true;
ret_type = TYPE_IVEC2;
} else if (na == TYPE_INT && nb == TYPE_IVEC3) {
valid = true;
ret_type = TYPE_IVEC3;
} else if (na == TYPE_INT && nb == TYPE_IVEC4) {
valid = true;
ret_type = TYPE_IVEC4;
} else if (na == TYPE_UINT && nb == TYPE_UVEC2) {
valid = true;
ret_type = TYPE_UVEC2;
} else if (na == TYPE_UINT && nb == TYPE_UVEC3) {
valid = true;
ret_type = TYPE_UVEC3;
} else if (na == TYPE_UINT && nb == TYPE_UVEC4) {
valid = true;
ret_type = TYPE_UVEC4;
} else if (na == TYPE_FLOAT && nb == TYPE_VEC2) {
valid = true;
ret_type = TYPE_VEC2;
} else if (na == TYPE_FLOAT && nb == TYPE_VEC3) {
valid = true;
ret_type = TYPE_VEC3;
} else if (na == TYPE_FLOAT && nb == TYPE_VEC4) {
valid = true;
ret_type = TYPE_VEC4;
Fix some incorrect conversions which lead to crash in shaders
2020-07-14 20:28:18 +03:00
} else if (na == TYPE_FLOAT && nb == TYPE_MAT2) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
valid = true;
ret_type = TYPE_MAT2;
Fix some incorrect conversions which lead to crash in shaders
2020-07-14 20:28:18 +03:00
} else if (na == TYPE_FLOAT && nb == TYPE_MAT3) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
valid = true;
ret_type = TYPE_MAT3;
Fix some incorrect conversions which lead to crash in shaders
2020-07-14 20:28:18 +03:00
} else if (na == TYPE_FLOAT && nb == TYPE_MAT4) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
valid = true;
ret_type = TYPE_MAT4;
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
} else if (p_op->op == OP_MUL && na == TYPE_VEC2 && nb == TYPE_MAT2) {
valid = true;
ret_type = TYPE_VEC2;
} else if (p_op->op == OP_MUL && na == TYPE_VEC3 && nb == TYPE_MAT3) {
valid = true;
ret_type = TYPE_VEC3;
} else if (p_op->op == OP_MUL && na == TYPE_VEC4 && nb == TYPE_MAT4) {
valid = true;
ret_type = TYPE_VEC4;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
case OP_ASSIGN_MOD:
case OP_MOD: {
/*
* The operator modulus (%) operates on signed or unsigned integers or integer vectors. The operand
* types must both be signed or both be unsigned. The operands cannot be vectors of differing size. If
* one operand is a scalar and the other vector, then the scalar is applied component-wise to the vector,
* resulting in the same type as the vector. If both are vectors of the same size, the result is computed
* component-wise.
*/
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if ((!p_op->arguments[0]->is_indexed() && p_op->arguments[0]->get_array_size() > 0) || (!p_op->arguments[1]->is_indexed() && p_op->arguments[1]->get_array_size() > 0)) {
break; // don't accept arrays
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (na == TYPE_INT && nb == TYPE_INT) {
valid = true;
ret_type = TYPE_INT;
} else if (na == TYPE_IVEC2 && nb == TYPE_INT) {
valid = true;
ret_type = TYPE_IVEC2;
} else if (na == TYPE_IVEC3 && nb == TYPE_INT) {
valid = true;
ret_type = TYPE_IVEC3;
} else if (na == TYPE_IVEC4 && nb == TYPE_INT) {
valid = true;
ret_type = TYPE_IVEC4;
} else if (na == TYPE_IVEC2 && nb == TYPE_IVEC2) {
valid = true;
ret_type = TYPE_IVEC2;
} else if (na == TYPE_IVEC3 && nb == TYPE_IVEC3) {
valid = true;
ret_type = TYPE_IVEC3;
} else if (na == TYPE_IVEC4 && nb == TYPE_IVEC4) {
valid = true;
ret_type = TYPE_IVEC4;
/////
} else if (na == TYPE_UINT && nb == TYPE_UINT) {
valid = true;
ret_type = TYPE_UINT;
} else if (na == TYPE_UVEC2 && nb == TYPE_UINT) {
valid = true;
ret_type = TYPE_UVEC2;
} else if (na == TYPE_UVEC3 && nb == TYPE_UINT) {
valid = true;
ret_type = TYPE_UVEC3;
} else if (na == TYPE_UVEC4 && nb == TYPE_UINT) {
valid = true;
ret_type = TYPE_UVEC4;
} else if (na == TYPE_UVEC2 && nb == TYPE_UVEC2) {
valid = true;
ret_type = TYPE_UVEC2;
} else if (na == TYPE_UVEC3 && nb == TYPE_UVEC3) {
valid = true;
ret_type = TYPE_UVEC3;
} else if (na == TYPE_UVEC4 && nb == TYPE_UVEC4) {
valid = true;
ret_type = TYPE_UVEC4;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
case OP_ASSIGN_SHIFT_LEFT:
case OP_ASSIGN_SHIFT_RIGHT:
case OP_SHIFT_LEFT:
case OP_SHIFT_RIGHT: {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if ((!p_op->arguments[0]->is_indexed() && p_op->arguments[0]->get_array_size() > 0) || (!p_op->arguments[1]->is_indexed() && p_op->arguments[1]->get_array_size() > 0)) {
break; // don't accept arrays
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (na == TYPE_INT && nb == TYPE_INT) {
valid = true;
ret_type = TYPE_INT;
} else if (na == TYPE_IVEC2 && nb == TYPE_INT) {
valid = true;
ret_type = TYPE_IVEC2;
} else if (na == TYPE_IVEC3 && nb == TYPE_INT) {
valid = true;
ret_type = TYPE_IVEC3;
} else if (na == TYPE_IVEC4 && nb == TYPE_INT) {
valid = true;
ret_type = TYPE_IVEC4;
} else if (na == TYPE_IVEC2 && nb == TYPE_IVEC2) {
valid = true;
ret_type = TYPE_IVEC2;
} else if (na == TYPE_IVEC3 && nb == TYPE_IVEC3) {
valid = true;
ret_type = TYPE_IVEC3;
} else if (na == TYPE_IVEC4 && nb == TYPE_IVEC4) {
valid = true;
ret_type = TYPE_IVEC4;
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
} else if (na == TYPE_UINT && nb == TYPE_UINT) {
valid = true;
ret_type = TYPE_UINT;
} else if (na == TYPE_UVEC2 && nb == TYPE_UINT) {
valid = true;
ret_type = TYPE_UVEC2;
} else if (na == TYPE_UVEC3 && nb == TYPE_UINT) {
valid = true;
ret_type = TYPE_UVEC3;
} else if (na == TYPE_UVEC4 && nb == TYPE_UINT) {
valid = true;
ret_type = TYPE_UVEC4;
} else if (na == TYPE_UVEC2 && nb == TYPE_UVEC2) {
valid = true;
ret_type = TYPE_UVEC2;
} else if (na == TYPE_UVEC3 && nb == TYPE_UVEC3) {
valid = true;
ret_type = TYPE_UVEC3;
} else if (na == TYPE_UVEC4 && nb == TYPE_UVEC4) {
valid = true;
ret_type = TYPE_UVEC4;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
} break;
case OP_ASSIGN: {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
int sa = 0;
int sb = 0;
if (!p_op->arguments[0]->is_indexed()) {
sa = p_op->arguments[0]->get_array_size();
}
if (!p_op->arguments[1]->is_indexed()) {
sb = p_op->arguments[1]->get_array_size();
}
if (sa != sb) {
break; // don't accept arrays if their sizes are not equal
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (na == TYPE_STRUCT || nb == TYPE_STRUCT) {
valid = p_op->arguments[0]->get_datatype_name() == p_op->arguments[1]->get_datatype_name();
} else {
valid = na == nb;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ret_type = na;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
ret_size = sa;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
case OP_ASSIGN_ADD:
case OP_ASSIGN_SUB:
case OP_ASSIGN_MUL:
case OP_ASSIGN_DIV: {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
int sa = 0;
int sb = 0;
if (!p_op->arguments[0]->is_indexed()) {
sa = p_op->arguments[0]->get_array_size();
}
if (!p_op->arguments[1]->is_indexed()) {
sb = p_op->arguments[1]->get_array_size();
}
if (sa > 0 || sb > 0) {
break; // don't accept arrays
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (na == nb) {
Allow using more assignment operators on matrixes in shaders
2021-08-11 11:50:55 +03:00
valid = (na > TYPE_BOOL && na <= TYPE_MAT4);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ret_type = na;
} else if (na == TYPE_IVEC2 && nb == TYPE_INT) {
valid = true;
ret_type = TYPE_IVEC2;
} else if (na == TYPE_IVEC3 && nb == TYPE_INT) {
valid = true;
ret_type = TYPE_IVEC3;
} else if (na == TYPE_IVEC4 && nb == TYPE_INT) {
valid = true;
ret_type = TYPE_IVEC4;
} else if (na == TYPE_UVEC2 && nb == TYPE_UINT) {
valid = true;
ret_type = TYPE_UVEC2;
} else if (na == TYPE_UVEC3 && nb == TYPE_UINT) {
valid = true;
ret_type = TYPE_UVEC3;
} else if (na == TYPE_UVEC4 && nb == TYPE_UINT) {
valid = true;
ret_type = TYPE_UVEC4;
} else if (na == TYPE_VEC2 && nb == TYPE_FLOAT) {
valid = true;
ret_type = TYPE_VEC2;
} else if (na == TYPE_VEC3 && nb == TYPE_FLOAT) {
valid = true;
ret_type = TYPE_VEC3;
} else if (na == TYPE_VEC4 && nb == TYPE_FLOAT) {
valid = true;
ret_type = TYPE_VEC4;
Fix some incorrect conversions which lead to crash in shaders
2020-07-14 20:28:18 +03:00
} else if (na == TYPE_MAT2 && nb == TYPE_FLOAT) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
valid = true;
ret_type = TYPE_MAT2;
Fix some incorrect conversions which lead to crash in shaders
2020-07-14 20:28:18 +03:00
} else if (na == TYPE_MAT3 && nb == TYPE_FLOAT) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
valid = true;
ret_type = TYPE_MAT3;
Fix some incorrect conversions which lead to crash in shaders
2020-07-14 20:28:18 +03:00
} else if (na == TYPE_MAT4 && nb == TYPE_FLOAT) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
valid = true;
ret_type = TYPE_MAT4;
Allow *= operator between vec and mat types in shaders
2018-11-24 18:57:11 +01:00
} else if (p_op->op == OP_ASSIGN_MUL && na == TYPE_VEC2 && nb == TYPE_MAT2) {
valid = true;
ret_type = TYPE_VEC2;
} else if (p_op->op == OP_ASSIGN_MUL && na == TYPE_VEC3 && nb == TYPE_MAT3) {
valid = true;
ret_type = TYPE_VEC3;
} else if (p_op->op == OP_ASSIGN_MUL && na == TYPE_VEC4 && nb == TYPE_MAT4) {
valid = true;
ret_type = TYPE_VEC4;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
} break;
case OP_ASSIGN_BIT_AND:
case OP_ASSIGN_BIT_OR:
case OP_ASSIGN_BIT_XOR:
case OP_BIT_AND:
case OP_BIT_OR:
case OP_BIT_XOR: {
/*
* The bitwise operators and (&), exclusive-or (^), and inclusive-or (|). The operands must be of type
* signed or unsigned integers or integer vectors. The operands cannot be vectors of differing size. If
* one operand is a scalar and the other a vector, the scalar is applied component-wise to the vector,
* resulting in the same type as the vector. The fundamental types of the operands (signed or unsigned)
* must match.
*/
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
int sa = 0;
int sb = 0;
if (!p_op->arguments[0]->is_indexed()) {
sa = p_op->arguments[0]->get_array_size();
}
if (!p_op->arguments[1]->is_indexed()) {
sb = p_op->arguments[1]->get_array_size();
}
if (sa > 0 || sb > 0) {
break; // don't accept arrays
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (na > nb && p_op->op >= OP_BIT_AND) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
//can swap for non assign
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
SWAP(na, nb);
}
if (na == TYPE_INT && nb == TYPE_INT) {
valid = true;
ret_type = TYPE_INT;
} else if (na == TYPE_IVEC2 && nb == TYPE_INT) {
valid = true;
ret_type = TYPE_IVEC2;
} else if (na == TYPE_IVEC3 && nb == TYPE_INT) {
valid = true;
ret_type = TYPE_IVEC3;
} else if (na == TYPE_IVEC4 && nb == TYPE_INT) {
valid = true;
ret_type = TYPE_IVEC4;
} else if (na == TYPE_IVEC2 && nb == TYPE_IVEC2) {
valid = true;
ret_type = TYPE_IVEC2;
} else if (na == TYPE_IVEC3 && nb == TYPE_IVEC3) {
valid = true;
ret_type = TYPE_IVEC3;
} else if (na == TYPE_IVEC4 && nb == TYPE_IVEC4) {
valid = true;
ret_type = TYPE_IVEC4;
/////
} else if (na == TYPE_UINT && nb == TYPE_UINT) {
valid = true;
ret_type = TYPE_UINT;
} else if (na == TYPE_UVEC2 && nb == TYPE_UINT) {
valid = true;
ret_type = TYPE_UVEC2;
} else if (na == TYPE_UVEC3 && nb == TYPE_UINT) {
valid = true;
ret_type = TYPE_UVEC3;
} else if (na == TYPE_UVEC4 && nb == TYPE_UINT) {
valid = true;
ret_type = TYPE_UVEC4;
} else if (na == TYPE_UVEC2 && nb == TYPE_UVEC2) {
valid = true;
ret_type = TYPE_UVEC2;
} else if (na == TYPE_UVEC3 && nb == TYPE_UVEC3) {
valid = true;
ret_type = TYPE_UVEC3;
} else if (na == TYPE_UVEC4 && nb == TYPE_UVEC4) {
valid = true;
ret_type = TYPE_UVEC4;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
case OP_BIT_INVERT: { //unaries
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!p_op->arguments[0]->is_indexed() && p_op->arguments[0]->get_array_size() > 0) {
break; // don't accept arrays
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataType na = p_op->arguments[0]->get_datatype();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
valid = na >= TYPE_INT && na < TYPE_FLOAT;
ret_type = na;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
case OP_SELECT_IF: {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
int sa = 0;
int sb = 0;
if (!p_op->arguments[1]->is_indexed()) {
sa = p_op->arguments[1]->get_array_size();
}
if (!p_op->arguments[2]->is_indexed()) {
sb = p_op->arguments[2]->get_array_size();
}
if (sa != sb) {
break; // don't accept arrays if their sizes are not equal
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
DataType nc = p_op->arguments[2]->get_datatype();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
valid = na == TYPE_BOOL && (nb == nc);
ret_type = nb;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
ret_size = sa;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
default: {
ERR_FAIL_V(false);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 16:41:43 +02:00
if (r_ret_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
*r_ret_type = ret_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 16:41:43 +02:00
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (r_ret_size) {
*r_ret_size = ret_size;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return valid;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
const ShaderLanguage::BuiltinFuncDef ShaderLanguage::builtin_func_defs[] = {
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// Constructors.
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "bool", TYPE_BOOL, { TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec2", TYPE_BVEC2, { TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec2", TYPE_BVEC2, { TYPE_BOOL, TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec3", TYPE_BVEC3, { TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec3", TYPE_BVEC3, { TYPE_BOOL, TYPE_BOOL, TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec3", TYPE_BVEC3, { TYPE_BVEC2, TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec3", TYPE_BVEC3, { TYPE_BOOL, TYPE_BVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec4", TYPE_BVEC4, { TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec4", TYPE_BVEC4, { TYPE_BOOL, TYPE_BOOL, TYPE_BOOL, TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec4", TYPE_BVEC4, { TYPE_BOOL, TYPE_BVEC2, TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec4", TYPE_BVEC4, { TYPE_BVEC2, TYPE_BOOL, TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec4", TYPE_BVEC4, { TYPE_BOOL, TYPE_BOOL, TYPE_BVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec4", TYPE_BVEC4, { TYPE_BOOL, TYPE_BVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec4", TYPE_BVEC4, { TYPE_BVEC3, TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec4", TYPE_BVEC4, { TYPE_BVEC2, TYPE_BVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "float", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec2", TYPE_VEC2, { TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec2", TYPE_VEC2, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec3", TYPE_VEC3, { TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec3", TYPE_VEC3, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec3", TYPE_VEC3, { TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec3", TYPE_VEC3, { TYPE_FLOAT, TYPE_VEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec4", TYPE_VEC4, { TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec4", TYPE_VEC4, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec4", TYPE_VEC4, { TYPE_FLOAT, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec4", TYPE_VEC4, { TYPE_VEC2, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec4", TYPE_VEC4, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec4", TYPE_VEC4, { TYPE_FLOAT, TYPE_VEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec4", TYPE_VEC4, { TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec4", TYPE_VEC4, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "int", TYPE_INT, { TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec2", TYPE_IVEC2, { TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec2", TYPE_IVEC2, { TYPE_INT, TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec3", TYPE_IVEC3, { TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec3", TYPE_IVEC3, { TYPE_INT, TYPE_INT, TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec3", TYPE_IVEC3, { TYPE_IVEC2, TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec3", TYPE_IVEC3, { TYPE_INT, TYPE_IVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec4", TYPE_IVEC4, { TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec4", TYPE_IVEC4, { TYPE_INT, TYPE_INT, TYPE_INT, TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec4", TYPE_IVEC4, { TYPE_INT, TYPE_IVEC2, TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec4", TYPE_IVEC4, { TYPE_IVEC2, TYPE_INT, TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec4", TYPE_IVEC4, { TYPE_INT, TYPE_INT, TYPE_IVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec4", TYPE_IVEC4, { TYPE_INT, TYPE_IVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec4", TYPE_IVEC4, { TYPE_IVEC3, TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec4", TYPE_IVEC4, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uint", TYPE_UINT, { TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec2", TYPE_UVEC2, { TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec2", TYPE_UVEC2, { TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec3", TYPE_UVEC3, { TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec3", TYPE_UVEC3, { TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec3", TYPE_UVEC3, { TYPE_UVEC2, TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec3", TYPE_UVEC3, { TYPE_UINT, TYPE_UVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_UVEC2, TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UVEC2, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_UINT, TYPE_UVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_UVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UVEC3, TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "mat2", TYPE_MAT2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "mat3", TYPE_MAT3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "mat4", TYPE_MAT4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "mat2", TYPE_MAT2, { TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "mat3", TYPE_MAT3, { TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "mat4", TYPE_MAT4, { TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// Conversion scalars.
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "int", TYPE_INT, { TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "int", TYPE_INT, { TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "int", TYPE_INT, { TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "int", TYPE_INT, { TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "float", TYPE_FLOAT, { TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "float", TYPE_FLOAT, { TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "float", TYPE_FLOAT, { TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "float", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "uint", TYPE_UINT, { TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uint", TYPE_UINT, { TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uint", TYPE_UINT, { TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uint", TYPE_UINT, { TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "bool", TYPE_BOOL, { TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bool", TYPE_BOOL, { TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bool", TYPE_BOOL, { TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "bool", TYPE_BOOL, { TYPE_FLOAT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// Conversion vectors.
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "ivec2", TYPE_IVEC2, { TYPE_BVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec2", TYPE_IVEC2, { TYPE_IVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec2", TYPE_IVEC2, { TYPE_UVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec2", TYPE_IVEC2, { TYPE_VEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec2", TYPE_VEC2, { TYPE_BVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec2", TYPE_VEC2, { TYPE_IVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec2", TYPE_VEC2, { TYPE_UVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "vec2", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec2", TYPE_UVEC2, { TYPE_BVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec2", TYPE_UVEC2, { TYPE_IVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec2", TYPE_UVEC2, { TYPE_UVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec2", TYPE_UVEC2, { TYPE_VEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "bvec2", TYPE_BVEC2, { TYPE_BVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec2", TYPE_BVEC2, { TYPE_IVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec2", TYPE_BVEC2, { TYPE_UVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "bvec2", TYPE_BVEC2, { TYPE_VEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec3", TYPE_IVEC3, { TYPE_BVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec3", TYPE_IVEC3, { TYPE_IVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec3", TYPE_IVEC3, { TYPE_UVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "ivec3", TYPE_IVEC3, { TYPE_VEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec3", TYPE_VEC3, { TYPE_BVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec3", TYPE_VEC3, { TYPE_IVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec3", TYPE_VEC3, { TYPE_UVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "vec3", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec3", TYPE_UVEC3, { TYPE_BVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec3", TYPE_UVEC3, { TYPE_IVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec3", TYPE_UVEC3, { TYPE_UVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec3", TYPE_UVEC3, { TYPE_VEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "bvec3", TYPE_BVEC3, { TYPE_BVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec3", TYPE_BVEC3, { TYPE_IVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec3", TYPE_BVEC3, { TYPE_UVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "bvec3", TYPE_BVEC3, { TYPE_VEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec4", TYPE_IVEC4, { TYPE_BVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec4", TYPE_IVEC4, { TYPE_IVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "ivec4", TYPE_IVEC4, { TYPE_UVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "ivec4", TYPE_IVEC4, { TYPE_VEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec4", TYPE_VEC4, { TYPE_BVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec4", TYPE_VEC4, { TYPE_IVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "vec4", TYPE_VEC4, { TYPE_UVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "vec4", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec4", TYPE_UVEC4, { TYPE_BVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_IVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_VEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "bvec4", TYPE_BVEC4, { TYPE_BVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec4", TYPE_BVEC4, { TYPE_IVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec4", TYPE_BVEC4, { TYPE_UVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, true },
{ "bvec4", TYPE_BVEC4, { TYPE_VEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// Conversion between matrixes.
Added conversions between matrixes in shaders
2018-07-25 18:14:52 +03:00
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "mat2", TYPE_MAT2, { TYPE_MAT3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "mat2", TYPE_MAT2, { TYPE_MAT4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "mat3", TYPE_MAT3, { TYPE_MAT2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "mat3", TYPE_MAT3, { TYPE_MAT4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "mat4", TYPE_MAT4, { TYPE_MAT2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "mat4", TYPE_MAT4, { TYPE_MAT3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Added conversions between matrixes in shaders
2018-07-25 18:14:52 +03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// Built-ins - trigonometric functions.
// radians
Added missing shader functions
2018-02-18 18:08:18 +03:00
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "radians", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "degrees" }, TAG_GLOBAL, false },
{ "radians", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "degrees" }, TAG_GLOBAL, false },
{ "radians", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "degrees" }, TAG_GLOBAL, false },
{ "radians", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "degrees" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// degrees
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "degrees", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "radians" }, TAG_GLOBAL, false },
{ "degrees", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "radians" }, TAG_GLOBAL, false },
{ "degrees", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "radians" }, TAG_GLOBAL, false },
{ "degrees", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "radians" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// sin
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "sin", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "angle" }, TAG_GLOBAL, false },
{ "sin", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "angle" }, TAG_GLOBAL, false },
{ "sin", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "angle" }, TAG_GLOBAL, false },
{ "sin", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "angle" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// cos
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "cos", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "angle" }, TAG_GLOBAL, false },
{ "cos", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "angle" }, TAG_GLOBAL, false },
{ "cos", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "angle" }, TAG_GLOBAL, false },
{ "cos", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "angle" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// tan
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "tan", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "angle" }, TAG_GLOBAL, false },
{ "tan", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "angle" }, TAG_GLOBAL, false },
{ "tan", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "angle" }, TAG_GLOBAL, false },
{ "tan", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "angle" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// asin
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "asin", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "asin", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "asin", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "asin", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// acos
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "acos", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "acos", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "acos", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "acos", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// atan
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "atan", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "y_over_x" }, TAG_GLOBAL, false },
{ "atan", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "y_over_x" }, TAG_GLOBAL, false },
{ "atan", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "y_over_x" }, TAG_GLOBAL, false },
{ "atan", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "y_over_x" }, TAG_GLOBAL, false },
{ "atan", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "y", "x" }, TAG_GLOBAL, false },
{ "atan", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "y", "x" }, TAG_GLOBAL, false },
{ "atan", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "y", "x" }, TAG_GLOBAL, false },
{ "atan", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "y", "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// sinh
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "sinh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "sinh", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "sinh", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "sinh", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// cosh
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "cosh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "cosh", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "cosh", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "cosh", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// tanh
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "tanh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "tanh", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "tanh", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "tanh", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// asinh
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "asinh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "asinh", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "asinh", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "asinh", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// acosh
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "acosh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "acosh", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "acosh", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "acosh", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// atanh
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "atanh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "atanh", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "atanh", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "atanh", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Added missing shader functions
2018-02-18 18:08:18 +03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// Builtins - exponential functions.
// pow
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "pow", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "x", "y" }, TAG_GLOBAL, false },
{ "pow", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "x", "y" }, TAG_GLOBAL, false },
{ "pow", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "x", "y" }, TAG_GLOBAL, false },
{ "pow", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "x", "y" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// exp
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "exp", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "exp", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "exp", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "exp", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// log
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "log", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "log", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "log", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "log", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// exp2
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "exp2", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "exp2", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "exp2", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "exp2", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// log2
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "log2", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "log2", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "log2", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "log2", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// sqrt
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "sqrt", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "sqrt", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "sqrt", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "sqrt", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// inversesqrt
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "inversesqrt", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "inversesqrt", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "inversesqrt", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "inversesqrt", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// Built-ins - common functions.
// abs
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "abs", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "abs", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "abs", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "abs", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "abs", TYPE_INT, { TYPE_INT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "abs", TYPE_IVEC2, { TYPE_IVEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "abs", TYPE_IVEC3, { TYPE_IVEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "abs", TYPE_IVEC4, { TYPE_IVEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// sign
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "sign", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "sign", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "sign", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "sign", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "sign", TYPE_INT, { TYPE_INT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "sign", TYPE_IVEC2, { TYPE_IVEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "sign", TYPE_IVEC3, { TYPE_IVEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "sign", TYPE_IVEC4, { TYPE_IVEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// floor
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "floor", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "floor", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "floor", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "floor", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// trunc
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "trunc", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "trunc", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "trunc", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "trunc", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// round
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "round", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "round", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "round", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "round", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// roundEven
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "roundEven", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "roundEven", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "roundEven", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "roundEven", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// ceil
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "ceil", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "ceil", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "ceil", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "ceil", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// fract
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "fract", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "fract", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "fract", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "fract", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// mod
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "mod", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "x", "y" }, TAG_GLOBAL, false },
{ "mod", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "x", "y" }, TAG_GLOBAL, false },
{ "mod", TYPE_VEC2, { TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "x", "y" }, TAG_GLOBAL, false },
{ "mod", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "x", "y" }, TAG_GLOBAL, false },
{ "mod", TYPE_VEC3, { TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "x", "y" }, TAG_GLOBAL, false },
{ "mod", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "x", "y" }, TAG_GLOBAL, false },
{ "mod", TYPE_VEC4, { TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "x", "y" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// modf
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "modf", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "x", "i" }, TAG_GLOBAL, true },
{ "modf", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "x", "i" }, TAG_GLOBAL, true },
{ "modf", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "x", "i" }, TAG_GLOBAL, true },
{ "modf", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "x", "i" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// min
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "min", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_VEC2, { TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_VEC3, { TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_VEC4, { TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_INT, { TYPE_INT, TYPE_INT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_IVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_IVEC2, { TYPE_IVEC2, TYPE_INT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_IVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_IVEC3, { TYPE_IVEC3, TYPE_INT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_IVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_IVEC4, { TYPE_IVEC4, TYPE_INT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_UINT, { TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "min", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "min", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UINT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "min", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "min", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UINT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "min", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "min", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UINT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// max
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "max", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_VEC2, { TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_VEC3, { TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_VEC4, { TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_INT, { TYPE_INT, TYPE_INT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_IVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_IVEC2, { TYPE_IVEC2, TYPE_INT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_IVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_IVEC3, { TYPE_IVEC3, TYPE_INT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_IVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_IVEC4, { TYPE_IVEC4, TYPE_INT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_UINT, { TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "max", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "max", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UINT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "max", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "max", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UINT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "max", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "max", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UINT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// clamp
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "clamp", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_VEC2, { TYPE_VEC2, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_VEC3, { TYPE_VEC3, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_VEC4, { TYPE_VEC4, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_INT, { TYPE_INT, TYPE_INT, TYPE_INT, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_IVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_IVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_IVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_IVEC2, { TYPE_IVEC2, TYPE_INT, TYPE_INT, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_IVEC3, { TYPE_IVEC3, TYPE_INT, TYPE_INT, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_IVEC4, { TYPE_IVEC4, TYPE_INT, TYPE_INT, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_UINT, { TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, true },
{ "clamp", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, true },
{ "clamp", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, true },
{ "clamp", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, true },
{ "clamp", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, true },
{ "clamp", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, true },
{ "clamp", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// mix
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "mix", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "a", "b", "value" }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "a", "b", "value" }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_BVEC2, TYPE_VOID }, { "a", "b", "value" }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "a", "b", "value" }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "a", "b", "value" }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_BVEC3, TYPE_VOID }, { "a", "b", "value" }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "a", "b", "value" }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "a", "b", "value" }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_BVEC4, TYPE_VOID }, { "a", "b", "value" }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "a", "b", "value" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// step
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "step", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "edge", "x" }, TAG_GLOBAL, false },
{ "step", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "edge", "x" }, TAG_GLOBAL, false },
{ "step", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "edge", "x" }, TAG_GLOBAL, false },
{ "step", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "edge", "x" }, TAG_GLOBAL, false },
{ "step", TYPE_VEC2, { TYPE_FLOAT, TYPE_VEC2, TYPE_VOID }, { "edge", "x" }, TAG_GLOBAL, false },
{ "step", TYPE_VEC3, { TYPE_FLOAT, TYPE_VEC3, TYPE_VOID }, { "edge", "x" }, TAG_GLOBAL, false },
{ "step", TYPE_VEC4, { TYPE_FLOAT, TYPE_VEC4, TYPE_VOID }, { "edge", "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// smoothstep
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "smoothstep", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "edge0", "edge1", "value" }, TAG_GLOBAL, false },
{ "smoothstep", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "edge0", "edge1", "value" }, TAG_GLOBAL, false },
{ "smoothstep", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "edge0", "edge1", "value" }, TAG_GLOBAL, false },
{ "smoothstep", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "edge0", "edge1", "value" }, TAG_GLOBAL, false },
{ "smoothstep", TYPE_VEC2, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VEC2, TYPE_VOID }, { "edge0", "edge1", "value" }, TAG_GLOBAL, false },
{ "smoothstep", TYPE_VEC3, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VEC3, TYPE_VOID }, { "edge0", "edge1", "value" }, TAG_GLOBAL, false },
{ "smoothstep", TYPE_VEC4, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VEC4, TYPE_VOID }, { "edge0", "edge1", "value" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// isnan
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "isnan", TYPE_BOOL, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "isnan", TYPE_BVEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "isnan", TYPE_BVEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "isnan", TYPE_BVEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// isinf
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "isinf", TYPE_BOOL, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "isinf", TYPE_BVEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "isinf", TYPE_BVEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "isinf", TYPE_BVEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// floatBitsToInt
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "floatBitsToInt", TYPE_INT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, true },
{ "floatBitsToInt", TYPE_IVEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, true },
{ "floatBitsToInt", TYPE_IVEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, true },
{ "floatBitsToInt", TYPE_IVEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// floatBitsToUint
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "floatBitsToUint", TYPE_UINT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, true },
{ "floatBitsToUint", TYPE_UVEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, true },
{ "floatBitsToUint", TYPE_UVEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, true },
{ "floatBitsToUint", TYPE_UVEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// intBitsToFloat
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "intBitsToFloat", TYPE_FLOAT, { TYPE_INT, TYPE_VOID }, { "x" }, TAG_GLOBAL, true },
{ "intBitsToFloat", TYPE_VEC2, { TYPE_IVEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, true },
{ "intBitsToFloat", TYPE_VEC3, { TYPE_IVEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, true },
{ "intBitsToFloat", TYPE_VEC4, { TYPE_IVEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// uintBitsToFloat
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "uintBitsToFloat", TYPE_FLOAT, { TYPE_UINT, TYPE_VOID }, { "x" }, TAG_GLOBAL, true },
{ "uintBitsToFloat", TYPE_VEC2, { TYPE_UVEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, true },
{ "uintBitsToFloat", TYPE_VEC3, { TYPE_UVEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, true },
{ "uintBitsToFloat", TYPE_VEC4, { TYPE_UVEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, true },
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// Built-ins - geometric functions.
// length
{ "length", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "length", TYPE_FLOAT, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "length", TYPE_FLOAT, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "length", TYPE_FLOAT, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// distance
{ "distance", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "distance", TYPE_FLOAT, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "distance", TYPE_FLOAT, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "distance", TYPE_FLOAT, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// dot
{ "dot", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "dot", TYPE_FLOAT, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "dot", TYPE_FLOAT, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "dot", TYPE_FLOAT, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// cross
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "cross", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// normalize
{ "normalize", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "v" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "normalize", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "v" }, TAG_GLOBAL, false },
{ "normalize", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "v" }, TAG_GLOBAL, false },
{ "normalize", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "v" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// reflect
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "reflect", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "I", "N" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// refract
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "refract", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "I", "N", "eta" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// faceforward
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "faceforward", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "N", "I", "Nref" }, TAG_GLOBAL, false },
{ "faceforward", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "N", "I", "Nref" }, TAG_GLOBAL, false },
{ "faceforward", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "N", "I", "Nref" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// matrixCompMult
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "matrixCompMult", TYPE_MAT2, { TYPE_MAT2, TYPE_MAT2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "matrixCompMult", TYPE_MAT3, { TYPE_MAT3, TYPE_MAT3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "matrixCompMult", TYPE_MAT4, { TYPE_MAT4, TYPE_MAT4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// outerProduct
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "outerProduct", TYPE_MAT2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "c", "r" }, TAG_GLOBAL, false },
{ "outerProduct", TYPE_MAT3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "c", "r" }, TAG_GLOBAL, false },
{ "outerProduct", TYPE_MAT4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "c", "r" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// transpose
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "transpose", TYPE_MAT2, { TYPE_MAT2, TYPE_VOID }, { "m" }, TAG_GLOBAL, false },
{ "transpose", TYPE_MAT3, { TYPE_MAT3, TYPE_VOID }, { "m" }, TAG_GLOBAL, false },
{ "transpose", TYPE_MAT4, { TYPE_MAT4, TYPE_VOID }, { "m" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// determinant
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "determinant", TYPE_FLOAT, { TYPE_MAT2, TYPE_VOID }, { "m" }, TAG_GLOBAL, false },
{ "determinant", TYPE_FLOAT, { TYPE_MAT3, TYPE_VOID }, { "m" }, TAG_GLOBAL, false },
{ "determinant", TYPE_FLOAT, { TYPE_MAT4, TYPE_VOID }, { "m" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// inverse
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "inverse", TYPE_MAT2, { TYPE_MAT2, TYPE_VOID }, { "m" }, TAG_GLOBAL, false },
{ "inverse", TYPE_MAT3, { TYPE_MAT3, TYPE_VOID }, { "m" }, TAG_GLOBAL, false },
{ "inverse", TYPE_MAT4, { TYPE_MAT4, TYPE_VOID }, { "m" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// lessThan
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "lessThan", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "lessThan", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "lessThan", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "lessThan", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "lessThan", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "lessThan", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "lessThan", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "lessThan", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "lessThan", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// greaterThan
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "greaterThan", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "greaterThan", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "greaterThan", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "greaterThan", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "greaterThan", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "greaterThan", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "greaterThan", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "greaterThan", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "greaterThan", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// lessThanEqual
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "lessThanEqual", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "lessThanEqual", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "lessThanEqual", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "lessThanEqual", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "lessThanEqual", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "lessThanEqual", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "lessThanEqual", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "lessThanEqual", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "lessThanEqual", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// greaterThanEqual
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "greaterThanEqual", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "greaterThanEqual", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "greaterThanEqual", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "greaterThanEqual", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "greaterThanEqual", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "greaterThanEqual", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "greaterThanEqual", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "greaterThanEqual", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "greaterThanEqual", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// equal
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "equal", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "equal", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "equal", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "equal", TYPE_BVEC2, { TYPE_BVEC2, TYPE_BVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC3, { TYPE_BVEC3, TYPE_BVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC4, { TYPE_BVEC4, TYPE_BVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// notEqual
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "notEqual", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "notEqual", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "notEqual", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
{ "notEqual", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, true },
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "notEqual", TYPE_BVEC2, { TYPE_BVEC2, TYPE_BVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC3, { TYPE_BVEC3, TYPE_BVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC4, { TYPE_BVEC4, TYPE_BVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// any
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "any", TYPE_BOOL, { TYPE_BVEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "any", TYPE_BOOL, { TYPE_BVEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "any", TYPE_BOOL, { TYPE_BVEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// all
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "all", TYPE_BOOL, { TYPE_BVEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "all", TYPE_BOOL, { TYPE_BVEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "all", TYPE_BOOL, { TYPE_BVEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// not
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "not", TYPE_BVEC2, { TYPE_BVEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "not", TYPE_BVEC3, { TYPE_BVEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "not", TYPE_BVEC4, { TYPE_BVEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// Built-ins: texture functions.
// textureSize
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "textureSize", TYPE_IVEC2, { TYPE_SAMPLER2D, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC2, { TYPE_ISAMPLER2D, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC2, { TYPE_USAMPLER2D, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC3, { TYPE_SAMPLER2DARRAY, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC3, { TYPE_ISAMPLER2DARRAY, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC3, { TYPE_USAMPLER2DARRAY, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC3, { TYPE_SAMPLER3D, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC3, { TYPE_ISAMPLER3D, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC3, { TYPE_USAMPLER3D, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC2, { TYPE_SAMPLERCUBE, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC2, { TYPE_SAMPLERCUBEARRAY, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// texture
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "texture", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "texture", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, true },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, true },
{ "texture", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "texture", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, true },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, true },
{ "texture", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "texture", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, true },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, true },
{ "texture", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "texture", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
{ "texture", TYPE_VEC4, { TYPE_SAMPLERCUBEARRAY, TYPE_VEC4, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "texture", TYPE_VEC4, { TYPE_SAMPLERCUBEARRAY, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// textureProj
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC4, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC4, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC4, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC4, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC4, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC4, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// textureLod
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "textureLod", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "textureLod", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "textureLod", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "textureLod", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "textureLod", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "textureLod", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "textureLod", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "textureLod", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "textureLod", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "textureLod", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "textureLod", TYPE_VEC4, { TYPE_SAMPLERCUBEARRAY, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// texelFetch
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "texelFetch", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_IVEC2, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "texelFetch", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_IVEC2, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "texelFetch", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_IVEC2, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "texelFetch", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "texelFetch", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "texelFetch", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "texelFetch", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "texelFetch", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "texelFetch", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// textureProjLod
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "textureProjLod", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// textureGrad
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "textureGrad", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_VEC3, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_VEC3, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_VEC3, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_VEC4, { TYPE_SAMPLERCUBEARRAY, TYPE_VEC4, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, true },
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
// textureGather
{ "textureGather", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureGather", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureGather", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureGather", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "comp" }, TAG_GLOBAL, true },
{ "textureGather", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "comp" }, TAG_GLOBAL, true },
{ "textureGather", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "comp" }, TAG_GLOBAL, true },
{ "textureGather", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureGather", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureGather", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureGather", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_VEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "comp" }, TAG_GLOBAL, true },
{ "textureGather", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_VEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "comp" }, TAG_GLOBAL, true },
{ "textureGather", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_VEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "comp" }, TAG_GLOBAL, true },
{ "textureGather", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureGather", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "comp" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// dFdx
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "dFdx", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdx", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdx", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdx", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// dFdy
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "dFdy", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdy", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdy", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdy", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// fwidth
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "fwidth", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "fwidth", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "fwidth", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "fwidth", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// Sub-functions.
// array
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "length", TYPE_INT, { TYPE_VOID }, { "" }, TAG_ARRAY, true },
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// Modern functions.
// fma
Added 'fma' function to shader language
2020-02-14 23:09:53 +03:00
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "fma", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "a", "b", "c" }, TAG_GLOBAL, false },
{ "fma", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "a", "b", "c" }, TAG_GLOBAL, false },
{ "fma", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "a", "b", "c" }, TAG_GLOBAL, false },
{ "fma", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "a", "b", "c" }, TAG_GLOBAL, false },
Added 'fma' function to shader language
2020-02-14 23:09:53 +03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// Packing/Unpacking functions.
{ "packHalf2x16", TYPE_UINT, { TYPE_VEC2, TYPE_VOID }, { "v" }, TAG_GLOBAL, true },
{ "packUnorm2x16", TYPE_UINT, { TYPE_VEC2, TYPE_VOID }, { "v" }, TAG_GLOBAL, true },
{ "packSnorm2x16", TYPE_UINT, { TYPE_VEC2, TYPE_VOID }, { "v" }, TAG_GLOBAL, true },
{ "packUnorm4x8", TYPE_UINT, { TYPE_VEC4, TYPE_VOID }, { "v" }, TAG_GLOBAL, true },
{ "packSnorm4x8", TYPE_UINT, { TYPE_VEC4, TYPE_VOID }, { "v" }, TAG_GLOBAL, true },
{ "unpackHalf2x16", TYPE_VEC2, { TYPE_UINT, TYPE_VOID }, { "v" }, TAG_GLOBAL, true },
{ "unpackUnorm2x16", TYPE_VEC2, { TYPE_UINT, TYPE_VOID }, { "v" }, TAG_GLOBAL, true },
{ "unpackSnorm2x16", TYPE_VEC2, { TYPE_UINT, TYPE_VOID }, { "v" }, TAG_GLOBAL, true },
{ "unpackUnorm4x8", TYPE_VEC4, { TYPE_UINT, TYPE_VOID }, { "v" }, TAG_GLOBAL, true },
{ "unpackSnorm4x8", TYPE_VEC4, { TYPE_UINT, TYPE_VOID }, { "v" }, TAG_GLOBAL, true },
// bitfieldExtract
{ "bitfieldExtract", TYPE_INT, { TYPE_INT, TYPE_INT, TYPE_INT, TYPE_VOID }, { "value", "offset", "bits" }, TAG_GLOBAL, true },
{ "bitfieldExtract", TYPE_IVEC2, { TYPE_IVEC2, TYPE_INT, TYPE_INT, TYPE_VOID }, { "value", "offset", "bits" }, TAG_GLOBAL, true },
{ "bitfieldExtract", TYPE_IVEC3, { TYPE_IVEC3, TYPE_INT, TYPE_INT, TYPE_VOID }, { "value", "offset", "bits" }, TAG_GLOBAL, true },
{ "bitfieldExtract", TYPE_IVEC4, { TYPE_IVEC4, TYPE_INT, TYPE_INT, TYPE_VOID }, { "value", "offset", "bits" }, TAG_GLOBAL, true },
{ "bitfieldExtract", TYPE_UINT, { TYPE_UINT, TYPE_INT, TYPE_INT, TYPE_VOID }, { "value", "offset", "bits" }, TAG_GLOBAL, true },
{ "bitfieldExtract", TYPE_UVEC2, { TYPE_UVEC2, TYPE_INT, TYPE_INT, TYPE_VOID }, { "value", "offset", "bits" }, TAG_GLOBAL, true },
{ "bitfieldExtract", TYPE_UVEC3, { TYPE_UVEC3, TYPE_INT, TYPE_INT, TYPE_VOID }, { "value", "offset", "bits" }, TAG_GLOBAL, true },
{ "bitfieldExtract", TYPE_UVEC4, { TYPE_UVEC4, TYPE_INT, TYPE_INT, TYPE_VOID }, { "value", "offset", "bits" }, TAG_GLOBAL, true },
// bitfieldInsert
{ "bitfieldInsert", TYPE_INT, { TYPE_INT, TYPE_INT, TYPE_INT, TYPE_INT, TYPE_VOID }, { "base", "insert", "offset", "bits" }, TAG_GLOBAL, true },
{ "bitfieldInsert", TYPE_IVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_INT, TYPE_INT, TYPE_VOID }, { "base", "insert", "offset", "bits" }, TAG_GLOBAL, true },
{ "bitfieldInsert", TYPE_IVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_INT, TYPE_INT, TYPE_VOID }, { "base", "insert", "offset", "bits" }, TAG_GLOBAL, true },
{ "bitfieldInsert", TYPE_IVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_INT, TYPE_INT, TYPE_VOID }, { "base", "insert", "offset", "bits" }, TAG_GLOBAL, true },
{ "bitfieldInsert", TYPE_UINT, { TYPE_UINT, TYPE_UINT, TYPE_INT, TYPE_INT, TYPE_VOID }, { "base", "insert", "offset", "bits" }, TAG_GLOBAL, true },
{ "bitfieldInsert", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_INT, TYPE_INT, TYPE_VOID }, { "base", "insert", "offset", "bits" }, TAG_GLOBAL, true },
{ "bitfieldInsert", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_INT, TYPE_INT, TYPE_VOID }, { "base", "insert", "offset", "bits" }, TAG_GLOBAL, true },
{ "bitfieldInsert", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_INT, TYPE_INT, TYPE_VOID }, { "base", "insert", "offset", "bits" }, TAG_GLOBAL, true },
// bitfieldReverse
{ "bitfieldReverse", TYPE_INT, { TYPE_INT, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "bitfieldReverse", TYPE_IVEC2, { TYPE_IVEC2, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "bitfieldReverse", TYPE_IVEC3, { TYPE_IVEC3, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "bitfieldReverse", TYPE_IVEC4, { TYPE_IVEC4, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "bitfieldReverse", TYPE_UINT, { TYPE_UINT, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "bitfieldReverse", TYPE_UVEC2, { TYPE_UVEC2, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "bitfieldReverse", TYPE_UVEC3, { TYPE_UVEC3, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "bitfieldReverse", TYPE_UVEC4, { TYPE_UVEC4, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
// bitCount
{ "bitCount", TYPE_INT, { TYPE_INT, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "bitCount", TYPE_IVEC2, { TYPE_IVEC2, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "bitCount", TYPE_IVEC3, { TYPE_IVEC3, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "bitCount", TYPE_IVEC4, { TYPE_IVEC4, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "bitCount", TYPE_UINT, { TYPE_UINT, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "bitCount", TYPE_UVEC2, { TYPE_UVEC2, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "bitCount", TYPE_UVEC3, { TYPE_UVEC3, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "bitCount", TYPE_UVEC4, { TYPE_UVEC4, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
// findLSB
{ "findLSB", TYPE_INT, { TYPE_INT, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "findLSB", TYPE_IVEC2, { TYPE_IVEC2, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "findLSB", TYPE_IVEC3, { TYPE_IVEC3, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "findLSB", TYPE_IVEC4, { TYPE_IVEC4, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "findLSB", TYPE_UINT, { TYPE_UINT, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "findLSB", TYPE_UVEC2, { TYPE_UVEC2, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "findLSB", TYPE_UVEC3, { TYPE_UVEC3, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "findLSB", TYPE_UVEC4, { TYPE_UVEC4, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
// findMSB
{ "findMSB", TYPE_INT, { TYPE_INT, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "findMSB", TYPE_IVEC2, { TYPE_IVEC2, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "findMSB", TYPE_IVEC3, { TYPE_IVEC3, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "findMSB", TYPE_IVEC4, { TYPE_IVEC4, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "findMSB", TYPE_UINT, { TYPE_UINT, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "findMSB", TYPE_UVEC2, { TYPE_UVEC2, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "findMSB", TYPE_UVEC3, { TYPE_UVEC3, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
{ "findMSB", TYPE_UVEC4, { TYPE_UVEC4, TYPE_VOID }, { "value" }, TAG_GLOBAL, true },
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
// umulExtended
{ "umulExtended", TYPE_VOID, { TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "x", "y", "msb", "lsb" }, TAG_GLOBAL, true },
{ "umulExtended", TYPE_VOID, { TYPE_UVEC2, TYPE_UVEC2, TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "x", "y", "msb", "lsb" }, TAG_GLOBAL, true },
{ "umulExtended", TYPE_VOID, { TYPE_UVEC3, TYPE_UVEC3, TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "x", "y", "msb", "lsb" }, TAG_GLOBAL, true },
{ "umulExtended", TYPE_VOID, { TYPE_UVEC4, TYPE_UVEC4, TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "x", "y", "msb", "lsb" }, TAG_GLOBAL, true },
// imulExtended
{ "imulExtended", TYPE_VOID, { TYPE_INT, TYPE_INT, TYPE_INT, TYPE_INT, TYPE_VOID }, { "x", "y", "msb", "lsb" }, TAG_GLOBAL, true },
{ "imulExtended", TYPE_VOID, { TYPE_IVEC2, TYPE_IVEC2, TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, { "x", "y", "msb", "lsb" }, TAG_GLOBAL, true },
{ "imulExtended", TYPE_VOID, { TYPE_IVEC3, TYPE_IVEC3, TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, { "x", "y", "msb", "lsb" }, TAG_GLOBAL, true },
{ "imulExtended", TYPE_VOID, { TYPE_IVEC4, TYPE_IVEC4, TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, { "x", "y", "msb", "lsb" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// uaddCarry
{ "uaddCarry", TYPE_UINT, { TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "x", "y", "carry" }, TAG_GLOBAL, true },
{ "uaddCarry", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "x", "y", "carry" }, TAG_GLOBAL, true },
{ "uaddCarry", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "x", "y", "carry" }, TAG_GLOBAL, true },
{ "uaddCarry", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "x", "y", "carry" }, TAG_GLOBAL, true },
// usubBorrow
{ "usubBorrow", TYPE_UINT, { TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "x", "y", "borrow" }, TAG_GLOBAL, true },
{ "usubBorrow", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "x", "y", "borrow" }, TAG_GLOBAL, true },
{ "usubBorrow", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "x", "y", "borrow" }, TAG_GLOBAL, true },
{ "usubBorrow", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "x", "y", "borrow" }, TAG_GLOBAL, true },
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
// ldexp
{ "ldexp", TYPE_FLOAT, { TYPE_FLOAT, TYPE_INT, TYPE_VOID }, { "x", "exp" }, TAG_GLOBAL, true },
{ "ldexp", TYPE_VEC2, { TYPE_VEC2, TYPE_IVEC2, TYPE_VOID }, { "x", "exp" }, TAG_GLOBAL, true },
{ "ldexp", TYPE_VEC3, { TYPE_VEC3, TYPE_IVEC3, TYPE_VOID }, { "x", "exp" }, TAG_GLOBAL, true },
{ "ldexp", TYPE_VEC4, { TYPE_VEC4, TYPE_IVEC4, TYPE_VOID }, { "x", "exp" }, TAG_GLOBAL, true },
// frexp
{ "frexp", TYPE_FLOAT, { TYPE_FLOAT, TYPE_INT, TYPE_VOID }, { "x", "exp" }, TAG_GLOBAL, true },
{ "frexp", TYPE_VEC2, { TYPE_VEC2, TYPE_IVEC2, TYPE_VOID }, { "x", "exp" }, TAG_GLOBAL, true },
{ "frexp", TYPE_VEC3, { TYPE_VEC3, TYPE_IVEC3, TYPE_VOID }, { "x", "exp" }, TAG_GLOBAL, true },
{ "frexp", TYPE_VEC4, { TYPE_VEC4, TYPE_IVEC4, TYPE_VOID }, { "x", "exp" }, TAG_GLOBAL, true },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ nullptr, TYPE_VOID, { TYPE_VOID }, { "" }, TAG_GLOBAL, false }
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
};
Proper validation of out arguments in built-in shader functions, closes #16244
2018-11-14 18:55:38 -03:00
const ShaderLanguage::BuiltinFuncOutArgs ShaderLanguage::builtin_func_out_args[] = {
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
{ "modf", { 1, -1 } },
{ "umulExtended", { 2, 3 } },
{ "imulExtended", { 2, 3 } },
{ "uaddCarry", { 2, -1 } },
{ "usubBorrow", { 2, -1 } },
{ "ldexp", { 1, -1 } },
{ "frexp", { 1, -1 } },
{ nullptr, { 0, -1 } }
};
const ShaderLanguage::BuiltinFuncConstArgs ShaderLanguage::builtin_func_const_args[] = {
{ "textureGather", 2, 0, 3 },
{ nullptr, 0, 0, 0 }
Proper validation of out arguments in built-in shader functions, closes #16244
2018-11-14 18:55:38 -03:00
};
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
bool ShaderLanguage::is_const_suffix_lut_initialized = false;
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionInfo &p_function_info, OperatorNode *p_func, DataType *r_ret_type, StringName *r_ret_type_str) {
Make the default return value on crash explicit Noticed that the error condition will return a NULL instead of something more explicit like "false". Should make the code more readable at a glance.
2019-07-11 23:06:58 -04:00
ERR_FAIL_COND_V(p_func->op != OP_CALL && p_func->op != OP_CONSTRUCT, false);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Vector<DataType> args;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
Vector<StringName> args2;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
Vector<int> args3;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Make the default return value on crash explicit Noticed that the error condition will return a NULL instead of something more explicit like "false". Should make the code more readable at a glance.
2019-07-11 23:06:58 -04:00
ERR_FAIL_COND_V(p_func->arguments[0]->type != Node::TYPE_VARIABLE, false);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
StringName name = static_cast<VariableNode *>(p_func->arguments[0])->name.operator String();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 1; i < p_func->arguments.size(); i++) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
args.push_back(p_func->arguments[i]->get_datatype());
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
args2.push_back(p_func->arguments[i]->get_datatype_name());
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
args3.push_back(p_func->arguments[i]->get_array_size());
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
int argcount = args.size();
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
if (p_function_info.stage_functions.has(name)) {
//stage based function
const StageFunctionInfo &sf = p_function_info.stage_functions[name];
if (argcount != sf.arguments.size()) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Invalid number of arguments when calling stage function '%s', which expects %d arguments."), String(name), sf.arguments.size()));
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
return false;
}
//validate arguments
for (int i = 0; i < argcount; i++) {
if (args[i] != sf.arguments[i].type) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Invalid argument type when calling stage function '%s', type expected is '%s'."), String(name), get_datatype_name(sf.arguments[i].type)));
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
return false;
}
}
if (r_ret_type) {
*r_ret_type = sf.return_type;
}
if (r_ret_type_str) {
*r_ret_type_str = "";
}
return true;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool failed_builtin = false;
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 12:38:35 +03:00
bool unsupported_builtin = false;
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 13:28:29 +03:00
int builtin_idx = 0;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (argcount <= 4) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
// test builtins
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
int idx = 0;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
while (builtin_func_defs[idx].name) {
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
if (completion_class != builtin_func_defs[idx].tag) {
idx++;
continue;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (name == builtin_func_defs[idx].name) {
failed_builtin = true;
bool fail = false;
for (int i = 0; i < argcount; i++) {
Fix shader crash when passing array.length to functions and similar cases
2021-10-05 09:47:50 +03:00
if (p_func->arguments[i + 1]->type == Node::TYPE_ARRAY) {
const ArrayNode *anode = static_cast<const ArrayNode *>(p_func->arguments[i + 1]);
if (anode->call_expression == nullptr && !anode->is_indexed()) {
fail = true;
break;
}
Fix shader crash when passing array to built-in function without index
2021-09-18 14:05:14 +03:00
}
Ensure implicit conversions for scalar constants work in shaders, closes #26239
2019-02-26 23:20:39 -03:00
if (get_scalar_type(args[i]) == args[i] && p_func->arguments[i + 1]->type == Node::TYPE_CONSTANT && convert_constant(static_cast<ConstantNode *>(p_func->arguments[i + 1]), builtin_func_defs[idx].args[i])) {
//all good, but needs implicit conversion later
} else if (args[i] != builtin_func_defs[idx].args[i]) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
fail = true;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
break;
}
}
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 12:38:35 +03:00
if (!fail) {
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
if (RenderingServer::get_singleton()->is_low_end()) {
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 12:38:35 +03:00
if (builtin_func_defs[idx].high_end) {
fail = true;
unsupported_builtin = true;
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 13:28:29 +03:00
builtin_idx = idx;
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 12:38:35 +03: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 16:41:43 +02:00
if (!fail && argcount < 4 && builtin_func_defs[idx].args[argcount] != TYPE_VOID) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
fail = true; //make sure the number of arguments matches
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 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
if (!fail) {
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
{
int constarg_idx = 0;
while (builtin_func_const_args[constarg_idx].name) {
if (String(name) == builtin_func_const_args[constarg_idx].name) {
int arg = builtin_func_const_args[constarg_idx].arg + 1;
if (p_func->arguments.size() <= arg) {
break;
Proper validation of out arguments in built-in shader functions, closes #16244
2018-11-14 18:55:38 -03:00
}
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
int min = builtin_func_const_args[constarg_idx].min;
int max = builtin_func_const_args[constarg_idx].max;
bool error = false;
if (p_func->arguments[arg]->type == Node::TYPE_VARIABLE) {
const VariableNode *vn = (VariableNode *)p_func->arguments[arg];
bool is_const = false;
ConstantNode::Value value;
Prevent shader crash when passing constant expression to `textureGather`
2021-10-21 19:46:05 +03:00
value.sint = -1;
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
_find_identifier(p_block, false, p_function_info, vn->name, nullptr, nullptr, &is_const, nullptr, nullptr, &value);
if (!is_const || value.sint < min || value.sint > max) {
error = true;
Fix shader crash if passing const values to modf function
2020-03-18 13:22:12 +03:00
}
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
} else {
if (p_func->arguments[arg]->type == Node::TYPE_CONSTANT) {
ConstantNode *cn = (ConstantNode *)p_func->arguments[arg];
if (cn->get_datatype() == TYPE_INT && cn->values.size() == 1) {
int value = cn->values[0].sint;
if (value < min || value > max) {
error = true;
Fix shader crash if passing const values to modf function
2020-03-18 13:22:12 +03:00
}
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
} else {
error = true;
Fix shader crash if passing const values to modf function
2020-03-18 13:22:12 +03:00
}
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
} else {
error = true;
Fix shader crash if passing const values to modf function
2020-03-18 13:22:12 +03:00
}
}
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
if (error) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Expected integer constant within [%d..%d] range."), min, max));
Fix shader crash if passing const values to modf function
2020-03-18 13:22:12 +03:00
return false;
}
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
}
constarg_idx++;
}
}
Fix shader crash if passing const values to modf function
2020-03-18 13:22:12 +03:00
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
//make sure its not an out argument used in the wrong way
int outarg_idx = 0;
while (builtin_func_out_args[outarg_idx].name) {
if (String(name) == builtin_func_out_args[outarg_idx].name) {
for (int arg = 0; arg < BuiltinFuncOutArgs::MAX_ARGS; arg++) {
int arg_idx = builtin_func_out_args[outarg_idx].arguments[arg];
if (arg_idx == -1) {
break;
}
if (arg_idx < argcount) {
if (p_func->arguments[arg_idx + 1]->type != Node::TYPE_VARIABLE && p_func->arguments[arg_idx + 1]->type != Node::TYPE_MEMBER && p_func->arguments[arg_idx + 1]->type != Node::TYPE_ARRAY) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Argument %d of function '%s' is not a variable, array, or member."), arg_idx + 1, String(name)));
Fix shader crash if passing const values to modf function
2020-03-18 13:22:12 +03:00
return false;
}
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
if (p_func->arguments[arg_idx + 1]->type == Node::TYPE_ARRAY) {
ArrayNode *mn = static_cast<ArrayNode *>(p_func->arguments[arg_idx + 1]);
if (mn->is_const) {
fail = true;
}
} else if (p_func->arguments[arg_idx + 1]->type == Node::TYPE_MEMBER) {
MemberNode *mn = static_cast<MemberNode *>(p_func->arguments[arg_idx + 1]);
if (mn->basetype_const) {
fail = true;
}
} else { // TYPE_VARIABLE
VariableNode *vn = static_cast<VariableNode *>(p_func->arguments[arg_idx + 1]);
if (vn->is_const) {
fail = true;
} else {
StringName varname = vn->name;
if (shader->uniforms.has(varname)) {
fail = true;
} else {
if (shader->varyings.has(varname)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Varyings cannot be passed for the '%s' parameter."), "out"));
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
return false;
}
if (p_function_info.built_ins.has(varname)) {
BuiltInInfo info = p_function_info.built_ins[varname];
if (info.constant) {
fail = true;
}
}
}
}
Fix shader crash if passing const values to modf function
2020-03-18 13:22:12 +03:00
}
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
if (fail) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("A constant value cannot be passed for the '%s' parameter."), "out"));
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
return false;
Proper validation of out arguments in built-in shader functions, closes #16244
2018-11-14 18:55:38 -03:00
}
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
StringName var_name;
if (p_func->arguments[arg_idx + 1]->type == Node::TYPE_ARRAY) {
var_name = static_cast<const ArrayNode *>(p_func->arguments[arg_idx + 1])->name;
} else if (p_func->arguments[arg_idx + 1]->type == Node::TYPE_MEMBER) {
Node *n = static_cast<const MemberNode *>(p_func->arguments[arg_idx + 1])->owner;
while (n->type == Node::TYPE_MEMBER) {
n = static_cast<const MemberNode *>(n)->owner;
}
if (n->type != Node::TYPE_VARIABLE && n->type != Node::TYPE_ARRAY) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Argument %d of function '%s' is not a variable, array, or member."), arg_idx + 1, String(name)));
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
return false;
}
if (n->type == Node::TYPE_VARIABLE) {
var_name = static_cast<const VariableNode *>(n)->name;
} else { // TYPE_ARRAY
var_name = static_cast<const ArrayNode *>(n)->name;
}
} else { // TYPE_VARIABLE
var_name = static_cast<const VariableNode *>(p_func->arguments[arg_idx + 1])->name;
}
const BlockNode *b = p_block;
bool valid = false;
while (b) {
if (b->variables.has(var_name) || p_function_info.built_ins.has(var_name)) {
valid = true;
break;
}
if (b->parent_function) {
for (int i = 0; i < b->parent_function->arguments.size(); i++) {
if (b->parent_function->arguments[i].name == var_name) {
valid = true;
break;
}
Enables passing out built-in parameter from parent function in shaders
2020-02-22 11:09:06 +03:00
}
}
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
b = b->parent_block;
Enables passing out built-in parameter from parent function in shaders
2020-02-22 11:09:06 +03:00
}
Proper validation of out arguments in built-in shader functions, closes #16244
2018-11-14 18:55:38 -03:00
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
if (!valid) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Argument %d of function '%s' can only take a local variable, array, or member."), arg_idx + 1, String(name)));
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
return false;
}
Proper validation of out arguments in built-in shader functions, closes #16244
2018-11-14 18:55:38 -03:00
}
}
}
outarg_idx++;
}
Ensure implicit conversions for scalar constants work in shaders, closes #26239
2019-02-26 23:20:39 -03:00
//implicitly convert values if possible
for (int i = 0; i < argcount; i++) {
if (get_scalar_type(args[i]) != args[i] || args[i] == builtin_func_defs[idx].args[i] || p_func->arguments[i + 1]->type != Node::TYPE_CONSTANT) {
//can't do implicit conversion here
continue;
}
//this is an implicit conversion
ConstantNode *constant = static_cast<ConstantNode *>(p_func->arguments[i + 1]);
ConstantNode *conversion = alloc_node<ConstantNode>();
conversion->datatype = builtin_func_defs[idx].args[i];
conversion->values.resize(1);
convert_constant(constant, builtin_func_defs[idx].args[i], conversion->values.ptrw());
p_func->arguments.write[i + 1] = conversion;
}
Proper validation of out arguments in built-in shader functions, closes #16244
2018-11-14 18:55:38 -03: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 16:41:43 +02:00
if (r_ret_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
*r_ret_type = builtin_func_defs[idx].rettype;
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 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return true;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
}
idx++;
}
}
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 12:38:35 +03:00
if (unsupported_builtin) {
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 13:28:29 +03:00
String arglist = "";
for (int i = 0; i < argcount; i++) {
if (i > 0) {
arglist += ", ";
}
arglist += get_datatype_name(builtin_func_defs[builtin_idx].args[i]);
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Built-in function \"%s(%s)\" is only supported on high-end platforms."), String(name), arglist));
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 12:38:35 +03:00
return false;
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
if (failed_builtin) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
String arg_list;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < argcount; i++) {
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 16:41:43 +02:00
if (i > 0) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
arg_list += ",";
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 16:41:43 +02:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
Improve messages in shader function validation
2020-09-05 11:12:29 +03:00
String arg_name;
if (args[i] == TYPE_STRUCT) {
arg_name = args2[i];
} else {
arg_name = get_datatype_name(args[i]);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
Fix shader crash when passing array to built-in function without index
2021-09-18 14:05:14 +03:00
if (args3[i] > 0) {
arg_name += "[";
arg_name += itos(args3[i]);
arg_name += "]";
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
arg_list += arg_name;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Invalid arguments for the built-in function: \"%s(%s)\"."), String(name), arg_list));
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return false;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
// try existing functions..
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
StringName exclude_function;
BlockNode *block = p_block;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (block) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (block->parent_function) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
exclude_function = block->parent_function->name;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
block = block->parent_block;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (name == exclude_function) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Recursion is not allowed."));
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return false;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Improve messages in shader function validation
2020-09-05 11:12:29 +03:00
int last_arg_count = 0;
String arg_list = "";
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < shader->functions.size(); i++) {
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 16:41:43 +02:00
if (name != shader->functions[i].name) {
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
continue;
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 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (!shader->functions[i].callable) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Function '%s' can't be called from source code."), String(name)));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return false;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
FunctionNode *pfunc = shader->functions[i].function;
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 03:42:46 -06:00
if (arg_list.is_empty()) {
Fix crash regression in the shader function validation introduced in #41780
2020-09-05 13:49:50 +03:00
for (int j = 0; j < pfunc->arguments.size(); j++) {
Improve messages in shader function validation
2020-09-05 11:12:29 +03:00
if (j > 0) {
arg_list += ", ";
}
String func_arg_name;
if (pfunc->arguments[j].type == TYPE_STRUCT) {
func_arg_name = pfunc->arguments[j].type_str;
} else {
func_arg_name = get_datatype_name(pfunc->arguments[j].type);
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (pfunc->arguments[j].array_size > 0) {
func_arg_name += "[";
func_arg_name += itos(pfunc->arguments[j].array_size);
func_arg_name += "]";
}
Improve messages in shader function validation
2020-09-05 11:12:29 +03:00
arg_list += func_arg_name;
}
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03: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 16:41:43 +02:00
if (pfunc->arguments.size() != args.size()) {
Improve messages in shader function validation
2020-09-05 11:12:29 +03:00
last_arg_count = pfunc->arguments.size();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
continue;
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 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool fail = false;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
for (int j = 0; j < args.size(); j++) {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (get_scalar_type(args[j]) == args[j] && p_func->arguments[j + 1]->type == Node::TYPE_CONSTANT && args3[j] == 0 && convert_constant(static_cast<ConstantNode *>(p_func->arguments[j + 1]), pfunc->arguments[j].type)) {
Ensure implicit conversions for scalar constants work in shaders, closes #26239
2019-02-26 23:20:39 -03:00
//all good, but it needs implicit conversion later
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
} else if (args[j] != pfunc->arguments[j].type || (args[j] == TYPE_STRUCT && args2[j] != pfunc->arguments[j].type_str) || args3[j] != pfunc->arguments[j].array_size) {
Improve messages in shader function validation
2020-09-05 11:12:29 +03:00
String func_arg_name;
if (pfunc->arguments[j].type == TYPE_STRUCT) {
func_arg_name = pfunc->arguments[j].type_str;
} else {
func_arg_name = get_datatype_name(pfunc->arguments[j].type);
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (pfunc->arguments[j].array_size > 0) {
func_arg_name += "[";
func_arg_name += itos(pfunc->arguments[j].array_size);
func_arg_name += "]";
}
Improve messages in shader function validation
2020-09-05 11:12:29 +03:00
String arg_name;
if (args[j] == TYPE_STRUCT) {
arg_name = args2[j];
} else {
arg_name = get_datatype_name(args[j]);
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (args3[j] > 0) {
arg_name += "[";
arg_name += itos(args3[j]);
arg_name += "]";
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Invalid argument for \"%s(%s)\" function: argument %d should be %s but is %s."), String(name), arg_list, j + 1, func_arg_name, arg_name));
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
fail = true;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
break;
}
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (!fail) {
Ensure implicit conversions for scalar constants work in shaders, closes #26239
2019-02-26 23:20:39 -03:00
//implicitly convert values if possible
for (int k = 0; k < args.size(); k++) {
if (get_scalar_type(args[k]) != args[k] || args[k] == pfunc->arguments[k].type || p_func->arguments[k + 1]->type != Node::TYPE_CONSTANT) {
//can't do implicit conversion here
continue;
}
//this is an implicit conversion
ConstantNode *constant = static_cast<ConstantNode *>(p_func->arguments[k + 1]);
ConstantNode *conversion = alloc_node<ConstantNode>();
conversion->datatype = pfunc->arguments[k].type;
conversion->values.resize(1);
convert_constant(constant, pfunc->arguments[k].type, conversion->values.ptrw());
p_func->arguments.write[k + 1] = conversion;
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (r_ret_type) {
property validate assignment condition in new variables, fixes #9411
2017-08-20 16:15:08 -03:00
*r_ret_type = pfunc->return_type;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (pfunc->return_type == TYPE_STRUCT) {
*r_ret_type_str = pfunc->return_struct_name;
}
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return true;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
}
Improve messages in shader function validation
2020-09-05 11:12:29 +03:00
if (last_arg_count > args.size()) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Too few arguments for \"%s(%s)\" call. Expected at least %d but received %d."), String(name), arg_list, last_arg_count, args.size()));
Improve messages in shader function validation
2020-09-05 11:12:29 +03:00
} else if (last_arg_count < args.size()) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Too many arguments for \"%s(%s)\" call. Expected at most %d but received %d."), String(name), arg_list, last_arg_count, args.size()));
Improve messages in shader function validation
2020-09-05 11:12:29 +03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return false;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
bool ShaderLanguage::_compare_datatypes(DataType p_datatype_a, String p_datatype_name_a, int p_array_size_a, DataType p_datatype_b, String p_datatype_name_b, int p_array_size_b) {
bool result = true;
if (p_datatype_a == TYPE_STRUCT || p_datatype_b == TYPE_STRUCT) {
if (p_datatype_name_a != p_datatype_name_b) {
result = false;
}
} else {
if (p_datatype_a != p_datatype_b) {
result = false;
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (p_array_size_a != p_array_size_b) {
result = false;
}
if (!result) {
String type_name = p_datatype_a == TYPE_STRUCT ? p_datatype_name_a : get_datatype_name(p_datatype_a);
if (p_array_size_a > 0) {
type_name += "[";
type_name += itos(p_array_size_a);
type_name += "]";
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
String type_name2 = p_datatype_b == TYPE_STRUCT ? p_datatype_name_b : get_datatype_name(p_datatype_b);
if (p_array_size_b > 0) {
type_name2 += "[";
type_name2 += itos(p_array_size_b);
type_name2 += "]";
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Invalid assignment of '%s' to '%s'."), type_name2, type_name));
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return result;
}
bool ShaderLanguage::_compare_datatypes_in_nodes(Node *a, Node *b) {
return _compare_datatypes(a->get_datatype(), a->get_datatype_name(), a->get_array_size(), b->get_datatype(), b->get_datatype_name(), b->get_array_size());
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
bool ShaderLanguage::_parse_function_arguments(BlockNode *p_block, const FunctionInfo &p_function_info, OperatorNode *p_func, int *r_complete_arg) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
TkPos pos = _get_tkpos();
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Token tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type == TK_PARENTHESIS_CLOSE) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return true;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Style: Fix statements ending with ';;'
2017-01-14 18:03:38 +01:00
_set_tkpos(pos);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (true) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
if (r_complete_arg) {
pos = _get_tkpos();
tk = _get_token();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type == TK_CURSOR) {
*r_complete_arg = p_func->arguments.size() - 1;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
} else {
_set_tkpos(pos);
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Node *arg = _parse_and_reduce_expression(p_block, p_function_info);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
if (!arg) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return false;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
p_func->arguments.push_back(arg);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type == TK_PARENTHESIS_CLOSE) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return true;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (tk.type != TK_COMMA) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
// something is broken
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected ',' or ')' after argument."));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return false;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return true;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
bool ShaderLanguage::is_token_operator(TokenType p_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
return (p_type == TK_OP_EQUAL ||
p_type == TK_OP_NOT_EQUAL ||
p_type == TK_OP_LESS ||
p_type == TK_OP_LESS_EQUAL ||
p_type == TK_OP_GREATER ||
p_type == TK_OP_GREATER_EQUAL ||
p_type == TK_OP_AND ||
p_type == TK_OP_OR ||
p_type == TK_OP_NOT ||
p_type == TK_OP_ADD ||
p_type == TK_OP_SUB ||
p_type == TK_OP_MUL ||
p_type == TK_OP_DIV ||
p_type == TK_OP_MOD ||
p_type == TK_OP_SHIFT_LEFT ||
p_type == TK_OP_SHIFT_RIGHT ||
p_type == TK_OP_ASSIGN ||
p_type == TK_OP_ASSIGN_ADD ||
p_type == TK_OP_ASSIGN_SUB ||
p_type == TK_OP_ASSIGN_MUL ||
p_type == TK_OP_ASSIGN_DIV ||
p_type == TK_OP_ASSIGN_MOD ||
p_type == TK_OP_ASSIGN_SHIFT_LEFT ||
p_type == TK_OP_ASSIGN_SHIFT_RIGHT ||
p_type == TK_OP_ASSIGN_BIT_AND ||
p_type == TK_OP_ASSIGN_BIT_OR ||
p_type == TK_OP_ASSIGN_BIT_XOR ||
p_type == TK_OP_BIT_AND ||
p_type == TK_OP_BIT_OR ||
p_type == TK_OP_BIT_XOR ||
p_type == TK_OP_BIT_INVERT ||
p_type == TK_OP_INCREMENT ||
p_type == TK_OP_DECREMENT ||
p_type == TK_QUESTION ||
p_type == TK_COLON);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Prevents shader crashing if varying assigned incorrectly
2021-07-26 14:38:33 +03:00
bool ShaderLanguage::is_token_operator_assign(TokenType p_type) {
return (p_type == TK_OP_ASSIGN ||
p_type == TK_OP_ASSIGN_ADD ||
p_type == TK_OP_ASSIGN_SUB ||
p_type == TK_OP_ASSIGN_MUL ||
p_type == TK_OP_ASSIGN_DIV ||
p_type == TK_OP_ASSIGN_MOD ||
p_type == TK_OP_ASSIGN_SHIFT_LEFT ||
p_type == TK_OP_ASSIGN_SHIFT_RIGHT ||
p_type == TK_OP_ASSIGN_BIT_AND ||
p_type == TK_OP_ASSIGN_BIT_OR ||
p_type == TK_OP_ASSIGN_BIT_XOR);
}
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
bool ShaderLanguage::is_token_hint(TokenType p_type) {
return int(p_type) > int(TK_RENDER_MODE) && int(p_type) < int(TK_SHADER_TYPE);
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool ShaderLanguage::convert_constant(ConstantNode *p_constant, DataType p_to_type, ConstantNode::Value *p_value) {
if (p_constant->datatype == p_to_type) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
if (p_value) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < p_constant->values.size(); i++) {
p_value[i] = p_constant->values[i];
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return true;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (p_constant->datatype == TYPE_INT && p_to_type == TYPE_FLOAT) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
if (p_value) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
p_value->real = p_constant->values[0].sint;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
return true;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (p_constant->datatype == TYPE_UINT && p_to_type == TYPE_FLOAT) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
if (p_value) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
p_value->real = p_constant->values[0].uint;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
return true;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (p_constant->datatype == TYPE_INT && p_to_type == TYPE_UINT) {
if (p_constant->values[0].sint < 0) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return false;
}
if (p_value) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
p_value->uint = p_constant->values[0].sint;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
return true;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (p_constant->datatype == TYPE_UINT && p_to_type == TYPE_INT) {
if (p_constant->values[0].uint > 0x7FFFFFFF) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return false;
}
if (p_value) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
p_value->sint = p_constant->values[0].uint;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
return true;
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 16:41:43 +02:00
} else {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03: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 16:41:43 +02:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
bool ShaderLanguage::is_scalar_type(DataType p_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
return p_type == TYPE_BOOL || p_type == TYPE_INT || p_type == TYPE_UINT || p_type == TYPE_FLOAT;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
More fixes to mobile renderer * Specify all precision qualifiers * Makes renderer work on Adreno Vulkan
2021-08-18 12:18:50 -03:00
bool ShaderLanguage::is_float_type(DataType p_type) {
switch (p_type) {
case TYPE_FLOAT:
case TYPE_VEC2:
case TYPE_VEC3:
case TYPE_VEC4:
case TYPE_MAT2:
case TYPE_MAT3:
case TYPE_MAT4:
case TYPE_SAMPLER2D:
case TYPE_SAMPLER2DARRAY:
case TYPE_SAMPLER3D:
case TYPE_SAMPLERCUBE:
case TYPE_SAMPLERCUBEARRAY: {
return true;
}
default: {
return false;
}
}
}
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 18:31:01 -03:00
bool ShaderLanguage::is_sampler_type(DataType p_type) {
add 3D textures
2018-06-26 13:59:26 +02:00
return p_type == TYPE_SAMPLER2D ||
clang-format: Disable alignment of operands, too unreliable Sets `AlignOperands` to `DontAlign`. `clang-format` developers seem to mostly care about space-based indentation and every other version of clang-format breaks the bad mismatch of tabs and spaces that it seems to use for operand alignment. So it's better without, so that it respects our two-tabs `ContinuationIndentWidth`.
2021-10-28 15:19:35 +02:00
p_type == TYPE_ISAMPLER2D ||
p_type == TYPE_USAMPLER2D ||
p_type == TYPE_SAMPLER2DARRAY ||
p_type == TYPE_ISAMPLER2DARRAY ||
p_type == TYPE_USAMPLER2DARRAY ||
p_type == TYPE_SAMPLER3D ||
p_type == TYPE_ISAMPLER3D ||
p_type == TYPE_USAMPLER3D ||
p_type == TYPE_SAMPLERCUBE ||
p_type == TYPE_SAMPLERCUBEARRAY;
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 18:31:01 -03:00
}
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
Variant ShaderLanguage::constant_value_to_variant(const Vector<ShaderLanguage::ConstantNode::Value> &p_value, DataType p_type, int p_array_size, ShaderLanguage::ShaderNode::Uniform::Hint p_hint) {
int array_size = p_array_size;
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
if (p_value.size() > 0) {
Variant value;
switch (p_type) {
case ShaderLanguage::TYPE_BOOL:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size > 0) {
PackedInt32Array array = PackedInt32Array();
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].boolean);
}
value = Variant(array);
} else {
value = Variant(p_value[0].boolean);
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
case ShaderLanguage::TYPE_BVEC2:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
array_size *= 2;
if (array_size > 0) {
PackedInt32Array array = PackedInt32Array();
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].boolean);
}
value = Variant(array);
} else {
value = Variant(p_value[0].boolean);
}
break;
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
case ShaderLanguage::TYPE_BVEC3:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
array_size *= 3;
if (array_size > 0) {
PackedInt32Array array = PackedInt32Array();
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].boolean);
}
value = Variant(array);
} else {
value = Variant(p_value[0].boolean);
}
break;
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
case ShaderLanguage::TYPE_BVEC4:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
array_size *= 4;
if (array_size > 0) {
PackedInt32Array array = PackedInt32Array();
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].boolean);
}
value = Variant(array);
} else {
value = Variant(p_value[0].boolean);
}
break;
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
case ShaderLanguage::TYPE_INT:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size > 0) {
PackedInt32Array array = PackedInt32Array();
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].sint);
}
value = Variant(array);
} else {
value = Variant(p_value[0].sint);
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
case ShaderLanguage::TYPE_IVEC2:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size > 0) {
array_size *= 2;
PackedInt32Array array = PackedInt32Array();
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].sint);
}
value = Variant(array);
} else {
value = Variant(Vector2(p_value[0].sint, p_value[1].sint));
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
case ShaderLanguage::TYPE_IVEC3:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size > 0) {
array_size *= 3;
PackedInt32Array array = PackedInt32Array();
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].sint);
}
value = Variant(array);
} else {
value = Variant(Vector3(p_value[0].sint, p_value[1].sint, p_value[2].sint));
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
case ShaderLanguage::TYPE_IVEC4:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size > 0) {
array_size *= 4;
PackedInt32Array array = PackedInt32Array();
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].sint);
}
value = Variant(array);
} else {
value = Variant(Plane(p_value[0].sint, p_value[1].sint, p_value[2].sint, p_value[3].sint));
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
case ShaderLanguage::TYPE_UINT:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size > 0) {
PackedInt32Array array = PackedInt32Array();
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].uint);
}
value = Variant(array);
} else {
value = Variant(p_value[0].uint);
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
case ShaderLanguage::TYPE_UVEC2:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size > 0) {
array_size *= 2;
PackedInt32Array array = PackedInt32Array();
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].uint);
}
value = Variant(array);
} else {
value = Variant(Vector2(p_value[0].uint, p_value[1].uint));
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
case ShaderLanguage::TYPE_UVEC3:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size > 0) {
array_size *= 3;
PackedInt32Array array = PackedInt32Array();
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].uint);
}
value = Variant(array);
} else {
value = Variant(Vector3(p_value[0].uint, p_value[1].uint, p_value[2].uint));
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
case ShaderLanguage::TYPE_UVEC4:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size > 0) {
array_size *= 4;
PackedInt32Array array = PackedInt32Array();
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].uint);
}
value = Variant(array);
} else {
value = Variant(Plane(p_value[0].uint, p_value[1].uint, p_value[2].uint, p_value[3].uint));
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
case ShaderLanguage::TYPE_FLOAT:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size > 0) {
PackedFloat32Array array = PackedFloat32Array();
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].real);
}
value = Variant(array);
} else {
value = Variant(p_value[0].real);
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
case ShaderLanguage::TYPE_VEC2:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size > 0) {
array_size *= 2;
PackedVector2Array array = PackedVector2Array();
for (int i = 0; i < array_size; i += 2) {
array.push_back(Vector2(p_value[i].real, p_value[i + 1].real));
}
value = Variant(array);
} else {
value = Variant(Vector2(p_value[0].real, p_value[1].real));
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
case ShaderLanguage::TYPE_VEC3:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size > 0) {
array_size *= 3;
PackedVector3Array array = PackedVector3Array();
for (int i = 0; i < array_size; i += 3) {
array.push_back(Vector3(p_value[i].real, p_value[i + 1].real, p_value[i + 2].real));
}
value = Variant(array);
} else {
value = Variant(Vector3(p_value[0].real, p_value[1].real, p_value[2].real));
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
case ShaderLanguage::TYPE_VEC4:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size > 0) {
array_size *= 4;
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
PackedColorArray array = PackedColorArray();
for (int i = 0; i < array_size; i += 4) {
array.push_back(Color(p_value[i].real, p_value[i + 1].real, p_value[i + 2].real, p_value[i + 3].real));
}
value = Variant(array);
} else {
PackedFloat32Array array = PackedFloat32Array();
for (int i = 0; i < array_size; i += 4) {
array.push_back(p_value[i].real);
array.push_back(p_value[i + 1].real);
array.push_back(p_value[i + 2].real);
array.push_back(p_value[i + 3].real);
}
value = Variant(array);
}
Use hint_color when getting shader default params
2018-11-16 12:20:23 +01:00
} else {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
value = Variant(Color(p_value[0].real, p_value[1].real, p_value[2].real, p_value[3].real));
} else {
value = Variant(Plane(p_value[0].real, p_value[1].real, p_value[2].real, p_value[3].real));
}
Use hint_color when getting shader default params
2018-11-16 12:20:23 +01:00
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
case ShaderLanguage::TYPE_MAT2:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size > 0) {
array_size *= 4;
PackedFloat32Array array = PackedFloat32Array();
for (int i = 0; i < array_size; i += 4) {
array.push_back(p_value[i].real);
array.push_back(p_value[i + 1].real);
array.push_back(p_value[i + 2].real);
array.push_back(p_value[i + 3].real);
}
value = Variant(array);
} else {
value = Variant(Transform2D(p_value[0].real, p_value[2].real, p_value[1].real, p_value[3].real, 0.0, 0.0));
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
case ShaderLanguage::TYPE_MAT3: {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size > 0) {
array_size *= 9;
PackedFloat32Array array = PackedFloat32Array();
for (int i = 0; i < array_size; i += 9) {
for (int j = 0; j < 9; j++) {
array.push_back(p_value[i + j].real);
}
}
value = Variant(array);
} else {
Basis p;
p[0][0] = p_value[0].real;
p[0][1] = p_value[1].real;
p[0][2] = p_value[2].real;
p[1][0] = p_value[3].real;
p[1][1] = p_value[4].real;
p[1][2] = p_value[5].real;
p[2][0] = p_value[6].real;
p[2][1] = p_value[7].real;
p[2][2] = p_value[8].real;
value = Variant(p);
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
}
case ShaderLanguage::TYPE_MAT4: {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size > 0) {
array_size *= 16;
PackedFloat32Array array = PackedFloat32Array();
for (int i = 0; i < array_size; i += 16) {
for (int j = 0; j < 16; j++) {
array.push_back(p_value[i + j].real);
}
}
value = Variant(array);
} else {
Basis p;
p[0][0] = p_value[0].real;
p[0][1] = p_value[1].real;
p[0][2] = p_value[2].real;
p[1][0] = p_value[4].real;
p[1][1] = p_value[5].real;
p[1][2] = p_value[6].real;
p[2][0] = p_value[8].real;
p[2][1] = p_value[9].real;
p[2][2] = p_value[10].real;
Transform3D t = Transform3D(p, Vector3(p_value[3].real, p_value[7].real, p_value[11].real));
value = Variant(t);
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
}
Fix warnings about unhandled enum value in switch [-Wswitch] Fixes GCC 5 warnings of the form: core/io/http_client.cpp:288:9: warning: enumeration value 'STATUS_SSL_HANDSHAKE_ERROR' not handled in switch [-Wswitch] core/io/marshalls.cpp:806:9: warning: enumeration value 'AABB' not handled in switch [-Wswitch] Those can be trivial cases where adding a default fallback is the solution, or more complex issues/hidden bugs where missed values are actually meant to be handled.
2018-09-26 13:13:56 +02:00
case ShaderLanguage::TYPE_ISAMPLER2DARRAY:
case ShaderLanguage::TYPE_ISAMPLER2D:
case ShaderLanguage::TYPE_ISAMPLER3D:
case ShaderLanguage::TYPE_SAMPLER2DARRAY:
case ShaderLanguage::TYPE_SAMPLER2D:
case ShaderLanguage::TYPE_SAMPLER3D:
case ShaderLanguage::TYPE_USAMPLER2DARRAY:
case ShaderLanguage::TYPE_USAMPLER2D:
case ShaderLanguage::TYPE_USAMPLER3D:
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 09:34:23 -03:00
case ShaderLanguage::TYPE_SAMPLERCUBE:
case ShaderLanguage::TYPE_SAMPLERCUBEARRAY: {
Fix warnings about unhandled enum value in switch [-Wswitch] Fixes GCC 5 warnings of the form: core/io/http_client.cpp:288:9: warning: enumeration value 'STATUS_SSL_HANDSHAKE_ERROR' not handled in switch [-Wswitch] core/io/marshalls.cpp:806:9: warning: enumeration value 'AABB' not handled in switch [-Wswitch] Those can be trivial cases where adding a default fallback is the solution, or more complex issues/hidden bugs where missed values are actually meant to be handled.
2018-09-26 13:13:56 +02:00
// Texture types, likely not relevant here.
break;
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
case ShaderLanguage::TYPE_STRUCT:
break;
Fix warnings about unhandled enum value in switch [-Wswitch] Fixes GCC 5 warnings of the form: core/io/http_client.cpp:288:9: warning: enumeration value 'STATUS_SSL_HANDSHAKE_ERROR' not handled in switch [-Wswitch] core/io/marshalls.cpp:806:9: warning: enumeration value 'AABB' not handled in switch [-Wswitch] Those can be trivial cases where adding a default fallback is the solution, or more complex issues/hidden bugs where missed values are actually meant to be handled.
2018-09-26 13:13:56 +02:00
case ShaderLanguage::TYPE_VOID:
break;
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
case ShaderLanguage::TYPE_MAX:
break;
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
}
return value;
}
return Variant();
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
PropertyInfo ShaderLanguage::uniform_to_property_info(const ShaderNode::Uniform &p_uniform) {
PropertyInfo pi;
switch (p_uniform.type) {
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
case ShaderLanguage::TYPE_VOID:
pi.type = Variant::NIL;
break;
case ShaderLanguage::TYPE_BOOL:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.array_size > 0) {
pi.type = Variant::PACKED_INT32_ARRAY;
} else {
pi.type = Variant::BOOL;
}
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
break;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case ShaderLanguage::TYPE_BVEC2:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.array_size > 0) {
pi.type = Variant::PACKED_INT32_ARRAY;
} else {
pi.type = Variant::INT;
pi.hint = PROPERTY_HINT_FLAGS;
pi.hint_string = "x,y";
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
break;
case ShaderLanguage::TYPE_BVEC3:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.array_size > 0) {
pi.type = Variant::PACKED_INT32_ARRAY;
} else {
pi.type = Variant::INT;
pi.hint = PROPERTY_HINT_FLAGS;
pi.hint_string = "x,y,z";
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
break;
case ShaderLanguage::TYPE_BVEC4:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.array_size > 0) {
pi.type = Variant::PACKED_INT32_ARRAY;
} else {
pi.type = Variant::INT;
pi.hint = PROPERTY_HINT_FLAGS;
pi.hint_string = "x,y,z,w";
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
break;
case ShaderLanguage::TYPE_UINT:
case ShaderLanguage::TYPE_INT: {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.array_size > 0) {
pi.type = Variant::PACKED_INT32_ARRAY;
} else {
pi.type = Variant::INT;
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_RANGE) {
pi.hint = PROPERTY_HINT_RANGE;
pi.hint_string = rtos(p_uniform.hint_range[0]) + "," + rtos(p_uniform.hint_range[1]) + "," + rtos(p_uniform.hint_range[2]);
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
}
} break;
case ShaderLanguage::TYPE_IVEC2:
case ShaderLanguage::TYPE_IVEC3:
case ShaderLanguage::TYPE_IVEC4:
case ShaderLanguage::TYPE_UVEC2:
case ShaderLanguage::TYPE_UVEC3:
case ShaderLanguage::TYPE_UVEC4: {
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT. - Renames PackedIntArray to PackedInt32Array. - Renames PackedFloatArray to PackedFloat32Array. - Adds PackedInt64Array and PackedFloat64Array. - Renames Variant::REAL to Variant::FLOAT for consistency. Packed arrays are for storing large amount of data and creating stuff like meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of memory. That said, many users requested the ability to have 64 bits packed arrays for their games, so this is just an optional added type. For Variant, the float datatype is always 64 bits, and exposed as `float`. We still have `real_t` which is the datatype that can change from 32 to 64 bits depending on a compile flag (not entirely working right now, but that's the idea). It affects math related datatypes and code only. Neither Variant nor PackedArray make use of real_t, which is only intended for math precision, so the term is removed from there to keep only float.
2020-02-24 15:20:53 -03:00
pi.type = Variant::PACKED_INT32_ARRAY;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
} break;
case ShaderLanguage::TYPE_FLOAT: {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.array_size > 0) {
pi.type = Variant::PACKED_FLOAT32_ARRAY;
} else {
pi.type = Variant::FLOAT;
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_RANGE) {
pi.hint = PROPERTY_HINT_RANGE;
pi.hint_string = rtos(p_uniform.hint_range[0]) + "," + rtos(p_uniform.hint_range[1]) + "," + rtos(p_uniform.hint_range[2]);
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
}
} break;
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
case ShaderLanguage::TYPE_VEC2:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.array_size > 0) {
pi.type = Variant::PACKED_VECTOR2_ARRAY;
} else {
pi.type = Variant::VECTOR2;
}
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
break;
case ShaderLanguage::TYPE_VEC3:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.array_size > 0) {
pi.type = Variant::PACKED_VECTOR3_ARRAY;
} else {
pi.type = Variant::VECTOR3;
}
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
break;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case ShaderLanguage::TYPE_VEC4: {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.array_size > 0) {
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
pi.type = Variant::PACKED_COLOR_ARRAY;
} else {
pi.type = Variant::PACKED_FLOAT32_ARRAY;
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
} else {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
pi.type = Variant::COLOR;
} else {
pi.type = Variant::PLANE;
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
}
} break;
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
case ShaderLanguage::TYPE_MAT2:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.array_size > 0) {
pi.type = Variant::PACKED_FLOAT32_ARRAY;
} else {
pi.type = Variant::TRANSFORM2D;
}
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
break;
case ShaderLanguage::TYPE_MAT3:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.array_size > 0) {
pi.type = Variant::PACKED_FLOAT32_ARRAY;
} else {
pi.type = Variant::BASIS;
}
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
break;
case ShaderLanguage::TYPE_MAT4:
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.array_size > 0) {
pi.type = Variant::PACKED_FLOAT32_ARRAY;
} else {
pi.type = Variant::TRANSFORM3D;
}
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
break;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case ShaderLanguage::TYPE_SAMPLER2D:
case ShaderLanguage::TYPE_ISAMPLER2D:
case ShaderLanguage::TYPE_USAMPLER2D: {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.array_size > 0) {
pi.type = Variant::ARRAY;
} else {
pi.type = Variant::OBJECT;
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
pi.hint = PROPERTY_HINT_RESOURCE_TYPE;
pi.hint_string = "Texture2D";
} break;
case ShaderLanguage::TYPE_SAMPLER2DARRAY:
case ShaderLanguage::TYPE_ISAMPLER2DARRAY:
case ShaderLanguage::TYPE_USAMPLER2DARRAY: {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.array_size > 0) {
pi.type = Variant::ARRAY;
} else {
pi.type = Variant::OBJECT;
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
pi.hint = PROPERTY_HINT_RESOURCE_TYPE;
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 09:34:23 -03:00
pi.hint_string = "TextureLayered";
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
} break;
case ShaderLanguage::TYPE_SAMPLER3D:
case ShaderLanguage::TYPE_ISAMPLER3D:
case ShaderLanguage::TYPE_USAMPLER3D: {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.array_size > 0) {
pi.type = Variant::ARRAY;
} else {
pi.type = Variant::OBJECT;
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
pi.hint = PROPERTY_HINT_RESOURCE_TYPE;
pi.hint_string = "Texture3D";
} break;
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 09:34:23 -03:00
case ShaderLanguage::TYPE_SAMPLERCUBE:
case ShaderLanguage::TYPE_SAMPLERCUBEARRAY: {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.array_size > 0) {
pi.type = Variant::ARRAY;
} else {
pi.type = Variant::OBJECT;
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
pi.hint = PROPERTY_HINT_RESOURCE_TYPE;
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 09:34:23 -03:00
pi.hint_string = "TextureLayered";
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
} break;
Fix various GCC compilation warnings after Vulkan merge Part of #36132.
2020-02-13 15:53:32 +01:00
case ShaderLanguage::TYPE_STRUCT: {
// FIXME: Implement this.
} break;
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
case ShaderLanguage::TYPE_MAX:
break;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
}
return pi;
}
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
uint32_t ShaderLanguage::get_datatype_size(ShaderLanguage::DataType p_type) {
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
switch (p_type) {
Fix various GCC compilation warnings after Vulkan merge Part of #36132.
2020-02-13 15:53:32 +01:00
case TYPE_VOID:
return 0;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case TYPE_BOOL:
Fix various GCC compilation warnings after Vulkan merge Part of #36132.
2020-02-13 15:53:32 +01:00
return 4;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case TYPE_BVEC2:
Fix various GCC compilation warnings after Vulkan merge Part of #36132.
2020-02-13 15:53:32 +01:00
return 8;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case TYPE_BVEC3:
Fix various GCC compilation warnings after Vulkan merge Part of #36132.
2020-02-13 15:53:32 +01:00
return 12;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case TYPE_BVEC4:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 16;
case TYPE_INT:
return 4;
case TYPE_IVEC2:
return 8;
case TYPE_IVEC3:
return 12;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case TYPE_IVEC4:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 16;
case TYPE_UINT:
return 4;
case TYPE_UVEC2:
return 8;
case TYPE_UVEC3:
return 12;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case TYPE_UVEC4:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 16;
case TYPE_FLOAT:
return 4;
case TYPE_VEC2:
return 8;
case TYPE_VEC3:
return 12;
Fix various GCC compilation warnings after Vulkan merge Part of #36132.
2020-02-13 15:53:32 +01:00
case TYPE_VEC4:
return 16;
case TYPE_MAT2:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 32; // 4 * 4 + 4 * 4
Fix various GCC compilation warnings after Vulkan merge Part of #36132.
2020-02-13 15:53:32 +01:00
case TYPE_MAT3:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 48; // 4 * 4 + 4 * 4 + 4 * 4
Fix various GCC compilation warnings after Vulkan merge Part of #36132.
2020-02-13 15:53:32 +01:00
case TYPE_MAT4:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 64;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case TYPE_SAMPLER2D:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 16;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case TYPE_ISAMPLER2D:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 16;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case TYPE_USAMPLER2D:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 16;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case TYPE_SAMPLER2DARRAY:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 16;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case TYPE_ISAMPLER2DARRAY:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 16;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case TYPE_USAMPLER2DARRAY:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 16;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case TYPE_SAMPLER3D:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 16;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case TYPE_ISAMPLER3D:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 16;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case TYPE_USAMPLER3D:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 16;
Fix various GCC compilation warnings after Vulkan merge Part of #36132.
2020-02-13 15:53:32 +01:00
case TYPE_SAMPLERCUBE:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 16;
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 09:34:23 -03:00
case TYPE_SAMPLERCUBEARRAY:
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
return 16;
Fix various GCC compilation warnings after Vulkan merge Part of #36132.
2020-02-13 15:53:32 +01:00
case TYPE_STRUCT:
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
return 0;
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
case TYPE_MAX: {
ERR_FAIL_V(0);
};
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
}
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
ERR_FAIL_V(0);
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
void ShaderLanguage::get_keyword_list(List<String> *r_keywords) {
Set<String> kws;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
int idx = 0;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (keyword_list[idx].text) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
kws.insert(keyword_list[idx].text);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
idx++;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
idx = 0;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
while (builtin_func_defs[idx].name) {
kws.insert(builtin_func_defs[idx].name);
idx++;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (Set<String>::Element *E = kws.front(); E; E = E->next()) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
r_keywords->push_back(E->get());
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
Highlight control flow keywords with a different color This makes them easier to distinguish from other keywords.
2021-04-08 16:12:22 +02:00
bool ShaderLanguage::is_control_flow_keyword(String p_keyword) {
return p_keyword == "break" ||
clang-format: Disable alignment of operands, too unreliable Sets `AlignOperands` to `DontAlign`. `clang-format` developers seem to mostly care about space-based indentation and every other version of clang-format breaks the bad mismatch of tabs and spaces that it seems to use for operand alignment. So it's better without, so that it respects our two-tabs `ContinuationIndentWidth`.
2021-10-28 15:19:35 +02:00
p_keyword == "case" ||
p_keyword == "continue" ||
p_keyword == "default" ||
p_keyword == "do" ||
p_keyword == "else" ||
p_keyword == "for" ||
p_keyword == "if" ||
p_keyword == "return" ||
p_keyword == "switch" ||
p_keyword == "while";
Highlight control flow keywords with a different color This makes them easier to distinguish from other keywords.
2021-04-08 16:12:22 +02:00
}
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 18:31:01 -03:00
void ShaderLanguage::get_builtin_funcs(List<String> *r_keywords) {
Set<String> kws;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
int idx = 0;
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 18:31:01 -03:00
while (builtin_func_defs[idx].name) {
kws.insert(builtin_func_defs[idx].name);
idx++;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (Set<String>::Element *E = kws.front(); E; E = E->next()) {
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 18:31:01 -03:00
r_keywords->push_back(E->get());
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
ShaderLanguage::DataType ShaderLanguage::get_scalar_type(DataType p_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
static const DataType scalar_types[] = {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
TYPE_VOID,
TYPE_BOOL,
TYPE_BOOL,
TYPE_BOOL,
TYPE_BOOL,
TYPE_INT,
TYPE_INT,
TYPE_INT,
TYPE_INT,
TYPE_UINT,
TYPE_UINT,
TYPE_UINT,
TYPE_UINT,
TYPE_FLOAT,
TYPE_FLOAT,
TYPE_FLOAT,
TYPE_FLOAT,
TYPE_FLOAT,
TYPE_FLOAT,
TYPE_FLOAT,
TYPE_FLOAT,
TYPE_INT,
TYPE_UINT,
TYPE_FLOAT,
};
return scalar_types[p_type];
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Fix vector reduction in shader language
2018-04-29 20:58:42 +02:00
int ShaderLanguage::get_cardinality(DataType p_type) {
static const int cardinality_table[] = {
0,
1,
2,
3,
4,
1,
2,
3,
4,
1,
2,
3,
4,
1,
2,
3,
4,
4,
Fix handling of shader constants that caused crash, closes #15166
2018-08-31 13:11:13 +02:00
9,
16,
Fix vector reduction in shader language
2018-04-29 20:58:42 +02:00
1,
1,
1,
1,
};
return cardinality_table[p_type];
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool ShaderLanguage::_get_completable_identifier(BlockNode *p_block, CompletionType p_type, StringName &identifier) {
identifier = StringName();
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
fixed uninitialized variables and false positives found by CppCheck
2018-10-24 22:20:05 +02:00
TkPos pos = { 0, 0 };
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
Token tk = _get_token();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type == TK_IDENTIFIER) {
identifier = tk.text;
pos = _get_tkpos();
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
tk = _get_token();
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type == TK_CURSOR) {
completion_type = p_type;
completion_line = tk_line;
completion_block = p_block;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
pos = _get_tkpos();
tk = _get_token();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type == TK_IDENTIFIER) {
identifier = identifier.operator String() + tk.text.operator String();
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
} else {
_set_tkpos(pos);
}
return true;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (identifier != StringName()) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
_set_tkpos(pos);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return false;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 18:23:16 -03:00
bool ShaderLanguage::_is_operator_assign(Operator p_op) const {
switch (p_op) {
case OP_ASSIGN:
case OP_ASSIGN_ADD:
case OP_ASSIGN_SUB:
case OP_ASSIGN_MUL:
case OP_ASSIGN_DIV:
case OP_ASSIGN_MOD:
case OP_ASSIGN_SHIFT_LEFT:
case OP_ASSIGN_SHIFT_RIGHT:
case OP_ASSIGN_BIT_AND:
case OP_ASSIGN_BIT_OR:
case OP_ASSIGN_BIT_XOR:
return true;
default:
return false;
}
return false;
}
Allow passing varying from fragment to light shader function
2020-12-26 14:26:19 +03:00
bool ShaderLanguage::_validate_varying_assign(ShaderNode::Varying &p_varying, String *r_message) {
Forbid varyings from assigning in custom functions to prevent crashes
2021-07-15 10:13:40 +03:00
if (current_function != String("vertex") && current_function != String("fragment")) {
*r_message = vformat(RTR("Varying may not be assigned in the '%s' function."), current_function);
Allow passing varying from fragment to light shader function
2020-12-26 14:26:19 +03:00
return false;
}
switch (p_varying.stage) {
case ShaderNode::Varying::STAGE_UNKNOWN: // first assign
Refactor GLSL shader compilation -Used a more consistent set of keywords for the shader -Remove all harcoded entry points -Re-wrote the GLSL shader parser, new system is more flexible. Allows any entry point organization. -Entry point for sky shaders is now sky(). -Entry point for particle shaders is now process().
2021-04-13 17:01:43 -03:00
if (current_function == varying_function_names.vertex) {
Allow passing varying from fragment to light shader function
2020-12-26 14:26:19 +03:00
p_varying.stage = ShaderNode::Varying::STAGE_VERTEX;
Refactor GLSL shader compilation -Used a more consistent set of keywords for the shader -Remove all harcoded entry points -Re-wrote the GLSL shader parser, new system is more flexible. Allows any entry point organization. -Entry point for sky shaders is now sky(). -Entry point for particle shaders is now process().
2021-04-13 17:01:43 -03:00
} else if (current_function == varying_function_names.fragment) {
Allow passing varying from fragment to light shader function
2020-12-26 14:26:19 +03:00
p_varying.stage = ShaderNode::Varying::STAGE_FRAGMENT;
}
break;
Allow using vertex-stage varying in both `fragment` and `light`
2021-07-22 11:41:02 +03:00
case ShaderNode::Varying::STAGE_VERTEX_TO_FRAGMENT_LIGHT:
Allow passing varying from fragment to light shader function
2020-12-26 14:26:19 +03:00
case ShaderNode::Varying::STAGE_VERTEX:
Refactor GLSL shader compilation -Used a more consistent set of keywords for the shader -Remove all harcoded entry points -Re-wrote the GLSL shader parser, new system is more flexible. Allows any entry point organization. -Entry point for sky shaders is now sky(). -Entry point for particle shaders is now process().
2021-04-13 17:01:43 -03:00
if (current_function == varying_function_names.fragment) {
Allow passing varying from fragment to light shader function
2020-12-26 14:26:19 +03:00
*r_message = RTR("Varyings which assigned in 'vertex' function may not be reassigned in 'fragment' or 'light'.");
return false;
}
break;
Forbid varyings from assigning in custom functions to prevent crashes
2021-07-15 10:13:40 +03:00
case ShaderNode::Varying::STAGE_FRAGMENT_TO_LIGHT:
Allow passing varying from fragment to light shader function
2020-12-26 14:26:19 +03:00
case ShaderNode::Varying::STAGE_FRAGMENT:
Refactor GLSL shader compilation -Used a more consistent set of keywords for the shader -Remove all harcoded entry points -Re-wrote the GLSL shader parser, new system is more flexible. Allows any entry point organization. -Entry point for sky shaders is now sky(). -Entry point for particle shaders is now process().
2021-04-13 17:01:43 -03:00
if (current_function == varying_function_names.vertex) {
Allow passing varying from fragment to light shader function
2020-12-26 14:26:19 +03:00
*r_message = RTR("Varyings which assigned in 'fragment' function may not be reassigned in 'vertex' or 'light'.");
return false;
}
break;
default:
break;
}
return true;
}
Fix shader handle constant expressions in function call
2021-04-27 14:58:32 +03:00
bool ShaderLanguage::_check_node_constness(const Node *p_node) const {
switch (p_node->type) {
case Node::TYPE_OPERATOR: {
OperatorNode *op_node = (OperatorNode *)p_node;
Fix typo in shader_language.cpp
2021-05-18 18:31:46 +03:00
for (int i = int(op_node->op == OP_CALL); i < op_node->arguments.size(); i++) {
Fix shader handle constant expressions in function call
2021-04-27 14:58:32 +03:00
if (!_check_node_constness(op_node->arguments[i])) {
return false;
}
}
} break;
case Node::TYPE_CONSTANT:
break;
case Node::TYPE_VARIABLE: {
VariableNode *varn = (VariableNode *)p_node;
if (!varn->is_const) {
return false;
}
} break;
case Node::TYPE_ARRAY: {
ArrayNode *arrn = (ArrayNode *)p_node;
if (!arrn->is_const) {
return false;
}
} break;
default:
return false;
}
return true;
}
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
bool ShaderLanguage::_validate_assign(Node *p_node, const FunctionInfo &p_function_info, String *r_message) {
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 18:23:16 -03:00
if (p_node->type == Node::TYPE_OPERATOR) {
OperatorNode *op = static_cast<OperatorNode *>(p_node);
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
Fix bad operator check in `ShaderLanguage::_validate_assign`
2018-05-16 21:28:12 +02:00
if (op->op == OP_INDEX) {
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
return _validate_assign(op->arguments[0], p_function_info, r_message);
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
} else if (_is_operator_assign(op->op)) {
//chained assignment
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
return _validate_assign(op->arguments[1], p_function_info, r_message);
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
} else if (op->op == OP_CALL) {
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 16:41:43 +02:00
if (r_message) {
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
*r_message = RTR("Assignment to function.");
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 16:41:43 +02:00
}
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
return false;
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 18:23:16 -03:00
}
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
} else if (p_node->type == Node::TYPE_MEMBER) {
MemberNode *member = static_cast<MemberNode *>(p_node);
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
if (member->has_swizzling_duplicates) {
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 16:41:43 +02:00
if (r_message) {
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
*r_message = RTR("Swizzling assignment contains duplicates.");
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 16:41:43 +02:00
}
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
return false;
}
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
return _validate_assign(member->owner, p_function_info, r_message);
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
} else if (p_node->type == Node::TYPE_VARIABLE) {
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 18:23:16 -03:00
VariableNode *var = static_cast<VariableNode *>(p_node);
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
if (shader->uniforms.has(var->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 16:41:43 +02:00
if (r_message) {
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
*r_message = RTR("Assignment to uniform.");
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 16:41:43 +02:00
}
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
return false;
}
Implemented local shader constants
2019-08-05 10:35:53 +03:00
if (shader->constants.has(var->name) || var->is_const) {
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 16:41:43 +02:00
if (r_message) {
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
*r_message = RTR("Constants cannot be modified.");
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 16:41:43 +02:00
}
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
return false;
}
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
if (!(p_function_info.built_ins.has(var->name) && p_function_info.built_ins[var->name].constant)) {
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
return true;
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 18:23:16 -03:00
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
} else if (p_node->type == Node::TYPE_ARRAY) {
Implemented local shader constants
2019-08-05 10:35:53 +03:00
ArrayNode *arr = static_cast<ArrayNode *>(p_node);
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
if (shader->constants.has(arr->name) || arr->is_const) {
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 16:41:43 +02:00
if (r_message) {
Implemented local shader constants
2019-08-05 10:35:53 +03:00
*r_message = RTR("Constants cannot be modified.");
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 16:41:43 +02:00
}
Implemented local shader constants
2019-08-05 10:35:53 +03:00
return false;
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
return true;
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 18:23:16 -03:00
}
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03: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 16:41:43 +02:00
if (r_message) {
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
*r_message = "Assignment to constant expression.";
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 16:41:43 +02:00
}
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
return false;
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 18:23:16 -03:00
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
bool ShaderLanguage::_propagate_function_call_sampler_uniform_settings(StringName p_name, int p_argument, TextureFilter p_filter, TextureRepeat p_repeat) {
Static analyzer fixes: Removes unused code in OS. Fixes return types. Fixes few typos.
2020-12-08 20:58:49 +02:00
for (int i = 0; i < shader->functions.size(); i++) {
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
if (shader->functions[i].name == p_name) {
ERR_FAIL_INDEX_V(p_argument, shader->functions[i].function->arguments.size(), false);
FunctionNode::Argument *arg = &shader->functions[i].function->arguments.write[p_argument];
if (arg->tex_builtin_check) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Sampler argument %d of function '%s' called more than once using both built-ins and uniform textures, this is not supported (use either one or the other)."), p_argument, String(p_name)));
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
return false;
} else if (arg->tex_argument_check) {
//was checked, verify that filter and repeat are the same
if (arg->tex_argument_filter == p_filter && arg->tex_argument_repeat == p_repeat) {
return true;
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Sampler argument %d of function '%s' called more than once using textures that differ in either filter or repeat setting."), p_argument, String(p_name)));
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
return false;
}
} else {
arg->tex_argument_check = true;
arg->tex_argument_filter = p_filter;
arg->tex_argument_repeat = p_repeat;
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
for (KeyValue<StringName, Set<int>> &E : arg->tex_argument_connect) {
for (Set<int>::Element *F = E.value.front(); F; F = F->next()) {
if (!_propagate_function_call_sampler_uniform_settings(E.key, F->get(), p_filter, p_repeat)) {
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
return false;
}
}
}
return true;
}
}
}
ERR_FAIL_V(false); //bug? function not found
}
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 14:29:06 +02:00
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
bool ShaderLanguage::_propagate_function_call_sampler_builtin_reference(StringName p_name, int p_argument, const StringName &p_builtin) {
Static analyzer fixes: Removes unused code in OS. Fixes return types. Fixes few typos.
2020-12-08 20:58:49 +02:00
for (int i = 0; i < shader->functions.size(); i++) {
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
if (shader->functions[i].name == p_name) {
ERR_FAIL_INDEX_V(p_argument, shader->functions[i].function->arguments.size(), false);
FunctionNode::Argument *arg = &shader->functions[i].function->arguments.write[p_argument];
if (arg->tex_argument_check) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Sampler argument %d of function '%s' called more than once using both built-ins and uniform textures, this is not supported (use either one or the other)."), p_argument, String(p_name)));
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
return false;
} else if (arg->tex_builtin_check) {
//was checked, verify that the built-in is the same
if (arg->tex_builtin == p_builtin) {
return true;
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Sampler argument %d of function '%s' called more than once using different built-ins. Only calling with the same built-in is supported."), p_argument, String(p_name)));
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
return false;
}
} else {
arg->tex_builtin_check = true;
arg->tex_builtin = p_builtin;
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
for (KeyValue<StringName, Set<int>> &E : arg->tex_argument_connect) {
for (Set<int>::Element *F = E.value.front(); F; F = F->next()) {
if (!_propagate_function_call_sampler_builtin_reference(E.key, F->get(), p_builtin)) {
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
return false;
}
}
}
return true;
}
}
}
ERR_FAIL_V(false); //bug? function not found
}
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
Error ShaderLanguage::_parse_array_size(BlockNode *p_block, const FunctionInfo &p_function_info, bool p_forbid_unknown_size, Node **r_size_expression, int *r_array_size, bool *r_unknown_size) {
bool error = false;
if (r_array_size != nullptr && *r_array_size > 0) {
error = true;
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
}
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
if (r_unknown_size != nullptr && *r_unknown_size) {
error = true;
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
}
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
if (error) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Array size is already defined.")));
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
return ERR_PARSE_ERROR;
}
TkPos pos = _get_tkpos();
Token tk = _get_token();
if (tk.type == TK_BRACKET_CLOSE) {
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
if (p_forbid_unknown_size) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Unknown array size is forbidden in that context.")));
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
return ERR_PARSE_ERROR;
}
if (r_unknown_size != nullptr) {
*r_unknown_size = true;
}
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
} else {
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
int array_size = 0;
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
if (!tk.is_integer_constant() || ((int)tk.constant) <= 0) {
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
_set_tkpos(pos);
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
Node *n = _parse_and_reduce_expression(p_block, p_function_info);
if (n) {
if (n->type == Node::TYPE_VARIABLE) {
VariableNode *vn = static_cast<VariableNode *>(n);
if (vn) {
ConstantNode::Value v;
DataType data_type;
bool is_const = false;
_find_identifier(p_block, false, p_function_info, vn->name, &data_type, nullptr, &is_const, nullptr, nullptr, &v);
if (is_const) {
if (data_type == TYPE_INT) {
int32_t value = v.sint;
if (value > 0) {
array_size = value;
}
} else if (data_type == TYPE_UINT) {
uint32_t value = v.uint;
if (value > 0U) {
array_size = value;
}
}
}
}
} else if (n->type == Node::TYPE_OPERATOR) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Array size expressions are not supported.")));
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
return ERR_PARSE_ERROR;
}
if (r_size_expression != nullptr) {
*r_size_expression = n;
}
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
}
} else if (((int)tk.constant) > 0) {
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
array_size = (uint32_t)tk.constant;
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
}
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
if (array_size <= 0) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected a positive integer constant."));
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_BRACKET_CLOSE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("]");
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
return ERR_PARSE_ERROR;
}
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
if (r_array_size != nullptr) {
*r_array_size = array_size;
}
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
}
return OK;
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
ShaderLanguage::Node *ShaderLanguage::_parse_array_constructor(BlockNode *p_block, const FunctionInfo &p_function_info) {
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
DataType type = TYPE_VOID;
String struct_name = "";
int array_size = 0;
bool auto_size = false;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
bool undefined_size = false;
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
Token tk = _get_token();
if (tk.type == TK_CURLY_BRACKET_OPEN) {
auto_size = true;
} else {
if (shader->structs.has(tk.text)) {
type = TYPE_STRUCT;
struct_name = tk.text;
} else {
if (!is_token_variable_datatype(tk.type)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Invalid data type for the array."));
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
return nullptr;
}
type = get_token_datatype(tk.type);
}
tk = _get_token();
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (tk.type == TK_BRACKET_OPEN) {
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
Error error = _parse_array_size(p_block, p_function_info, false, nullptr, &array_size, &undefined_size);
if (error != OK) {
return nullptr;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
}
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
tk = _get_token();
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("[");
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return nullptr;
}
}
ArrayConstructNode *an = alloc_node<ArrayConstructNode>();
if (tk.type == TK_PARENTHESIS_OPEN || auto_size) { // initialization
int idx = 0;
while (true) {
Node *n = _parse_and_reduce_expression(p_block, p_function_info);
if (!n) {
return nullptr;
}
// define type by using the first member
if (auto_size && idx == 0) {
type = n->get_datatype();
if (type == TYPE_STRUCT) {
struct_name = n->get_datatype_name();
}
} else {
if (!_compare_datatypes(type, struct_name, 0, n->get_datatype(), n->get_datatype_name(), 0)) {
return nullptr;
}
}
tk = _get_token();
if (tk.type == TK_COMMA) {
an->initializer.push_back(n);
} else if (!auto_size && tk.type == TK_PARENTHESIS_CLOSE) {
an->initializer.push_back(n);
break;
} else if (auto_size && tk.type == TK_CURLY_BRACKET_CLOSE) {
an->initializer.push_back(n);
break;
} else {
if (auto_size) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("}", ",");
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(")", ",");
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
}
return nullptr;
}
idx++;
}
if (!auto_size && !undefined_size && an->initializer.size() != array_size) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Array size mismatch."));
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return nullptr;
}
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected array initialization."));
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return nullptr;
}
an->datatype = type;
an->struct_name = struct_name;
return an;
}
ShaderLanguage::Node *ShaderLanguage::_parse_array_constructor(BlockNode *p_block, const FunctionInfo &p_function_info, DataType p_type, const StringName &p_struct_name, int p_array_size) {
DataType type = TYPE_VOID;
String struct_name = "";
int array_size = 0;
bool auto_size = false;
TkPos prev_pos = _get_tkpos();
Token tk = _get_token();
if (tk.type == TK_CURLY_BRACKET_OPEN) {
auto_size = true;
} else {
if (shader->structs.has(tk.text)) {
type = TYPE_STRUCT;
struct_name = tk.text;
} else {
if (!is_token_variable_datatype(tk.type)) {
_set_tkpos(prev_pos);
Node *n = _parse_and_reduce_expression(p_block, p_function_info);
if (!n) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Invalid data type for the array."));
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return nullptr;
}
if (!_compare_datatypes(p_type, p_struct_name, p_array_size, n->get_datatype(), n->get_datatype_name(), n->get_array_size())) {
return nullptr;
}
return n;
}
type = get_token_datatype(tk.type);
}
tk = _get_token();
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
if (tk.type == TK_BRACKET_OPEN) {
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
bool is_unknown_size = false;
Error error = _parse_array_size(p_block, p_function_info, false, nullptr, &array_size, &is_unknown_size);
if (error != OK) {
return nullptr;
}
if (is_unknown_size) {
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
array_size = p_array_size;
}
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
tk = _get_token();
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("[");
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
return nullptr;
}
if (type != p_type || struct_name != p_struct_name || array_size != p_array_size) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
String from;
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
if (type == TYPE_STRUCT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
from += struct_name;
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
from += get_datatype_name(type);
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
from += "[";
from += itos(array_size);
from += "]'";
String to;
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
if (type == TYPE_STRUCT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
to += p_struct_name;
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
to += get_datatype_name(p_type);
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
to += "[";
to += itos(p_array_size);
to += "]'";
_set_error(vformat(RTR("Cannot convert from '%s' to '%s'."), from, to));
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
return nullptr;
}
}
ArrayConstructNode *an = alloc_node<ArrayConstructNode>();
an->datatype = p_type;
an->struct_name = p_struct_name;
if (tk.type == TK_PARENTHESIS_OPEN || auto_size) { // initialization
while (true) {
Node *n = _parse_and_reduce_expression(p_block, p_function_info);
if (!n) {
return nullptr;
}
Fix shader crash when passing array.length to functions and similar cases
2021-10-05 09:47:50 +03:00
if (!_compare_datatypes(p_type, p_struct_name, 0, n->get_datatype(), n->get_datatype_name(), n->get_array_size())) {
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
return nullptr;
}
tk = _get_token();
if (tk.type == TK_COMMA) {
an->initializer.push_back(n);
} else if (!auto_size && tk.type == TK_PARENTHESIS_CLOSE) {
an->initializer.push_back(n);
break;
} else if (auto_size && tk.type == TK_CURLY_BRACKET_CLOSE) {
an->initializer.push_back(n);
break;
} else {
if (auto_size) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("}", ",");
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(")", ",");
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
}
return nullptr;
}
}
if (an->initializer.size() != p_array_size) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Array size mismatch."));
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
return nullptr;
}
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected array initialization."));
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
return nullptr;
}
return an;
}
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, const FunctionInfo &p_function_info) {
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
Vector<Expression> expression;
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
//Vector<TokenType> operators;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (true) {
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
Node *expr = nullptr;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
TkPos prepos = _get_tkpos();
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Token tk = _get_token();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
TkPos pos = _get_tkpos();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
bool is_const = false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type == TK_PARENTHESIS_OPEN) {
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
//handle subexpression
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
expr = _parse_and_reduce_expression(p_block, p_function_info);
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 16:41:43 +02:00
if (!expr) {
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
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 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type != TK_PARENTHESIS_CLOSE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected ')' in expression."));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Rename TYPE_REAL to TYPE_FLOAT To be consistent with the naming everywhere else.
2020-12-04 09:25:14 -03:00
} else if (tk.type == TK_FLOAT_CONSTANT) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
ConstantNode *constant = alloc_node<ConstantNode>();
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
ConstantNode::Value v;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
v.real = tk.constant;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
constant->values.push_back(v);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
constant->datatype = TYPE_FLOAT;
expr = constant;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (tk.type == TK_INT_CONSTANT) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
ConstantNode *constant = alloc_node<ConstantNode>();
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
ConstantNode::Value v;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
v.sint = tk.constant;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
constant->values.push_back(v);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
constant->datatype = TYPE_INT;
expr = constant;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
} else if (tk.type == TK_UINT_CONSTANT) {
ConstantNode *constant = alloc_node<ConstantNode>();
ConstantNode::Value v;
v.uint = tk.constant;
constant->values.push_back(v);
constant->datatype = TYPE_UINT;
expr = constant;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (tk.type == TK_TRUE) {
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
//handle true constant
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
ConstantNode *constant = alloc_node<ConstantNode>();
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
ConstantNode::Value v;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
v.boolean = true;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
constant->values.push_back(v);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
constant->datatype = TYPE_BOOL;
expr = constant;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (tk.type == TK_FALSE) {
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
//handle false constant
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
ConstantNode *constant = alloc_node<ConstantNode>();
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
ConstantNode::Value v;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
v.boolean = false;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
constant->values.push_back(v);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
constant->datatype = TYPE_BOOL;
expr = constant;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (tk.type == TK_TYPE_VOID) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
//make sure void is not used in expression
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Void value not allowed in expression."));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
} else if (is_token_nonvoid_datatype(tk.type) || tk.type == TK_CURLY_BRACKET_OPEN) {
if (tk.type == TK_CURLY_BRACKET_OPEN) {
//array constructor
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
_set_tkpos(prepos);
expr = _parse_array_constructor(p_block, p_function_info);
} else {
DataType datatype;
DataPrecision precision;
bool precision_defined = false;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (is_token_precision(tk.type)) {
precision = get_token_precision(tk.type);
precision_defined = true;
tk = _get_token();
}
datatype = get_token_datatype(tk.type);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (tk.type == TK_BRACKET_OPEN) {
//array constructor
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
_set_tkpos(prepos);
expr = _parse_array_constructor(p_block, p_function_info);
} else {
if (tk.type != TK_PARENTHESIS_OPEN) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected '(' after the type name."));
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return nullptr;
}
//basic type constructor
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
OperatorNode *func = alloc_node<OperatorNode>();
func->op = OP_CONSTRUCT;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (precision_defined) {
func->return_precision_cache = precision;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
VariableNode *funcname = alloc_node<VariableNode>();
funcname->name = get_datatype_name(datatype);
func->arguments.push_back(funcname);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
int carg = -1;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
bool ok = _parse_function_arguments(p_block, p_function_info, func, &carg);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (carg >= 0) {
completion_type = COMPLETION_CALL_ARGUMENTS;
completion_line = tk_line;
completion_block = p_block;
completion_function = funcname->name;
completion_argument = carg;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!ok) {
return nullptr;
}
if (!_validate_function_call(p_block, p_function_info, func, &func->return_cache, &func->struct_name)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("No matching constructor found for: '%s'."), String(funcname->name)));
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return nullptr;
}
expr = _reduce_expression(p_block, func);
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (tk.type == TK_IDENTIFIER) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
_set_tkpos(prepos);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
StringName identifier;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
StructNode *pstruct = nullptr;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
bool struct_init = false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
_get_completable_identifier(p_block, COMPLETION_IDENTIFIER, identifier);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (shader->structs.has(identifier)) {
pstruct = shader->structs[identifier].shader_struct;
struct_init = true;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
tk = _get_token();
if (tk.type == TK_PARENTHESIS_OPEN) {
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (struct_init) { //a struct constructor
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
const StringName &name = identifier;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
OperatorNode *func = alloc_node<OperatorNode>();
func->op = OP_STRUCT;
func->struct_name = name;
func->return_cache = TYPE_STRUCT;
VariableNode *funcname = alloc_node<VariableNode>();
funcname->name = name;
func->arguments.push_back(funcname);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
for (int i = 0; i < pstruct->members.size(); i++) {
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
Node *nexpr;
Prevent shader crash if name of variable overrides function name
2019-10-06 20:35:41 +03:00
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
if (pstruct->members[i]->array_size != 0) {
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
nexpr = _parse_array_constructor(p_block, p_function_info, pstruct->members[i]->get_datatype(), pstruct->members[i]->struct_name, pstruct->members[i]->array_size);
if (!nexpr) {
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
}
} else {
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
nexpr = _parse_and_reduce_expression(p_block, p_function_info);
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
if (!nexpr) {
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
}
if (!_compare_datatypes_in_nodes(pstruct->members[i], nexpr)) {
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
}
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (i + 1 < pstruct->members.size()) {
tk = _get_token();
if (tk.type != TK_COMMA) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(",");
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
}
func->arguments.push_back(nexpr);
}
tk = _get_token();
if (tk.type != TK_PARENTHESIS_CLOSE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(")");
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 18:31:01 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
expr = func;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
} else { //a function call
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
const StringName &name = identifier;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
OperatorNode *func = alloc_node<OperatorNode>();
func->op = OP_CALL;
VariableNode *funcname = alloc_node<VariableNode>();
funcname->name = name;
func->arguments.push_back(funcname);
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
int carg = -1;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
bool ok = _parse_function_arguments(p_block, p_function_info, func, &carg);
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
// Check if block has a variable with the same name as function to prevent shader crash.
ShaderLanguage::BlockNode *bnode = p_block;
while (bnode) {
if (bnode->variables.has(name)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected a function name."));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
bnode = bnode->parent_block;
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
//test if function was parsed first
int function_index = -1;
for (int i = 0; i < shader->functions.size(); i++) {
if (shader->functions[i].name == name) {
//add to current function as dependency
for (int j = 0; j < shader->functions.size(); j++) {
if (shader->functions[j].name == current_function) {
shader->functions.write[j].uses_function.insert(name);
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
break;
}
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
//see if texture arguments must connect
function_index = i;
break;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (carg >= 0) {
completion_type = COMPLETION_CALL_ARGUMENTS;
completion_line = tk_line;
completion_block = p_block;
completion_function = funcname->name;
completion_argument = carg;
}
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 16:41:43 +02:00
if (!ok) {
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
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 16:41:43 +02:00
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
if (!_validate_function_call(p_block, p_function_info, func, &func->return_cache, &func->struct_name)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("No matching function found for: '%s'."), String(funcname->name)));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
completion_class = TAG_GLOBAL; // reset sub-class
if (function_index >= 0) {
//connect texture arguments, so we can cache in the
//argument what type of filter and repeat to use
FunctionNode *call_function = shader->functions[function_index].function;
if (call_function) {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
func->return_cache = call_function->get_datatype();
func->struct_name = call_function->get_datatype_name();
func->return_array_size = call_function->get_array_size();
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
//get current base function
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
FunctionNode *base_function = nullptr;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
{
BlockNode *b = p_block;
while (b) {
if (b->parent_function) {
base_function = b->parent_function;
break;
} else {
b = b->parent_block;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
}
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
ERR_FAIL_COND_V(!base_function, nullptr); //bug, wtf
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
for (int i = 0; i < call_function->arguments.size(); i++) {
int argidx = i + 1;
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
if (argidx < func->arguments.size()) {
Allow pass varyings as out param to the function, when it's possible
2021-12-23 14:04:30 +03:00
bool error = false;
Node *n = func->arguments[argidx];
ArgumentQualifier arg_qual = call_function->arguments[i].qualifier;
bool is_out_arg = arg_qual != ArgumentQualifier::ARGUMENT_QUALIFIER_IN;
if (n->type == Node::TYPE_VARIABLE || n->type == Node::TYPE_ARRAY) {
StringName varname;
if (n->type == Node::TYPE_VARIABLE) {
VariableNode *vn = static_cast<VariableNode *>(n);
varname = vn->name;
} else { // TYPE_ARRAY
ArrayNode *an = static_cast<ArrayNode *>(n);
varname = an->name;
}
if (shader->varyings.has(varname)) {
switch (shader->varyings[varname].stage) {
case ShaderNode::Varying::STAGE_UNKNOWN: {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Varying '%s' must be assigned in the vertex or fragment function first."), varname));
Allow pass varyings as out param to the function, when it's possible
2021-12-23 14:04:30 +03:00
return nullptr;
}
case ShaderNode::Varying::STAGE_VERTEX_TO_FRAGMENT_LIGHT:
[[fallthrough]];
case ShaderNode::Varying::STAGE_VERTEX:
if (is_out_arg && current_function != varying_function_names.vertex) { // inout/out
error = true;
}
break;
case ShaderNode::Varying::STAGE_FRAGMENT_TO_LIGHT:
[[fallthrough]];
case ShaderNode::Varying::STAGE_FRAGMENT:
if (!is_out_arg) {
if (current_function != varying_function_names.fragment && current_function != varying_function_names.light) {
error = true;
}
} else if (current_function != varying_function_names.fragment) { // inout/out
error = true;
}
break;
default:
break;
}
if (error) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Varying '%s' cannot be passed for the '%s' parameter in that context."), varname, _get_qualifier_str(arg_qual)));
Allow pass varyings as out param to the function, when it's possible
2021-12-23 14:04:30 +03:00
return nullptr;
}
}
}
bool is_const_arg = call_function->arguments[i].is_const;
if (is_const_arg || is_out_arg) {
StringName varname;
if (n->type == Node::TYPE_CONSTANT || n->type == Node::TYPE_OPERATOR || n->type == Node::TYPE_ARRAY_CONSTRUCT) {
if (!is_const_arg) {
Allow passing non-variable constant to const function param in shaders
2021-11-19 11:25:23 +03:00
error = true;
}
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
} else if (n->type == Node::TYPE_ARRAY) {
ArrayNode *an = static_cast<ArrayNode *>(n);
Allow pass varyings as out param to the function, when it's possible
2021-12-23 14:04:30 +03:00
if (!is_const_arg && (an->call_expression != nullptr || an->is_const)) {
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
error = true;
}
Allow pass varyings as out param to the function, when it's possible
2021-12-23 14:04:30 +03:00
varname = an->name;
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
} else if (n->type == Node::TYPE_VARIABLE) {
VariableNode *vn = static_cast<VariableNode *>(n);
Allow pass varyings as out param to the function, when it's possible
2021-12-23 14:04:30 +03:00
if (vn->is_const && !is_const_arg) {
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
error = true;
}
Allow pass varyings as out param to the function, when it's possible
2021-12-23 14:04:30 +03:00
varname = vn->name;
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
} else if (n->type == Node::TYPE_MEMBER) {
MemberNode *mn = static_cast<MemberNode *>(n);
Allow pass varyings as out param to the function, when it's possible
2021-12-23 14:04:30 +03:00
if (mn->basetype_const && is_out_arg) {
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
error = true;
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
Allow pass varyings as out param to the function, when it's possible
2021-12-23 14:04:30 +03:00
if (!error && varname != StringName()) {
if (shader->constants.has(varname)) {
error = true;
} else if (shader->uniforms.has(varname)) {
error = true;
} else if (p_function_info.built_ins.has(varname)) {
BuiltInInfo info = p_function_info.built_ins[varname];
if (info.constant) {
error = true;
}
}
}
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
if (error) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("A constant value cannot be passed for '%s' parameter."), _get_qualifier_str(arg_qual)));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
}
if (is_sampler_type(call_function->arguments[i].type)) {
//let's see where our argument comes from
ERR_CONTINUE(n->type != Node::TYPE_VARIABLE); //bug? this should always be a variable
VariableNode *vn = static_cast<VariableNode *>(n);
StringName varname = vn->name;
if (shader->uniforms.has(varname)) {
//being sampler, this either comes from a uniform
ShaderNode::Uniform *u = &shader->uniforms[varname];
ERR_CONTINUE(u->type != call_function->arguments[i].type); //this should have been validated previously
//propagate
if (!_propagate_function_call_sampler_uniform_settings(name, i, u->filter, u->repeat)) {
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
}
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
} else if (p_function_info.built_ins.has(varname)) {
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
//a built-in
if (!_propagate_function_call_sampler_builtin_reference(name, i, varname)) {
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
}
} else {
//or this comes from an argument, but nothing else can be a sampler
bool found = false;
for (int j = 0; j < base_function->arguments.size(); j++) {
if (base_function->arguments[j].name == varname) {
if (!base_function->arguments[j].tex_argument_connect.has(call_function->name)) {
base_function->arguments.write[j].tex_argument_connect[call_function->name] = Set<int>();
}
base_function->arguments.write[j].tex_argument_connect[call_function->name].insert(i);
found = true;
break;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
}
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
ERR_CONTINUE(!found);
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
}
}
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
} else {
break;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
}
}
}
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
expr = func;
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
#ifdef DEBUG_ENABLED
if (check_warnings) {
Added a shader warning about unused local variable
2021-06-29 14:34:54 +03:00
StringName func_name;
if (p_block && p_block->parent_function) {
func_name = p_block->parent_function->name;
}
_parse_used_identifier(name, IdentifierType::IDENTIFIER_FUNCTION, func_name);
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
}
#endif // DEBUG_ENABLED
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} else {
//an identifier
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
last_name = identifier;
last_type = IDENTIFIER_MAX;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
_set_tkpos(pos);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataType data_type;
IdentifierType ident_type;
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
int array_size = 0;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
StringName struct_name;
Fix shader crash when using local var with the same name as varying
2021-08-13 08:12:04 +03:00
bool is_local = false;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Prevent shader crash if invalid builtin used after array member accessor
2020-02-07 14:50:11 +03:00
if (p_block && p_block->block_tag != SubClassTag::TAG_GLOBAL) {
int idx = 0;
bool found = false;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Prevent shader crash if invalid builtin used after array member accessor
2020-02-07 14:50:11 +03:00
while (builtin_func_defs[idx].name) {
if (builtin_func_defs[idx].tag == p_block->block_tag && builtin_func_defs[idx].name == identifier) {
found = true;
break;
}
idx++;
}
if (!found) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Unknown identifier in expression: '%s'."), String(identifier)));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Prevent shader crash if invalid builtin used after array member accessor
2020-02-07 14:50:11 +03:00
}
} else {
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
if (!_find_identifier(p_block, false, p_function_info, identifier, &data_type, &ident_type, &is_const, &array_size, &struct_name)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Unknown identifier in expression: '%s'."), String(identifier)));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Prevent shader crash if invalid builtin used after array member accessor
2020-02-07 14:50:11 +03:00
}
Allow passing varying from fragment to light shader function
2020-12-26 14:26:19 +03:00
if (ident_type == IDENTIFIER_VARYING) {
TkPos prev_pos = _get_tkpos();
Token next_token = _get_token();
Fix shader crash when using varying array in fragment->light context
2021-08-11 09:38:38 +03:00
// An array of varyings.
if (next_token.type == TK_BRACKET_OPEN) {
_get_token(); // Pass constant.
_get_token(); // Pass TK_BRACKET_CLOSE.
next_token = _get_token();
}
Allow passing varying from fragment to light shader function
2020-12-26 14:26:19 +03:00
_set_tkpos(prev_pos);
Prevents shader crashing if varying assigned incorrectly
2021-07-26 14:38:33 +03:00
Fix shader crash when using varying array in fragment->light context
2021-08-11 09:38:38 +03:00
String error;
Prevents shader crashing if varying assigned incorrectly
2021-07-26 14:38:33 +03:00
if (is_token_operator_assign(next_token.type)) {
Allow passing varying from fragment to light shader function
2020-12-26 14:26:19 +03:00
if (!_validate_varying_assign(shader->varyings[identifier], &error)) {
_set_error(error);
return nullptr;
}
} else {
Allow pass varyings as out param to the function, when it's possible
2021-12-23 14:04:30 +03:00
ShaderNode::Varying &var = shader->varyings[identifier];
switch (var.stage) {
case ShaderNode::Varying::STAGE_VERTEX:
if (current_function == varying_function_names.fragment || current_function == varying_function_names.light) {
var.stage = ShaderNode::Varying::STAGE_VERTEX_TO_FRAGMENT_LIGHT;
}
break;
case ShaderNode::Varying::STAGE_FRAGMENT:
if (current_function == varying_function_names.light) {
var.stage = ShaderNode::Varying::STAGE_FRAGMENT_TO_LIGHT;
}
break;
default:
break;
Allow passing varying from fragment to light shader function
2020-12-26 14:26:19 +03:00
}
}
}
Prevent shader crash if invalid builtin used after array member accessor
2020-02-07 14:50:11 +03:00
if (ident_type == IDENTIFIER_FUNCTION) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Can't use function as identifier: '%s'."), String(identifier)));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Prevent shader crash if invalid builtin used after array member accessor
2020-02-07 14:50:11 +03:00
}
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
if (is_const) {
last_type = IDENTIFIER_CONSTANT;
} else {
last_type = ident_type;
}
Fix shader crash when using local var with the same name as varying
2021-08-13 08:12:04 +03:00
is_local = ident_type == IDENTIFIER_LOCAL_VAR || ident_type == IDENTIFIER_FUNCTION_ARGUMENT;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
Node *index_expression = nullptr;
Node *call_expression = nullptr;
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
Node *assign_expression = nullptr;
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
if (array_size > 0) {
Fix shader crash when passing array.length to functions and similar cases
2021-10-05 09:47:50 +03:00
prepos = _get_tkpos();
tk = _get_token();
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
Fix shader crash when passing array.length to functions and similar cases
2021-10-05 09:47:50 +03:00
if (tk.type == TK_OP_ASSIGN) {
if (is_const) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Constants cannot be modified."));
Fix shader crash when passing array.length to functions and similar cases
2021-10-05 09:47:50 +03:00
return nullptr;
}
assign_expression = _parse_array_constructor(p_block, p_function_info, data_type, struct_name, array_size);
if (!assign_expression) {
return nullptr;
}
} else if (tk.type == TK_PERIOD) {
completion_class = TAG_ARRAY;
p_block->block_tag = SubClassTag::TAG_ARRAY;
call_expression = _parse_and_reduce_expression(p_block, p_function_info);
p_block->block_tag = SubClassTag::TAG_GLOBAL;
if (!call_expression) {
return nullptr;
}
data_type = call_expression->get_datatype();
} else if (tk.type == TK_BRACKET_OPEN) { // indexing
index_expression = _parse_and_reduce_expression(p_block, p_function_info);
if (!index_expression) {
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
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 16:41:43 +02:00
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
Fix shader crash when passing array to index expression
2021-10-07 10:46:41 +03:00
if (index_expression->get_array_size() != 0 || (index_expression->get_datatype() != TYPE_INT && index_expression->get_datatype() != TYPE_UINT)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Only integer expressions are allowed for indexing."));
Fix shader crash when passing array.length to functions and similar cases
2021-10-05 09:47:50 +03:00
return nullptr;
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
Fix shader crash when passing array.length to functions and similar cases
2021-10-05 09:47:50 +03:00
if (index_expression->type == Node::TYPE_CONSTANT) {
ConstantNode *cnode = (ConstantNode *)index_expression;
if (cnode) {
if (!cnode->values.is_empty()) {
int value = cnode->values[0].sint;
if (value < 0 || value >= array_size) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), value, 0, array_size - 1));
Fix shader crash when passing array.length to functions and similar cases
2021-10-05 09:47:50 +03:00
return nullptr;
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
}
}
}
Fix shader crash when passing array.length to functions and similar cases
2021-10-05 09:47:50 +03:00
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
Fix shader crash when passing array.length to functions and similar cases
2021-10-05 09:47:50 +03:00
tk = _get_token();
if (tk.type != TK_BRACKET_CLOSE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("]");
Fix shader crash when passing array.length to functions and similar cases
2021-10-05 09:47:50 +03:00
return nullptr;
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
}
Fix shader crash when passing array.length to functions and similar cases
2021-10-05 09:47:50 +03:00
} else {
_set_tkpos(prepos);
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
}
ArrayNode *arrname = alloc_node<ArrayNode>();
arrname->name = identifier;
arrname->datatype_cache = data_type;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
arrname->struct_name = struct_name;
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
arrname->index_expression = index_expression;
arrname->call_expression = call_expression;
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
arrname->assign_expression = assign_expression;
Implemented local shader constants
2019-08-05 10:35:53 +03:00
arrname->is_const = is_const;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
arrname->array_size = array_size;
Fix shader crash when using local var with the same name as varying
2021-08-13 08:12:04 +03:00
arrname->is_local = is_local;
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
expr = arrname;
} else {
VariableNode *varname = alloc_node<VariableNode>();
varname->name = identifier;
varname->datatype_cache = data_type;
Implemented local shader constants
2019-08-05 10:35:53 +03:00
varname->is_const = is_const;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
varname->struct_name = struct_name;
Fix shader crash when using local var with the same name as varying
2021-08-13 08:12:04 +03:00
varname->is_local = is_local;
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
expr = varname;
}
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
#ifdef DEBUG_ENABLED
if (check_warnings) {
Added a shader warning about unused local variable
2021-06-29 14:34:54 +03:00
StringName func_name;
Fix incorrect unused local var warning in shader blocks
2022-01-23 20:22:31 +03:00
BlockNode *b = p_block;
Added a shader warning about unused local variable
2021-06-29 14:34:54 +03:00
Fix incorrect unused local var warning in shader blocks
2022-01-23 20:22:31 +03:00
while (b) {
if (b->parent_function) {
func_name = b->parent_function->name;
break;
} else {
b = b->parent_block;
}
Added a shader warning about unused local variable
2021-06-29 14:34:54 +03:00
}
_parse_used_identifier(identifier, ident_type, func_name);
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
}
#endif // DEBUG_ENABLED
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (tk.type == TK_OP_ADD) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
continue; //this one does nothing
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (tk.type == TK_OP_SUB || tk.type == TK_OP_NOT || tk.type == TK_OP_BIT_INVERT || tk.type == TK_OP_INCREMENT || tk.type == TK_OP_DECREMENT) {
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
Expression e;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
e.is_op = true;
switch (tk.type) {
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
case TK_OP_SUB:
e.op = OP_NEGATE;
break;
case TK_OP_NOT:
e.op = OP_NOT;
break;
case TK_OP_BIT_INVERT:
e.op = OP_BIT_INVERT;
break;
case TK_OP_INCREMENT:
e.op = OP_INCREMENT;
break;
case TK_OP_DECREMENT:
e.op = OP_DECREMENT;
break;
default:
ERR_FAIL_V(nullptr);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
expression.push_back(e);
continue;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
} else {
Allow multiple declarations in for loop in a shader
2022-02-03 11:13:20 +03:00
bool valid = false;
if (p_block && p_block->block_type == BlockNode::BLOCK_TYPE_FOR_EXPRESSION && tk.type == TK_PARENTHESIS_CLOSE) {
valid = true;
Allow using empty statements in the shader, added formatting warning
2021-11-30 23:28:35 +03:00
_set_tkpos(prepos);
OperatorNode *func = alloc_node<OperatorNode>();
func->op = OP_EMPTY;
expr = func;
}
Allow multiple declarations in for loop in a shader
2022-02-03 11:13:20 +03:00
if (!valid) {
if (tk.type != TK_SEMICOLON) {
_set_error(vformat(RTR("Expected expression, found: '%s'."), get_token_text(tk)));
return nullptr;
} else {
#ifdef DEBUG_ENABLED
Few more fixes to for loop in shaders
2022-02-04 08:40:42 +03:00
if (!p_block || (p_block->block_type != BlockNode::BLOCK_TYPE_FOR_INIT && p_block->block_type != BlockNode::BLOCK_TYPE_FOR_CONDITION)) {
if (check_warnings && HAS_WARNING(ShaderWarning::FORMATTING_ERROR_FLAG)) {
_add_line_warning(ShaderWarning::FORMATTING_ERROR, RTR("Empty statement. Remove ';' to fix this warning."));
}
Allow multiple declarations in for loop in a shader
2022-02-03 11:13:20 +03:00
}
#endif // DEBUG_ENABLED
_set_tkpos(prepos);
OperatorNode *func = alloc_node<OperatorNode>();
func->op = OP_EMPTY;
expr = func;
}
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
ERR_FAIL_COND_V(!expr, nullptr);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
/* OK now see what's NEXT to the operator.. */
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (true) {
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
TkPos pos2 = _get_tkpos();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Fixed error due to bad cursor handling when parsing shader code Fixed completion error log thrown on "no auto-completion found" for typings with no completion.
2018-07-14 19:59:11 +02:00
if (tk.type == TK_CURSOR) {
//do nothing
} else if (tk.type == TK_PERIOD) {
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
DataType dt = expr->get_datatype();
String st = expr->get_datatype_name();
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!expr->is_indexed() && expr->get_array_size() > 0) {
completion_class = TAG_ARRAY;
p_block->block_tag = SubClassTag::TAG_ARRAY;
Node *call_expression = _parse_and_reduce_expression(p_block, p_function_info);
p_block->block_tag = SubClassTag::TAG_GLOBAL;
if (!call_expression) {
return nullptr;
}
expr = call_expression;
break;
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
StringName identifier;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (_get_completable_identifier(p_block, dt == TYPE_STRUCT ? COMPLETION_STRUCT : COMPLETION_INDEX, identifier)) {
if (dt == TYPE_STRUCT) {
completion_struct = st;
} else {
completion_base = dt;
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (identifier == StringName()) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an identifier as a member."));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
String ident = identifier;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool ok = true;
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
bool repeated = false;
Fix some code found by Coverity Scan and PVS Studio
2019-07-23 09:14:31 +02:00
DataType member_type = TYPE_VOID;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
StringName member_struct_name = "";
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
int array_size = 0;
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
Set<char> position_symbols;
Set<char> color_symbols;
Set<char> texture_symbols;
bool mix_error = false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
switch (dt) {
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
case TYPE_STRUCT: {
ok = false;
String member_name = String(ident.ptr());
if (shader->structs.has(st)) {
StructNode *n = shader->structs[st].shader_struct;
Use const references where possible for List range iterators
2021-07-24 15:46:25 +02:00
for (const MemberNode *E : n->members) {
Use C++ iterators for Lists in many situations
2021-07-15 23:45:57 -04:00
if (String(E->name) == member_name) {
member_type = E->datatype;
array_size = E->array_size;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (member_type == TYPE_STRUCT) {
Use C++ iterators for Lists in many situations
2021-07-15 23:45:57 -04:00
member_struct_name = E->struct_name;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
ok = true;
break;
}
}
}
} break;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
case TYPE_BVEC2:
case TYPE_IVEC2:
case TYPE_UVEC2:
case TYPE_VEC2: {
int l = ident.length();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (l == 1) {
member_type = DataType(dt - 1);
} else if (l == 2) {
member_type = dt;
Allow constructing larger data types by swizzling GLSL allows the construction of larger data types by swizzling smaller ones, but Godot shading language treated this as an error: vec2 test2 = vec2(0.0, 1.0); vec3 test3 = test2.xxx; // error: Invalid member for vec2 expression This commit updates the expression parser for the 2 and 3-component data types accordingly. Fixes #10496
2019-05-11 10:41:13 -07:00
} else if (l == 3) {
member_type = DataType(dt + 1);
} else if (l == 4) {
member_type = DataType(dt + 2);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ok = false;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
break;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
const char32_t *c = ident.ptr();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < l; i++) {
switch (c[i]) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
case 'r':
case 'g':
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
if (position_symbols.size() > 0 || texture_symbols.size() > 0) {
mix_error = true;
break;
}
if (!color_symbols.has(c[i])) {
color_symbols.insert(c[i]);
} else {
repeated = true;
}
break;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
case 'x':
case 'y':
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
if (color_symbols.size() > 0 || texture_symbols.size() > 0) {
mix_error = true;
break;
}
if (!position_symbols.has(c[i])) {
position_symbols.insert(c[i]);
} else {
repeated = true;
}
break;
case 's':
case 't':
if (color_symbols.size() > 0 || position_symbols.size() > 0) {
mix_error = true;
break;
}
if (!texture_symbols.has(c[i])) {
texture_symbols.insert(c[i]);
} else {
repeated = true;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
break;
default:
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ok = false;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
break;
}
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
case TYPE_BVEC3:
case TYPE_IVEC3:
case TYPE_UVEC3:
case TYPE_VEC3: {
int l = ident.length();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (l == 1) {
member_type = DataType(dt - 2);
} else if (l == 2) {
member_type = DataType(dt - 1);
} else if (l == 3) {
member_type = dt;
Allow constructing larger data types by swizzling GLSL allows the construction of larger data types by swizzling smaller ones, but Godot shading language treated this as an error: vec2 test2 = vec2(0.0, 1.0); vec3 test3 = test2.xxx; // error: Invalid member for vec2 expression This commit updates the expression parser for the 2 and 3-component data types accordingly. Fixes #10496
2019-05-11 10:41:13 -07:00
} else if (l == 4) {
member_type = DataType(dt + 1);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ok = false;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
break;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
const char32_t *c = ident.ptr();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < l; i++) {
switch (c[i]) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
case 'r':
case 'g':
case 'b':
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
if (position_symbols.size() > 0 || texture_symbols.size() > 0) {
mix_error = true;
break;
}
if (!color_symbols.has(c[i])) {
color_symbols.insert(c[i]);
} else {
repeated = true;
}
break;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
case 'x':
case 'y':
case 'z':
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
if (color_symbols.size() > 0 || texture_symbols.size() > 0) {
mix_error = true;
break;
}
if (!position_symbols.has(c[i])) {
position_symbols.insert(c[i]);
} else {
repeated = true;
}
break;
case 's':
case 't':
case 'p':
if (color_symbols.size() > 0 || position_symbols.size() > 0) {
mix_error = true;
break;
}
if (!texture_symbols.has(c[i])) {
texture_symbols.insert(c[i]);
} else {
repeated = true;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
break;
default:
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ok = false;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
break;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
case TYPE_BVEC4:
case TYPE_IVEC4:
case TYPE_UVEC4:
case TYPE_VEC4: {
int l = ident.length();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (l == 1) {
member_type = DataType(dt - 3);
} else if (l == 2) {
member_type = DataType(dt - 2);
} else if (l == 3) {
member_type = DataType(dt - 1);
} else if (l == 4) {
member_type = dt;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ok = false;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
break;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
const char32_t *c = ident.ptr();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < l; i++) {
switch (c[i]) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
case 'r':
case 'g':
case 'b':
case 'a':
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
if (position_symbols.size() > 0 || texture_symbols.size() > 0) {
mix_error = true;
break;
}
if (!color_symbols.has(c[i])) {
color_symbols.insert(c[i]);
} else {
repeated = true;
}
break;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
case 'x':
case 'y':
case 'z':
case 'w':
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
if (color_symbols.size() > 0 || texture_symbols.size() > 0) {
mix_error = true;
break;
}
if (!position_symbols.has(c[i])) {
position_symbols.insert(c[i]);
} else {
repeated = true;
}
break;
case 's':
case 't':
case 'p':
case 'q':
if (color_symbols.size() > 0 || position_symbols.size() > 0) {
mix_error = true;
break;
}
if (!texture_symbols.has(c[i])) {
texture_symbols.insert(c[i]);
} else {
repeated = true;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
break;
default:
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ok = false;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
break;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
-Fixed shader lang to not be able to get scalar from matrix (ie mat.x), to make it more GLSL compatible -Fixed referencing of world_transform in fragment shader not working -Fixed unsycn bug related to getting shader param list from the server -Fixed getting all textures from shader properly, fixes #8353
2017-06-17 11:03:48 -03:00
default: {
ok = false;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
if (mix_error) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Cannot combine symbols from different sets in expression '.%s'."), ident));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
if (!ok) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Invalid member for '%s' expression: '.%s'."), (dt == TYPE_STRUCT ? st : get_datatype_name(dt)), ident));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
MemberNode *mn = alloc_node<MemberNode>();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
mn->basetype = dt;
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
mn->basetype_const = is_const;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
mn->datatype = member_type;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
mn->base_struct_name = st;
mn->struct_name = member_struct_name;
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
mn->array_size = array_size;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
mn->name = ident;
mn->owner = expr;
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
mn->has_swizzling_duplicates = repeated;
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
if (array_size > 0) {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
TkPos prev_pos = _get_tkpos();
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
tk = _get_token();
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
if (tk.type == TK_OP_ASSIGN) {
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
if (last_type == IDENTIFIER_CONSTANT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Constants cannot be modified."));
Fix using post-init shader array constructors
2020-12-26 21:13:24 +03:00
return nullptr;
}
Node *assign_expression = _parse_array_constructor(p_block, p_function_info, member_type, member_struct_name, array_size);
if (!assign_expression) {
return nullptr;
}
mn->assign_expression = assign_expression;
} else if (tk.type == TK_PERIOD) {
Implements length() shader function for arrays in structs
2021-05-19 21:50:11 +03:00
completion_class = TAG_ARRAY;
p_block->block_tag = SubClassTag::TAG_ARRAY;
Node *call_expression = _parse_and_reduce_expression(p_block, p_function_info);
p_block->block_tag = SubClassTag::TAG_GLOBAL;
if (!call_expression) {
return nullptr;
}
mn->datatype = call_expression->get_datatype();
mn->call_expression = call_expression;
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
} else if (tk.type == TK_BRACKET_OPEN) {
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Node *index_expression = _parse_and_reduce_expression(p_block, p_function_info);
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 16:41:43 +02:00
if (!index_expression) {
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
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 16:41:43 +02:00
}
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
Fix shader crash when passing array to index expression
2021-10-07 10:46:41 +03:00
if (index_expression->get_array_size() != 0 || (index_expression->get_datatype() != TYPE_INT && index_expression->get_datatype() != TYPE_UINT)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Only integer expressions are allowed for indexing."));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
}
if (index_expression->type == Node::TYPE_CONSTANT) {
ConstantNode *cnode = (ConstantNode *)index_expression;
if (cnode) {
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
if (!cnode->values.is_empty()) {
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
int value = cnode->values[0].sint;
if (value < 0 || value >= array_size) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), value, 0, array_size - 1));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
}
}
}
}
tk = _get_token();
if (tk.type != TK_BRACKET_CLOSE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("]");
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
}
mn->index_expression = index_expression;
} else {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
_set_tkpos(prev_pos);
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
expr = mn;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
//todo
//member (period) has priority over any operator
//creates a subindexing expression in place
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
/*} else if (tk.type==TK_BRACKET_OPEN) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
//todo
//subindexing has priority over any operator
//creates a subindexing expression in place
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
*/
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
} else if (tk.type == TK_BRACKET_OPEN) {
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Node *index = _parse_and_reduce_expression(p_block, p_function_info);
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 16:41:43 +02:00
if (!index) {
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
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 16:41:43 +02:00
}
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
Fix shader crash when passing array to index expression
2021-10-07 10:46:41 +03:00
if (index->get_array_size() != 0 || (index->get_datatype() != TYPE_INT && index->get_datatype() != TYPE_UINT)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Only integer expressions are allowed for indexing."));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
}
Fix use of unitialized variables The second in my quest to make Godot 3.x compile with -Werror on GCC7
2017-09-01 22:33:39 +02:00
DataType member_type = TYPE_VOID;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
String member_struct_name;
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (expr->get_array_size() > 0) {
Fix editor crash if passing index as variable to function parameter
2021-07-26 17:40:15 +03:00
if (index->type == Node::TYPE_CONSTANT) {
uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
if (index_constant >= (uint32_t)expr->get_array_size()) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), index_constant, 0, expr->get_array_size() - 1));
Fix editor crash if passing index as variable to function parameter
2021-07-26 17:40:15 +03:00
return nullptr;
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
}
member_type = expr->get_datatype();
if (member_type == TYPE_STRUCT) {
member_struct_name = expr->get_datatype_name();
}
} else {
switch (expr->get_datatype()) {
case TYPE_BVEC2:
case TYPE_VEC2:
case TYPE_IVEC2:
case TYPE_UVEC2:
case TYPE_MAT2:
if (index->type == Node::TYPE_CONSTANT) {
uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
if (index_constant >= 2) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), index_constant, 0, 1));
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return nullptr;
}
}
switch (expr->get_datatype()) {
case TYPE_BVEC2:
member_type = TYPE_BOOL;
break;
case TYPE_VEC2:
member_type = TYPE_FLOAT;
break;
case TYPE_IVEC2:
member_type = TYPE_INT;
break;
case TYPE_UVEC2:
member_type = TYPE_UINT;
break;
case TYPE_MAT2:
member_type = TYPE_VEC2;
break;
default:
break;
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
break;
case TYPE_BVEC3:
case TYPE_VEC3:
case TYPE_IVEC3:
case TYPE_UVEC3:
case TYPE_MAT3:
if (index->type == Node::TYPE_CONSTANT) {
uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
if (index_constant >= 3) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), index_constant, 0, 2));
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return nullptr;
}
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
}
Fixes logically dead code (Coverity) Fixes reported logically dead codes by Coverity * image.cpp: Doesn't really need any modification. But to remove the bug report then we have to move the MAX call away from the for loop statement. * rasterizer_gles3.cpp: Removes unnecessary elif condition since it is checked earlier in the function * collada.cpp: If stamement never reached due to macro ERR_CONTINUE does the same. * navigation_mesh.cpp: Variables should always be null - however, also checked for the very same condition in their function call. Leaving this for review (whether the function call is necessary or not) * path_editor_plugin.cpp: If cancel is true, then it should restore the edited value to the original provided. http://docs.godotengine.org/en/3.0/classes/class_editorspatialgizmo.html#class-editorspatialgizmo-commit-handle * spatial_editor_gizmos.cpp: the very condition of i >= 3 is predetermined in the if case right before it. Thus case 1 is always '1' and case 2 is always '-1' * grid_map_editor.cpp: Same as above in spatial_editor_gizmos.cpp * voxel_light_baker.cpp: Same as above in spatial_editor_gizmos.cpp * visual_server.cpp: Same as above in spatial_editor_gizmos.cpp * visual_script_expression.cpp: char '-' is already true in the switch case mechanism. Thus it can never reach to default case. * particles.cpp: Case 'PARAM_MAX' is unreachable due to index checking right before the switch execution. * shader_language.cpp: Invalid index is handled in switch default case. `type < TYPE_FLOAT && type > TYPE_VEC4` -> `(type < TYPE_FLOAT || type > TYPE_VEC4`) Fixes the "always false problem" in TODO comment.
2018-04-21 22:35:23 +08:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
switch (expr->get_datatype()) {
case TYPE_BVEC3:
member_type = TYPE_BOOL;
break;
case TYPE_VEC3:
member_type = TYPE_FLOAT;
break;
case TYPE_IVEC3:
member_type = TYPE_INT;
break;
case TYPE_UVEC3:
member_type = TYPE_UINT;
break;
case TYPE_MAT3:
member_type = TYPE_VEC3;
break;
default:
break;
}
break;
case TYPE_BVEC4:
case TYPE_VEC4:
case TYPE_IVEC4:
case TYPE_UVEC4:
case TYPE_MAT4:
if (index->type == Node::TYPE_CONSTANT) {
uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
if (index_constant >= 4) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Index [%d] out of range [%d..%d]."), index_constant, 0, 3));
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return nullptr;
}
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
}
Fixes logically dead code (Coverity) Fixes reported logically dead codes by Coverity * image.cpp: Doesn't really need any modification. But to remove the bug report then we have to move the MAX call away from the for loop statement. * rasterizer_gles3.cpp: Removes unnecessary elif condition since it is checked earlier in the function * collada.cpp: If stamement never reached due to macro ERR_CONTINUE does the same. * navigation_mesh.cpp: Variables should always be null - however, also checked for the very same condition in their function call. Leaving this for review (whether the function call is necessary or not) * path_editor_plugin.cpp: If cancel is true, then it should restore the edited value to the original provided. http://docs.godotengine.org/en/3.0/classes/class_editorspatialgizmo.html#class-editorspatialgizmo-commit-handle * spatial_editor_gizmos.cpp: the very condition of i >= 3 is predetermined in the if case right before it. Thus case 1 is always '1' and case 2 is always '-1' * grid_map_editor.cpp: Same as above in spatial_editor_gizmos.cpp * voxel_light_baker.cpp: Same as above in spatial_editor_gizmos.cpp * visual_server.cpp: Same as above in spatial_editor_gizmos.cpp * visual_script_expression.cpp: char '-' is already true in the switch case mechanism. Thus it can never reach to default case. * particles.cpp: Case 'PARAM_MAX' is unreachable due to index checking right before the switch execution. * shader_language.cpp: Invalid index is handled in switch default case. `type < TYPE_FLOAT && type > TYPE_VEC4` -> `(type < TYPE_FLOAT || type > TYPE_VEC4`) Fixes the "always false problem" in TODO comment.
2018-04-21 22:35:23 +08:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
switch (expr->get_datatype()) {
case TYPE_BVEC4:
member_type = TYPE_BOOL;
break;
case TYPE_VEC4:
member_type = TYPE_FLOAT;
break;
case TYPE_IVEC4:
member_type = TYPE_INT;
break;
case TYPE_UVEC4:
member_type = TYPE_UINT;
break;
case TYPE_MAT4:
member_type = TYPE_VEC4;
break;
default:
break;
}
break;
default: {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("An object of type '%s' can't be indexed."), (expr->get_datatype() == TYPE_STRUCT ? expr->get_datatype_name() : get_datatype_name(expr->get_datatype()))));
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return nullptr;
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
}
}
}
OperatorNode *op = alloc_node<OperatorNode>();
op->op = OP_INDEX;
op->return_cache = member_type;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
op->struct_name = member_struct_name;
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
op->arguments.push_back(expr);
op->arguments.push_back(index);
expr = op;
tk = _get_token();
if (tk.type != TK_BRACKET_CLOSE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("]");
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (tk.type == TK_OP_INCREMENT || tk.type == TK_OP_DECREMENT) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
OperatorNode *op = alloc_node<OperatorNode>();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
op->op = tk.type == TK_OP_DECREMENT ? OP_POST_DECREMENT : OP_POST_INCREMENT;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
op->arguments.push_back(expr);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!_validate_operator(op, &op->return_cache, &op->return_array_size)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Invalid base type for increment/decrement operator."));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 18:23:16 -03:00
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
if (!_validate_assign(expr, p_function_info)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Invalid use of increment/decrement operator in a constant expression."));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 18:23:16 -03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
expr = op;
} else {
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
_set_tkpos(pos2);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
break;
}
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
Expression e;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
e.is_op = false;
e.node = expr;
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
expression.push_back(e);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
pos = _get_tkpos();
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (is_token_operator(tk.type)) {
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
Expression o;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
o.is_op = true;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
switch (tk.type) {
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
case TK_OP_EQUAL:
o.op = OP_EQUAL;
break;
case TK_OP_NOT_EQUAL:
o.op = OP_NOT_EQUAL;
break;
case TK_OP_LESS:
o.op = OP_LESS;
break;
case TK_OP_LESS_EQUAL:
o.op = OP_LESS_EQUAL;
break;
case TK_OP_GREATER:
o.op = OP_GREATER;
break;
case TK_OP_GREATER_EQUAL:
o.op = OP_GREATER_EQUAL;
break;
case TK_OP_AND:
o.op = OP_AND;
break;
case TK_OP_OR:
o.op = OP_OR;
break;
case TK_OP_ADD:
o.op = OP_ADD;
break;
case TK_OP_SUB:
o.op = OP_SUB;
break;
case TK_OP_MUL:
o.op = OP_MUL;
break;
case TK_OP_DIV:
o.op = OP_DIV;
break;
case TK_OP_MOD:
o.op = OP_MOD;
break;
case TK_OP_SHIFT_LEFT:
o.op = OP_SHIFT_LEFT;
break;
case TK_OP_SHIFT_RIGHT:
o.op = OP_SHIFT_RIGHT;
break;
case TK_OP_ASSIGN:
o.op = OP_ASSIGN;
break;
case TK_OP_ASSIGN_ADD:
o.op = OP_ASSIGN_ADD;
break;
case TK_OP_ASSIGN_SUB:
o.op = OP_ASSIGN_SUB;
break;
case TK_OP_ASSIGN_MUL:
o.op = OP_ASSIGN_MUL;
break;
case TK_OP_ASSIGN_DIV:
o.op = OP_ASSIGN_DIV;
break;
case TK_OP_ASSIGN_MOD:
o.op = OP_ASSIGN_MOD;
break;
case TK_OP_ASSIGN_SHIFT_LEFT:
o.op = OP_ASSIGN_SHIFT_LEFT;
break;
case TK_OP_ASSIGN_SHIFT_RIGHT:
o.op = OP_ASSIGN_SHIFT_RIGHT;
break;
case TK_OP_ASSIGN_BIT_AND:
o.op = OP_ASSIGN_BIT_AND;
break;
case TK_OP_ASSIGN_BIT_OR:
o.op = OP_ASSIGN_BIT_OR;
break;
case TK_OP_ASSIGN_BIT_XOR:
o.op = OP_ASSIGN_BIT_XOR;
break;
case TK_OP_BIT_AND:
o.op = OP_BIT_AND;
break;
case TK_OP_BIT_OR:
o.op = OP_BIT_OR;
break;
case TK_OP_BIT_XOR:
o.op = OP_BIT_XOR;
break;
case TK_QUESTION:
o.op = OP_SELECT_IF;
break;
case TK_COLON:
o.op = OP_SELECT_ELSE;
break;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
default: {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Invalid token for the operator: '%s'."), get_token_text(tk)));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
expression.push_back(o);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
} else {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
_set_tkpos(pos); //something else, so rollback and end
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
break;
}
}
/* Reduce the set set of expressions and place them in an operator tree, respecting precedence */
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (expression.size() > 1) {
int next_op = -1;
int min_priority = 0xFFFFF;
bool is_unary = false;
bool is_ternary = false;
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < expression.size(); i++) {
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
if (!expression[i].is_op) {
continue;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool unary = false;
bool ternary = false;
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
Operator op = expression[i].op;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
int priority;
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
switch (op) {
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
case OP_EQUAL:
priority = 8;
break;
case OP_NOT_EQUAL:
priority = 8;
break;
case OP_LESS:
priority = 7;
break;
case OP_LESS_EQUAL:
priority = 7;
break;
case OP_GREATER:
priority = 7;
break;
case OP_GREATER_EQUAL:
priority = 7;
break;
case OP_AND:
priority = 12;
break;
case OP_OR:
priority = 14;
break;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
case OP_NOT:
priority = 3;
unary = true;
break;
case OP_NEGATE:
priority = 3;
unary = true;
break;
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
case OP_ADD:
priority = 5;
break;
case OP_SUB:
priority = 5;
break;
case OP_MUL:
priority = 4;
break;
case OP_DIV:
priority = 4;
break;
case OP_MOD:
priority = 4;
break;
case OP_SHIFT_LEFT:
priority = 6;
break;
case OP_SHIFT_RIGHT:
priority = 6;
break;
case OP_ASSIGN:
priority = 16;
break;
case OP_ASSIGN_ADD:
priority = 16;
break;
case OP_ASSIGN_SUB:
priority = 16;
break;
case OP_ASSIGN_MUL:
priority = 16;
break;
case OP_ASSIGN_DIV:
priority = 16;
break;
case OP_ASSIGN_MOD:
priority = 16;
break;
case OP_ASSIGN_SHIFT_LEFT:
priority = 16;
break;
case OP_ASSIGN_SHIFT_RIGHT:
priority = 16;
break;
case OP_ASSIGN_BIT_AND:
priority = 16;
break;
case OP_ASSIGN_BIT_OR:
priority = 16;
break;
case OP_ASSIGN_BIT_XOR:
priority = 16;
break;
case OP_BIT_AND:
priority = 9;
break;
case OP_BIT_OR:
priority = 11;
break;
case OP_BIT_XOR:
priority = 10;
break;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
case OP_BIT_INVERT:
priority = 3;
unary = true;
break;
case OP_INCREMENT:
priority = 3;
unary = true;
break;
case OP_DECREMENT:
priority = 3;
unary = true;
break;
case OP_SELECT_IF:
priority = 15;
ternary = true;
break;
case OP_SELECT_ELSE:
priority = 15;
ternary = true;
break;
default:
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
ERR_FAIL_V(nullptr); //unexpected operator
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
}
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
#ifdef DEBUG_ENABLED
Prevents editor crash when compare with negative float in shader
2021-09-22 13:23:34 +03:00
if (check_warnings && HAS_WARNING(ShaderWarning::FLOAT_COMPARISON_FLAG) && (op == OP_EQUAL || op == OP_NOT_EQUAL) &&
(!expression[i - 1].is_op && !expression[i + 1].is_op) &&
(expression[i - 1].node->get_datatype() == TYPE_FLOAT && expression[i + 1].node->get_datatype() == TYPE_FLOAT)) {
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
_add_line_warning(ShaderWarning::FLOAT_COMPARISON);
}
#endif // DEBUG_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (priority < min_priority) {
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
// < is used for left to right (default)
// <= is used for right to left
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
next_op = i;
min_priority = priority;
is_unary = unary;
is_ternary = ternary;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
}
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
ERR_FAIL_COND_V(next_op == -1, nullptr);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
// OK! create operator..
if (is_unary) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
int expr_pos = next_op;
while (expression[expr_pos].is_op) {
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
expr_pos++;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (expr_pos == expression.size()) {
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
//can happen..
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Unexpected end of expression."));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
}
}
Fix various typos Found via `codespell`
2020-03-11 13:59:18 -04:00
//consecutively do unary operators
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = expr_pos - 1; i >= next_op; i--) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
OperatorNode *op = alloc_node<OperatorNode>();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
op->op = expression[i].op;
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
if ((op->op == OP_INCREMENT || op->op == OP_DECREMENT) && !_validate_assign(expression[i + 1].node, p_function_info)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Can't use increment/decrement operator in a constant expression."));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 18:23:16 -03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
op->arguments.push_back(expression[i + 1].node);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
expression.write[i].is_op = false;
expression.write[i].node = op;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!_validate_operator(op, &op->return_cache, &op->return_array_size)) {
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
String at;
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
for (int j = 0; j < op->arguments.size(); j++) {
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 16:41:43 +02:00
if (j > 0) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
at += ", ";
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 16:41:43 +02:00
}
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
at += get_datatype_name(op->arguments[j]->get_datatype());
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!op->arguments[j]->is_indexed() && op->arguments[j]->get_array_size() > 0) {
at += "[";
at += itos(op->arguments[j]->get_array_size());
at += "]";
}
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Invalid arguments to unary operator '%s': %s."), get_operator_text(op->op), at));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
}
Rename `remove()` to `remove_at()` when removing by index
2021-07-03 16:17:03 -06:00
expression.remove_at(i + 1);
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} else if (is_ternary) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (next_op < 1 || next_op >= (expression.size() - 1)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_parsing_error();
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
ERR_FAIL_V(nullptr);
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (next_op + 2 >= expression.size() || !expression[next_op + 2].is_op || expression[next_op + 2].op != OP_SELECT_ELSE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Missing matching ':' for select operator."));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
OperatorNode *op = alloc_node<OperatorNode>();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
op->op = expression[next_op].op;
op->arguments.push_back(expression[next_op - 1].node);
op->arguments.push_back(expression[next_op + 1].node);
op->arguments.push_back(expression[next_op + 3].node);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
expression.write[next_op - 1].is_op = false;
expression.write[next_op - 1].node = op;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!_validate_operator(op, &op->return_cache, &op->return_array_size)) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
String at;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < op->arguments.size(); i++) {
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 16:41:43 +02:00
if (i > 0) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
at += ", ";
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 16:41:43 +02:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
at += get_datatype_name(op->arguments[i]->get_datatype());
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!op->arguments[i]->is_indexed() && op->arguments[i]->get_array_size() > 0) {
at += "[";
at += itos(op->arguments[i]->get_array_size());
at += "]";
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Invalid argument to ternary operator: '%s'."), at));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < 4; i++) {
Rename `remove()` to `remove_at()` when removing by index
2021-07-03 16:17:03 -06:00
expression.remove_at(next_op);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (next_op < 1 || next_op >= (expression.size() - 1)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_parsing_error();
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
ERR_FAIL_V(nullptr);
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
OperatorNode *op = alloc_node<OperatorNode>();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
op->op = expression[next_op].op;
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (expression[next_op - 1].is_op) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_parsing_error();
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
ERR_FAIL_V(nullptr);
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
}
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
if (_is_operator_assign(op->op)) {
String assign_message;
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
if (!_validate_assign(expression[next_op - 1].node, p_function_info, &assign_message)) {
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
_set_error(assign_message);
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
}
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 18:23:16 -03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (expression[next_op + 1].is_op) {
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
// this is not invalid and can really appear
// but it becomes invalid anyway because no binary op
Fix typos 'a' and 'an'
2017-09-02 21:19:06 +07:00
// can be followed by a unary op in a valid combination,
Fix typos in source code using codespell From https://github.com/lucasdemarchi/codespell
2017-03-24 21:45:31 +01:00
// due to how precedence works, unaries will always disappear first
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_parsing_error();
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
op->arguments.push_back(expression[next_op - 1].node); //expression goes as left
op->arguments.push_back(expression[next_op + 1].node); //next expression goes as right
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
expression.write[next_op - 1].node = op;
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
//replace all 3 nodes by this operator and make it an expression
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!_validate_operator(op, &op->return_cache, &op->return_array_size)) {
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
String at;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < op->arguments.size(); i++) {
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 16:41:43 +02:00
if (i > 0) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
at += ", ";
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 16:41:43 +02:00
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (op->arguments[i]->get_datatype() == TYPE_STRUCT) {
at += op->arguments[i]->get_datatype_name();
} else {
at += get_datatype_name(op->arguments[i]->get_datatype());
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!op->arguments[i]->is_indexed() && op->arguments[i]->get_array_size() > 0) {
at += "[";
at += itos(op->arguments[i]->get_array_size());
at += "]";
}
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Invalid arguments to operator '%s': '%s'."), get_operator_text(op->op), at));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Rename `remove()` to `remove_at()` when removing by index
2021-07-03 16:17:03 -06:00
expression.remove_at(next_op);
expression.remove_at(next_op);
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-17 23:23:42 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return expression[0].node;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ShaderLanguage::Node *ShaderLanguage::_reduce_expression(BlockNode *p_block, ShaderLanguage::Node *p_node) {
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 16:41:43 +02:00
if (p_node->type != Node::TYPE_OPERATOR) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return p_node;
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 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
//for now only reduce simple constructors
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
OperatorNode *op = static_cast<OperatorNode *>(p_node);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (op->op == OP_CONSTRUCT) {
ERR_FAIL_COND_V(op->arguments[0]->type != Node::TYPE_VARIABLE, p_node);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
Fix handling of shader constants that caused crash, closes #15166
2018-08-31 13:11:13 +02:00
DataType type = op->get_datatype();
DataType base = get_scalar_type(type);
int cardinality = get_cardinality(type);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
Vector<ConstantNode::Value> values;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 1; i < op->arguments.size(); i++) {
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
op->arguments.write[i] = _reduce_expression(p_block, op->arguments[i]);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (op->arguments[i]->type == Node::TYPE_CONSTANT) {
ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[i]);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (get_scalar_type(cn->datatype) == base) {
Fix handling of shader constants that caused crash, closes #15166
2018-08-31 13:11:13 +02:00
for (int j = 0; j < cn->values.size(); j++) {
values.push_back(cn->values[j]);
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (get_scalar_type(cn->datatype) == cn->datatype) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
ConstantNode::Value v;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (!convert_constant(cn, base, &v)) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return p_node;
}
values.push_back(v);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} else {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return p_node;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
} else {
return p_node;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
}
Fix handling of shader constants that caused crash, closes #15166
2018-08-31 13:11:13 +02:00
if (values.size() == 1) {
if (type >= TYPE_MAT2 && type <= TYPE_MAT4) {
ConstantNode::Value value = values[0];
ConstantNode::Value zero;
zero.real = 0.0f;
int size = 2 + (type - TYPE_MAT2);
values.clear();
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
values.push_back(i == j ? value : zero);
}
}
} else {
Fixed an access after free in ShaderLanguage::_reduce_expression. Passing an element reference of a vector to a push_back call to that same vector can cause an access after free. This is because push_back will resize the vector, reallocating if necessary, leaving the reference referring to the freed memory. Removed an instance of this usage here.
2018-09-19 14:28:19 +01:00
ConstantNode::Value value = values[0];
Fix handling of shader constants that caused crash, closes #15166
2018-08-31 13:11:13 +02:00
for (int i = 1; i < cardinality; i++) {
Fixed an access after free in ShaderLanguage::_reduce_expression. Passing an element reference of a vector to a push_back call to that same vector can cause an access after free. This is because push_back will resize the vector, reallocating if necessary, leaving the reference referring to the freed memory. Removed an instance of this usage here.
2018-09-19 14:28:19 +01:00
values.push_back(value);
Fix handling of shader constants that caused crash, closes #15166
2018-08-31 13:11:13 +02:00
}
}
} else if (values.size() != cardinality) {
ERR_PRINT("Failed to reduce expression, values and cardinality mismatch.");
return p_node;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ConstantNode *cn = alloc_node<ConstantNode>();
cn->datatype = op->get_datatype();
cn->values = values;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return cn;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (op->op == OP_NEGATE) {
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
op->arguments.write[0] = _reduce_expression(p_block, op->arguments[0]);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (op->arguments[0]->type == Node::TYPE_CONSTANT) {
ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[0]);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
DataType base = get_scalar_type(cn->datatype);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
Vector<ConstantNode::Value> values;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < cn->values.size(); i++) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
ConstantNode::Value nv;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
switch (base) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
case TYPE_BOOL: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
nv.boolean = !cn->values[i].boolean;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
} break;
case TYPE_INT: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
nv.sint = -cn->values[i].sint;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
} break;
case TYPE_UINT: {
Fix Visual Studio throwing C4146 warning.
2019-11-18 12:45:01 +00:00
// Intentionally wrap the unsigned int value, because GLSL does.
nv.uint = 0 - cn->values[i].uint;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
} break;
case TYPE_FLOAT: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
nv.real = -cn->values[i].real;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
} 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 17:08:36 +02:00
default: {
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
values.push_back(nv);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
cn->values = values;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return cn;
}
}
return p_node;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
ShaderLanguage::Node *ShaderLanguage::_parse_and_reduce_expression(BlockNode *p_block, const FunctionInfo &p_function_info) {
ShaderLanguage::Node *expr = _parse_expression(p_block, p_function_info);
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 16:41:43 +02:00
if (!expr) { //errored
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
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 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
expr = _reduce_expression(p_block, expr);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return expr;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Error ShaderLanguage::_parse_block(BlockNode *p_block, const FunctionInfo &p_function_info, bool p_just_one, bool p_can_break, bool p_can_continue) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (true) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
TkPos pos = _get_tkpos();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Token tk = _get_token();
Implements switch to shaders
2019-08-14 14:22:25 +03:00
if (p_block && p_block->block_type == BlockNode::BLOCK_TYPE_SWITCH) {
if (tk.type != TK_CF_CASE && tk.type != TK_CF_DEFAULT && tk.type != TK_CURLY_BRACKET_CLOSE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("A switch may only contain '%s' and '%s' blocks."), "case", "default"));
Implements switch to shaders
2019-08-14 14:22:25 +03:00
return ERR_PARSE_ERROR;
}
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
bool is_struct = shader->structs.has(tk.text);
Few more fixes to for loop in shaders
2022-02-04 08:40:42 +03:00
bool is_var_init = false;
bool is_condition = false;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type == TK_CURLY_BRACKET_CLOSE) { //end of block
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (p_just_one) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("}");
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return OK;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
} else if (tk.type == TK_CONST || is_token_precision(tk.type) || is_token_nonvoid_datatype(tk.type) || is_struct) {
Few more fixes to for loop in shaders
2022-02-04 08:40:42 +03:00
is_var_init = true;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
String struct_name = "";
if (is_struct) {
struct_name = tk.text;
Fix struct usage passing to shader warning system
2021-12-15 22:39:03 +03:00
#ifdef DEBUG_ENABLED
if (check_warnings && HAS_WARNING(ShaderWarning::UNUSED_STRUCT_FLAG) && used_structs.has(struct_name)) {
used_structs[struct_name].used = true;
}
#endif // DEBUG_ENABLED
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
Implemented local shader constants
2019-08-05 10:35:53 +03:00
bool is_const = false;
if (tk.type == TK_CONST) {
is_const = true;
tk = _get_token();
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (!is_struct) {
is_struct = shader->structs.has(tk.text); // check again.
struct_name = tk.text;
}
Implemented local shader constants
2019-08-05 10:35:53 +03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
DataPrecision precision = PRECISION_DEFAULT;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (is_token_precision(tk.type)) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
precision = get_token_precision(tk.type);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (!is_struct) {
is_struct = shader->structs.has(tk.text); // check again.
}
if (is_struct && precision != PRECISION_DEFAULT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("The precision modifier cannot be used on structs."));
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (!is_token_nonvoid_datatype(tk.type)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected variable type after precision modifier."));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (!is_struct) {
if (!is_token_variable_datatype(tk.type)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Invalid variable type (samplers are not allowed)."));
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
}
Do not allow samplers where they dont belong (variables/return types), fixes #15133
2018-11-12 08:36:26 -03:00
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
DataType type = is_struct ? TYPE_STRUCT : get_token_datatype(tk.type);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Disallow uint/uvec usage on GLES2 platform
2020-01-20 15:34:25 +03:00
if (_validate_datatype(type) != OK) {
return ERR_PARSE_ERROR;
}
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
int array_size = 0;
bool fixed_array_size = false;
bool first = true;
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
VariableDeclarationNode *vdnode = alloc_node<VariableDeclarationNode>();
vdnode->precision = precision;
if (is_struct) {
vdnode->struct_name = struct_name;
vdnode->datatype = TYPE_STRUCT;
} else {
vdnode->datatype = type;
};
vdnode->is_const = is_const;
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
do {
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
bool unknown_size = false;
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
VariableDeclarationNode::Declaration decl;
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
if (first) {
first = false;
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
if (tk.type != TK_IDENTIFIER && tk.type != TK_BRACKET_OPEN) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an identifier or '[' after type."));
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
return ERR_PARSE_ERROR;
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
}
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
if (tk.type == TK_BRACKET_OPEN) {
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
Error error = _parse_array_size(p_block, p_function_info, false, &decl.size_expression, &array_size, &unknown_size);
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
if (error != OK) {
return error;
}
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
decl.size = array_size;
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
fixed_array_size = true;
tk = _get_token();
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
}
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
}
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
if (tk.type != TK_IDENTIFIER) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an identifier."));
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
return ERR_PARSE_ERROR;
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
StringName name = tk.text;
Fix few redefinition name errors for variable/param/function in shaders
2019-10-06 17:24:30 +03:00
ShaderLanguage::IdentifierType itype;
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
if (_find_identifier(p_block, true, p_function_info, name, (ShaderLanguage::DataType *)nullptr, &itype)) {
Fix few redefinition name errors for variable/param/function in shaders
2019-10-06 17:24:30 +03:00
if (itype != IDENTIFIER_FUNCTION) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_redefinition_error(String(name));
Fix few redefinition name errors for variable/param/function in shaders
2019-10-06 17:24:30 +03:00
return ERR_PARSE_ERROR;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
decl.name = name;
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
Added a shader warning about unused local variable
2021-06-29 14:34:54 +03:00
#ifdef DEBUG_ENABLED
Fix unknown identifier error in for loop
2022-02-06 08:17:25 +03:00
if (check_warnings && HAS_WARNING(ShaderWarning::UNUSED_LOCAL_VARIABLE_FLAG) && p_block) {
FunctionNode *parent_function = nullptr;
{
BlockNode *block = p_block;
while (block && !block->parent_function) {
block = block->parent_block;
}
parent_function = block->parent_function;
}
if (parent_function) {
StringName func_name = parent_function->name;
Added a shader warning about unused local variable
2021-06-29 14:34:54 +03:00
if (!used_local_vars.has(func_name)) {
used_local_vars.insert(func_name, Map<StringName, Usage>());
}
used_local_vars[func_name].insert(name, Usage(tk_line));
}
}
#endif // DEBUG_ENABLED
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
BlockNode::Variable var;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
var.type = type;
var.precision = precision;
var.line = tk_line;
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
var.array_size = array_size;
Implemented local shader constants
2019-08-05 10:35:53 +03:00
var.is_const = is_const;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
var.struct_name = struct_name;
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
tk = _get_token();
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
if (tk.type == TK_BRACKET_OPEN) {
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
if (RenderingServer::get_singleton()->is_low_end() && is_const) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Local const arrays are only supported on high-end platforms."));
Disabled array initialization, const array and arr.length in shaders
2020-01-16 11:46:11 +03:00
return ERR_PARSE_ERROR;
}
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
Error error = _parse_array_size(p_block, p_function_info, false, &decl.size_expression, &var.array_size, &unknown_size);
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
if (error != OK) {
return error;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
decl.size = var.array_size;
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
array_size = var.array_size;
Added local array initializer
2019-07-15 18:47:22 +03:00
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
tk = _get_token();
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
if (var.array_size > 0 || unknown_size) {
Added local array initializer
2019-07-15 18:47:22 +03:00
bool full_def = false;
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
Added local array initializer
2019-07-15 18:47:22 +03:00
if (tk.type == TK_OP_ASSIGN) {
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
if (RenderingServer::get_singleton()->is_low_end()) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Array initialization is only supported on high-end platforms."));
Disabled array initialization, const array and arr.length in shaders
2020-01-16 11:46:11 +03:00
return ERR_PARSE_ERROR;
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
TkPos prev_pos = _get_tkpos();
Added local array initializer
2019-07-15 18:47:22 +03:00
tk = _get_token();
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (tk.type == TK_IDENTIFIER) { // a function call array initialization
_set_tkpos(prev_pos);
Node *n = _parse_and_reduce_expression(p_block, p_function_info);
Added local array initializer
2019-07-15 18:47:22 +03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!n) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected array initializer."));
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return ERR_PARSE_ERROR;
} else {
if (unknown_size) {
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
decl.size = n->get_array_size();
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
var.array_size = n->get_array_size();
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!_compare_datatypes(var.type, var.struct_name, var.array_size, n->get_datatype(), n->get_datatype_name(), n->get_array_size())) {
Added local array initializer
2019-07-15 18:47:22 +03:00
return ERR_PARSE_ERROR;
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
decl.single_expression = true;
decl.initializer.push_back(n);
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
tk = _get_token();
} else {
if (tk.type != TK_CURLY_BRACKET_OPEN) {
if (unknown_size) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("{");
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
}
Added local array initializer
2019-07-15 18:47:22 +03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
full_def = true;
Added local array initializer
2019-07-15 18:47:22 +03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
DataPrecision precision2 = PRECISION_DEFAULT;
if (is_token_precision(tk.type)) {
precision2 = get_token_precision(tk.type);
Added missing form of array constructor in shaders
2020-01-18 11:41:55 +03:00
tk = _get_token();
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (shader->structs.has(tk.text)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("The precision modifier cannot be used on structs."));
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return ERR_PARSE_ERROR;
}
if (!is_token_nonvoid_datatype(tk.type)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected data type after precision modifier."));
Added missing form of array constructor in shaders
2020-01-18 11:41:55 +03:00
return ERR_PARSE_ERROR;
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
}
Added missing form of array constructor in shaders
2020-01-18 11:41:55 +03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
DataType type2;
StringName struct_name2 = "";
if (shader->structs.has(tk.text)) {
type2 = TYPE_STRUCT;
struct_name2 = tk.text;
} else {
if (!is_token_variable_datatype(tk.type)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Invalid data type for the array."));
Added local array initializer
2019-07-15 18:47:22 +03:00
return ERR_PARSE_ERROR;
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
type2 = get_token_datatype(tk.type);
}
Added local array initializer
2019-07-15 18:47:22 +03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
int array_size2 = 0;
tk = _get_token();
if (tk.type == TK_BRACKET_OPEN) {
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
bool is_unknown_size = false;
Error error = _parse_array_size(p_block, p_function_info, false, nullptr, &array_size2, &is_unknown_size);
if (error != OK) {
return error;
}
if (is_unknown_size) {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
array_size2 = var.array_size;
Added missing form of array constructor in shaders
2020-01-18 11:41:55 +03:00
}
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
tk = _get_token();
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("[");
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return ERR_PARSE_ERROR;
Added local array initializer
2019-07-15 18:47:22 +03:00
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (precision != precision2 || type != type2 || struct_name != struct_name2 || var.array_size != array_size2) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
String from;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (precision2 != PRECISION_DEFAULT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
from += get_precision_name(precision2);
from += " ";
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
}
if (type2 == TYPE_STRUCT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
from += struct_name2;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
from += get_datatype_name(type2);
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
from += "[";
from += itos(array_size2);
from += "]'";
String to;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (precision != PRECISION_DEFAULT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
to += get_precision_name(precision);
to += " ";
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
}
if (type == TYPE_STRUCT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
to += struct_name;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
to += get_datatype_name(type);
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
to += "[";
to += itos(var.array_size);
to += "]'";
_set_error(vformat(RTR("Cannot convert from '%s' to '%s'."), from, to));
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return ERR_PARSE_ERROR;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
Added local array initializer
2019-07-15 18:47:22 +03:00
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
bool curly = tk.type == TK_CURLY_BRACKET_OPEN;
Added local array initializer
2019-07-15 18:47:22 +03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (unknown_size) {
if (!curly) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("{");
Added local array initializer
2019-07-15 18:47:22 +03:00
return ERR_PARSE_ERROR;
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
} else {
if (full_def) {
if (curly) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("(");
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return ERR_PARSE_ERROR;
}
}
Added local array initializer
2019-07-15 18:47:22 +03:00
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (tk.type == TK_PARENTHESIS_OPEN || curly) { // initialization
while (true) {
Node *n = _parse_and_reduce_expression(p_block, p_function_info);
if (!n) {
return ERR_PARSE_ERROR;
}
Added local array initializer
2019-07-15 18:47:22 +03:00
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
if (is_const && n->type == Node::TYPE_OPERATOR && ((OperatorNode *)n)->op == OP_CALL) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected a constant expression."));
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
return ERR_PARSE_ERROR;
}
Prevent shader crash if function call been used on constant
2019-10-06 18:05:44 +03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!_compare_datatypes(var.type, struct_name, 0, n->get_datatype(), n->get_datatype_name(), 0)) {
return ERR_PARSE_ERROR;
}
Added local array initializer
2019-07-15 18:47:22 +03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
tk = _get_token();
if (tk.type == TK_COMMA) {
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
decl.initializer.push_back(n);
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
continue;
} else if (!curly && tk.type == TK_PARENTHESIS_CLOSE) {
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
decl.initializer.push_back(n);
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
break;
} else if (curly && tk.type == TK_CURLY_BRACKET_CLOSE) {
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
decl.initializer.push_back(n);
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
break;
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 16:41:43 +02:00
} else {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (curly) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("}", ",");
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(")", ",");
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
}
return ERR_PARSE_ERROR;
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 16:41:43 +02:00
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
}
if (unknown_size) {
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
decl.size = decl.initializer.size();
var.array_size = decl.initializer.size();
} else if (decl.initializer.size() != var.array_size) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Array size mismatch."));
Added local array initializer
2019-07-15 18:47:22 +03:00
return ERR_PARSE_ERROR;
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
tk = _get_token();
Added local array initializer
2019-07-15 18:47:22 +03:00
}
}
} else {
if (unknown_size) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected array initialization."));
Added local array initializer
2019-07-15 18:47:22 +03:00
return ERR_PARSE_ERROR;
}
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
if (is_const) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected initialization of constant."));
Force user to initialize local shader constants
2019-08-13 09:55:43 +03:00
return ERR_PARSE_ERROR;
}
Added local array initializer
2019-07-15 18:47:22 +03:00
}
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
array_size = var.array_size;
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
} else if (tk.type == TK_OP_ASSIGN) {
Fix premature declaration of shader variables created with assignment
2018-01-01 19:56:44 +01:00
//variable created with assignment! must parse an expression
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Node *n = _parse_and_reduce_expression(p_block, p_function_info);
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 16:41:43 +02:00
if (!n) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
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 16:41:43 +02:00
}
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
if (is_const && n->type == Node::TYPE_OPERATOR && ((OperatorNode *)n)->op == OP_CALL) {
Fix shader handle constant expressions in function call
2021-04-27 14:58:32 +03:00
OperatorNode *op = ((OperatorNode *)n);
for (int i = 1; i < op->arguments.size(); i++) {
if (!_check_node_constness(op->arguments[i])) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Expected constant expression for argument %d of function call after '='."), i - 1));
Fix shader handle constant expressions in function call
2021-04-27 14:58:32 +03:00
return ERR_PARSE_ERROR;
}
}
Prevent shader crash if function call been used on constant
2019-10-06 18:05:44 +03:00
}
property validate assignment condition in new variables, fixes #9411
2017-08-20 16:15:08 -03:00
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
if (n->type == Node::TYPE_CONSTANT) {
ConstantNode *const_node = static_cast<ConstantNode *>(n);
if (const_node && const_node->values.size() == 1) {
var.value = const_node->values[0];
}
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!_compare_datatypes(var.type, var.struct_name, var.array_size, n->get_datatype(), n->get_datatype_name(), n->get_array_size())) {
property validate assignment condition in new variables, fixes #9411
2017-08-20 16:15:08 -03:00
return ERR_PARSE_ERROR;
}
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
decl.initializer.push_back(n);
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
tk = _get_token();
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
} else {
Force user to initialize local shader constants
2019-08-13 09:55:43 +03:00
if (is_const) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected initialization of constant."));
Force user to initialize local shader constants
2019-08-13 09:55:43 +03:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
vdnode->declarations.push_back(decl);
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
p_block->variables[name] = var;
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
if (!fixed_array_size) {
array_size = 0;
}
Allow multiple declarations in for loop in a shader
2022-02-03 11:13:20 +03:00
if (tk.type == TK_SEMICOLON) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
break;
Allow multiple declarations in for loop in a shader
2022-02-03 11:13:20 +03:00
} else if (tk.type != TK_COMMA) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(",", ";");
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
return ERR_PARSE_ERROR;
}
Fix shader array parsing in variable declaration
2021-12-15 17:32:54 +03:00
} while (tk.type == TK_COMMA); //another variable
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
p_block->statements.push_back((Node *)vdnode);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (tk.type == TK_CURLY_BRACKET_OPEN) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
//a sub block, just because..
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
BlockNode *block = alloc_node<BlockNode>();
block->parent_block = p_block;
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
if (_parse_block(block, p_function_info, false, p_can_break, p_can_continue) != OK) {
Fix incorrect shader block parsing
2020-03-20 17:24:00 +03:00
return ERR_PARSE_ERROR;
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
p_block->statements.push_back(block);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (tk.type == TK_CF_IF) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
//if () {}
tk = _get_token();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type != TK_PARENTHESIS_OPEN) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_after_error("(", "if");
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
ControlFlowNode *cf = alloc_node<ControlFlowNode>();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
cf->flow_op = FLOW_OP_IF;
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Node *n = _parse_and_reduce_expression(p_block, p_function_info);
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 16:41:43 +02:00
if (!n) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
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 16:41:43 +02:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Fix shader crash if non-boolean expression inserted into "if"
2019-10-28 08:35:33 +03:00
if (n->get_datatype() != TYPE_BOOL) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected a boolean expression."));
Fix shader crash if non-boolean expression inserted into "if"
2019-10-28 08:35:33 +03:00
return ERR_PARSE_ERROR;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type != TK_PARENTHESIS_CLOSE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(")");
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
BlockNode *block = alloc_node<BlockNode>();
block->parent_block = p_block;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
cf->expressions.push_back(n);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
cf->blocks.push_back(block);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
p_block->statements.push_back(cf);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Error err = _parse_block(block, p_function_info, true, p_can_break, p_can_continue);
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 16:41:43 +02:00
if (err) {
Added depth texture support (using parallax) to default material.
2017-06-04 18:08:06 -03: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 16:41:43 +02:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
pos = _get_tkpos();
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type == TK_CF_ELSE) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
block = alloc_node<BlockNode>();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
block->parent_block = p_block;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
cf->blocks.push_back(block);
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
err = _parse_block(block, p_function_info, true, p_can_break, p_can_continue);
Restore shader parsing errors with lack of semicolon in a block
2021-12-11 17:30:40 +03:00
if (err) {
return err;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
} else {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
_set_tkpos(pos); //rollback
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Implements switch to shaders
2019-08-14 14:22:25 +03:00
} else if (tk.type == TK_CF_SWITCH) {
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
if (RenderingServer::get_singleton()->is_low_end()) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("The '%s' operator is only supported on high-end platforms."), "switch"));
Removed switch operator from GLES2 shader back-end
2019-11-02 12:36:43 +03:00
return ERR_PARSE_ERROR;
}
Implements switch to shaders
2019-08-14 14:22:25 +03:00
// switch() {}
tk = _get_token();
if (tk.type != TK_PARENTHESIS_OPEN) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_after_error("(", "switch");
Implements switch to shaders
2019-08-14 14:22:25 +03:00
return ERR_PARSE_ERROR;
}
ControlFlowNode *cf = alloc_node<ControlFlowNode>();
cf->flow_op = FLOW_OP_SWITCH;
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Node *n = _parse_and_reduce_expression(p_block, p_function_info);
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 16:41:43 +02:00
if (!n) {
Implements switch to shaders
2019-08-14 14:22:25 +03:00
return ERR_PARSE_ERROR;
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 16:41:43 +02:00
}
Implements switch to shaders
2019-08-14 14:22:25 +03:00
if (n->get_datatype() != TYPE_INT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an integer expression."));
Implements switch to shaders
2019-08-14 14:22:25 +03:00
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_PARENTHESIS_CLOSE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(")");
Implements switch to shaders
2019-08-14 14:22:25 +03:00
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_CURLY_BRACKET_OPEN) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_after_error("{", "switch");
Implements switch to shaders
2019-08-14 14:22:25 +03:00
return ERR_PARSE_ERROR;
}
BlockNode *switch_block = alloc_node<BlockNode>();
switch_block->block_type = BlockNode::BLOCK_TYPE_SWITCH;
switch_block->parent_block = p_block;
cf->expressions.push_back(n);
cf->blocks.push_back(switch_block);
p_block->statements.push_back(cf);
int prev_type = TK_CF_CASE;
while (true) { // Go-through multiple cases.
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
if (_parse_block(switch_block, p_function_info, true, true, false) != OK) {
Implements switch to shaders
2019-08-14 14:22:25 +03:00
return ERR_PARSE_ERROR;
}
pos = _get_tkpos();
tk = _get_token();
if (tk.type == TK_CF_CASE || tk.type == TK_CF_DEFAULT) {
if (prev_type == TK_CF_DEFAULT) {
if (tk.type == TK_CF_CASE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Cases must be defined before default case."));
Implements switch to shaders
2019-08-14 14:22:25 +03:00
return ERR_PARSE_ERROR;
} else if (prev_type == TK_CF_DEFAULT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Default case must be defined only once."));
Implements switch to shaders
2019-08-14 14:22:25 +03:00
return ERR_PARSE_ERROR;
}
}
prev_type = tk.type;
_set_tkpos(pos);
continue;
} else {
Set<int> constants;
for (int i = 0; i < switch_block->statements.size(); i++) { // Checks for duplicates.
ControlFlowNode *flow = (ControlFlowNode *)switch_block->statements[i];
if (flow) {
if (flow->flow_op == FLOW_OP_CASE) {
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
if (flow->expressions[0]->type == Node::TYPE_CONSTANT) {
ConstantNode *cn = static_cast<ConstantNode *>(flow->expressions[0]);
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
if (!cn || cn->values.is_empty()) {
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
return ERR_PARSE_ERROR;
}
if (constants.has(cn->values[0].sint)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Duplicated case label: %d."), cn->values[0].sint));
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
return ERR_PARSE_ERROR;
}
constants.insert(cn->values[0].sint);
} else if (flow->expressions[0]->type == Node::TYPE_VARIABLE) {
VariableNode *vn = static_cast<VariableNode *>(flow->expressions[0]);
if (!vn) {
return ERR_PARSE_ERROR;
}
ConstantNode::Value v;
_find_identifier(p_block, false, p_function_info, vn->name, nullptr, nullptr, nullptr, nullptr, nullptr, &v);
if (constants.has(v.sint)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Duplicated case label: %d."), v.sint));
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
return ERR_PARSE_ERROR;
}
constants.insert(v.sint);
Implements switch to shaders
2019-08-14 14:22:25 +03:00
}
} else if (flow->flow_op == FLOW_OP_DEFAULT) {
continue;
} else {
return ERR_PARSE_ERROR;
}
} else {
return ERR_PARSE_ERROR;
}
}
break;
}
}
} else if (tk.type == TK_CF_CASE) {
// case x : break; | return;
if (p_block && p_block->block_type == BlockNode::BLOCK_TYPE_CASE) {
_set_tkpos(pos);
return OK;
}
if (!p_block || (p_block->block_type != BlockNode::BLOCK_TYPE_SWITCH)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("'%s' must be placed within a '%s' block."), "case", "switch"));
Implements switch to shaders
2019-08-14 14:22:25 +03:00
return ERR_PARSE_ERROR;
}
tk = _get_token();
int sign = 1;
if (tk.type == TK_OP_SUB) {
sign = -1;
tk = _get_token();
}
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
Node *n = nullptr;
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
if (!tk.is_integer_constant()) {
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
bool correct_constant_expression = false;
DataType data_type;
Implements switch to shaders
2019-08-14 14:22:25 +03:00
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
if (tk.type == TK_IDENTIFIER) {
bool is_const;
_find_identifier(p_block, false, p_function_info, tk.text, &data_type, nullptr, &is_const);
if (is_const) {
if (data_type == TYPE_INT) {
correct_constant_expression = true;
}
}
}
if (!correct_constant_expression) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an integer constant."));
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
return ERR_PARSE_ERROR;
}
VariableNode *vn = alloc_node<VariableNode>();
vn->name = tk.text;
n = vn;
} else {
ConstantNode::Value v;
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
if (tk.type == TK_UINT_CONSTANT) {
v.uint = (uint32_t)tk.constant;
} else {
v.sint = (int)tk.constant * sign;
}
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
ConstantNode *cn = alloc_node<ConstantNode>();
cn->values.push_back(v);
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
cn->datatype = (tk.type == TK_UINT_CONSTANT ? TYPE_UINT : TYPE_INT);
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
n = cn;
}
Implements switch to shaders
2019-08-14 14:22:25 +03:00
tk = _get_token();
if (tk.type != TK_COLON) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(":");
Implements switch to shaders
2019-08-14 14:22:25 +03:00
return ERR_PARSE_ERROR;
}
ControlFlowNode *cf = alloc_node<ControlFlowNode>();
cf->flow_op = FLOW_OP_CASE;
BlockNode *case_block = alloc_node<BlockNode>();
case_block->block_type = BlockNode::BLOCK_TYPE_CASE;
case_block->parent_block = p_block;
cf->expressions.push_back(n);
cf->blocks.push_back(case_block);
p_block->statements.push_back(cf);
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Error err = _parse_block(case_block, p_function_info, false, true, 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 16:41:43 +02:00
if (err) {
Implements switch to shaders
2019-08-14 14:22:25 +03: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 16:41:43 +02:00
}
Implements switch to shaders
2019-08-14 14:22:25 +03:00
return OK;
} else if (tk.type == TK_CF_DEFAULT) {
if (p_block && p_block->block_type == BlockNode::BLOCK_TYPE_CASE) {
_set_tkpos(pos);
return OK;
}
if (!p_block || (p_block->block_type != BlockNode::BLOCK_TYPE_SWITCH)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("'%s' must be placed within a '%s' block."), "default", "switch"));
Implements switch to shaders
2019-08-14 14:22:25 +03:00
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_COLON) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(":");
Implements switch to shaders
2019-08-14 14:22:25 +03:00
return ERR_PARSE_ERROR;
}
ControlFlowNode *cf = alloc_node<ControlFlowNode>();
cf->flow_op = FLOW_OP_DEFAULT;
BlockNode *default_block = alloc_node<BlockNode>();
default_block->block_type = BlockNode::BLOCK_TYPE_DEFAULT;
default_block->parent_block = p_block;
cf->blocks.push_back(default_block);
p_block->statements.push_back(cf);
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Error err = _parse_block(default_block, p_function_info, false, true, 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 16:41:43 +02:00
if (err) {
Implements switch to shaders
2019-08-14 14:22:25 +03: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 16:41:43 +02:00
}
Implements switch to shaders
2019-08-14 14:22:25 +03:00
return OK;
Implemented do/while loops for shaders
2019-08-13 16:19:14 +03:00
} else if (tk.type == TK_CF_DO || tk.type == TK_CF_WHILE) {
// do {} while()
// while() {}
bool is_do = tk.type == TK_CF_DO;
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
BlockNode *do_block = nullptr;
Implemented do/while loops for shaders
2019-08-13 16:19:14 +03:00
if (is_do) {
do_block = alloc_node<BlockNode>();
do_block->parent_block = p_block;
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Error err = _parse_block(do_block, p_function_info, true, true, true);
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 16:41:43 +02:00
if (err) {
Implemented do/while loops for shaders
2019-08-13 16:19:14 +03: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 16:41:43 +02:00
}
Implemented do/while loops for shaders
2019-08-13 16:19:14 +03:00
tk = _get_token();
if (tk.type != TK_CF_WHILE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_after_error("while", "do");
Implemented do/while loops for shaders
2019-08-13 16:19:14 +03:00
return ERR_PARSE_ERROR;
}
}
Added depth texture support (using parallax) to default material.
2017-06-04 18:08:06 -03:00
tk = _get_token();
Implemented do/while loops for shaders
2019-08-13 16:19:14 +03:00
Added depth texture support (using parallax) to default material.
2017-06-04 18:08:06 -03:00
if (tk.type != TK_PARENTHESIS_OPEN) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_after_error("(", "while");
Added depth texture support (using parallax) to default material.
2017-06-04 18:08:06 -03:00
return ERR_PARSE_ERROR;
}
ControlFlowNode *cf = alloc_node<ControlFlowNode>();
Implemented do/while loops for shaders
2019-08-13 16:19:14 +03:00
if (is_do) {
cf->flow_op = FLOW_OP_DO;
} else {
cf->flow_op = FLOW_OP_WHILE;
}
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Node *n = _parse_and_reduce_expression(p_block, p_function_info);
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 16:41:43 +02:00
if (!n) {
Added depth texture support (using parallax) to default material.
2017-06-04 18:08:06 -03:00
return ERR_PARSE_ERROR;
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 16:41:43 +02:00
}
Added depth texture support (using parallax) to default material.
2017-06-04 18:08:06 -03:00
tk = _get_token();
if (tk.type != TK_PARENTHESIS_CLOSE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(")");
Added depth texture support (using parallax) to default material.
2017-06-04 18:08:06 -03:00
return ERR_PARSE_ERROR;
}
Implemented do/while loops for shaders
2019-08-13 16:19:14 +03:00
if (!is_do) {
BlockNode *block = alloc_node<BlockNode>();
block->parent_block = p_block;
cf->expressions.push_back(n);
cf->blocks.push_back(block);
p_block->statements.push_back(cf);
Added depth texture support (using parallax) to default material.
2017-06-04 18:08:06 -03:00
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Error err = _parse_block(block, p_function_info, true, true, true);
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 16:41:43 +02:00
if (err) {
Implemented do/while loops for shaders
2019-08-13 16:19:14 +03: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 16:41:43 +02:00
}
Implemented do/while loops for shaders
2019-08-13 16:19:14 +03:00
} else {
cf->expressions.push_back(n);
cf->blocks.push_back(do_block);
p_block->statements.push_back(cf);
tk = _get_token();
if (tk.type != TK_SEMICOLON) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(";");
Implemented do/while loops for shaders
2019-08-13 16:19:14 +03:00
return ERR_PARSE_ERROR;
}
}
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
} else if (tk.type == TK_CF_FOR) {
Implemented do/while loops for shaders
2019-08-13 16:19:14 +03:00
// for() {}
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
tk = _get_token();
if (tk.type != TK_PARENTHESIS_OPEN) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_after_error("(", "for");
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
return ERR_PARSE_ERROR;
}
ControlFlowNode *cf = alloc_node<ControlFlowNode>();
cf->flow_op = FLOW_OP_FOR;
BlockNode *init_block = alloc_node<BlockNode>();
Allow multiple declarations in for loop in a shader
2022-02-03 11:13:20 +03:00
init_block->block_type = BlockNode::BLOCK_TYPE_FOR_INIT;
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
init_block->parent_block = p_block;
Fix unused variable warnings The forth in my quest to make Godot 3.x compile with -Werror on GCC7
2017-09-02 22:32:31 +02:00
init_block->single_statement = true;
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
cf->blocks.push_back(init_block);
Allow multiple declarations in for loop in a shader
2022-02-03 11:13:20 +03:00
Error err = _parse_block(init_block, p_function_info, true, false, false);
if (err != OK) {
return err;
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
}
Allow multiple declarations in for loop in a shader
2022-02-03 11:13:20 +03:00
BlockNode *condition_block = alloc_node<BlockNode>();
condition_block->block_type = BlockNode::BLOCK_TYPE_FOR_CONDITION;
condition_block->parent_block = init_block;
condition_block->single_statement = true;
condition_block->use_comma_between_statements = true;
cf->blocks.push_back(condition_block);
err = _parse_block(condition_block, p_function_info, true, false, false);
if (err != OK) {
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 16:41:43 +02:00
}
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
Allow multiple declarations in for loop in a shader
2022-02-03 11:13:20 +03:00
BlockNode *expression_block = alloc_node<BlockNode>();
expression_block->block_type = BlockNode::BLOCK_TYPE_FOR_EXPRESSION;
expression_block->parent_block = init_block;
expression_block->single_statement = true;
expression_block->use_comma_between_statements = true;
cf->blocks.push_back(expression_block);
err = _parse_block(expression_block, p_function_info, true, false, false);
if (err != OK) {
return err;
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
}
BlockNode *block = alloc_node<BlockNode>();
Shader Language: Add in-for declared variables within for-block scope.
2017-12-17 01:43:59 +01:00
block->parent_block = init_block;
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
cf->blocks.push_back(block);
p_block->statements.push_back(cf);
Allow multiple declarations in for loop in a shader
2022-02-03 11:13:20 +03:00
err = _parse_block(block, p_function_info, true, true, true);
if (err != OK) {
Added depth texture support (using parallax) to default material.
2017-06-04 18:08:06 -03: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 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
} else if (tk.type == TK_CF_RETURN) {
//check return type
BlockNode *b = p_block;
Prevents usage of return in main shader functions
2020-06-27 09:24:49 +03:00
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
while (b && !b->parent_function) {
b = b->parent_block;
}
if (!b) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_parsing_error();
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
return ERR_BUG;
}
Prevent return statement from using in block in shader main functions
2021-11-23 10:36:33 +03:00
if (b && b->parent_function && p_function_info.main_function) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Using '%s' in the '%s' processor function is incorrect."), "return", b->parent_function->name));
Prevent return statement from using in block in shader main functions
2021-11-23 10:36:33 +03:00
return ERR_PARSE_ERROR;
}
Prevents shader crash if passing invalid struct to the return statement
2021-02-21 07:35:09 +03:00
String return_struct_name = String(b->parent_function->return_struct_name);
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
String array_size_string;
if (b->parent_function->return_array_size > 0) {
array_size_string = "[" + itos(b->parent_function->return_array_size) + "]";
}
Prevents shader crash if passing invalid struct to the return statement
2021-02-21 07:35:09 +03:00
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
ControlFlowNode *flow = alloc_node<ControlFlowNode>();
flow->flow_op = FLOW_OP_RETURN;
pos = _get_tkpos();
tk = _get_token();
if (tk.type == TK_SEMICOLON) {
//all is good
if (b->parent_function->return_type != TYPE_VOID) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Expected '%s' with an expression of type '%s'."), "return", (!return_struct_name.is_empty() ? return_struct_name : get_datatype_name(b->parent_function->return_type)) + array_size_string));
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
return ERR_PARSE_ERROR;
}
} else {
_set_tkpos(pos); //rollback, wants expression
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Node *expr = _parse_and_reduce_expression(p_block, p_function_info);
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 16:41:43 +02:00
if (!expr) {
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
return ERR_PARSE_ERROR;
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 16:41:43 +02:00
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
Prevent shader crash when returning array when return type is scalar
2021-06-06 14:59:52 +03:00
if (b->parent_function->return_type != expr->get_datatype() || b->parent_function->return_array_size != expr->get_array_size() || return_struct_name != expr->get_datatype_name()) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Expected return with an expression of type '%s'."), (!return_struct_name.is_empty() ? return_struct_name : get_datatype_name(b->parent_function->return_type)) + array_size_string));
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_SEMICOLON) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_after_error(";", "return");
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
return ERR_PARSE_ERROR;
}
flow->expressions.push_back(expr);
}
removed DISCARD built in variable, replaced by actual discard GLSL instruction, fixes #9677
2017-08-29 10:14:07 -03:00
p_block->statements.push_back(flow);
Fix nested break/return in shader switch statement
2020-01-10 11:57:56 +03:00
BlockNode *block = p_block;
while (block) {
if (block->block_type == BlockNode::BLOCK_TYPE_CASE || block->block_type == BlockNode::BLOCK_TYPE_DEFAULT) {
return OK;
}
block = block->parent_block;
Implements switch to shaders
2019-08-14 14:22:25 +03:00
}
removed DISCARD built in variable, replaced by actual discard GLSL instruction, fixes #9677
2017-08-29 10:14:07 -03:00
} else if (tk.type == TK_CF_DISCARD) {
//check return type
BlockNode *b = p_block;
while (b && !b->parent_function) {
b = b->parent_block;
}
if (!b) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_parsing_error();
removed DISCARD built in variable, replaced by actual discard GLSL instruction, fixes #9677
2017-08-29 10:14:07 -03:00
return ERR_BUG;
}
if (!b->parent_function->can_discard) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Use of '%s' is not allowed here."), "discard"));
removed DISCARD built in variable, replaced by actual discard GLSL instruction, fixes #9677
2017-08-29 10:14:07 -03:00
return ERR_PARSE_ERROR;
}
ControlFlowNode *flow = alloc_node<ControlFlowNode>();
flow->flow_op = FLOW_OP_DISCARD;
pos = _get_tkpos();
tk = _get_token();
if (tk.type != TK_SEMICOLON) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_after_error(";", "discard");
Added missing returns on error scenarios
2021-02-28 19:02:52 +00:00
return ERR_PARSE_ERROR;
removed DISCARD built in variable, replaced by actual discard GLSL instruction, fixes #9677
2017-08-29 10:14:07 -03:00
}
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
p_block->statements.push_back(flow);
} else if (tk.type == TK_CF_BREAK) {
if (!p_can_break) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("'%s' is not allowed outside of a loop or '%s' statement."), "break", "switch"));
Added missing returns on error scenarios
2021-02-28 19:02:52 +00:00
return ERR_PARSE_ERROR;
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
}
ControlFlowNode *flow = alloc_node<ControlFlowNode>();
flow->flow_op = FLOW_OP_BREAK;
pos = _get_tkpos();
tk = _get_token();
if (tk.type != TK_SEMICOLON) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_after_error(";", "break");
Added missing returns on error scenarios
2021-02-28 19:02:52 +00:00
return ERR_PARSE_ERROR;
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
}
p_block->statements.push_back(flow);
Fix nested break/return in shader switch statement
2020-01-10 11:57:56 +03:00
BlockNode *block = p_block;
while (block) {
if (block->block_type == BlockNode::BLOCK_TYPE_CASE || block->block_type == BlockNode::BLOCK_TYPE_DEFAULT) {
return OK;
}
block = block->parent_block;
Implements switch to shaders
2019-08-14 14:22:25 +03:00
}
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
} else if (tk.type == TK_CF_CONTINUE) {
Implements switch to shaders
2019-08-14 14:22:25 +03:00
if (!p_can_continue) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("'%s' is not allowed outside of a loop."), "continue"));
Added missing returns on error scenarios
2021-02-28 19:02:52 +00:00
return ERR_PARSE_ERROR;
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
}
ControlFlowNode *flow = alloc_node<ControlFlowNode>();
flow->flow_op = FLOW_OP_CONTINUE;
pos = _get_tkpos();
tk = _get_token();
if (tk.type != TK_SEMICOLON) {
//all is good
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_after_error(";", "continue");
Added missing returns on error scenarios
2021-02-28 19:02:52 +00:00
return ERR_PARSE_ERROR;
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 15:22:33 -03:00
}
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
p_block->statements.push_back(flow);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} else {
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
//nothing else, so expression
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
_set_tkpos(pos); //rollback
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Node *expr = _parse_and_reduce_expression(p_block, p_function_info);
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 16:41:43 +02:00
if (!expr) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return ERR_PARSE_ERROR;
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 16:41:43 +02:00
}
Few more fixes to for loop in shaders
2022-02-04 08:40:42 +03:00
is_condition = expr->type == Node::TYPE_OPERATOR && expr->get_datatype() == TYPE_BOOL;
Allow multiple declarations in for loop in a shader
2022-02-03 11:13:20 +03:00
if (expr->type == Node::TYPE_OPERATOR) {
OperatorNode *op = static_cast<OperatorNode *>(expr);
if (op->op == OP_EMPTY) {
Few more fixes to for loop in shaders
2022-02-04 08:40:42 +03:00
is_var_init = true;
is_condition = true;
Allow multiple declarations in for loop in a shader
2022-02-03 11:13:20 +03:00
}
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
p_block->statements.push_back(expr);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow multiple declarations in for loop in a shader
2022-02-03 11:13:20 +03:00
if (p_block->block_type == BlockNode::BLOCK_TYPE_FOR_CONDITION) {
if (tk.type == TK_COMMA) {
Few more fixes to for loop in shaders
2022-02-04 08:40:42 +03:00
if (!is_condition) {
_set_error(RTR("The middle expression is expected to be a boolean operator."));
return ERR_PARSE_ERROR;
}
Allow multiple declarations in for loop in a shader
2022-02-03 11:13:20 +03:00
continue;
}
if (tk.type != TK_SEMICOLON) {
_set_expected_error(",", ";");
return ERR_PARSE_ERROR;
}
} else if (p_block->block_type == BlockNode::BLOCK_TYPE_FOR_EXPRESSION) {
if (tk.type == TK_COMMA) {
continue;
}
if (tk.type != TK_PARENTHESIS_CLOSE) {
_set_expected_error(",", ")");
return ERR_PARSE_ERROR;
}
} else if (tk.type != TK_SEMICOLON) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(";");
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Few more fixes to for loop in shaders
2022-02-04 08:40:42 +03:00
if (p_block) {
if (p_block->block_type == BlockNode::BLOCK_TYPE_FOR_INIT && !is_var_init) {
_set_error(RTR("The left expression is expected to be a variable declaration."));
return ERR_PARSE_ERROR;
}
if (p_block->block_type == BlockNode::BLOCK_TYPE_FOR_CONDITION && !is_condition) {
_set_error(RTR("The middle expression is expected to be a boolean operator."));
return ERR_PARSE_ERROR;
}
}
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 16:41:43 +02:00
if (p_just_one) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
break;
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 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
return OK;
}
Improve error messages related to `shader_type` The list of allowed shader types is now displayed if any `shader_type`-related error is emitted. This makes it easier to remember which shader types are allowed when creating a new shader.
2019-10-26 17:41:47 +02:00
String ShaderLanguage::_get_shader_type_list(const Set<String> &p_shader_types) const {
// Return a list of shader types as an human-readable string
String valid_types;
for (const Set<String>::Element *E = p_shader_types.front(); E; E = E->next()) {
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 03:42:46 -06:00
if (!valid_types.is_empty()) {
Improve error messages related to `shader_type` The list of allowed shader types is now displayed if any `shader_type`-related error is emitted. This makes it easier to remember which shader types are allowed when creating a new shader.
2019-10-26 17:41:47 +02:00
valid_types += ", ";
}
valid_types += "'" + E->get() + "'";
}
return valid_types;
}
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
String ShaderLanguage::_get_qualifier_str(ArgumentQualifier p_qualifier) const {
switch (p_qualifier) {
case ArgumentQualifier::ARGUMENT_QUALIFIER_IN:
return "in";
case ArgumentQualifier::ARGUMENT_QUALIFIER_OUT:
return "out";
case ArgumentQualifier::ARGUMENT_QUALIFIER_INOUT:
return "inout";
}
return "";
}
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 13:28:29 +03:00
Error ShaderLanguage::_validate_datatype(DataType p_type) {
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
if (RenderingServer::get_singleton()->is_low_end()) {
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 13:28:29 +03:00
bool invalid_type = false;
switch (p_type) {
Disallow uint/uvec usage on GLES2 platform
2020-01-20 15:34:25 +03:00
case TYPE_UINT:
case TYPE_UVEC2:
case TYPE_UVEC3:
case TYPE_UVEC4:
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 13:28:29 +03:00
case TYPE_ISAMPLER2D:
case TYPE_USAMPLER2D:
case TYPE_ISAMPLER3D:
case TYPE_USAMPLER3D:
case TYPE_USAMPLER2DARRAY:
case TYPE_ISAMPLER2DARRAY:
invalid_type = true;
break;
default:
break;
}
if (invalid_type) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("The \"%s\" type is only supported on high-end platforms."), get_datatype_name(p_type)));
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 13:28:29 +03:00
return ERR_UNAVAILABLE;
}
}
return OK;
}
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
Error ShaderLanguage::_parse_shader(const Map<StringName, FunctionInfo> &p_functions, const Vector<ModeInfo> &p_render_modes, const Set<String> &p_shader_types) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Token tk = _get_token();
Break futher shader compilation after missing `;` after`shader_type`
2021-08-11 12:37:59 +03:00
TkPos prev_pos;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
if (tk.type != TK_SHADER_TYPE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Expected '%s' at the beginning of shader. Valid types are: %s."), "shader_type", _get_shader_type_list(p_shader_types)));
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
return ERR_PARSE_ERROR;
}
Add completion for shader_type
2022-01-13 18:00:59 +03:00
StringName shader_type_identifier;
_get_completable_identifier(nullptr, COMPLETION_SHADER_TYPE, shader_type_identifier);
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
Add completion for shader_type
2022-01-13 18:00:59 +03:00
if (shader_type_identifier == StringName()) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Expected an identifier after '%s', indicating the type of shader. Valid types are: %s."), "shader_type", _get_shader_type_list(p_shader_types)));
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
return ERR_PARSE_ERROR;
}
if (!p_shader_types.has(shader_type_identifier)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Invalid shader type. Valid types are: %s"), _get_shader_type_list(p_shader_types)));
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
return ERR_PARSE_ERROR;
}
Break futher shader compilation after missing `;` after`shader_type`
2021-08-11 12:37:59 +03:00
prev_pos = _get_tkpos();
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
tk = _get_token();
if (tk.type != TK_SEMICOLON) {
Break futher shader compilation after missing `;` after`shader_type`
2021-08-11 12:37:59 +03:00
_set_tkpos(prev_pos);
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_after_error(";", "shader_type " + String(shader_type_identifier));
Break futher shader compilation after missing `;` after`shader_type`
2021-08-11 12:37:59 +03:00
return ERR_PARSE_ERROR;
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
}
tk = _get_token();
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 18:31:01 -03:00
int texture_uniforms = 0;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
int texture_binding = 0;
Revert "Pushes array of uniforms to first place in the buffer"
2021-11-25 16:13:19 +03:00
int uniforms = 0;
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
int instance_index = 0;
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
#ifdef DEBUG_ENABLED
int uniform_buffer_size = 0;
Add a check for device in shader lang to prevent startup editor crash
2022-01-04 08:56:33 +03:00
int max_uniform_buffer_size = 0;
Enhances a shader uniform limit warning
2022-01-08 18:34:00 +03:00
int uniform_buffer_exceeded_line = -1;
bool check_device_limit_warnings = false;
{
RenderingDevice *device = RenderingDevice::get_singleton();
if (device != nullptr) {
check_device_limit_warnings = check_warnings && HAS_WARNING(ShaderWarning::DEVICE_LIMIT_EXCEEDED_FLAG);
max_uniform_buffer_size = device->limit_get(RenderingDevice::LIMIT_MAX_UNIFORM_BUFFER_SIZE);
}
Add a check for device in shader lang to prevent startup editor crash
2022-01-04 08:56:33 +03:00
}
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
#endif // DEBUG_ENABLED
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
ShaderNode::Uniform::Scope uniform_scope = ShaderNode::Uniform::SCOPE_LOCAL;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
FIx autocompletion for emit_particle in shader editor
2020-10-13 11:53:06 +03:00
stages = &p_functions;
Fix built-in(PI, TAU, E) assignment to a global constant in a shader
2021-11-29 10:21:10 +03:00
const FunctionInfo &constants = p_functions.has("constants") ? p_functions["constants"] : FunctionInfo();
FIx autocompletion for emit_particle in shader editor
2020-10-13 11:53:06 +03:00
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
Map<String, String> defined_modes;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (tk.type != TK_EOF) {
switch (tk.type) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
case TK_RENDER_MODE: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (true) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
StringName mode;
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
_get_completable_identifier(nullptr, COMPLETION_RENDER_MODE, mode);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (mode == StringName()) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an identifier for render mode."));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
const String smode = String(mode);
Vectors: Use clear() and has(). Use clear() instead of resize(0). Use has() instead of "find(p_val) != -1".
2022-02-02 00:04:13 +05:45
if (shader->render_modes.has(mode)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Duplicated render mode: '%s'."), smode));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
bool found = false;
for (int i = 0; i < p_render_modes.size(); i++) {
const ModeInfo &info = p_render_modes[i];
const String name = String(info.name);
if (smode.begins_with(name)) {
if (!info.options.is_empty()) {
Vectors: Use clear() and has(). Use clear() instead of resize(0). Use has() instead of "find(p_val) != -1".
2022-02-02 00:04:13 +05:45
if (info.options.has(smode.substr(name.length() + 1))) {
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
found = true;
if (defined_modes.has(name)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Redefinition of render mode: '%s'. The '%s' mode has already been set to '%s'."), smode, name, defined_modes[name]));
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
return ERR_PARSE_ERROR;
}
defined_modes.insert(name, smode);
break;
}
} else {
found = true;
break;
}
}
}
if (!found) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Invalid render mode: '%s'."), smode));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
Added additional token checks for the shader if..else.. statement. Fixes issue #2791.
2015-11-22 13:49:58 +08:00
PBR more or less working, still working on bringing gizmos back
2016-10-27 11:50:26 -03:00
shader->render_modes.push_back(mode);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type == TK_COMMA) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
//all good, do nothing
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (tk.type == TK_SEMICOLON) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
break; //done
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Unexpected token: '%s'."), get_token_text(tk)));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
}
} break;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
case TK_STRUCT: {
ShaderNode::Struct st;
DataType type;
tk = _get_token();
if (tk.type == TK_IDENTIFIER) {
st.name = tk.text;
Fix shader crash when using existed constant name for struct
2021-12-01 18:08:14 +03:00
if (shader->constants.has(st.name) || shader->structs.has(st.name)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_redefinition_error(String(st.name));
Prevents shader crash if two struct with the same name are declared
2021-02-21 13:45:01 +03:00
return ERR_PARSE_ERROR;
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
tk = _get_token();
if (tk.type != TK_CURLY_BRACKET_OPEN) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("{");
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
}
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected a struct identifier."));
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
}
StructNode *st_node = alloc_node<StructNode>();
st.shader_struct = st_node;
int member_count = 0;
Fix shader crash if duplicated struct members created
2020-02-15 22:19:45 +03:00
Set<String> member_names;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
while (true) { // variables list
tk = _get_token();
if (tk.type == TK_CURLY_BRACKET_CLOSE) {
break;
}
StringName struct_name = "";
bool struct_dt = false;
bool use_precision = false;
DataPrecision precision = DataPrecision::PRECISION_DEFAULT;
if (tk.type == TK_STRUCT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Nested structs are not allowed."));
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
}
if (is_token_precision(tk.type)) {
precision = get_token_precision(tk.type);
use_precision = true;
tk = _get_token();
}
if (shader->structs.has(tk.text)) {
struct_name = tk.text;
Fix struct usage passing to shader warning system
2021-12-15 22:39:03 +03:00
#ifdef DEBUG_ENABLED
if (check_warnings && HAS_WARNING(ShaderWarning::UNUSED_STRUCT_FLAG) && used_structs.has(struct_name)) {
used_structs[struct_name].used = true;
}
#endif // DEBUG_ENABLED
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
struct_dt = true;
if (use_precision) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("The precision modifier cannot be used on structs."));
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
}
}
if (!is_token_datatype(tk.type) && !struct_dt) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected data type."));
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
} else {
type = struct_dt ? TYPE_STRUCT : get_token_datatype(tk.type);
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
if (type == TYPE_VOID || is_sampler_type(type)) {
_set_error(vformat(RTR("A '%s' data type is not allowed here."), get_datatype_name(type)));
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
}
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
Allow declaring multiple members in one expression in shader structs
2021-12-13 17:40:52 +03:00
bool first = true;
bool fixed_array_size = false;
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
int array_size = 0;
Allow declaring multiple members in one expression in shader structs
2021-12-13 17:40:52 +03:00
do {
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
tk = _get_token();
Allow declaring multiple members in one expression in shader structs
2021-12-13 17:40:52 +03:00
if (first) {
first = false;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
Allow declaring multiple members in one expression in shader structs
2021-12-13 17:40:52 +03:00
if (tk.type != TK_IDENTIFIER && tk.type != TK_BRACKET_OPEN) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an identifier or '['."));
Allow declaring multiple members in one expression in shader structs
2021-12-13 17:40:52 +03:00
return ERR_PARSE_ERROR;
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
Allow declaring multiple members in one expression in shader structs
2021-12-13 17:40:52 +03:00
if (tk.type == TK_BRACKET_OPEN) {
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
Error error = _parse_array_size(nullptr, constants, true, nullptr, &array_size, nullptr);
Allow declaring multiple members in one expression in shader structs
2021-12-13 17:40:52 +03:00
if (error != OK) {
return error;
}
fixed_array_size = true;
tk = _get_token();
}
}
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
Allow declaring multiple members in one expression in shader structs
2021-12-13 17:40:52 +03:00
if (tk.type != TK_IDENTIFIER) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an identifier."));
Allow declaring multiple members in one expression in shader structs
2021-12-13 17:40:52 +03:00
return ERR_PARSE_ERROR;
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
}
Allow declaring multiple members in one expression in shader structs
2021-12-13 17:40:52 +03:00
MemberNode *member = alloc_node<MemberNode>();
member->precision = precision;
member->datatype = type;
member->struct_name = struct_name;
member->name = tk.text;
member->array_size = array_size;
if (member_names.has(member->name)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_redefinition_error(String(member->name));
Allow declaring multiple members in one expression in shader structs
2021-12-13 17:40:52 +03:00
return ERR_PARSE_ERROR;
}
member_names.insert(member->name);
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
tk = _get_token();
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
Allow declaring multiple members in one expression in shader structs
2021-12-13 17:40:52 +03:00
if (tk.type == TK_BRACKET_OPEN) {
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
Error error = _parse_array_size(nullptr, constants, true, nullptr, &member->array_size, nullptr);
Allow declaring multiple members in one expression in shader structs
2021-12-13 17:40:52 +03:00
if (error != OK) {
return error;
}
tk = _get_token();
}
if (!fixed_array_size) {
array_size = 0;
}
if (tk.type != TK_SEMICOLON && tk.type != TK_COMMA) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(",", ";");
Allow declaring multiple members in one expression in shader structs
2021-12-13 17:40:52 +03:00
return ERR_PARSE_ERROR;
}
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
Allow declaring multiple members in one expression in shader structs
2021-12-13 17:40:52 +03:00
st_node->members.push_back(member);
member_count++;
} while (tk.type == TK_COMMA); // another member
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
}
if (member_count == 0) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Empty structs are not allowed."));
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_SEMICOLON) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(";");
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
}
shader->structs[st.name] = st;
shader->vstructs.push_back(st); // struct's order is important!
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
#ifdef DEBUG_ENABLED
if (check_warnings && HAS_WARNING(ShaderWarning::UNUSED_STRUCT_FLAG)) {
used_structs.insert(st.name, Usage(tk_line));
}
#endif // DEBUG_ENABLED
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
} break;
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
case TK_GLOBAL: {
tk = _get_token();
if (tk.type != TK_UNIFORM) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_after_error("uniform", "global");
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
return ERR_PARSE_ERROR;
}
uniform_scope = ShaderNode::Uniform::SCOPE_GLOBAL;
};
[[fallthrough]];
case TK_INSTANCE: {
if (uniform_scope == ShaderNode::Uniform::SCOPE_LOCAL) {
tk = _get_token();
if (tk.type != TK_UNIFORM) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_after_error("uniform", "instance");
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
return ERR_PARSE_ERROR;
}
uniform_scope = ShaderNode::Uniform::SCOPE_INSTANCE;
}
};
[[fallthrough]];
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
case TK_UNIFORM:
case TK_VARYING: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool uniform = tk.type == TK_UNIFORM;
Forbids varying declaration in particles and sky shaders
2020-09-20 18:45:37 +03:00
if (!uniform) {
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 04:28:55 -07:00
if (shader_type_identifier == "particles" || shader_type_identifier == "sky" || shader_type_identifier == "fog") {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Varyings cannot be used in '%s' shaders."), shader_type_identifier));
Forbids varying declaration in particles and sky shaders
2020-09-20 18:45:37 +03:00
return ERR_PARSE_ERROR;
}
}
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
bool precision_defined = false;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataPrecision precision = PRECISION_DEFAULT;
Added interpolation modifiers to shaderlang
2017-11-27 16:47:46 +01:00
DataInterpolation interpolation = INTERPOLATION_SMOOTH;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataType type;
StringName name;
Fix shader crash when using varying array in fragment->light context
2021-08-11 09:38:38 +03:00
int array_size = 0;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
Added interpolation modifiers to shaderlang
2017-11-27 16:47:46 +01:00
if (is_token_interpolation(tk.type)) {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (uniform) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Interpolation qualifiers are not supported for uniforms."));
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
return ERR_PARSE_ERROR;
}
Added interpolation modifiers to shaderlang
2017-11-27 16:47:46 +01:00
interpolation = get_token_interpolation(tk.type);
tk = _get_token();
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (is_token_precision(tk.type)) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
precision = get_token_precision(tk.type);
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
precision_defined = true;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (shader->structs.has(tk.text)) {
if (uniform) {
if (precision_defined) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("The precision modifier cannot be used on structs."));
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
return ERR_PARSE_ERROR;
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("The '%s' data type is not supported for uniforms."), "struct"));
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
return ERR_PARSE_ERROR;
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("The '%s' data type not allowed here."), "struct"));
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
return ERR_PARSE_ERROR;
}
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (!is_token_datatype(tk.type)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected data type."));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
type = get_token_datatype(tk.type);
Added additional token checks for the shader if..else.. statement. Fixes issue #2791.
2015-11-22 13:49:58 +08:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (type == TYPE_VOID) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("The '%s' data type is not allowed here."), "void"));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
Fixes logically dead code (Coverity) Fixes reported logically dead codes by Coverity * image.cpp: Doesn't really need any modification. But to remove the bug report then we have to move the MAX call away from the for loop statement. * rasterizer_gles3.cpp: Removes unnecessary elif condition since it is checked earlier in the function * collada.cpp: If stamement never reached due to macro ERR_CONTINUE does the same. * navigation_mesh.cpp: Variables should always be null - however, also checked for the very same condition in their function call. Leaving this for review (whether the function call is necessary or not) * path_editor_plugin.cpp: If cancel is true, then it should restore the edited value to the original provided. http://docs.godotengine.org/en/3.0/classes/class_editorspatialgizmo.html#class-editorspatialgizmo-commit-handle * spatial_editor_gizmos.cpp: the very condition of i >= 3 is predetermined in the if case right before it. Thus case 1 is always '1' and case 2 is always '-1' * grid_map_editor.cpp: Same as above in spatial_editor_gizmos.cpp * voxel_light_baker.cpp: Same as above in spatial_editor_gizmos.cpp * visual_server.cpp: Same as above in spatial_editor_gizmos.cpp * visual_script_expression.cpp: char '-' is already true in the switch case mechanism. Thus it can never reach to default case. * particles.cpp: Case 'PARAM_MAX' is unreachable due to index checking right before the switch execution. * shader_language.cpp: Invalid index is handled in switch default case. `type < TYPE_FLOAT && type > TYPE_VEC4` -> `(type < TYPE_FLOAT || type > TYPE_VEC4`) Fixes the "always false problem" in TODO comment.
2018-04-21 22:35:23 +08:00
Allow matrixes in varyings
2018-08-19 15:16:54 +03:00
if (!uniform && (type < TYPE_FLOAT || type > TYPE_MAT4)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Invalid type for varying, only 'float', 'vec2', 'vec3', 'vec4', 'mat2', 'mat3', 'mat4', or arrays of these types are allowed."));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
Added additional token checks for the shader if..else.. statement. Fixes issue #2791.
2015-11-22 13:49:58 +08:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
Fix shader crash when using varying array in fragment->light context
2021-08-11 09:38:38 +03:00
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
if (tk.type != TK_IDENTIFIER && tk.type != TK_BRACKET_OPEN) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an identifier or '['."));
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
return ERR_PARSE_ERROR;
}
Fix shader crash when using varying array in fragment->light context
2021-08-11 09:38:38 +03:00
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
if (tk.type == TK_BRACKET_OPEN) {
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
Error error = _parse_array_size(nullptr, constants, true, nullptr, &array_size, nullptr);
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
if (error != OK) {
return error;
Fix shader crash when using varying array in fragment->light context
2021-08-11 09:38:38 +03:00
}
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
tk = _get_token();
Fix shader crash when using varying array in fragment->light context
2021-08-11 09:38:38 +03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type != TK_IDENTIFIER) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an identifier."));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Break futher shader compilation after missing `;` after`shader_type`
2021-08-11 12:37:59 +03:00
prev_pos = _get_tkpos();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
name = tk.text;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Fix built-in(PI, TAU, E) assignment to a global constant in a shader
2021-11-29 10:21:10 +03:00
if (_find_identifier(nullptr, false, constants, name)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_redefinition_error(String(name));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Added check if field name in the shader is equal to builtin
2019-10-29 14:36:11 +03:00
if (has_builtin(p_functions, name)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_redefinition_error(String(name));
Added check if field name in the shader is equal to builtin
2019-10-29 14:36:11 +03:00
return ERR_PARSE_ERROR;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (uniform) {
Prevent checking of global uniform type outside the editor
2022-01-25 19:22:37 +03:00
if (uniform_scope == ShaderNode::Uniform::SCOPE_GLOBAL && Engine::get_singleton()->is_editor_hint()) { // Type checking for global uniforms is not allowed outside the editor.
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
//validate global uniform
DataType gvtype = global_var_get_type_func(name);
if (gvtype == TYPE_MAX) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Global uniform '%s' does not exist. Create it in Project Settings."), String(name)));
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
return ERR_PARSE_ERROR;
}
if (type != gvtype) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Global uniform '%s' must be of type '%s'."), String(name), get_datatype_name(gvtype)));
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
return ERR_PARSE_ERROR;
}
}
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
ShaderNode::Uniform uniform2;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
uniform2.type = type;
uniform2.scope = uniform_scope;
uniform2.precision = precision;
uniform2.array_size = array_size;
tk = _get_token();
if (tk.type == TK_BRACKET_OPEN) {
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
Error error = _parse_array_size(nullptr, constants, true, nullptr, &uniform2.array_size, nullptr);
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
if (error != OK) {
return error;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
tk = _get_token();
}
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 18:31:01 -03:00
if (is_sampler_type(type)) {
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
if (uniform_scope == ShaderNode::Uniform::SCOPE_INSTANCE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Uniforms with '%s' qualifiers can't be of sampler type.", "instance")));
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
return ERR_PARSE_ERROR;
}
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
uniform2.texture_order = texture_uniforms++;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
uniform2.texture_binding = texture_binding;
if (uniform2.array_size > 0) {
texture_binding += uniform2.array_size;
} else {
++texture_binding;
}
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
uniform2.order = -1;
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 13:28:29 +03:00
if (_validate_datatype(type) != OK) {
return ERR_PARSE_ERROR;
}
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 18:31:01 -03:00
} else {
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 09:34:23 -03:00
if (uniform_scope == ShaderNode::Uniform::SCOPE_INSTANCE && (type == TYPE_MAT2 || type == TYPE_MAT3 || type == TYPE_MAT4)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Uniforms with '%s' qualifier can't be of matrix type.", "instance")));
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
return ERR_PARSE_ERROR;
}
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
uniform2.texture_order = -1;
Revert "Pushes array of uniforms to first place in the buffer"
2021-11-25 16:13:19 +03:00
if (uniform_scope != ShaderNode::Uniform::SCOPE_INSTANCE) {
uniform2.order = uniforms++;
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
#ifdef DEBUG_ENABLED
Enhances a shader uniform limit warning
2022-01-08 18:34:00 +03:00
if (check_device_limit_warnings) {
if (uniform2.array_size > 0) {
int size = get_datatype_size(uniform2.type) * uniform2.array_size;
int m = (16 * uniform2.array_size);
if ((size % m) != 0U) {
size += m - (size % m);
}
uniform_buffer_size += size;
} else {
uniform_buffer_size += get_datatype_size(uniform2.type);
}
if (uniform_buffer_exceeded_line == -1 && uniform_buffer_size > max_uniform_buffer_size) {
uniform_buffer_exceeded_line = tk_line;
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
}
}
#endif // DEBUG_ENABLED
Revert "Pushes array of uniforms to first place in the buffer"
2021-11-25 16:13:19 +03:00
}
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 18:31:01 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (uniform2.array_size > 0) {
if (uniform_scope == ShaderNode::Uniform::SCOPE_GLOBAL) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("The '%s' qualifier is not supported for uniform arrays."), "SCOPE_GLOBAL"));
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
return ERR_PARSE_ERROR;
}
if (uniform_scope == ShaderNode::Uniform::SCOPE_INSTANCE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("The '%s' qualifier is not supported for uniform arrays."), "SCOPE_INSTANCE"));
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
return ERR_PARSE_ERROR;
}
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
int custom_instance_index = -1;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type == TK_COLON) {
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
completion_type = COMPLETION_HINT;
completion_base = type;
completion_base_array = uniform2.array_size > 0;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
//hint
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
do {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
completion_line = tk.line;
if (!is_token_hint(tk.type)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected valid type hint after ':'."));
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
return ERR_PARSE_ERROR;
}
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (uniform2.array_size > 0) {
if (tk.type != TK_HINT_COLOR) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("This hint is not supported for uniform arrays."));
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
return ERR_PARSE_ERROR;
}
}
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
if (tk.type == TK_HINT_WHITE_TEXTURE) {
uniform2.hint = ShaderNode::Uniform::HINT_WHITE;
} else if (tk.type == TK_HINT_BLACK_TEXTURE) {
uniform2.hint = ShaderNode::Uniform::HINT_BLACK;
} else if (tk.type == TK_HINT_NORMAL_TEXTURE) {
uniform2.hint = ShaderNode::Uniform::HINT_NORMAL;
} else if (tk.type == TK_HINT_ROUGHNESS_NORMAL_TEXTURE) {
uniform2.hint = ShaderNode::Uniform::HINT_ROUGHNESS_NORMAL;
} else if (tk.type == TK_HINT_ROUGHNESS_R) {
uniform2.hint = ShaderNode::Uniform::HINT_ROUGHNESS_R;
} else if (tk.type == TK_HINT_ROUGHNESS_G) {
uniform2.hint = ShaderNode::Uniform::HINT_ROUGHNESS_G;
} else if (tk.type == TK_HINT_ROUGHNESS_B) {
uniform2.hint = ShaderNode::Uniform::HINT_ROUGHNESS_B;
} else if (tk.type == TK_HINT_ROUGHNESS_A) {
uniform2.hint = ShaderNode::Uniform::HINT_ROUGHNESS_A;
} else if (tk.type == TK_HINT_ROUGHNESS_GRAY) {
uniform2.hint = ShaderNode::Uniform::HINT_ROUGHNESS_GRAY;
Rename `hint_aniso` to `hint_anisotropy` in the shader language The word "anisotropy" is used in full form in BaseMaterial3D's anisotropy-related properties.
2021-12-09 20:29:06 +01:00
} else if (tk.type == TK_HINT_ANISOTROPY_TEXTURE) {
uniform2.hint = ShaderNode::Uniform::HINT_ANISOTROPY;
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
} else if (tk.type == TK_HINT_ALBEDO_TEXTURE) {
uniform2.hint = ShaderNode::Uniform::HINT_ALBEDO;
} else if (tk.type == TK_HINT_BLACK_ALBEDO_TEXTURE) {
uniform2.hint = ShaderNode::Uniform::HINT_BLACK_ALBEDO;
} else if (tk.type == TK_HINT_COLOR) {
if (type != TYPE_VEC4) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Color hint is for '%s' only."), "vec4"));
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
return ERR_PARSE_ERROR;
}
uniform2.hint = ShaderNode::Uniform::HINT_COLOR;
} else if (tk.type == TK_HINT_RANGE) {
uniform2.hint = ShaderNode::Uniform::HINT_RANGE;
if (type != TYPE_FLOAT && type != TYPE_INT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Range hint is for '%s' and '%s' only."), "float", "int"));
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
return ERR_PARSE_ERROR;
}
Huge amount of improvement in the material system. Materials should be a lot more complete and usable now.
2016-11-20 22:49:53 -03:00
tk = _get_token();
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
if (tk.type != TK_PARENTHESIS_OPEN) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_after_error("(", "hint_range");
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
float sign = 1.0;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
if (tk.type == TK_OP_SUB) {
sign = -1.0;
tk = _get_token();
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
if (tk.type != TK_FLOAT_CONSTANT && !tk.is_integer_constant()) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an integer constant."));
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
uniform2.hint_range[0] = tk.constant;
uniform2.hint_range[0] *= sign;
Huge amount of improvement in the material system. Materials should be a lot more complete and usable now.
2016-11-20 22:49:53 -03:00
tk = _get_token();
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
if (tk.type != TK_COMMA) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected ',' after integer constant."));
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
sign = 1.0;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
if (tk.type == TK_OP_SUB) {
sign = -1.0;
tk = _get_token();
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
if (tk.type != TK_FLOAT_CONSTANT && !tk.is_integer_constant()) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an integer constant after ','."));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
uniform2.hint_range[1] = tk.constant;
uniform2.hint_range[1] *= sign;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
if (tk.type == TK_COMMA) {
tk = _get_token();
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
if (tk.type != TK_FLOAT_CONSTANT && !tk.is_integer_constant()) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an integer constant after ','."));
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
return ERR_PARSE_ERROR;
}
uniform2.hint_range[2] = tk.constant;
tk = _get_token();
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} else {
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
if (type == TYPE_INT) {
uniform2.hint_range[2] = 1;
} else {
uniform2.hint_range[2] = 0.001;
}
}
if (tk.type != TK_PARENTHESIS_CLOSE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(")");
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
return ERR_PARSE_ERROR;
}
} else if (tk.type == TK_HINT_INSTANCE_INDEX) {
if (custom_instance_index != -1) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Can only specify '%s' once."), "instance_index"));
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_PARENTHESIS_OPEN) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_after_error("(", "instance_index");
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type == TK_OP_SUB) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("The instance index can't be negative."));
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
return ERR_PARSE_ERROR;
}
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
if (!tk.is_integer_constant()) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an integer constant."));
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
return ERR_PARSE_ERROR;
}
custom_instance_index = tk.constant;
if (custom_instance_index >= MAX_INSTANCE_UNIFORM_INDICES) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Allowed instance uniform indices must be within [0..%d] range."), MAX_INSTANCE_UNIFORM_INDICES - 1));
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_PARENTHESIS_CLOSE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(")");
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
return ERR_PARSE_ERROR;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
} else if (tk.type == TK_FILTER_LINEAR) {
uniform2.filter = FILTER_LINEAR;
} else if (tk.type == TK_FILTER_NEAREST) {
uniform2.filter = FILTER_NEAREST;
} else if (tk.type == TK_FILTER_NEAREST_MIPMAP) {
uniform2.filter = FILTER_NEAREST_MIPMAP;
} else if (tk.type == TK_FILTER_LINEAR_MIPMAP) {
uniform2.filter = FILTER_LINEAR_MIPMAP;
Rename shader hint `filter_anisotropy` to `filter_anisotropic`
2021-12-15 22:12:38 +03:00
} else if (tk.type == TK_FILTER_NEAREST_MIPMAP_ANISOTROPIC) {
uniform2.filter = FILTER_NEAREST_MIPMAP_ANISOTROPIC;
} else if (tk.type == TK_FILTER_LINEAR_MIPMAP_ANISOTROPIC) {
uniform2.filter = FILTER_LINEAR_MIPMAP_ANISOTROPIC;
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
} else if (tk.type == TK_REPEAT_DISABLE) {
uniform2.repeat = REPEAT_DISABLE;
} else if (tk.type == TK_REPEAT_ENABLE) {
uniform2.repeat = REPEAT_ENABLE;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
if (uniform2.hint != ShaderNode::Uniform::HINT_RANGE && uniform2.hint != ShaderNode::Uniform::HINT_NONE && uniform2.hint != ShaderNode::Uniform::HINT_COLOR && type <= TYPE_MAT4) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("This hint is only for sampler types."));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
} while (tk.type == TK_COMMA);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
if (uniform_scope == ShaderNode::Uniform::SCOPE_INSTANCE) {
if (custom_instance_index >= 0) {
uniform2.instance_index = custom_instance_index;
} else {
uniform2.instance_index = instance_index++;
if (instance_index > MAX_INSTANCE_UNIFORM_INDICES) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Too many '%s' uniforms in shader, maximum supported is %d."), "instance", MAX_INSTANCE_UNIFORM_INDICES));
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
return ERR_PARSE_ERROR;
}
}
}
//reset scope for next uniform
Hinted shader uniforms can have a default value
2018-03-15 15:23:40 +01:00
if (tk.type == TK_OP_ASSIGN) {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (uniform2.array_size > 0) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Setting default values to uniform arrays is not supported."));
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
return ERR_PARSE_ERROR;
}
Fix built-in(PI, TAU, E) assignment to a global constant in a shader
2021-11-29 10:21:10 +03:00
Node *expr = _parse_and_reduce_expression(nullptr, constants);
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 16:41:43 +02:00
if (!expr) {
Hinted shader uniforms can have a default value
2018-03-15 15:23:40 +01:00
return ERR_PARSE_ERROR;
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 16:41:43 +02:00
}
Hinted shader uniforms can have a default value
2018-03-15 15:23:40 +01:00
if (expr->type != Node::TYPE_CONSTANT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected constant expression after '='."));
Hinted shader uniforms can have a default value
2018-03-15 15:23:40 +01:00
return ERR_PARSE_ERROR;
}
ConstantNode *cn = static_cast<ConstantNode *>(expr);
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
uniform2.default_value.resize(cn->values.size());
Hinted shader uniforms can have a default value
2018-03-15 15:23:40 +01:00
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
if (!convert_constant(cn, uniform2.type, uniform2.default_value.ptrw())) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Can't convert constant to '%s'."), get_datatype_name(uniform2.type)));
Hinted shader uniforms can have a default value
2018-03-15 15:23:40 +01:00
return ERR_PARSE_ERROR;
}
tk = _get_token();
}
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
shader->uniforms[name] = uniform2;
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
#ifdef DEBUG_ENABLED
if (check_warnings && HAS_WARNING(ShaderWarning::UNUSED_UNIFORM_FLAG)) {
used_uniforms.insert(name, Usage(tk_line));
}
#endif // DEBUG_ENABLED
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-16 23:52:00 -03:00
//reset scope for next uniform
uniform_scope = ShaderNode::Uniform::SCOPE_LOCAL;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type != TK_SEMICOLON) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(";");
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
completion_type = COMPLETION_NONE;
Allow passing varying from fragment to light shader function
2020-12-26 14:26:19 +03:00
} else { // varying
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
ShaderNode::Varying varying;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
varying.type = type;
Fix many asan and ubsan reported issues This allows most demos to run without any ubsan or asan errors. There are still some things in thirdpart/ and some things in AudioServer that needs a look but this fixes a lot of issues. This should help debug less obvious issues, hopefully. This fixes #25217 and fixes #25218
2019-01-30 02:12:41 +01:00
varying.precision = precision;
Added interpolation modifiers to shaderlang
2017-11-27 16:47:46 +01:00
varying.interpolation = interpolation;
Break futher shader compilation after missing `;` after`shader_type`
2021-08-11 12:37:59 +03:00
varying.tkpos = prev_pos;
Fix shader crash when using varying array in fragment->light context
2021-08-11 09:38:38 +03:00
varying.array_size = array_size;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
Implement shader array support for varyings
2019-07-29 17:08:25 +03:00
if (tk.type != TK_SEMICOLON && tk.type != TK_BRACKET_OPEN) {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (array_size == 0) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(";", "[");
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(";");
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
Implement shader array support for varyings
2019-07-29 17:08:25 +03:00
if (tk.type == TK_BRACKET_OPEN) {
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
Error error = _parse_array_size(nullptr, constants, true, nullptr, &varying.array_size, nullptr);
if (error != OK) {
return error;
Fix shader crash when using varying array in fragment->light context
2021-08-11 09:38:38 +03:00
}
Implement shader array support for varyings
2019-07-29 17:08:25 +03:00
tk = _get_token();
}
shader->varyings[name] = varying;
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
#ifdef DEBUG_ENABLED
if (check_warnings && HAS_WARNING(ShaderWarning::UNUSED_VARYING_FLAG)) {
used_varyings.insert(name, Usage(tk_line));
}
#endif // DEBUG_ENABLED
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
} break;
Add completion for shader_type
2022-01-13 18:00:59 +03:00
case TK_SHADER_TYPE: {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Shader type is already defined."));
Add completion for shader_type
2022-01-13 18:00:59 +03:00
return ERR_PARSE_ERROR;
} break;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
default: {
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
//function or constant variable
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
bool is_constant = false;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
bool is_struct = false;
StringName struct_name;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataPrecision precision = PRECISION_DEFAULT;
DataType type;
StringName name;
Fix declaring array size twice in global shader constant
2021-12-01 16:44:11 +03:00
int array_size = 0;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
if (tk.type == TK_CONST) {
is_constant = true;
tk = _get_token();
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (is_token_precision(tk.type)) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
precision = get_token_precision(tk.type);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (shader->structs.has(tk.text)) {
if (precision != PRECISION_DEFAULT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("The precision modifier cannot be used on structs."));
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
}
is_struct = true;
struct_name = tk.text;
} else {
if (!is_token_datatype(tk.type)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected constant, function, uniform or varying."));
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
}
Do not allow samplers where they dont belong (variables/return types), fixes #15133
2018-11-12 08:36:26 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (!is_token_variable_datatype(tk.type)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
if (is_constant) {
_set_error(RTR("Invalid constant type (samplers are not allowed)."));
} else {
_set_error(RTR("Invalid function type (samplers are not allowed)."));
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
}
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (is_struct) {
type = TYPE_STRUCT;
} else {
type = get_token_datatype(tk.type);
}
Break futher shader compilation after missing `;` after`shader_type`
2021-08-11 12:37:59 +03:00
prev_pos = _get_tkpos();
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
tk = _get_token();
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
Fix declaring array size twice in global shader constant
2021-12-01 16:44:11 +03:00
bool unknown_size = false;
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
bool fixed_array_size = false;
Fix declaring array size twice in global shader constant
2021-12-01 16:44:11 +03:00
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
if (tk.type == TK_BRACKET_OPEN) {
Fix declaring array size twice in global shader constant
2021-12-01 16:44:11 +03:00
if (is_constant && RenderingServer::get_singleton()->is_low_end()) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Global constant arrays are only supported on high-end platforms."));
Fix declaring array size twice in global shader constant
2021-12-01 16:44:11 +03:00
return ERR_PARSE_ERROR;
}
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
Error error = _parse_array_size(nullptr, constants, !is_constant, nullptr, &array_size, &unknown_size);
if (error != OK) {
return error;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
}
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
fixed_array_size = true;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
prev_pos = _get_tkpos();
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
_set_tkpos(prev_pos);
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
_get_completable_identifier(nullptr, COMPLETION_MAIN_FUNCTION, name);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (name == StringName()) {
Fix declaring array size twice in global shader constant
2021-12-01 16:44:11 +03:00
if (is_constant) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an identifier or '[' after type."));
Fix declaring array size twice in global shader constant
2021-12-01 16:44:11 +03:00
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected a function name after type."));
Fix declaring array size twice in global shader constant
2021-12-01 16:44:11 +03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Fix shader crash when using existed constant name for struct
2021-12-01 18:08:14 +03:00
if (shader->structs.has(name) || _find_identifier(nullptr, false, constants, name) || has_builtin(p_functions, name)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_redefinition_error(String(name));
Added check if field name in the shader is equal to builtin
2019-10-29 14:36:11 +03:00
return ERR_PARSE_ERROR;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type != TK_PARENTHESIS_OPEN) {
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
if (type == TYPE_VOID) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected '(' after function identifier."));
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
return ERR_PARSE_ERROR;
}
//variable
while (true) {
ShaderNode::Constant constant;
Fix shader constant sorting
2020-04-11 12:40:17 +03:00
constant.name = name;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
constant.type = is_struct ? TYPE_STRUCT : type;
constant.type_str = struct_name;
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
constant.precision = precision;
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
constant.initializer = nullptr;
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
constant.array_size = array_size;
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
if (tk.type == TK_BRACKET_OPEN) {
if (RenderingServer::get_singleton()->is_low_end()) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Global const arrays are only supported on high-end platforms."));
Fix declaring array size twice in global shader constant
2021-12-01 16:44:11 +03:00
return ERR_PARSE_ERROR;
}
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
Error error = _parse_array_size(nullptr, constants, false, nullptr, &constant.array_size, &unknown_size);
if (error != OK) {
return error;
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
}
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
tk = _get_token();
}
if (tk.type == TK_OP_ASSIGN) {
if (!is_constant) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Global non-constant variables are not supported. Expected '%s' keyword before constant definition."), "const"));
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
return ERR_PARSE_ERROR;
}
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
if (constant.array_size > 0 || unknown_size) {
bool full_def = false;
Unify variable and array declarations in shaders
2022-01-18 10:40:41 +03:00
VariableDeclarationNode::Declaration decl;
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
decl.name = name;
decl.size = constant.array_size;
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
tk = _get_token();
if (tk.type != TK_CURLY_BRACKET_OPEN) {
if (unknown_size) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("{");
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
return ERR_PARSE_ERROR;
}
full_def = true;
DataPrecision precision2 = PRECISION_DEFAULT;
if (is_token_precision(tk.type)) {
precision2 = get_token_precision(tk.type);
tk = _get_token();
if (!is_token_nonvoid_datatype(tk.type)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected data type after precision modifier."));
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
return ERR_PARSE_ERROR;
}
}
StringName struct_name2;
DataType type2;
if (shader->structs.has(tk.text)) {
type2 = TYPE_STRUCT;
struct_name2 = tk.text;
} else {
if (!is_token_variable_datatype(tk.type)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Invalid data type for the array."));
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
return ERR_PARSE_ERROR;
}
type2 = get_token_datatype(tk.type);
}
int array_size2 = 0;
tk = _get_token();
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
if (tk.type == TK_BRACKET_OPEN) {
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
bool is_unknown_size = false;
Error error = _parse_array_size(nullptr, constants, false, nullptr, &array_size2, &is_unknown_size);
if (error != OK) {
return error;
}
if (is_unknown_size) {
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
array_size2 = constant.array_size;
}
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
tk = _get_token();
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("[");
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
return ERR_PARSE_ERROR;
}
if (constant.precision != precision2 || constant.type != type2 || struct_name != struct_name2 || constant.array_size != array_size2) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
String from;
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
if (type2 == TYPE_STRUCT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
from += struct_name2;
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
} else {
if (precision2 != PRECISION_DEFAULT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
from += get_precision_name(precision2);
from += " ";
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
from += get_datatype_name(type2);
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
from += "[";
from += itos(array_size2);
from += "]'";
String to;
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
if (type == TYPE_STRUCT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
to += struct_name;
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
} else {
if (precision != PRECISION_DEFAULT) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
to += get_precision_name(precision);
to += " ";
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
to += get_datatype_name(type);
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
}
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
to += "[";
to += itos(constant.array_size);
to += "]'";
_set_error(vformat(RTR("Cannot convert from '%s' to '%s'."), from, to));
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
return ERR_PARSE_ERROR;
}
}
bool curly = tk.type == TK_CURLY_BRACKET_OPEN;
if (unknown_size) {
if (!curly) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("{");
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
return ERR_PARSE_ERROR;
}
} else {
if (full_def) {
if (curly) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("(");
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
return ERR_PARSE_ERROR;
}
}
}
if (tk.type == TK_PARENTHESIS_OPEN || curly) { // initialization
while (true) {
Fix built-in(PI, TAU, E) assignment to a global constant in a shader
2021-11-29 10:21:10 +03:00
Node *n = _parse_and_reduce_expression(nullptr, constants);
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
if (!n) {
return ERR_PARSE_ERROR;
}
if (n->type == Node::TYPE_OPERATOR && ((OperatorNode *)n)->op == OP_CALL) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected constant expression."));
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
return ERR_PARSE_ERROR;
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (!_compare_datatypes(constant.type, struct_name, 0, n->get_datatype(), n->get_datatype_name(), 0)) {
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type == TK_COMMA) {
decl.initializer.push_back(n);
continue;
} else if (!curly && tk.type == TK_PARENTHESIS_CLOSE) {
decl.initializer.push_back(n);
break;
} else if (curly && tk.type == TK_CURLY_BRACKET_CLOSE) {
decl.initializer.push_back(n);
break;
} else {
Style: Apply clang-tidy's `readability-braces-around-statements`
2021-04-05 14:09:59 +02:00
if (curly) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error("}", ",");
Style: Apply clang-tidy's `readability-braces-around-statements`
2021-04-05 14:09:59 +02:00
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(")", ",");
Style: Apply clang-tidy's `readability-braces-around-statements`
2021-04-05 14:09:59 +02:00
}
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
return ERR_PARSE_ERROR;
}
}
if (unknown_size) {
decl.size = decl.initializer.size();
constant.array_size = decl.initializer.size();
} else if (decl.initializer.size() != constant.array_size) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Array size mismatch."));
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
return ERR_PARSE_ERROR;
}
}
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
array_size = constant.array_size;
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
ConstantNode *expr = memnew(ConstantNode);
expr->datatype = constant.type;
expr->struct_name = constant.type_str;
expr->array_size = constant.array_size;
expr->array_declarations.push_back(decl);
constant.initializer = static_cast<ConstantNode *>(expr);
} else {
//variable created with assignment! must parse an expression
Fix built-in(PI, TAU, E) assignment to a global constant in a shader
2021-11-29 10:21:10 +03:00
Node *expr = _parse_and_reduce_expression(nullptr, constants);
Style: Apply clang-tidy's `readability-braces-around-statements`
2021-04-05 14:09:59 +02:00
if (!expr) {
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
return ERR_PARSE_ERROR;
Style: Apply clang-tidy's `readability-braces-around-statements`
2021-04-05 14:09:59 +02:00
}
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
if (expr->type == Node::TYPE_OPERATOR && ((OperatorNode *)expr)->op == OP_CALL) {
Fix shader handle constant expressions in function call
2021-04-27 14:58:32 +03:00
OperatorNode *op = ((OperatorNode *)expr);
for (int i = 1; i < op->arguments.size(); i++) {
if (!_check_node_constness(op->arguments[i])) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Expected constant expression for argument %d of function call after '='."), i - 1));
Fix shader handle constant expressions in function call
2021-04-27 14:58:32 +03:00
return ERR_PARSE_ERROR;
}
}
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
}
constant.initializer = static_cast<ConstantNode *>(expr);
Fix shader crash when assigning array to non-array in global constant
2021-11-30 21:28:55 +03:00
if (!_compare_datatypes(type, struct_name, 0, expr->get_datatype(), expr->get_datatype_name(), expr->get_array_size())) {
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
}
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
}
tk = _get_token();
} else {
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
if (constant.array_size > 0 || unknown_size) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected array initialization."));
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
return ERR_PARSE_ERROR;
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected initialization of constant."));
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
return ERR_PARSE_ERROR;
}
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
}
shader->constants[name] = constant;
Fix shader constant sorting
2020-04-11 12:40:17 +03:00
shader->vconstants.push_back(constant);
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
#ifdef DEBUG_ENABLED
if (check_warnings && HAS_WARNING(ShaderWarning::UNUSED_CONSTANT_FLAG)) {
used_constants.insert(name, Usage(tk_line));
}
#endif // DEBUG_ENABLED
Fix shader constant sorting
2020-04-11 12:40:17 +03:00
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
if (tk.type == TK_COMMA) {
tk = _get_token();
if (tk.type != TK_IDENTIFIER) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an identifier after type."));
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
return ERR_PARSE_ERROR;
}
name = tk.text;
Fix built-in(PI, TAU, E) assignment to a global constant in a shader
2021-11-29 10:21:10 +03:00
if (_find_identifier(nullptr, false, constants, name)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_redefinition_error(String(name));
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
return ERR_PARSE_ERROR;
}
Added check if field name in the shader is equal to builtin
2019-10-29 14:36:11 +03:00
if (has_builtin(p_functions, name)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_redefinition_error(String(name));
Added check if field name in the shader is equal to builtin
2019-10-29 14:36:11 +03:00
return ERR_PARSE_ERROR;
}
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
tk = _get_token();
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
if (!fixed_array_size) {
array_size = 0;
}
unknown_size = false;
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
} else if (tk.type == TK_SEMICOLON) {
break;
} else {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(",", ";");
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
return ERR_PARSE_ERROR;
}
}
break;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
FunctionInfo builtins;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (p_functions.has(name)) {
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
builtins = p_functions[name];
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Makes shader 'TIME' available in custom functions by default
2020-03-19 17:58:39 +03:00
if (p_functions.has("global")) { // Adds global variables: 'TIME'
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
for (const KeyValue<StringName, BuiltInInfo> &E : p_functions["global"].built_ins) {
builtins.built_ins.insert(E.key, E.value);
Makes shader 'TIME' available in custom functions by default
2020-03-19 17:58:39 +03:00
}
}
Fix built-in(PI, TAU, E) assignment to a global constant in a shader
2021-11-29 10:21:10 +03:00
if (p_functions.has("constants")) { // Adds global constants: 'PI', 'TAU', 'E'
for (const KeyValue<StringName, BuiltInInfo> &E : p_functions["constants"].built_ins) {
builtins.built_ins.insert(E.key, E.value);
}
}
Prevent redefinition of main functions in shader
2022-01-13 14:39:35 +03:00
for (int i = 0; i < shader->functions.size(); i++) {
if (!shader->functions[i].callable && shader->functions[i].name == name) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_redefinition_error(String(name));
Prevent redefinition of main functions in shader
2022-01-13 14:39:35 +03:00
return ERR_PARSE_ERROR;
}
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
ShaderNode::Function function;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
function.callable = !p_functions.has(name);
function.name = name;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
FunctionNode *func_node = alloc_node<FunctionNode>();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
function.function = func_node;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
shader->functions.push_back(function);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
func_node->name = name;
func_node->return_type = type;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
func_node->return_struct_name = struct_name;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
func_node->return_precision = precision;
Fix declaring array size twice in global shader constant
2021-12-01 16:44:11 +03:00
func_node->return_array_size = array_size;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Discarding now works in shaders "discard" has been added to the list of recognised keywords. A flag specifing when discarding is allowed is now set correctly.
2017-09-24 01:27:12 -06:00
if (p_functions.has(name)) {
func_node->can_discard = p_functions[name].can_discard;
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
} else {
#ifdef DEBUG_ENABLED
if (check_warnings && HAS_WARNING(ShaderWarning::UNUSED_FUNCTION_FLAG)) {
used_functions.insert(name, Usage(tk_line));
}
#endif // DEBUG_ENABLED
Discarding now works in shaders "discard" has been added to the list of recognised keywords. A flag specifing when discarding is allowed is now set correctly.
2017-09-24 01:27:12 -06:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
func_node->body = alloc_node<BlockNode>();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
func_node->body->parent_function = func_node;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (true) {
if (tk.type == TK_PARENTHESIS_CLOSE) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
break;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Added const qualifier support for function arguments in shaders
2020-07-01 11:55:49 +03:00
bool is_const = false;
if (tk.type == TK_CONST) {
is_const = true;
tk = _get_token();
}
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
ArgumentQualifier qualifier = ARGUMENT_QUALIFIER_IN;
if (tk.type == TK_ARG_IN) {
qualifier = ARGUMENT_QUALIFIER_IN;
tk = _get_token();
} else if (tk.type == TK_ARG_OUT) {
Added const qualifier support for function arguments in shaders
2020-07-01 11:55:49 +03:00
if (is_const) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("The '%s' qualifier cannot be used within a function parameter declared with '%s'."), "out", "const"));
Added const qualifier support for function arguments in shaders
2020-07-01 11:55:49 +03:00
return ERR_PARSE_ERROR;
}
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
qualifier = ARGUMENT_QUALIFIER_OUT;
tk = _get_token();
} else if (tk.type == TK_ARG_INOUT) {
Added const qualifier support for function arguments in shaders
2020-07-01 11:55:49 +03:00
if (is_const) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("The '%s' qualifier cannot be used within a function parameter declared with '%s'."), "inout", "const"));
Added const qualifier support for function arguments in shaders
2020-07-01 11:55:49 +03:00
return ERR_PARSE_ERROR;
}
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
qualifier = ARGUMENT_QUALIFIER_INOUT;
tk = _get_token();
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataType ptype;
StringName pname;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
StringName param_struct_name;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
DataPrecision pprecision = PRECISION_DEFAULT;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
bool use_precision = false;
Fix declaring array size twice in global shader constant
2021-12-01 16:44:11 +03:00
int arg_array_size = 0;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
if (is_token_precision(tk.type)) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
pprecision = get_token_precision(tk.type);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
use_precision = true;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
is_struct = false;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (shader->structs.has(tk.text)) {
is_struct = true;
param_struct_name = tk.text;
Fix struct usage passing to shader warning system
2021-12-15 22:39:03 +03:00
#ifdef DEBUG_ENABLED
if (check_warnings && HAS_WARNING(ShaderWarning::UNUSED_STRUCT_FLAG) && used_structs.has(param_struct_name)) {
used_structs[param_struct_name].used = true;
}
#endif // DEBUG_ENABLED
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (use_precision) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("The precision modifier cannot be used on structs."));
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
}
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (!is_struct && !is_token_datatype(tk.type)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected a valid data type for argument."));
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 13:28:29 +03:00
return ERR_PARSE_ERROR;
}
Prevent usage 'out' modifier on opaque shader types (textures currently)
2020-02-13 21:02:47 +03:00
if (qualifier == ARGUMENT_QUALIFIER_OUT || qualifier == ARGUMENT_QUALIFIER_INOUT) {
if (is_sampler_type(get_token_datatype(tk.type))) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Opaque types cannot be output parameters."));
Prevent usage 'out' modifier on opaque shader types (textures currently)
2020-02-13 21:02:47 +03:00
return ERR_PARSE_ERROR;
}
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
if (is_struct) {
ptype = TYPE_STRUCT;
} else {
ptype = get_token_datatype(tk.type);
if (_validate_datatype(ptype) != OK) {
return ERR_PARSE_ERROR;
}
if (ptype == TYPE_VOID) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Void type not allowed as argument."));
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
return ERR_PARSE_ERROR;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
tk = _get_token();
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
if (tk.type == TK_BRACKET_OPEN) {
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
Error error = _parse_array_size(nullptr, constants, true, nullptr, &arg_array_size, nullptr);
if (error != OK) {
return error;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
}
tk = _get_token();
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type != TK_IDENTIFIER) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected an identifier for argument name."));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
pname = tk.text;
Fix few redefinition name errors for variable/param/function in shaders
2019-10-06 17:24:30 +03:00
ShaderLanguage::IdentifierType itype;
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
if (_find_identifier(func_node->body, false, builtins, pname, (ShaderLanguage::DataType *)nullptr, &itype)) {
Fix few redefinition name errors for variable/param/function in shaders
2019-10-06 17:24:30 +03:00
if (itype != IDENTIFIER_FUNCTION) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_redefinition_error(String(pname));
Fix few redefinition name errors for variable/param/function in shaders
2019-10-06 17:24:30 +03:00
return ERR_PARSE_ERROR;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
Added check if field name in the shader is equal to builtin
2019-10-29 14:36:11 +03:00
if (has_builtin(p_functions, pname)) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_redefinition_error(String(pname));
Added check if field name in the shader is equal to builtin
2019-10-29 14:36:11 +03:00
return ERR_PARSE_ERROR;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
FunctionNode::Argument arg;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
arg.type = ptype;
arg.name = pname;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
arg.type_str = param_struct_name;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
arg.precision = pprecision;
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
arg.qualifier = qualifier;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
arg.tex_argument_check = false;
arg.tex_builtin_check = false;
arg.tex_argument_filter = FILTER_DEFAULT;
arg.tex_argument_repeat = REPEAT_DEFAULT;
Added const qualifier support for function arguments in shaders
2020-07-01 11:55:49 +03:00
arg.is_const = is_const;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
if (tk.type == TK_BRACKET_OPEN) {
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
Error error = _parse_array_size(nullptr, constants, true, nullptr, &arg_array_size, nullptr);
if (error != OK) {
return error;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
}
tk = _get_token();
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
Fix declaring array size twice in global shader constant
2021-12-01 16:44:11 +03:00
arg.array_size = arg_array_size;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
func_node->arguments.push_back(arg);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type == TK_COMMA) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
//do none and go on
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (tk.type != TK_PARENTHESIS_CLOSE) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_expected_error(",", ")");
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
}
if (p_functions.has(name)) {
//if one of the core functions, make sure they are of the correct form
if (func_node->arguments.size() > 0) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Function '%s' expects no arguments."), String(name)));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (func_node->return_type != TYPE_VOID) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Function '%s' must be of '%s' return type."), String(name), "void"));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
}
Fix typos in source code using codespell From https://github.com/lucasdemarchi/codespell
2017-03-24 21:45:31 +01:00
//all good let's parse inside the function!
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type != TK_CURLY_BRACKET_OPEN) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(RTR("Expected a '{' to begin function."));
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return ERR_PARSE_ERROR;
}
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 18:31:01 -03:00
current_function = name;
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Error err = _parse_block(func_node->body, builtins);
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 16:41:43 +02:00
if (err) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03: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 16:41:43 +02:00
}
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 18:31:01 -03:00
Fix shader crash when users miss the return statement
2019-08-23 15:40:42 +03:00
if (func_node->return_type != DataType::TYPE_VOID) {
BlockNode *block = func_node->body;
if (_find_last_flow_op_in_block(block, FlowOperation::FLOW_OP_RETURN) != OK) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_set_error(vformat(RTR("Expected at least one '%s' statement in a non-void function."), "return"));
Fix shader crash when users miss the return statement
2019-08-23 15:40:42 +03:00
return ERR_PARSE_ERROR;
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
current_function = StringName();
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Allow using vertex varying in custom functions under any circumstances
2021-07-22 11:09:53 +03:00
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
#ifdef DEBUG_ENABLED
Enhances a shader uniform limit warning
2022-01-08 18:34:00 +03:00
if (check_device_limit_warnings && uniform_buffer_exceeded_line != -1) {
Add translation links to shader errors
2022-01-19 15:00:11 +03:00
_add_warning(ShaderWarning::DEVICE_LIMIT_EXCEEDED, uniform_buffer_exceeded_line, RTR("uniform buffer"), { uniform_buffer_size, max_uniform_buffer_size });
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
}
#endif // DEBUG_ENABLED
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
return OK;
}
Added check if field name in the shader is equal to builtin
2019-10-29 14:36:11 +03:00
bool ShaderLanguage::has_builtin(const Map<StringName, ShaderLanguage::FunctionInfo> &p_functions, const StringName &p_name) {
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
for (const KeyValue<StringName, ShaderLanguage::FunctionInfo> &E : p_functions) {
if (E.value.built_ins.has(p_name)) {
Fix particles shader to use built-ins
2020-09-02 22:02:04 +03:00
return true;
}
}
Refactor GLSL shader compilation -Used a more consistent set of keywords for the shader -Remove all harcoded entry points -Re-wrote the GLSL shader parser, new system is more flexible. Allows any entry point organization. -Entry point for sky shaders is now sky(). -Entry point for particle shaders is now process().
2021-04-13 17:01:43 -03:00
Added check if field name in the shader is equal to builtin
2019-10-29 14:36:11 +03:00
return false;
}
Fix shader crash when users miss the return statement
2019-08-23 15:40:42 +03:00
Error ShaderLanguage::_find_last_flow_op_in_op(ControlFlowNode *p_flow, FlowOperation p_op) {
bool found = false;
for (int i = p_flow->blocks.size() - 1; i >= 0; i--) {
if (p_flow->blocks[i]->type == Node::TYPE_BLOCK) {
BlockNode *last_block = (BlockNode *)p_flow->blocks[i];
if (_find_last_flow_op_in_block(last_block, p_op) == OK) {
found = true;
break;
}
}
}
if (found) {
return OK;
}
return FAILED;
}
Error ShaderLanguage::_find_last_flow_op_in_block(BlockNode *p_block, FlowOperation p_op) {
bool found = false;
for (int i = p_block->statements.size() - 1; i >= 0; i--) {
if (p_block->statements[i]->type == Node::TYPE_CONTROL_FLOW) {
ControlFlowNode *flow = (ControlFlowNode *)p_block->statements[i];
if (flow->flow_op == p_op) {
found = true;
break;
} else {
if (_find_last_flow_op_in_op(flow, p_op) == OK) {
found = true;
break;
}
}
} else if (p_block->statements[i]->type == Node::TYPE_BLOCK) {
BlockNode *block = (BlockNode *)p_block->statements[i];
if (_find_last_flow_op_in_block(block, p_op) == OK) {
found = true;
break;
}
}
}
if (found) {
return OK;
}
return FAILED;
}
allow comments and whitespace before shader_type declaration
2018-01-24 19:00:51 -06:00
// skips over whitespace and /* */ and // comments
static int _get_first_ident_pos(const String &p_code) {
int idx = 0;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
#define GETCHAR(m_idx) (((idx + m_idx) < p_code.length()) ? p_code[idx + m_idx] : char32_t(0))
allow comments and whitespace before shader_type declaration
2018-01-24 19:00:51 -06:00
while (true) {
if (GETCHAR(0) == '/' && GETCHAR(1) == '/') {
idx += 2;
while (true) {
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 16:41:43 +02:00
if (GETCHAR(0) == 0) {
Style: clang-format: Disable AllowShortIfStatementsOnASingleLine Part of #33027, also discussed in #29848. Enforcing the use of brackets even on single line statements would be preferred, but `clang-format` doesn't have this functionality yet.
2020-05-10 12:56:01 +02:00
return 0;
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 16:41:43 +02:00
}
allow comments and whitespace before shader_type declaration
2018-01-24 19:00:51 -06:00
if (GETCHAR(0) == '\n') {
idx++;
break; // loop
}
idx++;
}
} else if (GETCHAR(0) == '/' && GETCHAR(1) == '*') {
idx += 2;
while (true) {
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 16:41:43 +02:00
if (GETCHAR(0) == 0) {
Style: clang-format: Disable AllowShortIfStatementsOnASingleLine Part of #33027, also discussed in #29848. Enforcing the use of brackets even on single line statements would be preferred, but `clang-format` doesn't have this functionality yet.
2020-05-10 12:56:01 +02:00
return 0;
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 16:41:43 +02:00
}
allow comments and whitespace before shader_type declaration
2018-01-24 19:00:51 -06:00
if (GETCHAR(0) == '*' && GETCHAR(1) == '/') {
idx += 2;
break; // loop
}
idx++;
}
} else {
switch (GETCHAR(0)) {
case ' ':
case '\t':
case '\r':
case '\n': {
idx++;
} break; // switch
default:
return idx;
}
}
}
#undef GETCHAR
}
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
String ShaderLanguage::get_shader_type(const String &p_code) {
bool reading_type = false;
String cur_identifier;
allow comments and whitespace before shader_type declaration
2018-01-24 19:00:51 -06:00
for (int i = _get_first_ident_pos(p_code); i < p_code.length(); i++) {
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
if (p_code[i] == ';') {
break;
} else if (p_code[i] <= 32) {
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 03:42:46 -06:00
if (!cur_identifier.is_empty()) {
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
if (!reading_type) {
if (cur_identifier != "shader_type") {
return String();
}
reading_type = true;
cur_identifier = String();
} else {
return cur_identifier;
}
}
} else {
cur_identifier += String::chr(p_code[i]);
}
}
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 16:41:43 +02:00
if (reading_type) {
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
return cur_identifier;
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 16:41:43 +02:00
}
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
return String();
}
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
#ifdef DEBUG_ENABLED
void ShaderLanguage::_check_warning_accums() {
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
for (const KeyValue<ShaderWarning::Code, Map<StringName, Map<StringName, Usage>> *> &E : warnings_check_map2) {
for (Map<StringName, Map<StringName, Usage>>::Element *T = (*E.value).front(); T; T = T->next()) {
for (const KeyValue<StringName, Usage> &U : T->get()) {
if (!U.value.used) {
_add_warning(E.key, U.value.decl_line, U.key);
Added a shader warning about unused local variable
2021-06-29 14:34:54 +03:00
}
}
}
}
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
for (const KeyValue<ShaderWarning::Code, Map<StringName, Usage> *> &E : warnings_check_map) {
for (const Map<StringName, Usage>::Element *U = (*E.value).front(); U; U = U->next()) {
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
if (!U->get().used) {
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
_add_warning(E.key, U->get().decl_line, U->key());
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
}
}
}
}
List<ShaderWarning>::Element *ShaderLanguage::get_warnings_ptr() {
return warnings.front();
}
void ShaderLanguage::enable_warning_checking(bool p_enabled) {
check_warnings = p_enabled;
}
bool ShaderLanguage::is_warning_checking_enabled() const {
return check_warnings;
}
void ShaderLanguage::set_warning_flags(uint32_t p_flags) {
warning_flags = p_flags;
}
uint32_t ShaderLanguage::get_warning_flags() const {
return warning_flags;
}
#endif // DEBUG_ENABLED
Make `compile` shader function to use struct instead long parameter list
2021-08-08 08:04:20 +03:00
Error ShaderLanguage::compile(const String &p_code, const ShaderCompileInfo &p_info) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
clear();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
code = p_code;
Make `compile` shader function to use struct instead long parameter list
2021-08-08 08:04:20 +03:00
global_var_get_type_func = p_info.global_variable_type_func;
varying_function_names = p_info.varying_function_names;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
nodes = nullptr;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
shader = alloc_node<ShaderNode>();
Make `compile` shader function to use struct instead long parameter list
2021-08-08 08:04:20 +03:00
Error err = _parse_shader(p_info.functions, p_info.render_modes, p_info.shader_types);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
#ifdef DEBUG_ENABLED
if (check_warnings) {
_check_warning_accums();
}
#endif // DEBUG_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (err != OK) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return err;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
return OK;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Make `compile` shader function to use struct instead long parameter list
2021-08-08 08:04:20 +03:00
Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_info, List<ScriptCodeCompletionOption> *r_options, String &r_call_hint) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
clear();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
code = p_code;
Make `compile` shader function to use struct instead long parameter list
2021-08-08 08:04:20 +03:00
varying_function_names = p_info.varying_function_names;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
nodes = nullptr;
Make `compile` shader function to use struct instead long parameter list
2021-08-08 08:04:20 +03:00
global_var_get_type_func = p_info.global_variable_type_func;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
shader = alloc_node<ShaderNode>();
Make `compile` shader function to use struct instead long parameter list
2021-08-08 08:04:20 +03:00
_parse_shader(p_info.functions, p_info.render_modes, p_info.shader_types);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
switch (completion_type) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
case COMPLETION_NONE: {
Fixed error due to bad cursor handling when parsing shader code Fixed completion error log thrown on "no auto-completion found" for typings with no completion.
2018-07-14 19:59:11 +02:00
//do nothing
return OK;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
} break;
Add completion for shader_type
2022-01-13 18:00:59 +03:00
case COMPLETION_SHADER_TYPE: {
for (const String &shader_type : p_info.shader_types) {
ScriptCodeCompletionOption option(shader_type, ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
r_options->push_back(option);
}
return OK;
} break;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
case COMPLETION_RENDER_MODE: {
Make `compile` shader function to use struct instead long parameter list
2021-08-08 08:04:20 +03:00
for (int i = 0; i < p_info.render_modes.size(); i++) {
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
const ModeInfo &info = p_info.render_modes[i];
if (!info.options.is_empty()) {
bool found = false;
for (int j = 0; j < info.options.size(); j++) {
if (shader->render_modes.has(String(info.name) + "_" + String(info.options[j]))) {
found = true;
}
}
if (!found) {
for (int j = 0; j < info.options.size(); j++) {
Add completion for shader_type
2022-01-13 18:00:59 +03:00
ScriptCodeCompletionOption option(String(info.name) + "_" + String(info.options[j]), ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
r_options->push_back(option);
}
}
} else {
const String name = String(info.name);
if (!shader->render_modes.has(name)) {
Add completion for shader_type
2022-01-13 18:00:59 +03:00
ScriptCodeCompletionOption option(name, ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
r_options->push_back(option);
}
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return OK;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
} break;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
case COMPLETION_STRUCT: {
if (shader->structs.has(completion_struct)) {
StructNode *node = shader->structs[completion_struct].shader_struct;
for (int i = 0; i < node->members.size(); i++) {
ScriptCodeCompletionOption option(node->members[i]->name, ScriptCodeCompletionOption::KIND_MEMBER);
r_options->push_back(option);
}
}
return OK;
} break;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
case COMPLETION_MAIN_FUNCTION: {
Make `compile` shader function to use struct instead long parameter list
2021-08-08 08:04:20 +03:00
for (const KeyValue<StringName, FunctionInfo> &E : p_info.functions) {
Remove incorrect items from completion of main functions in shader
2022-01-24 10:01:24 +03:00
if (!E.value.main_function) {
continue;
}
bool found = false;
for (int i = 0; i < shader->functions.size(); i++) {
if (shader->functions[i].name == E.key) {
found = true;
break;
}
}
if (found) {
continue;
}
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
ScriptCodeCompletionOption option(E.key, ScriptCodeCompletionOption::KIND_FUNCTION);
Fix code completion for shader editor
2019-07-06 12:03:17 +08:00
r_options->push_back(option);
Misc Fixes ========== -NOTIFICATION_WM_QUIT fixed on android (seems tha way this is reported changed in newer sdk) -WIP implementation of APK Expansion APIs for publishing games larger than 50mb in Play Store -Feaures in the new tutorials are all present in the sourcecode -This (hopefully) should get rid of the animation list order getting corrupted -Improved 3D Scene Importer (Skeletons, Animations and other stuff were not being merged). Anything missing? -In code editor, the automatic syntax checker will only use file_exists() to check preload() else it might freeze the editor too much while typing if the preload is a big resource -Fixed bugs in PolygonPathFinder, stil pending to do a node and a demo
2014-06-27 23:21:45 -03:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return OK;
Misc Fixes ========== -NOTIFICATION_WM_QUIT fixed on android (seems tha way this is reported changed in newer sdk) -WIP implementation of APK Expansion APIs for publishing games larger than 50mb in Play Store -Feaures in the new tutorials are all present in the sourcecode -This (hopefully) should get rid of the animation list order getting corrupted -Improved 3D Scene Importer (Skeletons, Animations and other stuff were not being merged). Anything missing? -In code editor, the automatic syntax checker will only use file_exists() to check preload() else it might freeze the editor too much while typing if the preload is a big resource -Fixed bugs in PolygonPathFinder, stil pending to do a node and a demo
2014-06-27 23:21:45 -03:00
} break;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
case COMPLETION_IDENTIFIER:
case COMPLETION_FUNCTION_CALL: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool comp_ident = completion_type == COMPLETION_IDENTIFIER;
Fix code completion for shader editor
2019-07-06 12:03:17 +08:00
Map<String, ScriptCodeCompletionOption::Kind> matches;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
StringName skip_function;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
BlockNode *block = completion_block;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
if (completion_class == TAG_GLOBAL) {
while (block) {
if (comp_ident) {
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
for (const KeyValue<StringName, BlockNode::Variable> &E : block->variables) {
if (E.value.line < completion_line) {
matches.insert(E.key, ScriptCodeCompletionOption::KIND_VARIABLE);
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
if (block->parent_function) {
if (comp_ident) {
for (int i = 0; i < block->parent_function->arguments.size(); i++) {
Fix invalid autocompletion pasting of shader param name
2019-10-08 18:33:22 +03:00
matches.insert(block->parent_function->arguments[i].name, ScriptCodeCompletionOption::KIND_VARIABLE);
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
skip_function = block->parent_function->name;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
block = block->parent_block;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
Fix shader TIME auto-completion
2020-03-19 21:26:35 +03:00
if (comp_ident) {
Make `compile` shader function to use struct instead long parameter list
2021-08-08 08:04:20 +03:00
if (p_info.functions.has("global")) {
for (const KeyValue<StringName, BuiltInInfo> &E : p_info.functions["global"].built_ins) {
Fix shader TIME auto-completion
2020-03-19 21:26:35 +03:00
ScriptCodeCompletionOption::Kind kind = ScriptCodeCompletionOption::KIND_MEMBER;
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
if (E.value.constant) {
Fix shader TIME auto-completion
2020-03-19 21:26:35 +03:00
kind = ScriptCodeCompletionOption::KIND_CONSTANT;
}
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
matches.insert(E.key, kind);
Fix shader TIME auto-completion
2020-03-19 21:26:35 +03:00
}
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
Make `compile` shader function to use struct instead long parameter list
2021-08-08 08:04:20 +03:00
if (p_info.functions.has("constants")) {
for (const KeyValue<StringName, BuiltInInfo> &E : p_info.functions["constants"].built_ins) {
Fix built-in(PI, TAU, E) assignment to a global constant in a shader
2021-11-29 10:21:10 +03:00
ScriptCodeCompletionOption::Kind kind = ScriptCodeCompletionOption::KIND_MEMBER;
if (E.value.constant) {
kind = ScriptCodeCompletionOption::KIND_CONSTANT;
}
matches.insert(E.key, kind);
}
}
Make `compile` shader function to use struct instead long parameter list
2021-08-08 08:04:20 +03:00
if (skip_function != StringName() && p_info.functions.has(skip_function)) {
for (const KeyValue<StringName, BuiltInInfo> &E : p_info.functions[skip_function].built_ins) {
Fix shader TIME auto-completion
2020-03-19 21:26:35 +03:00
ScriptCodeCompletionOption::Kind kind = ScriptCodeCompletionOption::KIND_MEMBER;
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
if (E.value.constant) {
Fix shader TIME auto-completion
2020-03-19 21:26:35 +03:00
kind = ScriptCodeCompletionOption::KIND_CONSTANT;
}
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
matches.insert(E.key, kind);
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
}
Fix code completion for shader editor
2019-07-06 12:03:17 +08:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
Fix completion for global constants in shaders
2022-01-13 19:49:43 +03:00
for (const KeyValue<StringName, ShaderNode::Constant> &E : shader->constants) {
matches.insert(E.key, ScriptCodeCompletionOption::KIND_CONSTANT);
}
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
for (const KeyValue<StringName, ShaderNode::Varying> &E : shader->varyings) {
matches.insert(E.key, ScriptCodeCompletionOption::KIND_VARIABLE);
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
}
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
for (const KeyValue<StringName, ShaderNode::Uniform> &E : shader->uniforms) {
matches.insert(E.key, ScriptCodeCompletionOption::KIND_MEMBER);
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
for (int i = 0; i < shader->functions.size(); i++) {
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 16:41:43 +02:00
if (!shader->functions[i].callable || shader->functions[i].name == skip_function) {
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
continue;
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 16:41:43 +02:00
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
matches.insert(String(shader->functions[i].name), ScriptCodeCompletionOption::KIND_FUNCTION);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
int idx = 0;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
bool low_end = RenderingServer::get_singleton()->is_low_end();
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
FIx autocompletion for emit_particle in shader editor
2020-10-13 11:53:06 +03:00
if (stages && stages->has(skip_function)) {
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
for (const KeyValue<StringName, StageFunctionInfo> &E : (*stages)[skip_function].stage_functions) {
matches.insert(String(E.key), ScriptCodeCompletionOption::KIND_FUNCTION);
FIx autocompletion for emit_particle in shader editor
2020-10-13 11:53:06 +03:00
}
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
while (builtin_func_defs[idx].name) {
Hides high-level functions from GLES2 shader autocompletion
2020-01-23 12:41:21 +03:00
if (low_end && builtin_func_defs[idx].high_end) {
idx++;
continue;
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
matches.insert(String(builtin_func_defs[idx].name), ScriptCodeCompletionOption::KIND_FUNCTION);
idx++;
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
} else { // sub-class
int idx = 0;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
bool low_end = RenderingServer::get_singleton()->is_low_end();
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
while (builtin_func_defs[idx].name) {
Hides high-level functions from GLES2 shader autocompletion
2020-01-23 12:41:21 +03:00
if (low_end && builtin_func_defs[idx].high_end) {
idx++;
continue;
}
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
if (builtin_func_defs[idx].tag == completion_class) {
matches.insert(String(builtin_func_defs[idx].name), ScriptCodeCompletionOption::KIND_FUNCTION);
}
idx++;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
for (const KeyValue<String, ScriptCodeCompletionOption::Kind> &E : matches) {
ScriptCodeCompletionOption option(E.key, E.value);
if (E.value == ScriptCodeCompletionOption::KIND_FUNCTION) {
Fix code completion for shader editor
2019-07-06 12:03:17 +08:00
option.insert_text += "(";
}
r_options->push_back(option);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
return OK;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
} break;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
case COMPLETION_CALL_ARGUMENTS: {
FIx autocompletion for emit_particle in shader editor
2020-10-13 11:53:06 +03:00
StringName block_function;
BlockNode *block = completion_block;
while (block) {
if (block->parent_function) {
block_function = block->parent_function->name;
}
block = block->parent_block;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < shader->functions.size(); i++) {
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 16:41:43 +02:00
if (!shader->functions[i].callable) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
continue;
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 16:41:43 +02:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (shader->functions[i].name == completion_function) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
String calltip;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += get_datatype_name(shader->functions[i].function->return_type);
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (shader->functions[i].function->return_array_size > 0) {
calltip += "[";
calltip += itos(shader->functions[i].function->return_array_size);
calltip += "]";
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += " ";
calltip += shader->functions[i].name;
calltip += "(";
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int j = 0; j < shader->functions[i].function->arguments.size(); j++) {
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 16:41:43 +02:00
if (j > 0) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += ", ";
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 16:41:43 +02:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += " ";
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 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (j == completion_argument) {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
calltip += char32_t(0xFFFF);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Added const qualifier support for function arguments in shaders
2020-07-01 11:55:49 +03:00
if (shader->functions[i].function->arguments[j].is_const) {
calltip += "const ";
}
Show shader method out/inout qualifier in intellisense
2020-03-18 15:43:05 +03:00
if (shader->functions[i].function->arguments[j].qualifier != ArgumentQualifier::ARGUMENT_QUALIFIER_IN) {
if (shader->functions[i].function->arguments[j].qualifier == ArgumentQualifier::ARGUMENT_QUALIFIER_OUT) {
calltip += "out ";
} else { // ArgumentQualifier::ARGUMENT_QUALIFIER_INOUT
calltip += "inout ";
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += get_datatype_name(shader->functions[i].function->arguments[j].type);
calltip += " ";
calltip += shader->functions[i].function->arguments[j].name;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
if (shader->functions[i].function->arguments[j].array_size > 0) {
calltip += "[";
calltip += itos(shader->functions[i].function->arguments[j].array_size);
calltip += "]";
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (j == completion_argument) {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
calltip += char32_t(0xFFFF);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 16:41:43 +02:00
if (shader->functions[i].function->arguments.size()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += " ";
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 16:41:43 +02:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += ")";
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
r_call_hint = calltip;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return OK;
}
}
New Demo, Screen Space Shaders -Fixes to screen space shaders. -Fixes to isometric light demo.
2015-03-10 00:53:09 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
int idx = 0;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
String calltip;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
bool low_end = RenderingServer::get_singleton()->is_low_end();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
FIx autocompletion for emit_particle in shader editor
2020-10-13 11:53:06 +03:00
if (stages && stages->has(block_function)) {
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
for (const KeyValue<StringName, StageFunctionInfo> &E : (*stages)[block_function].stage_functions) {
if (completion_function == E.key) {
calltip += get_datatype_name(E.value.return_type);
FIx autocompletion for emit_particle in shader editor
2020-10-13 11:53:06 +03:00
calltip += " ";
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
calltip += E.key;
FIx autocompletion for emit_particle in shader editor
2020-10-13 11:53:06 +03:00
calltip += "(";
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
for (int i = 0; i < E.value.arguments.size(); i++) {
FIx autocompletion for emit_particle in shader editor
2020-10-13 11:53:06 +03:00
if (i > 0) {
calltip += ", ";
} else {
calltip += " ";
}
if (i == completion_argument) {
calltip += char32_t(0xFFFF);
}
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
calltip += get_datatype_name(E.value.arguments[i].type);
FIx autocompletion for emit_particle in shader editor
2020-10-13 11:53:06 +03:00
calltip += " ";
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
calltip += E.value.arguments[i].name;
FIx autocompletion for emit_particle in shader editor
2020-10-13 11:53:06 +03:00
if (i == completion_argument) {
calltip += char32_t(0xFFFF);
}
}
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
if (E.value.arguments.size()) {
FIx autocompletion for emit_particle in shader editor
2020-10-13 11:53:06 +03:00
calltip += " ";
}
calltip += ")";
r_call_hint = calltip;
return OK;
}
}
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
while (builtin_func_defs[idx].name) {
Hides high-level functions from GLES2 shader autocompletion
2020-01-23 12:41:21 +03:00
if (low_end && builtin_func_defs[idx].high_end) {
idx++;
continue;
}
Show shader method out/inout qualifier in intellisense
2020-03-18 15:43:05 +03:00
int idx2 = 0;
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
Set<int> out_args;
Show shader method out/inout qualifier in intellisense
2020-03-18 15:43:05 +03:00
while (builtin_func_out_args[idx2].name != nullptr) {
if (builtin_func_out_args[idx2].name == builtin_func_defs[idx].name) {
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
for (int i = 0; i < BuiltinFuncOutArgs::MAX_ARGS; i++) {
int arg = builtin_func_out_args[idx2].arguments[i];
if (arg == -1) {
break;
}
out_args.insert(arg);
}
Show shader method out/inout qualifier in intellisense
2020-03-18 15:43:05 +03:00
break;
}
idx2++;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (completion_function == builtin_func_defs[idx].name) {
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
if (builtin_func_defs[idx].tag != completion_class) {
idx++;
continue;
}
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 16:41:43 +02:00
if (calltip.length()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += "\n";
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 16:41:43 +02:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += get_datatype_name(builtin_func_defs[idx].rettype);
calltip += " ";
calltip += builtin_func_defs[idx].name;
calltip += "(";
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool found_arg = false;
FIx autocompletion for emit_particle in shader editor
2020-10-13 11:53:06 +03:00
for (int i = 0; i < BuiltinFuncDef::MAX_ARGS - 1; i++) {
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 16:41:43 +02:00
if (builtin_func_defs[idx].args[i] == TYPE_VOID) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
break;
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 16:41:43 +02:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03: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 16:41:43 +02:00
if (i > 0) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += ", ";
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 16:41:43 +02:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += " ";
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 16:41:43 +02:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (i == completion_argument) {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
calltip += char32_t(0xFFFF);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
if (out_args.has(i)) {
Show shader method out/inout qualifier in intellisense
2020-03-18 15:43:05 +03:00
calltip += "out ";
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += get_datatype_name(builtin_func_defs[idx].args[i]);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
String arg_name = (String)builtin_func_defs[idx].args_names[i];
if (!arg_name.is_empty()) {
calltip += " ";
calltip += arg_name;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (i == completion_argument) {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
calltip += char32_t(0xFFFF);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
found_arg = true;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03: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 16:41:43 +02:00
if (found_arg) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += " ";
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 16:41:43 +02:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += ")";
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
}
2D shader progress
2015-01-11 20:52:42 -03:00
idx++;
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
r_call_hint = calltip;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return OK;
2D shader progress
2015-01-11 20:52:42 -03:00
} break;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
case COMPLETION_INDEX: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
const char colv[4] = { 'r', 'g', 'b', 'a' };
const char coordv[4] = { 'x', 'y', 'z', 'w' };
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
const char coordt[4] = { 's', 't', 'p', 'q' };
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
int limit = 0;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
switch (completion_base) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
case TYPE_BVEC2:
case TYPE_IVEC2:
case TYPE_UVEC2:
case TYPE_VEC2: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
limit = 2;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
} break;
case TYPE_BVEC3:
case TYPE_IVEC3:
case TYPE_UVEC3:
case TYPE_VEC3: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
limit = 3;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
} break;
case TYPE_BVEC4:
case TYPE_IVEC4:
case TYPE_UVEC4:
case TYPE_VEC4: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
limit = 4;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
} 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 17:08:36 +02:00
default: {
}
2D shader progress
2015-01-11 20:52:42 -03:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < limit; i++) {
Fix code completion for shader editor
2019-07-06 12:03:17 +08:00
r_options->push_back(ScriptCodeCompletionOption(String::chr(colv[i]), ScriptCodeCompletionOption::KIND_PLAIN_TEXT));
r_options->push_back(ScriptCodeCompletionOption(String::chr(coordv[i]), ScriptCodeCompletionOption::KIND_PLAIN_TEXT));
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
r_options->push_back(ScriptCodeCompletionOption(String::chr(coordt[i]), ScriptCodeCompletionOption::KIND_PLAIN_TEXT));
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
} break;
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
case COMPLETION_HINT: {
if (completion_base == DataType::TYPE_VEC4) {
ScriptCodeCompletionOption option("hint_color", ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
r_options->push_back(option);
} else if ((completion_base == DataType::TYPE_INT || completion_base == DataType::TYPE_FLOAT) && !completion_base_array) {
ScriptCodeCompletionOption option("hint_range", ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
if (completion_base == DataType::TYPE_INT) {
option.insert_text = "hint_range(0, 100, 1)";
} else {
option.insert_text = "hint_range(0.0, 1.0, 0.1)";
}
r_options->push_back(option);
} else if ((int(completion_base) > int(TYPE_MAT4) && int(completion_base) < int(TYPE_STRUCT)) && !completion_base_array) {
static Vector<String> options;
if (options.is_empty()) {
options.push_back("filter_linear");
options.push_back("filter_linear_mipmap");
Rename shader hint `filter_anisotropy` to `filter_anisotropic`
2021-12-15 22:12:38 +03:00
options.push_back("filter_linear_mipmap_anisotropic");
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
options.push_back("filter_nearest");
options.push_back("filter_nearest_mipmap");
Rename shader hint `filter_anisotropy` to `filter_anisotropic`
2021-12-15 22:12:38 +03:00
options.push_back("filter_nearest_mipmap_anisotropic");
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
options.push_back("hint_albedo");
Rename `hint_aniso` to `hint_anisotropy` in the shader language The word "anisotropy" is used in full form in BaseMaterial3D's anisotropy-related properties.
2021-12-09 20:29:06 +01:00
options.push_back("hint_anisotropy");
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
options.push_back("hint_black");
options.push_back("hint_black_albedo");
options.push_back("hint_normal");
options.push_back("hint_roughness_a");
options.push_back("hint_roughness_b");
options.push_back("hint_roughness_g");
options.push_back("hint_roughness_gray");
options.push_back("hint_roughness_normal");
options.push_back("hint_roughness_r");
options.push_back("hint_white");
options.push_back("repeat_enable");
options.push_back("repeat_disable");
}
for (int i = 0; i < options.size(); i++) {
ScriptCodeCompletionOption option(options[i], ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
r_options->push_back(option);
}
}
if (!completion_base_array) {
ScriptCodeCompletionOption option("instance_index", ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
option.insert_text = "instance_index(0)";
r_options->push_back(option);
}
} break;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
return ERR_PARSE_ERROR;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
String ShaderLanguage::get_error_text() {
return error_str;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
New Demo, Screen Space Shaders -Fixes to screen space shaders. -Fixes to isometric light demo.
2015-03-10 00:53:09 -03:00
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
int ShaderLanguage::get_error_line() {
return error_line;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 11:31:18 -03:00
ShaderLanguage::ShaderNode *ShaderLanguage::get_shader() {
return shader;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
ShaderLanguage::ShaderLanguage() {
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
nodes = nullptr;
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
completion_class = TAG_GLOBAL;
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
#ifdef DEBUG_ENABLED
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
warnings_check_map.insert(ShaderWarning::UNUSED_CONSTANT, &used_constants);
warnings_check_map.insert(ShaderWarning::UNUSED_FUNCTION, &used_functions);
warnings_check_map.insert(ShaderWarning::UNUSED_STRUCT, &used_structs);
warnings_check_map.insert(ShaderWarning::UNUSED_UNIFORM, &used_uniforms);
warnings_check_map.insert(ShaderWarning::UNUSED_VARYING, &used_varyings);
Added a shader warning about unused local variable
2021-06-29 14:34:54 +03:00
warnings_check_map2.insert(ShaderWarning::UNUSED_LOCAL_VARIABLE, &used_local_vars);
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
#endif // DEBUG_ENABLED
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 16:33:42 -03:00
}
ShaderLanguage::~ShaderLanguage() {
clear();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Reference in a new issue Copy permalink