RenderingDevice::texture_get_data doesn't handle compressed textures properly

[nikitalita]

Tested versions

current master @ 26cd27065

System information

Godot Engine v4.6.dev.custom_build.26cd27065 - macOS Sequoia (15.6.0) - Multi-window, 1 monitor - Metal (Forward+) - integrated Apple M4 Max (Apple9) - Apple M4 Max (16 threads) - 64.00 GiB memory

Issue description

according to @clayjohn :

Turns out we don't handle compressed textures properly in that function and we just read them as if they are laid out linearly in memory

As a result of this, the result of CompressedTexture2D::get_image() becomes non-deterministic if it's compressed and has mipmaps

Relevant PRs:
#108422
#111328

Steps to reproduce

Run the below MRP, observe stdout

Minimal reproduction project (MRP)

tex-non-deterministic-mrp.zip

[stuartcarnie]

This MRP does not exercise the RenderingDeviceDriver::texture_get_data, as it falls back to the following code:

godot/servers/rendering/rendering_device.cpp

Lines 1990 to 2083 in e267e28

	LocalVector<RDD::TextureCopyableLayout> mip_layouts;
	uint32_t work_mip_alignment = driver->api_trait_get(RDD::API_TRAIT_TEXTURE_TRANSFER_ALIGNMENT);
	uint32_t work_buffer_size = 0;
	mip_layouts.resize(tex->mipmaps);
	for (uint32_t i = 0; i < tex->mipmaps; i++) {
	RDD::TextureSubresource subres;
	subres.aspect = RDD::TEXTURE_ASPECT_COLOR;
	subres.layer = p_layer;
	subres.mipmap = i;
	driver->texture_get_copyable_layout(tex->driver_id, subres, &mip_layouts[i]);
	// Assuming layers are tightly packed. If this is not true on some driver, we must modify the copy algorithm.
	DEV_ASSERT(mip_layouts[i].layer_pitch == mip_layouts[i].size / tex->layers);
	work_buffer_size = STEPIFY(work_buffer_size, work_mip_alignment) + mip_layouts[i].size;
	}
	RDD::BufferID tmp_buffer = driver->buffer_create(work_buffer_size, RDD::BUFFER_USAGE_TRANSFER_TO_BIT, RDD::MEMORY_ALLOCATION_TYPE_CPU);
	ERR_FAIL_COND_V(!tmp_buffer, Vector<uint8_t>());
	thread_local LocalVector<RDD::BufferTextureCopyRegion> command_buffer_texture_copy_regions_vector;
	command_buffer_texture_copy_regions_vector.clear();
	uint32_t w = tex->width;
	uint32_t h = tex->height;
	uint32_t d = tex->depth;
	for (uint32_t i = 0; i < tex->mipmaps; i++) {
	RDD::BufferTextureCopyRegion copy_region;
	copy_region.buffer_offset = mip_layouts[i].offset;
	copy_region.texture_subresources.aspect = tex->read_aspect_flags;
	copy_region.texture_subresources.mipmap = i;
	copy_region.texture_subresources.base_layer = p_layer;
	copy_region.texture_subresources.layer_count = 1;
	copy_region.texture_region_size.x = w;
	copy_region.texture_region_size.y = h;
	copy_region.texture_region_size.z = d;
	command_buffer_texture_copy_regions_vector.push_back(copy_region);
	w = MAX(1u, w >> 1);
	h = MAX(1u, h >> 1);
	d = MAX(1u, d >> 1);
	}
	if (_texture_make_mutable(tex, p_texture)) {
	// The texture must be mutable to be used as a copy source due to layout transitions.
	draw_graph.add_synchronization();
	}
	draw_graph.add_texture_get_data(tex->driver_id, tex->draw_tracker, tmp_buffer, command_buffer_texture_copy_regions_vector);
	// Flush everything so memory can be safely mapped.
	_flush_and_stall_for_all_frames();
	const uint8_t *read_ptr = driver->buffer_map(tmp_buffer);
	ERR_FAIL_NULL_V(read_ptr, Vector<uint8_t>());
	uint32_t block_w = 0;
	uint32_t block_h = 0;
	get_compressed_image_format_block_dimensions(tex->format, block_w, block_h);
	Vector<uint8_t> buffer_data;
	uint32_t tight_buffer_size = get_image_format_required_size(tex->format, tex->width, tex->height, tex->depth, tex->mipmaps);
	buffer_data.resize(tight_buffer_size);
	uint8_t *write_ptr = buffer_data.ptrw();
	w = tex->width;
	h = tex->height;
	d = tex->depth;
	for (uint32_t i = 0; i < tex->mipmaps; i++) {
	uint32_t width = 0, height = 0, depth = 0;
	uint32_t tight_mip_size = get_image_format_required_size(tex->format, w, h, d, 1, &width, &height, &depth);
	uint32_t tight_row_pitch = tight_mip_size / ((height / block_h) * depth);
	// Copy row-by-row to erase padding due to alignments.
	const uint8_t *rp = read_ptr;
	uint8_t *wp = write_ptr;
	for (uint32_t row = h * d / block_h; row != 0; row--) {
	memcpy(wp, rp, tight_row_pitch);
	rp += mip_layouts[i].row_pitch;
	wp += tight_row_pitch;
	}
	w = MAX(block_w, w >> 1);
	h = MAX(block_h, h >> 1);
	d = MAX(1u, d >> 1);
	read_ptr += mip_layouts[i].size;
	write_ptr += tight_mip_size;
	}
	driver->buffer_unmap(tmp_buffer);
	driver->buffer_free(tmp_buffer);
	return buffer_data;

I suspect it will be an issue with the driver implementations of texture_get_copyable_layout

[nikitalita]

cc @blueskythlikesclouds