From 062d74bb9cb8710dbea34442a53af6aad796a453 Mon Sep 17 00:00:00 2001 From: HP van Braam Date: Fri, 13 Dec 2024 19:03:37 +0100 Subject: [PATCH] Fix ubsan reported errors in rendering This allows the TPS demo to run without an ubsan reports from any of the rendering code. --- .../d3d12/rendering_context_driver_d3d12.cpp | 2 +- .../metal/rendering_context_driver_metal.mm | 2 +- .../rendering_context_driver_vulkan.cpp | 4 +-- .../vulkan/rendering_device_driver_vulkan.cpp | 4 +-- .../render_forward_clustered.cpp | 6 ++-- .../scene_shader_forward_clustered.cpp | 30 +++++++++--------- .../scene_shader_forward_clustered.h | 31 ++++++++++--------- .../renderer_rd/renderer_canvas_render_rd.h | 2 +- servers/rendering/renderer_scene_cull.cpp | 30 +++++++++--------- servers/rendering/renderer_scene_cull.h | 2 +- servers/rendering/rendering_context_driver.h | 26 +++++++++------- servers/rendering/rendering_device.cpp | 18 +++++------ 12 files changed, 81 insertions(+), 76 deletions(-) diff --git a/drivers/d3d12/rendering_context_driver_d3d12.cpp b/drivers/d3d12/rendering_context_driver_d3d12.cpp index 7cd36f90d2..7081d1730f 100644 --- a/drivers/d3d12/rendering_context_driver_d3d12.cpp +++ b/drivers/d3d12/rendering_context_driver_d3d12.cpp @@ -184,7 +184,7 @@ Error RenderingContextDriverD3D12::_initialize_devices() { Device &device = driver_devices[i]; device.name = desc.Description; - device.vendor = Vendor(desc.VendorId); + device.vendor = desc.VendorId; device.workarounds = Workarounds(); if (desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE) { diff --git a/drivers/metal/rendering_context_driver_metal.mm b/drivers/metal/rendering_context_driver_metal.mm index ac53f73447..53e5e98144 100644 --- a/drivers/metal/rendering_context_driver_metal.mm +++ b/drivers/metal/rendering_context_driver_metal.mm @@ -52,7 +52,7 @@ Error RenderingContextDriverMetal::initialize() { } #endif device.type = DEVICE_TYPE_INTEGRATED_GPU; - device.vendor = VENDOR_APPLE; + device.vendor = Vendor::VENDOR_APPLE; device.workarounds = Workarounds(); MetalDeviceProperties props(metal_device); diff --git a/drivers/vulkan/rendering_context_driver_vulkan.cpp b/drivers/vulkan/rendering_context_driver_vulkan.cpp index df9bd98624..3c1aa323f4 100644 --- a/drivers/vulkan/rendering_context_driver_vulkan.cpp +++ b/drivers/vulkan/rendering_context_driver_vulkan.cpp @@ -843,7 +843,7 @@ Error RenderingContextDriverVulkan::_initialize_devices() { Device &driver_device = driver_devices[i]; driver_device.name = String::utf8(props.deviceName); - driver_device.vendor = Vendor(props.vendorID); + driver_device.vendor = props.vendorID; driver_device.type = DeviceType(props.deviceType); driver_device.workarounds = Workarounds(); @@ -880,7 +880,7 @@ void RenderingContextDriverVulkan::_check_driver_workarounds(const VkPhysicalDev // This bug was fixed in driver version 512.503.0, so we only enabled it on devices older than this. // r_device.workarounds.avoid_compute_after_draw = - r_device.vendor == VENDOR_QUALCOMM && + r_device.vendor == Vendor::VENDOR_QUALCOMM && p_device_properties.deviceID >= 0x6000000 && // Adreno 6xx p_device_properties.driverVersion < VK_MAKE_VERSION(512, 503, 0) && r_device.name.find("Turnip") < 0; diff --git a/drivers/vulkan/rendering_device_driver_vulkan.cpp b/drivers/vulkan/rendering_device_driver_vulkan.cpp index 3189ab0bd1..a9002785f0 100644 --- a/drivers/vulkan/rendering_device_driver_vulkan.cpp +++ b/drivers/vulkan/rendering_device_driver_vulkan.cpp @@ -1898,10 +1898,10 @@ RDD::TextureID RenderingDeviceDriverVulkan::texture_create_shared(TextureID p_or vkGetPhysicalDeviceFormatProperties(physical_device, RD_TO_VK_FORMAT[p_view.format], &properties); const VkFormatFeatureFlags &supported_flags = owner_tex_info->vk_create_info.tiling == VK_IMAGE_TILING_LINEAR ? properties.linearTilingFeatures : properties.optimalTilingFeatures; if ((usage_info->usage & VK_IMAGE_USAGE_STORAGE_BIT) && !(supported_flags & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)) { - usage_info->usage &= ~VK_IMAGE_USAGE_STORAGE_BIT; + usage_info->usage &= ~uint32_t(VK_IMAGE_USAGE_STORAGE_BIT); } if ((usage_info->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) && !(supported_flags & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) { - usage_info->usage &= ~VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + usage_info->usage &= ~uint32_t(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); } } diff --git a/servers/rendering/renderer_rd/forward_clustered/render_forward_clustered.cpp b/servers/rendering/renderer_rd/forward_clustered/render_forward_clustered.cpp index 4084465033..0c62513e1a 100644 --- a/servers/rendering/renderer_rd/forward_clustered/render_forward_clustered.cpp +++ b/servers/rendering/renderer_rd/forward_clustered/render_forward_clustered.cpp @@ -2099,7 +2099,7 @@ void RenderForwardClustered::_render_scene(RenderDataRD *p_render_data, const Co } } - uint32_t opaque_color_pass_flags = using_motion_pass ? (color_pass_flags & ~COLOR_PASS_FLAG_MOTION_VECTORS) : color_pass_flags; + uint32_t opaque_color_pass_flags = using_motion_pass ? (color_pass_flags & ~uint32_t(COLOR_PASS_FLAG_MOTION_VECTORS)) : color_pass_flags; RID opaque_framebuffer = using_motion_pass ? rb_data->get_color_pass_fb(opaque_color_pass_flags) : color_framebuffer; RenderListParameters render_list_params(render_list[RENDER_LIST_OPAQUE].elements.ptr(), render_list[RENDER_LIST_OPAQUE].element_info.ptr(), render_list[RENDER_LIST_OPAQUE].elements.size(), reverse_cull, PASS_MODE_COLOR, opaque_color_pass_flags, rb_data.is_null(), p_render_data->directional_light_soft_shadows, rp_uniform_set, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME, Vector2(), p_render_data->scene_data->lod_distance_multiplier, p_render_data->scene_data->screen_mesh_lod_threshold, p_render_data->scene_data->view_count, 0, base_specialization); _render_list_with_draw_list(&render_list_params, opaque_framebuffer, RD::DrawFlags(load_color ? RD::DRAW_DEFAULT_ALL : RD::DRAW_CLEAR_COLOR_ALL) | (depth_pre_pass ? RD::DRAW_DEFAULT_ALL : RD::DRAW_CLEAR_DEPTH), c, 0.0f); @@ -2293,10 +2293,10 @@ void RenderForwardClustered::_render_scene(RenderDataRD *p_render_data, const Co _setup_environment(p_render_data, is_reflection_probe, screen_size, p_default_bg_color, false); { - uint32_t transparent_color_pass_flags = (color_pass_flags | COLOR_PASS_FLAG_TRANSPARENT) & ~(COLOR_PASS_FLAG_SEPARATE_SPECULAR); + uint32_t transparent_color_pass_flags = (color_pass_flags | uint32_t(COLOR_PASS_FLAG_TRANSPARENT)) & ~uint32_t(COLOR_PASS_FLAG_SEPARATE_SPECULAR); if (using_motion_pass) { // Motion vectors on transparent draw calls are not required when using the reactive mask. - transparent_color_pass_flags &= ~(COLOR_PASS_FLAG_MOTION_VECTORS); + transparent_color_pass_flags &= ~uint32_t(COLOR_PASS_FLAG_MOTION_VECTORS); } RID alpha_framebuffer = rb_data.is_valid() ? rb_data->get_color_pass_fb(transparent_color_pass_flags) : color_only_framebuffer; diff --git a/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.cpp b/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.cpp index 6dadbf25ac..faf9927746 100644 --- a/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.cpp +++ b/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.cpp @@ -222,27 +222,27 @@ RS::ShaderNativeSourceCode SceneShaderForwardClustered::ShaderData::get_native_s } } -SceneShaderForwardClustered::ShaderVersion SceneShaderForwardClustered::ShaderData::_get_shader_version(PipelineVersion p_pipeline_version, uint32_t p_color_pass_flags, bool p_ubershader) const { - uint32_t ubershader_base = p_ubershader ? SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL : 0; +uint16_t SceneShaderForwardClustered::ShaderData::_get_shader_version(PipelineVersion p_pipeline_version, uint32_t p_color_pass_flags, bool p_ubershader) const { + uint32_t ubershader_base = p_ubershader ? ShaderVersion::SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL : 0; switch (p_pipeline_version) { case PIPELINE_VERSION_DEPTH_PASS: - return ShaderVersion(SHADER_VERSION_DEPTH_PASS + ubershader_base); + return ShaderVersion::SHADER_VERSION_DEPTH_PASS + ubershader_base; case PIPELINE_VERSION_DEPTH_PASS_DP: - return ShaderVersion(SHADER_VERSION_DEPTH_PASS_DP + ubershader_base); + return ShaderVersion::SHADER_VERSION_DEPTH_PASS_DP + ubershader_base; case PIPELINE_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS: - return ShaderVersion(SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS + ubershader_base); + return ShaderVersion::SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS + ubershader_base; case PIPELINE_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_VOXEL_GI: - return ShaderVersion(SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_VOXEL_GI + ubershader_base); + return ShaderVersion::SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_VOXEL_GI + ubershader_base; case PIPELINE_VERSION_DEPTH_PASS_MULTIVIEW: - return ShaderVersion(SHADER_VERSION_DEPTH_PASS_MULTIVIEW + ubershader_base); + return ShaderVersion::SHADER_VERSION_DEPTH_PASS_MULTIVIEW + ubershader_base; case PIPELINE_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_MULTIVIEW: - return ShaderVersion(SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_MULTIVIEW + ubershader_base); + return ShaderVersion::SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_MULTIVIEW + ubershader_base; case PIPELINE_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_VOXEL_GI_MULTIVIEW: - return ShaderVersion(SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_VOXEL_GI_MULTIVIEW + ubershader_base); + return ShaderVersion::SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_VOXEL_GI_MULTIVIEW + ubershader_base; case PIPELINE_VERSION_DEPTH_PASS_WITH_MATERIAL: - return ShaderVersion(SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL + SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL); + return ShaderVersion::SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL + ShaderVersion::SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL; case PIPELINE_VERSION_DEPTH_PASS_WITH_SDF: - return ShaderVersion(SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL + SHADER_VERSION_DEPTH_PASS_WITH_SDF); + return ShaderVersion::SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL + ShaderVersion::SHADER_VERSION_DEPTH_PASS_WITH_SDF; case PIPELINE_VERSION_COLOR_PASS: { int shader_flags = 0; @@ -266,11 +266,11 @@ SceneShaderForwardClustered::ShaderVersion SceneShaderForwardClustered::ShaderDa shader_flags |= SHADER_COLOR_PASS_FLAG_MULTIVIEW; } - return ShaderVersion(SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL + SHADER_VERSION_COLOR_PASS + shader_flags); + return ShaderVersion::SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL + ShaderVersion::SHADER_VERSION_COLOR_PASS + shader_flags; } break; default: { DEV_ASSERT(false && "Unknown pipeline version."); - return ShaderVersion(0); + return 0; } break; } } @@ -404,7 +404,7 @@ RD::PolygonCullMode SceneShaderForwardClustered::ShaderData::get_cull_mode_from_ return cull_mode_rd_table[p_cull_variant][cull_mode]; } -RID SceneShaderForwardClustered::ShaderData::_get_shader_variant(ShaderVersion p_shader_version) const { +RID SceneShaderForwardClustered::ShaderData::_get_shader_variant(uint16_t p_shader_version) const { if (version.is_valid()) { MutexLock lock(SceneShaderForwardClustered::singleton_mutex); ERR_FAIL_NULL_V(SceneShaderForwardClustered::singleton, RID()); @@ -426,7 +426,7 @@ RID SceneShaderForwardClustered::ShaderData::get_shader_variant(PipelineVersion uint64_t SceneShaderForwardClustered::ShaderData::get_vertex_input_mask(PipelineVersion p_pipeline_version, uint32_t p_color_pass_flags, bool p_ubershader) { // Vertex input masks require knowledge of the shader. Since querying the shader can be expensive due to high contention and the necessary mutex, we cache the result instead. - ShaderVersion shader_version = _get_shader_version(p_pipeline_version, p_color_pass_flags, p_ubershader); + uint16_t shader_version = _get_shader_version(p_pipeline_version, p_color_pass_flags, p_ubershader); uint64_t input_mask = vertex_input_masks[shader_version].load(std::memory_order_relaxed); if (input_mask == 0) { RID shader_rid = _get_shader_variant(shader_version); diff --git a/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.h b/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.h index 1f4058a121..9e9e5dd8a2 100644 --- a/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.h +++ b/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.h @@ -50,18 +50,19 @@ public: SHADER_GROUP_ADVANCED_MULTIVIEW, }; - enum ShaderVersion { - SHADER_VERSION_DEPTH_PASS, - SHADER_VERSION_DEPTH_PASS_DP, - SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS, - SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_VOXEL_GI, - SHADER_VERSION_DEPTH_PASS_MULTIVIEW, - SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_MULTIVIEW, - SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_VOXEL_GI_MULTIVIEW, - SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL, - SHADER_VERSION_DEPTH_PASS_WITH_SDF, - SHADER_VERSION_COLOR_PASS, - SHADER_VERSION_MAX + // Not an enum because these values are constants that are processed as numbers + // to arrive at a unique version for a particular shader. + struct ShaderVersion { + constexpr static uint16_t SHADER_VERSION_DEPTH_PASS = 0; + constexpr static uint16_t SHADER_VERSION_DEPTH_PASS_DP = 1; + constexpr static uint16_t SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS = 2; + constexpr static uint16_t SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_VOXEL_GI = 3; + constexpr static uint16_t SHADER_VERSION_DEPTH_PASS_MULTIVIEW = 4; + constexpr static uint16_t SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_MULTIVIEW = 5; + constexpr static uint16_t SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_VOXEL_GI_MULTIVIEW = 6; + constexpr static uint16_t SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL = 7; + constexpr static uint16_t SHADER_VERSION_DEPTH_PASS_WITH_SDF = 8; + constexpr static uint16_t SHADER_VERSION_COLOR_PASS = 9; }; enum ShaderColorPassFlags { @@ -205,7 +206,7 @@ public: RID version; - static const uint32_t VERTEX_INPUT_MASKS_SIZE = SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL + SHADER_VERSION_COLOR_PASS + SHADER_COLOR_PASS_FLAG_COUNT; + static const uint32_t VERTEX_INPUT_MASKS_SIZE = ShaderVersion::SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL + ShaderVersion::SHADER_VERSION_COLOR_PASS + SHADER_COLOR_PASS_FLAG_COUNT; std::atomic vertex_input_masks[VERTEX_INPUT_MASKS_SIZE] = {}; Vector texture_uniforms; @@ -281,8 +282,8 @@ public: virtual bool is_animated() const; virtual bool casts_shadows() const; virtual RS::ShaderNativeSourceCode get_native_source_code() const; - ShaderVersion _get_shader_version(PipelineVersion p_pipeline_version, uint32_t p_color_pass_flags, bool p_ubershader) const; - RID _get_shader_variant(ShaderVersion p_shader_version) const; + uint16_t _get_shader_version(PipelineVersion p_pipeline_version, uint32_t p_color_pass_flags, bool p_ubershader) const; + RID _get_shader_variant(uint16_t p_shader_version) const; void _clear_vertex_input_mask_cache(); RID get_shader_variant(PipelineVersion p_pipeline_version, uint32_t p_color_pass_flags, bool p_ubershader) const; uint64_t get_vertex_input_mask(PipelineVersion p_pipeline_version, uint32_t p_color_pass_flags, bool p_ubershader); diff --git a/servers/rendering/renderer_rd/renderer_canvas_render_rd.h b/servers/rendering/renderer_rd/renderer_canvas_render_rd.h index e4f1779b09..6d8275db2e 100644 --- a/servers/rendering/renderer_rd/renderer_canvas_render_rd.h +++ b/servers/rendering/renderer_rd/renderer_canvas_render_rd.h @@ -138,7 +138,7 @@ class RendererCanvasRenderRD : public RendererCanvasRender { uint32_t hash() const { uint32_t h = hash_murmur3_one_32(variant); h = hash_murmur3_one_32(framebuffer_format_id, h); - h = hash_murmur3_one_32(vertex_format_id, h); + h = hash_murmur3_one_64((uint64_t)vertex_format_id, h); h = hash_murmur3_one_32(render_primitive, h); h = hash_murmur3_one_32(shader_specialization.packed_0, h); h = hash_murmur3_one_32(lcd_blend, h); diff --git a/servers/rendering/renderer_scene_cull.cpp b/servers/rendering/renderer_scene_cull.cpp index 1fcbcb9853..48b6dadd56 100644 --- a/servers/rendering/renderer_scene_cull.cpp +++ b/servers/rendering/renderer_scene_cull.cpp @@ -359,7 +359,7 @@ void RendererSceneCull::_instance_unpair(Instance *p_A, Instance *p_B) { if (geom->lightmap_captures.is_empty() && A->scenario && A->array_index >= 0) { InstanceData &idata = A->scenario->instance_data[A->array_index]; - idata.flags &= ~uint32_t(InstanceData::FLAG_LIGHTMAP_CAPTURE); + idata.flags &= ~InstanceData::FLAG_LIGHTMAP_CAPTURE; } lightmap_data->geometries.erase(A); @@ -532,7 +532,7 @@ void RendererSceneCull::_instance_update_mesh_instance(Instance *p_instance) con if (p_instance->mesh_instance.is_valid()) { idata.flags |= InstanceData::FLAG_USES_MESH_INSTANCE; } else { - idata.flags &= ~uint32_t(InstanceData::FLAG_USES_MESH_INSTANCE); + idata.flags &= ~InstanceData::FLAG_USES_MESH_INSTANCE; } } } @@ -1232,7 +1232,7 @@ void RendererSceneCull::instance_set_ignore_culling(RID p_instance, bool p_enabl if (instance->ignore_all_culling) { idata.flags |= InstanceData::FLAG_IGNORE_ALL_CULLING; } else { - idata.flags &= ~uint32_t(InstanceData::FLAG_IGNORE_ALL_CULLING); + idata.flags &= ~InstanceData::FLAG_IGNORE_ALL_CULLING; } } } @@ -1324,7 +1324,7 @@ void RendererSceneCull::instance_geometry_set_flag(RID p_instance, RS::InstanceF if (instance->baked_light) { idata.flags |= InstanceData::FLAG_USES_BAKED_LIGHT; } else { - idata.flags &= ~uint32_t(InstanceData::FLAG_USES_BAKED_LIGHT); + idata.flags &= ~InstanceData::FLAG_USES_BAKED_LIGHT; } } @@ -1364,7 +1364,7 @@ void RendererSceneCull::instance_geometry_set_flag(RID p_instance, RS::InstanceF if (instance->redraw_if_visible) { idata.flags |= InstanceData::FLAG_REDRAW_IF_VISIBLE; } else { - idata.flags &= ~uint32_t(InstanceData::FLAG_REDRAW_IF_VISIBLE); + idata.flags &= ~InstanceData::FLAG_REDRAW_IF_VISIBLE; } } @@ -1377,7 +1377,7 @@ void RendererSceneCull::instance_geometry_set_flag(RID p_instance, RS::InstanceF if (instance->ignore_occlusion_culling) { idata.flags |= InstanceData::FLAG_IGNORE_OCCLUSION_CULLING; } else { - idata.flags &= ~uint32_t(InstanceData::FLAG_IGNORE_OCCLUSION_CULLING); + idata.flags &= ~InstanceData::FLAG_IGNORE_OCCLUSION_CULLING; } } } break; @@ -1398,13 +1398,13 @@ void RendererSceneCull::instance_geometry_set_cast_shadows_setting(RID p_instanc if (instance->cast_shadows != RS::SHADOW_CASTING_SETTING_OFF) { idata.flags |= InstanceData::FLAG_CAST_SHADOWS; } else { - idata.flags &= ~uint32_t(InstanceData::FLAG_CAST_SHADOWS); + idata.flags &= ~InstanceData::FLAG_CAST_SHADOWS; } if (instance->cast_shadows == RS::SHADOW_CASTING_SETTING_SHADOWS_ONLY) { idata.flags |= InstanceData::FLAG_CAST_SHADOWS_ONLY; } else { - idata.flags &= ~uint32_t(InstanceData::FLAG_CAST_SHADOWS_ONLY); + idata.flags &= ~InstanceData::FLAG_CAST_SHADOWS_ONLY; } } @@ -2967,7 +2967,7 @@ void RendererSceneCull::_scene_cull(CullData &cull_data, InstanceCullResult &cul } cull_data.cull->lock.unlock(); - idata.flags &= ~uint32_t(InstanceData::FLAG_REFLECTION_PROBE_DIRTY); + idata.flags &= ~InstanceData::FLAG_REFLECTION_PROBE_DIRTY; } if (RSG::light_storage->reflection_probe_instance_has_reflection(RID::from_uint64(idata.instance_data_rid))) { @@ -3056,7 +3056,7 @@ void RendererSceneCull::_scene_cull(CullData &cull_data, InstanceCullResult &cul ERR_FAIL_NULL(geom->geometry_instance); geom->geometry_instance->pair_light_instances(instance_pair_buffer, idx); - idata.flags &= ~uint32_t(InstanceData::FLAG_GEOM_LIGHTING_DIRTY); + idata.flags &= ~InstanceData::FLAG_GEOM_LIGHTING_DIRTY; } if (idata.flags & InstanceData::FLAG_GEOM_PROJECTOR_SOFTSHADOW_DIRTY) { @@ -3066,7 +3066,7 @@ void RendererSceneCull::_scene_cull(CullData &cull_data, InstanceCullResult &cul cull_data.cull->lock.lock(); geom->geometry_instance->set_softshadow_projector_pairing(geom->softshadow_count > 0, geom->projector_count > 0); cull_data.cull->lock.unlock(); - idata.flags &= ~uint32_t(InstanceData::FLAG_GEOM_PROJECTOR_SOFTSHADOW_DIRTY); + idata.flags &= ~InstanceData::FLAG_GEOM_PROJECTOR_SOFTSHADOW_DIRTY; } if (geometry_instance_pair_mask & (1 << RS::INSTANCE_REFLECTION_PROBE) && (idata.flags & InstanceData::FLAG_GEOM_REFLECTION_DIRTY)) { @@ -3084,7 +3084,7 @@ void RendererSceneCull::_scene_cull(CullData &cull_data, InstanceCullResult &cul ERR_FAIL_NULL(geom->geometry_instance); geom->geometry_instance->pair_reflection_probe_instances(instance_pair_buffer, idx); - idata.flags &= ~uint32_t(InstanceData::FLAG_GEOM_REFLECTION_DIRTY); + idata.flags &= ~InstanceData::FLAG_GEOM_REFLECTION_DIRTY; } if (geometry_instance_pair_mask & (1 << RS::INSTANCE_DECAL) && (idata.flags & InstanceData::FLAG_GEOM_DECAL_DIRTY)) { @@ -3103,7 +3103,7 @@ void RendererSceneCull::_scene_cull(CullData &cull_data, InstanceCullResult &cul ERR_FAIL_NULL(geom->geometry_instance); geom->geometry_instance->pair_decal_instances(instance_pair_buffer, idx); - idata.flags &= ~uint32_t(InstanceData::FLAG_GEOM_DECAL_DIRTY); + idata.flags &= ~InstanceData::FLAG_GEOM_DECAL_DIRTY; } if (idata.flags & InstanceData::FLAG_GEOM_VOXEL_GI_DIRTY) { @@ -3121,7 +3121,7 @@ void RendererSceneCull::_scene_cull(CullData &cull_data, InstanceCullResult &cul ERR_FAIL_NULL(geom->geometry_instance); geom->geometry_instance->pair_voxel_gi_instances(instance_pair_buffer, idx); - idata.flags &= ~uint32_t(InstanceData::FLAG_GEOM_VOXEL_GI_DIRTY); + idata.flags &= ~InstanceData::FLAG_GEOM_VOXEL_GI_DIRTY; } if ((idata.flags & InstanceData::FLAG_LIGHTMAP_CAPTURE) && idata.instance->last_frame_pass != frame_number && !idata.instance->lightmap_target_sh.is_empty() && !idata.instance->lightmap_sh.is_empty()) { @@ -3981,7 +3981,7 @@ void RendererSceneCull::render_probes() { ERR_FAIL_NULL(geom->geometry_instance); geom->geometry_instance->pair_voxel_gi_instances(instance_pair_buffer, idx); - ins->scenario->instance_data[ins->array_index].flags &= ~uint32_t(InstanceData::FLAG_GEOM_VOXEL_GI_DIRTY); + ins->scenario->instance_data[ins->array_index].flags &= ~InstanceData::FLAG_GEOM_VOXEL_GI_DIRTY; } ERR_FAIL_NULL(geom->geometry_instance); diff --git a/servers/rendering/renderer_scene_cull.h b/servers/rendering/renderer_scene_cull.h index cfab52208a..d56daea240 100644 --- a/servers/rendering/renderer_scene_cull.h +++ b/servers/rendering/renderer_scene_cull.h @@ -259,7 +259,7 @@ public: struct InstanceData { // Store instance pointer as well as common instance processing information, // to make processing more cache friendly. - enum Flags { + enum Flags : uint32_t { FLAG_BASE_TYPE_MASK = 0xFF, FLAG_CAST_SHADOWS = (1 << 8), FLAG_CAST_SHADOWS_ONLY = (1 << 9), diff --git a/servers/rendering/rendering_context_driver.h b/servers/rendering/rendering_context_driver.h index 2e5951ae4f..cd973cf3c9 100644 --- a/servers/rendering/rendering_context_driver.h +++ b/servers/rendering/rendering_context_driver.h @@ -52,16 +52,20 @@ public: void window_destroy(DisplayServer::WindowID p_window); public: - enum Vendor { - VENDOR_UNKNOWN = 0x0, - VENDOR_AMD = 0x1002, - VENDOR_IMGTEC = 0x1010, - VENDOR_APPLE = 0x106B, - VENDOR_NVIDIA = 0x10DE, - VENDOR_ARM = 0x13B5, - VENDOR_MICROSOFT = 0x1414, - VENDOR_QUALCOMM = 0x5143, - VENDOR_INTEL = 0x8086 + // Not an enum as these values are matched against values returned by + // the various drivers, which report them in uint32_t. Casting to an + // enum value is dangerous in this case as we don't actually know what + // range the driver is reporting a value in. + struct Vendor { + constexpr static uint32_t VENDOR_UNKNOWN = 0x0; + constexpr static uint32_t VENDOR_AMD = 0x1002; + constexpr static uint32_t VENDOR_IMGTEC = 0x1010; + constexpr static uint32_t VENDOR_APPLE = 0x106B; + constexpr static uint32_t VENDOR_NVIDIA = 0x10DE; + constexpr static uint32_t VENDOR_ARM = 0x13B5; + constexpr static uint32_t VENDOR_MICROSOFT = 0x1414; + constexpr static uint32_t VENDOR_QUALCOMM = 0x5143; + constexpr static uint32_t VENDOR_INTEL = 0x8086; }; enum DeviceType { @@ -79,7 +83,7 @@ public: struct Device { String name = "Unknown"; - Vendor vendor = VENDOR_UNKNOWN; + uint32_t vendor = Vendor::VENDOR_UNKNOWN; DeviceType type = DEVICE_TYPE_OTHER; Workarounds workarounds; }; diff --git a/servers/rendering/rendering_device.cpp b/servers/rendering/rendering_device.cpp index 33a42d4776..d62fa1f420 100644 --- a/servers/rendering/rendering_device.cpp +++ b/servers/rendering/rendering_device.cpp @@ -53,21 +53,21 @@ static String _get_device_vendor_name(const RenderingContextDriver::Device &p_device) { switch (p_device.vendor) { - case RenderingContextDriver::VENDOR_AMD: + case RenderingContextDriver::Vendor::VENDOR_AMD: return "AMD"; - case RenderingContextDriver::VENDOR_IMGTEC: + case RenderingContextDriver::Vendor::VENDOR_IMGTEC: return "ImgTec"; - case RenderingContextDriver::VENDOR_APPLE: + case RenderingContextDriver::Vendor::VENDOR_APPLE: return "Apple"; - case RenderingContextDriver::VENDOR_NVIDIA: + case RenderingContextDriver::Vendor::VENDOR_NVIDIA: return "NVIDIA"; - case RenderingContextDriver::VENDOR_ARM: + case RenderingContextDriver::Vendor::VENDOR_ARM: return "ARM"; - case RenderingContextDriver::VENDOR_MICROSOFT: + case RenderingContextDriver::Vendor::VENDOR_MICROSOFT: return "Microsoft"; - case RenderingContextDriver::VENDOR_QUALCOMM: + case RenderingContextDriver::Vendor::VENDOR_QUALCOMM: return "Qualcomm"; - case RenderingContextDriver::VENDOR_INTEL: + case RenderingContextDriver::Vendor::VENDOR_INTEL: return "Intel"; default: return "Unknown"; @@ -2371,7 +2371,7 @@ RDD::RenderPassID RenderingDevice::_render_pass_create(RenderingDeviceDriver *p_ } LocalVector attachments; - LocalVector attachment_remap; + LocalVector attachment_remap; for (int i = 0; i < p_attachments.size(); i++) { if (p_attachments[i].usage_flags == AttachmentFormat::UNUSED_ATTACHMENT) {