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

11914 lines
386 KiB
C++
Raw Normal View History

One Copyright Update to rule them all As many open source projects have started doing it, we're removing the current year from the copyright notice, so that we don't need to bump it every year. It seems like only the first year of publication is technically relevant for copyright notices, and even that seems to be something that many companies stopped listing altogether (in a version controlled codebase, the commits are a much better source of date of publication than a hardcoded copyright statement). We also now list Godot Engine contributors first as we're collectively the current maintainers of the project, and we clarify that the "exclusive" copyright of the co-founders covers the timespan before opensourcing (their further contributions are included as part of Godot Engine contributors). Also fixed "cf." Frenchism - it's meant as "refer to / see".
2023-01-05 13:25:55 +01:00
/**************************************************************************/
/* shader_language.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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"
Style: Cleanup single-line blocks, semicolons, dead code Remove currently unused implementation of TextureBasisU, could be re-added later on if needed and ported.
2022-02-16 13:56:32 +01:00
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"
Clean up Shader Preprocessor * Moved preprocessor to Shader and ShaderInclude * Clean up RenderingServer side * Preprocessor is separate from parser now, but it emits tokens with include location hints. * Improved ShaderEditor validation code * Added include file code completion * Added notification for all files affected by a broken include.
2022-06-29 11:31:18 +02:00
#include "core/templates/local_vector.h"
Forbid passing multiview sampler to the custom function in shaders
2023-01-29 12:14:22 +03:00
#include "servers/rendering/renderer_compositor.h"
Validate varying count when compiling shaders This avoids crashing on devices when a number of varyings greater than the device limit is used. For now this accurately prints an error when compiling the shader, but the error text only pops up in the editor if the number of user varyings is above the limit.
2025-02-12 16:12:46 -08:00
#include "servers/rendering/rendering_server_globals.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"
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
#include "shader_types.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)
Fix orphan strings in shader preprocessor
2024-11-26 11:59:52 +03:00
SafeNumeric<int> ShaderLanguage::instance_counter;
Improve code for setup of `global_func_set` in `ShaderLanguage`
2024-07-02 18:16:04 +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 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",
Fix array of token names in the shader parser
2023-01-25 18:18:07 +03:00
"FLOAT_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",
Fix array of token names in the shader parser
2023-01-25 18:18:07 +03:00
"UINT_CONSTANT",
Add `hint_enum` for uniform int in gdshader
2024-07-13 14:30:08 -04:00
"STRING_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",
[Shader Language] Add missing token name.
2024-12-11 21:05:14 +02:00
"TYPE_SAMPLEREXT",
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",
Fix array of token names in the shader parser
2023-01-25 18:18:07 +03:00
"STRUCT",
-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",
Fix array of token names in the shader parser
2023-01-25 18:18:07 +03:00
"CF_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
"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",
Fix array of token names in the shader parser
2023-01-25 18:18:07 +03:00
"UNIFORM_GROUP",
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",
Fix array of token names in the shader parser
2023-01-25 18:18:07 +03:00
"ARG_IN",
"ARG_OUT",
"ARG_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",
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
"HINT_DEFAULT_WHITE_TEXTURE",
"HINT_DEFAULT_BLACK_TEXTURE",
Add `hint_transparent` to use a transparent black placeholder texture This can be used in shaders to avoid the need to supply a transparent placeholder texture manually.
2021-08-14 18:29:52 +02:00
"HINT_DEFAULT_TRANSPARENT_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_NORMAL_TEXTURE",
Fix array of token names in the shader parser
2023-01-25 18:18:07 +03:00
"HINT_ROUGHNESS_NORMAL_TEXTURE",
"HINT_ROUGHNESS_R",
"HINT_ROUGHNESS_G",
"HINT_ROUGHNESS_B",
"HINT_ROUGHNESS_A",
"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
"HINT_ANISOTROPY_TEXTURE",
Fix array of token names in the shader parser
2023-01-25 18:18:07 +03:00
"HINT_SOURCE_COLOR",
-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_RANGE",
Add `hint_enum` for uniform int in gdshader
2024-07-13 14:30:08 -04:00
"HINT_ENUM",
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",
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
"HINT_SCREEN_TEXTURE",
"HINT_NORMAL_ROUGHNESS_TEXTURE",
"HINT_DEPTH_TEXTURE",
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
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
enum ContextFlag : uint32_t {
CF_UNSPECIFIED = 0U,
CF_BLOCK = 1U, // "void test() { <x> }"
CF_FUNC_DECL_PARAM_SPEC = 2U, // "void test(<x> int param) {}"
CF_FUNC_DECL_PARAM_TYPE = 4U, // "void test(<x> param) {}"
CF_IF_DECL = 8U, // "if(<x>) {}"
CF_BOOLEAN = 16U, // "bool t = <x>;"
CF_GLOBAL_SPACE = 32U, // "struct", "const", "void" etc.
CF_DATATYPE = 64U, // "<x> value;"
CF_UNIFORM_TYPE = 128U, // "uniform <x> myUniform;"
CF_VARYING_TYPE = 256U, // "varying <x> myVarying;"
CF_PRECISION_MODIFIER = 512U, // "<x> vec4 a = vec4(0.0, 1.0, 2.0, 3.0);"
CF_INTERPOLATION_QUALIFIER = 1024U, // "varying <x> vec3 myColor;"
CF_UNIFORM_KEYWORD = 2048U, // "uniform"
CF_CONST_KEYWORD = 4096U, // "const"
CF_UNIFORM_QUALIFIER = 8192U, // "<x> uniform float t;"
Remove `shader_type` from completion (when it does not need any more)
2022-09-07 16:19:36 +03:00
CF_SHADER_TYPE = 16384U, // "shader_type"
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
};
const uint32_t KCF_DATATYPE = CF_BLOCK | CF_GLOBAL_SPACE | CF_DATATYPE | CF_FUNC_DECL_PARAM_TYPE | CF_UNIFORM_TYPE;
const uint32_t KCF_SAMPLER_DATATYPE = CF_FUNC_DECL_PARAM_TYPE | CF_UNIFORM_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
const ShaderLanguage::KeyWord ShaderLanguage::keyword_list[] = {
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
{ TK_TRUE, "true", CF_BLOCK | CF_IF_DECL | CF_BOOLEAN, {}, {} },
{ TK_FALSE, "false", CF_BLOCK | CF_IF_DECL | CF_BOOLEAN, {}, {} },
// data types
{ TK_TYPE_VOID, "void", CF_GLOBAL_SPACE, {}, {} },
{ TK_TYPE_BOOL, "bool", KCF_DATATYPE, {}, {} },
{ TK_TYPE_BVEC2, "bvec2", KCF_DATATYPE, {}, {} },
{ TK_TYPE_BVEC3, "bvec3", KCF_DATATYPE, {}, {} },
{ TK_TYPE_BVEC4, "bvec4", KCF_DATATYPE, {}, {} },
{ TK_TYPE_INT, "int", KCF_DATATYPE, {}, {} },
{ TK_TYPE_IVEC2, "ivec2", KCF_DATATYPE, {}, {} },
{ TK_TYPE_IVEC3, "ivec3", KCF_DATATYPE, {}, {} },
{ TK_TYPE_IVEC4, "ivec4", KCF_DATATYPE, {}, {} },
{ TK_TYPE_UINT, "uint", KCF_DATATYPE, {}, {} },
{ TK_TYPE_UVEC2, "uvec2", KCF_DATATYPE, {}, {} },
{ TK_TYPE_UVEC3, "uvec3", KCF_DATATYPE, {}, {} },
{ TK_TYPE_UVEC4, "uvec4", KCF_DATATYPE, {}, {} },
{ TK_TYPE_FLOAT, "float", KCF_DATATYPE | CF_VARYING_TYPE, {}, {} },
{ TK_TYPE_VEC2, "vec2", KCF_DATATYPE | CF_VARYING_TYPE, {}, {} },
{ TK_TYPE_VEC3, "vec3", KCF_DATATYPE | CF_VARYING_TYPE, {}, {} },
{ TK_TYPE_VEC4, "vec4", KCF_DATATYPE | CF_VARYING_TYPE, {}, {} },
{ TK_TYPE_MAT2, "mat2", KCF_DATATYPE | CF_VARYING_TYPE, {}, {} },
{ TK_TYPE_MAT3, "mat3", KCF_DATATYPE | CF_VARYING_TYPE, {}, {} },
{ TK_TYPE_MAT4, "mat4", KCF_DATATYPE | CF_VARYING_TYPE, {}, {} },
{ TK_TYPE_SAMPLER2D, "sampler2D", KCF_SAMPLER_DATATYPE, {}, {} },
{ TK_TYPE_ISAMPLER2D, "isampler2D", KCF_SAMPLER_DATATYPE, {}, {} },
{ TK_TYPE_USAMPLER2D, "usampler2D", KCF_SAMPLER_DATATYPE, {}, {} },
{ TK_TYPE_SAMPLER2DARRAY, "sampler2DArray", KCF_SAMPLER_DATATYPE, {}, {} },
{ TK_TYPE_ISAMPLER2DARRAY, "isampler2DArray", KCF_SAMPLER_DATATYPE, {}, {} },
{ TK_TYPE_USAMPLER2DARRAY, "usampler2DArray", KCF_SAMPLER_DATATYPE, {}, {} },
{ TK_TYPE_SAMPLER3D, "sampler3D", KCF_SAMPLER_DATATYPE, {}, {} },
{ TK_TYPE_ISAMPLER3D, "isampler3D", KCF_SAMPLER_DATATYPE, {}, {} },
{ TK_TYPE_USAMPLER3D, "usampler3D", KCF_SAMPLER_DATATYPE, {}, {} },
{ TK_TYPE_SAMPLERCUBE, "samplerCube", KCF_SAMPLER_DATATYPE, {}, {} },
{ TK_TYPE_SAMPLERCUBEARRAY, "samplerCubeArray", KCF_SAMPLER_DATATYPE, {}, {} },
Add external texture support (GLES3) Co-authored-by: Fredia Huya-Kouadio <fhuyakou@gmail.com> Co-authored-by: Mauricio Narvaez <nvz@meta.com>
2023-10-14 03:58:59 -07:00
{ TK_TYPE_SAMPLEREXT, "samplerExternalOES", KCF_SAMPLER_DATATYPE, {}, {} },
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
// interpolation qualifiers
{ TK_INTERPOLATION_FLAT, "flat", CF_INTERPOLATION_QUALIFIER, {}, {} },
{ TK_INTERPOLATION_SMOOTH, "smooth", CF_INTERPOLATION_QUALIFIER, {}, {} },
// precision modifiers
{ TK_PRECISION_LOW, "lowp", CF_BLOCK | CF_PRECISION_MODIFIER, {}, {} },
{ TK_PRECISION_MID, "mediump", CF_BLOCK | CF_PRECISION_MODIFIER, {}, {} },
{ TK_PRECISION_HIGH, "highp", CF_BLOCK | CF_PRECISION_MODIFIER, {}, {} },
// global space keywords
{ TK_UNIFORM, "uniform", CF_GLOBAL_SPACE | CF_UNIFORM_KEYWORD, {}, {} },
Implement shader uniform groups/subgroups
2022-07-13 11:31:27 +03:00
{ TK_UNIFORM_GROUP, "group_uniforms", CF_GLOBAL_SPACE, {}, {} },
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
{ TK_VARYING, "varying", CF_GLOBAL_SPACE, { "particles", "sky", "fog" }, {} },
{ TK_CONST, "const", CF_BLOCK | CF_GLOBAL_SPACE | CF_CONST_KEYWORD, {}, {} },
{ TK_STRUCT, "struct", CF_GLOBAL_SPACE, {}, {} },
Remove `shader_type` from completion (when it does not need any more)
2022-09-07 16:19:36 +03:00
{ TK_SHADER_TYPE, "shader_type", CF_SHADER_TYPE, {}, {} },
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
{ TK_RENDER_MODE, "render_mode", CF_GLOBAL_SPACE, {}, {} },
// uniform qualifiers
{ TK_INSTANCE, "instance", CF_GLOBAL_SPACE | CF_UNIFORM_QUALIFIER, {}, {} },
{ TK_GLOBAL, "global", CF_GLOBAL_SPACE | CF_UNIFORM_QUALIFIER, {}, {} },
// block keywords
{ TK_CF_IF, "if", CF_BLOCK, {}, {} },
{ TK_CF_ELSE, "else", CF_BLOCK, {}, {} },
{ TK_CF_FOR, "for", CF_BLOCK, {}, {} },
{ TK_CF_WHILE, "while", CF_BLOCK, {}, {} },
{ TK_CF_DO, "do", CF_BLOCK, {}, {} },
{ TK_CF_SWITCH, "switch", CF_BLOCK, {}, {} },
{ TK_CF_CASE, "case", CF_BLOCK, {}, {} },
{ TK_CF_DEFAULT, "default", CF_BLOCK, {}, {} },
{ TK_CF_BREAK, "break", CF_BLOCK, {}, {} },
{ TK_CF_CONTINUE, "continue", CF_BLOCK, {}, {} },
{ TK_CF_RETURN, "return", CF_BLOCK, {}, {} },
Allow usage of `discard` inside custom shader functions
2024-06-25 15:39:21 +03:00
{ TK_CF_DISCARD, "discard", CF_BLOCK, { "particles", "sky", "fog" }, { "vertex" } },
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
// function specifier keywords
{ TK_ARG_IN, "in", CF_FUNC_DECL_PARAM_SPEC, {}, {} },
{ TK_ARG_OUT, "out", CF_FUNC_DECL_PARAM_SPEC, {}, {} },
{ TK_ARG_INOUT, "inout", CF_FUNC_DECL_PARAM_SPEC, {}, {} },
// hints
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
{ TK_HINT_SOURCE_COLOR, "source_color", CF_UNSPECIFIED, {}, {} },
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
{ TK_HINT_RANGE, "hint_range", CF_UNSPECIFIED, {}, {} },
Add `hint_enum` for uniform int in gdshader
2024-07-13 14:30:08 -04:00
{ TK_HINT_ENUM, "hint_enum", CF_UNSPECIFIED, {}, {} },
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
{ TK_HINT_INSTANCE_INDEX, "instance_index", CF_UNSPECIFIED, {}, {} },
// sampler hints
{ TK_HINT_NORMAL_TEXTURE, "hint_normal", CF_UNSPECIFIED, {}, {} },
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
{ TK_HINT_DEFAULT_WHITE_TEXTURE, "hint_default_white", CF_UNSPECIFIED, {}, {} },
{ TK_HINT_DEFAULT_BLACK_TEXTURE, "hint_default_black", CF_UNSPECIFIED, {}, {} },
Add `hint_transparent` to use a transparent black placeholder texture This can be used in shaders to avoid the need to supply a transparent placeholder texture manually.
2021-08-14 18:29:52 +02:00
{ TK_HINT_DEFAULT_TRANSPARENT_TEXTURE, "hint_default_transparent", CF_UNSPECIFIED, {}, {} },
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
{ TK_HINT_ANISOTROPY_TEXTURE, "hint_anisotropy", CF_UNSPECIFIED, {}, {} },
{ TK_HINT_ROUGHNESS_R, "hint_roughness_r", CF_UNSPECIFIED, {}, {} },
{ TK_HINT_ROUGHNESS_G, "hint_roughness_g", CF_UNSPECIFIED, {}, {} },
{ TK_HINT_ROUGHNESS_B, "hint_roughness_b", CF_UNSPECIFIED, {}, {} },
{ TK_HINT_ROUGHNESS_A, "hint_roughness_a", CF_UNSPECIFIED, {}, {} },
{ TK_HINT_ROUGHNESS_NORMAL_TEXTURE, "hint_roughness_normal", CF_UNSPECIFIED, {}, {} },
{ TK_HINT_ROUGHNESS_GRAY, "hint_roughness_gray", CF_UNSPECIFIED, {}, {} },
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
{ TK_HINT_SCREEN_TEXTURE, "hint_screen_texture", CF_UNSPECIFIED, {}, {} },
{ TK_HINT_NORMAL_ROUGHNESS_TEXTURE, "hint_normal_roughness_texture", CF_UNSPECIFIED, {}, {} },
{ TK_HINT_DEPTH_TEXTURE, "hint_depth_texture", CF_UNSPECIFIED, {}, {} },
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
{ TK_FILTER_NEAREST, "filter_nearest", CF_UNSPECIFIED, {}, {} },
{ TK_FILTER_LINEAR, "filter_linear", CF_UNSPECIFIED, {}, {} },
{ TK_FILTER_NEAREST_MIPMAP, "filter_nearest_mipmap", CF_UNSPECIFIED, {}, {} },
{ TK_FILTER_LINEAR_MIPMAP, "filter_linear_mipmap", CF_UNSPECIFIED, {}, {} },
{ TK_FILTER_NEAREST_MIPMAP_ANISOTROPIC, "filter_nearest_mipmap_anisotropic", CF_UNSPECIFIED, {}, {} },
{ TK_FILTER_LINEAR_MIPMAP_ANISOTROPIC, "filter_linear_mipmap_anisotropic", CF_UNSPECIFIED, {}, {} },
{ TK_REPEAT_ENABLE, "repeat_enable", CF_UNSPECIFIED, {}, {} },
{ TK_REPEAT_DISABLE, "repeat_disable", CF_UNSPECIFIED, {}, {} },
{ TK_ERROR, nullptr, CF_UNSPECIFIED, {}, {} }
-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;
Add `hint_enum` for uniform int in gdshader
2024-07-13 14:30:08 -04:00
case '"': {
String _content = "";
bool _previous_backslash = false;
while (true) {
bool _ended = false;
char32_t c = GETCHAR(0);
if (c == 0) {
return _make_token(TK_ERROR, "EOF reached before string termination.");
}
switch (c) {
case '"': {
if (_previous_backslash) {
_content += '"';
_previous_backslash = false;
} else {
_ended = true;
}
break;
}
case '\\': {
if (_previous_backslash) {
_content += '\\';
}
_previous_backslash = !_previous_backslash;
break;
}
case '\n': {
return _make_token(TK_ERROR, "Unexpected end of string.");
}
default: {
if (!_previous_backslash) {
_content += c;
} else {
return _make_token(TK_ERROR, "Only \\\" and \\\\ escape characters supported.");
}
break;
}
}
char_idx++;
if (_ended) {
break;
}
}
return _make_token(TK_STRING_CONSTANT, _content);
} 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 '\'' //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;
Clean up Shader Preprocessor * Moved preprocessor to Shader and ShaderInclude * Clean up RenderingServer side * Preprocessor is separate from parser now, but it emits tokens with include location hints. * Improved ShaderEditor validation code * Added include file code completion * Added notification for all files affected by a broken include.
2022-06-29 11:31:18 +02:00
case '@': {
if (GETCHAR(0) == '@' && GETCHAR(1) == '>') {
char_idx += 2;
LocalVector<char32_t> incp;
while (GETCHAR(0) != '\n') {
incp.push_back(GETCHAR(0));
char_idx++;
}
incp.push_back(0); // Zero end it.
String include_path(incp.ptr());
include_positions.write[include_positions.size() - 1].line = tk_line;
Fix shader language preprocessor include marker handling
2023-09-04 14:51:04 +03:00
String marker = ">>" + include_path;
if (!include_markers_handled.has(marker)) {
include_markers_handled.insert(marker);
FilePosition fp;
fp.file = include_path;
fp.line = 0;
tk_line = 0;
include_positions.push_back(fp);
Clean up Shader Preprocessor * Moved preprocessor to Shader and ShaderInclude * Clean up RenderingServer side * Preprocessor is separate from parser now, but it emits tokens with include location hints. * Improved ShaderEditor validation code * Added include file code completion * Added notification for all files affected by a broken include.
2022-06-29 11:31:18 +02:00
}
Fix shader language preprocessor include marker handling
2023-09-04 14:51:04 +03:00
} else if (GETCHAR(0) == '@' && GETCHAR(1) == '<') {
Clean up Shader Preprocessor * Moved preprocessor to Shader and ShaderInclude * Clean up RenderingServer side * Preprocessor is separate from parser now, but it emits tokens with include location hints. * Improved ShaderEditor validation code * Added include file code completion * Added notification for all files affected by a broken include.
2022-06-29 11:31:18 +02:00
char_idx += 2;
Fix shader language preprocessor include marker handling
2023-09-04 14:51:04 +03:00
LocalVector<char32_t> incp;
while (GETCHAR(0) != '\n') {
incp.push_back(GETCHAR(0));
char_idx++;
}
incp.push_back(0); // Zero end it.
String include_path(incp.ptr());
String marker = "<<" + include_path;
if (!include_markers_handled.has(marker)) {
include_markers_handled.insert(marker);
if (include_positions.size() == 1) {
return _make_token(TK_ERROR, "Invalid include exit hint @@< without matching enter hint.");
}
include_positions.resize(include_positions.size() - 1); // Pop back.
}
Several shader preprocessor parser fixes and improvements
2023-01-25 18:18:26 +02:00
tk_line = include_positions[include_positions.size() - 1].line - 1; // Restore line.
Clean up Shader Preprocessor * Moved preprocessor to Shader and ShaderInclude * Clean up RenderingServer side * Preprocessor is separate from parser now, but it emits tokens with include location hints. * Improved ShaderEditor validation code * Added include file code completion * Added notification for all files affected by a broken include.
2022-06-29 11:31:18 +02:00
} else {
return _make_token(TK_ERROR, "Invalid include enter/exit hint token (@@> and @@<)");
}
} 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: {
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 == '+';
Fix using uint suffix at the hex number declaration in shaders
2023-07-01 14:26:05 +03:00
suffix_lut[CASE_HEXA_PERIOD][i] = t == 'e' || t == 'f' || t == 'u';
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
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;
Prevent defining float constant without number after exponent in shaders
2022-06-10 11:29:28 +03:00
bool digit_after_exp = 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
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)) {
Prevent defining float constant without number after exponent in shaders
2022-06-10 11:29:28 +03:00
if (exponent_found) {
digit_after_exp = true;
}
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
Style: Cleanup single-line blocks, semicolons, dead code Remove currently unused implementation of TextureBasisU, could be re-added later on if needed and ported.
2022-02-16 13:56:32 +01:00
if (hexa_found) { // Integer (hex).
Fix using uint suffix at the hex number declaration in shaders
2023-07-01 14:26:05 +03:00
if (uint_suffix_found) {
// Strip the suffix.
str = str.left(str.length() - 1);
// Compensate reading cursor position.
char_idx += 1;
}
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
Prevent defining float constant without number after exponent in shaders
2022-06-10 11:29:28 +03:00
if (exponent_found && (!digit_after_exp || (!is_digit(last_char) && last_char != 'f'))) { // Checks for eg: "2E", "2E-", "2E+" and 0ef, 0e+f, 0.0ef, 0.0e-f (exponent without digit after it).
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
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
bool ShaderLanguage::_lookup_next(Token &r_tk) {
TkPos pre_pos = _get_tkpos();
int line = pre_pos.tk_line;
_get_token();
Token tk = _get_token();
_set_tkpos(pre_pos);
if (tk.line == line) {
r_tk = tk;
return true;
}
return false;
}
Fix shader crash when the comma used in `for` loop as a trailing
2024-08-10 11:07:53 +03:00
ShaderLanguage::Token ShaderLanguage::_peek() {
TkPos pre_pos = _get_tkpos();
Token tk = _get_token();
_set_tkpos(pre_pos);
return 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
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 ||
Add external texture support (GLES3) Co-authored-by: Fredia Huya-Kouadio <fhuyakou@gmail.com> Co-authored-by: Mauricio Narvaez <nvz@meta.com>
2023-10-14 03:58:59 -07:00
p_type == TK_TYPE_SAMPLERCUBEARRAY ||
p_type == TK_TYPE_SAMPLEREXT);
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
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
bool ShaderLanguage::is_token_arg_qual(TokenType p_type) {
return (
p_type == TK_ARG_IN ||
p_type == TK_ARG_OUT ||
p_type == TK_ARG_INOUT);
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on 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 "";
}
Fix shader crash when using boolean type for vertex->fragment varyings
2022-12-22 23:19:30 +03:00
String ShaderLanguage::get_interpolation_name(DataInterpolation p_interpolation) {
switch (p_interpolation) {
case INTERPOLATION_FLAT:
return "flat";
case INTERPOLATION_SMOOTH:
return "smooth";
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";
Add external texture support (GLES3) Co-authored-by: Fredia Huya-Kouadio <fhuyakou@gmail.com> Co-authored-by: Mauricio Narvaez <nvz@meta.com>
2023-10-14 03:58:59 -07:00
case TYPE_SAMPLEREXT:
return "samplerExternalOES";
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 "";
}
Refactor shader hints
2022-05-31 11:44:44 +03:00
String ShaderLanguage::get_uniform_hint_name(ShaderNode::Uniform::Hint p_hint) {
String result;
switch (p_hint) {
case ShaderNode::Uniform::HINT_RANGE: {
result = "hint_range";
} break;
Add `hint_enum` for uniform int in gdshader
2024-07-13 14:30:08 -04:00
case ShaderNode::Uniform::HINT_ENUM: {
result = "hint_enum";
} break;
Refactor shader hints
2022-05-31 11:44:44 +03:00
case ShaderNode::Uniform::HINT_SOURCE_COLOR: {
Prevent duplicated hints in shader uniform completion
2022-09-11 14:49:19 +03:00
result = "source_color";
Refactor shader hints
2022-05-31 11:44:44 +03:00
} break;
case ShaderNode::Uniform::HINT_NORMAL: {
result = "hint_normal";
} break;
case ShaderNode::Uniform::HINT_ROUGHNESS_NORMAL: {
result = "hint_roughness_normal";
} break;
case ShaderNode::Uniform::HINT_ROUGHNESS_R: {
result = "hint_roughness_r";
} break;
case ShaderNode::Uniform::HINT_ROUGHNESS_G: {
result = "hint_roughness_g";
} break;
case ShaderNode::Uniform::HINT_ROUGHNESS_B: {
result = "hint_roughness_b";
} break;
case ShaderNode::Uniform::HINT_ROUGHNESS_A: {
result = "hint_roughness_a";
} break;
case ShaderNode::Uniform::HINT_ROUGHNESS_GRAY: {
result = "hint_roughness_gray";
} break;
case ShaderNode::Uniform::HINT_DEFAULT_BLACK: {
result = "hint_default_black";
} break;
case ShaderNode::Uniform::HINT_DEFAULT_WHITE: {
result = "hint_default_white";
} break;
Add `hint_transparent` to use a transparent black placeholder texture This can be used in shaders to avoid the need to supply a transparent placeholder texture manually.
2021-08-14 18:29:52 +02:00
case ShaderNode::Uniform::HINT_DEFAULT_TRANSPARENT: {
result = "hint_default_transparent";
} break;
Refactor shader hints
2022-05-31 11:44:44 +03:00
case ShaderNode::Uniform::HINT_ANISOTROPY: {
result = "hint_anisotropy";
} break;
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
case ShaderNode::Uniform::HINT_SCREEN_TEXTURE: {
result = "hint_screen_texture";
} break;
case ShaderNode::Uniform::HINT_NORMAL_ROUGHNESS_TEXTURE: {
result = "hint_normal_roughness_texture";
} break;
case ShaderNode::Uniform::HINT_DEPTH_TEXTURE: {
result = "hint_depth_texture";
} break;
Refactor shader hints
2022-05-31 11:44:44 +03:00
default:
break;
}
return result;
}
String ShaderLanguage::get_texture_filter_name(TextureFilter p_filter) {
String result;
switch (p_filter) {
case FILTER_NEAREST: {
result = "filter_nearest";
} break;
case FILTER_LINEAR: {
result = "filter_linear";
} break;
case FILTER_NEAREST_MIPMAP: {
result = "filter_nearest_mipmap";
} break;
case FILTER_LINEAR_MIPMAP: {
result = "filter_linear_mipmap";
} break;
case FILTER_NEAREST_MIPMAP_ANISOTROPIC: {
result = "filter_nearest_mipmap_anisotropic";
} break;
case FILTER_LINEAR_MIPMAP_ANISOTROPIC: {
result = "filter_linear_mipmap_anisotropic";
} break;
default: {
} break;
}
return result;
}
String ShaderLanguage::get_texture_repeat_name(TextureRepeat p_repeat) {
String result;
switch (p_repeat) {
case REPEAT_DISABLE: {
result = "repeat_disable";
} break;
case REPEAT_ENABLE: {
result = "repeat_enable";
} break;
default: {
} break;
}
return result;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
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;
Implement shader uniform groups/subgroups
2022-07-13 11:31:27 +03:00
current_uniform_group_name = "";
current_uniform_subgroup_name = "";
Prevent duplicated hints in shader uniform completion
2022-09-11 14:49:19 +03:00
current_uniform_hint = ShaderNode::Uniform::HINT_NONE;
current_uniform_filter = FILTER_DEFAULT;
current_uniform_repeat = REPEAT_DEFAULT;
current_uniform_instance_index_defined = 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
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
Clean up Shader Preprocessor * Moved preprocessor to Shader and ShaderInclude * Clean up RenderingServer side * Preprocessor is separate from parser now, but it emits tokens with include location hints. * Improved ShaderEditor validation code * Added include file code completion * Added notification for all files affected by a broken include.
2022-06-29 11:31:18 +02:00
include_positions.clear();
include_positions.push_back(FilePosition());
Fix shader language preprocessor include marker handling
2023-09-04 14:51:04 +03:00
include_markers_handled.clear();
Forbid calling of derivative functions in incorrect functions
2024-06-19 18:38:51 +03:00
calls_info.clear();
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
function_overload_count.clear();
Fix shader language preprocessor include marker handling
2023-09-04 14:51:04 +03:00
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
#ifdef DEBUG_ENABLED
Remove `shader_type` from completion (when it does not need any more)
2022-09-07 16:19:36 +03:00
keyword_completion_context = CF_UNSPECIFIED;
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
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 = "";
Fix shader failure when using non-const initializer on a constant
2023-02-01 09:04:10 +03:00
is_const_decl = 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
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +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, Vector<Scalar> *r_constant_values) {
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
if (is_shader_inc) {
for (int i = 0; i < RenderingServer::SHADER_MAX; i++) {
for (const KeyValue<StringName, FunctionInfo> &E : ShaderTypes::get_singleton()->get_functions(RenderingServer::ShaderMode(i))) {
Fix predefined constants to be accessible in the shader includes
2022-11-01 19:52:49 +03:00
if ((current_function == E.key || E.key == "global" || E.key == "constants") && E.value.built_ins.has(p_identifier)) {
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
if (r_data_type) {
*r_data_type = E.value.built_ins[p_identifier].type;
}
if (r_is_const) {
*r_is_const = E.value.built_ins[p_identifier].constant;
}
if (r_type) {
*r_type = IDENTIFIER_BUILTIN_VAR;
}
return true;
}
}
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
}
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
} else {
if (p_function_info.built_ins.has(p_identifier)) {
if (r_data_type) {
*r_data_type = p_function_info.built_ins[p_identifier].type;
}
if (r_is_const) {
*r_is_const = p_function_info.built_ins[p_identifier].constant;
}
if (r_type) {
*r_type = IDENTIFIER_BUILTIN_VAR;
}
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;
}
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
if (r_constant_values && !p_block->variables[p_identifier].values.is_empty()) {
*r_constant_values = p_block->variables[p_identifier].values;
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
}
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;
}
Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-28 11:40:18 +02:00
ERR_FAIL_NULL_V(p_block->parent_block, 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
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) {
Fix completion of functions with struct param/return type in shaders
2024-05-28 12:13:25 +03:00
*r_struct_name = function->arguments[i].struct_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
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) {
Fix completion of functions with struct param/return type in shaders
2024-05-28 12:13:25 +03:00
*r_struct_name = shader->constants[p_identifier].struct_name;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
if (r_constant_values) {
if (shader->constants[p_identifier].initializer && !shader->constants[p_identifier].initializer->get_values().is_empty()) {
*r_constant_values = shader->constants[p_identifier].initializer->get_values();
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
}
}
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;
}
Re-allows constants in global space to be initialized with function call
2023-09-13 19:11:12 +03:00
for (int i = 0; i < shader->vfunctions.size(); i++) {
if (!shader->vfunctions[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
Re-allows constants in global space to be initialized with function call
2023-09-13 19:11:12 +03:00
if (shader->vfunctions[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) {
Re-allows constants in global space to be initialized with function call
2023-09-13 19:11:12 +03:00
*r_data_type = shader->vfunctions[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) {
Re-allows constants in global space to be initialized with function call
2023-09-13 19:11:12 +03:00
*r_array_size = shader->vfunctions[i].function->return_array_size;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +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_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
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
bool ShaderLanguage::_validate_operator(const BlockNode *p_block, 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();
Prevent shader crash when doing invalid operation on boolean vector
2024-06-30 22:09:45 +03:00
valid = na > TYPE_BVEC4 && na < 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
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) {
Prevent shader crash when doing invalid operation on boolean vector
2024-06-30 22:09:45 +03:00
valid = (na > TYPE_BVEC4 && 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) {
Prevent shader crash when doing invalid operation on boolean vector
2024-06-30 22:09:45 +03:00
valid = (na > TYPE_BVEC4 && 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;
}
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
if (valid && (!p_block || p_block->use_op_eval)) {
// Need to be placed here and not in the `_reduce_expression` because otherwise expressions like `1 + 2 / 2` will not work correctly.
valid = _eval_operator(p_block, p_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
return valid;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
Vector<ShaderLanguage::Scalar> ShaderLanguage::_get_node_values(const BlockNode *p_block, Node *p_node) {
Vector<Scalar> result;
switch (p_node->type) {
case Node::NODE_TYPE_VARIABLE: {
_find_identifier(p_block, false, FunctionInfo(), static_cast<VariableNode *>(p_node)->name, nullptr, nullptr, nullptr, nullptr, nullptr, &result);
} break;
default: {
result = p_node->get_values();
} break;
}
return result;
}
bool ShaderLanguage::_eval_operator(const BlockNode *p_block, OperatorNode *p_op) {
bool is_valid = true;
switch (p_op->op) {
case OP_EQUAL:
case OP_NOT_EQUAL:
case OP_LESS:
case OP_LESS_EQUAL:
case OP_GREATER:
case OP_GREATER_EQUAL:
case OP_AND:
case OP_OR:
case OP_ADD:
case OP_SUB:
case OP_MUL:
case OP_DIV:
case OP_MOD:
case OP_SHIFT_LEFT:
case OP_SHIFT_RIGHT:
case OP_BIT_AND:
case OP_BIT_OR:
case OP_BIT_XOR: {
DataType a = p_op->arguments[0]->get_datatype();
DataType b = p_op->arguments[1]->get_datatype();
bool is_op_vec_transform = false;
if (p_op->op == OP_MUL) {
DataType ta = a;
DataType tb = b;
if (ta > tb) {
SWAP(ta, tb);
}
if (ta == TYPE_VEC2 && tb == TYPE_MAT2) {
is_op_vec_transform = true;
} else if (ta == TYPE_VEC3 && tb == TYPE_MAT3) {
is_op_vec_transform = true;
} else if (ta == TYPE_VEC4 && tb == TYPE_MAT4) {
is_op_vec_transform = true;
}
}
Vector<Scalar> va = _get_node_values(p_block, p_op->arguments[0]);
Vector<Scalar> vb = _get_node_values(p_block, p_op->arguments[1]);
if (is_op_vec_transform) {
p_op->values = _eval_vector_transform(va, vb, a, b, p_op->get_datatype());
} else {
p_op->values = _eval_vector(va, vb, a, b, p_op->get_datatype(), p_op->op, is_valid);
}
} break;
case OP_NOT:
case OP_NEGATE:
case OP_BIT_INVERT: {
p_op->values = _eval_unary_vector(_get_node_values(p_block, p_op->arguments[0]), p_op->get_datatype(), p_op->op);
} break;
default: {
} break;
}
return is_valid;
}
ShaderLanguage::Scalar ShaderLanguage::_eval_unary_scalar(const Scalar &p_a, Operator p_op, DataType p_ret_type) {
Scalar scalar;
switch (p_op) {
case OP_NOT: {
scalar.boolean = !p_a.boolean;
} break;
case OP_NEGATE: {
if (p_ret_type >= TYPE_INT && p_ret_type <= TYPE_IVEC4) {
scalar.sint = -p_a.sint;
} else if (p_ret_type >= TYPE_UINT && p_ret_type <= TYPE_UVEC4) {
// Intentionally wrap the unsigned int value, because GLSL does.
scalar.uint = 0 - p_a.uint;
} else { // float types
scalar.real = -scalar.real;
}
} break;
case OP_BIT_INVERT: {
if (p_ret_type >= TYPE_INT && p_ret_type <= TYPE_IVEC4) {
scalar.sint = ~p_a.sint;
} else { // uint types
scalar.uint = ~p_a.uint;
}
} break;
default: {
} break;
}
return scalar;
}
ShaderLanguage::Scalar ShaderLanguage::_eval_scalar(const Scalar &p_a, const Scalar &p_b, Operator p_op, DataType p_ret_type, bool &r_is_valid) {
Scalar scalar;
switch (p_op) {
case OP_EQUAL: {
scalar.boolean = p_a.boolean == p_b.boolean;
} break;
case OP_NOT_EQUAL: {
scalar.boolean = p_a.boolean != p_b.boolean;
} break;
case OP_LESS: {
if (p_ret_type == TYPE_INT) {
scalar.boolean = p_a.sint < p_b.sint;
} else if (p_ret_type == TYPE_UINT) {
scalar.boolean = p_a.uint < p_b.uint;
} else { // float type
scalar.boolean = p_a.real < p_b.real;
}
} break;
case OP_LESS_EQUAL: {
if (p_ret_type == TYPE_INT) {
scalar.boolean = p_a.sint <= p_b.sint;
} else if (p_ret_type == TYPE_UINT) {
scalar.boolean = p_a.uint <= p_b.uint;
} else { // float type
scalar.boolean = p_a.real <= p_b.real;
}
} break;
case OP_GREATER: {
if (p_ret_type == TYPE_INT) {
scalar.boolean = p_a.sint > p_b.sint;
} else if (p_ret_type == TYPE_UINT) {
scalar.boolean = p_a.uint > p_b.uint;
} else { // float type
scalar.boolean = p_a.real > p_b.real;
}
} break;
case OP_GREATER_EQUAL: {
if (p_ret_type == TYPE_INT) {
scalar.boolean = p_a.sint >= p_b.sint;
} else if (p_ret_type == TYPE_UINT) {
scalar.boolean = p_a.uint >= p_b.uint;
} else { // float type
scalar.boolean = p_a.real >= p_b.real;
}
} break;
case OP_AND: {
scalar.boolean = p_a.boolean && p_b.boolean;
} break;
case OP_OR: {
scalar.boolean = p_a.boolean || p_b.boolean;
} break;
case OP_ADD: {
if (p_ret_type >= TYPE_INT && p_ret_type <= TYPE_IVEC4) {
scalar.sint = p_a.sint + p_b.sint;
} else if (p_ret_type >= TYPE_UINT && p_ret_type <= TYPE_UVEC4) {
scalar.uint = p_a.uint + p_b.uint;
} else { // float + matrix types
scalar.real = p_a.real + p_b.real;
}
} break;
case OP_SUB: {
if (p_ret_type >= TYPE_INT && p_ret_type <= TYPE_IVEC4) {
scalar.sint = p_a.sint - p_b.sint;
} else if (p_ret_type >= TYPE_UINT && p_ret_type <= TYPE_UVEC4) {
scalar.uint = p_a.uint - p_b.uint;
} else { // float + matrix types
scalar.real = p_a.real - p_b.real;
}
} break;
case OP_MUL: {
if (p_ret_type >= TYPE_INT && p_ret_type <= TYPE_IVEC4) {
scalar.sint = p_a.sint * p_b.sint;
} else if (p_ret_type >= TYPE_UINT && p_ret_type <= TYPE_UVEC4) {
scalar.uint = p_a.uint * p_b.uint;
} else { // float + matrix types
scalar.real = p_a.real * p_b.real;
}
} break;
case OP_DIV: {
if (p_ret_type >= TYPE_INT && p_ret_type <= TYPE_IVEC4) {
if (p_b.sint == 0) {
_set_error(RTR("Division by zero error."));
r_is_valid = false;
break;
}
scalar.sint = p_a.sint / p_b.sint;
} else if (p_ret_type == TYPE_UINT && p_ret_type <= TYPE_UVEC4) {
if (p_b.uint == 0U) {
_set_error(RTR("Division by zero error."));
r_is_valid = false;
break;
}
scalar.uint = p_a.uint / p_b.uint;
} else { // float + matrix types
scalar.real = p_a.real / p_b.real;
}
} break;
case OP_MOD: {
if (p_ret_type >= TYPE_INT && p_ret_type <= TYPE_IVEC4) {
if (p_b.sint == 0) {
_set_error(RTR("Modulo by zero error."));
r_is_valid = false;
break;
}
scalar.sint = p_a.sint % p_b.sint;
} else { // uint types
if (p_b.uint == 0U) {
_set_error(RTR("Modulo by zero error."));
r_is_valid = false;
break;
}
scalar.uint = p_a.uint % p_b.uint;
}
} break;
case OP_SHIFT_LEFT: {
if (p_ret_type >= TYPE_INT && p_ret_type <= TYPE_IVEC4) {
scalar.sint = p_a.sint << p_b.sint;
} else { // uint types
scalar.uint = p_a.uint << p_b.uint;
}
} break;
case OP_SHIFT_RIGHT: {
if (p_ret_type >= TYPE_INT && p_ret_type <= TYPE_IVEC4) {
scalar.sint = p_a.sint >> p_b.sint;
} else { // uint types
scalar.uint = p_a.uint >> p_b.uint;
}
} break;
case OP_BIT_AND: {
if (p_ret_type >= TYPE_INT && p_ret_type <= TYPE_IVEC4) {
scalar.sint = p_a.sint & p_b.sint;
} else { // uint types
scalar.uint = p_a.uint & p_b.uint;
}
} break;
case OP_BIT_OR: {
if (p_ret_type >= TYPE_INT && p_ret_type <= TYPE_IVEC4) {
scalar.sint = p_a.sint | p_b.sint;
} else { // uint types
scalar.uint = p_a.uint | p_b.uint;
}
} break;
case OP_BIT_XOR: {
if (p_ret_type >= TYPE_INT && p_ret_type <= TYPE_IVEC4) {
scalar.sint = p_a.sint ^ p_b.sint;
} else { // uint types
scalar.uint = p_a.uint ^ p_b.uint;
}
} break;
default: {
} break;
}
return scalar;
}
Vector<ShaderLanguage::Scalar> ShaderLanguage::_eval_unary_vector(const Vector<Scalar> &p_va, DataType p_ret_type, Operator p_op) {
uint32_t size = get_datatype_component_count(p_ret_type);
if (p_va.size() != p_ret_type) {
return Vector<Scalar>(); // Non-evaluable values should not be parsed further.
}
Vector<Scalar> value;
value.resize(size);
Scalar *w = value.ptrw();
for (uint32_t i = 0U; i < size; i++) {
w[i] = _eval_unary_scalar(p_va[i], p_op, p_ret_type);
}
return value;
}
Vector<ShaderLanguage::Scalar> ShaderLanguage::_eval_vector(const Vector<Scalar> &p_va, const Vector<Scalar> &p_vb, DataType p_left_type, DataType p_right_type, DataType p_ret_type, Operator p_op, bool &r_is_valid) {
uint32_t left_size = get_datatype_component_count(p_left_type);
uint32_t right_size = get_datatype_component_count(p_right_type);
if (p_va.size() != left_size || p_vb.size() != right_size) {
return Vector<Scalar>(); // Non-evaluable values should not be parsed further.
}
uint32_t ret_size = get_datatype_component_count(p_ret_type);
Vector<Scalar> value;
value.resize(ret_size);
Scalar *w = value.ptrw();
for (uint32_t i = 0U; i < ret_size; i++) {
w[i] = _eval_scalar(p_va[MIN(i, left_size - 1)], p_vb[MIN(i, right_size - 1)], p_op, p_ret_type, r_is_valid);
if (!r_is_valid) {
return value;
}
}
return value;
}
Vector<ShaderLanguage::Scalar> ShaderLanguage::_eval_vector_transform(const Vector<Scalar> &p_va, const Vector<Scalar> &p_vb, DataType p_left_type, DataType p_right_type, DataType p_ret_type) {
uint32_t left_size = get_datatype_component_count(p_left_type);
uint32_t right_size = get_datatype_component_count(p_right_type);
if (p_va.size() != left_size || p_vb.size() != right_size) {
return Vector<Scalar>(); // Non-evaluable values should not be parsed further.
}
uint32_t ret_size = get_datatype_component_count(p_ret_type);
Vector<Scalar> value;
value.resize_zeroed(ret_size);
Scalar *w = value.ptrw();
switch (p_ret_type) {
case TYPE_VEC2: {
if (left_size == 2) { // v * m
Vector2 v = Vector2(p_va[0].real, p_va[1].real);
w[0].real = (p_vb[0].real * v.x + p_vb[1].real * v.y);
w[1].real = (p_vb[2].real * v.x + p_vb[3].real * v.y);
} else { // m * v
Vector2 v = Vector2(p_vb[0].real, p_vb[1].real);
w[0].real = (p_va[0].real * v.x + p_va[2].real * v.y);
w[1].real = (p_va[1].real * v.x + p_va[3].real * v.y);
}
} break;
case TYPE_VEC3: {
if (left_size == 3) { // v * m
Vector3 v = Vector3(p_va[0].real, p_va[1].real, p_va[2].real);
w[0].real = (p_vb[0].real * v.x + p_vb[1].real * v.y + p_vb[2].real * v.z);
w[1].real = (p_vb[3].real * v.x + p_vb[4].real * v.y + p_vb[5].real * v.z);
w[2].real = (p_vb[6].real * v.x + p_vb[7].real * v.y + p_vb[8].real * v.z);
} else { // m * v
Vector3 v = Vector3(p_vb[0].real, p_vb[1].real, p_vb[2].real);
w[0].real = (p_va[0].real * v.x + p_va[3].real * v.y + p_va[6].real * v.z);
w[1].real = (p_va[1].real * v.x + p_va[4].real * v.y + p_va[7].real * v.z);
w[2].real = (p_va[2].real * v.x + p_va[5].real * v.y + p_va[8].real * v.z);
}
} break;
case TYPE_VEC4: {
if (left_size == 4) { // v * m
Vector4 v = Vector4(p_va[0].real, p_va[1].real, p_va[2].real, p_va[3].real);
w[0].real = (p_vb[0].real * v.x + p_vb[1].real * v.y + p_vb[2].real * v.z + p_vb[3].real * v.w);
w[1].real = (p_vb[4].real * v.x + p_vb[5].real * v.y + p_vb[6].real * v.z + p_vb[7].real * v.w);
w[2].real = (p_vb[8].real * v.x + p_vb[9].real * v.y + p_vb[10].real * v.z + p_vb[11].real * v.w);
w[3].real = (p_vb[12].real * v.x + p_vb[13].real * v.y + p_vb[14].real * v.z + p_vb[15].real * v.w);
} else { // m * v
Vector4 v = Vector4(p_vb[0].real, p_vb[1].real, p_vb[2].real, p_vb[3].real);
w[0].real = (p_vb[0].real * v.x + p_vb[4].real * v.y + p_vb[8].real * v.z + p_vb[12].real * v.w);
w[1].real = (p_vb[1].real * v.x + p_vb[5].real * v.y + p_vb[9].real * v.z + p_vb[13].real * v.w);
w[2].real = (p_vb[2].real * v.x + p_vb[6].real * v.y + p_vb[10].real * v.z + p_vb[14].real * v.w);
w[3].real = (p_vb[3].real * v.x + p_vb[7].real * v.y + p_vb[11].real * v.z + p_vb[15].real * v.w);
}
} break;
default: {
} break;
}
return 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
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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "uint", TYPE_UINT, { TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec2", TYPE_UVEC2, { TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec2", TYPE_UVEC2, { TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec3", TYPE_UVEC3, { TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec3", TYPE_UVEC3, { TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec3", TYPE_UVEC3, { TYPE_UVEC2, TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec3", TYPE_UVEC3, { TYPE_UINT, TYPE_UVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_UVEC2, TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec4", TYPE_UVEC4, { TYPE_UVEC2, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_UINT, TYPE_UVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_UVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec4", TYPE_UVEC4, { TYPE_UVEC3, TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec4", TYPE_UVEC4, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "int", TYPE_INT, { TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "float", TYPE_FLOAT, { TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "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
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "uint", TYPE_UINT, { TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uint", TYPE_UINT, { TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uint", TYPE_UINT, { TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uint", TYPE_UINT, { 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
{ "bool", TYPE_BOOL, { TYPE_BOOL, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bool", TYPE_BOOL, { TYPE_INT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "bool", TYPE_BOOL, { TYPE_UINT, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "vec2", TYPE_VEC2, { TYPE_UVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "vec2", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "uvec2", TYPE_UVEC2, { TYPE_BVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec2", TYPE_UVEC2, { TYPE_IVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec2", TYPE_UVEC2, { TYPE_UVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec2", TYPE_UVEC2, { TYPE_VEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "bvec2", TYPE_BVEC2, { TYPE_BVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec2", TYPE_BVEC2, { TYPE_IVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "bvec2", TYPE_BVEC2, { TYPE_UVEC2, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "ivec3", TYPE_IVEC3, { TYPE_UVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "vec3", TYPE_VEC3, { TYPE_UVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "vec3", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "uvec3", TYPE_UVEC3, { TYPE_BVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec3", TYPE_UVEC3, { TYPE_IVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec3", TYPE_UVEC3, { TYPE_UVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec3", TYPE_UVEC3, { TYPE_VEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "bvec3", TYPE_BVEC3, { TYPE_BVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec3", TYPE_BVEC3, { TYPE_IVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "bvec3", TYPE_BVEC3, { TYPE_UVEC3, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "ivec4", TYPE_IVEC4, { TYPE_UVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "vec4", TYPE_VEC4, { TYPE_UVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "vec4", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "uvec4", TYPE_UVEC4, { TYPE_BVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec4", TYPE_UVEC4, { TYPE_IVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec4", TYPE_UVEC4, { TYPE_UVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "uvec4", TYPE_UVEC4, { TYPE_VEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "bvec4", TYPE_BVEC4, { TYPE_BVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
{ "bvec4", TYPE_BVEC4, { TYPE_IVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "bvec4", TYPE_BVEC4, { TYPE_UVEC4, TYPE_VOID }, { "" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "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
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "modf", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "x", "i" }, TAG_GLOBAL, false },
{ "modf", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "x", "i" }, TAG_GLOBAL, false },
{ "modf", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "x", "i" }, TAG_GLOBAL, false },
{ "modf", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "x", "i" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "min", TYPE_UINT, { TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UINT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UINT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "min", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UINT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "max", TYPE_UINT, { TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UINT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UINT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "max", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UINT, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "clamp", TYPE_UINT, { TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
{ "clamp", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UINT, TYPE_UINT, TYPE_VOID }, { "x", "minVal", "maxVal" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
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
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "floatBitsToInt", TYPE_INT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "floatBitsToInt", TYPE_IVEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "floatBitsToInt", TYPE_IVEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "floatBitsToInt", TYPE_IVEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// floatBitsToUint
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "floatBitsToUint", TYPE_UINT, { TYPE_FLOAT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "floatBitsToUint", TYPE_UVEC2, { TYPE_VEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "floatBitsToUint", TYPE_UVEC3, { TYPE_VEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "floatBitsToUint", TYPE_UVEC4, { TYPE_VEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// intBitsToFloat
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "intBitsToFloat", TYPE_FLOAT, { TYPE_INT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "intBitsToFloat", TYPE_VEC2, { TYPE_IVEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "intBitsToFloat", TYPE_VEC3, { TYPE_IVEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "intBitsToFloat", TYPE_VEC4, { TYPE_IVEC4, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// uintBitsToFloat
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "uintBitsToFloat", TYPE_FLOAT, { TYPE_UINT, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "uintBitsToFloat", TYPE_VEC2, { TYPE_UVEC2, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "uintBitsToFloat", TYPE_VEC3, { TYPE_UVEC3, TYPE_VOID }, { "x" }, TAG_GLOBAL, false },
{ "uintBitsToFloat", TYPE_VEC4, { TYPE_UVEC4, 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 - 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
Allow vec2 and vec4 for reflect and refract
2022-08-07 18:03:16 +02:00
{ "reflect", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "I", "N" }, TAG_GLOBAL, false },
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 },
Allow vec2 and vec4 for reflect and refract
2022-08-07 18:03:16 +02:00
{ "reflect", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "I", "N" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// refract
Allow vec2 and vec4 for reflect and refract
2022-08-07 18:03:16 +02:00
{ "refract", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "I", "N", "eta" }, TAG_GLOBAL, false },
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 },
Allow vec2 and vec4 for reflect and refract
2022-08-07 18:03:16 +02:00
{ "refract", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "I", "N", "eta" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "lessThan", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "lessThan", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "lessThan", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "greaterThan", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "greaterThan", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "greaterThan", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "lessThanEqual", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "lessThanEqual", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "lessThanEqual", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "greaterThanEqual", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "greaterThanEqual", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "greaterThanEqual", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "equal", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "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
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "notEqual", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, { "a", "b" }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, 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_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
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "textureSize", TYPE_IVEC2, { TYPE_SAMPLER2D, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, false },
{ "textureSize", TYPE_IVEC2, { TYPE_ISAMPLER2D, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, false },
{ "textureSize", TYPE_IVEC2, { TYPE_USAMPLER2D, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, false },
{ "textureSize", TYPE_IVEC3, { TYPE_SAMPLER2DARRAY, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, false },
{ "textureSize", TYPE_IVEC3, { TYPE_ISAMPLER2DARRAY, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, false },
{ "textureSize", TYPE_IVEC3, { TYPE_USAMPLER2DARRAY, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, false },
{ "textureSize", TYPE_IVEC3, { TYPE_SAMPLER3D, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, false },
{ "textureSize", TYPE_IVEC3, { TYPE_ISAMPLER3D, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, false },
{ "textureSize", TYPE_IVEC3, { TYPE_USAMPLER3D, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, false },
{ "textureSize", TYPE_IVEC2, { TYPE_SAMPLERCUBE, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, false },
{ "textureSize", TYPE_IVEC2, { TYPE_SAMPLERCUBEARRAY, TYPE_INT, TYPE_VOID }, { "sampler", "lod" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "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 external texture support (GLES3) Co-authored-by: Fredia Huya-Kouadio <fhuyakou@gmail.com> Co-authored-by: Mauricio Narvaez <nvz@meta.com>
2023-10-14 03:58:59 -07:00
{ "texture", TYPE_VEC4, { TYPE_SAMPLEREXT, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "texture", TYPE_VEC4, { TYPE_SAMPLEREXT, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// textureProj
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC4, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC4, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC4, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC4, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC4, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC4, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "bias" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
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 },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "textureLod", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "textureLod", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "textureLod", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "textureLod", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "textureLod", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "textureLod", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "textureLod", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "textureLod", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
{ "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
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "texelFetch", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_IVEC2, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "texelFetch", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_IVEC2, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "texelFetch", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_IVEC2, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "texelFetch", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "texelFetch", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "texelFetch", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "texelFetch", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "texelFetch", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "texelFetch", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// textureProjLod
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "textureProjLod", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "textureProjLod", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "textureProjLod", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "textureProjLod", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "textureProjLod", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "textureProjLod", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "textureProjLod", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "textureProjLod", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
{ "textureProjLod", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, { "sampler", "coords", "lod" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// textureGrad
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "textureGrad", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureGrad", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureGrad", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureGrad", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_VEC3, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureGrad", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_VEC3, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureGrad", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_VEC3, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureGrad", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureGrad", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureGrad", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureGrad", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureGrad", TYPE_VEC4, { TYPE_SAMPLERCUBEARRAY, TYPE_VEC4, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
Add `textureProjGrad` function to the shader language
2022-08-12 11:29:10 +03:00
// textureProjGrad
{ "textureProjGrad", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC3, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureProjGrad", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC4, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureProjGrad", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC3, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureProjGrad", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC4, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureProjGrad", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureProjGrad", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC4, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureProjGrad", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC4, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureProjGrad", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC4, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
{ "textureProjGrad", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC4, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords", "dPdx", "dPdy" }, TAG_GLOBAL, false },
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
// textureGather
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "textureGather", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "textureGather", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "textureGather", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "textureGather", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "comp" }, TAG_GLOBAL, false },
{ "textureGather", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "comp" }, TAG_GLOBAL, false },
{ "textureGather", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "comp" }, TAG_GLOBAL, false },
{ "textureGather", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "textureGather", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "textureGather", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "textureGather", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_VEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "comp" }, TAG_GLOBAL, false },
{ "textureGather", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_VEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "comp" }, TAG_GLOBAL, false },
{ "textureGather", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_VEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "comp" }, TAG_GLOBAL, false },
{ "textureGather", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_VOID }, { "sampler", "coords" }, TAG_GLOBAL, false },
{ "textureGather", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_INT, TYPE_VOID }, { "sampler", "coords", "comp" }, TAG_GLOBAL, false },
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
Add `textureQueryLod/Levels` functions to the shader language
2022-08-12 12:51:03 +03:00
// textureQueryLod
{ "textureQueryLod", TYPE_VEC2, { TYPE_SAMPLER2D, TYPE_VEC2 }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureQueryLod", TYPE_VEC2, { TYPE_ISAMPLER2D, TYPE_VEC2 }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureQueryLod", TYPE_VEC2, { TYPE_USAMPLER2D, TYPE_VEC2 }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureQueryLod", TYPE_VEC2, { TYPE_SAMPLER2DARRAY, TYPE_VEC2 }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureQueryLod", TYPE_VEC2, { TYPE_ISAMPLER2DARRAY, TYPE_VEC2 }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureQueryLod", TYPE_VEC2, { TYPE_USAMPLER2DARRAY, TYPE_VEC2 }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureQueryLod", TYPE_VEC2, { TYPE_SAMPLER3D, TYPE_VEC3 }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureQueryLod", TYPE_VEC2, { TYPE_ISAMPLER3D, TYPE_VEC3 }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureQueryLod", TYPE_VEC2, { TYPE_USAMPLER3D, TYPE_VEC3 }, { "sampler", "coords" }, TAG_GLOBAL, true },
{ "textureQueryLod", TYPE_VEC2, { TYPE_SAMPLERCUBE, TYPE_VEC3 }, { "sampler", "coords" }, TAG_GLOBAL, true },
// textureQueryLevels
{ "textureQueryLevels", TYPE_INT, { TYPE_SAMPLER2D }, { "sampler" }, TAG_GLOBAL, true },
{ "textureQueryLevels", TYPE_INT, { TYPE_ISAMPLER2D }, { "sampler" }, TAG_GLOBAL, true },
{ "textureQueryLevels", TYPE_INT, { TYPE_USAMPLER2D }, { "sampler" }, TAG_GLOBAL, true },
{ "textureQueryLevels", TYPE_INT, { TYPE_SAMPLER2DARRAY }, { "sampler" }, TAG_GLOBAL, true },
{ "textureQueryLevels", TYPE_INT, { TYPE_ISAMPLER2DARRAY }, { "sampler" }, TAG_GLOBAL, true },
{ "textureQueryLevels", TYPE_INT, { TYPE_USAMPLER2DARRAY }, { "sampler" }, TAG_GLOBAL, true },
{ "textureQueryLevels", TYPE_INT, { TYPE_SAMPLER3D }, { "sampler" }, TAG_GLOBAL, true },
{ "textureQueryLevels", TYPE_INT, { TYPE_ISAMPLER3D }, { "sampler" }, TAG_GLOBAL, true },
{ "textureQueryLevels", TYPE_INT, { TYPE_USAMPLER3D }, { "sampler" }, TAG_GLOBAL, true },
{ "textureQueryLevels", TYPE_INT, { TYPE_SAMPLERCUBE }, { "sampler" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// dFdx
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "dFdx", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "p" }, TAG_GLOBAL, false },
{ "dFdx", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "p" }, TAG_GLOBAL, false },
{ "dFdx", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "p" }, TAG_GLOBAL, false },
{ "dFdx", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "p" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
Add derivative functions with precision to shaders
2023-01-26 14:31:37 +03:00
// dFdxCoarse
{ "dFdxCoarse", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdxCoarse", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdxCoarse", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdxCoarse", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
// dFdxFine
{ "dFdxFine", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdxFine", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdxFine", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdxFine", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// dFdy
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "dFdy", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "p" }, TAG_GLOBAL, false },
{ "dFdy", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "p" }, TAG_GLOBAL, false },
{ "dFdy", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "p" }, TAG_GLOBAL, false },
{ "dFdy", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "p" }, TAG_GLOBAL, false },
Added parameter names to shader built-in function autocompletion
2021-08-08 14:49:59 +03:00
Add derivative functions with precision to shaders
2023-01-26 14:31:37 +03:00
// dFdyCoarse
{ "dFdyCoarse", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdyCoarse", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdyCoarse", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdyCoarse", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
// dFdyFine
{ "dFdyFine", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdyFine", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdyFine", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "dFdyFine", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// fwidth
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "fwidth", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "p" }, TAG_GLOBAL, false },
{ "fwidth", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "p" }, TAG_GLOBAL, false },
{ "fwidth", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "p" }, TAG_GLOBAL, false },
{ "fwidth", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "p" }, TAG_GLOBAL, false },
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
Add derivative functions with precision to shaders
2023-01-26 14:31:37 +03:00
// fwidthCoarse
{ "fwidthCoarse", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "fwidthCoarse", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "fwidthCoarse", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "fwidthCoarse", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
// fwidthFine
{ "fwidthFine", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "fwidthFine", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "fwidthFine", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
{ "fwidthFine", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, { "p" }, TAG_GLOBAL, true },
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
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "length", TYPE_INT, { TYPE_VOID }, { "" }, TAG_ARRAY, 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
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
Mark fma function as high end so it isn't used with the gl_compatibility renderer
2023-02-08 12:37:20 -08:00
{ "fma", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, { "a", "b", "c" }, TAG_GLOBAL, true },
{ "fma", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, { "a", "b", "c" }, TAG_GLOBAL, true },
{ "fma", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, { "a", "b", "c" }, TAG_GLOBAL, true },
{ "fma", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, { "a", "b", "c" }, TAG_GLOBAL, true },
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.
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "packHalf2x16", TYPE_UINT, { TYPE_VEC2, TYPE_VOID }, { "v" }, TAG_GLOBAL, false },
{ "packUnorm2x16", TYPE_UINT, { TYPE_VEC2, TYPE_VOID }, { "v" }, TAG_GLOBAL, false },
{ "packSnorm2x16", TYPE_UINT, { TYPE_VEC2, TYPE_VOID }, { "v" }, TAG_GLOBAL, false },
{ "packUnorm4x8", TYPE_UINT, { TYPE_VEC4, TYPE_VOID }, { "v" }, TAG_GLOBAL, false },
{ "packSnorm4x8", TYPE_UINT, { TYPE_VEC4, TYPE_VOID }, { "v" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
Remove GLES2 shader constraints from GLES3
2022-06-14 12:01:52 -07:00
{ "unpackHalf2x16", TYPE_VEC2, { TYPE_UINT, TYPE_VOID }, { "v" }, TAG_GLOBAL, false },
{ "unpackUnorm2x16", TYPE_VEC2, { TYPE_UINT, TYPE_VOID }, { "v" }, TAG_GLOBAL, false },
{ "unpackSnorm2x16", TYPE_VEC2, { TYPE_UINT, TYPE_VOID }, { "v" }, TAG_GLOBAL, false },
{ "unpackUnorm4x8", TYPE_VEC4, { TYPE_UINT, TYPE_VOID }, { "v" }, TAG_GLOBAL, false },
{ "unpackSnorm4x8", TYPE_VEC4, { TYPE_UINT, TYPE_VOID }, { "v" }, TAG_GLOBAL, false },
Add missing shader built-ins
2021-09-25 21:05:57 +03:00
// 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
};
Prevent using built-ins for func names in shaders
2024-05-30 21:15:21 +03:00
HashSet<StringName> global_func_set;
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
};
Forbid calling of derivative functions in incorrect functions
2024-06-19 18:38:51 +03:00
const ShaderLanguage::BuiltinEntry ShaderLanguage::frag_only_func_defs[] = {
{ "dFdx" },
{ "dFdxCoarse" },
{ "dFdxFine" },
{ "dFdy" },
{ "dFdyCoarse" },
{ "dFdyFine" },
{ "fwidth" },
{ "fwidthCoarse" },
{ "fwidthFine" },
{ nullptr }
};
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
bool ShaderLanguage::is_const_suffix_lut_initialized = false;
Forbid passing multiview sampler to the custom function in shaders
2023-01-29 12:14:22 +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, bool *r_is_custom_function) {
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
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
ERR_FAIL_COND_V(p_func->arguments[0]->type != Node::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();
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
StringName rname = static_cast<VariableNode *>(p_func->arguments[0])->rname.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
Allow using stage functions inside custom shader functions
2024-06-27 10:18:44 +03:00
if (stages) {
// Stage functions can be used in custom functions as well, that why need to check them all.
for (const KeyValue<StringName, FunctionInfo> &E : *stages) {
if (E.value.stage_functions.has(name)) {
// Stage-based function.
const StageFunctionInfo &sf = E.value.stage_functions[name];
if (argcount != sf.arguments.size()) {
_set_error(vformat(RTR("Invalid number of arguments when calling stage function '%s', which expects %d arguments."), String(name), sf.arguments.size()));
return false;
}
// Validate arguments.
for (int i = 0; i < argcount; i++) {
if (args[i] != sf.arguments[i].type) {
_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)));
return false;
}
}
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18:10 -03:00
Allow using stage functions inside custom shader functions
2024-06-27 10:18:44 +03:00
if (r_ret_type) {
*r_ret_type = sf.return_type;
}
if (r_ret_type_str) {
*r_ret_type_str = "";
}
return true;
}
Implement manual particle emission and particle sub emitters.
2020-09-06 09:18: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
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++) {
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (p_func->arguments[i + 1]->type == Node::NODE_TYPE_ARRAY) {
Fix shader crash when passing array.length to functions and similar cases
2021-10-05 09:47:50 +03:00
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
}
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (get_scalar_type(args[i]) == args[i] && p_func->arguments[i + 1]->type == Node::NODE_TYPE_CONSTANT && convert_constant(static_cast<ConstantNode *>(p_func->arguments[i + 1]), builtin_func_defs[idx].args[i])) {
Ensure implicit conversions for scalar constants work in shaders, closes #26239
2019-02-26 23:20:39 -03:00
//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;
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
Vector<Scalar> values = _get_node_values(p_block, p_func->arguments[arg]);
if (p_func->arguments[arg]->get_datatype() == TYPE_INT && !values.is_empty()) {
if (values[0].sint < min || values[0].sint > max) {
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
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 {
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
error = true;
Fix shader crash if passing const values to modf function
2020-03-18 13:22:12 +03:00
}
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +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) {
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (p_func->arguments[arg_idx + 1]->type != Node::NODE_TYPE_VARIABLE && p_func->arguments[arg_idx + 1]->type != Node::NODE_TYPE_MEMBER && p_func->arguments[arg_idx + 1]->type != Node::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
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (p_func->arguments[arg_idx + 1]->type == Node::NODE_TYPE_ARRAY) {
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
ArrayNode *mn = static_cast<ArrayNode *>(p_func->arguments[arg_idx + 1]);
if (mn->is_const) {
fail = true;
}
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
} else if (p_func->arguments[arg_idx + 1]->type == Node::NODE_TYPE_MEMBER) {
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
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;
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (p_func->arguments[arg_idx + 1]->type == Node::NODE_TYPE_ARRAY) {
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
var_name = static_cast<const ArrayNode *>(p_func->arguments[arg_idx + 1])->name;
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
} else if (p_func->arguments[arg_idx + 1]->type == Node::NODE_TYPE_MEMBER) {
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
Node *n = static_cast<const MemberNode *>(p_func->arguments[arg_idx + 1])->owner;
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
while (n->type == Node::NODE_TYPE_MEMBER) {
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
n = static_cast<const MemberNode *>(n)->owner;
}
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (n->type != Node::NODE_TYPE_VARIABLE && n->type != Node::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;
}
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (n->type == Node::NODE_TYPE_VARIABLE) {
Added few more built-ins to shader language
2021-10-13 12:49:57 +03:00
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++) {
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (get_scalar_type(args[i]) != args[i] || args[i] == builtin_func_defs[idx].args[i] || p_func->arguments[i + 1]->type != Node::NODE_TYPE_CONSTANT) {
Ensure implicit conversions for scalar constants work in shaders, closes #26239
2019-02-26 23:20:39 -03:00
//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;
Add error for undefined function in shader
2023-07-14 11:36:48 +02:00
bool exists = false;
Improve messages in shader function validation
2020-09-05 11:12:29 +03:00
String arg_list = "";
Re-allows constants in global space to be initialized with function call
2023-09-13 19:11:12 +03:00
for (int i = 0; i < shader->vfunctions.size(); i++) {
if (name != shader->vfunctions[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
}
Add error for undefined function in shader
2023-07-14 11:36:48 +02:00
exists = true;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Re-allows constants in global space to be initialized with function call
2023-09-13 19:11:12 +03:00
if (!shader->vfunctions[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
Re-allows constants in global space to be initialized with function call
2023-09-13 19:11:12 +03:00
FunctionNode *pfunc = shader->vfunctions[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) {
Fix completion of functions with struct param/return type in shaders
2024-05-28 12:13:25 +03:00
func_arg_name = pfunc->arguments[j].struct_name;
Improve messages in shader function validation
2020-09-05 11:12:29 +03:00
} 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;
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
bool use_constant_conversion = function_overload_count[rname] == 0;
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++) {
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
if (use_constant_conversion && get_scalar_type(args[j]) == args[j] && p_func->arguments[j + 1]->type == Node::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
Fix completion of functions with struct param/return type in shaders
2024-05-28 12:13:25 +03:00
} else if (args[j] != pfunc->arguments[j].type || (args[j] == TYPE_STRUCT && args2[j] != pfunc->arguments[j].struct_name) || 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) {
Fix completion of functions with struct param/return type in shaders
2024-05-28 12:13:25 +03:00
func_arg_name = pfunc->arguments[j].struct_name;
Improve messages in shader function validation
2020-09-05 11:12:29 +03:00
} 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 += "]";
}
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
_set_error(vformat(RTR("Invalid argument for \"%s(%s)\" function: argument %d should be %s but is %s."), String(rname), 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++) {
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (get_scalar_type(args[k]) != args[k] || args[k] == pfunc->arguments[k].type || p_func->arguments[k + 1]->type != Node::NODE_TYPE_CONSTANT) {
Ensure implicit conversions for scalar constants work in shaders, closes #26239
2019-02-26 23:20:39 -03:00
//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;
}
}
Forbid passing multiview sampler to the custom function in shaders
2023-01-29 12:14:22 +03:00
if (r_is_custom_function) {
*r_is_custom_function = 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
return true;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
}
Add error for undefined function in shader
2023-07-14 11:36:48 +02:00
if (exists) {
if (last_arg_count > args.size()) {
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
_set_error(vformat(RTR("Too few arguments for \"%s(%s)\" call. Expected at least %d but received %d."), String(rname), arg_list, last_arg_count, args.size()));
Add error for undefined function in shader
2023-07-14 11:36:48 +02:00
} else if (last_arg_count < args.size()) {
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
_set_error(vformat(RTR("Too many arguments for \"%s(%s)\" call. Expected at most %d but received %d."), String(rname), arg_list, last_arg_count, args.size()));
Add error for undefined function in shader
2023-07-14 11:36:48 +02:00
}
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
}
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (is_const_decl && arg->type == Node::NODE_TYPE_VARIABLE) {
Fix shader failure when using non-const initializer on a constant
2023-02-01 09:04:10 +03:00
const VariableNode *var = static_cast<const VariableNode *>(arg);
if (!var->is_const) {
_set_error(RTR("Expected constant expression."));
return 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
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);
}
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
bool ShaderLanguage::convert_constant(ConstantNode *p_constant, DataType p_to_type, Scalar *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
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) {
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
return p_type > TYPE_MAT4 && p_type < TYPE_STRUCT;
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 18:31:01 -03:00
}
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
Variant ShaderLanguage::constant_value_to_variant(const Vector<Scalar> &p_value, DataType p_type, int p_array_size, ShaderLanguage::ShaderNode::Uniform::Hint p_hint) {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
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) {
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedInt32Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
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) {
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedInt32Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
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) {
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedInt32Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
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) {
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedInt32Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
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) {
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedInt32Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
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;
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedInt32Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].sint);
}
value = Variant(array);
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
value = Variant(Vector2i(p_value[0].sint, p_value[1].sint));
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
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;
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedInt32Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].sint);
}
value = Variant(array);
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
value = Variant(Vector3i(p_value[0].sint, p_value[1].sint, p_value[2].sint));
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
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;
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedInt32Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].sint);
}
value = Variant(array);
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
value = Variant(Vector4i(p_value[0].sint, p_value[1].sint, p_value[2].sint, p_value[3].sint));
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
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) {
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedInt32Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
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;
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedInt32Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].uint);
}
value = Variant(array);
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
value = Variant(Vector2i(p_value[0].uint, p_value[1].uint));
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
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;
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedInt32Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].uint);
}
value = Variant(array);
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
value = Variant(Vector3i(p_value[0].uint, p_value[1].uint, p_value[2].uint));
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
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;
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedInt32Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
for (int i = 0; i < array_size; i++) {
array.push_back(p_value[i].uint);
}
value = Variant(array);
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
value = Variant(Vector4i(p_value[0].uint, p_value[1].uint, p_value[2].uint, p_value[3].uint));
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
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) {
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedFloat32Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
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;
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedVector2Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
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;
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedColorArray array;
Add `hint_color` support for `vec3` in shaders
2022-05-01 09:47:35 +03:00
for (int i = 0; i < array_size; i += 3) {
array.push_back(Color(p_value[i].real, p_value[i + 1].real, p_value[i + 2].real));
}
value = Variant(array);
} else {
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedVector3Array array;
Add `hint_color` support for `vec3` in shaders
2022-05-01 09:47:35 +03:00
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);
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
} else {
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
Add `hint_color` support for `vec3` in shaders
2022-05-01 09:47:35 +03:00
value = Variant(Color(p_value[0].real, p_value[1].real, p_value[2].real));
} else {
value = Variant(Vector3(p_value[0].real, p_value[1].real, p_value[2].real));
}
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
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;
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedColorArray array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
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 {
Use `PackedVector4Array` instead of float array for vec4 array uniform
2024-06-26 17:11:32 +03:00
PackedVector4Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
for (int i = 0; i < array_size; i += 4) {
Use `PackedVector4Array` instead of float array for vec4 array uniform
2024-06-26 17:11:32 +03:00
array.push_back(Vector4(p_value[i].real, p_value[i + 1].real, p_value[i + 2].real, p_value[i + 3].real));
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
value = Variant(array);
}
Use hint_color when getting shader default params
2018-11-16 12:20:23 +01:00
} else {
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
value = Variant(Color(p_value[0].real, p_value[1].real, p_value[2].real, p_value[3].real));
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
value = Variant(Vector4(p_value[0].real, p_value[1].real, p_value[2].real, p_value[3].real));
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
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;
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedFloat32Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
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;
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedFloat32Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
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;
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
PackedFloat32Array array;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
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 {
Fix incorrect conversion of default value for mat4 uniform in shaders
2022-07-27 09:01:12 +03:00
Projection p = Projection(Vector4(p_value[0].real, p_value[1].real, p_value[2].real, p_value[3].real),
Vector4(p_value[4].real, p_value[5].real, p_value[6].real, p_value[7].real),
Vector4(p_value[8].real, p_value[9].real, p_value[10].real, p_value[11].real),
Vector4(p_value[12].real, p_value[13].real, p_value[14].real, p_value[15].real));
value = Variant(p);
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
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:
Add external texture support (GLES3) Co-authored-by: Fredia Huya-Kouadio <fhuyakou@gmail.com> Co-authored-by: Mauricio Narvaez <nvz@meta.com>
2023-10-14 03:58:59 -07:00
case ShaderLanguage::TYPE_SAMPLERCUBEARRAY:
case ShaderLanguage::TYPE_SAMPLEREXT: {
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();
}
Fix shader uniforms has null as default value
2024-08-16 12:21:32 +03:00
Variant ShaderLanguage::get_default_datatype_value(DataType p_type, int p_array_size, ShaderLanguage::ShaderNode::Uniform::Hint p_hint) {
int array_size = p_array_size;
Variant value;
switch (p_type) {
case ShaderLanguage::TYPE_BOOL:
if (array_size > 0) {
PackedInt32Array array;
for (int i = 0; i < array_size; i++) {
array.push_back(false);
}
value = Variant(array);
} else {
VariantInitializer<bool>::init(&value);
VariantDefaultInitializer<bool>::init(&value);
}
break;
case ShaderLanguage::TYPE_BVEC2:
array_size *= 2;
if (array_size > 0) {
PackedInt32Array array;
for (int i = 0; i < array_size; i++) {
array.push_back(false);
}
value = Variant(array);
} else {
VariantInitializer<int64_t>::init(&value);
VariantDefaultInitializer<int64_t>::init(&value);
}
break;
case ShaderLanguage::TYPE_BVEC3:
array_size *= 3;
if (array_size > 0) {
PackedInt32Array array;
for (int i = 0; i < array_size; i++) {
array.push_back(false);
}
value = Variant(array);
} else {
VariantInitializer<int64_t>::init(&value);
VariantDefaultInitializer<int64_t>::init(&value);
}
break;
case ShaderLanguage::TYPE_BVEC4:
array_size *= 4;
if (array_size > 0) {
PackedInt32Array array;
for (int i = 0; i < array_size; i++) {
array.push_back(false);
}
value = Variant(array);
} else {
VariantInitializer<int64_t>::init(&value);
VariantDefaultInitializer<int64_t>::init(&value);
}
break;
case ShaderLanguage::TYPE_INT:
if (array_size > 0) {
PackedInt32Array array;
for (int i = 0; i < array_size; i++) {
array.push_back(0);
}
value = Variant(array);
} else {
VariantInitializer<int64_t>::init(&value);
VariantDefaultInitializer<int64_t>::init(&value);
}
break;
case ShaderLanguage::TYPE_IVEC2:
if (array_size > 0) {
array_size *= 2;
PackedInt32Array array;
for (int i = 0; i < array_size; i++) {
array.push_back(0);
}
value = Variant(array);
} else {
VariantInitializer<Vector2i>::init(&value);
VariantDefaultInitializer<Vector2i>::init(&value);
}
break;
case ShaderLanguage::TYPE_IVEC3:
if (array_size > 0) {
array_size *= 3;
PackedInt32Array array;
for (int i = 0; i < array_size; i++) {
array.push_back(0);
}
value = Variant(array);
} else {
VariantInitializer<Vector3i>::init(&value);
VariantDefaultInitializer<Vector3i>::init(&value);
}
break;
case ShaderLanguage::TYPE_IVEC4:
if (array_size > 0) {
array_size *= 4;
PackedInt32Array array;
for (int i = 0; i < array_size; i++) {
array.push_back(0);
}
value = Variant(array);
} else {
VariantInitializer<Vector4i>::init(&value);
VariantDefaultInitializer<Vector4i>::init(&value);
}
break;
case ShaderLanguage::TYPE_UINT:
if (array_size > 0) {
PackedInt32Array array;
for (int i = 0; i < array_size; i++) {
array.push_back(0U);
}
value = Variant(array);
} else {
VariantInitializer<int64_t>::init(&value);
VariantDefaultInitializer<int64_t>::init(&value);
}
break;
case ShaderLanguage::TYPE_UVEC2:
if (array_size > 0) {
array_size *= 2;
PackedInt32Array array;
for (int i = 0; i < array_size; i++) {
array.push_back(0U);
}
value = Variant(array);
} else {
VariantInitializer<Vector2i>::init(&value);
VariantDefaultInitializer<Vector2i>::init(&value);
}
break;
case ShaderLanguage::TYPE_UVEC3:
if (array_size > 0) {
array_size *= 3;
PackedInt32Array array;
for (int i = 0; i < array_size; i++) {
array.push_back(0U);
}
value = Variant(array);
} else {
VariantInitializer<Vector3i>::init(&value);
VariantDefaultInitializer<Vector3i>::init(&value);
}
break;
case ShaderLanguage::TYPE_UVEC4:
if (array_size > 0) {
array_size *= 4;
PackedInt32Array array;
for (int i = 0; i < array_size; i++) {
array.push_back(0U);
}
value = Variant(array);
} else {
VariantInitializer<Vector4i>::init(&value);
VariantDefaultInitializer<Vector4i>::init(&value);
}
break;
case ShaderLanguage::TYPE_FLOAT:
if (array_size > 0) {
PackedFloat32Array array;
for (int i = 0; i < array_size; i++) {
array.push_back(0.0f);
}
value = Variant(array);
} else {
VariantInitializer<float>::init(&value);
VariantDefaultInitializer<float>::init(&value);
}
break;
case ShaderLanguage::TYPE_VEC2:
if (array_size > 0) {
PackedVector2Array array;
for (int i = 0; i < array_size; i++) {
array.push_back(Vector2(0.0f, 0.0f));
}
value = Variant(array);
} else {
VariantInitializer<Vector2>::init(&value);
VariantDefaultInitializer<Vector2>::init(&value);
}
break;
case ShaderLanguage::TYPE_VEC3:
if (array_size > 0) {
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
PackedColorArray array;
for (int i = 0; i < array_size; i++) {
array.push_back(Color(0.0f, 0.0f, 0.0f));
}
value = Variant(array);
} else {
PackedVector3Array array;
for (int i = 0; i < array_size; i++) {
array.push_back(Vector3(0.0f, 0.0f, 0.0f));
}
value = Variant(array);
}
} else {
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
VariantInitializer<Color>::init(&value);
VariantDefaultInitializer<Color>::init(&value);
} else {
VariantInitializer<Vector3>::init(&value);
VariantDefaultInitializer<Vector3>::init(&value);
}
}
break;
case ShaderLanguage::TYPE_VEC4:
if (array_size > 0) {
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
PackedColorArray array;
for (int i = 0; i < array_size; i++) {
array.push_back(Color(0.0f, 0.0f, 0.0f, 0.0f));
}
value = Variant(array);
} else {
PackedVector4Array array;
for (int i = 0; i < array_size; i++) {
array.push_back(Vector4(0.0f, 0.0f, 0.0f, 0.0f));
}
value = Variant(array);
}
} else {
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
VariantInitializer<Color>::init(&value);
VariantDefaultInitializer<Color>::init(&value);
} else {
VariantInitializer<Vector4>::init(&value);
VariantDefaultInitializer<Vector4>::init(&value);
}
}
break;
case ShaderLanguage::TYPE_MAT2:
if (array_size > 0) {
PackedFloat32Array array;
for (int i = 0; i < array_size; i++) {
for (int j = 0; j < 4; j++) {
array.push_back(0.0f);
}
}
value = Variant(array);
} else {
VariantInitializer<Transform2D>::init(&value);
VariantDefaultInitializer<Transform2D>::init(&value);
}
break;
case ShaderLanguage::TYPE_MAT3: {
if (array_size > 0) {
PackedFloat32Array array;
for (int i = 0; i < array_size; i++) {
for (int j = 0; j < 9; j++) {
array.push_back(0.0f);
}
}
value = Variant(array);
} else {
VariantInitializer<Basis>::init(&value);
VariantDefaultInitializer<Basis>::init(&value);
}
break;
}
case ShaderLanguage::TYPE_MAT4: {
if (array_size > 0) {
PackedFloat32Array array;
for (int i = 0; i < array_size; i++) {
for (int j = 0; j < 16; j++) {
array.push_back(0.0f);
}
}
value = Variant(array);
} else {
VariantInitializer<Projection>::init(&value);
VariantDefaultInitializer<Projection>::init(&value);
}
break;
}
default: {
} break;
}
return value;
}
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;
[Rendering] Add hints to some uniform `PropertyInfo`s * Enforce range on `int/uint` * Use flags for `bvec2/3/4` arrays
2024-03-14 19:15:46 +01:00
pi.hint = PROPERTY_HINT_TYPE_STRING;
pi.hint_string = itos(Variant::INT) + "/" + itos(PROPERTY_HINT_FLAGS) + ":" + RTR("On");
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
} 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;
[Rendering] Add hints to some uniform `PropertyInfo`s * Enforce range on `int/uint` * Use flags for `bvec2/3/4` arrays
2024-03-14 19:15:46 +01:00
pi.hint = PROPERTY_HINT_TYPE_STRING;
pi.hint_string = itos(Variant::INT) + "/" + itos(PROPERTY_HINT_FLAGS) + ":x,y";
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
} 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;
[Rendering] Add hints to some uniform `PropertyInfo`s * Enforce range on `int/uint` * Use flags for `bvec2/3/4` arrays
2024-03-14 19:15:46 +01:00
pi.hint = PROPERTY_HINT_TYPE_STRING;
pi.hint_string = itos(Variant::INT) + "/" + itos(PROPERTY_HINT_FLAGS) + ":x,y,z";
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
} 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;
[Rendering] Add hints to some uniform `PropertyInfo`s * Enforce range on `int/uint` * Use flags for `bvec2/3/4` arrays
2024-03-14 19:15:46 +01:00
pi.hint = PROPERTY_HINT_TYPE_STRING;
pi.hint_string = itos(Variant::INT) + "/" + itos(PROPERTY_HINT_FLAGS) + ":x,y,z,w";
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
} 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;
[Rendering] Add hints to some uniform `PropertyInfo`s * Enforce range on `int/uint` * Use flags for `bvec2/3/4` arrays
2024-03-14 19:15:46 +01:00
// TODO: Handle range and encoding for for unsigned values.
Add `hint_enum` for uniform int in gdshader
2024-07-13 14:30:08 -04:00
} else if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_ENUM) {
pi.type = Variant::INT;
pi.hint = PROPERTY_HINT_ENUM;
String hint_string;
pi.hint_string = String(",").join(p_uniform.hint_enum_names);
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
} else {
pi.type = Variant::INT;
[Rendering] Add hints to some uniform `PropertyInfo`s * Enforce range on `int/uint` * Use flags for `bvec2/3/4` arrays
2024-03-14 19:15:46 +01:00
pi.hint = PROPERTY_HINT_RANGE;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_RANGE) {
pi.hint_string = rtos(p_uniform.hint_range[0]) + "," + rtos(p_uniform.hint_range[1]) + "," + rtos(p_uniform.hint_range[2]);
[Rendering] Add hints to some uniform `PropertyInfo`s * Enforce range on `int/uint` * Use flags for `bvec2/3/4` arrays
2024-03-14 19:15:46 +01:00
} else if (p_uniform.type == ShaderLanguage::TYPE_UINT) {
pi.hint_string = "0," + itos(UINT32_MAX);
} else {
pi.hint_string = itos(INT32_MIN) + "," + itos(INT32_MAX);
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
}
} break;
case ShaderLanguage::TYPE_UVEC2:
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
case ShaderLanguage::TYPE_IVEC2: {
if (p_uniform.array_size > 0) {
pi.type = Variant::PACKED_INT32_ARRAY;
[Rendering] Add hints to some uniform `PropertyInfo`s * Enforce range on `int/uint` * Use flags for `bvec2/3/4` arrays
2024-03-14 19:15:46 +01:00
// TODO: Handle vector pairs?
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
} else {
pi.type = Variant::VECTOR2I;
}
} break;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
case ShaderLanguage::TYPE_UVEC3:
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
case ShaderLanguage::TYPE_IVEC3: {
if (p_uniform.array_size > 0) {
pi.type = Variant::PACKED_INT32_ARRAY;
[Rendering] Add hints to some uniform `PropertyInfo`s * Enforce range on `int/uint` * Use flags for `bvec2/3/4` arrays
2024-03-14 19:15:46 +01:00
// TODO: Handle vector pairs?
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
} else {
pi.type = Variant::VECTOR3I;
}
} break;
case ShaderLanguage::TYPE_UVEC4:
case ShaderLanguage::TYPE_IVEC4: {
if (p_uniform.array_size > 0) {
pi.type = Variant::PACKED_INT32_ARRAY;
[Rendering] Add hints to some uniform `PropertyInfo`s * Enforce range on `int/uint` * Use flags for `bvec2/3/4` arrays
2024-03-14 19:15:46 +01:00
// TODO: Handle vector pairs?
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
} else {
pi.type = Variant::VECTOR4I;
}
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) {
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
Add `hint_color` support for `vec3` in shaders
2022-05-01 09:47:35 +03:00
pi.hint = PROPERTY_HINT_COLOR_NO_ALPHA;
pi.type = Variant::PACKED_COLOR_ARRAY;
} else {
pi.type = Variant::PACKED_VECTOR3_ARRAY;
}
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
} else {
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
Add `hint_color` support for `vec3` in shaders
2022-05-01 09:47:35 +03:00
pi.hint = PROPERTY_HINT_COLOR_NO_ALPHA;
pi.type = Variant::COLOR;
} else {
pi.type = Variant::VECTOR3;
}
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
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) {
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
pi.type = Variant::PACKED_COLOR_ARRAY;
} else {
Use `PackedVector4Array` instead of float array for vec4 array uniform
2024-06-26 17:11:32 +03:00
pi.type = Variant::PACKED_VECTOR4_ARRAY;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
} else {
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
pi.type = Variant::COLOR;
} else {
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
pi.type = Variant::VECTOR4;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
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 {
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
pi.type = Variant::PROJECTION;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
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;
Shader: Set proper resource type hints for sampler uniforms Supersedes #64383.
2022-11-22 15:38:45 +01:00
pi.hint = PROPERTY_HINT_ARRAY_TYPE;
Add MAKE_RESOURCE_TYPE_HINT macro to simplify binding arrays of resources
2022-11-22 16:10:41 +01:00
pi.hint_string = MAKE_RESOURCE_TYPE_HINT("Texture2D");
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
} else {
pi.type = Variant::OBJECT;
Shader: Set proper resource type hints for sampler uniforms Supersedes #64383.
2022-11-22 15:38:45 +01:00
pi.hint = PROPERTY_HINT_RESOURCE_TYPE;
pi.hint_string = "Texture2D";
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
} break;
case ShaderLanguage::TYPE_SAMPLER2DARRAY:
case ShaderLanguage::TYPE_ISAMPLER2DARRAY:
Shader: Set proper resource type hints for sampler uniforms Supersedes #64383.
2022-11-22 15:38:45 +01:00
case ShaderLanguage::TYPE_USAMPLER2DARRAY:
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;
Shader: Set proper resource type hints for sampler uniforms Supersedes #64383.
2022-11-22 15:38:45 +01:00
pi.hint = PROPERTY_HINT_ARRAY_TYPE;
Add MAKE_RESOURCE_TYPE_HINT macro to simplify binding arrays of resources
2022-11-22 16:10:41 +01:00
pi.hint_string = MAKE_RESOURCE_TYPE_HINT("TextureLayered");
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
} else {
pi.type = Variant::OBJECT;
Shader: Set proper resource type hints for sampler uniforms Supersedes #64383.
2022-11-22 15:38:45 +01:00
pi.hint = PROPERTY_HINT_RESOURCE_TYPE;
pi.hint_string = "TextureLayered";
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
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;
Shader: Set proper resource type hints for sampler uniforms Supersedes #64383.
2022-11-22 15:38:45 +01:00
pi.hint = PROPERTY_HINT_ARRAY_TYPE;
Add MAKE_RESOURCE_TYPE_HINT macro to simplify binding arrays of resources
2022-11-22 16:10:41 +01:00
pi.hint_string = MAKE_RESOURCE_TYPE_HINT("Texture3D");
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
} else {
pi.type = Variant::OBJECT;
Shader: Set proper resource type hints for sampler uniforms Supersedes #64383.
2022-11-22 15:38:45 +01:00
pi.hint = PROPERTY_HINT_RESOURCE_TYPE;
pi.hint_string = "Texture3D";
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
} break;
Add external texture support (GLES3) Co-authored-by: Fredia Huya-Kouadio <fhuyakou@gmail.com> Co-authored-by: Mauricio Narvaez <nvz@meta.com>
2023-10-14 03:58:59 -07:00
case ShaderLanguage::TYPE_SAMPLEREXT: {
if (p_uniform.array_size > 0) {
pi.type = Variant::ARRAY;
pi.hint = PROPERTY_HINT_ARRAY_TYPE;
pi.hint_string = MAKE_RESOURCE_TYPE_HINT("ExternalTexture");
} else {
pi.type = Variant::OBJECT;
pi.hint = PROPERTY_HINT_RESOURCE_TYPE;
pi.hint_string = "ExternalTexture";
}
} 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;
Add external texture support (GLES3) Co-authored-by: Fredia Huya-Kouadio <fhuyakou@gmail.com> Co-authored-by: Mauricio Narvaez <nvz@meta.com>
2023-10-14 03:58:59 -07:00
case TYPE_SAMPLEREXT:
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
}
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
uint32_t ShaderLanguage::get_datatype_component_count(ShaderLanguage::DataType p_type) {
switch (p_type) {
case TYPE_BOOL:
return 1U;
case TYPE_BVEC2:
return 2U;
case TYPE_BVEC3:
return 3U;
case TYPE_BVEC4:
return 4U;
case TYPE_INT:
return 1U;
case TYPE_IVEC2:
return 2U;
case TYPE_IVEC3:
return 3U;
case TYPE_IVEC4:
return 4U;
case TYPE_UINT:
return 1U;
case TYPE_UVEC2:
return 2U;
case TYPE_UVEC3:
return 3U;
case TYPE_UVEC4:
return 4U;
case TYPE_FLOAT:
return 1U;
case TYPE_VEC2:
return 2U;
case TYPE_VEC3:
return 3U;
case TYPE_VEC4:
return 4U;
case TYPE_MAT2:
return 4U;
case TYPE_MAT3:
return 9U;
case TYPE_MAT4:
return 16U;
default:
break;
}
return 0U;
}
-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) {
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
HashSet<String> kws;
-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 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++;
}
Use range iterators for RBSet in most cases
2022-05-18 17:43:40 -06:00
for (const String &E : kws) {
r_keywords->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
}
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) {
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
HashSet<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
Use range iterators for RBSet in most cases
2022-05-18 17:43:40 -06:00
for (const String &E : kws) {
r_keywords->push_back(E);
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
}
-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,
Fix Fog shader buffer overflow
2022-11-15 06:51:48 -08:00
TYPE_INT,
TYPE_UINT,
TYPE_FLOAT,
TYPE_INT,
TYPE_UINT,
TYPE_FLOAT,
TYPE_FLOAT,
Add external texture support (GLES3) Co-authored-by: Fredia Huya-Kouadio <fhuyakou@gmail.com> Co-authored-by: Mauricio Narvaez <nvz@meta.com>
2023-10-14 03:58:59 -07:00
TYPE_FLOAT,
Fix Fog shader buffer overflow
2022-11-15 06:51:48 -08:00
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
};
Fix Fog shader buffer overflow
2022-11-15 06:51:48 -08:00
static_assert(sizeof(scalar_types) / sizeof(*scalar_types) == TYPE_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
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,
Fix Fog shader buffer overflow
2022-11-15 06:51:48 -08:00
1,
1,
1,
1,
1,
1,
1,
1,
Add external texture support (GLES3) Co-authored-by: Fredia Huya-Kouadio <fhuyakou@gmail.com> Co-authored-by: Mauricio Narvaez <nvz@meta.com>
2023-10-14 03:58:59 -07:00
1,
Fix vector reduction in shader language
2018-04-29 20:58:42 +02:00
};
Fix Fog shader buffer overflow
2022-11-15 06:51:48 -08:00
static_assert(sizeof(cardinality_table) / sizeof(*cardinality_table) == TYPE_MAX);
Fix vector reduction in shader language
2018-04-29 20:58:42 +02:00
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;
}
}
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) {
Add missing != operator to `StringName`
2022-12-20 17:22:44 +03:00
if (current_function != "vertex" && current_function != "fragment") {
Forbid varyings from assigning in custom functions to prevent crashes
2021-07-15 10:13:40 +03:00
*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) {
Fix shader crash when using boolean type for vertex->fragment varyings
2022-12-22 23:19:30 +03:00
if (p_varying.type < TYPE_INT) {
Fix shader crash when using varyings with non-`flat` integer type
2024-08-18 10:19:16 +03:00
*r_message = vformat(RTR("Varying with '%s' data type may only be assigned in the '%s' function."), get_datatype_name(p_varying.type), "fragment");
Fix shader crash when using boolean type for vertex->fragment varyings
2022-12-22 23:19:30 +03:00
return false;
}
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;
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) {
Fix shader crash when using varyings with non-`flat` integer type
2024-08-18 10:19:16 +03:00
*r_message = vformat(RTR("Varyings which assigned in '%s' function may not be reassigned in '%s' or '%s'."), "vertex", "fragment", "light");
Allow passing varying from fragment to light shader function
2020-12-26 14:26:19 +03:00
return false;
}
break;
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) {
Fix shader crash when using varyings with non-`flat` integer type
2024-08-18 10:19:16 +03:00
*r_message = vformat(RTR("Varyings which assigned in '%s' function may not be reassigned in '%s' or '%s'."), "fragment", "vertex", "light");
Allow passing varying from fragment to light shader function
2020-12-26 14:26:19 +03:00
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) {
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
case Node::NODE_TYPE_OPERATOR: {
Fix some issues found by cppcheck.
2022-04-05 13:40:26 +03:00
const OperatorNode *op_node = static_cast<const 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;
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
case Node::NODE_TYPE_CONSTANT:
Fix shader handle constant expressions in function call
2021-04-27 14:58:32 +03:00
break;
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
case Node::NODE_TYPE_VARIABLE: {
More codespell fixes, do more changes from previous ignore list
2023-02-01 10:49:05 +01:00
const VariableNode *var_node = static_cast<const VariableNode *>(p_node);
if (!var_node->is_const) {
Fix shader handle constant expressions in function call
2021-04-27 14:58:32 +03:00
return false;
}
} break;
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
case Node::NODE_TYPE_ARRAY: {
More codespell fixes, do more changes from previous ignore list
2023-02-01 10:49:05 +01:00
const ArrayNode *arr_node = static_cast<const ArrayNode *>(p_node);
if (!arr_node->is_const) {
Fix shader handle constant expressions in function call
2021-04-27 14:58:32 +03:00
return false;
}
} break;
default:
return false;
}
return true;
}
Forbid calling of derivative functions in incorrect functions
2024-06-19 18:38:51 +03:00
bool ShaderLanguage::_check_restricted_func(const StringName &p_name, const StringName &p_current_function) const {
int idx = 0;
while (frag_only_func_defs[idx].name) {
if (StringName(frag_only_func_defs[idx].name) == p_name) {
if (is_supported_frag_only_funcs) {
if (p_current_function == "vertex" && stages->has(p_current_function)) {
return true;
}
} else {
return true;
}
break;
}
idx++;
}
return false;
}
bool ShaderLanguage::_validate_restricted_func(const StringName &p_name, const CallInfo *p_func_info, bool p_is_builtin_hint) {
const bool is_in_restricted_function = p_func_info->name == "vertex";
// No need to check up the hierarchy if it's a built-in.
if (!p_is_builtin_hint) {
for (const CallInfo *func_info : p_func_info->calls) {
if (is_in_restricted_function && func_info->name != p_name) {
// Skips check for non-called method.
continue;
}
if (!_validate_restricted_func(p_name, func_info)) {
return false;
}
}
}
Fix shader crash when using a varying in separate func before it defined
2024-07-23 21:07:33 +03:00
if (!p_func_info->uses_restricted_items.is_empty()) {
const Pair<StringName, CallInfo::Item> &first_element = p_func_info->uses_restricted_items.get(0);
if (first_element.second.type == CallInfo::Item::ITEM_TYPE_VARYING) {
const ShaderNode::Varying &varying = shader->varyings[first_element.first];
if (varying.stage == ShaderNode::Varying::STAGE_VERTEX) {
return true;
}
}
_set_tkpos(first_element.second.pos);
Forbid calling of derivative functions in incorrect functions
2024-06-19 18:38:51 +03:00
if (is_in_restricted_function) {
_set_error(vformat(RTR("'%s' cannot be used within the '%s' processor function."), first_element.first, "vertex"));
} else {
_set_error(vformat(RTR("'%s' cannot be used here, because '%s' is called by the '%s' processor function (which is not allowed)."), first_element.first, p_func_info->name, "vertex"));
}
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) {
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (p_node->type == Node::NODE_TYPE_OPERATOR) {
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 18:23:16 -03:00
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
}
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
} else if (p_node->type == Node::NODE_TYPE_MEMBER) {
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
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
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
} else if (p_node->type == Node::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;
}
Fix assign with swizzle in shader not doing varying validation check
2023-10-23 17:52:50 +08:00
if (shader->varyings.has(var->name)) {
return _validate_varying_assign(shader->varyings[var->name], r_message);
}
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
}
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
} else if (p_node->type == Node::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
}
Restrict sampler hint validation to only screen texture hints
2024-07-28 22:31:57 -07:00
ShaderLanguage::ShaderNode::Uniform::Hint ShaderLanguage::_sanitize_hint(ShaderNode::Uniform::Hint p_hint) {
if (p_hint == ShaderNode::Uniform::HINT_SCREEN_TEXTURE ||
p_hint == ShaderNode::Uniform::HINT_NORMAL_ROUGHNESS_TEXTURE ||
p_hint == ShaderNode::Uniform::HINT_DEPTH_TEXTURE) {
return p_hint;
}
return ShaderNode::Uniform::HINT_NONE;
}
Emit normal_roughness compatibility code in custom functions
2024-07-26 10:45:36 -07:00
bool ShaderLanguage::_propagate_function_call_sampler_uniform_settings(const StringName &p_name, int p_argument, TextureFilter p_filter, TextureRepeat p_repeat, ShaderNode::Uniform::Hint p_hint) {
Re-allows constants in global space to be initialized with function call
2023-09-13 19:11:12 +03:00
for (int i = 0; i < shader->vfunctions.size(); i++) {
if (shader->vfunctions[i].name == p_name) {
ERR_FAIL_INDEX_V(p_argument, shader->vfunctions[i].function->arguments.size(), false);
FunctionNode::Argument *arg = &shader->vfunctions[i].function->arguments.write[p_argument];
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
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) {
Emit normal_roughness compatibility code in custom functions
2024-07-26 10:45:36 -07:00
// Was checked, verify that filter, repeat, and hint are the same.
Restrict sampler hint validation to only screen texture hints
2024-07-28 22:31:57 -07:00
if (arg->tex_argument_filter == p_filter && arg->tex_argument_repeat == p_repeat && arg->tex_hint == _sanitize_hint(p_hint)) {
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
return true;
} else {
Emit normal_roughness compatibility code in custom functions
2024-07-26 10:45:36 -07:00
_set_error(vformat(RTR("Sampler argument %d of function '%s' called more than once using textures that differ in either filter, repeat, or texture hint 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;
Restrict sampler hint validation to only screen texture hints
2024-07-28 22:31:57 -07:00
arg->tex_hint = _sanitize_hint(p_hint);
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
for (KeyValue<StringName, HashSet<int>> &E : arg->tex_argument_connect) {
Use range iterators for RBSet in most cases
2022-05-18 17:43:40 -06:00
for (const int &F : E.value) {
Emit normal_roughness compatibility code in custom functions
2024-07-26 10:45:36 -07:00
if (!_propagate_function_call_sampler_uniform_settings(E.key, F, p_filter, p_repeat, p_hint)) {
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
Add const lvalue ref to container parameters
2021-08-01 16:47:20 -03:00
bool ShaderLanguage::_propagate_function_call_sampler_builtin_reference(const StringName &p_name, int p_argument, const StringName &p_builtin) {
Re-allows constants in global space to be initialized with function call
2023-09-13 19:11:12 +03:00
for (int i = 0; i < shader->vfunctions.size(); i++) {
if (shader->vfunctions[i].name == p_name) {
ERR_FAIL_INDEX_V(p_argument, shader->vfunctions[i].function->arguments.size(), false);
FunctionNode::Argument *arg = &shader->vfunctions[i].function->arguments.write[p_argument];
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
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;
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
for (KeyValue<StringName, HashSet<int>> &E : arg->tex_argument_connect) {
Use range iterators for RBSet in most cases
2022-05-18 17:43:40 -06:00
for (const int &F : E.value) {
if (!_propagate_function_call_sampler_builtin_reference(E.key, F, 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 {
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
_set_tkpos(pos);
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
int array_size = 0;
Node *expr = _parse_and_reduce_expression(p_block, p_function_info);
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
if (expr) {
Vector<Scalar> values = _get_node_values(p_block, expr);
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
if (!values.is_empty()) {
switch (expr->get_datatype()) {
case TYPE_INT: {
array_size = values[0].sint;
} break;
case TYPE_UINT: {
array_size = (int)values[0].uint;
} break;
default: {
} break;
Refactor size expression parsing for arrays in the shaders
2022-01-15 12:10:26 +03:00
}
Allow declare the shader arrays with a size defined before identifier
2021-10-07 16:00:19 +03:00
}
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
if (r_size_expression != nullptr) {
*r_size_expression = expr;
}
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 basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
_set_error(vformat(RTR("Array size mismatch. Expected %d elements (found %d)."), array_size, an->initializer.size()));
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 basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
_set_error(vformat(RTR("Array size mismatch. Expected %d elements (found %d)."), p_array_size, an->initializer.size()));
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;
}
Fix multiple ternary expressions to be used without parenthesis
2024-07-14 18:08:05 +03:00
ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, const FunctionInfo &p_function_info, const ExpressionInfo *p_previous_expression_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;
Warn users when assigning VERTEX directly to POSITION due to compatibility breakage from reverse z changes
2024-04-12 10:31:36 -07:00
#ifdef DEBUG_ENABLED
bool check_position_write = check_warnings && HAS_WARNING(ShaderWarning::MAGIC_POSITION_WRITE_FLAG);
check_position_write = check_position_write && String(shader_type_identifier) == "spatial" && current_function == "vertex";
#endif
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>();
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
Scalar 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>();
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
Scalar 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>();
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
Scalar v;
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
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>();
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
Scalar 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>();
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
Scalar 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;
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
DataPrecision precision = PRECISION_DEFAULT;
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);
tk = _get_token();
}
datatype = get_token_datatype(tk.type);
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
if (precision != PRECISION_DEFAULT && _validate_precision(datatype, precision) != OK) {
return 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
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
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
if (precision != PRECISION_DEFAULT) {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
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
Reduce and prevent unnecessary random-access to `List` Random-access access to `List` when iterating is `O(n^2)` (`O(n)` when accessing a single element) * Removed subscript operator, in favor of a more explicit `get` * Added conversion from `Iterator` to `ConstIterator` * Remade existing operations into other solutions when applicable
2024-04-15 15:18:34 +02:00
for (List<ShaderLanguage::MemberNode *>::Element *E = pstruct->members.front(); E; E = E->next()) {
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
Reduce and prevent unnecessary random-access to `List` Random-access access to `List` when iterating is `O(n^2)` (`O(n)` when accessing a single element) * Removed subscript operator, in favor of a more explicit `get` * Added conversion from `Iterator` to `ConstIterator` * Remade existing operations into other solutions when applicable
2024-04-15 15:18:34 +02:00
if (E->get()->array_size != 0) {
nexpr = _parse_array_constructor(p_block, p_function_info, E->get()->get_datatype(), E->get()->struct_name, E->get()->array_size);
Fix using post-init shader array constructors
2020-12-26 21:13:24 +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
}
} 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
}
Reduce and prevent unnecessary random-access to `List` Random-access access to `List` when iterating is `O(n^2)` (`O(n)` when accessing a single element) * Removed subscript operator, in favor of a more explicit `get` * Added conversion from `Iterator` to `ConstIterator` * Remade existing operations into other solutions when applicable
2024-04-15 15:18:34 +02:00
if (!_compare_datatypes_in_nodes(E->get(), 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
Reduce and prevent unnecessary random-access to `List` Random-access access to `List` when iterating is `O(n^2)` (`O(n)` when accessing a single element) * Removed subscript operator, in favor of a more explicit `get` * Added conversion from `Iterator` to `ConstIterator` * Remade existing operations into other solutions when applicable
2024-04-15 15:18:34 +02:00
if (E->next()) {
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
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
Re-allows constants in global space to be initialized with function call
2023-09-13 19:11:12 +03:00
// Non-builtin function call is forbidden for constant declaration.
if (is_const_decl) {
if (shader->functions.has(identifier)) {
Fix shader failure when using non-const initializer on a constant
2023-02-01 09:04:10 +03:00
_set_error(RTR("Expected constant expression."));
Re-allows constants in global space to be initialized with function call
2023-09-13 19:11:12 +03:00
return nullptr;
Fix shader failure when using non-const initializer on a constant
2023-02-01 09:04:10 +03:00
}
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
const StringName &rname = identifier;
StringName name = identifier;
Forbid calling of derivative functions in incorrect functions
2024-06-19 18:38:51 +03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
OperatorNode *func = alloc_node<OperatorNode>();
func->op = OP_CALL;
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
VariableNode *funcname = alloc_node<VariableNode>();
funcname->name = name;
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
funcname->rname = name;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
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
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
// Test if function was parsed first.
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
int function_index = -1;
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
for (int i = 0, max_valid_args = 0; i < shader->vfunctions.size(); i++) {
if (!shader->vfunctions[i].callable || shader->vfunctions[i].rname != rname) {
continue;
}
bool found = true;
int valid_args = 0;
// Search for correct overload.
for (int j = 1; j < func->arguments.size(); j++) {
if (j - 1 == shader->vfunctions[i].function->arguments.size()) {
found = false;
break;
}
const FunctionNode::Argument &a = shader->vfunctions[i].function->arguments[j - 1];
Node *b = func->arguments[j];
if (a.type == b->get_datatype() && a.array_size == b->get_array_size()) {
if (a.type == TYPE_STRUCT) {
if (a.struct_name != b->get_datatype_name()) {
found = false;
break;
} else {
valid_args++;
}
} else {
valid_args++;
}
} else {
if (function_overload_count[rname] == 0 && get_scalar_type(a.type) == a.type && b->type == Node::NODE_TYPE_CONSTANT && a.array_size == 0 && convert_constant(static_cast<ConstantNode *>(b), a.type)) {
// Implicit cast if no overloads.
continue;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
}
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
found = false;
break;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
}
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
}
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
// Using the best match index for completion hint if the function not found.
if (valid_args > max_valid_args) {
name = shader->vfunctions[i].name;
funcname->name = name;
max_valid_args = valid_args;
}
if (!found) {
continue;
}
// Add to current function as dependency.
for (int j = 0; j < shader->vfunctions.size(); j++) {
if (shader->vfunctions[j].name == current_function) {
shader->vfunctions.write[j].uses_function.insert(name);
break;
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 11:31:30 -03:00
}
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
name = shader->vfunctions[i].name;
funcname->name = name;
// See if texture arguments must connect.
function_index = i;
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
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 custom function overloading in shading language
2024-05-27 22:16:54 +03:00
if (name != current_function) { // Recursion is not allowed.
// Register call.
if (calls_info.has(name)) {
calls_info[current_function].calls.push_back(&calls_info[name]);
}
bool is_builtin = false;
Allow using stage functions inside custom shader functions
2024-06-27 10:18:44 +03:00
if (is_supported_frag_only_funcs && stages) {
for (const KeyValue<StringName, FunctionInfo> &E : *stages) {
if (E.value.stage_functions.has(name)) {
// Register usage of the restricted stage function.
calls_info[current_function].uses_restricted_items.push_back(Pair<StringName, CallInfo::Item>(name, CallInfo::Item(CallInfo::Item::ITEM_TYPE_BUILTIN, _get_tkpos())));
is_builtin = true;
break;
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
}
}
Allow using stage functions inside custom shader functions
2024-06-27 10:18:44 +03:00
}
if (!is_builtin) {
int idx = 0;
while (frag_only_func_defs[idx].name) {
if (frag_only_func_defs[idx].name == name) {
// If a built-in function not found for the current shader type, then it shouldn't be parsed further.
if (!is_supported_frag_only_funcs) {
_set_error(vformat(RTR("Built-in function '%s' is not supported for the '%s' shader type."), name, shader_type_identifier));
return nullptr;
}
// Register usage of the restricted function.
calls_info[current_function].uses_restricted_items.push_back(Pair<StringName, CallInfo::Item>(name, CallInfo::Item(CallInfo::Item::ITEM_TYPE_BUILTIN, _get_tkpos())));
is_builtin = true;
break;
}
idx++;
}
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
}
// Recursively checks for the restricted function call.
if (is_supported_frag_only_funcs && current_function == "vertex" && stages->has(current_function) && !_validate_restricted_func(name, &calls_info[current_function], is_builtin)) {
return nullptr;
}
}
Forbid passing multiview sampler to the custom function in shaders
2023-01-29 12:14:22 +03:00
bool is_custom_func = false;
if (!_validate_function_call(p_block, p_function_info, func, &func->return_cache, &func->struct_name, &is_custom_func)) {
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
_set_error(vformat(RTR("No matching function found for: '%s'."), String(funcname->rname)));
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
Re-allows constants in global space to be initialized with function call
2023-09-13 19:11:12 +03:00
FunctionNode *call_function = shader->vfunctions[function_index].function;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
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
}
}
[Servers] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:04:18 +02:00
ERR_FAIL_NULL_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;
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (n->type == Node::NODE_TYPE_VARIABLE || n->type == Node::NODE_TYPE_ARRAY) {
Allow pass varyings as out param to the function, when it's possible
2021-12-23 14:04:30 +03:00
StringName varname;
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (n->type == Node::NODE_TYPE_VARIABLE) {
Allow pass varyings as out param to the function, when it's possible
2021-12-23 14:04:30 +03:00
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) {
Fix shader crash when using a varying in separate func before it defined
2024-07-23 21:07:33 +03:00
case ShaderNode::Varying::STAGE_UNKNOWN:
if (is_out_arg) {
error = true;
}
break;
Allow pass varyings as out param to the function, when it's possible
2021-12-23 14:04:30 +03:00
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:
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;
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (n->type == Node::NODE_TYPE_CONSTANT || n->type == Node::NODE_TYPE_OPERATOR || n->type == Node::NODE_TYPE_ARRAY_CONSTRUCT) {
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) {
Allow passing non-variable constant to const function param in shaders
2021-11-19 11:25:23 +03:00
error = true;
}
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
} else if (n->type == Node::NODE_TYPE_ARRAY) {
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
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;
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
} else if (n->type == Node::NODE_TYPE_VARIABLE) {
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
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;
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
} else if (n->type == Node::NODE_TYPE_MEMBER) {
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
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) {
Fix typo in `shader_language.cpp`
2023-10-08 18:55:06 +03:00
_set_error(vformat(RTR("A constant value cannot be passed for the '%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)) {
Make shaderLanguage's parser recognize sampler passed in from array
2024-07-17 12:50:02 +08:00
// Let's see where our argument comes from.
StringName varname;
if (n->type == Node::NODE_TYPE_VARIABLE) {
VariableNode *vn = static_cast<VariableNode *>(n);
varname = vn->name;
} else if (n->type == Node::NODE_TYPE_ARRAY) {
ArrayNode *an = static_cast<ArrayNode *>(n);
varname = an->name;
}
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
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
Forbid passing multiview sampler to the custom function in shaders
2023-01-29 12:14:22 +03:00
if (RendererCompositor::get_singleton()->is_xr_enabled() && is_custom_func) {
ShaderNode::Uniform::Hint hint = u->hint;
if (hint == ShaderNode::Uniform::HINT_DEPTH_TEXTURE || hint == ShaderNode::Uniform::HINT_SCREEN_TEXTURE || hint == ShaderNode::Uniform::HINT_NORMAL_ROUGHNESS_TEXTURE) {
_set_error(vformat(RTR("Unable to pass a multiview texture sampler as a parameter to custom function. Consider to sample it in the main function and then pass the vector result to it."), get_uniform_hint_name(hint)));
return nullptr;
}
}
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
//propagate
Emit normal_roughness compatibility code in custom functions
2024-07-26 10:45:36 -07:00
if (!_propagate_function_call_sampler_uniform_settings(name, i, u->filter, u->repeat, u->hint)) {
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)) {
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
base_function->arguments.write[j].tex_argument_connect[call_function->name] = HashSet<int>();
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 23:16:47 +03:00
}
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
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
if (check_warnings && is_custom_func) {
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
Fix MSVC warnings C4701 and C4703: Potentially uninitialized variable used
2022-09-28 17:05:34 +02:00
DataType data_type = TYPE_MAX;
IdentifierType ident_type = IDENTIFIER_MAX;
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)) {
Remove SCREEN_TEXTURE, DEPTH_TEXTURE, and NORMAL_ROUGHNESS_TEXTURE in favour of texture hints
2023-01-05 11:55:59 -08:00
if (identifier == "SCREEN_TEXTURE" || identifier == "DEPTH_TEXTURE" || identifier == "NORMAL_ROUGHNESS_TEXTURE") {
String name = String(identifier);
String name_lower = name.to_lower();
Fix type in hint when using removed built-in textures
2023-01-20 22:06:51 -06:00
_set_error(vformat(RTR("%s has been removed in favor of using hint_%s with a uniform.\nTo continue with minimal code changes add 'uniform sampler2D %s : hint_%s, filter_linear_mipmap;' near the top of your shader."), name, name_lower, name, name_lower));
Remove SCREEN_TEXTURE, DEPTH_TEXTURE, and NORMAL_ROUGHNESS_TEXTURE in favour of texture hints
2023-01-05 11:55:59 -08:00
return nullptr;
}
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
}
Fix shader failure when using non-const initializer on a constant
2023-02-01 09:04:10 +03:00
if (is_const_decl && !is_const) {
_set_error(RTR("Expected constant expression."));
return nullptr;
}
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
Allow using integer varyings with `flat` interpolation modifier
2022-08-24 12:41:42 +03:00
ShaderNode::Varying &var = shader->varyings[identifier];
Fix shader crash when using a varying in separate func before it defined
2024-07-23 21:07:33 +03:00
calls_info[current_function].uses_restricted_items.push_back(Pair<StringName, CallInfo::Item>(identifier, CallInfo::Item(CallInfo::Item::ITEM_TYPE_VARYING, prev_pos)));
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 {
Fix shader crash when using varyings with non-`flat` integer type
2024-08-18 10:19:16 +03:00
if (var.stage == ShaderNode::Varying::STAGE_UNKNOWN && var.type < TYPE_INT) {
if (current_function == varying_function_names.vertex) {
_set_error(vformat(RTR("Varying with '%s' data type may only be used in the '%s' function."), get_datatype_name(var.type), "fragment"));
} else {
_set_error(vformat(RTR("Varying '%s' must be assigned in the '%s' function first."), identifier, "fragment"));
}
return nullptr;
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
}
Warn users when assigning VERTEX directly to POSITION due to compatibility breakage from reverse z changes
2024-04-12 10:31:36 -07:00
#ifdef DEBUG_ENABLED
if (check_position_write && ident_type == IDENTIFIER_BUILTIN_VAR) {
if (String(identifier) == "POSITION") {
// Check if the user wrote "POSITION = vec4(VERTEX," and warn if they did.
TkPos prev_pos = _get_tkpos();
if (_get_token().type == TK_OP_ASSIGN &&
_get_token().type == TK_TYPE_VEC4 &&
_get_token().type == TK_PARENTHESIS_OPEN &&
_get_token().text == "VERTEX" &&
_get_token().type == TK_COMMA) {
_add_line_warning(ShaderWarning::MAGIC_POSITION_WRITE);
}
// Reset the position so compiling can continue as normal.
_set_tkpos(prev_pos);
}
}
#endif
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;
Fix shader crashing when attempting to access `length()` at global space
2022-04-01 08:39:29 +03:00
if (p_block != nullptr) {
p_block->block_tag = SubClassTag::TAG_ARRAY;
}
Fix shader crash when passing array.length to functions and similar cases
2021-10-05 09:47:50 +03:00
call_expression = _parse_and_reduce_expression(p_block, p_function_info);
Fix shader crashing when attempting to access `length()` at global space
2022-04-01 08:39:29 +03:00
if (p_block != nullptr) {
p_block->block_tag = SubClassTag::TAG_GLOBAL;
}
Fix shader crash when passing array.length to functions and similar cases
2021-10-05 09:47:50 +03:00
if (!call_expression) {
return nullptr;
}
} 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
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (index_expression->type == Node::NODE_TYPE_CONSTANT) {
Fix some issues found by cppcheck.
2022-04-05 13:40:26 +03:00
ConstantNode *cnode = static_cast<ConstantNode *>(index_expression);
Fix shader crash when passing array.length to functions and similar cases
2021-10-05 09:47:50 +03:00
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
}
[Servers] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:04:18 +02:00
ERR_FAIL_NULL_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) {
Fix incorrect keyword completion after period in shader editor
2022-05-20 18:38:06 +03:00
#ifdef DEBUG_ENABLED
uint32_t prev_keyword_completion_context = keyword_completion_context;
keyword_completion_context = CF_UNSPECIFIED;
#endif
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;
Fix shader crashing when attempting to access `length()` at global space
2022-04-01 08:39:29 +03:00
if (p_block != nullptr) {
p_block->block_tag = SubClassTag::TAG_ARRAY;
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
Node *call_expression = _parse_and_reduce_expression(p_block, p_function_info);
Fix shader crashing when attempting to access `length()` at global space
2022-04-01 08:39:29 +03:00
if (p_block != nullptr) {
p_block->block_tag = SubClassTag::TAG_GLOBAL;
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
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
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
RBSet<char> position_symbols;
RBSet<char> color_symbols;
RBSet<char> texture_symbols;
Fix bugs in shader swizzling
2020-02-13 17:50:20 +03:00
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;
Fix shader crashing when attempting to access `length()` at global space
2022-04-01 08:39:29 +03:00
if (p_block != nullptr) {
p_block->block_tag = SubClassTag::TAG_ARRAY;
}
Fix incorrect parsing array's `length()` at return statement in shader
2022-04-03 09:52:41 +03:00
mn->call_expression = _parse_and_reduce_expression(p_block, p_function_info);
Fix shader crashing when attempting to access `length()` at global space
2022-04-01 08:39:29 +03:00
if (p_block != nullptr) {
p_block->block_tag = SubClassTag::TAG_GLOBAL;
}
Fix incorrect parsing array's `length()` at return statement in shader
2022-04-03 09:52:41 +03:00
if (!mn->call_expression) {
Implements length() shader function for arrays in structs
2021-05-19 21:50:11 +03:00
return nullptr;
}
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
}
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (index_expression->type == Node::NODE_TYPE_CONSTANT) {
Fix some issues found by cppcheck.
2022-04-05 13:40:26 +03:00
ConstantNode *cnode = static_cast<ConstantNode *>(index_expression);
Added support for arrays as shader struct members
2020-02-11 22:03:04 +03:00
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
Fix incorrect keyword completion after period in shader editor
2022-05-20 18:38:06 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = prev_keyword_completion_context;
#endif
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on 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) {
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (index->type == Node::NODE_TYPE_CONSTANT) {
Fix editor crash if passing index as variable to function parameter
2021-07-26 17:40:15 +03:00
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:
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (index->type == Node::NODE_TYPE_CONSTANT) {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
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:
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (index->type == Node::NODE_TYPE_CONSTANT) {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
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:
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (index->type == Node::NODE_TYPE_CONSTANT) {
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
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
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
if (!_validate_operator(p_block, 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
Fix crash at using increment op for varying in `light` shader function
2025-02-15 17:37:18 +03:00
String error;
if (!_validate_assign(expr, p_function_info, &error)) {
_set_error(error);
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
Fix multiple ternary expressions to be used without parenthesis
2024-07-14 18:08:05 +03:00
if (p_previous_expression_info != nullptr && tk.type == p_previous_expression_info->tt_break && !p_previous_expression_info->is_last_expr) {
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 (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
Fix multiple ternary expressions to be used without parenthesis
2024-07-14 18:08:05 +03:00
if (o.op == OP_SELECT_IF) {
ExpressionInfo info;
info.expression = &expression;
info.tt_break = TK_COLON;
expr = _parse_and_reduce_expression(p_block, p_function_info, &info);
if (!expr) {
return nullptr;
}
expression.push_back({ true, { OP_SELECT_ELSE } });
if (p_previous_expression_info != nullptr) {
info.is_last_expr = p_previous_expression_info->is_last_expr;
} else {
info.is_last_expr = true;
}
expr = _parse_and_reduce_expression(p_block, p_function_info, &info);
if (!expr) {
return nullptr;
}
break;
}
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;
Fix crash at using increment op for varying in `light` shader function
2025-02-15 17:37:18 +03:00
String error;
if ((op->op == OP_INCREMENT || op->op == OP_DECREMENT) && !_validate_assign(expression[i + 1].node, p_function_info, &error)) {
_set_error(error);
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
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
if (!_validate_operator(p_block, op, &op->return_cache, &op->return_array_size)) {
if (error_set) {
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
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;
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
if (!_validate_operator(p_block, op, &op->return_cache, &op->return_array_size)) {
if (error_set) {
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
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)) {
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
if (p_block && expression[next_op - 1].node->type == Node::NODE_TYPE_VARIABLE) {
VariableNode *vn = static_cast<VariableNode *>(expression[next_op - 1].node);
p_block->use_op_eval = vn->is_const;
}
Manually fix, merge and close #15168
2018-07-29 12:17:45 -03:00
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
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
if (!_validate_operator(p_block, op, &op->return_cache, &op->return_array_size)) {
if (error_set) {
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
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
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
if (p_block) {
p_block->use_op_eval = true;
}
Fix multiple ternary expressions to be used without parenthesis
2024-07-14 18:08:05 +03:00
if (p_previous_expression_info != nullptr) {
p_previous_expression_info->expression->push_back(expression[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 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) {
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (p_node->type != Node::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) {
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
ERR_FAIL_COND_V(op->arguments[0]->type != Node::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
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
Vector<Scalar> 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
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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]);
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (op->arguments[i]->type == Node::NODE_TYPE_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
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) {
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
Scalar 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) {
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
Scalar value = values[0];
Scalar zero;
Fix handling of shader constants that caused crash, closes #15166
2018-08-31 13:11:13 +02:00
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 {
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
Scalar 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]);
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (op->arguments[0]->type == Node::NODE_TYPE_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
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
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
Vector<Scalar> 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++) {
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
Scalar 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
}
Fix multiple ternary expressions to be used without parenthesis
2024-07-14 18:08:05 +03:00
ShaderLanguage::Node *ShaderLanguage::_parse_and_reduce_expression(BlockNode *p_block, const FunctionInfo &p_function_info, const ExpressionInfo *p_previous_expression_info) {
ShaderLanguage::Node *expr = _parse_expression(p_block, p_function_info, p_previous_expression_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();
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on 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();
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
Token next;
#endif // DEBUG_ENABLED
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
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
uint32_t precision_flag = CF_PRECISION_MODIFIER;
keyword_completion_context = CF_DATATYPE;
if (!is_token_precision(tk.type)) {
if (!is_struct) {
keyword_completion_context |= precision_flag;
}
}
#endif // DEBUG_ENABLED
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.
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
if (keyword_completion_context & precision_flag) {
keyword_completion_context ^= precision_flag;
}
#endif // DEBUG_ENABLED
}
#ifdef DEBUG_ENABLED
if (is_const && _lookup_next(next)) {
if (is_token_precision(next.type)) {
keyword_completion_context = CF_UNSPECIFIED;
}
if (is_token_datatype(next.type)) {
keyword_completion_context ^= CF_DATATYPE;
}
}
#endif // DEBUG_ENABLED
if (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_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
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
if (precision != PRECISION_DEFAULT && _validate_precision(type, precision) != OK) {
return ERR_PARSE_ERROR;
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_UNSPECIFIED;
#endif // DEBUG_ENABLED
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)) {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
used_local_vars.insert(func_name, HashMap<StringName, Usage>());
Added a shader warning about unused local variable
2021-06-29 14:34:54 +03:00
}
used_local_vars[func_name].insert(name, Usage(tk_line));
}
}
#endif // DEBUG_ENABLED
Fix shader failure when using non-const initializer on a constant
2023-02-01 09:04:10 +03:00
is_const_decl = is_const;
Added a shader warning about unused local variable
2021-06-29 14:34:54 +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
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) {
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();
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
if (var.type == DataType::TYPE_BOOL) {
keyword_completion_context = CF_BOOLEAN;
}
#endif // DEBUG_ENABLED
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) {
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 (!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
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
if (precision2 != PRECISION_DEFAULT && _validate_precision(type2, precision2) != OK) {
return ERR_PARSE_ERROR;
}
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
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (is_const && n->type == Node::NODE_TYPE_OPERATOR && static_cast<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 basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
_set_error(vformat(RTR("Array size mismatch. Expected %d elements (found %d)."), var.array_size, decl.initializer.size()));
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();
Fix editor crash when shader has incorrect global array declaration
2024-07-23 17:52:08 +08:00
} else {
_set_expected_error("(");
return ERR_PARSE_ERROR;
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) {
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
p_block->use_op_eval = is_const;
// 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
}
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (is_const && n->type == Node::NODE_TYPE_OPERATOR && static_cast<OperatorNode *>(n)->op == OP_CALL) {
Fix some issues found by cppcheck.
2022-04-05 13:40:26 +03:00
OperatorNode *op = static_cast<OperatorNode *>(n);
Fix shader handle constant expressions in function call
2021-04-27 14:58:32 +03:00
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
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
if (is_const) {
var.values = n->get_values();
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +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())) {
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 failure when using non-const initializer on a constant
2023-02-01 09:04:10 +03:00
is_const_decl = false;
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
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_BLOCK;
#endif // DEBUG_ENABLED
Fix some issues found by cppcheck.
2022-04-05 13:40:26 +03:00
p_block->statements.push_back(static_cast<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;
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_IF_DECL;
#endif // DEBUG_ENABLED
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
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_BLOCK;
#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
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) {
// 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
}
Fix shader incorrectly expects `int` on `uint` and vice-versa in cases
2024-08-13 11:38:41 +03:00
const ShaderLanguage::DataType data_type = n->get_datatype();
if (data_type != TYPE_INT && data_type != TYPE_UINT) {
_set_error(RTR("Expected an integer or unsigned integer expression."));
return ERR_PARSE_ERROR;
Implements switch to shaders
2019-08-14 14:22:25 +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(")");
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;
Fix shader incorrectly expects `int` on `uint` and vice-versa in cases
2024-08-13 11:38:41 +03:00
switch_block->expected_type = data_type;
Implements switch to shaders
2019-08-14 14:22:25 +03:00
cf->expressions.push_back(n);
cf->blocks.push_back(switch_block);
p_block->statements.push_back(cf);
Fix shader incorrectly expects `int` on `uint` and vice-versa in cases
2024-08-13 11:38:41 +03:00
pos = _get_tkpos();
tk = _get_token();
TokenType prev_type;
if (tk.type == TK_CF_CASE || tk.type == TK_CF_DEFAULT) {
prev_type = tk.type;
_set_tkpos(pos);
} else {
_set_expected_error("case", "default");
return ERR_PARSE_ERROR;
}
Implements switch to shaders
2019-08-14 14:22:25 +03:00
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 {
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;
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) {
Fix shader incorrectly expects `int` on `uint` and vice-versa in cases
2024-08-13 11:38:41 +03:00
DataType data_type;
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
bool is_const;
Fix shader incorrectly expects `int` on `uint` and vice-versa in cases
2024-08-13 11:38:41 +03:00
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
_find_identifier(p_block, false, p_function_info, tk.text, &data_type, nullptr, &is_const);
Fix shader incorrectly expects `int` on `uint` and vice-versa in cases
2024-08-13 11:38:41 +03:00
if (is_const && data_type == p_block->expected_type) {
correct_constant_expression = true;
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
}
}
Fix shader incorrectly expects `int` on `uint` and vice-versa in cases
2024-08-13 11:38:41 +03:00
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
if (!correct_constant_expression) {
Fix shader incorrectly expects `int` on `uint` and vice-versa in cases
2024-08-13 11:38:41 +03:00
if (p_block->expected_type == TYPE_UINT) {
_set_error(RTR("Expected an unsigned integer constant."));
} else {
_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;
Fix shader incorrectly expects `int` on `uint` and vice-versa in cases
2024-08-13 11:38:41 +03:00
{
Vector<Scalar> v;
DataType data_type;
_find_identifier(p_block, false, p_function_info, vn->name, &data_type, nullptr, nullptr, nullptr, nullptr, &v);
if (data_type == TYPE_INT) {
if (p_block->constants.has(v[0].sint)) {
_set_error(vformat(RTR("Duplicated case label: %d."), v[0].sint));
return ERR_PARSE_ERROR;
}
p_block->constants.insert(v[0].sint);
} else {
if (p_block->constants.has(v[0].uint)) {
_set_error(vformat(RTR("Duplicated case label: %d."), v[0].uint));
return ERR_PARSE_ERROR;
}
p_block->constants.insert(v[0].uint);
}
}
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
n = vn;
} else {
Fix shader incorrectly expects `int` on `uint` and vice-versa in cases
2024-08-13 11:38:41 +03:00
ConstantNode *cn = alloc_node<ConstantNode>();
Add basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
Scalar v;
Fix shader incorrectly expects `int` on `uint` and vice-versa in cases
2024-08-13 11:38:41 +03:00
if (p_block->expected_type == TYPE_UINT) {
if (tk.type != TK_UINT_CONSTANT) {
_set_error(RTR("Expected an unsigned integer constant."));
return ERR_PARSE_ERROR;
}
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
v.uint = (uint32_t)tk.constant;
Fix shader incorrectly expects `int` on `uint` and vice-versa in cases
2024-08-13 11:38:41 +03:00
if (p_block->constants.has(v.uint)) {
_set_error(vformat(RTR("Duplicated case label: %d."), v.uint));
return ERR_PARSE_ERROR;
}
p_block->constants.insert(v.uint);
cn->datatype = TYPE_UINT;
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
} else {
Fix shader incorrectly expects `int` on `uint` and vice-versa in cases
2024-08-13 11:38:41 +03:00
if (tk.type != TK_INT_CONSTANT) {
_set_error(RTR("Expected an integer constant."));
return ERR_PARSE_ERROR;
}
v.sint = (int32_t)tk.constant * sign;
if (p_block->constants.has(v.sint)) {
_set_error(vformat(RTR("Duplicated case label: %d."), v.sint));
return ERR_PARSE_ERROR;
}
p_block->constants.insert(v.sint);
cn->datatype = TYPE_INT;
Refactor constant suffix parsing in a shader
2021-12-03 22:05:23 +03:00
}
Added support for constants in shader `case` and array size declaration
2020-12-16 20:13:56 +03:00
cn->values.push_back(v);
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);
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_DATATYPE;
#endif // DEBUG_ENABLED
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
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_UNSPECIFIED;
#endif // DEBUG_ENABLED
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);
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_BLOCK;
#endif // DEBUG_ENABLED
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;
}
Code simplifications found by cppcheck They are based on: - Boolean arithmetic simplifications - setting variables that are not accessed - constant variables
2022-10-28 01:39:28 +02:00
if (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 {
Fix shader crash when return a void function call
2024-09-26 11:20:39 +03:00
if (b->parent_function->return_type == TYPE_VOID) {
_set_error(vformat(RTR("'%s' function cannot return a value."), "void"));
return ERR_PARSE_ERROR;
}
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
_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
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
if (b->parent_function->return_type == DataType::TYPE_BOOL) {
keyword_completion_context = CF_BOOLEAN;
}
#endif // DEBUG_ENABLED
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;
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
if (b->parent_function->return_type == DataType::TYPE_BOOL) {
keyword_completion_context = CF_BLOCK;
}
#endif // DEBUG_ENABLED
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
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) {
Allow usage of `discard` inside custom shader functions
2024-06-25 15:39:21 +03:00
if (!is_discard_supported) {
_set_error(vformat(RTR("Use of '%s' is not supported for the '%s' shader type."), "discard", shader_type_identifier));
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
//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) {
Allow usage of `discard` inside custom shader functions
2024-06-25 15:39:21 +03:00
_set_error(vformat(RTR("'%s' cannot be used within the '%s' processor function."), "discard", b->parent_function->name));
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();
Allow usage of `discard` inside custom shader functions
2024-06-25 15:39:21 +03:00
calls_info[b->parent_function->name].uses_restricted_items.push_back(Pair<StringName, CallInfo::Item>("discard", CallInfo::Item(CallInfo::Item::ITEM_TYPE_BUILTIN, pos)));
removed DISCARD built in variable, replaced by actual discard GLSL instruction, fixes #9677
2017-08-29 10:14:07 -03:00
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
}
Fix middle expression of `for` loop to accept not only operators
2024-08-15 10:29:19 +03:00
is_condition = expr->get_datatype() == TYPE_BOOL;
Allow multiple declarations in for loop in a shader
2022-02-03 11:13:20 +03:00
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (expr->type == Node::NODE_TYPE_OPERATOR) {
Allow multiple declarations in for loop in a shader
2022-02-03 11:13:20 +03:00
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) {
Fix middle expression of `for` loop to accept not only operators
2024-08-15 10:29:19 +03:00
_set_error(RTR("The middle expression is expected to have a boolean data type."));
Few more fixes to for loop in shaders
2022-02-04 08:40:42 +03:00
return ERR_PARSE_ERROR;
}
Fix shader crash when the comma used in `for` loop as a trailing
2024-08-10 11:07:53 +03:00
tk = _peek();
if (tk.type == TK_SEMICOLON) {
_set_error(vformat(RTR("Expected expression, found: '%s'."), get_token_text(tk)));
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) {
Fix shader crash when the comma used in `for` loop as a trailing
2024-08-10 11:07:53 +03:00
tk = _peek();
if (tk.type == TK_PARENTHESIS_CLOSE) {
_set_error(vformat(RTR("Expected expression, found: '%s'."), get_token_text(tk)));
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_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) {
Fix middle expression of `for` loop to accept not only operators
2024-08-15 10:29:19 +03:00
_set_error(RTR("The middle expression is expected to have a boolean data type."));
Few more fixes to for loop in shaders
2022-02-04 08:40: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
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;
}
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
String ShaderLanguage::_get_shader_type_list(const HashSet<String> &p_shader_types) const {
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
// Return a list of shader types as an human-readable string
String valid_types;
Use range iterators for RBSet in most cases
2022-05-18 17:43:40 -06:00
for (const String &E : p_shader_types) {
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 += ", ";
}
Use range iterators for RBSet in most cases
2022-05-18 17:43:40 -06:00
valid_types += "'" + E + "'";
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
}
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 "";
}
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
Error ShaderLanguage::_validate_precision(DataType p_type, DataPrecision p_precision) {
switch (p_type) {
case TYPE_STRUCT: {
_set_error(RTR("The precision modifier cannot be used on structs."));
return FAILED;
} break;
case TYPE_BOOL:
case TYPE_BVEC2:
case TYPE_BVEC3:
case TYPE_BVEC4: {
_set_error(RTR("The precision modifier cannot be used on boolean types."));
return FAILED;
} break;
default:
break;
}
return OK;
}
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
Error ShaderLanguage::_parse_shader(const HashMap<StringName, FunctionInfo> &p_functions, const Vector<ModeInfo> &p_render_modes, const HashSet<String> &p_shader_types) {
Adding shader preprocessor support Co-authored-by: TheOrangeDay <6472143+TheOrangeDay@users.noreply.github.com>
2022-03-08 13:39:16 +03:00
Token tk;
Break futher shader compilation after missing `;` after`shader_type`
2021-08-11 12:37:59 +03:00
TkPos prev_pos;
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
Token next;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
if (!is_shader_inc) {
Remove `shader_type` from completion (when it does not need any more)
2022-09-07 16:19:36 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_SHADER_TYPE;
#endif // DEBUG_ENABLED
Adding shader preprocessor support Co-authored-by: TheOrangeDay <6472143+TheOrangeDay@users.noreply.github.com>
2022-03-08 13:39:16 +03:00
tk = _get_token();
if (tk.type != TK_SHADER_TYPE) {
_set_error(vformat(RTR("Expected '%s' at the beginning of shader. Valid types are: %s."), "shader_type", _get_shader_type_list(p_shader_types)));
return ERR_PARSE_ERROR;
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
Adding shader preprocessor support Co-authored-by: TheOrangeDay <6472143+TheOrangeDay@users.noreply.github.com>
2022-03-08 13:39:16 +03:00
keyword_completion_context = CF_UNSPECIFIED;
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#endif // DEBUG_ENABLED
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
Adding shader preprocessor support Co-authored-by: TheOrangeDay <6472143+TheOrangeDay@users.noreply.github.com>
2022-03-08 13:39:16 +03:00
_get_completable_identifier(nullptr, COMPLETION_SHADER_TYPE, shader_type_identifier);
if (shader_type_identifier == StringName()) {
_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)));
return ERR_PARSE_ERROR;
}
if (!p_shader_types.has(shader_type_identifier)) {
_set_error(vformat(RTR("Invalid shader type. Valid types are: %s"), _get_shader_type_list(p_shader_types)));
return ERR_PARSE_ERROR;
}
prev_pos = _get_tkpos();
tk = _get_token();
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
Adding shader preprocessor support Co-authored-by: TheOrangeDay <6472143+TheOrangeDay@users.noreply.github.com>
2022-03-08 13:39:16 +03:00
if (tk.type != TK_SEMICOLON) {
_set_tkpos(prev_pos);
_set_expected_after_error(";", "shader_type " + String(shader_type_identifier));
return ERR_PARSE_ERROR;
}
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_GLOBAL_SPACE;
#endif // DEBUG_ENABLED
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;
Fix texture samplers to not being last in the property list
2024-07-26 12:19:13 +03:00
int prop_index = 0;
Add a shader warning when the uniform buffer limit is exceeded
2021-12-22 10:15:12 +03:00
#ifdef DEBUG_ENABLED
Fix device limit exceeding for uniform buffer
2022-03-10 23:13:27 +05:30
uint64_t uniform_buffer_size = 0;
Validate varying count when compiling shaders This avoids crashing on devices when a number of varyings greater than the device limit is used. For now this accurately prints an error when compiling the shader, but the error text only pops up in the editor if the number of user varyings is above the limit.
2025-02-12 16:12:46 -08:00
uint64_t max_uniform_buffer_size = 65536;
Enhances a shader uniform limit warning
2022-01-08 18:34:00 +03:00
int uniform_buffer_exceeded_line = -1;
Validate varying count when compiling shaders This avoids crashing on devices when a number of varyings greater than the device limit is used. For now this accurately prints an error when compiling the shader, but the error text only pops up in the editor if the number of user varyings is above the limit.
2025-02-12 16:12:46 -08:00
bool check_device_limit_warnings = check_warnings && HAS_WARNING(ShaderWarning::DEVICE_LIMIT_EXCEEDED_FLAG);
// Can be false for internal shaders created in the process of initializing the engine.
if (RSG::utilities) {
max_uniform_buffer_size = RSG::utilities->get_maximum_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;
Allow usage of `discard` inside custom shader functions
2024-06-25 15:39:21 +03:00
is_discard_supported = shader_type_identifier == "canvas_item" || shader_type_identifier == "spatial";
is_supported_frag_only_funcs = is_discard_supported || shader_type_identifier == "sky";
Forbid calling of derivative functions in incorrect functions
2024-06-19 18:38:51 +03:00
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
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<String, String> defined_modes;
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +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 (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: {
Exclude incorrect completion options for `render_mode` in shaders
2023-05-15 07:38:20 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_UNSPECIFIED;
#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
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;
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
if (is_shader_inc) {
for (int i = 0; i < RenderingServer::SHADER_MAX; i++) {
const Vector<ModeInfo> modes = ShaderTypes::get_singleton()->get_modes(RenderingServer::ShaderMode(i));
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
for (int j = 0; j < modes.size(); j++) {
const ModeInfo &info = modes[j];
const String name = String(info.name);
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
if (smode.begins_with(name)) {
if (!info.options.is_empty()) {
if (info.options.has(smode.substr(name.length() + 1))) {
found = true;
if (defined_modes.has(name)) {
_set_error(vformat(RTR("Redefinition of render mode: '%s'. The '%s' mode has already been set to '%s'."), smode, name, defined_modes[name]));
return ERR_PARSE_ERROR;
}
defined_modes.insert(name, smode);
break;
}
} else {
found = true;
break;
}
}
}
}
} else {
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()) {
if (info.options.has(smode.substr(name.length() + 1))) {
found = true;
if (defined_modes.has(name)) {
_set_error(vformat(RTR("Redefinition of render mode: '%s'. The '%s' mode has already been set to '%s'."), smode, name, defined_modes[name]));
return ERR_PARSE_ERROR;
}
defined_modes.insert(name, smode);
break;
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
}
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
} else {
found = true;
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
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;
}
}
Exclude incorrect completion options for `render_mode` in shaders
2023-05-15 07:38:20 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_GLOBAL_SPACE;
#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
} break;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
case TK_STRUCT: {
ShaderNode::Struct st;
DataType type;
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_UNSPECIFIED;
#endif // DEBUG_ENABLED
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
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;
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
HashSet<String> member_names;
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
while (true) { // variables list
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_DATATYPE | CF_PRECISION_MODIFIER;
#endif // DEBUG_ENABLED
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
tk = _get_token();
if (tk.type == TK_CURLY_BRACKET_CLOSE) {
break;
}
StringName struct_name = "";
bool struct_dt = false;
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
DataPrecision precision = PRECISION_DEFAULT;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
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);
tk = _get_token();
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context ^= CF_PRECISION_MODIFIER;
#endif // DEBUG_ENABLED
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
}
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 (!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);
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
if (precision != PRECISION_DEFAULT && _validate_precision(type, precision) != OK) {
return ERR_PARSE_ERROR;
}
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;
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_UNSPECIFIED;
#endif // DEBUG_ENABLED
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;
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_UNSPECIFIED;
#endif // DEBUG_ENABLED
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
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;
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_GLOBAL_SPACE;
#endif // DEBUG_ENABLED
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
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: {
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_UNIFORM_KEYWORD;
if (_lookup_next(next)) {
if (next.type == TK_UNIFORM) {
keyword_completion_context ^= CF_UNIFORM_KEYWORD;
}
}
#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
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: {
Fix global uniforms parsed as instance uniform
2022-11-17 17:18:20 -05:00
if (tk.type == TK_INSTANCE) {
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
Fix global uniforms parsed as instance uniform
2022-11-17 17:18:20 -05:00
keyword_completion_context = CF_UNIFORM_KEYWORD;
if (_lookup_next(next)) {
if (next.type == TK_UNIFORM) {
keyword_completion_context ^= CF_UNIFORM_KEYWORD;
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
}
#endif // DEBUG_ENABLED
Implement 2D instance shader parameters Co-authored-by: kobewi <kobewi4e@gmail.com> Co-authored-by: yesfish <huwpascoe@users.noreply.github.com> Co-authored-by: Álex Román Núñez <eirexe123@gmail.com>
2023-05-29 00:23:00 +02:00
if (shader_type_identifier != StringName() && String(shader_type_identifier) != "spatial" && String(shader_type_identifier) != "canvas_item") {
Fix global uniforms parsed as instance uniform
2022-11-17 17:18:20 -05:00
_set_error(vformat(RTR("Uniform instances are not yet implemented for '%s' shaders."), shader_type_identifier));
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;
}
Fix global uniforms parsed as instance uniform
2022-11-17 17:18:20 -05:00
if (uniform_scope == ShaderNode::Uniform::SCOPE_LOCAL) {
tk = _get_token();
if (tk.type != TK_UNIFORM) {
_set_expected_after_error("uniform", "instance");
return ERR_PARSE_ERROR;
}
uniform_scope = ShaderNode::Uniform::SCOPE_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
}
};
[[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: {
Refactor shader hints
2022-05-31 11:44:44 +03:00
bool is_uniform = tk.type == TK_UNIFORM;
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_UNSPECIFIED;
#endif // DEBUG_ENABLED
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (!is_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;
}
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on 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;
Fix shader crash when using boolean type for vertex->fragment varyings
2022-12-22 23:19:30 +03:00
DataInterpolation interpolation = INTERPOLATION_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
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();
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
bool temp_error = false;
uint32_t datatype_flag;
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (!is_uniform) {
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
datatype_flag = CF_VARYING_TYPE;
keyword_completion_context = CF_INTERPOLATION_QUALIFIER | CF_PRECISION_MODIFIER | datatype_flag;
if (_lookup_next(next)) {
if (is_token_interpolation(next.type)) {
keyword_completion_context ^= (CF_INTERPOLATION_QUALIFIER | datatype_flag);
} else if (is_token_precision(next.type)) {
keyword_completion_context ^= (CF_PRECISION_MODIFIER | datatype_flag);
} else if (is_token_datatype(next.type)) {
keyword_completion_context ^= datatype_flag;
}
}
} else {
datatype_flag = CF_UNIFORM_TYPE;
keyword_completion_context = CF_PRECISION_MODIFIER | datatype_flag;
if (_lookup_next(next)) {
if (is_token_precision(next.type)) {
keyword_completion_context ^= (CF_PRECISION_MODIFIER | datatype_flag);
} else if (is_token_datatype(next.type)) {
keyword_completion_context ^= datatype_flag;
}
}
}
#endif // DEBUG_ENABLED
Added interpolation modifiers to shaderlang
2017-11-27 16:47:46 +01:00
if (is_token_interpolation(tk.type)) {
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (is_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."));
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
temp_error = true;
#else
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
return ERR_PARSE_ERROR;
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#endif // DEBUG_ENABLED
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
}
Added interpolation modifiers to shaderlang
2017-11-27 16:47:46 +01:00
interpolation = get_token_interpolation(tk.type);
tk = _get_token();
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
if (keyword_completion_context & CF_INTERPOLATION_QUALIFIER) {
keyword_completion_context ^= CF_INTERPOLATION_QUALIFIER;
}
if (_lookup_next(next)) {
if (is_token_precision(next.type)) {
keyword_completion_context ^= CF_PRECISION_MODIFIER;
} else if (is_token_datatype(next.type)) {
keyword_completion_context ^= datatype_flag;
}
}
if (temp_error) {
return ERR_PARSE_ERROR;
}
#endif // DEBUG_ENABLED
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
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();
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
if (keyword_completion_context & CF_INTERPOLATION_QUALIFIER) {
keyword_completion_context ^= CF_INTERPOLATION_QUALIFIER;
}
if (keyword_completion_context & CF_PRECISION_MODIFIER) {
keyword_completion_context ^= CF_PRECISION_MODIFIER;
}
if (_lookup_next(next)) {
if (is_token_datatype(next.type)) {
keyword_completion_context = CF_UNSPECIFIED;
}
}
#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
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
if (shader->structs.has(tk.text)) {
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (is_uniform) {
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 {
Improve some editor strings for localization
2023-02-09 17:01:32 +08:00
_set_error(vformat(RTR("The '%s' data type is 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
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
if (precision != PRECISION_DEFAULT && _validate_precision(type, precision) != OK) {
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 (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
Fix shader crash when using boolean type for vertex->fragment varyings
2022-12-22 23:19:30 +03:00
if (!is_uniform && interpolation != INTERPOLATION_DEFAULT && type < TYPE_INT) {
_set_error(vformat(RTR("Interpolation modifier '%s' cannot be used with boolean types."), get_interpolation_name(interpolation)));
return ERR_PARSE_ERROR;
}
Allow using integer varyings with `flat` interpolation modifier
2022-08-24 12:41:42 +03:00
if (!is_uniform && type > TYPE_MAT4) {
_set_error(RTR("Invalid data type for 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 ERR_PARSE_ERROR;
}
Added additional token checks for the shader if..else.. statement. Fixes issue #2791.
2015-11-22 13:49:58 +08:00
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_UNSPECIFIED;
#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
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;
}
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (is_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
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
DataType gvtype = global_shader_uniform_get_type_func(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
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;
}
}
Refactor shader hints
2022-05-31 11:44:44 +03:00
ShaderNode::Uniform uniform;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Refactor shader hints
2022-05-31 11:44:44 +03:00
uniform.type = type;
uniform.scope = uniform_scope;
uniform.precision = precision;
uniform.array_size = array_size;
Implement shader uniform groups/subgroups
2022-07-13 11:31:27 +03:00
uniform.group = current_uniform_group_name;
uniform.subgroup = current_uniform_subgroup_name;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
tk = _get_token();
if (tk.type == TK_BRACKET_OPEN) {
Refactor shader hints
2022-05-31 11:44:44 +03:00
Error error = _parse_array_size(nullptr, constants, true, nullptr, &uniform.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) {
Fixed shader error message for instance qualifier Moved argument from RTR to vformat. Message is now similar to uniform-arrays-error further down.
2022-02-09 21:32:09 +01:00
_set_error(vformat(RTR("The '%s' qualifier is not supported for sampler types."), "SCOPE_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;
}
Refactor shader hints
2022-05-31 11:44:44 +03:00
uniform.texture_order = texture_uniforms++;
uniform.texture_binding = texture_binding;
if (uniform.array_size > 0) {
texture_binding += uniform.array_size;
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
} else {
++texture_binding;
}
Refactor shader hints
2022-05-31 11:44:44 +03:00
uniform.order = -1;
Fix texture samplers to not being last in the property list
2024-07-26 12:19:13 +03:00
uniform.prop_order = prop_index++;
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)) {
Fixed shader error message for instance qualifier Moved argument from RTR to vformat. Message is now similar to uniform-arrays-error further down.
2022-02-09 21:32:09 +01:00
_set_error(vformat(RTR("The '%s' qualifier is not supported for matrix types."), "SCOPE_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;
}
Refactor shader hints
2022-05-31 11:44:44 +03:00
uniform.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) {
Refactor shader hints
2022-05-31 11:44:44 +03:00
uniform.order = uniforms++;
Fix texture samplers to not being last in the property list
2024-07-26 12:19:13 +03:00
uniform.prop_order = prop_index++;
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) {
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (uniform.array_size > 0) {
int size = get_datatype_size(uniform.type) * uniform.array_size;
int m = (16 * uniform.array_size);
Enhances a shader uniform limit warning
2022-01-08 18:34:00 +03:00
if ((size % m) != 0U) {
size += m - (size % m);
}
uniform_buffer_size += size;
} else {
Refactor shader hints
2022-05-31 11:44:44 +03:00
uniform_buffer_size += get_datatype_size(uniform.type);
Enhances a shader uniform limit warning
2022-01-08 18:34:00 +03:00
}
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
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (uniform.array_size > 0) {
Added support for uniform arrays in shaders
2021-06-09 12:33:41 +03:00
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;
Refactor shader hints
2022-05-31 11:44:44 +03:00
completion_base_array = uniform.array_size > 0;
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +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
//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
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (uniform.array_size > 0) {
Allow more hint types for uniform arrays
2023-07-06 14:44:24 +02:00
static Vector<int> supported_hints = {
TK_HINT_SOURCE_COLOR, TK_REPEAT_DISABLE, TK_REPEAT_ENABLE,
TK_FILTER_LINEAR, TK_FILTER_LINEAR_MIPMAP, TK_FILTER_LINEAR_MIPMAP_ANISOTROPIC,
TK_FILTER_NEAREST, TK_FILTER_NEAREST_MIPMAP, TK_FILTER_NEAREST_MIPMAP_ANISOTROPIC
};
if (!supported_hints.has(tk.type)) {
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;
}
}
Refactor shader hints
2022-05-31 11:44:44 +03:00
ShaderNode::Uniform::Hint new_hint = ShaderNode::Uniform::HINT_NONE;
TextureFilter new_filter = FILTER_DEFAULT;
TextureRepeat new_repeat = REPEAT_DEFAULT;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Refactor shader hints
2022-05-31 11:44:44 +03:00
switch (tk.type) {
case TK_HINT_SOURCE_COLOR: {
if (type != TYPE_VEC3 && type != TYPE_VEC4 && !is_sampler_type(type)) {
_set_error(vformat(RTR("Source color hint is for '%s', '%s' or sampler types only."), "vec3", "vec4"));
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (is_sampler_type(type)) {
if (uniform.use_color) {
_set_error(vformat(RTR("Duplicated hint: '%s'."), "source_color"));
return ERR_PARSE_ERROR;
}
uniform.use_color = true;
} else {
new_hint = ShaderNode::Uniform::HINT_SOURCE_COLOR;
}
} break;
case TK_HINT_DEFAULT_BLACK_TEXTURE: {
new_hint = ShaderNode::Uniform::HINT_DEFAULT_BLACK;
} break;
case TK_HINT_DEFAULT_WHITE_TEXTURE: {
new_hint = ShaderNode::Uniform::HINT_DEFAULT_WHITE;
} break;
Add `hint_transparent` to use a transparent black placeholder texture This can be used in shaders to avoid the need to supply a transparent placeholder texture manually.
2021-08-14 18:29:52 +02:00
case TK_HINT_DEFAULT_TRANSPARENT_TEXTURE: {
new_hint = ShaderNode::Uniform::HINT_DEFAULT_TRANSPARENT;
} break;
Refactor shader hints
2022-05-31 11:44:44 +03:00
case TK_HINT_NORMAL_TEXTURE: {
new_hint = ShaderNode::Uniform::HINT_NORMAL;
} break;
case TK_HINT_ROUGHNESS_NORMAL_TEXTURE: {
new_hint = ShaderNode::Uniform::HINT_ROUGHNESS_NORMAL;
} break;
case TK_HINT_ROUGHNESS_R: {
new_hint = ShaderNode::Uniform::HINT_ROUGHNESS_R;
} break;
case TK_HINT_ROUGHNESS_G: {
new_hint = ShaderNode::Uniform::HINT_ROUGHNESS_G;
} break;
case TK_HINT_ROUGHNESS_B: {
new_hint = ShaderNode::Uniform::HINT_ROUGHNESS_B;
} break;
case TK_HINT_ROUGHNESS_A: {
new_hint = ShaderNode::Uniform::HINT_ROUGHNESS_A;
} break;
case TK_HINT_ROUGHNESS_GRAY: {
new_hint = ShaderNode::Uniform::HINT_ROUGHNESS_GRAY;
} break;
case TK_HINT_ANISOTROPY_TEXTURE: {
new_hint = ShaderNode::Uniform::HINT_ANISOTROPY;
} break;
case TK_HINT_RANGE: {
if (type != TYPE_FLOAT && type != TYPE_INT) {
_set_error(vformat(RTR("Range hint is for '%s' and '%s' only."), "float", "int"));
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();
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (tk.type != TK_PARENTHESIS_OPEN) {
_set_expected_after_error("(", "hint_range");
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Refactor shader hints
2022-05-31 11:44:44 +03:00
tk = _get_token();
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
Refactor shader hints
2022-05-31 11:44:44 +03:00
float sign = 1.0;
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
Refactor shader hints
2022-05-31 11:44:44 +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 shader hints
2022-05-31 11:44:44 +03:00
if (tk.type != TK_FLOAT_CONSTANT && !tk.is_integer_constant()) {
_set_error(RTR("Expected an integer constant."));
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Refactor shader hints
2022-05-31 11:44:44 +03:00
uniform.hint_range[0] = tk.constant;
uniform.hint_range[0] *= sign;
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
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (tk.type != TK_COMMA) {
_set_error(RTR("Expected ',' after integer constant."));
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Refactor shader hints
2022-05-31 11:44:44 +03:00
tk = _get_token();
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
Refactor shader hints
2022-05-31 11:44:44 +03:00
sign = 1.0;
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (tk.type == TK_OP_SUB) {
sign = -1.0;
tk = _get_token();
}
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -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 ','."));
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
return ERR_PARSE_ERROR;
}
Refactor shader hints
2022-05-31 11:44:44 +03:00
uniform.hint_range[1] = tk.constant;
uniform.hint_range[1] *= sign;
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
tk = _get_token();
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (tk.type == TK_COMMA) {
tk = _get_token();
if (tk.type != TK_FLOAT_CONSTANT && !tk.is_integer_constant()) {
_set_error(RTR("Expected an integer constant after ','."));
return ERR_PARSE_ERROR;
}
uniform.hint_range[2] = tk.constant;
tk = _get_token();
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
} else {
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (type == TYPE_INT) {
uniform.hint_range[2] = 1;
} else {
uniform.hint_range[2] = 0.001;
}
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
}
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (tk.type != TK_PARENTHESIS_CLOSE) {
_set_expected_error(")");
return ERR_PARSE_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
Refactor shader hints
2022-05-31 11:44:44 +03:00
new_hint = ShaderNode::Uniform::HINT_RANGE;
} break;
Add `hint_enum` for uniform int in gdshader
2024-07-13 14:30:08 -04:00
case TK_HINT_ENUM: {
if (type != TYPE_INT) {
_set_error(vformat(RTR("Enum hint is for '%s' only."), "int"));
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_PARENTHESIS_OPEN) {
_set_expected_after_error("(", "hint_enum");
return ERR_PARSE_ERROR;
}
while (true) {
tk = _get_token();
if (tk.type != TK_STRING_CONSTANT) {
_set_error(RTR("Expected a string constant."));
return ERR_PARSE_ERROR;
}
uniform.hint_enum_names.push_back(tk.text);
tk = _get_token();
if (tk.type == TK_PARENTHESIS_CLOSE) {
break;
} else if (tk.type != TK_COMMA) {
_set_error(RTR("Expected ',' or ')' after string constant."));
return ERR_PARSE_ERROR;
}
}
new_hint = ShaderNode::Uniform::HINT_ENUM;
} break;
Refactor shader hints
2022-05-31 11:44:44 +03:00
case TK_HINT_INSTANCE_INDEX: {
if (custom_instance_index != -1) {
_set_error(vformat(RTR("Can only specify '%s' once."), "instance_index"));
return ERR_PARSE_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
Refactor shader hints
2022-05-31 11:44:44 +03:00
tk = _get_token();
if (tk.type != TK_PARENTHESIS_OPEN) {
_set_expected_after_error("(", "instance_index");
return ERR_PARSE_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
Refactor shader hints
2022-05-31 11:44:44 +03:00
tk = _get_token();
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
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (tk.type == TK_OP_SUB) {
_set_error(RTR("The instance index can't be negative."));
return ERR_PARSE_ERROR;
}
if (!tk.is_integer_constant()) {
_set_error(RTR("Expected an integer constant."));
return ERR_PARSE_ERROR;
}
custom_instance_index = tk.constant;
Prevent duplicated hints in shader uniform completion
2022-09-11 14:49:19 +03:00
current_uniform_instance_index_defined = true;
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (custom_instance_index >= MAX_INSTANCE_UNIFORM_INDICES) {
_set_error(vformat(RTR("Allowed instance uniform indices must be within [0..%d] range."), MAX_INSTANCE_UNIFORM_INDICES - 1));
return ERR_PARSE_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
Refactor shader hints
2022-05-31 11:44:44 +03:00
tk = _get_token();
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
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (tk.type != TK_PARENTHESIS_CLOSE) {
_set_expected_error(")");
return ERR_PARSE_ERROR;
}
} break;
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
case TK_HINT_SCREEN_TEXTURE: {
new_hint = ShaderNode::Uniform::HINT_SCREEN_TEXTURE;
Fix editor crash when assigning some uniform hints to the textures
2022-10-16 19:34:12 +03:00
--texture_uniforms;
Decrement texture_binding count when using screen textures
2023-01-20 12:48:13 -08:00
--texture_binding;
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
} break;
case TK_HINT_NORMAL_ROUGHNESS_TEXTURE: {
new_hint = ShaderNode::Uniform::HINT_NORMAL_ROUGHNESS_TEXTURE;
Fix editor crash when assigning some uniform hints to the textures
2022-10-16 19:34:12 +03:00
--texture_uniforms;
Decrement texture_binding count when using screen textures
2023-01-20 12:48:13 -08:00
--texture_binding;
Return shader parse error when using 'hint_normal_roughness_texture' and not using the Forward+ backend
2023-06-29 16:18:31 +01:00
if (OS::get_singleton()->get_current_rendering_method() != "forward_plus") {
Standardize terms for renderers in error strings Use "Forward+", "Mobile", "Compatibility", and "renderer" or "rendering method".
2024-11-01 17:00:35 -07:00
_set_error(RTR("'hint_normal_roughness_texture' is only available when using the Forward+ renderer."));
Add a shader error when trying to using hint_normal_roughness_texture in the gl_compatibility renderer
2023-01-30 09:04:34 -08:00
return ERR_PARSE_ERROR;
}
Fix false positive errors in gdshaderinc files These language features are wrongly detected as errors (not supported) when used in gdshaderinc files: - instance uniforms - hint_normal_roughness_texture - hint_depth_texture This type of error should only occur when the shader type is not spatial and not a gdshaderinc file.
2024-03-21 15:46:41 +01:00
if (shader_type_identifier != StringName() && String(shader_type_identifier) != "spatial") {
Error on hint_normal_roughness_texture and hint_depth_texture outside of spatial shader
2023-03-03 21:36:48 +01:00
_set_error(vformat(RTR("'hint_normal_roughness_texture' is not supported in '%s' shaders."), shader_type_identifier));
return ERR_PARSE_ERROR;
}
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
} break;
case TK_HINT_DEPTH_TEXTURE: {
new_hint = ShaderNode::Uniform::HINT_DEPTH_TEXTURE;
Fix editor crash when assigning some uniform hints to the textures
2022-10-16 19:34:12 +03:00
--texture_uniforms;
Decrement texture_binding count when using screen textures
2023-01-20 12:48:13 -08:00
--texture_binding;
Fix false positive errors in gdshaderinc files These language features are wrongly detected as errors (not supported) when used in gdshaderinc files: - instance uniforms - hint_normal_roughness_texture - hint_depth_texture This type of error should only occur when the shader type is not spatial and not a gdshaderinc file.
2024-03-21 15:46:41 +01:00
if (shader_type_identifier != StringName() && String(shader_type_identifier) != "spatial") {
Error on hint_normal_roughness_texture and hint_depth_texture outside of spatial shader
2023-03-03 21:36:48 +01:00
_set_error(vformat(RTR("'hint_depth_texture' is not supported in '%s' shaders."), shader_type_identifier));
return ERR_PARSE_ERROR;
}
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
} break;
Refactor shader hints
2022-05-31 11:44:44 +03:00
case TK_FILTER_NEAREST: {
new_filter = FILTER_NEAREST;
} break;
case TK_FILTER_LINEAR: {
new_filter = FILTER_LINEAR;
} break;
case TK_FILTER_NEAREST_MIPMAP: {
new_filter = FILTER_NEAREST_MIPMAP;
} break;
case TK_FILTER_LINEAR_MIPMAP: {
new_filter = FILTER_LINEAR_MIPMAP;
} break;
case TK_FILTER_NEAREST_MIPMAP_ANISOTROPIC: {
new_filter = FILTER_NEAREST_MIPMAP_ANISOTROPIC;
} break;
case TK_FILTER_LINEAR_MIPMAP_ANISOTROPIC: {
new_filter = FILTER_LINEAR_MIPMAP_ANISOTROPIC;
} break;
case TK_REPEAT_DISABLE: {
new_repeat = REPEAT_DISABLE;
} break;
case TK_REPEAT_ENABLE: {
new_repeat = REPEAT_ENABLE;
} break;
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
Refactor shader hints
2022-05-31 11:44:44 +03:00
default:
break;
}
Add `hint_enum` for uniform int in gdshader
2024-07-13 14:30:08 -04:00
bool is_sampler_hint = new_hint != ShaderNode::Uniform::HINT_NONE && new_hint != ShaderNode::Uniform::HINT_SOURCE_COLOR && new_hint != ShaderNode::Uniform::HINT_RANGE && new_hint != ShaderNode::Uniform::HINT_ENUM;
if (((new_filter != FILTER_DEFAULT || new_repeat != REPEAT_DEFAULT) || is_sampler_hint) && !is_sampler_type(type)) {
Refactor shader hints
2022-05-31 11:44:44 +03:00
_set_error(RTR("This hint is only for sampler types."));
return ERR_PARSE_ERROR;
}
if (new_hint != ShaderNode::Uniform::HINT_NONE) {
if (uniform.hint != ShaderNode::Uniform::HINT_NONE) {
if (uniform.hint == new_hint) {
_set_error(vformat(RTR("Duplicated hint: '%s'."), get_uniform_hint_name(new_hint)));
} else {
_set_error(vformat(RTR("Redefinition of hint: '%s'. The hint has already been set to '%s'."), get_uniform_hint_name(new_hint), get_uniform_hint_name(uniform.hint)));
}
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 shader hints
2022-05-31 11:44:44 +03:00
} else {
uniform.hint = new_hint;
Prevent duplicated hints in shader uniform completion
2022-09-11 14:49:19 +03:00
current_uniform_hint = new_hint;
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
}
Refactor shader hints
2022-05-31 11:44:44 +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
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (new_filter != FILTER_DEFAULT) {
if (uniform.filter != FILTER_DEFAULT) {
if (uniform.filter == new_filter) {
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
_set_error(vformat(RTR("Duplicated filter mode: '%s'."), get_texture_filter_name(new_filter)));
Refactor shader hints
2022-05-31 11:44:44 +03:00
} else {
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
_set_error(vformat(RTR("Redefinition of filter mode: '%s'. The filter mode has already been set to '%s'."), get_texture_filter_name(new_filter), get_texture_filter_name(uniform.filter)));
Refactor shader hints
2022-05-31 11:44:44 +03:00
}
Modernized default 3D material, fixes material bugs.
2019-09-15 01:01:52 -03:00
return ERR_PARSE_ERROR;
Refactor shader hints
2022-05-31 11:44:44 +03:00
} else {
uniform.filter = new_filter;
Prevent duplicated hints in shader uniform completion
2022-09-11 14:49:19 +03:00
current_uniform_filter = new_filter;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on 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
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (new_repeat != REPEAT_DEFAULT) {
if (uniform.repeat != REPEAT_DEFAULT) {
if (uniform.repeat == new_repeat) {
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
_set_error(vformat(RTR("Duplicated repeat mode: '%s'."), get_texture_repeat_name(new_repeat)));
Refactor shader hints
2022-05-31 11:44:44 +03:00
} else {
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
_set_error(vformat(RTR("Redefinition of repeat mode: '%s'. The repeat mode has already been set to '%s'."), get_texture_repeat_name(new_repeat), get_texture_repeat_name(uniform.repeat)));
Refactor shader hints
2022-05-31 11:44:44 +03:00
}
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
return ERR_PARSE_ERROR;
Refactor shader hints
2022-05-31 11:44:44 +03:00
} else {
uniform.repeat = new_repeat;
Prevent duplicated hints in shader uniform completion
2022-09-11 14:49:19 +03:00
current_uniform_repeat = new_repeat;
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +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
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) {
Refactor shader hints
2022-05-31 11:44:44 +03:00
uniform.instance_index = custom_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
} else {
Refactor shader hints
2022-05-31 11:44:44 +03:00
uniform.instance_index = 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
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) {
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (uniform.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
}
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (expr->type != Node::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);
Refactor shader hints
2022-05-31 11:44:44 +03:00
uniform.default_value.resize(cn->values.size());
Hinted shader uniforms can have a default value
2018-03-15 15:23:40 +01:00
Refactor shader hints
2022-05-31 11:44:44 +03:00
if (!convert_constant(cn, uniform.type, uniform.default_value.ptrw())) {
_set_error(vformat(RTR("Can't convert constant to '%s'."), get_datatype_name(uniform.type)));
Hinted shader uniforms can have a default value
2018-03-15 15:23:40 +01:00
return ERR_PARSE_ERROR;
}
tk = _get_token();
}
Refactor shader hints
2022-05-31 11:44:44 +03:00
shader->uniforms[name] = uniform;
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
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_GLOBAL_SPACE;
#endif // DEBUG_ENABLED
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
completion_type = COMPLETION_NONE;
Prevent duplicated hints in shader uniform completion
2022-09-11 14:49:19 +03:00
current_uniform_hint = ShaderNode::Uniform::HINT_NONE;
current_uniform_filter = FILTER_DEFAULT;
current_uniform_repeat = REPEAT_DEFAULT;
current_uniform_instance_index_defined = false;
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;
Implement shader uniform groups/subgroups
2022-07-13 11:31:27 +03:00
case TK_UNIFORM_GROUP: {
tk = _get_token();
if (tk.type == TK_IDENTIFIER) {
current_uniform_group_name = tk.text;
Fix uniform subgroup in shader will carry out to next group
2024-07-29 11:07:09 +08:00
current_uniform_subgroup_name = "";
Implement shader uniform groups/subgroups
2022-07-13 11:31:27 +03:00
tk = _get_token();
if (tk.type == TK_PERIOD) {
tk = _get_token();
if (tk.type == TK_IDENTIFIER) {
current_uniform_subgroup_name = tk.text;
tk = _get_token();
if (tk.type != TK_SEMICOLON) {
_set_expected_error(";");
return ERR_PARSE_ERROR;
}
} else {
_set_error(RTR("Expected an uniform subgroup identifier."));
return ERR_PARSE_ERROR;
}
} else if (tk.type != TK_SEMICOLON) {
_set_expected_error(";", ".");
return ERR_PARSE_ERROR;
}
} else {
if (tk.type != TK_SEMICOLON) {
if (current_uniform_group_name.is_empty()) {
_set_error(RTR("Expected an uniform group identifier."));
} else {
_set_error(RTR("Expected an uniform group identifier or `;`."));
}
return ERR_PARSE_ERROR;
Code simplifications found by cppcheck They are based on: - Boolean arithmetic simplifications - setting variables that are not accessed - constant variables
2022-10-28 01:39:28 +02:00
} else if (current_uniform_group_name.is_empty()) {
Implement shader uniform groups/subgroups
2022-07-13 11:31:27 +03:00
_set_error(RTR("Group needs to be opened before."));
return ERR_PARSE_ERROR;
} else {
current_uniform_group_name = "";
current_uniform_subgroup_name = "";
}
}
} 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)) {
is_struct = true;
struct_name = tk.text;
} else {
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
if (_lookup_next(next)) {
if (next.type == TK_UNIFORM) {
keyword_completion_context = CF_UNIFORM_QUALIFIER;
}
}
#endif // DEBUG_ENABLED
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +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 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);
}
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
if (precision != PRECISION_DEFAULT && _validate_precision(type, precision) != OK) {
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();
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
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_UNSPECIFIED;
#endif // DEBUG_ENABLED
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) {
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
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
IdentifierType itype;
if (shader->structs.has(name) || (_find_identifier(nullptr, false, constants, name, nullptr, &itype) && itype != IDENTIFIER_FUNCTION) || has_builtin(p_functions, name, !is_constant)) {
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;
Fix completion of functions with struct param/return type in shaders
2024-05-28 12:13:25 +03:00
constant.struct_name = 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;
Fix shader failure when using non-const initializer on a constant
2023-02-01 09:04:10 +03:00
is_const_decl = true;
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
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;
}
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (n->type == Node::NODE_TYPE_OPERATOR && static_cast<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 basic support to evaluate operator value in shader language
2024-07-01 16:39:49 +03:00
_set_error(vformat(RTR("Array size mismatch. Expected %d elements (found %d)."), constant.array_size, decl.initializer.size()));
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
return ERR_PARSE_ERROR;
}
Fix editor crash when shader has incorrect global array declaration
2024-07-23 17:52:08 +08:00
} else {
_set_expected_error("(");
return ERR_PARSE_ERROR;
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
}
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;
Fix completion of functions with struct param/return type in shaders
2024-05-28 12:13:25 +03:00
expr->struct_name = constant.struct_name;
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
expr->array_size = constant.array_size;
expr->array_declarations.push_back(decl);
constant.initializer = static_cast<ConstantNode *>(expr);
} else {
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
if (constant.type == DataType::TYPE_BOOL) {
keyword_completion_context = CF_BOOLEAN;
}
#endif // DEBUG_ENABLED
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
//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
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
if (constant.type == DataType::TYPE_BOOL) {
keyword_completion_context = CF_GLOBAL_SPACE;
}
#endif // DEBUG_ENABLED
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (expr->type == Node::NODE_TYPE_OPERATOR && static_cast<OperatorNode *>(expr)->op == OP_CALL) {
Fix some issues found by cppcheck.
2022-04-05 13:40:26 +03:00
OperatorNode *op = static_cast<OperatorNode *>(expr);
Fix shader handle constant expressions in function call
2021-04-27 14:58:32 +03:00
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
}
Fix crash on shader constant initialization on MinGW compiler
2024-06-22 16:15:40 +03:00
constant.initializer = expr;
Implemented global const array to shaders
2019-10-11 20:43:42 +03:00
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) {
Fix shader failure when using non-const initializer on a constant
2023-02-01 09:04:10 +03:00
is_const_decl = false;
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 17:19:24 +03:00
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
Forbid function declaration with a const qualifier in shaders
2024-08-08 11:23:27 +03:00
if (is_constant) {
_set_error(vformat(RTR("'%s' qualifier cannot be used with a function return type."), "const"));
return ERR_PARSE_ERROR;
}
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);
}
}
Re-allows constants in global space to be initialized with function call
2023-09-13 19:11:12 +03:00
for (int i = 0; i < shader->vfunctions.size(); i++) {
if (!shader->vfunctions[i].callable && shader->vfunctions[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;
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
function.rname = 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>();
function.function = func_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
func_node->name = name;
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
func_node->rname = 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_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;
Allow usage of `discard` inside custom shader functions
2024-06-25 15:39:21 +03:00
} else {
func_node->can_discard = is_discard_supported; // Allow use it for custom functions (in supported shader types).
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
}
if (!function_overload_count.has(name)) {
function_overload_count.insert(name, 0);
Basic warning support implementation for the Godot Shading Language.
2021-01-01 18:04:47 +03:00
} else {
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
function_overload_count[name]++;
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;
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_CONST_KEYWORD | CF_FUNC_DECL_PARAM_SPEC | CF_PRECISION_MODIFIER | CF_FUNC_DECL_PARAM_TYPE; // eg. const in mediump float
if (_lookup_next(next)) {
if (next.type == TK_CONST) {
keyword_completion_context = CF_UNSPECIFIED;
} else if (is_token_arg_qual(next.type)) {
keyword_completion_context = CF_CONST_KEYWORD;
} else if (is_token_precision(next.type)) {
keyword_completion_context = (CF_CONST_KEYWORD | CF_FUNC_DECL_PARAM_SPEC | CF_FUNC_DECL_PARAM_TYPE);
} else if (is_token_datatype(next.type)) {
keyword_completion_context = (CF_CONST_KEYWORD | CF_FUNC_DECL_PARAM_SPEC | CF_PRECISION_MODIFIER);
}
}
#endif // DEBUG_ENABLED
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
bool param_is_const = false;
Added const qualifier support for function arguments in shaders
2020-07-01 11:55:49 +03:00
if (tk.type == TK_CONST) {
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
param_is_const = true;
Added const qualifier support for function arguments in shaders
2020-07-01 11:55:49 +03:00
tk = _get_token();
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
if (keyword_completion_context & CF_CONST_KEYWORD) {
keyword_completion_context ^= CF_CONST_KEYWORD;
}
if (_lookup_next(next)) {
if (is_token_arg_qual(next.type)) {
keyword_completion_context = CF_UNSPECIFIED;
} else if (is_token_precision(next.type)) {
keyword_completion_context = (CF_FUNC_DECL_PARAM_SPEC | CF_FUNC_DECL_PARAM_TYPE);
} else if (is_token_datatype(next.type)) {
keyword_completion_context = (CF_FUNC_DECL_PARAM_SPEC | CF_PRECISION_MODIFIER);
}
}
#endif // DEBUG_ENABLED
Added const qualifier support for function arguments in shaders
2020-07-01 11:55:49 +03:00
}
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
ArgumentQualifier param_qualifier = ARGUMENT_QUALIFIER_IN;
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
if (is_token_arg_qual(tk.type)) {
bool error = false;
switch (tk.type) {
case TK_ARG_IN: {
param_qualifier = ARGUMENT_QUALIFIER_IN;
} break;
case TK_ARG_OUT: {
if (param_is_const) {
_set_error(vformat(RTR("The '%s' qualifier cannot be used within a function parameter declared with '%s'."), "out", "const"));
error = true;
}
param_qualifier = ARGUMENT_QUALIFIER_OUT;
} break;
case TK_ARG_INOUT: {
if (param_is_const) {
_set_error(vformat(RTR("The '%s' qualifier cannot be used within a function parameter declared with '%s'."), "inout", "const"));
error = true;
}
param_qualifier = ARGUMENT_QUALIFIER_INOUT;
} break;
default:
error = true;
break;
Added const qualifier support for function arguments in shaders
2020-07-01 11:55:49 +03:00
}
New particle system, mostly working, some small features missing.
2017-04-06 23:36:37 -03:00
tk = _get_token();
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
if (keyword_completion_context & CF_CONST_KEYWORD) {
keyword_completion_context ^= CF_CONST_KEYWORD;
}
if (keyword_completion_context & CF_FUNC_DECL_PARAM_SPEC) {
keyword_completion_context ^= CF_FUNC_DECL_PARAM_SPEC;
}
if (_lookup_next(next)) {
if (is_token_precision(next.type)) {
keyword_completion_context = CF_FUNC_DECL_PARAM_TYPE;
} else if (is_token_datatype(next.type)) {
keyword_completion_context = CF_PRECISION_MODIFIER;
}
}
#endif // DEBUG_ENABLED
if (error) {
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
}
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
DataType param_type;
StringName param_name;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
StringName param_struct_name;
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
DataPrecision param_precision = PRECISION_DEFAULT;
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)) {
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
param_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();
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
if (keyword_completion_context & CF_CONST_KEYWORD) {
keyword_completion_context ^= CF_CONST_KEYWORD;
}
if (keyword_completion_context & CF_FUNC_DECL_PARAM_SPEC) {
keyword_completion_context ^= CF_FUNC_DECL_PARAM_SPEC;
}
if (keyword_completion_context & CF_PRECISION_MODIFIER) {
keyword_completion_context ^= CF_PRECISION_MODIFIER;
}
if (_lookup_next(next)) {
if (is_token_datatype(next.type)) {
keyword_completion_context = CF_UNSPECIFIED;
}
}
#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
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
}
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 shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
if (param_qualifier == ARGUMENT_QUALIFIER_OUT || param_qualifier == ARGUMENT_QUALIFIER_INOUT) {
Prevent usage 'out' modifier on opaque shader types (textures currently)
2020-02-13 21:02:47 +03:00
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) {
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
param_type = TYPE_STRUCT;
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
} else {
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
param_type = get_token_datatype(tk.type);
if (param_type == 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
}
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
if (param_precision != PRECISION_DEFAULT && _validate_precision(param_type, param_precision) != OK) {
return ERR_PARSE_ERROR;
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_UNSPECIFIED;
#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
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;
}
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
param_name = tk.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
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
if (_find_identifier(func_node->body, false, builtins, param_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) {
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
_set_redefinition_error(String(param_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
}
Added check if field name in the shader is equal to builtin
2019-10-29 14:36:11 +03:00
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
if (has_builtin(p_functions, param_name)) {
_set_redefinition_error(String(param_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
FunctionNode::Argument arg;
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
arg.type = param_type;
arg.name = param_name;
Fix completion of functions with struct param/return type in shaders
2024-05-28 12:13:25 +03:00
arg.struct_name = param_struct_name;
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
arg.precision = param_precision;
arg.qualifier = param_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;
Prevent shader crash when using precision on boolean types
2022-04-26 11:46:06 +03:00
arg.is_const = param_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;
}
}
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
// Searches for function index and check for the exact duplicate in overloads.
int function_index = 0;
for (int i = 0; i < shader->vfunctions.size(); i++) {
if (!shader->vfunctions[i].callable || shader->vfunctions[i].rname != name) {
continue;
}
function_index++;
if (shader->vfunctions[i].function->arguments.size() != func_node->arguments.size()) {
continue;
}
bool is_same = true;
for (int j = 0; j < shader->vfunctions[i].function->arguments.size(); j++) {
FunctionNode::Argument a = func_node->arguments[j];
FunctionNode::Argument b = shader->vfunctions[i].function->arguments[j];
if (a.type == b.type && a.array_size == b.array_size) {
if (a.type == TYPE_STRUCT) {
is_same = a.struct_name == b.struct_name;
}
} else {
is_same = false;
}
if (!is_same) {
break;
}
}
if (is_same) {
_set_redefinition_error(String(name));
return ERR_PARSE_ERROR;
}
}
// Creates a fake name for function overload, which will be replaced by the real name by the compiler.
String name2 = name;
if (function_index > 0) {
name2 = vformat("%s@%s", name, itos(function_index + 1));
function.name = name2;
func_node->name = name2;
}
shader->functions.insert(name2, function);
shader->vfunctions.push_back(function);
CallInfo call_info;
call_info.name = name2;
calls_info.insert(name2, call_info);
#ifdef DEBUG_ENABLED
if (check_warnings && HAS_WARNING(ShaderWarning::UNUSED_FUNCTION_FLAG) && !p_functions.has(name)) {
used_functions.insert(name2, 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
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;
}
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
current_function = name2;
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 18:31:01 -03:00
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_BLOCK;
#endif // DEBUG_ENABLED
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
}
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
keyword_completion_context = CF_GLOBAL_SPACE;
#endif // DEBUG_ENABLED
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
}
Validate varying count when compiling shaders This avoids crashing on devices when a number of varyings greater than the device limit is used. For now this accurately prints an error when compiling the shader, but the error text only pops up in the editor if the number of user varyings is above the limit.
2025-02-12 16:12:46 -08:00
uint32_t varying_index = base_varying_index;
uint32_t max_varyings = 31;
// Can be false for internal shaders created in the process of initializing the engine.
if (RSG::utilities) {
max_varyings = RSG::utilities->get_maximum_shader_varyings();
}
Allow using vertex varying in custom functions under any circumstances
2021-07-22 11:09:53 +03:00
Fix shader crash when using varyings with non-`flat` integer type
2024-08-18 10:19:16 +03:00
for (const KeyValue<StringName, ShaderNode::Varying> &kv : shader->varyings) {
if (kv.value.stage != ShaderNode::Varying::STAGE_FRAGMENT && (kv.value.type > TYPE_BVEC4 && kv.value.type < TYPE_FLOAT) && kv.value.interpolation != INTERPOLATION_FLAT) {
_set_tkpos(kv.value.tkpos);
_set_error(vformat(RTR("Varying with integer data type must be declared with `%s` interpolation qualifier."), "flat"));
return ERR_PARSE_ERROR;
}
Validate varying count when compiling shaders This avoids crashing on devices when a number of varyings greater than the device limit is used. For now this accurately prints an error when compiling the shader, but the error text only pops up in the editor if the number of user varyings is above the limit.
2025-02-12 16:12:46 -08:00
if (varying_index + kv.value.get_size() > max_varyings) {
_set_tkpos(kv.value.tkpos);
_set_error(vformat(RTR("Too many varyings used in shader (%d used, maximum supported is %d)."), varying_index + kv.value.get_size(), max_varyings));
return ERR_PARSE_ERROR;
}
varying_index += kv.value.get_size();
Fix shader crash when using varyings with non-`flat` integer type
2024-08-18 10:19:16 +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;
}
Prevent using built-ins for func names in shaders
2024-05-30 21:15:21 +03:00
bool ShaderLanguage::has_builtin(const HashMap<StringName, ShaderLanguage::FunctionInfo> &p_functions, const StringName &p_name, bool p_check_global_funcs) {
if (p_check_global_funcs && global_func_set.has(p_name)) {
return true;
}
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--) {
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
if (p_flow->blocks[i]->type == Node::NODE_TYPE_BLOCK) {
Fix some issues found by cppcheck.
2022-04-05 13:40:26 +03:00
BlockNode *last_block = static_cast<BlockNode *>(p_flow->blocks[i]);
Fix shader crash when users miss the return statement
2019-08-23 15:40:42 +03:00
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;
Reduce and prevent unnecessary random-access to `List` Random-access access to `List` when iterating is `O(n^2)` (`O(n)` when accessing a single element) * Removed subscript operator, in favor of a more explicit `get` * Added conversion from `Iterator` to `ConstIterator` * Remade existing operations into other solutions when applicable
2024-04-15 15:18:34 +02:00
for (List<ShaderLanguage::Node *>::Element *E = p_block->statements.back(); E; E = E->prev()) {
if (E->get()->type == Node::NODE_TYPE_CONTROL_FLOW) {
ControlFlowNode *flow = static_cast<ControlFlowNode *>(E->get());
Fix shader crash when users miss the return statement
2019-08-23 15:40:42 +03:00
if (flow->flow_op == p_op) {
found = true;
break;
} else {
if (_find_last_flow_op_in_op(flow, p_op) == OK) {
found = true;
break;
}
}
Reduce and prevent unnecessary random-access to `List` Random-access access to `List` when iterating is `O(n^2)` (`O(n)` when accessing a single element) * Removed subscript operator, in favor of a more explicit `get` * Added conversion from `Iterator` to `ConstIterator` * Remade existing operations into other solutions when applicable
2024-04-15 15:18:34 +02:00
} else if (E->get()->type == Node::NODE_TYPE_BLOCK) {
BlockNode *block = static_cast<BlockNode *>(E->get());
Fix shader crash when users miss the return statement
2019-08-23 15:40:42 +03:00
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();
}
Mark shader built-ins as used when passed to functions as out parameter
2022-11-14 11:11:33 +03:00
bool ShaderLanguage::is_builtin_func_out_parameter(const String &p_name, int p_param) {
int i = 0;
while (builtin_func_out_args[i].name) {
if (p_name == builtin_func_out_args[i].name) {
for (int j = 0; j < BuiltinFuncOutArgs::MAX_ARGS; j++) {
int arg = builtin_func_out_args[i].arguments[j];
if (arg == p_param) {
return true;
}
if (arg < 0) {
return false;
}
}
}
i++;
}
return false;
}
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() {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
for (const KeyValue<ShaderWarning::Code, HashMap<StringName, HashMap<StringName, Usage>> *> &E : warnings_check_map2) {
for (const KeyValue<StringName, HashMap<StringName, Usage>> &T : *E.value) {
for (const KeyValue<StringName, Usage> &U : T.value) {
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
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
}
}
}
}
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
for (const KeyValue<ShaderWarning::Code, HashMap<StringName, Usage> *> &E : warnings_check_map) {
for (const KeyValue<StringName, Usage> &U : (*E.value)) {
if (!U.value.used) {
_add_warning(E.key, U.value.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();
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
is_shader_inc = p_info.is_include;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Clean up Shader Preprocessor * Moved preprocessor to Shader and ShaderInclude * Clean up RenderingServer side * Preprocessor is separate from parser now, but it emits tokens with include location hints. * Improved ShaderEditor validation code * Added include file code completion * Added notification for all files affected by a broken include.
2022-06-29 11:31:18 +02:00
code = p_code;
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniform_get_type_func = p_info.global_shader_uniform_type_func;
Clean up Shader Preprocessor * Moved preprocessor to Shader and ShaderInclude * Clean up RenderingServer side * Preprocessor is separate from parser now, but it emits tokens with include location hints. * Improved ShaderEditor validation code * Added include file code completion * Added notification for all files affected by a broken include.
2022-06-29 11:31:18 +02:00
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;
Validate varying count when compiling shaders This avoids crashing on devices when a number of varyings greater than the device limit is used. For now this accurately prints an error when compiling the shader, but the error text only pops up in the editor if the number of user varyings is above the limit.
2025-02-12 16:12:46 -08:00
base_varying_index = p_info.base_varying_index;
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>();
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +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
Add GDExtension support to Script * Ability to create script languages from GDExtension * Some additions to gdnative_extension.h to make this happen * Moved the GDExtension binder to core This now allows creating scripting languages from GDExtension, with the same ease as if it was a module. It replaces the old PluginScript from Godot 3.x. Warning: GodotCPP will need to be updated to support this (it may be a bit of work as ScriptInstance needs to be created over there again).
2022-03-26 16:48:43 +01:00
Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_info, List<ScriptLanguage::CodeCompletionOption> *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();
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
is_shader_inc = p_info.is_include;
-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
Clean up Shader Preprocessor * Moved preprocessor to Shader and ShaderInclude * Clean up RenderingServer side * Preprocessor is separate from parser now, but it emits tokens with include location hints. * Improved ShaderEditor validation code * Added include file code completion * Added notification for all files affected by a broken include.
2022-06-29 11:31:18 +02: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;
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniform_get_type_func = p_info.global_shader_uniform_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>();
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +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
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
#ifdef DEBUG_ENABLED
// Adds context keywords.
if (keyword_completion_context != CF_UNSPECIFIED) {
int sz = sizeof(keyword_list) / sizeof(KeyWord);
for (int i = 0; i < sz; i++) {
if (keyword_list[i].flags == CF_UNSPECIFIED) {
break; // Ignore hint keywords (parsed below).
}
if (keyword_list[i].flags & keyword_completion_context) {
Allow usage of `discard` inside custom shader functions
2024-06-25 15:39:21 +03:00
if (keyword_list[i].excluded_shader_types.has(shader_type_identifier) || keyword_list[i].excluded_functions.has(current_function)) {
Add keyword completion to shader editor
2022-04-27 14:18:32 +03:00
continue;
}
ScriptLanguage::CodeCompletionOption option(keyword_list[i].text, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
r_options->push_back(option);
}
}
}
#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
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) {
Add GDExtension support to Script * Ability to create script languages from GDExtension * Some additions to gdnative_extension.h to make this happen * Moved the GDExtension binder to core This now allows creating scripting languages from GDExtension, with the same ease as if it was a module. It replaces the old PluginScript from Godot 3.x. Warning: GodotCPP will need to be updated to support this (it may be a bit of work as ScriptInstance needs to be created over there again).
2022-03-26 16:48:43 +01:00
ScriptLanguage::CodeCompletionOption option(shader_type, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
Add completion for shader_type
2022-01-13 18:00:59 +03:00
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: {
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
if (is_shader_inc) {
for (int i = 0; i < RenderingServer::SHADER_MAX; i++) {
const Vector<ModeInfo> modes = ShaderTypes::get_singleton()->get_modes(RenderingServer::ShaderMode(i));
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
for (int j = 0; j < modes.size(); j++) {
const ModeInfo &info = modes[j];
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
if (!info.options.is_empty()) {
bool found = false;
for (int k = 0; k < info.options.size(); k++) {
if (shader->render_modes.has(String(info.name) + "_" + String(info.options[k]))) {
found = true;
}
}
if (!found) {
for (int k = 0; k < info.options.size(); k++) {
ScriptLanguage::CodeCompletionOption option(String(info.name) + "_" + String(info.options[k]), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
r_options->push_back(option);
}
}
} else {
const String name = String(info.name);
if (!shader->render_modes.has(name)) {
ScriptLanguage::CodeCompletionOption option(name, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
r_options->push_back(option);
}
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
}
}
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
}
} else {
for (int i = 0; i < p_info.render_modes.size(); i++) {
const ModeInfo &info = p_info.render_modes[i];
if (!info.options.is_empty()) {
bool found = false;
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
for (int j = 0; j < info.options.size(); j++) {
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
if (shader->render_modes.has(String(info.name) + "_" + String(info.options[j]))) {
found = true;
}
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +03:00
}
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
if (!found) {
for (int j = 0; j < info.options.size(); j++) {
ScriptLanguage::CodeCompletionOption option(String(info.name) + "_" + String(info.options[j]), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
r_options->push_back(option);
}
}
} else {
const String name = String(info.name);
if (!shader->render_modes.has(name)) {
ScriptLanguage::CodeCompletionOption option(name, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
r_options->push_back(option);
}
Refactor render_mode in shaders, forbid declaring duplicates
2021-12-21 17:21:55 +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
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;
Reduce and prevent unnecessary random-access to `List` Random-access access to `List` when iterating is `O(n^2)` (`O(n)` when accessing a single element) * Removed subscript operator, in favor of a more explicit `get` * Added conversion from `Iterator` to `ConstIterator` * Remade existing operations into other solutions when applicable
2024-04-15 15:18:34 +02:00
for (ShaderLanguage::MemberNode *member : node->members) {
ScriptLanguage::CodeCompletionOption option(member->name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER);
Implementation of 'struct' for shaders
2020-01-17 22:35:22 +03:00
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;
Re-allows constants in global space to be initialized with function call
2023-09-13 19:11:12 +03:00
for (int i = 0; i < shader->vfunctions.size(); i++) {
if (shader->vfunctions[i].name == E.key) {
Remove incorrect items from completion of main functions in shader
2022-01-24 10:01:24 +03:00
found = true;
break;
}
}
if (found) {
continue;
}
Add GDExtension support to Script * Ability to create script languages from GDExtension * Some additions to gdnative_extension.h to make this happen * Moved the GDExtension binder to core This now allows creating scripting languages from GDExtension, with the same ease as if it was a module. It replaces the old PluginScript from Godot 3.x. Warning: GodotCPP will need to be updated to support this (it may be a bit of work as ScriptInstance needs to be created over there again).
2022-03-26 16:48:43 +01:00
ScriptLanguage::CodeCompletionOption option(E.key, ScriptLanguage::CODE_COMPLETION_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;
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<String, ScriptLanguage::CodeCompletionKind> 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) {
Add GDExtension support to Script * Ability to create script languages from GDExtension * Some additions to gdnative_extension.h to make this happen * Moved the GDExtension binder to core This now allows creating scripting languages from GDExtension, with the same ease as if it was a module. It replaces the old PluginScript from Godot 3.x. Warning: GodotCPP will need to be updated to support this (it may be a bit of work as ScriptInstance needs to be created over there again).
2022-03-26 16:48:43 +01:00
matches.insert(E.key, ScriptLanguage::CODE_COMPLETION_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++) {
Add GDExtension support to Script * Ability to create script languages from GDExtension * Some additions to gdnative_extension.h to make this happen * Moved the GDExtension binder to core This now allows creating scripting languages from GDExtension, with the same ease as if it was a module. It replaces the old PluginScript from Godot 3.x. Warning: GodotCPP will need to be updated to support this (it may be a bit of work as ScriptInstance needs to be created over there again).
2022-03-26 16:48:43 +01:00
matches.insert(block->parent_function->arguments[i].name, ScriptLanguage::CODE_COMPLETION_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) {
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
if (is_shader_inc) {
for (int i = 0; i < RenderingServer::SHADER_MAX; i++) {
const HashMap<StringName, ShaderLanguage::FunctionInfo> info = ShaderTypes::get_singleton()->get_functions(RenderingServer::ShaderMode(i));
if (info.has("global")) {
for (const KeyValue<StringName, BuiltInInfo> &E : info["global"].built_ins) {
ScriptLanguage::CodeCompletionKind kind = ScriptLanguage::CODE_COMPLETION_KIND_MEMBER;
if (E.value.constant) {
kind = ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT;
}
matches.insert(E.key, kind);
}
}
if (info.has("constants")) {
for (const KeyValue<StringName, BuiltInInfo> &E : info["constants"].built_ins) {
ScriptLanguage::CodeCompletionKind kind = ScriptLanguage::CODE_COMPLETION_KIND_MEMBER;
if (E.value.constant) {
kind = ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT;
}
matches.insert(E.key, kind);
}
}
if (skip_function != StringName() && info.has(skip_function)) {
for (const KeyValue<StringName, BuiltInInfo> &E : info[skip_function].built_ins) {
ScriptLanguage::CodeCompletionKind kind = ScriptLanguage::CODE_COMPLETION_KIND_MEMBER;
if (E.value.constant) {
kind = ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT;
}
matches.insert(E.key, kind);
}
}
}
} else {
if (p_info.functions.has("global")) {
for (const KeyValue<StringName, BuiltInInfo> &E : p_info.functions["global"].built_ins) {
ScriptLanguage::CodeCompletionKind kind = ScriptLanguage::CODE_COMPLETION_KIND_MEMBER;
if (E.value.constant) {
kind = ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT;
}
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
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +03:00
if (p_info.functions.has("constants")) {
for (const KeyValue<StringName, BuiltInInfo> &E : p_info.functions["constants"].built_ins) {
ScriptLanguage::CodeCompletionKind kind = ScriptLanguage::CODE_COMPLETION_KIND_MEMBER;
if (E.value.constant) {
kind = ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT;
}
matches.insert(E.key, kind);
Fix built-in(PI, TAU, E) assignment to a global constant in a shader
2021-11-29 10:21:10 +03:00
}
}
Fix errors when using built-ins in shaderinc
2022-07-25 08:19:48 +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) {
ScriptLanguage::CodeCompletionKind kind = ScriptLanguage::CODE_COMPLETION_KIND_MEMBER;
if (E.value.constant) {
kind = ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT;
}
matches.insert(E.key, kind);
Fix shader TIME auto-completion
2020-03-19 21:26:35 +03:00
}
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) {
Add GDExtension support to Script * Ability to create script languages from GDExtension * Some additions to gdnative_extension.h to make this happen * Moved the GDExtension binder to core This now allows creating scripting languages from GDExtension, with the same ease as if it was a module. It replaces the old PluginScript from Godot 3.x. Warning: GodotCPP will need to be updated to support this (it may be a bit of work as ScriptInstance needs to be created over there again).
2022-03-26 16:48:43 +01:00
matches.insert(E.key, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
Fix completion for global constants in shaders
2022-01-13 19:49:43 +03:00
}
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
for (const KeyValue<StringName, ShaderNode::Varying> &E : shader->varyings) {
Add GDExtension support to Script * Ability to create script languages from GDExtension * Some additions to gdnative_extension.h to make this happen * Moved the GDExtension binder to core This now allows creating scripting languages from GDExtension, with the same ease as if it was a module. It replaces the old PluginScript from Godot 3.x. Warning: GodotCPP will need to be updated to support this (it may be a bit of work as ScriptInstance needs to be created over there again).
2022-03-26 16:48:43 +01:00
matches.insert(E.key, ScriptLanguage::CODE_COMPLETION_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) {
Add GDExtension support to Script * Ability to create script languages from GDExtension * Some additions to gdnative_extension.h to make this happen * Moved the GDExtension binder to core This now allows creating scripting languages from GDExtension, with the same ease as if it was a module. It replaces the old PluginScript from Godot 3.x. Warning: GodotCPP will need to be updated to support this (it may be a bit of work as ScriptInstance needs to be created over there again).
2022-03-26 16:48:43 +01:00
matches.insert(E.key, ScriptLanguage::CODE_COMPLETION_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
Re-allows constants in global space to be initialized with function call
2023-09-13 19:11:12 +03:00
for (int i = 0; i < shader->vfunctions.size(); i++) {
if (!shader->vfunctions[i].callable || shader->vfunctions[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
}
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
matches.insert(String(shader->vfunctions[i].rname), ScriptLanguage::CODE_COMPLETION_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
Allow using stage functions inside custom shader functions
2024-06-27 10:18:44 +03:00
if (stages) {
// Stage functions can be used in custom functions as well, that why need to check them all.
for (const KeyValue<StringName, FunctionInfo> &E : *stages) {
for (const KeyValue<StringName, StageFunctionInfo> &F : E.value.stage_functions) {
if (F.value.skip_function == skip_function && stages->has(skip_function)) {
continue;
}
matches.insert(String(F.key), ScriptLanguage::CODE_COMPLETION_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) {
Forbid calling of derivative functions in incorrect functions
2024-06-19 18:38:51 +03:00
if ((low_end && builtin_func_defs[idx].high_end) || _check_restricted_func(builtin_func_defs[idx].name, skip_function)) {
Hides high-level functions from GLES2 shader autocompletion
2020-01-23 12:41:21 +03:00
idx++;
continue;
}
Forbid calling of derivative functions in incorrect functions
2024-06-19 18:38:51 +03:00
Add GDExtension support to Script * Ability to create script languages from GDExtension * Some additions to gdnative_extension.h to make this happen * Moved the GDExtension binder to core This now allows creating scripting languages from GDExtension, with the same ease as if it was a module. It replaces the old PluginScript from Godot 3.x. Warning: GodotCPP will need to be updated to support this (it may be a bit of work as ScriptInstance needs to be created over there again).
2022-03-26 16:48:43 +01:00
matches.insert(String(builtin_func_defs[idx].name), ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
Implemented local shader arrays
2019-07-10 19:52:50 +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
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) {
Add GDExtension support to Script * Ability to create script languages from GDExtension * Some additions to gdnative_extension.h to make this happen * Moved the GDExtension binder to core This now allows creating scripting languages from GDExtension, with the same ease as if it was a module. It replaces the old PluginScript from Godot 3.x. Warning: GodotCPP will need to be updated to support this (it may be a bit of work as ScriptInstance needs to be created over there again).
2022-03-26 16:48:43 +01:00
matches.insert(String(builtin_func_defs[idx].name), ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
Implemented local shader arrays
2019-07-10 19:52:50 +03:00
}
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
Add GDExtension support to Script * Ability to create script languages from GDExtension * Some additions to gdnative_extension.h to make this happen * Moved the GDExtension binder to core This now allows creating scripting languages from GDExtension, with the same ease as if it was a module. It replaces the old PluginScript from Godot 3.x. Warning: GodotCPP will need to be updated to support this (it may be a bit of work as ScriptInstance needs to be created over there again).
2022-03-26 16:48:43 +01:00
for (const KeyValue<String, ScriptLanguage::CodeCompletionKind> &E : matches) {
ScriptLanguage::CodeCompletionOption option(E.key, E.value);
if (E.value == ScriptLanguage::CODE_COMPLETION_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;
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
String calltip;
FIx autocompletion for emit_particle in shader editor
2020-10-13 11:53:06 +03:00
while (block) {
if (block->parent_function) {
block_function = block->parent_function->name;
}
block = block->parent_block;
}
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
for (int i = 0, overload_index = 0; i < shader->vfunctions.size(); i++) {
if (!shader->vfunctions[i].callable || shader->vfunctions[i].rname != 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
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
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
if (shader->vfunctions[i].function->return_type == TYPE_STRUCT) {
calltip += String(shader->vfunctions[i].function->return_struct_name);
} else {
calltip += get_datatype_name(shader->vfunctions[i].function->return_type);
}
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
if (shader->vfunctions[i].function->return_array_size > 0) {
calltip += "[";
calltip += itos(shader->vfunctions[i].function->return_array_size);
calltip += "]";
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
calltip += " ";
calltip += shader->vfunctions[i].rname;
calltip += "(";
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
for (int j = 0; j < shader->vfunctions[i].function->arguments.size(); j++) {
if (j > 0) {
calltip += ", ";
} else {
calltip += " ";
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
if (j == completion_argument) {
calltip += char32_t(0xFFFF);
}
Added const qualifier support for function arguments in shaders
2020-07-01 11:55:49 +03:00
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
if (shader->vfunctions[i].function->arguments[j].is_const) {
calltip += "const ";
}
Show shader method out/inout qualifier in intellisense
2020-03-18 15:43:05 +03:00
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
if (shader->vfunctions[i].function->arguments[j].qualifier != ArgumentQualifier::ARGUMENT_QUALIFIER_IN) {
if (shader->vfunctions[i].function->arguments[j].qualifier == ArgumentQualifier::ARGUMENT_QUALIFIER_OUT) {
calltip += "out ";
} else { // ArgumentQualifier::ARGUMENT_QUALIFIER_INOUT
calltip += "inout ";
Fix completion of functions with struct param/return type in shaders
2024-05-28 12:13:25 +03:00
}
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
if (shader->vfunctions[i].function->arguments[j].type == TYPE_STRUCT) {
calltip += String(shader->vfunctions[i].function->arguments[j].struct_name);
} else {
calltip += get_datatype_name(shader->vfunctions[i].function->arguments[j].type);
}
calltip += " ";
calltip += shader->vfunctions[i].function->arguments[j].name;
Allow shader arrays to be passed as parameters and return value
2021-05-21 19:16:23 +03:00
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
if (shader->vfunctions[i].function->arguments[j].array_size > 0) {
calltip += "[";
calltip += itos(shader->vfunctions[i].function->arguments[j].array_size);
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
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
if (j == completion_argument) {
calltip += char32_t(0xFFFF);
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
}
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
if (shader->vfunctions[i].function->arguments.size()) {
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
}
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
calltip += ")";
New Demo, Screen Space Shaders -Fixes to screen space shaders. -Fixes to isometric light demo.
2015-03-10 00:53:09 -03:00
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
if (overload_index < function_overload_count[shader->vfunctions[i].rname]) {
overload_index++;
calltip += "\n";
continue;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
r_call_hint = calltip;
return OK;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Allow using stage functions inside custom shader functions
2024-06-27 10:18:44 +03:00
if (stages) {
// Stage functions can be used in custom functions as well, that why need to check them all.
for (const KeyValue<StringName, FunctionInfo> &S : *stages) {
for (const KeyValue<StringName, StageFunctionInfo> &E : S.value.stage_functions) {
// No need to check for the skip function here.
if (completion_function != E.key) {
continue;
}
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
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;
}
}
}
Implement custom function overloading in shading language
2024-05-27 22:16:54 +03:00
int idx = 0;
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
while (builtin_func_defs[idx].name) {
Forbid calling of derivative functions in incorrect functions
2024-06-19 18:38:51 +03:00
if ((low_end && builtin_func_defs[idx].high_end) || _check_restricted_func(builtin_func_defs[idx].name, block_function)) {
Hides high-level functions from GLES2 shader autocompletion
2020-01-23 12:41:21 +03:00
idx++;
continue;
}
Show shader method out/inout qualifier in intellisense
2020-03-18 15:43:05 +03:00
int idx2 = 0;
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
HashSet<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' };
Add coloring for completion of vector components
2023-03-12 10:33:38 +03:00
const String theme_color_names[4] = { "axis_x_color", "axis_y_color", "axis_z_color", "axis_w_color" };
-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++) {
Add coloring for completion of vector components
2023-03-12 10:33:38 +03:00
r_options->push_back(ScriptLanguage::CodeCompletionOption(String::chr(colv[i]), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT, ScriptLanguage::LOCATION_OTHER, theme_color_names[i]));
r_options->push_back(ScriptLanguage::CodeCompletionOption(String::chr(coordv[i]), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT, ScriptLanguage::LOCATION_OTHER, theme_color_names[i]));
r_options->push_back(ScriptLanguage::CodeCompletionOption(String::chr(coordt[i]), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT, ScriptLanguage::LOCATION_OTHER, theme_color_names[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
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: {
Add `hint_color` support for `vec3` in shaders
2022-05-01 09:47:35 +03:00
if (completion_base == DataType::TYPE_VEC3 || completion_base == DataType::TYPE_VEC4) {
Prevent duplicated hints in shader uniform completion
2022-09-11 14:49:19 +03:00
if (current_uniform_hint == ShaderNode::Uniform::HINT_NONE) {
ScriptLanguage::CodeCompletionOption option("source_color", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
r_options->push_back(option);
}
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
} else if ((completion_base == DataType::TYPE_INT || completion_base == DataType::TYPE_FLOAT) && !completion_base_array) {
Prevent duplicated hints in shader uniform completion
2022-09-11 14:49:19 +03:00
if (current_uniform_hint == ShaderNode::Uniform::HINT_NONE) {
Add `hint_enum` for uniform int in gdshader
2024-07-13 14:30:08 -04:00
Vector<String> options;
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
Prevent duplicated hints in shader uniform completion
2022-09-11 14:49:19 +03:00
if (completion_base == DataType::TYPE_INT) {
Add `hint_enum` for uniform int in gdshader
2024-07-13 14:30:08 -04:00
options.push_back("hint_range(0, 100, 1)");
options.push_back("hint_enum(\"Zero\", \"One\", \"Two\")");
Prevent duplicated hints in shader uniform completion
2022-09-11 14:49:19 +03:00
} else {
Add `hint_enum` for uniform int in gdshader
2024-07-13 14:30:08 -04:00
options.push_back("hint_range(0.0, 1.0, 0.1)");
Prevent duplicated hints in shader uniform completion
2022-09-11 14:49:19 +03:00
}
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
Add `hint_enum` for uniform int in gdshader
2024-07-13 14:30:08 -04:00
for (const String &option_text : options) {
String hint_name = option_text.substr(0, option_text.find_char(char32_t('(')));
ScriptLanguage::CodeCompletionOption option(hint_name, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
option.insert_text = option_text;
r_options->push_back(option);
}
Prevent duplicated hints in shader uniform completion
2022-09-11 14:49:19 +03:00
}
Fix completion of `source_color` hint for texture arrays in shaders
2023-04-08 20:09:27 +03:00
} else if ((int(completion_base) > int(TYPE_MAT4) && int(completion_base) < int(TYPE_STRUCT))) {
Prevent duplicated hints in shader uniform completion
2022-09-11 14:49:19 +03:00
Vector<String> options;
Add autocomplete for filter/repeat hints on uniform arrays
2023-07-13 11:27:28 +12:00
if (current_uniform_filter == FILTER_DEFAULT) {
options.push_back("filter_linear");
options.push_back("filter_linear_mipmap");
options.push_back("filter_linear_mipmap_anisotropic");
options.push_back("filter_nearest");
options.push_back("filter_nearest_mipmap");
options.push_back("filter_nearest_mipmap_anisotropic");
}
if (current_uniform_repeat == REPEAT_DEFAULT) {
options.push_back("repeat_enable");
options.push_back("repeat_disable");
}
Fix completion of `source_color` hint for texture arrays in shaders
2023-04-08 20:09:27 +03:00
if (completion_base_array) {
if (current_uniform_hint == ShaderNode::Uniform::HINT_NONE) {
options.push_back("source_color");
}
} else {
if (current_uniform_hint == ShaderNode::Uniform::HINT_NONE) {
options.push_back("hint_anisotropy");
options.push_back("hint_default_black");
options.push_back("hint_default_white");
options.push_back("hint_default_transparent");
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_screen_texture");
options.push_back("hint_normal_roughness_texture");
options.push_back("hint_depth_texture");
options.push_back("source_color");
}
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
}
for (int i = 0; i < options.size(); i++) {
Add GDExtension support to Script * Ability to create script languages from GDExtension * Some additions to gdnative_extension.h to make this happen * Moved the GDExtension binder to core This now allows creating scripting languages from GDExtension, with the same ease as if it was a module. It replaces the old PluginScript from Godot 3.x. Warning: GodotCPP will need to be updated to support this (it may be a bit of work as ScriptInstance needs to be created over there again).
2022-03-26 16:48:43 +01:00
ScriptLanguage::CodeCompletionOption option(options[i], ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
r_options->push_back(option);
}
}
Prevent duplicated hints in shader uniform completion
2022-09-11 14:49:19 +03:00
if (!completion_base_array && !current_uniform_instance_index_defined) {
Add GDExtension support to Script * Ability to create script languages from GDExtension * Some additions to gdnative_extension.h to make this happen * Moved the GDExtension binder to core This now allows creating scripting languages from GDExtension, with the same ease as if it was a module. It replaces the old PluginScript from Godot 3.x. Warning: GodotCPP will need to be updated to support this (it may be a bit of work as ScriptInstance needs to be created over there again).
2022-03-26 16:48:43 +01:00
ScriptLanguage::CodeCompletionOption option("instance_index", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
Added completion for uniform hints in a shader
2021-12-09 20:29:23 +03:00
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
Clean up Shader Preprocessor * Moved preprocessor to Shader and ShaderInclude * Clean up RenderingServer side * Preprocessor is separate from parser now, but it emits tokens with include location hints. * Improved ShaderEditor validation code * Added include file code completion * Added notification for all files affected by a broken include.
2022-06-29 11:31:18 +02:00
Vector<ShaderLanguage::FilePosition> ShaderLanguage::get_include_positions() {
return include_positions;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on 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
Fix orphan strings in shader preprocessor
2024-11-26 11:59:52 +03:00
if (instance_counter.get() == 0) {
Improve code for setup of `global_func_set` in `ShaderLanguage`
2024-07-02 18:16:04 +03:00
int idx = 0;
while (builtin_func_defs[idx].name) {
if (builtin_func_defs[idx].tag == SubClassTag::TAG_GLOBAL) {
global_func_set.insert(builtin_func_defs[idx].name);
Prevent using built-ins for func names in shaders
2024-05-30 21:15:21 +03:00
}
Improve code for setup of `global_func_set` in `ShaderLanguage`
2024-07-02 18:16:04 +03:00
idx++;
Prevent using built-ins for func names in shaders
2024-05-30 21:15:21 +03:00
}
}
Fix orphan strings in shader preprocessor
2024-11-26 11:59:52 +03:00
instance_counter.increment();
Prevent using built-ins for func names in shaders
2024-05-30 21:15:21 +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();
Fix orphan strings in shader preprocessor
2024-11-26 11:59:52 +03:00
instance_counter.decrement();
if (instance_counter.get() == 0) {
Improve code for setup of `global_func_set` in `ShaderLanguage`
2024-07-02 18:16:04 +03:00
global_func_set.clear();
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Reference in a new issue Copy permalink