asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/servers/rendering/shader_language.cpp

7627 lines
236 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* shader_language.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 14:16:55 +02:00
/* https://godotengine.org */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/*************************************************************************/
Update copyright statements to 2020 Happy new year to the wonderful Godot community! We're starting a new decade with a well-established, non-profit, free and open source game engine, and tons of further improvements in the pipeline from hundreds of contributors. Godot will keep getting better, and we're looking forward to all the games that the community will keep developing and releasing with it.
2020-01-01 11:16:22 +01:00
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-05 00:50:27 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#include "shader_language.h"
Make core/ includes absolute, remove subfolders from include path This allows more consistency in the manner we include core headers, where previously there would be a mix of absolute, relative and include path-dependent includes.
2018-09-11 18:13:45 +02:00
#include "core/os/os.h"
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 23:33:38 +01:00
#include "core/string/print_string.h"
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
#include "servers/rendering_server.h"
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
static bool _is_text_char(char32_t c) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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 (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
static bool _is_number(char32_t c) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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 (c >= '0' && c <= '9');
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
static bool _is_hex(char32_t c) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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 (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 20:22:33 +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
"--",
"()",
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
"construct",
"index" };
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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-10 02:10:30 +01: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 21:33:42 +02:00
"IDENTIFIER",
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
"TRUE",
"FALSE",
"REAL_CONSTANT",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
"INT_CONSTANT",
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 16:31:18 +02: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-10 02:10:30 +01: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 04:53:09 +01:00
"TYPE_MAT2",
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 16:31:18 +02: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 16:31:18 +02: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 14:34:23 +02:00
"TYPE_SAMPLERCUBEARRAY",
Make the shader token names consistent.
2018-03-08 00:56:47 +01:00
"INTERPOLATION_FLAT",
"INTERPOLATION_SMOOTH",
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
"CONST",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
"PRECISION_LOW",
"PRECISION_MID",
"PRECISION_HIGH",
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 16:31:18 +02:00
"OP_MOD",
"OP_SHIFT_LEFT",
"OP_SHIFT_RIGHT",
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 16:31:18 +02: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-10 02:10:30 +01: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 16:31:18 +02:00
"CF_FOR",
"CF_WHILE",
"CF_DO",
"CF_SWITCH",
"CF_CASE",
"CF_BREAK",
"CF_CONTINUE",
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
"CF_RETURN",
removed DISCARD built in variable, replaced by actual discard GLSL instruction, fixes #9677
2017-08-29 15:14:07 +02:00
"CF_DISCARD",
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 16:31:18 +02:00
"QUESTION",
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
"COMMA",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
"COLON",
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
"SEMICOLON",
"PERIOD",
"UNIFORM",
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-17 04:52:00 +02: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 16:31:18 +02:00
"VARYING",
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
"IN",
"OUT",
"INOUT",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
"RENDER_MODE",
"HINT_WHITE_TEXTURE",
"HINT_BLACK_TEXTURE",
"HINT_NORMAL_TEXTURE",
Huge amount of improvement in the material system. Materials should be a lot more complete and usable now.
2016-11-21 02:49:53 +01:00
"HINT_ANISO_TEXTURE",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
"HINT_ALBEDO_TEXTURE",
Huge amount of improvement in the material system. Materials should be a lot more complete and usable now.
2016-11-21 02:49:53 +01:00
"HINT_BLACK_ALBEDO_TEXTURE",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
"HINT_COLOR",
"HINT_RANGE",
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-17 04:52:00 +02:00
"HINT_INSTANCE_INDEX",
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
"FILTER_NEAREST",
"FILTER_LINEAR",
"FILTER_NEAREST_MIPMAP",
"FILTER_LINEAR_MIPMAP",
"FILTER_NEAREST_MIPMAP_ANISO",
"FILTER_LINEAR_MIPMAP_ANISO",
"REPEAT_ENABLE",
"REPEAT_DISABLE",
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02: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 16:31:18 +02:00
"CURSOR",
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
"ERROR",
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
"EOF",
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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];
Rename TYPE_REAL to TYPE_FLOAT To be consistent with the naming everywhere else.
2020-12-04 13:25:14 +01:00
if (p_token.type == TK_INT_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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
return name;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02: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 16:31:18 +02: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 21:33:42 +02:00
return tk;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
const ShaderLanguage::KeyWord ShaderLanguage::keyword_list[] = {
{ TK_TRUE, "true" },
{ TK_FALSE, "false" },
{ TK_TYPE_VOID, "void" },
{ TK_TYPE_BOOL, "bool" },
{ TK_TYPE_BVEC2, "bvec2" },
{ TK_TYPE_BVEC3, "bvec3" },
{ TK_TYPE_BVEC4, "bvec4" },
{ TK_TYPE_INT, "int" },
{ TK_TYPE_IVEC2, "ivec2" },
{ TK_TYPE_IVEC3, "ivec3" },
{ TK_TYPE_IVEC4, "ivec4" },
{ TK_TYPE_UINT, "uint" },
{ TK_TYPE_UVEC2, "uvec2" },
{ TK_TYPE_UVEC3, "uvec3" },
{ TK_TYPE_UVEC4, "uvec4" },
{ TK_TYPE_FLOAT, "float" },
{ TK_TYPE_VEC2, "vec2" },
{ TK_TYPE_VEC3, "vec3" },
{ TK_TYPE_VEC4, "vec4" },
{ TK_TYPE_MAT2, "mat2" },
{ TK_TYPE_MAT3, "mat3" },
{ TK_TYPE_MAT4, "mat4" },
{ TK_TYPE_SAMPLER2D, "sampler2D" },
{ TK_TYPE_ISAMPLER2D, "isampler2D" },
{ TK_TYPE_USAMPLER2D, "usampler2D" },
add 3D textures
2018-06-26 13:59:26 +02:00
{ TK_TYPE_SAMPLER2DARRAY, "sampler2DArray" },
{ TK_TYPE_ISAMPLER2DARRAY, "isampler2DArray" },
{ TK_TYPE_USAMPLER2DARRAY, "usampler2DArray" },
{ TK_TYPE_SAMPLER3D, "sampler3D" },
{ TK_TYPE_ISAMPLER3D, "isampler3D" },
{ TK_TYPE_USAMPLER3D, "usampler3D" },
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
{ TK_TYPE_SAMPLERCUBE, "samplerCube" },
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
{ TK_TYPE_SAMPLERCUBEARRAY, "samplerCubeArray" },
Added interpolation modifiers to shaderlang
2017-11-27 16:47:46 +01:00
{ TK_INTERPOLATION_FLAT, "flat" },
{ TK_INTERPOLATION_SMOOTH, "smooth" },
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
{ TK_CONST, "const" },
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
{ TK_STRUCT, "struct" },
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
{ TK_PRECISION_LOW, "lowp" },
{ TK_PRECISION_MID, "mediump" },
{ TK_PRECISION_HIGH, "highp" },
{ TK_CF_IF, "if" },
{ TK_CF_ELSE, "else" },
{ TK_CF_FOR, "for" },
{ TK_CF_WHILE, "while" },
{ TK_CF_DO, "do" },
{ TK_CF_SWITCH, "switch" },
{ TK_CF_CASE, "case" },
Implements switch to shaders
2019-08-14 13:22:25 +02:00
{ TK_CF_DEFAULT, "default" },
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
{ TK_CF_BREAK, "break" },
{ TK_CF_CONTINUE, "continue" },
{ TK_CF_RETURN, "return" },
Discarding now works in shaders "discard" has been added to the list of recognised keywords. A flag specifing when discarding is allowed is now set correctly.
2017-09-24 09:27:12 +02:00
{ TK_CF_DISCARD, "discard" },
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
{ TK_UNIFORM, "uniform" },
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-17 04:52:00 +02:00
{ TK_INSTANCE, "instance" },
{ TK_GLOBAL, "global" },
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
{ TK_VARYING, "varying" },
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
{ TK_ARG_IN, "in" },
{ TK_ARG_OUT, "out" },
{ TK_ARG_INOUT, "inout" },
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
{ TK_RENDER_MODE, "render_mode" },
{ TK_HINT_WHITE_TEXTURE, "hint_white" },
{ TK_HINT_BLACK_TEXTURE, "hint_black" },
{ TK_HINT_NORMAL_TEXTURE, "hint_normal" },
Several fixes to 3D rendering, and multimesh implementation.
2019-09-14 05:37:42 +02:00
{ TK_HINT_ROUGHNESS_NORMAL_TEXTURE, "hint_roughness_normal" },
{ TK_HINT_ROUGHNESS_R, "hint_roughness_r" },
{ TK_HINT_ROUGHNESS_G, "hint_roughness_g" },
{ TK_HINT_ROUGHNESS_B, "hint_roughness_b" },
{ TK_HINT_ROUGHNESS_A, "hint_roughness_a" },
{ TK_HINT_ROUGHNESS_GRAY, "hint_roughness_gray" },
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
{ TK_HINT_ANISO_TEXTURE, "hint_aniso" },
{ TK_HINT_ALBEDO_TEXTURE, "hint_albedo" },
{ TK_HINT_BLACK_ALBEDO_TEXTURE, "hint_black_albedo" },
{ TK_HINT_COLOR, "hint_color" },
{ TK_HINT_RANGE, "hint_range" },
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-17 04:52:00 +02:00
{ TK_HINT_INSTANCE_INDEX, "instance_index" },
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
{ TK_FILTER_NEAREST, "filter_nearest" },
{ TK_FILTER_LINEAR, "filter_linear" },
{ TK_FILTER_NEAREST_MIPMAP, "filter_nearest_mipmap" },
{ TK_FILTER_LINEAR_MIPMAP, "filter_linear_mipmap" },
{ TK_FILTER_NEAREST_MIPMAP_ANISO, "filter_nearest_mipmap_aniso" },
{ TK_FILTER_LINEAR_MIPMAP_ANISO, "filter_linear_mipmap_aniso" },
{ TK_REPEAT_ENABLE, "repeat_enable" },
{ TK_REPEAT_DISABLE, "repeat_disable" },
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
{ TK_SHADER_TYPE, "shader_type" },
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
{ TK_ERROR, nullptr }
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
};
-Fixed shader commets, /* */ works well and crash is solved, fixes #1711
2015-04-26 17:34:42 +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 21:33:42 +02:00
ShaderLanguage::Token ShaderLanguage::_get_token() {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02: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-10 02:10:30 +01: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 21:33:42 +02: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 16:31:18 +02: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 21:33:42 +02: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 21:33:42 +02:00
case '*': { // block comment
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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 21:33:42 +02: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 21:33:42 +02: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 21:33:42 +02:00
tk_line++;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
char_idx++;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
} break;
case '/': { // line comment skip
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02: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 21:33:42 +02:00
return _make_token(TK_EOF);
}
char_idx++;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
} break;
case '=': { // diveq
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
char_idx++;
return _make_token(TK_OP_ASSIGN_DIV);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
} break;
default:
return _make_token(TK_OP_DIV);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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 21:33:42 +02:00
char_idx++;
return _make_token(TK_OP_EQUAL);
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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 21:33:42 +02: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 21:33:42 +02: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 21:33:42 +02:00
char_idx++;
return _make_token(TK_OP_ASSIGN_SHIFT_LEFT);
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
return _make_token(TK_OP_SHIFT_LEFT);
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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 21:33:42 +02:00
char_idx++;
return _make_token(TK_OP_GREATER_EQUAL);
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02: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 21:33:42 +02:00
char_idx++;
return _make_token(TK_OP_ASSIGN_SHIFT_RIGHT);
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
return _make_token(TK_OP_SHIFT_RIGHT);
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
return _make_token(TK_OP_GREATER);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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 21:33:42 +02:00
char_idx++;
return _make_token(TK_OP_NOT_EQUAL);
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
return _make_token(TK_OP_NOT);
} break;
//case '"' //string - no strings in shader
//case '\'' //string - no strings in shader
case '{':
return _make_token(TK_CURLY_BRACKET_OPEN);
case '}':
return _make_token(TK_CURLY_BRACKET_CLOSE);
case '[':
return _make_token(TK_BRACKET_OPEN);
case ']':
return _make_token(TK_BRACKET_CLOSE);
case '(':
return _make_token(TK_PARENTHESIS_OPEN);
case ')':
return _make_token(TK_PARENTHESIS_CLOSE);
case ',':
return _make_token(TK_COMMA);
case ';':
return _make_token(TK_SEMICOLON);
case '?':
return _make_token(TK_QUESTION);
case ':':
return _make_token(TK_COLON);
case '^':
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 21:33:42 +02: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 21:33:42 +02: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 21:33:42 +02: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 21:33:42 +02:00
char_idx++;
return _make_token(TK_OP_OR);
}
return _make_token(TK_OP_BIT_OR);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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 21:33:42 +02: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 21:33:42 +02: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 21:33:42 +02:00
char_idx++;
return _make_token(TK_OP_INCREMENT);
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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 21:33:42 +02: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 21:33:42 +02:00
char_idx++;
return _make_token(TK_OP_DECREMENT);
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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 21:33:42 +02:00
char_idx++;
return _make_token(TK_OP_ASSIGN_MOD);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
return _make_token(TK_OP_MOD);
} break;
default: {
char_idx--; //go back one, since we have no idea what this is
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 (_is_number(GETCHAR(0)) || (GETCHAR(0) == '.' && _is_number(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 21:33:42 +02:00
// parse number
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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;
bool hexa_found = false;
bool sign_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;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
String str;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
int i = 0;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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(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 (period_found || exponent_found || hexa_found || float_suffix_found) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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, "Invalid 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
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
period_found = true;
} else if (GETCHAR(i) == 'x') {
Style: Enforce braces around if blocks and loops 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 (hexa_found || str.length() != 1 || str[0] != '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
return _make_token(TK_ERROR, "Invalid 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
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
hexa_found = true;
} else if (GETCHAR(i) == 'e') {
Style: Enforce braces around if blocks and loops 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 (hexa_found || exponent_found || float_suffix_found) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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, "Invalid 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
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
exponent_found = true;
* 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
} else if (GETCHAR(i) == 'f') {
Style: Enforce braces around if blocks and loops 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 (hexa_found || exponent_found) {
* 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 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
}
* 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
float_suffix_found = 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 21:33:42 +02:00
} else if (_is_number(GETCHAR(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 (float_suffix_found) {
* 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 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
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
} else if (hexa_found && _is_hex(GETCHAR(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
} else if ((GETCHAR(i) == '-' || GETCHAR(i) == '+') && exponent_found) {
Style: Enforce braces around if blocks and loops 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 (sign_found) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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, "Invalid 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
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
sign_found = 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 {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02: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-10 02:10:30 +01:00
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
str += char32_t(GETCHAR(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 21:33:42 +02:00
i++;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02: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
if (hexa_found) {
Support for hex numbers in shaders
2019-12-29 10:19:10 +01:00
//integer(hex)
if (str.size() > 11 || !str.is_valid_hex_number(true)) { // > 0xFFFFFFFF
return _make_token(TK_ERROR, "Invalid (hexadecimal) numeric constant");
}
Always treat exponent as float
2018-12-28 09:20:11 +01:00
} else if (period_found || exponent_found || float_suffix_found) {
* 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
//floats
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
if (last_char != '.' && !_is_number(last_char)) {
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) {
//strip the suffix
str = str.left(str.length() - 1);
//compensate reading cursor position
char_idx += 1;
}
if (!str.is_valid_float()) {
return _make_token(TK_ERROR, "Invalid (float) numeric constant");
}
} else {
//integers
if (!_is_number(last_char)) {
return _make_token(TK_ERROR, "Invalid (integer) numeric constant");
}
if (!str.is_valid_integer()) {
return _make_token(TK_ERROR, "Invalid numeric constant");
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02: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 13:25:14 +01:00
tk.type = TK_FLOAT_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 04:53:09 +01:00
Support for hex numbers in shaders
2019-12-29 10:19:10 +01:00
if (hexa_found) {
Remove 32-bit String hex_to_int method
2020-05-13 11:19:29 +02:00
tk.constant = (double)str.hex_to_int(true);
Support for hex numbers in shaders
2019-12-29 10:19:10 +01:00
} else {
Make all String float conversion methods be 64-bit
2020-07-24 20:07:57 +02:00
tk.constant = str.to_float();
Support for hex numbers in shaders
2019-12-29 10:19:10 +01: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-10 02:10:30 +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 21:33:42 +02:00
return tk;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02: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 16:31:18 +02: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 21:33:42 +02:00
return _make_token(TK_PERIOD);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
if (_is_text_char(GETCHAR(0))) {
// parse identifier
String str;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 (_is_text_char(GETCHAR(0))) {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02: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 21:33:42 +02:00
char_idx++;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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-10 02:10:30 +01: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 16:31:18 +02: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 21:33:42 +02:00
}
idx++;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Prevent shader crash when name conflict with "dus" and "__" occured
2020-02-01 10:34:02 +01: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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-10 02:10:30 +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 21:33:42 +02:00
} break;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
ERR_PRINT("BUG");
return Token();
allow comments and whitespace before shader_type declaration
2018-01-25 02:00:51 +01:00
#undef GETCHAR
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
String ShaderLanguage::token_debug(const String &p_code) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
clear();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-10 02:10:30 +01:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
String output;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 16:31:18 +02:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
return output;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Do not allow samplers where they dont belong (variables/return types), fixes #15133
2018-11-12 12:36:26 +01: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-10 02:10:30 +01: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 21:33:42 +02: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 14:34:23 +02:00
p_type == TK_TYPE_SAMPLERCUBE ||
p_type == TK_TYPE_SAMPLERCUBEARRAY);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02: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 21:33:42 +02: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 21:33:42 +02: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 21:33:42 +02: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 21:33:42 +02: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-10 02:10:30 +01:00
}
Added local array initializer
2019-07-15 17:47:22 +02: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 17:47:22 +02:00
default:
break;
}
return "";
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 14:34:23 +02:00
case TYPE_SAMPLERCUBEARRAY:
return "samplerCubeArray";
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
case TYPE_STRUCT:
return "struct";
case TYPE_MAX:
return "invalid";
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
return "";
}
bool ShaderLanguage::is_token_nonvoid_datatype(TokenType p_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
return is_token_datatype(p_type) && p_type != TK_TYPE_VOID;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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();
Clears completion_class in shaders (may cause troubles if not).
2020-01-19 14:35:54 +01:00
completion_class = SubClassTag::TAG_GLOBAL;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
completion_struct = StringName();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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
error_line = 0;
tk_line = 1;
char_idx = 0;
error_set = false;
error_str = "";
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 21:33:42 +02: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 21:33:42 +02:00
memdelete(n);
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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) {
if (p_function_info.built_ins.has(p_identifier)) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
if (r_data_type) {
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
*r_data_type = p_function_info.built_ins[p_identifier].type;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
}
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 21:16:47 +01:00
if (r_is_const) {
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
*r_is_const = p_function_info.built_ins[p_identifier].constant;
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 21:16:47 +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 21:33:42 +02:00
if (r_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
*r_type = IDENTIFIER_BUILTIN_VAR;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
return true;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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-10 02:10:30 +01: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 21:33:42 +02: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-10 02:10:30 +01:00
}
Implemented local shader constants
2019-08-05 09:35:53 +02:00
if (r_is_const) {
*r_is_const = p_block->variables[p_identifier].is_const;
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
if (r_array_size) {
*r_array_size = p_block->variables[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 21:33:42 +02: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_LOCAL_VAR;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (r_struct_name) {
*r_struct_name = p_block->variables[p_identifier].struct_name;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02: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 21:33:42 +02:00
break;
} else {
Allow to reassign local variables in shaders
2020-03-20 12:09:43 +01:00
if (p_allow_reassign) {
break;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ERR_FAIL_COND_V(!p_block->parent_block, false);
p_block = p_block->parent_block;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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 21:33:42 +02: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 21:33:42 +02: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_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 21:33:42 +02:00
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (r_struct_name) {
*r_struct_name = function->arguments[i].type_str;
}
Added const qualifier support for function arguments in shaders
2020-07-01 10:55:49 +02:00
if (r_is_const) {
*r_is_const = function->arguments[i].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 21:33:42 +02:00
return true;
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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 21:33:42 +02:00
}
Implement shader array support for varyings
2019-07-29 16:08:25 +02: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 21:33:42 +02: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 21:33:42 +02:00
}
return true;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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 21:33:42 +02: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 21:33:42 +02:00
}
return true;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
if (shader->constants.has(p_identifier)) {
if (r_data_type) {
*r_data_type = shader->constants[p_identifier].type;
}
Implemented global const array to shaders
2019-10-11 19:43:42 +02:00
if (r_array_size) {
*r_array_size = shader->constants[p_identifier].array_size;
}
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
if (r_type) {
*r_type = IDENTIFIER_CONSTANT;
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (r_struct_name) {
*r_struct_name = shader->constants[p_identifier].type_str;
}
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
return true;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < shader->functions.size(); i++) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (!shader->functions[i].callable) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02: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-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (shader->functions[i].name == p_identifier) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
if (r_data_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
*r_data_type = shader->functions[i].function->return_type;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02: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 21:33:42 +02:00
}
Show that identifier found in function names
2019-08-10 06:15:33 +02: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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
return false;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 ShaderLanguage::_validate_operator(OperatorNode *p_op, DataType *r_ret_type) {
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;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +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
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 21:33:42 +02:00
case OP_EQUAL:
case OP_NOT_EQUAL: {
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 21:33:42 +02:00
} break;
case OP_LESS:
case OP_LESS_EQUAL:
case OP_GREATER:
case OP_GREATER_EQUAL: {
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-10 02:10:30 +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 21:33:42 +02:00
} break;
case OP_AND:
case OP_OR: {
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-10 02:10:30 +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 21:33:42 +02:00
} break;
case OP_NOT: {
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-10 02:10:30 +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 21:33:42 +02:00
} break;
case OP_INCREMENT:
case OP_DECREMENT:
case OP_POST_INCREMENT:
case OP_POST_DECREMENT:
case OP_NEGATE: {
DataType na = p_op->arguments[0]->get_datatype();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
valid = na > TYPE_BOOL && na < TYPE_MAT2;
ret_type = na;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
} break;
case OP_ADD:
case OP_SUB:
case OP_MUL:
case OP_DIV: {
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 21:33:42 +02:00
//make things easier;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
SWAP(na, nb);
}
if (na == nb) {
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
valid = (na > TYPE_BOOL && na <= TYPE_MAT4);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ret_type = na;
} else if (na == TYPE_INT && nb == TYPE_IVEC2) {
valid = true;
ret_type = TYPE_IVEC2;
} else if (na == TYPE_INT && nb == TYPE_IVEC3) {
valid = true;
ret_type = TYPE_IVEC3;
} else if (na == TYPE_INT && nb == TYPE_IVEC4) {
valid = true;
ret_type = TYPE_IVEC4;
} else if (na == TYPE_UINT && nb == TYPE_UVEC2) {
valid = true;
ret_type = TYPE_UVEC2;
} else if (na == TYPE_UINT && nb == TYPE_UVEC3) {
valid = true;
ret_type = TYPE_UVEC3;
} else if (na == TYPE_UINT && nb == TYPE_UVEC4) {
valid = true;
ret_type = TYPE_UVEC4;
} else if (na == TYPE_FLOAT && nb == TYPE_VEC2) {
valid = true;
ret_type = TYPE_VEC2;
} else if (na == TYPE_FLOAT && nb == TYPE_VEC3) {
valid = true;
ret_type = TYPE_VEC3;
} else if (na == TYPE_FLOAT && nb == TYPE_VEC4) {
valid = true;
ret_type = TYPE_VEC4;
Fix some incorrect conversions which lead to crash in shaders
2020-07-14 19:28:18 +02: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 19:28:18 +02: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 19:28:18 +02: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-07 04:36:37 +02: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-10 02:10:30 +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 21:33:42 +02: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-10 02:10:30 +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 21:33:42 +02:00
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-10 02:10:30 +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 21:33:42 +02:00
} break;
case OP_ASSIGN_SHIFT_LEFT:
case OP_ASSIGN_SHIFT_RIGHT:
case OP_SHIFT_LEFT:
case OP_SHIFT_RIGHT: {
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-07 04:36:37 +02: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 21:33:42 +02:00
}
} break;
case OP_ASSIGN: {
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01: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;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
} break;
case OP_ASSIGN_ADD:
case OP_ASSIGN_SUB:
case OP_ASSIGN_MUL:
case OP_ASSIGN_DIV: {
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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) {
valid = (na > TYPE_BOOL && na < TYPE_MAT2) || (p_op->op == OP_ASSIGN_MUL && na >= TYPE_MAT2 && na <= TYPE_MAT4);
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 19:28:18 +02: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 19:28:18 +02: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 19:28:18 +02: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 21:33:42 +02: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-10 02:10:30 +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 21:33:42 +02:00
DataType na = p_op->arguments[0]->get_datatype();
DataType nb = p_op->arguments[1]->get_datatype();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02: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-10 02:10:30 +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 21:33:42 +02:00
} break;
case OP_BIT_INVERT: { //unaries
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 21:33:42 +02:00
} break;
case OP_SELECT_IF: {
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-10 02:10:30 +01: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;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
} break;
default: {
ERR_FAIL_V(false);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
return valid;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
const ShaderLanguage::BuiltinFuncDef ShaderLanguage::builtin_func_defs[] = {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
//constructors
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01: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 },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "uint", TYPE_UINT, { TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec2", TYPE_UVEC2, { TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec2", TYPE_UVEC2, { TYPE_UINT, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec3", TYPE_UVEC3, { TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec3", TYPE_UVEC3, { TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec3", TYPE_UVEC3, { TYPE_UVEC2, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec3", TYPE_UVEC3, { TYPE_UINT, TYPE_UVEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_UVEC2, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UVEC2, TYPE_UINT, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_UINT, TYPE_UVEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_UVEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UVEC3, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01: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 21:33:42 +02:00
//conversion scalars
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "int", TYPE_INT, { TYPE_BOOL, TYPE_VOID }, TAG_GLOBAL, false },
{ "int", TYPE_INT, { TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "int", TYPE_INT, { TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01: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 21:33:42 +02:00
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "float", TYPE_FLOAT, { TYPE_BOOL, TYPE_VOID }, TAG_GLOBAL, false },
{ "float", TYPE_FLOAT, { TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "float", TYPE_FLOAT, { TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01: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 21:33:42 +02:00
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "uint", TYPE_UINT, { TYPE_BOOL, TYPE_VOID }, TAG_GLOBAL, true },
{ "uint", TYPE_UINT, { TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "uint", TYPE_UINT, { TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "uint", TYPE_UINT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "bool", TYPE_BOOL, { TYPE_BOOL, TYPE_VOID }, TAG_GLOBAL, false },
{ "bool", TYPE_BOOL, { TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "bool", TYPE_BOOL, { TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01: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 21:33:42 +02:00
//conversion vectors
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01: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 },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "vec2", TYPE_VEC2, { TYPE_UVEC2, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "vec2", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "uvec2", TYPE_UVEC2, { TYPE_BVEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec2", TYPE_UVEC2, { TYPE_IVEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec2", TYPE_UVEC2, { TYPE_UVEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec2", TYPE_UVEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "bvec2", TYPE_BVEC2, { TYPE_BVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "bvec2", TYPE_BVEC2, { TYPE_IVEC2, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "bvec2", TYPE_BVEC2, { TYPE_UVEC2, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01: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 },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "ivec3", TYPE_IVEC3, { TYPE_UVEC3, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01: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 },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "vec3", TYPE_VEC3, { TYPE_UVEC3, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "vec3", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "uvec3", TYPE_UVEC3, { TYPE_BVEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec3", TYPE_UVEC3, { TYPE_IVEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec3", TYPE_UVEC3, { TYPE_UVEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec3", TYPE_UVEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "bvec3", TYPE_BVEC3, { TYPE_BVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "bvec3", TYPE_BVEC3, { TYPE_IVEC3, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "bvec3", TYPE_BVEC3, { TYPE_UVEC3, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01: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 },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "ivec4", TYPE_IVEC4, { TYPE_UVEC4, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01: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 },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "vec4", TYPE_VEC4, { TYPE_UVEC4, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "vec4", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "uvec4", TYPE_UVEC4, { TYPE_BVEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_IVEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_UVEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "uvec4", TYPE_UVEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "bvec4", TYPE_BVEC4, { TYPE_BVEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "bvec4", TYPE_BVEC4, { TYPE_IVEC4, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "bvec4", TYPE_BVEC4, { TYPE_UVEC4, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01: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 21:33:42 +02:00
Added conversions between matrixes in shaders
2018-07-25 17:14:52 +02:00
//conversion between matrixes
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01: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 17:14:52 +02:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
//builtins - trigonometry
Added missing shader functions
2018-02-18 16:08:18 +01:00
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "radians", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "radians", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "radians", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "radians", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "degrees", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "degrees", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "degrees", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "degrees", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "sin", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "sin", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "sin", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "sin", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "cos", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "cos", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "cos", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "cos", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "tan", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "tan", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "tan", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "tan", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "asin", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "asin", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "asin", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "asin", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "acos", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "acos", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "acos", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "acos", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "atan", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "atan", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "atan", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "atan", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "atan", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "atan", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "atan", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "atan", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "sinh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "sinh", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "sinh", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "sinh", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "cosh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "cosh", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "cosh", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "cosh", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "tanh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "tanh", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "tanh", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "tanh", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "asinh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "asinh", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "asinh", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "asinh", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "acosh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "acosh", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "acosh", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "acosh", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "atanh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "atanh", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "atanh", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "atanh", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
Added missing shader functions
2018-02-18 16:08:18 +01:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
//builtins - exponential
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "pow", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "pow", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "pow", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "pow", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "exp", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "exp", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "exp", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "exp", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "log", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "log", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "log", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "log", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "exp2", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "exp2", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "exp2", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "exp2", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "log2", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "log2", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "log2", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "log2", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "sqrt", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "sqrt", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "sqrt", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "sqrt", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "inversesqrt", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "inversesqrt", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "inversesqrt", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "inversesqrt", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
//builtins - common
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "abs", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "abs", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "abs", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "abs", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "abs", TYPE_INT, { TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
{ "abs", TYPE_IVEC2, { TYPE_IVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "abs", TYPE_IVEC3, { TYPE_IVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "abs", TYPE_IVEC4, { TYPE_IVEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "sign", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "sign", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "sign", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "sign", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "sign", TYPE_INT, { TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
{ "sign", TYPE_IVEC2, { TYPE_IVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "sign", TYPE_IVEC3, { TYPE_IVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "sign", TYPE_IVEC4, { TYPE_IVEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "floor", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "floor", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "floor", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "floor", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "trunc", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "trunc", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "trunc", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "trunc", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "round", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "round", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "round", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "round", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "roundEven", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "roundEven", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "roundEven", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "roundEven", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "ceil", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "ceil", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "ceil", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "ceil", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "fract", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "fract", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "fract", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "fract", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "mod", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "mod", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "mod", TYPE_VEC2, { TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "mod", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "mod", TYPE_VEC3, { TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "mod", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "mod", TYPE_VEC4, { TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "modf", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "modf", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "modf", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "modf", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "min", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "min", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "min", TYPE_VEC2, { TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "min", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "min", TYPE_VEC3, { TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "min", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "min", TYPE_VEC4, { TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "min", TYPE_INT, { TYPE_INT, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
{ "min", TYPE_IVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "min", TYPE_IVEC2, { TYPE_IVEC2, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
{ "min", TYPE_IVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "min", TYPE_IVEC3, { TYPE_IVEC3, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
{ "min", TYPE_IVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "min", TYPE_IVEC4, { TYPE_IVEC4, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "min", TYPE_UINT, { TYPE_UINT, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "min", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "min", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "min", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "min", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "min", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "min", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "max", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "max", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "max", TYPE_VEC2, { TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "max", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "max", TYPE_VEC3, { TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "max", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "max", TYPE_VEC4, { TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "max", TYPE_INT, { TYPE_INT, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
{ "max", TYPE_IVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "max", TYPE_IVEC2, { TYPE_IVEC2, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
{ "max", TYPE_IVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "max", TYPE_IVEC3, { TYPE_IVEC3, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
{ "max", TYPE_IVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "max", TYPE_IVEC4, { TYPE_IVEC4, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "max", TYPE_UINT, { TYPE_UINT, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "max", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "max", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "max", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "max", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "max", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "max", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "clamp", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "clamp", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "clamp", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "clamp", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "clamp", TYPE_VEC2, { TYPE_VEC2, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "clamp", TYPE_VEC3, { TYPE_VEC3, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "clamp", TYPE_VEC4, { TYPE_VEC4, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "clamp", TYPE_INT, { TYPE_INT, TYPE_INT, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
{ "clamp", TYPE_IVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "clamp", TYPE_IVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "clamp", TYPE_IVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "clamp", TYPE_IVEC2, { TYPE_IVEC2, TYPE_INT, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
{ "clamp", TYPE_IVEC3, { TYPE_IVEC3, TYPE_INT, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
{ "clamp", TYPE_IVEC4, { TYPE_IVEC4, TYPE_INT, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "clamp", TYPE_UINT, { TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "clamp", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "clamp", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "clamp", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "clamp", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UINT, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "clamp", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UINT, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "clamp", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UINT, TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "mix", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_BVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_BVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_BVEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "mix", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "step", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "step", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "step", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "step", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "step", TYPE_VEC2, { TYPE_FLOAT, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "step", TYPE_VEC3, { TYPE_FLOAT, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "step", TYPE_VEC4, { TYPE_FLOAT, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "smoothstep", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "smoothstep", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "smoothstep", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "smoothstep", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "smoothstep", TYPE_VEC2, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "smoothstep", TYPE_VEC3, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "smoothstep", TYPE_VEC4, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "isnan", TYPE_BOOL, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "isnan", TYPE_BVEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "isnan", TYPE_BVEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "isnan", TYPE_BVEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "isinf", TYPE_BOOL, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "isinf", TYPE_BVEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "isinf", TYPE_BVEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "isinf", TYPE_BVEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "floatBitsToInt", TYPE_INT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "floatBitsToInt", TYPE_IVEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "floatBitsToInt", TYPE_IVEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "floatBitsToInt", TYPE_IVEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "floatBitsToUint", TYPE_UINT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "floatBitsToUint", TYPE_UVEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "floatBitsToUint", TYPE_UVEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "floatBitsToUint", TYPE_UVEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "intBitsToFloat", TYPE_FLOAT, { TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "intBitsToFloat", TYPE_VEC2, { TYPE_IVEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "intBitsToFloat", TYPE_VEC3, { TYPE_IVEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "intBitsToFloat", TYPE_VEC4, { TYPE_IVEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "uintBitsToFloat", TYPE_FLOAT, { TYPE_UINT, TYPE_VOID }, TAG_GLOBAL, true },
{ "uintBitsToFloat", TYPE_VEC2, { TYPE_UVEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "uintBitsToFloat", TYPE_VEC3, { TYPE_UVEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "uintBitsToFloat", TYPE_VEC4, { TYPE_UVEC4, TYPE_VOID }, TAG_GLOBAL, true },
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
//builtins - geometric
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "length", TYPE_FLOAT, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "length", TYPE_FLOAT, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "length", TYPE_FLOAT, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "distance", TYPE_FLOAT, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "distance", TYPE_FLOAT, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "distance", TYPE_FLOAT, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "dot", TYPE_FLOAT, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "dot", TYPE_FLOAT, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "dot", TYPE_FLOAT, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "cross", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "normalize", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "normalize", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "normalize", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "reflect", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "refract", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "faceforward", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "faceforward", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "faceforward", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "matrixCompMult", TYPE_MAT2, { TYPE_MAT2, TYPE_MAT2, TYPE_VOID }, TAG_GLOBAL, false },
{ "matrixCompMult", TYPE_MAT3, { TYPE_MAT3, TYPE_MAT3, TYPE_VOID }, TAG_GLOBAL, false },
{ "matrixCompMult", TYPE_MAT4, { TYPE_MAT4, TYPE_MAT4, TYPE_VOID }, TAG_GLOBAL, false },
{ "outerProduct", TYPE_MAT2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "outerProduct", TYPE_MAT3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "outerProduct", TYPE_MAT4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "transpose", TYPE_MAT2, { TYPE_MAT2, TYPE_VOID }, TAG_GLOBAL, false },
{ "transpose", TYPE_MAT3, { TYPE_MAT3, TYPE_VOID }, TAG_GLOBAL, false },
{ "transpose", TYPE_MAT4, { TYPE_MAT4, TYPE_VOID }, TAG_GLOBAL, false },
{ "determinant", TYPE_FLOAT, { TYPE_MAT2, TYPE_VOID }, TAG_GLOBAL, false },
{ "determinant", TYPE_FLOAT, { TYPE_MAT3, TYPE_VOID }, TAG_GLOBAL, false },
{ "determinant", TYPE_FLOAT, { TYPE_MAT4, TYPE_VOID }, TAG_GLOBAL, false },
{ "inverse", TYPE_MAT2, { TYPE_MAT2, TYPE_VOID }, TAG_GLOBAL, false },
{ "inverse", TYPE_MAT3, { TYPE_MAT3, TYPE_VOID }, TAG_GLOBAL, false },
{ "inverse", TYPE_MAT4, { TYPE_MAT4, TYPE_VOID }, TAG_GLOBAL, false },
{ "lessThan", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "lessThan", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "lessThan", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "lessThan", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "lessThan", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "lessThan", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "lessThan", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "lessThan", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "lessThan", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "greaterThan", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "greaterThan", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "greaterThan", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "greaterThan", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "greaterThan", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "greaterThan", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "greaterThan", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "greaterThan", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "greaterThan", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "lessThanEqual", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "lessThanEqual", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "lessThanEqual", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "lessThanEqual", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "lessThanEqual", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "lessThanEqual", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "lessThanEqual", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "lessThanEqual", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "lessThanEqual", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "greaterThanEqual", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "greaterThanEqual", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "greaterThanEqual", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "greaterThanEqual", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "greaterThanEqual", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "greaterThanEqual", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "greaterThanEqual", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "greaterThanEqual", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "greaterThanEqual", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "equal", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID }, TAG_GLOBAL, false },
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "equal", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "equal", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "equal", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "equal", TYPE_BVEC2, { TYPE_BVEC2, TYPE_BVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC3, { TYPE_BVEC3, TYPE_BVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "equal", TYPE_BVEC4, { TYPE_BVEC4, TYPE_BVEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, 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 21:33:42 +02:00
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
{ "notEqual", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "notEqual", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "notEqual", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID }, TAG_GLOBAL, true },
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "notEqual", TYPE_BVEC2, { TYPE_BVEC2, TYPE_BVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC3, { TYPE_BVEC3, TYPE_BVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "notEqual", TYPE_BVEC4, { TYPE_BVEC4, TYPE_BVEC4, 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 21:33:42 +02:00
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "any", TYPE_BOOL, { TYPE_BVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "any", TYPE_BOOL, { TYPE_BVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "any", TYPE_BOOL, { TYPE_BVEC4, 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 21:33:42 +02:00
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "all", TYPE_BOOL, { TYPE_BVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "all", TYPE_BOOL, { TYPE_BVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "all", TYPE_BOOL, { TYPE_BVEC4, 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 21:33:42 +02:00
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "not", TYPE_BVEC2, { TYPE_BVEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "not", TYPE_BVEC3, { TYPE_BVEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "not", TYPE_BVEC4, { TYPE_BVEC4, 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 21:33:42 +02:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
//builtins - texture
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "textureSize", TYPE_IVEC2, { TYPE_SAMPLER2D, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC2, { TYPE_ISAMPLER2D, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC2, { TYPE_USAMPLER2D, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC3, { TYPE_SAMPLER2DARRAY, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC3, { TYPE_ISAMPLER2DARRAY, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC3, { TYPE_USAMPLER2DARRAY, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC3, { TYPE_SAMPLER3D, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC3, { TYPE_ISAMPLER3D, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC3, { TYPE_USAMPLER3D, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureSize", TYPE_IVEC2, { TYPE_SAMPLERCUBE, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
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 14:34:23 +02:00
{ "textureSize", TYPE_IVEC2, { TYPE_SAMPLERCUBEARRAY, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "texture", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "texture", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 11:28:29 +01:00
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
Add support for 3D textures to GLES2
2020-01-15 08:53:13 +01:00
{ "texture", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "texture", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 11:28:29 +01:00
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
Add support for 3D textures to GLES2
2020-01-15 08:53:13 +01:00
{ "texture", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "texture", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 11:28:29 +01:00
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "texture", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "texture", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "texture", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "texture", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
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 14:34:23 +02:00
{ "texture", TYPE_VEC4, { TYPE_SAMPLERCUBEARRAY, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
{ "texture", TYPE_VEC4, { TYPE_SAMPLERCUBEARRAY, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProj", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureLod", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 11:28:29 +01:00
{ "textureLod", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureLod", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
Add support for 3D textures to GLES2
2020-01-15 08:53:13 +01:00
{ "textureLod", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 11:28:29 +01:00
{ "textureLod", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureLod", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
Add support for 3D textures to GLES2
2020-01-15 08:53:13 +01:00
{ "textureLod", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 11:28:29 +01:00
{ "textureLod", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureLod", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "textureLod", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
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 14:34:23 +02:00
{ "textureLod", TYPE_VEC4, { TYPE_SAMPLERCUBEARRAY, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "texelFetch", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_IVEC2, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "texelFetch", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_IVEC2, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "texelFetch", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_IVEC2, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "texelFetch", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "texelFetch", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "texelFetch", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "texelFetch", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "texelFetch", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "texelFetch", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_IVEC3, TYPE_INT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureProjLod", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_VEC4, { TYPE_SAMPLER2DARRAY, TYPE_VEC3, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_IVEC4, { TYPE_ISAMPLER2DARRAY, TYPE_VEC3, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_UVEC4, { TYPE_USAMPLER2DARRAY, TYPE_VEC3, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_VEC4, { TYPE_SAMPLER3D, TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_IVEC4, { TYPE_ISAMPLER3D, TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_UVEC4, { TYPE_USAMPLER3D, TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "textureGrad", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
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 14:34:23 +02:00
{ "textureGrad", TYPE_VEC4, { TYPE_SAMPLERCUBEARRAY, TYPE_VEC4, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
{ "dFdx", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "dFdx", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "dFdx", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "dFdx", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "dFdy", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "dFdy", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "dFdy", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "dFdy", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, true },
{ "fwidth", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, true },
{ "fwidth", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, true },
{ "fwidth", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, true },
{ "fwidth", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, true },
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
//sub-functions
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
//array
Disabled array initialization, const array and arr.length in shaders
2020-01-16 09:46:11 +01:00
{ "length", TYPE_INT, { TYPE_VOID }, TAG_ARRAY, true },
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Added 'fma' function to shader language
2020-02-14 21:09:53 +01:00
// modern functions
Enables 'fma' for GLES2
2020-07-10 20:57:07 +02:00
{ "fma", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID }, TAG_GLOBAL, false },
{ "fma", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID }, TAG_GLOBAL, false },
{ "fma", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID }, TAG_GLOBAL, false },
{ "fma", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
Added 'fma' function to shader language
2020-02-14 21:09:53 +01:00
Replace NULL with nullptr
2020-04-02 01:20:12 +02: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 21:33:42 +02:00
};
Proper validation of out arguments in built-in shader functions, closes #16244
2018-11-14 22:55:38 +01:00
const ShaderLanguage::BuiltinFuncOutArgs ShaderLanguage::builtin_func_out_args[] = {
//constructors
{ "modf", 1 },
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
{ nullptr, 0 }
Proper validation of out arguments in built-in shader functions, closes #16244
2018-11-14 22:55:38 +01:00
};
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
bool ShaderLanguage::_validate_function_call(BlockNode *p_block, const FunctionInfo &p_function_info, OperatorNode *p_func, DataType *r_ret_type, StringName *r_ret_type_str) {
Make the default return value on crash explicit Noticed that the error condition will return a NULL instead of something more explicit like "false". Should make the code more readable at a glance.
2019-07-12 05:06:58 +02:00
ERR_FAIL_COND_V(p_func->op != OP_CALL && p_func->op != OP_CONSTRUCT, false);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Vector<DataType> args;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
Vector<StringName> args2;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Make the default return value on crash explicit Noticed that the error condition will return a NULL instead of something more explicit like "false". Should make the code more readable at a glance.
2019-07-12 05:06:58 +02:00
ERR_FAIL_COND_V(p_func->arguments[0]->type != Node::TYPE_VARIABLE, false);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
StringName name = static_cast<VariableNode *>(p_func->arguments[0])->name.operator String();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02:00
args.push_back(p_func->arguments[i]->get_datatype());
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
args2.push_back(p_func->arguments[i]->get_datatype_name());
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 16:31:18 +02:00
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
if (p_function_info.stage_functions.has(name)) {
//stage based function
const StageFunctionInfo &sf = p_function_info.stage_functions[name];
if (argcount != sf.arguments.size()) {
_set_error(vformat("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("Invalid argument type when calling stage function '%s', type expected is '%s'.", String(name), String(get_datatype_name(sf.arguments[i].type))));
return false;
}
}
if (r_ret_type) {
*r_ret_type = sf.return_type;
}
if (r_ret_type_str) {
*r_ret_type_str = "";
}
return true;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool failed_builtin = false;
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
bool unsupported_builtin = false;
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 11:28:29 +01:00
int builtin_idx = 0;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 16:31:18 +02: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-10 02:10:30 +01:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
while (builtin_func_defs[idx].name) {
Implemented local shader arrays
2019-07-10 18:52:50 +02: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++) {
Ensure implicit conversions for scalar constants work in shaders, closes #26239
2019-02-27 03:20:39 +01:00
if (get_scalar_type(args[i]) == args[i] && p_func->arguments[i + 1]->type == Node::TYPE_CONSTANT && convert_constant(static_cast<ConstantNode *>(p_func->arguments[i + 1]), builtin_func_defs[idx].args[i])) {
//all good, but needs implicit conversion later
} else if (args[i] != builtin_func_defs[idx].args[i]) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
fail = true;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
break;
}
}
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01: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 19:21:27 +01:00
if (RenderingServer::get_singleton()->is_low_end()) {
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01: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 11:28:29 +01:00
builtin_idx = idx;
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01: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-10 02:10:30 +01:00
if (!fail) {
Proper validation of out arguments in built-in shader functions, closes #16244
2018-11-14 22:55:38 +01: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) {
int arg_idx = builtin_func_out_args[outarg_idx].argument;
if (arg_idx < argcount) {
Fix shader crash if passing const values to modf function
2020-03-18 11:22:12 +01:00
if (p_func->arguments[arg_idx + 1]->type != Node::TYPE_VARIABLE && p_func->arguments[arg_idx + 1]->type != Node::TYPE_MEMBER && p_func->arguments[arg_idx + 1]->type != Node::TYPE_ARRAY) {
_set_error("Argument " + itos(arg_idx + 1) + " of function '" + String(name) + "' is not a variable, array or member.");
Proper validation of out arguments in built-in shader functions, closes #16244
2018-11-14 22:55:38 +01:00
return false;
}
Fix shader crash if passing const values to modf function
2020-03-18 11:22:12 +01:00
if (p_func->arguments[arg_idx + 1]->type == Node::TYPE_ARRAY) {
ArrayNode *mn = static_cast<ArrayNode *>(p_func->arguments[arg_idx + 1]);
if (mn->is_const) {
fail = true;
}
} else if (p_func->arguments[arg_idx + 1]->type == Node::TYPE_MEMBER) {
MemberNode *mn = static_cast<MemberNode *>(p_func->arguments[arg_idx + 1]);
if (mn->basetype_const) {
fail = true;
}
} else { // TYPE_VARIABLE
VariableNode *vn = static_cast<VariableNode *>(p_func->arguments[arg_idx + 1]);
if (vn->is_const) {
fail = true;
} else {
StringName varname = vn->name;
if (shader->uniforms.has(varname)) {
fail = true;
} else {
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
if (p_function_info.built_ins.has(varname)) {
BuiltInInfo info = p_function_info.built_ins[varname];
Fix shader crash if passing const values to modf function
2020-03-18 11:22:12 +01:00
if (info.constant) {
fail = true;
}
}
}
}
}
if (fail) {
_set_error(vformat("Constant value cannot be passed for '%s' parameter!", "out"));
return false;
}
StringName var_name;
if (p_func->arguments[arg_idx + 1]->type == Node::TYPE_ARRAY) {
var_name = static_cast<const ArrayNode *>(p_func->arguments[arg_idx + 1])->name;
} else if (p_func->arguments[arg_idx + 1]->type == Node::TYPE_MEMBER) {
Node *n = static_cast<const MemberNode *>(p_func->arguments[arg_idx + 1])->owner;
while (n->type == Node::TYPE_MEMBER) {
n = static_cast<const MemberNode *>(n)->owner;
}
if (n->type != Node::TYPE_VARIABLE && n->type != Node::TYPE_ARRAY) {
_set_error("Argument " + itos(arg_idx + 1) + " of function '" + String(name) + "' is not a variable, array or member.");
return false;
}
if (n->type == Node::TYPE_VARIABLE) {
var_name = static_cast<const VariableNode *>(n)->name;
} else { // TYPE_ARRAY
var_name = static_cast<const ArrayNode *>(n)->name;
}
} else { // TYPE_VARIABLE
var_name = static_cast<const VariableNode *>(p_func->arguments[arg_idx + 1])->name;
}
Proper validation of out arguments in built-in shader functions, closes #16244
2018-11-14 22:55:38 +01:00
const BlockNode *b = p_block;
bool valid = false;
while (b) {
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
if (b->variables.has(var_name) || p_function_info.built_ins.has(var_name)) {
Proper validation of out arguments in built-in shader functions, closes #16244
2018-11-14 22:55:38 +01:00
valid = true;
break;
}
Enables passing out built-in parameter from parent function in shaders
2020-02-22 09:09:06 +01:00
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;
}
}
}
Proper validation of out arguments in built-in shader functions, closes #16244
2018-11-14 22:55:38 +01:00
b = b->parent_block;
}
if (!valid) {
Fix shader crash if passing const values to modf function
2020-03-18 11:22:12 +01:00
_set_error("Argument " + itos(arg_idx + 1) + " of function '" + String(name) + "' can only take a local variable, array or member.");
Proper validation of out arguments in built-in shader functions, closes #16244
2018-11-14 22:55:38 +01:00
return false;
}
}
}
outarg_idx++;
}
Ensure implicit conversions for scalar constants work in shaders, closes #26239
2019-02-27 03:20:39 +01:00
//implicitly convert values if possible
for (int i = 0; i < argcount; i++) {
if (get_scalar_type(args[i]) != args[i] || args[i] == builtin_func_defs[idx].args[i] || p_func->arguments[i + 1]->type != Node::TYPE_CONSTANT) {
//can't do implicit conversion here
continue;
}
//this is an implicit conversion
ConstantNode *constant = static_cast<ConstantNode *>(p_func->arguments[i + 1]);
ConstantNode *conversion = alloc_node<ConstantNode>();
conversion->datatype = builtin_func_defs[idx].args[i];
conversion->values.resize(1);
convert_constant(constant, builtin_func_defs[idx].args[i], conversion->values.ptrw());
p_func->arguments.write[i + 1] = conversion;
}
Proper validation of out arguments in built-in shader functions, closes #16244
2018-11-14 22:55:38 +01: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-10 02:10:30 +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 21:33:42 +02:00
return true;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
}
idx++;
}
}
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
if (unsupported_builtin) {
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 11:28:29 +01: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]);
}
String err = "Built-in function \"" + String(name) + "(" + arglist + ")\" is supported only on high-end platform!";
Prevents shader crash on GLES2 if unsupported built-in has been used
2019-10-30 10:38:35 +01:00
_set_error(err);
return false;
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
if (failed_builtin) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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 err = "Invalid arguments for built-in function: " + String(name) + "(";
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) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
err += ",";
Style: Enforce braces around if blocks and loops 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 16:31:18 +02:00
Improve messages in shader function validation
2020-09-05 10:12:29 +02: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 16:31:18 +02:00
}
Improve messages in shader function validation
2020-09-05 10:12:29 +02:00
err += arg_name;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +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
err += ")";
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
_set_error(err);
return false;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02:00
StringName exclude_function;
BlockNode *block = p_block;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02: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-10 02:10:30 +01: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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
_set_error("Recursion is not allowed");
return false;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Improve messages in shader function validation
2020-09-05 10:12:29 +02:00
int last_arg_count = 0;
String arg_list = "";
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < shader->functions.size(); i++) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (name != shader->functions[i].name) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-10 02:10:30 +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 21:33:42 +02:00
if (!shader->functions[i].callable) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
_set_error("Function '" + String(name) + " can't be called from source code.");
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
return false;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
FunctionNode *pfunc = shader->functions[i].function;
Improve messages in shader function validation
2020-09-05 10:12:29 +02:00
if (arg_list == "") {
Fix crash regression in the shader function validation introduced in #41780
2020-09-05 12:49:50 +02:00
for (int j = 0; j < pfunc->arguments.size(); j++) {
Improve messages in shader function validation
2020-09-05 10:12:29 +02:00
if (j > 0) {
arg_list += ", ";
}
String func_arg_name;
if (pfunc->arguments[j].type == TYPE_STRUCT) {
func_arg_name = pfunc->arguments[j].type_str;
} else {
func_arg_name = get_datatype_name(pfunc->arguments[j].type);
}
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 21:33:42 +02: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 10:12:29 +02:00
last_arg_count = pfunc->arguments.size();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool fail = false;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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++) {
Ensure implicit conversions for scalar constants work in shaders, closes #26239
2019-02-27 03:20:39 +01:00
if (get_scalar_type(args[j]) == args[j] && p_func->arguments[j + 1]->type == Node::TYPE_CONSTANT && convert_constant(static_cast<ConstantNode *>(p_func->arguments[j + 1]), pfunc->arguments[j].type)) {
//all good, but it needs implicit conversion later
Improve messages in shader function validation
2020-09-05 10:12:29 +02:00
} else if (args[j] != pfunc->arguments[j].type || (args[j] == TYPE_STRUCT && args2[j] != pfunc->arguments[j].type_str)) {
String func_arg_name;
if (pfunc->arguments[j].type == TYPE_STRUCT) {
func_arg_name = pfunc->arguments[j].type_str;
} else {
func_arg_name = get_datatype_name(pfunc->arguments[j].type);
}
String arg_name;
if (args[j] == TYPE_STRUCT) {
arg_name = args2[j];
} else {
arg_name = get_datatype_name(args[j]);
}
_set_error(vformat("Invalid argument for \"%s(%s)\" function: argument %s should be %s but is %s.", String(name), arg_list, j + 1, func_arg_name, arg_name));
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
fail = true;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02:00
if (!fail) {
Ensure implicit conversions for scalar constants work in shaders, closes #26239
2019-02-27 03:20:39 +01:00
//implicitly convert values if possible
for (int k = 0; k < args.size(); k++) {
if (get_scalar_type(args[k]) != args[k] || args[k] == pfunc->arguments[k].type || p_func->arguments[k + 1]->type != Node::TYPE_CONSTANT) {
//can't do implicit conversion here
continue;
}
//this is an implicit conversion
ConstantNode *constant = static_cast<ConstantNode *>(p_func->arguments[k + 1]);
ConstantNode *conversion = alloc_node<ConstantNode>();
conversion->datatype = pfunc->arguments[k].type;
conversion->values.resize(1);
convert_constant(constant, pfunc->arguments[k].type, conversion->values.ptrw());
p_func->arguments.write[k + 1] = conversion;
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (r_ret_type) {
property validate assignment condition in new variables, fixes #9411
2017-08-20 21:15:08 +02:00
*r_ret_type = pfunc->return_type;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (pfunc->return_type == TYPE_STRUCT) {
*r_ret_type_str = pfunc->return_struct_name;
}
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
return true;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
}
Improve messages in shader function validation
2020-09-05 10:12:29 +02:00
if (last_arg_count > args.size()) {
_set_error(vformat("Too few arguments for \"%s(%s)\" call. Expected at least %s but received %s.", String(name), arg_list, last_arg_count, args.size()));
} else if (last_arg_count < args.size()) {
_set_error(vformat("Too many arguments for \"%s(%s)\" call. Expected at most %s but received %s.", String(name), arg_list, last_arg_count, args.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 21:33:42 +02:00
return false;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
bool ShaderLanguage::_compare_datatypes_in_nodes(Node *a, Node *b) const {
if (a->get_datatype() != b->get_datatype()) {
return false;
}
if (a->get_datatype() == TYPE_STRUCT || b->get_datatype() == TYPE_STRUCT) {
if (a->get_datatype_name() != b->get_datatype_name()) {
return false;
}
}
return true;
}
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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 16:31:18 +02: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 21:33:42 +02:00
Token tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 16:31:18 +02:00
return true;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 16:31:18 +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
while (true) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 16:31:18 +02: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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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 16:31:18 +02: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 21:33:42 +02: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 16:31:18 +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 21:33:42 +02:00
p_func->arguments.push_back(arg);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 16:31:18 +02: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 21:33:42 +02:00
// something is broken
_set_error("Expected ',' or ')' after argument");
return false;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
return true;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-10 02:10:30 +01: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 ShaderLanguage::convert_constant(ConstantNode *p_constant, DataType p_to_type, ConstantNode::Value *p_value) {
if (p_constant->datatype == p_to_type) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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-10 02:10:30 +01:00
}
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02:00
}
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 23:31:01 +02:00
bool ShaderLanguage::is_sampler_type(DataType p_type) {
add 3D textures
2018-06-26 13:59:26 +02:00
return p_type == TYPE_SAMPLER2D ||
p_type == TYPE_ISAMPLER2D ||
p_type == TYPE_USAMPLER2D ||
p_type == TYPE_SAMPLER2DARRAY ||
p_type == TYPE_ISAMPLER2DARRAY ||
p_type == TYPE_USAMPLER2DARRAY ||
p_type == TYPE_SAMPLER3D ||
p_type == TYPE_ISAMPLER3D ||
p_type == TYPE_USAMPLER3D ||
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 14:34:23 +02:00
p_type == TYPE_SAMPLERCUBE ||
p_type == TYPE_SAMPLERCUBEARRAY;
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 23:31:01 +02:00
}
Use hint_color when getting shader default params
2018-11-16 12:20:23 +01:00
Variant ShaderLanguage::constant_value_to_variant(const Vector<ShaderLanguage::ConstantNode::Value> &p_value, DataType p_type, ShaderLanguage::ShaderNode::Uniform::Hint p_hint) {
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:
value = Variant(p_value[0].boolean);
break;
case ShaderLanguage::TYPE_BVEC2:
case ShaderLanguage::TYPE_BVEC3:
case ShaderLanguage::TYPE_BVEC4:
case ShaderLanguage::TYPE_INT:
value = Variant(p_value[0].sint);
break;
case ShaderLanguage::TYPE_IVEC2:
value = Variant(Vector2(p_value[0].sint, p_value[1].sint));
break;
case ShaderLanguage::TYPE_IVEC3:
value = Variant(Vector3(p_value[0].sint, p_value[1].sint, p_value[2].sint));
break;
case ShaderLanguage::TYPE_IVEC4:
value = Variant(Plane(p_value[0].sint, p_value[1].sint, p_value[2].sint, p_value[3].sint));
break;
case ShaderLanguage::TYPE_UINT:
value = Variant(p_value[0].uint);
break;
case ShaderLanguage::TYPE_UVEC2:
value = Variant(Vector2(p_value[0].uint, p_value[1].uint));
break;
case ShaderLanguage::TYPE_UVEC3:
value = Variant(Vector3(p_value[0].uint, p_value[1].uint, p_value[2].uint));
break;
case ShaderLanguage::TYPE_UVEC4:
value = Variant(Plane(p_value[0].uint, p_value[1].uint, p_value[2].uint, p_value[3].uint));
break;
case ShaderLanguage::TYPE_FLOAT:
value = Variant(p_value[0].real);
break;
case ShaderLanguage::TYPE_VEC2:
value = Variant(Vector2(p_value[0].real, p_value[1].real));
break;
case ShaderLanguage::TYPE_VEC3:
value = Variant(Vector3(p_value[0].real, p_value[1].real, p_value[2].real));
break;
case ShaderLanguage::TYPE_VEC4:
Use hint_color when getting shader default params
2018-11-16 12:20:23 +01:00
if (p_hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
value = Variant(Color(p_value[0].real, p_value[1].real, p_value[2].real, p_value[3].real));
} else {
value = Variant(Plane(p_value[0].real, p_value[1].real, p_value[2].real, p_value[3].real));
}
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
break;
case ShaderLanguage::TYPE_MAT2:
value = Variant(Transform2D(p_value[0].real, p_value[2].real, p_value[1].real, p_value[3].real, 0.0, 0.0));
break;
case ShaderLanguage::TYPE_MAT3: {
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);
break;
}
case ShaderLanguage::TYPE_MAT4: {
Basis p;
p[0][0] = p_value[0].real;
p[0][1] = p_value[1].real;
p[0][2] = p_value[2].real;
p[1][0] = p_value[4].real;
p[1][1] = p_value[5].real;
p[1][2] = p_value[6].real;
p[2][0] = p_value[8].real;
p[2][1] = p_value[9].real;
p[2][2] = p_value[10].real;
Transform t = Transform(p, Vector3(p_value[3].real, p_value[7].real, p_value[11].real));
value = Variant(t);
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 14:34:23 +02:00
case ShaderLanguage::TYPE_SAMPLERCUBE:
case ShaderLanguage::TYPE_SAMPLERCUBEARRAY: {
Fix warnings about unhandled enum value in switch [-Wswitch] Fixes GCC 5 warnings of the form: core/io/http_client.cpp:288:9: warning: enumeration value 'STATUS_SSL_HANDSHAKE_ERROR' not handled in switch [-Wswitch] core/io/marshalls.cpp:806:9: warning: enumeration value 'AABB' not handled in switch [-Wswitch] Those can be trivial cases where adding a default fallback is the solution, or more complex issues/hidden bugs where missed values are actually meant to be handled.
2018-09-26 13:13:56 +02:00
// Texture types, likely not relevant here.
break;
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01: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-17 04:52:00 +02:00
case ShaderLanguage::TYPE_MAX:
break;
Set uniform default values in inspector
2018-09-05 00:54:35 +02:00
}
return value;
}
return Variant();
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02: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:
pi.type = Variant::BOOL;
break;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
case ShaderLanguage::TYPE_BVEC2:
pi.type = Variant::INT;
pi.hint = PROPERTY_HINT_FLAGS;
pi.hint_string = "x,y";
break;
case ShaderLanguage::TYPE_BVEC3:
pi.type = Variant::INT;
pi.hint = PROPERTY_HINT_FLAGS;
pi.hint_string = "x,y,z";
break;
case ShaderLanguage::TYPE_BVEC4:
pi.type = Variant::INT;
pi.hint = PROPERTY_HINT_FLAGS;
pi.hint_string = "x,y,z,w";
break;
case ShaderLanguage::TYPE_UINT:
case ShaderLanguage::TYPE_INT: {
pi.type = Variant::INT;
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_RANGE) {
pi.hint = PROPERTY_HINT_RANGE;
Fix shader's step hint range for integers
2020-02-29 07:56:02 +01:00
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 16:31:30 +02:00
}
} break;
case ShaderLanguage::TYPE_IVEC2:
case ShaderLanguage::TYPE_IVEC3:
case ShaderLanguage::TYPE_IVEC4:
case ShaderLanguage::TYPE_UVEC2:
case ShaderLanguage::TYPE_UVEC3:
case ShaderLanguage::TYPE_UVEC4: {
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT. - Renames PackedIntArray to PackedInt32Array. - Renames PackedFloatArray to PackedFloat32Array. - Adds PackedInt64Array and PackedFloat64Array. - Renames Variant::REAL to Variant::FLOAT for consistency. Packed arrays are for storing large amount of data and creating stuff like meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of memory. That said, many users requested the ability to have 64 bits packed arrays for their games, so this is just an optional added type. For Variant, the float datatype is always 64 bits, and exposed as `float`. We still have `real_t` which is the datatype that can change from 32 to 64 bits depending on a compile flag (not entirely working right now, but that's the idea). It affects math related datatypes and code only. Neither Variant nor PackedArray make use of real_t, which is only intended for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
pi.type = Variant::PACKED_INT32_ARRAY;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
} break;
case ShaderLanguage::TYPE_FLOAT: {
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT. - Renames PackedIntArray to PackedInt32Array. - Renames PackedFloatArray to PackedFloat32Array. - Adds PackedInt64Array and PackedFloat64Array. - Renames Variant::REAL to Variant::FLOAT for consistency. Packed arrays are for storing large amount of data and creating stuff like meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of memory. That said, many users requested the ability to have 64 bits packed arrays for their games, so this is just an optional added type. For Variant, the float datatype is always 64 bits, and exposed as `float`. We still have `real_t` which is the datatype that can change from 32 to 64 bits depending on a compile flag (not entirely working right now, but that's the idea). It affects math related datatypes and code only. Neither Variant nor PackedArray make use of real_t, which is only intended for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
pi.type = Variant::FLOAT;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
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]);
}
} break;
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
case ShaderLanguage::TYPE_VEC2:
pi.type = Variant::VECTOR2;
break;
case ShaderLanguage::TYPE_VEC3:
pi.type = Variant::VECTOR3;
break;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
case ShaderLanguage::TYPE_VEC4: {
if (p_uniform.hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
pi.type = Variant::COLOR;
} else {
pi.type = Variant::PLANE;
}
} break;
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
case ShaderLanguage::TYPE_MAT2:
pi.type = Variant::TRANSFORM2D;
break;
case ShaderLanguage::TYPE_MAT3:
pi.type = Variant::BASIS;
break;
case ShaderLanguage::TYPE_MAT4:
pi.type = Variant::TRANSFORM;
break;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
case ShaderLanguage::TYPE_SAMPLER2D:
case ShaderLanguage::TYPE_ISAMPLER2D:
case ShaderLanguage::TYPE_USAMPLER2D: {
pi.type = Variant::OBJECT;
pi.hint = PROPERTY_HINT_RESOURCE_TYPE;
pi.hint_string = "Texture2D";
} break;
case ShaderLanguage::TYPE_SAMPLER2DARRAY:
case ShaderLanguage::TYPE_ISAMPLER2DARRAY:
case ShaderLanguage::TYPE_USAMPLER2DARRAY: {
pi.type = Variant::OBJECT;
pi.hint = PROPERTY_HINT_RESOURCE_TYPE;
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
pi.hint_string = "TextureLayered";
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
} break;
case ShaderLanguage::TYPE_SAMPLER3D:
case ShaderLanguage::TYPE_ISAMPLER3D:
case ShaderLanguage::TYPE_USAMPLER3D: {
pi.type = Variant::OBJECT;
pi.hint = PROPERTY_HINT_RESOURCE_TYPE;
pi.hint_string = "Texture3D";
} break;
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
case ShaderLanguage::TYPE_SAMPLERCUBE:
case ShaderLanguage::TYPE_SAMPLERCUBEARRAY: {
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
pi.type = Variant::OBJECT;
pi.hint = PROPERTY_HINT_RESOURCE_TYPE;
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
pi.hint_string = "TextureLayered";
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
} break;
Fix various GCC compilation warnings after Vulkan merge Part of #36132.
2020-02-13 15:53:32 +01:00
case ShaderLanguage::TYPE_STRUCT: {
// FIXME: Implement this.
} break;
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-17 04:52:00 +02:00
case ShaderLanguage::TYPE_MAX:
break;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
}
return pi;
}
uint32_t ShaderLanguage::get_type_size(DataType p_type) {
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 16:31:30 +02:00
case TYPE_BOOL:
case TYPE_INT:
case TYPE_UINT:
Fix various GCC compilation warnings after Vulkan merge Part of #36132.
2020-02-13 15:53:32 +01:00
case TYPE_FLOAT:
return 4;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
case TYPE_BVEC2:
case TYPE_IVEC2:
case TYPE_UVEC2:
Fix various GCC compilation warnings after Vulkan merge Part of #36132.
2020-02-13 15:53:32 +01:00
case TYPE_VEC2:
return 8;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
case TYPE_BVEC3:
case TYPE_IVEC3:
case TYPE_UVEC3:
Fix various GCC compilation warnings after Vulkan merge Part of #36132.
2020-02-13 15:53:32 +01:00
case TYPE_VEC3:
return 12;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
case TYPE_BVEC4:
case TYPE_IVEC4:
case TYPE_UVEC4:
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:
return 8;
case TYPE_MAT3:
return 12;
case TYPE_MAT4:
return 16;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
case TYPE_SAMPLER2D:
case TYPE_ISAMPLER2D:
case TYPE_USAMPLER2D:
case TYPE_SAMPLER2DARRAY:
case TYPE_ISAMPLER2DARRAY:
case TYPE_USAMPLER2DARRAY:
case TYPE_SAMPLER3D:
case TYPE_ISAMPLER3D:
case TYPE_USAMPLER3D:
Fix various GCC compilation warnings after Vulkan merge Part of #36132.
2020-02-13 15:53:32 +01:00
case 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 14:34:23 +02:00
case TYPE_SAMPLERCUBEARRAY:
Fix various GCC compilation warnings after Vulkan merge Part of #36132.
2020-02-13 15:53:32 +01:00
return 4; //not really, but useful for indices
case TYPE_STRUCT:
// FIXME: Implement.
return 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-17 04:52:00 +02:00
case ShaderLanguage::TYPE_MAX:
return 0;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
}
return 0;
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
void ShaderLanguage::get_keyword_list(List<String> *r_keywords) {
Set<String> kws;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
int idx = 0;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +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
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 16:31:18 +02:00
kws.insert(keyword_list[idx].text);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-10 02:10:30 +01:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
while (builtin_func_defs[idx].name) {
kws.insert(builtin_func_defs[idx].name);
idx++;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (Set<String>::Element *E = kws.front(); E; E = E->next()) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
r_keywords->push_back(E->get());
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
}
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 23:31:01 +02:00
void ShaderLanguage::get_builtin_funcs(List<String> *r_keywords) {
Set<String> kws;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 23:31:01 +02:00
while (builtin_func_defs[idx].name) {
kws.insert(builtin_func_defs[idx].name);
idx++;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (Set<String>::Element *E = kws.front(); E; E = E->next()) {
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 23:31:01 +02:00
r_keywords->push_back(E->get());
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 16:31:18 +02:00
TYPE_VOID,
TYPE_BOOL,
TYPE_BOOL,
TYPE_BOOL,
TYPE_BOOL,
TYPE_INT,
TYPE_INT,
TYPE_INT,
TYPE_INT,
TYPE_UINT,
TYPE_UINT,
TYPE_UINT,
TYPE_UINT,
TYPE_FLOAT,
TYPE_FLOAT,
TYPE_FLOAT,
TYPE_FLOAT,
TYPE_FLOAT,
TYPE_FLOAT,
TYPE_FLOAT,
TYPE_FLOAT,
TYPE_INT,
TYPE_UINT,
TYPE_FLOAT,
};
return scalar_types[p_type];
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Fix vector reduction in shader language
2018-04-29 20:58:42 +02:00
int ShaderLanguage::get_cardinality(DataType p_type) {
static const int cardinality_table[] = {
0,
1,
2,
3,
4,
1,
2,
3,
4,
1,
2,
3,
4,
1,
2,
3,
4,
4,
Fix handling of shader constants that caused crash, closes #15166
2018-08-31 13:11:13 +02:00
9,
16,
Fix vector reduction in shader language
2018-04-29 20:58:42 +02:00
1,
1,
1,
1,
};
return cardinality_table[p_type];
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool ShaderLanguage::_get_completable_identifier(BlockNode *p_block, CompletionType p_type, StringName &identifier) {
identifier = StringName();
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02:00
_set_tkpos(pos);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
return false;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 22:23:16 +01:00
bool ShaderLanguage::_is_operator_assign(Operator p_op) const {
switch (p_op) {
case OP_ASSIGN:
case OP_ASSIGN_ADD:
case OP_ASSIGN_SUB:
case OP_ASSIGN_MUL:
case OP_ASSIGN_DIV:
case OP_ASSIGN_MOD:
case OP_ASSIGN_SHIFT_LEFT:
case OP_ASSIGN_SHIFT_RIGHT:
case OP_ASSIGN_BIT_AND:
case OP_ASSIGN_BIT_OR:
case OP_ASSIGN_BIT_XOR:
return true;
default:
return false;
}
return false;
}
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
bool ShaderLanguage::_validate_assign(Node *p_node, const FunctionInfo &p_function_info, String *r_message) {
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 22:23:16 +01:00
if (p_node->type == Node::TYPE_OPERATOR) {
OperatorNode *op = static_cast<OperatorNode *>(p_node);
Manually fix, merge and close #15168
2018-07-29 17:17:45 +02: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 14:18:10 +02:00
return _validate_assign(op->arguments[0], p_function_info, r_message);
Manually fix, merge and close #15168
2018-07-29 17:17:45 +02:00
} else if (_is_operator_assign(op->op)) {
//chained assignment
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
return _validate_assign(op->arguments[1], p_function_info, r_message);
Manually fix, merge and close #15168
2018-07-29 17:17:45 +02: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 17:17:45 +02: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 17:17:45 +02:00
return false;
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 22:23:16 +01:00
}
Manually fix, merge and close #15168
2018-07-29 17:17:45 +02:00
} else if (p_node->type == Node::TYPE_MEMBER) {
MemberNode *member = static_cast<MemberNode *>(p_node);
Fix bugs in shader swizzling
2020-02-13 15:50:20 +01: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 15:50:20 +01: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 15:50:20 +01:00
return false;
}
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
return _validate_assign(member->owner, p_function_info, r_message);
Manually fix, merge and close #15168
2018-07-29 17:17:45 +02:00
} else if (p_node->type == Node::TYPE_VARIABLE) {
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 22:23:16 +01:00
VariableNode *var = static_cast<VariableNode *>(p_node);
Manually fix, merge and close #15168
2018-07-29 17:17:45 +02: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 17:17:45 +02: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 17:17:45 +02:00
return false;
}
if (shader->varyings.has(var->name) && current_function != String("vertex")) {
Style: Enforce braces around if blocks and loops 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 17:17:45 +02:00
*r_message = RTR("Varyings can only be assigned in vertex 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 17:17:45 +02:00
return false;
}
Implemented local shader constants
2019-08-05 09:35:53 +02: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 16:19:24 +02: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 16:19:24 +02:00
return false;
}
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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 17:17:45 +02:00
return true;
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 22:23:16 +01:00
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
} else if (p_node->type == Node::TYPE_ARRAY) {
Implemented local shader constants
2019-08-05 09:35:53 +02:00
ArrayNode *arr = static_cast<ArrayNode *>(p_node);
Implemented global const array to shaders
2019-10-11 19:43:42 +02: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 09:35:53 +02: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 09:35:53 +02:00
return false;
}
Implement shader array support for varyings
2019-07-29 16:08:25 +02:00
if (shader->varyings.has(arr->name) && current_function != String("vertex")) {
Style: Enforce braces around if blocks and loops 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) {
Implement shader array support for varyings
2019-07-29 16:08:25 +02:00
*r_message = RTR("Varyings can only be assigned in vertex 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
}
Implement shader array support for varyings
2019-07-29 16:08:25 +02:00
return false;
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
return true;
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 22:23:16 +01:00
}
Manually fix, merge and close #15168
2018-07-29 17:17:45 +02: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 17:17:45 +02: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 17:17:45 +02:00
return false;
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 22:23:16 +01:00
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
bool ShaderLanguage::_propagate_function_call_sampler_uniform_settings(StringName p_name, int p_argument, TextureFilter p_filter, TextureRepeat p_repeat) {
Static analyzer fixes: Removes unused code in OS. Fixes return types. Fixes few typos.
2020-12-08 19:58:49 +01:00
for (int i = 0; i < shader->functions.size(); i++) {
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
if (shader->functions[i].name == p_name) {
ERR_FAIL_INDEX_V(p_argument, shader->functions[i].function->arguments.size(), false);
FunctionNode::Argument *arg = &shader->functions[i].function->arguments.write[p_argument];
if (arg->tex_builtin_check) {
_set_error("Sampler argument #" + itos(p_argument) + " of function '" + String(p_name) + "' called more than once using both built-ins and uniform textures, this is not supported (use either one or the other).");
return false;
} else if (arg->tex_argument_check) {
//was checked, verify that filter and repeat are the same
if (arg->tex_argument_filter == p_filter && arg->tex_argument_repeat == p_repeat) {
return true;
} else {
_set_error("Sampler argument #" + itos(p_argument) + " of function '" + String(p_name) + "' called more than once using textures that differ in either filter or repeat setting.");
return false;
}
} else {
arg->tex_argument_check = true;
arg->tex_argument_filter = p_filter;
arg->tex_argument_repeat = p_repeat;
Style: Set clang-format Standard to Cpp11 For us, it practically only changes the fact that `A<A<int>>` is now used instead of the C++03 compatible `A<A<int> >`. Note: clang-format 10+ changed the `Standard` arguments to fully specified `c++11`, `c++14`, etc. versions, but we can't use `c++17` now if we want to preserve compatibility with clang-format 8 and 9. `Cpp11` is still supported as deprecated alias for `Latest`.
2020-03-17 07:33:00 +01:00
for (Map<StringName, Set<int>>::Element *E = arg->tex_argument_connect.front(); E; E = E->next()) {
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
for (Set<int>::Element *F = E->get().front(); F; F = F->next()) {
if (!_propagate_function_call_sampler_uniform_settings(E->key(), F->get(), p_filter, p_repeat)) {
return false;
}
}
}
return true;
}
}
}
ERR_FAIL_V(false); //bug? function not found
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
bool ShaderLanguage::_propagate_function_call_sampler_builtin_reference(StringName p_name, int p_argument, const StringName &p_builtin) {
Static analyzer fixes: Removes unused code in OS. Fixes return types. Fixes few typos.
2020-12-08 19:58:49 +01:00
for (int i = 0; i < shader->functions.size(); i++) {
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
if (shader->functions[i].name == p_name) {
ERR_FAIL_INDEX_V(p_argument, shader->functions[i].function->arguments.size(), false);
FunctionNode::Argument *arg = &shader->functions[i].function->arguments.write[p_argument];
if (arg->tex_argument_check) {
_set_error("Sampler argument #" + itos(p_argument) + " of function '" + String(p_name) + "' called more than once using both built-ins and uniform textures, this is not supported (use either one or the other).");
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 {
_set_error("Sampler argument #" + itos(p_argument) + " of function '" + String(p_name) + "' called more than once using different built-ins. Only calling with the same built-in is supported.");
return false;
}
} else {
arg->tex_builtin_check = true;
arg->tex_builtin = p_builtin;
Style: Set clang-format Standard to Cpp11 For us, it practically only changes the fact that `A<A<int>>` is now used instead of the C++03 compatible `A<A<int> >`. Note: clang-format 10+ changed the `Standard` arguments to fully specified `c++11`, `c++14`, etc. versions, but we can't use `c++17` now if we want to preserve compatibility with clang-format 8 and 9. `Cpp11` is still supported as deprecated alias for `Latest`.
2020-03-17 07:33:00 +01:00
for (Map<StringName, Set<int>>::Element *E = arg->tex_argument_connect.front(); E; E = E->next()) {
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
for (Set<int>::Element *F = E->get().front(); F; F = F->next()) {
if (!_propagate_function_call_sampler_builtin_reference(E->key(), F->get(), p_builtin)) {
return false;
}
}
}
return true;
}
}
}
ERR_FAIL_V(false); //bug? function not found
}
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, const FunctionInfo &p_function_info) {
More Bugfix... -=-=-=-=-=-== -Fix bug in camera follow script -Fix negate operator not working in shader language -Fix uninitialized pointer in raycast query API
2014-09-18 04:23:42 +02:00
Vector<Expression> expression;
Implemented local shader arrays
2019-07-10 18:52:50 +02: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-18 04:23:42 +02:00
//Vector<TokenType> operators;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 16:31:18 +02: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 21:33:42 +02: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-10 02:10:30 +01:00
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 21:16:47 +01: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-10 02:10:30 +01:00
//handle subexpression
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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-10 02:10:30 +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 21:33:42 +02: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) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
_set_error("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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Rename TYPE_REAL to TYPE_FLOAT To be consistent with the naming everywhere else.
2020-12-04 13:25:14 +01: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 21:33:42 +02:00
ConstantNode *constant = alloc_node<ConstantNode>();
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
ConstantNode::Value v;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
v.real = tk.constant;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 21:33:42 +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
} 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 21:33:42 +02:00
ConstantNode *constant = alloc_node<ConstantNode>();
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
ConstantNode::Value v;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
v.sint = tk.constant;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 21:33:42 +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
} else if (tk.type == TK_TRUE) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02:00
ConstantNode *constant = alloc_node<ConstantNode>();
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
ConstantNode::Value v;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
v.boolean = true;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 21:33:42 +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
} else if (tk.type == TK_FALSE) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02:00
ConstantNode *constant = alloc_node<ConstantNode>();
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
ConstantNode::Value v;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
v.boolean = false;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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-10 02:10:30 +01: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 21:33:42 +02:00
//make sure void is not used in expression
_set_error("Void value not allowed in Expression");
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
} else if (is_token_nonvoid_datatype(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 21:33:42 +02:00
//basic type constructor
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
OperatorNode *func = 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
func->op = OP_CONSTRUCT;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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
func->return_precision_cache = get_token_precision(tk.type);
tk = _get_token();
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
VariableNode *funcname = alloc_node<VariableNode>();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
funcname->name = get_datatype_name(get_token_datatype(tk.type));
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
func->arguments.push_back(funcname);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
_set_error("Expected '(' after type name");
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 carg = -1;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
bool ok = _parse_function_arguments(p_block, p_function_info, func, &carg);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 (carg >= 0) {
completion_type = COMPLETION_CALL_ARGUMENTS;
completion_line = tk_line;
completion_block = p_block;
completion_function = funcname->name;
completion_argument = carg;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 (!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
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
if (!_validate_function_call(p_block, p_function_info, func, &func->return_cache, &func->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
_set_error("No matching constructor found for: '" + String(funcname->name) + "'");
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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, func);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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_IDENTIFIER) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
_set_tkpos(prepos);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
StringName identifier;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
StructNode *pstruct = nullptr;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01: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-10 02:10:30 +01:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01: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 20:35:22 +01:00
if (struct_init) { //a struct constructor
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
const StringName &name = identifier;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01: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-10 02:10:30 +01:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
for (int i = 0; i < pstruct->members.size(); i++) {
Added support for arrays as shader struct members
2020-02-11 20:03:04 +01:00
Node *nexpr;
Prevent shader crash if name of variable overrides function name
2019-10-06 19:35:41 +02:00
Added support for arrays as shader struct members
2020-02-11 20:03:04 +01:00
if (pstruct->members[i]->array_size != 0) {
DataType type = pstruct->members[i]->get_datatype();
String struct_name = pstruct->members[i]->struct_name;
int array_size = pstruct->members[i]->array_size;
DataType type2;
String struct_name2 = "";
int array_size2 = 0;
bool auto_size = false;
tk = _get_token();
if (tk.type == TK_CURLY_BRACKET_OPEN) {
auto_size = true;
} else {
if (shader->structs.has(tk.text)) {
type2 = TYPE_STRUCT;
struct_name2 = tk.text;
} else {
if (!is_token_variable_datatype(tk.type)) {
_set_error("Invalid data type for array");
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 20:03:04 +01:00
}
type2 = get_token_datatype(tk.type);
}
tk = _get_token();
if (tk.type == TK_BRACKET_OPEN) {
TkPos pos2 = _get_tkpos();
tk = _get_token();
if (tk.type == TK_BRACKET_CLOSE) {
array_size2 = array_size;
tk = _get_token();
} else {
_set_tkpos(pos2);
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
Node *n = _parse_and_reduce_expression(p_block, p_function_info);
Added support for arrays as shader struct members
2020-02-11 20:03:04 +01:00
if (!n || n->type != Node::TYPE_CONSTANT || n->get_datatype() != TYPE_INT) {
_set_error("Expected single integer constant > 0");
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 20:03:04 +01:00
}
ConstantNode *cnode = (ConstantNode *)n;
if (cnode->values.size() == 1) {
array_size2 = cnode->values[0].sint;
if (array_size2 <= 0) {
_set_error("Expected single integer constant > 0");
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 20:03:04 +01:00
}
} else {
_set_error("Expected single integer constant > 0");
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 20:03:04 +01:00
}
tk = _get_token();
if (tk.type != TK_BRACKET_CLOSE) {
_set_error("Expected ']'");
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 20:03:04 +01:00
} else {
tk = _get_token();
}
}
} else {
_set_error("Expected '['");
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 20:03:04 +01:00
}
if (type != type2 || struct_name != struct_name2 || array_size != array_size2) {
String error_str = "Cannot convert from '";
if (type2 == TYPE_STRUCT) {
error_str += struct_name2;
} else {
error_str += get_datatype_name(type2);
}
error_str += "[";
error_str += itos(array_size2);
error_str += "]'";
error_str += " to '";
if (type == TYPE_STRUCT) {
error_str += struct_name;
} else {
error_str += get_datatype_name(type);
}
error_str += "[";
error_str += itos(array_size);
error_str += "]'";
_set_error(error_str);
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 20:03:04 +01:00
}
}
ArrayConstructNode *an = alloc_node<ArrayConstructNode>();
an->datatype = type;
an->struct_name = struct_name;
if (tk.type == TK_PARENTHESIS_OPEN || auto_size) { // initialization
while (true) {
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
Node *n = _parse_and_reduce_expression(p_block, p_function_info);
Added support for arrays as shader struct members
2020-02-11 20:03:04 +01:00
if (!n) {
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 20:03:04 +01:00
}
if (type != n->get_datatype() || struct_name != n->get_datatype_name()) {
_set_error("Invalid assignment of '" + (n->get_datatype() == TYPE_STRUCT ? n->get_datatype_name() : get_datatype_name(n->get_datatype())) + "' to '" + (type == TYPE_STRUCT ? struct_name : get_datatype_name(type)) + "'");
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 20:03:04 +01:00
}
tk = _get_token();
if (tk.type == TK_COMMA) {
an->initializer.push_back(n);
continue;
} 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 {
Style: Enforce braces around if blocks and loops 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 (auto_size) {
Added support for arrays as shader struct members
2020-02-11 20:03:04 +01:00
_set_error("Expected '}' or ','");
Style: Enforce braces around if blocks and loops 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 support for arrays as shader struct members
2020-02-11 20:03:04 +01:00
_set_error("Expected ')' or ','");
Style: Enforce braces around if blocks and loops 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
}
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 20:03:04 +01:00
}
}
if (an->initializer.size() != array_size) {
_set_error("Array size mismatch");
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 20:03:04 +01:00
}
} else {
_set_error("Expected array initialization!");
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 20:03:04 +01:00
}
nexpr = an;
} else {
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
nexpr = _parse_and_reduce_expression(p_block, p_function_info);
Added support for arrays as shader struct members
2020-02-11 20:03:04 +01: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 20:03:04 +01:00
}
Node *node = pstruct->members[i];
if (!_compare_datatypes_in_nodes(pstruct->members[i], nexpr)) {
String type_name = nexpr->get_datatype() == TYPE_STRUCT ? nexpr->get_datatype_name() : get_datatype_name(nexpr->get_datatype());
String type_name2 = node->get_datatype() == TYPE_STRUCT ? node->get_datatype_name() : get_datatype_name(node->get_datatype());
_set_error("Invalid assignment of '" + type_name + "' to '" + type_name2 + "'");
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 20:03:04 +01:00
}
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (i + 1 < pstruct->members.size()) {
tk = _get_token();
if (tk.type != TK_COMMA) {
_set_error("Expected ','");
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
}
}
func->arguments.push_back(nexpr);
}
tk = _get_token();
if (tk.type != TK_PARENTHESIS_CLOSE) {
_set_error("Expected ')'");
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 23:31:01 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
expr = func;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
} else { //a function
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
const StringName &name = identifier;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
OperatorNode *func = alloc_node<OperatorNode>();
func->op = OP_CALL;
VariableNode *funcname = alloc_node<VariableNode>();
funcname->name = name;
func->arguments.push_back(funcname);
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
int carg = -1;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
bool ok = _parse_function_arguments(p_block, p_function_info, func, &carg);
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01: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)) {
_set_error("Expected function name");
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
}
bnode = bnode->parent_block;
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
//test if function was parsed first
int function_index = -1;
for (int i = 0; i < shader->functions.size(); i++) {
if (shader->functions[i].name == name) {
//add to current function as dependency
for (int j = 0; j < shader->functions.size(); j++) {
if (shader->functions[j].name == current_function) {
shader->functions.write[j].uses_function.insert(name);
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
break;
}
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
//see if texture arguments must connect
function_index = i;
break;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01: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 20:35:22 +01:00
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
if (!_validate_function_call(p_block, p_function_info, func, &func->return_cache, &func->struct_name)) {
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
_set_error("No matching function found for: '" + String(funcname->name) + "'");
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
}
completion_class = TAG_GLOBAL; // reset sub-class
if (function_index >= 0) {
//connect texture arguments, so we can cache in the
//argument what type of filter and repeat to use
FunctionNode *call_function = shader->functions[function_index].function;
if (call_function) {
//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 20:35:22 +01: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 16:31:30 +02:00
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
}
}
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
ERR_FAIL_COND_V(!base_function, nullptr); //bug, wtf
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01: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 21:16:47 +01:00
if (argidx < func->arguments.size()) {
Added const qualifier support for function arguments in shaders
2020-07-01 10:55:49 +02:00
if (call_function->arguments[i].is_const || call_function->arguments[i].qualifier == ArgumentQualifier::ARGUMENT_QUALIFIER_OUT || call_function->arguments[i].qualifier == ArgumentQualifier::ARGUMENT_QUALIFIER_INOUT) {
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 21:16:47 +01:00
bool error = false;
Node *n = func->arguments[argidx];
if (n->type == Node::TYPE_CONSTANT || n->type == Node::TYPE_OPERATOR) {
error = true;
} else if (n->type == Node::TYPE_ARRAY) {
ArrayNode *an = static_cast<ArrayNode *>(n);
Fix few places in shaders where const passing still incorrect
2020-06-25 09:40:19 +02:00
if (an->call_expression != nullptr || an->is_const) {
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 21:16:47 +01:00
error = true;
}
} else if (n->type == Node::TYPE_VARIABLE) {
VariableNode *vn = static_cast<VariableNode *>(n);
if (vn->is_const) {
error = true;
} else {
StringName varname = vn->name;
Fix few places in shaders where const passing still incorrect
2020-06-25 09:40:19 +02:00
if (shader->constants.has(varname)) {
error = true;
} else if (shader->uniforms.has(varname)) {
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 21:16:47 +01:00
error = true;
} else {
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
if (p_function_info.built_ins.has(varname)) {
BuiltInInfo info = p_function_info.built_ins[varname];
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 21:16:47 +01:00
if (info.constant) {
error = true;
}
}
}
}
} else if (n->type == Node::TYPE_MEMBER) {
MemberNode *mn = static_cast<MemberNode *>(n);
if (mn->basetype_const) {
error = true;
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
}
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 21:16:47 +01:00
if (error) {
_set_error(vformat("Constant value cannot be passed for '%s' parameter!", _get_qualifier_str(call_function->arguments[i].qualifier)));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
}
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 21:16:47 +01:00
}
if (is_sampler_type(call_function->arguments[i].type)) {
//let's see where our argument comes from
Node *n = func->arguments[argidx];
ERR_CONTINUE(n->type != Node::TYPE_VARIABLE); //bug? this should always be a variable
VariableNode *vn = static_cast<VariableNode *>(n);
StringName varname = vn->name;
if (shader->uniforms.has(varname)) {
//being sampler, this either comes from a uniform
ShaderNode::Uniform *u = &shader->uniforms[varname];
ERR_CONTINUE(u->type != call_function->arguments[i].type); //this should have been validated previously
//propagate
if (!_propagate_function_call_sampler_uniform_settings(name, i, u->filter, u->repeat)) {
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 21:16:47 +01:00
}
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
} else if (p_function_info.built_ins.has(varname)) {
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 21:16:47 +01: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 21:16:47 +01:00
}
} else {
//or this comes from an argument, but nothing else can be a sampler
bool found = false;
for (int j = 0; j < base_function->arguments.size(); j++) {
if (base_function->arguments[j].name == varname) {
if (!base_function->arguments[j].tex_argument_connect.has(call_function->name)) {
base_function->arguments.write[j].tex_argument_connect[call_function->name] = Set<int>();
}
base_function->arguments.write[j].tex_argument_connect[call_function->name].insert(i);
found = true;
break;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
}
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
}
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 21:16:47 +01:00
ERR_CONTINUE(!found);
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
}
}
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 21:16:47 +01:00
} else {
break;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
}
}
}
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
expr = func;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +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 21:33:42 +02:00
} else {
//an identifier
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
_set_tkpos(pos);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
DataType data_type;
IdentifierType ident_type;
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
int array_size = 0;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
StringName struct_name;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Prevent shader crash if invalid builtin used after array member accessor
2020-02-07 12:50:11 +01:00
if (p_block && p_block->block_tag != SubClassTag::TAG_GLOBAL) {
int idx = 0;
bool found = false;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Prevent shader crash if invalid builtin used after array member accessor
2020-02-07 12:50:11 +01: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) {
_set_error("Unknown identifier in expression: " + 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 12:50:11 +01:00
}
} else {
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
if (!_find_identifier(p_block, false, p_function_info, identifier, &data_type, &ident_type, &is_const, &array_size, &struct_name)) {
Prevent shader crash if invalid builtin used after array member accessor
2020-02-07 12:50:11 +01:00
_set_error("Unknown identifier in expression: " + 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 12:50:11 +01:00
}
if (ident_type == IDENTIFIER_FUNCTION) {
_set_error("Can't use function as identifier: " + 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 12:50:11 +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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
Node *index_expression = nullptr;
Node *call_expression = nullptr;
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
if (array_size > 0) {
tk = _get_token();
if (tk.type != TK_BRACKET_OPEN && tk.type != TK_PERIOD) {
_set_error("Expected '[' or '.'");
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
}
if (tk.type == TK_PERIOD) {
completion_class = TAG_ARRAY;
Prevent shader crash if invalid builtin used after array member accessor
2020-02-07 12:50:11 +01:00
p_block->block_tag = SubClassTag::TAG_ARRAY;
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
call_expression = _parse_and_reduce_expression(p_block, p_function_info);
Prevent shader crash if invalid builtin used after array member accessor
2020-02-07 12:50:11 +01:00
p_block->block_tag = SubClassTag::TAG_GLOBAL;
Style: Enforce braces around if blocks and loops 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 (!call_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 18:52:50 +02:00
data_type = call_expression->get_datatype();
} else { // indexing
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
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
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
if (index_expression->get_datatype() != TYPE_INT && index_expression->get_datatype() != TYPE_UINT) {
_set_error("Only integer expressions are allowed for indexing");
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
}
if (index_expression->type == Node::TYPE_CONSTANT) {
ConstantNode *cnode = (ConstantNode *)index_expression;
if (cnode) {
if (!cnode->values.empty()) {
int value = cnode->values[0].sint;
if (value < 0 || value >= array_size) {
_set_error(vformat("Index [%s] out of range [%s..%s]", value, 0, array_size - 1));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
}
}
}
}
tk = _get_token();
if (tk.type != TK_BRACKET_CLOSE) {
_set_error("Expected ']'");
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
}
}
ArrayNode *arrname = alloc_node<ArrayNode>();
arrname->name = identifier;
arrname->datatype_cache = data_type;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
arrname->struct_name = struct_name;
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
arrname->index_expression = index_expression;
arrname->call_expression = call_expression;
Implemented local shader constants
2019-08-05 09:35:53 +02:00
arrname->is_const = is_const;
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
expr = arrname;
} else {
VariableNode *varname = alloc_node<VariableNode>();
varname->name = identifier;
varname->datatype_cache = data_type;
Implemented local shader constants
2019-08-05 09:35:53 +02:00
varname->is_const = is_const;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
varname->struct_name = struct_name;
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
expr = varname;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02: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-18 04:23:42 +02: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-10 02:10:30 +01: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-18 04:23:42 +02:00
expression.push_back(e);
continue;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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
_set_error("Expected expression, found: " + get_token_text(tk));
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
//nothing
}
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
ERR_FAIL_COND_V(!expr, nullptr);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/* OK now see what's NEXT to the operator.. */
/* OK now see what's NEXT to the operator.. */
/* 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-10 02:10:30 +01: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
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
} else if (tk.type == TK_IDENTIFIER) {
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
} else if (tk.type == TK_PERIOD) {
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
DataType dt = expr->get_datatype();
String st = expr->get_datatype_name();
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
StringName identifier;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01: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 16:31:18 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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()) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
_set_error("Expected identifier as 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 21:33:42 +02:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 21:33:42 +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
bool ok = true;
Fix bugs in shader swizzling
2020-02-13 15:50:20 +01: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 20:35:22 +01:00
StringName member_struct_name = "";
Added support for arrays as shader struct members
2020-02-11 20:03:04 +01:00
int array_size = 0;
Fix bugs in shader swizzling
2020-02-13 15:50:20 +01:00
Set<char> position_symbols;
Set<char> color_symbols;
Set<char> texture_symbols;
bool mix_error = false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
switch (dt) {
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
case TYPE_STRUCT: {
ok = false;
String member_name = String(ident.ptr());
if (shader->structs.has(st)) {
StructNode *n = shader->structs[st].shader_struct;
for (List<MemberNode *>::Element *E = n->members.front(); E; E = E->next()) {
if (String(E->get()->name) == member_name) {
member_type = E->get()->datatype;
Added support for arrays as shader struct members
2020-02-11 20:03:04 +01:00
array_size = E->get()->array_size;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (member_type == TYPE_STRUCT) {
member_struct_name = E->get()->struct_name;
}
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 21:33:42 +02: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 19:41:13 +02: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 21:33:42 +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
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 21:33:42 +02:00
break;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02: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 21:33:42 +02:00
case 'r':
case 'g':
Fix bugs in shader swizzling
2020-02-13 15:50:20 +01: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 21:33:42 +02:00
case 'x':
case 'y':
Fix bugs in shader swizzling
2020-02-13 15:50:20 +01: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 21:33:42 +02: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 21:33:42 +02:00
break;
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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 19:41:13 +02: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 21:33:42 +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
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 21:33:42 +02:00
break;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02: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 21:33:42 +02:00
case 'r':
case 'g':
case 'b':
Fix bugs in shader swizzling
2020-02-13 15:50:20 +01: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 21:33:42 +02:00
case 'x':
case 'y':
case 'z':
Fix bugs in shader swizzling
2020-02-13 15:50:20 +01: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 21:33:42 +02: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 21:33:42 +02:00
break;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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 21:33:42 +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
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 21:33:42 +02:00
break;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02: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 21:33:42 +02:00
case 'r':
case 'g':
case 'b':
case 'a':
Fix bugs in shader swizzling
2020-02-13 15:50:20 +01: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 21:33:42 +02:00
case 'x':
case 'y':
case 'z':
case 'w':
Fix bugs in shader swizzling
2020-02-13 15:50:20 +01: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 21:33:42 +02: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 21:33:42 +02:00
break;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
} break;
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02: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 16:03:48 +02: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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Fix bugs in shader swizzling
2020-02-13 15:50:20 +01:00
if (mix_error) {
_set_error("Cannot combine symbols from different sets in expression ." + ident);
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Fix bugs in shader swizzling
2020-02-13 15:50:20 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Fix bugs in shader swizzling
2020-02-13 15:50:20 +01:00
if (!ok) {
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
_set_error("Invalid member for " + (dt == TYPE_STRUCT ? st : get_datatype_name(dt)) + " expression: ." + 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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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 21:16:47 +01: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 20:35:22 +01:00
mn->base_struct_name = st;
mn->struct_name = member_struct_name;
Added support for arrays as shader struct members
2020-02-11 20:03:04 +01: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 15:50:20 +01:00
mn->has_swizzling_duplicates = repeated;
Added support for arrays as shader struct members
2020-02-11 20:03:04 +01:00
if (array_size > 0) {
tk = _get_token();
if (tk.type == TK_PERIOD) {
_set_error("Nested array length() is not yet implemented");
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 20:03:04 +01:00
} else if (tk.type == TK_BRACKET_OPEN) {
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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 20:03:04 +01:00
if (index_expression->get_datatype() != TYPE_INT && index_expression->get_datatype() != TYPE_UINT) {
_set_error("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 20:03:04 +01:00
}
if (index_expression->type == Node::TYPE_CONSTANT) {
ConstantNode *cnode = (ConstantNode *)index_expression;
if (cnode) {
if (!cnode->values.empty()) {
int value = cnode->values[0].sint;
if (value < 0 || value >= array_size) {
_set_error(vformat("Index [%s] out of range [%s..%s]", 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 20:03:04 +01:00
}
}
}
}
tk = _get_token();
if (tk.type != TK_BRACKET_CLOSE) {
_set_error("Expected ']'");
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 20:03:04 +01:00
}
mn->index_expression = index_expression;
} else {
_set_error("Expected '[' or '.'");
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 20:03:04 +01: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-10 02:10:30 +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 21:33:42 +02:00
//todo
//member (period) has priority over any operator
//creates a subindexing expression in place
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02:00
//todo
//subindexing has priority over any operator
//creates a subindexing expression in place
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
*/
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
} else if (tk.type == TK_BRACKET_OPEN) {
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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-07 04:36:37 +02:00
if (index->get_datatype() != TYPE_INT && index->get_datatype() != TYPE_UINT) {
_set_error("Only integer datatypes 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-07 04:36:37 +02: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;
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
switch (expr->get_datatype()) {
case TYPE_BVEC2:
case TYPE_VEC2:
case TYPE_IVEC2:
case TYPE_UVEC2:
case TYPE_MAT2:
if (index->type == Node::TYPE_CONSTANT) {
uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
if (index_constant >= 2) {
_set_error("Index out of range (0-1)");
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-07 04:36:37 +02: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 16:35:23 +02:00
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
switch (expr->get_datatype()) {
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
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-07 04:36:37 +02:00
}
break;
case TYPE_BVEC3:
case TYPE_VEC3:
case TYPE_IVEC3:
case TYPE_UVEC3:
case TYPE_MAT3:
if (index->type == Node::TYPE_CONSTANT) {
uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
if (index_constant >= 3) {
_set_error("Index out of range (0-2)");
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-07 04:36:37 +02: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 16:35:23 +02:00
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
switch (expr->get_datatype()) {
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
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;
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
}
break;
case TYPE_BVEC4:
case TYPE_VEC4:
case TYPE_IVEC4:
case TYPE_UVEC4:
case TYPE_MAT4:
if (index->type == Node::TYPE_CONSTANT) {
uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
if (index_constant >= 4) {
_set_error("Index out of range (0-3)");
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-07 04:36:37 +02: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 16:35:23 +02:00
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
switch (expr->get_datatype()) {
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
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;
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
}
break;
default: {
Added support for arrays as shader struct members
2020-02-11 20:03:04 +01:00
_set_error("Object of type '" + (expr->get_datatype() == TYPE_STRUCT ? expr->get_datatype_name() : get_datatype_name(expr->get_datatype())) + "' can't be indexed");
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-07 04:36:37 +02:00
}
}
OperatorNode *op = alloc_node<OperatorNode>();
op->op = OP_INDEX;
op->return_cache = member_type;
op->arguments.push_back(expr);
op->arguments.push_back(index);
expr = op;
tk = _get_token();
if (tk.type != TK_BRACKET_CLOSE) {
_set_error("Expected ']' after indexing expression");
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-07 04:36:37 +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
} 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 21:33:42 +02: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 21:33:42 +02:00
op->arguments.push_back(expr);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 (!_validate_operator(op, &op->return_cache)) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
_set_error("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 21:33:42 +02:00
}
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 22:23:16 +01:00
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
if (!_validate_assign(expr, p_function_info)) {
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 22:23:16 +01:00
_set_error("Invalid use of increment/decrement operator in constant expression.");
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 22:23:16 +01: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 21:33:42 +02:00
break;
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-18 04:23:42 +02: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-18 04:23:42 +02:00
expression.push_back(e);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 21:33:42 +02:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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-18 04:23:42 +02: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 21:33:42 +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
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 21:33:42 +02:00
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
_set_error("Invalid token for operator: " + 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 21:33:42 +02:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +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 21:33:42 +02: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-18 04:23:42 +02: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 21:33:42 +02:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} else {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
_set_tkpos(pos); //something else, so rollback and end
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-18 04:23:42 +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
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-18 04:23:42 +02: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;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
int priority;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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 (expression[i].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
}
if (priority < min_priority) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-10 02:10:30 +01: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-10 02:10:30 +01:00
// OK! create operator..
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-18 04:23:42 +02: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-18 04:23:42 +02: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-18 04:23:42 +02:00
//can happen..
Change ".." punctuation for "..." in editor strings (#16507)
2018-04-22 19:36:01 +02:00
_set_error("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-18 04:23:42 +02:00
}
}
Fix various typos Found via `codespell`
2020-03-11 18:59:18 +01: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 21:33:42 +02:00
OperatorNode *op = alloc_node<OperatorNode>();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
op->op = expression[i].op;
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
if ((op->op == OP_INCREMENT || op->op == OP_DECREMENT) && !_validate_assign(expression[i + 1].node, p_function_info)) {
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 22:23:16 +01:00
_set_error("Can't use increment/decrement operator in constant expression.");
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 22:23:16 +01: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 21:33:42 +02: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 21:33:42 +02:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (!_validate_operator(op, &op->return_cache)) {
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-18 04:23:42 +02: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) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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 += " and ";
Style: Enforce braces around if blocks and loops 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());
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-18 04:23:42 +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
_set_error("Invalid arguments to unary operator '" + 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-18 04:23:42 +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
expression.remove(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-18 04:23:42 +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 21:33:42 +02: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)) {
Change ".." punctuation for "..." in editor strings (#16507)
2018-04-22 19:36:01 +02:00
_set_error("Parser bug...");
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-18 04:23:42 +02:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (next_op + 2 >= expression.size() || !expression[next_op + 2].is_op || expression[next_op + 2].op != OP_SELECT_ELSE) {
Fix typos in shader_language.cpp
2018-04-17 14:20:26 +02:00
_set_error("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 21:33:42 +02: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-18 04:23:42 +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 21:33:42 +02: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 21:33:42 +02: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;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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 (!_validate_operator(op, &op->return_cache)) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02: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) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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 += " and ";
Style: Enforce braces around if blocks and loops 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());
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +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
_set_error("Invalid argument to ternary ?: operator: " + 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 21:33:42 +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
for (int i = 0; i < 4; 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 21:33:42 +02:00
expression.remove(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-18 04:23:42 +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
if (next_op < 1 || next_op >= (expression.size() - 1)) {
Change ".." punctuation for "..." in editor strings (#16507)
2018-04-22 19:36:01 +02:00
_set_error("Parser bug...");
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-18 04:23:42 +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 21:33:42 +02: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-18 04:23:42 +02:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (expression[next_op - 1].is_op) {
Change ".." punctuation for "..." in editor strings (#16507)
2018-04-22 19:36:01 +02:00
_set_error("Parser bug...");
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-18 04:23:42 +02:00
}
Manually fix, merge and close #15168
2018-07-29 17:17:45 +02:00
if (_is_operator_assign(op->op)) {
String assign_message;
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
if (!_validate_assign(expression[next_op - 1].node, p_function_info, &assign_message)) {
Manually fix, merge and close #15168
2018-07-29 17:17:45 +02: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 17:17:45 +02:00
}
Made built-in identifiers properly constant in shaders. Fixes #14449, closes #14629
2017-12-15 22:23:16 +01: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-18 04:23:42 +02: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 16:19:06 +02: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-18 04:23:42 +02:00
Change ".." punctuation for "..." in editor strings (#16507)
2018-04-22 19:36:01 +02:00
_set_error("Parser bug...");
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-18 04:23:42 +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
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-18 04:23:42 +02: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 21:33:42 +02:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (!_validate_operator(op, &op->return_cache)) {
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-18 04:23:42 +02: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) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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 += " and ";
Style: Enforce braces around if blocks and loops 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 20:35:22 +01: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());
}
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-18 04:23:42 +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
_set_error("Invalid arguments to operator '" + 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-18 04:23:42 +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 21:33:42 +02: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-18 04:23:42 +02:00
expression.remove(next_op);
expression.remove(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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
return expression[0].node;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ShaderLanguage::Node *ShaderLanguage::_reduce_expression(BlockNode *p_block, ShaderLanguage::Node *p_node) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (p_node->type != Node::TYPE_OPERATOR) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02: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-10 02:10:30 +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 21:33:42 +02: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-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (op->op == OP_CONSTRUCT) {
ERR_FAIL_COND_V(op->arguments[0]->type != Node::TYPE_VARIABLE, p_node);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 16:31:18 +02:00
Vector<ConstantNode::Value> values;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 1; i < op->arguments.size(); i++) {
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
op->arguments.write[i] = _reduce_expression(p_block, op->arguments[i]);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (op->arguments[i]->type == Node::TYPE_CONSTANT) {
ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[i]);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (get_scalar_type(cn->datatype) == base) {
Fix handling of shader constants that caused crash, closes #15166
2018-08-31 13:11:13 +02:00
for (int j = 0; j < cn->values.size(); j++) {
values.push_back(cn->values[j]);
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (get_scalar_type(cn->datatype) == cn->datatype) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
ConstantNode::Value v;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (!convert_constant(cn, base, &v)) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 21:33:42 +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 16:31:18 +02: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 21:33:42 +02:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
} else {
return p_node;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
}
Fix handling of shader constants that caused crash, closes #15166
2018-08-31 13:11:13 +02:00
if (values.size() == 1) {
if (type >= TYPE_MAT2 && type <= TYPE_MAT4) {
ConstantNode::Value value = values[0];
ConstantNode::Value zero;
zero.real = 0.0f;
int size = 2 + (type - TYPE_MAT2);
values.clear();
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
values.push_back(i == j ? value : zero);
}
}
} else {
Fixed an access after free in ShaderLanguage::_reduce_expression. Passing an element reference of a vector to a push_back call to that same vector can cause an access after free. This is because push_back will resize the vector, reallocating if necessary, leaving the reference referring to the freed memory. Removed an instance of this usage here.
2018-09-19 15:28:19 +02:00
ConstantNode::Value value = values[0];
Fix handling of shader constants that caused crash, closes #15166
2018-08-31 13:11:13 +02:00
for (int i = 1; i < cardinality; i++) {
Fixed an access after free in ShaderLanguage::_reduce_expression. Passing an element reference of a vector to a push_back call to that same vector can cause an access after free. This is because push_back will resize the vector, reallocating if necessary, leaving the reference referring to the freed memory. Removed an instance of this usage here.
2018-09-19 15:28:19 +02: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 16:31:18 +02:00
return cn;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
} else if (op->op == OP_NEGATE) {
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 03:11:03 +02:00
op->arguments.write[0] = _reduce_expression(p_block, op->arguments[0]);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (op->arguments[0]->type == Node::TYPE_CONSTANT) {
ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[0]);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-10 02:10:30 +01:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
Vector<ConstantNode::Value> values;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < cn->values.size(); i++) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
ConstantNode::Value nv;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
switch (base) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02:00
} break;
case TYPE_UINT: {
Fix Visual Studio throwing C4146 warning.
2019-11-18 13:45:01 +01: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 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
values.push_back(nv);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02:00
return cn;
}
}
return p_node;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
ShaderLanguage::Node *ShaderLanguage::_parse_and_reduce_expression(BlockNode *p_block, const FunctionInfo &p_function_info) {
ShaderLanguage::Node *expr = _parse_expression(p_block, p_function_info);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (!expr) { //errored
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
return nullptr;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-10 02:10:30 +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 21:33:42 +02:00
return expr;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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 16:31:18 +02:00
TkPos pos = _get_tkpos();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
Token tk = _get_token();
Implements switch to shaders
2019-08-14 13:22:25 +02: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) {
_set_error("Switch may contains only case and default blocks");
return ERR_PARSE_ERROR;
}
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
bool is_struct = shader->structs.has(tk.text);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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 21:33:42 +02:00
if (p_just_one) {
_set_error("Unexpected '}'");
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
return OK;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
} else if (tk.type == TK_CONST || is_token_precision(tk.type) || is_token_nonvoid_datatype(tk.type) || is_struct) {
String struct_name = "";
if (is_struct) {
struct_name = tk.text;
}
Implemented local shader constants
2019-08-05 09:35:53 +02:00
bool is_const = false;
if (tk.type == TK_CONST) {
is_const = true;
tk = _get_token();
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (!is_struct) {
is_struct = shader->structs.has(tk.text); // check again.
struct_name = tk.text;
}
Implemented local shader constants
2019-08-05 09:35:53 +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
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 21:33:42 +02: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 21:33:42 +02:00
tk = _get_token();
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (!is_struct) {
is_struct = shader->structs.has(tk.text); // check again.
}
if (is_struct && precision != PRECISION_DEFAULT) {
_set_error("Precision modifier cannot be used on structs.");
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 21:33:42 +02:00
if (!is_token_nonvoid_datatype(tk.type)) {
Fix typos in shader_language.cpp
2018-04-17 14:20:26 +02:00
_set_error("Expected datatype after precision");
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
return ERR_PARSE_ERROR;
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (!is_struct) {
if (!is_token_variable_datatype(tk.type)) {
_set_error("Invalid data type for variable (samplers not allowed)");
return ERR_PARSE_ERROR;
}
Do not allow samplers where they dont belong (variables/return types), fixes #15133
2018-11-12 12:36:26 +01:00
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
DataType type = is_struct ? TYPE_STRUCT : get_token_datatype(tk.type);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
if (_validate_datatype(type) != OK) {
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 21:33:42 +02:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
Node *vardecl = nullptr;
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +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
while (true) {
if (tk.type != TK_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 21:33:42 +02:00
_set_error("Expected identifier after type");
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
StringName name = tk.text;
Fix few redefinition name errors for variable/param/function in shaders
2019-10-06 16:24:30 +02:00
ShaderLanguage::IdentifierType itype;
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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 16:24:30 +02:00
if (itype != IDENTIFIER_FUNCTION) {
_set_error("Redefinition of '" + String(name) + "'");
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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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;
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
var.array_size = 0;
Implemented local shader constants
2019-08-05 09:35:53 +02:00
var.is_const = is_const;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
var.struct_name = struct_name;
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02:00
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
tk = _get_token();
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02:00
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
if (tk.type == TK_BRACKET_OPEN) {
Added local array initializer
2019-07-15 17:47:22 +02:00
bool unknown_size = false;
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02:00
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
if (RenderingServer::get_singleton()->is_low_end() && is_const) {
Disabled array initialization, const array and arr.length in shaders
2020-01-16 09:46:11 +01:00
_set_error("Local const arrays are supported only on high-end platform!");
return ERR_PARSE_ERROR;
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
ArrayDeclarationNode *node = alloc_node<ArrayDeclarationNode>();
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (is_struct) {
node->struct_name = struct_name;
node->datatype = TYPE_STRUCT;
} else {
node->datatype = type;
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
node->precision = precision;
Implemented local shader constants
2019-08-05 09:35:53 +02:00
node->is_const = is_const;
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
vardecl = (Node *)node;
ArrayDeclarationNode::Declaration decl;
decl.name = name;
decl.size = 0U;
tk = _get_token();
Added local array initializer
2019-07-15 17:47:22 +02:00
if (tk.type == TK_BRACKET_CLOSE) {
unknown_size = true;
} else {
if (tk.type != TK_INT_CONSTANT || ((int)tk.constant) <= 0) {
_set_error("Expected integer constant > 0 or ']'");
return ERR_PARSE_ERROR;
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
Implemented do/while loops for shaders
2019-08-13 15:19:14 +02:00
decl.size = ((uint32_t)tk.constant);
Added local array initializer
2019-07-15 17:47:22 +02:00
tk = _get_token();
if (tk.type != TK_BRACKET_CLOSE) {
_set_error("Expected ']'");
return ERR_PARSE_ERROR;
}
var.array_size = decl.size;
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
}
Added local array initializer
2019-07-15 17:47:22 +02:00
bool full_def = false;
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
tk = _get_token();
Added local array initializer
2019-07-15 17:47:22 +02:00
if (tk.type == TK_OP_ASSIGN) {
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
if (RenderingServer::get_singleton()->is_low_end()) {
Disabled array initialization, const array and arr.length in shaders
2020-01-16 09:46:11 +01:00
_set_error("Array initialization is supported only on high-end platform!");
return ERR_PARSE_ERROR;
}
Added local array initializer
2019-07-15 17:47:22 +02:00
tk = _get_token();
if (tk.type != TK_CURLY_BRACKET_OPEN) {
if (unknown_size) {
_set_error("Expected '{'");
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();
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (shader->structs.has(tk.text)) {
_set_error("Precision modifier cannot be used on structs.");
return ERR_PARSE_ERROR;
}
Added local array initializer
2019-07-15 17:47:22 +02:00
if (!is_token_nonvoid_datatype(tk.type)) {
_set_error("Expected datatype after precision");
return ERR_PARSE_ERROR;
}
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
DataType type2;
Implemented global const array to shaders
2019-10-11 19:43:42 +02:00
StringName struct_name2 = "";
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (shader->structs.has(tk.text)) {
type2 = TYPE_STRUCT;
struct_name2 = tk.text;
} else {
if (!is_token_variable_datatype(tk.type)) {
_set_error("Invalid data type for array");
return ERR_PARSE_ERROR;
}
type2 = get_token_datatype(tk.type);
Added local array initializer
2019-07-15 17:47:22 +02:00
}
int array_size2 = 0;
tk = _get_token();
if (tk.type == TK_BRACKET_OPEN) {
Added missing form of array constructor in shaders
2020-01-18 09:41:55 +01:00
TkPos pos2 = _get_tkpos();
tk = _get_token();
if (tk.type == TK_BRACKET_CLOSE) {
array_size2 = var.array_size;
tk = _get_token();
} else {
_set_tkpos(pos2);
Added local array initializer
2019-07-15 17:47:22 +02:00
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
Node *n = _parse_and_reduce_expression(p_block, p_function_info);
Added missing form of array constructor in shaders
2020-01-18 09:41:55 +01:00
if (!n || n->type != Node::TYPE_CONSTANT || n->get_datatype() != TYPE_INT) {
_set_error("Expected single integer constant > 0");
return ERR_PARSE_ERROR;
}
ConstantNode *cnode = (ConstantNode *)n;
if (cnode->values.size() == 1) {
array_size2 = cnode->values[0].sint;
if (array_size2 <= 0) {
_set_error("Expected single integer constant > 0");
return ERR_PARSE_ERROR;
}
} else {
Added local array initializer
2019-07-15 17:47:22 +02:00
_set_error("Expected single integer constant > 0");
return ERR_PARSE_ERROR;
}
tk = _get_token();
Added missing form of array constructor in shaders
2020-01-18 09:41:55 +01:00
if (tk.type != TK_BRACKET_CLOSE) {
_set_error("Expected ']'");
return ERR_PARSE_ERROR;
} else {
tk = _get_token();
}
Added local array initializer
2019-07-15 17:47:22 +02:00
}
} else {
Added missing form of array constructor in shaders
2020-01-18 09:41:55 +01:00
_set_error("Expected '['");
Added local array initializer
2019-07-15 17:47:22 +02:00
return ERR_PARSE_ERROR;
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (precision != precision2 || type != type2 || struct_name != struct_name2 || var.array_size != array_size2) {
Added local array initializer
2019-07-15 17:47:22 +02:00
String error_str = "Cannot convert from '";
if (precision2 != PRECISION_DEFAULT) {
error_str += get_precision_name(precision2);
error_str += " ";
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (type2 == TYPE_STRUCT) {
error_str += struct_name2;
} else {
error_str += get_datatype_name(type2);
}
Added local array initializer
2019-07-15 17:47:22 +02:00
error_str += "[";
error_str += itos(array_size2);
error_str += "]'";
error_str += " to '";
if (precision != PRECISION_DEFAULT) {
error_str += get_precision_name(precision);
error_str += " ";
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (type == TYPE_STRUCT) {
error_str += struct_name;
} else {
error_str += get_datatype_name(type);
}
Added local array initializer
2019-07-15 17:47:22 +02:00
error_str += "[";
error_str += itos(var.array_size);
error_str += "]'";
_set_error(error_str);
return ERR_PARSE_ERROR;
}
}
bool curly = tk.type == TK_CURLY_BRACKET_OPEN;
if (unknown_size) {
if (!curly) {
_set_error("Expected '{'");
return ERR_PARSE_ERROR;
}
} else {
if (full_def) {
if (curly) {
_set_error("Expected '('");
return ERR_PARSE_ERROR;
}
}
}
if (tk.type == TK_PARENTHESIS_OPEN || curly) { // initialization
while (true) {
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
Node *n = _parse_and_reduce_expression(p_block, p_function_info);
Added local array initializer
2019-07-15 17:47:22 +02:00
if (!n) {
return ERR_PARSE_ERROR;
}
Prevent shader crash if function call been used on constant
2019-10-06 17:05:44 +02:00
if (node->is_const && n->type == Node::TYPE_OPERATOR && ((OperatorNode *)n)->op == OP_CALL) {
_set_error("Expected constant expression");
return ERR_PARSE_ERROR;
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (var.type != n->get_datatype() || struct_name != n->get_datatype_name()) {
_set_error("Invalid assignment of '" + (n->get_datatype() == TYPE_STRUCT ? n->get_datatype_name() : get_datatype_name(n->get_datatype())) + "' to '" + (var.type == TYPE_STRUCT ? struct_name : get_datatype_name(var.type)) + "'");
Added local array initializer
2019-07-15 17:47:22 +02: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: Enforce braces around if blocks and loops 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 (curly) {
Added local array initializer
2019-07-15 17:47:22 +02:00
_set_error("Expected '}' or ','");
Style: Enforce braces around if blocks and loops 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 local array initializer
2019-07-15 17:47:22 +02:00
_set_error("Expected ')' or ','");
Style: Enforce braces around if blocks and loops 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 local array initializer
2019-07-15 17:47:22 +02:00
return ERR_PARSE_ERROR;
}
}
if (unknown_size) {
decl.size = decl.initializer.size();
var.array_size = decl.initializer.size();
} else if (decl.initializer.size() != var.array_size) {
_set_error("Array size mismatch");
return ERR_PARSE_ERROR;
}
tk = _get_token();
}
} else {
if (unknown_size) {
_set_error("Expected array initialization");
return ERR_PARSE_ERROR;
}
Force user to initialize local shader constants
2019-08-13 08:55:43 +02:00
if (is_const) {
_set_error("Expected initialization of constant");
return ERR_PARSE_ERROR;
}
Added local array initializer
2019-07-15 17:47:22 +02:00
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
node->declarations.push_back(decl);
} else if (tk.type == TK_OP_ASSIGN) {
VariableDeclarationNode *node = alloc_node<VariableDeclarationNode>();
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (is_struct) {
node->struct_name = struct_name;
node->datatype = TYPE_STRUCT;
} else {
node->datatype = type;
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
node->precision = precision;
Implemented local shader constants
2019-08-05 09:35:53 +02:00
node->is_const = is_const;
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
vardecl = (Node *)node;
VariableDeclarationNode::Declaration decl;
decl.name = name;
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
decl.initializer = nullptr;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Fix premature declaration of shader variables created with assignment
2018-01-01 19:56:44 +01:00
//variable created with assignment! must parse an expression
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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 21:33:42 +02: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
}
Prevent shader crash if function call been used on constant
2019-10-06 17:05:44 +02:00
if (node->is_const && n->type == Node::TYPE_OPERATOR && ((OperatorNode *)n)->op == OP_CALL) {
_set_error("Expected constant expression after '='");
return ERR_PARSE_ERROR;
}
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02:00
decl.initializer = n;
property validate assignment condition in new variables, fixes #9411
2017-08-20 21:15:08 +02:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (var.type == TYPE_STRUCT ? (var.struct_name != n->get_datatype_name()) : (var.type != n->get_datatype())) {
_set_error("Invalid assignment of '" + (n->get_datatype() == TYPE_STRUCT ? n->get_datatype_name() : get_datatype_name(n->get_datatype())) + "' to '" + (var.type == TYPE_STRUCT ? String(var.struct_name) : get_datatype_name(var.type)) + "'");
property validate assignment condition in new variables, fixes #9411
2017-08-20 21:15:08 +02:00
return ERR_PARSE_ERROR;
}
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02:00
tk = _get_token();
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
node->declarations.push_back(decl);
} else {
Force user to initialize local shader constants
2019-08-13 08:55:43 +02:00
if (is_const) {
_set_error("Expected initialization of constant");
return ERR_PARSE_ERROR;
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
VariableDeclarationNode *node = alloc_node<VariableDeclarationNode>();
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (is_struct) {
node->struct_name = struct_name;
node->datatype = TYPE_STRUCT;
} else {
node->datatype = type;
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
node->precision = precision;
vardecl = (Node *)node;
VariableDeclarationNode::Declaration decl;
decl.name = name;
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
decl.initializer = nullptr;
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
node->declarations.push_back(decl);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
p_block->statements.push_back(vardecl);
Fix premature declaration of shader variables created with assignment
2018-01-01 19:56:44 +01:00
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
p_block->variables[name] = var;
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (tk.type == TK_COMMA) {
Prevent shader crash if multiple variables has been declared in 'for'
2020-03-26 11:32:39 +01:00
if (p_block->block_type == BlockNode::BLOCK_TYPE_FOR) {
_set_error("Multiple declarations in 'for' loop are not implemented yet.");
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 21:33:42 +02:00
tk = _get_token();
//another variable
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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 21:33:42 +02:00
break;
} else {
Added local array initializer
2019-07-15 17:47:22 +02:00
_set_error("Expected ',' or ';' after variable");
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +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
} 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 21:33:42 +02: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 14:18:10 +02:00
if (_parse_block(block, p_function_info, false, p_can_break, p_can_continue) != OK) {
Fix incorrect shader block parsing
2020-03-20 15:24:00 +01: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 16:31:18 +02: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 21:33:42 +02: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) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
_set_error("Expected '(' after if");
return ERR_PARSE_ERROR;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
ControlFlowNode *cf = alloc_node<ControlFlowNode>();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
cf->flow_op = FLOW_OP_IF;
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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 21:33:42 +02:00
return ERR_PARSE_ERROR;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
Fix shader crash if non-boolean expression inserted into "if"
2019-10-28 06:35:33 +01:00
if (n->get_datatype() != TYPE_BOOL) {
_set_error("Expected boolean expression");
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 21:33:42 +02: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) {
Added depth texture support (using parallax) to default material.
2017-06-04 23:08:06 +02:00
_set_error("Expected ')' after 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 21:33:42 +02:00
return ERR_PARSE_ERROR;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 16:31:18 +02: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 21:33:42 +02: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 16:31:18 +02: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 21:33:42 +02:00
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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 23:08:06 +02: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 21:33:42 +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
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 21:33:42 +02: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 21:33:42 +02: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 21:33:42 +02:00
cf->blocks.push_back(block);
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
err = _parse_block(block, p_function_info, true, p_can_break, p_can_continue);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} else {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
_set_tkpos(pos); //rollback
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Implements switch to shaders
2019-08-14 13:22:25 +02:00
} else if (tk.type == TK_CF_SWITCH) {
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
if (RenderingServer::get_singleton()->is_low_end()) {
Removed switch operator from GLES2 shader back-end
2019-11-02 10:36:43 +01:00
_set_error("\"switch\" operator is supported only on high-end platform!");
return ERR_PARSE_ERROR;
}
Implements switch to shaders
2019-08-14 13:22:25 +02:00
// switch() {}
tk = _get_token();
if (tk.type != TK_PARENTHESIS_OPEN) {
_set_error("Expected '(' after switch");
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 14:18:10 +02: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 13:22:25 +02:00
return ERR_PARSE_ERROR;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Implements switch to shaders
2019-08-14 13:22:25 +02:00
if (n->get_datatype() != TYPE_INT) {
_set_error("Expected integer expression");
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_PARENTHESIS_CLOSE) {
_set_error("Expected ')' after expression");
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_CURLY_BRACKET_OPEN) {
_set_error("Expected '{' after switch statement");
return ERR_PARSE_ERROR;
}
BlockNode *switch_block = alloc_node<BlockNode>();
switch_block->block_type = BlockNode::BLOCK_TYPE_SWITCH;
switch_block->parent_block = p_block;
cf->expressions.push_back(n);
cf->blocks.push_back(switch_block);
p_block->statements.push_back(cf);
int prev_type = TK_CF_CASE;
while (true) { // Go-through multiple cases.
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
if (_parse_block(switch_block, p_function_info, true, true, false) != OK) {
Implements switch to shaders
2019-08-14 13:22:25 +02: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) {
_set_error("Cases must be defined before default case.");
return ERR_PARSE_ERROR;
} else if (prev_type == TK_CF_DEFAULT) {
_set_error("Default case must be defined only once.");
return ERR_PARSE_ERROR;
}
}
prev_type = tk.type;
_set_tkpos(pos);
continue;
} else {
Set<int> constants;
for (int i = 0; i < switch_block->statements.size(); i++) { // Checks for duplicates.
ControlFlowNode *flow = (ControlFlowNode *)switch_block->statements[i];
if (flow) {
if (flow->flow_op == FLOW_OP_CASE) {
ConstantNode *n2 = static_cast<ConstantNode *>(flow->expressions[0]);
if (!n2) {
return ERR_PARSE_ERROR;
}
if (n2->values.empty()) {
return ERR_PARSE_ERROR;
}
if (constants.has(n2->values[0].sint)) {
_set_error("Duplicated case label: '" + itos(n2->values[0].sint) + "'");
return ERR_PARSE_ERROR;
}
constants.insert(n2->values[0].sint);
} else if (flow->flow_op == FLOW_OP_DEFAULT) {
continue;
} else {
return ERR_PARSE_ERROR;
}
} else {
return ERR_PARSE_ERROR;
}
}
break;
}
}
} else if (tk.type == TK_CF_CASE) {
// case x : break; | return;
if (p_block && p_block->block_type == BlockNode::BLOCK_TYPE_CASE) {
_set_tkpos(pos);
return OK;
}
if (!p_block || (p_block->block_type != BlockNode::BLOCK_TYPE_SWITCH)) {
_set_error("case must be placed within switch block");
return ERR_PARSE_ERROR;
}
tk = _get_token();
int sign = 1;
if (tk.type == TK_OP_SUB) {
sign = -1;
tk = _get_token();
}
if (tk.type != TK_INT_CONSTANT) {
_set_error("Expected integer constant");
return ERR_PARSE_ERROR;
}
int constant = (int)tk.constant * sign;
tk = _get_token();
if (tk.type != TK_COLON) {
_set_error("Expected ':'");
return ERR_PARSE_ERROR;
}
ControlFlowNode *cf = alloc_node<ControlFlowNode>();
cf->flow_op = FLOW_OP_CASE;
ConstantNode *n = alloc_node<ConstantNode>();
ConstantNode::Value v;
v.sint = constant;
n->values.push_back(v);
n->datatype = TYPE_INT;
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 14:18:10 +02: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 13:22:25 +02: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 13:22:25 +02: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)) {
_set_error("default must be placed within switch block");
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_COLON) {
_set_error("Expected ':'");
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 14:18:10 +02: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 13:22:25 +02: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 13:22:25 +02:00
return OK;
Implemented do/while loops for shaders
2019-08-13 15:19:14 +02: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 15:19:14 +02: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 14:18:10 +02: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 15:19:14 +02: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 15:19:14 +02:00
tk = _get_token();
if (tk.type != TK_CF_WHILE) {
_set_error("Expected while after do");
return ERR_PARSE_ERROR;
}
}
Added depth texture support (using parallax) to default material.
2017-06-04 23:08:06 +02:00
tk = _get_token();
Implemented do/while loops for shaders
2019-08-13 15:19:14 +02:00
Added depth texture support (using parallax) to default material.
2017-06-04 23:08:06 +02:00
if (tk.type != TK_PARENTHESIS_OPEN) {
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02:00
_set_error("Expected '(' after while");
Added depth texture support (using parallax) to default material.
2017-06-04 23:08:06 +02:00
return ERR_PARSE_ERROR;
}
ControlFlowNode *cf = alloc_node<ControlFlowNode>();
Implemented do/while loops for shaders
2019-08-13 15:19:14 +02: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 14:18:10 +02: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 23:08:06 +02: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 23:08:06 +02:00
tk = _get_token();
if (tk.type != TK_PARENTHESIS_CLOSE) {
_set_error("Expected ')' after expression");
return ERR_PARSE_ERROR;
}
Implemented do/while loops for shaders
2019-08-13 15:19:14 +02: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 23:08:06 +02:00
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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 15:19:14 +02: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 15:19:14 +02: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) {
_set_error("Expected ';'");
return ERR_PARSE_ERROR;
}
}
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02:00
} else if (tk.type == TK_CF_FOR) {
Implemented do/while loops for shaders
2019-08-13 15:19:14 +02:00
// for() {}
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02:00
tk = _get_token();
if (tk.type != TK_PARENTHESIS_OPEN) {
_set_error("Expected '(' after for");
return ERR_PARSE_ERROR;
}
ControlFlowNode *cf = alloc_node<ControlFlowNode>();
cf->flow_op = FLOW_OP_FOR;
BlockNode *init_block = alloc_node<BlockNode>();
Prevent shader crash if multiple variables has been declared in 'for'
2020-03-26 11:32:39 +01:00
init_block->block_type = BlockNode::BLOCK_TYPE_FOR;
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02: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 20:22:33 +02:00
cf->blocks.push_back(init_block);
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
if (_parse_block(init_block, p_function_info, true, false, false) != OK) {
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02:00
return ERR_PARSE_ERROR;
}
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
Node *n = _parse_and_reduce_expression(init_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 support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02: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 support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02:00
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
if (n->get_datatype() != TYPE_BOOL) {
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02:00
_set_error("Middle expression is expected to be boolean.");
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_SEMICOLON) {
_set_error("Expected ';' after middle expression");
return ERR_PARSE_ERROR;
}
cf->expressions.push_back(n);
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
n = _parse_and_reduce_expression(init_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 support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02: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 support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02:00
cf->expressions.push_back(n);
tk = _get_token();
if (tk.type != TK_PARENTHESIS_CLOSE) {
_set_error("Expected ')' after third expression");
return ERR_PARSE_ERROR;
}
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 20:22:33 +02:00
cf->blocks.push_back(block);
p_block->statements.push_back(cf);
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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) {
Added depth texture support (using parallax) to default material.
2017-06-04 23:08:06 +02: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-10 02:10:30 +01:00
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02: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 08:24:49 +02:00
if (b && b->parent_function && (b->parent_function->name == "vertex" || b->parent_function->name == "fragment" || b->parent_function->name == "light")) {
_set_error(vformat("Using 'return' in '%s' processor function results in undefined behavior!", b->parent_function->name));
return ERR_PARSE_ERROR;
}
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
while (b && !b->parent_function) {
b = b->parent_block;
}
if (!b) {
_set_error("Bug");
return ERR_BUG;
}
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) {
_set_error("Expected return with expression of type '" + get_datatype_name(b->parent_function->return_type) + "'");
return ERR_PARSE_ERROR;
}
} else {
_set_tkpos(pos); //rollback, wants expression
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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-07 04:36:37 +02: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
}
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
if (b->parent_function->return_type != expr->get_datatype()) {
_set_error("Expected return expression of type '" + get_datatype_name(b->parent_function->return_type) + "'");
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_SEMICOLON) {
_set_error("Expected ';' after return expression");
return ERR_PARSE_ERROR;
}
flow->expressions.push_back(expr);
}
removed DISCARD built in variable, replaced by actual discard GLSL instruction, fixes #9677
2017-08-29 15:14:07 +02:00
p_block->statements.push_back(flow);
Fix nested break/return in shader switch statement
2020-01-10 09:57:56 +01: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 13:22:25 +02:00
}
removed DISCARD built in variable, replaced by actual discard GLSL instruction, fixes #9677
2017-08-29 15:14:07 +02:00
} else if (tk.type == TK_CF_DISCARD) {
//check return type
BlockNode *b = p_block;
while (b && !b->parent_function) {
b = b->parent_block;
}
if (!b) {
_set_error("Bug");
return ERR_BUG;
}
if (!b->parent_function->can_discard) {
_set_error("Use of 'discard' is not allowed here.");
return ERR_PARSE_ERROR;
}
ControlFlowNode *flow = alloc_node<ControlFlowNode>();
flow->flow_op = FLOW_OP_DISCARD;
pos = _get_tkpos();
tk = _get_token();
if (tk.type != TK_SEMICOLON) {
//all is good
_set_error("Expected ';' after discard");
}
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02:00
p_block->statements.push_back(flow);
} else if (tk.type == TK_CF_BREAK) {
if (!p_can_break) {
//all is good
_set_error("Breaking is not allowed here");
}
ControlFlowNode *flow = alloc_node<ControlFlowNode>();
flow->flow_op = FLOW_OP_BREAK;
pos = _get_tkpos();
tk = _get_token();
if (tk.type != TK_SEMICOLON) {
//all is good
_set_error("Expected ';' after break");
}
p_block->statements.push_back(flow);
Fix nested break/return in shader switch statement
2020-01-10 09:57:56 +01: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 13:22:25 +02:00
}
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02:00
} else if (tk.type == TK_CF_CONTINUE) {
Implements switch to shaders
2019-08-14 13:22:25 +02:00
if (!p_can_continue) {
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02:00
//all is good
Fix typos in shader_language.cpp
2018-04-17 14:20:26 +02:00
_set_error("Continuing is not allowed here");
Added support for for, break and continue. Closes #10560, closes #10661
2017-09-05 20:22:33 +02: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
_set_error("Expected ';' after continue");
}
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02: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 21:33:42 +02:00
} else {
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02: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 16:31:18 +02:00
_set_tkpos(pos); //rollback
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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 16:31:18 +02: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
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 21:33:42 +02:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
_set_error("Expected ';' after statement");
return ERR_PARSE_ERROR;
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 (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 21:33:42 +02: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-10 02:10:30 +01:00
}
return OK;
}
Improve error messages related to `shader_type` The list of allowed shader types is now displayed if any `shader_type`-related error is emitted. This makes it easier to remember which shader types are allowed when creating a new shader.
2019-10-26 17:41:47 +02:00
String ShaderLanguage::_get_shader_type_list(const Set<String> &p_shader_types) const {
// Return a list of shader types as an human-readable string
String valid_types;
for (const Set<String>::Element *E = p_shader_types.front(); E; E = E->next()) {
if (valid_types != String()) {
valid_types += ", ";
}
valid_types += "'" + E->get() + "'";
}
return valid_types;
}
Fix shader crash if pass const argument to 'out/inout' parameter
2020-02-12 21:16:47 +01:00
String ShaderLanguage::_get_qualifier_str(ArgumentQualifier p_qualifier) const {
switch (p_qualifier) {
case ArgumentQualifier::ARGUMENT_QUALIFIER_IN:
return "in";
case ArgumentQualifier::ARGUMENT_QUALIFIER_OUT:
return "out";
case ArgumentQualifier::ARGUMENT_QUALIFIER_INOUT:
return "inout";
}
return "";
}
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 11:28:29 +01:00
Error ShaderLanguage::_validate_datatype(DataType p_type) {
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
if (RenderingServer::get_singleton()->is_low_end()) {
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 11:28:29 +01:00
bool invalid_type = false;
switch (p_type) {
Disallow uint/uvec usage on GLES2 platform
2020-01-20 13:34:25 +01:00
case TYPE_UINT:
case TYPE_UVEC2:
case TYPE_UVEC3:
case TYPE_UVEC4:
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 11:28:29 +01:00
case TYPE_ISAMPLER2D:
case TYPE_USAMPLER2D:
case TYPE_ISAMPLER3D:
case TYPE_USAMPLER3D:
case TYPE_USAMPLER2DARRAY:
case TYPE_ISAMPLER2DARRAY:
invalid_type = true;
break;
default:
break;
}
if (invalid_type) {
_set_error(vformat("\"%s\" type is supported only on high-end platform!", get_datatype_name(p_type)));
return ERR_UNAVAILABLE;
}
}
return OK;
}
Visual Shaders are back.
2018-07-14 23:15:42 +02:00
Error ShaderLanguage::_parse_shader(const Map<StringName, FunctionInfo> &p_functions, const Vector<StringName> &p_render_modes, const Set<String> &p_shader_types) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
Token tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
if (tk.type != TK_SHADER_TYPE) {
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
_set_error("Expected 'shader_type' at the beginning of shader. Valid types are: " + _get_shader_type_list(p_shader_types));
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_IDENTIFIER) {
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
_set_error("Expected identifier after 'shader_type', indicating type of shader. Valid types are: " + _get_shader_type_list(p_shader_types));
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
return ERR_PARSE_ERROR;
}
String shader_type_identifier;
shader_type_identifier = tk.text;
if (!p_shader_types.has(shader_type_identifier)) {
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
_set_error("Invalid shader type. Valid types are: " + _get_shader_type_list(p_shader_types));
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_SEMICOLON) {
_set_error("Expected ';' after 'shader_type <type>'.");
}
tk = _get_token();
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 23:31:01 +02:00
int texture_uniforms = 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
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-17 04:52:00 +02:00
int instance_index = 0;
ShaderNode::Uniform::Scope uniform_scope = ShaderNode::Uniform::SCOPE_LOCAL;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
FIx autocompletion for emit_particle in shader editor
2020-10-13 10:53:06 +02:00
stages = &p_functions;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it 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 21:33:42 +02:00
case TK_RENDER_MODE: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
while (true) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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-10 02:10:30 +01: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()) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
_set_error("Expected identifier for render mode");
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Visual Shaders are back.
2018-07-14 23:15:42 +02:00
if (p_render_modes.find(mode) == -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
_set_error("Invalid render mode: '" + String(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 21:33:42 +02:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (shader->render_modes.find(mode) != -1) {
_set_error("Duplicate render mode: '" + String(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 21:33:42 +02:00
return ERR_PARSE_ERROR;
}
Added additional token checks for the shader if..else.. statement. Fixes issue #2791.
2015-11-22 06:49:58 +01:00
PBR more or less working, still working on bringing gizmos back
2016-10-27 16:50:26 +02:00
shader->render_modes.push_back(mode);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02: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 21:33:42 +02: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 21:33:42 +02:00
break; //done
} 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
_set_error("Unexpected token: " + 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 21:33:42 +02:00
return ERR_PARSE_ERROR;
}
}
} break;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
case TK_STRUCT: {
ShaderNode::Struct st;
DataType type;
tk = _get_token();
if (tk.type == TK_IDENTIFIER) {
st.name = tk.text;
tk = _get_token();
if (tk.type != TK_CURLY_BRACKET_OPEN) {
_set_error("Expected '{'");
return ERR_PARSE_ERROR;
}
} else {
_set_error("Expected struct identifier!");
return ERR_PARSE_ERROR;
}
StructNode *st_node = alloc_node<StructNode>();
st.shader_struct = st_node;
int member_count = 0;
Fix shader crash if duplicated struct members created
2020-02-15 20:19:45 +01:00
Set<String> member_names;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
while (true) { // variables list
tk = _get_token();
if (tk.type == TK_CURLY_BRACKET_CLOSE) {
break;
}
StringName struct_name = "";
bool struct_dt = false;
bool use_precision = false;
DataPrecision precision = DataPrecision::PRECISION_DEFAULT;
if (tk.type == TK_STRUCT) {
_set_error("nested structs are not allowed!");
return ERR_PARSE_ERROR;
}
if (is_token_precision(tk.type)) {
precision = get_token_precision(tk.type);
use_precision = true;
tk = _get_token();
}
if (shader->structs.has(tk.text)) {
struct_name = tk.text;
struct_dt = true;
if (use_precision) {
_set_error("Precision modifier cannot be used on structs.");
return ERR_PARSE_ERROR;
}
}
if (!is_token_datatype(tk.type) && !struct_dt) {
_set_error("Expected datatype.");
return ERR_PARSE_ERROR;
} else {
type = struct_dt ? TYPE_STRUCT : get_token_datatype(tk.type);
if (is_sampler_type(type)) {
_set_error("sampler datatype not allowed here");
return ERR_PARSE_ERROR;
} else if (type == TYPE_VOID) {
_set_error("void datatype not allowed here");
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_IDENTIFIER) {
_set_error("Expected identifier!");
return ERR_PARSE_ERROR;
}
MemberNode *member = alloc_node<MemberNode>();
member->precision = precision;
member->datatype = type;
member->struct_name = struct_name;
member->name = tk.text;
Fix shader crash if duplicated struct members created
2020-02-15 20:19:45 +01:00
if (member_names.has(member->name)) {
_set_error("Redefinition of '" + String(member->name) + "'");
return ERR_PARSE_ERROR;
}
member_names.insert(member->name);
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
tk = _get_token();
Added support for arrays as shader struct members
2020-02-11 20:03:04 +01:00
if (tk.type == TK_BRACKET_OPEN) {
tk = _get_token();
if (tk.type == TK_INT_CONSTANT && tk.constant > 0) {
member->array_size = (int)tk.constant;
tk = _get_token();
if (tk.type == TK_BRACKET_CLOSE) {
tk = _get_token();
if (tk.type != TK_SEMICOLON) {
_set_error("Expected ';'");
return ERR_PARSE_ERROR;
}
} else {
_set_error("Expected ']'");
return ERR_PARSE_ERROR;
}
} else {
_set_error("Expected single integer constant > 0");
return ERR_PARSE_ERROR;
}
}
st_node->members.push_back(member);
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (tk.type != TK_SEMICOLON) {
Added support for arrays as shader struct members
2020-02-11 20:03:04 +01:00
_set_error("Expected ']' or ';'");
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
return ERR_PARSE_ERROR;
}
member_count++;
}
}
if (member_count == 0) {
_set_error("Empty structs are not allowed!");
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_SEMICOLON) {
_set_error("Expected ';'");
return ERR_PARSE_ERROR;
}
shader->structs[st.name] = st;
shader->vstructs.push_back(st); // struct's order is important!
} 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-17 04:52:00 +02:00
case TK_GLOBAL: {
tk = _get_token();
if (tk.type != TK_UNIFORM) {
_set_error("Expected 'uniform' after 'global'");
return ERR_PARSE_ERROR;
}
uniform_scope = ShaderNode::Uniform::SCOPE_GLOBAL;
};
[[fallthrough]];
case TK_INSTANCE: {
if (uniform_scope == ShaderNode::Uniform::SCOPE_LOCAL) {
tk = _get_token();
if (tk.type != TK_UNIFORM) {
_set_error("Expected 'uniform' after 'instance'");
return ERR_PARSE_ERROR;
}
uniform_scope = ShaderNode::Uniform::SCOPE_INSTANCE;
}
};
[[fallthrough]];
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
case TK_UNIFORM:
case TK_VARYING: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool uniform = tk.type == TK_UNIFORM;
Forbids varying declaration in particles and sky shaders
2020-09-20 17:45:37 +02:00
if (!uniform) {
if (shader_type_identifier == "particles" || shader_type_identifier == "sky") {
_set_error(vformat("Varyings cannot be used in '%s' shaders!", shader_type_identifier));
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 21:33:42 +02:00
DataPrecision precision = PRECISION_DEFAULT;
Added interpolation modifiers to shaderlang
2017-11-27 16:47:46 +01:00
DataInterpolation interpolation = INTERPOLATION_SMOOTH;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
DataType type;
StringName name;
tk = _get_token();
Added interpolation modifiers to shaderlang
2017-11-27 16:47:46 +01:00
if (is_token_interpolation(tk.type)) {
interpolation = get_token_interpolation(tk.type);
tk = _get_token();
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02: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 21:33:42 +02:00
tk = _get_token();
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
if (!is_token_datatype(tk.type)) {
_set_error("Expected datatype. ");
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
type = get_token_datatype(tk.type);
Added additional token checks for the shader if..else.. statement. Fixes issue #2791.
2015-11-22 06:49:58 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (type == TYPE_VOID) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
_set_error("void datatype not allowed here");
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 16:35:23 +02:00
Allow matrixes in varyings
2018-08-19 14:16:54 +02:00
if (!uniform && (type < TYPE_FLOAT || type > TYPE_MAT4)) {
Implement shader array support for varyings
2019-07-29 16:08:25 +02:00
_set_error("Invalid type for varying, only float,vec2,vec3,vec4,mat2,mat3,mat4 or array of these types allowed.");
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
return ERR_PARSE_ERROR;
}
Added additional token checks for the shader if..else.. statement. Fixes issue #2791.
2015-11-22 06:49:58 +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 21:33:42 +02: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_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 21:33:42 +02:00
_set_error("Expected identifier!");
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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
name = tk.text;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
if (_find_identifier(nullptr, false, FunctionInfo(), 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
_set_error("Redefinition of '" + 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 21:33:42 +02:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Added check if field name in the shader is equal to builtin
2019-10-29 12:36:11 +01:00
if (has_builtin(p_functions, name)) {
_set_error("Redefinition of '" + String(name) + "'");
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 21:33:42 +02:00
if (uniform) {
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-17 04:52:00 +02:00
if (uniform_scope == ShaderNode::Uniform::SCOPE_GLOBAL) {
//validate global uniform
DataType gvtype = global_var_get_type_func(name);
if (gvtype == TYPE_MAX) {
_set_error("Global uniform '" + String(name) + "' does not exist. Create it in Project Settings.");
return ERR_PARSE_ERROR;
}
if (type != gvtype) {
_set_error("Global uniform '" + String(name) + "' must be of type '" + get_datatype_name(gvtype) + "'.");
return ERR_PARSE_ERROR;
}
}
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
ShaderNode::Uniform uniform2;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 23:31:01 +02: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-17 04:52:00 +02:00
if (uniform_scope == ShaderNode::Uniform::SCOPE_INSTANCE) {
_set_error("Uniforms with 'instance' qualifiers can't be of sampler type.");
return ERR_PARSE_ERROR;
}
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
uniform2.texture_order = texture_uniforms++;
uniform2.order = -1;
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 11:28:29 +01:00
if (_validate_datatype(type) != OK) {
return ERR_PARSE_ERROR;
}
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 23:31:01 +02: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 14:34:23 +02:00
if (uniform_scope == ShaderNode::Uniform::SCOPE_INSTANCE && (type == TYPE_MAT2 || type == TYPE_MAT3 || type == TYPE_MAT4)) {
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-17 04:52:00 +02:00
_set_error("Uniforms with 'instance' qualifiers can't be of matrix type.");
return ERR_PARSE_ERROR;
}
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
uniform2.texture_order = -1;
uniform2.order = uniforms++;
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 23:31:01 +02:00
}
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
uniform2.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-17 04:52:00 +02:00
uniform2.scope = uniform_scope;
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
uniform2.precision = precision;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
//todo parse default value
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-17 04:52:00 +02: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) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
//hint
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02: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 21:33:42 +02:00
tk = _get_token();
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
if (tk.type == TK_HINT_WHITE_TEXTURE) {
uniform2.hint = ShaderNode::Uniform::HINT_WHITE;
} else if (tk.type == TK_HINT_BLACK_TEXTURE) {
uniform2.hint = ShaderNode::Uniform::HINT_BLACK;
} else if (tk.type == TK_HINT_NORMAL_TEXTURE) {
uniform2.hint = ShaderNode::Uniform::HINT_NORMAL;
} else if (tk.type == TK_HINT_ROUGHNESS_NORMAL_TEXTURE) {
uniform2.hint = ShaderNode::Uniform::HINT_ROUGHNESS_NORMAL;
} else if (tk.type == TK_HINT_ROUGHNESS_R) {
uniform2.hint = ShaderNode::Uniform::HINT_ROUGHNESS_R;
} else if (tk.type == TK_HINT_ROUGHNESS_G) {
uniform2.hint = ShaderNode::Uniform::HINT_ROUGHNESS_G;
} else if (tk.type == TK_HINT_ROUGHNESS_B) {
uniform2.hint = ShaderNode::Uniform::HINT_ROUGHNESS_B;
} else if (tk.type == TK_HINT_ROUGHNESS_A) {
uniform2.hint = ShaderNode::Uniform::HINT_ROUGHNESS_A;
} else if (tk.type == TK_HINT_ROUGHNESS_GRAY) {
uniform2.hint = ShaderNode::Uniform::HINT_ROUGHNESS_GRAY;
} else if (tk.type == TK_HINT_ANISO_TEXTURE) {
uniform2.hint = ShaderNode::Uniform::HINT_ANISO;
} else if (tk.type == TK_HINT_ALBEDO_TEXTURE) {
uniform2.hint = ShaderNode::Uniform::HINT_ALBEDO;
} else if (tk.type == TK_HINT_BLACK_ALBEDO_TEXTURE) {
uniform2.hint = ShaderNode::Uniform::HINT_BLACK_ALBEDO;
} else if (tk.type == TK_HINT_COLOR) {
if (type != TYPE_VEC4) {
_set_error("Color hint is for vec4 only");
return ERR_PARSE_ERROR;
}
uniform2.hint = ShaderNode::Uniform::HINT_COLOR;
} else if (tk.type == TK_HINT_RANGE) {
uniform2.hint = ShaderNode::Uniform::HINT_RANGE;
if (type != TYPE_FLOAT && type != TYPE_INT) {
_set_error("Range hint is for float and int only");
return ERR_PARSE_ERROR;
}
Huge amount of improvement in the material system. Materials should be a lot more complete and usable now.
2016-11-21 02:49:53 +01:00
tk = _get_token();
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
if (tk.type != TK_PARENTHESIS_OPEN) {
_set_error("Expected '(' after hint_range");
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
float sign = 1.0;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
if (tk.type == TK_OP_SUB) {
sign = -1.0;
tk = _get_token();
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Rename TYPE_REAL to TYPE_FLOAT To be consistent with the naming everywhere else.
2020-12-04 13:25:14 +01:00
if (tk.type != TK_FLOAT_CONSTANT && tk.type != TK_INT_CONSTANT) {
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
_set_error("Expected integer constant");
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
uniform2.hint_range[0] = tk.constant;
uniform2.hint_range[0] *= sign;
Huge amount of improvement in the material system. Materials should be a lot more complete and usable now.
2016-11-21 02:49:53 +01:00
tk = _get_token();
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
if (tk.type != TK_COMMA) {
_set_error("Expected ',' after integer constant");
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
sign = 1.0;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
if (tk.type == TK_OP_SUB) {
sign = -1.0;
tk = _get_token();
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Rename TYPE_REAL to TYPE_FLOAT To be consistent with the naming everywhere else.
2020-12-04 13:25:14 +01:00
if (tk.type != TK_FLOAT_CONSTANT && 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 21:33:42 +02:00
_set_error("Expected integer constant after ','");
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
uniform2.hint_range[1] = tk.constant;
uniform2.hint_range[1] *= sign;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
tk = _get_token();
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
if (tk.type == TK_COMMA) {
tk = _get_token();
Rename TYPE_REAL to TYPE_FLOAT To be consistent with the naming everywhere else.
2020-12-04 13:25:14 +01:00
if (tk.type != TK_FLOAT_CONSTANT && tk.type != TK_INT_CONSTANT) {
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
_set_error("Expected integer constant after ','");
return ERR_PARSE_ERROR;
}
uniform2.hint_range[2] = tk.constant;
tk = _get_token();
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
} else {
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
if (type == TYPE_INT) {
uniform2.hint_range[2] = 1;
} else {
uniform2.hint_range[2] = 0.001;
}
}
if (tk.type != TK_PARENTHESIS_CLOSE) {
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-17 04:52:00 +02:00
_set_error("Expected ')'");
return ERR_PARSE_ERROR;
}
} else if (tk.type == TK_HINT_INSTANCE_INDEX) {
if (custom_instance_index != -1) {
_set_error("Can only specify 'instance_index' once.");
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_PARENTHESIS_OPEN) {
_set_error("Expected '(' after 'instance_index'");
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type == TK_OP_SUB) {
_set_error("The instance index can't be negative.");
return ERR_PARSE_ERROR;
}
if (tk.type != TK_INT_CONSTANT) {
_set_error("Expected integer constant");
return ERR_PARSE_ERROR;
}
custom_instance_index = tk.constant;
if (custom_instance_index >= MAX_INSTANCE_UNIFORM_INDICES) {
_set_error("Allowed instance uniform indices are 0-" + itos(MAX_INSTANCE_UNIFORM_INDICES - 1));
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_PARENTHESIS_CLOSE) {
_set_error("Expected ')'");
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02: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 21:33:42 +02:00
}
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
} else if (tk.type == TK_FILTER_LINEAR) {
uniform2.filter = FILTER_LINEAR;
} else if (tk.type == TK_FILTER_NEAREST) {
uniform2.filter = FILTER_NEAREST;
} else if (tk.type == TK_FILTER_NEAREST_MIPMAP) {
uniform2.filter = FILTER_NEAREST_MIPMAP;
} else if (tk.type == TK_FILTER_LINEAR_MIPMAP) {
uniform2.filter = FILTER_LINEAR_MIPMAP;
} else if (tk.type == TK_FILTER_NEAREST_MIPMAP_ANISO) {
uniform2.filter = FILTER_NEAREST_MIPMAP_ANISO;
} else if (tk.type == TK_FILTER_LINEAR_MIPMAP_ANISO) {
uniform2.filter = FILTER_LINEAR_MIPMAP_ANISO;
} else if (tk.type == TK_REPEAT_DISABLE) {
uniform2.repeat = REPEAT_DISABLE;
} else if (tk.type == TK_REPEAT_ENABLE) {
uniform2.repeat = REPEAT_ENABLE;
} else {
_set_error("Expected valid type hint after ':'.");
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
if (uniform2.hint != ShaderNode::Uniform::HINT_RANGE && uniform2.hint != ShaderNode::Uniform::HINT_NONE && uniform2.hint != ShaderNode::Uniform::HINT_COLOR && type <= TYPE_MAT4) {
_set_error("This hint is only for sampler types");
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Modernized default 3D material, fixes material bugs.
2019-09-15 06:01:52 +02: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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-17 04:52:00 +02:00
if (uniform_scope == ShaderNode::Uniform::SCOPE_INSTANCE) {
if (custom_instance_index >= 0) {
uniform2.instance_index = custom_instance_index;
} else {
uniform2.instance_index = instance_index++;
if (instance_index > MAX_INSTANCE_UNIFORM_INDICES) {
_set_error("Too many 'instance' uniforms in shader, maximum supported is " + itos(MAX_INSTANCE_UNIFORM_INDICES));
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) {
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
Node *expr = _parse_and_reduce_expression(nullptr, FunctionInfo());
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (!expr) {
Hinted shader uniforms can have a default value
2018-03-15 15:23:40 +01:00
return ERR_PARSE_ERROR;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Hinted shader uniforms can have a default value
2018-03-15 15:23:40 +01:00
if (expr->type != Node::TYPE_CONSTANT) {
_set_error("Expected constant expression after '='");
return ERR_PARSE_ERROR;
}
ConstantNode *cn = static_cast<ConstantNode *>(expr);
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
uniform2.default_value.resize(cn->values.size());
Hinted shader uniforms can have a default value
2018-03-15 15:23:40 +01:00
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
if (!convert_constant(cn, uniform2.type, uniform2.default_value.ptrw())) {
_set_error("Can't convert constant to " + get_datatype_name(uniform2.type));
Hinted shader uniforms can have a default value
2018-03-15 15:23:40 +01:00
return ERR_PARSE_ERROR;
}
tk = _get_token();
}
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
shader->uniforms[name] = uniform2;
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-17 04:52:00 +02: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 16:31:18 +02:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (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 21:33:42 +02:00
_set_error("Expected ';'");
return ERR_PARSE_ERROR;
}
} else {
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;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
tk = _get_token();
Implement shader array support for varyings
2019-07-29 16:08:25 +02:00
if (tk.type != TK_SEMICOLON && tk.type != TK_BRACKET_OPEN) {
_set_error("Expected ';' or '['");
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
return ERR_PARSE_ERROR;
}
Implement shader array support for varyings
2019-07-29 16:08:25 +02:00
if (tk.type == TK_BRACKET_OPEN) {
tk = _get_token();
if (tk.type == TK_INT_CONSTANT && tk.constant > 0) {
varying.array_size = (int)tk.constant;
tk = _get_token();
if (tk.type == TK_BRACKET_CLOSE) {
tk = _get_token();
if (tk.type != TK_SEMICOLON) {
_set_error("Expected ';'");
return ERR_PARSE_ERROR;
}
} else {
_set_error("Expected ']'");
return ERR_PARSE_ERROR;
}
} else {
_set_error("Expected single integer constant > 0");
return ERR_PARSE_ERROR;
}
}
shader->varyings[name] = 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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
} break;
default: {
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
//function or constant variable
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
bool is_constant = false;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01: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 21:33:42 +02:00
DataPrecision precision = PRECISION_DEFAULT;
DataType type;
StringName name;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02: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 21:33:42 +02: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 21:33:42 +02:00
tk = _get_token();
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (shader->structs.has(tk.text)) {
if (precision != PRECISION_DEFAULT) {
_set_error("Precision modifier cannot be used on structs.");
return ERR_PARSE_ERROR;
}
is_struct = true;
struct_name = tk.text;
} else {
if (!is_token_datatype(tk.type)) {
_set_error("Expected constant, function, uniform or varying");
return ERR_PARSE_ERROR;
}
Do not allow samplers where they dont belong (variables/return types), fixes #15133
2018-11-12 12:36:26 +01:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (!is_token_variable_datatype(tk.type)) {
_set_error("Invalid data type for constants or function return (samplers not allowed)");
return ERR_PARSE_ERROR;
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (is_struct) {
type = TYPE_STRUCT;
} else {
type = get_token_datatype(tk.type);
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
TkPos prev_pos = _get_tkpos();
tk = _get_token();
if (tk.type == TK_BRACKET_OPEN) {
_set_error("Cannot use arrays as return types");
return ERR_PARSE_ERROR;
}
_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-10 02:10:30 +01: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()) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
_set_error("Expected function name after datatype");
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
if (_find_identifier(nullptr, false, FunctionInfo(), 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
_set_error("Redefinition of '" + 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 21:33:42 +02:00
return ERR_PARSE_ERROR;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Added check if field name in the shader is equal to builtin
2019-10-29 12:36:11 +01:00
if (has_builtin(p_functions, name)) {
_set_error("Redefinition of '" + String(name) + "'");
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 21:33:42 +02: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 16:19:24 +02:00
if (type == TYPE_VOID) {
_set_error("Expected '(' after function identifier");
return ERR_PARSE_ERROR;
}
//variable
while (true) {
ShaderNode::Constant constant;
Fix shader constant sorting
2020-04-11 11:40:17 +02:00
constant.name = name;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
constant.type = is_struct ? TYPE_STRUCT : type;
constant.type_str = struct_name;
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
constant.precision = precision;
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
constant.initializer = nullptr;
Implemented global const array to shaders
2019-10-11 19:43:42 +02:00
constant.array_size = 0;
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
Implemented global const array to shaders
2019-10-11 19:43:42 +02:00
bool unknown_size = false;
if (tk.type == TK_BRACKET_OPEN) {
if (RenderingServer::get_singleton()->is_low_end()) {
_set_error("Global const arrays are supported only on high-end platform!");
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
return ERR_PARSE_ERROR;
}
Implemented global const array to shaders
2019-10-11 19:43:42 +02:00
tk = _get_token();
if (tk.type == TK_BRACKET_CLOSE) {
unknown_size = true;
tk = _get_token();
} else if (tk.type == TK_INT_CONSTANT && ((int)tk.constant) > 0) {
constant.array_size = (int)tk.constant;
tk = _get_token();
if (tk.type != TK_BRACKET_CLOSE) {
_set_error("Expected ']'");
return ERR_PARSE_ERROR;
}
tk = _get_token();
} else {
_set_error("Expected integer constant > 0 or ']'");
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02: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
}
Implemented global const array to shaders
2019-10-11 19:43:42 +02:00
}
if (tk.type == TK_OP_ASSIGN) {
if (!is_constant) {
_set_error("Expected 'const' keyword before constant definition");
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
return ERR_PARSE_ERROR;
}
Implemented global const array to shaders
2019-10-11 19:43:42 +02:00
if (constant.array_size > 0 || unknown_size) {
bool full_def = false;
ArrayDeclarationNode::Declaration decl;
decl.name = name;
decl.size = constant.array_size;
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
Implemented global const array to shaders
2019-10-11 19:43:42 +02:00
tk = _get_token();
if (tk.type != TK_CURLY_BRACKET_OPEN) {
if (unknown_size) {
_set_error("Expected '{'");
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)) {
_set_error("Expected datatype after precision");
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)) {
_set_error("Invalid data type for array");
return ERR_PARSE_ERROR;
}
type2 = get_token_datatype(tk.type);
}
int array_size2 = 0;
tk = _get_token();
if (tk.type == TK_BRACKET_OPEN) {
TkPos pos2 = _get_tkpos();
tk = _get_token();
if (tk.type == TK_BRACKET_CLOSE) {
array_size2 = constant.array_size;
tk = _get_token();
} else {
_set_tkpos(pos2);
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
Node *n = _parse_and_reduce_expression(NULL, FunctionInfo());
Implemented global const array to shaders
2019-10-11 19:43:42 +02:00
if (!n || n->type != Node::TYPE_CONSTANT || n->get_datatype() != TYPE_INT) {
_set_error("Expected single integer constant > 0");
return ERR_PARSE_ERROR;
}
ConstantNode *cnode = (ConstantNode *)n;
if (cnode->values.size() == 1) {
array_size2 = cnode->values[0].sint;
if (array_size2 <= 0) {
_set_error("Expected single integer constant > 0");
return ERR_PARSE_ERROR;
}
} else {
_set_error("Expected single integer constant > 0");
return ERR_PARSE_ERROR;
}
tk = _get_token();
if (tk.type != TK_BRACKET_CLOSE) {
_set_error("Expected ']");
return ERR_PARSE_ERROR;
} else {
tk = _get_token();
}
}
} else {
_set_error("Expected '[");
return ERR_PARSE_ERROR;
}
if (constant.precision != precision2 || constant.type != type2 || struct_name != struct_name2 || constant.array_size != array_size2) {
String error_str = "Cannot convert from '";
if (type2 == TYPE_STRUCT) {
error_str += struct_name2;
} else {
if (precision2 != PRECISION_DEFAULT) {
error_str += get_precision_name(precision2);
error_str += " ";
}
error_str += get_datatype_name(type2);
}
error_str += "[";
error_str += itos(array_size2);
error_str += "]'";
error_str += " to '";
if (type == TYPE_STRUCT) {
error_str += struct_name;
} else {
if (precision != PRECISION_DEFAULT) {
error_str += get_precision_name(precision);
error_str += " ";
}
error_str += get_datatype_name(type);
}
error_str += "[";
error_str += itos(constant.array_size);
error_str += "]'";
_set_error(error_str);
return ERR_PARSE_ERROR;
}
}
bool curly = tk.type == TK_CURLY_BRACKET_OPEN;
if (unknown_size) {
if (!curly) {
_set_error("Expected '{'");
return ERR_PARSE_ERROR;
}
} else {
if (full_def) {
if (curly) {
_set_error("Expected '('");
return ERR_PARSE_ERROR;
}
}
}
if (tk.type == TK_PARENTHESIS_OPEN || curly) { // initialization
while (true) {
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
Node *n = _parse_and_reduce_expression(NULL, FunctionInfo());
Implemented global const array to shaders
2019-10-11 19:43:42 +02:00
if (!n) {
return ERR_PARSE_ERROR;
}
if (n->type == Node::TYPE_OPERATOR && ((OperatorNode *)n)->op == OP_CALL) {
_set_error("Expected constant expression");
return ERR_PARSE_ERROR;
}
if (constant.type != n->get_datatype() || n->get_datatype_name() != struct_name) {
_set_error("Invalid assignment of '" + (n->get_datatype() == TYPE_STRUCT ? n->get_datatype_name() : get_datatype_name(n->get_datatype())) + "' to '" + (is_struct ? String(struct_name) : get_datatype_name(constant.type)) + "'");
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 {
if (curly)
_set_error("Expected '}' or ','");
else
_set_error("Expected ')' or ','");
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) {
_set_error("Array size mismatch");
return ERR_PARSE_ERROR;
}
}
ConstantNode *expr = memnew(ConstantNode);
expr->datatype = constant.type;
expr->struct_name = constant.type_str;
expr->array_size = constant.array_size;
expr->array_declarations.push_back(decl);
constant.initializer = static_cast<ConstantNode *>(expr);
} else {
//variable created with assignment! must parse an expression
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
Node *expr = _parse_and_reduce_expression(NULL, FunctionInfo());
Implemented global const array to shaders
2019-10-11 19:43:42 +02:00
if (!expr)
return ERR_PARSE_ERROR;
if (expr->type == Node::TYPE_OPERATOR && ((OperatorNode *)expr)->op == OP_CALL) {
_set_error("Expected constant expression after '='");
return ERR_PARSE_ERROR;
}
constant.initializer = static_cast<ConstantNode *>(expr);
if (type != expr->get_datatype() || expr->get_datatype_name() != struct_name) {
_set_error("Invalid assignment of '" + (expr->get_datatype() == TYPE_STRUCT ? expr->get_datatype_name() : get_datatype_name(expr->get_datatype())) + "' to '" + (is_struct ? String(struct_name) : get_datatype_name(type)) + "'");
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
return ERR_PARSE_ERROR;
}
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
}
tk = _get_token();
} else {
Implemented global const array to shaders
2019-10-11 19:43:42 +02:00
if (constant.array_size > 0 || unknown_size) {
_set_error("Expected array initialization");
return ERR_PARSE_ERROR;
} else {
_set_error("Expected initialization of constant");
return ERR_PARSE_ERROR;
}
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
}
shader->constants[name] = constant;
Fix shader constant sorting
2020-04-11 11:40:17 +02:00
shader->vconstants.push_back(constant);
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
if (tk.type == TK_COMMA) {
tk = _get_token();
if (tk.type != TK_IDENTIFIER) {
_set_error("Expected identifier after type");
return ERR_PARSE_ERROR;
}
name = tk.text;
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
if (_find_identifier(nullptr, false, FunctionInfo(), name)) {
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
_set_error("Redefinition of '" + String(name) + "'");
return ERR_PARSE_ERROR;
}
Added check if field name in the shader is equal to builtin
2019-10-29 12:36:11 +01:00
if (has_builtin(p_functions, name)) {
_set_error("Redefinition of '" + String(name) + "'");
return ERR_PARSE_ERROR;
}
Added constant support to shaders Co-authored-by: DavidSichma <sichmada@gmail.com>
2019-05-30 16:19:24 +02:00
tk = _get_token();
} else if (tk.type == TK_SEMICOLON) {
break;
} else {
_set_error("Expected ',' or ';' after constant");
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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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 21:33:42 +02:00
if (p_functions.has(name)) {
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Makes shader 'TIME' available in custom functions by default
2020-03-19 15:58:39 +01:00
if (p_functions.has("global")) { // Adds global variables: 'TIME'
for (Map<StringName, BuiltInInfo>::Element *E = p_functions["global"].built_ins.front(); E; E = E->next()) {
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
builtins.built_ins.insert(E->key(), E->value());
Makes shader 'TIME' available in custom functions by default
2020-03-19 15:58:39 +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 21:33:42 +02:00
ShaderNode::Function function;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
function.callable = !p_functions.has(name);
function.name = name;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
FunctionNode *func_node = alloc_node<FunctionNode>();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
function.function = func_node;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
shader->functions.push_back(function);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
func_node->name = name;
func_node->return_type = type;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01: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;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 09:27:12 +02:00
if (p_functions.has(name)) {
func_node->can_discard = p_functions[name].can_discard;
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02: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-10 02:10:30 +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 21:33:42 +02:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:33:42 +02:00
break;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Added const qualifier support for function arguments in shaders
2020-07-01 10:55:49 +02:00
bool is_const = false;
if (tk.type == TK_CONST) {
is_const = true;
tk = _get_token();
}
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
ArgumentQualifier qualifier = ARGUMENT_QUALIFIER_IN;
if (tk.type == TK_ARG_IN) {
qualifier = ARGUMENT_QUALIFIER_IN;
tk = _get_token();
} else if (tk.type == TK_ARG_OUT) {
Added const qualifier support for function arguments in shaders
2020-07-01 10:55:49 +02:00
if (is_const) {
_set_error("'out' qualifier cannot be used within a function parameter declared with 'const'.");
return ERR_PARSE_ERROR;
}
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
qualifier = ARGUMENT_QUALIFIER_OUT;
tk = _get_token();
} else if (tk.type == TK_ARG_INOUT) {
Added const qualifier support for function arguments in shaders
2020-07-01 10:55:49 +02:00
if (is_const) {
_set_error("'inout' qualifier cannot be used within a function parameter declared with 'const'.");
return ERR_PARSE_ERROR;
}
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
qualifier = ARGUMENT_QUALIFIER_INOUT;
tk = _get_token();
}
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
DataType ptype;
StringName pname;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
StringName param_struct_name;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
DataPrecision pprecision = PRECISION_DEFAULT;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
bool use_precision = false;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
if (is_token_precision(tk.type)) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
pprecision = get_token_precision(tk.type);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
tk = _get_token();
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
use_precision = true;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
is_struct = false;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (shader->structs.has(tk.text)) {
is_struct = true;
param_struct_name = tk.text;
if (use_precision) {
_set_error("Precision modifier cannot be used on structs.");
return ERR_PARSE_ERROR;
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (!is_struct && !is_token_datatype(tk.type)) {
_set_error("Expected a valid datatype for argument");
Prevents usage of unsupported texture shader types in GLES2
2019-11-03 11:28:29 +01:00
return ERR_PARSE_ERROR;
}
Prevent usage 'out' modifier on opaque shader types (textures currently)
2020-02-13 19:02:47 +01:00
if (qualifier == ARGUMENT_QUALIFIER_OUT || qualifier == ARGUMENT_QUALIFIER_INOUT) {
if (is_sampler_type(get_token_datatype(tk.type))) {
_set_error("Opaque types cannot be output parameters.");
return ERR_PARSE_ERROR;
}
}
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
if (is_struct) {
ptype = TYPE_STRUCT;
} else {
ptype = get_token_datatype(tk.type);
if (_validate_datatype(ptype) != OK) {
return ERR_PARSE_ERROR;
}
if (ptype == TYPE_VOID) {
_set_error("void not allowed in argument");
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 21:33:42 +02:00
}
tk = _get_token();
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
if (tk.type == TK_BRACKET_OPEN) {
_set_error("Arrays as parameters are not implemented yet");
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 (tk.type != TK_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 21:33:42 +02:00
_set_error("Expected identifier for argument name");
return ERR_PARSE_ERROR;
}
pname = tk.text;
Fix few redefinition name errors for variable/param/function in shaders
2019-10-06 16:24:30 +02:00
ShaderLanguage::IdentifierType itype;
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02:00
if (_find_identifier(func_node->body, false, builtins, pname, (ShaderLanguage::DataType *)nullptr, &itype)) {
Fix few redefinition name errors for variable/param/function in shaders
2019-10-06 16:24:30 +02:00
if (itype != IDENTIFIER_FUNCTION) {
_set_error("Redefinition of '" + String(pname) + "'");
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 21:33:42 +02:00
}
Added check if field name in the shader is equal to builtin
2019-10-29 12:36:11 +01:00
if (has_builtin(p_functions, pname)) {
_set_error("Redefinition of '" + String(pname) + "'");
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 21:33:42 +02:00
FunctionNode::Argument arg;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
arg.type = ptype;
arg.name = pname;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
arg.type_str = param_struct_name;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
arg.precision = pprecision;
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
arg.qualifier = qualifier;
Completed material/2D shader support (missing SCREEN_TEXTURE)
2019-07-21 16:31:30 +02:00
arg.tex_argument_check = false;
arg.tex_builtin_check = false;
arg.tex_argument_filter = FILTER_DEFAULT;
arg.tex_argument_repeat = REPEAT_DEFAULT;
Added const qualifier support for function arguments in shaders
2020-07-01 10:55:49 +02:00
arg.is_const = is_const;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
func_node->arguments.push_back(arg);
tk = _get_token();
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
if (tk.type == TK_BRACKET_OPEN) {
_set_error("Arrays as parameters are not implemented yet");
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 21:33:42 +02:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (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 21:33:42 +02: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) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
_set_error("Expected ',' or ')' after identifier");
return ERR_PARSE_ERROR;
}
}
if (p_functions.has(name)) {
//if one of the core functions, make sure they are of the correct form
if (func_node->arguments.size() > 0) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
_set_error("Function '" + String(name) + "' expects no arguments.");
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02: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) {
_set_error("Function '" + String(name) + "' must be of void 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 21:33:42 +02: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 21:33:42 +02: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) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
_set_error("Expected '{' to begin function");
return ERR_PARSE_ERROR;
}
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 23:31:01 +02:00
current_function = name;
Implement manual particle emission and particle sub emitters.
2020-09-06 14:18:10 +02: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 21:33:42 +02:00
return err;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
2D Shaders are working again using the new syntax, though all is buggy in general
2016-10-10 23:31:01 +02:00
Fix shader crash when users miss the return statement
2019-08-23 14:40:42 +02: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) {
_set_error("Expected at least one return statement in a non-void function.");
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 21:33:42 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
tk = _get_token();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
return OK;
}
Added check if field name in the shader is equal to builtin
2019-10-29 12:36:11 +01:00
bool ShaderLanguage::has_builtin(const Map<StringName, ShaderLanguage::FunctionInfo> &p_functions, const StringName &p_name) {
if (p_functions.has("vertex")) {
if (p_functions["vertex"].built_ins.has(p_name)) {
return true;
}
}
if (p_functions.has("fragment")) {
if (p_functions["fragment"].built_ins.has(p_name)) {
return true;
}
}
if (p_functions.has("light")) {
if (p_functions["light"].built_ins.has(p_name)) {
return true;
}
}
Fix particles shader to use built-ins
2020-09-02 21:02:04 +02:00
if (p_functions.has("compute")) {
if (p_functions["compute"].built_ins.has(p_name)) {
return true;
}
}
Added check if field name in the shader is equal to builtin
2019-10-29 12:36:11 +01:00
return false;
}
Fix shader crash when users miss the return statement
2019-08-23 14:40:42 +02:00
Error ShaderLanguage::_find_last_flow_op_in_op(ControlFlowNode *p_flow, FlowOperation p_op) {
bool found = false;
for (int i = p_flow->blocks.size() - 1; i >= 0; i--) {
if (p_flow->blocks[i]->type == Node::TYPE_BLOCK) {
BlockNode *last_block = (BlockNode *)p_flow->blocks[i];
if (_find_last_flow_op_in_block(last_block, p_op) == OK) {
found = true;
break;
}
}
}
if (found) {
return OK;
}
return FAILED;
}
Error ShaderLanguage::_find_last_flow_op_in_block(BlockNode *p_block, FlowOperation p_op) {
bool found = false;
for (int i = p_block->statements.size() - 1; i >= 0; i--) {
if (p_block->statements[i]->type == Node::TYPE_CONTROL_FLOW) {
ControlFlowNode *flow = (ControlFlowNode *)p_block->statements[i];
if (flow->flow_op == p_op) {
found = true;
break;
} else {
if (_find_last_flow_op_in_op(flow, p_op) == OK) {
found = true;
break;
}
}
} else if (p_block->statements[i]->type == Node::TYPE_BLOCK) {
BlockNode *block = (BlockNode *)p_block->statements[i];
if (_find_last_flow_op_in_block(block, p_op) == OK) {
found = true;
break;
}
}
}
if (found) {
return OK;
}
return FAILED;
}
allow comments and whitespace before shader_type declaration
2018-01-25 02:00:51 +01: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 12:43:20 +02: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-25 02:00:51 +01: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-25 02:00:51 +01: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-25 02:00:51 +01: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-07 04:36:37 +02: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-25 02:00:51 +01: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-07 04:36:37 +02:00
if (p_code[i] == ';') {
break;
} else if (p_code[i] <= 32) {
if (cur_identifier != String()) {
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-07 04:36:37 +02: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-07 04:36:37 +02:00
return String();
}
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-17 04:52:00 +02:00
Error ShaderLanguage::compile(const String &p_code, const Map<StringName, FunctionInfo> &p_functions, const Vector<StringName> &p_render_modes, const Set<String> &p_shader_types, GlobalVariableGetTypeFunc p_global_variable_type_func) {
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
clear();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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;
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-17 04:52:00 +02:00
global_var_get_type_func = p_global_variable_type_func;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
nodes = nullptr;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
shader = alloc_node<ShaderNode>();
New particle system, mostly working, some small features missing.
2017-04-07 04:36:37 +02:00
Error err = _parse_shader(p_functions, p_render_modes, p_shader_types);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 (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 21:33:42 +02:00
return err;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +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 21:33:42 +02:00
return OK;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-17 04:52:00 +02:00
Error ShaderLanguage::complete(const String &p_code, const Map<StringName, FunctionInfo> &p_functions, const Vector<StringName> &p_render_modes, const Set<String> &p_shader_types, GlobalVariableGetTypeFunc p_global_variable_type_func, List<ScriptCodeCompletionOption> *r_options, String &r_call_hint) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
clear();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
code = p_code;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
nodes = nullptr;
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-17 04:52:00 +02:00
global_var_get_type_func = p_global_variable_type_func;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
shader = alloc_node<ShaderNode>();
Removed unnecessary shader error log messages
2019-10-02 09:50:22 +02:00
_parse_shader(p_functions, p_render_modes, p_shader_types);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +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
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 16:31:18 +02: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-10 02:10:30 +01:00
} break;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
case COMPLETION_RENDER_MODE: {
Visual Shaders are back.
2018-07-14 23:15:42 +02:00
for (int i = 0; i < p_render_modes.size(); i++) {
Fix code completion for shader editor
2019-07-06 06:03:17 +02:00
ScriptCodeCompletionOption option(p_render_modes[i], ScriptCodeCompletionOption::KIND_ENUM);
r_options->push_back(option);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
return OK;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
Implementation of 'struct' for shaders
2020-01-17 20:35:22 +01:00
case COMPLETION_STRUCT: {
if (shader->structs.has(completion_struct)) {
StructNode *node = shader->structs[completion_struct].shader_struct;
for (int i = 0; i < node->members.size(); i++) {
ScriptCodeCompletionOption option(node->members[i]->name, ScriptCodeCompletionOption::KIND_MEMBER);
r_options->push_back(option);
}
}
return OK;
} break;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
case COMPLETION_MAIN_FUNCTION: {
removed DISCARD built in variable, replaced by actual discard GLSL instruction, fixes #9677
2017-08-29 15:14:07 +02:00
for (const Map<StringName, FunctionInfo>::Element *E = p_functions.front(); E; E = E->next()) {
Fix code completion for shader editor
2019-07-06 06:03:17 +02:00
ScriptCodeCompletionOption option(E->key(), ScriptCodeCompletionOption::KIND_FUNCTION);
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-28 04:21:45 +02:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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-28 04:21:45 +02:00
} break;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
case COMPLETION_IDENTIFIER:
case COMPLETION_FUNCTION_CALL: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
bool comp_ident = completion_type == COMPLETION_IDENTIFIER;
Fix code completion for shader editor
2019-07-06 06:03:17 +02:00
Map<String, ScriptCodeCompletionOption::Kind> matches;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 16:31:18 +02:00
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
if (completion_class == TAG_GLOBAL) {
while (block) {
if (comp_ident) {
for (const Map<StringName, BlockNode::Variable>::Element *E = block->variables.front(); E; E = E->next()) {
if (E->get().line < completion_line) {
matches.insert(E->key(), ScriptCodeCompletionOption::KIND_VARIABLE);
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
}
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
if (block->parent_function) {
if (comp_ident) {
for (int i = 0; i < block->parent_function->arguments.size(); i++) {
Fix invalid autocompletion pasting of shader param name
2019-10-08 17:33:22 +02:00
matches.insert(block->parent_function->arguments[i].name, ScriptCodeCompletionOption::KIND_VARIABLE);
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
}
Implemented local shader arrays
2019-07-10 18:52:50 +02: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 16:31:18 +02:00
}
Implemented local shader arrays
2019-07-10 18:52:50 +02: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 16:31:18 +02:00
}
Fix shader TIME auto-completion
2020-03-19 19:26:35 +01:00
if (comp_ident) {
if (p_functions.has("global")) {
for (Map<StringName, BuiltInInfo>::Element *E = p_functions["global"].built_ins.front(); E; E = E->next()) {
ScriptCodeCompletionOption::Kind kind = ScriptCodeCompletionOption::KIND_MEMBER;
if (E->get().constant) {
kind = ScriptCodeCompletionOption::KIND_CONSTANT;
}
matches.insert(E->key(), kind);
}
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
Fix shader TIME auto-completion
2020-03-19 19:26:35 +01:00
if (skip_function != StringName() && p_functions.has(skip_function)) {
for (Map<StringName, BuiltInInfo>::Element *E = p_functions[skip_function].built_ins.front(); E; E = E->next()) {
ScriptCodeCompletionOption::Kind kind = ScriptCodeCompletionOption::KIND_MEMBER;
if (E->get().constant) {
kind = ScriptCodeCompletionOption::KIND_CONSTANT;
}
matches.insert(E->key(), kind);
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
}
Fix code completion for shader editor
2019-07-06 06:03:17 +02:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
for (const Map<StringName, ShaderNode::Varying>::Element *E = shader->varyings.front(); E; E = E->next()) {
matches.insert(E->key(), ScriptCodeCompletionOption::KIND_VARIABLE);
}
for (const Map<StringName, ShaderNode::Uniform>::Element *E = shader->uniforms.front(); E; E = E->next()) {
matches.insert(E->key(), ScriptCodeCompletionOption::KIND_MEMBER);
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
for (int i = 0; i < shader->functions.size(); i++) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (!shader->functions[i].callable || shader->functions[i].name == skip_function) {
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
continue;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
matches.insert(String(shader->functions[i].name), ScriptCodeCompletionOption::KIND_FUNCTION);
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
}
Implemented local shader arrays
2019-07-10 18:52:50 +02: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 19:21:27 +01: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 16:31:18 +02:00
FIx autocompletion for emit_particle in shader editor
2020-10-13 10:53:06 +02:00
if (stages && stages->has(skip_function)) {
for (const Map<StringName, StageFunctionInfo>::Element *E = (*stages)[skip_function].stage_functions.front(); E; E = E->next()) {
matches.insert(String(E->key()), ScriptCodeCompletionOption::KIND_FUNCTION);
}
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
while (builtin_func_defs[idx].name) {
Hides high-level functions from GLES2 shader autocompletion
2020-01-23 10:41:21 +01:00
if (low_end && builtin_func_defs[idx].high_end) {
idx++;
continue;
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
matches.insert(String(builtin_func_defs[idx].name), ScriptCodeCompletionOption::KIND_FUNCTION);
idx++;
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
Implemented local shader arrays
2019-07-10 18:52:50 +02: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 19:21:27 +01:00
bool low_end = RenderingServer::get_singleton()->is_low_end();
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
while (builtin_func_defs[idx].name) {
Hides high-level functions from GLES2 shader autocompletion
2020-01-23 10:41:21 +01:00
if (low_end && builtin_func_defs[idx].high_end) {
idx++;
continue;
}
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
if (builtin_func_defs[idx].tag == completion_class) {
matches.insert(String(builtin_func_defs[idx].name), ScriptCodeCompletionOption::KIND_FUNCTION);
}
idx++;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
Fix code completion for shader editor
2019-07-06 06:03:17 +02:00
for (Map<String, ScriptCodeCompletionOption::Kind>::Element *E = matches.front(); E; E = E->next()) {
ScriptCodeCompletionOption option(E->key(), E->value());
if (E->value() == ScriptCodeCompletionOption::KIND_FUNCTION) {
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 16:31:18 +02:00
}
return OK;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
case COMPLETION_CALL_ARGUMENTS: {
FIx autocompletion for emit_particle in shader editor
2020-10-13 10:53:06 +02:00
StringName block_function;
BlockNode *block = completion_block;
while (block) {
if (block->parent_function) {
block_function = block->parent_function->name;
}
block = block->parent_block;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < shader->functions.size(); i++) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (!shader->functions[i].callable) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
continue;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (shader->functions[i].name == completion_function) {
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
String calltip;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += get_datatype_name(shader->functions[i].function->return_type);
calltip += " ";
calltip += shader->functions[i].name;
calltip += "(";
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int j = 0; j < shader->functions[i].function->arguments.size(); j++) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (j > 0) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += ", ";
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += " ";
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (j == completion_argument) {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02: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 16:31:18 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Added const qualifier support for function arguments in shaders
2020-07-01 10:55:49 +02:00
if (shader->functions[i].function->arguments[j].is_const) {
calltip += "const ";
}
Show shader method out/inout qualifier in intellisense
2020-03-18 13:43:05 +01:00
if (shader->functions[i].function->arguments[j].qualifier != ArgumentQualifier::ARGUMENT_QUALIFIER_IN) {
if (shader->functions[i].function->arguments[j].qualifier == ArgumentQualifier::ARGUMENT_QUALIFIER_OUT) {
calltip += "out ";
} else { // ArgumentQualifier::ARGUMENT_QUALIFIER_INOUT
calltip += "inout ";
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += get_datatype_name(shader->functions[i].function->arguments[j].type);
calltip += " ";
calltip += shader->functions[i].function->arguments[j].name;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (j == completion_argument) {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02: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 16:31:18 +02:00
}
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (shader->functions[i].function->arguments.size()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += " ";
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
calltip += ")";
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 16:31:18 +02:00
return OK;
}
}
New Demo, Screen Space Shaders -Fixes to screen space shaders. -Fixes to isometric light demo.
2015-03-10 04:53:09 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
int idx = 0;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
String calltip;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
bool low_end = RenderingServer::get_singleton()->is_low_end();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
FIx autocompletion for emit_particle in shader editor
2020-10-13 10:53:06 +02:00
if (stages && stages->has(block_function)) {
for (const Map<StringName, StageFunctionInfo>::Element *E = (*stages)[block_function].stage_functions.front(); E; E = E->next()) {
if (completion_function == E->key()) {
calltip += get_datatype_name(E->get().return_type);
calltip += " ";
calltip += E->key();
calltip += "(";
for (int i = 0; i < E->get().arguments.size(); i++) {
if (i > 0) {
calltip += ", ";
} else {
calltip += " ";
}
if (i == completion_argument) {
calltip += char32_t(0xFFFF);
}
calltip += get_datatype_name(E->get().arguments[i].type);
calltip += " ";
calltip += E->get().arguments[i].name;
if (i == completion_argument) {
calltip += char32_t(0xFFFF);
}
}
if (E->get().arguments.size()) {
calltip += " ";
}
calltip += ")";
r_call_hint = calltip;
return OK;
}
}
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
while (builtin_func_defs[idx].name) {
Hides high-level functions from GLES2 shader autocompletion
2020-01-23 10:41:21 +01:00
if (low_end && builtin_func_defs[idx].high_end) {
idx++;
continue;
}
Show shader method out/inout qualifier in intellisense
2020-03-18 13:43:05 +01:00
int idx2 = 0;
int out_arg = -1;
while (builtin_func_out_args[idx2].name != nullptr) {
if (builtin_func_out_args[idx2].name == builtin_func_defs[idx].name) {
out_arg = builtin_func_out_args[idx2].argument;
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 18:52:50 +02: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 16:31:18 +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 += 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 16:31:18 +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
bool found_arg = false;
FIx autocompletion for emit_particle in shader editor
2020-10-13 10:53:06 +02: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 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (i == completion_argument) {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02: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 16:31:18 +02:00
}
Show shader method out/inout qualifier in intellisense
2020-03-18 13:43:05 +01:00
if (out_arg >= 0 && i == out_arg) {
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 16:31:18 +02:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (i == completion_argument) {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02: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 16:31:18 +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
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 16:31:18 +02: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 16:31:18 +02:00
}
2D shader progress
2015-01-12 00:52:42 +01:00
idx++;
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +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
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 16:31:18 +02:00
return OK;
2D shader progress
2015-01-12 00:52:42 +01:00
} break;
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 15:50:20 +01:00
const char coordt[4] = { 's', 't', 'p', 'q' };
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +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
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 16:31:18 +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
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 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02: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 16:31:18 +02:00
} break;
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
case TYPE_MAT2:
limit = 2;
break;
case TYPE_MAT3:
limit = 3;
break;
case TYPE_MAT4:
limit = 4;
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-12 00:52:42 +01:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (int i = 0; i < limit; i++) {
Fix code completion for shader editor
2019-07-06 06:03:17 +02:00
r_options->push_back(ScriptCodeCompletionOption(String::chr(colv[i]), ScriptCodeCompletionOption::KIND_PLAIN_TEXT));
r_options->push_back(ScriptCodeCompletionOption(String::chr(coordv[i]), ScriptCodeCompletionOption::KIND_PLAIN_TEXT));
Fix bugs in shader swizzling
2020-02-13 15:50:20 +01:00
r_options->push_back(ScriptCodeCompletionOption(String::chr(coordt[i]), ScriptCodeCompletionOption::KIND_PLAIN_TEXT));
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} break;
}
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 21:33:42 +02:00
String ShaderLanguage::get_error_text() {
return error_str;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
New Demo, Screen Space Shaders -Fixes to screen space shaders. -Fixes to isometric light demo.
2015-03-10 04:53:09 +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 21:33:42 +02:00
int ShaderLanguage::get_error_line() {
return error_line;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
-the new shader language seems to work -shader editor plugin can edit shaders -code completion in shader editor plugin
2016-10-07 16:31:18 +02: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 21:33:42 +02:00
ShaderLanguage::ShaderLanguage() {
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
nodes = nullptr;
Implemented local shader arrays
2019-07-10 18:52:50 +02:00
completion_class = TAG_GLOBAL;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 21:33:42 +02:00
}
ShaderLanguage::~ShaderLanguage() {
clear();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Reference in a new issue Copy permalink