Stowage/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-10-31 05:31:01 +00:00
Code Issues Projects Releases Packages Wiki Activity
godot/drivers/gles3/storage/material_storage.cpp

3193 lines
115 KiB
C++
Raw Normal View History

One Copyright Update to rule them all As many open source projects have started doing it, we're removing the current year from the copyright notice, so that we don't need to bump it every year. It seems like only the first year of publication is technically relevant for copyright notices, and even that seems to be something that many companies stopped listing altogether (in a version controlled codebase, the commits are a much better source of date of publication than a hardcoded copyright statement). We also now list Godot Engine contributors first as we're collectively the current maintainers of the project, and we clarify that the "exclusive" copyright of the co-founders covers the timespan before opensourcing (their further contributions are included as part of Godot Engine contributors). Also fixed "cf." Frenchism - it's meant as "refer to / see".
2023-01-05 13:25:55 +01:00
/**************************************************************************/
/* material_storage.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
#ifdef GLES3_ENABLED
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
#include "core/config/project_settings.h"
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
#include "config.h"
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
#include "material_storage.h"
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
#include "particles_storage.h"
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
#include "texture_storage.h"
#include "drivers/gles3/rasterizer_canvas_gles3.h"
Forbid passing multiview sampler to the custom function in shaders
2023-01-29 12:14:22 +03:00
#include "drivers/gles3/rasterizer_gles3.h"
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
#include "servers/rendering/storage/variant_converters.h"
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
using namespace GLES3;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
///////////////////////////////////////////////////////////////////////////
// UBI helper functions
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
static void _fill_std140_variant_ubo_value(ShaderLanguage::DataType type, int p_array_size, const Variant &value, uint8_t *data) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
switch (type) {
case ShaderLanguage::TYPE_BOOL: {
uint32_t *gui = (uint32_t *)data;
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
PackedInt32Array ba = value;
for (int i = 0; i < ba.size(); i++) {
ba.set(i, ba[i] ? 1 : 0);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
write_array_std140<int32_t>(ba, gui, p_array_size, 4);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
bool v = value;
gui[0] = v ? 1 : 0;
}
} break;
case ShaderLanguage::TYPE_BVEC2: {
uint32_t *gui = (uint32_t *)data;
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
PackedInt32Array ba = convert_array_std140<Vector2i, int32_t>(value);
for (int i = 0; i < ba.size(); i++) {
ba.set(i, ba[i] ? 1 : 0);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
write_array_std140<Vector2i>(ba, gui, p_array_size, 4);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
Fix incorrect setup of boolean uniform instances
2022-10-09 08:14:07 +03:00
uint32_t v = value;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
gui[0] = v & 1 ? 1 : 0;
gui[1] = v & 2 ? 1 : 0;
}
} break;
case ShaderLanguage::TYPE_BVEC3: {
uint32_t *gui = (uint32_t *)data;
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
PackedInt32Array ba = convert_array_std140<Vector3i, int32_t>(value);
for (int i = 0; i < ba.size(); i++) {
ba.set(i, ba[i] ? 1 : 0);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
write_array_std140<Vector3i>(ba, gui, p_array_size, 4);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
Fix incorrect setup of boolean uniform instances
2022-10-09 08:14:07 +03:00
uint32_t v = value;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
gui[0] = (v & 1) ? 1 : 0;
gui[1] = (v & 2) ? 1 : 0;
gui[2] = (v & 4) ? 1 : 0;
}
} break;
case ShaderLanguage::TYPE_BVEC4: {
uint32_t *gui = (uint32_t *)data;
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
PackedInt32Array ba = convert_array_std140<Vector4i, int32_t>(value);
for (int i = 0; i < ba.size(); i++) {
ba.set(i, ba[i] ? 1 : 0);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
write_array_std140<Vector4i>(ba, gui, p_array_size, 4);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
Fix incorrect setup of boolean uniform instances
2022-10-09 08:14:07 +03:00
uint32_t v = value;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
gui[0] = (v & 1) ? 1 : 0;
gui[1] = (v & 2) ? 1 : 0;
gui[2] = (v & 4) ? 1 : 0;
gui[3] = (v & 8) ? 1 : 0;
}
} break;
case ShaderLanguage::TYPE_INT: {
int32_t *gui = (int32_t *)data;
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
const PackedInt32Array &iv = value;
write_array_std140<int32_t>(iv, gui, p_array_size, 4);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
int v = value;
gui[0] = v;
}
} break;
case ShaderLanguage::TYPE_IVEC2: {
int32_t *gui = (int32_t *)data;
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
const PackedInt32Array &iv = convert_array_std140<Vector2i, int32_t>(value);
write_array_std140<Vector2i>(iv, gui, p_array_size, 4);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector2i v = convert_to_vector<Vector2i>(value);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
gui[0] = v.x;
gui[1] = v.y;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
} break;
case ShaderLanguage::TYPE_IVEC3: {
int32_t *gui = (int32_t *)data;
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
const PackedInt32Array &iv = convert_array_std140<Vector3i, int32_t>(value);
write_array_std140<Vector3i>(iv, gui, p_array_size, 4);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector3i v = convert_to_vector<Vector3i>(value);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
gui[0] = v.x;
gui[1] = v.y;
gui[2] = v.z;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
} break;
case ShaderLanguage::TYPE_IVEC4: {
int32_t *gui = (int32_t *)data;
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
const PackedInt32Array &iv = convert_array_std140<Vector4i, int32_t>(value);
write_array_std140<Vector4i>(iv, gui, p_array_size, 4);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector4i v = convert_to_vector<Vector4i>(value);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
gui[0] = v.x;
gui[1] = v.y;
gui[2] = v.z;
gui[3] = v.w;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
} break;
case ShaderLanguage::TYPE_UINT: {
uint32_t *gui = (uint32_t *)data;
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
const PackedInt32Array &iv = value;
write_array_std140<uint32_t>(iv, gui, p_array_size, 4);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
int v = value;
gui[0] = v;
}
} break;
case ShaderLanguage::TYPE_UVEC2: {
uint32_t *gui = (uint32_t *)data;
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
const PackedInt32Array &iv = convert_array_std140<Vector2i, int32_t>(value);
write_array_std140<Vector2i>(iv, gui, p_array_size, 4);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector2i v = convert_to_vector<Vector2i>(value);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
gui[0] = v.x;
gui[1] = v.y;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
} break;
case ShaderLanguage::TYPE_UVEC3: {
uint32_t *gui = (uint32_t *)data;
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
const PackedInt32Array &iv = convert_array_std140<Vector3i, int32_t>(value);
write_array_std140<Vector3i>(iv, gui, p_array_size, 4);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector3i v = convert_to_vector<Vector3i>(value);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
gui[0] = v.x;
gui[1] = v.y;
gui[2] = v.z;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
} break;
case ShaderLanguage::TYPE_UVEC4: {
uint32_t *gui = (uint32_t *)data;
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
const PackedInt32Array &iv = convert_array_std140<Vector4i, int32_t>(value);
write_array_std140<Vector4i>(iv, gui, p_array_size, 4);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector4i v = convert_to_vector<Vector4i>(value);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
gui[0] = v.x;
gui[1] = v.y;
gui[2] = v.z;
gui[3] = v.w;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
} break;
case ShaderLanguage::TYPE_FLOAT: {
float *gui = (float *)data;
if (p_array_size > 0) {
const PackedFloat32Array &a = value;
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
write_array_std140<float>(a, gui, p_array_size, 4);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
float v = value;
gui[0] = v;
}
} break;
case ShaderLanguage::TYPE_VEC2: {
float *gui = (float *)data;
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
const PackedFloat32Array &a = convert_array_std140<Vector2, float>(value);
write_array_std140<Vector2>(a, gui, p_array_size, 4);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector2 v = convert_to_vector<Vector2>(value);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
gui[0] = v.x;
gui[1] = v.y;
}
} break;
case ShaderLanguage::TYPE_VEC3: {
float *gui = (float *)data;
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
const PackedFloat32Array &a = convert_array_std140<Vector3, float>(value);
write_array_std140<Vector3>(a, gui, p_array_size, 4);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector3 v = convert_to_vector<Vector3>(value);
gui[0] = v.x;
gui[1] = v.y;
gui[2] = v.z;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
} break;
case ShaderLanguage::TYPE_VEC4: {
float *gui = (float *)data;
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
const PackedFloat32Array &a = convert_array_std140<Vector4, float>(value);
write_array_std140<Vector4>(a, gui, p_array_size, 4);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector4 v = convert_to_vector<Vector4>(value);
gui[0] = v.x;
gui[1] = v.y;
gui[2] = v.z;
gui[3] = v.w;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
} break;
case ShaderLanguage::TYPE_MAT2: {
float *gui = (float *)data;
if (p_array_size > 0) {
const PackedFloat32Array &a = value;
int s = a.size();
for (int i = 0, j = 0; i < p_array_size * 4; i += 4, j += 8) {
if (i + 3 < s) {
gui[j] = a[i];
gui[j + 1] = a[i + 1];
gui[j + 4] = a[i + 2];
gui[j + 5] = a[i + 3];
} else {
gui[j] = 1;
gui[j + 1] = 0;
gui[j + 4] = 0;
gui[j + 5] = 1;
}
gui[j + 2] = 0; // ignored
gui[j + 3] = 0; // ignored
gui[j + 6] = 0; // ignored
gui[j + 7] = 0; // ignored
}
} else {
Transform2D v = value;
//in std140 members of mat2 are treated as vec4s
Rename Transform2D "elements" to "columns"
2022-04-24 16:59:24 -05:00
gui[0] = v.columns[0][0];
gui[1] = v.columns[0][1];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
gui[2] = 0; // ignored
gui[3] = 0; // ignored
Rename Transform2D "elements" to "columns"
2022-04-24 16:59:24 -05:00
gui[4] = v.columns[1][0];
gui[5] = v.columns[1][1];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
gui[6] = 0; // ignored
gui[7] = 0; // ignored
}
} break;
case ShaderLanguage::TYPE_MAT3: {
float *gui = (float *)data;
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
const PackedFloat32Array &a = convert_array_std140<Basis, float>(value);
const Basis default_basis;
const int s = a.size();
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
for (int i = 0, j = 0; i < p_array_size * 9; i += 9, j += 12) {
if (i + 8 < s) {
gui[j] = a[i];
gui[j + 1] = a[i + 1];
gui[j + 2] = a[i + 2];
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
gui[j + 3] = 0; // Ignored.
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
gui[j + 4] = a[i + 3];
gui[j + 5] = a[i + 4];
gui[j + 6] = a[i + 5];
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
gui[j + 7] = 0; // Ignored.
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
gui[j + 8] = a[i + 6];
gui[j + 9] = a[i + 7];
gui[j + 10] = a[i + 8];
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
gui[j + 11] = 0; // Ignored.
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
convert_item_std140(default_basis, gui + j);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
}
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
convert_item_std140<Basis>(value, gui);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
} break;
case ShaderLanguage::TYPE_MAT4: {
float *gui = (float *)data;
if (p_array_size > 0) {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
const PackedFloat32Array &a = convert_array_std140<Projection, float>(value);
write_array_std140<Projection>(a, gui, p_array_size, 16);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
} else {
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
convert_item_std140<Projection>(value, gui);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
} break;
default: {
}
}
}
_FORCE_INLINE_ static void _fill_std140_ubo_value(ShaderLanguage::DataType type, const Vector<ShaderLanguage::ConstantNode::Value> &value, uint8_t *data) {
switch (type) {
case ShaderLanguage::TYPE_BOOL: {
uint32_t *gui = (uint32_t *)data;
Fix incorrect setup of boolean uniform instances
2022-10-09 08:14:07 +03:00
gui[0] = value[0].boolean ? 1 : 0;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} break;
case ShaderLanguage::TYPE_BVEC2: {
uint32_t *gui = (uint32_t *)data;
gui[0] = value[0].boolean ? 1 : 0;
gui[1] = value[1].boolean ? 1 : 0;
} break;
case ShaderLanguage::TYPE_BVEC3: {
uint32_t *gui = (uint32_t *)data;
gui[0] = value[0].boolean ? 1 : 0;
gui[1] = value[1].boolean ? 1 : 0;
gui[2] = value[2].boolean ? 1 : 0;
} break;
case ShaderLanguage::TYPE_BVEC4: {
uint32_t *gui = (uint32_t *)data;
gui[0] = value[0].boolean ? 1 : 0;
gui[1] = value[1].boolean ? 1 : 0;
gui[2] = value[2].boolean ? 1 : 0;
gui[3] = value[3].boolean ? 1 : 0;
} break;
case ShaderLanguage::TYPE_INT: {
int32_t *gui = (int32_t *)data;
gui[0] = value[0].sint;
} break;
case ShaderLanguage::TYPE_IVEC2: {
int32_t *gui = (int32_t *)data;
for (int i = 0; i < 2; i++) {
gui[i] = value[i].sint;
}
} break;
case ShaderLanguage::TYPE_IVEC3: {
int32_t *gui = (int32_t *)data;
for (int i = 0; i < 3; i++) {
gui[i] = value[i].sint;
}
} break;
case ShaderLanguage::TYPE_IVEC4: {
int32_t *gui = (int32_t *)data;
for (int i = 0; i < 4; i++) {
gui[i] = value[i].sint;
}
} break;
case ShaderLanguage::TYPE_UINT: {
uint32_t *gui = (uint32_t *)data;
gui[0] = value[0].uint;
} break;
case ShaderLanguage::TYPE_UVEC2: {
int32_t *gui = (int32_t *)data;
for (int i = 0; i < 2; i++) {
gui[i] = value[i].uint;
}
} break;
case ShaderLanguage::TYPE_UVEC3: {
int32_t *gui = (int32_t *)data;
for (int i = 0; i < 3; i++) {
gui[i] = value[i].uint;
}
} break;
case ShaderLanguage::TYPE_UVEC4: {
int32_t *gui = (int32_t *)data;
for (int i = 0; i < 4; i++) {
gui[i] = value[i].uint;
}
} break;
case ShaderLanguage::TYPE_FLOAT: {
float *gui = (float *)data;
gui[0] = value[0].real;
} break;
case ShaderLanguage::TYPE_VEC2: {
float *gui = (float *)data;
for (int i = 0; i < 2; i++) {
gui[i] = value[i].real;
}
} break;
case ShaderLanguage::TYPE_VEC3: {
float *gui = (float *)data;
for (int i = 0; i < 3; i++) {
gui[i] = value[i].real;
}
} break;
case ShaderLanguage::TYPE_VEC4: {
float *gui = (float *)data;
for (int i = 0; i < 4; i++) {
gui[i] = value[i].real;
}
} break;
case ShaderLanguage::TYPE_MAT2: {
float *gui = (float *)data;
//in std140 members of mat2 are treated as vec4s
gui[0] = value[0].real;
gui[1] = value[1].real;
gui[2] = 0;
gui[3] = 0;
gui[4] = value[2].real;
gui[5] = value[3].real;
gui[6] = 0;
gui[7] = 0;
} break;
case ShaderLanguage::TYPE_MAT3: {
float *gui = (float *)data;
gui[0] = value[0].real;
gui[1] = value[1].real;
gui[2] = value[2].real;
gui[3] = 0;
gui[4] = value[3].real;
gui[5] = value[4].real;
gui[6] = value[5].real;
gui[7] = 0;
gui[8] = value[6].real;
gui[9] = value[7].real;
gui[10] = value[8].real;
gui[11] = 0;
} break;
case ShaderLanguage::TYPE_MAT4: {
float *gui = (float *)data;
for (int i = 0; i < 16; i++) {
gui[i] = value[i].real;
}
} break;
default: {
}
}
}
_FORCE_INLINE_ static void _fill_std140_ubo_empty(ShaderLanguage::DataType type, int p_array_size, uint8_t *data) {
if (p_array_size <= 0) {
p_array_size = 1;
}
switch (type) {
case ShaderLanguage::TYPE_BOOL:
case ShaderLanguage::TYPE_INT:
case ShaderLanguage::TYPE_UINT:
case ShaderLanguage::TYPE_FLOAT: {
memset(data, 0, 4 * p_array_size);
} break;
case ShaderLanguage::TYPE_BVEC2:
case ShaderLanguage::TYPE_IVEC2:
case ShaderLanguage::TYPE_UVEC2:
case ShaderLanguage::TYPE_VEC2: {
memset(data, 0, 8 * p_array_size);
} break;
case ShaderLanguage::TYPE_BVEC3:
case ShaderLanguage::TYPE_IVEC3:
case ShaderLanguage::TYPE_UVEC3:
Fix incorrect offset for vec3 datatypes in `_fill_std140_ubo_empty`
2022-10-09 06:32:50 +03:00
case ShaderLanguage::TYPE_VEC3: {
memset(data, 0, 12 * p_array_size);
} break;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
case ShaderLanguage::TYPE_BVEC4:
case ShaderLanguage::TYPE_IVEC4:
case ShaderLanguage::TYPE_UVEC4:
case ShaderLanguage::TYPE_VEC4: {
memset(data, 0, 16 * p_array_size);
} break;
case ShaderLanguage::TYPE_MAT2: {
memset(data, 0, 32 * p_array_size);
} break;
case ShaderLanguage::TYPE_MAT3: {
memset(data, 0, 48 * p_array_size);
} break;
case ShaderLanguage::TYPE_MAT4: {
memset(data, 0, 64 * p_array_size);
} break;
default: {
}
}
}
Refactor `ShaderData` & fix the sorting of shader uniforms
2022-12-13 15:39:53 +03:00
///////////////////////////////////////////////////////////////////////////
// ShaderData
void ShaderData::set_path_hint(const String &p_hint) {
path = p_hint;
}
void ShaderData::set_default_texture_parameter(const StringName &p_name, RID p_texture, int p_index) {
if (!p_texture.is_valid()) {
if (default_texture_params.has(p_name) && default_texture_params[p_name].has(p_index)) {
default_texture_params[p_name].erase(p_index);
if (default_texture_params[p_name].is_empty()) {
default_texture_params.erase(p_name);
}
}
} else {
if (!default_texture_params.has(p_name)) {
default_texture_params[p_name] = HashMap<int, RID>();
}
default_texture_params[p_name][p_index] = p_texture;
}
}
Variant ShaderData::get_default_parameter(const StringName &p_parameter) const {
if (uniforms.has(p_parameter)) {
ShaderLanguage::ShaderNode::Uniform uniform = uniforms[p_parameter];
Vector<ShaderLanguage::ConstantNode::Value> default_value = uniform.default_value;
return ShaderLanguage::constant_value_to_variant(default_value, uniform.type, uniform.array_size, uniform.hint);
}
return Variant();
}
void ShaderData::get_shader_uniform_list(List<PropertyInfo> *p_param_list) const {
SortArray<Pair<StringName, int>, ShaderLanguage::UniformOrderComparator> sorter;
LocalVector<Pair<StringName, int>> filtered_uniforms;
for (const KeyValue<StringName, ShaderLanguage::ShaderNode::Uniform> &E : uniforms) {
if (E.value.scope != ShaderLanguage::ShaderNode::Uniform::SCOPE_LOCAL) {
continue;
}
if (E.value.texture_order >= 0) {
filtered_uniforms.push_back(Pair<StringName, int>(E.key, E.value.texture_order + 100000));
} else {
filtered_uniforms.push_back(Pair<StringName, int>(E.key, E.value.order));
}
}
int uniform_count = filtered_uniforms.size();
sorter.sort(filtered_uniforms.ptr(), uniform_count);
String last_group;
for (int i = 0; i < uniform_count; i++) {
const StringName &uniform_name = filtered_uniforms[i].first;
const ShaderLanguage::ShaderNode::Uniform &uniform = uniforms[uniform_name];
String group = uniform.group;
if (!uniform.subgroup.is_empty()) {
group += "::" + uniform.subgroup;
}
if (group != last_group) {
PropertyInfo pi;
pi.usage = PROPERTY_USAGE_GROUP;
pi.name = group;
p_param_list->push_back(pi);
last_group = group;
}
PropertyInfo pi = ShaderLanguage::uniform_to_property_info(uniform);
pi.name = uniform_name;
p_param_list->push_back(pi);
}
}
void ShaderData::get_instance_param_list(List<RendererMaterialStorage::InstanceShaderParam> *p_param_list) const {
for (const KeyValue<StringName, ShaderLanguage::ShaderNode::Uniform> &E : uniforms) {
if (E.value.scope != ShaderLanguage::ShaderNode::Uniform::SCOPE_INSTANCE) {
continue;
}
RendererMaterialStorage::InstanceShaderParam p;
p.info = ShaderLanguage::uniform_to_property_info(E.value);
p.info.name = E.key; //supply name
p.index = E.value.instance_index;
p.default_value = ShaderLanguage::constant_value_to_variant(E.value.default_value, E.value.type, E.value.array_size, E.value.hint);
p_param_list->push_back(p);
}
}
bool ShaderData::is_parameter_texture(const StringName &p_param) const {
if (!uniforms.has(p_param)) {
return false;
}
return uniforms[p_param].texture_order >= 0;
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
///////////////////////////////////////////////////////////////////////////
// MaterialData
SceneShader compiling
2022-05-03 13:28:15 -07:00
// Look up table to translate ShaderLanguage::DataType to GL_TEXTURE_*
static const GLenum target_from_type[ShaderLanguage::TYPE_MAX] = {
GL_TEXTURE_2D, // TYPE_VOID,
GL_TEXTURE_2D, // TYPE_BOOL,
GL_TEXTURE_2D, // TYPE_BVEC2,
GL_TEXTURE_2D, // TYPE_BVEC3,
GL_TEXTURE_2D, // TYPE_BVEC4,
GL_TEXTURE_2D, // TYPE_INT,
GL_TEXTURE_2D, // TYPE_IVEC2,
GL_TEXTURE_2D, // TYPE_IVEC3,
GL_TEXTURE_2D, // TYPE_IVEC4,
GL_TEXTURE_2D, // TYPE_UINT,
GL_TEXTURE_2D, // TYPE_UVEC2,
GL_TEXTURE_2D, // TYPE_UVEC3,
GL_TEXTURE_2D, // TYPE_UVEC4,
GL_TEXTURE_2D, // TYPE_FLOAT,
GL_TEXTURE_2D, // TYPE_VEC2,
GL_TEXTURE_2D, // TYPE_VEC3,
GL_TEXTURE_2D, // TYPE_VEC4,
GL_TEXTURE_2D, // TYPE_MAT2,
GL_TEXTURE_2D, // TYPE_MAT3,
GL_TEXTURE_2D, // TYPE_MAT4,
GL_TEXTURE_2D, // TYPE_SAMPLER2D,
GL_TEXTURE_2D, // TYPE_ISAMPLER2D,
GL_TEXTURE_2D, // TYPE_USAMPLER2D,
GL_TEXTURE_2D_ARRAY, // TYPE_SAMPLER2DARRAY,
GL_TEXTURE_2D_ARRAY, // TYPE_ISAMPLER2DARRAY,
GL_TEXTURE_2D_ARRAY, // TYPE_USAMPLER2DARRAY,
GL_TEXTURE_3D, // TYPE_SAMPLER3D,
GL_TEXTURE_3D, // TYPE_ISAMPLER3D,
GL_TEXTURE_3D, // TYPE_USAMPLER3D,
GL_TEXTURE_CUBE_MAP, // TYPE_SAMPLERCUBE,
GL_TEXTURE_CUBE_MAP, // TYPE_SAMPLERCUBEARRAY,
GL_TEXTURE_2D, // TYPE_STRUCT
};
Properly map shader language texture hints to sampler hints in GLES3 renderer
2023-01-06 15:52:12 -08:00
static const RS::CanvasItemTextureRepeat repeat_from_uniform[ShaderLanguage::REPEAT_DEFAULT + 1] = {
RS::CanvasItemTextureRepeat::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED, // ShaderLanguage::TextureRepeat::REPEAT_DISABLE,
RS::CanvasItemTextureRepeat::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED, // ShaderLanguage::TextureRepeat::REPEAT_ENABLE,
RS::CanvasItemTextureRepeat::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED, // ShaderLanguage::TextureRepeat::REPEAT_DEFAULT,
};
Add proper default texture filter and repeat modes for Canvas shaders in the OpenGL3 renderer
2023-03-03 10:58:57 -08:00
static const RS::CanvasItemTextureRepeat repeat_from_uniform_canvas[ShaderLanguage::REPEAT_DEFAULT + 1] = {
RS::CanvasItemTextureRepeat::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED, // ShaderLanguage::TextureRepeat::REPEAT_DISABLE,
RS::CanvasItemTextureRepeat::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED, // ShaderLanguage::TextureRepeat::REPEAT_ENABLE,
RS::CanvasItemTextureRepeat::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED, // ShaderLanguage::TextureRepeat::REPEAT_DEFAULT,
};
Properly map shader language texture hints to sampler hints in GLES3 renderer
2023-01-06 15:52:12 -08:00
static const RS::CanvasItemTextureFilter filter_from_uniform[ShaderLanguage::FILTER_DEFAULT + 1] = {
RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_NEAREST, // ShaderLanguage::TextureFilter::FILTER_NEAREST,
RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, // ShaderLanguage::TextureFilter::FILTER_LINEAR,
RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS, // ShaderLanguage::TextureFilter::FILTER_NEAREST_MIPMAP,
RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, // ShaderLanguage::TextureFilter::FILTER_LINEAR_MIPMAP,
RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC, // ShaderLanguage::TextureFilter::FILTER_NEAREST_MIPMAP_ANISOTROPIC,
RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC, // ShaderLanguage::TextureFilter::FILTER_LINEAR_MIPMAP_ANISOTROPIC,
RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, // ShaderLanguage::TextureFilter::FILTER_DEFAULT,
};
Add proper default texture filter and repeat modes for Canvas shaders in the OpenGL3 renderer
2023-03-03 10:58:57 -08:00
static const RS::CanvasItemTextureFilter filter_from_uniform_canvas[ShaderLanguage::FILTER_DEFAULT + 1] = {
RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_NEAREST, // ShaderLanguage::TextureFilter::FILTER_NEAREST,
RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, // ShaderLanguage::TextureFilter::FILTER_LINEAR,
RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS, // ShaderLanguage::TextureFilter::FILTER_NEAREST_MIPMAP,
RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, // ShaderLanguage::TextureFilter::FILTER_LINEAR_MIPMAP,
RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC, // ShaderLanguage::TextureFilter::FILTER_NEAREST_MIPMAP_ANISOTROPIC,
RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC, // ShaderLanguage::TextureFilter::FILTER_LINEAR_MIPMAP_ANISOTROPIC,
RS::CanvasItemTextureFilter::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, // ShaderLanguage::TextureFilter::FILTER_DEFAULT,
};
Ensure that "detect 3D" is only called when using 3D shaders
2023-06-13 13:20:11 -07:00
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) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
MaterialStorage *material_storage = MaterialStorage::get_singleton();
bool uses_global_buffer = false;
for (const KeyValue<StringName, ShaderLanguage::ShaderNode::Uniform> &E : p_uniforms) {
if (E.value.order < 0) {
continue; // texture, does not go here
}
if (E.value.scope == ShaderLanguage::ShaderNode::Uniform::SCOPE_INSTANCE) {
continue; //instance uniforms don't appear in the buffer
}
if (E.value.scope == ShaderLanguage::ShaderNode::Uniform::SCOPE_GLOBAL) {
//this is a global variable, get the index to it
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Variable *gv = material_storage->global_shader_uniforms.variables.getptr(E.key);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
uint32_t index = 0;
if (gv) {
index = gv->buffer_index;
} else {
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
WARN_PRINT("Shader uses global parameter '" + E.key + "', but it was removed at some point. Material will not display correctly.");
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
uint32_t offset = p_uniform_offsets[E.value.order];
uint32_t *intptr = (uint32_t *)&p_buffer[offset];
*intptr = index;
uses_global_buffer = true;
continue;
}
//regular uniform
uint32_t offset = p_uniform_offsets[E.value.order];
#ifdef DEBUG_ENABLED
uint32_t size = 0U;
// The following code enforces a 16-byte alignment of uniform arrays.
if (E.value.array_size > 0) {
size = ShaderLanguage::get_datatype_size(E.value.type) * E.value.array_size;
int m = (16 * E.value.array_size);
if ((size % m) != 0U) {
size += m - (size % m);
}
} else {
size = ShaderLanguage::get_datatype_size(E.value.type);
}
ERR_CONTINUE(offset + size > p_buffer_size);
#endif
uint8_t *data = &p_buffer[offset];
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<StringName, Variant>::ConstIterator V = p_parameters.find(E.key);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (V) {
//user provided
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
_fill_std140_variant_ubo_value(E.value.type, E.value.array_size, V->value, data);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else if (E.value.default_value.size()) {
//default value
_fill_std140_ubo_value(E.value.type, E.value.default_value, data);
//value=E.value.default_value;
} else {
//zero because it was not provided
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
if ((E.value.type == ShaderLanguage::TYPE_VEC3 || E.value.type == ShaderLanguage::TYPE_VEC4) && E.value.hint == ShaderLanguage::ShaderNode::Uniform::HINT_SOURCE_COLOR) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
//colors must be set as black, with alpha as 1.0
Basic 3D rendering
2022-05-10 10:02:44 -07:00
_fill_std140_variant_ubo_value(E.value.type, E.value.array_size, Color(0, 0, 0, 1), data);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
//else just zero it out
_fill_std140_ubo_empty(E.value.type, E.value.array_size, data);
}
}
}
if (uses_global_buffer != (global_buffer_E != nullptr)) {
if (uses_global_buffer) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_buffer_E = material_storage->global_shader_uniforms.materials_using_buffer.push_back(self);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
material_storage->global_shader_uniforms.materials_using_buffer.erase(global_buffer_E);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
global_buffer_E = nullptr;
}
}
}
MaterialData::~MaterialData() {
MaterialStorage *material_storage = MaterialStorage::get_singleton();
if (global_buffer_E) {
//unregister global buffers
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
material_storage->global_shader_uniforms.materials_using_buffer.erase(global_buffer_E);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
if (global_texture_E) {
//unregister global textures
for (const KeyValue<StringName, uint64_t> &E : used_global_textures) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Variable *v = material_storage->global_shader_uniforms.variables.getptr(E.key);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (v) {
v->texture_materials.erase(self);
}
}
//unregister material from those using global textures
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
material_storage->global_shader_uniforms.materials_using_texture.erase(global_texture_E);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
if (uniform_buffer) {
glDeleteBuffers(1, &uniform_buffer);
Add basic lighting to GLES3 renderer. This includes all three light types and IBL, but does not include shadows or any form of GI
2022-05-16 11:56:03 -07:00
uniform_buffer = 0;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
}
Ensure that "detect 3D" is only called when using 3D shaders
2023-06-13 13:20:11 -07:00
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) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
TextureStorage *texture_storage = TextureStorage::get_singleton();
MaterialStorage *material_storage = MaterialStorage::get_singleton();
#ifdef TOOLS_ENABLED
Texture *roughness_detect_texture = nullptr;
RS::TextureDetectRoughnessChannel roughness_channel = RS::TEXTURE_DETECT_ROUGHNESS_R;
Texture *normal_detect_texture = nullptr;
#endif
bool uses_global_textures = false;
global_textures_pass++;
for (int i = 0, k = 0; i < p_texture_uniforms.size(); i++) {
const StringName &uniform_name = p_texture_uniforms[i].name;
int uniform_array_size = p_texture_uniforms[i].array_size;
Vector<RID> textures;
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
if (p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_SCREEN_TEXTURE ||
p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL_ROUGHNESS_TEXTURE ||
p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_DEPTH_TEXTURE) {
continue;
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (p_texture_uniforms[i].global) {
uses_global_textures = true;
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Variable *v = material_storage->global_shader_uniforms.variables.getptr(uniform_name);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (v) {
if (v->buffer_index >= 0) {
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
WARN_PRINT("Shader uses global parameter texture '" + String(uniform_name) + "', but it changed type and is no longer a texture!.");
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<StringName, uint64_t>::Iterator E = used_global_textures.find(uniform_name);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (!E) {
E = used_global_textures.insert(uniform_name, global_textures_pass);
v->texture_materials.insert(self);
} else {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
E->value = global_textures_pass;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
textures.push_back(v->override.get_type() != Variant::NIL ? v->override : v->value);
}
} else {
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
WARN_PRINT("Shader uses global parameter texture '" + String(uniform_name) + "', but it was removed at some point. Material will not display correctly.");
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
} else {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<StringName, Variant>::ConstIterator V = p_parameters.find(uniform_name);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (V) {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
if (V->value.is_array()) {
Array array = (Array)V->value;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (uniform_array_size > 0) {
for (int j = 0; j < array.size(); j++) {
textures.push_back(array[j]);
}
} else {
if (array.size() > 0) {
textures.push_back(array[0]);
}
}
} else {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
textures.push_back(V->value);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
}
if (uniform_array_size > 0) {
if (textures.size() < uniform_array_size) {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<StringName, HashMap<int, RID>>::ConstIterator W = p_default_textures.find(uniform_name);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
for (int j = textures.size(); j < uniform_array_size; j++) {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
if (W && W->value.has(j)) {
textures.push_back(W->value[j]);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
textures.push_back(RID());
}
}
}
} else if (textures.is_empty()) {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<StringName, HashMap<int, RID>>::ConstIterator W = p_default_textures.find(uniform_name);
if (W && W->value.has(0)) {
textures.push_back(W->value[0]);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
}
}
RID gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_WHITE);
if (textures.is_empty()) {
//check default usage
switch (p_texture_uniforms[i].type) {
case ShaderLanguage::TYPE_ISAMPLER2D:
case ShaderLanguage::TYPE_USAMPLER2D:
case ShaderLanguage::TYPE_SAMPLER2D: {
switch (p_texture_uniforms[i].hint) {
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
case ShaderLanguage::ShaderNode::Uniform::HINT_DEFAULT_BLACK: {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_BLACK);
} break;
Add `hint_transparent` to use a transparent black placeholder texture This can be used in shaders to avoid the need to supply a transparent placeholder texture manually.
2021-08-14 18:29:52 +02:00
case ShaderLanguage::ShaderNode::Uniform::HINT_DEFAULT_TRANSPARENT: {
gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_TRANSPARENT);
} break;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
case ShaderLanguage::ShaderNode::Uniform::HINT_ANISOTROPY: {
gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_ANISO);
} break;
case ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL: {
gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_NORMAL);
} break;
case ShaderLanguage::ShaderNode::Uniform::HINT_ROUGHNESS_NORMAL: {
gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_NORMAL);
} break;
default: {
gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_WHITE);
} break;
}
} break;
case ShaderLanguage::TYPE_SAMPLERCUBE: {
switch (p_texture_uniforms[i].hint) {
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
case ShaderLanguage::ShaderNode::Uniform::HINT_DEFAULT_BLACK: {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_CUBEMAP_BLACK);
} break;
default: {
gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_CUBEMAP_WHITE);
} break;
}
} break;
case ShaderLanguage::TYPE_SAMPLERCUBEARRAY: {
Add warnings and fallbacks for particles sub emitters when using the GL Compatibility rendering backend Co-authored-by: Hugo Locurcio <hugo.locurcio@hugo.pro>
2023-06-20 14:03:14 -07:00
ERR_PRINT_ONCE("Type: SamplerCubeArray not supported in GL Compatibility rendering backend, please use another type.");
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} break;
case ShaderLanguage::TYPE_ISAMPLER3D:
case ShaderLanguage::TYPE_USAMPLER3D:
case ShaderLanguage::TYPE_SAMPLER3D: {
switch (p_texture_uniforms[i].hint) {
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
case ShaderLanguage::ShaderNode::Uniform::HINT_DEFAULT_BLACK: {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_3D_BLACK);
} break;
default: {
gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_3D_WHITE);
} break;
}
} break;
case ShaderLanguage::TYPE_ISAMPLER2DARRAY:
case ShaderLanguage::TYPE_USAMPLER2DARRAY:
case ShaderLanguage::TYPE_SAMPLER2DARRAY: {
gl_texture = texture_storage->texture_gl_get_default(DEFAULT_GL_TEXTURE_2D_ARRAY_WHITE);
} break;
default: {
}
}
#ifdef TOOLS_ENABLED
if (roughness_detect_texture && normal_detect_texture && !normal_detect_texture->path.is_empty()) {
roughness_detect_texture->detect_roughness_callback(roughness_detect_texture->detect_roughness_callback_ud, normal_detect_texture->path, roughness_channel);
}
#endif
if (uniform_array_size > 0) {
for (int j = 0; j < uniform_array_size; j++) {
p_textures[k++] = gl_texture;
}
} else {
p_textures[k++] = gl_texture;
}
} else {
for (int j = 0; j < textures.size(); j++) {
Texture *tex = TextureStorage::get_singleton()->get_texture(textures[j]);
if (tex) {
gl_texture = textures[j];
#ifdef TOOLS_ENABLED
Ensure that "detect 3D" is only called when using 3D shaders
2023-06-13 13:20:11 -07:00
if (tex->detect_3d_callback && p_is_3d_shader_type) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
tex->detect_3d_callback(tex->detect_3d_callback_ud);
}
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)) {
if (p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_ROUGHNESS_NORMAL) {
normal_detect_texture = tex;
}
tex->detect_normal_callback(tex->detect_normal_callback_ud);
}
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)) {
//find the normal texture
roughness_detect_texture = tex;
roughness_channel = RS::TextureDetectRoughnessChannel(p_texture_uniforms[i].hint - ShaderLanguage::ShaderNode::Uniform::HINT_ROUGHNESS_R);
}
#endif
}
#ifdef TOOLS_ENABLED
if (roughness_detect_texture && normal_detect_texture && !normal_detect_texture->path.is_empty()) {
roughness_detect_texture->detect_roughness_callback(roughness_detect_texture->detect_roughness_callback_ud, normal_detect_texture->path, roughness_channel);
}
#endif
p_textures[k++] = gl_texture;
}
}
}
{
//for textures no longer used, unregister them
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
List<StringName> to_delete;
for (KeyValue<StringName, uint64_t> &E : used_global_textures) {
if (E.value != global_textures_pass) {
to_delete.push_back(E.key);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Variable *v = material_storage->global_shader_uniforms.variables.getptr(E.key);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (v) {
v->texture_materials.erase(self);
}
}
}
while (to_delete.front()) {
used_global_textures.erase(to_delete.front()->get());
to_delete.pop_front();
}
//handle registering/unregistering global textures
if (uses_global_textures != (global_texture_E != nullptr)) {
if (uses_global_textures) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_texture_E = material_storage->global_shader_uniforms.materials_using_texture.push_back(self);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
material_storage->global_shader_uniforms.materials_using_texture.erase(global_texture_E);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
global_texture_E = nullptr;
}
}
}
}
Ensure that "detect 3D" is only called when using 3D shaders
2023-06-13 13:20:11 -07:00
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) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if ((uint32_t)ubo_data.size() != p_ubo_size) {
p_uniform_dirty = true;
if (!uniform_buffer) {
glGenBuffers(1, &uniform_buffer);
}
ubo_data.resize(p_ubo_size);
if (ubo_data.size()) {
memset(ubo_data.ptrw(), 0, ubo_data.size()); //clear
}
}
//check whether buffer changed
if (p_uniform_dirty && ubo_data.size()) {
Ensure that "detect 3D" is only called when using 3D shaders
2023-06-13 13:20:11 -07:00
update_uniform_buffer(p_uniforms, p_uniform_offsets, p_parameters, ubo_data.ptrw(), ubo_data.size());
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
glBindBuffer(GL_UNIFORM_BUFFER, uniform_buffer);
glBufferData(GL_UNIFORM_BUFFER, ubo_data.size(), ubo_data.ptrw(), GL_DYNAMIC_DRAW);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
}
uint32_t tex_uniform_count = 0U;
for (int i = 0; i < p_texture_uniforms.size(); i++) {
tex_uniform_count += uint32_t(p_texture_uniforms[i].array_size > 0 ? p_texture_uniforms[i].array_size : 1);
}
if ((uint32_t)texture_cache.size() != tex_uniform_count || p_textures_dirty) {
texture_cache.resize(tex_uniform_count);
p_textures_dirty = true;
}
if (p_textures_dirty && tex_uniform_count) {
Ensure that "detect 3D" is only called when using 3D shaders
2023-06-13 13:20:11 -07:00
update_textures(p_parameters, p_default_texture_params, p_texture_uniforms, texture_cache.ptrw(), p_is_3d_shader_type);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
}
///////////////////////////////////////////////////////////////////////////
// Material Storage
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
MaterialStorage *MaterialStorage::singleton = nullptr;
MaterialStorage *MaterialStorage::get_singleton() {
return singleton;
}
MaterialStorage::MaterialStorage() {
singleton = this;
SceneShader compiling
2022-05-03 13:28:15 -07:00
shader_data_request_func[RS::SHADER_SPATIAL] = _create_scene_shader_func;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
shader_data_request_func[RS::SHADER_CANVAS_ITEM] = _create_canvas_shader_func;
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
shader_data_request_func[RS::SHADER_PARTICLES] = _create_particles_shader_func;
SkyShaders working
2022-04-29 15:34:01 -07:00
shader_data_request_func[RS::SHADER_SKY] = _create_sky_shader_func;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
shader_data_request_func[RS::SHADER_FOG] = nullptr;
SceneShader compiling
2022-05-03 13:28:15 -07:00
material_data_request_func[RS::SHADER_SPATIAL] = _create_scene_material_func;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
material_data_request_func[RS::SHADER_CANVAS_ITEM] = _create_canvas_material_func;
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
material_data_request_func[RS::SHADER_PARTICLES] = _create_particles_material_func;
SkyShaders working
2022-04-29 15:34:01 -07:00
material_data_request_func[RS::SHADER_SKY] = _create_sky_material_func;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
material_data_request_func[RS::SHADER_FOG] = nullptr;
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
static_assert(sizeof(GlobalShaderUniforms::Value) == 16);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniforms.buffer_size = MAX(4096, (int)GLOBAL_GET("rendering/limits/global_shader_variables/buffer_size"));
if (global_shader_uniforms.buffer_size > uint32_t(Config::get_singleton()->max_uniform_buffer_size)) {
global_shader_uniforms.buffer_size = uint32_t(Config::get_singleton()->max_uniform_buffer_size);
Make solving project setting errors easier Show full project setting path in error messages. Force filtering for advanced settings if filter is not empty.
2022-11-29 02:42:19 +01:00
WARN_PRINT("Project setting \"rendering/limits/global_shader_variables/buffer_size\" exceeds maximum uniform buffer size of: " + itos(Config::get_singleton()->max_uniform_buffer_size));
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniforms.buffer_values = memnew_arr(GlobalShaderUniforms::Value, global_shader_uniforms.buffer_size);
memset(global_shader_uniforms.buffer_values, 0, sizeof(GlobalShaderUniforms::Value) * global_shader_uniforms.buffer_size);
global_shader_uniforms.buffer_usage = memnew_arr(GlobalShaderUniforms::ValueUsage, global_shader_uniforms.buffer_size);
global_shader_uniforms.buffer_dirty_regions = memnew_arr(bool, global_shader_uniforms.buffer_size / GlobalShaderUniforms::BUFFER_DIRTY_REGION_SIZE);
memset(global_shader_uniforms.buffer_dirty_regions, 0, sizeof(bool) * global_shader_uniforms.buffer_size / GlobalShaderUniforms::BUFFER_DIRTY_REGION_SIZE);
glGenBuffers(1, &global_shader_uniforms.buffer);
glBindBuffer(GL_UNIFORM_BUFFER, global_shader_uniforms.buffer);
glBufferData(GL_UNIFORM_BUFFER, sizeof(GlobalShaderUniforms::Value) * global_shader_uniforms.buffer_size, nullptr, GL_DYNAMIC_DRAW);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
glBindBuffer(GL_UNIFORM_BUFFER, 0);
{
// Setup CanvasItem compiler
ShaderCompiler::DefaultIdentifierActions actions;
actions.renames["VERTEX"] = "vertex";
actions.renames["LIGHT_VERTEX"] = "light_vertex";
actions.renames["SHADOW_VERTEX"] = "shadow_vertex";
actions.renames["UV"] = "uv";
Commit Fix for GLES3 point size not working
2023-02-25 23:39:43 -08:00
actions.renames["POINT_SIZE"] = "point_size";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.renames["MODEL_MATRIX"] = "model_matrix";
Fix canvasitem shader builtins when using GLES3 Remove prefix canvas_data. as it isn't used in the internal canvasitem shader
2022-09-14 12:41:08 -07:00
actions.renames["CANVAS_MATRIX"] = "canvas_transform";
actions.renames["SCREEN_MATRIX"] = "screen_transform";
actions.renames["TIME"] = "time";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.renames["PI"] = _MKSTR(Math_PI);
actions.renames["TAU"] = _MKSTR(Math_TAU);
actions.renames["E"] = _MKSTR(Math_E);
actions.renames["AT_LIGHT_PASS"] = "false";
actions.renames["INSTANCE_CUSTOM"] = "instance_custom";
actions.renames["COLOR"] = "color";
actions.renames["NORMAL"] = "normal";
actions.renames["NORMAL_MAP"] = "normal_map";
actions.renames["NORMAL_MAP_DEPTH"] = "normal_map_depth";
actions.renames["TEXTURE"] = "color_texture";
Properly expose TEXTURE_PIXEL_SIZE in Opengl3 renderer
2022-10-03 18:37:57 -07:00
actions.renames["TEXTURE_PIXEL_SIZE"] = "color_texture_pixel_size";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.renames["NORMAL_TEXTURE"] = "normal_texture";
actions.renames["SPECULAR_SHININESS_TEXTURE"] = "specular_texture";
actions.renames["SPECULAR_SHININESS"] = "specular_shininess";
actions.renames["SCREEN_UV"] = "screen_uv";
Fix canvasitem shader builtins when using GLES3 Remove prefix canvas_data. as it isn't used in the internal canvasitem shader
2022-09-14 12:41:08 -07:00
actions.renames["SCREEN_PIXEL_SIZE"] = "screen_pixel_size";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.renames["FRAGCOORD"] = "gl_FragCoord";
actions.renames["POINT_COORD"] = "gl_PointCoord";
actions.renames["INSTANCE_ID"] = "gl_InstanceIndex";
actions.renames["VERTEX_ID"] = "gl_VertexIndex";
actions.renames["LIGHT_POSITION"] = "light_position";
Clean up canvas light shader API. Expose LIGHT_ENERGY and LIGHT_IS_DIRECTIONAL. Add LIGHT_DIRECTION
2022-09-28 11:45:08 -07:00
actions.renames["LIGHT_DIRECTION"] = "light_direction";
actions.renames["LIGHT_IS_DIRECTIONAL"] = "is_directional";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.renames["LIGHT_COLOR"] = "light_color";
actions.renames["LIGHT_ENERGY"] = "light_energy";
actions.renames["LIGHT"] = "light";
actions.renames["SHADOW_MODULATE"] = "shadow_modulate";
actions.renames["texture_sdf"] = "texture_sdf";
actions.renames["texture_sdf_normal"] = "texture_sdf_normal";
actions.renames["sdf_to_screen_uv"] = "sdf_to_screen_uv";
actions.renames["screen_uv_to_sdf"] = "screen_uv_to_sdf";
actions.usage_defines["COLOR"] = "#define COLOR_USED\n";
actions.usage_defines["SCREEN_UV"] = "#define SCREEN_UV_USED\n";
actions.usage_defines["SCREEN_PIXEL_SIZE"] = "@SCREEN_UV";
actions.usage_defines["NORMAL"] = "#define NORMAL_USED\n";
actions.usage_defines["NORMAL_MAP"] = "#define NORMAL_MAP_USED\n";
actions.usage_defines["LIGHT"] = "#define LIGHT_SHADER_CODE_USED\n";
added usage_defines for SPECULAR_SHININESS added usage defines for opengl3 renderer
2022-06-21 00:28:50 -04:00
actions.usage_defines["SPECULAR_SHININESS"] = "#define SPECULAR_SHININESS_USED\n";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.render_mode_defines["skip_vertex_transform"] = "#define SKIP_TRANSFORM_USED\n";
actions.render_mode_defines["unshaded"] = "#define MODE_UNSHADED\n";
actions.render_mode_defines["light_only"] = "#define MODE_LIGHT_ONLY\n";
Add option to use world coordinates in canvas item shader By using the render mode `world_vertex_coords` you can automatically use the vertex coordinates in world space
2023-08-30 14:59:06 +02:00
actions.render_mode_defines["world_vertex_coords"] = "#define USE_WORLD_VERTEX_COORDS\n";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Properly append global uniform buffer name in gl_compatibility shaders Also error when using instance uniforms
2023-01-26 12:14:45 -08:00
actions.global_buffer_array_variable = "global_shader_uniforms";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
shaders.compiler_canvas.initialize(actions);
}
{
// Setup Scene compiler
SceneShader compiling
2022-05-03 13:28:15 -07:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
//shader compiler
ShaderCompiler::DefaultIdentifierActions actions;
actions.renames["MODEL_MATRIX"] = "model_matrix";
actions.renames["MODEL_NORMAL_MATRIX"] = "model_normal_matrix";
actions.renames["VIEW_MATRIX"] = "scene_data.view_matrix";
actions.renames["INV_VIEW_MATRIX"] = "scene_data.inv_view_matrix";
actions.renames["PROJECTION_MATRIX"] = "projection_matrix";
actions.renames["INV_PROJECTION_MATRIX"] = "inv_projection_matrix";
actions.renames["MODELVIEW_MATRIX"] = "modelview";
actions.renames["MODELVIEW_NORMAL_MATRIX"] = "modelview_normal";
actions.renames["VERTEX"] = "vertex";
actions.renames["NORMAL"] = "normal";
actions.renames["TANGENT"] = "tangent";
actions.renames["BINORMAL"] = "binormal";
actions.renames["POSITION"] = "position";
actions.renames["UV"] = "uv_interp";
actions.renames["UV2"] = "uv2_interp";
actions.renames["COLOR"] = "color_interp";
Commit Fix for GLES3 point size not working
2023-02-25 23:39:43 -08:00
actions.renames["POINT_SIZE"] = "point_size";
Remove requirement to have vertex positions when creating a mesh. Meshes can now be constructed from an index buffer alone
2022-06-24 11:22:26 -07:00
actions.renames["INSTANCE_ID"] = "gl_InstanceID";
actions.renames["VERTEX_ID"] = "gl_VertexID";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.renames["ALPHA_SCISSOR_THRESHOLD"] = "alpha_scissor_threshold";
actions.renames["ALPHA_HASH_SCALE"] = "alpha_hash_scale";
actions.renames["ALPHA_ANTIALIASING_EDGE"] = "alpha_antialiasing_edge";
actions.renames["ALPHA_TEXTURE_COORDINATE"] = "alpha_texture_coordinate";
//builtins
actions.renames["TIME"] = "scene_data.time";
Add EXPOSURE built in to spatial shaders This allows users to restore light values to pre-pre-exposure amounts
2023-01-13 14:02:46 -08:00
actions.renames["EXPOSURE"] = "(1.0 / scene_data.emissive_exposure_normalization)";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.renames["PI"] = _MKSTR(Math_PI);
actions.renames["TAU"] = _MKSTR(Math_TAU);
actions.renames["E"] = _MKSTR(Math_E);
actions.renames["VIEWPORT_SIZE"] = "scene_data.viewport_size";
actions.renames["FRAGCOORD"] = "gl_FragCoord";
actions.renames["FRONT_FACING"] = "gl_FrontFacing";
actions.renames["NORMAL_MAP"] = "normal_map";
actions.renames["NORMAL_MAP_DEPTH"] = "normal_map_depth";
actions.renames["ALBEDO"] = "albedo";
actions.renames["ALPHA"] = "alpha";
actions.renames["METALLIC"] = "metallic";
actions.renames["SPECULAR"] = "specular";
actions.renames["ROUGHNESS"] = "roughness";
actions.renames["RIM"] = "rim";
actions.renames["RIM_TINT"] = "rim_tint";
actions.renames["CLEARCOAT"] = "clearcoat";
actions.renames["CLEARCOAT_ROUGHNESS"] = "clearcoat_roughness";
actions.renames["ANISOTROPY"] = "anisotropy";
actions.renames["ANISOTROPY_FLOW"] = "anisotropy_flow";
actions.renames["SSS_STRENGTH"] = "sss_strength";
actions.renames["SSS_TRANSMITTANCE_COLOR"] = "transmittance_color";
actions.renames["SSS_TRANSMITTANCE_DEPTH"] = "transmittance_depth";
actions.renames["SSS_TRANSMITTANCE_BOOST"] = "transmittance_boost";
actions.renames["BACKLIGHT"] = "backlight";
actions.renames["AO"] = "ao";
actions.renames["AO_LIGHT_AFFECT"] = "ao_light_affect";
actions.renames["EMISSION"] = "emission";
actions.renames["POINT_COORD"] = "gl_PointCoord";
actions.renames["INSTANCE_CUSTOM"] = "instance_custom";
actions.renames["SCREEN_UV"] = "screen_uv";
actions.renames["DEPTH"] = "gl_FragDepth";
Fix `FOG` built-in in spatial/fragment shader
2022-07-26 08:07:22 +03:00
actions.renames["FOG"] = "fog";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.renames["RADIANCE"] = "custom_radiance";
actions.renames["IRRADIANCE"] = "custom_irradiance";
actions.renames["BONE_INDICES"] = "bone_attrib";
actions.renames["BONE_WEIGHTS"] = "weight_attrib";
actions.renames["CUSTOM0"] = "custom0_attrib";
actions.renames["CUSTOM1"] = "custom1_attrib";
actions.renames["CUSTOM2"] = "custom2_attrib";
actions.renames["CUSTOM3"] = "custom3_attrib";
actions.renames["OUTPUT_IS_SRGB"] = "SHADER_IS_SRGB";
Add spatial built-ins (camera-pos, object-pos, camera-eye etc.)
2022-07-28 23:56:28 +02:00
actions.renames["NODE_POSITION_WORLD"] = "model_matrix[3].xyz";
actions.renames["CAMERA_POSITION_WORLD"] = "scene_data.inv_view_matrix[3].xyz";
actions.renames["CAMERA_DIRECTION_WORLD"] = "scene_data.view_matrix[3].xyz";
Implement CAMERA_VISIBLE_LAYERS as built-in shader variable
2022-10-12 19:33:06 -07:00
actions.renames["CAMERA_VISIBLE_LAYERS"] = "scene_data.camera_visible_layers";
Fix Rotation Issue with NODE_POSITION_VIEW Visual Shader Node
2023-04-15 19:52:09 +02:00
actions.renames["NODE_POSITION_VIEW"] = "(scene_data.view_matrix * model_matrix)[3].xyz";
Add spatial built-ins (camera-pos, object-pos, camera-eye etc.)
2022-07-28 23:56:28 +02:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.renames["VIEW_INDEX"] = "ViewIndex";
Make screen texture and depth texture work in Multiview
2023-01-15 16:07:59 +11:00
actions.renames["VIEW_MONO_LEFT"] = "uint(0)";
actions.renames["VIEW_RIGHT"] = "uint(1)";
Expose EYE_OFFSET to gdshader code
2023-02-01 12:33:22 +11:00
actions.renames["EYE_OFFSET"] = "eye_offset";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
//for light
actions.renames["VIEW"] = "view";
Add SPECULAR_AMOUNT spatial light shader built-in Light3D has a light_specular property which is used to set the intensity of specular contributed by this light source, but it was previously only used by the default material light shader, and not possible to use in a custom light() shader.
2023-03-18 10:03:07 +01:00
actions.renames["SPECULAR_AMOUNT"] = "specular_amount";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.renames["LIGHT_COLOR"] = "light_color";
Add LIGHT_IS_DIRECTIONAL built-in for spatial shaders
2023-04-20 14:33:30 +02:00
actions.renames["LIGHT_IS_DIRECTIONAL"] = "is_directional";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.renames["LIGHT"] = "light";
actions.renames["ATTENUATION"] = "attenuation";
actions.renames["DIFFUSE_LIGHT"] = "diffuse_light";
actions.renames["SPECULAR_LIGHT"] = "specular_light";
actions.usage_defines["NORMAL"] = "#define NORMAL_USED\n";
actions.usage_defines["TANGENT"] = "#define TANGENT_USED\n";
actions.usage_defines["BINORMAL"] = "@TANGENT";
actions.usage_defines["RIM"] = "#define LIGHT_RIM_USED\n";
actions.usage_defines["RIM_TINT"] = "@RIM";
actions.usage_defines["CLEARCOAT"] = "#define LIGHT_CLEARCOAT_USED\n";
actions.usage_defines["CLEARCOAT_ROUGHNESS"] = "@CLEARCOAT";
actions.usage_defines["ANISOTROPY"] = "#define LIGHT_ANISOTROPY_USED\n";
actions.usage_defines["ANISOTROPY_FLOW"] = "@ANISOTROPY";
actions.usage_defines["AO"] = "#define AO_USED\n";
actions.usage_defines["AO_LIGHT_AFFECT"] = "#define AO_USED\n";
actions.usage_defines["UV"] = "#define UV_USED\n";
actions.usage_defines["UV2"] = "#define UV2_USED\n";
actions.usage_defines["BONE_INDICES"] = "#define BONES_USED\n";
actions.usage_defines["BONE_WEIGHTS"] = "#define WEIGHTS_USED\n";
actions.usage_defines["CUSTOM0"] = "#define CUSTOM0_USED\n";
actions.usage_defines["CUSTOM1"] = "#define CUSTOM1_USED\n";
actions.usage_defines["CUSTOM2"] = "#define CUSTOM2_USED\n";
actions.usage_defines["CUSTOM3"] = "#define CUSTOM3_USED\n";
actions.usage_defines["NORMAL_MAP"] = "#define NORMAL_MAP_USED\n";
actions.usage_defines["NORMAL_MAP_DEPTH"] = "@NORMAL_MAP";
actions.usage_defines["COLOR"] = "#define COLOR_USED\n";
actions.usage_defines["INSTANCE_CUSTOM"] = "#define ENABLE_INSTANCE_CUSTOM\n";
actions.usage_defines["POSITION"] = "#define OVERRIDE_POSITION\n";
actions.usage_defines["ALPHA_SCISSOR_THRESHOLD"] = "#define ALPHA_SCISSOR_USED\n";
actions.usage_defines["ALPHA_HASH_SCALE"] = "#define ALPHA_HASH_USED\n";
actions.usage_defines["ALPHA_ANTIALIASING_EDGE"] = "#define ALPHA_ANTIALIASING_EDGE_USED\n";
actions.usage_defines["ALPHA_TEXTURE_COORDINATE"] = "@ALPHA_ANTIALIASING_EDGE";
actions.usage_defines["SSS_STRENGTH"] = "#define ENABLE_SSS\n";
actions.usage_defines["SSS_TRANSMITTANCE_DEPTH"] = "#define ENABLE_TRANSMITTANCE\n";
actions.usage_defines["BACKLIGHT"] = "#define LIGHT_BACKLIGHT_USED\n";
actions.usage_defines["SCREEN_UV"] = "#define SCREEN_UV_USED\n";
actions.usage_defines["DIFFUSE_LIGHT"] = "#define USE_LIGHT_SHADER_CODE\n";
actions.usage_defines["SPECULAR_LIGHT"] = "#define USE_LIGHT_SHADER_CODE\n";
actions.usage_defines["FOG"] = "#define CUSTOM_FOG_USED\n";
actions.usage_defines["RADIANCE"] = "#define CUSTOM_RADIANCE_USED\n";
actions.usage_defines["IRRADIANCE"] = "#define CUSTOM_IRRADIANCE_USED\n";
actions.render_mode_defines["skip_vertex_transform"] = "#define SKIP_TRANSFORM_USED\n";
actions.render_mode_defines["world_vertex_coords"] = "#define VERTEX_WORLD_COORDS_USED\n";
actions.render_mode_defines["ensure_correct_normals"] = "#define ENSURE_CORRECT_NORMALS\n";
actions.render_mode_defines["cull_front"] = "#define DO_SIDE_CHECK\n";
actions.render_mode_defines["cull_disabled"] = "#define DO_SIDE_CHECK\n";
actions.render_mode_defines["particle_trails"] = "#define USE_PARTICLE_TRAILS\n";
Fix use of discard in shaders discard was being included in all shaders set to depth pass opaque, which is the majority of shaders Instead it should only be used with alpha prepass materials
2023-07-24 23:21:04 +02:00
actions.render_mode_defines["depth_prepass_alpha"] = "#define USE_OPAQUE_PREPASS\n";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
bool force_lambert = GLOBAL_GET("rendering/shading/overrides/force_lambert_over_burley");
if (!force_lambert) {
actions.render_mode_defines["diffuse_burley"] = "#define DIFFUSE_BURLEY\n";
}
actions.render_mode_defines["diffuse_lambert_wrap"] = "#define DIFFUSE_LAMBERT_WRAP\n";
actions.render_mode_defines["diffuse_toon"] = "#define DIFFUSE_TOON\n";
actions.render_mode_defines["sss_mode_skin"] = "#define SSS_MODE_SKIN\n";
actions.render_mode_defines["specular_schlick_ggx"] = "#define SPECULAR_SCHLICK_GGX\n";
actions.render_mode_defines["specular_toon"] = "#define SPECULAR_TOON\n";
actions.render_mode_defines["specular_disabled"] = "#define SPECULAR_DISABLED\n";
actions.render_mode_defines["shadows_disabled"] = "#define SHADOWS_DISABLED\n";
actions.render_mode_defines["ambient_light_disabled"] = "#define AMBIENT_LIGHT_DISABLED\n";
actions.render_mode_defines["shadow_to_opacity"] = "#define USE_SHADOW_TO_OPACITY\n";
actions.render_mode_defines["unshaded"] = "#define MODE_UNSHADED\n";
Implement render mode fog_disabled and BaseMaterial3D setting Disable Fog
2023-09-04 00:04:14 +02:00
actions.render_mode_defines["fog_disabled"] = "#define FOG_DISABLED\n";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.default_filter = ShaderLanguage::FILTER_LINEAR_MIPMAP;
actions.default_repeat = ShaderLanguage::REPEAT_ENABLE;
Forbid passing multiview sampler to the custom function in shaders
2023-01-29 12:14:22 +03:00
actions.check_multiview_samplers = RasterizerGLES3::get_singleton()->is_xr_enabled();
Properly append global uniform buffer name in gl_compatibility shaders Also error when using instance uniforms
2023-01-26 12:14:45 -08:00
actions.global_buffer_array_variable = "global_shader_uniforms";
Make screen texture and depth texture work in Multiview
2023-01-15 16:07:59 +11:00
SceneShader compiling
2022-05-03 13:28:15 -07:00
shaders.compiler_scene.initialize(actions);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
{
// Setup Particles compiler
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
ShaderCompiler::DefaultIdentifierActions actions;
actions.renames["COLOR"] = "out_color";
actions.renames["VELOCITY"] = "out_velocity_flags.xyz";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
//actions.renames["MASS"] = "mass"; ?
actions.renames["ACTIVE"] = "particle_active";
actions.renames["RESTART"] = "restart";
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
actions.renames["CUSTOM"] = "out_custom";
for (int i = 0; i < PARTICLES_MAX_USERDATAS; i++) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
String udname = "USERDATA" + itos(i + 1);
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
actions.renames[udname] = "out_userdata" + itos(i + 1);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.usage_defines[udname] = "#define USERDATA" + itos(i + 1) + "_USED\n";
}
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
actions.renames["TRANSFORM"] = "xform";
actions.renames["TIME"] = "time";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.renames["PI"] = _MKSTR(Math_PI);
actions.renames["TAU"] = _MKSTR(Math_TAU);
actions.renames["E"] = _MKSTR(Math_E);
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
actions.renames["LIFETIME"] = "lifetime";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.renames["DELTA"] = "local_delta";
actions.renames["NUMBER"] = "particle_number";
actions.renames["INDEX"] = "index";
Particle internal refactor and additions for more artistic control Co-authored-by: Hugo Locurcio <hugo.locurcio@hugo.pro> Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com> Co-authored-by: Raul Santos <raulsntos@gmail.com> Co-authored-by: Mew Pur Pur <85438892+MewPurPur@users.noreply.github.com> Co-authored-by: Clay John <claynjohn@gmail.com>
2023-08-13 13:08:52 +02:00
actions.renames["AMOUNT_RATIO"] = "amount_ratio";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
//actions.renames["GRAVITY"] = "current_gravity";
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
actions.renames["EMISSION_TRANSFORM"] = "emission_transform";
actions.renames["RANDOM_SEED"] = "random_seed";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.renames["RESTART_POSITION"] = "restart_position";
actions.renames["RESTART_ROT_SCALE"] = "restart_rotation_scale";
actions.renames["RESTART_VELOCITY"] = "restart_velocity";
actions.renames["RESTART_COLOR"] = "restart_color";
actions.renames["RESTART_CUSTOM"] = "restart_custom";
actions.renames["COLLIDED"] = "collided";
actions.renames["COLLISION_NORMAL"] = "collision_normal";
actions.renames["COLLISION_DEPTH"] = "collision_depth";
actions.renames["ATTRACTOR_FORCE"] = "attractor_force";
Particle internal refactor and additions for more artistic control Co-authored-by: Hugo Locurcio <hugo.locurcio@hugo.pro> Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com> Co-authored-by: Raul Santos <raulsntos@gmail.com> Co-authored-by: Mew Pur Pur <85438892+MewPurPur@users.noreply.github.com> Co-authored-by: Clay John <claynjohn@gmail.com>
2023-08-13 13:08:52 +02:00
actions.renames["EMITTER_VELOCITY"] = "emitter_velocity";
actions.renames["INTERPOLATE_TO_END"] = "interp_to_end";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Add warnings and fallbacks for particles sub emitters when using the GL Compatibility rendering backend Co-authored-by: Hugo Locurcio <hugo.locurcio@hugo.pro>
2023-06-20 14:03:14 -07:00
// These are unsupported, but may be used by users. To avoid compile time overhead, we add the stub only when used.
actions.renames["FLAG_EMIT_POSITION"] = "uint(1)";
actions.renames["FLAG_EMIT_ROT_SCALE"] = "uint(2)";
actions.renames["FLAG_EMIT_VELOCITY"] = "uint(4)";
actions.renames["FLAG_EMIT_COLOR"] = "uint(8)";
actions.renames["FLAG_EMIT_CUSTOM"] = "uint(16)";
actions.renames["emit_subparticle"] = "emit_subparticle";
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";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.render_mode_defines["disable_force"] = "#define DISABLE_FORCE\n";
actions.render_mode_defines["disable_velocity"] = "#define DISABLE_VELOCITY\n";
actions.render_mode_defines["keep_data"] = "#define ENABLE_KEEP_DATA\n";
Fix typo - "collison" -> "collision"
2022-09-29 13:56:26 -08:00
actions.render_mode_defines["collision_use_scale"] = "#define USE_COLLISION_SCALE\n";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.default_filter = ShaderLanguage::FILTER_LINEAR_MIPMAP;
actions.default_repeat = ShaderLanguage::REPEAT_ENABLE;
Properly append global uniform buffer name in gl_compatibility shaders Also error when using instance uniforms
2023-01-26 12:14:45 -08:00
actions.global_buffer_array_variable = "global_shader_uniforms";
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
shaders.compiler_particles.initialize(actions);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
{
// Setup Sky compiler
ShaderCompiler::DefaultIdentifierActions actions;
actions.renames["COLOR"] = "color";
actions.renames["ALPHA"] = "alpha";
actions.renames["EYEDIR"] = "cube_normal";
SkyShaders working
2022-04-29 15:34:01 -07:00
actions.renames["POSITION"] = "position";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.renames["SKY_COORDS"] = "panorama_coords";
actions.renames["SCREEN_UV"] = "uv";
SkyShaders working
2022-04-29 15:34:01 -07:00
actions.renames["TIME"] = "time";
Use IGN instead of white noise for sky dithering
2022-04-29 12:46:29 -07:00
actions.renames["FRAGCOORD"] = "gl_FragCoord";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.renames["PI"] = _MKSTR(Math_PI);
actions.renames["TAU"] = _MKSTR(Math_TAU);
actions.renames["E"] = _MKSTR(Math_E);
actions.renames["HALF_RES_COLOR"] = "half_res_color";
actions.renames["QUARTER_RES_COLOR"] = "quarter_res_color";
actions.renames["RADIANCE"] = "radiance";
actions.renames["FOG"] = "custom_fog";
actions.renames["LIGHT0_ENABLED"] = "directional_lights.data[0].enabled";
actions.renames["LIGHT0_DIRECTION"] = "directional_lights.data[0].direction_energy.xyz";
actions.renames["LIGHT0_ENERGY"] = "directional_lights.data[0].direction_energy.w";
actions.renames["LIGHT0_COLOR"] = "directional_lights.data[0].color_size.xyz";
actions.renames["LIGHT0_SIZE"] = "directional_lights.data[0].color_size.w";
actions.renames["LIGHT1_ENABLED"] = "directional_lights.data[1].enabled";
actions.renames["LIGHT1_DIRECTION"] = "directional_lights.data[1].direction_energy.xyz";
actions.renames["LIGHT1_ENERGY"] = "directional_lights.data[1].direction_energy.w";
actions.renames["LIGHT1_COLOR"] = "directional_lights.data[1].color_size.xyz";
actions.renames["LIGHT1_SIZE"] = "directional_lights.data[1].color_size.w";
actions.renames["LIGHT2_ENABLED"] = "directional_lights.data[2].enabled";
actions.renames["LIGHT2_DIRECTION"] = "directional_lights.data[2].direction_energy.xyz";
actions.renames["LIGHT2_ENERGY"] = "directional_lights.data[2].direction_energy.w";
actions.renames["LIGHT2_COLOR"] = "directional_lights.data[2].color_size.xyz";
actions.renames["LIGHT2_SIZE"] = "directional_lights.data[2].color_size.w";
actions.renames["LIGHT3_ENABLED"] = "directional_lights.data[3].enabled";
actions.renames["LIGHT3_DIRECTION"] = "directional_lights.data[3].direction_energy.xyz";
actions.renames["LIGHT3_ENERGY"] = "directional_lights.data[3].direction_energy.w";
actions.renames["LIGHT3_COLOR"] = "directional_lights.data[3].color_size.xyz";
actions.renames["LIGHT3_SIZE"] = "directional_lights.data[3].color_size.w";
actions.renames["AT_CUBEMAP_PASS"] = "AT_CUBEMAP_PASS";
actions.renames["AT_HALF_RES_PASS"] = "AT_HALF_RES_PASS";
actions.renames["AT_QUARTER_RES_PASS"] = "AT_QUARTER_RES_PASS";
actions.usage_defines["HALF_RES_COLOR"] = "\n#define USES_HALF_RES_COLOR\n";
actions.usage_defines["QUARTER_RES_COLOR"] = "\n#define USES_QUARTER_RES_COLOR\n";
actions.render_mode_defines["disable_fog"] = "#define DISABLE_FOG\n";
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
actions.render_mode_defines["use_debanding"] = "#define USE_DEBANDING\n";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.default_filter = ShaderLanguage::FILTER_LINEAR_MIPMAP;
actions.default_repeat = ShaderLanguage::REPEAT_ENABLE;
Properly append global uniform buffer name in gl_compatibility shaders Also error when using instance uniforms
2023-01-26 12:14:45 -08:00
actions.global_buffer_array_variable = "global_shader_uniforms";
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
shaders.compiler_sky.initialize(actions);
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
MaterialStorage::~MaterialStorage() {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
//shaders.copy.version_free(shaders.copy_version);
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
memdelete_arr(global_shader_uniforms.buffer_values);
memdelete_arr(global_shader_uniforms.buffer_usage);
memdelete_arr(global_shader_uniforms.buffer_dirty_regions);
glDeleteBuffers(1, &global_shader_uniforms.buffer);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
singleton = nullptr;
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
/* GLOBAL SHADER UNIFORM API */
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
int32_t MaterialStorage::_global_shader_uniform_allocate(uint32_t p_elements) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
int32_t idx = 0;
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
while (idx + p_elements <= global_shader_uniforms.buffer_size) {
if (global_shader_uniforms.buffer_usage[idx].elements == 0) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
bool valid = true;
for (uint32_t i = 1; i < p_elements; i++) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
if (global_shader_uniforms.buffer_usage[idx + i].elements > 0) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
valid = false;
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
idx += i + global_shader_uniforms.buffer_usage[idx + i].elements;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
break;
}
}
if (!valid) {
continue; //if not valid, idx is in new position
}
return idx;
} else {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
idx += global_shader_uniforms.buffer_usage[idx].elements;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
}
return -1;
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
void MaterialStorage::_global_shader_uniform_store_in_buffer(int32_t p_index, RS::GlobalShaderParameterType p_type, const Variant &p_value) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
switch (p_type) {
case RS::GLOBAL_VAR_TYPE_BOOL: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
bool b = p_value;
bv.x = b ? 1.0 : 0.0;
bv.y = 0.0;
bv.z = 0.0;
bv.w = 0.0;
} break;
case RS::GLOBAL_VAR_TYPE_BVEC2: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
uint32_t bvec = p_value;
bv.x = (bvec & 1) ? 1.0 : 0.0;
bv.y = (bvec & 2) ? 1.0 : 0.0;
bv.z = 0.0;
bv.w = 0.0;
} break;
case RS::GLOBAL_VAR_TYPE_BVEC3: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
uint32_t bvec = p_value;
bv.x = (bvec & 1) ? 1.0 : 0.0;
bv.y = (bvec & 2) ? 1.0 : 0.0;
bv.z = (bvec & 4) ? 1.0 : 0.0;
bv.w = 0.0;
} break;
case RS::GLOBAL_VAR_TYPE_BVEC4: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
uint32_t bvec = p_value;
bv.x = (bvec & 1) ? 1.0 : 0.0;
bv.y = (bvec & 2) ? 1.0 : 0.0;
bv.z = (bvec & 4) ? 1.0 : 0.0;
bv.w = (bvec & 8) ? 1.0 : 0.0;
} break;
case RS::GLOBAL_VAR_TYPE_INT: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::ValueInt &bv = *(GlobalShaderUniforms::ValueInt *)&global_shader_uniforms.buffer_values[p_index];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
int32_t v = p_value;
bv.x = v;
bv.y = 0;
bv.z = 0;
bv.w = 0;
} break;
case RS::GLOBAL_VAR_TYPE_IVEC2: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::ValueInt &bv = *(GlobalShaderUniforms::ValueInt *)&global_shader_uniforms.buffer_values[p_index];
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector2i v = convert_to_vector<Vector2i>(p_value);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
bv.x = v.x;
bv.y = v.y;
bv.z = 0;
bv.w = 0;
} break;
case RS::GLOBAL_VAR_TYPE_IVEC3: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::ValueInt &bv = *(GlobalShaderUniforms::ValueInt *)&global_shader_uniforms.buffer_values[p_index];
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector3i v = convert_to_vector<Vector3i>(p_value);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
bv.x = v.x;
bv.y = v.y;
bv.z = v.z;
bv.w = 0;
} break;
case RS::GLOBAL_VAR_TYPE_IVEC4: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::ValueInt &bv = *(GlobalShaderUniforms::ValueInt *)&global_shader_uniforms.buffer_values[p_index];
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector4i v = convert_to_vector<Vector4i>(p_value);
bv.x = v.x;
bv.y = v.y;
bv.z = v.z;
bv.w = v.w;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} break;
case RS::GLOBAL_VAR_TYPE_RECT2I: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::ValueInt &bv = *(GlobalShaderUniforms::ValueInt *)&global_shader_uniforms.buffer_values[p_index];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Rect2i v = p_value;
bv.x = v.position.x;
bv.y = v.position.y;
bv.z = v.size.x;
bv.w = v.size.y;
} break;
case RS::GLOBAL_VAR_TYPE_UINT: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::ValueUInt &bv = *(GlobalShaderUniforms::ValueUInt *)&global_shader_uniforms.buffer_values[p_index];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
uint32_t v = p_value;
bv.x = v;
bv.y = 0;
bv.z = 0;
bv.w = 0;
} break;
case RS::GLOBAL_VAR_TYPE_UVEC2: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::ValueUInt &bv = *(GlobalShaderUniforms::ValueUInt *)&global_shader_uniforms.buffer_values[p_index];
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector2i v = convert_to_vector<Vector2i>(p_value);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
bv.x = v.x;
bv.y = v.y;
bv.z = 0;
bv.w = 0;
} break;
case RS::GLOBAL_VAR_TYPE_UVEC3: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::ValueUInt &bv = *(GlobalShaderUniforms::ValueUInt *)&global_shader_uniforms.buffer_values[p_index];
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector3i v = convert_to_vector<Vector3i>(p_value);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
bv.x = v.x;
bv.y = v.y;
bv.z = v.z;
bv.w = 0;
} break;
case RS::GLOBAL_VAR_TYPE_UVEC4: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::ValueUInt &bv = *(GlobalShaderUniforms::ValueUInt *)&global_shader_uniforms.buffer_values[p_index];
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector4i v = convert_to_vector<Vector4i>(p_value);
bv.x = v.x;
bv.y = v.y;
bv.z = v.z;
bv.w = v.w;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} break;
case RS::GLOBAL_VAR_TYPE_FLOAT: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
float v = p_value;
bv.x = v;
bv.y = 0;
bv.z = 0;
bv.w = 0;
} break;
case RS::GLOBAL_VAR_TYPE_VEC2: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector2 v = convert_to_vector<Vector2>(p_value);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
bv.x = v.x;
bv.y = v.y;
bv.z = 0;
bv.w = 0;
} break;
case RS::GLOBAL_VAR_TYPE_VEC3: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector3 v = convert_to_vector<Vector3>(p_value);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
bv.x = v.x;
bv.y = v.y;
bv.z = v.z;
bv.w = 0;
} break;
case RS::GLOBAL_VAR_TYPE_VEC4: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Vector4 v = convert_to_vector<Vector4>(p_value);
bv.x = v.x;
bv.y = v.y;
bv.z = v.z;
bv.w = v.w;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} break;
case RS::GLOBAL_VAR_TYPE_COLOR: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Color v = p_value;
bv.x = v.r;
bv.y = v.g;
bv.z = v.b;
bv.w = v.a;
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Value &bv_linear = global_shader_uniforms.buffer_values[p_index + 1];
Basic 3D rendering
2022-05-10 10:02:44 -07:00
//v = v.srgb_to_linear();
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
bv_linear.x = v.r;
bv_linear.y = v.g;
bv_linear.z = v.b;
bv_linear.w = v.a;
} break;
case RS::GLOBAL_VAR_TYPE_RECT2: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Value &bv = global_shader_uniforms.buffer_values[p_index];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Rect2 v = p_value;
bv.x = v.position.x;
bv.y = v.position.y;
bv.z = v.size.x;
bv.w = v.size.y;
} break;
case RS::GLOBAL_VAR_TYPE_MAT2: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Value *bv = &global_shader_uniforms.buffer_values[p_index];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Vector<float> m2 = p_value;
if (m2.size() < 4) {
m2.resize(4);
}
bv[0].x = m2[0];
bv[0].y = m2[1];
bv[0].z = 0;
bv[0].w = 0;
bv[1].x = m2[2];
bv[1].y = m2[3];
bv[1].z = 0;
bv[1].w = 0;
} break;
case RS::GLOBAL_VAR_TYPE_MAT3: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Value *bv = &global_shader_uniforms.buffer_values[p_index];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Basis v = p_value;
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
convert_item_std140<Basis>(v, &bv->x);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} break;
case RS::GLOBAL_VAR_TYPE_MAT4: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Value *bv = &global_shader_uniforms.buffer_values[p_index];
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
Projection m = p_value;
convert_item_std140<Projection>(m, &bv->x);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} break;
case RS::GLOBAL_VAR_TYPE_TRANSFORM_2D: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Value *bv = &global_shader_uniforms.buffer_values[p_index];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Transform2D v = p_value;
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
convert_item_std140<Transform2D>(v, &bv->x);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} break;
case RS::GLOBAL_VAR_TYPE_TRANSFORM: {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Value *bv = &global_shader_uniforms.buffer_values[p_index];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Transform3D v = p_value;
Fix shader uniform storage conversions and crash
2023-03-15 08:40:06 +02:00
convert_item_std140<Transform3D>(v, &bv->x);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} break;
default: {
ERR_FAIL();
}
}
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
void MaterialStorage::_global_shader_uniform_mark_buffer_dirty(int32_t p_index, int32_t p_elements) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
int32_t prev_chunk = -1;
for (int32_t i = 0; i < p_elements; i++) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
int32_t chunk = (p_index + i) / GlobalShaderUniforms::BUFFER_DIRTY_REGION_SIZE;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (chunk != prev_chunk) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
if (!global_shader_uniforms.buffer_dirty_regions[chunk]) {
global_shader_uniforms.buffer_dirty_regions[chunk] = true;
global_shader_uniforms.buffer_dirty_region_count++;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
}
prev_chunk = chunk;
}
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
void MaterialStorage::global_shader_parameter_add(const StringName &p_name, RS::GlobalShaderParameterType p_type, const Variant &p_value) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
ERR_FAIL_COND(global_shader_uniforms.variables.has(p_name));
GlobalShaderUniforms::Variable gv;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
gv.type = p_type;
gv.value = p_value;
gv.buffer_index = -1;
if (p_type >= RS::GLOBAL_VAR_TYPE_SAMPLER2D) {
//is texture
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniforms.must_update_texture_materials = true; //normally there are none
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
gv.buffer_elements = 1;
if (p_type == RS::GLOBAL_VAR_TYPE_COLOR || p_type == RS::GLOBAL_VAR_TYPE_MAT2) {
//color needs to elements to store srgb and linear
gv.buffer_elements = 2;
}
if (p_type == RS::GLOBAL_VAR_TYPE_MAT3 || p_type == RS::GLOBAL_VAR_TYPE_TRANSFORM_2D) {
//color needs to elements to store srgb and linear
gv.buffer_elements = 3;
}
if (p_type == RS::GLOBAL_VAR_TYPE_MAT4 || p_type == RS::GLOBAL_VAR_TYPE_TRANSFORM) {
//color needs to elements to store srgb and linear
gv.buffer_elements = 4;
}
//is vector, allocate in buffer and update index
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
gv.buffer_index = _global_shader_uniform_allocate(gv.buffer_elements);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
ERR_FAIL_COND_MSG(gv.buffer_index < 0, vformat("Failed allocating global variable '%s' out of buffer memory. Consider increasing it in the Project Settings.", String(p_name)));
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniforms.buffer_usage[gv.buffer_index].elements = gv.buffer_elements;
_global_shader_uniform_store_in_buffer(gv.buffer_index, gv.type, gv.value);
_global_shader_uniform_mark_buffer_dirty(gv.buffer_index, gv.buffer_elements);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniforms.must_update_buffer_materials = true; //normally there are none
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniforms.variables[p_name] = gv;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
void MaterialStorage::global_shader_parameter_remove(const StringName &p_name) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
if (!global_shader_uniforms.variables.has(p_name)) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
return;
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Variable &gv = global_shader_uniforms.variables[p_name];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (gv.buffer_index >= 0) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniforms.buffer_usage[gv.buffer_index].elements = 0;
global_shader_uniforms.must_update_buffer_materials = true;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniforms.must_update_texture_materials = true;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniforms.variables.erase(p_name);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
Vector<StringName> MaterialStorage::global_shader_parameter_get_list() const {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (!Engine::get_singleton()->is_editor_hint()) {
ERR_FAIL_V_MSG(Vector<StringName>(), "This function should never be used outside the editor, it can severely damage performance.");
}
Vector<StringName> names;
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
for (const KeyValue<StringName, GlobalShaderUniforms::Variable> &E : global_shader_uniforms.variables) {
Add a new HashMap implementation Adds a new, cleaned up, HashMap implementation. * Uses Robin Hood Hashing (https://en.wikipedia.org/wiki/Hash_table#Robin_Hood_hashing). * Keeps elements in a double linked list for simpler, ordered, iteration. * Allows keeping iterators for later use in removal (Unlike Map<>, it does not do much for performance vs keeping the key, but helps replace old code). * Uses a more modern C++ iterator API, deprecates the old one. * Supports custom allocator (in case there is a wish to use a paged one). This class aims to unify all the associative template usage and replace it by this one: * Map<> (whereas key order does not matter, which is 99% of cases) * HashMap<> * OrderedHashMap<> * OAHashMap<>
2022-05-08 10:09:19 +02:00
names.push_back(E.key);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
names.sort_custom<StringName::AlphCompare>();
return names;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
void MaterialStorage::global_shader_parameter_set(const StringName &p_name, const Variant &p_value) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
ERR_FAIL_COND(!global_shader_uniforms.variables.has(p_name));
GlobalShaderUniforms::Variable &gv = global_shader_uniforms.variables[p_name];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
gv.value = p_value;
if (gv.override.get_type() == Variant::NIL) {
if (gv.buffer_index >= 0) {
//buffer
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
_global_shader_uniform_store_in_buffer(gv.buffer_index, gv.type, gv.value);
_global_shader_uniform_mark_buffer_dirty(gv.buffer_index, gv.buffer_elements);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
//texture
MaterialStorage *material_storage = MaterialStorage::get_singleton();
Use range iterators for RBSet in most cases
2022-05-18 17:43:40 -06:00
for (const RID &E : gv.texture_materials) {
Material *material = material_storage->get_material(E);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
ERR_CONTINUE(!material);
material_storage->_material_queue_update(material, false, true);
}
}
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
void MaterialStorage::global_shader_parameter_set_override(const StringName &p_name, const Variant &p_value) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
if (!global_shader_uniforms.variables.has(p_name)) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
return; //variable may not exist
}
ERR_FAIL_COND(p_value.get_type() == Variant::OBJECT);
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
GlobalShaderUniforms::Variable &gv = global_shader_uniforms.variables[p_name];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
gv.override = p_value;
if (gv.buffer_index >= 0) {
//buffer
if (gv.override.get_type() == Variant::NIL) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
_global_shader_uniform_store_in_buffer(gv.buffer_index, gv.type, gv.value);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
_global_shader_uniform_store_in_buffer(gv.buffer_index, gv.type, gv.override);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
_global_shader_uniform_mark_buffer_dirty(gv.buffer_index, gv.buffer_elements);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
//texture
MaterialStorage *material_storage = MaterialStorage::get_singleton();
Use range iterators for RBSet in most cases
2022-05-18 17:43:40 -06:00
for (const RID &E : gv.texture_materials) {
Material *material = material_storage->get_material(E);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
ERR_CONTINUE(!material);
material_storage->_material_queue_update(material, false, true);
}
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
Variant MaterialStorage::global_shader_parameter_get(const StringName &p_name) const {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (!Engine::get_singleton()->is_editor_hint()) {
ERR_FAIL_V_MSG(Variant(), "This function should never be used outside the editor, it can severely damage performance.");
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
if (!global_shader_uniforms.variables.has(p_name)) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
return Variant();
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
return global_shader_uniforms.variables[p_name].value;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
RS::GlobalShaderParameterType MaterialStorage::global_shader_parameter_get_type_internal(const StringName &p_name) const {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
if (!global_shader_uniforms.variables.has(p_name)) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
return RS::GLOBAL_VAR_TYPE_MAX;
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
return global_shader_uniforms.variables[p_name].type;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
RS::GlobalShaderParameterType MaterialStorage::global_shader_parameter_get_type(const StringName &p_name) const {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (!Engine::get_singleton()->is_editor_hint()) {
ERR_FAIL_V_MSG(RS::GLOBAL_VAR_TYPE_MAX, "This function should never be used outside the editor, it can severely damage performance.");
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
return global_shader_parameter_get_type_internal(p_name);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
void MaterialStorage::global_shader_parameters_load_settings(bool p_load_textures) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
List<PropertyInfo> settings;
ProjectSettings::get_singleton()->get_property_list(&settings);
for (const PropertyInfo &E : settings) {
if (E.name.begins_with("shader_globals/")) {
StringName name = E.name.get_slice("/", 1);
Unify usage of GLOBAL/EDITOR_GET
2022-10-18 16:43:37 +02:00
Dictionary d = GLOBAL_GET(E.name);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
ERR_CONTINUE(!d.has("type"));
ERR_CONTINUE(!d.has("value"));
String type = d["type"];
static const char *global_var_type_names[RS::GLOBAL_VAR_TYPE_MAX] = {
"bool",
"bvec2",
"bvec3",
"bvec4",
"int",
"ivec2",
"ivec3",
"ivec4",
"rect2i",
"uint",
"uvec2",
"uvec3",
"uvec4",
"float",
"vec2",
"vec3",
"vec4",
"color",
"rect2",
"mat2",
"mat3",
"mat4",
"transform_2d",
"transform",
"sampler2D",
"sampler2DArray",
"sampler3D",
"samplerCube",
};
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
RS::GlobalShaderParameterType gvtype = RS::GLOBAL_VAR_TYPE_MAX;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
for (int i = 0; i < RS::GLOBAL_VAR_TYPE_MAX; i++) {
if (global_var_type_names[i] == type) {
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
gvtype = RS::GlobalShaderParameterType(i);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
break;
}
}
ERR_CONTINUE(gvtype == RS::GLOBAL_VAR_TYPE_MAX); //type invalid
Variant value = d["value"];
if (gvtype >= RS::GLOBAL_VAR_TYPE_SAMPLER2D) {
//textire
if (!p_load_textures) {
continue;
}
String path = value;
Fix global shader uniform texture loading
2023-08-15 14:03:37 +03:00
if (path.is_empty()) {
value = RID();
} else {
Ref<Resource> resource = ResourceLoader::load(path);
value = resource;
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
if (global_shader_uniforms.variables.has(name)) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
//has it, update it
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
global_shader_parameter_set(name, value);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
global_shader_parameter_add(name, gvtype, value);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
}
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
void MaterialStorage::global_shader_parameters_clear() {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniforms.variables.clear();
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
GLuint MaterialStorage::global_shader_parameters_get_uniform_buffer() const {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
return global_shader_uniforms.buffer;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
int32_t MaterialStorage::global_shader_parameters_instance_allocate(RID p_instance) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
ERR_FAIL_COND_V(global_shader_uniforms.instance_buffer_pos.has(p_instance), -1);
int32_t pos = _global_shader_uniform_allocate(ShaderLanguage::MAX_INSTANCE_UNIFORM_INDICES);
global_shader_uniforms.instance_buffer_pos[p_instance] = pos; //save anyway
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
ERR_FAIL_COND_V_MSG(pos < 0, -1, "Too many instances using shader instance variables. Increase buffer size in Project Settings.");
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniforms.buffer_usage[pos].elements = ShaderLanguage::MAX_INSTANCE_UNIFORM_INDICES;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
return pos;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
void MaterialStorage::global_shader_parameters_instance_free(RID p_instance) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
ERR_FAIL_COND(!global_shader_uniforms.instance_buffer_pos.has(p_instance));
int32_t pos = global_shader_uniforms.instance_buffer_pos[p_instance];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (pos >= 0) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniforms.buffer_usage[pos].elements = 0;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniforms.instance_buffer_pos.erase(p_instance);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Fix incorrect setup of boolean uniform instances
2022-10-09 08:14:07 +03:00
void MaterialStorage::global_shader_parameters_instance_update(RID p_instance, int p_index, const Variant &p_value, int p_flags_count) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
if (!global_shader_uniforms.instance_buffer_pos.has(p_instance)) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
return; //just not allocated, ignore
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
int32_t pos = global_shader_uniforms.instance_buffer_pos[p_instance];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (pos < 0) {
return; //again, not allocated, ignore
}
ERR_FAIL_INDEX(p_index, ShaderLanguage::MAX_INSTANCE_UNIFORM_INDICES);
Fix incorrect setup of boolean uniform instances
2022-10-09 08:14:07 +03:00
Variant::Type value_type = p_value.get_type();
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
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
ShaderLanguage::DataType datatype_from_value[Variant::COLOR + 1] = {
ShaderLanguage::TYPE_MAX, //nil
ShaderLanguage::TYPE_BOOL, //bool
ShaderLanguage::TYPE_INT, //int
ShaderLanguage::TYPE_FLOAT, //float
ShaderLanguage::TYPE_MAX, //string
ShaderLanguage::TYPE_VEC2, //vec2
ShaderLanguage::TYPE_IVEC2, //vec2i
ShaderLanguage::TYPE_VEC4, //rect2
ShaderLanguage::TYPE_IVEC4, //rect2i
ShaderLanguage::TYPE_VEC3, // vec3
ShaderLanguage::TYPE_IVEC3, //vec3i
ShaderLanguage::TYPE_MAX, //xform2d not supported here
Fix passing values to the instance uniforms in the shader
2022-08-01 13:39:51 +03:00
ShaderLanguage::TYPE_VEC4, //vec4
ShaderLanguage::TYPE_IVEC4, //vec4i
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
ShaderLanguage::TYPE_VEC4, //plane
ShaderLanguage::TYPE_VEC4, //quat
ShaderLanguage::TYPE_MAX, //aabb not supported here
ShaderLanguage::TYPE_MAX, //basis not supported here
ShaderLanguage::TYPE_MAX, //xform not supported here
Fix passing values to the instance uniforms in the shader
2022-08-01 13:39:51 +03:00
ShaderLanguage::TYPE_MAX, //projection not supported here
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
ShaderLanguage::TYPE_VEC4 //color
};
Fix incorrect setup of boolean uniform instances
2022-10-09 08:14:07 +03:00
ShaderLanguage::DataType datatype = ShaderLanguage::TYPE_MAX;
if (value_type == Variant::INT && p_flags_count > 0) {
switch (p_flags_count) {
case 1:
datatype = ShaderLanguage::TYPE_BVEC2;
break;
case 2:
datatype = ShaderLanguage::TYPE_BVEC3;
break;
case 3:
datatype = ShaderLanguage::TYPE_BVEC4;
break;
}
} else {
datatype = datatype_from_value[value_type];
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Fix incorrect setup of boolean uniform instances
2022-10-09 08:14:07 +03:00
ERR_FAIL_COND_MSG(datatype == ShaderLanguage::TYPE_MAX, "Unsupported variant type for instance parameter: " + Variant::get_type_name(value_type)); //anything greater not supported
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
pos += p_index;
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
_fill_std140_variant_ubo_value(datatype, 0, p_value, (uint8_t *)&global_shader_uniforms.buffer_values[pos]);
_global_shader_uniform_mark_buffer_dirty(pos, 1);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
void MaterialStorage::_update_global_shader_uniforms() {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
MaterialStorage *material_storage = MaterialStorage::get_singleton();
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
if (global_shader_uniforms.buffer_dirty_region_count > 0) {
uint32_t total_regions = global_shader_uniforms.buffer_size / GlobalShaderUniforms::BUFFER_DIRTY_REGION_SIZE;
if (total_regions / global_shader_uniforms.buffer_dirty_region_count <= 4) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
// 25% of regions dirty, just update all buffer
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
glBindBuffer(GL_UNIFORM_BUFFER, global_shader_uniforms.buffer);
glBufferData(GL_UNIFORM_BUFFER, sizeof(GlobalShaderUniforms::Value) * global_shader_uniforms.buffer_size, global_shader_uniforms.buffer_values, GL_DYNAMIC_DRAW);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
glBindBuffer(GL_UNIFORM_BUFFER, 0);
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
memset(global_shader_uniforms.buffer_dirty_regions, 0, sizeof(bool) * total_regions);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
uint32_t region_byte_size = sizeof(GlobalShaderUniforms::Value) * GlobalShaderUniforms::BUFFER_DIRTY_REGION_SIZE;
glBindBuffer(GL_UNIFORM_BUFFER, global_shader_uniforms.buffer);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
for (uint32_t i = 0; i < total_regions; i++) {
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
if (global_shader_uniforms.buffer_dirty_regions[i]) {
glBufferSubData(GL_UNIFORM_BUFFER, i * region_byte_size, region_byte_size, &global_shader_uniforms.buffer_values[i * GlobalShaderUniforms::BUFFER_DIRTY_REGION_SIZE]);
global_shader_uniforms.buffer_dirty_regions[i] = false;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
}
glBindBuffer(GL_UNIFORM_BUFFER, 0);
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniforms.buffer_dirty_region_count = 0;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
if (global_shader_uniforms.must_update_buffer_materials) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
// only happens in the case of a buffer variable added or removed,
// so not often.
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
for (const RID &E : global_shader_uniforms.materials_using_buffer) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Material *material = material_storage->get_material(E);
ERR_CONTINUE(!material); //wtf
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
material_storage->_material_queue_update(material, true, false);
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniforms.must_update_buffer_materials = false;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
if (global_shader_uniforms.must_update_texture_materials) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
// only happens in the case of a buffer variable added or removed,
// so not often.
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
for (const RID &E : global_shader_uniforms.materials_using_texture) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Material *material = material_storage->get_material(E);
ERR_CONTINUE(!material); //wtf
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
material_storage->_material_queue_update(material, false, true);
}
Rename RenderingServer global shader uniform methods to be more explicit The `global_shader_uniform` name is longer, but it makes it much easier to find the methods when searching in the class reference.
2022-04-03 18:56:43 +02:00
global_shader_uniforms.must_update_texture_materials = false;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
/* SHADER API */
RID MaterialStorage::shader_allocate() {
return shader_owner.allocate_rid();
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
void MaterialStorage::shader_initialize(RID p_rid) {
Shader shader;
shader.data = nullptr;
shader.mode = RS::SHADER_MAX;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
shader_owner.initialize_rid(p_rid, shader);
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
void MaterialStorage::shader_free(RID p_rid) {
Fixed ambiguous reference to "Shader" and "Material" classes in drivers/gles3/storage/material_storage.cpp
2022-04-05 00:37:37 -04:00
GLES3::Shader *shader = shader_owner.get_or_null(p_rid);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL(shader);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
//make material unreference this
while (shader->owners.size()) {
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
material_set_shader((*shader->owners.begin())->self, RID());
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
//clear data if exists
if (shader->data) {
memdelete(shader->data);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
shader_owner.free(p_rid);
}
void MaterialStorage::shader_set_code(RID p_shader, const String &p_code) {
Fixed ambiguous reference to "Shader" and "Material" classes in drivers/gles3/storage/material_storage.cpp
2022-04-05 00:37:37 -04:00
GLES3::Shader *shader = shader_owner.get_or_null(p_shader);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL(shader);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
shader->code = p_code;
String mode_string = ShaderLanguage::get_shader_type(p_code);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
RS::ShaderMode new_mode;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
if (mode_string == "canvas_item") {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
new_mode = RS::SHADER_CANVAS_ITEM;
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
} else if (mode_string == "particles") {
new_mode = RS::SHADER_PARTICLES;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
} else if (mode_string == "spatial") {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
new_mode = RS::SHADER_SPATIAL;
} else if (mode_string == "sky") {
new_mode = RS::SHADER_SKY;
//} else if (mode_string == "fog") {
// new_mode = RS::SHADER_FOG;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
} else {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
new_mode = RS::SHADER_MAX;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
ERR_PRINT("shader type " + mode_string + " not supported in OpenGL renderer");
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (new_mode != shader->mode) {
if (shader->data) {
memdelete(shader->data);
shader->data = nullptr;
}
Use range iterators for RBSet in most cases
2022-05-18 17:43:40 -06:00
for (Material *E : shader->owners) {
Material *material = E;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
material->shader_mode = new_mode;
if (material->data) {
memdelete(material->data);
material->data = nullptr;
}
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
shader->mode = new_mode;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (new_mode < RS::SHADER_MAX && shader_data_request_func[new_mode]) {
shader->data = shader_data_request_func[new_mode]();
} else {
shader->mode = RS::SHADER_MAX; //invalid
}
Use range iterators for RBSet in most cases
2022-05-18 17:43:40 -06:00
for (Material *E : shader->owners) {
Material *material = E;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (shader->data) {
material->data = material_data_request_func[new_mode](shader->data);
material->data->self = material->self;
material->data->set_next_pass(material->next_pass);
material->data->set_render_priority(material->priority);
}
material->shader_mode = new_mode;
}
if (shader->data) {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
for (const KeyValue<StringName, HashMap<int, RID>> &E : shader->default_texture_parameter) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
for (const KeyValue<int, RID> &E2 : E.value) {
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
shader->data->set_default_texture_parameter(E.key, E2.value, E2.key);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
}
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (shader->data) {
shader->data->set_code(p_code);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Use range iterators for RBSet in most cases
2022-05-18 17:43:40 -06:00
for (Material *E : shader->owners) {
Material *material = E;
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 10:08:33 +10:00
material->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_MATERIAL);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
_material_queue_update(material, true, true);
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Clean up Shader Preprocessor * Moved preprocessor to Shader and ShaderInclude * Clean up RenderingServer side * Preprocessor is separate from parser now, but it emits tokens with include location hints. * Improved ShaderEditor validation code * Added include file code completion * Added notification for all files affected by a broken include.
2022-06-29 11:31:18 +02:00
void MaterialStorage::shader_set_path_hint(RID p_shader, const String &p_path) {
GLES3::Shader *shader = shader_owner.get_or_null(p_shader);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL(shader);
Clean up Shader Preprocessor * Moved preprocessor to Shader and ShaderInclude * Clean up RenderingServer side * Preprocessor is separate from parser now, but it emits tokens with include location hints. * Improved ShaderEditor validation code * Added include file code completion * Added notification for all files affected by a broken include.
2022-06-29 11:31:18 +02:00
shader->path_hint = p_path;
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
if (shader->data) {
shader->data->set_path_hint(p_path);
}
Clean up Shader Preprocessor * Moved preprocessor to Shader and ShaderInclude * Clean up RenderingServer side * Preprocessor is separate from parser now, but it emits tokens with include location hints. * Improved ShaderEditor validation code * Added include file code completion * Added notification for all files affected by a broken include.
2022-06-29 11:31:18 +02:00
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
String MaterialStorage::shader_get_code(RID p_shader) const {
Fixed ambiguous reference to "Shader" and "Material" classes in drivers/gles3/storage/material_storage.cpp
2022-04-05 00:37:37 -04:00
const GLES3::Shader *shader = shader_owner.get_or_null(p_shader);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL_V(shader, String());
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
return shader->code;
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
void MaterialStorage::get_shader_parameter_list(RID p_shader, List<PropertyInfo> *p_param_list) const {
Fixed ambiguous reference to "Shader" and "Material" classes in drivers/gles3/storage/material_storage.cpp
2022-04-05 00:37:37 -04:00
GLES3::Shader *shader = shader_owner.get_or_null(p_shader);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL(shader);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (shader->data) {
Rename shader parameter uniform setter/getter methods for consistency `shader_uniform` is now consistenly used across both per-shader and per-instance shader uniform methods. This makes methods easier to find in the class reference when looking for them.
2022-04-03 19:09:09 +02:00
return shader->data->get_shader_uniform_list(p_param_list);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
void MaterialStorage::shader_set_default_texture_parameter(RID p_shader, const StringName &p_name, RID p_texture, int p_index) {
Fixed ambiguous reference to "Shader" and "Material" classes in drivers/gles3/storage/material_storage.cpp
2022-04-05 00:37:37 -04:00
GLES3::Shader *shader = shader_owner.get_or_null(p_shader);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL(shader);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (p_texture.is_valid() && TextureStorage::get_singleton()->owns_texture(p_texture)) {
if (!shader->default_texture_parameter.has(p_name)) {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
shader->default_texture_parameter[p_name] = HashMap<int, RID>();
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
shader->default_texture_parameter[p_name][p_index] = p_texture;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
} else {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (shader->default_texture_parameter.has(p_name) && shader->default_texture_parameter[p_name].has(p_index)) {
shader->default_texture_parameter[p_name].erase(p_index);
if (shader->default_texture_parameter[p_name].is_empty()) {
shader->default_texture_parameter.erase(p_name);
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (shader->data) {
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
shader->data->set_default_texture_parameter(p_name, p_texture, p_index);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
Use range iterators for RBSet in most cases
2022-05-18 17:43:40 -06:00
for (Material *E : shader->owners) {
Material *material = E;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
_material_queue_update(material, false, true);
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
RID MaterialStorage::shader_get_default_texture_parameter(RID p_shader, const StringName &p_name, int p_index) const {
Fixed ambiguous reference to "Shader" and "Material" classes in drivers/gles3/storage/material_storage.cpp
2022-04-05 00:37:37 -04:00
const GLES3::Shader *shader = shader_owner.get_or_null(p_shader);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL_V(shader, RID());
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (shader->default_texture_parameter.has(p_name) && shader->default_texture_parameter[p_name].has(p_index)) {
return shader->default_texture_parameter[p_name][p_index];
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
return RID();
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
Variant MaterialStorage::shader_get_parameter_default(RID p_shader, const StringName &p_param) const {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Shader *shader = shader_owner.get_or_null(p_shader);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL_V(shader, Variant());
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (shader->data) {
return shader->data->get_default_parameter(p_param);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
return Variant();
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
RS::ShaderNativeSourceCode MaterialStorage::shader_get_native_source_code(RID p_shader) const {
Shader *shader = shader_owner.get_or_null(p_shader);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL_V(shader, RS::ShaderNativeSourceCode());
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (shader->data) {
return shader->data->get_native_source_code();
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
return RS::ShaderNativeSourceCode();
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
/* MATERIAL API */
opengl3 driver now works on windows including multi window fixed and simplified gl_manager_windows swap buffers now called for all windows fixed missing pixel format setting in additional windows this makes them work in OpenGL contexts changed verbose error printing to write once this error message happens very frequently while opengl3 is not finished removed dead code no longer needed after changes fixed comments that were misinformation window messages during window creation now handled these were previously discarded messages now tunnel the required context changed failure to create opengl3 window on windows to be more fatal marked a problem with pen code conditional compilation of vulkan and opengl3 on windows fixed windows debug builds now show messages on debug console also rendering driver selection box now shows only compiled drivers marked some problematic code thanks to akien-mga for patiently rewriting my style mistakes
2022-05-08 19:25:49 -04:00
void MaterialStorage::_material_queue_update(GLES3::Material *material, bool p_uniform, bool p_texture) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
material->uniform_dirty = material->uniform_dirty || p_uniform;
material->texture_dirty = material->texture_dirty || p_texture;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (material->update_element.in_list()) {
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
return;
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
material_update_list.add(&material->update_element);
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
void MaterialStorage::_update_queued_materials() {
while (material_update_list.first()) {
Material *material = material_update_list.first()->self();
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (material->data) {
material->data->update_parameters(material->params, material->uniform_dirty, material->texture_dirty);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
material->texture_dirty = false;
material->uniform_dirty = false;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
material_update_list.remove(&material->update_element);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
}
RID MaterialStorage::material_allocate() {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
return material_owner.allocate_rid();
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
void MaterialStorage::material_initialize(RID p_rid) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
material_owner.initialize_rid(p_rid);
Material *material = material_owner.get_or_null(p_rid);
material->self = p_rid;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
void MaterialStorage::material_free(RID p_rid) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Material *material = material_owner.get_or_null(p_rid);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL(material);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Clear material arrays to prevent freeing of invalid texture RID
2023-01-13 21:14:00 +03:00
// Need to clear texture arrays to prevent spin locking of their RID's.
// This happens when the app is being closed.
for (KeyValue<StringName, Variant> &E : material->params) {
if (E.value.get_type() == Variant::ARRAY) {
Array(E.value).clear();
}
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
material_set_shader(p_rid, RID()); //clean up shader
material->dependency.deleted_notify(p_rid);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
material_owner.free(p_rid);
}
void MaterialStorage::material_set_shader(RID p_material, RID p_shader) {
Fixed ambiguous reference to "Shader" and "Material" classes in drivers/gles3/storage/material_storage.cpp
2022-04-05 00:37:37 -04:00
GLES3::Material *material = material_owner.get_or_null(p_material);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL(material);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (material->data) {
memdelete(material->data);
material->data = nullptr;
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
if (material->shader) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
material->shader->owners.erase(material);
material->shader = nullptr;
material->shader_mode = RS::SHADER_MAX;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (p_shader.is_null()) {
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 10:08:33 +10:00
material->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_MATERIAL);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
material->shader_id = 0;
return;
}
Shader *shader = get_shader(p_shader);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL(shader);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
material->shader = shader;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
material->shader_mode = shader->mode;
material->shader_id = p_shader.get_local_index();
shader->owners.insert(material);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (shader->mode == RS::SHADER_MAX) {
return;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-28 11:40:18 +02:00
ERR_FAIL_NULL(shader->data);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
material->data = material_data_request_func[shader->mode](shader->data);
material->data->self = p_material;
material->data->set_next_pass(material->next_pass);
material->data->set_render_priority(material->priority);
//updating happens later
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 10:08:33 +10:00
material->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_MATERIAL);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
_material_queue_update(material, true, true);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
void MaterialStorage::material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) {
Fixed ambiguous reference to "Shader" and "Material" classes in drivers/gles3/storage/material_storage.cpp
2022-04-05 00:37:37 -04:00
GLES3::Material *material = material_owner.get_or_null(p_material);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL(material);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
if (p_value.get_type() == Variant::NIL) {
material->params.erase(p_param);
} else {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
ERR_FAIL_COND(p_value.get_type() == Variant::OBJECT); //object not allowed
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
material->params[p_param] = p_value;
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (material->shader && material->shader->data) { //shader is valid
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
bool is_texture = material->shader->data->is_parameter_texture(p_param);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
_material_queue_update(material, !is_texture, is_texture);
} else {
_material_queue_update(material, true, true);
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Variant MaterialStorage::material_get_param(RID p_material, const StringName &p_param) const {
Fixed ambiguous reference to "Shader" and "Material" classes in drivers/gles3/storage/material_storage.cpp
2022-04-05 00:37:37 -04:00
const GLES3::Material *material = material_owner.get_or_null(p_material);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL_V(material, Variant());
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
if (material->params.has(p_param)) {
return material->params[p_param];
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
} else {
return Variant();
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
}
void MaterialStorage::material_set_next_pass(RID p_material, RID p_next_material) {
Fixed ambiguous reference to "Shader" and "Material" classes in drivers/gles3/storage/material_storage.cpp
2022-04-05 00:37:37 -04:00
GLES3::Material *material = material_owner.get_or_null(p_material);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL(material);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (material->next_pass == p_next_material) {
return;
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
material->next_pass = p_next_material;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (material->data) {
material->data->set_next_pass(p_next_material);
}
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 10:08:33 +10:00
material->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_MATERIAL);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
void MaterialStorage::material_set_render_priority(RID p_material, int priority) {
ERR_FAIL_COND(priority < RS::MATERIAL_RENDER_PRIORITY_MIN);
ERR_FAIL_COND(priority > RS::MATERIAL_RENDER_PRIORITY_MAX);
Fixed ambiguous reference to "Shader" and "Material" classes in drivers/gles3/storage/material_storage.cpp
2022-04-05 00:37:37 -04:00
GLES3::Material *material = material_owner.get_or_null(p_material);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL(material);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
material->priority = priority;
if (material->data) {
material->data->set_render_priority(priority);
}
Notify mesh surface when render_priority changes This ensures that the mesh properly takes render_priority into account when changed
2023-02-13 18:09:33 -08:00
material->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_MATERIAL);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
bool MaterialStorage::material_is_animated(RID p_material) {
Fixed ambiguous reference to "Shader" and "Material" classes in drivers/gles3/storage/material_storage.cpp
2022-04-05 00:37:37 -04:00
GLES3::Material *material = material_owner.get_or_null(p_material);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL_V(material, false);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (material->shader && material->shader->data) {
if (material->shader->data->is_animated()) {
return true;
} else if (material->next_pass.is_valid()) {
return material_is_animated(material->next_pass);
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
return false; //by default nothing is animated
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
bool MaterialStorage::material_casts_shadows(RID p_material) {
Fixed ambiguous reference to "Shader" and "Material" classes in drivers/gles3/storage/material_storage.cpp
2022-04-05 00:37:37 -04:00
GLES3::Material *material = material_owner.get_or_null(p_material);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL_V(material, true);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (material->shader && material->shader->data) {
if (material->shader->data->casts_shadows()) {
return true;
} else if (material->next_pass.is_valid()) {
return material_casts_shadows(material->next_pass);
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
return true; //by default everything casts shadows
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
void MaterialStorage::material_get_instance_shader_parameters(RID p_material, List<InstanceShaderParam> *r_parameters) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
GLES3::Material *material = material_owner.get_or_null(p_material);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL(material);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (material->shader && material->shader->data) {
material->shader->data->get_instance_param_list(r_parameters);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
if (material->next_pass.is_valid()) {
Rename `uniform` to `parameter` across the engine
2022-08-27 12:22:43 +03:00
material_get_instance_shader_parameters(material->next_pass, r_parameters);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
}
}
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 10:08:33 +10:00
void MaterialStorage::material_update_dependency(RID p_material, DependencyTracker *p_instance) {
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
Material *material = material_owner.get_or_null(p_material);
[Drivers,Platform] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 17:46:44 +02:00
ERR_FAIL_NULL(material);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
p_instance->update_dependency(&material->dependency);
if (material->next_pass.is_valid()) {
material_update_dependency(material->next_pass, p_instance);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
}
fix gles texture uniform array binding
2023-03-25 12:46:33 +03:00
LocalVector<ShaderGLES3::TextureUniformData> get_texture_uniform_data(const Vector<ShaderCompiler::GeneratedCode::Texture> &texture_uniforms) {
LocalVector<ShaderGLES3::TextureUniformData> texture_uniform_data;
for (int i = 0; i < texture_uniforms.size(); i++) {
int num_textures = texture_uniforms[i].array_size;
if (num_textures == 0) {
num_textures = 1;
}
texture_uniform_data.push_back({ texture_uniforms[i].name, num_textures });
}
return texture_uniform_data;
}
SkyShaders working
2022-04-29 15:34:01 -07:00
/* Canvas Shader Data */
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
void CanvasShaderData::set_code(const String &p_code) {
// compile the shader
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
code = p_code;
valid = false;
ubo_size = 0;
uniforms.clear();
uses_screen_texture = false;
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
uses_screen_texture_mipmaps = false;
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
uses_sdf = false;
uses_time = false;
if (code.is_empty()) {
return; //just invalid, but no error
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
ShaderCompiler::GeneratedCode gen_code;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Add clipping, backbuffer, and CanvasGroups to 2D GLES3 renderer As well as significant consequent cleanup in the RenderTarget, Texture, and Canvas renderer code
2022-05-18 08:04:41 -07:00
int blend_modei = BLEND_MODE_MIX;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
ShaderCompiler::IdentifierActions actions;
actions.entry_point_stages["vertex"] = ShaderCompiler::STAGE_VERTEX;
actions.entry_point_stages["fragment"] = ShaderCompiler::STAGE_FRAGMENT;
actions.entry_point_stages["light"] = ShaderCompiler::STAGE_FRAGMENT;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Add clipping, backbuffer, and CanvasGroups to 2D GLES3 renderer As well as significant consequent cleanup in the RenderTarget, Texture, and Canvas renderer code
2022-05-18 08:04:41 -07:00
actions.render_mode_values["blend_add"] = Pair<int *, int>(&blend_modei, BLEND_MODE_ADD);
actions.render_mode_values["blend_mix"] = Pair<int *, int>(&blend_modei, BLEND_MODE_MIX);
actions.render_mode_values["blend_sub"] = Pair<int *, int>(&blend_modei, BLEND_MODE_SUB);
actions.render_mode_values["blend_mul"] = Pair<int *, int>(&blend_modei, BLEND_MODE_MUL);
actions.render_mode_values["blend_premul_alpha"] = Pair<int *, int>(&blend_modei, BLEND_MODE_PMALPHA);
actions.render_mode_values["blend_disabled"] = Pair<int *, int>(&blend_modei, BLEND_MODE_DISABLED);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
actions.usage_flag_pointers["texture_sdf"] = &uses_sdf;
actions.usage_flag_pointers["TIME"] = &uses_time;
actions.uniforms = &uniforms;
Error err = MaterialStorage::get_singleton()->shaders.compiler_canvas.compile(RS::SHADER_CANVAS_ITEM, code, &actions, path, gen_code);
ERR_FAIL_COND_MSG(err != OK, "Shader compilation failed.");
if (version.is_null()) {
version = MaterialStorage::get_singleton()->shaders.canvas_shader.version_create();
}
Add clipping, backbuffer, and CanvasGroups to 2D GLES3 renderer As well as significant consequent cleanup in the RenderTarget, Texture, and Canvas renderer code
2022-05-18 08:04:41 -07:00
blend_mode = BlendMode(blend_modei);
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
uses_screen_texture_mipmaps = gen_code.uses_screen_texture_mipmaps;
Remove SCREEN_TEXTURE, DEPTH_TEXTURE, and NORMAL_ROUGHNESS_TEXTURE in favour of texture hints
2023-01-05 11:55:59 -08:00
uses_screen_texture = gen_code.uses_screen_texture;
Add clipping, backbuffer, and CanvasGroups to 2D GLES3 renderer As well as significant consequent cleanup in the RenderTarget, Texture, and Canvas renderer code
2022-05-18 08:04:41 -07:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
#if 0
print_line("**compiling shader:");
print_line("**defines:\n");
for (int i = 0; i < gen_code.defines.size(); i++) {
print_line(gen_code.defines[i]);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
HashMap<String, String>::Iterator el = gen_code.code.begin();
while (el) {
print_line("\n**code " + el->key + ":\n" + el->value);
++el;
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
print_line("\n**uniforms:\n" + gen_code.uniforms);
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
print_line("\n**vertex_globals:\n" + gen_code.stage_globals[ShaderCompiler::STAGE_VERTEX]);
print_line("\n**fragment_globals:\n" + gen_code.stage_globals[ShaderCompiler::STAGE_FRAGMENT]);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
#endif
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
fix gles texture uniform array binding
2023-03-25 12:46:33 +03:00
LocalVector<ShaderGLES3::TextureUniformData> texture_uniform_data = get_texture_uniform_data(gen_code.texture_uniforms);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
fix gles texture uniform array binding
2023-03-25 12:46:33 +03:00
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);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
ERR_FAIL_COND(!MaterialStorage::get_singleton()->shaders.canvas_shader.version_is_valid(version));
ubo_size = gen_code.uniform_total_size;
ubo_offsets = gen_code.uniform_offsets;
texture_uniforms = gen_code.texture_uniforms;
valid = true;
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
bool CanvasShaderData::is_animated() const {
return false;
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
bool CanvasShaderData::casts_shadows() const {
return false;
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
RS::ShaderNativeSourceCode CanvasShaderData::get_native_source_code() const {
return MaterialStorage::get_singleton()->shaders.canvas_shader.version_get_native_source_code(version);
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
CanvasShaderData::CanvasShaderData() {
valid = false;
uses_screen_texture = false;
uses_sdf = false;
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
CanvasShaderData::~CanvasShaderData() {
if (version.is_valid()) {
MaterialStorage::get_singleton()->shaders.canvas_shader.version_free(version);
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
GLES3::ShaderData *GLES3::_create_canvas_shader_func() {
CanvasShaderData *shader_data = memnew(CanvasShaderData);
return shader_data;
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
void CanvasMaterialData::update_parameters(const HashMap<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
Ensure that "detect 3D" is only called when using 3D shaders
2023-06-13 13:20:11 -07:00
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);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
fix gles texture uniform array binding
2023-03-25 12:46:33 +03:00
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) {
const RID *textures = p_textures.ptr();
const ShaderCompiler::GeneratedCode::Texture *texture_uniforms = p_texture_uniforms.ptr();
int texture_uniform_index = 0;
int texture_uniform_count = 0;
for (int ti = 0; ti < p_textures.size(); ti++) {
ERR_FAIL_COND_MSG(texture_uniform_index >= p_texture_uniforms.size(), "texture_uniform_index out of bounds");
GLES3::Texture *texture = TextureStorage::get_singleton()->get_texture(textures[ti]);
const ShaderCompiler::GeneratedCode::Texture &texture_uniform = texture_uniforms[texture_uniform_index];
if (texture) {
glActiveTexture(GL_TEXTURE0 + texture_offset + ti);
glBindTexture(target_from_type[texture_uniform.type], texture->tex_id);
if (texture->render_target) {
texture->render_target->used_in_frame = true;
}
texture->gl_set_filter(filter_mapping[int(texture_uniform.filter)]);
texture->gl_set_repeat(repeat_mapping[int(texture_uniform.repeat)]);
}
texture_uniform_count++;
if (texture_uniform_count >= texture_uniform.array_size) {
texture_uniform_index++;
texture_uniform_count = 0;
}
}
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
void CanvasMaterialData::bind_uniforms() {
// Bind Material Uniforms
Basic 3D rendering
2022-05-10 10:02:44 -07:00
glBindBufferBase(GL_UNIFORM_BUFFER, RasterizerCanvasGLES3::MATERIAL_UNIFORM_LOCATION, uniform_buffer);
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
fix gles texture uniform array binding
2023-03-25 12:46:33 +03:00
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
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
}
Overhaul GLES3: Add basis for 3D renderer, overhaul materials and textures
2022-02-19 16:08:53 -08:00
CanvasMaterialData::~CanvasMaterialData() {
}
GLES3::MaterialData *GLES3::_create_canvas_material_func(ShaderData *p_shader) {
CanvasMaterialData *material_data = memnew(CanvasMaterialData);
material_data->shader_data = static_cast<CanvasShaderData *>(p_shader);
//update will happen later anyway so do nothing.
return material_data;
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
SkyShaders working
2022-04-29 15:34:01 -07:00
////////////////////////////////////////////////////////////////////////////////
// SKY SHADER
void SkyShaderData::set_code(const String &p_code) {
//compile
code = p_code;
valid = false;
ubo_size = 0;
uniforms.clear();
if (code.is_empty()) {
return; //just invalid, but no error
}
ShaderCompiler::GeneratedCode gen_code;
ShaderCompiler::IdentifierActions actions;
actions.entry_point_stages["sky"] = ShaderCompiler::STAGE_FRAGMENT;
uses_time = false;
uses_half_res = false;
uses_quarter_res = false;
uses_position = false;
uses_light = false;
actions.render_mode_flags["use_half_res_pass"] = &uses_half_res;
actions.render_mode_flags["use_quarter_res_pass"] = &uses_quarter_res;
actions.usage_flag_pointers["TIME"] = &uses_time;
actions.usage_flag_pointers["POSITION"] = &uses_position;
actions.usage_flag_pointers["LIGHT0_ENABLED"] = &uses_light;
actions.usage_flag_pointers["LIGHT0_ENERGY"] = &uses_light;
actions.usage_flag_pointers["LIGHT0_DIRECTION"] = &uses_light;
actions.usage_flag_pointers["LIGHT0_COLOR"] = &uses_light;
actions.usage_flag_pointers["LIGHT0_SIZE"] = &uses_light;
actions.usage_flag_pointers["LIGHT1_ENABLED"] = &uses_light;
actions.usage_flag_pointers["LIGHT1_ENERGY"] = &uses_light;
actions.usage_flag_pointers["LIGHT1_DIRECTION"] = &uses_light;
actions.usage_flag_pointers["LIGHT1_COLOR"] = &uses_light;
actions.usage_flag_pointers["LIGHT1_SIZE"] = &uses_light;
actions.usage_flag_pointers["LIGHT2_ENABLED"] = &uses_light;
actions.usage_flag_pointers["LIGHT2_ENERGY"] = &uses_light;
actions.usage_flag_pointers["LIGHT2_DIRECTION"] = &uses_light;
actions.usage_flag_pointers["LIGHT2_COLOR"] = &uses_light;
actions.usage_flag_pointers["LIGHT2_SIZE"] = &uses_light;
actions.usage_flag_pointers["LIGHT3_ENABLED"] = &uses_light;
actions.usage_flag_pointers["LIGHT3_ENERGY"] = &uses_light;
actions.usage_flag_pointers["LIGHT3_DIRECTION"] = &uses_light;
actions.usage_flag_pointers["LIGHT3_COLOR"] = &uses_light;
actions.usage_flag_pointers["LIGHT3_SIZE"] = &uses_light;
actions.uniforms = &uniforms;
Error err = MaterialStorage::get_singleton()->shaders.compiler_sky.compile(RS::SHADER_SKY, code, &actions, path, gen_code);
ERR_FAIL_COND_MSG(err != OK, "Shader compilation failed.");
if (version.is_null()) {
version = MaterialStorage::get_singleton()->shaders.sky_shader.version_create();
}
#if 0
print_line("**compiling shader:");
print_line("**defines:\n");
for (int i = 0; i < gen_code.defines.size(); i++) {
print_line(gen_code.defines[i]);
}
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
HashMap<String, String>::Iterator el = gen_code.code.begin();
while (el) {
print_line("\n**code " + el->key + ":\n" + el->value);
++el;
}
SkyShaders working
2022-04-29 15:34:01 -07:00
print_line("\n**uniforms:\n" + gen_code.uniforms);
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
print_line("\n**vertex_globals:\n" + gen_code.stage_globals[ShaderCompiler::STAGE_VERTEX]);
print_line("\n**fragment_globals:\n" + gen_code.stage_globals[ShaderCompiler::STAGE_FRAGMENT]);
SkyShaders working
2022-04-29 15:34:01 -07:00
#endif
fix gles texture uniform array binding
2023-03-25 12:46:33 +03:00
LocalVector<ShaderGLES3::TextureUniformData> texture_uniform_data = get_texture_uniform_data(gen_code.texture_uniforms);
SkyShaders working
2022-04-29 15:34:01 -07:00
fix gles texture uniform array binding
2023-03-25 12:46:33 +03:00
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);
SkyShaders working
2022-04-29 15:34:01 -07:00
ERR_FAIL_COND(!MaterialStorage::get_singleton()->shaders.sky_shader.version_is_valid(version));
ubo_size = gen_code.uniform_total_size;
ubo_offsets = gen_code.uniform_offsets;
texture_uniforms = gen_code.texture_uniforms;
valid = true;
}
bool SkyShaderData::is_animated() const {
return false;
}
bool SkyShaderData::casts_shadows() const {
return false;
}
RS::ShaderNativeSourceCode SkyShaderData::get_native_source_code() const {
return MaterialStorage::get_singleton()->shaders.sky_shader.version_get_native_source_code(version);
}
SkyShaderData::SkyShaderData() {
valid = false;
}
SkyShaderData::~SkyShaderData() {
if (version.is_valid()) {
MaterialStorage::get_singleton()->shaders.sky_shader.version_free(version);
}
}
GLES3::ShaderData *GLES3::_create_sky_shader_func() {
SkyShaderData *shader_data = memnew(SkyShaderData);
return shader_data;
}
////////////////////////////////////////////////////////////////////////////////
// Sky material
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
void SkyMaterialData::update_parameters(const HashMap<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
Add basic lighting to GLES3 renderer. This includes all three light types and IBL, but does not include shadows or any form of GI
2022-05-16 11:56:03 -07:00
uniform_set_updated = true;
Ensure that "detect 3D" is only called when using 3D shaders
2023-06-13 13:20:11 -07:00
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);
SkyShaders working
2022-04-29 15:34:01 -07:00
}
SkyMaterialData::~SkyMaterialData() {
}
GLES3::MaterialData *GLES3::_create_sky_material_func(ShaderData *p_shader) {
SkyMaterialData *material_data = memnew(SkyMaterialData);
material_data->shader_data = static_cast<SkyShaderData *>(p_shader);
//update will happen later anyway so do nothing.
return material_data;
}
void SkyMaterialData::bind_uniforms() {
// Bind Material Uniforms
Basic 3D rendering
2022-05-10 10:02:44 -07:00
glBindBufferBase(GL_UNIFORM_BUFFER, SKY_MATERIAL_UNIFORM_LOCATION, uniform_buffer);
SceneShader compiling
2022-05-03 13:28:15 -07:00
fix gles texture uniform array binding
2023-03-25 12:46:33 +03:00
bind_uniforms_generic(texture_cache, shader_data->texture_uniforms);
SceneShader compiling
2022-05-03 13:28:15 -07:00
}
////////////////////////////////////////////////////////////////////////////////
// Scene SHADER
void SceneShaderData::set_code(const String &p_code) {
//compile
code = p_code;
valid = false;
ubo_size = 0;
uniforms.clear();
if (code.is_empty()) {
return; //just invalid, but no error
}
ShaderCompiler::GeneratedCode gen_code;
int blend_modei = BLEND_MODE_MIX;
int depth_testi = DEPTH_TEST_ENABLED;
int alpha_antialiasing_modei = ALPHA_ANTIALIASING_OFF;
int cull_modei = CULL_BACK;
int depth_drawi = DEPTH_DRAW_OPAQUE;
uses_point_size = false;
uses_alpha = false;
uses_alpha_clip = false;
uses_blend_alpha = false;
Ignore depth draw optimization when using depth draw alpha prepass This is necessary as the scene shader still uses alpha in this case so we can't discard fragments that weren't written to the depth buffer
2023-01-03 09:26:15 -08:00
uses_depth_prepass_alpha = false;
SceneShader compiling
2022-05-03 13:28:15 -07:00
uses_discard = false;
uses_roughness = false;
uses_normal = false;
wireframe = false;
unshaded = false;
uses_vertex = false;
uses_position = false;
uses_sss = false;
uses_transmittance = false;
uses_screen_texture = false;
uses_depth_texture = false;
uses_normal_texture = false;
uses_time = false;
writes_modelview_or_projection = false;
uses_world_coordinates = false;
uses_particle_trails = false;
ShaderCompiler::IdentifierActions actions;
actions.entry_point_stages["vertex"] = ShaderCompiler::STAGE_VERTEX;
actions.entry_point_stages["fragment"] = ShaderCompiler::STAGE_FRAGMENT;
actions.entry_point_stages["light"] = ShaderCompiler::STAGE_FRAGMENT;
actions.render_mode_values["blend_add"] = Pair<int *, int>(&blend_modei, BLEND_MODE_ADD);
actions.render_mode_values["blend_mix"] = Pair<int *, int>(&blend_modei, BLEND_MODE_MIX);
actions.render_mode_values["blend_sub"] = Pair<int *, int>(&blend_modei, BLEND_MODE_SUB);
actions.render_mode_values["blend_mul"] = Pair<int *, int>(&blend_modei, BLEND_MODE_MUL);
actions.render_mode_values["alpha_to_coverage"] = Pair<int *, int>(&alpha_antialiasing_modei, ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE);
actions.render_mode_values["alpha_to_coverage_and_one"] = Pair<int *, int>(&alpha_antialiasing_modei, ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE_AND_TO_ONE);
actions.render_mode_values["depth_draw_never"] = Pair<int *, int>(&depth_drawi, DEPTH_DRAW_DISABLED);
actions.render_mode_values["depth_draw_opaque"] = Pair<int *, int>(&depth_drawi, DEPTH_DRAW_OPAQUE);
actions.render_mode_values["depth_draw_always"] = Pair<int *, int>(&depth_drawi, DEPTH_DRAW_ALWAYS);
actions.render_mode_values["depth_test_disabled"] = Pair<int *, int>(&depth_testi, DEPTH_TEST_DISABLED);
actions.render_mode_values["cull_disabled"] = Pair<int *, int>(&cull_modei, CULL_DISABLED);
actions.render_mode_values["cull_front"] = Pair<int *, int>(&cull_modei, CULL_FRONT);
actions.render_mode_values["cull_back"] = Pair<int *, int>(&cull_modei, CULL_BACK);
actions.render_mode_flags["unshaded"] = &unshaded;
actions.render_mode_flags["wireframe"] = &wireframe;
actions.render_mode_flags["particle_trails"] = &uses_particle_trails;
Avoid default fallback material when using world_vertex_coords This avoids z-fighting between the opaque shader and the depth prepass shader
2023-10-05 19:11:48 -06:00
actions.render_mode_flags["world_vertex_coords"] = &uses_world_coordinates;
SceneShader compiling
2022-05-03 13:28:15 -07:00
actions.usage_flag_pointers["ALPHA"] = &uses_alpha;
actions.usage_flag_pointers["ALPHA_SCISSOR_THRESHOLD"] = &uses_alpha_clip;
Use opaque rendering pipeline for alpha hash materials This has several benefits: - Transparency sorting issues inherent to alpha blending no longer occur. - Alpha hash materials can now cast shadows (also works with GeometryInstance3D Transparency's property for alpha hash materials). - Higher performance.
2022-06-10 11:09:17 +02:00
// Use alpha clip pipeline for alpha hash/dither.
// This prevents sorting issues inherent to alpha blending and allows such materials to cast shadows.
actions.usage_flag_pointers["ALPHA_HASH_SCALE"] = &uses_alpha_clip;
Ignore depth draw optimization when using depth draw alpha prepass This is necessary as the scene shader still uses alpha in this case so we can't discard fragments that weren't written to the depth buffer
2023-01-03 09:26:15 -08:00
actions.render_mode_flags["depth_prepass_alpha"] = &uses_depth_prepass_alpha;
SceneShader compiling
2022-05-03 13:28:15 -07:00
actions.usage_flag_pointers["SSS_STRENGTH"] = &uses_sss;
actions.usage_flag_pointers["SSS_TRANSMITTANCE_DEPTH"] = &uses_transmittance;
actions.usage_flag_pointers["DISCARD"] = &uses_discard;
actions.usage_flag_pointers["TIME"] = &uses_time;
actions.usage_flag_pointers["ROUGHNESS"] = &uses_roughness;
actions.usage_flag_pointers["NORMAL"] = &uses_normal;
actions.usage_flag_pointers["NORMAL_MAP"] = &uses_normal;
actions.usage_flag_pointers["POINT_SIZE"] = &uses_point_size;
actions.usage_flag_pointers["POINT_COORD"] = &uses_point_size;
actions.write_flag_pointers["MODELVIEW_MATRIX"] = &writes_modelview_or_projection;
actions.write_flag_pointers["PROJECTION_MATRIX"] = &writes_modelview_or_projection;
actions.write_flag_pointers["VERTEX"] = &uses_vertex;
actions.write_flag_pointers["POSITION"] = &uses_position;
Basic 3D rendering
2022-05-10 10:02:44 -07:00
actions.usage_flag_pointers["TANGENT"] = &uses_tangent;
actions.usage_flag_pointers["BINORMAL"] = &uses_tangent;
Enhance checks and user experience around tangents. Ensure `ensure_tangents` option actually creates tangent array. Even if it is just a dummy array. Allow mesh to generate its own tangents when using compression. This allows users to compress meshes without tangents. Warn users if they are trying to read from tangents without providing tangents.
2023-10-31 15:51:07 +01:00
actions.usage_flag_pointers["ANISOTROPY"] = &uses_tangent;
actions.usage_flag_pointers["ANISOTROPY_FLOW"] = &uses_tangent;
Basic 3D rendering
2022-05-10 10:02:44 -07:00
actions.usage_flag_pointers["COLOR"] = &uses_color;
actions.usage_flag_pointers["UV"] = &uses_uv;
actions.usage_flag_pointers["UV2"] = &uses_uv2;
actions.usage_flag_pointers["CUSTOM0"] = &uses_custom0;
actions.usage_flag_pointers["CUSTOM1"] = &uses_custom1;
actions.usage_flag_pointers["CUSTOM2"] = &uses_custom2;
actions.usage_flag_pointers["CUSTOM3"] = &uses_custom3;
actions.usage_flag_pointers["BONE_INDICES"] = &uses_bones;
actions.usage_flag_pointers["BONE_WEIGHTS"] = &uses_weights;
SceneShader compiling
2022-05-03 13:28:15 -07:00
actions.uniforms = &uniforms;
Error err = MaterialStorage::get_singleton()->shaders.compiler_scene.compile(RS::SHADER_SPATIAL, code, &actions, path, gen_code);
ERR_FAIL_COND_MSG(err != OK, "Shader compilation failed.");
if (version.is_null()) {
version = MaterialStorage::get_singleton()->shaders.scene_shader.version_create();
}
depth_draw = DepthDraw(depth_drawi);
depth_test = DepthTest(depth_testi);
cull_mode = Cull(cull_modei);
blend_mode = BlendMode(blend_modei);
alpha_antialiasing_mode = AlphaAntiAliasing(alpha_antialiasing_modei);
Vertex and attribute compression to reduce the size of the vertex format. This allows Godot to automatically compress meshes to save a lot of bandwidth. In general, this requires no interaction from the user and should result in no noticable quality loss. This scheme is not backwards compatible, so we have provided an upgrade mechanism, and a mesh versioning mechanism. Existing meshes can still be used as a result, but users can get a performance boost by reimporting assets.
2023-08-29 21:04:32 +02:00
vertex_input_mask = uint64_t(uses_normal);
Basic 3D rendering
2022-05-10 10:02:44 -07:00
vertex_input_mask |= uses_tangent << 1;
vertex_input_mask |= uses_color << 2;
vertex_input_mask |= uses_uv << 3;
vertex_input_mask |= uses_uv2 << 4;
vertex_input_mask |= uses_custom0 << 5;
vertex_input_mask |= uses_custom1 << 6;
vertex_input_mask |= uses_custom2 << 7;
vertex_input_mask |= uses_custom3 << 8;
vertex_input_mask |= uses_bones << 9;
vertex_input_mask |= uses_weights << 10;
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
uses_screen_texture_mipmaps = gen_code.uses_screen_texture_mipmaps;
Remove SCREEN_TEXTURE, DEPTH_TEXTURE, and NORMAL_ROUGHNESS_TEXTURE in favour of texture hints
2023-01-05 11:55:59 -08:00
uses_screen_texture = gen_code.uses_screen_texture;
uses_depth_texture = gen_code.uses_depth_texture;
uses_normal_texture = gen_code.uses_normal_roughness_texture;
Implement is_animated and casts_shadows This allows the renderer to correctly decide when to update shadow maps This PR also adds TIME to a few missing places
2022-11-13 12:46:52 -08:00
uses_vertex_time = gen_code.uses_vertex_time;
uses_fragment_time = gen_code.uses_fragment_time;
SceneShader compiling
2022-05-03 13:28:15 -07:00
Add warnings for unsupported features in mobile and gl_compatibility backends
2023-02-25 16:24:41 -08:00
#ifdef DEBUG_ENABLED
if (uses_particle_trails) {
WARN_PRINT_ONCE_ED("Particle trails are only available when using the Forward+ or Mobile rendering backends.");
}
if (uses_sss) {
WARN_PRINT_ONCE_ED("Sub-surface scattering is only available when using the Forward+ rendering backend.");
}
if (uses_transmittance) {
WARN_PRINT_ONCE_ED("Transmittance is only available when using the Forward+ rendering backend.");
}
if (uses_depth_texture) {
WARN_PRINT_ONCE_ED("Reading from the depth texture is not supported when using the GL Compatibility backend yet. Support will be added in a future release.");
}
if (uses_normal_texture) {
WARN_PRINT_ONCE_ED("Reading from the normal-roughness texture is only available when using the Forward+ or Mobile rendering backends.");
}
#endif
SceneShader compiling
2022-05-03 13:28:15 -07:00
#if 0
print_line("**compiling shader:");
print_line("**defines:\n");
for (int i = 0; i < gen_code.defines.size(); i++) {
print_line(gen_code.defines[i]);
}
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
HashMap<String, String>::Iterator el = gen_code.code.begin();
SceneShader compiling
2022-05-03 13:28:15 -07:00
while (el) {
Add shader uniform hints for screen textures so users can specify custom filter and repeat modes. At this time, it works best in the Vulkan Renderers as they support using multiple samplers with the same texture. In GLES3 this feature really only allows you to use the screen texture without mipmaps if you want to save the cost of generating them.
2022-08-09 12:29:49 -04:00
print_line("\n**code " + el->key + ":\n" + el->value);
++el;
SceneShader compiling
2022-05-03 13:28:15 -07:00
}
print_line("\n**uniforms:\n" + gen_code.uniforms);
print_line("\n**vertex_globals:\n" + gen_code.stage_globals[ShaderCompiler::STAGE_VERTEX]);
print_line("\n**fragment_globals:\n" + gen_code.stage_globals[ShaderCompiler::STAGE_FRAGMENT]);
#endif
fix gles texture uniform array binding
2023-03-25 12:46:33 +03:00
LocalVector<ShaderGLES3::TextureUniformData> texture_uniform_data = get_texture_uniform_data(gen_code.texture_uniforms);
SceneShader compiling
2022-05-03 13:28:15 -07:00
fix gles texture uniform array binding
2023-03-25 12:46:33 +03:00
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);
SceneShader compiling
2022-05-03 13:28:15 -07:00
ERR_FAIL_COND(!MaterialStorage::get_singleton()->shaders.scene_shader.version_is_valid(version));
ubo_size = gen_code.uniform_total_size;
ubo_offsets = gen_code.uniform_offsets;
texture_uniforms = gen_code.texture_uniforms;
// if any form of Alpha Antialiasing is enabled, set the blend mode to alpha to coverage
if (alpha_antialiasing_mode != ALPHA_ANTIALIASING_OFF) {
blend_mode = BLEND_MODE_ALPHA_TO_COVERAGE;
}
Fixed issues with blend modes in OpenGL 3 renderer Added uses_blend_alpha = true for ADD, SUBTRACT, and MULTIPLY blend modes to match the other renderers Fixes #76334
2023-05-23 16:17:45 -04:00
if (blend_mode == BLEND_MODE_ADD || blend_mode == BLEND_MODE_SUB || blend_mode == BLEND_MODE_MUL) {
uses_blend_alpha = true; // Force alpha used because of blend.
}
SceneShader compiling
2022-05-03 13:28:15 -07:00
valid = true;
}
bool SceneShaderData::is_animated() const {
Implement is_animated and casts_shadows This allows the renderer to correctly decide when to update shadow maps This PR also adds TIME to a few missing places
2022-11-13 12:46:52 -08:00
return (uses_fragment_time && uses_discard) || (uses_vertex_time && uses_vertex);
SceneShader compiling
2022-05-03 13:28:15 -07:00
}
bool SceneShaderData::casts_shadows() const {
Implement is_animated and casts_shadows This allows the renderer to correctly decide when to update shadow maps This PR also adds TIME to a few missing places
2022-11-13 12:46:52 -08:00
bool has_read_screen_alpha = uses_screen_texture || uses_depth_texture || uses_normal_texture;
bool has_base_alpha = (uses_alpha && !uses_alpha_clip) || has_read_screen_alpha;
bool has_alpha = has_base_alpha || uses_blend_alpha;
Ignore depth draw optimization when using depth draw alpha prepass This is necessary as the scene shader still uses alpha in this case so we can't discard fragments that weren't written to the depth buffer
2023-01-03 09:26:15 -08:00
return !has_alpha || (uses_depth_prepass_alpha && !(depth_draw == DEPTH_DRAW_DISABLED || depth_test == DEPTH_TEST_DISABLED));
SceneShader compiling
2022-05-03 13:28:15 -07:00
}
RS::ShaderNativeSourceCode SceneShaderData::get_native_source_code() const {
return MaterialStorage::get_singleton()->shaders.scene_shader.version_get_native_source_code(version);
}
SceneShaderData::SceneShaderData() {
valid = false;
uses_screen_texture = false;
}
SceneShaderData::~SceneShaderData() {
if (version.is_valid()) {
MaterialStorage::get_singleton()->shaders.scene_shader.version_free(version);
}
}
GLES3::ShaderData *GLES3::_create_scene_shader_func() {
SceneShaderData *shader_data = memnew(SceneShaderData);
return shader_data;
}
void SceneMaterialData::set_render_priority(int p_priority) {
priority = p_priority - RS::MATERIAL_RENDER_PRIORITY_MIN; //8 bits
}
void SceneMaterialData::set_next_pass(RID p_pass) {
next_pass = p_pass;
}
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
void SceneMaterialData::update_parameters(const HashMap<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
Ensure that "detect 3D" is only called when using 3D shaders
2023-06-13 13:20:11 -07:00
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);
SceneShader compiling
2022-05-03 13:28:15 -07:00
}
SceneMaterialData::~SceneMaterialData() {
}
GLES3::MaterialData *GLES3::_create_scene_material_func(ShaderData *p_shader) {
SceneMaterialData *material_data = memnew(SceneMaterialData);
material_data->shader_data = static_cast<SceneShaderData *>(p_shader);
//update will happen later anyway so do nothing.
return material_data;
}
void SceneMaterialData::bind_uniforms() {
// Bind Material Uniforms
Basic 3D rendering
2022-05-10 10:02:44 -07:00
glBindBufferBase(GL_UNIFORM_BUFFER, SCENE_MATERIAL_UNIFORM_LOCATION, uniform_buffer);
SkyShaders working
2022-04-29 15:34:01 -07:00
fix gles texture uniform array binding
2023-03-25 12:46:33 +03:00
bind_uniforms_generic(texture_cache, shader_data->texture_uniforms);
SkyShaders working
2022-04-29 15:34:01 -07:00
}
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
/* Particles SHADER */
void ParticlesShaderData::set_code(const String &p_code) {
//compile
code = p_code;
valid = false;
ubo_size = 0;
uniforms.clear();
uses_collision = false;
if (code.is_empty()) {
return; //just invalid, but no error
}
ShaderCompiler::GeneratedCode gen_code;
ShaderCompiler::IdentifierActions actions;
actions.entry_point_stages["start"] = ShaderCompiler::STAGE_VERTEX;
actions.entry_point_stages["process"] = ShaderCompiler::STAGE_VERTEX;
actions.usage_flag_pointers["COLLIDED"] = &uses_collision;
userdata_count = 0;
for (uint32_t i = 0; i < PARTICLES_MAX_USERDATAS; i++) {
userdatas_used[i] = false;
actions.usage_flag_pointers["USERDATA" + itos(i + 1)] = &userdatas_used[i];
}
actions.uniforms = &uniforms;
Error err = MaterialStorage::get_singleton()->shaders.compiler_particles.compile(RS::SHADER_PARTICLES, code, &actions, path, gen_code);
ERR_FAIL_COND_MSG(err != OK, "Shader compilation failed.");
if (version.is_null()) {
version = MaterialStorage::get_singleton()->shaders.particles_process_shader.version_create();
}
for (uint32_t i = 0; i < PARTICLES_MAX_USERDATAS; i++) {
if (userdatas_used[i]) {
userdata_count++;
}
}
fix gles texture uniform array binding
2023-03-25 12:46:33 +03:00
LocalVector<ShaderGLES3::TextureUniformData> texture_uniform_data = get_texture_uniform_data(gen_code.texture_uniforms);
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
fix gles texture uniform array binding
2023-03-25 12:46:33 +03:00
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);
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
ERR_FAIL_COND(!MaterialStorage::get_singleton()->shaders.particles_process_shader.version_is_valid(version));
ubo_size = gen_code.uniform_total_size;
ubo_offsets = gen_code.uniform_offsets;
texture_uniforms = gen_code.texture_uniforms;
valid = true;
}
bool ParticlesShaderData::is_animated() const {
return false;
}
bool ParticlesShaderData::casts_shadows() const {
return false;
}
RS::ShaderNativeSourceCode ParticlesShaderData::get_native_source_code() const {
return MaterialStorage::get_singleton()->shaders.particles_process_shader.version_get_native_source_code(version);
}
ParticlesShaderData::~ParticlesShaderData() {
if (version.is_valid()) {
MaterialStorage::get_singleton()->shaders.particles_process_shader.version_free(version);
}
}
GLES3::ShaderData *GLES3::_create_particles_shader_func() {
ParticlesShaderData *shader_data = memnew(ParticlesShaderData);
return shader_data;
}
void ParticleProcessMaterialData::update_parameters(const HashMap<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
Ensure that "detect 3D" is only called when using 3D shaders
2023-06-13 13:20:11 -07:00
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);
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
}
ParticleProcessMaterialData::~ParticleProcessMaterialData() {
}
GLES3::MaterialData *GLES3::_create_particles_material_func(ShaderData *p_shader) {
ParticleProcessMaterialData *material_data = memnew(ParticleProcessMaterialData);
material_data->shader_data = static_cast<ParticlesShaderData *>(p_shader);
//update will happen later anyway so do nothing.
return material_data;
}
void ParticleProcessMaterialData::bind_uniforms() {
// Bind Material Uniforms
glBindBufferBase(GL_UNIFORM_BUFFER, GLES3::PARTICLES_MATERIAL_UNIFORM_LOCATION, uniform_buffer);
fix gles texture uniform array binding
2023-03-25 12:46:33 +03:00
bind_uniforms_generic(texture_cache, shader_data->texture_uniforms, 1); // Start at GL_TEXTURE1 because texture slot 0 is reserved for the heightmap texture.
Add GPUParticles to the OpenGL3 renderer. This includes collision (2D SDF, Box, Sphere, Heightmap), attraction (Box, Sphere), and all sorting modes. This does not include 3D SDF collisions, trails, or manual emission.
2022-11-07 22:40:03 -08:00
}
Extract global variable, shader and material storage
2022-03-21 22:25:25 +11:00
#endif // !GLES3_ENABLED
Reference in a new issue Copy permalink