godotengine/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-11-04 12:00:25 +00:00
Code Releases Wiki Activity

[macOS] Selectively bake "no image atomics" shader variants.

Browse Source
This commit is contained in:
Pāvels Nadtočajevs
2025-07-11 09:23:02 +03:00
parent c6d130abd9
commit 87e91f7c7a
5 changed files with 136 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

79
servers/rendering/renderer_rd/cluster_builder_rd.cpp
View File

@@ -57,62 +57,105 @@ ClusterBuilderSharedDataRD::ClusterBuilderSharedDataRD() {
Vector<String> variants;
variants.push_back("");
variants.push_back("\n#define USE_ATTACHMENT\n");
variants.push_back("\n#define MOLTENVK_USED\n");
variants.push_back("\n#define USE_ATTACHMENT\n#define MOLTENVK_USED\n");
variants.push_back("\n#define MOLTENVK_USED\n#define NO_IMAGE_ATOMICS\n");
variants.push_back("\n#define USE_ATTACHMENT\n#define MOLTENVK_USED\n#define NO_IMAGE_ATOMICS\n");
variants.push_back("\n#define NO_IMAGE_ATOMICS\n");
variants.push_back("\n#define MOLTENVK_USED\n#define NO_IMAGE_ATOMICS\n");
ClusterRender::ShaderVariant shader_variant;
if (RD::get_singleton()->has_feature(RD::SUPPORTS_FRAGMENT_SHADER_WITH_ONLY_SIDE_EFFECTS)) {
fb_format = RD::get_singleton()->framebuffer_format_create_empty();
RenderingDevice *rd = RD::get_singleton();
if (rd->has_feature(RD::SUPPORTS_FRAGMENT_SHADER_WITH_ONLY_SIDE_EFFECTS)) {
fb_format = rd->framebuffer_format_create_empty();
blend_state = RD::PipelineColorBlendState::create_disabled();
#if (defined(MACOS_ENABLED) || defined(APPLE_EMBEDDED_ENABLED))
if (RD::get_singleton()->get_device_capabilities().device_family == RDD::DEVICE_VULKAN) {
if (rd->get_device_capabilities().device_family == RDD::DEVICE_VULKAN) {
shader_variant = ClusterRender::SHADER_NORMAL_MOLTENVK;
} else {
} else if (rd->has_feature(RD::SUPPORTS_IMAGE_ATOMIC_32_BIT)) {
shader_variant = ClusterRender::SHADER_NORMAL;
} else {
shader_variant = ClusterRender::SHADER_NORMAL_NO_ATOMICS;
}
#else
shader_variant = ClusterRender::SHADER_NORMAL;
if (rd->has_feature(RD::SUPPORTS_IMAGE_ATOMIC_32_BIT)) {
shader_variant = ClusterRender::SHADER_NORMAL;
} else {
shader_variant = ClusterRender::SHADER_NORMAL_NO_ATOMICS;
}
#endif
} else {
Vector<RD::AttachmentFormat> afs;
afs.push_back(RD::AttachmentFormat());
afs.write[0].usage_flags = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
fb_format = RD::get_singleton()->framebuffer_format_create(afs);
fb_format = rd->framebuffer_format_create(afs);
blend_state = RD::PipelineColorBlendState::create_blend();
#if (defined(MACOS_ENABLED) || defined(APPLE_EMBEDDED_ENABLED))
if (RD::get_singleton()->get_device_capabilities().device_family == RDD::DEVICE_VULKAN) {
if (rd->get_device_capabilities().device_family == RDD::DEVICE_VULKAN) {
shader_variant = ClusterRender::SHADER_USE_ATTACHMENT_MOLTENVK;
} else {
} else if (rd->has_feature(RD::SUPPORTS_IMAGE_ATOMIC_32_BIT)) {
shader_variant = ClusterRender::SHADER_USE_ATTACHMENT;
} else {
shader_variant = ClusterRender::SHADER_USE_ATTACHMENT_NO_ATOMICS;
}
#else
shader_variant = ClusterRender::SHADER_USE_ATTACHMENT;
if (rd->has_feature(RD::SUPPORTS_IMAGE_ATOMIC_32_BIT)) {
shader_variant = ClusterRender::SHADER_USE_ATTACHMENT;
} else {
shader_variant = ClusterRender::SHADER_USE_ATTACHMENT_NO_ATOMICS;
}
#endif
}
cluster_render.cluster_render_shader.initialize(variants);
#if (defined(MACOS_ENABLED) || defined(APPLE_EMBEDDED_ENABLED))
if (RD::get_singleton()->get_device_capabilities().device_family == RDD::DEVICE_VULKAN) {
if (rd->get_device_capabilities().device_family == RDD::DEVICE_VULKAN) {
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_NORMAL, false);
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_USE_ATTACHMENT, false);
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_NORMAL_NO_ATOMICS, false);
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_USE_ATTACHMENT_NO_ATOMICS, false);
} else if (rd->has_feature(RD::SUPPORTS_IMAGE_ATOMIC_32_BIT)) {
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_NORMAL_MOLTENVK, false);
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_USE_ATTACHMENT_MOLTENVK, false);
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_NORMAL_NO_ATOMICS, false);
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_USE_ATTACHMENT_NO_ATOMICS, false);
} else {
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_NORMAL, false);
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_USE_ATTACHMENT, false);
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_NORMAL_MOLTENVK, false);
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_USE_ATTACHMENT_MOLTENVK, false);
}
#else
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_NORMAL_MOLTENVK, false);
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_USE_ATTACHMENT_MOLTENVK, false);
if (rd->has_feature(RD::SUPPORTS_IMAGE_ATOMIC_32_BIT)) {
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_NORMAL_MOLTENVK, false);
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_USE_ATTACHMENT_MOLTENVK, false);
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_NORMAL_NO_ATOMICS, false);
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_USE_ATTACHMENT_NO_ATOMICS, false);
} else {
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_NORMAL, false);
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_USE_ATTACHMENT, false);
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_NORMAL_MOLTENVK, false);
cluster_render.cluster_render_shader.set_variant_enabled(ClusterRender::SHADER_USE_ATTACHMENT_MOLTENVK, false);
}
#endif
// Do not bake default (with "gl_HelperInvocation" and image atomics) variants for macOS/iOS Vulkan, but bake it for the rest of configs (including Metal).
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_NORMAL, "macos_forward_clustered_vulkan", false, true);
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_USE_ATTACHMENT, "macos_forward_clustered_vulkan", false, true);
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_NORMAL_MOLTENVK, "macos_forward_clustered_vulkan", true, false);
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_USE_ATTACHMENT_MOLTENVK, "macos_forward_clustered_vulkan", true, false);
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_NORMAL, "ios_forward_clustered_vulkan", false, true);
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_USE_ATTACHMENT, "macos_forward_clustered_vulkan", false, true);
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_USE_ATTACHMENT, "ios_forward_clustered_vulkan", false, true);
// Bake no "gl_HelperInvocation" and no "image atomics" variants for macOS/iOS Vulkan only.
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_NORMAL_MOLTENVK, "macos_forward_clustered_vulkan", true, false);
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_NORMAL_MOLTENVK, "ios_forward_clustered_vulkan", true, false);
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_USE_ATTACHMENT_MOLTENVK, "macos_forward_clustered_vulkan", true, false);
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_USE_ATTACHMENT_MOLTENVK, "ios_forward_clustered_vulkan", true, false);
// Bake no "image atomics" variants for macOS/iOS/visionOS Metal only.
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_NORMAL_NO_ATOMICS, "macos_forward_clustered_metal", true, false);
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_NORMAL_NO_ATOMICS, "ios_forward_clustered_metal", true, false);
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_NORMAL_NO_ATOMICS, "visionos_forward_clustered_metal", true, false);
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_USE_ATTACHMENT_NO_ATOMICS, "macos_forward_clustered_metal", true, false);
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_USE_ATTACHMENT_NO_ATOMICS, "ios_forward_clustered_metal", true, false);
cluster_render.cluster_render_shader.set_variants_bake_for(ClusterRender::SHADER_USE_ATTACHMENT_NO_ATOMICS, "visionos_forward_clustered_metal", true, false);
cluster_render.shader_version = cluster_render.cluster_render_shader.version_create();
cluster_render.shader = cluster_render.cluster_render_shader.version_get_shader(cluster_render.shader_version, shader_variant);
cluster_render.shader_pipelines[ClusterRender::PIPELINE_NORMAL] = RD::get_singleton()->render_pipeline_create(cluster_render.shader, fb_format, vertex_format, RD::RENDER_PRIMITIVE_TRIANGLES, rasterization_state, RD::PipelineMultisampleState(), RD::PipelineDepthStencilState(), blend_state, 0);

2
servers/rendering/renderer_rd/cluster_builder_rd.h
View File

@@ -78,6 +78,8 @@ class ClusterBuilderSharedDataRD {
SHADER_USE_ATTACHMENT,
SHADER_NORMAL_MOLTENVK,
SHADER_USE_ATTACHMENT_MOLTENVK,
SHADER_NORMAL_NO_ATOMICS,
SHADER_USE_ATTACHMENT_NO_ATOMICS,
};
enum PipelineVersion {

79
servers/rendering/renderer_rd/environment/fog.cpp
View File

@@ -47,6 +47,24 @@ Fog::~Fog() {
singleton = nullptr;
}
int Fog::_get_fog_variant() {
RenderingDevice *rd = RD::get_singleton();
if (rd->has_feature(RD::SUPPORTS_IMAGE_ATOMIC_32_BIT)) {
return 0;
} else {
return 1;
}
}
int Fog::_get_fog_process_variant(int p_idx) {
RenderingDevice *rd = RD::get_singleton();
if (rd->has_feature(RD::SUPPORTS_IMAGE_ATOMIC_32_BIT)) {
return p_idx;
} else {
return p_idx + VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_MAX;
}
}
/* FOG VOLUMES */
RID Fog::fog_volume_allocate() {
@@ -143,7 +161,7 @@ Vector3 Fog::fog_volume_get_size(RID p_fog_volume) const {
bool Fog::FogMaterialData::update_parameters(const HashMap<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
uniform_set_updated = true;
return update_parameters_uniform_set(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, uniform_set, Fog::get_singleton()->volumetric_fog.shader.version_get_shader(shader_data->version, 0), VolumetricFogShader::FogSet::FOG_SET_MATERIAL, true, true);
return update_parameters_uniform_set(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, uniform_set, Fog::get_singleton()->volumetric_fog.shader.version_get_shader(shader_data->version, _get_fog_variant()), VolumetricFogShader::FogSet::FOG_SET_MATERIAL, true, true);
}
Fog::FogMaterialData::~FogMaterialData() {
@@ -194,8 +212,26 @@ void Fog::init_fog_shader(uint32_t p_max_directional_lights, int p_roughness_lay
// Initialize local fog shader
Vector<String> volumetric_fog_modes;
volumetric_fog_modes.push_back("");
volumetric_fog_modes.push_back("#define NO_IMAGE_ATOMICS\n");
volumetric_fog.shader.initialize(volumetric_fog_modes, defines);
RenderingDevice *rd = RD::get_singleton();
if (rd->has_feature(RD::SUPPORTS_IMAGE_ATOMIC_32_BIT)) {
volumetric_fog.shader.set_variant_enabled(1, false);
} else {
volumetric_fog.shader.set_variant_enabled(0, false);
}
// Always bake default (with image atomics) variant.
volumetric_fog.shader.set_variants_bake_for(0, "*", true, true);
// Bake no "image atomics" variant for macOS/iOS (Vulkan and Metal) and visionOS (Metal).
volumetric_fog.shader.set_variants_bake_for(1, "macos_forward_clustered_vulkan", true, false);
volumetric_fog.shader.set_variants_bake_for(1, "macos_forward_clustered_metal", true, false);
volumetric_fog.shader.set_variants_bake_for(1, "ios_forward_clustered_vulkan", true, false);
volumetric_fog.shader.set_variants_bake_for(1, "ios_forward_clustered_metal", true, false);
volumetric_fog.shader.set_variants_bake_for(1, "visionos_forward_clustered_metal", true, false);
material_storage->shader_set_data_request_function(RendererRD::MaterialStorage::SHADER_TYPE_FOG, _create_fog_shader_funcs);
material_storage->material_set_data_request_function(RendererRD::MaterialStorage::SHADER_TYPE_FOG, _create_fog_material_funcs);
volumetric_fog.volume_ubo = RD::get_singleton()->uniform_buffer_create(sizeof(VolumetricFogShader::VolumeUBO));
@@ -252,7 +288,7 @@ ALBEDO = vec3(1.0);
material_storage->material_set_shader(volumetric_fog.default_material, volumetric_fog.default_shader);
FogMaterialData *md = static_cast<FogMaterialData *>(material_storage->material_get_data(volumetric_fog.default_material, RendererRD::MaterialStorage::SHADER_TYPE_FOG));
volumetric_fog.default_shader_rd = volumetric_fog.shader.version_get_shader(md->shader_data->version, 0);
volumetric_fog.default_shader_rd = volumetric_fog.shader.version_get_shader(md->shader_data->version, _get_fog_variant());
Vector<RD::Uniform> uniforms;
@@ -282,10 +318,35 @@ ALBEDO = vec3(1.0);
volumetric_fog_modes.push_back("\n#define MODE_FOG\n");
volumetric_fog_modes.push_back("\n#define MODE_COPY\n");
volumetric_fog_modes.push_back("\n#define MODE_DENSITY\n#define NO_IMAGE_ATOMICS\n");
volumetric_fog_modes.push_back("\n#define MODE_DENSITY\n#define ENABLE_SDFGI\n#define NO_IMAGE_ATOMICS\n");
volumetric_fog_modes.push_back("\n#define MODE_FILTER\n#define NO_IMAGE_ATOMICS\n");
volumetric_fog_modes.push_back("\n#define MODE_FOG\n#define NO_IMAGE_ATOMICS\n");
volumetric_fog_modes.push_back("\n#define MODE_COPY\n#define NO_IMAGE_ATOMICS\n");
volumetric_fog.process_shader.initialize(volumetric_fog_modes, defines);
RenderingDevice *rd = RD::get_singleton();
for (int i = 0; i < VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_MAX; i++) {
if (rd->has_feature(RD::SUPPORTS_IMAGE_ATOMIC_32_BIT)) {
volumetric_fog.process_shader.set_variant_enabled(i + VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_MAX, false);
} else {
volumetric_fog.process_shader.set_variant_enabled(i, false);
}
// Always bake default (with image atomics) variant.
volumetric_fog.process_shader.set_variants_bake_for(i, "*", true, true);
// Bake no "image atomics" variant for macOS/iOS (Vulkan and Metal) and visionOS (Metal) only.
volumetric_fog.process_shader.set_variants_bake_for(i + VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_MAX, "macos_forward_clustered_vulkan", true, false);
volumetric_fog.process_shader.set_variants_bake_for(i + VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_MAX, "macos_forward_clustered_metal", true, false);
volumetric_fog.process_shader.set_variants_bake_for(i + VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_MAX, "ios_forward_clustered_vulkan", true, false);
volumetric_fog.process_shader.set_variants_bake_for(i + VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_MAX, "ios_forward_clustered_metal", true, false);
volumetric_fog.process_shader.set_variants_bake_for(i + VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_MAX, "visionos_forward_clustered_metal", true, false);
}
volumetric_fog.process_shader_version = volumetric_fog.process_shader.version_create();
for (int i = 0; i < VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_MAX; i++) {
volumetric_fog.process_pipelines[i] = RD::get_singleton()->compute_pipeline_create(volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, i));
volumetric_fog.process_pipelines[i] = RD::get_singleton()->compute_pipeline_create(volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, _get_fog_process_variant(i)));
}
volumetric_fog.params_ubo = RD::get_singleton()->uniform_buffer_create(sizeof(VolumetricFogShader::ParamsUBO));
}
@@ -349,7 +410,7 @@ void Fog::FogShaderData::set_code(const String &p_code) {
ubo_offsets = gen_code.uniform_offsets;
texture_uniforms = gen_code.texture_uniforms;
pipeline = RD::get_singleton()->compute_pipeline_create(fog_singleton->volumetric_fog.shader.version_get_shader(version, 0));
pipeline = RD::get_singleton()->compute_pipeline_create(fog_singleton->volumetric_fog.shader.version_get_shader(version, _get_fog_variant()));
valid = true;
}
@@ -941,10 +1002,10 @@ void Fog::volumetric_fog_update(const VolumetricFogSettings &p_settings, const P
if (fog->copy_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(fog->copy_uniform_set)) {
RD::get_singleton()->free(fog->copy_uniform_set);
}
fog->copy_uniform_set = RD::get_singleton()->uniform_set_create(copy_uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_COPY), 0);
fog->copy_uniform_set = RD::get_singleton()->uniform_set_create(copy_uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, _get_fog_process_variant(VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_COPY)), 0);
if (!gi_dependent_sets_valid) {
fog->gi_dependent_sets.process_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_FOG), 0);
fog->gi_dependent_sets.process_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, _get_fog_process_variant(VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_FOG)), 0);
RID aux7 = uniforms.write[7].get_id(0);
RID aux8 = uniforms.write[8].get_id(0);
@@ -952,11 +1013,11 @@ void Fog::volumetric_fog_update(const VolumetricFogSettings &p_settings, const P
uniforms.write[7].set_id(0, aux8);
uniforms.write[8].set_id(0, aux7);
fog->gi_dependent_sets.process_uniform_set2 = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_FOG), 0);
fog->gi_dependent_sets.process_uniform_set2 = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, _get_fog_process_variant(VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_FOG)), 0);
uniforms.remove_at(8);
uniforms.write[7].set_id(0, aux7);
fog->gi_dependent_sets.process_uniform_set_density = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_DENSITY), 0);
fog->gi_dependent_sets.process_uniform_set_density = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, _get_fog_process_variant(VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_DENSITY)), 0);
}
}
@@ -990,7 +1051,7 @@ void Fog::volumetric_fog_update(const VolumetricFogSettings &p_settings, const P
uniforms.push_back(u);
}
fog->sdfgi_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_DENSITY_WITH_SDFGI), 1);
fog->sdfgi_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, _get_fog_process_variant(VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_DENSITY_WITH_SDFGI)), 1);
}
}

3
servers/rendering/renderer_rd/environment/fog.h
View File

@@ -48,6 +48,9 @@ class Fog : public RendererFog {
private:
static Fog *singleton;
static int _get_fog_variant();
static int _get_fog_process_variant(int p_idx);
/* FOG VOLUMES */
struct FogVolume {

7
servers/rendering/renderer_rd/shader_rd.cpp
View File

@@ -233,13 +233,6 @@ void ShaderRD::_build_variant_code(StringBuilder &builder, uint32_t p_variant, c
for (const KeyValue<StringName, CharString> &E : p_version->code_sections) {
builder.append(String("#define ") + String(E.key) + "_CODE_USED\n");
}
#if (defined(MACOS_ENABLED) || defined(APPLE_EMBEDDED_ENABLED))
RenderingDevice *rd = RD::get_singleton();
if (!rd->has_feature(RD::SUPPORTS_IMAGE_ATOMIC_32_BIT)) {
builder.append("#define NO_IMAGE_ATOMICS\n");
}
#endif
builder.append(String("#define RENDER_DRIVER_") + OS::get_singleton()->get_current_rendering_driver_name().to_upper() + "\n");
builder.append("#define samplerExternalOES sampler2D\n");
builder.append("#define textureExternalOES texture2D\n");