shader_language.h 36 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279
  1. /**************************************************************************/
  2. /* shader_language.h */
  3. /**************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /**************************************************************************/
  8. /* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
  9. /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
  10. /* */
  11. /* Permission is hereby granted, free of charge, to any person obtaining */
  12. /* a copy of this software and associated documentation files (the */
  13. /* "Software"), to deal in the Software without restriction, including */
  14. /* without limitation the rights to use, copy, modify, merge, publish, */
  15. /* distribute, sublicense, and/or sell copies of the Software, and to */
  16. /* permit persons to whom the Software is furnished to do so, subject to */
  17. /* the following conditions: */
  18. /* */
  19. /* The above copyright notice and this permission notice shall be */
  20. /* included in all copies or substantial portions of the Software. */
  21. /* */
  22. /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
  23. /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
  24. /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
  25. /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
  26. /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
  27. /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
  28. /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
  29. /**************************************************************************/
  30. #pragma once
  31. #include "core/object/script_language.h"
  32. #include "core/string/string_name.h"
  33. #include "core/string/ustring.h"
  34. #include "core/templates/list.h"
  35. #include "core/templates/rb_map.h"
  36. #include "core/templates/safe_refcount.h"
  37. #include "core/typedefs.h"
  38. #include "core/variant/variant.h"
  39. #include "scene/resources/shader_include.h"
  40. #ifdef DEBUG_ENABLED
  41. #include "shader_warnings.h"
  42. #endif // DEBUG_ENABLED
  43. class ShaderLanguage {
  44. public:
  45. struct TkPos {
  46. int char_idx;
  47. int tk_line;
  48. };
  49. enum TokenType {
  50. TK_EMPTY,
  51. TK_IDENTIFIER,
  52. TK_TRUE,
  53. TK_FALSE,
  54. TK_FLOAT_CONSTANT,
  55. TK_INT_CONSTANT,
  56. TK_UINT_CONSTANT,
  57. TK_STRING_CONSTANT,
  58. TK_TYPE_VOID,
  59. TK_TYPE_BOOL,
  60. TK_TYPE_BVEC2,
  61. TK_TYPE_BVEC3,
  62. TK_TYPE_BVEC4,
  63. TK_TYPE_INT,
  64. TK_TYPE_IVEC2,
  65. TK_TYPE_IVEC3,
  66. TK_TYPE_IVEC4,
  67. TK_TYPE_UINT,
  68. TK_TYPE_UVEC2,
  69. TK_TYPE_UVEC3,
  70. TK_TYPE_UVEC4,
  71. TK_TYPE_FLOAT,
  72. TK_TYPE_VEC2,
  73. TK_TYPE_VEC3,
  74. TK_TYPE_VEC4,
  75. TK_TYPE_MAT2,
  76. TK_TYPE_MAT3,
  77. TK_TYPE_MAT4,
  78. TK_TYPE_SAMPLER2D,
  79. TK_TYPE_ISAMPLER2D,
  80. TK_TYPE_USAMPLER2D,
  81. TK_TYPE_SAMPLER2DARRAY,
  82. TK_TYPE_ISAMPLER2DARRAY,
  83. TK_TYPE_USAMPLER2DARRAY,
  84. TK_TYPE_SAMPLER3D,
  85. TK_TYPE_ISAMPLER3D,
  86. TK_TYPE_USAMPLER3D,
  87. TK_TYPE_SAMPLERCUBE,
  88. TK_TYPE_SAMPLERCUBEARRAY,
  89. TK_TYPE_SAMPLEREXT,
  90. TK_INTERPOLATION_FLAT,
  91. TK_INTERPOLATION_SMOOTH,
  92. TK_CONST,
  93. TK_STRUCT,
  94. TK_PRECISION_LOW,
  95. TK_PRECISION_MID,
  96. TK_PRECISION_HIGH,
  97. TK_OP_EQUAL,
  98. TK_OP_NOT_EQUAL,
  99. TK_OP_LESS,
  100. TK_OP_LESS_EQUAL,
  101. TK_OP_GREATER,
  102. TK_OP_GREATER_EQUAL,
  103. TK_OP_AND,
  104. TK_OP_OR,
  105. TK_OP_NOT,
  106. TK_OP_ADD,
  107. TK_OP_SUB,
  108. TK_OP_MUL,
  109. TK_OP_DIV,
  110. TK_OP_MOD,
  111. TK_OP_SHIFT_LEFT,
  112. TK_OP_SHIFT_RIGHT,
  113. TK_OP_ASSIGN,
  114. TK_OP_ASSIGN_ADD,
  115. TK_OP_ASSIGN_SUB,
  116. TK_OP_ASSIGN_MUL,
  117. TK_OP_ASSIGN_DIV,
  118. TK_OP_ASSIGN_MOD,
  119. TK_OP_ASSIGN_SHIFT_LEFT,
  120. TK_OP_ASSIGN_SHIFT_RIGHT,
  121. TK_OP_ASSIGN_BIT_AND,
  122. TK_OP_ASSIGN_BIT_OR,
  123. TK_OP_ASSIGN_BIT_XOR,
  124. TK_OP_BIT_AND,
  125. TK_OP_BIT_OR,
  126. TK_OP_BIT_XOR,
  127. TK_OP_BIT_INVERT,
  128. TK_OP_INCREMENT,
  129. TK_OP_DECREMENT,
  130. TK_CF_IF,
  131. TK_CF_ELSE,
  132. TK_CF_FOR,
  133. TK_CF_WHILE,
  134. TK_CF_DO,
  135. TK_CF_SWITCH,
  136. TK_CF_CASE,
  137. TK_CF_DEFAULT,
  138. TK_CF_BREAK,
  139. TK_CF_CONTINUE,
  140. TK_CF_RETURN,
  141. TK_CF_DISCARD,
  142. TK_BRACKET_OPEN,
  143. TK_BRACKET_CLOSE,
  144. TK_CURLY_BRACKET_OPEN,
  145. TK_CURLY_BRACKET_CLOSE,
  146. TK_PARENTHESIS_OPEN,
  147. TK_PARENTHESIS_CLOSE,
  148. TK_QUESTION,
  149. TK_COMMA,
  150. TK_COLON,
  151. TK_SEMICOLON,
  152. TK_PERIOD,
  153. TK_UNIFORM,
  154. TK_UNIFORM_GROUP,
  155. TK_INSTANCE,
  156. TK_GLOBAL,
  157. TK_VARYING,
  158. TK_ARG_IN,
  159. TK_ARG_OUT,
  160. TK_ARG_INOUT,
  161. TK_RENDER_MODE,
  162. TK_STENCIL_MODE,
  163. TK_HINT_DEFAULT_WHITE_TEXTURE,
  164. TK_HINT_DEFAULT_BLACK_TEXTURE,
  165. TK_HINT_DEFAULT_TRANSPARENT_TEXTURE,
  166. TK_HINT_NORMAL_TEXTURE,
  167. TK_HINT_ROUGHNESS_NORMAL_TEXTURE,
  168. TK_HINT_ROUGHNESS_R,
  169. TK_HINT_ROUGHNESS_G,
  170. TK_HINT_ROUGHNESS_B,
  171. TK_HINT_ROUGHNESS_A,
  172. TK_HINT_ROUGHNESS_GRAY,
  173. TK_HINT_ANISOTROPY_TEXTURE,
  174. TK_HINT_SOURCE_COLOR,
  175. TK_HINT_COLOR_CONVERSION_DISABLED,
  176. TK_HINT_RANGE,
  177. TK_HINT_ENUM,
  178. TK_HINT_INSTANCE_INDEX,
  179. TK_HINT_SCREEN_TEXTURE,
  180. TK_HINT_NORMAL_ROUGHNESS_TEXTURE,
  181. TK_HINT_DEPTH_TEXTURE,
  182. TK_FILTER_NEAREST,
  183. TK_FILTER_LINEAR,
  184. TK_FILTER_NEAREST_MIPMAP,
  185. TK_FILTER_LINEAR_MIPMAP,
  186. TK_FILTER_NEAREST_MIPMAP_ANISOTROPIC,
  187. TK_FILTER_LINEAR_MIPMAP_ANISOTROPIC,
  188. TK_REPEAT_ENABLE,
  189. TK_REPEAT_DISABLE,
  190. TK_SHADER_TYPE,
  191. TK_CURSOR,
  192. TK_ERROR,
  193. TK_EOF,
  194. TK_MAX
  195. };
  196. /* COMPILER */
  197. // lame work around to Apple defining this as a macro in 10.12 SDK
  198. #ifdef TYPE_BOOL
  199. #undef TYPE_BOOL
  200. #endif
  201. enum DataType {
  202. TYPE_VOID,
  203. TYPE_BOOL,
  204. TYPE_BVEC2,
  205. TYPE_BVEC3,
  206. TYPE_BVEC4,
  207. TYPE_INT,
  208. TYPE_IVEC2,
  209. TYPE_IVEC3,
  210. TYPE_IVEC4,
  211. TYPE_UINT,
  212. TYPE_UVEC2,
  213. TYPE_UVEC3,
  214. TYPE_UVEC4,
  215. TYPE_FLOAT,
  216. TYPE_VEC2,
  217. TYPE_VEC3,
  218. TYPE_VEC4,
  219. TYPE_MAT2,
  220. TYPE_MAT3,
  221. TYPE_MAT4,
  222. TYPE_SAMPLER2D,
  223. TYPE_ISAMPLER2D,
  224. TYPE_USAMPLER2D,
  225. TYPE_SAMPLER2DARRAY,
  226. TYPE_ISAMPLER2DARRAY,
  227. TYPE_USAMPLER2DARRAY,
  228. TYPE_SAMPLER3D,
  229. TYPE_ISAMPLER3D,
  230. TYPE_USAMPLER3D,
  231. TYPE_SAMPLERCUBE,
  232. TYPE_SAMPLERCUBEARRAY,
  233. TYPE_SAMPLEREXT,
  234. TYPE_STRUCT,
  235. TYPE_MAX
  236. };
  237. enum DataPrecision {
  238. PRECISION_LOWP,
  239. PRECISION_MEDIUMP,
  240. PRECISION_HIGHP,
  241. PRECISION_DEFAULT,
  242. };
  243. enum DataInterpolation {
  244. INTERPOLATION_FLAT,
  245. INTERPOLATION_SMOOTH,
  246. INTERPOLATION_DEFAULT,
  247. };
  248. enum Operator {
  249. OP_EQUAL,
  250. OP_NOT_EQUAL,
  251. OP_LESS,
  252. OP_LESS_EQUAL,
  253. OP_GREATER,
  254. OP_GREATER_EQUAL,
  255. OP_AND,
  256. OP_OR,
  257. OP_NOT,
  258. OP_NEGATE,
  259. OP_ADD,
  260. OP_SUB,
  261. OP_MUL,
  262. OP_DIV,
  263. OP_MOD,
  264. OP_SHIFT_LEFT,
  265. OP_SHIFT_RIGHT,
  266. OP_ASSIGN,
  267. OP_ASSIGN_ADD,
  268. OP_ASSIGN_SUB,
  269. OP_ASSIGN_MUL,
  270. OP_ASSIGN_DIV,
  271. OP_ASSIGN_MOD,
  272. OP_ASSIGN_SHIFT_LEFT,
  273. OP_ASSIGN_SHIFT_RIGHT,
  274. OP_ASSIGN_BIT_AND,
  275. OP_ASSIGN_BIT_OR,
  276. OP_ASSIGN_BIT_XOR,
  277. OP_BIT_AND,
  278. OP_BIT_OR,
  279. OP_BIT_XOR,
  280. OP_BIT_INVERT,
  281. OP_INCREMENT,
  282. OP_DECREMENT,
  283. OP_SELECT_IF,
  284. OP_SELECT_ELSE, //used only internally, then only IF appears with 3 arguments
  285. OP_POST_INCREMENT,
  286. OP_POST_DECREMENT,
  287. OP_CALL,
  288. OP_CONSTRUCT,
  289. OP_STRUCT,
  290. OP_INDEX,
  291. OP_EMPTY,
  292. OP_MAX
  293. };
  294. enum FlowOperation {
  295. FLOW_OP_IF,
  296. FLOW_OP_RETURN,
  297. FLOW_OP_FOR,
  298. FLOW_OP_WHILE,
  299. FLOW_OP_DO,
  300. FLOW_OP_BREAK,
  301. FLOW_OP_SWITCH,
  302. FLOW_OP_CASE,
  303. FLOW_OP_DEFAULT,
  304. FLOW_OP_CONTINUE,
  305. FLOW_OP_DISCARD
  306. };
  307. enum ArgumentQualifier {
  308. ARGUMENT_QUALIFIER_IN,
  309. ARGUMENT_QUALIFIER_OUT,
  310. ARGUMENT_QUALIFIER_INOUT,
  311. };
  312. enum SubClassTag {
  313. TAG_GLOBAL,
  314. TAG_ARRAY,
  315. };
  316. enum TextureFilter {
  317. FILTER_NEAREST,
  318. FILTER_LINEAR,
  319. FILTER_NEAREST_MIPMAP,
  320. FILTER_LINEAR_MIPMAP,
  321. FILTER_NEAREST_MIPMAP_ANISOTROPIC,
  322. FILTER_LINEAR_MIPMAP_ANISOTROPIC,
  323. FILTER_DEFAULT,
  324. };
  325. enum TextureRepeat {
  326. REPEAT_DISABLE,
  327. REPEAT_ENABLE,
  328. REPEAT_DEFAULT,
  329. };
  330. enum {
  331. MAX_INSTANCE_UNIFORM_INDICES = 16
  332. };
  333. struct VaryingFunctionNames {
  334. StringName fragment;
  335. StringName vertex;
  336. StringName light;
  337. VaryingFunctionNames() {
  338. fragment = "fragment";
  339. vertex = "vertex";
  340. light = "light";
  341. }
  342. };
  343. union Scalar {
  344. bool boolean = false;
  345. float real;
  346. int32_t sint;
  347. uint32_t uint;
  348. };
  349. struct Node {
  350. Node *next = nullptr;
  351. enum Type {
  352. NODE_TYPE_SHADER,
  353. NODE_TYPE_FUNCTION,
  354. NODE_TYPE_BLOCK,
  355. NODE_TYPE_VARIABLE,
  356. NODE_TYPE_VARIABLE_DECLARATION,
  357. NODE_TYPE_CONSTANT,
  358. NODE_TYPE_OPERATOR,
  359. NODE_TYPE_CONTROL_FLOW,
  360. NODE_TYPE_MEMBER,
  361. NODE_TYPE_ARRAY,
  362. NODE_TYPE_ARRAY_CONSTRUCT,
  363. NODE_TYPE_STRUCT,
  364. };
  365. Type type;
  366. virtual DataType get_datatype() const { return TYPE_VOID; }
  367. virtual String get_datatype_name() const { return ""; }
  368. virtual int get_array_size() const { return 0; }
  369. virtual bool is_indexed() const { return false; }
  370. virtual Vector<Scalar> get_values() const { return Vector<Scalar>(); }
  371. Node(Type t) :
  372. type(t) {}
  373. virtual ~Node() {}
  374. };
  375. template <typename T>
  376. T *alloc_node() {
  377. T *node = memnew(T);
  378. node->next = nodes;
  379. nodes = node;
  380. return node;
  381. }
  382. Node *nodes = nullptr;
  383. struct OperatorNode : public Node {
  384. DataType return_cache = TYPE_VOID;
  385. DataPrecision return_precision_cache = PRECISION_DEFAULT;
  386. int return_array_size = 0;
  387. Operator op = OP_EQUAL;
  388. StringName struct_name;
  389. Vector<Node *> arguments;
  390. Vector<Scalar> values;
  391. virtual DataType get_datatype() const override { return return_cache; }
  392. virtual String get_datatype_name() const override { return String(struct_name); }
  393. virtual int get_array_size() const override { return return_array_size; }
  394. virtual bool is_indexed() const override { return op == OP_INDEX; }
  395. virtual Vector<Scalar> get_values() const override { return values; }
  396. OperatorNode() :
  397. Node(NODE_TYPE_OPERATOR) {}
  398. };
  399. struct VariableNode : public Node {
  400. DataType datatype_cache = TYPE_VOID;
  401. StringName name;
  402. StringName rname;
  403. StringName struct_name;
  404. bool is_const = false;
  405. bool is_local = false;
  406. virtual DataType get_datatype() const override { return datatype_cache; }
  407. virtual String get_datatype_name() const override { return String(struct_name); }
  408. VariableNode() :
  409. Node(NODE_TYPE_VARIABLE) {}
  410. };
  411. struct VariableDeclarationNode : public Node {
  412. DataPrecision precision = PRECISION_DEFAULT;
  413. DataType datatype = TYPE_VOID;
  414. String struct_name;
  415. bool is_const = false;
  416. struct Declaration {
  417. StringName name;
  418. uint32_t size = 0U;
  419. Node *size_expression = nullptr;
  420. Vector<Node *> initializer;
  421. bool single_expression = false;
  422. };
  423. Vector<Declaration> declarations;
  424. virtual DataType get_datatype() const override { return datatype; }
  425. VariableDeclarationNode() :
  426. Node(NODE_TYPE_VARIABLE_DECLARATION) {}
  427. };
  428. struct ArrayNode : public Node {
  429. DataType datatype_cache = TYPE_VOID;
  430. StringName struct_name;
  431. StringName name;
  432. Node *index_expression = nullptr;
  433. Node *call_expression = nullptr;
  434. Node *assign_expression = nullptr;
  435. bool is_const = false;
  436. int array_size = 0;
  437. bool is_local = false;
  438. virtual DataType get_datatype() const override { return call_expression ? call_expression->get_datatype() : datatype_cache; }
  439. virtual String get_datatype_name() const override { return call_expression ? call_expression->get_datatype_name() : String(struct_name); }
  440. virtual int get_array_size() const override { return (index_expression || call_expression) ? 0 : array_size; }
  441. virtual bool is_indexed() const override { return index_expression != nullptr; }
  442. ArrayNode() :
  443. Node(NODE_TYPE_ARRAY) {}
  444. };
  445. struct ArrayConstructNode : public Node {
  446. DataType datatype = TYPE_VOID;
  447. String struct_name;
  448. Vector<Node *> initializer;
  449. virtual DataType get_datatype() const override { return datatype; }
  450. virtual String get_datatype_name() const override { return struct_name; }
  451. virtual int get_array_size() const override { return initializer.size(); }
  452. ArrayConstructNode() :
  453. Node(NODE_TYPE_ARRAY_CONSTRUCT) {}
  454. };
  455. struct ConstantNode : public Node {
  456. DataType datatype = TYPE_VOID;
  457. String struct_name = "";
  458. int array_size = 0;
  459. Vector<Scalar> values;
  460. Vector<VariableDeclarationNode::Declaration> array_declarations;
  461. virtual DataType get_datatype() const override { return datatype; }
  462. virtual String get_datatype_name() const override { return struct_name; }
  463. virtual int get_array_size() const override { return array_size; }
  464. virtual Vector<Scalar> get_values() const override {
  465. return values;
  466. }
  467. ConstantNode() :
  468. Node(NODE_TYPE_CONSTANT) {}
  469. };
  470. struct FunctionNode;
  471. struct BlockNode : public Node {
  472. FunctionNode *parent_function = nullptr;
  473. BlockNode *parent_block = nullptr;
  474. enum BlockType {
  475. BLOCK_TYPE_STANDARD,
  476. BLOCK_TYPE_FOR_INIT,
  477. BLOCK_TYPE_FOR_CONDITION,
  478. BLOCK_TYPE_FOR_EXPRESSION,
  479. BLOCK_TYPE_SWITCH,
  480. BLOCK_TYPE_CASE,
  481. BLOCK_TYPE_DEFAULT,
  482. };
  483. int block_type = BLOCK_TYPE_STANDARD;
  484. SubClassTag block_tag = SubClassTag::TAG_GLOBAL;
  485. struct Variable {
  486. DataType type;
  487. StringName struct_name;
  488. DataPrecision precision;
  489. int line; //for completion
  490. int array_size;
  491. bool is_const;
  492. Vector<Scalar> values;
  493. };
  494. HashMap<StringName, Variable> variables;
  495. List<Node *> statements;
  496. bool single_statement = false;
  497. bool use_comma_between_statements = false;
  498. bool use_op_eval = true;
  499. DataType expected_type = TYPE_VOID;
  500. HashSet<int> constants;
  501. BlockNode() :
  502. Node(NODE_TYPE_BLOCK) {}
  503. };
  504. struct ControlFlowNode : public Node {
  505. FlowOperation flow_op = FLOW_OP_IF;
  506. Vector<Node *> expressions;
  507. Vector<BlockNode *> blocks;
  508. ControlFlowNode() :
  509. Node(NODE_TYPE_CONTROL_FLOW) {}
  510. };
  511. struct MemberNode : public Node {
  512. DataType basetype = TYPE_VOID;
  513. bool basetype_const = false;
  514. StringName base_struct_name;
  515. DataPrecision precision = PRECISION_DEFAULT;
  516. DataType datatype = TYPE_VOID;
  517. int array_size = 0;
  518. StringName struct_name;
  519. StringName name;
  520. Node *owner = nullptr;
  521. Node *index_expression = nullptr;
  522. Node *assign_expression = nullptr;
  523. Node *call_expression = nullptr;
  524. bool has_swizzling_duplicates = false;
  525. virtual DataType get_datatype() const override { return call_expression ? call_expression->get_datatype() : datatype; }
  526. virtual String get_datatype_name() const override { return call_expression ? call_expression->get_datatype_name() : String(struct_name); }
  527. virtual int get_array_size() const override { return (index_expression || call_expression) ? 0 : array_size; }
  528. virtual bool is_indexed() const override { return index_expression != nullptr || call_expression != nullptr; }
  529. MemberNode() :
  530. Node(NODE_TYPE_MEMBER) {}
  531. };
  532. struct StructNode : public Node {
  533. List<MemberNode *> members;
  534. StructNode() :
  535. Node(NODE_TYPE_STRUCT) {}
  536. };
  537. struct ShaderNode : public Node {
  538. struct Constant {
  539. StringName name;
  540. DataType type;
  541. StringName struct_name;
  542. DataPrecision precision;
  543. Node *initializer = nullptr;
  544. int array_size;
  545. };
  546. struct Function {
  547. StringName name;
  548. StringName rname;
  549. FunctionNode *function = nullptr;
  550. HashSet<StringName> uses_function;
  551. bool callable;
  552. };
  553. struct Struct {
  554. StringName name;
  555. StructNode *shader_struct = nullptr;
  556. };
  557. struct Varying {
  558. enum Stage {
  559. STAGE_UNKNOWN,
  560. STAGE_VERTEX,
  561. STAGE_FRAGMENT,
  562. };
  563. Stage stage = STAGE_UNKNOWN;
  564. DataType type = TYPE_VOID;
  565. DataInterpolation interpolation = INTERPOLATION_FLAT;
  566. DataPrecision precision = PRECISION_DEFAULT;
  567. int array_size = 0;
  568. TkPos tkpos;
  569. uint32_t get_size() const {
  570. uint32_t size = 1;
  571. if (array_size > 0) {
  572. size = (uint32_t)array_size;
  573. }
  574. switch (type) {
  575. case TYPE_MAT2:
  576. size *= 2;
  577. break;
  578. case TYPE_MAT3:
  579. size *= 3;
  580. break;
  581. case TYPE_MAT4:
  582. size *= 4;
  583. break;
  584. default:
  585. break;
  586. }
  587. return size;
  588. }
  589. Varying() {}
  590. };
  591. struct Uniform {
  592. enum Hint {
  593. HINT_NONE,
  594. HINT_RANGE,
  595. HINT_ENUM,
  596. HINT_SOURCE_COLOR,
  597. HINT_COLOR_CONVERSION_DISABLED,
  598. HINT_NORMAL,
  599. HINT_ROUGHNESS_NORMAL,
  600. HINT_ROUGHNESS_R,
  601. HINT_ROUGHNESS_G,
  602. HINT_ROUGHNESS_B,
  603. HINT_ROUGHNESS_A,
  604. HINT_ROUGHNESS_GRAY,
  605. HINT_DEFAULT_BLACK,
  606. HINT_DEFAULT_WHITE,
  607. HINT_DEFAULT_TRANSPARENT,
  608. HINT_ANISOTROPY,
  609. HINT_SCREEN_TEXTURE,
  610. HINT_NORMAL_ROUGHNESS_TEXTURE,
  611. HINT_DEPTH_TEXTURE,
  612. HINT_MAX
  613. };
  614. enum Scope {
  615. SCOPE_LOCAL,
  616. SCOPE_INSTANCE,
  617. SCOPE_GLOBAL,
  618. };
  619. int order = 0;
  620. int prop_order = 0;
  621. int texture_order = 0;
  622. int texture_binding = 0;
  623. DataType type = TYPE_VOID;
  624. DataPrecision precision = PRECISION_DEFAULT;
  625. int array_size = 0;
  626. Vector<Scalar> default_value;
  627. Scope scope = SCOPE_LOCAL;
  628. Hint hint = HINT_NONE;
  629. bool use_color = false;
  630. TextureFilter filter = FILTER_DEFAULT;
  631. TextureRepeat repeat = REPEAT_DEFAULT;
  632. float hint_range[3];
  633. PackedStringArray hint_enum_names;
  634. int instance_index = 0;
  635. String group;
  636. String subgroup;
  637. _FORCE_INLINE_ bool is_texture() const {
  638. // Order is assigned to -1 for texture uniforms.
  639. return order < 0;
  640. }
  641. Uniform() {
  642. hint_range[0] = 0.0f;
  643. hint_range[1] = 1.0f;
  644. hint_range[2] = 0.001f;
  645. }
  646. };
  647. HashMap<StringName, Constant> constants;
  648. HashMap<StringName, Varying> varyings;
  649. HashMap<StringName, Uniform> uniforms;
  650. HashMap<StringName, Struct> structs;
  651. HashMap<StringName, Function> functions;
  652. Vector<StringName> render_modes;
  653. Vector<StringName> stencil_modes;
  654. int stencil_reference = -1;
  655. Vector<Function> vfunctions;
  656. Vector<Constant> vconstants;
  657. Vector<Struct> vstructs;
  658. ShaderNode() :
  659. Node(NODE_TYPE_SHADER) {}
  660. };
  661. struct FunctionNode : public Node {
  662. struct Argument {
  663. ArgumentQualifier qualifier;
  664. StringName name;
  665. DataType type;
  666. StringName struct_name;
  667. DataPrecision precision;
  668. //for passing textures as arguments
  669. bool tex_argument_check;
  670. TextureFilter tex_argument_filter;
  671. TextureRepeat tex_argument_repeat;
  672. bool tex_builtin_check;
  673. StringName tex_builtin;
  674. ShaderNode::Uniform::Hint tex_hint;
  675. bool is_const;
  676. int array_size;
  677. HashMap<StringName, HashSet<int>> tex_argument_connect;
  678. };
  679. StringName name;
  680. StringName rname;
  681. DataType return_type = TYPE_VOID;
  682. StringName return_struct_name;
  683. DataPrecision return_precision = PRECISION_DEFAULT;
  684. int return_array_size = 0;
  685. Vector<Argument> arguments;
  686. BlockNode *body = nullptr;
  687. bool can_discard = false;
  688. virtual DataType get_datatype() const override { return return_type; }
  689. virtual String get_datatype_name() const override { return String(return_struct_name); }
  690. virtual int get_array_size() const override { return return_array_size; }
  691. FunctionNode() :
  692. Node(NODE_TYPE_FUNCTION) {}
  693. };
  694. struct UniformOrderComparator {
  695. _FORCE_INLINE_ bool operator()(const Pair<StringName, int> &A, const Pair<StringName, int> &B) const {
  696. return A.second < B.second;
  697. }
  698. };
  699. struct Expression {
  700. bool is_op;
  701. union {
  702. Operator op;
  703. Node *node = nullptr;
  704. };
  705. };
  706. struct ExpressionInfo {
  707. Vector<Expression> *expression = nullptr;
  708. TokenType tt_break = TK_EMPTY;
  709. bool is_last_expr = false;
  710. };
  711. struct VarInfo {
  712. StringName name;
  713. DataType type;
  714. };
  715. enum CompletionType {
  716. COMPLETION_NONE,
  717. COMPLETION_SHADER_TYPE,
  718. COMPLETION_RENDER_MODE,
  719. COMPLETION_STENCIL_MODE,
  720. COMPLETION_MAIN_FUNCTION,
  721. COMPLETION_IDENTIFIER,
  722. COMPLETION_FUNCTION_CALL,
  723. COMPLETION_CALL_ARGUMENTS,
  724. COMPLETION_INDEX,
  725. COMPLETION_STRUCT,
  726. COMPLETION_HINT,
  727. };
  728. struct Token {
  729. TokenType type;
  730. StringName text;
  731. double constant;
  732. uint16_t line;
  733. bool is_integer_constant() const {
  734. return type == TK_INT_CONSTANT || type == TK_UINT_CONSTANT;
  735. }
  736. };
  737. static String get_operator_text(Operator p_op);
  738. static String get_token_text(Token p_token);
  739. static bool is_token_datatype(TokenType p_type);
  740. static bool is_token_variable_datatype(TokenType p_type);
  741. static DataType get_token_datatype(TokenType p_type);
  742. static bool is_token_interpolation(TokenType p_type);
  743. static DataInterpolation get_token_interpolation(TokenType p_type);
  744. static bool is_token_precision(TokenType p_type);
  745. static bool is_token_arg_qual(TokenType p_type);
  746. static DataPrecision get_token_precision(TokenType p_type);
  747. static String get_precision_name(DataPrecision p_type);
  748. static String get_interpolation_name(DataInterpolation p_interpolation);
  749. static String get_datatype_name(DataType p_type);
  750. static String get_uniform_hint_name(ShaderNode::Uniform::Hint p_hint);
  751. static String get_texture_filter_name(TextureFilter p_filter);
  752. static String get_texture_repeat_name(TextureRepeat p_repeat);
  753. static bool is_token_nonvoid_datatype(TokenType p_type);
  754. static bool is_token_operator(TokenType p_type);
  755. static bool is_token_operator_assign(TokenType p_type);
  756. static bool is_token_hint(TokenType p_type);
  757. static bool convert_constant(ConstantNode *p_constant, DataType p_to_type, Scalar *p_value = nullptr);
  758. static DataType get_scalar_type(DataType p_type);
  759. static int get_cardinality(DataType p_type);
  760. static bool is_scalar_type(DataType p_type);
  761. static bool is_float_type(DataType p_type);
  762. static bool is_sampler_type(DataType p_type);
  763. static bool is_hint_color(ShaderNode::Uniform::Hint p_hint);
  764. static Variant constant_value_to_variant(const Vector<Scalar> &p_value, DataType p_type, int p_array_size, ShaderLanguage::ShaderNode::Uniform::Hint p_hint = ShaderLanguage::ShaderNode::Uniform::HINT_NONE);
  765. static Variant get_default_datatype_value(DataType p_type, int p_array_size, ShaderLanguage::ShaderNode::Uniform::Hint p_hint);
  766. static PropertyInfo uniform_to_property_info(const ShaderNode::Uniform &p_uniform);
  767. static uint32_t get_datatype_size(DataType p_type);
  768. static uint32_t get_datatype_component_count(DataType p_type);
  769. static void get_keyword_list(List<String> *r_keywords);
  770. static bool is_control_flow_keyword(String p_keyword);
  771. static void get_builtin_funcs(List<String> *r_keywords);
  772. static SafeNumeric<int> instance_counter;
  773. struct BuiltInInfo {
  774. DataType type = TYPE_VOID;
  775. bool constant = false;
  776. Vector<Scalar> values;
  777. BuiltInInfo() {}
  778. BuiltInInfo(DataType p_type, bool p_constant = false, const Vector<Scalar> &p_values = {}) :
  779. type(p_type),
  780. constant(p_constant),
  781. values(p_values) {}
  782. };
  783. struct StageFunctionInfo {
  784. struct Argument {
  785. StringName name;
  786. DataType type;
  787. Argument(const StringName &p_name = StringName(), DataType p_type = TYPE_VOID) {
  788. name = p_name;
  789. type = p_type;
  790. }
  791. };
  792. Vector<Argument> arguments;
  793. DataType return_type = TYPE_VOID;
  794. String skip_function;
  795. };
  796. struct ModeInfo {
  797. StringName name;
  798. Vector<StringName> options;
  799. ModeInfo() {}
  800. ModeInfo(const StringName &p_name) :
  801. name(p_name) {
  802. }
  803. ModeInfo(const StringName &p_name, const StringName &p_arg1, const StringName &p_arg2) :
  804. name(p_name) {
  805. options.push_back(p_arg1);
  806. options.push_back(p_arg2);
  807. }
  808. ModeInfo(const StringName &p_name, const StringName &p_arg1, const StringName &p_arg2, const StringName &p_arg3) :
  809. name(p_name) {
  810. options.push_back(p_arg1);
  811. options.push_back(p_arg2);
  812. options.push_back(p_arg3);
  813. }
  814. ModeInfo(const StringName &p_name, const StringName &p_arg1, const StringName &p_arg2, const StringName &p_arg3, const StringName &p_arg4) :
  815. name(p_name) {
  816. options.push_back(p_arg1);
  817. options.push_back(p_arg2);
  818. options.push_back(p_arg3);
  819. options.push_back(p_arg4);
  820. }
  821. ModeInfo(const StringName &p_name, const StringName &p_arg1, const StringName &p_arg2, const StringName &p_arg3, const StringName &p_arg4, const StringName &p_arg5) :
  822. name(p_name) {
  823. options.push_back(p_arg1);
  824. options.push_back(p_arg2);
  825. options.push_back(p_arg3);
  826. options.push_back(p_arg4);
  827. options.push_back(p_arg5);
  828. }
  829. ModeInfo(const StringName &p_name, const StringName &p_arg1, const StringName &p_arg2, const StringName &p_arg3, const StringName &p_arg4, const StringName &p_arg5, const StringName &p_arg6) :
  830. name(p_name) {
  831. options.push_back(p_arg1);
  832. options.push_back(p_arg2);
  833. options.push_back(p_arg3);
  834. options.push_back(p_arg4);
  835. options.push_back(p_arg5);
  836. options.push_back(p_arg6);
  837. }
  838. ModeInfo(const StringName &p_name, std::initializer_list<StringName> p_args) :
  839. name(p_name) {
  840. for (const StringName &arg : p_args) {
  841. options.push_back(arg);
  842. }
  843. }
  844. };
  845. struct FunctionInfo {
  846. HashMap<StringName, BuiltInInfo> built_ins;
  847. HashMap<StringName, StageFunctionInfo> stage_functions;
  848. bool can_discard = false;
  849. bool main_function = false;
  850. };
  851. static bool has_builtin(const HashMap<StringName, ShaderLanguage::FunctionInfo> &p_functions, const StringName &p_name, bool p_check_global_funcs = false);
  852. typedef DataType (*GlobalShaderUniformGetTypeFunc)(const StringName &p_name);
  853. struct FilePosition {
  854. String file;
  855. int line = 0;
  856. };
  857. private:
  858. struct KeyWord {
  859. TokenType token;
  860. const char *text;
  861. uint32_t flags;
  862. const Vector<String> excluded_shader_types;
  863. const Vector<String> excluded_functions;
  864. };
  865. static const KeyWord keyword_list[];
  866. GlobalShaderUniformGetTypeFunc global_shader_uniform_get_type_func = nullptr;
  867. bool error_set = false;
  868. String error_str;
  869. int error_line = 0;
  870. Vector<FilePosition> include_positions;
  871. HashSet<String> include_markers_handled;
  872. HashMap<StringName, int> function_overload_count;
  873. // Additional function information (eg. call hierarchy). No need to expose it to compiler.
  874. struct CallInfo {
  875. struct Item {
  876. enum ItemType {
  877. ITEM_TYPE_BUILTIN,
  878. ITEM_TYPE_VARYING,
  879. } type;
  880. TkPos pos;
  881. Item() {}
  882. Item(ItemType p_type, TkPos p_pos) :
  883. type(p_type), pos(p_pos) {}
  884. };
  885. StringName name;
  886. List<Pair<StringName, Item>> uses_restricted_items;
  887. List<CallInfo *> calls;
  888. };
  889. RBMap<StringName, CallInfo> calls_info;
  890. #ifdef DEBUG_ENABLED
  891. struct Usage {
  892. int decl_line;
  893. bool used = false;
  894. Usage(int p_decl_line = -1) {
  895. decl_line = p_decl_line;
  896. }
  897. };
  898. HashMap<StringName, Usage> used_constants;
  899. HashMap<StringName, Usage> used_varyings;
  900. HashMap<StringName, Usage> used_uniforms;
  901. HashMap<StringName, Usage> used_functions;
  902. HashMap<StringName, Usage> used_structs;
  903. HashMap<ShaderWarning::Code, HashMap<StringName, Usage> *> warnings_check_map;
  904. HashMap<StringName, HashMap<StringName, Usage>> used_local_vars;
  905. HashMap<ShaderWarning::Code, HashMap<StringName, HashMap<StringName, Usage>> *> warnings_check_map2;
  906. List<ShaderWarning> warnings;
  907. bool check_warnings = false;
  908. uint32_t warning_flags = 0;
  909. void _add_line_warning(ShaderWarning::Code p_code, const StringName &p_subject = "", const Vector<Variant> &p_extra_args = Vector<Variant>()) {
  910. warnings.push_back(ShaderWarning(p_code, tk_line, p_subject, p_extra_args));
  911. }
  912. void _add_global_warning(ShaderWarning::Code p_code, const StringName &p_subject = "", const Vector<Variant> &p_extra_args = Vector<Variant>()) {
  913. warnings.push_back(ShaderWarning(p_code, -1, p_subject, p_extra_args));
  914. }
  915. void _add_warning(ShaderWarning::Code p_code, int p_line, const StringName &p_subject = "", const Vector<Variant> &p_extra_args = Vector<Variant>()) {
  916. warnings.push_back(ShaderWarning(p_code, p_line, p_subject, p_extra_args));
  917. }
  918. void _check_warning_accums();
  919. #endif // DEBUG_ENABLED
  920. String code;
  921. int char_idx = 0;
  922. int tk_line = 0;
  923. StringName shader_type_identifier;
  924. StringName current_function;
  925. bool is_const_decl = false;
  926. StringName last_name;
  927. bool is_shader_inc = false;
  928. String current_uniform_group_name;
  929. String current_uniform_subgroup_name;
  930. VaryingFunctionNames varying_function_names;
  931. uint32_t base_varying_index = 0;
  932. TkPos _get_tkpos() {
  933. TkPos tkp;
  934. tkp.char_idx = char_idx;
  935. tkp.tk_line = tk_line;
  936. return tkp;
  937. }
  938. void _set_tkpos(TkPos p_pos) {
  939. char_idx = p_pos.char_idx;
  940. tk_line = p_pos.tk_line;
  941. }
  942. void _set_error(const String &p_str) {
  943. if (error_set) {
  944. return;
  945. }
  946. error_line = tk_line;
  947. error_set = true;
  948. error_str = p_str;
  949. include_positions.write[include_positions.size() - 1].line = tk_line;
  950. }
  951. void _set_expected_error(const String &p_what) {
  952. _set_error(vformat(RTR("Expected a '%s'."), p_what));
  953. }
  954. void _set_expected_error(const String &p_first, const String p_second) {
  955. _set_error(vformat(RTR("Expected a '%s' or '%s'."), p_first, p_second));
  956. }
  957. void _set_expected_after_error(const String &p_what, const String &p_after) {
  958. _set_error(vformat(RTR("Expected a '%s' after '%s'."), p_what, p_after));
  959. }
  960. void _set_redefinition_error(const String &p_what) {
  961. _set_error(vformat(RTR("Redefinition of '%s'."), p_what));
  962. }
  963. void _set_parsing_error() {
  964. _set_error("Parser bug.");
  965. }
  966. static const char *token_names[TK_MAX];
  967. Token _make_token(TokenType p_type, const StringName &p_text = StringName());
  968. Token _get_token();
  969. bool _lookup_next(Token &r_tk);
  970. Token _peek();
  971. ShaderNode *shader = nullptr;
  972. enum IdentifierType {
  973. IDENTIFIER_FUNCTION,
  974. IDENTIFIER_UNIFORM,
  975. IDENTIFIER_VARYING,
  976. IDENTIFIER_FUNCTION_ARGUMENT,
  977. IDENTIFIER_LOCAL_VAR,
  978. IDENTIFIER_BUILTIN_VAR,
  979. IDENTIFIER_CONSTANT,
  980. IDENTIFIER_MAX,
  981. };
  982. IdentifierType last_type = IDENTIFIER_MAX;
  983. bool _find_identifier(const BlockNode *p_block, bool p_allow_reassign, const FunctionInfo &p_function_info, const StringName &p_identifier, DataType *r_data_type = nullptr, IdentifierType *r_type = nullptr, bool *r_is_const = nullptr, int *r_array_size = nullptr, StringName *r_struct_name = nullptr, Vector<Scalar> *r_constant_values = nullptr);
  984. #ifdef DEBUG_ENABLED
  985. void _parse_used_identifier(const StringName &p_identifier, IdentifierType p_type, const StringName &p_function);
  986. #endif // DEBUG_ENABLED
  987. bool _is_operator_assign(Operator p_op) const;
  988. bool _validate_assign(Node *p_node, const FunctionInfo &p_function_info, String *r_message = nullptr);
  989. bool _validate_operator(const BlockNode *p_block, const FunctionInfo &p_function_info, OperatorNode *p_op, DataType *r_ret_type = nullptr, int *r_ret_size = nullptr);
  990. Vector<Scalar> _get_node_values(const BlockNode *p_block, const FunctionInfo &p_function_info, Node *p_node);
  991. bool _eval_operator(const BlockNode *p_block, const FunctionInfo &p_function_info, OperatorNode *p_op);
  992. Scalar _eval_unary_scalar(const Scalar &p_a, Operator p_op, DataType p_ret_type);
  993. Scalar _eval_scalar(const Scalar &p_a, const Scalar &p_b, Operator p_op, DataType p_ret_type, bool &r_is_valid);
  994. Vector<Scalar> _eval_unary_vector(const Vector<Scalar> &p_va, DataType p_ret_type, Operator p_op);
  995. Vector<Scalar> _eval_vector(const Vector<Scalar> &p_va, const Vector<Scalar> &p_vb, DataType p_left_type, DataType p_right_type, DataType p_ret_type, Operator p_op, bool &r_is_valid);
  996. Vector<Scalar> _eval_vector_transform(const Vector<Scalar> &p_va, const Vector<Scalar> &p_vb, DataType p_left_type, DataType p_right_type, DataType p_ret_type);
  997. struct BuiltinEntry {
  998. const char *name;
  999. };
  1000. struct BuiltinFuncDef {
  1001. enum { MAX_ARGS = 5 };
  1002. const char *name;
  1003. DataType rettype;
  1004. const DataType args[MAX_ARGS];
  1005. const char *args_names[MAX_ARGS];
  1006. SubClassTag tag;
  1007. bool high_end;
  1008. };
  1009. struct BuiltinFuncOutArgs { //arguments used as out in built in functions
  1010. enum { MAX_ARGS = 2 };
  1011. const char *name;
  1012. const int arguments[MAX_ARGS];
  1013. };
  1014. struct BuiltinFuncConstArgs {
  1015. const char *name;
  1016. int arg;
  1017. int min;
  1018. int max;
  1019. };
  1020. CompletionType completion_type;
  1021. ShaderNode::Uniform::Hint current_uniform_hint = ShaderNode::Uniform::HINT_NONE;
  1022. TextureFilter current_uniform_filter = FILTER_DEFAULT;
  1023. TextureRepeat current_uniform_repeat = REPEAT_DEFAULT;
  1024. bool current_uniform_instance_index_defined = false;
  1025. int completion_line = 0;
  1026. BlockNode *completion_block = nullptr;
  1027. DataType completion_base;
  1028. bool completion_base_array = false;
  1029. SubClassTag completion_class;
  1030. StringName completion_function;
  1031. StringName completion_struct;
  1032. int completion_argument = 0;
  1033. #ifdef DEBUG_ENABLED
  1034. uint32_t keyword_completion_context;
  1035. #endif // DEBUG_ENABLED
  1036. const HashMap<StringName, FunctionInfo> *stages = nullptr;
  1037. bool is_supported_frag_only_funcs = false;
  1038. bool is_discard_supported = false;
  1039. bool _get_completable_identifier(BlockNode *p_block, CompletionType p_type, StringName &identifier);
  1040. static const BuiltinFuncDef builtin_func_defs[];
  1041. static const BuiltinFuncOutArgs builtin_func_out_args[];
  1042. static const BuiltinFuncConstArgs builtin_func_const_args[];
  1043. static const BuiltinEntry frag_only_func_defs[];
  1044. static bool is_const_suffix_lut_initialized;
  1045. Error _validate_precision(DataType p_type, DataPrecision p_precision);
  1046. bool _compare_datatypes(DataType p_datatype_a, String p_datatype_name_a, int p_array_size_a, DataType p_datatype_b, String p_datatype_name_b, int p_array_size_b);
  1047. bool _compare_datatypes_in_nodes(Node *a, Node *b);
  1048. bool _validate_function_call(BlockNode *p_block, const FunctionInfo &p_function_info, OperatorNode *p_func, DataType *r_ret_type, StringName *r_ret_type_str, bool *r_is_custom_function = nullptr);
  1049. bool _parse_function_arguments(BlockNode *p_block, const FunctionInfo &p_function_info, OperatorNode *p_func, int *r_complete_arg = nullptr);
  1050. ShaderNode::Uniform::Hint _sanitize_hint(ShaderNode::Uniform::Hint p_hint);
  1051. bool _propagate_function_call_sampler_uniform_settings(const StringName &p_name, int p_argument, TextureFilter p_filter, TextureRepeat p_repeat, ShaderNode::Uniform::Hint p_hint);
  1052. bool _propagate_function_call_sampler_builtin_reference(const StringName &p_name, int p_argument, const StringName &p_builtin);
  1053. bool _validate_varying_assign(ShaderNode::Varying &p_varying, String *r_message);
  1054. bool _check_node_constness(const Node *p_node) const;
  1055. bool _check_restricted_func(const StringName &p_name, const StringName &p_current_function) const;
  1056. bool _validate_restricted_func(const StringName &p_call_name, const CallInfo *p_func_info, bool p_is_builtin_hint = false);
  1057. Node *_parse_expression(BlockNode *p_block, const FunctionInfo &p_function_info, const ExpressionInfo *p_previous_expression_info = nullptr);
  1058. Error _parse_array_size(BlockNode *p_block, const FunctionInfo &p_function_info, bool p_forbid_unknown_size, Node **r_size_expression, int *r_array_size, bool *r_unknown_size);
  1059. Node *_parse_array_constructor(BlockNode *p_block, const FunctionInfo &p_function_info);
  1060. Node *_parse_array_constructor(BlockNode *p_block, const FunctionInfo &p_function_info, DataType p_type, const StringName &p_struct_name, int p_array_size);
  1061. ShaderLanguage::Node *_reduce_expression(BlockNode *p_block, ShaderLanguage::Node *p_node);
  1062. Node *_parse_and_reduce_expression(BlockNode *p_block, const FunctionInfo &p_function_info, const ExpressionInfo *p_previous_expression_info = nullptr);
  1063. Error _parse_block(BlockNode *p_block, const FunctionInfo &p_function_info, bool p_just_one = false, bool p_can_break = false, bool p_can_continue = false);
  1064. String _get_shader_type_list(const HashSet<String> &p_shader_types) const;
  1065. String _get_qualifier_str(ArgumentQualifier p_qualifier) const;
  1066. bool _parse_numeric_constant_expression(const FunctionInfo &p_function_info, float &r_constant);
  1067. Error _parse_shader(const HashMap<StringName, FunctionInfo> &p_functions, const Vector<ModeInfo> &p_render_modes, const Vector<ModeInfo> &p_stencil_modes, const HashSet<String> &p_shader_types);
  1068. Error _find_last_flow_op_in_block(BlockNode *p_block, FlowOperation p_op);
  1069. Error _find_last_flow_op_in_op(ControlFlowNode *p_flow, FlowOperation p_op);
  1070. Error _parse_shader_mode(bool p_is_stencil, const Vector<ModeInfo> &p_modes, HashMap<String, String> &r_defined_modes);
  1071. public:
  1072. #ifdef DEBUG_ENABLED
  1073. List<ShaderWarning>::Element *get_warnings_ptr();
  1074. void enable_warning_checking(bool p_enabled);
  1075. bool is_warning_checking_enabled() const;
  1076. void set_warning_flags(uint32_t p_flags);
  1077. uint32_t get_warning_flags() const;
  1078. #endif // DEBUG_ENABLED
  1079. //static void get_keyword_list(ShaderType p_type,List<String> *p_keywords);
  1080. void clear();
  1081. static String get_shader_type(const String &p_code);
  1082. static bool is_builtin_func_out_parameter(const String &p_name, int p_param);
  1083. struct ShaderCompileInfo {
  1084. HashMap<StringName, FunctionInfo> functions;
  1085. Vector<ModeInfo> render_modes;
  1086. Vector<ModeInfo> stencil_modes;
  1087. VaryingFunctionNames varying_function_names;
  1088. HashSet<String> shader_types;
  1089. GlobalShaderUniformGetTypeFunc global_shader_uniform_type_func = nullptr;
  1090. bool is_include = false;
  1091. uint32_t base_varying_index = 0;
  1092. };
  1093. Error compile(const String &p_code, const ShaderCompileInfo &p_info);
  1094. Error complete(const String &p_code, const ShaderCompileInfo &p_info, List<ScriptLanguage::CodeCompletionOption> *r_options, String &r_call_hint);
  1095. String get_error_text();
  1096. Vector<FilePosition> get_include_positions();
  1097. int get_error_line();
  1098. ShaderNode *get_shader();
  1099. String token_debug(const String &p_code);
  1100. ShaderLanguage();
  1101. ~ShaderLanguage();
  1102. };