CoCalc -- material

GitHub Repository: godotengine/godot
Path: blob/master/drivers/gles3/storage/material_storage.cpp
¹⁰⁰⁰⁵ views
1
/**************************************************************************/
2
/*  material_storage.cpp                                                  */
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

31
#ifdef GLES3_ENABLED
32

33
#include "core/config/project_settings.h"
34

35
#include "config.h"
36
#include "material_storage.h"
37
#include "particles_storage.h"
38
#include "texture_storage.h"
39

40
#include "drivers/gles3/rasterizer_canvas_gles3.h"
41
#include "drivers/gles3/rasterizer_gles3.h"
42
#include "servers/rendering/storage/variant_converters.h"
43

44
using namespace GLES3;
45

46
///////////////////////////////////////////////////////////////////////////
47
// UBI helper functions
48

49
static void _fill_std140_variant_ubo_value(ShaderLanguage::DataType type, int p_array_size, const Variant &value, uint8_t *data) {
50
	switch (type) {
51
		case ShaderLanguage::TYPE_BOOL: {
52
			uint32_t *gui = (uint32_t *)data;
53

54
			if (p_array_size > 0) {
55
				PackedInt32Array ba = value;
56
				for (int i = 0; i < ba.size(); i++) {
57
					ba.set(i, ba[i] ? 1 : 0);
58
				}
59
				write_array_std140<int32_t>(ba, gui, p_array_size, 4);
60
			} else {
61
				bool v = value;
62
				gui[0] = v ? 1 : 0;
63
			}
64
		} break;
65
		case ShaderLanguage::TYPE_BVEC2: {
66
			uint32_t *gui = (uint32_t *)data;
67

68
			if (p_array_size > 0) {
69
				PackedInt32Array ba = convert_array_std140<Vector2i, int32_t>(value);
70
				for (int i = 0; i < ba.size(); i++) {
71
					ba.set(i, ba[i] ? 1 : 0);
72
				}
73
				write_array_std140<Vector2i>(ba, gui, p_array_size, 4);
74
			} else {
75
				uint32_t v = value;
76
				gui[0] = v & 1 ? 1 : 0;
77
				gui[1] = v & 2 ? 1 : 0;
78
			}
79
		} break;
80
		case ShaderLanguage::TYPE_BVEC3: {
81
			uint32_t *gui = (uint32_t *)data;
82

83
			if (p_array_size > 0) {
84
				PackedInt32Array ba = convert_array_std140<Vector3i, int32_t>(value);
85
				for (int i = 0; i < ba.size(); i++) {
86
					ba.set(i, ba[i] ? 1 : 0);
87
				}
88
				write_array_std140<Vector3i>(ba, gui, p_array_size, 4);
89
			} else {
90
				uint32_t v = value;
91
				gui[0] = (v & 1) ? 1 : 0;
92
				gui[1] = (v & 2) ? 1 : 0;
93
				gui[2] = (v & 4) ? 1 : 0;
94
			}
95
		} break;
96
		case ShaderLanguage::TYPE_BVEC4: {
97
			uint32_t *gui = (uint32_t *)data;
98

99
			if (p_array_size > 0) {
100
				PackedInt32Array ba = convert_array_std140<Vector4i, int32_t>(value);
101
				for (int i = 0; i < ba.size(); i++) {
102
					ba.set(i, ba[i] ? 1 : 0);
103
				}
104
				write_array_std140<Vector4i>(ba, gui, p_array_size, 4);
105
			} else {
106
				uint32_t v = value;
107
				gui[0] = (v & 1) ? 1 : 0;
108
				gui[1] = (v & 2) ? 1 : 0;
109
				gui[2] = (v & 4) ? 1 : 0;
110
				gui[3] = (v & 8) ? 1 : 0;
111
			}
112
		} break;
113
		case ShaderLanguage::TYPE_INT: {
114
			int32_t *gui = (int32_t *)data;
115

116
			if (p_array_size > 0) {
117
				const PackedInt32Array &iv = value;
118
				write_array_std140<int32_t>(iv, gui, p_array_size, 4);
119
			} else {
120
				int v = value;
121
				gui[0] = v;
122
			}
123
		} break;
124
		case ShaderLanguage::TYPE_IVEC2: {
125
			int32_t *gui = (int32_t *)data;
126

127
			if (p_array_size > 0) {
128
				const PackedInt32Array &iv = convert_array_std140<Vector2i, int32_t>(value);
129
				write_array_std140<Vector2i>(iv, gui, p_array_size, 4);
130
			} else {
131
				Vector2i v = convert_to_vector<Vector2i>(value);
132
				gui[0] = v.x;
133
				gui[1] = v.y;
134
			}
135
		} break;
136
		case ShaderLanguage::TYPE_IVEC3: {
137
			int32_t *gui = (int32_t *)data;
138

139
			if (p_array_size > 0) {
140
				const PackedInt32Array &iv = convert_array_std140<Vector3i, int32_t>(value);
141
				write_array_std140<Vector3i>(iv, gui, p_array_size, 4);
142
			} else {
143
				Vector3i v = convert_to_vector<Vector3i>(value);
144
				gui[0] = v.x;
145
				gui[1] = v.y;
146
				gui[2] = v.z;
147
			}
148
		} break;
149
		case ShaderLanguage::TYPE_IVEC4: {
150
			int32_t *gui = (int32_t *)data;
151

152
			if (p_array_size > 0) {
153
				const PackedInt32Array &iv = convert_array_std140<Vector4i, int32_t>(value);
154
				write_array_std140<Vector4i>(iv, gui, p_array_size, 4);
155
			} else {
156
				Vector4i v = convert_to_vector<Vector4i>(value);
157
				gui[0] = v.x;
158
				gui[1] = v.y;
159
				gui[2] = v.z;
160
				gui[3] = v.w;
161
			}
162
		} break;
163
		case ShaderLanguage::TYPE_UINT: {
164
			uint32_t *gui = (uint32_t *)data;
165

166
			if (p_array_size > 0) {
167
				const PackedInt32Array &iv = value;
168
				write_array_std140<uint32_t>(iv, gui, p_array_size, 4);
169
			} else {
170
				int v = value;
171
				gui[0] = v;
172
			}
173
		} break;
174
		case ShaderLanguage::TYPE_UVEC2: {
175
			uint32_t *gui = (uint32_t *)data;
176

177
			if (p_array_size > 0) {
178
				const PackedInt32Array &iv = convert_array_std140<Vector2i, int32_t>(value);
179
				write_array_std140<Vector2i>(iv, gui, p_array_size, 4);
180
			} else {
181
				Vector2i v = convert_to_vector<Vector2i>(value);
182
				gui[0] = v.x;
183
				gui[1] = v.y;
184
			}
185
		} break;
186
		case ShaderLanguage::TYPE_UVEC3: {
187
			uint32_t *gui = (uint32_t *)data;
188

189
			if (p_array_size > 0) {
190
				const PackedInt32Array &iv = convert_array_std140<Vector3i, int32_t>(value);
191
				write_array_std140<Vector3i>(iv, gui, p_array_size, 4);
192
			} else {
193
				Vector3i v = convert_to_vector<Vector3i>(value);
194
				gui[0] = v.x;
195
				gui[1] = v.y;
196
				gui[2] = v.z;
197
			}
198
		} break;
199
		case ShaderLanguage::TYPE_UVEC4: {
200
			uint32_t *gui = (uint32_t *)data;
201

202
			if (p_array_size > 0) {
203
				const PackedInt32Array &iv = convert_array_std140<Vector4i, int32_t>(value);
204
				write_array_std140<Vector4i>(iv, gui, p_array_size, 4);
205
			} else {
206
				Vector4i v = convert_to_vector<Vector4i>(value);
207
				gui[0] = v.x;
208
				gui[1] = v.y;
209
				gui[2] = v.z;
210
				gui[3] = v.w;
211
			}
212
		} break;
213
		case ShaderLanguage::TYPE_FLOAT: {
214
			float *gui = (float *)data;
215

216
			if (p_array_size > 0) {
217
				const PackedFloat32Array &a = value;
218
				write_array_std140<float>(a, gui, p_array_size, 4);
219
			} else {
220
				float v = value;
221
				gui[0] = v;
222
			}
223
		} break;
224
		case ShaderLanguage::TYPE_VEC2: {
225
			float *gui = (float *)data;
226

227
			if (p_array_size > 0) {
228
				const PackedFloat32Array &a = convert_array_std140<Vector2, float>(value);
229
				write_array_std140<Vector2>(a, gui, p_array_size, 4);
230
			} else {
231
				Vector2 v = convert_to_vector<Vector2>(value);
232
				gui[0] = v.x;
233
				gui[1] = v.y;
234
			}
235
		} break;
236
		case ShaderLanguage::TYPE_VEC3: {
237
			float *gui = (float *)data;
238

239
			if (p_array_size > 0) {
240
				const PackedFloat32Array &a = convert_array_std140<Vector3, float>(value);
241
				write_array_std140<Vector3>(a, gui, p_array_size, 4);
242
			} else {
243
				Vector3 v = convert_to_vector<Vector3>(value);
244
				gui[0] = v.x;
245
				gui[1] = v.y;
246
				gui[2] = v.z;
247
			}
248
		} break;
249
		case ShaderLanguage::TYPE_VEC4: {
250
			float *gui = (float *)data;
251

252
			if (p_array_size > 0) {
253
				const PackedFloat32Array &a = convert_array_std140<Vector4, float>(value);
254
				write_array_std140<Vector4>(a, gui, p_array_size, 4);
255
			} else {
256
				Vector4 v = convert_to_vector<Vector4>(value);
257
				gui[0] = v.x;
258
				gui[1] = v.y;
259
				gui[2] = v.z;
260
				gui[3] = v.w;
261
			}
262
		} break;
263
		case ShaderLanguage::TYPE_MAT2: {
264
			float *gui = (float *)data;
265

266
			if (p_array_size > 0) {
267
				const PackedFloat32Array &a = value;
268
				int s = a.size();
269

270
				for (int i = 0, j = 0; i < p_array_size * 4; i += 4, j += 8) {
271
					if (i + 3 < s) {
272
						gui[j] = a[i];
273
						gui[j + 1] = a[i + 1];
274

275
						gui[j + 4] = a[i + 2];
276
						gui[j + 5] = a[i + 3];
277
					} else {
278
						gui[j] = 1;
279
						gui[j + 1] = 0;
280

281
						gui[j + 4] = 0;
282
						gui[j + 5] = 1;
283
					}
284
					gui[j + 2] = 0; // ignored
285
					gui[j + 3] = 0; // ignored
286
					gui[j + 6] = 0; // ignored
287
					gui[j + 7] = 0; // ignored
288
				}
289
			} else {
290
				Transform2D v = value;
291

292
				//in std140 members of mat2 are treated as vec4s
293
				gui[0] = v.columns[0][0];
294
				gui[1] = v.columns[0][1];
295
				gui[2] = 0; // ignored
296
				gui[3] = 0; // ignored
297

298
				gui[4] = v.columns[1][0];
299
				gui[5] = v.columns[1][1];
300
				gui[6] = 0; // ignored
301
				gui[7] = 0; // ignored
302
			}
303
		} break;
304
		case ShaderLanguage::TYPE_MAT3: {
305
			float *gui = (float *)data;
306

307
			if (p_array_size > 0) {
308
				const PackedFloat32Array &a = convert_array_std140<Basis, float>(value);
309
				const Basis default_basis;
310
				const int s = a.size();
311

312
				for (int i = 0, j = 0; i < p_array_size * 9; i += 9, j += 12) {
313
					if (i + 8 < s) {
314
						gui[j] = a[i];
315
						gui[j + 1] = a[i + 1];
316
						gui[j + 2] = a[i + 2];
317
						gui[j + 3] = 0; // Ignored.
318

319
						gui[j + 4] = a[i + 3];
320
						gui[j + 5] = a[i + 4];
321
						gui[j + 6] = a[i + 5];
322
						gui[j + 7] = 0; // Ignored.
323

324
						gui[j + 8] = a[i + 6];
325
						gui[j + 9] = a[i + 7];
326
						gui[j + 10] = a[i + 8];
327
						gui[j + 11] = 0; // Ignored.
328
					} else {
329
						convert_item_std140(default_basis, gui + j);
330
					}
331
				}
332
			} else {
333
				convert_item_std140<Basis>(value, gui);
334
			}
335
		} break;
336
		case ShaderLanguage::TYPE_MAT4: {
337
			float *gui = (float *)data;
338

339
			if (p_array_size > 0) {
340
				const PackedFloat32Array &a = convert_array_std140<Projection, float>(value);
341
				write_array_std140<Projection>(a, gui, p_array_size, 16);
342
			} else {
343
				convert_item_std140<Projection>(value, gui);
344
			}
345
		} break;
346
		default: {
347
		}
348
	}
349
}
350

351
_FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type, const Vector<ShaderLanguage::Scalar> &value, uint8_t *data) {
352
	switch (type) {
353
		case ShaderLanguage::TYPE_BOOL: {
354
			uint32_t *gui = (uint32_t *)data;
355
			gui[0] = value[0].boolean ? 1 : 0;
356
		} break;
357
		case ShaderLanguage::TYPE_BVEC2: {
358
			uint32_t *gui = (uint32_t *)data;
359
			gui[0] = value[0].boolean ? 1 : 0;
360
			gui[1] = value[1].boolean ? 1 : 0;
361

362
		} break;
363
		case ShaderLanguage::TYPE_BVEC3: {
364
			uint32_t *gui = (uint32_t *)data;
365
			gui[0] = value[0].boolean ? 1 : 0;
366
			gui[1] = value[1].boolean ? 1 : 0;
367
			gui[2] = value[2].boolean ? 1 : 0;
368

369
		} break;
370
		case ShaderLanguage::TYPE_BVEC4: {
371
			uint32_t *gui = (uint32_t *)data;
372
			gui[0] = value[0].boolean ? 1 : 0;
373
			gui[1] = value[1].boolean ? 1 : 0;
374
			gui[2] = value[2].boolean ? 1 : 0;
375
			gui[3] = value[3].boolean ? 1 : 0;
376

377
		} break;
378
		case ShaderLanguage::TYPE_INT: {
379
			int32_t *gui = (int32_t *)data;
380
			gui[0] = value[0].sint;
381

382
		} break;
383
		case ShaderLanguage::TYPE_IVEC2: {
384
			int32_t *gui = (int32_t *)data;
385

386
			for (int i = 0; i < 2; i++) {
387
				gui[i] = value[i].sint;
388
			}
389

390
		} break;
391
		case ShaderLanguage::TYPE_IVEC3: {
392
			int32_t *gui = (int32_t *)data;
393

394
			for (int i = 0; i < 3; i++) {
395
				gui[i] = value[i].sint;
396
			}
397

398
		} break;
399
		case ShaderLanguage::TYPE_IVEC4: {
400
			int32_t *gui = (int32_t *)data;
401

402
			for (int i = 0; i < 4; i++) {
403
				gui[i] = value[i].sint;
404
			}
405

406
		} break;
407
		case ShaderLanguage::TYPE_UINT: {
408
			uint32_t *gui = (uint32_t *)data;
409
			gui[0] = value[0].uint;
410

411
		} break;
412
		case ShaderLanguage::TYPE_UVEC2: {
413
			int32_t *gui = (int32_t *)data;
414

415
			for (int i = 0; i < 2; i++) {
416
				gui[i] = value[i].uint;
417
			}
418
		} break;
419
		case ShaderLanguage::TYPE_UVEC3: {
420
			int32_t *gui = (int32_t *)data;
421

422
			for (int i = 0; i < 3; i++) {
423
				gui[i] = value[i].uint;
424
			}
425

426
		} break;
427
		case ShaderLanguage::TYPE_UVEC4: {
428
			int32_t *gui = (int32_t *)data;
429

430
			for (int i = 0; i < 4; i++) {
431
				gui[i] = value[i].uint;
432
			}
433
		} break;
434
		case ShaderLanguage::TYPE_FLOAT: {
435
			float *gui = (float *)data;
436
			gui[0] = value[0].real;
437

438
		} break;
439
		case ShaderLanguage::TYPE_VEC2: {
440
			float *gui = (float *)data;
441

442
			for (int i = 0; i < 2; i++) {
443
				gui[i] = value[i].real;
444
			}
445

446
		} break;
447
		case ShaderLanguage::TYPE_VEC3: {
448
			float *gui = (float *)data;
449

450
			for (int i = 0; i < 3; i++) {
451
				gui[i] = value[i].real;
452
			}
453

454
		} break;
455
		case ShaderLanguage::TYPE_VEC4: {
456
			float *gui = (float *)data;
457

458
			for (int i = 0; i < 4; i++) {
459
				gui[i] = value[i].real;
460
			}
461
		} break;
462
		case ShaderLanguage::TYPE_MAT2: {
463
			float *gui = (float *)data;
464

465
			//in std140 members of mat2 are treated as vec4s
466
			gui[0] = value[0].real;
467
			gui[1] = value[1].real;
468
			gui[2] = 0;
469
			gui[3] = 0;
470
			gui[4] = value[2].real;
471
			gui[5] = value[3].real;
472
			gui[6] = 0;
473
			gui[7] = 0;
474
		} break;
475
		case ShaderLanguage::TYPE_MAT3: {
476
			float *gui = (float *)data;
477

478
			gui[0] = value[0].real;
479
			gui[1] = value[1].real;
480
			gui[2] = value[2].real;
481
			gui[3] = 0;
482
			gui[4] = value[3].real;
483
			gui[5] = value[4].real;
484
			gui[6] = value[5].real;
485
			gui[7] = 0;
486
			gui[8] = value[6].real;
487
			gui[9] = value[7].real;
488
			gui[10] = value[8].real;
489
			gui[11] = 0;
490
		} break;
491
		case ShaderLanguage::TYPE_MAT4: {
492
			float *gui = (float *)data;
493

494
			for (int i = 0; i < 16; i++) {
495
				gui[i] = value[i].real;
496
			}
497
		} break;
498
		default: {
499
		}
500
	}
501
}
502

503
_FORCE_INLINE_ static void _fill_std140_ubo_empty(ShaderLanguage::DataType type, int p_array_size, uint8_t *data) {
504
	if (p_array_size <= 0) {
505
		p_array_size = 1;
506
	}
507

508
	switch (type) {
509
		case ShaderLanguage::TYPE_BOOL:
510
		case ShaderLanguage::TYPE_INT:
511
		case ShaderLanguage::TYPE_UINT:
512
		case ShaderLanguage::TYPE_FLOAT: {
513
			memset(data, 0, 4 * p_array_size);
514
		} break;
515
		case ShaderLanguage::TYPE_BVEC2:
516
		case ShaderLanguage::TYPE_IVEC2:
517
		case ShaderLanguage::TYPE_UVEC2:
518
		case ShaderLanguage::TYPE_VEC2: {
519
			memset(data, 0, 8 * p_array_size);
520
		} break;
521
		case ShaderLanguage::TYPE_BVEC3:
522
		case ShaderLanguage::TYPE_IVEC3:
523
		case ShaderLanguage::TYPE_UVEC3:
524
		case ShaderLanguage::TYPE_VEC3: {
525
			memset(data, 0, 12 * p_array_size);
526
		} break;
527
		case ShaderLanguage::TYPE_BVEC4:
528
		case ShaderLanguage::TYPE_IVEC4:
529
		case ShaderLanguage::TYPE_UVEC4:
530
		case ShaderLanguage::TYPE_VEC4: {
531
			memset(data, 0, 16 * p_array_size);
532
		} break;
533
		case ShaderLanguage::TYPE_MAT2: {
534
			memset(data, 0, 32 * p_array_size);
535
		} break;
536
		case ShaderLanguage::TYPE_MAT3: {
537
			memset(data, 0, 48 * p_array_size);
538
		} break;
539
		case ShaderLanguage::TYPE_MAT4: {
540
			memset(data, 0, 64 * p_array_size);
541
		} break;
542

543
		default: {
544
		}
545
	}
546
}
547

548
///////////////////////////////////////////////////////////////////////////
549
// ShaderData
550

551
void ShaderData::set_path_hint(const String &p_hint) {
552
	path = p_hint;
553
}
554

555
void ShaderData::set_default_texture_parameter(const StringName &p_name, RID p_texture, int p_index) {
556
	if (!p_texture.is_valid()) {
557
		if (default_texture_params.has(p_name) && default_texture_params[p_name].has(p_index)) {
558
			default_texture_params[p_name].erase(p_index);
559

560
			if (default_texture_params[p_name].is_empty()) {
561
				default_texture_params.erase(p_name);
562
			}
563
		}
564
	} else {
565
		if (!default_texture_params.has(p_name)) {
566
			default_texture_params[p_name] = HashMap<int, RID>();
567
		}
568
		default_texture_params[p_name][p_index] = p_texture;
569
	}
570
}
571

572
Variant ShaderData::get_default_parameter(const StringName &p_parameter) const {
573
	if (uniforms.has(p_parameter)) {
574
		ShaderLanguage::ShaderNode::Uniform uniform = uniforms[p_parameter];
575
		Vector<ShaderLanguage::Scalar> default_value = uniform.default_value;
576
		if (default_value.is_empty()) {
577
			return ShaderLanguage::get_default_datatype_value(uniform.type, uniform.array_size, uniform.hint);
578
		}
579
		return ShaderLanguage::constant_value_to_variant(default_value, uniform.type, uniform.array_size, uniform.hint);
580
	}
581
	return Variant();
582
}
583

584
void ShaderData::get_shader_uniform_list(List<PropertyInfo> *p_param_list) const {
585
	SortArray<Pair<StringName, int>, ShaderLanguage::UniformOrderComparator> sorter;
586
	LocalVector<Pair<StringName, int>> filtered_uniforms;
587

588
	for (const KeyValue<StringName, ShaderLanguage::ShaderNode::Uniform> &E : uniforms) {
589
		if (E.value.scope != ShaderLanguage::ShaderNode::Uniform::SCOPE_LOCAL) {
590
			continue;
591
		}
592
		filtered_uniforms.push_back(Pair<StringName, int>(E.key, E.value.prop_order));
593
	}
594
	int uniform_count = filtered_uniforms.size();
595
	sorter.sort(filtered_uniforms.ptr(), uniform_count);
596

597
	String last_group;
598
	for (int i = 0; i < uniform_count; i++) {
599
		const StringName &uniform_name = filtered_uniforms[i].first;
600
		const ShaderLanguage::ShaderNode::Uniform &uniform = uniforms[uniform_name];
601

602
		String group = uniform.group;
603
		if (!uniform.subgroup.is_empty()) {
604
			group += "::" + uniform.subgroup;
605
		}
606

607
		if (group != last_group) {
608
			PropertyInfo pi;
609
			pi.usage = PROPERTY_USAGE_GROUP;
610
			pi.name = group;
611
			p_param_list->push_back(pi);
612

613
			last_group = group;
614
		}
615

616
		PropertyInfo pi = ShaderLanguage::uniform_to_property_info(uniform);
617
		pi.name = uniform_name;
618
		p_param_list->push_back(pi);
619
	}
620
}
621

622
void ShaderData::get_instance_param_list(List<RendererMaterialStorage::InstanceShaderParam> *p_param_list) const {
623
	for (const KeyValue<StringName, ShaderLanguage::ShaderNode::Uniform> &E : uniforms) {
624
		if (E.value.scope != ShaderLanguage::ShaderNode::Uniform::SCOPE_INSTANCE) {
625
			continue;
626
		}
627

628
		RendererMaterialStorage::InstanceShaderParam p;
629
		p.info = ShaderLanguage::uniform_to_property_info(E.value);
630
		p.info.name = E.key; //supply name
631
		p.index = E.value.instance_index;
632
		p.default_value = ShaderLanguage::constant_value_to_variant(E.value.default_value, E.value.type, E.value.array_size, E.value.hint);
633
		p_param_list->push_back(p);
634
	}
635
}
636

637
bool ShaderData::is_parameter_texture(const StringName &p_param) const {
638
	if (!uniforms.has(p_param)) {
639
		return false;
640
	}
641

642
	return uniforms[p_param].is_texture();
643
}
644

645
///////////////////////////////////////////////////////////////////////////
646
// MaterialData
647

648
// Look up table to translate ShaderLanguage::DataType to GL_TEXTURE_*
649
static const GLenum target_from_type[ShaderLanguage::TYPE_MAX] = {
650
	GL_TEXTURE_2D, // TYPE_VOID,
651
	GL_TEXTURE_2D, // TYPE_BOOL,
652
	GL_TEXTURE_2D, // TYPE_BVEC2,
653
	GL_TEXTURE_2D, // TYPE_BVEC3,
654
	GL_TEXTURE_2D, // TYPE_BVEC4,
655
	GL_TEXTURE_2D, // TYPE_INT,
656
	GL_TEXTURE_2D, // TYPE_IVEC2,
657
	GL_TEXTURE_2D, // TYPE_IVEC3,
658
	GL_TEXTURE_2D, // TYPE_IVEC4,
659
	GL_TEXTURE_2D, // TYPE_UINT,
660
	GL_TEXTURE_2D, // TYPE_UVEC2,
661
	GL_TEXTURE_2D, // TYPE_UVEC3,
662
	GL_TEXTURE_2D, // TYPE_UVEC4,
663
	GL_TEXTURE_2D, // TYPE_FLOAT,
664
	GL_TEXTURE_2D, // TYPE_VEC2,
665
	GL_TEXTURE_2D, // TYPE_VEC3,
666
	GL_TEXTURE_2D, // TYPE_VEC4,
667
	GL_TEXTURE_2D, // TYPE_MAT2,
668
	GL_TEXTURE_2D, // TYPE_MAT3,
669
	GL_TEXTURE_2D, // TYPE_MAT4,
670
	GL_TEXTURE_2D, // TYPE_SAMPLER2D,
671
	GL_TEXTURE_2D, // TYPE_ISAMPLER2D,
672
	GL_TEXTURE_2D, // TYPE_USAMPLER2D,
673
	GL_TEXTURE_2D_ARRAY, // TYPE_SAMPLER2DARRAY,
674
	GL_TEXTURE_2D_ARRAY, // TYPE_ISAMPLER2DARRAY,
675
	GL_TEXTURE_2D_ARRAY, // TYPE_USAMPLER2DARRAY,
676
	GL_TEXTURE_3D, // TYPE_SAMPLER3D,
677
	GL_TEXTURE_3D, // TYPE_ISAMPLER3D,
678
	GL_TEXTURE_3D, // TYPE_USAMPLER3D,
679
	GL_TEXTURE_CUBE_MAP, // TYPE_SAMPLERCUBE,
680
	GL_TEXTURE_CUBE_MAP, // TYPE_SAMPLERCUBEARRAY,
681
	_GL_TEXTURE_EXTERNAL_OES, // TYPE_SAMPLEREXT
682
	GL_TEXTURE_2D, // TYPE_STRUCT
683
};
684

685
static const RS::CanvasItemTextureRepeat repeat_from_uniform[ShaderLanguage::REPEAT_DEFAULT + 1] = {
686
	RS::CanvasItemTextureRepeat::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED, // ShaderLanguage::TextureRepeat::REPEAT_DISABLE,
687
	RS::CanvasItemTextureRepeat::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED, // ShaderLanguage::TextureRepeat::REPEAT_ENABLE,
688
	RS::CanvasItemTextureRepeat::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED, // ShaderLanguage::TextureRepeat::REPEAT_DEFAULT,
689
};
690

691
static const RS::CanvasItemTextureRepeat repeat_from_uniform_canvas[ShaderLanguage::REPEAT_DEFAULT + 1] = {
692
	RS::CanvasItemTextureRepeat::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED, // ShaderLanguage::TextureRepeat::REPEAT_DISABLE,
693
	RS::CanvasItemTextureRepeat::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED, // ShaderLanguage::TextureRepeat::REPEAT_ENABLE,
694
	RS::CanvasItemTextureRepeat::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED, // ShaderLanguage::TextureRepeat::REPEAT_DEFAULT,
695
};
696

697
static const RS::CanvasItemTextureFilter filter_from_uniform[ShaderLanguage::FILTER_DEFAULT + 1] = {
698
	RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_NEAREST, // ShaderLanguage::TextureFilter::FILTER_NEAREST,
699
	RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, // ShaderLanguage::TextureFilter::FILTER_LINEAR,
700
	RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS, // ShaderLanguage::TextureFilter::FILTER_NEAREST_MIPMAP,
701
	RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, // ShaderLanguage::TextureFilter::FILTER_LINEAR_MIPMAP,
702
	RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC, // ShaderLanguage::TextureFilter::FILTER_NEAREST_MIPMAP_ANISOTROPIC,
703
	RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC, // ShaderLanguage::TextureFilter::FILTER_LINEAR_MIPMAP_ANISOTROPIC,
704
	RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, // ShaderLanguage::TextureFilter::FILTER_DEFAULT,
705
};
706

707
static const RS::CanvasItemTextureFilter filter_from_uniform_canvas[ShaderLanguage::FILTER_DEFAULT + 1] = {
708
	RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_NEAREST, // ShaderLanguage::TextureFilter::FILTER_NEAREST,
709
	RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, // ShaderLanguage::TextureFilter::FILTER_LINEAR,
710
	RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS, // ShaderLanguage::TextureFilter::FILTER_NEAREST_MIPMAP,
711
	RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, // ShaderLanguage::TextureFilter::FILTER_LINEAR_MIPMAP,
712
	RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC, // ShaderLanguage::TextureFilter::FILTER_NEAREST_MIPMAP_ANISOTROPIC,
713
	RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC, // ShaderLanguage::TextureFilter::FILTER_LINEAR_MIPMAP_ANISOTROPIC,
714
	RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, // ShaderLanguage::TextureFilter::FILTER_DEFAULT,
715
};
716

717
void MaterialData::update_uniform_buffer(const HashMap<StringName, ShaderLanguage::ShaderNode::Uniform> &p_uniforms, const uint32_t *p_uniform_offsets, const HashMap<StringName, Variant> &p_parameters, uint8_t *p_buffer, uint32_t p_buffer_size) {
718
	MaterialStorage *material_storage = MaterialStorage::get_singleton();
719
	bool uses_global_buffer = false;
720

721
	for (const KeyValue<StringName, ShaderLanguage::ShaderNode::Uniform> &E : p_uniforms) {
722
		if (E.value.is_texture()) {
723
			continue; // texture, does not go here
724
		}
725

726
		if (E.value.scope == ShaderLanguage::ShaderNode::Uniform::SCOPE_INSTANCE) {
727
			continue; //instance uniforms don't appear in the buffer
728
		}
729

730
		if (E.value.scope == ShaderLanguage::ShaderNode::Uniform::SCOPE_GLOBAL) {
731
			//this is a global variable, get the index to it
732
			GlobalShaderUniforms::Variable *gv = material_storage->global_shader_uniforms.variables.getptr(E.key);
733
			uint32_t index = 0;
734
			if (gv) {
735
				index = gv->buffer_index;
736
			} else {
737
				WARN_PRINT("Shader uses global parameter '" + E.key + "', but it was removed at some point. Material will not display correctly.");
738
			}
739

740
			uint32_t offset = p_uniform_offsets[E.value.order];
741
			uint32_t *intptr = (uint32_t *)&p_buffer[offset];
742
			*intptr = index;
743
			uses_global_buffer = true;
744
			continue;
745
		}
746

747
		//regular uniform
748
		uint32_t offset = p_uniform_offsets[E.value.order];
749
#ifdef DEBUG_ENABLED
750
		uint32_t size = 0U;
751
		// The following code enforces a 16-byte alignment of uniform arrays.
752
		if (E.value.array_size > 0) {
753
			size = ShaderLanguage::get_datatype_size(E.value.type) * E.value.array_size;
754
			int m = (16 * E.value.array_size);
755
			if ((size % m) != 0U) {
756
				size += m - (size % m);
757
			}
758
		} else {
759
			size = ShaderLanguage::get_datatype_size(E.value.type);
760
		}
761
		ERR_CONTINUE(offset + size > p_buffer_size);
762
#endif
763
		uint8_t *data = &p_buffer[offset];
764
		HashMap<StringName, Variant>::ConstIterator V = p_parameters.find(E.key);
765

766
		if (V) {
767
			//user provided
768
			_fill_std140_variant_ubo_value(E.value.type, E.value.array_size, V->value, data);
769

770
		} else if (E.value.default_value.size()) {
771
			//default value
772
			_fill_std140_ubo_value(E.value.type, E.value.default_value, data);
773
			//value=E.value.default_value;
774
		} else {
775
			//zero because it was not provided
776
			if ((E.value.type == ShaderLanguage::TYPE_VEC3 || E.value.type == ShaderLanguage::TYPE_VEC4) && E.value.hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
777
				//colors must be set as black, with alpha as 1.0
778
				_fill_std140_variant_ubo_value(E.value.type, E.value.array_size, Color(0, 0, 0, 1), data);
779
			} else if ((E.value.type == ShaderLanguage::TYPE_VEC3 || E.value.type == ShaderLanguage::TYPE_VEC4) && E.value.hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR_CONVERSION_DISABLED) {
780
				//colors must be set as black, with alpha as 1.0
781
				_fill_std140_variant_ubo_value(E.value.type, E.value.array_size, Color(0, 0, 0, 1), data);
782
			} else if (E.value.type == ShaderLanguage::TYPE_MAT2) {
783
				// mat uniforms are identity matrix by default.
784
				_fill_std140_variant_ubo_value(E.value.type, E.value.array_size, Transform2D(), data);
785
			} else if (E.value.type == ShaderLanguage::TYPE_MAT3) {
786
				_fill_std140_variant_ubo_value(E.value.type, E.value.array_size, Basis(), data);
787
			} else if (E.value.type == ShaderLanguage::TYPE_MAT4) {
788
				_fill_std140_variant_ubo_value(E.value.type, E.value.array_size, Projection(), data);
789
			} else {
790
				//else just zero it out
791
				_fill_std140_ubo_empty(E.value.type, E.value.array_size, data);
792
			}
793
		}
794
	}
795

796
	if (uses_global_buffer != (global_buffer_E != nullptr)) {
797
		if (uses_global_buffer) {
798
			global_buffer_E = material_storage->global_shader_uniforms.materials_using_buffer.push_back(self);
799
		} else {
800
			material_storage->global_shader_uniforms.materials_using_buffer.erase(global_buffer_E);
801
			global_buffer_E = nullptr;
802
		}
803
	}
804
}
805

806
MaterialData::~MaterialData() {
807
	MaterialStorage *material_storage = MaterialStorage::get_singleton();
808

809
	if (global_buffer_E) {
810
		//unregister global buffers
811
		material_storage->global_shader_uniforms.materials_using_buffer.erase(global_buffer_E);
812
	}
813

814
	if (global_texture_E) {
815
		//unregister global textures
816

817
		for (const KeyValue<StringName, uint64_t> &E : used_global_textures) {
818
			GlobalShaderUniforms::Variable *v = material_storage->global_shader_uniforms.variables.getptr(E.key);
819
			if (v) {
820
				v->texture_materials.erase(self);
821
			}
822
		}
823
		//unregister material from those using global textures
824
		material_storage->global_shader_uniforms.materials_using_texture.erase(global_texture_E);
825
	}
826

827
	if (uniform_buffer) {
828
		glDeleteBuffers(1, &uniform_buffer);
829
		uniform_buffer = 0;
830
	}
831
}
832

833
void MaterialData::update_textures(const HashMap<StringName, Variant> &p_parameters, const HashMap<StringName, HashMap<int, RID>> &p_default_textures, const Vector<ShaderCompiler::GeneratedCode::Texture> &p_texture_uniforms, RID *p_textures, bool p_is_3d_shader_type) {
834
	TextureStorage *texture_storage = TextureStorage::get_singleton();
835
	MaterialStorage *material_storage = MaterialStorage::get_singleton();
836

837
#ifdef TOOLS_ENABLED
838
	Texture *roughness_detect_texture = nullptr;
839
	RS::TextureDetectRoughnessChannel roughness_channel = RS::TEXTURE_DETECT_ROUGHNESS_R;
840
	Texture *normal_detect_texture = nullptr;
841
#endif
842

843
	bool uses_global_textures = false;
844
	global_textures_pass++;
845

846
	for (int i = 0, k = 0; i < p_texture_uniforms.size(); i++) {
847
		const StringName &uniform_name = p_texture_uniforms[i].name;
848
		int uniform_array_size = p_texture_uniforms[i].array_size;
849

850
		Vector<RID> textures;
851

852
		if (p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_SCREEN_TEXTURE ||
853
				p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL_ROUGHNESS_TEXTURE ||
854
				p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_DEPTH_TEXTURE) {
855
			continue;
856
		}
857

858
		if (p_texture_uniforms[i].global) {
859
			uses_global_textures = true;
860

861
			GlobalShaderUniforms::Variable *v = material_storage->global_shader_uniforms.variables.getptr(uniform_name);
862
			if (v) {
863
				if (v->buffer_index >= 0) {
864
					WARN_PRINT("Shader uses global parameter texture '" + String(uniform_name) + "', but it changed type and is no longer a texture!");
865

866
				} else {
867
					HashMap<StringName, uint64_t>::Iterator E = used_global_textures.find(uniform_name);
868
					if (!E) {
869
						E = used_global_textures.insert(uniform_name, global_textures_pass);
870
						v->texture_materials.insert(self);
871
					} else {
872
						E->value = global_textures_pass;
873
					}
874

875
					RID override_rid = v->override;
876
					if (override_rid.is_valid()) {
877
						textures.push_back(override_rid);
878
					} else {
879
						RID value_rid = v->value;
880
						if (value_rid.is_valid()) {
881
							textures.push_back(value_rid);
882
						}
883
					}
884
				}
885

886
			} else {
887
				WARN_PRINT("Shader uses global parameter texture '" + String(uniform_name) + "', but it was removed at some point. Material will not display correctly.");
888
			}
889
		} else {
890
			HashMap<StringName, Variant>::ConstIterator V = p_parameters.find(uniform_name);
891
			if (V) {
892
				if (V->value.is_array()) {
893
					Array array = (Array)V->value;
894
					if (uniform_array_size > 0) {
895
						int size = MIN(uniform_array_size, array.size());
896
						for (int j = 0; j < size; j++) {
897
							textures.push_back(array[j]);
898
						}
899
					} else {
900
						if (array.size() > 0) {
901
							textures.push_back(array[0]);
902
						}
903
					}
904
				} else {
905
					textures.push_back(V->value);
906
				}
907
			}
908

909
			if (uniform_array_size > 0) {
910
				if (textures.size() < uniform_array_size) {
911
					HashMap<StringName, HashMap<int, RID>>::ConstIterator W = p_default_textures.find(uniform_name);
912
					for (int j = textures.size(); j < uniform_array_size; j++) {
913
						if (W && W->value.has(j)) {
914
							textures.push_back(W->value[j]);
915
						} else {
916
							textures.push_back(RID());
917
						}
918
					}
919
				}
920
			} else if (textures.is_empty()) {
921
				HashMap<StringName, HashMap<int, RID>>::ConstIterator W = p_default_textures.find(uniform_name);
922
				if (W && W->value.has(0)) {
923
					textures.push_back(W->value[0]);
924
				}
925
			}
926
		}
927

928
		RID gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_WHITE);
929

930
		if (textures.is_empty()) {
931
			//check default usage
932
			switch (p_texture_uniforms[i].type) {
933
				case ShaderLanguage::TYPE_ISAMPLER2D:
934
				case ShaderLanguage::TYPE_USAMPLER2D:
935
				case ShaderLanguage::TYPE_SAMPLER2D: {
936
					switch (p_texture_uniforms[i].hint) {
937
						case ShaderLanguage::ShaderNode::Uniform::HINT_DEFAULT_BLACK: {
938
							gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_BLACK);
939
						} break;
940
						case ShaderLanguage::ShaderNode::Uniform::HINT_DEFAULT_TRANSPARENT: {
941
							gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_TRANSPARENT);
942
						} break;
943
						case ShaderLanguage::ShaderNode::Uniform::HINT_ANISOTROPY: {
944
							gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_ANISO);
945
						} break;
946
						case ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL: {
947
							gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_NORMAL);
948
						} break;
949
						case ShaderLanguage::ShaderNode::Uniform::HINT_ROUGHNESS_NORMAL: {
950
							gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_NORMAL);
951
						} break;
952
						default: {
953
							gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_WHITE);
954
						} break;
955
					}
956
				} break;
957

958
				case ShaderLanguage::TYPE_SAMPLERCUBE: {
959
					switch (p_texture_uniforms[i].hint) {
960
						case ShaderLanguage::ShaderNode::Uniform::HINT_DEFAULT_BLACK: {
961
							gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_CUBEMAP_BLACK);
962
						} break;
963
						default: {
964
							gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_CUBEMAP_WHITE);
965
						} break;
966
					}
967
				} break;
968
				case ShaderLanguage::TYPE_SAMPLERCUBEARRAY: {
969
					ERR_PRINT_ONCE("Type: SamplerCubeArray is not supported in the Compatibility renderer, please use another type.");
970
				} break;
971
				case ShaderLanguage::TYPE_SAMPLEREXT: {
972
					gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_EXT);
973
				} break;
974

975
				case ShaderLanguage::TYPE_ISAMPLER3D:
976
				case ShaderLanguage::TYPE_USAMPLER3D:
977
				case ShaderLanguage::TYPE_SAMPLER3D: {
978
					switch (p_texture_uniforms[i].hint) {
979
						case ShaderLanguage::ShaderNode::Uniform::HINT_DEFAULT_BLACK: {
980
							gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_3D_BLACK);
981
						} break;
982
						default: {
983
							gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_3D_WHITE);
984
						} break;
985
					}
986
				} break;
987

988
				case ShaderLanguage::TYPE_ISAMPLER2DARRAY:
989
				case ShaderLanguage::TYPE_USAMPLER2DARRAY:
990
				case ShaderLanguage::TYPE_SAMPLER2DARRAY: {
991
					gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_2D_ARRAY_WHITE);
992
				} break;
993

994
				default: {
995
				}
996
			}
997
#ifdef TOOLS_ENABLED
998
			if (roughness_detect_texture && normal_detect_texture && !normal_detect_texture->path.is_empty()) {
999
				roughness_detect_texture->detect_roughness_callback(roughness_detect_texture->detect_roughness_callback_ud, normal_detect_texture->path, roughness_channel);
1000
			}
1001
#endif
1002
			if (uniform_array_size > 0) {
1003
				for (int j = 0; j < uniform_array_size; j++) {
1004
					p_textures[k++] = gl_texture;
1005
				}
1006
			} else {
1007
				p_textures[k++] = gl_texture;
1008
			}
1009
		} else {
1010
			for (int j = 0; j < textures.size(); j++) {
1011
				Texture *tex = TextureStorage::get_singleton()->get_texture(textures[j]);
1012

1013
				if (tex) {
1014
					gl_texture = textures[j];
1015
#ifdef TOOLS_ENABLED
1016
					if (tex->detect_3d_callback && p_is_3d_shader_type) {
1017
						tex->detect_3d_callback(tex->detect_3d_callback_ud);
1018
					}
1019
					if (tex->detect_normal_callback && (p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL || p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_ROUGHNESS_NORMAL)) {
1020
						if (p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_ROUGHNESS_NORMAL) {
1021
							normal_detect_texture = tex;
1022
						}
1023
						tex->detect_normal_callback(tex->detect_normal_callback_ud);
1024
					}
1025
					if (tex->detect_roughness_callback && (p_texture_uniforms[i].hint >= ShaderLanguage::ShaderNode::Uniform::HINT_ROUGHNESS_R || p_texture_uniforms[i].hint <= ShaderLanguage::ShaderNode::Uniform::HINT_ROUGHNESS_GRAY)) {
1026
						//find the normal texture
1027
						roughness_detect_texture = tex;
1028
						roughness_channel = RS::TextureDetectRoughnessChannel(p_texture_uniforms[i].hint - ShaderLanguage::ShaderNode::Uniform::HINT_ROUGHNESS_R);
1029
					}
1030
#endif
1031
				}
1032
#ifdef TOOLS_ENABLED
1033
				if (roughness_detect_texture && normal_detect_texture && !normal_detect_texture->path.is_empty()) {
1034
					roughness_detect_texture->detect_roughness_callback(roughness_detect_texture->detect_roughness_callback_ud, normal_detect_texture->path, roughness_channel);
1035
				}
1036
#endif
1037
				p_textures[k++] = gl_texture;
1038
			}
1039
		}
1040
	}
1041
	{
1042
		//for textures no longer used, unregister them
1043
		List<StringName> to_delete;
1044
		for (KeyValue<StringName, uint64_t> &E : used_global_textures) {
1045
			if (E.value != global_textures_pass) {
1046
				to_delete.push_back(E.key);
1047

1048
				GlobalShaderUniforms::Variable *v = material_storage->global_shader_uniforms.variables.getptr(E.key);
1049
				if (v) {
1050
					v->texture_materials.erase(self);
1051
				}
1052
			}
1053
		}
1054

1055
		while (to_delete.front()) {
1056
			used_global_textures.erase(to_delete.front()->get());
1057
			to_delete.pop_front();
1058
		}
1059
		//handle registering/unregistering global textures
1060
		if (uses_global_textures != (global_texture_E != nullptr)) {
1061
			if (uses_global_textures) {
1062
				global_texture_E = material_storage->global_shader_uniforms.materials_using_texture.push_back(self);
1063
			} else {
1064
				material_storage->global_shader_uniforms.materials_using_texture.erase(global_texture_E);
1065
				global_texture_E = nullptr;
1066
			}
1067
		}
1068
	}
1069
}
1070

1071
void MaterialData::update_parameters_internal(const HashMap<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty, const HashMap<StringName, ShaderLanguage::ShaderNode::Uniform> &p_uniforms, const uint32_t *p_uniform_offsets, const Vector<ShaderCompiler::GeneratedCode::Texture> &p_texture_uniforms, const HashMap<StringName, HashMap<int, RID>> &p_default_texture_params, uint32_t p_ubo_size, bool p_is_3d_shader_type) {
1072
	if ((uint32_t)ubo_data.size() != p_ubo_size) {
1073
		p_uniform_dirty = true;
1074
		if (!uniform_buffer) {
1075
			glGenBuffers(1, &uniform_buffer);
1076
		}
1077

1078
		ubo_data.resize(p_ubo_size);
1079
		if (ubo_data.size()) {
1080
			ERR_FAIL_COND(p_ubo_size > uint32_t(Config::get_singleton()->max_uniform_buffer_size));
1081
			memset(ubo_data.ptrw(), 0, ubo_data.size()); //clear
1082
		}
1083
	}
1084

1085
	//check whether buffer changed
1086
	if (p_uniform_dirty && ubo_data.size()) {
1087
		update_uniform_buffer(p_uniforms, p_uniform_offsets, p_parameters, ubo_data.ptrw(), ubo_data.size());
1088
		glBindBuffer(GL_UNIFORM_BUFFER, uniform_buffer);
1089
		glBufferData(GL_UNIFORM_BUFFER, ubo_data.size(), ubo_data.ptrw(), GL_DYNAMIC_DRAW);
1090
		glBindBuffer(GL_UNIFORM_BUFFER, 0);
1091
	}
1092

1093
	uint32_t tex_uniform_count = 0U;
1094
	for (int i = 0; i < p_texture_uniforms.size(); i++) {
1095
		tex_uniform_count += uint32_t(p_texture_uniforms[i].array_size > 0 ? p_texture_uniforms[i].array_size : 1);
1096
	}
1097

1098
	if ((uint32_t)texture_cache.size() != tex_uniform_count || p_textures_dirty) {
1099
		texture_cache.resize(tex_uniform_count);
1100
		p_textures_dirty = true;
1101
	}
1102

1103
	if (p_textures_dirty && tex_uniform_count) {
1104
		update_textures(p_parameters, p_default_texture_params, p_texture_uniforms, texture_cache.ptrw(), p_is_3d_shader_type);
1105
	}
1106
}
1107

1108
///////////////////////////////////////////////////////////////////////////
1109
// Material Storage
1110

1111
MaterialStorage *MaterialStorage::singleton = nullptr;
1112

1113
MaterialStorage *MaterialStorage::get_singleton() {
1114
	return singleton;
1115
}
1116

1117
MaterialStorage::MaterialStorage() {
1118
	singleton = this;
1119

1120
	shader_data_request_func[RS::SHADER_SPATIAL] = _create_scene_shader_func;
1121
	shader_data_request_func[RS::SHADER_CANVAS_ITEM] = _create_canvas_shader_func;
1122
	shader_data_request_func[RS::SHADER_PARTICLES] = _create_particles_shader_func;
1123
	shader_data_request_func[RS::SHADER_SKY] = _create_sky_shader_func;
1124
	shader_data_request_func[RS::SHADER_FOG] = nullptr;
1125

1126
	material_data_request_func[RS::SHADER_SPATIAL] = _create_scene_material_func;
1127
	material_data_request_func[RS::SHADER_CANVAS_ITEM] = _create_canvas_material_func;
1128
	material_data_request_func[RS::SHADER_PARTICLES] = _create_particles_material_func;
1129
	material_data_request_func[RS::SHADER_SKY] = _create_sky_material_func;
1130
	material_data_request_func[RS::SHADER_FOG] = nullptr;
1131

1132
	static_assert(sizeof(GlobalShaderUniforms::Value) == 16);
1133

1134
	global_shader_uniforms.buffer_size = MAX(16, (int)GLOBAL_GET("rendering/limits/global_shader_variables/buffer_size"));
1135
	if (global_shader_uniforms.buffer_size * sizeof(GlobalShaderUniforms::Value) > uint32_t(Config::get_singleton()->max_uniform_buffer_size)) {
1136
		// Limit to maximum support UBO size.
1137
		global_shader_uniforms.buffer_size = uint32_t(Config::get_singleton()->max_uniform_buffer_size) / sizeof(GlobalShaderUniforms::Value);
1138
	}
1139

1140
	global_shader_uniforms.buffer_values = memnew_arr(GlobalShaderUniforms::Value, global_shader_uniforms.buffer_size);
1141
	memset(global_shader_uniforms.buffer_values, 0, sizeof(GlobalShaderUniforms::Value) * global_shader_uniforms.buffer_size);
1142
	global_shader_uniforms.buffer_usage = memnew_arr(GlobalShaderUniforms::ValueUsage, global_shader_uniforms.buffer_size);
1143
	global_shader_uniforms.buffer_dirty_regions = memnew_arr(bool, 1 + (global_shader_uniforms.buffer_size / GlobalShaderUniforms::BUFFER_DIRTY_REGION_SIZE));
1144
	memset(global_shader_uniforms.buffer_dirty_regions, 0, sizeof(bool) * (1 + (global_shader_uniforms.buffer_size / GlobalShaderUniforms::BUFFER_DIRTY_REGION_SIZE)));
1145
	glGenBuffers(1, &global_shader_uniforms.buffer);
1146
	glBindBuffer(GL_UNIFORM_BUFFER, global_shader_uniforms.buffer);
1147
	glBufferData(GL_UNIFORM_BUFFER, sizeof(GlobalShaderUniforms::Value) * global_shader_uniforms.buffer_size, nullptr, GL_DYNAMIC_DRAW);
1148
	glBindBuffer(GL_UNIFORM_BUFFER, 0);
1149

1150
	{
1151
		// Setup CanvasItem compiler
1152
		ShaderCompiler::DefaultIdentifierActions actions;
1153

1154
		actions.renames["VERTEX"] = "vertex";
1155
		actions.renames["LIGHT_VERTEX"] = "light_vertex";
1156
		actions.renames["SHADOW_VERTEX"] = "shadow_vertex";
1157
		actions.renames["UV"] = "uv";
1158
		actions.renames["POINT_SIZE"] = "point_size";
1159

1160
		actions.renames["MODEL_MATRIX"] = "model_matrix";
1161
		actions.renames["CANVAS_MATRIX"] = "canvas_transform";
1162
		actions.renames["SCREEN_MATRIX"] = "screen_transform";
1163
		actions.renames["TIME"] = "time";
1164
		actions.renames["PI"] = String::num(Math::PI);
1165
		actions.renames["TAU"] = String::num(Math::TAU);
1166
		actions.renames["E"] = String::num(Math::E);
1167
		actions.renames["AT_LIGHT_PASS"] = "false";
1168
		actions.renames["INSTANCE_CUSTOM"] = "instance_custom";
1169

1170
		actions.renames["COLOR"] = "color";
1171
		actions.renames["NORMAL"] = "normal";
1172
		actions.renames["NORMAL_MAP"] = "normal_map";
1173
		actions.renames["NORMAL_MAP_DEPTH"] = "normal_map_depth";
1174
		actions.renames["TEXTURE"] = "color_texture";
1175
		actions.renames["TEXTURE_PIXEL_SIZE"] = "color_texture_pixel_size";
1176
		actions.renames["NORMAL_TEXTURE"] = "normal_texture";
1177
		actions.renames["SPECULAR_SHININESS_TEXTURE"] = "specular_texture";
1178
		actions.renames["SPECULAR_SHININESS"] = "specular_shininess";
1179
		actions.renames["SCREEN_UV"] = "screen_uv";
1180
		actions.renames["REGION_RECT"] = "region_rect";
1181
		actions.renames["SCREEN_PIXEL_SIZE"] = "screen_pixel_size";
1182
		actions.renames["FRAGCOORD"] = "gl_FragCoord";
1183
		actions.renames["POINT_COORD"] = "gl_PointCoord";
1184
		actions.renames["INSTANCE_ID"] = "gl_InstanceID";
1185
		actions.renames["VERTEX_ID"] = "gl_VertexID";
1186

1187
		actions.renames["CUSTOM0"] = "custom0";
1188
		actions.renames["CUSTOM1"] = "custom1";
1189

1190
		actions.renames["LIGHT_POSITION"] = "light_position";
1191
		actions.renames["LIGHT_DIRECTION"] = "light_direction";
1192
		actions.renames["LIGHT_IS_DIRECTIONAL"] = "is_directional";
1193
		actions.renames["LIGHT_COLOR"] = "light_color";
1194
		actions.renames["LIGHT_ENERGY"] = "light_energy";
1195
		actions.renames["LIGHT"] = "light";
1196
		actions.renames["SHADOW_MODULATE"] = "shadow_modulate";
1197

1198
		actions.renames["texture_sdf"] = "texture_sdf";
1199
		actions.renames["texture_sdf_normal"] = "texture_sdf_normal";
1200
		actions.renames["sdf_to_screen_uv"] = "sdf_to_screen_uv";
1201
		actions.renames["screen_uv_to_sdf"] = "screen_uv_to_sdf";
1202

1203
		actions.usage_defines["COLOR"] = "#define COLOR_USED\n";
1204
		actions.usage_defines["SCREEN_UV"] = "#define SCREEN_UV_USED\n";
1205
		actions.usage_defines["SCREEN_PIXEL_SIZE"] = "@SCREEN_UV";
1206
		actions.usage_defines["NORMAL"] = "#define NORMAL_USED\n";
1207
		actions.usage_defines["NORMAL_MAP"] = "#define NORMAL_MAP_USED\n";
1208
		actions.usage_defines["SPECULAR_SHININESS"] = "#define SPECULAR_SHININESS_USED\n";
1209
		actions.usage_defines["CUSTOM0"] = "#define CUSTOM0_USED\n";
1210
		actions.usage_defines["CUSTOM1"] = "#define CUSTOM1_USED\n";
1211

1212
		actions.render_mode_defines["skip_vertex_transform"] = "#define SKIP_TRANSFORM_USED\n";
1213
		actions.render_mode_defines["unshaded"] = "#define MODE_UNSHADED\n";
1214
		actions.render_mode_defines["light_only"] = "#define MODE_LIGHT_ONLY\n";
1215
		actions.render_mode_defines["world_vertex_coords"] = "#define USE_WORLD_VERTEX_COORDS\n";
1216

1217
		actions.global_buffer_array_variable = "global_shader_uniforms";
1218
		actions.instance_uniform_index_variable = "read_draw_data_instance_offset";
1219

1220
		shaders.compiler_canvas.initialize(actions);
1221
	}
1222

1223
	{
1224
		// Setup Scene compiler
1225

1226
		//shader compiler
1227
		ShaderCompiler::DefaultIdentifierActions actions;
1228

1229
		actions.renames["MODEL_MATRIX"] = "model_matrix";
1230
		actions.renames["MODEL_NORMAL_MATRIX"] = "model_normal_matrix";
1231
		actions.renames["VIEW_MATRIX"] = "scene_data.view_matrix";
1232
		actions.renames["INV_VIEW_MATRIX"] = "scene_data.inv_view_matrix";
1233
		actions.renames["PROJECTION_MATRIX"] = "projection_matrix";
1234
		actions.renames["INV_PROJECTION_MATRIX"] = "inv_projection_matrix";
1235
		actions.renames["MODELVIEW_MATRIX"] = "modelview";
1236
		actions.renames["MODELVIEW_NORMAL_MATRIX"] = "modelview_normal";
1237
		actions.renames["MAIN_CAM_INV_VIEW_MATRIX"] = "scene_data.main_cam_inv_view_matrix";
1238

1239
		actions.renames["VERTEX"] = "vertex";
1240
		actions.renames["NORMAL"] = "normal";
1241
		actions.renames["TANGENT"] = "tangent";
1242
		actions.renames["BINORMAL"] = "binormal";
1243
		actions.renames["POSITION"] = "position";
1244
		actions.renames["UV"] = "uv_interp";
1245
		actions.renames["UV2"] = "uv2_interp";
1246
		actions.renames["COLOR"] = "color_interp";
1247
		actions.renames["POINT_SIZE"] = "point_size";
1248
		actions.renames["INSTANCE_ID"] = "gl_InstanceID";
1249
		actions.renames["VERTEX_ID"] = "gl_VertexID";
1250
		actions.renames["Z_CLIP_SCALE"] = "z_clip_scale";
1251

1252
		actions.renames["ALPHA_SCISSOR_THRESHOLD"] = "alpha_scissor_threshold";
1253
		actions.renames["ALPHA_HASH_SCALE"] = "alpha_hash_scale";
1254
		actions.renames["ALPHA_ANTIALIASING_EDGE"] = "alpha_antialiasing_edge";
1255
		actions.renames["ALPHA_TEXTURE_COORDINATE"] = "alpha_texture_coordinate";
1256

1257
		//builtins
1258

1259
		actions.renames["TIME"] = "scene_data.time";
1260
		actions.renames["EXPOSURE"] = "(1.0 / scene_data.emissive_exposure_normalization)";
1261
		actions.renames["PI"] = String::num(Math::PI);
1262
		actions.renames["TAU"] = String::num(Math::TAU);
1263
		actions.renames["E"] = String::num(Math::E);
1264
		actions.renames["OUTPUT_IS_SRGB"] = "SHADER_IS_SRGB";
1265
		actions.renames["CLIP_SPACE_FAR"] = "SHADER_SPACE_FAR";
1266
		actions.renames["IN_SHADOW_PASS"] = "IN_SHADOW_PASS";
1267
		actions.renames["VIEWPORT_SIZE"] = "scene_data.viewport_size";
1268

1269
		actions.renames["FRAGCOORD"] = "gl_FragCoord";
1270
		actions.renames["FRONT_FACING"] = "gl_FrontFacing";
1271
		actions.renames["NORMAL_MAP"] = "normal_map";
1272
		actions.renames["NORMAL_MAP_DEPTH"] = "normal_map_depth";
1273
		actions.renames["BENT_NORMAL_MAP"] = "bent_normal_map";
1274
		actions.renames["ALBEDO"] = "albedo";
1275
		actions.renames["ALPHA"] = "alpha";
1276
		actions.renames["PREMUL_ALPHA_FACTOR"] = "premul_alpha";
1277
		actions.renames["METALLIC"] = "metallic";
1278
		actions.renames["SPECULAR"] = "specular";
1279
		actions.renames["ROUGHNESS"] = "roughness";
1280
		actions.renames["RIM"] = "rim";
1281
		actions.renames["RIM_TINT"] = "rim_tint";
1282
		actions.renames["CLEARCOAT"] = "clearcoat";
1283
		actions.renames["CLEARCOAT_ROUGHNESS"] = "clearcoat_roughness";
1284
		actions.renames["ANISOTROPY"] = "anisotropy";
1285
		actions.renames["ANISOTROPY_FLOW"] = "anisotropy_flow";
1286
		actions.renames["SSS_STRENGTH"] = "sss_strength";
1287
		actions.renames["SSS_TRANSMITTANCE_COLOR"] = "transmittance_color";
1288
		actions.renames["SSS_TRANSMITTANCE_DEPTH"] = "transmittance_depth";
1289
		actions.renames["SSS_TRANSMITTANCE_BOOST"] = "transmittance_boost";
1290
		actions.renames["BACKLIGHT"] = "backlight";
1291
		actions.renames["AO"] = "ao";
1292
		actions.renames["AO_LIGHT_AFFECT"] = "ao_light_affect";
1293
		actions.renames["EMISSION"] = "emission";
1294
		actions.renames["POINT_COORD"] = "gl_PointCoord";
1295
		actions.renames["INSTANCE_CUSTOM"] = "instance_custom";
1296
		actions.renames["SCREEN_UV"] = "screen_uv";
1297
		actions.renames["DEPTH"] = "gl_FragDepth";
1298
		actions.renames["FOG"] = "fog";
1299
		actions.renames["RADIANCE"] = "custom_radiance";
1300
		actions.renames["IRRADIANCE"] = "custom_irradiance";
1301
		actions.renames["BONE_INDICES"] = "bone_attrib";
1302
		actions.renames["BONE_WEIGHTS"] = "weight_attrib";
1303
		actions.renames["CUSTOM0"] = "custom0_attrib";
1304
		actions.renames["CUSTOM1"] = "custom1_attrib";
1305
		actions.renames["CUSTOM2"] = "custom2_attrib";
1306
		actions.renames["CUSTOM3"] = "custom3_attrib";
1307
		actions.renames["LIGHT_VERTEX"] = "light_vertex";
1308

1309
		actions.renames["NODE_POSITION_WORLD"] = "model_matrix[3].xyz";
1310
		actions.renames["CAMERA_POSITION_WORLD"] = "scene_data.inv_view_matrix[3].xyz";
1311
		actions.renames["CAMERA_DIRECTION_WORLD"] = "scene_data.inv_view_matrix[2].xyz";
1312
		actions.renames["CAMERA_VISIBLE_LAYERS"] = "scene_data.camera_visible_layers";
1313
		actions.renames["NODE_POSITION_VIEW"] = "(scene_data.view_matrix * model_matrix)[3].xyz";
1314

1315
		actions.renames["VIEW_INDEX"] = "ViewIndex";
1316
		actions.renames["VIEW_MONO_LEFT"] = "uint(0)";
1317
		actions.renames["VIEW_RIGHT"] = "uint(1)";
1318
		actions.renames["EYE_OFFSET"] = "eye_offset";
1319

1320
		//for light
1321
		actions.renames["VIEW"] = "view";
1322
		actions.renames["SPECULAR_AMOUNT"] = "specular_amount";
1323
		actions.renames["LIGHT_COLOR"] = "light_color";
1324
		actions.renames["LIGHT_IS_DIRECTIONAL"] = "is_directional";
1325
		actions.renames["LIGHT"] = "light";
1326
		actions.renames["ATTENUATION"] = "attenuation";
1327
		actions.renames["DIFFUSE_LIGHT"] = "diffuse_light";
1328
		actions.renames["SPECULAR_LIGHT"] = "specular_light";
1329

1330
		actions.usage_defines["NORMAL"] = "#define NORMAL_USED\n";
1331
		actions.usage_defines["TANGENT"] = "#define TANGENT_USED\n";
1332
		actions.usage_defines["BINORMAL"] = "@TANGENT";
1333
		actions.usage_defines["RIM"] = "#define LIGHT_RIM_USED\n";
1334
		actions.usage_defines["RIM_TINT"] = "@RIM";
1335
		actions.usage_defines["CLEARCOAT"] = "#define LIGHT_CLEARCOAT_USED\n";
1336
		actions.usage_defines["CLEARCOAT_ROUGHNESS"] = "@CLEARCOAT";
1337
		actions.usage_defines["ANISOTROPY"] = "#define LIGHT_ANISOTROPY_USED\n";
1338
		actions.usage_defines["ANISOTROPY_FLOW"] = "@ANISOTROPY";
1339
		actions.usage_defines["AO"] = "#define AO_USED\n";
1340
		actions.usage_defines["AO_LIGHT_AFFECT"] = "#define AO_USED\n";
1341
		actions.usage_defines["UV"] = "#define UV_USED\n";
1342
		actions.usage_defines["UV2"] = "#define UV2_USED\n";
1343
		actions.usage_defines["BONE_INDICES"] = "#define BONES_USED\n";
1344
		actions.usage_defines["BONE_WEIGHTS"] = "#define WEIGHTS_USED\n";
1345
		actions.usage_defines["CUSTOM0"] = "#define CUSTOM0_USED\n";
1346
		actions.usage_defines["CUSTOM1"] = "#define CUSTOM1_USED\n";
1347
		actions.usage_defines["CUSTOM2"] = "#define CUSTOM2_USED\n";
1348
		actions.usage_defines["CUSTOM3"] = "#define CUSTOM3_USED\n";
1349
		actions.usage_defines["NORMAL_MAP"] = "#define NORMAL_MAP_USED\n";
1350
		actions.usage_defines["NORMAL_MAP_DEPTH"] = "@NORMAL_MAP";
1351
		actions.usage_defines["BENT_NORMAL_MAP"] = "#define BENT_NORMAL_MAP_USED\n";
1352
		actions.usage_defines["COLOR"] = "#define COLOR_USED\n";
1353
		actions.usage_defines["INSTANCE_CUSTOM"] = "#define ENABLE_INSTANCE_CUSTOM\n";
1354
		actions.usage_defines["POSITION"] = "#define OVERRIDE_POSITION\n";
1355
		actions.usage_defines["LIGHT_VERTEX"] = "#define LIGHT_VERTEX_USED\n";
1356
		actions.usage_defines["Z_CLIP_SCALE"] = "#define Z_CLIP_SCALE_USED\n";
1357

1358
		actions.usage_defines["ALPHA_SCISSOR_THRESHOLD"] = "#define ALPHA_SCISSOR_USED\n";
1359
		actions.usage_defines["ALPHA_HASH_SCALE"] = "#define ALPHA_HASH_USED\n";
1360
		actions.usage_defines["ALPHA_ANTIALIASING_EDGE"] = "#define ALPHA_ANTIALIASING_EDGE_USED\n";
1361
		actions.usage_defines["ALPHA_TEXTURE_COORDINATE"] = "@ALPHA_ANTIALIASING_EDGE";
1362
		actions.usage_defines["PREMULT_ALPHA_FACTOR"] = "#define PREMULT_ALPHA_USED";
1363

1364
		actions.usage_defines["SSS_STRENGTH"] = "#define ENABLE_SSS\n";
1365
		actions.usage_defines["SSS_TRANSMITTANCE_DEPTH"] = "#define ENABLE_TRANSMITTANCE\n";
1366
		actions.usage_defines["BACKLIGHT"] = "#define LIGHT_BACKLIGHT_USED\n";
1367
		actions.usage_defines["SCREEN_UV"] = "#define SCREEN_UV_USED\n";
1368

1369
		actions.usage_defines["FOG"] = "#define CUSTOM_FOG_USED\n";
1370
		actions.usage_defines["RADIANCE"] = "#define CUSTOM_RADIANCE_USED\n";
1371
		actions.usage_defines["IRRADIANCE"] = "#define CUSTOM_IRRADIANCE_USED\n";
1372

1373
		actions.render_mode_defines["skip_vertex_transform"] = "#define SKIP_TRANSFORM_USED\n";
1374
		actions.render_mode_defines["world_vertex_coords"] = "#define VERTEX_WORLD_COORDS_USED\n";
1375
		actions.render_mode_defines["ensure_correct_normals"] = "#define ENSURE_CORRECT_NORMALS\n";
1376
		actions.render_mode_defines["cull_front"] = "#define DO_SIDE_CHECK\n";
1377
		actions.render_mode_defines["cull_disabled"] = "#define DO_SIDE_CHECK\n";
1378
		actions.render_mode_defines["particle_trails"] = "#define USE_PARTICLE_TRAILS\n";
1379
		actions.render_mode_defines["depth_prepass_alpha"] = "#define USE_OPAQUE_PREPASS\n";
1380

1381
		bool force_lambert = GLOBAL_GET("rendering/shading/overrides/force_lambert_over_burley");
1382

1383
		if (!force_lambert) {
1384
			actions.render_mode_defines["diffuse_burley"] = "#define DIFFUSE_BURLEY\n";
1385
		}
1386

1387
		actions.render_mode_defines["diffuse_lambert_wrap"] = "#define DIFFUSE_LAMBERT_WRAP\n";
1388
		actions.render_mode_defines["diffuse_toon"] = "#define DIFFUSE_TOON\n";
1389

1390
		actions.render_mode_defines["sss_mode_skin"] = "#define SSS_MODE_SKIN\n";
1391

1392
		actions.render_mode_defines["specular_schlick_ggx"] = "#define SPECULAR_SCHLICK_GGX\n";
1393
		actions.render_mode_defines["specular_toon"] = "#define SPECULAR_TOON\n";
1394
		actions.render_mode_defines["specular_disabled"] = "#define SPECULAR_DISABLED\n";
1395
		actions.render_mode_defines["shadows_disabled"] = "#define SHADOWS_DISABLED\n";
1396
		actions.render_mode_defines["ambient_light_disabled"] = "#define AMBIENT_LIGHT_DISABLED\n";
1397
		actions.render_mode_defines["shadow_to_opacity"] = "#define USE_SHADOW_TO_OPACITY\n";
1398
		actions.render_mode_defines["unshaded"] = "#define MODE_UNSHADED\n";
1399
		if (!GLES3::Config::get_singleton()->force_vertex_shading) {
1400
			// If forcing vertex shading, this will be defined already.
1401
			actions.render_mode_defines["vertex_lighting"] = "#define USE_VERTEX_LIGHTING\n";
1402
		}
1403
		actions.render_mode_defines["fog_disabled"] = "#define FOG_DISABLED\n";
1404

1405
		actions.render_mode_defines["specular_occlusion_disabled"] = "#define SPECULAR_OCCLUSION_DISABLED\n";
1406

1407
		actions.default_filter = ShaderLanguage::FILTER_LINEAR_MIPMAP;
1408
		actions.default_repeat = ShaderLanguage::REPEAT_ENABLE;
1409

1410
		actions.check_multiview_samplers = RasterizerGLES3::get_singleton()->is_xr_enabled();
1411
		actions.global_buffer_array_variable = "global_shader_uniforms";
1412
		actions.instance_uniform_index_variable = "instance_offset";
1413

1414
		shaders.compiler_scene.initialize(actions);
1415
	}
1416

1417
	{
1418
		// Setup Particles compiler
1419

1420
		ShaderCompiler::DefaultIdentifierActions actions;
1421

1422
		actions.renames["COLOR"] = "out_color";
1423
		actions.renames["VELOCITY"] = "out_velocity_flags.xyz";
1424
		actions.renames["MASS"] = "mass";
1425
		actions.renames["ACTIVE"] = "particle_active";
1426
		actions.renames["RESTART"] = "restart";
1427
		actions.renames["CUSTOM"] = "out_custom";
1428
		for (int i = 0; i < PARTICLES_MAX_USERDATAS; i++) {
1429
			String udname = "USERDATA" + itos(i + 1);
1430
			actions.renames[udname] = "out_userdata" + itos(i + 1);
1431
			actions.usage_defines[udname] = "#define USERDATA" + itos(i + 1) + "_USED\n";
1432
		}
1433
		actions.renames["TRANSFORM"] = "xform";
1434
		actions.renames["TIME"] = "time";
1435
		actions.renames["PI"] = String::num(Math::PI);
1436
		actions.renames["TAU"] = String::num(Math::TAU);
1437
		actions.renames["E"] = String::num(Math::E);
1438
		actions.renames["LIFETIME"] = "lifetime";
1439
		actions.renames["DELTA"] = "local_delta";
1440
		actions.renames["NUMBER"] = "particle_number";
1441
		actions.renames["INDEX"] = "index";
1442
		actions.renames["AMOUNT_RATIO"] = "amount_ratio";
1443
		//actions.renames["GRAVITY"] = "current_gravity";
1444
		actions.renames["EMISSION_TRANSFORM"] = "emission_transform";
1445
		actions.renames["RANDOM_SEED"] = "random_seed";
1446
		actions.renames["RESTART_POSITION"] = "restart_position";
1447
		actions.renames["RESTART_ROT_SCALE"] = "restart_rotation_scale";
1448
		actions.renames["RESTART_VELOCITY"] = "restart_velocity";
1449
		actions.renames["RESTART_COLOR"] = "restart_color";
1450
		actions.renames["RESTART_CUSTOM"] = "restart_custom";
1451
		actions.renames["COLLIDED"] = "collided";
1452
		actions.renames["COLLISION_NORMAL"] = "collision_normal";
1453
		actions.renames["COLLISION_DEPTH"] = "collision_depth";
1454
		actions.renames["ATTRACTOR_FORCE"] = "attractor_force";
1455
		actions.renames["EMITTER_VELOCITY"] = "emitter_velocity";
1456
		actions.renames["INTERPOLATE_TO_END"] = "interp_to_end";
1457

1458
		// These are unsupported, but may be used by users. To avoid compile time overhead, we add the stub only when used.
1459
		actions.renames["FLAG_EMIT_POSITION"] = "uint(1)";
1460
		actions.renames["FLAG_EMIT_ROT_SCALE"] = "uint(2)";
1461
		actions.renames["FLAG_EMIT_VELOCITY"] = "uint(4)";
1462
		actions.renames["FLAG_EMIT_COLOR"] = "uint(8)";
1463
		actions.renames["FLAG_EMIT_CUSTOM"] = "uint(16)";
1464
		actions.renames["emit_subparticle"] = "emit_subparticle";
1465
		actions.usage_defines["emit_subparticle"] = "\nbool emit_subparticle(mat4 p_xform, vec3 p_velocity, vec4 p_color, vec4 p_custom, uint p_flags) {\n\treturn false;\n}\n";
1466

1467
		actions.render_mode_defines["disable_force"] = "#define DISABLE_FORCE\n";
1468
		actions.render_mode_defines["disable_velocity"] = "#define DISABLE_VELOCITY\n";
1469
		actions.render_mode_defines["keep_data"] = "#define ENABLE_KEEP_DATA\n";
1470
		actions.render_mode_defines["collision_use_scale"] = "#define USE_COLLISION_SCALE\n";
1471

1472
		actions.default_filter = ShaderLanguage::FILTER_LINEAR_MIPMAP;
1473
		actions.default_repeat = ShaderLanguage::REPEAT_ENABLE;
1474

1475
		actions.global_buffer_array_variable = "global_shader_uniforms";
1476

1477
		shaders.compiler_particles.initialize(actions);
1478
	}
1479

1480
	{
1481
		// Setup Sky compiler
1482
		ShaderCompiler::DefaultIdentifierActions actions;
1483

1484
		actions.renames["COLOR"] = "color";
1485
		actions.renames["ALPHA"] = "alpha";
1486
		actions.renames["EYEDIR"] = "cube_normal";
1487
		actions.renames["POSITION"] = "position";
1488
		actions.renames["SKY_COORDS"] = "panorama_coords";
1489
		actions.renames["SCREEN_UV"] = "uv";
1490
		actions.renames["TIME"] = "time";
1491
		actions.renames["FRAGCOORD"] = "gl_FragCoord";
1492
		actions.renames["PI"] = String::num(Math::PI);
1493
		actions.renames["TAU"] = String::num(Math::TAU);
1494
		actions.renames["E"] = String::num(Math::E);
1495
		actions.renames["HALF_RES_COLOR"] = "half_res_color";
1496
		actions.renames["QUARTER_RES_COLOR"] = "quarter_res_color";
1497
		actions.renames["RADIANCE"] = "radiance";
1498
		actions.renames["FOG"] = "custom_fog";
1499
		actions.renames["LIGHT0_ENABLED"] = "directional_lights.data[0].enabled";
1500
		actions.renames["LIGHT0_DIRECTION"] = "directional_lights.data[0].direction_energy.xyz";
1501
		actions.renames["LIGHT0_ENERGY"] = "directional_lights.data[0].direction_energy.w";
1502
		actions.renames["LIGHT0_COLOR"] = "directional_lights.data[0].color_size.xyz";
1503
		actions.renames["LIGHT0_SIZE"] = "directional_lights.data[0].color_size.w";
1504
		actions.renames["LIGHT1_ENABLED"] = "directional_lights.data[1].enabled";
1505
		actions.renames["LIGHT1_DIRECTION"] = "directional_lights.data[1].direction_energy.xyz";
1506
		actions.renames["LIGHT1_ENERGY"] = "directional_lights.data[1].direction_energy.w";
1507
		actions.renames["LIGHT1_COLOR"] = "directional_lights.data[1].color_size.xyz";
1508
		actions.renames["LIGHT1_SIZE"] = "directional_lights.data[1].color_size.w";
1509
		actions.renames["LIGHT2_ENABLED"] = "directional_lights.data[2].enabled";
1510
		actions.renames["LIGHT2_DIRECTION"] = "directional_lights.data[2].direction_energy.xyz";
1511
		actions.renames["LIGHT2_ENERGY"] = "directional_lights.data[2].direction_energy.w";
1512
		actions.renames["LIGHT2_COLOR"] = "directional_lights.data[2].color_size.xyz";
1513
		actions.renames["LIGHT2_SIZE"] = "directional_lights.data[2].color_size.w";
1514
		actions.renames["LIGHT3_ENABLED"] = "directional_lights.data[3].enabled";
1515
		actions.renames["LIGHT3_DIRECTION"] = "directional_lights.data[3].direction_energy.xyz";
1516
		actions.renames["LIGHT3_ENERGY"] = "directional_lights.data[3].direction_energy.w";
1517
		actions.renames["LIGHT3_COLOR"] = "directional_lights.data[3].color_size.xyz";
1518
		actions.renames["LIGHT3_SIZE"] = "directional_lights.data[3].color_size.w";
1519
		actions.renames["AT_CUBEMAP_PASS"] = "AT_CUBEMAP_PASS";
1520
		actions.renames["AT_HALF_RES_PASS"] = "AT_HALF_RES_PASS";
1521
		actions.renames["AT_QUARTER_RES_PASS"] = "AT_QUARTER_RES_PASS";
1522
		actions.usage_defines["HALF_RES_COLOR"] = "\n#define USES_HALF_RES_COLOR\n";
1523
		actions.usage_defines["QUARTER_RES_COLOR"] = "\n#define USES_QUARTER_RES_COLOR\n";
1524
		actions.render_mode_defines["disable_fog"] = "#define DISABLE_FOG\n";
1525
		actions.render_mode_defines["use_debanding"] = "#define USE_DEBANDING\n";
1526

1527
		actions.default_filter = ShaderLanguage::FILTER_LINEAR_MIPMAP;
1528
		actions.default_repeat = ShaderLanguage::REPEAT_ENABLE;
1529

1530
		actions.global_buffer_array_variable = "global_shader_uniforms";
1531

1532
		shaders.compiler_sky.initialize(actions);
1533
	}
1534
}
1535

1536
MaterialStorage::~MaterialStorage() {
1537
	//shaders.copy.version_free(shaders.copy_version);
1538

1539
	memdelete_arr(global_shader_uniforms.buffer_values);
1540
	memdelete_arr(global_shader_uniforms.buffer_usage);
1541
	memdelete_arr(global_shader_uniforms.buffer_dirty_regions);
1542
	glDeleteBuffers(1, &global_shader_uniforms.buffer);
1543

1544
	singleton = nullptr;
1545
}
1546

1547
/* GLOBAL SHADER UNIFORM API */
1548

1549
int32_t MaterialStorage::_global_shader_uniform_allocate(uint32_t p_elements) {
1550
	int32_t idx = 0;
1551
	while (idx + p_elements <= global_shader_uniforms.buffer_size) {
1552
		if (global_shader_uniforms.buffer_usage[idx].elements == 0) {
1553
			bool valid = true;
1554
			for (uint32_t i = 1; i < p_elements; i++) {
1555
				if (global_shader_uniforms.buffer_usage[idx + i].elements > 0) {
1556
					valid = false;
1557
					idx += i + global_shader_uniforms.buffer_usage[idx + i].elements;
1558
					break;
1559
				}
1560
			}
1561

1562
			if (!valid) {
1563
				continue; //if not valid, idx is in new position
1564
			}
1565

1566
			return idx;
1567
		} else {
1568
			idx += global_shader_uniforms.buffer_usage[idx].elements;
1569
		}
1570
	}
1571

1572
	return -1;
1573
}
1574

1575
void MaterialStorage::_global_shader_uniform_store_in_buffer(int32_t p_index, RS::GlobalShaderParameterType p_type, const Variant &p_value) {
1576
	switch (p_type) {
1577
		case RS::GLOBAL_VAR_TYPE_BOOL: {
1578
			GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
1579
			bool b = p_value;
1580
			bv.x = b ? 1.0 : 0.0;
1581
			bv.y = 0.0;
1582
			bv.z = 0.0;
1583
			bv.w = 0.0;
1584

1585
		} break;
1586
		case RS::GLOBAL_VAR_TYPE_BVEC2: {
1587
			GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
1588
			uint32_t bvec = p_value;
1589
			bv.x = (bvec & 1) ? 1.0 : 0.0;
1590
			bv.y = (bvec & 2) ? 1.0 : 0.0;
1591
			bv.z = 0.0;
1592
			bv.w = 0.0;
1593
		} break;
1594
		case RS::GLOBAL_VAR_TYPE_BVEC3: {
1595
			GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
1596
			uint32_t bvec = p_value;
1597
			bv.x = (bvec & 1) ? 1.0 : 0.0;
1598
			bv.y = (bvec & 2) ? 1.0 : 0.0;
1599
			bv.z = (bvec & 4) ? 1.0 : 0.0;
1600
			bv.w = 0.0;
1601
		} break;
1602
		case RS::GLOBAL_VAR_TYPE_BVEC4: {
1603
			GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
1604
			uint32_t bvec = p_value;
1605
			bv.x = (bvec & 1) ? 1.0 : 0.0;
1606
			bv.y = (bvec & 2) ? 1.0 : 0.0;
1607
			bv.z = (bvec & 4) ? 1.0 : 0.0;
1608
			bv.w = (bvec & 8) ? 1.0 : 0.0;
1609
		} break;
1610
		case RS::GLOBAL_VAR_TYPE_INT: {
1611
			GlobalShaderUniforms::ValueInt &bv = *(GlobalShaderUniforms::ValueInt *)&global_shader_uniforms.buffer_values[p_index];
1612
			int32_t v = p_value;
1613
			bv.x = v;
1614
			bv.y = 0;
1615
			bv.z = 0;
1616
			bv.w = 0;
1617
		} break;
1618
		case RS::GLOBAL_VAR_TYPE_IVEC2: {
1619
			GlobalShaderUniforms::ValueInt &bv = *(GlobalShaderUniforms::ValueInt *)&global_shader_uniforms.buffer_values[p_index];
1620
			Vector2i v = convert_to_vector<Vector2i>(p_value);
1621
			bv.x = v.x;
1622
			bv.y = v.y;
1623
			bv.z = 0;
1624
			bv.w = 0;
1625
		} break;
1626
		case RS::GLOBAL_VAR_TYPE_IVEC3: {
1627
			GlobalShaderUniforms::ValueInt &bv = *(GlobalShaderUniforms::ValueInt *)&global_shader_uniforms.buffer_values[p_index];
1628
			Vector3i v = convert_to_vector<Vector3i>(p_value);
1629
			bv.x = v.x;
1630
			bv.y = v.y;
1631
			bv.z = v.z;
1632
			bv.w = 0;
1633
		} break;
1634
		case RS::GLOBAL_VAR_TYPE_IVEC4: {
1635
			GlobalShaderUniforms::ValueInt &bv = *(GlobalShaderUniforms::ValueInt *)&global_shader_uniforms.buffer_values[p_index];
1636
			Vector4i v = convert_to_vector<Vector4i>(p_value);
1637
			bv.x = v.x;
1638
			bv.y = v.y;
1639
			bv.z = v.z;
1640
			bv.w = v.w;
1641
		} break;
1642
		case RS::GLOBAL_VAR_TYPE_RECT2I: {
1643
			GlobalShaderUniforms::ValueInt &bv = *(GlobalShaderUniforms::ValueInt *)&global_shader_uniforms.buffer_values[p_index];
1644
			Rect2i v = p_value;
1645
			bv.x = v.position.x;
1646
			bv.y = v.position.y;
1647
			bv.z = v.size.x;
1648
			bv.w = v.size.y;
1649
		} break;
1650
		case RS::GLOBAL_VAR_TYPE_UINT: {
1651
			GlobalShaderUniforms::ValueUInt &bv = *(GlobalShaderUniforms::ValueUInt *)&global_shader_uniforms.buffer_values[p_index];
1652
			uint32_t v = p_value;
1653
			bv.x = v;
1654
			bv.y = 0;
1655
			bv.z = 0;
1656
			bv.w = 0;
1657
		} break;
1658
		case RS::GLOBAL_VAR_TYPE_UVEC2: {
1659
			GlobalShaderUniforms::ValueUInt &bv = *(GlobalShaderUniforms::ValueUInt *)&global_shader_uniforms.buffer_values[p_index];
1660
			Vector2i v = convert_to_vector<Vector2i>(p_value);
1661
			bv.x = v.x;
1662
			bv.y = v.y;
1663
			bv.z = 0;
1664
			bv.w = 0;
1665
		} break;
1666
		case RS::GLOBAL_VAR_TYPE_UVEC3: {
1667
			GlobalShaderUniforms::ValueUInt &bv = *(GlobalShaderUniforms::ValueUInt *)&global_shader_uniforms.buffer_values[p_index];
1668
			Vector3i v = convert_to_vector<Vector3i>(p_value);
1669
			bv.x = v.x;
1670
			bv.y = v.y;
1671
			bv.z = v.z;
1672
			bv.w = 0;
1673
		} break;
1674
		case RS::GLOBAL_VAR_TYPE_UVEC4: {
1675
			GlobalShaderUniforms::ValueUInt &bv = *(GlobalShaderUniforms::ValueUInt *)&global_shader_uniforms.buffer_values[p_index];
1676
			Vector4i v = convert_to_vector<Vector4i>(p_value);
1677
			bv.x = v.x;
1678
			bv.y = v.y;
1679
			bv.z = v.z;
1680
			bv.w = v.w;
1681
		} break;
1682
		case RS::GLOBAL_VAR_TYPE_FLOAT: {
1683
			GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
1684
			float v = p_value;
1685
			bv.x = v;
1686
			bv.y = 0;
1687
			bv.z = 0;
1688
			bv.w = 0;
1689
		} break;
1690
		case RS::GLOBAL_VAR_TYPE_VEC2: {
1691
			GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
1692
			Vector2 v = convert_to_vector<Vector2>(p_value);
1693
			bv.x = v.x;
1694
			bv.y = v.y;
1695
			bv.z = 0;
1696
			bv.w = 0;
1697
		} break;
1698
		case RS::GLOBAL_VAR_TYPE_VEC3: {
1699
			GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
1700
			Vector3 v = convert_to_vector<Vector3>(p_value);
1701
			bv.x = v.x;
1702
			bv.y = v.y;
1703
			bv.z = v.z;
1704
			bv.w = 0;
1705
		} break;
1706
		case RS::GLOBAL_VAR_TYPE_VEC4: {
1707
			GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
1708
			Vector4 v = convert_to_vector<Vector4>(p_value);
1709
			bv.x = v.x;
1710
			bv.y = v.y;
1711
			bv.z = v.z;
1712
			bv.w = v.w;
1713
		} break;
1714
		case RS::GLOBAL_VAR_TYPE_COLOR: {
1715
			GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
1716
			Color v = p_value;
1717
			bv.x = v.r;
1718
			bv.y = v.g;
1719
			bv.z = v.b;
1720
			bv.w = v.a;
1721

1722
			GlobalShaderUniforms::Value &bv_linear = global_shader_uniforms.buffer_values[p_index + 1];
1723
			//v = v.srgb_to_linear();
1724
			bv_linear.x = v.r;
1725
			bv_linear.y = v.g;
1726
			bv_linear.z = v.b;
1727
			bv_linear.w = v.a;
1728

1729
		} break;
1730
		case RS::GLOBAL_VAR_TYPE_RECT2: {
1731
			GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
1732
			Rect2 v = p_value;
1733
			bv.x = v.position.x;
1734
			bv.y = v.position.y;
1735
			bv.z = v.size.x;
1736
			bv.w = v.size.y;
1737
		} break;
1738
		case RS::GLOBAL_VAR_TYPE_MAT2: {
1739
			GlobalShaderUniforms::Value *bv = &global_shader_uniforms.buffer_values[p_index];
1740
			Vector<float> m2 = p_value;
1741
			if (m2.size() < 4) {
1742
				m2.resize(4);
1743
			}
1744
			bv[0].x = m2[0];
1745
			bv[0].y = m2[1];
1746
			bv[0].z = 0;
1747
			bv[0].w = 0;
1748

1749
			bv[1].x = m2[2];
1750
			bv[1].y = m2[3];
1751
			bv[1].z = 0;
1752
			bv[1].w = 0;
1753

1754
		} break;
1755
		case RS::GLOBAL_VAR_TYPE_MAT3: {
1756
			GlobalShaderUniforms::Value *bv = &global_shader_uniforms.buffer_values[p_index];
1757
			Basis v = p_value;
1758
			convert_item_std140<Basis>(v, &bv->x);
1759

1760
		} break;
1761
		case RS::GLOBAL_VAR_TYPE_MAT4: {
1762
			GlobalShaderUniforms::Value *bv = &global_shader_uniforms.buffer_values[p_index];
1763
			Projection m = p_value;
1764
			convert_item_std140<Projection>(m, &bv->x);
1765

1766
		} break;
1767
		case RS::GLOBAL_VAR_TYPE_TRANSFORM_2D: {
1768
			GlobalShaderUniforms::Value *bv = &global_shader_uniforms.buffer_values[p_index];
1769
			Transform2D v = p_value;
1770
			convert_item_std140<Transform2D>(v, &bv->x);
1771

1772
		} break;
1773
		case RS::GLOBAL_VAR_TYPE_TRANSFORM: {
1774
			GlobalShaderUniforms::Value *bv = &global_shader_uniforms.buffer_values[p_index];
1775
			Transform3D v = p_value;
1776
			convert_item_std140<Transform3D>(v, &bv->x);
1777

1778
		} break;
1779
		default: {
1780
			ERR_FAIL();
1781
		}
1782
	}
1783
}
1784

1785
void MaterialStorage::_global_shader_uniform_mark_buffer_dirty(int32_t p_index, int32_t p_elements) {
1786
	int32_t prev_chunk = -1;
1787

1788
	for (int32_t i = 0; i < p_elements; i++) {
1789
		int32_t chunk = (p_index + i) / GlobalShaderUniforms::BUFFER_DIRTY_REGION_SIZE;
1790
		if (chunk != prev_chunk) {
1791
			if (!global_shader_uniforms.buffer_dirty_regions[chunk]) {
1792
				global_shader_uniforms.buffer_dirty_regions[chunk] = true;
1793
				global_shader_uniforms.buffer_dirty_region_count++;
1794
			}
1795
		}
1796

1797
		prev_chunk = chunk;
1798
	}
1799
}
1800

1801
void MaterialStorage::global_shader_parameter_add(const StringName &p_name, RS::GlobalShaderParameterType p_type, const Variant &p_value) {
1802
	ERR_FAIL_COND(global_shader_uniforms.variables.has(p_name));
1803
	GlobalShaderUniforms::Variable gv;
1804
	gv.type = p_type;
1805
	gv.value = p_value;
1806
	gv.buffer_index = -1;
1807

1808
	if (p_type >= RS::GLOBAL_VAR_TYPE_SAMPLER2D) {
1809
		//is texture
1810
		global_shader_uniforms.must_update_texture_materials = true; //normally there are none
1811
	} else {
1812
		gv.buffer_elements = 1;
1813
		if (p_type == RS::GLOBAL_VAR_TYPE_COLOR || p_type == RS::GLOBAL_VAR_TYPE_MAT2) {
1814
			//color needs to elements to store srgb and linear
1815
			gv.buffer_elements = 2;
1816
		}
1817
		if (p_type == RS::GLOBAL_VAR_TYPE_MAT3 || p_type == RS::GLOBAL_VAR_TYPE_TRANSFORM_2D) {
1818
			//color needs to elements to store srgb and linear
1819
			gv.buffer_elements = 3;
1820
		}
1821
		if (p_type == RS::GLOBAL_VAR_TYPE_MAT4 || p_type == RS::GLOBAL_VAR_TYPE_TRANSFORM) {
1822
			//color needs to elements to store srgb and linear
1823
			gv.buffer_elements = 4;
1824
		}
1825

1826
		//is vector, allocate in buffer and update index
1827
		gv.buffer_index = _global_shader_uniform_allocate(gv.buffer_elements);
1828
		ERR_FAIL_COND_MSG(gv.buffer_index < 0, vformat("Failed allocating global variable '%s' out of buffer memory. Consider increasing rendering/limits/global_shader_variables/buffer_size in the Project Settings. Maximum items supported by this hardware is: %d.", String(p_name), Config::get_singleton()->max_uniform_buffer_size / sizeof(GlobalShaderUniforms::Value)));
1829
		global_shader_uniforms.buffer_usage[gv.buffer_index].elements = gv.buffer_elements;
1830
		_global_shader_uniform_store_in_buffer(gv.buffer_index, gv.type, gv.value);
1831
		_global_shader_uniform_mark_buffer_dirty(gv.buffer_index, gv.buffer_elements);
1832

1833
		global_shader_uniforms.must_update_buffer_materials = true; //normally there are none
1834
	}
1835

1836
	global_shader_uniforms.variables[p_name] = gv;
1837
}
1838

1839
void MaterialStorage::global_shader_parameter_remove(const StringName &p_name) {
1840
	if (!global_shader_uniforms.variables.has(p_name)) {
1841
		return;
1842
	}
1843
	GlobalShaderUniforms::Variable &gv = global_shader_uniforms.variables[p_name];
1844

1845
	if (gv.buffer_index >= 0) {
1846
		global_shader_uniforms.buffer_usage[gv.buffer_index].elements = 0;
1847
		global_shader_uniforms.must_update_buffer_materials = true;
1848
	} else {
1849
		global_shader_uniforms.must_update_texture_materials = true;
1850
	}
1851

1852
	global_shader_uniforms.variables.erase(p_name);
1853
}
1854

1855
Vector<StringName> MaterialStorage::global_shader_parameter_get_list() const {
1856
	if (!Engine::get_singleton()->is_editor_hint()) {
1857
		ERR_FAIL_V_MSG(Vector<StringName>(), "This function should never be used outside the editor, it can severely damage performance.");
1858
	}
1859

1860
	Vector<StringName> names;
1861
	for (const KeyValue<StringName, GlobalShaderUniforms::Variable> &E : global_shader_uniforms.variables) {
1862
		names.push_back(E.key);
1863
	}
1864
	names.sort_custom<StringName::AlphCompare>();
1865
	return names;
1866
}
1867

1868
void MaterialStorage::global_shader_parameter_set(const StringName &p_name, const Variant &p_value) {
1869
	ERR_FAIL_COND(!global_shader_uniforms.variables.has(p_name));
1870
	GlobalShaderUniforms::Variable &gv = global_shader_uniforms.variables[p_name];
1871
	gv.value = p_value;
1872
	if (gv.override.get_type() == Variant::NIL) {
1873
		if (gv.buffer_index >= 0) {
1874
			//buffer
1875
			_global_shader_uniform_store_in_buffer(gv.buffer_index, gv.type, gv.value);
1876
			_global_shader_uniform_mark_buffer_dirty(gv.buffer_index, gv.buffer_elements);
1877
		} else {
1878
			//texture
1879
			MaterialStorage *material_storage = MaterialStorage::get_singleton();
1880
			for (const RID &E : gv.texture_materials) {
1881
				Material *material = material_storage->get_material(E);
1882
				ERR_CONTINUE(!material);
1883
				material_storage->_material_queue_update(material, false, true);
1884
			}
1885
		}
1886
	}
1887
}
1888

1889
void MaterialStorage::global_shader_parameter_set_override(const StringName &p_name, const Variant &p_value) {
1890
	if (!global_shader_uniforms.variables.has(p_name)) {
1891
		return; //variable may not exist
1892
	}
1893

1894
	ERR_FAIL_COND(p_value.get_type() == Variant::OBJECT);
1895

1896
	GlobalShaderUniforms::Variable &gv = global_shader_uniforms.variables[p_name];
1897

1898
	gv.override = p_value;
1899

1900
	if (gv.buffer_index >= 0) {
1901
		//buffer
1902
		if (gv.override.get_type() == Variant::NIL) {
1903
			_global_shader_uniform_store_in_buffer(gv.buffer_index, gv.type, gv.value);
1904
		} else {
1905
			_global_shader_uniform_store_in_buffer(gv.buffer_index, gv.type, gv.override);
1906
		}
1907

1908
		_global_shader_uniform_mark_buffer_dirty(gv.buffer_index, gv.buffer_elements);
1909
	} else {
1910
		//texture
1911
		MaterialStorage *material_storage = MaterialStorage::get_singleton();
1912
		for (const RID &E : gv.texture_materials) {
1913
			Material *material = material_storage->get_material(E);
1914
			ERR_CONTINUE(!material);
1915
			material_storage->_material_queue_update(material, false, true);
1916
		}
1917
	}
1918
}
1919

1920
Variant MaterialStorage::global_shader_parameter_get(const StringName &p_name) const {
1921
	if (!Engine::get_singleton()->is_editor_hint()) {
1922
		ERR_FAIL_V_MSG(Variant(), "This function should never be used outside the editor, it can severely damage performance.");
1923
	}
1924

1925
	if (!global_shader_uniforms.variables.has(p_name)) {
1926
		return Variant();
1927
	}
1928

1929
	return global_shader_uniforms.variables[p_name].value;
1930
}
1931

1932
RS::GlobalShaderParameterType MaterialStorage::global_shader_parameter_get_type_internal(const StringName &p_name) const {
1933
	if (!global_shader_uniforms.variables.has(p_name)) {
1934
		return RS::GLOBAL_VAR_TYPE_MAX;
1935
	}
1936

1937
	return global_shader_uniforms.variables[p_name].type;
1938
}
1939

1940
RS::GlobalShaderParameterType MaterialStorage::global_shader_parameter_get_type(const StringName &p_name) const {
1941
	if (!Engine::get_singleton()->is_editor_hint()) {
1942
		ERR_FAIL_V_MSG(RS::GLOBAL_VAR_TYPE_MAX, "This function should never be used outside the editor, it can severely damage performance.");
1943
	}
1944

1945
	return global_shader_parameter_get_type_internal(p_name);
1946
}
1947

1948
void MaterialStorage::global_shader_parameters_load_settings(bool p_load_textures) {
1949
	List<PropertyInfo> settings;
1950
	ProjectSettings::get_singleton()->get_property_list(&settings);
1951

1952
	for (const PropertyInfo &E : settings) {
1953
		if (E.name.begins_with("shader_globals/")) {
1954
			StringName name = E.name.get_slicec('/', 1);
1955
			Dictionary d = GLOBAL_GET(E.name);
1956

1957
			ERR_CONTINUE(!d.has("type"));
1958
			ERR_CONTINUE(!d.has("value"));
1959

1960
			String type = d["type"];
1961

1962
			static const char *global_var_type_names[RS::GLOBAL_VAR_TYPE_MAX] = {
1963
				"bool",
1964
				"bvec2",
1965
				"bvec3",
1966
				"bvec4",
1967
				"int",
1968
				"ivec2",
1969
				"ivec3",
1970
				"ivec4",
1971
				"rect2i",
1972
				"uint",
1973
				"uvec2",
1974
				"uvec3",
1975
				"uvec4",
1976
				"float",
1977
				"vec2",
1978
				"vec3",
1979
				"vec4",
1980
				"color",
1981
				"rect2",
1982
				"mat2",
1983
				"mat3",
1984
				"mat4",
1985
				"transform_2d",
1986
				"transform",
1987
				"sampler2D",
1988
				"sampler2DArray",
1989
				"sampler3D",
1990
				"samplerCube",
1991
				"samplerExternalOES"
1992
			};
1993

1994
			RS::GlobalShaderParameterType gvtype = RS::GLOBAL_VAR_TYPE_MAX;
1995

1996
			for (int i = 0; i < RS::GLOBAL_VAR_TYPE_MAX; i++) {
1997
				if (global_var_type_names[i] == type) {
1998
					gvtype = RS::GlobalShaderParameterType(i);
1999
					break;
2000
				}
2001
			}
2002

2003
			ERR_CONTINUE(gvtype == RS::GLOBAL_VAR_TYPE_MAX); //type invalid
2004

2005
			Variant value = d["value"];
2006

2007
			if (gvtype >= RS::GLOBAL_VAR_TYPE_SAMPLER2D) {
2008
				String path = value;
2009
				// Don't load the textures, but still add the parameter so shaders compile correctly while loading.
2010
				if (!p_load_textures || path.is_empty()) {
2011
					value = RID();
2012
				} else {
2013
					Ref<Resource> resource = ResourceLoader::load(path);
2014
					value = resource;
2015
				}
2016
			}
2017

2018
			if (global_shader_uniforms.variables.has(name)) {
2019
				//has it, update it
2020
				global_shader_parameter_set(name, value);
2021
			} else {
2022
				global_shader_parameter_add(name, gvtype, value);
2023
			}
2024
		}
2025
	}
2026
}
2027

2028
void MaterialStorage::global_shader_parameters_clear() {
2029
	global_shader_uniforms.variables.clear();
2030
}
2031

2032
GLuint MaterialStorage::global_shader_parameters_get_uniform_buffer() const {
2033
	return global_shader_uniforms.buffer;
2034
}
2035

2036
int32_t MaterialStorage::global_shader_parameters_instance_allocate(RID p_instance) {
2037
	ERR_FAIL_COND_V(global_shader_uniforms.instance_buffer_pos.has(p_instance), -1);
2038
	int32_t pos = _global_shader_uniform_allocate(ShaderLanguage::MAX_INSTANCE_UNIFORM_INDICES);
2039
	global_shader_uniforms.instance_buffer_pos[p_instance] = pos; //save anyway
2040
	ERR_FAIL_COND_V_MSG(pos < 0, -1, vformat("Too many instances using shader instance variables. Consider increasing rendering/limits/global_shader_variables/buffer_size in the Project Settings. Maximum items supported by this hardware is: %d.", Config::get_singleton()->max_uniform_buffer_size / sizeof(GlobalShaderUniforms::Value)));
2041
	global_shader_uniforms.buffer_usage[pos].elements = ShaderLanguage::MAX_INSTANCE_UNIFORM_INDICES;
2042
	return pos;
2043
}
2044

2045
void MaterialStorage::global_shader_parameters_instance_free(RID p_instance) {
2046
	ERR_FAIL_COND(!global_shader_uniforms.instance_buffer_pos.has(p_instance));
2047
	int32_t pos = global_shader_uniforms.instance_buffer_pos[p_instance];
2048
	if (pos >= 0) {
2049
		global_shader_uniforms.buffer_usage[pos].elements = 0;
2050
	}
2051
	global_shader_uniforms.instance_buffer_pos.erase(p_instance);
2052
}
2053

2054
void MaterialStorage::global_shader_parameters_instance_update(RID p_instance, int p_index, const Variant &p_value, int p_flags_count) {
2055
	if (!global_shader_uniforms.instance_buffer_pos.has(p_instance)) {
2056
		return; //just not allocated, ignore
2057
	}
2058
	int32_t pos = global_shader_uniforms.instance_buffer_pos[p_instance];
2059

2060
	if (pos < 0) {
2061
		return; //again, not allocated, ignore
2062
	}
2063
	ERR_FAIL_INDEX(p_index, ShaderLanguage::MAX_INSTANCE_UNIFORM_INDICES);
2064

2065
	Variant::Type value_type = p_value.get_type();
2066
	ERR_FAIL_COND_MSG(p_value.get_type() > Variant::COLOR, "Unsupported variant type for instance parameter: " + Variant::get_type_name(value_type)); //anything greater not supported
2067

2068
	ShaderLanguage::DataType datatype_from_value[Variant::COLOR + 1] = {
2069
		ShaderLanguage::TYPE_MAX, //nil
2070
		ShaderLanguage::TYPE_BOOL, //bool
2071
		ShaderLanguage::TYPE_INT, //int
2072
		ShaderLanguage::TYPE_FLOAT, //float
2073
		ShaderLanguage::TYPE_MAX, //string
2074
		ShaderLanguage::TYPE_VEC2, //vec2
2075
		ShaderLanguage::TYPE_IVEC2, //vec2i
2076
		ShaderLanguage::TYPE_VEC4, //rect2
2077
		ShaderLanguage::TYPE_IVEC4, //rect2i
2078
		ShaderLanguage::TYPE_VEC3, // vec3
2079
		ShaderLanguage::TYPE_IVEC3, //vec3i
2080
		ShaderLanguage::TYPE_MAX, //xform2d not supported here
2081
		ShaderLanguage::TYPE_VEC4, //vec4
2082
		ShaderLanguage::TYPE_IVEC4, //vec4i
2083
		ShaderLanguage::TYPE_VEC4, //plane
2084
		ShaderLanguage::TYPE_VEC4, //quat
2085
		ShaderLanguage::TYPE_MAX, //aabb not supported here
2086
		ShaderLanguage::TYPE_MAX, //basis not supported here
2087
		ShaderLanguage::TYPE_MAX, //xform not supported here
2088
		ShaderLanguage::TYPE_MAX, //projection not supported here
2089
		ShaderLanguage::TYPE_VEC4 //color
2090
	};
2091

2092
	ShaderLanguage::DataType datatype = ShaderLanguage::TYPE_MAX;
2093
	if (value_type == Variant::INT && p_flags_count > 0) {
2094
		switch (p_flags_count) {
2095
			case 1:
2096
				datatype = ShaderLanguage::TYPE_BVEC2;
2097
				break;
2098
			case 2:
2099
				datatype = ShaderLanguage::TYPE_BVEC3;
2100
				break;
2101
			case 3:
2102
				datatype = ShaderLanguage::TYPE_BVEC4;
2103
				break;
2104
		}
2105
	} else {
2106
		datatype = datatype_from_value[value_type];
2107
	}
2108

2109
	ERR_FAIL_COND_MSG(datatype == ShaderLanguage::TYPE_MAX, "Unsupported variant type for instance parameter: " + Variant::get_type_name(value_type)); //anything greater not supported
2110

2111
	pos += p_index;
2112

2113
	_fill_std140_variant_ubo_value(datatype, 0, p_value, (uint8_t *)&global_shader_uniforms.buffer_values[pos]);
2114
	_global_shader_uniform_mark_buffer_dirty(pos, 1);
2115
}
2116

2117
void MaterialStorage::_update_global_shader_uniforms() {
2118
	MaterialStorage *material_storage = MaterialStorage::get_singleton();
2119
	if (global_shader_uniforms.buffer_dirty_region_count > 0) {
2120
		uint32_t total_regions = 1 + (global_shader_uniforms.buffer_size / GlobalShaderUniforms::BUFFER_DIRTY_REGION_SIZE);
2121
		if (total_regions / global_shader_uniforms.buffer_dirty_region_count <= 4) {
2122
			// 25% of regions dirty, just update all buffer
2123
			glBindBuffer(GL_UNIFORM_BUFFER, global_shader_uniforms.buffer);
2124
			glBufferData(GL_UNIFORM_BUFFER, sizeof(GlobalShaderUniforms::Value) * global_shader_uniforms.buffer_size, global_shader_uniforms.buffer_values, GL_DYNAMIC_DRAW);
2125
			glBindBuffer(GL_UNIFORM_BUFFER, 0);
2126
			memset(global_shader_uniforms.buffer_dirty_regions, 0, sizeof(bool) * total_regions);
2127
		} else {
2128
			uint32_t region_byte_size = sizeof(GlobalShaderUniforms::Value) * GlobalShaderUniforms::BUFFER_DIRTY_REGION_SIZE;
2129
			glBindBuffer(GL_UNIFORM_BUFFER, global_shader_uniforms.buffer);
2130
			for (uint32_t i = 0; i < total_regions; i++) {
2131
				if (global_shader_uniforms.buffer_dirty_regions[i]) {
2132
					glBufferSubData(GL_UNIFORM_BUFFER, i * region_byte_size, region_byte_size, &global_shader_uniforms.buffer_values[i * GlobalShaderUniforms::BUFFER_DIRTY_REGION_SIZE]);
2133
					global_shader_uniforms.buffer_dirty_regions[i] = false;
2134
				}
2135
			}
2136
			glBindBuffer(GL_UNIFORM_BUFFER, 0);
2137
		}
2138

2139
		global_shader_uniforms.buffer_dirty_region_count = 0;
2140
	}
2141

2142
	if (global_shader_uniforms.must_update_buffer_materials) {
2143
		// only happens in the case of a buffer variable added or removed,
2144
		// so not often.
2145
		for (const RID &E : global_shader_uniforms.materials_using_buffer) {
2146
			Material *material = material_storage->get_material(E);
2147
			ERR_CONTINUE(!material); //wtf
2148

2149
			material_storage->_material_queue_update(material, true, false);
2150
		}
2151

2152
		global_shader_uniforms.must_update_buffer_materials = false;
2153
	}
2154

2155
	if (global_shader_uniforms.must_update_texture_materials) {
2156
		// only happens in the case of a buffer variable added or removed,
2157
		// so not often.
2158
		for (const RID &E : global_shader_uniforms.materials_using_texture) {
2159
			Material *material = material_storage->get_material(E);
2160
			ERR_CONTINUE(!material); //wtf
2161

2162
			material_storage->_material_queue_update(material, false, true);
2163
		}
2164

2165
		global_shader_uniforms.must_update_texture_materials = false;
2166
	}
2167
}
2168

2169
/* SHADER API */
2170

2171
RID MaterialStorage::shader_allocate() {
2172
	return shader_owner.allocate_rid();
2173
}
2174

2175
void MaterialStorage::shader_initialize(RID p_rid, bool p_embedded) {
2176
	Shader shader;
2177
	shader.data = nullptr;
2178
	shader.mode = RS::SHADER_MAX;
2179

2180
	shader_owner.initialize_rid(p_rid, shader);
2181
}
2182

2183
void MaterialStorage::shader_free(RID p_rid) {
2184
	GLES3::Shader *shader = shader_owner.get_or_null(p_rid);
2185
	ERR_FAIL_NULL(shader);
2186

2187
	//make material unreference this
2188
	while (shader->owners.size()) {
2189
		material_set_shader((*shader->owners.begin())->self, RID());
2190
	}
2191

2192
	//clear data if exists
2193
	if (shader->data) {
2194
		memdelete(shader->data);
2195
	}
2196
	shader_owner.free(p_rid);
2197
}
2198

2199
void MaterialStorage::shader_set_code(RID p_shader, const String &p_code) {
2200
	GLES3::Shader *shader = shader_owner.get_or_null(p_shader);
2201
	ERR_FAIL_NULL(shader);
2202

2203
	shader->code = p_code;
2204

2205
	String mode_string = ShaderLanguage::get_shader_type(p_code);
2206

2207
	RS::ShaderMode new_mode;
2208
	if (mode_string == "canvas_item") {
2209
		new_mode = RS::SHADER_CANVAS_ITEM;
2210
	} else if (mode_string == "particles") {
2211
		new_mode = RS::SHADER_PARTICLES;
2212
	} else if (mode_string == "spatial") {
2213
		new_mode = RS::SHADER_SPATIAL;
2214
	} else if (mode_string == "sky") {
2215
		new_mode = RS::SHADER_SKY;
2216
		//} else if (mode_string == "fog") {
2217
		//	new_mode = RS::SHADER_FOG;
2218
	} else {
2219
		new_mode = RS::SHADER_MAX;
2220
		ERR_PRINT("shader type " + mode_string + " not supported in OpenGL renderer");
2221
	}
2222

2223
	if (new_mode != shader->mode) {
2224
		if (shader->data) {
2225
			memdelete(shader->data);
2226
			shader->data = nullptr;
2227
		}
2228

2229
		for (Material *E : shader->owners) {
2230
			Material *material = E;
2231
			material->shader_mode = new_mode;
2232
			if (material->data) {
2233
				memdelete(material->data);
2234
				material->data = nullptr;
2235
			}
2236
		}
2237

2238
		shader->mode = new_mode;
2239

2240
		if (new_mode < RS::SHADER_MAX && shader_data_request_func[new_mode]) {
2241
			shader->data = shader_data_request_func[new_mode]();
2242
		} else {
2243
			shader->mode = RS::SHADER_MAX; //invalid
2244
		}
2245

2246
		for (Material *E : shader->owners) {
2247
			Material *material = E;
2248
			if (shader->data) {
2249
				material->data = material_data_request_func[new_mode](shader->data);
2250
				material->data->self = material->self;
2251
				material->data->set_next_pass(material->next_pass);
2252
				material->data->set_render_priority(material->priority);
2253
			}
2254
			material->shader_mode = new_mode;
2255
		}
2256

2257
		if (shader->data) {
2258
			for (const KeyValue<StringName, HashMap<int, RID>> &E : shader->default_texture_parameter) {
2259
				for (const KeyValue<int, RID> &E2 : E.value) {
2260
					shader->data->set_default_texture_parameter(E.key, E2.value, E2.key);
2261
				}
2262
			}
2263
		}
2264
	}
2265

2266
	if (shader->data) {
2267
		shader->data->set_code(p_code);
2268
	}
2269

2270
	for (Material *E : shader->owners) {
2271
		Material *material = E;
2272
		material->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_MATERIAL);
2273
		_material_queue_update(material, true, true);
2274
	}
2275
}
2276

2277
void MaterialStorage::shader_set_path_hint(RID p_shader, const String &p_path) {
2278
	GLES3::Shader *shader = shader_owner.get_or_null(p_shader);
2279
	ERR_FAIL_NULL(shader);
2280

2281
	shader->path_hint = p_path;
2282
	if (shader->data) {
2283
		shader->data->set_path_hint(p_path);
2284
	}
2285
}
2286

2287
String MaterialStorage::shader_get_code(RID p_shader) const {
2288
	const GLES3::Shader *shader = shader_owner.get_or_null(p_shader);
2289
	ERR_FAIL_NULL_V(shader, String());
2290
	return shader->code;
2291
}
2292

2293
void MaterialStorage::get_shader_parameter_list(RID p_shader, List<PropertyInfo> *p_param_list) const {
2294
	GLES3::Shader *shader = shader_owner.get_or_null(p_shader);
2295
	ERR_FAIL_NULL(shader);
2296
	if (shader->data) {
2297
		return shader->data->get_shader_uniform_list(p_param_list);
2298
	}
2299
}
2300

2301
void MaterialStorage::shader_set_default_texture_parameter(RID p_shader, const StringName &p_name, RID p_texture, int p_index) {
2302
	GLES3::Shader *shader = shader_owner.get_or_null(p_shader);
2303
	ERR_FAIL_NULL(shader);
2304

2305
	if (p_texture.is_valid() && TextureStorage::get_singleton()->owns_texture(p_texture)) {
2306
		if (!shader->default_texture_parameter.has(p_name)) {
2307
			shader->default_texture_parameter[p_name] = HashMap<int, RID>();
2308
		}
2309
		shader->default_texture_parameter[p_name][p_index] = p_texture;
2310
	} else {
2311
		if (shader->default_texture_parameter.has(p_name) && shader->default_texture_parameter[p_name].has(p_index)) {
2312
			shader->default_texture_parameter[p_name].erase(p_index);
2313

2314
			if (shader->default_texture_parameter[p_name].is_empty()) {
2315
				shader->default_texture_parameter.erase(p_name);
2316
			}
2317
		}
2318
	}
2319
	if (shader->data) {
2320
		shader->data->set_default_texture_parameter(p_name, p_texture, p_index);
2321
	}
2322
	for (Material *E : shader->owners) {
2323
		Material *material = E;
2324
		_material_queue_update(material, false, true);
2325
	}
2326
}
2327

2328
RID MaterialStorage::shader_get_default_texture_parameter(RID p_shader, const StringName &p_name, int p_index) const {
2329
	const GLES3::Shader *shader = shader_owner.get_or_null(p_shader);
2330
	ERR_FAIL_NULL_V(shader, RID());
2331
	if (shader->default_texture_parameter.has(p_name) && shader->default_texture_parameter[p_name].has(p_index)) {
2332
		return shader->default_texture_parameter[p_name][p_index];
2333
	}
2334

2335
	return RID();
2336
}
2337

2338
Variant MaterialStorage::shader_get_parameter_default(RID p_shader, const StringName &p_param) const {
2339
	Shader *shader = shader_owner.get_or_null(p_shader);
2340
	ERR_FAIL_NULL_V(shader, Variant());
2341
	if (shader->data) {
2342
		return shader->data->get_default_parameter(p_param);
2343
	}
2344
	return Variant();
2345
}
2346

2347
RS::ShaderNativeSourceCode MaterialStorage::shader_get_native_source_code(RID p_shader) const {
2348
	Shader *shader = shader_owner.get_or_null(p_shader);
2349
	ERR_FAIL_NULL_V(shader, RS::ShaderNativeSourceCode());
2350
	if (shader->data) {
2351
		return shader->data->get_native_source_code();
2352
	}
2353
	return RS::ShaderNativeSourceCode();
2354
}
2355

2356
/* MATERIAL API */
2357

2358
void MaterialStorage::_material_queue_update(GLES3::Material *material, bool p_uniform, bool p_texture) {
2359
	material->uniform_dirty = material->uniform_dirty || p_uniform;
2360
	material->texture_dirty = material->texture_dirty || p_texture;
2361

2362
	if (material->update_element.in_list()) {
2363
		return;
2364
	}
2365

2366
	material_update_list.add(&material->update_element);
2367
}
2368

2369
void MaterialStorage::_update_queued_materials() {
2370
	while (material_update_list.first()) {
2371
		Material *material = material_update_list.first()->self();
2372

2373
		if (material->data) {
2374
			material->data->update_parameters(material->params, material->uniform_dirty, material->texture_dirty);
2375
		}
2376
		material->texture_dirty = false;
2377
		material->uniform_dirty = false;
2378

2379
		material_update_list.remove(&material->update_element);
2380
	}
2381
}
2382

2383
RID MaterialStorage::material_allocate() {
2384
	return material_owner.allocate_rid();
2385
}
2386

2387
void MaterialStorage::material_initialize(RID p_rid) {
2388
	material_owner.initialize_rid(p_rid);
2389
	Material *material = material_owner.get_or_null(p_rid);
2390
	material->self = p_rid;
2391
}
2392

2393
void MaterialStorage::material_free(RID p_rid) {
2394
	Material *material = material_owner.get_or_null(p_rid);
2395
	ERR_FAIL_NULL(material);
2396

2397
	// Need to clear texture arrays to prevent spin locking of their RID's.
2398
	// This happens when the app is being closed.
2399
	for (KeyValue<StringName, Variant> &E : material->params) {
2400
		if (E.value.get_type() == Variant::ARRAY) {
2401
			// Clear the array for this material only (the array may be shared).
2402
			E.value = Variant();
2403
		}
2404
	}
2405

2406
	material_set_shader(p_rid, RID()); //clean up shader
2407
	material->dependency.deleted_notify(p_rid);
2408

2409
	material_owner.free(p_rid);
2410
}
2411

2412
void MaterialStorage::material_set_shader(RID p_material, RID p_shader) {
2413
	GLES3::Material *material = material_owner.get_or_null(p_material);
2414
	ERR_FAIL_NULL(material);
2415

2416
	if (material->data) {
2417
		memdelete(material->data);
2418
		material->data = nullptr;
2419
	}
2420

2421
	if (material->shader) {
2422
		material->shader->owners.erase(material);
2423
		material->shader = nullptr;
2424
		material->shader_mode = RS::SHADER_MAX;
2425
	}
2426

2427
	if (p_shader.is_null()) {
2428
		material->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_MATERIAL);
2429
		material->shader_id = 0;
2430
		return;
2431
	}
2432

2433
	Shader *shader = get_shader(p_shader);
2434
	ERR_FAIL_NULL(shader);
2435
	material->shader = shader;
2436
	material->shader_mode = shader->mode;
2437
	material->shader_id = p_shader.get_local_index();
2438
	shader->owners.insert(material);
2439

2440
	if (shader->mode == RS::SHADER_MAX) {
2441
		return;
2442
	}
2443

2444
	ERR_FAIL_NULL(shader->data);
2445

2446
	material->data = material_data_request_func[shader->mode](shader->data);
2447
	material->data->self = p_material;
2448
	material->data->set_next_pass(material->next_pass);
2449
	material->data->set_render_priority(material->priority);
2450
	//updating happens later
2451
	material->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_MATERIAL);
2452
	_material_queue_update(material, true, true);
2453
}
2454

2455
void MaterialStorage::material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) {
2456
	GLES3::Material *material = material_owner.get_or_null(p_material);
2457
	ERR_FAIL_NULL(material);
2458

2459
	if (p_value.get_type() == Variant::NIL) {
2460
		material->params.erase(p_param);
2461
	} else {
2462
		ERR_FAIL_COND(p_value.get_type() == Variant::OBJECT); //object not allowed
2463
		material->params[p_param] = p_value;
2464
	}
2465

2466
	if (material->shader && material->shader->data) { //shader is valid
2467
		bool is_texture = material->shader->data->is_parameter_texture(p_param);
2468
		_material_queue_update(material, !is_texture, is_texture);
2469
	} else {
2470
		_material_queue_update(material, true, true);
2471
	}
2472
}
2473

2474
Variant MaterialStorage::material_get_param(RID p_material, const StringName &p_param) const {
2475
	const GLES3::Material *material = material_owner.get_or_null(p_material);
2476
	ERR_FAIL_NULL_V(material, Variant());
2477
	if (material->params.has(p_param)) {
2478
		return material->params[p_param];
2479
	} else {
2480
		return Variant();
2481
	}
2482
}
2483

2484
void MaterialStorage::material_set_next_pass(RID p_material, RID p_next_material) {
2485
	GLES3::Material *material = material_owner.get_or_null(p_material);
2486
	ERR_FAIL_NULL(material);
2487

2488
	if (material->next_pass == p_next_material) {
2489
		return;
2490
	}
2491

2492
	material->next_pass = p_next_material;
2493
	if (material->data) {
2494
		material->data->set_next_pass(p_next_material);
2495
	}
2496

2497
	material->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_MATERIAL);
2498
}
2499

2500
void MaterialStorage::material_set_render_priority(RID p_material, int priority) {
2501
	ERR_FAIL_COND(priority < RS::MATERIAL_RENDER_PRIORITY_MIN);
2502
	ERR_FAIL_COND(priority > RS::MATERIAL_RENDER_PRIORITY_MAX);
2503

2504
	GLES3::Material *material = material_owner.get_or_null(p_material);
2505
	ERR_FAIL_NULL(material);
2506
	material->priority = priority;
2507
	if (material->data) {
2508
		material->data->set_render_priority(priority);
2509
	}
2510
	material->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_MATERIAL);
2511
}
2512

2513
bool MaterialStorage::material_is_animated(RID p_material) {
2514
	GLES3::Material *material = material_owner.get_or_null(p_material);
2515
	ERR_FAIL_NULL_V(material, false);
2516
	if (material->shader && material->shader->data) {
2517
		if (material->shader->data->is_animated()) {
2518
			return true;
2519
		} else if (material->next_pass.is_valid()) {
2520
			return material_is_animated(material->next_pass);
2521
		}
2522
	}
2523
	return false; //by default nothing is animated
2524
}
2525

2526
bool MaterialStorage::material_casts_shadows(RID p_material) {
2527
	GLES3::Material *material = material_owner.get_or_null(p_material);
2528
	ERR_FAIL_NULL_V(material, true);
2529
	if (material->shader && material->shader->data) {
2530
		if (material->shader->data->casts_shadows()) {
2531
			return true;
2532
		} else if (material->next_pass.is_valid()) {
2533
			return material_casts_shadows(material->next_pass);
2534
		}
2535
	}
2536
	return true; //by default everything casts shadows
2537
}
2538

2539
RS::CullMode MaterialStorage::material_get_cull_mode(RID p_material) const {
2540
	const GLES3::Material *material = material_owner.get_or_null(p_material);
2541
	ERR_FAIL_NULL_V(material, RS::CULL_MODE_DISABLED);
2542
	ERR_FAIL_NULL_V(material->shader, RS::CULL_MODE_DISABLED);
2543
	if (material->shader->data) {
2544
		SceneShaderData *data = dynamic_cast<SceneShaderData *>(material->shader->data);
2545
		if (data) {
2546
			return (RS::CullMode)data->cull_mode;
2547
		}
2548
	}
2549
	return RS::CULL_MODE_DISABLED;
2550
}
2551

2552
void MaterialStorage::material_get_instance_shader_parameters(RID p_material, List<InstanceShaderParam> *r_parameters) {
2553
	GLES3::Material *material = material_owner.get_or_null(p_material);
2554
	ERR_FAIL_NULL(material);
2555
	if (material->shader && material->shader->data) {
2556
		material->shader->data->get_instance_param_list(r_parameters);
2557

2558
		if (material->next_pass.is_valid()) {
2559
			material_get_instance_shader_parameters(material->next_pass, r_parameters);
2560
		}
2561
	}
2562
}
2563

2564
void MaterialStorage::material_update_dependency(RID p_material, DependencyTracker *p_instance) {
2565
	Material *material = material_owner.get_or_null(p_material);
2566
	ERR_FAIL_NULL(material);
2567
	p_instance->update_dependency(&material->dependency);
2568
	if (material->next_pass.is_valid()) {
2569
		material_update_dependency(material->next_pass, p_instance);
2570
	}
2571
}
2572

2573
LocalVector<ShaderGLES3::TextureUniformData> get_texture_uniform_data(const Vector<ShaderCompiler::GeneratedCode::Texture> &texture_uniforms) {
2574
	LocalVector<ShaderGLES3::TextureUniformData> texture_uniform_data;
2575
	for (int i = 0; i < texture_uniforms.size(); i++) {
2576
		int num_textures = texture_uniforms[i].array_size;
2577
		if (num_textures == 0) {
2578
			num_textures = 1;
2579
		}
2580
		texture_uniform_data.push_back({ texture_uniforms[i].name, num_textures });
2581
	}
2582
	return texture_uniform_data;
2583
}
2584

2585
/* Canvas Shader Data */
2586

2587
void CanvasShaderData::set_code(const String &p_code) {
2588
	// Initialize and compile the shader.
2589

2590
	code = p_code;
2591
	valid = false;
2592
	ubo_size = 0;
2593
	uniforms.clear();
2594

2595
	uses_screen_texture = false;
2596
	uses_screen_texture_mipmaps = false;
2597
	uses_sdf = false;
2598
	uses_time = false;
2599
	uses_custom0 = false;
2600
	uses_custom1 = false;
2601

2602
	if (code.is_empty()) {
2603
		return; // Just invalid, but no error.
2604
	}
2605

2606
	ShaderCompiler::GeneratedCode gen_code;
2607

2608
	// Actual enum set further down after compilation.
2609
	int blend_modei = BLEND_MODE_MIX;
2610

2611
	ShaderCompiler::IdentifierActions actions;
2612
	actions.entry_point_stages["vertex"] = ShaderCompiler::STAGE_VERTEX;
2613
	actions.entry_point_stages["fragment"] = ShaderCompiler::STAGE_FRAGMENT;
2614
	actions.entry_point_stages["light"] = ShaderCompiler::STAGE_FRAGMENT;
2615

2616
	actions.render_mode_values["blend_add"] = Pair<int *, int>(&blend_modei, BLEND_MODE_ADD);
2617
	actions.render_mode_values["blend_mix"] = Pair<int *, int>(&blend_modei, BLEND_MODE_MIX);
2618
	actions.render_mode_values["blend_sub"] = Pair<int *, int>(&blend_modei, BLEND_MODE_SUB);
2619
	actions.render_mode_values["blend_mul"] = Pair<int *, int>(&blend_modei, BLEND_MODE_MUL);
2620
	actions.render_mode_values["blend_premul_alpha"] = Pair<int *, int>(&blend_modei, BLEND_MODE_PMALPHA);
2621
	actions.render_mode_values["blend_disabled"] = Pair<int *, int>(&blend_modei, BLEND_MODE_DISABLED);
2622

2623
	actions.usage_flag_pointers["texture_sdf"] = &uses_sdf;
2624
	actions.usage_flag_pointers["TIME"] = &uses_time;
2625
	actions.usage_flag_pointers["CUSTOM0"] = &uses_custom0;
2626
	actions.usage_flag_pointers["CUSTOM1"] = &uses_custom1;
2627

2628
	actions.uniforms = &uniforms;
2629
	Error err = MaterialStorage::get_singleton()->shaders.compiler_canvas.compile(RS::SHADER_CANVAS_ITEM, code, &actions, path, gen_code);
2630
	ERR_FAIL_COND_MSG(err != OK, "Shader compilation failed.");
2631

2632
	if (version.is_null()) {
2633
		version = MaterialStorage::get_singleton()->shaders.canvas_shader.version_create();
2634
	}
2635

2636
	blend_mode = BlendMode(blend_modei);
2637
	uses_screen_texture = gen_code.uses_screen_texture;
2638
	uses_screen_texture_mipmaps = gen_code.uses_screen_texture_mipmaps;
2639

2640
#if 0
2641
	print_line("**compiling shader:");
2642
	print_line("**defines:\n");
2643
	for (int i = 0; i < gen_code.defines.size(); i++) {
2644
		print_line(gen_code.defines[i]);
2645
	}
2646

2647
	HashMap<String, String>::Iterator el = gen_code.code.begin();
2648
	while (el) {
2649
		print_line("\n**code " + el->key + ":\n" + el->value);
2650
		++el;
2651
	}
2652

2653
	print_line("\n**uniforms:\n" + gen_code.uniforms);
2654
	print_line("\n**vertex_globals:\n" + gen_code.stage_globals[ShaderCompiler::STAGE_VERTEX]);
2655
	print_line("\n**fragment_globals:\n" + gen_code.stage_globals[ShaderCompiler::STAGE_FRAGMENT]);
2656
#endif
2657

2658
	LocalVector<ShaderGLES3::TextureUniformData> texture_uniform_data = get_texture_uniform_data(gen_code.texture_uniforms);
2659

2660
	MaterialStorage::get_singleton()->shaders.canvas_shader.version_set_code(version, gen_code.code, gen_code.uniforms, gen_code.stage_globals[ShaderCompiler::STAGE_VERTEX], gen_code.stage_globals[ShaderCompiler::STAGE_FRAGMENT], gen_code.defines, texture_uniform_data);
2661
	ERR_FAIL_COND(!MaterialStorage::get_singleton()->shaders.canvas_shader.version_is_valid(version));
2662

2663
	vertex_input_mask = RS::ARRAY_FORMAT_VERTEX | RS::ARRAY_FORMAT_COLOR | RS::ARRAY_FORMAT_TEX_UV;
2664
	vertex_input_mask |= uses_custom0 << RS::ARRAY_CUSTOM0;
2665
	vertex_input_mask |= uses_custom1 << RS::ARRAY_CUSTOM1;
2666

2667
	ubo_size = gen_code.uniform_total_size;
2668
	ubo_offsets = gen_code.uniform_offsets;
2669
	texture_uniforms = gen_code.texture_uniforms;
2670

2671
	valid = true;
2672
}
2673

2674
bool CanvasShaderData::is_animated() const {
2675
	return false;
2676
}
2677

2678
bool CanvasShaderData::casts_shadows() const {
2679
	return false;
2680
}
2681

2682
RS::ShaderNativeSourceCode CanvasShaderData::get_native_source_code() const {
2683
	return MaterialStorage::get_singleton()->shaders.canvas_shader.version_get_native_source_code(version);
2684
}
2685

2686
CanvasShaderData::CanvasShaderData() {
2687
	valid = false;
2688
	uses_screen_texture = false;
2689
	uses_sdf = false;
2690
}
2691

2692
CanvasShaderData::~CanvasShaderData() {
2693
	if (version.is_valid()) {
2694
		MaterialStorage::get_singleton()->shaders.canvas_shader.version_free(version);
2695
	}
2696
}
2697

2698
GLES3::ShaderData *GLES3::_create_canvas_shader_func() {
2699
	CanvasShaderData *shader_data = memnew(CanvasShaderData);
2700
	return shader_data;
2701
}
2702

2703
void CanvasMaterialData::update_parameters(const HashMap<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
2704
	update_parameters_internal(p_parameters, p_uniform_dirty, p_textures_dirty, shader_data->uniforms, shader_data->ubo_offsets.ptr(), shader_data->texture_uniforms, shader_data->default_texture_params, shader_data->ubo_size, false);
2705
}
2706

2707
static void bind_uniforms_generic(const Vector<RID> &p_textures, const Vector<ShaderCompiler::GeneratedCode::Texture> &p_texture_uniforms, int texture_offset = 0, const RS::CanvasItemTextureFilter *filter_mapping = filter_from_uniform, const RS::CanvasItemTextureRepeat *repeat_mapping = repeat_from_uniform) {
2708
	const RID *textures = p_textures.ptr();
2709
	const ShaderCompiler::GeneratedCode::Texture *texture_uniforms = p_texture_uniforms.ptr();
2710
	int texture_uniform_index = 0;
2711
	int texture_uniform_count = 0;
2712
	for (int ti = 0; ti < p_textures.size(); ti++) {
2713
		ERR_FAIL_COND_MSG(texture_uniform_index >= p_texture_uniforms.size(), "texture_uniform_index out of bounds");
2714
		GLES3::Texture *texture = TextureStorage::get_singleton()->get_texture(textures[ti]);
2715
		const ShaderCompiler::GeneratedCode::Texture &texture_uniform = texture_uniforms[texture_uniform_index];
2716
		if (texture) {
2717
			glActiveTexture(GL_TEXTURE0 + texture_offset + ti);
2718
			GLenum target = target_from_type[texture_uniform.type];
2719
			if (target == _GL_TEXTURE_EXTERNAL_OES && !GLES3::Config::get_singleton()->external_texture_supported) {
2720
				target = GL_TEXTURE_2D;
2721
			}
2722
			glBindTexture(target, texture->tex_id);
2723
			if (texture->render_target) {
2724
				texture->render_target->used_in_frame = true;
2725
			}
2726

2727
			texture->gl_set_filter(filter_mapping[int(texture_uniform.filter)]);
2728
			texture->gl_set_repeat(repeat_mapping[int(texture_uniform.repeat)]);
2729
		}
2730
		texture_uniform_count++;
2731
		if (texture_uniform_count >= texture_uniform.array_size) {
2732
			texture_uniform_index++;
2733
			texture_uniform_count = 0;
2734
		}
2735
	}
2736
}
2737

2738
void CanvasMaterialData::bind_uniforms() {
2739
	// Bind Material Uniforms
2740
	glBindBufferBase(GL_UNIFORM_BUFFER, RasterizerCanvasGLES3::MATERIAL_UNIFORM_LOCATION, uniform_buffer);
2741

2742
	bind_uniforms_generic(texture_cache, shader_data->texture_uniforms, 1, filter_from_uniform_canvas, repeat_from_uniform_canvas); // Start at GL_TEXTURE1 because texture slot 0 is used by the base texture
2743
}
2744

2745
CanvasMaterialData::~CanvasMaterialData() {
2746
}
2747

2748
GLES3::MaterialData *GLES3::_create_canvas_material_func(ShaderData *p_shader) {
2749
	CanvasMaterialData *material_data = memnew(CanvasMaterialData);
2750
	material_data->shader_data = static_cast<CanvasShaderData *>(p_shader);
2751
	//update will happen later anyway so do nothing.
2752
	return material_data;
2753
}
2754

2755
////////////////////////////////////////////////////////////////////////////////
2756
// SKY SHADER
2757

2758
void SkyShaderData::set_code(const String &p_code) {
2759
	// Initialize and compile the shader.
2760

2761
	code = p_code;
2762
	valid = false;
2763
	ubo_size = 0;
2764
	uniforms.clear();
2765

2766
	uses_time = false;
2767
	uses_position = false;
2768
	uses_half_res = false;
2769
	uses_quarter_res = false;
2770
	uses_light = false;
2771

2772
	if (code.is_empty()) {
2773
		return; // Just invalid, but no error.
2774
	}
2775

2776
	ShaderCompiler::GeneratedCode gen_code;
2777

2778
	ShaderCompiler::IdentifierActions actions;
2779
	actions.entry_point_stages["sky"] = ShaderCompiler::STAGE_FRAGMENT;
2780

2781
	actions.render_mode_flags["use_half_res_pass"] = &uses_half_res;
2782
	actions.render_mode_flags["use_quarter_res_pass"] = &uses_quarter_res;
2783

2784
	actions.usage_flag_pointers["TIME"] = &uses_time;
2785
	actions.usage_flag_pointers["POSITION"] = &uses_position;
2786
	actions.usage_flag_pointers["LIGHT0_ENABLED"] = &uses_light;
2787
	actions.usage_flag_pointers["LIGHT0_ENERGY"] = &uses_light;
2788
	actions.usage_flag_pointers["LIGHT0_DIRECTION"] = &uses_light;
2789
	actions.usage_flag_pointers["LIGHT0_COLOR"] = &uses_light;
2790
	actions.usage_flag_pointers["LIGHT0_SIZE"] = &uses_light;
2791
	actions.usage_flag_pointers["LIGHT1_ENABLED"] = &uses_light;
2792
	actions.usage_flag_pointers["LIGHT1_ENERGY"] = &uses_light;
2793
	actions.usage_flag_pointers["LIGHT1_DIRECTION"] = &uses_light;
2794
	actions.usage_flag_pointers["LIGHT1_COLOR"] = &uses_light;
2795
	actions.usage_flag_pointers["LIGHT1_SIZE"] = &uses_light;
2796
	actions.usage_flag_pointers["LIGHT2_ENABLED"] = &uses_light;
2797
	actions.usage_flag_pointers["LIGHT2_ENERGY"] = &uses_light;
2798
	actions.usage_flag_pointers["LIGHT2_DIRECTION"] = &uses_light;
2799
	actions.usage_flag_pointers["LIGHT2_COLOR"] = &uses_light;
2800
	actions.usage_flag_pointers["LIGHT2_SIZE"] = &uses_light;
2801
	actions.usage_flag_pointers["LIGHT3_ENABLED"] = &uses_light;
2802
	actions.usage_flag_pointers["LIGHT3_ENERGY"] = &uses_light;
2803
	actions.usage_flag_pointers["LIGHT3_DIRECTION"] = &uses_light;
2804
	actions.usage_flag_pointers["LIGHT3_COLOR"] = &uses_light;
2805
	actions.usage_flag_pointers["LIGHT3_SIZE"] = &uses_light;
2806

2807
	actions.uniforms = &uniforms;
2808

2809
	Error err = MaterialStorage::get_singleton()->shaders.compiler_sky.compile(RS::SHADER_SKY, code, &actions, path, gen_code);
2810
	ERR_FAIL_COND_MSG(err != OK, "Shader compilation failed.");
2811

2812
	if (version.is_null()) {
2813
		version = MaterialStorage::get_singleton()->shaders.sky_shader.version_create();
2814
	}
2815

2816
#if 0
2817
	print_line("**compiling shader:");
2818
	print_line("**defines:\n");
2819
	for (int i = 0; i < gen_code.defines.size(); i++) {
2820
		print_line(gen_code.defines[i]);
2821
	}
2822

2823
	HashMap<String, String>::Iterator el = gen_code.code.begin();
2824
	while (el) {
2825
		print_line("\n**code " + el->key + ":\n" + el->value);
2826
		++el;
2827
	}
2828

2829
	print_line("\n**uniforms:\n" + gen_code.uniforms);
2830
	print_line("\n**vertex_globals:\n" + gen_code.stage_globals[ShaderCompiler::STAGE_VERTEX]);
2831
	print_line("\n**fragment_globals:\n" + gen_code.stage_globals[ShaderCompiler::STAGE_FRAGMENT]);
2832
#endif
2833

2834
	LocalVector<ShaderGLES3::TextureUniformData> texture_uniform_data = get_texture_uniform_data(gen_code.texture_uniforms);
2835

2836
	MaterialStorage::get_singleton()->shaders.sky_shader.version_set_code(version, gen_code.code, gen_code.uniforms, gen_code.stage_globals[ShaderCompiler::STAGE_VERTEX], gen_code.stage_globals[ShaderCompiler::STAGE_FRAGMENT], gen_code.defines, texture_uniform_data);
2837
	ERR_FAIL_COND(!MaterialStorage::get_singleton()->shaders.sky_shader.version_is_valid(version));
2838

2839
	ubo_size = gen_code.uniform_total_size;
2840
	ubo_offsets = gen_code.uniform_offsets;
2841
	texture_uniforms = gen_code.texture_uniforms;
2842

2843
	valid = true;
2844
}
2845

2846
bool SkyShaderData::is_animated() const {
2847
	return false;
2848
}
2849

2850
bool SkyShaderData::casts_shadows() const {
2851
	return false;
2852
}
2853

2854
RS::ShaderNativeSourceCode SkyShaderData::get_native_source_code() const {
2855
	return MaterialStorage::get_singleton()->shaders.sky_shader.version_get_native_source_code(version);
2856
}
2857

2858
SkyShaderData::SkyShaderData() {
2859
	valid = false;
2860
}
2861

2862
SkyShaderData::~SkyShaderData() {
2863
	if (version.is_valid()) {
2864
		MaterialStorage::get_singleton()->shaders.sky_shader.version_free(version);
2865
	}
2866
}
2867

2868
GLES3::ShaderData *GLES3::_create_sky_shader_func() {
2869
	SkyShaderData *shader_data = memnew(SkyShaderData);
2870
	return shader_data;
2871
}
2872

2873
////////////////////////////////////////////////////////////////////////////////
2874
// Sky material
2875

2876
void SkyMaterialData::update_parameters(const HashMap<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
2877
	uniform_set_updated = true;
2878
	update_parameters_internal(p_parameters, p_uniform_dirty, p_textures_dirty, shader_data->uniforms, shader_data->ubo_offsets.ptr(), shader_data->texture_uniforms, shader_data->default_texture_params, shader_data->ubo_size, true);
2879
}
2880

2881
SkyMaterialData::~SkyMaterialData() {
2882
}
2883
GLES3::MaterialData *GLES3::_create_sky_material_func(ShaderData *p_shader) {
2884
	SkyMaterialData *material_data = memnew(SkyMaterialData);
2885
	material_data->shader_data = static_cast<SkyShaderData *>(p_shader);
2886
	//update will happen later anyway so do nothing.
2887
	return material_data;
2888
}
2889

2890
void SkyMaterialData::bind_uniforms() {
2891
	// Bind Material Uniforms
2892
	glBindBufferBase(GL_UNIFORM_BUFFER, SKY_MATERIAL_UNIFORM_LOCATION, uniform_buffer);
2893

2894
	bind_uniforms_generic(texture_cache, shader_data->texture_uniforms);
2895
}
2896

2897
////////////////////////////////////////////////////////////////////////////////
2898
// Scene SHADER
2899

2900
void SceneShaderData::set_code(const String &p_code) {
2901
	// Initialize and compile the shader.
2902

2903
	code = p_code;
2904
	valid = false;
2905
	ubo_size = 0;
2906
	uniforms.clear();
2907

2908
	uses_point_size = false;
2909
	uses_alpha = false;
2910
	uses_alpha_clip = false;
2911
	uses_blend_alpha = false;
2912
	uses_depth_prepass_alpha = false;
2913
	uses_discard = false;
2914
	uses_roughness = false;
2915
	uses_normal = false;
2916
	uses_particle_trails = false;
2917
	wireframe = false;
2918

2919
	unshaded = false;
2920
	uses_vertex = false;
2921
	uses_position = false;
2922
	uses_sss = false;
2923
	uses_transmittance = false;
2924
	uses_screen_texture = false;
2925
	uses_screen_texture_mipmaps = false;
2926
	uses_depth_texture = false;
2927
	uses_normal_texture = false;
2928
	uses_bent_normal_texture = false;
2929
	uses_time = false;
2930
	uses_vertex_time = false;
2931
	uses_fragment_time = false;
2932
	writes_modelview_or_projection = false;
2933
	uses_world_coordinates = false;
2934
	uses_tangent = false;
2935
	uses_color = false;
2936
	uses_uv = false;
2937
	uses_uv2 = false;
2938
	uses_custom0 = false;
2939
	uses_custom1 = false;
2940
	uses_custom2 = false;
2941
	uses_custom3 = false;
2942
	uses_bones = false;
2943
	uses_weights = false;
2944

2945
	if (code.is_empty()) {
2946
		return; // Just invalid, but no error.
2947
	}
2948

2949
	ShaderCompiler::GeneratedCode gen_code;
2950

2951
	// Actual enums set further down after compilation.
2952
	int blend_modei = BLEND_MODE_MIX;
2953
	int depth_test_disabledi = 0;
2954
	int depth_test_invertedi = 0;
2955
	int alpha_antialiasing_modei = ALPHA_ANTIALIASING_OFF;
2956
	int cull_modei = RS::CULL_MODE_BACK;
2957
	int depth_drawi = DEPTH_DRAW_OPAQUE;
2958

2959
	int stencil_readi = 0;
2960
	int stencil_writei = 0;
2961
	int stencil_write_depth_faili = 0;
2962
	int stencil_comparei = STENCIL_COMPARE_ALWAYS;
2963
	int stencil_referencei = -1;
2964

2965
	ShaderCompiler::IdentifierActions actions;
2966
	actions.entry_point_stages["vertex"] = ShaderCompiler::STAGE_VERTEX;
2967
	actions.entry_point_stages["fragment"] = ShaderCompiler::STAGE_FRAGMENT;
2968
	actions.entry_point_stages["light"] = ShaderCompiler::STAGE_FRAGMENT;
2969

2970
	actions.render_mode_values["blend_add"] = Pair<int *, int>(&blend_modei, BLEND_MODE_ADD);
2971
	actions.render_mode_values["blend_mix"] = Pair<int *, int>(&blend_modei, BLEND_MODE_MIX);
2972
	actions.render_mode_values["blend_sub"] = Pair<int *, int>(&blend_modei, BLEND_MODE_SUB);
2973
	actions.render_mode_values["blend_mul"] = Pair<int *, int>(&blend_modei, BLEND_MODE_MUL);
2974
	actions.render_mode_values["blend_premul_alpha"] = Pair<int *, int>(&blend_modei, BLEND_MODE_PREMULT_ALPHA);
2975

2976
	actions.render_mode_values["alpha_to_coverage"] = Pair<int *, int>(&alpha_antialiasing_modei, ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE);
2977
	actions.render_mode_values["alpha_to_coverage_and_one"] = Pair<int *, int>(&alpha_antialiasing_modei, ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE_AND_TO_ONE);
2978

2979
	actions.render_mode_values["depth_draw_never"] = Pair<int *, int>(&depth_drawi, DEPTH_DRAW_DISABLED);
2980
	actions.render_mode_values["depth_draw_opaque"] = Pair<int *, int>(&depth_drawi, DEPTH_DRAW_OPAQUE);
2981
	actions.render_mode_values["depth_draw_always"] = Pair<int *, int>(&depth_drawi, DEPTH_DRAW_ALWAYS);
2982

2983
	actions.render_mode_values["depth_test_disabled"] = Pair<int *, int>(&depth_test_disabledi, 1);
2984
	actions.render_mode_values["depth_test_inverted"] = Pair<int *, int>(&depth_test_invertedi, 1);
2985

2986
	actions.render_mode_values["cull_disabled"] = Pair<int *, int>(&cull_modei, RS::CULL_MODE_DISABLED);
2987
	actions.render_mode_values["cull_front"] = Pair<int *, int>(&cull_modei, RS::CULL_MODE_FRONT);
2988
	actions.render_mode_values["cull_back"] = Pair<int *, int>(&cull_modei, RS::CULL_MODE_BACK);
2989

2990
	actions.render_mode_flags["unshaded"] = &unshaded;
2991
	actions.render_mode_flags["wireframe"] = &wireframe;
2992
	actions.render_mode_flags["particle_trails"] = &uses_particle_trails;
2993
	actions.render_mode_flags["world_vertex_coords"] = &uses_world_coordinates;
2994

2995
	actions.usage_flag_pointers["ALPHA"] = &uses_alpha;
2996
	actions.usage_flag_pointers["ALPHA_SCISSOR_THRESHOLD"] = &uses_alpha_clip;
2997
	// Use alpha clip pipeline for alpha hash/dither.
2998
	// This prevents sorting issues inherent to alpha blending and allows such materials to cast shadows.
2999
	actions.usage_flag_pointers["ALPHA_HASH_SCALE"] = &uses_alpha_clip;
3000
	actions.render_mode_flags["depth_prepass_alpha"] = &uses_depth_prepass_alpha;
3001

3002
	actions.usage_flag_pointers["SSS_STRENGTH"] = &uses_sss;
3003
	actions.usage_flag_pointers["SSS_TRANSMITTANCE_DEPTH"] = &uses_transmittance;
3004

3005
	actions.usage_flag_pointers["DISCARD"] = &uses_discard;
3006
	actions.usage_flag_pointers["TIME"] = &uses_time;
3007
	actions.usage_flag_pointers["ROUGHNESS"] = &uses_roughness;
3008
	actions.usage_flag_pointers["NORMAL"] = &uses_normal;
3009
	actions.usage_flag_pointers["NORMAL_MAP"] = &uses_normal;
3010
	actions.usage_flag_pointers["BENT_NORMAL_MAP"] = &uses_bent_normal_texture;
3011

3012
	actions.usage_flag_pointers["POINT_SIZE"] = &uses_point_size;
3013
	actions.usage_flag_pointers["POINT_COORD"] = &uses_point_size;
3014

3015
	actions.write_flag_pointers["MODELVIEW_MATRIX"] = &writes_modelview_or_projection;
3016
	actions.write_flag_pointers["PROJECTION_MATRIX"] = &writes_modelview_or_projection;
3017
	actions.write_flag_pointers["VERTEX"] = &uses_vertex;
3018
	actions.write_flag_pointers["POSITION"] = &uses_position;
3019

3020
	actions.usage_flag_pointers["TANGENT"] = &uses_tangent;
3021
	actions.usage_flag_pointers["BINORMAL"] = &uses_tangent;
3022
	actions.usage_flag_pointers["ANISOTROPY"] = &uses_tangent;
3023
	actions.usage_flag_pointers["ANISOTROPY_FLOW"] = &uses_tangent;
3024
	actions.usage_flag_pointers["COLOR"] = &uses_color;
3025
	actions.usage_flag_pointers["UV"] = &uses_uv;
3026
	actions.usage_flag_pointers["UV2"] = &uses_uv2;
3027
	actions.usage_flag_pointers["CUSTOM0"] = &uses_custom0;
3028
	actions.usage_flag_pointers["CUSTOM1"] = &uses_custom1;
3029
	actions.usage_flag_pointers["CUSTOM2"] = &uses_custom2;
3030
	actions.usage_flag_pointers["CUSTOM3"] = &uses_custom3;
3031
	actions.usage_flag_pointers["BONE_INDICES"] = &uses_bones;
3032
	actions.usage_flag_pointers["BONE_WEIGHTS"] = &uses_weights;
3033

3034
	actions.stencil_mode_values["read"] = Pair<int *, int>(&stencil_readi, STENCIL_FLAG_READ);
3035
	actions.stencil_mode_values["write"] = Pair<int *, int>(&stencil_writei, STENCIL_FLAG_WRITE);
3036
	actions.stencil_mode_values["write_depth_fail"] = Pair<int *, int>(&stencil_write_depth_faili, STENCIL_FLAG_WRITE_DEPTH_FAIL);
3037

3038
	actions.stencil_mode_values["compare_less"] = Pair<int *, int>(&stencil_comparei, STENCIL_COMPARE_LESS);
3039
	actions.stencil_mode_values["compare_equal"] = Pair<int *, int>(&stencil_comparei, STENCIL_COMPARE_EQUAL);
3040
	actions.stencil_mode_values["compare_less_or_equal"] = Pair<int *, int>(&stencil_comparei, STENCIL_COMPARE_LESS_OR_EQUAL);
3041
	actions.stencil_mode_values["compare_greater"] = Pair<int *, int>(&stencil_comparei, STENCIL_COMPARE_GREATER);
3042
	actions.stencil_mode_values["compare_not_equal"] = Pair<int *, int>(&stencil_comparei, STENCIL_COMPARE_NOT_EQUAL);
3043
	actions.stencil_mode_values["compare_greater_or_equal"] = Pair<int *, int>(&stencil_comparei, STENCIL_COMPARE_GREATER_OR_EQUAL);
3044
	actions.stencil_mode_values["compare_always"] = Pair<int *, int>(&stencil_comparei, STENCIL_COMPARE_ALWAYS);
3045

3046
	actions.stencil_reference = &stencil_referencei;
3047

3048
	actions.uniforms = &uniforms;
3049

3050
	Error err = MaterialStorage::get_singleton()->shaders.compiler_scene.compile(RS::SHADER_SPATIAL, code, &actions, path, gen_code);
3051
	ERR_FAIL_COND_MSG(err != OK, "Shader compilation failed.");
3052

3053
	if (version.is_null()) {
3054
		version = MaterialStorage::get_singleton()->shaders.scene_shader.version_create();
3055
	}
3056

3057
	blend_mode = BlendMode(blend_modei);
3058
	alpha_antialiasing_mode = AlphaAntiAliasing(alpha_antialiasing_modei);
3059
	depth_draw = DepthDraw(depth_drawi);
3060
	if (depth_test_disabledi) {
3061
		depth_test = DEPTH_TEST_DISABLED;
3062
	} else if (depth_test_invertedi) {
3063
		depth_test = DEPTH_TEST_ENABLED_INVERTED;
3064
	} else {
3065
		depth_test = DEPTH_TEST_ENABLED;
3066
	}
3067
	cull_mode = RS::CullMode(cull_modei);
3068

3069
	vertex_input_mask = RS::ARRAY_FORMAT_VERTEX | RS::ARRAY_FORMAT_NORMAL; // We can always read vertices and normals.
3070
	vertex_input_mask |= uses_tangent << RS::ARRAY_TANGENT;
3071
	vertex_input_mask |= uses_color << RS::ARRAY_COLOR;
3072
	vertex_input_mask |= uses_uv << RS::ARRAY_TEX_UV;
3073
	vertex_input_mask |= uses_uv2 << RS::ARRAY_TEX_UV2;
3074
	vertex_input_mask |= uses_custom0 << RS::ARRAY_CUSTOM0;
3075
	vertex_input_mask |= uses_custom1 << RS::ARRAY_CUSTOM1;
3076
	vertex_input_mask |= uses_custom2 << RS::ARRAY_CUSTOM2;
3077
	vertex_input_mask |= uses_custom3 << RS::ARRAY_CUSTOM3;
3078
	vertex_input_mask |= uses_bones << RS::ARRAY_BONES;
3079
	vertex_input_mask |= uses_weights << RS::ARRAY_WEIGHTS;
3080

3081
	uses_screen_texture = gen_code.uses_screen_texture;
3082
	uses_screen_texture_mipmaps = gen_code.uses_screen_texture_mipmaps;
3083
	uses_depth_texture = gen_code.uses_depth_texture;
3084
	uses_normal_texture = gen_code.uses_normal_roughness_texture;
3085
	uses_vertex_time = gen_code.uses_vertex_time;
3086
	uses_fragment_time = gen_code.uses_fragment_time;
3087

3088
	stencil_enabled = stencil_referencei != -1;
3089
	stencil_flags = stencil_readi | stencil_writei | stencil_write_depth_faili;
3090
	stencil_compare = StencilCompare(stencil_comparei);
3091
	stencil_reference = stencil_referencei;
3092

3093
#ifdef DEBUG_ENABLED
3094
	if (uses_particle_trails) {
3095
		WARN_PRINT_ONCE_ED("Particle trails are only available when using the Forward+ or Mobile renderers.");
3096
	}
3097

3098
	if (uses_sss) {
3099
		WARN_PRINT_ONCE_ED("Subsurface scattering is only available when using the Forward+ renderer.");
3100
	}
3101

3102
	if (uses_transmittance) {
3103
		WARN_PRINT_ONCE_ED("Transmittance is only available when using the Forward+ renderer.");
3104
	}
3105

3106
	if (uses_normal_texture) {
3107
		WARN_PRINT_ONCE_ED("Reading from the normal-roughness texture is only available when using the Forward+ or Mobile renderers.");
3108
	}
3109
#endif
3110

3111
#if 0
3112
	print_line("**compiling shader:");
3113
	print_line("**defines:\n");
3114
	for (int i = 0; i < gen_code.defines.size(); i++) {
3115
		print_line(gen_code.defines[i]);
3116
	}
3117

3118
	HashMap<String, String>::Iterator el = gen_code.code.begin();
3119
	while (el) {
3120
		print_line("\n**code " + el->key + ":\n" + el->value);
3121
		++el;
3122
	}
3123

3124
	print_line("\n**uniforms:\n" + gen_code.uniforms);
3125
	print_line("\n**vertex_globals:\n" + gen_code.stage_globals[ShaderCompiler::STAGE_VERTEX]);
3126
	print_line("\n**fragment_globals:\n" + gen_code.stage_globals[ShaderCompiler::STAGE_FRAGMENT]);
3127
#endif
3128

3129
	LocalVector<ShaderGLES3::TextureUniformData> texture_uniform_data = get_texture_uniform_data(gen_code.texture_uniforms);
3130

3131
	MaterialStorage::get_singleton()->shaders.scene_shader.version_set_code(version, gen_code.code, gen_code.uniforms, gen_code.stage_globals[ShaderCompiler::STAGE_VERTEX], gen_code.stage_globals[ShaderCompiler::STAGE_FRAGMENT], gen_code.defines, texture_uniform_data);
3132
	ERR_FAIL_COND(!MaterialStorage::get_singleton()->shaders.scene_shader.version_is_valid(version));
3133

3134
	ubo_size = gen_code.uniform_total_size;
3135
	ubo_offsets = gen_code.uniform_offsets;
3136
	texture_uniforms = gen_code.texture_uniforms;
3137

3138
	// If any form of Alpha Antialiasing is enabled, set the blend mode to alpha to coverage.
3139
	if (alpha_antialiasing_mode != ALPHA_ANTIALIASING_OFF) {
3140
		blend_mode = BLEND_MODE_ALPHA_TO_COVERAGE;
3141
	}
3142

3143
	if (blend_mode == BLEND_MODE_ADD || blend_mode == BLEND_MODE_SUB || blend_mode == BLEND_MODE_MUL) {
3144
		uses_blend_alpha = true; // Force alpha used because of blend.
3145
	}
3146

3147
	valid = true;
3148
}
3149

3150
bool SceneShaderData::is_animated() const {
3151
	return (uses_fragment_time && uses_discard) || (uses_vertex_time && uses_vertex);
3152
}
3153

3154
bool SceneShaderData::casts_shadows() const {
3155
	bool has_read_screen_alpha = uses_screen_texture || uses_depth_texture || uses_normal_texture;
3156
	bool has_base_alpha = (uses_alpha && !uses_alpha_clip) || has_read_screen_alpha;
3157
	bool has_alpha = has_base_alpha || uses_blend_alpha;
3158

3159
	return !has_alpha || (uses_depth_prepass_alpha && !(depth_draw == DEPTH_DRAW_DISABLED || depth_test != DEPTH_TEST_ENABLED));
3160
}
3161

3162
RS::ShaderNativeSourceCode SceneShaderData::get_native_source_code() const {
3163
	return MaterialStorage::get_singleton()->shaders.scene_shader.version_get_native_source_code(version);
3164
}
3165

3166
SceneShaderData::SceneShaderData() {
3167
	valid = false;
3168
	uses_screen_texture = false;
3169
}
3170

3171
SceneShaderData::~SceneShaderData() {
3172
	if (version.is_valid()) {
3173
		MaterialStorage::get_singleton()->shaders.scene_shader.version_free(version);
3174
	}
3175
}
3176

3177
GLES3::ShaderData *GLES3::_create_scene_shader_func() {
3178
	SceneShaderData *shader_data = memnew(SceneShaderData);
3179
	return shader_data;
3180
}
3181

3182
void SceneMaterialData::set_render_priority(int p_priority) {
3183
	priority = p_priority - RS::MATERIAL_RENDER_PRIORITY_MIN; //8 bits
3184
}
3185

3186
void SceneMaterialData::set_next_pass(RID p_pass) {
3187
	next_pass = p_pass;
3188
}
3189

3190
void SceneMaterialData::update_parameters(const HashMap<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
3191
	update_parameters_internal(p_parameters, p_uniform_dirty, p_textures_dirty, shader_data->uniforms, shader_data->ubo_offsets.ptr(), shader_data->texture_uniforms, shader_data->default_texture_params, shader_data->ubo_size, true);
3192
}
3193

3194
SceneMaterialData::~SceneMaterialData() {
3195
}
3196

3197
GLES3::MaterialData *GLES3::_create_scene_material_func(ShaderData *p_shader) {
3198
	SceneMaterialData *material_data = memnew(SceneMaterialData);
3199
	material_data->shader_data = static_cast<SceneShaderData *>(p_shader);
3200
	//update will happen later anyway so do nothing.
3201
	return material_data;
3202
}
3203

3204
void SceneMaterialData::bind_uniforms() {
3205
	// Bind Material Uniforms
3206
	glBindBufferBase(GL_UNIFORM_BUFFER, SCENE_MATERIAL_UNIFORM_LOCATION, uniform_buffer);
3207

3208
	bind_uniforms_generic(texture_cache, shader_data->texture_uniforms);
3209
}
3210

3211
/* Particles SHADER */
3212

3213
void ParticlesShaderData::set_code(const String &p_code) {
3214
	// Initialize and compile the shader.
3215

3216
	code = p_code;
3217
	valid = false;
3218
	ubo_size = 0;
3219
	uniforms.clear();
3220

3221
	uses_collision = false;
3222
	uses_time = false;
3223

3224
	if (code.is_empty()) {
3225
		return; // Just invalid, but no error.
3226
	}
3227

3228
	ShaderCompiler::GeneratedCode gen_code;
3229

3230
	ShaderCompiler::IdentifierActions actions;
3231
	actions.entry_point_stages["start"] = ShaderCompiler::STAGE_VERTEX;
3232
	actions.entry_point_stages["process"] = ShaderCompiler::STAGE_VERTEX;
3233

3234
	actions.usage_flag_pointers["COLLIDED"] = &uses_collision;
3235

3236
	userdata_count = 0;
3237
	for (uint32_t i = 0; i < PARTICLES_MAX_USERDATAS; i++) {
3238
		userdatas_used[i] = false;
3239
		actions.usage_flag_pointers["USERDATA" + itos(i + 1)] = &userdatas_used[i];
3240
	}
3241

3242
	actions.uniforms = &uniforms;
3243

3244
	Error err = MaterialStorage::get_singleton()->shaders.compiler_particles.compile(RS::SHADER_PARTICLES, code, &actions, path, gen_code);
3245
	ERR_FAIL_COND_MSG(err != OK, "Shader compilation failed.");
3246

3247
	if (version.is_null()) {
3248
		version = MaterialStorage::get_singleton()->shaders.particles_process_shader.version_create();
3249
	}
3250

3251
	for (uint32_t i = 0; i < PARTICLES_MAX_USERDATAS; i++) {
3252
		if (userdatas_used[i]) {
3253
			userdata_count++;
3254
		}
3255
	}
3256

3257
	LocalVector<ShaderGLES3::TextureUniformData> texture_uniform_data = get_texture_uniform_data(gen_code.texture_uniforms);
3258

3259
	MaterialStorage::get_singleton()->shaders.particles_process_shader.version_set_code(version, gen_code.code, gen_code.uniforms, gen_code.stage_globals[ShaderCompiler::STAGE_VERTEX], gen_code.stage_globals[ShaderCompiler::STAGE_FRAGMENT], gen_code.defines, texture_uniform_data);
3260
	ERR_FAIL_COND(!MaterialStorage::get_singleton()->shaders.particles_process_shader.version_is_valid(version));
3261

3262
	ubo_size = gen_code.uniform_total_size;
3263
	ubo_offsets = gen_code.uniform_offsets;
3264
	texture_uniforms = gen_code.texture_uniforms;
3265

3266
	valid = true;
3267
}
3268

3269
bool ParticlesShaderData::is_animated() const {
3270
	return false;
3271
}
3272

3273
bool ParticlesShaderData::casts_shadows() const {
3274
	return false;
3275
}
3276

3277
RS::ShaderNativeSourceCode ParticlesShaderData::get_native_source_code() const {
3278
	return MaterialStorage::get_singleton()->shaders.particles_process_shader.version_get_native_source_code(version);
3279
}
3280

3281
ParticlesShaderData::~ParticlesShaderData() {
3282
	if (version.is_valid()) {
3283
		MaterialStorage::get_singleton()->shaders.particles_process_shader.version_free(version);
3284
	}
3285
}
3286

3287
GLES3::ShaderData *GLES3::_create_particles_shader_func() {
3288
	ParticlesShaderData *shader_data = memnew(ParticlesShaderData);
3289
	return shader_data;
3290
}
3291

3292
void ParticleProcessMaterialData::update_parameters(const HashMap<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
3293
	update_parameters_internal(p_parameters, p_uniform_dirty, p_textures_dirty, shader_data->uniforms, shader_data->ubo_offsets.ptr(), shader_data->texture_uniforms, shader_data->default_texture_params, shader_data->ubo_size, true);
3294
}
3295

3296
ParticleProcessMaterialData::~ParticleProcessMaterialData() {
3297
}
3298

3299
GLES3::MaterialData *GLES3::_create_particles_material_func(ShaderData *p_shader) {
3300
	ParticleProcessMaterialData *material_data = memnew(ParticleProcessMaterialData);
3301
	material_data->shader_data = static_cast<ParticlesShaderData *>(p_shader);
3302
	//update will happen later anyway so do nothing.
3303
	return material_data;
3304
}
3305

3306
void ParticleProcessMaterialData::bind_uniforms() {
3307
	// Bind Material Uniforms
3308
	glBindBufferBase(GL_UNIFORM_BUFFER, GLES3::PARTICLES_MATERIAL_UNIFORM_LOCATION, uniform_buffer);
3309

3310
	bind_uniforms_generic(texture_cache, shader_data->texture_uniforms, 1); // Start at GL_TEXTURE1 because texture slot 0 is reserved for the heightmap texture.
3311
}
3312

3313
#endif // !GLES3_ENABLED
3314

3315
Product

Resources

Company
