remove adhoc method for vision os xr

Author: huisedenanhai

drivers/metal/metal_objects.h

@@ -239,7 +239,6 @@ struct MDSubpass {
 	LocalVector<RDD::AttachmentReference> color_references;
 	RDD::AttachmentReference depth_stencil_reference;
 	LocalVector<RDD::AttachmentReference> resolve_references;
-	id<MTLRasterizationRateMap> rasterization_rate_map = nil;
 
 	MTLFmtCaps getRequiredFmtCapsForAttachmentAt(uint32_t p_index) const;
 };
@@ -918,6 +917,7 @@ class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MDFrameBuffer {
 
 public:
 	Size2i size;
+	id<MTLRasterizationRateMap> rasterization_rate_map = nil;
 	MDFrameBuffer(Vector<MTL::Texture> p_textures, Size2i p_size) :
 			textures(p_textures), size(p_size) {}
 	MDFrameBuffer() {}

drivers/metal/metal_objects.mm

@@ -766,21 +766,9 @@
 		}
 	}
 
-#ifdef VISIONOS_ENABLED
-	// If the subpass has a rasterization rate map, it means we're rendering in Immersive mode with foveation enabled.
-	// In that case, the renderTarget size should be the screen logical viewport, which is bigger than the actual render
-	// area (physical texture size). Not setting renderTargetWidth/renderTargetHeight is enough to render the full
-	// screen Immersive scene.
-	if (subpass.rasterization_rate_map != nil) {
-		desc.rasterizationRateMap = subpass.rasterization_rate_map;
-	} else {
-		desc.renderTargetWidth = MAX((NSUInteger)MIN(render.render_area.position.x + render.render_area.size.width, fb.size.width), 1u);
-		desc.renderTargetHeight = MAX((NSUInteger)MIN(render.render_area.position.y + render.render_area.size.height, fb.size.height), 1u);
-	}
-#else
+	desc.rasterizationRateMap = fb.rasterization_rate_map;
 	desc.renderTargetWidth = MAX((NSUInteger)MIN(render.render_area.position.x + render.render_area.size.width, fb.size.width), 1u);
 	desc.renderTargetHeight = MAX((NSUInteger)MIN(render.render_area.position.y + render.render_area.size.height, fb.size.height), 1u);
-#endif
 
 	if (attachmentCount == 0) {
 		// If there are no attachments, delay the creation of the encoder,

drivers/metal/rendering_device_driver_metal.h

@@ -415,6 +415,7 @@ class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) RenderingDeviceDriverMet
 	virtual const MultiviewCapabilities &get_multiview_capabilities() override final;
 	virtual const FragmentShadingRateCapabilities &get_fragment_shading_rate_capabilities() override final;
 	virtual const FragmentDensityMapCapabilities &get_fragment_density_map_capabilities() override final;
+	virtual bool is_rasterization_rate_map_supported() override final;
 	virtual String get_api_name() const override final { return "Metal"; }
 	virtual String get_api_version() const override final;
 	virtual String get_pipeline_cache_uuid() const override final;

drivers/metal/rendering_device_driver_metal.mm

@@ -49,6 +49,10 @@
 /**************************************************************************/
 
 #import "rendering_device_driver_metal.h"
+#include "core/string/print_string.h"
+#include "core/variant/variant.h"
+#include <Foundation/NSObjCRuntime.h>
+#include <cstdint>
 
 #import "pixel_formats.h"
 #import "rendering_context_driver_metal.h"
@@ -1074,11 +1078,20 @@ static const API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MTLSamplerBorderC
 
 	Vector<MTL::Texture> textures;
 	textures.resize(p_attachments.size());
+	id<MTLRasterizationRateMap> rasterization_rate_map = nil;
 
 	for (uint32_t i = 0; i < p_attachments.size(); i += 1) {
 		MDAttachment const &a = pass->attachments[i];
-		id<MTLTexture> tex = rid::get(p_attachments[i]);
-		if (tex == nil) {
+		id attacment = rid::get(p_attachments[i]);
+		id<MTLTexture> tex = nil;
+		bool is_rasterization_rate_map = false;
+		if ([attacment conformsToProtocol:@protocol(MTLRasterizationRateMap)]) {
+			rasterization_rate_map = attacment;
+			is_rasterization_rate_map = true;
+		} else if ([attacment conformsToProtocol:@protocol(MTLTexture)]) {
+			tex = attacment;
+		}
+		if (tex == nil && !is_rasterization_rate_map) {
 #if DEV_ENABLED
 			WARN_PRINT("Invalid texture for attachment " + itos(i));
 #endif
@@ -1094,6 +1107,7 @@ static const API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MTLSamplerBorderC
 	}
 
 	MDFrameBuffer *fb = new MDFrameBuffer(textures, Size2i(p_width, p_height));
+	fb->rasterization_rate_map = rasterization_rate_map;
 	return FramebufferID(fb);
 }
 
@@ -1833,7 +1847,6 @@ bool isArrayTexture(MTLTextureType p_type) {
 		subpass.color_references = p_subpasses[i].color_references;
 		subpass.depth_stencil_reference = p_subpasses[i].depth_stencil_reference;
 		subpass.resolve_references = p_subpasses[i].resolve_references;
-		subpass.rasterization_rate_map = (__bridge id<MTLRasterizationRateMap>)p_subpasses[i].rasterization_rate_map;
 	}
 
 	static const MTLLoadAction LOAD_ACTIONS[] = {
@@ -2780,6 +2793,13 @@ bool isArrayTexture(MTLTextureType p_type) {
 	return fdm_capabilities;
 }
 
+bool RenderingDeviceDriverMetal::is_rasterization_rate_map_supported() {
+	// Seems impossible to use layers more than one.
+	// This feature is introduced in the process of adding visionOS support, used when rendering stereo contents.
+	return [device supportsRasterizationRateMapWithLayerCount:1] &&
+			[device supportsRasterizationRateMapWithLayerCount:2];
+}
+
 String RenderingDeviceDriverMetal::get_api_version() const {
 	return vformat("%d.%d", capabilities.version_major, capabilities.version_minor);
 }

modules/visionos_xr/visionos_xr_interface.h

@@ -134,7 +134,7 @@ class VisionOSXRInterface : public XRInterface {
 	virtual Transform3D get_camera_transform() override;
 	virtual Transform3D get_transform_for_view(uint32_t p_view, const Transform3D &p_cam_transform) override;
 	virtual Projection get_projection_for_view(uint32_t p_view, double p_aspect, double p_z_near, double p_z_far) override;
-	virtual Rect2i get_viewport_for_view(uint32_t p_view) override;
+	virtual Rect2i get_render_region() override;
 
 	virtual void process() override;
 	virtual void pre_render() override;

modules/visionos_xr/visionos_xr_interface.mm

@@ -28,6 +28,7 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
 /**************************************************************************/
 
+#include <Metal/Metal.h>
 #ifdef VISIONOS_ENABLED
 
 #include "visionos_xr_interface.h"
@@ -288,18 +289,17 @@
 	return eye_projection;
 }
 
-Rect2i VisionOSXRInterface::get_viewport_for_view(uint32_t p_view) {
+Rect2i VisionOSXRInterface::get_render_region() {
 	_THREAD_SAFE_METHOD_
 
 	Rect2 viewport_rect;
 	if (!initialized) {
 		return viewport_rect;
 	}
 
-	ERR_FAIL_COND_V(p_view > get_view_count(), viewport_rect);
 	ERR_FAIL_NULL_V_MSG(current_drawable, viewport_rect, "Current drawable is nil, probably pre_render() has not been called");
 
-	cp_view_t view = cp_drawable_get_view(current_drawable, p_view);
+	cp_view_t view = cp_drawable_get_view(current_drawable, 0);
 	cp_view_texture_map_t view_texture_map = cp_view_get_view_texture_map(view);
 	MTLViewport viewport = cp_view_texture_map_get_viewport(view_texture_map);
 	viewport_rect = MTL::rect_from_mtl_viewport(viewport);
@@ -498,9 +498,19 @@
 	size_t count = cp_drawable_get_rasterization_rate_map_count(current_drawable);
 	ERR_FAIL_COND_V_MSG(count == 0, RID(), "No rasterizationRateMaps found");
 	id<MTLRasterizationRateMap> rasterization_rate_map = cp_drawable_get_rasterization_rate_map(current_drawable, 0);
+	MTLSize logical_size = rasterization_rate_map.screenSize;
 
 	RD::Texture texture;
 	texture.driver_id = RDD::TextureID((__bridge void *)rasterization_rate_map);
+	texture.type = RDD::TEXTURE_TYPE_2D_ARRAY;
+	texture.usage_flags = RDD::TEXTURE_USAGE_VRS_ATTACHMENT_BIT;
+	texture.format = RDD::DATA_FORMAT_R8_UINT;
+	texture.samples = RDD::TEXTURE_SAMPLES_1;
+	texture.width = logical_size.width;
+	texture.height = logical_size.height;
+	texture.depth = 1;
+	texture.mipmaps = 1;
+	texture.layers = rasterization_rate_map.layerCount;
 	ERR_FAIL_COND_V(!texture.driver_id, RID());
 
 	current_rasterization_rate_map = texture;

servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.cpp

@@ -38,6 +38,7 @@
 #include "servers/rendering/renderer_rd/uniform_set_cache_rd.h"
 #include "servers/rendering/rendering_device.h"
 #include "servers/rendering/rendering_server_default.h"
+#include "servers/xr/xr_interface.h"
 
 #define PRELOAD_PIPELINES_ON_SURFACE_CACHE_CONSTRUCTION 1
 
@@ -211,24 +212,16 @@ RID RenderForwardMobile::RenderBufferDataForwardMobile::get_color_fbs(Framebuffe
 	uint32_t view_count = render_buffers->get_view_count();
 
 	RID vrs_texture;
-	void *rasterization_rate_map = nullptr;
 #ifndef XR_DISABLED
 	RS::ViewportVRSMode vrs_mode = render_buffers->get_vrs_mode();
 	if (vrs_mode == RS::VIEWPORT_VRS_XR) {
 		Ref<XRInterface> xr_interface = XRServer::get_singleton()->get_primary_interface();
 		if (xr_interface.is_valid()) {
-			if (RD::get_singleton()->vrs_get_method() == RD::VRS_METHOD_FRAGMENT_DENSITY_MAP && xr_interface->get_vrs_texture_format() == XRInterface::XR_VRS_TEXTURE_FORMAT_FRAGMENT_DENSITY_MAP) {
+			bool use_vrs_fragment_density_map = RD::get_singleton()->vrs_get_method() == RD::VRS_METHOD_FRAGMENT_DENSITY_MAP && xr_interface->get_vrs_texture_format() == XRInterface::XR_VRS_TEXTURE_FORMAT_FRAGMENT_DENSITY_MAP;
+			bool use_vrs_rasterization_rate_map = RD::get_singleton()->vrs_get_method() == RD::VRS_METHOD_RASTERIZATION_RATE_MAP && xr_interface->get_vrs_texture_format() == XRInterface::XR_VRS_TEXTURE_FORMAT_RASTERIZATION_RATE_MAP;
+			if (use_vrs_fragment_density_map || use_vrs_rasterization_rate_map) {
 				vrs_texture = xr_interface->get_vrs_texture();
 			}
-#ifdef VISIONOS_ENABLED
-			if (xr_interface->get_vrs_texture_format() == XRInterface::XR_VRS_TEXTURE_FORMAT_RASTERIZATION_RATE_MAP) {
-				RID rasterization_rate_map_rid = xr_interface->get_vrs_texture();
-				RD::Texture *texture = RenderingDevice::get_singleton()->texture_owner.get_or_null(rasterization_rate_map_rid);
-				if (texture) {
-					rasterization_rate_map = (void *)texture->driver_id.id;
-				}
-			}
-#endif
 		}
 	}
 #endif // XR_DISABLED
@@ -256,7 +249,6 @@ RID RenderForwardMobile::RenderBufferDataForwardMobile::get_color_fbs(Framebuffe
 			RD::FramebufferPass pass;
 			pass.color_attachments.push_back(0);
 			pass.depth_attachment = 1;
-			pass.rasterization_rate_map = rasterization_rate_map;
 
 			if (use_msaa) {
 				// Add resolve
@@ -277,7 +269,6 @@ RID RenderForwardMobile::RenderBufferDataForwardMobile::get_color_fbs(Framebuffe
 			RD::FramebufferPass pass;
 			pass.color_attachments.push_back(0);
 			pass.depth_attachment = 1;
-			pass.rasterization_rate_map = rasterization_rate_map;
 
 			if (use_msaa) {
 				// add resolve
@@ -304,8 +295,6 @@ RID RenderForwardMobile::RenderBufferDataForwardMobile::get_color_fbs(Framebuffe
 			RD::FramebufferPass blit_pass;
 			blit_pass.input_attachments.push_back(color_buffer_id); // Read from our (resolved) color buffer
 			blit_pass.color_attachments.push_back(target_buffer_id); // Write into our target buffer
-			// this doesn't need VRS nor rasterization_rate_map
-			blit_pass.rasterization_rate_map = nullptr;
 			passes.push_back(blit_pass);
 
 			return FramebufferCacheRD::get_singleton()->get_cache_multipass(textures, passes, view_count);
@@ -1209,11 +1198,6 @@ void RenderForwardMobile::_render_scene(RenderDataRD *p_render_data, const Color
 		}
 
 		RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(framebuffer, load_color ? RD::DRAW_CLEAR_DEPTH : (RD::DRAW_CLEAR_COLOR_0 | RD::DRAW_CLEAR_DEPTH), c, 0.0f, 0, p_render_data->render_region, breadcrumb);
-		if (p_render_data->xr_viewports.size() == 2) {
-			RD::get_singleton()->draw_list_set_viewports(draw_list, p_render_data->xr_viewports);
-			RD::get_singleton()->draw_list_set_empty_scissor(draw_list);
-		}
-
 		RD::FramebufferFormatID fb_format = RD::get_singleton()->framebuffer_get_format(framebuffer);
 
 		if (copy_canvas) {

servers/rendering/renderer_rd/renderer_scene_render_rd.cpp

@@ -1416,8 +1416,6 @@ void RendererSceneRenderRD::render_scene(const Ref<RenderSceneBuffers> &p_render
 			render_data.transparent_bg = texture_storage->render_target_get_transparent(rb->get_render_target());
 			render_data.render_region = texture_storage->render_target_get_render_region(rb->get_render_target());
 		}
-
-		render_data.xr_viewports = p_camera_data->xr_viewports;
 	}
 
 	PagedArray<RID> empty;

servers/rendering/renderer_rd/storage_rd/render_data_rd.h

@@ -94,7 +94,4 @@ class RenderDataRD : public RenderData {
 	const RendererSceneRender::RenderSDFGIUpdateData *sdfgi_update_data = nullptr;
 
 	uint32_t voxel_gi_count = 0;
-
-	// For visionOS immersive rendering. It should have one rect for each view. It should be empty when XR is disabled.
-	LocalVector<Rect2i> xr_viewports;
 };

servers/rendering/renderer_scene_cull.cpp

@@ -2664,7 +2664,6 @@ void RendererSceneCull::render_camera(const Ref<RenderSceneBuffers> &p_render_bu
 		// We can support multiple views here each with their own camera
 		Transform3D transforms[RendererSceneRender::MAX_RENDER_VIEWS];
 		Projection projections[RendererSceneRender::MAX_RENDER_VIEWS];
-		Vector<Rect2i> viewports;
 
 		uint32_t view_count = p_xr_interface->get_view_count();
 		ERR_FAIL_COND_MSG(view_count == 0 || view_count > RendererSceneRender::MAX_RENDER_VIEWS, "Requested view count is not supported");
@@ -2678,10 +2677,6 @@ void RendererSceneCull::render_camera(const Ref<RenderSceneBuffers> &p_render_bu
 		for (uint32_t v = 0; v < view_count; v++) {
 			transforms[v] = p_xr_interface->get_transform_for_view(v, world_origin);
 			projections[v] = p_xr_interface->get_projection_for_view(v, aspect, camera->znear, camera->zfar);
-			Rect2 viewport = p_xr_interface->get_viewport_for_view(v);
-			if (viewport != Rect2()) {
-				viewports.push_back(p_xr_interface->get_viewport_for_view(v));
-			}
 		}
 
 		// If requested, we move the views to be rendered as if the HMD is at the XROrigin.
@@ -2695,7 +2690,7 @@ void RendererSceneCull::render_camera(const Ref<RenderSceneBuffers> &p_render_bu
 		if (view_count == 1) {
 			camera_data.set_camera(transforms[0], projections[0], false, false, camera->vaspect, jitter, p_jitter_phase_count, camera->visible_layers);
 		} else if (view_count == 2) {
-			camera_data.set_multiview_camera(view_count, transforms, projections, viewports, false, false, camera->vaspect);
+			camera_data.set_multiview_camera(view_count, transforms, projections, false, false, camera->vaspect);
 		}
 #endif // XR_DISABLED
 	}