C++ TCacheEntryBase::OverlapsMemoryRange方法代码示例

TextureCacheBase::TCacheEntryBase* TextureCacheBase::DoPartialTextureUpdates(TexCache::iterator iter_t)
{
	TCacheEntryBase* entry_to_update = iter_t->second;
	const bool isPaletteTexture = (entry_to_update->format == GX_TF_C4
		|| entry_to_update->format == GX_TF_C8
		|| entry_to_update->format == GX_TF_C14X2
		|| entry_to_update->format >= 0x10000);

	// Efb copies and paletted textures are excluded from these updates, until there's an example where a game would
	// benefit from this. Both would require more work to be done.
	if (entry_to_update->IsEfbCopy()
		|| isPaletteTexture)
		return entry_to_update;

	u32 block_width = TexDecoder_GetBlockWidthInTexels(entry_to_update->format & 0xf);
	u32 block_height = TexDecoder_GetBlockHeightInTexels(entry_to_update->format & 0xf);
	u32 block_size = block_width * block_height * TexDecoder_GetTexelSizeInNibbles(entry_to_update->format & 0xf) / 2;

	u32 numBlocksX = (entry_to_update->native_width + block_width - 1) / block_width;

	TexCache::iterator iter = textures_by_address.lower_bound(entry_to_update->addr);
	TexCache::iterator iterend = textures_by_address.upper_bound(entry_to_update->addr + entry_to_update->size_in_bytes);
	while (iter != iterend)
	{
		TCacheEntryBase* entry = iter->second;
		if (entry != entry_to_update
			&& entry->IsEfbCopy()
			&& entry->OverlapsMemoryRange(entry_to_update->addr, entry_to_update->size_in_bytes)
			&& entry->frameCount == FRAMECOUNT_INVALID
			&& entry->memory_stride == numBlocksX * block_size)
		{
			if (entry->hash == entry->CalculateHash())
			{
				u32 src_x, src_y, dst_x, dst_y;

				// Note for understanding the math:
				// Normal textures can't be strided, so the 2 missing cases with src_x > 0 don't exist
				if (entry->addr >= entry_to_update->addr)
				{
					u32 block_offset = (entry->addr - entry_to_update->addr) / block_size;
					u32 block_x = block_offset % numBlocksX;
					u32 block_y = block_offset / numBlocksX;
					src_x = 0;
					src_y = 0;
					dst_x = block_x * block_width;
					dst_y = block_y * block_height;
				}
				else
				{
					u32 block_offset = (entry_to_update->addr - entry->addr) / block_size;
					u32 block_x = (~block_offset + 1) % numBlocksX;
					u32 block_y = (block_offset + block_x) / numBlocksX;
					src_x = 0;
					src_y = block_y * block_height;
					dst_x = block_x * block_width;
					dst_y = 0;
				}

				u32 copy_width = std::min(entry->native_width - src_x, entry_to_update->native_width - dst_x);
				u32 copy_height = std::min(entry->native_height - src_y, entry_to_update->native_height - dst_y);

				// If one of the textures is scaled, scale both with the current efb scaling factor
				if (entry_to_update->native_width != entry_to_update->config.width
					|| entry_to_update->native_height != entry_to_update->config.height
					|| entry->native_width != entry->config.width || entry->native_height != entry->config.height)
				{
					ScaleTextureCacheEntryTo(&entry_to_update, Renderer::EFBToScaledX(entry_to_update->native_width), Renderer::EFBToScaledY(entry_to_update->native_height));
					ScaleTextureCacheEntryTo(&entry, Renderer::EFBToScaledX(entry->native_width), Renderer::EFBToScaledY(entry->native_height));

					src_x = Renderer::EFBToScaledX(src_x);
					src_y = Renderer::EFBToScaledY(src_y);
					dst_x = Renderer::EFBToScaledX(dst_x);
					dst_y = Renderer::EFBToScaledY(dst_y);
					copy_width = Renderer::EFBToScaledX(copy_width);
					copy_height = Renderer::EFBToScaledY(copy_height);
				}

				MathUtil::Rectangle<int> srcrect, dstrect;
				srcrect.left = src_x;
				srcrect.top = src_y;
				srcrect.right = (src_x + copy_width);
				srcrect.bottom = (src_y + copy_height);
				dstrect.left = dst_x;
				dstrect.top = dst_y;
				dstrect.right = (dst_x + copy_width);
				dstrect.bottom = (dst_y + copy_height);
				entry_to_update->CopyRectangleFromTexture(entry, srcrect, dstrect);
				// Mark the texture update as used, so it isn't applied more than once
				entry->frameCount = frameCount;
			}
			else
			{
				// If the hash does not match, this EFB copy will not be used for anything, so remove it
				iter = FreeTexture(iter);
				continue;
			}
		}
		++iter;
	}
	return entry_to_update;
//.........这里部分代码省略.........

TextureCacheBase::TCacheEntryBase* TextureCacheBase::DoPartialTextureUpdates(TexCache::iterator iter_t, u8* palette, u32 tlutfmt)
{
	TCacheEntryBase* entry_to_update = iter_t->second;
	const bool isPaletteTexture = (entry_to_update->format == GX_TF_C4
		|| entry_to_update->format == GX_TF_C8
		|| entry_to_update->format == GX_TF_C14X2
		|| entry_to_update->format >= 0x10000);

	// EFB copies are excluded from these updates, until there's an example where a game would
	// benefit from updating. This would require more work to be done.
	if (entry_to_update->IsEfbCopy())
		return entry_to_update;

	u32 block_width = TexDecoder_GetBlockWidthInTexels(entry_to_update->format & 0xf);
	u32 block_height = TexDecoder_GetBlockHeightInTexels(entry_to_update->format & 0xf);
	u32 block_size = block_width * block_height * TexDecoder_GetTexelSizeInNibbles(entry_to_update->format & 0xf) / 2;

	u32 numBlocksX = (entry_to_update->native_width + block_width - 1) / block_width;

	TexCache::iterator iter = textures_by_address.lower_bound(entry_to_update->addr > MAX_TEXTURE_BINARY_SIZE ? entry_to_update->addr - MAX_TEXTURE_BINARY_SIZE : 0);
	TexCache::iterator iterend = textures_by_address.upper_bound(entry_to_update->addr + entry_to_update->size_in_bytes);
	while (iter != iterend)
	{
		TCacheEntryBase* entry = iter->second;
		if (entry != entry_to_update
			&& entry->IsEfbCopy()
			&& entry->references.count(entry_to_update) == 0
			&& entry->OverlapsMemoryRange(entry_to_update->addr, entry_to_update->size_in_bytes)
			&& entry->memory_stride == numBlocksX * block_size)
		{
			if (entry->hash == entry->CalculateHash())
			{
				if (isPaletteTexture)
				{
					TCacheEntryBase *decoded_entry = entry->ApplyPalette(palette, tlutfmt);
					if (decoded_entry)
					{
						// Link the efb copy with the partially updated texture, so we won't apply this partial update again
						entry->CreateReference(entry_to_update);
						// Mark the texture update as used, as if it was loaded directly
						entry->frameCount = FRAMECOUNT_INVALID;
						entry = decoded_entry;
					}
					else
					{
						++iter;
						continue;
					}
				}

				u32 src_x, src_y, dst_x, dst_y;

				// Note for understanding the math:
				// Normal textures can't be strided, so the 2 missing cases with src_x > 0 don't exist
				if (entry->addr >= entry_to_update->addr)
				{
					u32 block_offset = (entry->addr - entry_to_update->addr) / block_size;
					u32 block_x = block_offset % numBlocksX;
					u32 block_y = block_offset / numBlocksX;
					src_x = 0;
					src_y = 0;
					dst_x = block_x * block_width;
					dst_y = block_y * block_height;
				}
				else
				{
					u32 block_offset = (entry_to_update->addr - entry->addr) / block_size;
					u32 block_x = (~block_offset + 1) % numBlocksX;
					u32 block_y = (block_offset + block_x) / numBlocksX;
					src_x = 0;
					src_y = block_y * block_height;
					dst_x = block_x * block_width;
					dst_y = 0;
				}

				u32 copy_width = std::min(entry->native_width - src_x, entry_to_update->native_width - dst_x);
				u32 copy_height = std::min(entry->native_height - src_y, entry_to_update->native_height - dst_y);

				// If one of the textures is scaled, scale both with the current efb scaling factor
				if (entry_to_update->native_width != entry_to_update->config.width
					|| entry_to_update->native_height != entry_to_update->config.height
					|| entry->native_width != entry->config.width || entry->native_height != entry->config.height)
				{
					ScaleTextureCacheEntryTo(&entry_to_update, Renderer::EFBToScaledX(entry_to_update->native_width), Renderer::EFBToScaledY(entry_to_update->native_height));
					ScaleTextureCacheEntryTo(&entry, Renderer::EFBToScaledX(entry->native_width), Renderer::EFBToScaledY(entry->native_height));

					src_x = Renderer::EFBToScaledX(src_x);
					src_y = Renderer::EFBToScaledY(src_y);
					dst_x = Renderer::EFBToScaledX(dst_x);
					dst_y = Renderer::EFBToScaledY(dst_y);
					copy_width = Renderer::EFBToScaledX(copy_width);
					copy_height = Renderer::EFBToScaledY(copy_height);
				}

				MathUtil::Rectangle<int> srcrect, dstrect;
				srcrect.left = src_x;
				srcrect.top = src_y;
				srcrect.right = (src_x + copy_width);
				srcrect.bottom = (src_y + copy_height);
				dstrect.left = dst_x;
//.........这里部分代码省略.........

TextureCacheBase::TCacheEntryBase* TextureCacheBase::DoPartialTextureUpdates(TexCache::iterator iter_t)
{
	TCacheEntryBase* entry_to_update = iter_t->second;
	const bool isPaletteTexture = (entry_to_update->format == GX_TF_C4
		|| entry_to_update->format == GX_TF_C8
		|| entry_to_update->format == GX_TF_C14X2
		|| entry_to_update->format >= 0x10000);

	// Efb copies and paletted textures are excluded from these updates, until there's an example where a game would
	// benefit from this. Both would require more work to be done.
	// TODO: Implement upscaling support for normal textures, and then remove the efb to ram and the scaled efb restrictions
	if (entry_to_update->IsEfbCopy()
		|| isPaletteTexture)
		return entry_to_update;

	u32 block_width = TexDecoder_GetBlockWidthInTexels(entry_to_update->format & 0xf);
	u32 block_height = TexDecoder_GetBlockHeightInTexels(entry_to_update->format & 0xf);
	u32 block_size = block_width * block_height * TexDecoder_GetTexelSizeInNibbles(entry_to_update->format & 0xf) / 2;

	u32 numBlocksX = (entry_to_update->native_width + block_width - 1) / block_width;

	TexCache::iterator iter = textures_by_address.lower_bound(entry_to_update->addr);
	TexCache::iterator iterend = textures_by_address.upper_bound(entry_to_update->addr + entry_to_update->size_in_bytes);
	bool entry_need_scaling = g_ActiveConfig.bCopyEFBScaled;
	while (iter != iterend)
	{
		TCacheEntryBase* entry = iter->second;
		if (entry != entry_to_update
			&& entry->IsEfbCopy()
			&& entry->OverlapsMemoryRange(entry_to_update->addr, entry_to_update->size_in_bytes)
			&& entry->frameCount == FRAMECOUNT_INVALID
			&& entry->memory_stride == numBlocksX * block_size)
		{
			u32 src_x, src_y, dst_x, dst_y;
			MathUtil::Rectangle<s32> srcrect, dstrect;

			u32 block_offset = std::abs((s32)((entry->addr - entry_to_update->addr) / block_size));
			u32 block_x = block_offset % numBlocksX;
			u32 block_y = block_offset / numBlocksX;

			if (entry->addr >= entry_to_update->addr)
			{
				dst_x = block_x * block_width;
				dst_y = block_y * block_height;
				src_x = 0;
				src_y = 0;
			}
			else
			{
				src_x = block_x * block_width;
				src_y = block_y * block_height;
				dst_x = 0;
				dst_y = 0;
			}
			u32 copy_width = std::min(entry->native_width - src_x, entry_to_update->native_width - dst_x);
			u32 copy_height = std::min(entry->native_height - src_y, entry_to_update->native_height - dst_y);

			if (g_ActiveConfig.bCopyEFBScaled)
			{
				src_x = Renderer::EFBToScaledX(src_x);
				src_y = Renderer::EFBToScaledY(src_y);
				dst_x = Renderer::EFBToScaledX(dst_x);
				dst_y = Renderer::EFBToScaledY(dst_y);
				copy_width = Renderer::EFBToScaledX(copy_width);
				copy_height = Renderer::EFBToScaledY(copy_height);
			}
			if (entry_need_scaling)
			{
				entry_need_scaling = false;
				u32 w = Renderer::EFBToScaledX(entry_to_update->native_width);
				u32 h = Renderer::EFBToScaledX(entry_to_update->native_height);
				u32 max = g_renderer->GetMaxTextureSize();
				if (max < w || max < h)
				{
					iter++;
					continue;
				}
				if (entry_to_update->config.width != w || entry_to_update->config.height != h)
				{
					TextureCacheBase::TCacheEntryConfig newconfig;
					newconfig.width = w;
					newconfig.height = h;
					newconfig.rendertarget = true;
					TCacheEntryBase* newentry = AllocateTexture(newconfig);
					newentry->SetGeneralParameters(entry_to_update->addr, entry_to_update->size_in_bytes, entry_to_update->format);
					newentry->SetDimensions(entry_to_update->native_width, entry_to_update->native_height, 1);
					newentry->SetHashes(entry_to_update->hash, entry_to_update->base_hash);
					newentry->frameCount = frameCount;
					newentry->is_efb_copy = false;
					srcrect.left = 0;
					srcrect.top = 0;
					srcrect.right = entry_to_update->config.width;
					srcrect.bottom = entry_to_update->config.height;
					dstrect.left = 0;
					dstrect.top = 0;
					dstrect.right = w;
					dstrect.bottom = h;
					newentry->CopyRectangleFromTexture(entry_to_update, srcrect, dstrect);
					entry_to_update = newentry;
					u64 key = iter_t->first;
//.........这里部分代码省略.........