1 /*************************************************************************/
2 /* shader_compiler_gles3.cpp */
3 /*************************************************************************/
4 /* This file is part of: */
5 /* GODOT ENGINE */
6 /* https://godotengine.org */
7 /*************************************************************************/
8 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
9 /* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
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
31 #include "shader_compiler_gles3.h"
32
33 #include "core/os/os.h"
34 #include "core/project_settings.h"
35
36 #define SL ShaderLanguage
37
_mktab(int p_level)38 static String _mktab(int p_level) {
39
40 String tb;
41 for (int i = 0; i < p_level; i++) {
42 tb += "\t";
43 }
44
45 return tb;
46 }
47
_typestr(SL::DataType p_type)48 static String _typestr(SL::DataType p_type) {
49
50 return ShaderLanguage::get_datatype_name(p_type);
51 }
52
_get_datatype_size(SL::DataType p_type)53 static int _get_datatype_size(SL::DataType p_type) {
54
55 switch (p_type) {
56
57 case SL::TYPE_VOID: return 0;
58 case SL::TYPE_BOOL: return 4;
59 case SL::TYPE_BVEC2: return 8;
60 case SL::TYPE_BVEC3: return 12;
61 case SL::TYPE_BVEC4: return 16;
62 case SL::TYPE_INT: return 4;
63 case SL::TYPE_IVEC2: return 8;
64 case SL::TYPE_IVEC3: return 12;
65 case SL::TYPE_IVEC4: return 16;
66 case SL::TYPE_UINT: return 4;
67 case SL::TYPE_UVEC2: return 8;
68 case SL::TYPE_UVEC3: return 12;
69 case SL::TYPE_UVEC4: return 16;
70 case SL::TYPE_FLOAT: return 4;
71 case SL::TYPE_VEC2: return 8;
72 case SL::TYPE_VEC3: return 12;
73 case SL::TYPE_VEC4: return 16;
74 case SL::TYPE_MAT2:
75 return 32; //4 * 4 + 4 * 4
76 case SL::TYPE_MAT3:
77 return 48; // 4 * 4 + 4 * 4 + 4 * 4
78 case SL::TYPE_MAT4: return 64;
79 case SL::TYPE_SAMPLER2D: return 16;
80 case SL::TYPE_ISAMPLER2D: return 16;
81 case SL::TYPE_USAMPLER2D: return 16;
82 case SL::TYPE_SAMPLER2DARRAY: return 16;
83 case SL::TYPE_ISAMPLER2DARRAY: return 16;
84 case SL::TYPE_USAMPLER2DARRAY: return 16;
85 case SL::TYPE_SAMPLER3D: return 16;
86 case SL::TYPE_ISAMPLER3D: return 16;
87 case SL::TYPE_USAMPLER3D: return 16;
88 case SL::TYPE_SAMPLERCUBE: return 16;
89 case SL::TYPE_SAMPLEREXT: return 16;
90 }
91
92 ERR_FAIL_V(0);
93 }
94
_get_datatype_alignment(SL::DataType p_type)95 static int _get_datatype_alignment(SL::DataType p_type) {
96
97 switch (p_type) {
98
99 case SL::TYPE_VOID: return 0;
100 case SL::TYPE_BOOL: return 4;
101 case SL::TYPE_BVEC2: return 8;
102 case SL::TYPE_BVEC3: return 16;
103 case SL::TYPE_BVEC4: return 16;
104 case SL::TYPE_INT: return 4;
105 case SL::TYPE_IVEC2: return 8;
106 case SL::TYPE_IVEC3: return 16;
107 case SL::TYPE_IVEC4: return 16;
108 case SL::TYPE_UINT: return 4;
109 case SL::TYPE_UVEC2: return 8;
110 case SL::TYPE_UVEC3: return 16;
111 case SL::TYPE_UVEC4: return 16;
112 case SL::TYPE_FLOAT: return 4;
113 case SL::TYPE_VEC2: return 8;
114 case SL::TYPE_VEC3: return 16;
115 case SL::TYPE_VEC4: return 16;
116 case SL::TYPE_MAT2: return 16;
117 case SL::TYPE_MAT3: return 16;
118 case SL::TYPE_MAT4: return 16;
119 case SL::TYPE_SAMPLER2D: return 16;
120 case SL::TYPE_ISAMPLER2D: return 16;
121 case SL::TYPE_USAMPLER2D: return 16;
122 case SL::TYPE_SAMPLER2DARRAY: return 16;
123 case SL::TYPE_ISAMPLER2DARRAY: return 16;
124 case SL::TYPE_USAMPLER2DARRAY: return 16;
125 case SL::TYPE_SAMPLER3D: return 16;
126 case SL::TYPE_ISAMPLER3D: return 16;
127 case SL::TYPE_USAMPLER3D: return 16;
128 case SL::TYPE_SAMPLERCUBE: return 16;
129 case SL::TYPE_SAMPLEREXT: return 16;
130 }
131
132 ERR_FAIL_V(0);
133 }
_interpstr(SL::DataInterpolation p_interp)134 static String _interpstr(SL::DataInterpolation p_interp) {
135
136 switch (p_interp) {
137 case SL::INTERPOLATION_FLAT: return "flat ";
138 case SL::INTERPOLATION_SMOOTH: return "";
139 }
140 return "";
141 }
142
_prestr(SL::DataPrecision p_pres)143 static String _prestr(SL::DataPrecision p_pres) {
144
145 switch (p_pres) {
146 case SL::PRECISION_LOWP: return "lowp ";
147 case SL::PRECISION_MEDIUMP: return "mediump ";
148 case SL::PRECISION_HIGHP: return "highp ";
149 case SL::PRECISION_DEFAULT: return "";
150 }
151 return "";
152 }
153
_qualstr(SL::ArgumentQualifier p_qual)154 static String _qualstr(SL::ArgumentQualifier p_qual) {
155
156 switch (p_qual) {
157 case SL::ARGUMENT_QUALIFIER_IN: return "";
158 case SL::ARGUMENT_QUALIFIER_OUT: return "out ";
159 case SL::ARGUMENT_QUALIFIER_INOUT: return "inout ";
160 }
161 return "";
162 }
163
_opstr(SL::Operator p_op)164 static String _opstr(SL::Operator p_op) {
165
166 return SL::get_operator_text(p_op);
167 }
168
_mkid(const String & p_id)169 static String _mkid(const String &p_id) {
170
171 String id = "m_" + p_id.replace("__", "_dus_");
172 return id.replace("__", "_dus_"); //doubleunderscore is reserved in glsl
173 }
174
f2sp0(float p_float)175 static String f2sp0(float p_float) {
176
177 String num = rtoss(p_float);
178 if (num.find(".") == -1 && num.find("e") == -1) {
179 num += ".0";
180 }
181 return num;
182 }
183
get_constant_text(SL::DataType p_type,const Vector<SL::ConstantNode::Value> & p_values)184 static String get_constant_text(SL::DataType p_type, const Vector<SL::ConstantNode::Value> &p_values) {
185
186 switch (p_type) {
187 case SL::TYPE_BOOL: return p_values[0].boolean ? "true" : "false";
188 case SL::TYPE_BVEC2:
189 case SL::TYPE_BVEC3:
190 case SL::TYPE_BVEC4: {
191
192 String text = "bvec" + itos(p_type - SL::TYPE_BOOL + 1) + "(";
193 for (int i = 0; i < p_values.size(); i++) {
194 if (i > 0)
195 text += ",";
196
197 text += p_values[i].boolean ? "true" : "false";
198 }
199 text += ")";
200 return text;
201 }
202
203 case SL::TYPE_INT: return itos(p_values[0].sint);
204 case SL::TYPE_IVEC2:
205 case SL::TYPE_IVEC3:
206 case SL::TYPE_IVEC4: {
207
208 String text = "ivec" + itos(p_type - SL::TYPE_INT + 1) + "(";
209 for (int i = 0; i < p_values.size(); i++) {
210 if (i > 0)
211 text += ",";
212
213 text += itos(p_values[i].sint);
214 }
215 text += ")";
216 return text;
217
218 } break;
219 case SL::TYPE_UINT: return itos(p_values[0].uint) + "u";
220 case SL::TYPE_UVEC2:
221 case SL::TYPE_UVEC3:
222 case SL::TYPE_UVEC4: {
223
224 String text = "uvec" + itos(p_type - SL::TYPE_UINT + 1) + "(";
225 for (int i = 0; i < p_values.size(); i++) {
226 if (i > 0)
227 text += ",";
228
229 text += itos(p_values[i].uint) + "u";
230 }
231 text += ")";
232 return text;
233 } break;
234 case SL::TYPE_FLOAT: return f2sp0(p_values[0].real);
235 case SL::TYPE_VEC2:
236 case SL::TYPE_VEC3:
237 case SL::TYPE_VEC4: {
238
239 String text = "vec" + itos(p_type - SL::TYPE_FLOAT + 1) + "(";
240 for (int i = 0; i < p_values.size(); i++) {
241 if (i > 0)
242 text += ",";
243
244 text += f2sp0(p_values[i].real);
245 }
246 text += ")";
247 return text;
248
249 } break;
250 case SL::TYPE_MAT2:
251 case SL::TYPE_MAT3:
252 case SL::TYPE_MAT4: {
253
254 String text = "mat" + itos(p_type - SL::TYPE_MAT2 + 2) + "(";
255 for (int i = 0; i < p_values.size(); i++) {
256 if (i > 0)
257 text += ",";
258
259 text += f2sp0(p_values[i].real);
260 }
261 text += ")";
262 return text;
263
264 } break;
265 default: ERR_FAIL_V(String());
266 }
267 }
268
_dump_function_deps(SL::ShaderNode * p_node,const StringName & p_for_func,const Map<StringName,String> & p_func_code,String & r_to_add,Set<StringName> & added)269 void ShaderCompilerGLES3::_dump_function_deps(SL::ShaderNode *p_node, const StringName &p_for_func, const Map<StringName, String> &p_func_code, String &r_to_add, Set<StringName> &added) {
270
271 int fidx = -1;
272
273 for (int i = 0; i < p_node->functions.size(); i++) {
274 if (p_node->functions[i].name == p_for_func) {
275 fidx = i;
276 break;
277 }
278 }
279
280 ERR_FAIL_COND(fidx == -1);
281
282 for (Set<StringName>::Element *E = p_node->functions[fidx].uses_function.front(); E; E = E->next()) {
283
284 if (added.has(E->get())) {
285 continue; //was added already
286 }
287
288 _dump_function_deps(p_node, E->get(), p_func_code, r_to_add, added);
289
290 SL::FunctionNode *fnode = NULL;
291
292 for (int i = 0; i < p_node->functions.size(); i++) {
293 if (p_node->functions[i].name == E->get()) {
294 fnode = p_node->functions[i].function;
295 break;
296 }
297 }
298
299 ERR_FAIL_COND(!fnode);
300
301 r_to_add += "\n";
302
303 String header;
304 header = _typestr(fnode->return_type) + " " + _mkid(fnode->name) + "(";
305 for (int i = 0; i < fnode->arguments.size(); i++) {
306
307 if (i > 0)
308 header += ", ";
309 header += _qualstr(fnode->arguments[i].qualifier) + _prestr(fnode->arguments[i].precision) + _typestr(fnode->arguments[i].type) + " " + _mkid(fnode->arguments[i].name);
310 }
311
312 header += ")\n";
313 r_to_add += header;
314 r_to_add += p_func_code[E->get()];
315
316 added.insert(E->get());
317 }
318 }
319
_dump_node_code(SL::Node * p_node,int p_level,GeneratedCode & r_gen_code,IdentifierActions & p_actions,const DefaultIdentifierActions & p_default_actions,bool p_assigning,bool p_use_scope)320 String ShaderCompilerGLES3::_dump_node_code(SL::Node *p_node, int p_level, GeneratedCode &r_gen_code, IdentifierActions &p_actions, const DefaultIdentifierActions &p_default_actions, bool p_assigning, bool p_use_scope) {
321
322 String code;
323
324 switch (p_node->type) {
325
326 case SL::Node::TYPE_SHADER: {
327
328 SL::ShaderNode *pnode = (SL::ShaderNode *)p_node;
329
330 for (int i = 0; i < pnode->render_modes.size(); i++) {
331
332 if (p_default_actions.render_mode_defines.has(pnode->render_modes[i]) && !used_rmode_defines.has(pnode->render_modes[i])) {
333
334 r_gen_code.defines.push_back(p_default_actions.render_mode_defines[pnode->render_modes[i]].utf8());
335 used_rmode_defines.insert(pnode->render_modes[i]);
336 }
337
338 if (p_actions.render_mode_flags.has(pnode->render_modes[i])) {
339 *p_actions.render_mode_flags[pnode->render_modes[i]] = true;
340 }
341
342 if (p_actions.render_mode_values.has(pnode->render_modes[i])) {
343 Pair<int *, int> &p = p_actions.render_mode_values[pnode->render_modes[i]];
344 *p.first = p.second;
345 }
346 }
347
348 int max_texture_uniforms = 0;
349 int max_uniforms = 0;
350
351 for (Map<StringName, SL::ShaderNode::Uniform>::Element *E = pnode->uniforms.front(); E; E = E->next()) {
352 if (SL::is_sampler_type(E->get().type))
353 max_texture_uniforms++;
354 else
355 max_uniforms++;
356 }
357
358 r_gen_code.texture_uniforms.resize(max_texture_uniforms);
359 r_gen_code.texture_hints.resize(max_texture_uniforms);
360 r_gen_code.texture_types.resize(max_texture_uniforms);
361
362 Vector<int> uniform_sizes;
363 Vector<int> uniform_alignments;
364 Vector<StringName> uniform_defines;
365 uniform_sizes.resize(max_uniforms);
366 uniform_alignments.resize(max_uniforms);
367 uniform_defines.resize(max_uniforms);
368 bool uses_uniforms = false;
369
370 for (Map<StringName, SL::ShaderNode::Uniform>::Element *E = pnode->uniforms.front(); E; E = E->next()) {
371
372 String ucode;
373
374 if (SL::is_sampler_type(E->get().type)) {
375 ucode = "uniform ";
376 }
377
378 ucode += _prestr(E->get().precision);
379 ucode += _typestr(E->get().type);
380 ucode += " " + _mkid(E->key());
381 ucode += ";\n";
382 if (SL::is_sampler_type(E->get().type)) {
383 r_gen_code.vertex_global += ucode;
384 r_gen_code.fragment_global += ucode;
385 r_gen_code.texture_uniforms.write[E->get().texture_order] = _mkid(E->key());
386 r_gen_code.texture_hints.write[E->get().texture_order] = E->get().hint;
387 r_gen_code.texture_types.write[E->get().texture_order] = E->get().type;
388 } else {
389 if (!uses_uniforms) {
390
391 r_gen_code.defines.push_back(String("#define USE_MATERIAL\n").ascii());
392 uses_uniforms = true;
393 }
394 uniform_defines.write[E->get().order] = ucode;
395 uniform_sizes.write[E->get().order] = _get_datatype_size(E->get().type);
396 uniform_alignments.write[E->get().order] = _get_datatype_alignment(E->get().type);
397 }
398
399 p_actions.uniforms->insert(E->key(), E->get());
400 }
401
402 for (int i = 0; i < max_uniforms; i++) {
403 r_gen_code.uniforms += uniform_defines[i];
404 }
405
406 // add up
407 int offset = 0;
408 for (int i = 0; i < uniform_sizes.size(); i++) {
409
410 int align = offset % uniform_alignments[i];
411
412 if (align != 0) {
413 offset += uniform_alignments[i] - align;
414 }
415
416 r_gen_code.uniform_offsets.push_back(offset);
417
418 offset += uniform_sizes[i];
419 }
420
421 r_gen_code.uniform_total_size = offset;
422 if (r_gen_code.uniform_total_size % 16 != 0) { //UBO sizes must be multiples of 16
423 r_gen_code.uniform_total_size += r_gen_code.uniform_total_size % 16;
424 }
425
426 for (Map<StringName, SL::ShaderNode::Varying>::Element *E = pnode->varyings.front(); E; E = E->next()) {
427
428 String vcode;
429 String interp_mode = _interpstr(E->get().interpolation);
430 vcode += _prestr(E->get().precision);
431 vcode += _typestr(E->get().type);
432 vcode += " " + _mkid(E->key());
433 if (E->get().array_size > 0) {
434 vcode += "[";
435 vcode += itos(E->get().array_size);
436 vcode += "]";
437 }
438 vcode += ";\n";
439 r_gen_code.vertex_global += interp_mode + "out " + vcode;
440 r_gen_code.fragment_global += interp_mode + "in " + vcode;
441 }
442
443 for (int i = 0; i < pnode->vconstants.size(); i++) {
444 String gcode;
445 gcode += "const ";
446 gcode += _prestr(pnode->vconstants[i].precision);
447 gcode += _typestr(pnode->vconstants[i].type);
448 gcode += " " + _mkid(String(pnode->vconstants[i].name));
449 gcode += "=";
450 gcode += _dump_node_code(pnode->vconstants[i].initializer, p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
451 gcode += ";\n";
452 r_gen_code.vertex_global += gcode;
453 r_gen_code.fragment_global += gcode;
454 }
455
456 Map<StringName, String> function_code;
457
458 //code for functions
459 for (int i = 0; i < pnode->functions.size(); i++) {
460 SL::FunctionNode *fnode = pnode->functions[i].function;
461 current_func_name = fnode->name;
462 function_code[fnode->name] = _dump_node_code(fnode->body, p_level + 1, r_gen_code, p_actions, p_default_actions, p_assigning);
463 }
464
465 //place functions in actual code
466
467 Set<StringName> added_vtx;
468 Set<StringName> added_fragment; //share for light
469
470 for (int i = 0; i < pnode->functions.size(); i++) {
471
472 SL::FunctionNode *fnode = pnode->functions[i].function;
473
474 current_func_name = fnode->name;
475
476 if (fnode->name == vertex_name) {
477
478 _dump_function_deps(pnode, fnode->name, function_code, r_gen_code.vertex_global, added_vtx);
479 r_gen_code.vertex = function_code[vertex_name];
480 }
481
482 if (fnode->name == fragment_name) {
483
484 _dump_function_deps(pnode, fnode->name, function_code, r_gen_code.fragment_global, added_fragment);
485 r_gen_code.fragment = function_code[fragment_name];
486 }
487
488 if (fnode->name == light_name) {
489
490 _dump_function_deps(pnode, fnode->name, function_code, r_gen_code.fragment_global, added_fragment);
491 r_gen_code.light = function_code[light_name];
492 }
493 }
494
495 //code+=dump_node_code(pnode->body,p_level);
496 } break;
497 case SL::Node::TYPE_FUNCTION: {
498
499 } break;
500 case SL::Node::TYPE_BLOCK: {
501 SL::BlockNode *bnode = (SL::BlockNode *)p_node;
502
503 //variables
504 if (!bnode->single_statement) {
505 code += _mktab(p_level - 1) + "{\n";
506 }
507
508 for (int i = 0; i < bnode->statements.size(); i++) {
509
510 String scode = _dump_node_code(bnode->statements[i], p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
511
512 if (bnode->statements[i]->type == SL::Node::TYPE_CONTROL_FLOW || bnode->single_statement) {
513 code += scode; //use directly
514 } else {
515 code += _mktab(p_level) + scode + ";\n";
516 }
517 }
518 if (!bnode->single_statement) {
519 code += _mktab(p_level - 1) + "}\n";
520 }
521
522 } break;
523 case SL::Node::TYPE_VARIABLE_DECLARATION: {
524 SL::VariableDeclarationNode *vdnode = (SL::VariableDeclarationNode *)p_node;
525
526 String declaration;
527 if (vdnode->is_const) {
528 declaration += "const ";
529 }
530 declaration += _prestr(vdnode->precision);
531 declaration += _typestr(vdnode->datatype);
532 for (int i = 0; i < vdnode->declarations.size(); i++) {
533 if (i > 0) {
534 declaration += ",";
535 } else {
536 declaration += " ";
537 }
538 declaration += _mkid(vdnode->declarations[i].name);
539 if (vdnode->declarations[i].initializer) {
540 declaration += "=";
541 declaration += _dump_node_code(vdnode->declarations[i].initializer, p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
542 }
543 }
544
545 code += declaration;
546 } break;
547 case SL::Node::TYPE_VARIABLE: {
548 SL::VariableNode *vnode = (SL::VariableNode *)p_node;
549
550 if (p_assigning && p_actions.write_flag_pointers.has(vnode->name)) {
551 *p_actions.write_flag_pointers[vnode->name] = true;
552 }
553
554 if (p_default_actions.usage_defines.has(vnode->name) && !used_name_defines.has(vnode->name)) {
555 String define = p_default_actions.usage_defines[vnode->name];
556 if (define.begins_with("@")) {
557 define = p_default_actions.usage_defines[define.substr(1, define.length())];
558 }
559 r_gen_code.defines.push_back(define.utf8());
560 used_name_defines.insert(vnode->name);
561 }
562
563 if (p_actions.usage_flag_pointers.has(vnode->name) && !used_flag_pointers.has(vnode->name)) {
564 *p_actions.usage_flag_pointers[vnode->name] = true;
565 used_flag_pointers.insert(vnode->name);
566 }
567
568 if (p_default_actions.renames.has(vnode->name))
569 code = p_default_actions.renames[vnode->name];
570 else
571 code = _mkid(vnode->name);
572
573 if (vnode->name == time_name) {
574 if (current_func_name == vertex_name) {
575 r_gen_code.uses_vertex_time = true;
576 }
577 if (current_func_name == fragment_name || current_func_name == light_name) {
578 r_gen_code.uses_fragment_time = true;
579 }
580 }
581
582 } break;
583 case SL::Node::TYPE_ARRAY_DECLARATION: {
584
585 SL::ArrayDeclarationNode *adnode = (SL::ArrayDeclarationNode *)p_node;
586
587 String declaration;
588 if (adnode->is_const) {
589 declaration += "const ";
590 }
591 declaration += _prestr(adnode->precision);
592 declaration += _typestr(adnode->datatype);
593 for (int i = 0; i < adnode->declarations.size(); i++) {
594 if (i > 0) {
595 declaration += ",";
596 } else {
597 declaration += " ";
598 }
599 declaration += _mkid(adnode->declarations[i].name);
600 declaration += "[";
601 declaration += itos(adnode->declarations[i].size);
602 declaration += "]";
603 int sz = adnode->declarations[i].initializer.size();
604 if (sz > 0) {
605 declaration += "=";
606 declaration += _typestr(adnode->datatype);
607 declaration += "[";
608 declaration += itos(sz);
609 declaration += "]";
610 declaration += "(";
611 for (int j = 0; j < sz; j++) {
612 declaration += _dump_node_code(adnode->declarations[i].initializer[j], p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
613 if (j != sz - 1) {
614 declaration += ", ";
615 }
616 }
617 declaration += ")";
618 }
619 }
620
621 code += declaration;
622 } break;
623 case SL::Node::TYPE_ARRAY: {
624 SL::ArrayNode *anode = (SL::ArrayNode *)p_node;
625
626 if (p_assigning && p_actions.write_flag_pointers.has(anode->name)) {
627 *p_actions.write_flag_pointers[anode->name] = true;
628 }
629
630 if (p_default_actions.usage_defines.has(anode->name) && !used_name_defines.has(anode->name)) {
631 String define = p_default_actions.usage_defines[anode->name];
632 if (define.begins_with("@")) {
633 define = p_default_actions.usage_defines[define.substr(1, define.length())];
634 }
635 r_gen_code.defines.push_back(define.utf8());
636 used_name_defines.insert(anode->name);
637 }
638
639 if (p_actions.usage_flag_pointers.has(anode->name) && !used_flag_pointers.has(anode->name)) {
640 *p_actions.usage_flag_pointers[anode->name] = true;
641 used_flag_pointers.insert(anode->name);
642 }
643
644 if (p_default_actions.renames.has(anode->name))
645 code = p_default_actions.renames[anode->name];
646 else
647 code = _mkid(anode->name);
648
649 if (anode->call_expression != NULL) {
650 code += ".";
651 code += _dump_node_code(anode->call_expression, p_level, r_gen_code, p_actions, p_default_actions, p_assigning, false);
652 }
653
654 if (anode->index_expression != NULL) {
655 code += "[";
656 code += _dump_node_code(anode->index_expression, p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
657 code += "]";
658 }
659
660 if (anode->name == time_name) {
661 if (current_func_name == vertex_name) {
662 r_gen_code.uses_vertex_time = true;
663 }
664 if (current_func_name == fragment_name || current_func_name == light_name) {
665 r_gen_code.uses_fragment_time = true;
666 }
667 }
668
669 } break;
670 case SL::Node::TYPE_CONSTANT: {
671 SL::ConstantNode *cnode = (SL::ConstantNode *)p_node;
672 return get_constant_text(cnode->datatype, cnode->values);
673
674 } break;
675 case SL::Node::TYPE_OPERATOR: {
676 SL::OperatorNode *onode = (SL::OperatorNode *)p_node;
677
678 switch (onode->op) {
679
680 case SL::OP_ASSIGN:
681 case SL::OP_ASSIGN_ADD:
682 case SL::OP_ASSIGN_SUB:
683 case SL::OP_ASSIGN_MUL:
684 case SL::OP_ASSIGN_DIV:
685 case SL::OP_ASSIGN_SHIFT_LEFT:
686 case SL::OP_ASSIGN_SHIFT_RIGHT:
687 case SL::OP_ASSIGN_MOD:
688 case SL::OP_ASSIGN_BIT_AND:
689 case SL::OP_ASSIGN_BIT_OR:
690 case SL::OP_ASSIGN_BIT_XOR:
691 code = _dump_node_code(onode->arguments[0], p_level, r_gen_code, p_actions, p_default_actions, true) + _opstr(onode->op) + _dump_node_code(onode->arguments[1], p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
692 break;
693 case SL::OP_BIT_INVERT:
694 case SL::OP_NEGATE:
695 case SL::OP_NOT:
696 case SL::OP_DECREMENT:
697 case SL::OP_INCREMENT:
698 code = _opstr(onode->op) + _dump_node_code(onode->arguments[0], p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
699 break;
700 case SL::OP_POST_DECREMENT:
701 case SL::OP_POST_INCREMENT:
702 code = _dump_node_code(onode->arguments[0], p_level, r_gen_code, p_actions, p_default_actions, p_assigning) + _opstr(onode->op);
703 break;
704 case SL::OP_CALL:
705 case SL::OP_CONSTRUCT: {
706
707 ERR_FAIL_COND_V(onode->arguments[0]->type != SL::Node::TYPE_VARIABLE, String());
708
709 SL::VariableNode *vnode = (SL::VariableNode *)onode->arguments[0];
710
711 if (onode->op == SL::OP_CONSTRUCT) {
712 code += String(vnode->name);
713 } else {
714
715 if (internal_functions.has(vnode->name)) {
716 code += vnode->name;
717 } else if (p_default_actions.renames.has(vnode->name)) {
718 code += p_default_actions.renames[vnode->name];
719 } else {
720 code += _mkid(vnode->name);
721 }
722 }
723
724 code += "(";
725
726 for (int i = 1; i < onode->arguments.size(); i++) {
727 if (i > 1)
728 code += ", ";
729 code += _dump_node_code(onode->arguments[i], p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
730 }
731 code += ")";
732 } break;
733 case SL::OP_INDEX: {
734
735 code += _dump_node_code(onode->arguments[0], p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
736 code += "[";
737 code += _dump_node_code(onode->arguments[1], p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
738 code += "]";
739
740 } break;
741 case SL::OP_SELECT_IF: {
742
743 code += "(";
744 code += _dump_node_code(onode->arguments[0], p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
745 code += "?";
746 code += _dump_node_code(onode->arguments[1], p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
747 code += ":";
748 code += _dump_node_code(onode->arguments[2], p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
749 code += ")";
750
751 } break;
752
753 default: {
754 if (p_use_scope) {
755 code += "(";
756 }
757 code += _dump_node_code(onode->arguments[0], p_level, r_gen_code, p_actions, p_default_actions, p_assigning) + _opstr(onode->op) + _dump_node_code(onode->arguments[1], p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
758 if (p_use_scope) {
759 code += ")";
760 }
761 break;
762 }
763 }
764
765 } break;
766 case SL::Node::TYPE_CONTROL_FLOW: {
767 SL::ControlFlowNode *cfnode = (SL::ControlFlowNode *)p_node;
768 if (cfnode->flow_op == SL::FLOW_OP_IF) {
769
770 code += _mktab(p_level) + "if (" + _dump_node_code(cfnode->expressions[0], p_level, r_gen_code, p_actions, p_default_actions, p_assigning) + ")\n";
771 code += _dump_node_code(cfnode->blocks[0], p_level + 1, r_gen_code, p_actions, p_default_actions, p_assigning);
772 if (cfnode->blocks.size() == 2) {
773
774 code += _mktab(p_level) + "else\n";
775 code += _dump_node_code(cfnode->blocks[1], p_level + 1, r_gen_code, p_actions, p_default_actions, p_assigning);
776 }
777 } else if (cfnode->flow_op == SL::FLOW_OP_SWITCH) {
778 code += _mktab(p_level) + "switch (" + _dump_node_code(cfnode->expressions[0], p_level, r_gen_code, p_actions, p_default_actions, p_assigning) + ")\n";
779 code += _dump_node_code(cfnode->blocks[0], p_level + 1, r_gen_code, p_actions, p_default_actions, p_assigning);
780 } else if (cfnode->flow_op == SL::FLOW_OP_CASE) {
781 code += _mktab(p_level) + "case " + _dump_node_code(cfnode->expressions[0], p_level, r_gen_code, p_actions, p_default_actions, p_assigning) + ":\n";
782 code += _dump_node_code(cfnode->blocks[0], p_level + 1, r_gen_code, p_actions, p_default_actions, p_assigning);
783 } else if (cfnode->flow_op == SL::FLOW_OP_DEFAULT) {
784 code += _mktab(p_level) + "default:\n";
785 code += _dump_node_code(cfnode->blocks[0], p_level + 1, r_gen_code, p_actions, p_default_actions, p_assigning);
786 } else if (cfnode->flow_op == SL::FLOW_OP_DO) {
787 code += _mktab(p_level) + "do";
788 code += _dump_node_code(cfnode->blocks[0], p_level + 1, r_gen_code, p_actions, p_default_actions, p_assigning);
789 code += _mktab(p_level) + "while (" + _dump_node_code(cfnode->expressions[0], p_level, r_gen_code, p_actions, p_default_actions, p_assigning) + ");";
790
791 } else if (cfnode->flow_op == SL::FLOW_OP_WHILE) {
792
793 code += _mktab(p_level) + "while (" + _dump_node_code(cfnode->expressions[0], p_level, r_gen_code, p_actions, p_default_actions, p_assigning) + ")\n";
794 code += _dump_node_code(cfnode->blocks[0], p_level + 1, r_gen_code, p_actions, p_default_actions, p_assigning);
795 } else if (cfnode->flow_op == SL::FLOW_OP_FOR) {
796
797 String left = _dump_node_code(cfnode->blocks[0], p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
798 String middle = _dump_node_code(cfnode->expressions[0], p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
799 String right = _dump_node_code(cfnode->expressions[1], p_level, r_gen_code, p_actions, p_default_actions, p_assigning);
800 code += _mktab(p_level) + "for (" + left + ";" + middle + ";" + right + ")\n";
801 code += _dump_node_code(cfnode->blocks[1], p_level + 1, r_gen_code, p_actions, p_default_actions, p_assigning);
802
803 } else if (cfnode->flow_op == SL::FLOW_OP_RETURN) {
804
805 if (cfnode->expressions.size()) {
806 code = "return " + _dump_node_code(cfnode->expressions[0], p_level, r_gen_code, p_actions, p_default_actions, p_assigning) + ";";
807 } else {
808 code = "return;";
809 }
810 } else if (cfnode->flow_op == SL::FLOW_OP_DISCARD) {
811
812 if (p_actions.usage_flag_pointers.has("DISCARD") && !used_flag_pointers.has("DISCARD")) {
813 *p_actions.usage_flag_pointers["DISCARD"] = true;
814 used_flag_pointers.insert("DISCARD");
815 }
816
817 code = "discard;";
818 } else if (cfnode->flow_op == SL::FLOW_OP_CONTINUE) {
819
820 code = "continue;";
821 } else if (cfnode->flow_op == SL::FLOW_OP_BREAK) {
822
823 code = "break;";
824 }
825
826 } break;
827 case SL::Node::TYPE_MEMBER: {
828 SL::MemberNode *mnode = (SL::MemberNode *)p_node;
829 code = _dump_node_code(mnode->owner, p_level, r_gen_code, p_actions, p_default_actions, p_assigning) + "." + mnode->name;
830
831 } break;
832 }
833
834 return code;
835 }
836
compile(VS::ShaderMode p_mode,const String & p_code,IdentifierActions * p_actions,const String & p_path,GeneratedCode & r_gen_code)837 Error ShaderCompilerGLES3::compile(VS::ShaderMode p_mode, const String &p_code, IdentifierActions *p_actions, const String &p_path, GeneratedCode &r_gen_code) {
838
839 Error err = parser.compile(p_code, ShaderTypes::get_singleton()->get_functions(p_mode), ShaderTypes::get_singleton()->get_modes(p_mode), ShaderTypes::get_singleton()->get_types());
840
841 if (err != OK) {
842
843 Vector<String> shader = p_code.split("\n");
844 for (int i = 0; i < shader.size(); i++) {
845 print_line(itos(i + 1) + " " + shader[i]);
846 }
847
848 _err_print_error(NULL, p_path.utf8().get_data(), parser.get_error_line(), parser.get_error_text().utf8().get_data(), ERR_HANDLER_SHADER);
849 return err;
850 }
851
852 r_gen_code.defines.clear();
853 r_gen_code.vertex = String();
854 r_gen_code.vertex_global = String();
855 r_gen_code.fragment = String();
856 r_gen_code.fragment_global = String();
857 r_gen_code.light = String();
858 r_gen_code.uses_fragment_time = false;
859 r_gen_code.uses_vertex_time = false;
860
861 used_name_defines.clear();
862 used_rmode_defines.clear();
863 used_flag_pointers.clear();
864
865 _dump_node_code(parser.get_shader(), 1, r_gen_code, *p_actions, actions[p_mode], false);
866
867 if (r_gen_code.uniform_total_size) { //uniforms used?
868 int md = sizeof(float) * 4;
869 if (r_gen_code.uniform_total_size % md) {
870 r_gen_code.uniform_total_size += md - (r_gen_code.uniform_total_size % md);
871 }
872 r_gen_code.uniform_total_size += md; //pad just in case
873 }
874
875 return OK;
876 }
877
ShaderCompilerGLES3()878 ShaderCompilerGLES3::ShaderCompilerGLES3() {
879
880 /** CANVAS ITEM SHADER **/
881
882 actions[VS::SHADER_CANVAS_ITEM].renames["VERTEX"] = "outvec.xy";
883 actions[VS::SHADER_CANVAS_ITEM].renames["UV"] = "uv";
884 actions[VS::SHADER_CANVAS_ITEM].renames["POINT_SIZE"] = "point_size";
885
886 actions[VS::SHADER_CANVAS_ITEM].renames["WORLD_MATRIX"] = "modelview_matrix";
887 actions[VS::SHADER_CANVAS_ITEM].renames["PROJECTION_MATRIX"] = "projection_matrix";
888 actions[VS::SHADER_CANVAS_ITEM].renames["EXTRA_MATRIX"] = "extra_matrix";
889 actions[VS::SHADER_CANVAS_ITEM].renames["TIME"] = "time";
890 actions[VS::SHADER_CANVAS_ITEM].renames["AT_LIGHT_PASS"] = "at_light_pass";
891 actions[VS::SHADER_CANVAS_ITEM].renames["INSTANCE_CUSTOM"] = "instance_custom";
892
893 actions[VS::SHADER_CANVAS_ITEM].renames["COLOR"] = "color";
894 actions[VS::SHADER_CANVAS_ITEM].renames["MODULATE"] = "final_modulate";
895 actions[VS::SHADER_CANVAS_ITEM].renames["NORMAL"] = "normal";
896 actions[VS::SHADER_CANVAS_ITEM].renames["NORMALMAP"] = "normal_map";
897 actions[VS::SHADER_CANVAS_ITEM].renames["NORMALMAP_DEPTH"] = "normal_depth";
898 actions[VS::SHADER_CANVAS_ITEM].renames["TEXTURE"] = "color_texture";
899 actions[VS::SHADER_CANVAS_ITEM].renames["TEXTURE_PIXEL_SIZE"] = "color_texpixel_size";
900 actions[VS::SHADER_CANVAS_ITEM].renames["NORMAL_TEXTURE"] = "normal_texture";
901 actions[VS::SHADER_CANVAS_ITEM].renames["SCREEN_UV"] = "screen_uv";
902 actions[VS::SHADER_CANVAS_ITEM].renames["SCREEN_TEXTURE"] = "screen_texture";
903 actions[VS::SHADER_CANVAS_ITEM].renames["SCREEN_PIXEL_SIZE"] = "screen_pixel_size";
904 actions[VS::SHADER_CANVAS_ITEM].renames["FRAGCOORD"] = "gl_FragCoord";
905 actions[VS::SHADER_CANVAS_ITEM].renames["POINT_COORD"] = "gl_PointCoord";
906
907 actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_VEC"] = "light_vec";
908 actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_HEIGHT"] = "light_height";
909 actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_COLOR"] = "light_color";
910 actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT_UV"] = "light_uv";
911 actions[VS::SHADER_CANVAS_ITEM].renames["LIGHT"] = "light";
912 actions[VS::SHADER_CANVAS_ITEM].renames["SHADOW_COLOR"] = "shadow_color";
913 actions[VS::SHADER_CANVAS_ITEM].renames["SHADOW_VEC"] = "shadow_vec";
914
915 actions[VS::SHADER_CANVAS_ITEM].usage_defines["COLOR"] = "#define COLOR_USED\n";
916 actions[VS::SHADER_CANVAS_ITEM].usage_defines["MODULATE"] = "#define MODULATE_USED\n";
917 actions[VS::SHADER_CANVAS_ITEM].usage_defines["SCREEN_TEXTURE"] = "#define SCREEN_TEXTURE_USED\n";
918 actions[VS::SHADER_CANVAS_ITEM].usage_defines["SCREEN_UV"] = "#define SCREEN_UV_USED\n";
919 actions[VS::SHADER_CANVAS_ITEM].usage_defines["SCREEN_PIXEL_SIZE"] = "@SCREEN_UV";
920 actions[VS::SHADER_CANVAS_ITEM].usage_defines["NORMAL"] = "#define NORMAL_USED\n";
921 actions[VS::SHADER_CANVAS_ITEM].usage_defines["NORMALMAP"] = "#define NORMALMAP_USED\n";
922 actions[VS::SHADER_CANVAS_ITEM].usage_defines["LIGHT"] = "#define USE_LIGHT_SHADER_CODE\n";
923 actions[VS::SHADER_CANVAS_ITEM].usage_defines["SHADOW_VEC"] = "#define SHADOW_VEC_USED\n";
924 actions[VS::SHADER_CANVAS_ITEM].render_mode_defines["skip_vertex_transform"] = "#define SKIP_TRANSFORM_USED\n";
925
926 /** SPATIAL SHADER **/
927
928 actions[VS::SHADER_SPATIAL].renames["WORLD_MATRIX"] = "world_transform";
929 actions[VS::SHADER_SPATIAL].renames["INV_CAMERA_MATRIX"] = "camera_inverse_matrix";
930 actions[VS::SHADER_SPATIAL].renames["CAMERA_MATRIX"] = "camera_matrix";
931 actions[VS::SHADER_SPATIAL].renames["PROJECTION_MATRIX"] = "projection_matrix";
932 actions[VS::SHADER_SPATIAL].renames["INV_PROJECTION_MATRIX"] = "inv_projection_matrix";
933 actions[VS::SHADER_SPATIAL].renames["MODELVIEW_MATRIX"] = "modelview";
934
935 actions[VS::SHADER_SPATIAL].renames["VERTEX"] = "vertex.xyz";
936 actions[VS::SHADER_SPATIAL].renames["NORMAL"] = "normal";
937 actions[VS::SHADER_SPATIAL].renames["TANGENT"] = "tangent";
938 actions[VS::SHADER_SPATIAL].renames["BINORMAL"] = "binormal";
939 actions[VS::SHADER_SPATIAL].renames["POSITION"] = "position";
940 actions[VS::SHADER_SPATIAL].renames["UV"] = "uv_interp";
941 actions[VS::SHADER_SPATIAL].renames["UV2"] = "uv2_interp";
942 actions[VS::SHADER_SPATIAL].renames["COLOR"] = "color_interp";
943 actions[VS::SHADER_SPATIAL].renames["POINT_SIZE"] = "point_size";
944 actions[VS::SHADER_SPATIAL].renames["INSTANCE_ID"] = "gl_InstanceID";
945
946 //builtins
947
948 actions[VS::SHADER_SPATIAL].renames["TIME"] = "time";
949 actions[VS::SHADER_SPATIAL].renames["VIEWPORT_SIZE"] = "viewport_size";
950
951 actions[VS::SHADER_SPATIAL].renames["FRAGCOORD"] = "gl_FragCoord";
952 actions[VS::SHADER_SPATIAL].renames["FRONT_FACING"] = "gl_FrontFacing";
953 actions[VS::SHADER_SPATIAL].renames["NORMALMAP"] = "normalmap";
954 actions[VS::SHADER_SPATIAL].renames["NORMALMAP_DEPTH"] = "normaldepth";
955 actions[VS::SHADER_SPATIAL].renames["ALBEDO"] = "albedo";
956 actions[VS::SHADER_SPATIAL].renames["ALPHA"] = "alpha";
957 actions[VS::SHADER_SPATIAL].renames["METALLIC"] = "metallic";
958 actions[VS::SHADER_SPATIAL].renames["SPECULAR"] = "specular";
959 actions[VS::SHADER_SPATIAL].renames["ROUGHNESS"] = "roughness";
960 actions[VS::SHADER_SPATIAL].renames["RIM"] = "rim";
961 actions[VS::SHADER_SPATIAL].renames["RIM_TINT"] = "rim_tint";
962 actions[VS::SHADER_SPATIAL].renames["CLEARCOAT"] = "clearcoat";
963 actions[VS::SHADER_SPATIAL].renames["CLEARCOAT_GLOSS"] = "clearcoat_gloss";
964 actions[VS::SHADER_SPATIAL].renames["ANISOTROPY"] = "anisotropy";
965 actions[VS::SHADER_SPATIAL].renames["ANISOTROPY_FLOW"] = "anisotropy_flow";
966 actions[VS::SHADER_SPATIAL].renames["SSS_STRENGTH"] = "sss_strength";
967 actions[VS::SHADER_SPATIAL].renames["TRANSMISSION"] = "transmission";
968 actions[VS::SHADER_SPATIAL].renames["AO"] = "ao";
969 actions[VS::SHADER_SPATIAL].renames["AO_LIGHT_AFFECT"] = "ao_light_affect";
970 actions[VS::SHADER_SPATIAL].renames["EMISSION"] = "emission";
971 actions[VS::SHADER_SPATIAL].renames["POINT_COORD"] = "gl_PointCoord";
972 actions[VS::SHADER_SPATIAL].renames["INSTANCE_CUSTOM"] = "instance_custom";
973 actions[VS::SHADER_SPATIAL].renames["SCREEN_UV"] = "screen_uv";
974 actions[VS::SHADER_SPATIAL].renames["SCREEN_TEXTURE"] = "screen_texture";
975 actions[VS::SHADER_SPATIAL].renames["DEPTH_TEXTURE"] = "depth_buffer";
976 actions[VS::SHADER_SPATIAL].renames["DEPTH"] = "gl_FragDepth";
977 actions[VS::SHADER_SPATIAL].renames["ALPHA_SCISSOR"] = "alpha_scissor";
978 actions[VS::SHADER_SPATIAL].renames["OUTPUT_IS_SRGB"] = "SHADER_IS_SRGB";
979
980 //for light
981 actions[VS::SHADER_SPATIAL].renames["VIEW"] = "view";
982 actions[VS::SHADER_SPATIAL].renames["LIGHT_COLOR"] = "light_color";
983 actions[VS::SHADER_SPATIAL].renames["LIGHT"] = "light";
984 actions[VS::SHADER_SPATIAL].renames["ATTENUATION"] = "attenuation";
985 actions[VS::SHADER_SPATIAL].renames["DIFFUSE_LIGHT"] = "diffuse_light";
986 actions[VS::SHADER_SPATIAL].renames["SPECULAR_LIGHT"] = "specular_light";
987
988 actions[VS::SHADER_SPATIAL].usage_defines["TANGENT"] = "#define ENABLE_TANGENT_INTERP\n";
989 actions[VS::SHADER_SPATIAL].usage_defines["BINORMAL"] = "@TANGENT";
990 actions[VS::SHADER_SPATIAL].usage_defines["RIM"] = "#define LIGHT_USE_RIM\n";
991 actions[VS::SHADER_SPATIAL].usage_defines["RIM_TINT"] = "@RIM";
992 actions[VS::SHADER_SPATIAL].usage_defines["CLEARCOAT"] = "#define LIGHT_USE_CLEARCOAT\n";
993 actions[VS::SHADER_SPATIAL].usage_defines["CLEARCOAT_GLOSS"] = "@CLEARCOAT";
994 actions[VS::SHADER_SPATIAL].usage_defines["ANISOTROPY"] = "#define LIGHT_USE_ANISOTROPY\n";
995 actions[VS::SHADER_SPATIAL].usage_defines["ANISOTROPY_FLOW"] = "@ANISOTROPY";
996 actions[VS::SHADER_SPATIAL].usage_defines["AO"] = "#define ENABLE_AO\n";
997 actions[VS::SHADER_SPATIAL].usage_defines["AO_LIGHT_AFFECT"] = "#define ENABLE_AO\n";
998 actions[VS::SHADER_SPATIAL].usage_defines["UV"] = "#define ENABLE_UV_INTERP\n";
999 actions[VS::SHADER_SPATIAL].usage_defines["UV2"] = "#define ENABLE_UV2_INTERP\n";
1000 actions[VS::SHADER_SPATIAL].usage_defines["NORMALMAP"] = "#define ENABLE_NORMALMAP\n";
1001 actions[VS::SHADER_SPATIAL].usage_defines["NORMALMAP_DEPTH"] = "@NORMALMAP";
1002 actions[VS::SHADER_SPATIAL].usage_defines["COLOR"] = "#define ENABLE_COLOR_INTERP\n";
1003 actions[VS::SHADER_SPATIAL].usage_defines["INSTANCE_CUSTOM"] = "#define ENABLE_INSTANCE_CUSTOM\n";
1004 actions[VS::SHADER_SPATIAL].usage_defines["ALPHA_SCISSOR"] = "#define ALPHA_SCISSOR_USED\n";
1005 actions[VS::SHADER_SPATIAL].usage_defines["POSITION"] = "#define OVERRIDE_POSITION\n";
1006
1007 actions[VS::SHADER_SPATIAL].usage_defines["SSS_STRENGTH"] = "#define ENABLE_SSS\n";
1008 actions[VS::SHADER_SPATIAL].usage_defines["TRANSMISSION"] = "#define TRANSMISSION_USED\n";
1009 actions[VS::SHADER_SPATIAL].usage_defines["SCREEN_TEXTURE"] = "#define SCREEN_TEXTURE_USED\n";
1010 actions[VS::SHADER_SPATIAL].usage_defines["SCREEN_UV"] = "#define SCREEN_UV_USED\n";
1011
1012 actions[VS::SHADER_SPATIAL].usage_defines["DIFFUSE_LIGHT"] = "#define USE_LIGHT_SHADER_CODE\n";
1013 actions[VS::SHADER_SPATIAL].usage_defines["SPECULAR_LIGHT"] = "#define USE_LIGHT_SHADER_CODE\n";
1014
1015 actions[VS::SHADER_SPATIAL].render_mode_defines["skip_vertex_transform"] = "#define SKIP_TRANSFORM_USED\n";
1016 actions[VS::SHADER_SPATIAL].render_mode_defines["world_vertex_coords"] = "#define VERTEX_WORLD_COORDS_USED\n";
1017 actions[VS::SHADER_SPATIAL].render_mode_defines["ensure_correct_normals"] = "#define ENSURE_CORRECT_NORMALS\n";
1018 actions[VS::SHADER_SPATIAL].render_mode_defines["cull_front"] = "#define DO_SIDE_CHECK\n";
1019 actions[VS::SHADER_SPATIAL].render_mode_defines["cull_disabled"] = "#define DO_SIDE_CHECK\n";
1020
1021 bool force_lambert = GLOBAL_GET("rendering/quality/shading/force_lambert_over_burley");
1022
1023 if (!force_lambert) {
1024 actions[VS::SHADER_SPATIAL].render_mode_defines["diffuse_burley"] = "#define DIFFUSE_BURLEY\n";
1025 }
1026
1027 actions[VS::SHADER_SPATIAL].render_mode_defines["diffuse_oren_nayar"] = "#define DIFFUSE_OREN_NAYAR\n";
1028 actions[VS::SHADER_SPATIAL].render_mode_defines["diffuse_lambert_wrap"] = "#define DIFFUSE_LAMBERT_WRAP\n";
1029 actions[VS::SHADER_SPATIAL].render_mode_defines["diffuse_toon"] = "#define DIFFUSE_TOON\n";
1030
1031 bool force_blinn = GLOBAL_GET("rendering/quality/shading/force_blinn_over_ggx");
1032
1033 if (!force_blinn) {
1034 actions[VS::SHADER_SPATIAL].render_mode_defines["specular_schlick_ggx"] = "#define SPECULAR_SCHLICK_GGX\n";
1035 } else {
1036 actions[VS::SHADER_SPATIAL].render_mode_defines["specular_schlick_ggx"] = "#define SPECULAR_BLINN\n";
1037 }
1038
1039 actions[VS::SHADER_SPATIAL].render_mode_defines["specular_blinn"] = "#define SPECULAR_BLINN\n";
1040 actions[VS::SHADER_SPATIAL].render_mode_defines["specular_phong"] = "#define SPECULAR_PHONG\n";
1041 actions[VS::SHADER_SPATIAL].render_mode_defines["specular_toon"] = "#define SPECULAR_TOON\n";
1042 actions[VS::SHADER_SPATIAL].render_mode_defines["specular_disabled"] = "#define SPECULAR_DISABLED\n";
1043 actions[VS::SHADER_SPATIAL].render_mode_defines["shadows_disabled"] = "#define SHADOWS_DISABLED\n";
1044 actions[VS::SHADER_SPATIAL].render_mode_defines["ambient_light_disabled"] = "#define AMBIENT_LIGHT_DISABLED\n";
1045 actions[VS::SHADER_SPATIAL].render_mode_defines["shadow_to_opacity"] = "#define USE_SHADOW_TO_OPACITY\n";
1046
1047 /* PARTICLES SHADER */
1048
1049 actions[VS::SHADER_PARTICLES].renames["COLOR"] = "out_color";
1050 actions[VS::SHADER_PARTICLES].renames["VELOCITY"] = "out_velocity_active.xyz";
1051 actions[VS::SHADER_PARTICLES].renames["MASS"] = "mass";
1052 actions[VS::SHADER_PARTICLES].renames["ACTIVE"] = "shader_active";
1053 actions[VS::SHADER_PARTICLES].renames["RESTART"] = "restart";
1054 actions[VS::SHADER_PARTICLES].renames["CUSTOM"] = "out_custom";
1055 actions[VS::SHADER_PARTICLES].renames["TRANSFORM"] = "xform";
1056 actions[VS::SHADER_PARTICLES].renames["TIME"] = "time";
1057 actions[VS::SHADER_PARTICLES].renames["LIFETIME"] = "lifetime";
1058 actions[VS::SHADER_PARTICLES].renames["DELTA"] = "local_delta";
1059 actions[VS::SHADER_PARTICLES].renames["NUMBER"] = "particle_number";
1060 actions[VS::SHADER_PARTICLES].renames["INDEX"] = "index";
1061 actions[VS::SHADER_PARTICLES].renames["GRAVITY"] = "current_gravity";
1062 actions[VS::SHADER_PARTICLES].renames["EMISSION_TRANSFORM"] = "emission_transform";
1063 actions[VS::SHADER_PARTICLES].renames["RANDOM_SEED"] = "random_seed";
1064
1065 actions[VS::SHADER_PARTICLES].render_mode_defines["disable_force"] = "#define DISABLE_FORCE\n";
1066 actions[VS::SHADER_PARTICLES].render_mode_defines["disable_velocity"] = "#define DISABLE_VELOCITY\n";
1067 actions[VS::SHADER_PARTICLES].render_mode_defines["keep_data"] = "#define ENABLE_KEEP_DATA\n";
1068
1069 vertex_name = "vertex";
1070 fragment_name = "fragment";
1071 light_name = "light";
1072 time_name = "TIME";
1073
1074 List<String> func_list;
1075
1076 ShaderLanguage::get_builtin_funcs(&func_list);
1077
1078 for (List<String>::Element *E = func_list.front(); E; E = E->next()) {
1079 internal_functions.insert(E->get());
1080 }
1081 }
1082