mirror of
https://github.com/PCSX2/pcsx2.git
synced 2026-11-17 19:44:19 +01:00
6553 lines
229 KiB
C++
6553 lines
229 KiB
C++
/* PCSX2 - PS2 Emulator for PCs
|
|
* Copyright (C) 2002-2021 PCSX2 Dev Team
|
|
*
|
|
* PCSX2 is free software: you can redistribute it and/or modify it under the terms
|
|
* of the GNU Lesser General Public License as published by the Free Software Found-
|
|
* ation, either version 3 of the License, or (at your option) any later version.
|
|
*
|
|
* PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with PCSX2.
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "PrecompiledHeader.h"
|
|
#include "GSTextureCache.h"
|
|
#include "GSTextureReplacements.h"
|
|
#include "GSRendererHW.h"
|
|
#include "GS/GSState.h"
|
|
#include "GS/GSGL.h"
|
|
#include "GS/GSPerfMon.h"
|
|
#include "GS/GSUtil.h"
|
|
#include "GS/GSXXH.h"
|
|
#include "common/BitUtils.h"
|
|
#include "common/HashCombine.h"
|
|
|
|
#ifdef __APPLE__
|
|
#include <stdlib.h>
|
|
#else
|
|
#include <malloc.h>
|
|
#endif
|
|
|
|
std::unique_ptr<GSTextureCache> g_texture_cache;
|
|
|
|
static u8* s_unswizzle_buffer;
|
|
|
|
/// List of candidates for purging when the hash cache gets too large.
|
|
static std::vector<std::pair<GSTextureCache::HashCacheMap::iterator, s32>> s_hash_cache_purge_list;
|
|
|
|
GSTextureCache::GSTextureCache()
|
|
{
|
|
// In theory 4MB is enough but 9MB is safer for overflow (8MB
|
|
// isn't enough in custom resolution)
|
|
// Test: onimusha 3 PAL 60Hz
|
|
s_unswizzle_buffer = (u8*)_aligned_malloc(9 * 1024 * 1024, VECTOR_ALIGNMENT);
|
|
pxAssertRel(s_unswizzle_buffer, "Failed to allocate unswizzle buffer");
|
|
|
|
m_surface_offset_cache.reserve(S_SURFACE_OFFSET_CACHE_MAX_SIZE);
|
|
}
|
|
|
|
GSTextureCache::~GSTextureCache()
|
|
{
|
|
RemoveAll(true, true, true);
|
|
|
|
s_hash_cache_purge_list = {};
|
|
_aligned_free(s_unswizzle_buffer);
|
|
}
|
|
|
|
void GSTextureCache::ReadbackAll()
|
|
{
|
|
for (int type = 0; type < 2; type++)
|
|
{
|
|
for (auto t : m_dst[type])
|
|
Read(t, t->m_drawn_since_read);
|
|
}
|
|
}
|
|
|
|
void GSTextureCache::RemoveAll(bool sources, bool targets, bool hash_cache)
|
|
{
|
|
if (sources || targets)
|
|
{
|
|
m_src.RemoveAll();
|
|
m_palette_map.Clear();
|
|
m_source_memory_usage = 0;
|
|
}
|
|
|
|
if (targets)
|
|
{
|
|
for (int type = 0; type < 2; type++)
|
|
{
|
|
for (auto t : m_dst[type])
|
|
delete t;
|
|
|
|
m_dst[type].clear();
|
|
}
|
|
|
|
m_target_heights.clear();
|
|
m_surface_offset_cache.clear();
|
|
m_target_memory_usage = 0;
|
|
}
|
|
|
|
if (hash_cache)
|
|
{
|
|
for (auto it : m_hash_cache)
|
|
g_gs_device->Recycle(it.second.texture);
|
|
|
|
m_hash_cache.clear();
|
|
m_hash_cache_memory_usage = 0;
|
|
m_hash_cache_replacement_memory_usage = 0;
|
|
}
|
|
}
|
|
|
|
bool GSTextureCache::FullRectDirty(Target* target, u32 rgba_mask)
|
|
{
|
|
// One complete dirty rect, not pieces (Add dirty rect function should be able to join these all together).
|
|
if (target->m_dirty.size() == 1 && (rgba_mask & target->m_dirty[0].rgba._u32) == rgba_mask && target->m_valid.rintersect(target->m_dirty[0].r).eq(target->m_valid))
|
|
{
|
|
if (rgba_mask == 0x8 && target->m_TEX0.PSM == PSMCT32)
|
|
{
|
|
target->m_valid_alpha_high = false;
|
|
target->m_valid_alpha_low = false;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool GSTextureCache::FullRectDirty(Target* target)
|
|
{
|
|
// Why?
|
|
if (target->m_age == 0)
|
|
return false;
|
|
|
|
return FullRectDirty(target, GSUtil::GetChannelMask(target->m_TEX0.PSM));
|
|
}
|
|
|
|
void GSTextureCache::AddDirtyRectTarget(Target* target, GSVector4i rect, u32 psm, u32 bw, RGBAMask rgba, bool req_linear)
|
|
{
|
|
bool skipdirty = false;
|
|
bool canskip = true;
|
|
|
|
if (rect.rempty())
|
|
return;
|
|
|
|
std::vector<GSDirtyRect>::iterator it = target->m_dirty.end();
|
|
while (it != target->m_dirty.begin())
|
|
{
|
|
--it;
|
|
if (it[0].bw == bw && it[0].psm == psm && it[0].rgba._u32 == rgba._u32)
|
|
{
|
|
if (it[0].r.rintersect(rect).eq(rect) && canskip)
|
|
{
|
|
skipdirty = true;
|
|
break;
|
|
}
|
|
|
|
// Edges lined up so just expand the dirty rect
|
|
if ((it[0].r.xzxz().eq(rect.xzxz()) && (it[0].r.wwww().eq(rect.yyyy()) || it[0].r.yyyy().eq(rect.wwww()))) ||
|
|
(it[0].r.ywyw().eq(rect.ywyw()) && (it[0].r.zzzz().eq(rect.xxxx()) || it[0].r.xxxx().eq(rect.zzzz()))) ||
|
|
it[0].r.rintersect(rect).eq(it[0].r)) // If the new rect completely envelops the old one.
|
|
{
|
|
rect = rect.runion(it[0].r);
|
|
it = target->m_dirty.erase(it);
|
|
canskip = false;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!skipdirty)
|
|
{
|
|
GL_INS("Dirty rect added for BP %x rect %d,%d->%d->%d", target->m_TEX0.TBP0, rect.x, rect.y, rect.z, rect.w);
|
|
target->m_dirty.push_back(GSDirtyRect(rect, psm, bw, rgba, req_linear));
|
|
|
|
if (!target->m_drawn_since_read.rempty())
|
|
{
|
|
// If we're covering the drawn area, clear it, in case of readback.
|
|
if (target->m_dirty[0].rgba._u32 == GSUtil::GetChannelMask(target->m_TEX0.PSM) && target->m_drawn_since_read.rintersect(target->m_dirty.GetTotalRect(target->m_TEX0, target->m_unscaled_size)).eq(target->m_drawn_since_read))
|
|
{
|
|
// Probably not completely covered and is still relevant, so don't wipe it.
|
|
if (target->m_dirty.size() > 1 && target->m_age == 0)
|
|
return;
|
|
|
|
target->m_drawn_since_read = GSVector4i::zero();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void GSTextureCache::ResizeTarget(Target* t, GSVector4i rect, u32 tbp, u32 psm, u32 tbw)
|
|
{
|
|
// Valid area isn't the whole texture anyway, no point in expanding.
|
|
if (t->m_valid.z < t->m_unscaled_size.x || t->m_valid.w < t->m_unscaled_size.y)
|
|
return;
|
|
|
|
const GSVector2i size_delta = { std::max(0, (rect.z - t->m_valid.z)), std::max(0, (rect.w - t->m_valid.w)) };
|
|
// If it's 1 row, it's probably the texture bounds accounting for bilinear, ignore it.
|
|
if (size_delta.x > 1 || size_delta.y > 1)
|
|
{
|
|
RGBAMask rgba;
|
|
rgba._u32 = GSUtil::GetChannelMask(t->m_TEX0.PSM);
|
|
// Dirty the expanded areas.
|
|
AddDirtyRectTarget(t, GSVector4i(t->m_valid.x, t->m_valid.w, t->m_valid.z + std::max(0, size_delta.x), t->m_valid.w + std::max(0, size_delta.y)), t->m_TEX0.PSM, t->m_TEX0.TBW, rgba);
|
|
AddDirtyRectTarget(t, GSVector4i(t->m_valid.z, t->m_valid.y, t->m_valid.z + std::max(0, size_delta.x), t->m_valid.w), t->m_TEX0.PSM, t->m_TEX0.TBW, rgba);
|
|
const GSVector4i valid_rect = { t->m_valid.x, t->m_valid.y, t->m_valid.z + std::max(0, size_delta.x), t->m_valid.w + std::max(0, size_delta.y) };
|
|
// Resizes of edges due to bilinear filtering and tex is rt could cause bad valid rects.
|
|
t->UpdateValidity(valid_rect, size_delta.x > 2 || size_delta.y > 2);
|
|
GetTargetSize(tbp, tbw, psm, valid_rect.z, valid_rect.w);
|
|
const int new_w = std::max(t->m_unscaled_size.x, valid_rect.z);
|
|
const int new_h = std::max(t->m_unscaled_size.y, valid_rect.w);
|
|
t->ResizeTexture(new_w, new_h);
|
|
}
|
|
}
|
|
|
|
|
|
bool GSTextureCache::CanTranslate(u32 bp, u32 bw, u32 spsm, GSVector4i r, u32 dbp, u32 dpsm, u32 dbw)
|
|
{
|
|
const GSVector2i src_page_size = GSLocalMemory::m_psm[spsm].pgs;
|
|
const GSVector2i dst_page_size = GSLocalMemory::m_psm[dpsm].pgs;
|
|
const bool bp_page_aligned_bp = ((bp & ~((1 << 5) - 1)) == bp) || bp == dbp;
|
|
const bool block_layout_match = GSLocalMemory::m_psm[spsm].bpp == GSLocalMemory::m_psm[dpsm].bpp;
|
|
const GSVector4i page_mask(GSVector4i((src_page_size.x - 1), (src_page_size.y - 1)).xyxy());
|
|
const GSVector4i masked_rect(r & ~page_mask);
|
|
const int src_pixel_width = static_cast<int>(bw * 64);
|
|
// We can do this if:
|
|
// The page width matches.
|
|
// The rect width is less than the width of the destination texture and the height is less than or equal to 1 page high.
|
|
// The rect width and height is equal to the page size and it covers the width of the incoming bw, so lines are sequential.
|
|
const bool page_aligned_rect = masked_rect.eq(r);
|
|
const bool width_match = ((bw * 64) / src_page_size.x) == ((dbw * 64) / dst_page_size.x);
|
|
const bool sequential_pages = page_aligned_rect && r.x == 0 && r.z == src_pixel_width;
|
|
const bool single_row = (((bw * 64) / src_page_size.x) <= ((dbw * 64) / dst_page_size.x)) && r.z <= src_pixel_width && r.w <= src_page_size.y;
|
|
|
|
if (block_layout_match)
|
|
{
|
|
// Same swizzle, so as long as the block is aligned and it's not a crazy size, we can translate it.
|
|
return bp_page_aligned_bp && (width_match || single_row || sequential_pages);
|
|
}
|
|
else
|
|
{
|
|
// If the format is different, the rect needs to additionally aligned to the pages.
|
|
return bp_page_aligned_bp && page_aligned_rect && (single_row || width_match || sequential_pages);
|
|
}
|
|
}
|
|
|
|
|
|
GSVector4i GSTextureCache::TranslateAlignedRectByPage(Target* t, u32 sbp, u32 spsm, u32 sbw, GSVector4i src_r, bool is_invalidation)
|
|
{
|
|
const GSVector2i src_page_size = GSLocalMemory::m_psm[spsm].pgs;
|
|
const GSVector2i dst_page_size = GSLocalMemory::m_psm[t->m_TEX0.PSM].pgs;
|
|
const int src_bw = static_cast<int>(std::max(1U, sbw) * 64);
|
|
const int dst_bw = static_cast<int>(std::max(1U, t->m_TEX0.TBW) * 64);
|
|
const int src_pgw = std::max(1, src_bw / src_page_size.x);
|
|
const int dst_pgw = std::max(1, dst_bw / dst_page_size.x);
|
|
GSVector4i in_rect = src_r;
|
|
|
|
if (sbp < t->m_end_block && t->m_end_block < t->m_TEX0.TBP0)
|
|
sbp += 0x4000;
|
|
|
|
int page_offset = (static_cast<int>(sbp) - static_cast<int>(t->m_TEX0.TBP0)) >> 5;
|
|
bool single_page = (in_rect.width() / src_page_size.x) <= 1 && (in_rect.height() / src_page_size.y) <= 1;
|
|
if (!single_page)
|
|
{
|
|
const int inc_vertical_offset = (page_offset / src_pgw) * src_page_size.y;
|
|
const int inc_horizontal_offset = (page_offset % src_pgw) * src_page_size.x;
|
|
in_rect = (in_rect + GSVector4i(0, inc_vertical_offset).xyxy()).max_i32(GSVector4i(0));
|
|
in_rect = (in_rect + GSVector4i(inc_horizontal_offset, 0).xyxy()).max_i32(GSVector4i(0));
|
|
page_offset = 0;
|
|
single_page = (in_rect.width() / src_page_size.x) <= 1 && (in_rect.height() / src_page_size.y) <= 1;
|
|
}
|
|
const int vertical_offset = (page_offset / dst_pgw) * dst_page_size.y;
|
|
int horizontal_offset = (page_offset % dst_pgw) * dst_page_size.x;
|
|
const GSVector4i rect_pages = GSVector4i(in_rect.x / src_page_size.x, in_rect.y / src_page_size.y, (in_rect.z + src_page_size.x - 1) / src_page_size.x, (in_rect.w + (src_page_size.y - 1)) / src_page_size.y);
|
|
const bool block_layout_match = GSLocalMemory::m_psm[spsm].bpp == GSLocalMemory::m_psm[t->m_TEX0.PSM].bpp;
|
|
GSVector4i new_rect = {};
|
|
|
|
if (src_pgw != dst_pgw || sbw == 0)
|
|
{
|
|
if (sbw == 0) // Intentionally check this separately
|
|
{
|
|
// BW == 0 loops vertically on the first page. So just copy the whole page vertically.
|
|
if (in_rect.z > dst_page_size.x)
|
|
{
|
|
new_rect.x = 0;
|
|
new_rect.z = (dst_page_size.x);
|
|
}
|
|
else
|
|
{
|
|
new_rect.x = in_rect.x;
|
|
new_rect.z = in_rect.z;
|
|
}
|
|
if (in_rect.w > dst_page_size.y)
|
|
{
|
|
new_rect.y = 0;
|
|
new_rect.w = dst_page_size.y;
|
|
}
|
|
else
|
|
{
|
|
new_rect.y = in_rect.y;
|
|
new_rect.w = in_rect.w;
|
|
}
|
|
}
|
|
else if (static_cast<int>(src_pgw) == rect_pages.width())
|
|
{
|
|
|
|
const int totalpages = rect_pages.width() * rect_pages.height();
|
|
const bool full_rows = in_rect.width() == (src_pgw * src_page_size.x);
|
|
const bool single_row = in_rect.x == 0 && in_rect.y == 0 && totalpages <= dst_pgw;
|
|
const bool uneven_pages = (horizontal_offset || (totalpages % dst_pgw) != 0) && !single_row;
|
|
|
|
// Less than or equal a page and the block layout matches, just copy the rect
|
|
if (block_layout_match && single_page)
|
|
{
|
|
new_rect = in_rect;
|
|
}
|
|
else if (uneven_pages)
|
|
{
|
|
// Results won't be square, if it's not invalidation, it's a texture, which is problematic to translate, so let's not (FIFA 2005).
|
|
if (!is_invalidation)
|
|
{
|
|
DevCon.Warning("Uneven pages mess up sbp %x dbp %x spgw %d dpgw %d", sbp, t->m_TEX0.TBP0, src_pgw, dst_pgw);
|
|
return GSVector4i::zero();
|
|
}
|
|
|
|
//TODO: Maybe control dirty blocks directly and add them page at a time for better granularity.
|
|
const u32 start_y_page = (rect_pages.y * src_pgw) / dst_pgw;
|
|
const u32 end_y_page = ((rect_pages.w * src_pgw) + (dst_pgw - 1)) / dst_pgw;
|
|
|
|
// Not easily translatable full pages and make sure the height is rounded upto encompass the half row.
|
|
horizontal_offset = 0;
|
|
new_rect.x = 0;
|
|
new_rect.z = (dst_pgw * dst_page_size.x);
|
|
new_rect.y = (start_y_page * dst_page_size.y);
|
|
new_rect.w = (end_y_page * dst_page_size.y);
|
|
}
|
|
else
|
|
{
|
|
const u32 start_y_page = (rect_pages.y * src_bw) / dst_bw;
|
|
// Full rows in original rect, so pages are sequential
|
|
if (single_row || full_rows)
|
|
{
|
|
new_rect.x = 0;
|
|
new_rect.z = std::min(totalpages * dst_page_size.x, dst_pgw * dst_page_size.x);
|
|
new_rect.y = start_y_page * dst_page_size.y;
|
|
new_rect.w = new_rect.y + (((totalpages + (dst_pgw - 1)) / dst_pgw) * dst_page_size.y);
|
|
}
|
|
else
|
|
{
|
|
DevCon.Warning("Panic! How did we get here?");
|
|
}
|
|
}
|
|
}
|
|
else if (single_page)
|
|
{
|
|
//The offsets will move this to the right place
|
|
new_rect = GSVector4i(rect_pages.x * dst_page_size.x, rect_pages.y * dst_page_size.y, rect_pages.z * dst_page_size.x, rect_pages.w * dst_page_size.y);
|
|
}
|
|
else
|
|
return GSVector4i::zero();
|
|
}
|
|
else
|
|
{
|
|
if (block_layout_match)
|
|
{
|
|
new_rect = in_rect;
|
|
// The width is mismatched to the page.
|
|
// Kinda scary but covering the whole row and the next one should be okay? :/ (Check with MVP 07, sbp == 0x39a0)
|
|
if (rect_pages.z > dst_pgw)
|
|
{
|
|
if (!is_invalidation)
|
|
return GSVector4i::zero();
|
|
|
|
// const u32 offset = rect_pages.z - (dst_pgw);
|
|
new_rect.x = 0;
|
|
new_rect.z = dst_pgw * dst_page_size.x;
|
|
new_rect.w += dst_page_size.y;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
new_rect = GSVector4i(rect_pages.x * dst_page_size.x, rect_pages.y * dst_page_size.y, rect_pages.z * dst_page_size.x, rect_pages.w * dst_page_size.y);
|
|
}
|
|
}
|
|
|
|
new_rect = (new_rect + GSVector4i(0, vertical_offset).xyxy()).max_i32(GSVector4i(0));
|
|
new_rect = (new_rect + GSVector4i(horizontal_offset, 0).xyxy()).max_i32(GSVector4i(0));
|
|
|
|
if (new_rect.z > (static_cast<int>(t->m_TEX0.TBW) * dst_page_size.x))
|
|
{
|
|
new_rect.z = (dst_pgw * dst_page_size.x);
|
|
new_rect.w += dst_page_size.y;
|
|
}
|
|
|
|
return new_rect;
|
|
}
|
|
|
|
void GSTextureCache::DirtyRectByPage(u32 sbp, u32 spsm, u32 sbw, Target* t, GSVector4i src_r)
|
|
{
|
|
if (src_r.rempty())
|
|
return;
|
|
|
|
const u32 start_bp = GSLocalMemory::GetStartBlockAddress(sbp, sbw, spsm, src_r);
|
|
const u32 end_bp = GSLocalMemory::GetEndBlockAddress(sbp, sbw, spsm, src_r);
|
|
GL_INS("Invalidating BP: 0x%x (%x -> %x) BW: %d PSM %s Target BP: 0x%x BW %x PSM %s", sbp, start_bp, end_bp, sbw, psm_str(spsm), t->m_TEX0.TBP0, t->m_TEX0.TBW, psm_str(t->m_TEX0.PSM));
|
|
|
|
// If the whole thing is covered, just invalidate the whole rect.
|
|
if (start_bp <= t->m_TEX0.TBP0 && end_bp >= t->UnwrappedEndBlock())
|
|
{
|
|
RGBAMask rgba;
|
|
rgba._u32 = GSUtil::GetChannelMask(spsm);
|
|
AddDirtyRectTarget(t, t->m_valid, t->m_TEX0.PSM, t->m_TEX0.TBW, rgba);
|
|
return;
|
|
}
|
|
|
|
GSLocalMemory::psm_t* src_info = &GSLocalMemory::m_psm[spsm];
|
|
const GSLocalMemory::psm_t* dst_info = &GSLocalMemory::m_psm[t->m_TEX0.PSM];
|
|
const int dst_width = std::max(static_cast<int>(t->m_TEX0.TBW * 64), 64);
|
|
|
|
int src_width = std::max(static_cast<int>(sbw * 64), 64);
|
|
int src_psm = spsm;
|
|
|
|
GSVector4i in_rect = src_r;
|
|
u32 target_bp = t->m_TEX0.TBP0;
|
|
int block_offset = static_cast<int>(sbp) - static_cast<int>(target_bp);
|
|
// Different format needs to be page aligned, unless the block layout matches, then we can block align
|
|
// Might be able to translate the original rect.
|
|
if (!(src_info->bpp == dst_info->bpp))
|
|
{
|
|
const int src_bpp = src_info->bpp;
|
|
|
|
if(block_offset)
|
|
in_rect = in_rect.ralign<Align_Outside>(src_info->bs);
|
|
else
|
|
in_rect = in_rect.ralign<Align_Outside>(src_info->pgs);
|
|
|
|
// Convert rect down in to pages and blocks.
|
|
const GSVector4i in_pages = GSVector4i(in_rect.x / src_info->pgs.x, in_rect.y / src_info->pgs.y, in_rect.z / src_info->pgs.x, in_rect.w / src_info->pgs.y);
|
|
in_rect -= GSVector4i(in_pages.x * src_info->pgs.x, in_pages.y * src_info->pgs.y, in_pages.z * src_info->pgs.x, in_pages.w * src_info->pgs.y);
|
|
// Handle a minimum of 1 block, they are a different shape between 16 and 32bit. 8x8 vs 16x8.
|
|
// FIXME: Block layouts are different between 32bit/8bit and other formats (8x4 instead of 4x8), so this could be a problem if the game invalidates too much.
|
|
const GSVector4i in_blocks = GSVector4i(in_rect.x / src_info->bs.x, in_rect.y / src_info->bs.y, (in_rect.z + (src_info->bs.x - 1)) / src_info->bs.x, (in_rect.w + (src_info->bs.y - 1)) / src_info->bs.y);
|
|
|
|
src_psm = t->m_TEX0.PSM;
|
|
src_info = &GSLocalMemory::m_psm[src_psm];
|
|
|
|
// Translate back to the new(dst) format.
|
|
in_rect = GSVector4i(in_pages.x * src_info->pgs.x, in_pages.y * src_info->pgs.y, in_pages.z * src_info->pgs.x, in_pages.w * src_info->pgs.y);
|
|
in_rect += GSVector4i(in_blocks.x * src_info->bs.x, in_blocks.y * src_info->bs.y, in_blocks.z * src_info->bs.x, in_blocks.w * src_info->bs.y);
|
|
|
|
if (in_rect.rempty())
|
|
return;
|
|
|
|
if (src_bpp < 16 || dst_info->bpp < 16)
|
|
{
|
|
// FIXME: This could break down if the width is 1 (64 pixels) as this is half a page in memory, but I don't have a good solution right now.
|
|
if (dst_info->bpp >= 16 && !(src_width & 127))
|
|
src_width = std::max(src_width / 2, 64);
|
|
else if (dst_info->bpp < 16)
|
|
src_width *= 2;
|
|
}
|
|
}
|
|
|
|
// This will round up pages for smaller formats such as PSMT8 and PSMT4.
|
|
// FIXME: Is this a problem? Does having buffer widths less than pages in size throw a real spanner in the works?
|
|
const int src_pg_width = std::max((src_width + (src_info->pgs.x - 1)) / src_info->pgs.x, 1);
|
|
const int dst_pg_width = std::max((dst_width + (dst_info->pgs.x - 1)) / dst_info->pgs.x, 1);
|
|
|
|
int page_offset = (block_offset) >> 5;
|
|
// remove any hoizontal offset, this is added back on later.
|
|
int start_page = page_offset + (src_r.x / src_info->pgs.x) + ((src_r.y / src_info->pgs.y) * std::max(static_cast<int>(sbw), 1));
|
|
const int horizontal_pages = (start_page % src_pg_width);
|
|
start_page -= horizontal_pages;
|
|
|
|
// Pages aligned.
|
|
const GSVector4i page_mask(GSVector4i((src_info->pgs.x - 1), (src_info->pgs.y - 1)).xyxy());
|
|
const GSVector4i page_masked_rect(in_rect & ~page_mask);
|
|
|
|
const bool page_aligned_rect = page_masked_rect.eq(in_rect);
|
|
|
|
// Blocks aligned.
|
|
const GSVector4i block_mask(GSVector4i((src_info->bs.x - 1), (src_info->bs.y - 1)).xyxy());
|
|
const GSVector4i block_masked_rect(in_rect & ~block_mask);
|
|
|
|
const bool block_aligned_rect = block_masked_rect.eq(in_rect);
|
|
|
|
int x_offset = 0;
|
|
int y_offset = 0;
|
|
|
|
// Deal with the page offset first, this will have the largest stride.
|
|
if (page_offset)
|
|
{
|
|
const int inc_vertical_offset = (page_offset / src_pg_width) * src_info->pgs.y;
|
|
const int inc_horizontal_offset = (page_offset % src_pg_width) * src_info->pgs.x;
|
|
in_rect = (in_rect + GSVector4i(0, inc_vertical_offset).xyxy()).max_i32(GSVector4i(0));
|
|
if (inc_horizontal_offset)
|
|
{
|
|
if (inc_horizontal_offset > 0)
|
|
{
|
|
const int max_horizontal_adjust = std::min(src_width - in_rect.z, inc_horizontal_offset);
|
|
in_rect = (in_rect + GSVector4i(max_horizontal_adjust, 0).xyxy()).max_i32(GSVector4i(0));
|
|
const int h_page_offset = (inc_horizontal_offset / src_info->pgs.x);
|
|
page_offset -= h_page_offset;
|
|
sbp -= h_page_offset << 5;
|
|
|
|
if (max_horizontal_adjust == 0)
|
|
x_offset = inc_horizontal_offset;
|
|
}
|
|
else if (inc_horizontal_offset < 0)
|
|
{
|
|
const int max_horizontal_adjust = std::min(in_rect.x, std::abs(inc_horizontal_offset));
|
|
in_rect = (in_rect - GSVector4i(max_horizontal_adjust, 0).xyxy()).max_i32(GSVector4i(0));
|
|
const int h_page_offset = (max_horizontal_adjust / src_info->pgs.x);
|
|
page_offset += h_page_offset;
|
|
sbp += h_page_offset << 5;
|
|
}
|
|
}
|
|
const int vertical_offset = (inc_vertical_offset / src_info->pgs.y) * src_pg_width;
|
|
page_offset -= vertical_offset;
|
|
|
|
sbp -= vertical_offset << 5;
|
|
// Update the block offset.
|
|
block_offset = static_cast<int>(sbp) - static_cast<int>(target_bp);
|
|
}
|
|
|
|
if (!x_offset)
|
|
start_page += horizontal_pages;
|
|
|
|
const bool matched_format = (src_info->bpp == dst_info->bpp);
|
|
const bool block_matched_format = matched_format && block_aligned_rect;
|
|
const bool req_depth_offset = (src_info->depth > 0 && !page_aligned_rect);
|
|
|
|
// If there is block offset left over, try to adjust to that.
|
|
if (block_matched_format && (block_offset || req_depth_offset))
|
|
{
|
|
if (block_offset > 0 || req_depth_offset)
|
|
{
|
|
const int xblocks = in_rect.width() / src_info->bs.x;
|
|
const int yblocks = in_rect.height() / src_info->bs.y;
|
|
// if !(block_offset & 0x7) is false, this is technically incorrect, but FFX hates it and starts making a mess, so it's better this way without adding complexity.
|
|
// TODO maybe: Add per block invalidation? ugh, would have to keep that to small blocks. 2 blocks in the case of FFX.
|
|
if ((xblocks <= 4 && yblocks <= 2) || req_depth_offset)
|
|
{
|
|
GSVector4i b2a_offset = GSVector4i::zero();
|
|
const GSVector4i target_rect = GSVector4i(0, 0, src_width, 2048);
|
|
bool offset_found = false;
|
|
|
|
for (b2a_offset.x = target_rect.x; b2a_offset.x < target_rect.z; b2a_offset.x += src_info->bs.x)
|
|
{
|
|
for (b2a_offset.y = target_rect.y; b2a_offset.y < target_rect.w; b2a_offset.y += src_info->bs.y)
|
|
{
|
|
const u32 a_candidate_bp = src_info->info.bn(b2a_offset.x, b2a_offset.y, target_bp, src_pg_width);
|
|
if (sbp == a_candidate_bp)
|
|
{
|
|
offset_found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (offset_found)
|
|
break;
|
|
}
|
|
|
|
if (offset_found)
|
|
{
|
|
if (b2a_offset.x && (b2a_offset.x + in_rect.z) > src_width)
|
|
{
|
|
if ((b2a_offset.x + in_rect.z) <= dst_width)
|
|
{
|
|
x_offset += b2a_offset.x;
|
|
}
|
|
|
|
b2a_offset.x = 0;
|
|
}
|
|
in_rect = (in_rect + b2a_offset.xyxy()).max_i32(GSVector4i(0));
|
|
|
|
if (block_offset > 0 && !req_depth_offset)
|
|
{
|
|
sbp = dst_info->info.bn(b2a_offset.x + x_offset, b2a_offset.y, target_bp, t->m_TEX0.TBW);
|
|
// Adjust the target BP to be pointing to the position without the offset.
|
|
target_bp = dst_info->info.bn(b2a_offset.x, b2a_offset.y, target_bp, t->m_TEX0.TBW);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
in_rect.x = in_rect.x & ~(src_info->pgs.x - 1);
|
|
in_rect.z = (in_rect.z + (src_info->pgs.x - 1)) & ~(src_info->pgs.x - 1);
|
|
in_rect.y = in_rect.y & ~(src_info->pgs.y - 1);
|
|
in_rect.w = (in_rect.w + (src_info->pgs.y - 1)) & ~(src_info->pgs.y - 1);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
in_rect.x = in_rect.x & ~(src_info->pgs.x - 1);
|
|
in_rect.z = (in_rect.z + (src_info->pgs.x - 1)) & ~(src_info->pgs.x - 1);
|
|
in_rect.y = in_rect.y & ~(src_info->pgs.y - 1);
|
|
in_rect.w = (in_rect.w + (src_info->pgs.y - 1)) & ~(src_info->pgs.y - 1);
|
|
}
|
|
}
|
|
|
|
// Match the space for the width of the buffer, based on 64 pixels (1 page) for all formats, except PSMT8/4 which is half.
|
|
// So multiply the others when comparing, so we don't lose "off by 1 width" comparison.
|
|
const int adjusted_src_width = (src_info->bpp >= 16) ? src_width * 2 : src_width;
|
|
const int adjusted_dst_width = (dst_info->bpp >= 16) ? dst_width * 2 : dst_width;
|
|
|
|
const bool width_okay = (adjusted_src_width == adjusted_dst_width) || (in_rect.z <= dst_width && in_rect.w <= src_info->pgs.y);
|
|
|
|
RGBAMask rgba;
|
|
rgba._u32 = GSUtil::GetChannelMask(spsm);
|
|
|
|
// Pick if we can do the fast or slow way.
|
|
if ((matched_format || page_aligned_rect || block_matched_format) && width_okay && sbp == target_bp)
|
|
{
|
|
in_rect = in_rect.rintersect(t->m_valid);
|
|
|
|
if (!in_rect.rempty())
|
|
AddDirtyRectTarget(t, in_rect, t->m_TEX0.PSM, t->m_TEX0.TBW, rgba);
|
|
}
|
|
else // Slow way.
|
|
{
|
|
const int page_draw = (std::max(src_info->pgs.x, in_rect.width()) + (src_info->pgs.x - 1)) / src_info->pgs.x;
|
|
const int page_skip = src_pg_width - page_draw;
|
|
const int vertical_pages = (std::max(src_info->pgs.y, in_rect.height()) / src_info->pgs.y);
|
|
const int horisontal_pages = (std::max(src_info->pgs.x, in_rect.width()) / src_info->pgs.x);
|
|
const int totalpages = vertical_pages * horisontal_pages + (page_skip * (vertical_pages-1));
|
|
const bool single_width = page_draw == 1;
|
|
|
|
// We can use the offset here for the X to pick the right function.
|
|
if (block_offset || req_depth_offset)
|
|
{
|
|
const int block_x = in_rect.x & (src_info->pgs.x - 1);
|
|
const int block_y = in_rect.y & (src_info->pgs.y - 1);
|
|
x_offset += block_x;
|
|
y_offset += block_y;
|
|
if(block_x)
|
|
in_rect = GSVector4i(in_rect.x - block_x, in_rect.y, in_rect.z - block_x, in_rect.w);
|
|
if (block_y)
|
|
in_rect = GSVector4i(in_rect.x, in_rect.y - block_y, in_rect.z, in_rect.w - block_y);
|
|
}
|
|
// Managed to page align everything, easier to deal with.
|
|
// If sbp is offset, make sure the target_bp is too, that means we've already dealt with the offset.
|
|
if ((!(sbp & 31) || sbp == target_bp) && !x_offset && (in_rect.z <= src_width || (in_rect.z % src_width) == 0) &&
|
|
(!(src_width & (src_info->pgs.x - 1)) || totalpages == 1) && !(in_rect.x & (src_info->pgs.x - 1)))
|
|
{
|
|
//const int start_page = (in_rect.x / src_info->pgs.x) + ((in_rect.y / src_info->pgs.y) * src_pg_width);
|
|
const int end_page = start_page + totalpages;
|
|
const int width = ((totalpages == 1 || single_width) && matched_format) ? in_rect.width() : dst_info->pgs.x;
|
|
const int height = (totalpages == 1 && matched_format) ? in_rect.height() : dst_info->pgs.y;
|
|
GSVector4i new_rect = GSVector4i::zero();
|
|
|
|
int drawn = 0;
|
|
for (int page = start_page; page < end_page; page++)
|
|
{
|
|
new_rect.x = x_offset + (page % dst_pg_width) * dst_info->pgs.x;
|
|
new_rect.z = new_rect.x + width;
|
|
new_rect.y = y_offset + (page / dst_pg_width) * dst_info->pgs.y;
|
|
new_rect.w = new_rect.y + height;
|
|
new_rect = new_rect.rintersect(t->m_valid);
|
|
|
|
if (!new_rect.rempty())
|
|
AddDirtyRectTarget(t, new_rect, t->m_TEX0.PSM, t->m_TEX0.TBW, rgba);
|
|
|
|
drawn++;
|
|
if (drawn == page_draw)
|
|
{
|
|
drawn = 0;
|
|
page += page_skip;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (in_rect.x & (dst_info->pgs.x - 1))
|
|
{
|
|
const u32 rect_off = (in_rect.x & (dst_info->pgs.x-1));
|
|
in_rect.x -= rect_off;
|
|
in_rect.z -= rect_off;
|
|
x_offset += rect_off;
|
|
}
|
|
if (in_rect.y & (dst_info->pgs.y - 1))
|
|
{
|
|
const u32 rect_off = (in_rect.y & (dst_info->pgs.y - 1));
|
|
in_rect.y -= rect_off;
|
|
in_rect.w -= rect_off;
|
|
y_offset += rect_off;
|
|
}
|
|
|
|
const int offset_pages = (x_offset / dst_info->pgs.x);
|
|
const int new_start_page = offset_pages + start_page;
|
|
const int end_page = new_start_page + totalpages;
|
|
const int width = ((totalpages == 1 || single_width) && matched_format) ? in_rect.width() : dst_info->pgs.x;
|
|
const int height = (totalpages == 1 && matched_format) ? in_rect.height() : dst_info->pgs.y;
|
|
|
|
GSVector4i new_rect = GSVector4i::zero();
|
|
x_offset -= offset_pages * dst_info->pgs.x;
|
|
|
|
int drawn = 0;
|
|
for (int page = new_start_page; page < end_page; page++)
|
|
{
|
|
int overflow = 0;
|
|
new_rect.x = x_offset + (page % dst_pg_width) * dst_info->pgs.x;
|
|
|
|
int x_end_pos = new_rect.x + width;
|
|
if (x_end_pos > dst_width)
|
|
{
|
|
overflow = x_end_pos - dst_width;
|
|
x_end_pos = dst_width;
|
|
}
|
|
new_rect.z = std::min(x_end_pos, dst_width);
|
|
new_rect.y = y_offset + (page / dst_pg_width) * dst_info->pgs.y;
|
|
new_rect.w = new_rect.y + height;
|
|
new_rect = new_rect.rintersect(t->m_valid);
|
|
|
|
if (!new_rect.rempty())
|
|
AddDirtyRectTarget(t, new_rect, t->m_TEX0.PSM, t->m_TEX0.TBW, rgba);
|
|
|
|
if (overflow)
|
|
{
|
|
new_rect.x = 0;
|
|
new_rect.z = overflow;
|
|
new_rect.y = ((page + 1) / dst_pg_width) * dst_info->pgs.y;
|
|
new_rect.w = new_rect.y + height;
|
|
new_rect = new_rect.rintersect(t->m_valid);
|
|
|
|
if (!new_rect.rempty())
|
|
AddDirtyRectTarget(t, new_rect, t->m_TEX0.PSM, t->m_TEX0.TBW, rgba);
|
|
}
|
|
|
|
drawn++;
|
|
if (drawn == page_draw)
|
|
{
|
|
drawn = 0;
|
|
page += page_skip;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
__ri static GSTextureCache::Source* FindSourceInMap(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA,
|
|
const GSLocalMemory::psm_t& psm_s, const u32* clut, const GSTexture* gpu_clut, const GSVector2i& compare_lod,
|
|
const GSTextureCache::SourceRegion& region, u32 fixed_tex0, FastList<GSTextureCache::Source*>& map)
|
|
{
|
|
for (auto i = map.begin(); i != map.end(); ++i)
|
|
{
|
|
GSTextureCache::Source* s = *i;
|
|
|
|
if (((TEX0.U32[0] ^ s->m_TEX0.U32[0]) | ((TEX0.U32[1] ^ s->m_TEX0.U32[1]) & 3)) != 0) // TBP0 TBW PSM TW TH
|
|
continue;
|
|
|
|
// Target are converted (AEM & palette) on the fly by the GPU. They don't need extra check
|
|
if (!s->m_target)
|
|
{
|
|
if (psm_s.pal > 0)
|
|
{
|
|
// If we're doing GPU CLUT, we don't want to use the CPU-converted version.
|
|
if (gpu_clut && !s->m_palette)
|
|
continue;
|
|
|
|
// We request a palette texture (psm_s.pal). If the texture was
|
|
// converted by the CPU (!s->m_palette), we need to ensure
|
|
// palette content is the same.
|
|
if (!s->m_palette && !s->ClutMatch({ clut, psm_s.pal }))
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
// We request a 24/16 bit RGBA texture. Alpha expansion was done by
|
|
// the CPU. We need to check that TEXA is identical
|
|
if (psm_s.fmt > 0 && s->m_TEXA.U64 != TEXA.U64)
|
|
continue;
|
|
}
|
|
|
|
// When fixed tex0 is used, we must find a matching region texture. The base likely
|
|
// doesn't contain to the correct region. Bit cheeky here, avoid a logical or by
|
|
// adding the invalid tex0 bit in.
|
|
if (((s->m_region.bits | fixed_tex0) != 0) && s->m_region.bits != region.bits)
|
|
continue;
|
|
|
|
// Same base mip texture, but we need to check that MXL was the same as well.
|
|
// When mipmapping is off, this will be 0,0 vs 0,0.
|
|
if (s->m_lod != compare_lod)
|
|
continue;
|
|
}
|
|
|
|
map.MoveFront(i.Index());
|
|
return s;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
GSTextureCache::Source* GSTextureCache::LookupDepthSource(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, const GIFRegCLAMP& CLAMP, const GSVector4i& r, const bool possible_shuffle, const bool linear, const u32 frame_fbp, bool req_color, bool req_alpha, bool palette)
|
|
{
|
|
if (GSConfig.UserHacks_DisableDepthSupport)
|
|
{
|
|
GL_CACHE("LookupDepthSource not supported (0x%x, F:0x%x)", TEX0.TBP0, TEX0.PSM);
|
|
return nullptr;
|
|
}
|
|
|
|
GL_CACHE("TC: Lookup Depth Source <%d,%d => %d,%d> (0x%x, %s, BW: %u, CBP: 0x%x, TW: %d, TH: %d)", r.x, r.y, r.z,
|
|
r.w, TEX0.TBP0, psm_str(TEX0.PSM), TEX0.TBW, TEX0.CBP, 1 << TEX0.TW, 1 << TEX0.TH);
|
|
|
|
const SourceRegion region = SourceRegion::Create(TEX0, CLAMP);
|
|
const GSLocalMemory::psm_t& psm_s = GSLocalMemory::m_psm[TEX0.PSM];
|
|
// Yes, this can get called with color PSMs that have palettes
|
|
const u32* const clut = g_gs_renderer->m_mem.m_clut;
|
|
GSTexture* const gpu_clut = (psm_s.pal > 0) ? g_gs_renderer->m_mem.m_clut.GetGPUTexture() : nullptr;
|
|
Source* src = FindSourceInMap(TEX0, TEXA, psm_s, clut, gpu_clut, GSVector2i(0, 0), region,
|
|
region.IsFixedTEX0(TEX0), m_src.m_map[TEX0.TBP0 >> 5]);
|
|
if (src)
|
|
{
|
|
GL_CACHE("TC: src hit: (0x%x, %s)", TEX0.TBP0, psm_str(TEX0.PSM));
|
|
src->Update(r);
|
|
return src;
|
|
}
|
|
|
|
Target* dst = nullptr;
|
|
|
|
// Check only current frame, I guess it is only used as a postprocessing effect
|
|
const u32 bp = TEX0.TBP0;
|
|
const u32 psm = TEX0.PSM;
|
|
bool inside_target = false;
|
|
GSVector4i target_rc;
|
|
|
|
for (auto t : m_dst[DepthStencil])
|
|
{
|
|
if (!t->m_used || !t->m_dirty.empty())
|
|
continue;
|
|
|
|
if (GSUtil::HasSharedBits(bp, psm, t->m_TEX0.TBP0, t->m_TEX0.PSM))
|
|
{
|
|
ASSERT(GSLocalMemory::m_psm[t->m_TEX0.PSM].depth);
|
|
if (t->m_age == 0)
|
|
{
|
|
// Perfect Match
|
|
dst = t;
|
|
inside_target = false;
|
|
break;
|
|
}
|
|
else if (t->m_age == 1)
|
|
{
|
|
// Better than nothing (Full Spectrum Warrior)
|
|
dst = t;
|
|
inside_target = false;
|
|
}
|
|
}
|
|
else if (!dst && bp >= t->m_TEX0.TBP0 && bp < t->m_end_block)
|
|
{
|
|
const GSVector2i page_size = GSLocalMemory::m_psm[t->m_TEX0.PSM].pgs;
|
|
const bool can_translate = CanTranslate(bp, TEX0.TBW, psm, r, t->m_TEX0.TBP0, t->m_TEX0.PSM, t->m_TEX0.TBW);
|
|
const bool swizzle_match = psm_s.depth == GSLocalMemory::m_psm[t->m_TEX0.PSM].depth;
|
|
GSVector4i new_rect = r;
|
|
|
|
if (linear)
|
|
{
|
|
new_rect.z -= 1;
|
|
new_rect.w -= 1;
|
|
}
|
|
|
|
if (can_translate)
|
|
{
|
|
if (swizzle_match)
|
|
{
|
|
target_rc = TranslateAlignedRectByPage(t, bp, psm, TEX0.TBW, new_rect);
|
|
}
|
|
else
|
|
{
|
|
// If it's not page aligned, grab the whole pages it covers, to be safe.
|
|
if (psm_s.bpp != GSLocalMemory::m_psm[t->m_TEX0.PSM].bpp)
|
|
{
|
|
const GSVector2i dst_page_size = psm_s.pgs;
|
|
target_rc = GSVector4i(target_rc.x / page_size.x, target_rc.y / page_size.y,
|
|
(target_rc.z + (page_size.x - 1)) / page_size.x,
|
|
(target_rc.w + (page_size.y - 1)) / page_size.y);
|
|
target_rc = GSVector4i(target_rc.x * dst_page_size.x, target_rc.y * dst_page_size.y,
|
|
target_rc.z * dst_page_size.x, target_rc.w * dst_page_size.y);
|
|
}
|
|
else
|
|
{
|
|
target_rc.x &= ~(page_size.x - 1);
|
|
target_rc.y &= ~(page_size.y - 1);
|
|
target_rc.z = (new_rect.z + (page_size.x - 1)) & ~(page_size.x - 1);
|
|
target_rc.w = (new_rect.w + (page_size.y - 1)) & ~(page_size.y - 1);
|
|
}
|
|
target_rc = TranslateAlignedRectByPage(t, bp & ~((1 << 5) - 1), psm, TEX0.TBW, target_rc);
|
|
}
|
|
|
|
if (!target_rc.rempty())
|
|
{
|
|
dst = t;
|
|
inside_target = true;
|
|
}
|
|
}
|
|
if (linear)
|
|
{
|
|
new_rect.z += 1;
|
|
new_rect.w += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dst && psm_s.trbpp != 24 && !dst->HasValidAlpha())
|
|
{
|
|
for (Target* t : m_dst[RenderTarget])
|
|
{
|
|
if (t->m_age <= 1 && t->m_TEX0.TBP0 == bp && t->m_TEX0.TBW == TEX0.TBW && t->HasValidAlpha())
|
|
{
|
|
GL_CACHE("TC depth: Using RT %x instead of depth because of missing alpha", t->m_TEX0.TBP0);
|
|
|
|
// Have to update here, because this is a source, it won't Update().
|
|
if (FullRectDirty(t, 0x7))
|
|
t->Update();
|
|
else if (!t->m_valid_rgb)
|
|
CopyRGBFromDepthToColor(t, dst);
|
|
|
|
dst = t;
|
|
inside_target = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!dst)
|
|
{
|
|
// Retry on the render target (Silent Hill 4)
|
|
for (auto t : m_dst[RenderTarget])
|
|
{
|
|
// FIXME: do I need to allow m_age == 1 as a potential match (as DepthStencil) ???
|
|
if (t->m_age <= 1 && t->m_used && t->m_dirty.empty() && GSUtil::HasSharedBits(bp, psm, t->m_TEX0.TBP0, t->m_TEX0.PSM))
|
|
{
|
|
ASSERT(GSLocalMemory::m_psm[t->m_TEX0.PSM].depth);
|
|
dst = t;
|
|
inside_target = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dst)
|
|
{
|
|
GL_CACHE("TC depth: dst %s hit: (0x%x, %s)", to_string(dst->m_type),
|
|
TEX0.TBP0, psm_str(psm));
|
|
|
|
// Create a shared texture source
|
|
src = new Source(TEX0, TEXA);
|
|
src->m_texture = dst->m_texture;
|
|
src->m_scale = dst->m_scale;
|
|
src->m_unscaled_size = dst->m_unscaled_size;
|
|
src->m_shared_texture = true;
|
|
src->m_target = true; // So renderer can check if a conversion is required
|
|
src->m_from_target = dst; // avoid complex condition on the renderer
|
|
src->m_from_target_TEX0 = dst->m_TEX0;
|
|
src->m_32_bits_fmt = dst->m_32_bits_fmt;
|
|
src->m_valid_rect = dst->m_valid;
|
|
src->m_end_block = dst->m_end_block;
|
|
|
|
if (inside_target)
|
|
{
|
|
// Need to set it up as a region target.
|
|
src->m_region.SetX(target_rc.x, target_rc.z);
|
|
src->m_region.SetY(target_rc.y, target_rc.w);
|
|
}
|
|
|
|
if (GSRendererHW::GetInstance()->IsTBPFrameOrZ(dst->m_TEX0.TBP0))
|
|
{
|
|
m_temporary_source = src;
|
|
}
|
|
else
|
|
{
|
|
src->SetPages();
|
|
m_src.Add(src, TEX0);
|
|
}
|
|
|
|
if (palette)
|
|
{
|
|
AttachPaletteToSource(src, psm_s.pal, true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// This is a bit of a worry, since it could load junk from local memory... but it's better than skipping the draw.
|
|
return LookupSource(TEX0, TEXA, CLAMP, r, nullptr, possible_shuffle, linear, frame_fbp, req_color, req_alpha);
|
|
}
|
|
|
|
ASSERT(src->m_texture);
|
|
ASSERT(src->m_scale == (dst ? dst->m_scale : 1.0f));
|
|
|
|
return src;
|
|
}
|
|
|
|
GSTextureCache::Source* GSTextureCache::LookupSource(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, const GIFRegCLAMP& CLAMP, const GSVector4i& r, const GSVector2i* lod, const bool possible_shuffle, const bool linear, const u32 frame_fbp, bool req_color, bool req_alpha)
|
|
{
|
|
GL_CACHE("TC: Lookup Source <%d,%d => %d,%d> (0x%x, %s, BW: %u, CBP: 0x%x, TW: %d, TH: %d)", r.x, r.y, r.z, r.w, TEX0.TBP0, psm_str(TEX0.PSM), TEX0.TBW, TEX0.CBP, 1 << TEX0.TW, 1 << TEX0.TH);
|
|
|
|
const GSLocalMemory::psm_t& psm_s = GSLocalMemory::m_psm[TEX0.PSM];
|
|
//const GSLocalMemory::psm_t& cpsm = psm.pal > 0 ? GSLocalMemory::m_psm[TEX0.CPSM] : psm;
|
|
|
|
const u32* const clut = g_gs_renderer->m_mem.m_clut;
|
|
GSTexture* const gpu_clut = (psm_s.pal > 0) ? g_gs_renderer->m_mem.m_clut.GetGPUTexture() : nullptr;
|
|
|
|
const SourceRegion region = SourceRegion::Create(TEX0, CLAMP);
|
|
|
|
// Prevent everything going to rubbish if a game somehow sends a TW/TH above 10, and region isn't being used.
|
|
if ((TEX0.TW > 10 && !region.HasX()) || (TEX0.TH > 10 && !region.HasY()))
|
|
{
|
|
GL_CACHE("Invalid TEX0 size %ux%u without region, aborting draw.", TEX0.TW, TEX0.TH);
|
|
return nullptr;
|
|
}
|
|
|
|
const GSVector2i compare_lod(lod ? *lod : GSVector2i(0, 0));
|
|
Source* src = nullptr;
|
|
|
|
// Region textures might be placed in a different page, so check that first.
|
|
const u32 lookup_page = TEX0.TBP0 >> 5;
|
|
const bool is_fixed_tex0 = region.IsFixedTEX0(1 << TEX0.TW, 1 << TEX0.TH);
|
|
if (region.GetMinX() != 0 || region.GetMinY() != 0)
|
|
{
|
|
const GSOffset offset(psm_s.info, TEX0.TBP0, TEX0.TBW, TEX0.PSM);
|
|
const u32 region_page = offset.bn(region.GetMinX(), region.GetMinY()) >> 5;
|
|
if (lookup_page != region_page)
|
|
src = FindSourceInMap(TEX0, TEXA, psm_s, clut, gpu_clut, compare_lod, region, is_fixed_tex0, m_src.m_map[region_page]);
|
|
}
|
|
if (!src)
|
|
src = FindSourceInMap(TEX0, TEXA, psm_s, clut, gpu_clut, compare_lod, region, is_fixed_tex0, m_src.m_map[lookup_page]);
|
|
|
|
|
|
Target* dst = nullptr;
|
|
bool half_right = false;
|
|
int x_offset = 0;
|
|
int y_offset = 0;
|
|
|
|
#ifdef DISABLE_HW_TEXTURE_CACHE
|
|
if (0)
|
|
#else
|
|
if (!src && (GSConfig.UserHacks_CPUFBConversion || TEX0.PSM != PSMT4))
|
|
#endif
|
|
{
|
|
const u32 bp = TEX0.TBP0;
|
|
const u32 psm = TEX0.PSM;
|
|
const u32 bw = TEX0.TBW;
|
|
|
|
// Arc the Lad finds the wrong surface here when looking for a depth stencil.
|
|
// Since we're currently not caching depth stencils (check ToDo in CreateSource) we should not look for it here.
|
|
|
|
// (Simply not doing this code at all makes a lot of previsouly missing stuff show (but breaks pretty much everything
|
|
// else.)
|
|
|
|
bool found_t = false;
|
|
bool tex_merge_rt = false;
|
|
auto& list = m_dst[RenderTarget];
|
|
for (auto i = list.begin(); i != list.end(); ++i)
|
|
{
|
|
Target* t = *i;
|
|
// Make sure it is page aligned, otherwise things get messy with the pixel order (Tomb Raider Legend).
|
|
if (t->m_used)
|
|
{
|
|
// If the BP is block offset it's unlikely to be a target, but a target can be made by a HW move, so we need to check for a match.
|
|
// Good for Baldurs Gate Dark Alliance (HW Move), bad for Tomb Raider Legends (just offset).
|
|
if (((bp & (BLOCKS_PER_PAGE - 1)) != (t->m_TEX0.TBP0 & (BLOCKS_PER_PAGE - 1))) && (bp & (BLOCKS_PER_PAGE - 1)))
|
|
continue;
|
|
|
|
const bool overlaps = t->Overlaps(bp, bw, psm, r);
|
|
|
|
// Try to make sure the target has available what we need, be careful of self referencing frames with font in the alpha.
|
|
if (overlaps && !t->HasValidBitsForFormat(psm, req_color, req_alpha) && !(possible_shuffle && GSLocalMemory::m_psm[psm].bpp == 16 && GSLocalMemory::m_psm[t->m_TEX0.PSM].bpp == 32))
|
|
continue;
|
|
|
|
const bool width_match = (std::max(64U, bw * 64U) >> GSLocalMemory::m_psm[psm].info.pageShiftX()) ==
|
|
(std::max(64U, t->m_TEX0.TBW * 64U) >> GSLocalMemory::m_psm[t->m_TEX0.PSM].info.pageShiftX());
|
|
|
|
if (bp == t->m_TEX0.TBP0 && !t->m_dirty.empty() && overlaps && GSUtil::GetChannelMask(psm) == GSUtil::GetChannelMask(t->m_TEX0.PSM) && GSRendererHW::GetInstance()->m_draw_transfers.size() > 0)
|
|
{
|
|
bool can_use = true;
|
|
|
|
if (!possible_shuffle && !(GSLocalMemory::m_psm[TEX0.PSM].bpp == 16 && GSLocalMemory::m_psm[t->m_TEX0.PSM].bpp == 32) && !width_match && t->m_dirty.size() >= 1 && !t->m_dirty.GetTotalRect(t->m_TEX0, t->m_unscaled_size).eq(t->m_valid))
|
|
{
|
|
std::vector<GSState::GSUploadQueue>::reverse_iterator iter;
|
|
|
|
const int start_draw = GSRendererHW::GetInstance()->m_draw_transfers.back().draw;
|
|
|
|
for (iter = GSRendererHW::GetInstance()->m_draw_transfers.rbegin(); iter != GSRendererHW::GetInstance()->m_draw_transfers.rend(); )
|
|
{
|
|
if (TEX0.TBP0 == iter->blit.DBP && GSUtil::HasCompatibleBits(iter->blit.DPSM, TEX0.PSM) && r.rintersect(iter->rect).eq(r))
|
|
{
|
|
can_use = false;
|
|
break;
|
|
}
|
|
|
|
// Give up after checking recent draws
|
|
if (start_draw - iter->draw > 0)
|
|
break;
|
|
|
|
++iter;
|
|
}
|
|
}
|
|
|
|
if (!can_use)
|
|
{
|
|
InvalidateSourcesFromTarget(t);
|
|
i = list.erase(i);
|
|
delete t;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Typical bug (MGS3 blue cloud):
|
|
// 1/ RT used as 32 bits => alpha channel written
|
|
// 2/ RT used as 24 bits => no update of alpha channel
|
|
// 3/ Lookup of texture that used alpha channel as index, HasSharedBits will return false
|
|
// because of the previous draw call format
|
|
//
|
|
// Solution: consider the RT as 32 bits if the alpha was used in the past
|
|
// We can render to the target as C32, but mask alpha, in which case, pretend like it doesn't have any.
|
|
const u32 t_psm = t->HasValidAlpha() ? t->m_TEX0.PSM & ~0x1 : ((t->m_TEX0.PSM == PSMCT32) ? PSMCT24 : t->m_TEX0.PSM);
|
|
bool rect_clean = GSUtil::HasSameSwizzleBits(psm, t_psm) || (t_psm == PSMCT32 && GSLocalMemory::m_psm[psm].bpp == 16 && possible_shuffle);
|
|
const bool tex_overlaps = bp >= t->m_TEX0.TBP0 && bp < t->UnwrappedEndBlock();
|
|
const bool real_fmt_match = (GSLocalMemory::m_psm[psm].trbpp == 16) == (t->m_32_bits_fmt == false);
|
|
if (rect_clean && tex_overlaps && !t->m_dirty.empty() && width_match)
|
|
{
|
|
GSVector4i new_rect = r;
|
|
|
|
if (linear)
|
|
{
|
|
new_rect.z -= 1;
|
|
new_rect.w -= 1;
|
|
}
|
|
|
|
bool partial = false;
|
|
// If it's compatible and page aligned, then handle it this way.
|
|
// It's quicker, and Surface Offsets can get it wrong.
|
|
// Example doing PSMT8H to C32, BP 0x1c80, TBP 0x1d80, incoming rect 0,128 -> 128,256
|
|
// Surface offsets translates it to 0, 128 -> 128, 128, not 0, 0 -> 128, 128.
|
|
if (bp > t->m_TEX0.TBP0)
|
|
{
|
|
const GSVector2i page_size = GSLocalMemory::m_psm[t->m_TEX0.PSM].pgs;
|
|
const bool can_translate = CanTranslate(bp, bw, psm, new_rect, t->m_TEX0.TBP0, t->m_TEX0.PSM, t->m_TEX0.TBW);
|
|
const bool swizzle_match = GSLocalMemory::m_psm[psm].depth == GSLocalMemory::m_psm[t->m_TEX0.PSM].depth;
|
|
|
|
if (can_translate)
|
|
{
|
|
if (swizzle_match)
|
|
{
|
|
new_rect = TranslateAlignedRectByPage(t, bp, psm, bw, new_rect);
|
|
}
|
|
else
|
|
{
|
|
// If it's not page aligned, grab the whole pages it covers, to be safe.
|
|
if (GSLocalMemory::m_psm[psm].bpp != GSLocalMemory::m_psm[t->m_TEX0.PSM].bpp)
|
|
{
|
|
const GSVector2i dst_page_size = GSLocalMemory::m_psm[psm].pgs;
|
|
new_rect = GSVector4i(new_rect.x / page_size.x, new_rect.y / page_size.y, (new_rect.z + (page_size.x - 1)) / page_size.x, (new_rect.w + (page_size.y - 1)) / page_size.y);
|
|
new_rect = GSVector4i(new_rect.x * dst_page_size.x, new_rect.y * dst_page_size.y, new_rect.z * dst_page_size.x, new_rect.w * dst_page_size.y);
|
|
}
|
|
else
|
|
{
|
|
new_rect.x &= ~(page_size.x - 1);
|
|
new_rect.y &= ~(page_size.y - 1);
|
|
new_rect.z = (new_rect.z + (page_size.x - 1)) & ~(page_size.x - 1);
|
|
new_rect.w = (new_rect.w + (page_size.y - 1)) & ~(page_size.y - 1);
|
|
}
|
|
new_rect = TranslateAlignedRectByPage(t, bp & ~((1 << 5) - 1), psm, bw, new_rect);
|
|
}
|
|
|
|
rect_clean = !new_rect.eq(GSVector4i::zero());
|
|
}
|
|
else
|
|
{
|
|
SurfaceOffsetKey sok;
|
|
sok.elems[0].bp = bp;
|
|
sok.elems[0].bw = bw;
|
|
sok.elems[0].psm = psm;
|
|
sok.elems[0].rect = new_rect;
|
|
sok.elems[1].bp = t->m_TEX0.TBP0;
|
|
sok.elems[1].bw = t->m_TEX0.TBW;
|
|
sok.elems[1].psm = t->m_TEX0.PSM;
|
|
sok.elems[1].rect = t->m_valid;
|
|
|
|
const SurfaceOffset so = ComputeSurfaceOffset(sok);
|
|
if (so.is_valid)
|
|
{
|
|
new_rect = so.b2a_offset;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (rect_clean)
|
|
{
|
|
for (auto& dirty : t->m_dirty)
|
|
{
|
|
GSVector4i dirty_rect = dirty.GetDirtyRect(t->m_TEX0, true);
|
|
if (!dirty_rect.rintersect(new_rect).rempty())
|
|
{
|
|
rect_clean = false;
|
|
partial |= !new_rect.rintersect(dirty_rect).eq(new_rect);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
const u32 channel_mask = GSUtil::GetChannelMask(psm);
|
|
const u32 channels = t->m_dirty.GetDirtyChannels() & channel_mask;
|
|
|
|
// If the source is reading the rt, make sure it's big enough.
|
|
if (!possible_shuffle && t && GSUtil::HasCompatibleBits(psm, t->m_TEX0.PSM) && real_fmt_match)
|
|
{
|
|
if (t->Overlaps(bp, bw, psm, new_rect))
|
|
ResizeTarget(t, new_rect, bp, psm, bw);
|
|
}
|
|
// If not all channels are clean/dirty or only part of the rect is dirty, we need to update the target.
|
|
if (((channels & channel_mask) != channel_mask || partial))
|
|
t->Update();
|
|
|
|
if (linear)
|
|
{
|
|
new_rect.z += 1;
|
|
new_rect.w += 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rect_clean = t->m_dirty.empty();
|
|
if (!possible_shuffle && rect_clean && bp == t->m_TEX0.TBP0 && t && GSUtil::HasCompatibleBits(psm, t->m_TEX0.PSM) && width_match && real_fmt_match)
|
|
{
|
|
if (t->Overlaps(bp, bw, psm, r))
|
|
ResizeTarget(t, r, bp, psm, bw);
|
|
}
|
|
}
|
|
|
|
if (t->m_TEX0.TBP0 != frame_fbp && !possible_shuffle && bp > t->m_TEX0.TBP0 && t->Overlaps(bp, bw, psm, r) && GSUtil::GetChannelMask(psm) == GSUtil::GetChannelMask(t->m_TEX0.PSM) && !width_match)
|
|
{
|
|
GSVector4i new_rect = r;
|
|
|
|
if (linear)
|
|
{
|
|
new_rect.z -= 1;
|
|
new_rect.w -= 1;
|
|
}
|
|
|
|
const GSLocalMemory::psm_t* src_info = &GSLocalMemory::m_psm[psm];
|
|
const int block_offset = static_cast<int>(bp) - static_cast<int>(t->m_TEX0.TBP0);
|
|
const int page_offset = (block_offset) >> 5;
|
|
const int start_page = page_offset + (new_rect.x / src_info->pgs.x) + ((new_rect.y / src_info->pgs.y) * std::max(static_cast<int>(bw), 1));
|
|
const int src_page_width = std::max(static_cast<int>((bw * 64) / src_info->pgs.x), 1);
|
|
const int dst_page_width = std::max(static_cast<int>((t->m_TEX0.TBW * 64) / GSLocalMemory::m_psm[t->m_TEX0.PSM].pgs.x), 1);
|
|
if (((start_page % dst_page_width) + src_page_width) > dst_page_width)
|
|
{
|
|
const u32 read_start = GSLocalMemory::GetStartBlockAddress(bp, bw, psm, new_rect);
|
|
const u32 read_end = GSLocalMemory::GetEndBlockAddress(bp, bw, psm, new_rect);
|
|
|
|
if (read_start > t->m_TEX0.TBP0 && read_end < t->m_end_block)
|
|
{
|
|
// Probably a bad overlapping target.
|
|
InvalidateSourcesFromTarget(t);
|
|
i = list.erase(i);
|
|
delete t;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
const bool t_clean = ((t->m_dirty.GetDirtyChannels() & GSUtil::GetChannelMask(psm)) == 0) || rect_clean;
|
|
const u32 color_psm = ((psm & 0x30) == 0x30) ? (psm & ~0x30) : psm;
|
|
const u32 tex_color_psm = ((t->m_TEX0.PSM & 0x30) == 0x30) ? (t->m_TEX0.PSM & ~0x30) : t->m_TEX0.PSM;
|
|
// Match if we haven't already got a tex in rt
|
|
if (t_clean && GSUtil::HasSharedBits(bp, psm, t->m_TEX0.TBP0, t_psm))
|
|
{
|
|
bool match = true;
|
|
if (found_t && (bw != t->m_TEX0.TBW || t->m_TEX0.PSM != psm))
|
|
match = false;
|
|
|
|
if (match)
|
|
{
|
|
// It is a complex to convert the code in shader. As a reference, let's do it on the CPU, it will be slow but
|
|
// 1/ it just works :)
|
|
// 2/ even with upscaling
|
|
// 3/ for both Direct3D and OpenGL
|
|
if (GSConfig.UserHacks_CPUFBConversion && (psm == PSMT4 || psm == PSMT8))
|
|
{
|
|
// Forces 4-bit and 8-bit frame buffer conversion to be done on the CPU instead of the GPU, but performance will be slower.
|
|
// There is no dedicated shader to handle 4-bit conversion (Stuntman has been confirmed to use 4-bit).
|
|
// Direct3D10/11 and OpenGL support 8-bit fb conversion but don't render some corner cases properly (Harry Potter games).
|
|
// The hack can fix glitches in some games.
|
|
if (!t->m_drawn_since_read.rempty())
|
|
{
|
|
Read(t, t->m_drawn_since_read);
|
|
|
|
t->m_drawn_since_read = GSVector4i::zero();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// We don't have a shader for this.
|
|
if (!possible_shuffle && TEX0.PSM == PSMT8 && GSLocalMemory::m_psm[t->m_TEX0.PSM].bpp != 32)
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
dst = t;
|
|
|
|
found_t = true;
|
|
tex_merge_rt = false;
|
|
x_offset = 0;
|
|
y_offset = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (t_clean && (t->m_TEX0.TBW >= 16) && GSUtil::HasSharedBits(bp, psm, t->m_TEX0.TBP0 + t->m_TEX0.TBW * 0x10, t->m_TEX0.PSM))
|
|
{
|
|
// Detect half of the render target (fix snow engine game)
|
|
// Target Page (8KB) have always a width of 64 pixels
|
|
// Half of the Target is TBW/2 pages * 8KB / (1 block * 256B) = 0x10
|
|
half_right = true;
|
|
dst = t;
|
|
found_t = true;
|
|
tex_merge_rt = false;
|
|
x_offset = 0;
|
|
y_offset = 0;
|
|
break;
|
|
}
|
|
// Make sure the texture actually is INSIDE the RT, it's possibly not valid if it isn't.
|
|
// Also check BP >= TBP, create source isn't equpped to expand it backwards and all data comes from the target. (GH3)
|
|
else if (GSConfig.UserHacks_TextureInsideRt >= GSTextureInRtMode::InsideTargets && color_psm >= PSMCT32 &&
|
|
color_psm <= PSMCT16S && (GSUtil::HasCompatibleBits(tex_color_psm, color_psm) ||
|
|
(possible_shuffle && tex_color_psm <= PSMCT24 && ((((t->UnwrappedEndBlock() + 1) - t->m_TEX0.TBP0) >> 1) + t->m_TEX0.TBP0) == bp)) &&
|
|
(t->Overlaps(bp, bw, psm, r) || t->Wraps()) &&
|
|
t->m_age <= 1 && (!found_t || dst->m_TEX0.TBW < bw))
|
|
{
|
|
// PSM equality needed because CreateSource does not handle PSM conversion.
|
|
// Only inclusive hit to limit false hits.
|
|
GSVector4i rect = r;
|
|
int src_bw = bw;
|
|
int src_psm = psm;
|
|
|
|
// If the input is C16 and it's actually a shuffle of 32bits we need to correct the size.
|
|
if ((tex_color_psm & 0xF) <= PSMCT24 && (psm & 0x7) == PSMCT16 && possible_shuffle)
|
|
{
|
|
src_psm = t->m_TEX0.PSM;
|
|
// If it's taking double width for the shuffle, half that.
|
|
if (src_bw == (t->m_TEX0.TBW * 2))
|
|
{
|
|
src_bw = t->m_TEX0.TBW;
|
|
|
|
rect.x /= 2;
|
|
rect.z /= 2;
|
|
}
|
|
else
|
|
{
|
|
rect.y /= 2;
|
|
rect.w /= 2;
|
|
}
|
|
}
|
|
if (bp > t->m_TEX0.TBP0)
|
|
{
|
|
GSVector4i new_rect = rect;
|
|
if (linear)
|
|
{
|
|
new_rect.z -= 1;
|
|
new_rect.w -= 1;
|
|
}
|
|
// Check if it is possible to hit with valid <x,y> offset on the given Target.
|
|
// Fixes Jak eyes rendering.
|
|
// Fixes Xenosaga 3 last dungeon graphic bug.
|
|
// Fixes Pause menu in The Getaway.
|
|
const bool can_translate = CanTranslate(bp, bw, src_psm, new_rect, t->m_TEX0.TBP0, t->m_TEX0.PSM, t->m_TEX0.TBW);
|
|
if (can_translate)
|
|
{
|
|
const bool swizzle_match = GSLocalMemory::m_psm[src_psm].depth == GSLocalMemory::m_psm[t->m_TEX0.PSM].depth;
|
|
const GSVector2i& page_size = GSLocalMemory::m_psm[t->m_TEX0.PSM].pgs;
|
|
const GSVector4i page_mask(GSVector4i((page_size.x - 1), (page_size.y - 1)).xyxy());
|
|
rect = new_rect & ~page_mask;
|
|
|
|
if (swizzle_match)
|
|
{
|
|
rect = TranslateAlignedRectByPage(t, bp, src_psm, bw, new_rect);
|
|
rect.x -= new_rect.x;
|
|
rect.y -= new_rect.y;
|
|
}
|
|
else
|
|
{
|
|
// If it's not page aligned, grab the whole pages it covers, to be safe.
|
|
if (GSLocalMemory::m_psm[psm].bpp != GSLocalMemory::m_psm[t->m_TEX0.PSM].bpp)
|
|
{
|
|
const GSVector2i& dst_page_size = GSLocalMemory::m_psm[t->m_TEX0.PSM].pgs;
|
|
new_rect = GSVector4i(new_rect.x / page_size.x, new_rect.y / page_size.y, (new_rect.z + (page_size.x - 1)) / page_size.x, (new_rect.w + (page_size.y - 1)) / page_size.y);
|
|
new_rect = GSVector4i(new_rect.x * dst_page_size.x, new_rect.y * dst_page_size.y, new_rect.z * dst_page_size.x, new_rect.w * dst_page_size.y);
|
|
}
|
|
else
|
|
{
|
|
new_rect.x &= ~(page_size.x - 1);
|
|
new_rect.y &= ~(page_size.y - 1);
|
|
new_rect.z = (new_rect.z + (page_size.x - 1)) & ~(page_size.x - 1);
|
|
new_rect.w = (new_rect.w + (page_size.y - 1)) & ~(page_size.y - 1);
|
|
}
|
|
rect = TranslateAlignedRectByPage(t, bp & ~((1 << 5) - 1), src_psm, bw, new_rect);
|
|
rect.x -= new_rect.x & ~(page_size.x - 1);
|
|
rect.y -= new_rect.y & ~(page_size.y - 1);
|
|
}
|
|
|
|
rect = rect.rintersect(t->m_valid);
|
|
|
|
if (rect.rempty())
|
|
continue;
|
|
|
|
if (!t->m_dirty.empty())
|
|
{
|
|
const GSVector4i dirty_rect = t->m_dirty.GetTotalRect(t->m_TEX0, GSVector2i(rect.z, rect.w)).rintersect(rect);
|
|
if (!dirty_rect.eq(rect))
|
|
{
|
|
// Only update if the rect isn't empty
|
|
if (!dirty_rect.rempty())
|
|
t->Update();
|
|
}
|
|
else
|
|
continue;
|
|
}
|
|
|
|
x_offset = rect.x;
|
|
y_offset = rect.y;
|
|
dst = t;
|
|
tex_merge_rt = false;
|
|
found_t = true;
|
|
if (dst->m_TEX0.TBP0 == frame_fbp && possible_shuffle)
|
|
break;
|
|
else
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
SurfaceOffset so = ComputeSurfaceOffset(bp, bw, src_psm, new_rect, t);
|
|
if (!so.is_valid && t->Wraps())
|
|
{
|
|
// Improves Beyond Good & Evil shadow.
|
|
const u32 bp_unwrap = bp + GSTextureCache::MAX_BP + 0x1;
|
|
so = ComputeSurfaceOffset(bp_unwrap, bw, src_psm, new_rect, t);
|
|
}
|
|
if (so.is_valid)
|
|
{
|
|
dst = t;
|
|
// Offset from Target to Source in Target coords.
|
|
x_offset = so.b2a_offset.x;
|
|
y_offset = so.b2a_offset.y;
|
|
tex_merge_rt = false;
|
|
found_t = true;
|
|
// Keep looking, just in case there is an exact match (Situation: Target frame drawn inside target frame, current makes a separate texture)
|
|
if (dst->m_TEX0.TBP0 == frame_fbp && possible_shuffle)
|
|
break;
|
|
else
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Some games, such as Tomb Raider: Underworld, and Destroy All Humans shift the texture pointer
|
|
// back behind the framebuffer, but then offset their texture coordinates to compensate. Why they
|
|
// do this, I have no idea... but it's usually only a page wide/high of an offset. Thankfully,
|
|
// they also seem to set region clamp with the offset as well, so we can use that to find the target
|
|
// that they're expecting to read from. Example from Tomb Raider: TBP0 0xee0 with a TBW of 8, MINU/V
|
|
// of 64,32, which means 9 pages down, or 0x1000, which lines up with the main framebuffer. Originally
|
|
// I had a check on the end block too, but since the game's a bit rude, it channel shuffles into new
|
|
// targets that it never regularly draws to, which means the end block for them won't be correct.
|
|
// Omitting that check here seemed less risky than blowing CS targets out...
|
|
const GSVector2i& page_size = GSLocalMemory::m_psm[src_psm].pgs;
|
|
const GSOffset offset(GSLocalMemory::m_psm[src_psm].info, bp, bw, psm);
|
|
if (bp < t->m_TEX0.TBP0 && region.HasX() && region.HasY() &&
|
|
(region.GetMinX() & (page_size.x - 1)) == 0 && (region.GetMinY() & (page_size.y - 1)) == 0 &&
|
|
offset.bn(region.GetMinX(), region.GetMinY()) == t->m_TEX0.TBP0)
|
|
{
|
|
GL_CACHE("TC: Target 0x%x detected in front of TBP 0x%x with %d,%d offset (%d pages)",
|
|
t->m_TEX0.TBP0, TEX0.TBP0, region.GetMinX(), region.GetMinY(),
|
|
(region.GetMinY() / page_size.y) * TEX0.TBW + (region.GetMinX() / page_size.x));
|
|
x_offset = -region.GetMinX();
|
|
y_offset = -region.GetMinY();
|
|
dst = t;
|
|
tex_merge_rt = false;
|
|
found_t = true;
|
|
if (dst->m_TEX0.TBP0 == frame_fbp && possible_shuffle)
|
|
break;
|
|
else
|
|
continue;
|
|
}
|
|
|
|
// Strictly speaking this path is no longer needed, but I'm leaving it here for now because Guitar
|
|
// Hero III needs it to merge crowd textures.
|
|
else if (GSConfig.UserHacks_TextureInsideRt >= GSTextureInRtMode::MergeTargets && !tex_merge_rt)
|
|
{
|
|
dst = t;
|
|
x_offset = 0;
|
|
y_offset = 0;
|
|
tex_merge_rt = true;
|
|
|
|
// Prefer a target inside over a target outside.
|
|
found_t = false;
|
|
if (dst->m_TEX0.TBP0 == frame_fbp && possible_shuffle)
|
|
break;
|
|
else
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pure depth texture format will be fetched by LookupDepthSource.
|
|
// However guess what, some games (GoW) read the depth as a standard
|
|
// color format (instead of a depth format). All pixels are scrambled
|
|
// (because color and depth don't have same location). They don't care
|
|
// pixel will be several draw calls later.
|
|
//
|
|
// Sigh... They don't help us.
|
|
|
|
if (!found_t && !dst && !GSConfig.UserHacks_DisableDepthSupport)
|
|
{
|
|
GSVector4i new_rect = r;
|
|
|
|
// Just in case the TextureMinMax trolls us as it does, when checking if inside the target.
|
|
new_rect.z -= 2;
|
|
new_rect.w -= 2;
|
|
|
|
// Let's try a trick to avoid to use wrongly a depth buffer
|
|
// Unfortunately, I don't have any Arc the Lad testcase
|
|
//
|
|
// 1/ Check only current frame, I guess it is only used as a postprocessing effect
|
|
for (auto t : m_dst[DepthStencil])
|
|
{
|
|
if (t->m_age <= 1 && t->m_used && t->m_dirty.empty() && GSUtil::HasSharedBits(bp, psm, t->m_TEX0.TBP0, t->m_TEX0.PSM) && t->Inside(bp, bw, psm, new_rect))
|
|
{
|
|
GL_INS("TC: Warning depth format read as color format. Pixels will be scrambled");
|
|
// Let's fetch a depth format texture. Rational, it will avoid the texture allocation and the
|
|
// rescaling of the current function.
|
|
if (psm_s.bpp > 8)
|
|
{
|
|
GIFRegTEX0 depth_TEX0;
|
|
depth_TEX0.U32[0] = TEX0.U32[0] | (0x30u << 20u);
|
|
depth_TEX0.U32[1] = TEX0.U32[1];
|
|
return LookupDepthSource(depth_TEX0, TEXA, CLAMP, r, possible_shuffle, linear, frame_fbp, req_color, req_alpha);
|
|
}
|
|
else
|
|
{
|
|
if (!possible_shuffle && TEX0.PSM == PSMT8 && GSLocalMemory::m_psm[t->m_TEX0.PSM].bpp != 32)
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
return LookupDepthSource(TEX0, TEXA, CLAMP, r, possible_shuffle, linear, frame_fbp, req_color, req_alpha, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (tex_merge_rt)
|
|
src = CreateMergedSource(TEX0, TEXA, region, dst->m_scale);
|
|
}
|
|
|
|
if (!src)
|
|
{
|
|
#ifdef ENABLE_OGL_DEBUG
|
|
if (dst)
|
|
{
|
|
GL_CACHE("TC: dst %s hit (%s, OFF <%d,%d>): (0x%x, %s)",
|
|
to_string(dst->m_type),
|
|
half_right ? "half" : "full",
|
|
x_offset,
|
|
y_offset,
|
|
TEX0.TBP0,
|
|
psm_str(TEX0.PSM));
|
|
}
|
|
else
|
|
{
|
|
GL_CACHE("TC: src miss (0x%x, 0x%x, %s)", TEX0.TBP0, psm_s.pal > 0 ? TEX0.CBP : 0, psm_str(TEX0.PSM));
|
|
}
|
|
#endif
|
|
src = CreateSource(TEX0, TEXA, dst, half_right, x_offset, y_offset, lod, &r, gpu_clut, region);
|
|
}
|
|
else
|
|
{
|
|
GL_CACHE("TC: src hit: (0x%x, 0x%x, %s)",
|
|
TEX0.TBP0, psm_s.pal > 0 ? TEX0.CBP : 0,
|
|
psm_str(TEX0.PSM));
|
|
|
|
if (gpu_clut)
|
|
AttachPaletteToSource(src, gpu_clut);
|
|
else if (src->m_palette && (!src->m_palette_obj || !src->ClutMatch({ clut, psm_s.pal })))
|
|
AttachPaletteToSource(src, psm_s.pal, true);
|
|
}
|
|
|
|
src->Update(r);
|
|
return src;
|
|
}
|
|
|
|
GSTextureCache::Target* GSTextureCache::FindTargetOverlap(Target* target, int type, int psm)
|
|
{
|
|
for (auto t : m_dst[type])
|
|
{
|
|
// Only checks that the texure starts at the requested bp, which shares data. Size isn't considered.
|
|
if (t != target && t->m_TEX0.TBW == target->m_TEX0.TBW && t->m_TEX0.TBP0 >= target->m_TEX0.TBP0 &&
|
|
t->UnwrappedEndBlock() <= target->UnwrappedEndBlock() && GSUtil::HasCompatibleBits(t->m_TEX0.PSM, psm))
|
|
return t;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
GSVector2i GSTextureCache::ScaleRenderTargetSize(const GSVector2i& sz, float scale)
|
|
{
|
|
return GSVector2i(static_cast<int>(std::ceil(static_cast<float>(sz.x) * scale)),
|
|
static_cast<int>(std::ceil(static_cast<float>(sz.y) * scale)));
|
|
}
|
|
|
|
GSTextureCache::Target* GSTextureCache::LookupTarget(GIFRegTEX0 TEX0, const GSVector2i& size, float scale, int type,
|
|
bool used, u32 fbmask, bool is_frame, bool preload, bool preserve_rgb, bool preserve_alpha, const GSVector4i draw_rect, bool is_shuffle, bool possible_clear)
|
|
{
|
|
const GSLocalMemory::psm_t& psm_s = GSLocalMemory::m_psm[TEX0.PSM];
|
|
const u32 bp = TEX0.TBP0;
|
|
GSVector2i new_size{0, 0};
|
|
GSVector2i new_scaled_size{0, 0};
|
|
const GSVector4 sRect(0, 0, 1, 1);
|
|
GSVector4 dRect{};
|
|
bool clear = true;
|
|
const auto& calcRescale = [&size, &scale, &new_size, &new_scaled_size, &clear, &dRect](const Target* tgt)
|
|
{
|
|
// TODO Possible optimization: rescale only the validity rectangle of the old target texture into the new one.
|
|
clear = (size.x > tgt->m_unscaled_size.x || size.y > tgt->m_unscaled_size.y);
|
|
new_size = size.max(tgt->m_unscaled_size);
|
|
new_scaled_size = ScaleRenderTargetSize(new_size, scale);
|
|
dRect = (GSVector4(GSVector4i::loadh(tgt->m_unscaled_size)) * GSVector4(scale)).ceil();
|
|
GL_INS("TC Rescale: %dx%d: %dx%d @ %f -> %dx%d @ %f", tgt->m_unscaled_size.x, tgt->m_unscaled_size.y,
|
|
tgt->m_texture->GetWidth(), tgt->m_texture->GetHeight(), tgt->m_scale, new_scaled_size.x, new_scaled_size.y,
|
|
scale);
|
|
};
|
|
|
|
Target* dst = nullptr;
|
|
auto& list = m_dst[type];
|
|
|
|
// TODO: Move all frame stuff to its own routine too.
|
|
if (!is_frame)
|
|
{
|
|
for (auto i = list.begin(); i != list.end(); ++i)
|
|
{
|
|
Target* t = *i;
|
|
|
|
if (bp == t->m_TEX0.TBP0)
|
|
{
|
|
bool can_use = true;
|
|
// if It's an old target and it's being completely overwritten, kill it.
|
|
// Dragon Quest 8 reuses a render-target sized buffer as a single-page buffer, without clearing it. But,
|
|
// it does dirty it by writing over the 64x64 region. So while we can't use this heuristic for tossing
|
|
// targets at BW=1 because it breaks other games, we can when the *new* buffer area is completely dirty.
|
|
if (!preserve_rgb && !preserve_alpha && TEX0.TBW != t->m_TEX0.TBW)
|
|
{
|
|
if (TEX0.TBW > 1 && t->m_age >= 1)
|
|
{
|
|
can_use = false;
|
|
}
|
|
else if (!t->m_dirty.empty())
|
|
{
|
|
const GSVector4i size_rect = GSVector4i::loadh(size);
|
|
can_use = !t->m_dirty.GetTotalRect(TEX0, size).rintersect(size_rect).eq(size_rect);
|
|
}
|
|
}
|
|
|
|
if (can_use && !is_shuffle && preserve_alpha && preserve_rgb && TEX0.TBW != t->m_TEX0.TBW && t->m_dirty.size() >= 1)
|
|
{
|
|
can_use = false;
|
|
}
|
|
|
|
if (can_use)
|
|
{
|
|
list.MoveFront(i.Index());
|
|
|
|
dst = t;
|
|
|
|
dst->m_32_bits_fmt |= (psm_s.bpp != 16);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
GL_INS("TC: Deleting RT BP 0x%x BW %d PSM %s due to change in target", t->m_TEX0.TBP0, t->m_TEX0.TBW, psm_str(t->m_TEX0.PSM));
|
|
InvalidateSourcesFromTarget(t);
|
|
i = list.erase(i);
|
|
delete t;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
assert(type == RenderTarget);
|
|
// Let's try to find a perfect frame that contains valid data
|
|
for (auto i = list.begin(); i != list.end(); ++i)
|
|
{
|
|
Target* t = *i;
|
|
|
|
// Only checks that the texure starts at the requested bp, size isn't considered.
|
|
if (bp == t->m_TEX0.TBP0 && t->m_end_block >= bp)
|
|
{
|
|
if (TEX0.TBW != t->m_TEX0.TBW && t->m_TEX0.TBW > 1 && t->m_age > 0)
|
|
{
|
|
// If frame is old and dirty, probably modified by the EE, so kill the wrong dimension version.
|
|
if (!t->m_dirty.empty())
|
|
{
|
|
DevCon.Warning("Wanted %x psm %x bw %x, got %x psm %x bw %x, deleting", TEX0.TBP0, TEX0.PSM, TEX0.TBW, t->m_TEX0.TBP0, t->m_TEX0.PSM, t->m_TEX0.TBW);
|
|
InvalidateSourcesFromTarget(t);
|
|
i = list.erase(i);
|
|
delete t;
|
|
continue;
|
|
}
|
|
}
|
|
dst = t;
|
|
GL_CACHE("TC: Lookup Frame %dx%d, perfect hit: (0x%x -> 0x%x %s)", size.x, size.y, bp, t->m_end_block, psm_str(TEX0.PSM));
|
|
if (size.x > 0 || size.y > 0)
|
|
ScaleTargetForDisplay(dst, TEX0, size.x, size.y);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 2nd try ! Try to find a frame at the requested bp -> bp + size is inside of (or equal to)
|
|
if (!dst)
|
|
{
|
|
for (auto i = list.begin(); i != list.end(); ++i)
|
|
{
|
|
Target* t = *i;
|
|
// Make sure the target is inside the texture
|
|
if (t->m_TEX0.TBP0 <= bp && bp <= t->m_end_block && t->Inside(bp, TEX0.TBW, TEX0.PSM, GSVector4i::loadh(size)))
|
|
{
|
|
if (TEX0.TBW != t->m_TEX0.TBW && t->m_TEX0.TBW > 1 && t->m_age > 0)
|
|
{
|
|
// If frame is old and dirty, probably modified by the EE, so kill the wrong dimension version.
|
|
if (!t->m_dirty.empty())
|
|
{
|
|
DevCon.Warning("2 Wanted %x psm %x bw %x, got %x psm %x bw %x, deleting", TEX0.TBP0, TEX0.PSM, TEX0.TBW, t->m_TEX0.TBP0, t->m_TEX0.PSM, t->m_TEX0.TBW);
|
|
InvalidateSourcesFromTarget(t);
|
|
i = list.erase(i);
|
|
delete t;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
dst = t;
|
|
GL_CACHE("TC: Lookup Frame %dx%d, inclusive hit: (0x%x, took 0x%x -> 0x%x %s)", size.x, size.y, bp, t->m_TEX0.TBP0, t->m_end_block, psm_str(TEX0.PSM));
|
|
|
|
if (size.x > 0 || size.y > 0)
|
|
ScaleTargetForDisplay(dst, TEX0, size.x, size.y);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3rd try ! Try to find a frame that doesn't contain valid data (honestly I'm not sure we need to do it)
|
|
if (!dst)
|
|
{
|
|
for (auto i = list.begin(); i != list.end(); ++i)
|
|
{
|
|
Target* t = *i;
|
|
if (bp == t->m_TEX0.TBP0 && TEX0.TBW == t->m_TEX0.TBW)
|
|
{
|
|
if (TEX0.TBW != t->m_TEX0.TBW && t->m_TEX0.TBW > 1 && t->m_age > 0)
|
|
{
|
|
// If frame is old and dirty, probably modified by the EE, so kill the wrong dimension version.
|
|
if (!t->m_dirty.empty())
|
|
{
|
|
DevCon.Warning("3 Wanted %x psm %x bw %x, got %x psm %x bw %x, deleting", TEX0.TBP0, TEX0.PSM, TEX0.TBW, t->m_TEX0.TBP0, t->m_TEX0.PSM, t->m_TEX0.TBW);
|
|
InvalidateSourcesFromTarget(t);
|
|
i = list.erase(i);
|
|
delete t;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
dst = t;
|
|
GL_CACHE("TC: Lookup Frame %dx%d, empty hit: (0x%x -> 0x%x %s)", size.x, size.y, bp, t->m_end_block, psm_str(TEX0.PSM));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dst)
|
|
{
|
|
if (type == DepthStencil)
|
|
{
|
|
GL_CACHE("TC: Lookup Target(Depth) %dx%d (0x%x, BW:%u, %s) hit (0x%x, BW:%d, %s)", size.x, size.y, bp,
|
|
TEX0.TBW, psm_str(TEX0.PSM), dst->m_TEX0.TBP0, dst->m_TEX0.TBW, psm_str(dst->m_TEX0.PSM));
|
|
}
|
|
else
|
|
{
|
|
GL_CACHE("TC: Lookup %s(Color) %dx%d (0x%x, BW:%u, FBMSK %08x, %s) hit (0x%x, BW:%d, %s)",
|
|
is_frame ? "Frame" : "Target", size.x, size.y, bp, TEX0.TBW, fbmask, psm_str(TEX0.PSM),
|
|
dst->m_TEX0.TBP0, dst->m_TEX0.TBW, psm_str(dst->m_TEX0.PSM));
|
|
}
|
|
|
|
if (dst->m_scale != scale)
|
|
{
|
|
calcRescale(dst);
|
|
GSTexture* tex = type == RenderTarget ? g_gs_device->CreateRenderTarget(new_scaled_size.x, new_scaled_size.y, GSTexture::Format::Color, clear) :
|
|
g_gs_device->CreateDepthStencil(new_scaled_size.x, new_scaled_size.y, GSTexture::Format::DepthStencil, clear);
|
|
if (!tex)
|
|
return nullptr;
|
|
|
|
g_gs_device->StretchRect(dst->m_texture, sRect, tex, dRect, (type == RenderTarget) ? ShaderConvert::COPY : ShaderConvert::DEPTH_COPY, false);
|
|
g_perfmon.Put(GSPerfMon::TextureCopies, 1);
|
|
m_target_memory_usage = (m_target_memory_usage - dst->m_texture->GetMemUsage()) + tex->GetMemUsage();
|
|
|
|
// If we're changing resolution scale, just toss the texture, it's not going to get reused.
|
|
if (!GSConfig.UserHacks_NativePaletteDraw || (dst->m_scale != 1.0f && scale != 1.0f))
|
|
delete dst->m_texture;
|
|
else
|
|
g_gs_device->Recycle(dst->m_texture);
|
|
|
|
dst->m_texture = tex;
|
|
dst->m_scale = scale;
|
|
dst->m_unscaled_size = new_size;
|
|
}
|
|
|
|
// If our RGB was invalidated, we need to pull it from depth.
|
|
const bool preserve_target = preserve_rgb || preserve_alpha;
|
|
if (type == RenderTarget && (preserve_target || !dst->m_valid.rintersect(draw_rect).eq(dst->m_valid)) &&
|
|
!dst->m_valid_rgb && !FullRectDirty(dst, 0x7) &&
|
|
(GSLocalMemory::m_psm[TEX0.PSM].trbpp < 24 || fbmask != 0x00FFFFFFu))
|
|
{
|
|
// Neo Contra clears 0x1400 with Z16S, then uses that address to upload C32 frames, this gets confused and makes a mess of it.
|
|
// TODO: Look in to making sure bad format conversions don't happen.
|
|
if (!is_frame)
|
|
{
|
|
GL_CACHE("TC: Attempt to repopulate RGB for %s[%x]", to_string(type), dst->m_TEX0.TBP0);
|
|
for (Target* dst_match : m_dst[DepthStencil])
|
|
{
|
|
if (dst_match->m_TEX0.TBP0 != TEX0.TBP0 || !dst_match->m_valid_rgb)
|
|
continue;
|
|
|
|
if (!CopyRGBFromDepthToColor(dst, dst_match))
|
|
{
|
|
// Needed new texture and memory allocation failed.
|
|
return nullptr;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!dst->m_valid_rgb)
|
|
{
|
|
GL_CACHE("TC: Cannot find RGB target for %s[%x], clearing.", to_string(type), dst->m_TEX0.TBP0);
|
|
|
|
// We couldn't get RGB from any depth targets. So clear and preload.
|
|
// Unfortunately, we still have an alpha channel to preserve, and we can't clear RGB...
|
|
// So, create a new target, clear/preload it, and copy RGB in.
|
|
GSTexture* tex = (type == RenderTarget) ?
|
|
g_gs_device->CreateRenderTarget(dst->m_texture->GetWidth(),
|
|
dst->m_texture->GetHeight(), GSTexture::Format::Color, true) :
|
|
g_gs_device->CreateDepthStencil(dst->m_texture->GetWidth(),
|
|
dst->m_texture->GetHeight(), GSTexture::Format::DepthStencil, true);
|
|
if (!tex)
|
|
return nullptr;
|
|
|
|
std::swap(dst->m_texture, tex);
|
|
PreloadTarget(TEX0, size, GSVector2i(dst->m_valid.z, dst->m_valid.w), is_frame, preload,
|
|
preserve_target, draw_rect, dst);
|
|
g_gs_device->StretchRect(tex, GSVector4::cxpr(0.0f, 0.0f, 1.0f, 1.0f), dst->m_texture,
|
|
GSVector4(dst->m_texture->GetRect()), false, false, false, true);
|
|
g_gs_device->Recycle(tex);
|
|
dst->m_valid_rgb = true;
|
|
}
|
|
}
|
|
|
|
// Drop dirty rect if we're overwriting the whole target.
|
|
if (!preserve_target && draw_rect.rintersect(dst->m_valid).eq(dst->m_valid))
|
|
{
|
|
if (!dst->m_dirty.empty())
|
|
{
|
|
GL_INS("TC: Clearing dirty list for %s[%x] because we're overwriting the whole target.", to_string(type), dst->m_TEX0.TBP0);
|
|
dst->m_dirty.clear();
|
|
}
|
|
|
|
// And invalidate the target, we're drawing over it so we don't care what's there.
|
|
GL_INS("TC: Invalidating target %s[%x] because it's completely overwritten.", to_string(type), dst->m_TEX0.TBP0);
|
|
g_gs_device->InvalidateRenderTarget(dst->m_texture);
|
|
}
|
|
}
|
|
else if (!is_frame && !GSConfig.UserHacks_DisableDepthSupport)
|
|
{
|
|
const int rev_type = (type == DepthStencil) ? RenderTarget : DepthStencil;
|
|
|
|
// Depth stencil/RT can be an older RT/DS but only check recent RT/DS to avoid to pick
|
|
// some bad data.
|
|
auto& rev_list = m_dst[rev_type];
|
|
Target* dst_match = nullptr;
|
|
for (auto i = rev_list.begin(); i != rev_list.end(); ++i)
|
|
{
|
|
Target* t = *i;
|
|
// Don't pull in targets without valid lower 24 bits, it makes no sense to convert them.
|
|
if (bp != t->m_TEX0.TBP0 || !t->m_valid_rgb)
|
|
continue;
|
|
|
|
const GSLocalMemory::psm_t& t_psm_s = GSLocalMemory::m_psm[t->m_TEX0.PSM];
|
|
if (t_psm_s.bpp != psm_s.bpp)
|
|
{
|
|
bool remove_target = possible_clear;
|
|
|
|
// If we have a BW change, and it's not a multiple of 2 (for a shuffle), the game's going to get a jigsaw
|
|
// puzzle of pages and can't be expecting to have legitimate data. Tokimeki Memorial 3 reuses a BW 17
|
|
// buffer as BW 10, and if we don't discard the BW 17 buffer, the BW 10 buffer ends up twice the size.
|
|
const u32 shuffle_bw = (psm_s.bpp > t_psm_s.bpp) ? (TEX0.TBW / 2u) : (TEX0.TBW * 2u);
|
|
if (t->m_TEX0.TBW != TEX0.TBW && t->m_TEX0.TBW != shuffle_bw)
|
|
{
|
|
// But we'll make sure the whole existing target's actually being drawn over to be safe.
|
|
const u32 end_block = GSLocalMemory::GetUnwrappedEndBlockAddress(TEX0.TBP0, TEX0.TBW, TEX0.PSM, draw_rect);
|
|
if (end_block >= t->UnwrappedEndBlock())
|
|
{
|
|
GL_CACHE("Not converting %s at %x TBW %u with end block of %x when we're drawing through %x",
|
|
to_string(rev_type), t->m_TEX0.TBP0, t->m_TEX0.TBW, t->UnwrappedEndBlock(), end_block);
|
|
remove_target = true;
|
|
}
|
|
}
|
|
|
|
// Probably an old target, get rid of it.
|
|
if (remove_target)
|
|
{
|
|
InvalidateSourcesFromTarget(t);
|
|
i = rev_list.erase(i);
|
|
delete t;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (t->m_age == 0)
|
|
{
|
|
dst_match = t;
|
|
break;
|
|
}
|
|
else if (t->m_age == 1 && (preserve_rgb || (preserve_alpha && (t->m_valid_alpha_low || t->m_valid_alpha_high))))
|
|
{
|
|
dst_match = t;
|
|
}
|
|
}
|
|
// We only want to use a matched target if it's actually being used.
|
|
if (dst_match)
|
|
{
|
|
calcRescale(dst_match);
|
|
|
|
// If we don't need A, and the existing target doesn't have valid alpha, don't bother converting it.
|
|
const bool has_alpha = dst_match->m_valid_alpha_low || dst_match->m_valid_alpha_high;
|
|
const bool preserve_target = (preserve_rgb || (preserve_alpha && has_alpha)) ||
|
|
!draw_rect.rintersect(dst_match->m_valid).eq(dst_match->m_valid);
|
|
|
|
bool half_width = false;
|
|
|
|
if (GSLocalMemory::m_psm[TEX0.PSM].bpp == 32 && GSLocalMemory::m_psm[dst_match->m_TEX0.PSM].bpp == 16)
|
|
if (dst_match->m_valid.z == ((TEX0.TBW * 64) * 2))
|
|
half_width = true;
|
|
|
|
// Clear instead of invalidating if there is anything which isn't touched.
|
|
clear |= (!preserve_target && fbmask != 0);
|
|
GIFRegTEX0 new_TEX0;
|
|
new_TEX0.TBP0 = TEX0.TBP0;
|
|
new_TEX0.TBW = (!half_width) ? dst_match->m_TEX0.TBW : TEX0.TBW;
|
|
new_TEX0.PSM = is_shuffle ? dst_match->m_TEX0.PSM :TEX0.PSM;
|
|
|
|
dst = Target::Create(new_TEX0, new_size.x, new_size.y, scale, type, clear);
|
|
if (!dst)
|
|
return nullptr;
|
|
|
|
dst->m_32_bits_fmt = dst_match->m_32_bits_fmt;
|
|
dst->OffsetHack_modxy = dst_match->OffsetHack_modxy;
|
|
dst->m_end_block = dst_match->m_end_block; // If we're copying the size, we need to keep the end block.
|
|
dst->m_valid = dst_match->m_valid;
|
|
dst->m_valid_alpha_low = dst_match->m_valid_alpha_low;//&& psm_s.trbpp != 24;
|
|
dst->m_valid_alpha_high = dst_match->m_valid_alpha_high;//&& psm_s.trbpp != 24;
|
|
dst->m_valid_rgb = dst_match->m_valid_rgb;
|
|
|
|
if(GSLocalMemory::m_psm[dst->m_TEX0.PSM].bpp == 16 && GSLocalMemory::m_psm[dst_match->m_TEX0.PSM].bpp > 16)
|
|
dst->m_TEX0.TBW = dst_match->m_TEX0.TBW; // Be careful of shuffles of the depth as C16, but using a buffer width of 16 (Mercenaries).
|
|
else if (GSLocalMemory::m_psm[dst->m_TEX0.PSM].bpp == 32 && GSLocalMemory::m_psm[dst_match->m_TEX0.PSM].bpp == 16)
|
|
{
|
|
// If we're coming from a 16bit target to 32bit, one of the dimensions is smaller.
|
|
if (half_width)
|
|
dst->m_valid.z /= 2;
|
|
else
|
|
dst->m_valid.w /= 2;
|
|
|
|
dst->UpdateValidity(dst->m_valid);
|
|
}
|
|
|
|
ShaderConvert shader;
|
|
// m_32_bits_fmt gets set on a shuffle or if the format isn't 16bit.
|
|
// In this case it needs to make sure it isn't part of a shuffle, where it needs to be interpreted as 32bits.
|
|
const bool fmt_16_bits = (psm_s.bpp == 16 && GSLocalMemory::m_psm[dst_match->m_TEX0.PSM].bpp == 16 && !dst->m_32_bits_fmt);
|
|
if (type == DepthStencil)
|
|
{
|
|
GL_CACHE("TC: Lookup Target(Depth) %dx%d, hit Color (0x%x, TBW %d, %s was %s)", new_size.x, new_size.y,
|
|
bp, TEX0.TBW, psm_str(TEX0.PSM), psm_str(dst_match->m_TEX0.PSM));
|
|
shader = (fmt_16_bits) ? ShaderConvert::RGB5A1_TO_FLOAT16 :
|
|
(ShaderConvert)(static_cast<int>(ShaderConvert::RGBA8_TO_FLOAT32) + psm_s.fmt);
|
|
}
|
|
else
|
|
{
|
|
GL_CACHE("TC: Lookup Target(Color) %dx%d, hit Depth (0x%x, TBW %d, FBMSK %0x, %s was %s)", new_size.x,
|
|
new_size.y, bp, TEX0.TBW, fbmask, psm_str(TEX0.PSM), psm_str(dst_match->m_TEX0.PSM));
|
|
shader = (fmt_16_bits) ? ShaderConvert::FLOAT16_TO_RGB5A1 : ShaderConvert::FLOAT32_TO_RGBA8;
|
|
}
|
|
|
|
|
|
if (!preserve_target)
|
|
{
|
|
GL_INS("TC: Not converting existing %s[%x] because it's fully overwritten.", to_string(!type), dst->m_TEX0.TBP0);
|
|
}
|
|
else
|
|
{
|
|
// The old target's going to get invalidated (at least until we handle concurrent frame+depth at the same BP),
|
|
// so just move the dirty rects across.
|
|
dst->m_dirty = std::move(dst_match->m_dirty);
|
|
dst_match->m_dirty = {};
|
|
dst->m_alpha_max = dst_match->m_alpha_max;
|
|
dst->m_alpha_min = dst_match->m_alpha_min;
|
|
|
|
// Don't bother copying the old target in if the whole thing is dirty.
|
|
if (dst->m_dirty.empty() || (~dst->m_dirty.GetDirtyChannels() & GSUtil::GetChannelMask(TEX0.PSM)) != 0 ||
|
|
!dst->m_dirty.GetDirtyRect(0, TEX0, dst->GetUnscaledRect(), false).eq(dst->GetUnscaledRect()))
|
|
{
|
|
// If the old target was cleared, simply propagate that through.
|
|
if (dst_match->m_texture->GetState() == GSTexture::State::Cleared)
|
|
{
|
|
if (type == DepthStencil)
|
|
{
|
|
const u32 cc = dst_match->m_texture->GetClearColor();
|
|
const float cd = ConvertColorToDepth(cc, shader);
|
|
GL_INS("TC: Convert clear color[%08X] to depth[%f]", cc, cd);
|
|
g_gs_device->ClearDepth(dst->m_texture, cd);
|
|
}
|
|
else
|
|
{
|
|
const float cd = dst_match->m_texture->GetClearDepth();
|
|
const u32 cc = ConvertDepthToColor(cd, shader);
|
|
GL_INS("TC: Convert clear depth[%f] to color[%08X]", cd, cc);
|
|
g_gs_device->ClearRenderTarget(dst->m_texture, cc);
|
|
}
|
|
}
|
|
else if (dst_match->m_texture->GetState() == GSTexture::State::Dirty)
|
|
{
|
|
g_gs_device->StretchRect(dst_match->m_texture, sRect, dst->m_texture, dRect, shader, false);
|
|
g_perfmon.Put(GSPerfMon::TextureCopies, 1);
|
|
}
|
|
}
|
|
|
|
// Now pull in any dirty areas in the new format.
|
|
dst->Update();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dst)
|
|
{
|
|
dst->m_used |= used;
|
|
dst->readbacks_since_draw = 0;
|
|
|
|
assert(dst && dst->m_texture && dst->m_scale == scale);
|
|
}
|
|
|
|
return dst;
|
|
}
|
|
|
|
GSTextureCache::Target* GSTextureCache::CreateTarget(GIFRegTEX0 TEX0, const GSVector2i& size, const GSVector2i& valid_size, float scale, int type,
|
|
bool used, u32 fbmask, bool is_frame, bool preload, bool preserve_target, const GSVector4i draw_rect, GSTextureCache::Source* src)
|
|
{
|
|
if (type == DepthStencil)
|
|
{
|
|
GL_CACHE("TC: Lookup Target(Depth) %dx%d, miss (0x%x, TBW %d, %s) draw %d", size.x, size.y, TEX0.TBP0,
|
|
TEX0.TBW, psm_str(TEX0.PSM), g_gs_renderer->s_n);
|
|
}
|
|
else
|
|
{
|
|
GL_CACHE("TC: Lookup %s(Color) %dx%d FBMSK %08x, miss (0x%x, TBW %d, %s) draw %d", is_frame ? "Frame" : "Target",
|
|
size.x, size.y, fbmask, TEX0.TBP0, TEX0.TBW, psm_str(TEX0.PSM), g_gs_renderer->s_n);
|
|
}
|
|
// Avoid making garbage targets (usually PCRTC).
|
|
if (GSVector4i::loadh(size).rempty())
|
|
return nullptr;
|
|
|
|
Target* dst = Target::Create(TEX0, size.x, size.y, scale, type, true);
|
|
|
|
const bool was_clear = PreloadTarget(TEX0, size, valid_size, is_frame, preload, preserve_target, draw_rect, dst, src);
|
|
|
|
dst->m_is_frame = is_frame;
|
|
|
|
dst->m_used |= used;
|
|
|
|
if (!is_frame)
|
|
{
|
|
// Not *strictly* correct if RGB is masked, but we won't use it as a texture if not..
|
|
dst->m_valid_rgb = true;
|
|
|
|
const int bpp = GSLocalMemory::m_psm[TEX0.PSM].trbpp;
|
|
const u32 mask = GSLocalMemory::m_psm[TEX0.PSM].fmsk;
|
|
// If the alpha is masked and preloaded, we need to say it's valid else textures might fail to use the whole texture if RGB is valid.
|
|
if (((fbmask & 0xFF000000) & mask) != (mask & 0xFF000000) && bpp != 24)
|
|
{
|
|
dst->m_valid_alpha_high = (~(fbmask & mask) & 0xf0000000) & mask;
|
|
dst->m_valid_alpha_low = (~(fbmask & mask) & 0x0f000000) & mask;
|
|
|
|
if (bpp == 16)
|
|
dst->m_valid_alpha_low = dst->m_valid_alpha_high;
|
|
}
|
|
else if ((dst->m_dirty.GetDirtyChannels() & 0x8) && bpp != 24)
|
|
{
|
|
if (!preload || was_clear)
|
|
{
|
|
dst->m_valid_alpha_high = true;
|
|
dst->m_valid_alpha_low = true;
|
|
}
|
|
else
|
|
{
|
|
std::vector<GSState::GSUploadQueue>::reverse_iterator iter;
|
|
const int start_transfer = g_gs_renderer->s_transfer_n;
|
|
const u32 tex_end = GSLocalMemory::GetUnwrappedEndBlockAddress(TEX0.TBP0, TEX0.TBW, TEX0.PSM, GSVector4i::loadh(size));
|
|
for (iter = GSRendererHW::GetInstance()->m_draw_transfers.rbegin(); iter != GSRendererHW::GetInstance()->m_draw_transfers.rend(); )
|
|
{
|
|
const u32 transfer_end = GSLocalMemory::GetUnwrappedEndBlockAddress(iter->blit.DBP, iter->blit.DBW, iter->blit.DPSM, iter->rect);
|
|
// If the format, and location doesn't overlap
|
|
if (TEX0.TBP0 == iter->blit.DBP && GSUtil::HasCompatibleBits(iter->blit.DPSM, TEX0.PSM) && (iter->blit.DBW == dst->m_TEX0.TBW || (transfer_end >= tex_end && (iter->blit.DBW * 64) == iter->rect.z)))
|
|
{
|
|
dst->m_valid_alpha_high = iter->blit.DPSM != PSMT4HL;
|
|
dst->m_valid_alpha_low = iter->blit.DPSM != PSMT4HH;
|
|
break;
|
|
}
|
|
|
|
if ((start_transfer - iter->draw) > 100)
|
|
break;
|
|
|
|
++iter;
|
|
}
|
|
}
|
|
}
|
|
if (was_clear)
|
|
dst->m_dirty.clear();
|
|
}
|
|
|
|
dst->readbacks_since_draw = 0;
|
|
|
|
assert(dst && dst->m_texture && dst->m_scale == scale);
|
|
return dst;
|
|
}
|
|
|
|
bool GSTextureCache::PreloadTarget(GIFRegTEX0 TEX0, const GSVector2i& size, const GSVector2i& valid_size, bool is_frame,
|
|
bool preload, bool preserve_target, const GSVector4i draw_rect, Target* dst, GSTextureCache::Source* src)
|
|
{
|
|
// In theory new textures contain invalidated data. Still in theory a new target
|
|
// must contains the content of the GS memory.
|
|
// In practice, TC will wrongly invalidate some RT. For example due to write on the alpha
|
|
// channel but colors is still valid. Unfortunately TC doesn't support the upload of data
|
|
// in target.
|
|
//
|
|
// Cleaning the code here will likely break several games. However it might reduce
|
|
// the noise in draw call debugging. It is the main reason to enable it on debug build.
|
|
//
|
|
// From a performance point of view, it might cost a little on big upscaling
|
|
// but normally few RT are miss so it must remain reasonable.
|
|
const GSLocalMemory::psm_t& psm_s = GSLocalMemory::m_psm[TEX0.PSM];
|
|
const bool supported_fmt = !GSConfig.UserHacks_DisableDepthSupport || psm_s.depth == 0;
|
|
bool hw_clear = false;
|
|
|
|
if (TEX0.TBW > 0 && supported_fmt)
|
|
{
|
|
const GSVector4i newrect = GSVector4i::loadh(size);
|
|
const u32 rect_end = GSLocalMemory::GetUnwrappedEndBlockAddress(TEX0.TBP0, TEX0.TBW, TEX0.PSM, newrect);
|
|
|
|
RGBAMask rgba;
|
|
rgba._u32 = GSUtil::GetChannelMask(TEX0.PSM);
|
|
dst->UpdateValidity(GSVector4i::loadh(valid_size));
|
|
|
|
if (!is_frame && !preload && !(src && src->m_TEX0.TBP0 == dst->m_TEX0.TBP0))
|
|
{
|
|
if ((preserve_target || !draw_rect.eq(dst->m_valid)) && GSRendererHW::GetInstance()->m_draw_transfers.size() > 0)
|
|
{
|
|
std::vector<GSState::GSUploadQueue>::reverse_iterator iter;
|
|
GSVector4i eerect = GSVector4i::zero();
|
|
const int last_draw = GSRendererHW::GetInstance()->m_draw_transfers.back().draw;
|
|
|
|
for (iter = GSRendererHW::GetInstance()->m_draw_transfers.rbegin(); iter != GSRendererHW::GetInstance()->m_draw_transfers.rend(); )
|
|
{
|
|
// Would be nice to make this 100, but B-Boy seems to rely on data uploaded ~200 draws ago. Making it bigger for now to be safe.
|
|
if (last_draw - iter->draw > 500)
|
|
break;
|
|
|
|
const u32 transfer_end = GSLocalMemory::GetUnwrappedEndBlockAddress(iter->blit.DBP, iter->blit.DBW, iter->blit.DPSM, iter->rect);
|
|
|
|
// If the format, and location doesn't overlap
|
|
if (transfer_end >= TEX0.TBP0 && iter->blit.DBP <= rect_end && GSUtil::HasCompatibleBits(iter->blit.DPSM, TEX0.PSM))
|
|
{
|
|
GSVector4i targetr = {};
|
|
const bool can_translate = CanTranslate(iter->blit.DBP, iter->blit.DBW, iter->blit.DPSM, iter->rect, TEX0.TBP0, TEX0.PSM, TEX0.TBW);
|
|
const bool swizzle_match = GSLocalMemory::m_psm[iter->blit.DPSM].depth == GSLocalMemory::m_psm[TEX0.PSM].depth;
|
|
if (can_translate)
|
|
{
|
|
if (swizzle_match)
|
|
{
|
|
targetr = TranslateAlignedRectByPage(dst, iter->blit.DBP, iter->blit.DPSM, iter->blit.DBW, iter->rect, true);
|
|
}
|
|
else
|
|
{
|
|
// If it's not page aligned, grab the whole pages it covers, to be safe.
|
|
GSVector4i new_rect = iter->rect;
|
|
const GSVector2i page_size = GSLocalMemory::m_psm[iter->blit.DPSM].pgs;
|
|
|
|
if (GSLocalMemory::m_psm[iter->blit.DPSM].bpp != GSLocalMemory::m_psm[TEX0.PSM].bpp)
|
|
{
|
|
const GSVector2i dst_page_size = GSLocalMemory::m_psm[iter->blit.DPSM].pgs;
|
|
new_rect = GSVector4i(new_rect.x / page_size.x, new_rect.y / page_size.y, (new_rect.z + (page_size.x - 1)) / page_size.x, (new_rect.w + (page_size.y - 1)) / page_size.y);
|
|
new_rect = GSVector4i(new_rect.x * dst_page_size.x, new_rect.y * dst_page_size.y, new_rect.z * dst_page_size.x, new_rect.w * dst_page_size.y);
|
|
}
|
|
else
|
|
{
|
|
new_rect.x &= ~(page_size.x - 1);
|
|
new_rect.y &= ~(page_size.y - 1);
|
|
new_rect.z = (new_rect.z + (page_size.x - 1)) & ~(page_size.x - 1);
|
|
new_rect.w = (new_rect.w + (page_size.y - 1)) & ~(page_size.y - 1);
|
|
}
|
|
targetr = TranslateAlignedRectByPage(dst, iter->blit.DBP & ~((1 << 5) - 1), iter->blit.DPSM, iter->blit.DBW, new_rect, true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
GSTextureCache::SurfaceOffsetKey sok;
|
|
sok.elems[0].bp = iter->blit.DBP;
|
|
sok.elems[0].bw = iter->blit.DBW;
|
|
sok.elems[0].psm = iter->blit.DPSM;
|
|
sok.elems[0].rect = iter->rect;
|
|
sok.elems[1].bp = TEX0.TBP0;
|
|
sok.elems[1].bw = TEX0.TBW;
|
|
sok.elems[1].psm = TEX0.PSM;
|
|
sok.elems[1].rect = newrect;
|
|
|
|
// Calculate the rect offset if the BP doesn't match.
|
|
targetr = (iter->blit.DBP == TEX0.TBP0) ? iter->rect : ComputeSurfaceOffset(sok).b2a_offset;
|
|
}
|
|
|
|
if (eerect.rempty())
|
|
eerect = targetr;
|
|
else
|
|
eerect = eerect.runion(targetr);
|
|
|
|
if (iter->zero_clear && iter->draw == last_draw)
|
|
{
|
|
hw_clear |= true;
|
|
}
|
|
|
|
if (iter->blit.DBP == TEX0.TBP0 && transfer_end == rect_end)
|
|
{
|
|
iter = std::vector<GSState::GSUploadQueue>::reverse_iterator(GSRendererHW::GetInstance()->m_draw_transfers.erase(iter.base() - 1));
|
|
}
|
|
else
|
|
++iter;
|
|
|
|
if (eerect.rintersect(newrect).eq(newrect))
|
|
break;
|
|
}
|
|
else
|
|
++iter;
|
|
}
|
|
|
|
if (!eerect.rempty())
|
|
{
|
|
GL_INS("Preloading the RT DATA from updated GS Memory");
|
|
eerect = eerect.rintersect(newrect);
|
|
AddDirtyRectTarget(dst, eerect, TEX0.PSM, TEX0.TBW, rgba, GSLocalMemory::m_psm[TEX0.PSM].trbpp >= 16);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (GSRendererHW::GetInstance()->m_draw_transfers.size() > 0)
|
|
{
|
|
GSState::GSUploadQueue last_draw = GSRendererHW::GetInstance()->m_draw_transfers.back();
|
|
if (last_draw.zero_clear && last_draw.blit.DBP == TEX0.TBP0 && last_draw.blit.DBW == TEX0.TBW)
|
|
{
|
|
hw_clear = true;
|
|
GSRendererHW::GetInstance()->m_draw_transfers.pop_back();
|
|
}
|
|
}
|
|
GL_INS("Preloading the RT DATA");
|
|
AddDirtyRectTarget(dst, newrect, TEX0.PSM, TEX0.TBW, rgba, GSLocalMemory::m_psm[TEX0.PSM].trbpp >= 16);
|
|
}
|
|
}
|
|
|
|
dst->UpdateValidity(GSVector4i::loadh(valid_size));
|
|
|
|
for (int type = 0; type < 2; type++)
|
|
{
|
|
auto& list = m_dst[type];
|
|
for (auto i = list.begin(); i != list.end();)
|
|
{
|
|
auto j = i;
|
|
Target* t = *j;
|
|
|
|
if (dst != t && t->m_TEX0.TBW == dst->m_TEX0.TBW && t->m_TEX0.PSM == dst->m_TEX0.PSM && t->m_TEX0.TBW > 4)
|
|
if(t->Overlaps(dst->m_TEX0.TBP0, dst->m_TEX0.TBW, dst->m_TEX0.PSM, dst->m_valid))
|
|
{
|
|
// could be overwriting a double buffer, so if it's the second half of it, just reduce the size down to half.
|
|
if (((((t->UnwrappedEndBlock() + 1) - t->m_TEX0.TBP0) >> 1) + t->m_TEX0.TBP0) == dst->m_TEX0.TBP0)
|
|
{
|
|
GSVector4i new_valid = t->m_valid;
|
|
new_valid.w /= 2;
|
|
GL_INS("RT resize buffer for FBP 0x%x, %dx%d => %d,%d", t->m_TEX0.TBP0, t->m_valid.width(), t->m_valid.height(), new_valid.width(), new_valid.height());
|
|
t->ResizeValidity(new_valid);
|
|
return hw_clear;
|
|
}
|
|
// The new texture is behind it but engulfs the whole thing, shrink the new target so it grows in the HW Draw resize.
|
|
else if (((((dst->UnwrappedEndBlock() + 1) - dst->m_TEX0.TBP0) >> 1) + dst->m_TEX0.TBP0) == t->m_TEX0.TBP0)
|
|
{
|
|
int overlapping_pages = ((dst->UnwrappedEndBlock() + 1) - t->m_TEX0.TBP0) >> 5;
|
|
int y_reduction = (overlapping_pages / dst->m_TEX0.TBW) * GSLocalMemory::m_psm[t->m_TEX0.PSM].pgs.y;
|
|
|
|
if (y_reduction == 0 || (overlapping_pages % dst->m_TEX0.TBW))
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
if (preserve_target || preload)
|
|
{
|
|
const int copy_width = (t->m_texture->GetWidth()) > (dst->m_texture->GetWidth()) ? (dst->m_texture->GetWidth()) : t->m_texture->GetWidth();
|
|
const int copy_height = y_reduction * t->m_scale;
|
|
const int old_height = (dst->m_valid.w - y_reduction) * dst->m_scale;
|
|
GL_INS("RT double buffer copy from FBP 0x%x, %dx%d => %d,%d", t->m_TEX0.TBP0, copy_width, copy_height, 0, old_height);
|
|
|
|
pxAssert(old_height > 0);
|
|
|
|
// Clear the dirty first
|
|
dst->Update();
|
|
// Invalidate has been moved to after DrawPrims(), because we might kill the current sources' backing.
|
|
if (!t->m_valid_rgb || !(t->m_valid_alpha_high || t->m_valid_alpha_low))
|
|
{
|
|
const GSVector4 src_rect = GSVector4(0, 0, copy_width, copy_height) / (GSVector4(t->m_texture->GetSize()).xyxy());
|
|
const GSVector4 dst_rect = GSVector4(0, old_height, copy_width, copy_height);
|
|
g_gs_device->StretchRect(t->m_texture, src_rect, dst->m_texture, dst_rect, t->m_valid_rgb, t->m_valid_rgb, t->m_valid_rgb, t->m_valid_alpha_high || t->m_valid_alpha_low);
|
|
}
|
|
else
|
|
{
|
|
// Invalidate has been moved to after DrawPrims(), because we might kill the current sources' backing.
|
|
g_gs_device->CopyRect(t->m_texture, dst->m_texture, GSVector4i(0, 0, copy_width, copy_height), 0, old_height);
|
|
}
|
|
}
|
|
if (src && src->m_target && src->m_from_target == t)
|
|
{
|
|
// This should never happen as we're making a new target so the src should never be something it overlaps, but just incase..
|
|
GSVector4i new_valid = t->m_valid;
|
|
new_valid.y = std::max(new_valid.y - y_reduction, 0);
|
|
new_valid.w = std::max(new_valid.w - y_reduction, 0);
|
|
t->m_TEX0.TBP0 += (y_reduction / GSLocalMemory::m_psm[t->m_TEX0.PSM].pgs.y) << 5;
|
|
t->ResizeValidity(new_valid);
|
|
}
|
|
else
|
|
{
|
|
InvalidateSourcesFromTarget(t);
|
|
i = list.erase(j);
|
|
delete t;
|
|
}
|
|
return hw_clear;
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
return hw_clear;
|
|
}
|
|
|
|
GSTextureCache::Target* GSTextureCache::LookupDisplayTarget(GIFRegTEX0 TEX0, const GSVector2i& size, float scale, bool is_feedback)
|
|
{
|
|
Target* dst = LookupTarget(TEX0, size, scale, RenderTarget, true, 0, true);
|
|
if (dst)
|
|
return dst;
|
|
|
|
// Didn't find a target, check if the frame was uploaded.
|
|
|
|
bool can_create = is_feedback;
|
|
|
|
if (!is_feedback && GSRendererHW::GetInstance()->m_draw_transfers.size() > 0)
|
|
{
|
|
const GSVector4i newrect = GSVector4i::loadh(size);
|
|
const u32 rect_end = GSLocalMemory::GetUnwrappedEndBlockAddress(TEX0.TBP0, TEX0.TBW, TEX0.PSM, newrect);
|
|
|
|
std::vector<GSState::GSUploadQueue>::reverse_iterator iter;
|
|
GSVector4i eerect = GSVector4i::zero();
|
|
const int last_draw = GSRendererHW::GetInstance()->m_draw_transfers.back().draw;
|
|
|
|
for (iter = GSRendererHW::GetInstance()->m_draw_transfers.rbegin(); iter != GSRendererHW::GetInstance()->m_draw_transfers.rend(); )
|
|
{
|
|
// Would be nice to make this 100, but B-Boy seems to rely on data uploaded ~200 draws ago. Making it bigger for now to be safe.
|
|
if (last_draw - iter->draw > 500)
|
|
break;
|
|
|
|
const u32 transfer_end = GSLocalMemory::GetUnwrappedEndBlockAddress(iter->blit.DBP, iter->blit.DBW, iter->blit.DPSM, iter->rect);
|
|
|
|
// If the format, and location doesn't overlap
|
|
if (transfer_end >= TEX0.TBP0 && iter->blit.DBP <= rect_end && GSUtil::HasCompatibleBits(iter->blit.DPSM, TEX0.PSM))
|
|
{
|
|
GSVector4i targetr = iter->rect;
|
|
|
|
if (eerect.rempty())
|
|
eerect = targetr;
|
|
else
|
|
eerect = eerect.runion(targetr);
|
|
|
|
if (iter->zero_clear && iter->draw == last_draw)
|
|
{
|
|
can_create = false;
|
|
break;
|
|
}
|
|
|
|
if (iter->blit.DBP == TEX0.TBP0 && transfer_end == rect_end)
|
|
{
|
|
iter = std::vector<GSState::GSUploadQueue>::reverse_iterator(GSRendererHW::GetInstance()->m_draw_transfers.erase(iter.base() - 1));
|
|
}
|
|
else
|
|
++iter;
|
|
|
|
// In theory it might not be a full rect, but it should be enough to display *something*.
|
|
// It's also possible we haven't saved enough of the transfers to fill the rect if the game draws the picture in lots of small transfers.
|
|
can_create = true;
|
|
break;
|
|
}
|
|
else
|
|
++iter;
|
|
}
|
|
}
|
|
|
|
return can_create ? CreateTarget(TEX0, size, size, scale, RenderTarget, true, 0, true) : nullptr;
|
|
}
|
|
|
|
void GSTextureCache::ScaleTargetForDisplay(Target* t, const GIFRegTEX0& dispfb, int real_w, int real_h)
|
|
{
|
|
// This handles a case where you have two images stacked on top of one another (usually FMVs), and
|
|
// the size of the top framebuffer is larger than the height of the image. Usually happens when
|
|
// conservative FB is on, as off it'll create a 1280 high framebuffer.
|
|
|
|
// The game alternates DISPFB between the top image, where the block pointer matches the target,
|
|
// but when it switches to the other buffer, LookupTarget() will score a partial match on the target
|
|
// because e.g. 448 < 512, but the target doesn't actually contain the full image. This usually leads
|
|
// to flickering. Test case: Neo Contra intro FMVs.
|
|
|
|
// So, for these cases, we simply expand the target to include both images, based on the read height.
|
|
// It won't affect normal rendering, since that doesn't go through this path.
|
|
|
|
// Compute offset into the target that we'll start reading from.
|
|
const int delta = dispfb.TBP0 - t->m_TEX0.TBP0;
|
|
int y_offset = 0;
|
|
if (delta > 0 && t->m_TEX0.TBW != 0)
|
|
{
|
|
const int pages = delta >> 5u;
|
|
const int y_pages = pages / t->m_TEX0.TBW;
|
|
y_offset = y_pages * GSLocalMemory::m_psm[t->m_TEX0.PSM].pgs.y;
|
|
}
|
|
|
|
// Take that into consideration to find the extent of the target which will be sampled.
|
|
GSTexture* old_texture = t->m_texture;
|
|
const float scale = t->m_scale;
|
|
const int old_width = t->m_unscaled_size.x;
|
|
const int old_height = t->m_unscaled_size.y;
|
|
const int needed_height = std::min(real_h + y_offset, GSRendererHW::MAX_FRAMEBUFFER_HEIGHT);
|
|
const int needed_width = std::min(real_w, static_cast<int>(dispfb.TBW * 64));
|
|
if (needed_height <= t->m_unscaled_size.y && needed_width <= t->m_unscaled_size.x)
|
|
return;
|
|
// We're expanding, so create a new texture.
|
|
const int new_height = std::max(t->m_unscaled_size.y, needed_height);
|
|
const int new_width = std::max(t->m_unscaled_size.x, needed_width);
|
|
const int scaled_new_height = static_cast<int>(std::ceil(static_cast<float>(new_height) * scale));
|
|
const int scaled_new_width = static_cast<int>(std::ceil(static_cast<float>(new_width) * scale));
|
|
GSTexture* new_texture = g_gs_device->CreateRenderTarget(scaled_new_width, scaled_new_height, GSTexture::Format::Color, false);
|
|
if (!new_texture)
|
|
{
|
|
// Memory allocation failure, do our best to hobble along.
|
|
return;
|
|
}
|
|
|
|
GL_CACHE("Expanding target for display output, target height %d @ 0x%X, display %d @ 0x%X offset %d needed %d",
|
|
t->m_unscaled_size.y, t->m_TEX0.TBP0, real_h, dispfb.TBP0, y_offset, needed_height);
|
|
|
|
// Fill the new texture with the old data, and discard the old texture.
|
|
g_gs_device->StretchRect(old_texture, new_texture, GSVector4(old_texture->GetSize()).zwxy(), ShaderConvert::COPY, false);
|
|
g_perfmon.Put(GSPerfMon::TextureCopies, 1);
|
|
m_target_memory_usage = (m_target_memory_usage - old_texture->GetMemUsage()) + new_texture->GetMemUsage();
|
|
g_gs_device->Recycle(old_texture);
|
|
t->m_texture = new_texture;
|
|
t->m_unscaled_size = GSVector2i(new_width, new_height);
|
|
|
|
RGBAMask rgba;
|
|
rgba._u32 = GSUtil::GetChannelMask(t->m_TEX0.PSM);
|
|
// We unconditionally preload the frame here, because otherwise we'll end up with blackness for one frame (when the expand happens).
|
|
const int preload_width = t->m_TEX0.TBW * 64;
|
|
if (old_width < preload_width && old_height < needed_height)
|
|
{
|
|
const GSVector4i right(old_width, 0, preload_width, needed_height);
|
|
const GSVector4i bottom(0, old_height, old_width, needed_height);
|
|
AddDirtyRectTarget(t, right, t->m_TEX0.PSM, t->m_TEX0.TBW, rgba);
|
|
AddDirtyRectTarget(t, bottom, t->m_TEX0.PSM, t->m_TEX0.TBW, rgba);
|
|
}
|
|
else
|
|
{
|
|
const GSVector4i newrect = GSVector4i((old_height < new_height) ? 0 : old_width,
|
|
(old_width < preload_width) ? 0 : old_height,
|
|
preload_width, needed_height);
|
|
AddDirtyRectTarget(t, newrect, t->m_TEX0.PSM, t->m_TEX0.TBW, rgba);
|
|
}
|
|
|
|
// Inject the new size back into the cache.
|
|
GetTargetSize(t->m_TEX0.TBP0, t->m_TEX0.TBW, t->m_TEX0.PSM, 0, static_cast<u32>(needed_height));
|
|
}
|
|
|
|
float GSTextureCache::ConvertColorToDepth(u32 c, ShaderConvert convert)
|
|
{
|
|
const float mult = std::exp2(g_gs_device->Features().clip_control ? -32.0f : -24.0f);
|
|
switch (convert)
|
|
{
|
|
case ShaderConvert::RGB5A1_TO_FLOAT16:
|
|
return static_cast<float>(((c & 0xF8u) >> 3) | (((c >> 8) & 0xF8u) << 2) | (((c >> 16) & 0xF8u) << 7) |
|
|
(((c >> 24) & 0x80u) << 8)) *
|
|
mult;
|
|
|
|
case ShaderConvert::RGBA8_TO_FLOAT16:
|
|
return static_cast<float>(c & 0x0000FFFF) * mult;
|
|
|
|
case ShaderConvert::RGBA8_TO_FLOAT24:
|
|
return static_cast<float>(c & 0x00FFFFFF) * mult;
|
|
|
|
case ShaderConvert::RGBA8_TO_FLOAT32:
|
|
default:
|
|
return static_cast<float>(c) * mult;
|
|
}
|
|
}
|
|
|
|
u32 GSTextureCache::ConvertDepthToColor(float d, ShaderConvert convert)
|
|
{
|
|
const float mult = std::exp2(g_gs_device->Features().clip_control ? 32.0f : 24.0f);
|
|
switch (convert)
|
|
{
|
|
case ShaderConvert::FLOAT16_TO_RGB5A1:
|
|
{
|
|
const u32 cc = static_cast<u32>(d * mult);
|
|
|
|
// Truely awful.
|
|
const GSVector4i vcc = GSVector4i(
|
|
GSVector4(GSVector4i(cc & 0x1Fu, (cc >> 5) & 0x1Fu, (cc >> 10) & 0x1Fu, (cc >> 15) & 0x01u)) *
|
|
GSVector4::cxpr(255.0f / 31.0f));
|
|
return (vcc.r | (vcc.g << 8) | (vcc.b << 16) | (vcc.a << 24));
|
|
}
|
|
|
|
case ShaderConvert::FLOAT32_TO_RGBA8:
|
|
default:
|
|
return static_cast<u32>(d * mult);
|
|
}
|
|
}
|
|
|
|
bool GSTextureCache::CopyRGBFromDepthToColor(Target* dst, Target* depth_src)
|
|
{
|
|
GL_CACHE("TC: Copy RGB from %dx%d %s[%x, %s] to %dx%d %s[%x, %s]", depth_src->GetUnscaledWidth(),
|
|
depth_src->GetUnscaledHeight(), to_string(depth_src->m_type), depth_src->m_TEX0.TBP0,
|
|
psm_str(depth_src->m_TEX0.PSM), dst->GetUnscaledWidth(), dst->GetUnscaledHeight(), to_string(dst->m_type),
|
|
dst->m_TEX0.TBP0, psm_str(dst->m_TEX0.PSM));
|
|
|
|
// The depth target might be larger (Driv3r).
|
|
const GSVector2i new_size = depth_src->GetUnscaledSize().max(dst->GetUnscaledSize());
|
|
const GSVector2i new_scaled_size = ScaleRenderTargetSize(new_size, dst->GetScale());
|
|
const bool needs_new_tex = (new_size != dst->m_unscaled_size);
|
|
GSTexture* tex = dst->m_texture;
|
|
if (needs_new_tex)
|
|
{
|
|
tex = g_gs_device->CreateRenderTarget(new_scaled_size.x, new_scaled_size.y, GSTexture::Format::Color,
|
|
new_size != dst->m_unscaled_size || new_size != depth_src->m_unscaled_size);
|
|
if (!tex)
|
|
return false;
|
|
|
|
m_target_memory_usage = (m_target_memory_usage - dst->m_texture->GetMemUsage()) + tex->GetMemUsage();
|
|
}
|
|
|
|
// Remove any dirty rectangles contained by this update, we don't want to pull from local memory.
|
|
const GSVector4i clear_dirty_rc = GSVector4i::loadh(depth_src->GetUnscaledSize());
|
|
for (u32 i = 0; i < dst->m_dirty.size(); i++)
|
|
{
|
|
GSDirtyRect& dr = dst->m_dirty[i];
|
|
const GSVector4i drc = dr.GetDirtyRect(dst->m_TEX0, false);
|
|
if (!drc.rintersect(clear_dirty_rc).rempty())
|
|
{
|
|
if ((dr.rgba._u32 &= ~0x7) == 0)
|
|
{
|
|
GL_CACHE("TC: Remove dirty rect (%d,%d=>%d,%d) from %s[%x, %s] due to incoming depth.", drc.left,
|
|
drc.top, drc.right, drc.bottom, to_string(dst->m_type), dst->m_TEX0.TBP0, psm_str(dst->m_TEX0.PSM));
|
|
dst->m_dirty.erase(dst->m_dirty.begin() + i);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
// Depth source should be up to date.
|
|
depth_src->Update();
|
|
|
|
constexpr ShaderConvert shader = ShaderConvert::FLOAT32_TO_RGB8;
|
|
if (depth_src->m_texture->GetState() == GSTexture::State::Cleared)
|
|
{
|
|
g_gs_device->ClearRenderTarget(tex, ConvertDepthToColor(depth_src->m_texture->GetClearDepth(), shader));
|
|
}
|
|
else if (depth_src->m_texture->GetState() != GSTexture::State::Invalidated)
|
|
{
|
|
const GSVector4 convert_rect = GSVector4(depth_src->GetUnscaledRect().rintersect(GSVector4i::loadh(new_size)));
|
|
g_gs_device->StretchRect(depth_src->m_texture, convert_rect / GSVector4(depth_src->GetUnscaledSize()).xyxy(),
|
|
tex, convert_rect * GSVector4(dst->GetScale()), shader, false);
|
|
g_perfmon.Put(GSPerfMon::TextureCopies, 1);
|
|
}
|
|
|
|
// Copy in alpha if we're a new texture.
|
|
if (needs_new_tex)
|
|
{
|
|
if (dst->m_valid_alpha_low || dst->m_valid_alpha_high)
|
|
{
|
|
g_gs_device->StretchRect(dst->m_texture, GSVector4::cxpr(0.0f, 0.0f, 1.0f, 1.0f), tex,
|
|
GSVector4(GSVector4i::loadh(dst->m_unscaled_size)), false, false, false, true);
|
|
g_perfmon.Put(GSPerfMon::TextureCopies, 1);
|
|
}
|
|
|
|
g_gs_device->Recycle(dst->m_texture);
|
|
dst->m_texture = tex;
|
|
}
|
|
|
|
dst->m_unscaled_size = new_size;
|
|
dst->m_valid_rgb = true;
|
|
dst->m_32_bits_fmt = true;
|
|
return true;
|
|
}
|
|
|
|
bool GSTextureCache::PrepareDownloadTexture(u32 width, u32 height, GSTexture::Format format, std::unique_ptr<GSDownloadTexture>* tex)
|
|
{
|
|
GSDownloadTexture* ctex = tex->get();
|
|
if (ctex && ctex->GetWidth() >= width && ctex->GetHeight() >= height)
|
|
return true;
|
|
|
|
// In the case of oddly sized texture reads, we'll keep the larger dimension.
|
|
const u32 new_width = ctex ? std::max(ctex->GetWidth(), width) : width;
|
|
const u32 new_height = ctex ? std::max(ctex->GetHeight(), height) : height;
|
|
tex->reset();
|
|
*tex = g_gs_device->CreateDownloadTexture(new_width, new_height, format);
|
|
if (!tex)
|
|
{
|
|
Console.WriteLn("Failed to create %ux%u download texture", new_width, new_height);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void GSTextureCache::InvalidateContainedTargets(u32 start_bp, u32 end_bp, u32 write_psm)
|
|
{
|
|
const bool preserve_alpha = (GSLocalMemory::m_psm[write_psm].trbpp == 24);
|
|
for (int type = 0; type < 2; type++)
|
|
{
|
|
auto& list = m_dst[type];
|
|
for (auto i = list.begin(); i != list.end();)
|
|
{
|
|
Target* const t = *i;
|
|
if (start_bp != t->m_TEX0.TBP0 && (t->m_TEX0.TBP0 < start_bp || t->UnwrappedEndBlock() > end_bp))
|
|
{
|
|
++i;
|
|
continue;
|
|
}
|
|
|
|
InvalidateSourcesFromTarget(t);
|
|
|
|
t->m_valid_alpha_low &= preserve_alpha;
|
|
t->m_valid_alpha_high &= preserve_alpha;
|
|
t->m_valid_rgb = false;
|
|
|
|
// Don't keep partial depth buffers around.
|
|
if ((!t->m_valid_alpha_low && !t->m_valid_alpha_high && !t->m_valid_rgb) || type == DepthStencil)
|
|
{
|
|
GL_CACHE("TC: InvalidateContainedTargets: Remove Target %s[%x, %s]", to_string(type), t->m_TEX0.TBP0, psm_str(t->m_TEX0.PSM));
|
|
i = list.erase(i);
|
|
delete t;
|
|
continue;
|
|
}
|
|
|
|
GL_CACHE("TC: InvalidateContainedTargets: Clear RGB valid on %s[%x, %s]", to_string(type), t->m_TEX0.TBP0, psm_str(t->m_TEX0.PSM));
|
|
++i;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Goal: Depth And Target at the same address is not possible. On GS it is
|
|
// the same memory but not on the Dx/GL. Therefore a write to the Depth/Target
|
|
// must invalidate the Target/Depth respectively
|
|
void GSTextureCache::InvalidateVideoMemType(int type, u32 bp, u32 write_psm, u32 write_fbmsk, bool dirty_only)
|
|
{
|
|
auto& list = m_dst[type];
|
|
for (auto i = list.begin(); i != list.end(); ++i)
|
|
{
|
|
Target* const t = *i;
|
|
if (bp != t->m_TEX0.TBP0 || (dirty_only && t->m_dirty.empty()))
|
|
continue;
|
|
|
|
const GSLocalMemory::psm_t& psm_s = GSLocalMemory::m_psm[write_psm];
|
|
const bool new_valid_alpha_low = t->m_valid_alpha_low && (psm_s.trbpp == 24 || (psm_s.trbpp == 32 && (write_fbmsk & 0x0F000000) == 0x0F000000));
|
|
const bool new_valid_alpha_high = t->m_valid_alpha_high && (psm_s.trbpp == 24 || (psm_s.trbpp == 32 && (write_fbmsk & 0xF0000000) == 0xF0000000));
|
|
const bool new_valid_rgb = t->m_valid_rgb && (psm_s.trbpp >= 24 && (write_fbmsk & 0x00FFFFFF) == 0x00FFFFFF);
|
|
|
|
// Don't bother trying to keep partial depth buffers around.
|
|
if ((new_valid_alpha_low || new_valid_alpha_high || new_valid_rgb) &&
|
|
(type != DepthStencil || (GSLocalMemory::m_psm[t->m_TEX0.PSM].trbpp == 24 && new_valid_rgb)))
|
|
{
|
|
if (t->m_valid_alpha_low != new_valid_alpha_low || t->m_valid_alpha_high != new_valid_alpha_high || t->m_valid_rgb != new_valid_rgb)
|
|
{
|
|
GL_CACHE("TC: InvalidateVideoMemType: Partial Remove Target(%s) (0x%x) RGB: %s->%s, Alow: %s->%s Ahigh: %s->%s",
|
|
to_string(type), t->m_TEX0.TBP0, t->m_valid_rgb ? "valid" : "invalid", new_valid_rgb ? "valid" : "invalid",
|
|
t->m_valid_alpha_low ? "valid" : "invalid", new_valid_alpha_low ? "valid" : "invalid",
|
|
t->m_valid_alpha_high ? "valid" : "invalid", new_valid_alpha_high ? "valid" : "invalid");
|
|
}
|
|
|
|
t->m_valid_alpha_low = new_valid_alpha_low;
|
|
t->m_valid_alpha_high = new_valid_alpha_high;
|
|
t->m_valid_rgb = new_valid_rgb;
|
|
break;
|
|
}
|
|
|
|
|
|
GL_CACHE("TC: InvalidateVideoMemType: Remove Target(%s) (0x%x)", to_string(type),
|
|
t->m_TEX0.TBP0);
|
|
|
|
// Need to also remove any sources which reference this target.
|
|
InvalidateSourcesFromTarget(t);
|
|
|
|
list.erase(i);
|
|
delete t;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Goal: invalidate data sent to the GPU when the source (GS memory) is modified
|
|
// Called each time you want to write to the GS memory
|
|
void GSTextureCache::InvalidateVideoMem(const GSOffset& off, const GSVector4i& rect, bool target)
|
|
{
|
|
const u32 bp = off.bp();
|
|
const u32 bw = off.bw();
|
|
const u32 psm = off.psm();
|
|
|
|
if (!target)
|
|
{
|
|
// Remove Source that have same BP as the render target (color&dss)
|
|
// rendering will dirty the copy
|
|
auto& list = m_src.m_map[bp >> 5];
|
|
for (auto i = list.begin(); i != list.end();)
|
|
{
|
|
Source* s = *i;
|
|
++i;
|
|
|
|
if (GSUtil::HasSharedBits(bp, psm, s->m_TEX0.TBP0, s->m_TEX0.PSM) ||
|
|
(GSUtil::HasSharedBits(bp, psm, s->m_from_target_TEX0.TBP0, s->m_TEX0.PSM) && s->m_target))
|
|
{
|
|
m_src.RemoveAt(s);
|
|
}
|
|
}
|
|
|
|
u32 bbp = bp + bw * 0x10;
|
|
if (bw >= 16 && bbp < 16384)
|
|
{
|
|
// Detect half of the render target (fix snow engine game)
|
|
// Target Page (8KB) have always a width of 64 pixels
|
|
// Half of the Target is TBW/2 pages * 8KB / (1 block * 256B) = 0x10
|
|
auto& list = m_src.m_map[bbp >> 5];
|
|
for (auto i = list.begin(); i != list.end();)
|
|
{
|
|
Source* s = *i;
|
|
++i;
|
|
|
|
if (GSUtil::HasSharedBits(bbp, psm, s->m_TEX0.TBP0, s->m_TEX0.PSM))
|
|
{
|
|
m_src.RemoveAt(s);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool found = false;
|
|
// Previously: rect.ralign<Align_Outside>((bp & 31) == 0 ? GSLocalMemory::m_psm[psm].pgs : GSLocalMemory::m_psm[psm].bs)
|
|
// But this causes rects to be too big, especially in WRC games, I don't think there's any need to align them here.
|
|
GSVector4i r = rect;
|
|
|
|
off.loopPages(rect, [&](u32 page)
|
|
{
|
|
auto& list = m_src.m_map[page];
|
|
for (auto i = list.begin(); i != list.end();)
|
|
{
|
|
Source* s = *i;
|
|
++i;
|
|
|
|
if (GSUtil::HasSharedBits(psm, s->m_TEX0.PSM))
|
|
{
|
|
bool b = bp == s->m_TEX0.TBP0;
|
|
|
|
if (!s->m_target)
|
|
{
|
|
found |= b;
|
|
|
|
// No point keeping invalidated sources around when the hash cache is active,
|
|
// we can just re-hash and create a new source from the cached texture.
|
|
if (s->m_from_hash_cache || (GSConfig.UserHacks_DisablePartialInvalidation && s->m_repeating))
|
|
{
|
|
m_src.RemoveAt(s);
|
|
}
|
|
else
|
|
{
|
|
u32* RESTRICT valid = s->m_valid.get();
|
|
|
|
if (valid && !s->CanPreload())
|
|
{
|
|
// Invalidate data of input texture
|
|
if (s->m_repeating)
|
|
{
|
|
// Note: very hot path on snowbling engine game
|
|
for (const GSVector2i& k : s->m_p2t[page])
|
|
{
|
|
valid[k.x] &= k.y;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
valid[page] = 0;
|
|
}
|
|
}
|
|
|
|
s->m_complete_layers = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// render target used as input texture
|
|
b |= bp == s->m_from_target_TEX0.TBP0;
|
|
|
|
if (!b)
|
|
b = s->Overlaps(bp, bw, psm, rect);
|
|
|
|
if (b)
|
|
{
|
|
m_src.RemoveAt(s);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
if (!target)
|
|
return;
|
|
|
|
// Get the bounds that we're invalidating in blocks, so we can remove any targets which are completely contained.
|
|
// Unfortunately sometimes the draw rect is incorrect, and since the end block gets the rect -1, it'll underflow,
|
|
// so we need to prevent that from happening. Just make it a single block in that case, and hope for the best.
|
|
const u32 start_bp = GSLocalMemory::GetStartBlockAddress(off.bp(), off.bw(), off.psm(), rect);
|
|
const u32 end_bp = rect.rempty() ? start_bp : GSLocalMemory::GetUnwrappedEndBlockAddress(off.bp(), off.bw(), off.psm(), rect);
|
|
|
|
RGBAMask rgba;
|
|
rgba._u32 = GSUtil::GetChannelMask(psm);
|
|
|
|
for (int type = 0; type < 2; type++)
|
|
{
|
|
auto& list = m_dst[type];
|
|
for (auto i = list.begin(); i != list.end();)
|
|
{
|
|
auto j = i;
|
|
Target* t = *j;
|
|
|
|
// Don't bother checking any further if the target doesn't overlap with the write/invalidation.
|
|
if ((bp < t->m_TEX0.TBP0 && end_bp < t->m_TEX0.TBP0) || bp > t->UnwrappedEndBlock())
|
|
{
|
|
++i;
|
|
continue;
|
|
}
|
|
|
|
++i;
|
|
|
|
if (GSUtil::HasSharedBits(psm, t->m_TEX0.PSM))
|
|
{
|
|
if (bp == t->m_TEX0.TBP0)
|
|
{
|
|
if (GSUtil::HasCompatibleBits(psm, t->m_TEX0.PSM) && bw == std::max(t->m_TEX0.TBW, 1U))
|
|
{
|
|
GL_CACHE("TC: Dirty Target(%s) (0x%x) r(%d,%d,%d,%d)", to_string(type),
|
|
t->m_TEX0.TBP0, r.x, r.y, r.z, r.w);
|
|
|
|
if (GSLocalMemory::m_psm[psm].depth)
|
|
DirtyRectByPage(bp, psm, bw, t, r);
|
|
else
|
|
AddDirtyRectTarget(t, r, psm, bw, rgba);
|
|
|
|
if (FullRectDirty(t))
|
|
{
|
|
InvalidateSourcesFromTarget(t);
|
|
i = list.erase(j);
|
|
GL_CACHE("TC: Remove Target(%s) (0x%x)", to_string(type),
|
|
t->m_TEX0.TBP0);
|
|
delete t;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (t->Overlaps(bp, bw, psm, r))
|
|
{
|
|
// Try the hard way for partial invalidation.
|
|
DirtyRectByPage(bp, psm, bw, t, r);
|
|
|
|
if (FullRectDirty(t, rgba._u32))
|
|
{
|
|
InvalidateSourcesFromTarget(t);
|
|
i = list.erase(j);
|
|
GL_CACHE("TC: Remove Target(%s) (0x%x)", to_string(type),
|
|
t->m_TEX0.TBP0);
|
|
delete t;
|
|
}
|
|
}
|
|
}
|
|
// This is a situation where it is uploading in to the alpha channel but that is not part of the mask for the target format.
|
|
// So we need to make sure the alpha is not marked as valid. (Juiced does a shuffle on the Z24 depth, making the alpha valid data).
|
|
else if (GSUtil::GetChannelMask(psm) == 0x8 && GSUtil::GetChannelMask(t->m_TEX0.PSM) == 0x7 && t->Overlaps(bp, bw, psm, r))
|
|
{
|
|
t->m_valid_alpha_high &= !(psm == PSMT8H || psm == PSMT4HH);
|
|
t->m_valid_alpha_low &= !(psm == PSMT8H || psm == PSMT4HL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Goal: retrive the data from the GPU to the GS memory.
|
|
// Called each time you want to read from the GS memory.
|
|
// full_flush is set when it's a Local->Local stransfer and both src and destination are the same.
|
|
void GSTextureCache::InvalidateLocalMem(const GSOffset& off, const GSVector4i& r, bool full_flush)
|
|
{
|
|
const u32 bp = off.bp();
|
|
const u32 psm = off.psm();
|
|
[[maybe_unused]] const u32 bw = off.bw();
|
|
const u32 read_start = GSLocalMemory::m_psm[psm].info.bn(r.x, r.y, bp, bw);
|
|
const u32 read_end = GSLocalMemory::m_psm[psm].info.bn(r.z - 1, r.w - 1, bp, bw);
|
|
|
|
GL_CACHE("TC: InvalidateLocalMem off(0x%x, %u, %s) r(%d, %d => %d, %d)",
|
|
bp,
|
|
bw,
|
|
psm_str(psm),
|
|
r.x,
|
|
r.y,
|
|
r.z,
|
|
r.w);
|
|
|
|
// Could be reading Z24/32 back as CT32 (Gundam Battle Assault 3)
|
|
if (GSLocalMemory::m_psm[psm].bpp >= 16)
|
|
{
|
|
if (GSConfig.HWDownloadMode != GSHardwareDownloadMode::Enabled)
|
|
{
|
|
DevCon.Error("Skipping depth readback of %ux%u @ %u,%u", r.width(), r.height(), r.left, r.top);
|
|
return;
|
|
}
|
|
|
|
bool z_found = false;
|
|
|
|
if (!GSConfig.UserHacks_DisableDepthSupport)
|
|
{
|
|
auto& dss = m_dst[DepthStencil];
|
|
for (auto it = dss.rbegin(); it != dss.rend(); ++it) // Iterate targets from LRU to MRU.
|
|
{
|
|
Target* t = *it;
|
|
|
|
if (t->m_32_bits_fmt && t->m_TEX0.PSM > PSMZ24)
|
|
t->m_TEX0.PSM = PSMZ32;
|
|
|
|
// Check the offset of the read, if they're not pointing at or inside this texture, it's probably not what we want.
|
|
//const bool expecting_this_tex = ((bp <= t->m_TEX0.TBP0 && read_start >= t->m_TEX0.TBP0) || bp >= t->m_TEX0.TBP0) && read_end <= t->m_end_block;
|
|
const bool bpp_match = GSLocalMemory::m_psm[t->m_TEX0.PSM].bpp == GSLocalMemory::m_psm[psm].bpp;
|
|
const u32 page_mask = ((1 << 5) - 1);
|
|
const bool expecting_this_tex = bpp_match && (((read_start & ~page_mask) == t->m_TEX0.TBP0) || (bp >= t->m_TEX0.TBP0 && ((read_end + page_mask) & ~page_mask) <= ((t->m_end_block + page_mask) & ~page_mask)));
|
|
if (!expecting_this_tex)
|
|
continue;
|
|
|
|
t->readbacks_since_draw++;
|
|
|
|
GSVector2i page_size = GSLocalMemory::m_psm[t->m_TEX0.PSM].pgs;
|
|
const bool can_translate = CanTranslate(bp, bw, psm, r, t->m_TEX0.TBP0, t->m_TEX0.PSM, t->m_TEX0.TBW);
|
|
const bool swizzle_match = GSLocalMemory::m_psm[psm].depth == GSLocalMemory::m_psm[t->m_TEX0.PSM].depth;
|
|
// Calculate the rect offset if the BP doesn't match.
|
|
GSVector4i targetr = {};
|
|
if (full_flush || t->readbacks_since_draw > 1)
|
|
{
|
|
targetr = t->m_drawn_since_read;
|
|
}
|
|
else if (can_translate)
|
|
{
|
|
if (swizzle_match)
|
|
{
|
|
targetr = TranslateAlignedRectByPage(t, bp, psm, bw, r, true);
|
|
}
|
|
else
|
|
{
|
|
// If it's not page aligned, grab the whole pages it covers, to be safe.
|
|
GSVector4i new_rect = r;
|
|
|
|
if (GSLocalMemory::m_psm[psm].bpp != GSLocalMemory::m_psm[t->m_TEX0.PSM].bpp)
|
|
{
|
|
const GSVector2i dst_page_size = GSLocalMemory::m_psm[psm].pgs;
|
|
new_rect = GSVector4i(new_rect.x / page_size.x, new_rect.y / page_size.y, (new_rect.z + (page_size.x - 1)) / page_size.x, (new_rect.w + (page_size.y - 1)) / page_size.y);
|
|
new_rect = GSVector4i(new_rect.x * dst_page_size.x, new_rect.y * dst_page_size.y, new_rect.z * dst_page_size.x, new_rect.w * dst_page_size.y);
|
|
}
|
|
else
|
|
{
|
|
new_rect.x &= ~(page_size.x - 1);
|
|
new_rect.y &= ~(page_size.y - 1);
|
|
new_rect.z = (r.z + (page_size.x - 1)) & ~(page_size.x - 1);
|
|
new_rect.w = (r.w + (page_size.y - 1)) & ~(page_size.y - 1);
|
|
}
|
|
if (new_rect.eq(GSVector4i::zero()))
|
|
{
|
|
|
|
SurfaceOffsetKey sok;
|
|
sok.elems[0].bp = bp;
|
|
sok.elems[0].bw = bw;
|
|
sok.elems[0].psm = psm;
|
|
sok.elems[0].rect = r;
|
|
sok.elems[1].bp = t->m_TEX0.TBP0;
|
|
sok.elems[1].bw = t->m_TEX0.TBW;
|
|
sok.elems[1].psm = t->m_TEX0.PSM;
|
|
sok.elems[1].rect = t->m_valid;
|
|
|
|
new_rect = ComputeSurfaceOffset(sok).b2a_offset;
|
|
}
|
|
targetr = TranslateAlignedRectByPage(t, bp & ~((1 << 5) - 1), psm, bw, new_rect, true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
targetr = t->m_drawn_since_read;
|
|
}
|
|
|
|
const GSVector4i draw_rect = (t->readbacks_since_draw > 1) ? t->m_drawn_since_read : targetr.rintersect(t->m_drawn_since_read);
|
|
const GSVector4i dirty_rect = t->m_dirty.GetTotalRect(t->m_TEX0, t->m_unscaled_size);
|
|
// Recently made this section dirty, no need to read it.
|
|
if (draw_rect.rintersect(dirty_rect).eq(draw_rect))
|
|
return;
|
|
|
|
if (t->m_drawn_since_read.eq(GSVector4i::zero()))
|
|
{
|
|
if (draw_rect.rintersect(t->m_valid).eq(draw_rect))
|
|
return;
|
|
else
|
|
continue;
|
|
}
|
|
|
|
if (!draw_rect.rempty())
|
|
{
|
|
// The draw rect and read rect overlap somewhat, we should update the target before downloading it.
|
|
if (t->m_TEX0.TBP0 == bp && !dirty_rect.rintersect(targetr).rempty())
|
|
t->Update();
|
|
|
|
Read(t, draw_rect);
|
|
|
|
// Getaway (J) stores a Z texture at 0x2800 which it uses and the next frame it stores the reflection map in
|
|
// 0x2800, so this will misdetect. So if it's not expecting a Z, check for RT's too.
|
|
z_found = read_start >= t->m_TEX0.TBP0 && read_end <= t->m_end_block && GSLocalMemory::m_psm[psm].depth == GSLocalMemory::m_psm[t->m_TEX0.PSM].depth;
|
|
|
|
if (draw_rect.rintersect(t->m_drawn_since_read).eq(t->m_drawn_since_read))
|
|
t->m_drawn_since_read = GSVector4i::zero();
|
|
}
|
|
}
|
|
}
|
|
if (z_found)
|
|
return;
|
|
}
|
|
|
|
// Games of note that use this for various effects/transfers which may cause problems.
|
|
// Silent Hill Shattered Memories
|
|
// Chaos Legion
|
|
// Busin 0: Wizardry Alternative
|
|
// Kingdom Hearts 2
|
|
// Final Fantasy X
|
|
// Dark Cloud 2
|
|
// Dog's Life
|
|
// SOCOM 2
|
|
// Fatal Frame series
|
|
auto& rts = m_dst[RenderTarget];
|
|
|
|
for (int pass = 0; pass < 2; pass++)
|
|
{
|
|
for (auto it = rts.rbegin(); it != rts.rend(); it++) // Iterate targets from LRU to MRU.
|
|
{
|
|
Target* t = *it;
|
|
|
|
if (t->m_32_bits_fmt && t->m_TEX0.PSM > PSMCT24)
|
|
t->m_TEX0.PSM = PSMCT32;
|
|
|
|
const bool exact_bp = t->m_TEX0.TBP0 == bp;
|
|
// pass 0 == Exact match, pass 1 == partial match
|
|
if (pass == 0)
|
|
{
|
|
// Check exact match first
|
|
const bool bpp_match = GSLocalMemory::m_psm[t->m_TEX0.PSM].bpp == GSLocalMemory::m_psm[psm].bpp;
|
|
const u32 page_mask = ((1 << 5) - 1);
|
|
const bool exact_mem_match = (read_start & ~page_mask) == (t->m_TEX0.TBP0 & ~page_mask) && ((read_end + page_mask) & ~page_mask) == ((t->m_end_block + page_mask) & ~page_mask);
|
|
const bool expecting_this_tex = exact_mem_match || (bpp_match && bw == t->m_TEX0.TBW && (((read_start & ~page_mask) == t->m_TEX0.TBP0) || (bp >= t->m_TEX0.TBP0 && ((read_end + page_mask) & ~page_mask) <= ((t->m_end_block + page_mask) & ~page_mask))));
|
|
|
|
if (!expecting_this_tex)
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
// Check loose matches if we still haven't got all the data.
|
|
const bool expecting_this_tex = t->Overlaps(bp, bw, psm, r);
|
|
|
|
if (!expecting_this_tex || !GSUtil::HasSharedBits(psm, t->m_TEX0.PSM))
|
|
continue;
|
|
}
|
|
|
|
t->readbacks_since_draw++;
|
|
|
|
GSVector2i page_size = GSLocalMemory::m_psm[t->m_TEX0.PSM].pgs;
|
|
const bool can_translate = CanTranslate(bp, bw, psm, r, t->m_TEX0.TBP0, t->m_TEX0.PSM, t->m_TEX0.TBW);
|
|
const bool swizzle_match = GSLocalMemory::m_psm[psm].depth == GSLocalMemory::m_psm[t->m_TEX0.PSM].depth;
|
|
// Calculate the rect offset if the BP doesn't match.
|
|
GSVector4i targetr = {};
|
|
if (full_flush || t->readbacks_since_draw > 1)
|
|
{
|
|
targetr = t->m_drawn_since_read;
|
|
}
|
|
else if (can_translate)
|
|
{
|
|
if (swizzle_match)
|
|
{
|
|
targetr = TranslateAlignedRectByPage(t, bp, psm, bw, r, true);
|
|
}
|
|
else
|
|
{
|
|
// If it's not page aligned, grab the whole pages it covers, to be safe.
|
|
GSVector4i new_rect = r;
|
|
|
|
if (GSLocalMemory::m_psm[psm].bpp != GSLocalMemory::m_psm[t->m_TEX0.PSM].bpp)
|
|
{
|
|
const GSVector2i dst_page_size = GSLocalMemory::m_psm[psm].pgs;
|
|
new_rect = GSVector4i(new_rect.x / page_size.x, new_rect.y / page_size.y, (new_rect.z + (page_size.x - 1)) / page_size.x, (new_rect.w + (page_size.y - 1)) / page_size.y);
|
|
new_rect = GSVector4i(new_rect.x * dst_page_size.x, new_rect.y * dst_page_size.y, new_rect.z * dst_page_size.x, new_rect.w * dst_page_size.y);
|
|
}
|
|
else
|
|
{
|
|
new_rect.x &= ~(page_size.x - 1);
|
|
new_rect.y &= ~(page_size.y - 1);
|
|
new_rect.z = (r.z + (page_size.x - 1)) & ~(page_size.x - 1);
|
|
new_rect.w = (r.w + (page_size.y - 1)) & ~(page_size.y - 1);
|
|
}
|
|
if (new_rect.eq(GSVector4i::zero()))
|
|
{
|
|
|
|
SurfaceOffsetKey sok;
|
|
sok.elems[0].bp = bp;
|
|
sok.elems[0].bw = bw;
|
|
sok.elems[0].psm = psm;
|
|
sok.elems[0].rect = r;
|
|
sok.elems[1].bp = t->m_TEX0.TBP0;
|
|
sok.elems[1].bw = t->m_TEX0.TBW;
|
|
sok.elems[1].psm = t->m_TEX0.PSM;
|
|
sok.elems[1].rect = t->m_valid;
|
|
|
|
new_rect = ComputeSurfaceOffset(sok).b2a_offset;
|
|
}
|
|
targetr = TranslateAlignedRectByPage(t, bp & ~((1 << 5) - 1), psm, bw, new_rect, true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
targetr = t->m_drawn_since_read;
|
|
}
|
|
|
|
if (t->m_drawn_since_read.eq(GSVector4i::zero()))
|
|
{
|
|
if (targetr.rintersect(t->m_valid).eq(targetr) && exact_bp)
|
|
return;
|
|
else
|
|
continue;
|
|
}
|
|
|
|
const GSVector4i dirty_rect = t->m_dirty.GetTotalRect(t->m_TEX0, t->m_unscaled_size);
|
|
// Recently made this section dirty, no need to read it.
|
|
if (targetr.rintersect(dirty_rect).eq(targetr))
|
|
{
|
|
if (exact_bp)
|
|
return;
|
|
else
|
|
continue;
|
|
}
|
|
|
|
// Need to check the drawn area first.
|
|
// Shadow Hearts From the New World tries to double buffer, then because we don't support rendering inside an RT, it makes a new one.
|
|
// This makes sure any misdetection doesn't accidentally break the drawn area or skip download completely.
|
|
targetr = targetr.rintersect(t->m_drawn_since_read);
|
|
|
|
if (!targetr.rempty())
|
|
{
|
|
// We can skip the download if all pages that are read from are not dirty.
|
|
if (!t->m_dirty.empty())
|
|
{
|
|
bool only_in_dirty_area = true;
|
|
off.pageLooperForRect(r).loopPagesWithBreak([t, &dirty_rect, &only_in_dirty_area](u32 page) {
|
|
const GSVector4i page_rect = GSLocalMemory::GetRectForPageOffset(t->m_TEX0.TBP0,
|
|
page * BLOCKS_PER_PAGE, t->m_TEX0.TBW, t->m_TEX0.PSM);
|
|
if (!dirty_rect.rintersect(page_rect).eq(page_rect))
|
|
{
|
|
only_in_dirty_area = false;
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
|
|
if (only_in_dirty_area)
|
|
{
|
|
if (exact_bp)
|
|
return;
|
|
else
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (GSConfig.HWDownloadMode != GSHardwareDownloadMode::Enabled)
|
|
{
|
|
DevCon.Error("Skipping depth readback of %ux%u @ %u,%u", targetr.width(), targetr.height(), targetr.left, targetr.top);
|
|
continue;
|
|
}
|
|
|
|
// The draw rect and read rect overlap somewhat, we should update the target before downloading it.
|
|
if (exact_bp && !dirty_rect.rintersect(targetr).rempty())
|
|
t->Update();
|
|
|
|
Read(t, targetr);
|
|
|
|
// Try to cut down how much we read next, if we can.
|
|
// Fatal Frame reads in vertical strips, SOCOM 2 does horizontal, so we can handle that below.
|
|
if (t->m_drawn_since_read.rintersect(targetr).eq(t->m_drawn_since_read))
|
|
{
|
|
t->m_drawn_since_read = GSVector4i::zero();
|
|
}
|
|
else if (targetr.xzxz().eq(t->m_drawn_since_read.xzxz())
|
|
&& targetr.w >= t->m_drawn_since_read.y)
|
|
{
|
|
if (targetr.y <= t->m_drawn_since_read.y)
|
|
t->m_drawn_since_read.y = targetr.w;
|
|
else if (targetr.w >= t->m_drawn_since_read.w)
|
|
t->m_drawn_since_read.w = targetr.y;
|
|
}
|
|
else if (targetr.ywyw().eq(t->m_drawn_since_read.ywyw())
|
|
&& targetr.z >= t->m_drawn_since_read.x)
|
|
{
|
|
if (targetr.x <= t->m_drawn_since_read.x)
|
|
t->m_drawn_since_read.x = targetr.z;
|
|
else if (targetr.z >= t->m_drawn_since_read.z)
|
|
t->m_drawn_since_read.z = targetr.x;
|
|
}
|
|
|
|
if (exact_bp && read_end <= t->m_end_block)
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool GSTextureCache::Move(u32 SBP, u32 SBW, u32 SPSM, int sx, int sy, u32 DBP, u32 DBW, u32 DPSM, int dx, int dy, int w, int h)
|
|
{
|
|
if (SBP == DBP && SPSM == DPSM && !GSLocalMemory::m_psm[SPSM].depth && ShuffleMove(SBP, SBW, SPSM, sx, sy, dx, dy, w, h))
|
|
return true;
|
|
|
|
if (SPSM == DPSM && SBW == 1 && SBW == DBW && PageMove(SBP, DBP, SBW, SPSM, sx, sy, dx, dy, w, h))
|
|
return true;
|
|
|
|
bool alpha_only = false;
|
|
|
|
if (SPSM == PSMT8H && SPSM == DPSM)
|
|
alpha_only = true;
|
|
|
|
// TODO: In theory we could do channel swapping on the GPU, but we haven't found anything which needs it so far.
|
|
// Not even going to go down the rabbit hole of palette formats on the GPU.. We shouldn't have any targets with P4/P8 anyway.
|
|
const GSLocalMemory::psm_t& spsm_s = GSLocalMemory::m_psm[SPSM];
|
|
const GSLocalMemory::psm_t& dpsm_s = GSLocalMemory::m_psm[DPSM];
|
|
if (SPSM != DPSM || ((spsm_s.pal + dpsm_s.pal) != 0 && !alpha_only))
|
|
{
|
|
GL_CACHE("Skipping HW move from 0x%X to 0x%X with SPSM=%s DPSM=%s", SBP, DBP, psm_str(SPSM), psm_str(DPSM));
|
|
return false;
|
|
}
|
|
|
|
// DX11/12 is a bit lame and can't partial copy depth targets. We could do this with a blit instead,
|
|
// but so far haven't seen anything which needs it.
|
|
if (GSConfig.Renderer == GSRendererType::DX11 || GSConfig.Renderer == GSRendererType::DX12)
|
|
{
|
|
if (spsm_s.depth || dpsm_s.depth)
|
|
return false;
|
|
}
|
|
|
|
// Look for an exact match on the targets.
|
|
GSTextureCache::Target* src = GetExactTarget(SBP, SBW, spsm_s.depth ? DepthStencil : RenderTarget, SBP);
|
|
GSTextureCache::Target* dst = GetExactTarget(DBP, DBW, dpsm_s.depth ? DepthStencil : RenderTarget, DBP);
|
|
|
|
if (alpha_only && (!dst || GSLocalMemory::m_psm[dst->m_TEX0.PSM].bpp != 32))
|
|
return false;
|
|
|
|
// Beware of the case where a game might create a larger texture by moving a bunch of chunks around.
|
|
// We use dx/dy == 0 and the TBW check as a safeguard to make sure these go through to local memory.
|
|
// Good test case for this is the Xenosaga I cutscene transitions, or Gradius V.
|
|
if (src && !dst && dx == 0 && dy == 0 && ((static_cast<u32>(w) + 63) / 64) <= DBW)
|
|
{
|
|
GIFRegTEX0 new_TEX0 = {};
|
|
new_TEX0.TBP0 = DBP;
|
|
new_TEX0.TBW = DBW;
|
|
new_TEX0.PSM = DPSM;
|
|
|
|
const GSVector2i target_size = GetTargetSize(DBP, DBW, DPSM, Common::AlignUpPow2(w, 64), h);
|
|
dst = LookupTarget(new_TEX0, target_size, src->m_scale, src->m_type);
|
|
if (!dst)
|
|
dst = CreateTarget(new_TEX0, target_size, target_size, src->m_scale, src->m_type);
|
|
if (!dst)
|
|
return false;
|
|
|
|
dst->UpdateValidity(GSVector4i(dx, dy, dx + w, dy + h));
|
|
dst->OffsetHack_modxy = src->OffsetHack_modxy;
|
|
}
|
|
|
|
if (!src || !dst || src->m_scale != dst->m_scale)
|
|
return false;
|
|
|
|
// Scale coordinates.
|
|
const float scale = src->m_scale;
|
|
const int scaled_sx = static_cast<int>(sx * scale);
|
|
const int scaled_sy = static_cast<int>(sy * scale);
|
|
const int scaled_dx = static_cast<int>(dx * scale);
|
|
const int scaled_dy = static_cast<int>(dy * scale);
|
|
const int scaled_w = static_cast<int>(w * scale);
|
|
const int scaled_h = static_cast<int>(h * scale);
|
|
|
|
// The source isn't in our texture, otherwise it could falsely expand the texture causing a misdetection later, which then renders black.
|
|
if ((scaled_sx + scaled_w) > src->m_texture->GetWidth() || (scaled_sy + scaled_h) > src->m_texture->GetHeight())
|
|
return false;
|
|
|
|
// We don't want to copy "old" data that the game has overwritten with writes,
|
|
// so flush any overlapping dirty area.
|
|
src->UpdateIfDirtyIntersects(GSVector4i(sx, sy, sx + w, sy + h));
|
|
|
|
// The main point of HW moves is so GPU data can get used as sources. If we don't flush all writes,
|
|
// we're not going to be able to use it as a source.
|
|
dst->Update();
|
|
|
|
// Expand the target when we used a more conservative size.
|
|
const int required_dh = scaled_dy + scaled_h;
|
|
if ((scaled_dx + scaled_w) <= dst->m_texture->GetWidth() && required_dh > dst->m_texture->GetHeight())
|
|
{
|
|
int new_height = dy + h;
|
|
if (new_height > GSRendererHW::MAX_FRAMEBUFFER_HEIGHT)
|
|
return false;
|
|
|
|
// Align height to page size, that way we don't do too many small resizes (Dark Cloud).
|
|
new_height = Common::AlignUpPow2(new_height, static_cast<unsigned>(GSLocalMemory::m_psm[DPSM].bs.y));
|
|
|
|
// We don't recycle the old texture here, because the height cache will track the new size,
|
|
// so the old size won't get created again.
|
|
GL_INS("Resize %dx%d target to %dx%d for move", dst->m_unscaled_size.x, dst->m_unscaled_size.y, dst->m_unscaled_size.x, new_height);
|
|
GetTargetSize(DBP, DBW, DPSM, 0, new_height);
|
|
|
|
if (!dst->ResizeTexture(dst->m_unscaled_size.x, new_height, false))
|
|
{
|
|
// Resize failed, probably ran out of VRAM, better luck next time. Fall back to CPU.
|
|
// We injected the new height into the cache, so hopefully won't happen again.
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Make sure the copy doesn't go out of bounds (it shouldn't).
|
|
if ((scaled_dx + scaled_w) > dst->m_texture->GetWidth() || (scaled_dy + scaled_h) > dst->m_texture->GetHeight())
|
|
return false;
|
|
GL_CACHE("HW Move 0x%x[BW:%u PSM:%s] to 0x%x[BW:%u PSM:%s] <%d,%d->%d,%d> -> <%d,%d->%d,%d>", SBP, SBW,
|
|
psm_str(SPSM), DBP, DBW, psm_str(DPSM), sx, sy, sx + w, sy + h, dx, dy, dx + w, dy + h);
|
|
|
|
// If the copies overlap, this is a validation error, so we need to copy to a temporary texture first.
|
|
if ((SBP == DBP) && !(GSVector4i(sx, sy, sx + w, sy + h).rintersect(GSVector4i(dx, dy, dx + w, dy + h))).rempty())
|
|
{
|
|
GSTexture* tmp_texture = src->m_texture->IsDepthStencil() ?
|
|
g_gs_device->CreateDepthStencil(src->m_texture->GetWidth(), src->m_texture->GetHeight(), src->m_texture->GetFormat(), false) :
|
|
g_gs_device->CreateRenderTarget(src->m_texture->GetWidth(), src->m_texture->GetHeight(), src->m_texture->GetFormat(), false);
|
|
if (!tmp_texture)
|
|
{
|
|
Console.Error("(HW Move) Failed to allocate temporary %dx%d texture on HW move", w, h);
|
|
return false;
|
|
}
|
|
|
|
if(tmp_texture->IsDepthStencil())
|
|
{
|
|
const GSVector4 src_rect = GSVector4(scaled_sx, scaled_sy, scaled_sx + scaled_w, scaled_sy + scaled_h);
|
|
const GSVector4 tmp_rect = src_rect / (GSVector4(tmp_texture->GetSize()).xyxy());
|
|
const GSVector4 dst_rect = GSVector4(scaled_dx, scaled_dy, (scaled_dx + scaled_w), (scaled_dy + scaled_h));
|
|
g_gs_device->StretchRect(src->m_texture, tmp_rect, tmp_texture, src_rect, ShaderConvert::DEPTH_COPY, false);
|
|
g_gs_device->StretchRect(tmp_texture, tmp_rect, dst->m_texture, dst_rect, ShaderConvert::DEPTH_COPY, false);
|
|
}
|
|
else
|
|
{
|
|
if (SPSM == PSMT8H && SPSM == DPSM)
|
|
{
|
|
const GSVector4 src_rect = GSVector4(scaled_sx, scaled_sy, scaled_sx + scaled_w, scaled_sy + scaled_h);
|
|
const GSVector4 tmp_rect = src_rect / (GSVector4(tmp_texture->GetSize()).xyxy());
|
|
const GSVector4 dst_rect = GSVector4(scaled_dx, scaled_dy, (scaled_dx + scaled_w), (scaled_dy + scaled_h));
|
|
g_gs_device->StretchRect(src->m_texture, tmp_rect, tmp_texture, src_rect, false, false, false, true);
|
|
g_gs_device->StretchRect(tmp_texture, tmp_rect, dst->m_texture, dst_rect, false, false, false, true);
|
|
}
|
|
else
|
|
{
|
|
const GSVector4i src_rect = GSVector4i(scaled_sx, scaled_sy, scaled_sx + scaled_w, scaled_sy + scaled_h);
|
|
// Fast memcpy()-like path for color targets.
|
|
g_gs_device->CopyRect(src->m_texture, tmp_texture,
|
|
src_rect,
|
|
scaled_sx, scaled_sy);
|
|
|
|
g_gs_device->CopyRect(tmp_texture, dst->m_texture,
|
|
src_rect,
|
|
scaled_dx, scaled_dy);
|
|
}
|
|
}
|
|
|
|
g_gs_device->Recycle(tmp_texture);
|
|
}
|
|
else
|
|
{
|
|
if (SPSM == PSMT8H && SPSM == DPSM)
|
|
{
|
|
const GSVector4 src_rect = GSVector4(scaled_sx, scaled_sy, scaled_sx + scaled_w, scaled_sy + scaled_h) / (GSVector4(src->m_texture->GetSize()).xyxy());
|
|
const GSVector4 dst_rect = GSVector4(scaled_dx, scaled_dy, (scaled_dx + scaled_w), (scaled_dy + scaled_h));
|
|
g_gs_device->StretchRect(src->m_texture, src_rect, dst->m_texture, dst_rect, false, false, false, true);
|
|
}
|
|
else
|
|
{
|
|
g_gs_device->CopyRect(src->m_texture, dst->m_texture,
|
|
GSVector4i(scaled_sx, scaled_sy, scaled_sx + scaled_w, scaled_sy + scaled_h),
|
|
scaled_dx, scaled_dy);
|
|
}
|
|
}
|
|
|
|
// You'd think we'd update to use the source valid bits, but it's not, because it might be copying some data which was uploaded and dirtied the target.
|
|
// An example of this is Cross Channel - To All People where it renders a picture with 0x7f000000 FBMSK at 0x1180, which was all cleared to black on boot,
|
|
// Then it moves it to 0x2e80, where some garbage has been loaded underneath, so we can't assume that's the only valid data.
|
|
dst->m_valid_rgb |= src->m_valid_rgb;
|
|
dst->m_valid_alpha_low |= src->m_valid_alpha_low;
|
|
dst->m_valid_alpha_high |= src->m_valid_alpha_high;
|
|
dst->UpdateValidity(GSVector4i(dx, dy, dx + w, dy + h));
|
|
dst->UpdateDrawn(GSVector4i(dx, dy, dx + w, dy + h));
|
|
dst->m_alpha_max = src->m_alpha_max;
|
|
dst->m_alpha_min = src->m_alpha_min;
|
|
// Invalidate any sources that overlap with the target (since they're now stale).
|
|
InvalidateVideoMem(g_gs_renderer->m_mem.GetOffset(DBP, DBW, DPSM), GSVector4i(dx, dy, dx + w, dy + h), false);
|
|
return true;
|
|
}
|
|
|
|
bool GSTextureCache::ShuffleMove(u32 BP, u32 BW, u32 PSM, int sx, int sy, int dx, int dy, int w, int h)
|
|
{
|
|
// What are we doing here? Final Fantasy XII uses moves to copy the contents of the RG channels to the BA channels,
|
|
// by rendering in PSMCT32, and doing a PSMCT16 move with an 8x0 offset on the destination. This effectively reads
|
|
// from the original red/green channels, and writes to the blue/alpha channels. Who knows why they did it this way,
|
|
// when they could've used sprites, but it means that they had to offset the block pointer for each move. So, we
|
|
// need to use tex-in-rt here to figure out what the offset into the original PSMCT32 texture was, and HLE the move.
|
|
if (PSM != PSMCT16)
|
|
return false;
|
|
|
|
GL_CACHE("Trying ShuffleMove: BP=%04X BW=%u PSM=%u SX=%d SY=%d DX=%d DY=%d W=%d H=%d", BP, BW, PSM, sx, sy, dx, dy, w, h);
|
|
|
|
GSTextureCache::Target* tgt = nullptr;
|
|
for (auto t : m_dst[RenderTarget])
|
|
{
|
|
if (t->m_TEX0.PSM == PSMCT32 && BP >= t->m_TEX0.TBP0 && BP <= t->m_end_block)
|
|
{
|
|
const SurfaceOffset so(ComputeSurfaceOffset(BP, BW, PSM, GSVector4i(sx, sy, sx + w, sy + h), t));
|
|
if (so.is_valid)
|
|
{
|
|
tgt = t;
|
|
GL_CACHE("ShuffleMove: Surface offset %d,%d from BP %04X - %04X", so.b2a_offset.x, so.b2a_offset.y, BP, t->m_TEX0.TBP0);
|
|
sx += so.b2a_offset.x;
|
|
sy += so.b2a_offset.y;
|
|
dx += so.b2a_offset.x;
|
|
dy += so.b2a_offset.y;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!tgt)
|
|
{
|
|
GL_CACHE("ShuffleMove: No target found");
|
|
return false;
|
|
}
|
|
|
|
// Since we're only concerned with 32->16 shuffles, the difference should be 8x8 for this to work.
|
|
const s32 diff_x = (dx - sx);
|
|
if (std::abs(diff_x) != 8 || sy != dy)
|
|
{
|
|
GL_CACHE("ShuffleMove: Difference is not 8 pixels");
|
|
return false;
|
|
}
|
|
|
|
const bool read_ba = (diff_x < 0);
|
|
const bool write_rg = (diff_x < 0);
|
|
|
|
const GSVector4i bbox = write_rg ? GSVector4i(dx, dy, dx + w, dy + h) : GSVector4i(sx, sy, sx + w, sy + h);
|
|
|
|
GSHWDrawConfig& config = GSRendererHW::GetInstance()->BeginHLEHardwareDraw(tgt->m_texture, nullptr, tgt->m_scale, tgt->m_texture, tgt->m_scale, bbox);
|
|
config.colormask.wrgba = (write_rg ? (1 | 2) : (4 | 8));
|
|
config.ps.read_ba = read_ba;
|
|
config.ps.write_rg = write_rg;
|
|
config.ps.shuffle = true;
|
|
GSRendererHW::GetInstance()->EndHLEHardwareDraw(false);
|
|
return true;
|
|
}
|
|
|
|
bool GSTextureCache::PageMove(u32 SBP, u32 DBP, u32 BW, u32 PSM, int sx, int sy, int dx, int dy, int w, int h)
|
|
{
|
|
// Only supports 1-wide at the moment.
|
|
pxAssert(BW == 1);
|
|
|
|
const GSVector4i src = GSVector4i(sx, sy, sx + w, sy + h);
|
|
const GSVector4i drc = GSVector4i(dx, dy, dx + w, dy + h);
|
|
if (!GSLocalMemory::IsPageAligned(PSM, src) || !GSLocalMemory::IsPageAligned(PSM, drc))
|
|
return false;
|
|
|
|
// How many pages are we dealing with?
|
|
const GSVector2i& pgs = GSLocalMemory::m_psm[PSM].pgs;
|
|
const u32 num_pages = (h / pgs.y) * BW;
|
|
const u32 src_page_offset = ((sy / pgs.y) * BW) + (sx / pgs.x);
|
|
const u32 src_block_end = SBP + (((src_page_offset + num_pages) * BLOCKS_PER_PAGE) - 1);
|
|
const u32 dst_page_offset = ((dy / pgs.y) * BW) + (dx / pgs.x);
|
|
const u32 dst_block_end = DBP + (((dst_page_offset + num_pages) * BLOCKS_PER_PAGE) - 1);
|
|
pxAssert(num_pages > 0);
|
|
GL_PUSH("GSTextureCache::PageMove(): %u pages, with offset of %u src %u dst", num_pages, src_page_offset,
|
|
dst_page_offset);
|
|
|
|
// Find our targets.
|
|
Target* stgt = nullptr;
|
|
Target* dtgt = nullptr;
|
|
for (int type = 0; type < 2; type++)
|
|
{
|
|
for (Target* tgt : m_dst[type])
|
|
{
|
|
// We _could_ do compatible bits here maybe?
|
|
if (tgt->m_TEX0.PSM != PSM)
|
|
continue;
|
|
|
|
// Check that the end block is in range. If it's not, we can't do this, and have to fall back to local memory.
|
|
const u32 tgt_end = tgt->UnwrappedEndBlock();
|
|
if (tgt->m_TEX0.TBP0 <= SBP && src_block_end <= tgt_end)
|
|
stgt = tgt;
|
|
if (tgt->m_TEX0.TBP0 <= DBP && dst_block_end <= tgt_end)
|
|
dtgt = tgt;
|
|
|
|
if (stgt && dtgt)
|
|
break;
|
|
}
|
|
|
|
if (stgt && dtgt)
|
|
break;
|
|
}
|
|
if (!stgt || !dtgt)
|
|
{
|
|
GL_INS("Targets not found.");
|
|
return false;
|
|
}
|
|
|
|
// Double-check that we're not copying to a non-page-aligned target.
|
|
if (((SBP - stgt->m_TEX0.TBP0) % BLOCKS_PER_PAGE) != 0 || ((DBP - dtgt->m_TEX0.TBP0) % BLOCKS_PER_PAGE) != 0)
|
|
{
|
|
GL_INS("Effective SBP of %x or DBP of %x is not page aligned.", SBP - stgt->m_TEX0.TBP0, DBP - dtgt->m_TEX0.TBP0);
|
|
return false;
|
|
}
|
|
|
|
// Need to offset based on the target's actual BP.
|
|
const u32 real_src_offset = ((SBP - stgt->m_TEX0.TBP0) / BLOCKS_PER_PAGE) + src_page_offset;
|
|
const u32 real_dst_offset = ((DBP - dtgt->m_TEX0.TBP0) / BLOCKS_PER_PAGE) + dst_page_offset;
|
|
CopyPages(stgt, stgt->m_TEX0.TBW, real_src_offset, dtgt, dtgt->m_TEX0.TBW, real_dst_offset, num_pages);
|
|
return true;
|
|
}
|
|
|
|
void GSTextureCache::CopyPages(Target* src, u32 sbw, u32 src_offset, Target* dst, u32 dbw, u32 dst_offset, u32 num_pages, ShaderConvert shader)
|
|
{
|
|
GL_PUSH("GSTextureCache::CopyPages(): %u pages at %x[eff %x] BW %u to %x[eff %x] BW %u", num_pages,
|
|
src->m_TEX0.TBP0, src->m_TEX0.TBP0 + src_offset, sbw, dst->m_TEX0.TBP0, dst->m_TEX0.TBP0 + dst_offset, dbw);
|
|
|
|
// Create rectangles for the pages.
|
|
const GSVector2i& pgs = GSLocalMemory::m_psm[dst->m_TEX0.PSM].pgs;
|
|
const GSVector4i page_rc = GSVector4i::loadh(pgs);
|
|
const GSVector4 src_size = GSVector4(src->GetUnscaledSize()).xyxy();
|
|
const GSVector4 dst_scale = GSVector4(dst->GetScale());
|
|
GSDevice::MultiStretchRect* rects = static_cast<GSDevice::MultiStretchRect*>(alloca(sizeof(GSDevice::MultiStretchRect) * num_pages));
|
|
for (u32 i = 0; i < num_pages; i++)
|
|
{
|
|
const u32 src_page_num = src_offset + i;
|
|
const GSVector2i src_offset = GSVector2i((src_page_num % sbw) * pgs.x, (src_page_num / sbw) * pgs.y);
|
|
const u32 dst_page_num = dst_offset + i;
|
|
const GSVector2i dst_offset = GSVector2i((dst_page_num % dbw) * pgs.x, (dst_page_num / dbw) * pgs.y);
|
|
|
|
const GSVector4i src_rect = page_rc + GSVector4i(src_offset).xyxy();
|
|
const GSVector4i dst_rect = page_rc + GSVector4i(dst_offset).xyxy();
|
|
|
|
GL_INS("Copy page %u @ <%d,%d=>%d,%d> to %u @ <%d,%d=>%d,%d>", src_page_num, src_rect.x, src_rect.y, src_rect.z,
|
|
src_rect.w, dst_page_num, dst_rect.x, dst_rect.y, dst_rect.z, dst_rect.w);
|
|
|
|
GSDevice::MultiStretchRect& rc = rects[i];
|
|
rc.src = src->m_texture;
|
|
rc.src_rect = GSVector4(src_rect) / src_size;
|
|
rc.dst_rect = GSVector4(dst_rect) * dst_scale;
|
|
rc.linear = false;
|
|
rc.wmask.wrgba = 0xf;
|
|
}
|
|
|
|
// No need to sort here, it's all from the same texture.
|
|
g_gs_device->DrawMultiStretchRects(rects, num_pages, dst->m_texture, shader);
|
|
}
|
|
|
|
GSTextureCache::Target* GSTextureCache::GetExactTarget(u32 BP, u32 BW, int type, u32 end_bp)
|
|
{
|
|
auto& rts = m_dst[type];
|
|
for (auto it = rts.begin(); it != rts.end(); ++it) // Iterate targets from MRU to LRU.
|
|
{
|
|
Target* t = *it;
|
|
|
|
if (t->m_TEX0.TBP0 == BP && t->m_TEX0.TBW == BW && t->UnwrappedEndBlock() >= end_bp)
|
|
{
|
|
rts.MoveFront(it.Index());
|
|
return t;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
GSTextureCache::Target* GSTextureCache::GetTargetWithSharedBits(u32 BP, u32 PSM) const
|
|
{
|
|
auto& rts = m_dst[GSLocalMemory::m_psm[PSM].depth ? DepthStencil : RenderTarget];
|
|
for (auto it = rts.begin(); it != rts.end(); ++it) // Iterate targets from MRU to LRU.
|
|
{
|
|
Target* t = *it;
|
|
const u32 t_psm = (t->HasValidAlpha()) ? t->m_TEX0.PSM & ~0x1 : t->m_TEX0.PSM;
|
|
if (GSUtil::HasSharedBits(BP, PSM, t->m_TEX0.TBP0, t_psm))
|
|
return t;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
GSTextureCache::Target* GSTextureCache::FindOverlappingTarget(u32 BP, u32 end_bp) const
|
|
{
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
for (Target* tgt : m_dst[i])
|
|
{
|
|
if (CheckOverlap(tgt->m_TEX0.TBP0, tgt->m_end_block, BP, end_bp))
|
|
return tgt;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
GSTextureCache::Target* GSTextureCache::FindOverlappingTarget(u32 BP, u32 BW, u32 PSM, GSVector4i rc) const
|
|
{
|
|
const u32 end_bp = GSLocalMemory::GetUnwrappedEndBlockAddress(BP, BW, PSM, rc);
|
|
return FindOverlappingTarget(BP, end_bp);
|
|
}
|
|
|
|
GSVector2i GSTextureCache::GetTargetSize(u32 bp, u32 fbw, u32 psm, s32 min_width, s32 min_height)
|
|
{
|
|
TargetHeightElem search = {};
|
|
search.bp = bp;
|
|
search.fbw = fbw;
|
|
search.psm = psm;
|
|
search.width = min_width;
|
|
search.height = min_height;
|
|
|
|
for (auto it = m_target_heights.begin(); it != m_target_heights.end(); ++it)
|
|
{
|
|
TargetHeightElem& elem = const_cast<TargetHeightElem&>(*it);
|
|
if (elem.bits == search.bits)
|
|
{
|
|
if (elem.width < min_width || elem.height < min_height)
|
|
{
|
|
DbgCon.WriteLn("Expand size at %x %u %u from %ux%u to %ux%u", bp, fbw, psm, elem.width, elem.height,
|
|
min_width, min_height);
|
|
}
|
|
|
|
elem.width = std::max(elem.width, min_width);
|
|
elem.height = std::max(elem.height, min_height);
|
|
|
|
m_target_heights.MoveFront(it.Index());
|
|
elem.age = 0;
|
|
return GSVector2i(elem.width, elem.height);
|
|
}
|
|
}
|
|
|
|
DbgCon.WriteLn("New size at %x %u %u: %ux%u", bp, fbw, psm, min_width, min_height);
|
|
m_target_heights.push_front(search);
|
|
return GSVector2i(min_width, min_height);
|
|
}
|
|
|
|
bool GSTextureCache::Has32BitTarget(u32 bp)
|
|
{
|
|
// Look for 32-bit targets at the matching block.
|
|
for (auto i = m_dst[RenderTarget].begin(); i != m_dst[RenderTarget].end(); ++i)
|
|
{
|
|
const Target* const t = *i;
|
|
if (bp == t->m_TEX0.TBP0 && t->m_32_bits_fmt)
|
|
{
|
|
// May as well move it to the front, because we're going to be looking it up again.
|
|
m_dst[RenderTarget].MoveFront(i.Index());
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Try depth.
|
|
for (auto i = m_dst[DepthStencil].begin(); i != m_dst[DepthStencil].end(); ++i)
|
|
{
|
|
const Target* const t = *i;
|
|
if (bp == t->m_TEX0.TBP0 && t->m_32_bits_fmt)
|
|
{
|
|
// May as well move it to the front, because we're going to be looking it up again.
|
|
m_dst[DepthStencil].MoveFront(i.Index());
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Hack: remove Target that are strictly included in current rt. Typically uses for FMV
|
|
// For example, game is rendered at 0x800->0x1000, fmv will be uploaded to 0x0->0x2800
|
|
// FIXME In theory, we ought to report the data from the sub rt to the main rt. But let's
|
|
// postpone it for later.
|
|
void GSTextureCache::InvalidateVideoMemSubTarget(GSTextureCache::Target* rt)
|
|
{
|
|
if (!rt)
|
|
return;
|
|
|
|
auto& list = m_dst[RenderTarget];
|
|
|
|
for (auto i = list.begin(); i != list.end();)
|
|
{
|
|
Target* t = *i;
|
|
|
|
if ((t->m_TEX0.TBP0 > rt->m_TEX0.TBP0) && (t->m_end_block < rt->m_end_block) && (t->m_TEX0.TBW == rt->m_TEX0.TBW) && (t->m_TEX0.TBP0 < t->m_end_block))
|
|
{
|
|
GL_INS("InvalidateVideoMemSubTarget: rt 0x%x -> 0x%x, sub rt 0x%x -> 0x%x",
|
|
rt->m_TEX0.TBP0, rt->m_end_block, t->m_TEX0.TBP0, t->m_end_block);
|
|
|
|
// Need to also remove any sources which reference this target.
|
|
InvalidateSourcesFromTarget(t);
|
|
|
|
i = list.erase(i);
|
|
delete t;
|
|
}
|
|
else
|
|
{
|
|
++i;
|
|
}
|
|
}
|
|
}
|
|
|
|
void GSTextureCache::InvalidateSourcesFromTarget(const Target* t)
|
|
{
|
|
for (auto it = m_src.m_surfaces.begin(); it != m_src.m_surfaces.end();)
|
|
{
|
|
Source* src = *it++;
|
|
if (src->m_from_target == t)
|
|
{
|
|
GL_CACHE("TC: Removing source at %x referencing target", src->m_TEX0.TBP0);
|
|
m_src.RemoveAt(src);
|
|
}
|
|
}
|
|
}
|
|
|
|
void GSTextureCache::ReplaceSourceTexture(Source* s, GSTexture* new_texture, float new_scale,
|
|
const GSVector2i& new_unscaled_size, HashCacheEntry* hc_entry, bool new_texture_is_shared)
|
|
{
|
|
pxAssert(!hc_entry || !new_texture_is_shared);
|
|
|
|
if (s->m_from_hash_cache)
|
|
{
|
|
pxAssert(s->m_from_hash_cache->refcount > 0);
|
|
if ((--s->m_from_hash_cache->refcount) == 0)
|
|
s->m_from_hash_cache->age = 0;
|
|
}
|
|
else if (!s->m_shared_texture)
|
|
{
|
|
m_source_memory_usage -= s->m_texture->GetMemUsage();
|
|
g_gs_device->Recycle(s->m_texture);
|
|
}
|
|
|
|
s->m_texture = new_texture;
|
|
s->m_shared_texture = new_texture_is_shared;
|
|
s->m_from_hash_cache = hc_entry;
|
|
s->m_unscaled_size = new_unscaled_size;
|
|
s->m_scale = new_scale;
|
|
|
|
if (s->m_from_hash_cache)
|
|
s->m_from_hash_cache->refcount++;
|
|
else if (!s->m_shared_texture)
|
|
m_source_memory_usage += s->m_texture->GetMemUsage();
|
|
}
|
|
|
|
void GSTextureCache::IncAge()
|
|
{
|
|
static constexpr int max_age = 3;
|
|
static constexpr int max_preload_age = 30;
|
|
|
|
// You can't use m_map[page] because Source* are duplicated on several pages.
|
|
for (auto i = m_src.m_surfaces.begin(); i != m_src.m_surfaces.end();)
|
|
{
|
|
Source* s = *i;
|
|
|
|
++i;
|
|
if (++s->m_age > ((!s->m_from_hash_cache && s->CanPreload()) ? max_preload_age : max_age))
|
|
m_src.RemoveAt(s);
|
|
}
|
|
|
|
AgeHashCache();
|
|
|
|
// Clearing of Rendertargets causes flickering in many scene transitions.
|
|
// Sigh, this seems to be used to invalidate surfaces. So set a huge maxage to avoid flicker,
|
|
// but still invalidate surfaces. (Disgaea 2 fmv when booting the game through the BIOS)
|
|
// Original maxage was 4 here, Xenosaga 2 needs at least 240, else it flickers on scene transitions.
|
|
static constexpr int max_rt_age = 400; // ffx intro scene changes leave the old image untouched for a couple of frames and only then start using it
|
|
|
|
// Toss and recompute sizes after 2 seconds of not being used. Should be sufficient for most loading screens.
|
|
static constexpr int max_size_age = 120;
|
|
|
|
for (int type = 0; type < 2; type++)
|
|
{
|
|
auto& list = m_dst[type];
|
|
for (auto i = list.begin(); i != list.end();)
|
|
{
|
|
Target* t = *i;
|
|
|
|
if (++t->m_age > max_rt_age)
|
|
{
|
|
i = list.erase(i);
|
|
GL_CACHE("TC: Remove Target(%s): (0x%x) due to age", to_string(type),
|
|
t->m_TEX0.TBP0);
|
|
|
|
delete t;
|
|
}
|
|
else
|
|
{
|
|
++i;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (auto it = m_target_heights.begin(); it != m_target_heights.end();)
|
|
{
|
|
TargetHeightElem& elem = const_cast<TargetHeightElem&>(*it);
|
|
if (elem.age >= max_size_age)
|
|
{
|
|
it = m_target_heights.erase(it);
|
|
}
|
|
else
|
|
{
|
|
elem.age++;
|
|
++it;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Fixme: Several issues in here. Not handling depth stencil, pitch conversion doesnt work.
|
|
GSTextureCache::Source* GSTextureCache::CreateSource(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, Target* dst, bool half_right, int x_offset, int y_offset, const GSVector2i* lod, const GSVector4i* src_range, GSTexture* gpu_clut, SourceRegion region)
|
|
{
|
|
const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[TEX0.PSM];
|
|
Source* src = new Source(TEX0, TEXA);
|
|
|
|
// For debugging, we have an option to force copies instead of sampling the target directly.
|
|
static constexpr bool force_target_copy = false;
|
|
|
|
// Normally we wouldn't use the region with targets, but for the case where we're drawing UVs and the
|
|
// clamp rectangle exceeds the TW/TH (which is now unused), we do need to use it. Timesplitters 2 does
|
|
// its frame blending effect using a smaller TW/TH, *and* triangles instead of sprites just to be extra
|
|
// annoying.
|
|
// Be careful with offset targets as we can end up sampling the wrong part/not enough, but TW/TH can be nonsense, so we take the biggest one if there is an RT(dst).
|
|
// DBZ BT3 uses a region clamp offset when processing 2 player split screen and they set it 1 pixel too wide, meaning this code gets triggered.
|
|
// TS2 has junk small TW and TH, but the region makes more sense for the draw.
|
|
int tw = std::max(region.IsFixedTEX0W(1 << TEX0.TW) ? static_cast<int>(region.GetWidth()) : (1 << TEX0.TW), dst ? (1 << TEX0.TW) : 0);
|
|
int th = std::max(region.IsFixedTEX0H(1 << TEX0.TH) ? static_cast<int>(region.GetHeight()) : (1 << TEX0.TH), dst ? (1 << TEX0.TH) : 0);
|
|
|
|
int tlevels = 1;
|
|
if (lod)
|
|
{
|
|
// lod won't contain the full range when using basic mipmapping, only that
|
|
// which is hashed, so we just allocate the full thing.
|
|
tlevels = (GSConfig.HWMipmap != HWMipmapLevel::Full) ? -1 : (lod->y - lod->x + 1);
|
|
src->m_lod = *lod;
|
|
}
|
|
|
|
bool hack = false;
|
|
bool channel_shuffle = false;
|
|
|
|
if (dst && (x_offset != 0 || y_offset != 0))
|
|
{
|
|
const float scale = dst->m_scale;
|
|
const int x = static_cast<int>(scale * x_offset);
|
|
const int y = static_cast<int>(scale * y_offset);
|
|
const int w = static_cast<int>(std::ceil(scale * tw));
|
|
const int h = static_cast<int>(std::ceil(scale * th));
|
|
|
|
// If we have a source larger than the target (from tex-in-rt), texelFetch() for target region will return black.
|
|
if constexpr (force_target_copy)
|
|
{
|
|
// If we have a source larger than the target, we need to clear it, otherwise we'll read junk
|
|
const bool outside_target = ((x + w) > dst->m_texture->GetWidth() || (y + h) > dst->m_texture->GetHeight());
|
|
GSTexture* sTex = dst->m_texture;
|
|
GSTexture* dTex = outside_target ?
|
|
g_gs_device->CreateRenderTarget(w, h, GSTexture::Format::Color, true) :
|
|
g_gs_device->CreateTexture(w, h, tlevels, GSTexture::Format::Color, true);
|
|
m_source_memory_usage += dTex->GetMemUsage();
|
|
|
|
// copy the rt in
|
|
const GSVector4i area(GSVector4i(x, y, x + w, y + h).rintersect(GSVector4i(sTex->GetSize()).zwxy()));
|
|
if (!area.rempty())
|
|
g_gs_device->CopyRect(sTex, dTex, area, 0, 0);
|
|
|
|
src->m_texture = dTex;
|
|
src->m_unscaled_size = GSVector2i(tw, th);
|
|
}
|
|
else
|
|
{
|
|
GL_CACHE("TC: Sample offset (%d,%d) reduced region directly from target: %dx%d -> %dx%d @ %d,%d",
|
|
dst->m_texture->GetWidth(), x_offset, y_offset, dst->m_texture->GetHeight(), w, h, x_offset, y_offset);
|
|
|
|
if (x_offset < 0)
|
|
src->m_region.SetX(x_offset, region.GetMaxX() + x_offset);
|
|
else
|
|
src->m_region.SetX(x_offset, x_offset + tw);
|
|
if (y_offset < 0)
|
|
src->m_region.SetY(y_offset, region.GetMaxY() + y_offset);
|
|
else
|
|
src->m_region.SetY(y_offset, y_offset + th);
|
|
src->m_texture = dst->m_texture;
|
|
src->m_unscaled_size = dst->m_unscaled_size;
|
|
src->m_shared_texture = true;
|
|
}
|
|
|
|
// Invalidate immediately on recursive draws, because if we don't here, InvalidateVideoMem() will.
|
|
if (GSRendererHW::GetInstance()->IsTBPFrameOrZ(dst->m_TEX0.TBP0))
|
|
m_temporary_source = src;
|
|
|
|
// Keep a trace of origin of the texture
|
|
src->m_scale = scale;
|
|
src->m_end_block = dst->m_end_block;
|
|
src->m_target = true;
|
|
src->m_from_target = dst;
|
|
src->m_from_target_TEX0 = dst->m_TEX0;
|
|
|
|
if ((src->m_TEX0.PSM & 0xf) == PSMCT24)
|
|
{
|
|
src->m_alpha_minmax.first = TEXA.AEM ? 0 : TEXA.TA0;
|
|
src->m_alpha_minmax.second = TEXA.TA0;
|
|
}
|
|
else
|
|
{
|
|
src->m_alpha_minmax.first = dst->m_alpha_min;
|
|
src->m_alpha_minmax.second = dst->m_alpha_max;
|
|
|
|
if (!dst->m_32_bits_fmt)
|
|
{
|
|
const bool using_both = (src->m_alpha_minmax.first ^ src->m_alpha_minmax.second) & 128;
|
|
const bool using_ta1 = (src->m_alpha_minmax.second & 128);
|
|
|
|
src->m_alpha_minmax.first = TEXA.AEM ? 0 : (using_both ? std::min(TEXA.TA1, TEXA.TA0) : (using_ta1 ? TEXA.TA1 : TEXA.TA0));
|
|
src->m_alpha_minmax.second = (using_both ? std::max(TEXA.TA1, TEXA.TA0) : (using_ta1 ? TEXA.TA1 : TEXA.TA0));
|
|
}
|
|
}
|
|
src->m_32_bits_fmt = dst->m_32_bits_fmt;
|
|
|
|
if (psm.pal > 0)
|
|
{
|
|
// Attach palette for GPU texture conversion
|
|
AttachPaletteToSource(src, psm.pal, true);
|
|
}
|
|
}
|
|
else if (dst)
|
|
{
|
|
// TODO: clean up this mess
|
|
|
|
ShaderConvert shader = dst->m_type != RenderTarget ? ShaderConvert::FLOAT32_TO_RGBA8 : ShaderConvert::COPY;
|
|
channel_shuffle = GSRendererHW::GetInstance()->TestChannelShuffle(dst);
|
|
|
|
const bool is_8bits = TEX0.PSM == PSMT8 && !channel_shuffle;
|
|
if (is_8bits)
|
|
{
|
|
GL_INS("Reading RT as a packed-indexed 8 bits format");
|
|
shader = ShaderConvert::RGBA_TO_8I;
|
|
}
|
|
|
|
#ifdef ENABLE_OGL_DEBUG
|
|
if (TEX0.PSM == PSMT4)
|
|
{
|
|
GL_INS("ERROR: Reading RT as a packed-indexed 4 bits format is not supported");
|
|
}
|
|
#endif
|
|
|
|
if (GSLocalMemory::m_psm[TEX0.PSM].bpp > 8)
|
|
{
|
|
src->m_32_bits_fmt = dst->m_32_bits_fmt;
|
|
}
|
|
|
|
// Keep a trace of origin of the texture
|
|
src->m_target = true;
|
|
src->m_unscaled_size = GSVector2i(std::min(dst->m_unscaled_size.x, tw), std::min(dst->m_unscaled_size.y, th));
|
|
src->m_from_target = dst;
|
|
src->m_from_target_TEX0 = dst->m_TEX0;
|
|
src->m_valid_rect = dst->m_valid;
|
|
src->m_end_block = dst->m_end_block;
|
|
|
|
if ((src->m_TEX0.PSM & 0xf) == PSMCT24)
|
|
{
|
|
src->m_alpha_minmax.first = TEXA.AEM ? 0 : TEXA.TA0;
|
|
src->m_alpha_minmax.second = TEXA.TA0;
|
|
}
|
|
else
|
|
{
|
|
src->m_alpha_minmax.first = dst->m_alpha_min;
|
|
src->m_alpha_minmax.second = dst->m_alpha_max;
|
|
|
|
if (!dst->m_32_bits_fmt)
|
|
{
|
|
const bool using_both = (src->m_alpha_minmax.first ^ src->m_alpha_minmax.second) & 128;
|
|
const bool using_ta1 = (src->m_alpha_minmax.second & 128);
|
|
|
|
src->m_alpha_minmax.first = TEXA.AEM ? 0 : (using_both ? std::min(TEXA.TA1, TEXA.TA0) : (using_ta1 ? TEXA.TA1 : TEXA.TA0));
|
|
src->m_alpha_minmax.second = (using_both ? std::max(TEXA.TA1, TEXA.TA0) : (using_ta1 ? TEXA.TA1 : TEXA.TA0));
|
|
}
|
|
}
|
|
src->m_32_bits_fmt = dst->m_32_bits_fmt;
|
|
|
|
dst->Update();
|
|
|
|
// Rounding up should never exceed the texture size (since it itself should be rounded up), but just in case.
|
|
GSVector2i new_size(
|
|
std::min(static_cast<int>(std::ceil(static_cast<float>(src->m_unscaled_size.x) * dst->m_scale)),
|
|
dst->m_texture->GetWidth()),
|
|
std::min(static_cast<int>(std::ceil(static_cast<float>(src->m_unscaled_size.y) * dst->m_scale)),
|
|
dst->m_texture->GetHeight()));
|
|
|
|
if (is_8bits)
|
|
{
|
|
// Unscale 8 bits textures, quality won't be nice but format is really awful
|
|
src->m_unscaled_size.x = tw;
|
|
src->m_unscaled_size.y = th;
|
|
new_size.x = tw;
|
|
new_size.y = th;
|
|
}
|
|
|
|
// pitch conversion
|
|
|
|
if (dst->m_TEX0.TBW != TEX0.TBW) // && dst->m_TEX0.PSM == TEX0.PSM
|
|
{
|
|
// This is so broken :p
|
|
////Better not do the code below, "fixes" like every game that ever gets here..
|
|
////Edit: Ratchet and Clank needs this to show most of it's graphics at all.
|
|
////Someone else fix this please, I can't :p
|
|
////delete src; return NULL;
|
|
|
|
//// sfex3 uses this trick (bw: 10 -> 5, wraps the right side below the left)
|
|
|
|
//ASSERT(dst->m_TEX0.TBW > TEX0.TBW); // otherwise scale.x need to be reduced to make the larger texture fit (TODO)
|
|
|
|
//src->m_texture = g_gs_device->CreateRenderTarget(dstsize.x, dstsize.y, false);
|
|
|
|
//GSVector4 size = GSVector4(dstsize).xyxy();
|
|
//GSVector4 scale = GSVector4(dst->m_texture->GetScale()).xyxy();
|
|
|
|
//int blockWidth = 64;
|
|
//int blockHeight = TEX0.PSM == PSMCT32 || TEX0.PSM == PSMCT24 ? 32 : 64;
|
|
|
|
//GSVector4i br(0, 0, blockWidth, blockHeight);
|
|
|
|
//int sw = (int)dst->m_TEX0.TBW << 6;
|
|
|
|
//int dw = (int)TEX0.TBW << 6;
|
|
//int dh = 1 << TEX0.TH;
|
|
|
|
//if (sw != 0)
|
|
//for (int dy = 0; dy < dh; dy += blockHeight)
|
|
//{
|
|
// for (int dx = 0; dx < dw; dx += blockWidth)
|
|
// {
|
|
// int off = dy * dw / blockHeight + dx;
|
|
|
|
// int sx = off % sw;
|
|
// int sy = off / sw;
|
|
|
|
// GSVector4 sRect = GSVector4(GSVector4i(sx, sy).xyxy() + br) * scale / size;
|
|
// GSVector4 dRect = GSVector4(GSVector4i(dx, dy).xyxy() + br) * scale;
|
|
|
|
// g_gs_device->StretchRect(dst->m_texture, sRect, src->m_texture, dRect);
|
|
|
|
// // TODO: this is quite a lot of StretchRect, do it with one Draw
|
|
// }
|
|
//}
|
|
}
|
|
else if (tw < 1024)
|
|
{
|
|
// FIXME: timesplitters blurs the render target by blending itself over a couple of times
|
|
hack = true;
|
|
//if (tw == 256 && th == 128 && (TEX0.TBP0 == 0 || TEX0.TBP0 == 0x00e00))
|
|
//{
|
|
// delete src;
|
|
// return NULL;
|
|
//}
|
|
}
|
|
// width/height conversion
|
|
|
|
const float scale = is_8bits ? 1.0f : dst->m_scale;
|
|
src->m_scale = scale;
|
|
|
|
GSVector4i sRect = GSVector4i::loadh(new_size);
|
|
int destX = 0;
|
|
int destY = 0;
|
|
|
|
// Create a cleared RT if we somehow end up with an empty source rect (because the RT isn't large enough).
|
|
const bool source_rect_empty = sRect.rempty();
|
|
const bool use_texture = (shader == ShaderConvert::COPY && !source_rect_empty);
|
|
GSVector4i region_rect = GSVector4i(0, 0, tw, th);
|
|
|
|
if (half_right)
|
|
{
|
|
// You typically hit this code in snow engine game. Dstsize is the size of of Dx/GL RT
|
|
// which is set to some arbitrary number. h/w are based on the input texture
|
|
// so the only reliable way to find the real size of the target is to use the TBW value.
|
|
const int half_width = static_cast<int>(dst->m_TEX0.TBW * (64 / 2));
|
|
if (half_width < dst->m_unscaled_size.x)
|
|
{
|
|
const int copy_width = std::min(half_width, dst->m_unscaled_size.x - half_width);
|
|
region_rect = GSVector4i(half_width, 0, half_width + copy_width, th);
|
|
GL_CACHE("TC: Half right fix: %d,%d => %d,%d", region_rect.x, region_rect.y, region_rect.z, region_rect.w);
|
|
|
|
sRect = sRect.blend32<5>(GSVector4i(GSVector4(region_rect.rintersect(dst->GetUnscaledRect())) * GSVector4(dst->m_scale)));
|
|
new_size.x = sRect.width();
|
|
src->m_unscaled_size.x = copy_width;
|
|
}
|
|
else
|
|
{
|
|
DevCon.Error("Invalid half-right copy with width %d from %dx%d texture", half_width * 2, dst->m_unscaled_size.x, dst->m_unscaled_size.y);
|
|
}
|
|
}
|
|
|
|
// Assuming everything matches up, instead of copying the target, we can just sample it directly.
|
|
// It's the same as doing the copy first, except we save GPU time.
|
|
// TODO: We still need to copy if the TBW is mismatched. Except when TBW <= 1 (Jak 2).
|
|
const GSVector2i dst_texture_size = dst->m_texture->GetSize();
|
|
if ((!half_right || region_rect.z >= dst->m_unscaled_size.x) && // not a smaller subsample
|
|
use_texture && // not reinterpreting the RT
|
|
!force_target_copy)
|
|
{
|
|
// sample the target directly
|
|
src->m_texture = dst->m_texture;
|
|
src->m_scale = dst->m_scale;
|
|
src->m_unscaled_size = dst->m_unscaled_size;
|
|
src->m_shared_texture = true;
|
|
src->m_32_bits_fmt = dst->m_32_bits_fmt;
|
|
|
|
// if the size doesn't match, we need to engage shader sampling.
|
|
if (new_size != dst_texture_size)
|
|
{
|
|
GL_CACHE("TC: Sample reduced region directly from target: %dx%d -> %dx%d", dst_texture_size.x,
|
|
dst_texture_size.y, new_size.x, new_size.y);
|
|
|
|
if (new_size.x != dst_texture_size.x)
|
|
src->m_region.SetX(region_rect.x, region_rect.z);
|
|
if (new_size.y != dst_texture_size.y)
|
|
src->m_region.SetY(region_rect.y, region_rect.w);
|
|
}
|
|
|
|
// kill source immediately if it's the RT/DS, because that'll get invalidated immediately
|
|
if (GSRendererHW::GetInstance()->IsTBPFrameOrZ(dst->m_TEX0.TBP0))
|
|
{
|
|
GL_CACHE("TC: Source is RT or ZBUF, invalidating after draw.");
|
|
m_temporary_source = src;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Don't be fooled by the name. 'dst' is the old target (hence the input)
|
|
// 'src' is the new texture cache entry (hence the output)
|
|
GSTexture* sTex = dst->m_texture;
|
|
GSTexture* dTex = use_texture ?
|
|
g_gs_device->CreateTexture(new_size.x, new_size.y, 1, GSTexture::Format::Color, true) :
|
|
g_gs_device->CreateRenderTarget(new_size.x, new_size.y, GSTexture::Format::Color, source_rect_empty || destX != 0 || destY != 0);
|
|
m_source_memory_usage += dTex->GetMemUsage();
|
|
src->m_texture = dTex;
|
|
|
|
if (use_texture)
|
|
{
|
|
g_gs_device->CopyRect(sTex, dTex, sRect, destX, destY);
|
|
g_perfmon.Put(GSPerfMon::TextureCopies, 1);
|
|
}
|
|
else if (!source_rect_empty)
|
|
{
|
|
if (is_8bits)
|
|
{
|
|
g_gs_device->ConvertToIndexedTexture(sTex, dst->m_scale, x_offset, y_offset,
|
|
std::max<u32>(dst->m_TEX0.TBW, 1u) * 64, dst->m_TEX0.PSM, dTex,
|
|
std::max<u32>(TEX0.TBW, 1u) * 64, TEX0.PSM);
|
|
}
|
|
else
|
|
{
|
|
const GSVector4 sRectF = GSVector4(sRect) / GSVector4(1, 1, sTex->GetWidth(), sTex->GetHeight());
|
|
g_gs_device->StretchRect(
|
|
sTex, sRectF, dTex, GSVector4(destX, destY, new_size.x, new_size.y), shader, false);
|
|
}
|
|
|
|
g_perfmon.Put(GSPerfMon::TextureCopies, 1);
|
|
}
|
|
}
|
|
|
|
// GH: by default (m_paltex == 0) GS converts texture to the 32 bit format
|
|
// However it is different here. We want to reuse a Render Target as a texture.
|
|
// Because the texture is already on the GPU, CPU can't convert it.
|
|
if (psm.pal > 0)
|
|
{
|
|
AttachPaletteToSource(src, psm.pal, true);
|
|
}
|
|
|
|
// Offset hack. Can be enabled via GS options.
|
|
// The offset will be used in Draw().
|
|
dst->OffsetHack_modxy = hack ? g_gs_renderer->GetModXYOffset() : 0.0f;
|
|
}
|
|
else
|
|
{
|
|
if (GSUtil::GetChannelMask(TEX0.PSM) == 0xf && TEX0.TBP0 != GSRendererHW::GetInstance()->GetCachedCtx()->FRAME.Block() && TEX0.TBP0 != GSRendererHW::GetInstance()->GetCachedCtx()->ZBUF.Block())
|
|
{
|
|
// Kill any possible targets we missed, they might be wrong now.
|
|
g_texture_cache->InvalidateVideoMemType(GSTextureCache::RenderTarget, TEX0.TBP0, TEX0.PSM, GSRendererHW::GetInstance()->GetCachedCtx()->FRAME.FBMSK, true);
|
|
g_texture_cache->InvalidateVideoMemType(GSTextureCache::DepthStencil, TEX0.TBP0, TEX0.PSM, GSRendererHW::GetInstance()->GetCachedCtx()->FRAME.FBMSK, true);
|
|
}
|
|
|
|
// maintain the clut even when paltex is on for the dump/replacement texture lookup
|
|
bool paltex = (GSConfig.GPUPaletteConversion && psm.pal > 0) || gpu_clut;
|
|
const u32* clut = (psm.pal > 0) ? static_cast<const u32*>(g_gs_renderer->m_mem.m_clut) : nullptr;
|
|
|
|
// adjust texture size to fit
|
|
tw = region.HasX() ? region.GetWidth() : tw;
|
|
th = region.HasY() ? region.GetHeight() : th;
|
|
src->m_region = region;
|
|
src->m_unscaled_size = GSVector2i(tw, th);
|
|
src->m_scale = 1.0f;
|
|
|
|
// try the hash cache
|
|
if ((src->m_from_hash_cache = LookupHashCache(TEX0, TEXA, paltex, clut, lod, region)) != nullptr)
|
|
{
|
|
src->m_texture = src->m_from_hash_cache->texture;
|
|
src->m_alpha_minmax = src->m_from_hash_cache->alpha_minmax;
|
|
|
|
if (gpu_clut)
|
|
AttachPaletteToSource(src, gpu_clut);
|
|
else if (psm.pal > 0)
|
|
AttachPaletteToSource(src, psm.pal, paltex);
|
|
}
|
|
else if (paltex)
|
|
{
|
|
src->m_texture = g_gs_device->CreateTexture(tw, th, tlevels, GSTexture::Format::UNorm8);
|
|
m_source_memory_usage += src->m_texture->GetMemUsage();
|
|
if (gpu_clut)
|
|
AttachPaletteToSource(src, gpu_clut);
|
|
else
|
|
AttachPaletteToSource(src, psm.pal, true);
|
|
}
|
|
else
|
|
{
|
|
src->m_texture = g_gs_device->CreateTexture(tw, th, tlevels, GSTexture::Format::Color);
|
|
m_source_memory_usage += src->m_texture->GetMemUsage();
|
|
if (gpu_clut)
|
|
AttachPaletteToSource(src, gpu_clut);
|
|
else if (psm.pal > 0)
|
|
AttachPaletteToSource(src, psm.pal, false);
|
|
}
|
|
}
|
|
|
|
ASSERT(src->m_texture);
|
|
ASSERT(src->m_target == (dst != nullptr));
|
|
ASSERT(src->m_from_target == dst);
|
|
ASSERT(src->m_scale == ((!dst || (TEX0.PSM == PSMT8 && !channel_shuffle)) ? 1.0f : dst->m_scale));
|
|
|
|
if (src != m_temporary_source)
|
|
{
|
|
src->SetPages();
|
|
m_src.Add(src, TEX0);
|
|
}
|
|
|
|
return src;
|
|
}
|
|
|
|
GSTextureCache::Source* GSTextureCache::CreateMergedSource(GIFRegTEX0 TEX0, GIFRegTEXA TEXA, SourceRegion region, float scale)
|
|
{
|
|
// We *should* be able to use the TBW here as an indicator of size... except Destroy All Humans 2 sets
|
|
// TBW to 10, and samples from 64 through 703... which means it'd be grabbing the next row at the end.
|
|
const int tex_width = std::max<int>(64 * TEX0.TBW, region.GetMaxX());
|
|
const int tex_height = region.HasY() ? region.GetHeight() : (1 << TEX0.TH);
|
|
const int scaled_width = static_cast<int>(static_cast<float>(tex_width) * scale);
|
|
const int scaled_height = static_cast<int>(static_cast<float>(tex_height) * scale);
|
|
|
|
// Compute new end block based on size.
|
|
const u32 end_block = GSLocalMemory::m_psm[TEX0.PSM].info.bn(tex_width - 1, tex_height - 1, TEX0.TBP0, TEX0.TBW);
|
|
GL_PUSH("Merging targets from %x through %x", TEX0.TBP0, end_block);
|
|
|
|
const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[TEX0.PSM];
|
|
const int page_width = psm.pgs.x;
|
|
const int page_height = psm.pgs.y;
|
|
constexpr int page_blocks = 32;
|
|
|
|
// Number of pages to increment by for each row. This may be smaller than tex_width.
|
|
const int row_page_increment = TEX0.TBW;
|
|
const int page_block_increment = row_page_increment * page_blocks;
|
|
const int width_in_pages = (tex_width + (page_width - 1)) / page_width;
|
|
const int height_in_pages = (tex_height + (page_height - 1)) / page_height;
|
|
const int num_pages = width_in_pages * height_in_pages;
|
|
const GSVector4i page_rect(GSVector4i(psm.pgs).zwxy());
|
|
|
|
// Temporary texture for preloading local memory.
|
|
const GSOffset lm_off(psm.info, TEX0.TBP0, TEX0.TBW, TEX0.PSM);
|
|
GSTexture* lmtex = nullptr;
|
|
GSTexture::GSMap lmtex_map;
|
|
bool lmtex_mapped = false;
|
|
|
|
u8* pages_done = static_cast<u8*>(alloca((num_pages + 7) / 8));
|
|
std::memset(pages_done, 0, (num_pages + 7) / 8);
|
|
|
|
// Queue of rectangles to copy, we try to batch as many at once as possible.
|
|
// Multiply by 2 in case we need to preload.
|
|
GSDevice::MultiStretchRect* copy_queue =
|
|
static_cast<GSDevice::MultiStretchRect*>(alloca(sizeof(GSDevice::MultiStretchRect) * num_pages * 2));
|
|
u32 copy_count = 0;
|
|
|
|
// Page counters.
|
|
u32 start_TBP0 = TEX0.TBP0;
|
|
u32 current_TBP0 = start_TBP0;
|
|
int page_x = 0;
|
|
int page_y = 0;
|
|
|
|
// Helper to preload a page.
|
|
auto preload_page = [&](int dst_x, int dst_y) {
|
|
if (!lmtex)
|
|
{
|
|
lmtex = g_gs_device->CreateTexture(tex_width, tex_height, 1, GSTexture::Format::Color, false);
|
|
lmtex_mapped = lmtex->Map(lmtex_map);
|
|
}
|
|
|
|
const GSVector4i rect(
|
|
dst_x, dst_y, std::min(dst_x + page_width, tex_width), std::min(dst_y + page_height, tex_height));
|
|
|
|
if (lmtex_mapped)
|
|
{
|
|
psm.rtx(g_gs_renderer->m_mem, lm_off, rect, lmtex_map.bits + dst_y * lmtex_map.pitch + dst_x * sizeof(u32),
|
|
lmtex_map.pitch, TEXA);
|
|
}
|
|
else
|
|
{
|
|
// Slow for DX11... page_width * 4 should still be 32 byte aligned for AVX.
|
|
const int pitch = page_width * sizeof(u32);
|
|
psm.rtx(g_gs_renderer->m_mem, lm_off, rect, s_unswizzle_buffer, pitch, TEXA);
|
|
lmtex->Update(rect, s_unswizzle_buffer, pitch);
|
|
}
|
|
|
|
// Upload texture -> render target.
|
|
const bool linear = (scale != 1.0f);
|
|
copy_queue[copy_count++] = {GSVector4(rect) / GSVector4(lmtex->GetSize()).xyxy(),
|
|
GSVector4(rect) * GSVector4(scale).xyxy(), lmtex, linear, 0xf};
|
|
};
|
|
|
|
// The idea: loop through pages that this texture covers, find targets which overlap, and copy them in.
|
|
// For pages which don't have any targets covering, if preloading is enabled, load that page from local memory.
|
|
// Try to batch as much as possible, ideally this shouldn't be more than a handful of draw calls.
|
|
for (int page_num = 0; page_num < num_pages; page_num++)
|
|
{
|
|
const u32 this_start_block = current_TBP0;
|
|
const u32 this_end_block = (current_TBP0 + page_blocks) - 1;
|
|
bool found = false;
|
|
|
|
if (pages_done[page_num / 8] & (1u << (page_num % 8)))
|
|
goto next_page;
|
|
|
|
GL_INS("Searching for block range %x - %x for (%u,%u)", this_start_block, this_end_block, page_x * page_width,
|
|
page_y * page_height);
|
|
|
|
for (auto i = m_dst[RenderTarget].begin(); i != m_dst[RenderTarget].end(); ++i)
|
|
{
|
|
Target* const t = *i;
|
|
if (this_start_block >= t->m_TEX0.TBP0 && this_end_block <= t->m_end_block && GSUtil::HasCompatibleBits(t->m_TEX0.PSM, TEX0.PSM))
|
|
{
|
|
GL_INS(" Candidate at BP %x BW %d PSM %d", t->m_TEX0.TBP0, t->m_TEX0.TBW, t->m_TEX0.PSM);
|
|
|
|
// Can't copy multiple pages when we're past the TBW.. only grab one page at a time then.
|
|
GSVector4i src_rect(page_rect);
|
|
bool copy_multiple_pages = (t->m_TEX0.TBW == TEX0.TBW && page_x < row_page_increment);
|
|
int available_pages_x = 1;
|
|
int available_pages_y = 1;
|
|
if (copy_multiple_pages)
|
|
{
|
|
// TBW matches, we can copy multiple pages.
|
|
available_pages_x = (row_page_increment - page_x);
|
|
available_pages_y = (height_in_pages - page_y);
|
|
src_rect.z = available_pages_x * page_width;
|
|
src_rect.w = available_pages_y * page_height;
|
|
}
|
|
|
|
// Why do we do this? Things go really haywire when we try to get surface offsets when
|
|
// the valid rect isn't starting at 0. In most cases, the target has been cleared anyway,
|
|
// so we really should be setting this to 0, not the draw...
|
|
//
|
|
// Guitar Hero needs it, the player meshes don't necessarily touch the corner, and so
|
|
// does Aqua Teen Hunger Force.
|
|
//
|
|
const GSVector4i t_rect(t->m_valid.insert64<0>(0));
|
|
|
|
SurfaceOffset so;
|
|
if (this_start_block > t->m_TEX0.TBP0)
|
|
{
|
|
SurfaceOffsetKey sok;
|
|
sok.elems[0].bp = this_start_block;
|
|
sok.elems[0].bw = TEX0.TBW;
|
|
sok.elems[0].psm = TEX0.PSM;
|
|
sok.elems[0].rect = src_rect;
|
|
sok.elems[1].bp = t->m_TEX0.TBP0;
|
|
sok.elems[1].bw = t->m_TEX0.TBW;
|
|
sok.elems[1].psm = t->m_TEX0.PSM;
|
|
sok.elems[1].rect = t_rect;
|
|
so = ComputeSurfaceOffset(sok);
|
|
if (!so.is_valid)
|
|
goto next_page;
|
|
}
|
|
else
|
|
{
|
|
so.is_valid = true;
|
|
so.b2a_offset = src_rect.rintersect(t_rect);
|
|
}
|
|
|
|
// Adjust to what the target actually has.
|
|
if (copy_multiple_pages)
|
|
{
|
|
// Min here because we don't want to go off the end of the target.
|
|
available_pages_x = std::min(available_pages_x, (so.b2a_offset.width() + (psm.pgs.x - 1)) / psm.pgs.x);
|
|
available_pages_y = std::min(available_pages_y, (so.b2a_offset.height() + (psm.pgs.y - 1)) / psm.pgs.y);
|
|
}
|
|
|
|
// We might not even have a full page valid..
|
|
const bool linear = (scale != t->m_scale);
|
|
const int src_x_end = so.b2a_offset.z;
|
|
const int src_y_end = so.b2a_offset.w;
|
|
int src_y = so.b2a_offset.y;
|
|
int dst_y = page_y * page_height;
|
|
int current_copy_page = page_num;
|
|
|
|
for (int copy_page_y = 0; copy_page_y < available_pages_y; copy_page_y++)
|
|
{
|
|
if (src_y >= src_y_end)
|
|
break;
|
|
|
|
const int wanted_height = std::min(tex_height - dst_y, page_height);
|
|
const int copy_height = std::min(src_y_end - src_y, wanted_height);
|
|
int src_x = so.b2a_offset.x;
|
|
int dst_x = page_x * page_width;
|
|
int row_page = current_copy_page;
|
|
pxAssert(dst_y < tex_height && copy_height > 0);
|
|
|
|
for (int copy_page_x = 0; copy_page_x < available_pages_x; copy_page_x++)
|
|
{
|
|
if (src_x >= src_x_end)
|
|
break;
|
|
|
|
if ((pages_done[row_page / 8] & (1u << (row_page % 8))) == 0)
|
|
{
|
|
pages_done[row_page / 8] |= (1u << (row_page % 8));
|
|
|
|
// In case a whole page isn't valid.
|
|
const int wanted_width = std::min(tex_width - dst_x, page_width);
|
|
const int copy_width = std::min(src_x_end - src_x, wanted_width);
|
|
pxAssert(dst_x < tex_width && copy_width > 0);
|
|
|
|
// Preload any missing parts. This will happen when the valid rect isn't page aligned.
|
|
if (GSConfig.PreloadFrameWithGSData &&
|
|
(copy_width < wanted_width || copy_height < wanted_height))
|
|
{
|
|
preload_page(dst_x, dst_y);
|
|
}
|
|
|
|
GL_INS(" Copy from %d,%d -> %d,%d (%dx%d)", src_x, src_y, dst_x, dst_y, copy_width, copy_height);
|
|
copy_queue[copy_count++] = {
|
|
(GSVector4(src_x, src_y, src_x + copy_width, src_y + copy_height) *
|
|
GSVector4(t->m_scale).xyxy()) /
|
|
GSVector4(t->m_texture->GetSize()).xyxy(),
|
|
GSVector4(dst_x, dst_y, dst_x + copy_width, dst_y + copy_height) *
|
|
GSVector4(scale).xyxy(),
|
|
t->m_texture, linear, 0xf };
|
|
}
|
|
|
|
row_page++;
|
|
src_x += page_width;
|
|
dst_x += page_width;
|
|
}
|
|
|
|
current_copy_page += width_in_pages;
|
|
src_y += page_height;
|
|
dst_y += page_height;
|
|
}
|
|
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
{
|
|
if (GSConfig.PreloadFrameWithGSData)
|
|
{
|
|
pages_done[page_num / 8] |= (1u << (page_num % 8));
|
|
|
|
GL_INS(" *** NOT FOUND, preloading from local memory");
|
|
const int dst_x = page_x * page_width;
|
|
const int dst_y = page_y * page_height;
|
|
preload_page(dst_x, dst_y);
|
|
}
|
|
else
|
|
{
|
|
GL_INS(" *** NOT FOUND");
|
|
}
|
|
}
|
|
|
|
next_page:
|
|
current_TBP0 += page_blocks;
|
|
page_x++;
|
|
if (page_x == width_in_pages)
|
|
{
|
|
start_TBP0 += page_block_increment;
|
|
current_TBP0 = start_TBP0;
|
|
page_x = 0;
|
|
page_y++;
|
|
}
|
|
}
|
|
|
|
// If we didn't find anything, abort.
|
|
if (copy_count == 0)
|
|
{
|
|
GL_INS("No sources found.");
|
|
return nullptr;
|
|
}
|
|
|
|
// Actually do the drawing.
|
|
if (lmtex_mapped)
|
|
lmtex->Unmap();
|
|
|
|
// Allocate our render target for drawing everything to.
|
|
GSTexture* dtex = g_gs_device->CreateRenderTarget(scaled_width, scaled_height, GSTexture::Format::Color, true);
|
|
m_source_memory_usage += dtex->GetMemUsage();
|
|
|
|
// Sort rect list by the texture, we want to batch as many as possible together.
|
|
g_gs_device->SortMultiStretchRects(copy_queue, copy_count);
|
|
g_gs_device->DrawMultiStretchRects(copy_queue, copy_count, dtex, ShaderConvert::COPY);
|
|
g_perfmon.Put(GSPerfMon::TextureCopies, 1);
|
|
|
|
if (lmtex)
|
|
g_gs_device->Recycle(lmtex);
|
|
|
|
Source* src = new Source(TEX0, TEXA);
|
|
src->m_texture = dtex;
|
|
src->m_scale = scale;
|
|
src->m_unscaled_size = GSVector2i(tex_width, tex_height);
|
|
src->m_end_block = end_block;
|
|
src->m_target = true;
|
|
|
|
// Can't use the normal SetPages() here, it'll try to use TW/TH, which might be bad.
|
|
const GSOffset offset = g_gs_renderer->m_mem.GetOffset(TEX0.TBP0, TEX0.TBW, TEX0.PSM);
|
|
src->m_pages = offset.pageLooperForRect(GSVector4i(0, 0, tex_width, tex_height));
|
|
m_src.Add(src, TEX0);
|
|
|
|
return src;
|
|
}
|
|
|
|
// This really needs a better home...
|
|
extern bool FMVstarted;
|
|
|
|
GSTextureCache::HashCacheEntry* GSTextureCache::LookupHashCache(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, bool& paltex, const u32* clut, const GSVector2i* lod, SourceRegion region)
|
|
{
|
|
// don't bother hashing if we're not dumping or replacing.
|
|
const bool dump = GSConfig.DumpReplaceableTextures && (!FMVstarted || GSConfig.DumpTexturesWithFMVActive) &&
|
|
(clut ? GSConfig.DumpPaletteTextures : GSConfig.DumpDirectTextures);
|
|
const bool replace = GSConfig.LoadTextureReplacements && GSTextureReplacements::HasAnyReplacementTextures();
|
|
bool can_cache = (TEX0.PSM >= PSMT8H && TEX0.PSM <= PSMT4HH) ? CanPreloadTextureSize(TEX0.TW, TEX0.TH) : CanCacheTextureSize(TEX0.TW, TEX0.TH);
|
|
if (!dump && !replace && !can_cache)
|
|
return nullptr;
|
|
|
|
// need the hash either for replacing, dumping or caching.
|
|
// if dumping/replacing is on, we compute the clut hash regardless, since replacements aren't indexed
|
|
HashCacheKey key{ HashCacheKey::Create(TEX0, TEXA, (dump || replace || !paltex) ? clut : nullptr, lod, region) };
|
|
|
|
// handle dumping first, this is mostly isolated.
|
|
if (dump)
|
|
{
|
|
// dump base level
|
|
GSTextureReplacements::DumpTexture(key, TEX0, TEXA, region, g_gs_renderer->m_mem, 0);
|
|
|
|
// and the mips
|
|
if (lod && GSConfig.DumpReplaceableMipmaps)
|
|
{
|
|
const int basemip = lod->x;
|
|
const int nmips = lod->y - lod->x + 1;
|
|
for (int mip = 1; mip < nmips; mip++)
|
|
{
|
|
const GIFRegTEX0 MIP_TEX0{ g_gs_renderer->GetTex0Layer(basemip + mip) };
|
|
GSTextureReplacements::DumpTexture(key, MIP_TEX0, TEXA, region, g_gs_renderer->m_mem, mip);
|
|
}
|
|
}
|
|
}
|
|
|
|
// check with the full key
|
|
auto it = m_hash_cache.find(key);
|
|
|
|
// if this fails, and paltex is on, try indexed texture
|
|
const bool needs_second_lookup = paltex && (dump || replace);
|
|
if (needs_second_lookup && it == m_hash_cache.end())
|
|
it = m_hash_cache.find(key.WithRemovedCLUTHash());
|
|
|
|
// did we find either a replacement, cached/indexed texture?
|
|
if (it != m_hash_cache.end())
|
|
{
|
|
// super easy, cache hit. remove paltex if it's a replacement texture.
|
|
GL_CACHE("HC Hit: %" PRIx64 " %" PRIx64 " R-%" PRIx64, key.TEX0Hash, key.CLUTHash, key.region.bits);
|
|
HashCacheEntry* entry = &it->second;
|
|
paltex &= (entry->texture->GetFormat() == GSTexture::Format::UNorm8);
|
|
entry->refcount++;
|
|
return entry;
|
|
}
|
|
|
|
// cache miss.
|
|
GL_CACHE("HC Miss: %" PRIx64 " %" PRIx64 " R-%" PRIx64, key.TEX0Hash, key.CLUTHash, key.region.bits);
|
|
|
|
// check for a replacement texture with the full clut key
|
|
if (replace)
|
|
{
|
|
bool replacement_texture_pending = false;
|
|
std::pair<u8, u8> alpha_minmax;
|
|
GSTexture* replacement_tex = GSTextureReplacements::LookupReplacementTexture(key, lod != nullptr,
|
|
&replacement_texture_pending, &alpha_minmax);
|
|
if (replacement_tex)
|
|
{
|
|
// found a replacement texture! insert it into the hash cache, and clear paltex (since it's not indexed)
|
|
paltex = false;
|
|
const HashCacheEntry entry{ replacement_tex, 1u, 0u, alpha_minmax, true };
|
|
m_hash_cache_replacement_memory_usage += entry.texture->GetMemUsage();
|
|
return &m_hash_cache.emplace(key, entry).first->second;
|
|
}
|
|
else if (
|
|
replacement_texture_pending ||
|
|
|
|
// With preloading + paltex; when there's multiple textures with the same vram data, but different
|
|
// palettes, if we don't replace all of them, the first one to get loaded in will prevent any of the
|
|
// others from getting tested for replacement. So, disable paltex for the textures when any of the
|
|
// palette variants have replacements.
|
|
(paltex && GSTextureReplacements::HasReplacementTextureWithOtherPalette(key)))
|
|
{
|
|
// We didn't have a texture immediately, but there is a replacement available (and being loaded).
|
|
// so clear paltex, since when it gets injected back, it's not going to be indexed.
|
|
paltex = false;
|
|
|
|
// If the hash cache is disabled, this will be false, and we need to force it to be cached,
|
|
// so that when the replacement comes back, there's something for it to swap with.
|
|
can_cache = true;
|
|
}
|
|
}
|
|
|
|
// Using paltex without full preloading is a disaster case here. basically, unless *all* textures are
|
|
// replaced, any texture can get populated without the hash cache, which means it'll get partial invalidated,
|
|
// and unless it's 100% removed, this partial texture will always take precedence over future hash cache
|
|
// lookups, making replacements impossible.
|
|
if (paltex && !can_cache && TEX0.TW <= MAXIMUM_TEXTURE_HASH_CACHE_SIZE && TEX0.TH <= MAXIMUM_TEXTURE_HASH_CACHE_SIZE)
|
|
{
|
|
// We only need to remove paltex here if we're dumping, because we need all the palette permutations.
|
|
paltex &= !dump;
|
|
|
|
// We need to get it into the hash cache for dumping and replacing, because of the issue above.
|
|
can_cache = true;
|
|
}
|
|
|
|
// if this texture isn't cacheable, bail out now since we don't want to waste time preloading it
|
|
if (!can_cache)
|
|
return nullptr;
|
|
|
|
// expand/upload texture
|
|
const int tw = region.HasX() ? region.GetWidth() : (1 << TEX0.TW);
|
|
const int th = region.HasY() ? region.GetHeight() : (1 << TEX0.TH);
|
|
const int tlevels = lod ? ((GSConfig.HWMipmap != HWMipmapLevel::Full) ? -1 : (lod->y - lod->x + 1)) : 1;
|
|
GSTexture* tex = g_gs_device->CreateTexture(tw, th, tlevels, paltex ? GSTexture::Format::UNorm8 : GSTexture::Format::Color);
|
|
if (!tex)
|
|
{
|
|
// out of video memory if we hit here
|
|
return nullptr;
|
|
}
|
|
|
|
// upload base level
|
|
const bool is_direct = (GSLocalMemory::m_psm[TEX0.PSM].pal == 0);
|
|
std::pair<u8, u8> alpha_minmax = {0u, 255u};
|
|
PreloadTexture(TEX0, TEXA, region, g_gs_renderer->m_mem, paltex, tex, 0, is_direct ? &alpha_minmax : nullptr);
|
|
|
|
// upload mips if present
|
|
if (lod)
|
|
{
|
|
const int basemip = lod->x;
|
|
const int nmips = lod->y - lod->x + 1;
|
|
for (int mip = 1; mip < nmips; mip++)
|
|
{
|
|
const GIFRegTEX0 MIP_TEX0{g_gs_renderer->GetTex0Layer(basemip + mip)};
|
|
std::pair<u8, u8> mip_alpha_minmax;
|
|
PreloadTexture(MIP_TEX0, TEXA, region.AdjustForMipmap(mip), g_gs_renderer->m_mem, paltex, tex, mip,
|
|
is_direct ? &mip_alpha_minmax : nullptr);
|
|
if (!is_direct)
|
|
{
|
|
alpha_minmax.first = std::min(alpha_minmax.first, mip_alpha_minmax.first);
|
|
alpha_minmax.second = std::max(alpha_minmax.second, mip_alpha_minmax.second);
|
|
}
|
|
}
|
|
}
|
|
|
|
// remove the palette hash when using paltex/indexed
|
|
if (paltex)
|
|
key.RemoveCLUTHash();
|
|
|
|
// insert into the cache cache, and we're done
|
|
const HashCacheEntry entry{tex, 1u, 0u, alpha_minmax, false};
|
|
m_hash_cache_memory_usage += tex->GetMemUsage();
|
|
return &m_hash_cache.emplace(key, entry).first->second;
|
|
}
|
|
|
|
void GSTextureCache::RemoveFromHashCache(HashCacheMap::iterator it)
|
|
{
|
|
HashCacheEntry& e = it->second;
|
|
const u32 mem_usage = e.texture->GetMemUsage();
|
|
if (e.is_replacement)
|
|
m_hash_cache_replacement_memory_usage -= mem_usage;
|
|
else
|
|
m_hash_cache_memory_usage -= mem_usage;
|
|
g_gs_device->Recycle(e.texture);
|
|
m_hash_cache.erase(it);
|
|
}
|
|
|
|
void GSTextureCache::AgeHashCache()
|
|
{
|
|
// Where did this number come from?
|
|
// A game called Corvette draws its background FMVs with a ton of 17x17 tiles, which ends up
|
|
// being about 600 texture uploads per frame. We'll use 800 as an upper bound for a bit of
|
|
// a buffer, hopefully nothing's going to end up with more textures than that.
|
|
constexpr u32 MAX_HASH_CACHE_SIZE = 800;
|
|
constexpr u32 MAX_HASH_CACHE_AGE = 30;
|
|
|
|
bool might_need_cache_purge = (m_hash_cache.size() > MAX_HASH_CACHE_SIZE);
|
|
if (might_need_cache_purge)
|
|
s_hash_cache_purge_list.clear();
|
|
|
|
for (auto it = m_hash_cache.begin(); it != m_hash_cache.end();)
|
|
{
|
|
HashCacheEntry& e = it->second;
|
|
if (e.refcount > 0)
|
|
{
|
|
++it;
|
|
continue;
|
|
}
|
|
|
|
if (++e.age > MAX_HASH_CACHE_AGE)
|
|
{
|
|
RemoveFromHashCache(it++);
|
|
continue;
|
|
}
|
|
|
|
// We might free up enough just with "normal" removals above.
|
|
if (might_need_cache_purge)
|
|
{
|
|
might_need_cache_purge = (m_hash_cache.size() > MAX_HASH_CACHE_SIZE);
|
|
if (might_need_cache_purge)
|
|
s_hash_cache_purge_list.emplace_back(it, static_cast<s32>(e.age));
|
|
}
|
|
|
|
++it;
|
|
}
|
|
|
|
// Pushing to a list, sorting, and removing ends up faster than re-iterating the map.
|
|
if (might_need_cache_purge)
|
|
{
|
|
std::sort(s_hash_cache_purge_list.begin(), s_hash_cache_purge_list.end(),
|
|
[](const auto& lhs, const auto& rhs) { return lhs.second > rhs.second; });
|
|
|
|
const u32 entries_to_purge = std::min(static_cast<u32>(m_hash_cache.size() - MAX_HASH_CACHE_SIZE),
|
|
static_cast<u32>(s_hash_cache_purge_list.size()));
|
|
for (u32 i = 0; i < entries_to_purge; i++)
|
|
RemoveFromHashCache(s_hash_cache_purge_list[i].first);
|
|
}
|
|
}
|
|
|
|
GSTextureCache::Target* GSTextureCache::Target::Create(GIFRegTEX0 TEX0, int w, int h, float scale, int type, bool clear)
|
|
{
|
|
ASSERT(type == RenderTarget || type == DepthStencil);
|
|
|
|
const int scaled_w = static_cast<int>(std::ceil(static_cast<float>(w) * scale));
|
|
const int scaled_h = static_cast<int>(std::ceil(static_cast<float>(h) * scale));
|
|
GSTexture* texture = (type == RenderTarget) ?
|
|
g_gs_device->CreateRenderTarget(scaled_w, scaled_h, GSTexture::Format::Color, clear) :
|
|
g_gs_device->CreateDepthStencil(scaled_w, scaled_h, GSTexture::Format::DepthStencil, clear);
|
|
if (!texture)
|
|
return nullptr;
|
|
|
|
Target* t = new Target(TEX0, type, GSVector2i(w, h), scale, texture);
|
|
|
|
g_texture_cache->m_target_memory_usage += t->m_texture->GetMemUsage();
|
|
|
|
g_texture_cache->m_dst[type].push_front(t);
|
|
|
|
return t;
|
|
}
|
|
|
|
GSTexture* GSTextureCache::LookupPaletteSource(u32 CBP, u32 CPSM, u32 CBW, GSVector2i& offset, float* scale, const GSVector2i& size)
|
|
{
|
|
for (auto t : m_dst[RenderTarget])
|
|
{
|
|
if (!t->m_used)
|
|
continue;
|
|
|
|
GSVector2i this_offset;
|
|
if (t->m_TEX0.TBP0 == CBP)
|
|
{
|
|
// Exact match, this one's likely fine, unless the format is different.
|
|
if (t->m_TEX0.PSM != CPSM || (CBW != 0 && t->m_TEX0.TBW != CBW))
|
|
continue;
|
|
|
|
GL_INS("Exact match on BP 0x%04x BW %u", t->m_TEX0.TBP0, t->m_TEX0.TBW);
|
|
this_offset.x = 0;
|
|
this_offset.y = 0;
|
|
}
|
|
else if (GSConfig.UserHacks_GPUTargetCLUTMode == GSGPUTargetCLUTMode::InsideTarget &&
|
|
t->m_TEX0.TBP0 < CBP && t->m_end_block >= CBP)
|
|
{
|
|
// Somewhere within this target, can we find it?
|
|
const GSVector4i rc(0, 0, size.x, size.y);
|
|
SurfaceOffset so = ComputeSurfaceOffset(CBP, std::max<u32>(CBW, 0), CPSM, rc, t);
|
|
if (!so.is_valid)
|
|
continue;
|
|
|
|
GL_INS("Match inside RT at BP 0x%04X-0x%04X BW %u", t->m_TEX0.TBP0, t->m_end_block, t->m_TEX0.TBW);
|
|
this_offset.x = so.b2a_offset.left;
|
|
this_offset.y = so.b2a_offset.top;
|
|
}
|
|
else
|
|
{
|
|
// Not inside this target, skip.
|
|
continue;
|
|
}
|
|
|
|
// Make sure the clut isn't in an area of the target where the EE has overwritten it.
|
|
// Otherwise, we'll be using stale data on the CPU.
|
|
if (!t->m_dirty.empty())
|
|
{
|
|
GL_INS("Candidate is dirty, checking");
|
|
|
|
const GSVector4i clut_rc(this_offset.x, this_offset.y, this_offset.x + size.x, this_offset.y + size.y);
|
|
bool is_dirty = false;
|
|
for (GSDirtyRect& dirty : t->m_dirty)
|
|
{
|
|
if (!dirty.GetDirtyRect(t->m_TEX0, false).rintersect(clut_rc).rempty())
|
|
{
|
|
GL_INS("Dirty rectangle overlaps CLUT rectangle, skipping");
|
|
is_dirty = true;
|
|
break;
|
|
}
|
|
}
|
|
if (is_dirty)
|
|
continue;
|
|
}
|
|
|
|
offset = this_offset;
|
|
*scale = t->m_scale;
|
|
return t->m_texture;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
std::shared_ptr<GSTextureCache::Palette> GSTextureCache::LookupPaletteObject(const u32* clut, u16 pal, bool need_gs_texture)
|
|
{
|
|
return m_palette_map.LookupPalette(clut, pal, need_gs_texture);
|
|
}
|
|
|
|
void GSTextureCache::Read(Target* t, const GSVector4i& r)
|
|
{
|
|
if ((!t->m_dirty.empty() && !t->m_dirty.GetTotalRect(t->m_TEX0, t->m_unscaled_size).rintersect(r).rempty())
|
|
|| r.width() == 0 || r.height() == 0)
|
|
return;
|
|
|
|
const GIFRegTEX0& TEX0 = t->m_TEX0;
|
|
const bool is_depth = (t->m_type == DepthStencil);
|
|
|
|
GSTexture::Format fmt;
|
|
ShaderConvert ps_shader;
|
|
std::unique_ptr<GSDownloadTexture>* dltex;
|
|
switch (TEX0.PSM)
|
|
{
|
|
case PSMCT32:
|
|
case PSMCT24:
|
|
{
|
|
// If we're downloading a depth buffer that's been reinterpreted as a color
|
|
// format, convert it to integer. The format/swizzle is likely wrong, but it's
|
|
// better than writing back FP values to local memory.
|
|
if (is_depth)
|
|
{
|
|
fmt = GSTexture::Format::UInt32;
|
|
ps_shader = ShaderConvert::FLOAT32_TO_32_BITS;
|
|
dltex = &m_uint32_download_texture;
|
|
}
|
|
else
|
|
{
|
|
fmt = GSTexture::Format::Color;
|
|
ps_shader = ShaderConvert::COPY;
|
|
dltex = &m_color_download_texture;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case PSMCT16:
|
|
case PSMCT16S:
|
|
{
|
|
fmt = GSTexture::Format::UInt16;
|
|
ps_shader = is_depth ? ShaderConvert::FLOAT32_TO_16_BITS : ShaderConvert::RGBA8_TO_16_BITS;
|
|
dltex = &m_uint16_download_texture;
|
|
}
|
|
break;
|
|
|
|
case PSMZ32:
|
|
case PSMZ24:
|
|
{
|
|
fmt = GSTexture::Format::UInt32;
|
|
ps_shader = ShaderConvert::FLOAT32_TO_32_BITS;
|
|
dltex = &m_uint32_download_texture;
|
|
}
|
|
break;
|
|
|
|
case PSMZ16:
|
|
case PSMZ16S:
|
|
{
|
|
fmt = GSTexture::Format::UInt16;
|
|
ps_shader = ShaderConvert::FLOAT32_TO_16_BITS;
|
|
dltex = &m_uint16_download_texture;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
|
|
// Don't overwrite bits which aren't used in the target's format.
|
|
// Stops Burnout 3's sky from breaking when flushing targets to local memory.
|
|
const u32 write_mask = (t->m_valid_rgb ? 0x00FFFFFFu : 0) | (t->m_valid_alpha_low ? 0x0F000000u : 0) | (t->m_valid_alpha_high ? 0xF0000000u : 0);
|
|
if (write_mask == 0)
|
|
{
|
|
DbgCon.Warning("Not reading back target %x PSM %s due to no write mask", TEX0.TBP0, psm_str(TEX0.PSM));
|
|
return;
|
|
}
|
|
|
|
GL_PERF("TC: Read Back Target: (0x%x)[fmt: 0x%x]. Size %dx%d", TEX0.TBP0, TEX0.PSM, r.width(), r.height());
|
|
|
|
const GSVector4 src(GSVector4(r) * GSVector4(t->m_scale) / GSVector4(t->m_texture->GetSize()).xyxy());
|
|
const GSVector4i drc(0, 0, r.width(), r.height());
|
|
const bool direct_read = (t->m_type == RenderTarget && t->m_scale == 1.0f && ps_shader == ShaderConvert::COPY);
|
|
|
|
if (!PrepareDownloadTexture(drc.z, drc.w, fmt, dltex))
|
|
return;
|
|
|
|
if (direct_read)
|
|
{
|
|
dltex->get()->CopyFromTexture(drc, t->m_texture, r, 0, true);
|
|
}
|
|
else
|
|
{
|
|
GSTexture* tmp = g_gs_device->CreateRenderTarget(drc.z, drc.w, fmt, false);
|
|
if (tmp)
|
|
{
|
|
g_gs_device->StretchRect(t->m_texture, src, tmp, GSVector4(drc), ps_shader, false);
|
|
g_perfmon.Put(GSPerfMon::TextureCopies, 1);
|
|
dltex->get()->CopyFromTexture(drc, tmp, drc, 0, true);
|
|
g_gs_device->Recycle(tmp);
|
|
}
|
|
else
|
|
{
|
|
Console.Error("Failed to allocate temporary %dx%d target for read.", drc.z, drc.w);
|
|
return;
|
|
}
|
|
}
|
|
|
|
dltex->get()->Flush();
|
|
if (!dltex->get()->Map(drc))
|
|
return;
|
|
|
|
// Why does WritePixelNN() not take a const pointer?
|
|
const GSOffset off = g_gs_renderer->m_mem.GetOffset(TEX0.TBP0, TEX0.TBW, TEX0.PSM);
|
|
u8* bits = const_cast<u8*>(dltex->get()->GetMapPointer());
|
|
const u32 pitch = dltex->get()->GetMapPitch();
|
|
|
|
switch (TEX0.PSM)
|
|
{
|
|
case PSMCT32:
|
|
case PSMZ32:
|
|
case PSMCT24:
|
|
case PSMZ24:
|
|
g_gs_renderer->m_mem.WritePixel32(bits, pitch, off, r, write_mask);
|
|
break;
|
|
case PSMCT16:
|
|
case PSMCT16S:
|
|
case PSMZ16:
|
|
case PSMZ16S:
|
|
g_gs_renderer->m_mem.WritePixel16(bits, pitch, off, r);
|
|
break;
|
|
|
|
default:
|
|
Console.Error("Unknown PSM %u on Read", TEX0.PSM);
|
|
break;
|
|
}
|
|
|
|
dltex->get()->Unmap();
|
|
}
|
|
|
|
void GSTextureCache::Read(Source* t, const GSVector4i& r)
|
|
{
|
|
if (r.rempty())
|
|
return;
|
|
|
|
const GSVector4i drc(0, 0, r.width(), r.height());
|
|
|
|
if (!PrepareDownloadTexture(drc.z, drc.w, GSTexture::Format::Color, &m_color_download_texture))
|
|
return;
|
|
|
|
m_color_download_texture->CopyFromTexture(drc, t->m_texture, r, 0, true);
|
|
m_color_download_texture->Flush();
|
|
|
|
if (m_color_download_texture->Map(drc))
|
|
{
|
|
const GSOffset off = g_gs_renderer->m_mem.GetOffset(t->m_TEX0.TBP0, t->m_TEX0.TBW, t->m_TEX0.PSM);
|
|
g_gs_renderer->m_mem.WritePixel32(
|
|
const_cast<u8*>(m_color_download_texture->GetMapPointer()), m_color_download_texture->GetMapPitch(), off, r);
|
|
m_color_download_texture->Unmap();
|
|
}
|
|
}
|
|
|
|
// GSTextureCache::Surface
|
|
|
|
GSTextureCache::Surface::Surface() = default;
|
|
|
|
GSTextureCache::Surface::~Surface() = default;
|
|
|
|
bool GSTextureCache::Surface::Inside(u32 bp, u32 bw, u32 psm, const GSVector4i& rect)
|
|
{
|
|
// Valid only for color formats.
|
|
const GSOffset off(GSLocalMemory::m_psm[psm].info, bp, bw, psm);
|
|
const u32 end_block = off.bnNoWrap(rect.z - 1, rect.w - 1);
|
|
return bp >= m_TEX0.TBP0 && end_block <= UnwrappedEndBlock();
|
|
}
|
|
|
|
bool GSTextureCache::Surface::Overlaps(u32 bp, u32 bw, u32 psm, const GSVector4i& rect)
|
|
{
|
|
const GSOffset off(GSLocalMemory::m_psm[psm].info, bp, bw, psm);
|
|
|
|
// Computing the end block from the bottom-right pixel will not be correct for Z formats,
|
|
// as the block swizzle is not sequential.
|
|
u32 end_block = off.bnNoWrap(rect.z - 1, rect.w - 1);
|
|
u32 start_block = off.bnNoWrap(rect.x, rect.y);
|
|
|
|
// So, if the rectangle we're checking is page-aligned, round the block number up to the end of the page.
|
|
const GSVector2i page_size = GSLocalMemory::m_psm[psm].pgs;
|
|
if ((rect.z & (page_size.x - 1)) == 0 && (rect.w & (page_size.y - 1)) == 0)
|
|
{
|
|
constexpr u32 page_mask = (1 << 5) - 1;
|
|
end_block = (((end_block + page_mask) & ~page_mask)) - 1;
|
|
}
|
|
// Due to block ordering, end can be below start in a page, so if it's within a page, swap them.
|
|
else if (end_block < start_block && ((start_block - end_block) < (1 << 5)))
|
|
{
|
|
std::swap(start_block, end_block);
|
|
}
|
|
|
|
// Wrapping around to the beginning of memory.
|
|
if (end_block > MAX_BLOCKS && bp < m_end_block && m_end_block < m_TEX0.TBP0)
|
|
bp += MAX_BLOCKS;
|
|
|
|
const bool overlap = GSTextureCache::CheckOverlap(m_TEX0.TBP0, UnwrappedEndBlock(), start_block, end_block);
|
|
return overlap;
|
|
}
|
|
|
|
// GSTextureCache::Source
|
|
|
|
GSTextureCache::Source::Source(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA)
|
|
{
|
|
m_TEX0 = TEX0;
|
|
m_TEXA = TEXA;
|
|
}
|
|
|
|
GSTextureCache::Source::~Source()
|
|
{
|
|
_aligned_free(m_write.rect);
|
|
|
|
// Shared textures are pointers copy. Therefore no allocation
|
|
// to recycle.
|
|
if (!m_shared_texture && !m_from_hash_cache && m_texture)
|
|
{
|
|
g_texture_cache->m_source_memory_usage -= m_texture->GetMemUsage();
|
|
g_gs_device->Recycle(m_texture);
|
|
}
|
|
}
|
|
|
|
bool GSTextureCache::Source::IsPaletteFormat() const
|
|
{
|
|
return (GSLocalMemory::m_psm[m_TEX0.PSM].pal > 0);
|
|
}
|
|
|
|
void GSTextureCache::Source::SetPages()
|
|
{
|
|
const int tw = 1 << m_TEX0.TW;
|
|
const int th = 1 << m_TEX0.TH;
|
|
|
|
m_repeating = !m_from_hash_cache && m_TEX0.IsRepeating() && !m_region.IsFixedTEX0(tw, th);
|
|
|
|
if (m_repeating && !m_target && !CanPreload())
|
|
{
|
|
// TODO: wrong for lupin/invalid tex0
|
|
m_p2t = g_gs_renderer->m_mem.GetPage2TileMap(m_TEX0);
|
|
}
|
|
|
|
// Target regions are inverted - we're pointing to an area from the target BP, which might be offset,
|
|
// not an area from the source BP which is definitely offset. So use the target's BP instead, otherwise
|
|
// if the target gets invalidated, and we're offset, and the area doesn't cover us, we won't get removed.
|
|
const GSOffset offset =
|
|
(m_target && m_region.HasEither()) ?
|
|
g_gs_renderer->m_mem.GetOffset(m_from_target_TEX0.TBP0, m_from_target_TEX0.TBW, m_from_target_TEX0.PSM) :
|
|
g_gs_renderer->m_mem.GetOffset(m_TEX0.TBP0, m_TEX0.TBW, m_TEX0.PSM);
|
|
const GSVector4i rect = m_region.GetRect(tw, th);
|
|
m_pages = offset.pageLooperForRect(rect);
|
|
}
|
|
|
|
void GSTextureCache::Source::Update(const GSVector4i& rect, int level)
|
|
{
|
|
m_age = 0;
|
|
if (m_from_target)
|
|
m_from_target->m_age = 0;
|
|
|
|
if (m_target || m_from_hash_cache || (m_complete_layers & (1u << level)))
|
|
return;
|
|
|
|
if (CanPreload())
|
|
{
|
|
PreloadLevel(level);
|
|
return;
|
|
}
|
|
|
|
const GSVector2i& bs = GSLocalMemory::m_psm[m_TEX0.PSM].bs;
|
|
const int tw = 1 << m_TEX0.TW;
|
|
const int th = 1 << m_TEX0.TH;
|
|
|
|
GSVector4i r(rect);
|
|
const GSVector4i region_rect(m_region.GetRect(tw, th));
|
|
|
|
// Clamp to region, the input rect should already be moved to it.
|
|
if (m_region.HasEither())
|
|
r = r.rintersect(region_rect);
|
|
|
|
r = r.ralign<Align_Outside>(bs);
|
|
|
|
if (region_rect.eq(r.rintersect(region_rect)))
|
|
m_complete_layers |= (1u << level);
|
|
|
|
const GSOffset off = g_gs_renderer->m_mem.GetOffset(m_TEX0.TBP0, m_TEX0.TBW, m_TEX0.PSM);
|
|
GSOffset::BNHelper bn = off.bnMulti(r.left, r.top);
|
|
|
|
u32 blocks = 0;
|
|
|
|
if (!m_valid)
|
|
m_valid = std::make_unique<u32[]>(MAX_PAGES);
|
|
|
|
if (m_repeating)
|
|
{
|
|
for (int y = r.top; y < r.bottom; y += bs.y, bn.nextBlockY())
|
|
{
|
|
for (int x = r.left; x < r.right; bn.nextBlockX(), x += bs.x)
|
|
{
|
|
const int i = (bn.blkY() << 7) + bn.blkX();
|
|
const u32 addr = i % MAX_BLOCKS;
|
|
|
|
const u32 row = addr >> 5u;
|
|
const u32 col = 1 << (addr & 31u);
|
|
|
|
if ((m_valid[row] & col) == 0)
|
|
{
|
|
m_valid[row] |= col;
|
|
|
|
Write(GSVector4i(x, y, x + bs.x, y + bs.y), level, off);
|
|
|
|
blocks++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int y = r.top; y < r.bottom; y += bs.y, bn.nextBlockY())
|
|
{
|
|
for (int x = r.left; x < r.right; x += bs.x, bn.nextBlockX())
|
|
{
|
|
const u32 block = bn.value();
|
|
const u32 row = block >> 5u;
|
|
const u32 col = 1 << (block & 31u);
|
|
|
|
if ((m_valid[row] & col) == 0)
|
|
{
|
|
m_valid[row] |= col;
|
|
|
|
Write(GSVector4i(x, y, x + bs.x, y + bs.y), level, off);
|
|
|
|
blocks++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (blocks > 0)
|
|
{
|
|
g_perfmon.Put(GSPerfMon::Unswizzle, bs.x * bs.y * blocks << (m_palette ? 2 : 0));
|
|
Flush(m_write.count, level, off);
|
|
}
|
|
}
|
|
|
|
void GSTextureCache::Source::UpdateLayer(const GIFRegTEX0& TEX0, const GSVector4i& rect, int layer)
|
|
{
|
|
if (layer > 6)
|
|
return;
|
|
|
|
if (m_target) // Yeah keep dreaming
|
|
return;
|
|
|
|
if (TEX0 == m_layer_TEX0[layer])
|
|
return;
|
|
|
|
const GIFRegTEX0 old_TEX0 = m_TEX0;
|
|
|
|
m_layer_TEX0[layer] = TEX0;
|
|
m_TEX0 = TEX0;
|
|
|
|
Update(rect, layer);
|
|
|
|
m_TEX0 = old_TEX0;
|
|
}
|
|
|
|
void GSTextureCache::Source::Write(const GSVector4i& r, int layer, const GSOffset& off)
|
|
{
|
|
if (!m_write.rect)
|
|
m_write.rect = static_cast<GSVector4i*>(_aligned_malloc(3 * sizeof(GSVector4i), 16));
|
|
|
|
m_write.rect[m_write.count++] = r;
|
|
|
|
while (m_write.count >= 2)
|
|
{
|
|
GSVector4i& a = m_write.rect[m_write.count - 2];
|
|
GSVector4i& b = m_write.rect[m_write.count - 1];
|
|
|
|
if ((a == b.zyxw()).mask() == 0xfff0)
|
|
{
|
|
a.right = b.right; // extend right
|
|
|
|
m_write.count--;
|
|
}
|
|
else if ((a == b.xwzy()).mask() == 0xff0f)
|
|
{
|
|
a.bottom = b.bottom; // extend down
|
|
|
|
m_write.count--;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (m_write.count > 2)
|
|
{
|
|
Flush(1, layer, off);
|
|
}
|
|
}
|
|
|
|
void GSTextureCache::Source::Flush(u32 count, int layer, const GSOffset& off)
|
|
{
|
|
// This function as written will not work for paletted formats copied from framebuffers
|
|
// because they are 8 or 4 bit formats on the GS and the GS local memory module reads
|
|
// these into an 8 bit format while the D3D surfaces are 32 bit.
|
|
// However the function is never called for these cases. This is just for information
|
|
// should someone wish to use this function for these cases later.
|
|
const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[m_TEX0.PSM];
|
|
const SourceRegion region((layer == 0) ? m_region : m_region.AdjustForMipmap(layer));
|
|
|
|
// For the invalid tex0 case, the region might be larger than TEX0.TW/TH.
|
|
const int tw = std::max(region.GetWidth(), 1 << m_TEX0.TW);
|
|
const int th = std::max(region.GetHeight(), 1 << m_TEX0.TH);
|
|
const GSVector4i tex_r(region.GetRect(tw, th));
|
|
|
|
int pitch = std::max(tw, psm.bs.x) * sizeof(u32);
|
|
|
|
GSLocalMemory& mem = g_gs_renderer->m_mem;
|
|
|
|
GSLocalMemory::readTexture rtx = psm.rtx;
|
|
|
|
if (m_palette)
|
|
{
|
|
pitch >>= 2;
|
|
rtx = psm.rtxP;
|
|
}
|
|
|
|
pitch = VectorAlign(pitch);
|
|
|
|
for (u32 i = 0; i < count; i++)
|
|
{
|
|
const GSVector4i r(m_write.rect[i]);
|
|
|
|
// if update rect lies to the left/above of the region rectangle, or extends past the texture bounds, we can't use a direct map
|
|
if (((r > tex_r).mask() & 0xff00) == 0 && ((tex_r > r).mask() & 0x00ff) == 0)
|
|
{
|
|
GSTexture::GSMap m;
|
|
const GSVector4i map_r(r - tex_r.xyxy());
|
|
if (m_texture->Map(m, &map_r, layer))
|
|
{
|
|
rtx(mem, off, r, m.bits, m.pitch, m_TEXA);
|
|
m_texture->Unmap();
|
|
continue;
|
|
}
|
|
}
|
|
|
|
const GSVector4i rint(r.rintersect(tex_r));
|
|
if (rint.width() == 0 || rint.height() == 0)
|
|
continue;
|
|
|
|
rtx(mem, off, r, s_unswizzle_buffer, pitch, m_TEXA);
|
|
|
|
// need to offset if we're a region texture
|
|
const u8* src = s_unswizzle_buffer + (pitch * static_cast<u32>(std::max(tex_r.top - r.top, 0))) +
|
|
(static_cast<u32>(std::max(tex_r.left - r.left, 0)) << (m_palette ? 0 : 2));
|
|
m_texture->Update(rint - tex_r.xyxy(), src, pitch, layer);
|
|
}
|
|
|
|
if (count < m_write.count)
|
|
{
|
|
// Warning src and destination overlap. Memmove must be used instead of memcpy
|
|
memmove(&m_write.rect[0], &m_write.rect[count], (m_write.count - count) * sizeof(m_write.rect[0]));
|
|
}
|
|
|
|
m_write.count -= count;
|
|
}
|
|
|
|
void GSTextureCache::Source::PreloadLevel(int level)
|
|
{
|
|
// m_TEX0 is adjusted for mips (messy, should be changed).
|
|
const HashType hash = HashTexture(m_TEX0, m_TEXA, m_region);
|
|
|
|
// Layer is complete again, regardless of whether the hash matches or not (and we reupload).
|
|
const u8 layer_bit = static_cast<u8>(1) << level;
|
|
m_complete_layers |= layer_bit;
|
|
|
|
// Check whether the hash matches. Black textures will be 0, so check the valid bit.
|
|
if ((m_valid_hashes & layer_bit) && m_layer_hash[level] == hash)
|
|
return;
|
|
|
|
m_valid_hashes |= layer_bit;
|
|
m_layer_hash[level] = hash;
|
|
|
|
// And upload the texture.
|
|
if (IsPaletteFormat())
|
|
{
|
|
PreloadTexture(m_TEX0, m_TEXA, m_region.AdjustForMipmap(level), g_gs_renderer->m_mem, m_palette != nullptr,
|
|
m_texture, level, nullptr);
|
|
}
|
|
else
|
|
{
|
|
std::pair<u8, u8> mip_alpha_minmax;
|
|
PreloadTexture(m_TEX0, m_TEXA, m_region.AdjustForMipmap(level), g_gs_renderer->m_mem, m_palette != nullptr,
|
|
m_texture, level, &mip_alpha_minmax);
|
|
m_alpha_minmax.first = std::min(m_alpha_minmax.first, mip_alpha_minmax.first);
|
|
m_alpha_minmax.second = std::min(m_alpha_minmax.second, mip_alpha_minmax.second);
|
|
}
|
|
}
|
|
|
|
bool GSTextureCache::Source::ClutMatch(const PaletteKey& palette_key)
|
|
{
|
|
return PaletteKeyEqual()(palette_key, m_palette_obj->GetPaletteKey());
|
|
}
|
|
|
|
// GSTextureCache::Target
|
|
|
|
GSTextureCache::Target::Target(GIFRegTEX0 TEX0, int type, const GSVector2i& unscaled_size, float scale, GSTexture* texture)
|
|
: m_type(type)
|
|
, m_used(type == RenderTarget) // FIXME
|
|
, m_valid(GSVector4i::zero())
|
|
{
|
|
m_TEX0 = TEX0;
|
|
m_end_block = m_TEX0.TBP0;
|
|
m_unscaled_size = unscaled_size;
|
|
m_scale = scale;
|
|
m_texture = texture;
|
|
m_alpha_min = 0;
|
|
m_alpha_max = 0;
|
|
m_32_bits_fmt |= (GSLocalMemory::m_psm[TEX0.PSM].trbpp != 16);
|
|
}
|
|
|
|
GSTextureCache::Target::~Target()
|
|
{
|
|
// Targets should never be shared.
|
|
pxAssert(!m_shared_texture);
|
|
if (m_texture)
|
|
{
|
|
g_texture_cache->m_target_memory_usage -= m_texture->GetMemUsage();
|
|
g_gs_device->Recycle(m_texture);
|
|
}
|
|
|
|
#ifdef PCSX2_DEVBUILD
|
|
// Make sure all sources referencing this target have been removed.
|
|
for (GSTextureCache::Source* src : g_texture_cache->m_src.m_surfaces)
|
|
{
|
|
if (src->m_from_target == this)
|
|
{
|
|
pxFail(fmt::format("Source at TBP {:x} for target at TBP {:x} on target invalidation",
|
|
static_cast<u32>(src->m_TEX0.TBP0), static_cast<u32>(m_TEX0.TBP0))
|
|
.c_str());
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void GSTextureCache::Target::Update()
|
|
{
|
|
m_age = 0;
|
|
|
|
// FIXME: the union of the rects may also update wrong parts of the render target (but a lot faster :)
|
|
// GH: it must be doable
|
|
// 1/ rescale the new t to the good size
|
|
// 2/ copy each rectangle (rescale the rectangle) (use CopyRect or multiple vertex)
|
|
// Alternate
|
|
// 1/ uses multiple vertex rectangle
|
|
|
|
if (m_dirty.empty())
|
|
return;
|
|
|
|
// No handling please
|
|
if (m_type == DepthStencil && GSConfig.UserHacks_DisableDepthSupport)
|
|
{
|
|
// do the most likely thing a direct write would do, clear it
|
|
GL_INS("ERROR: Update DepthStencil dummy");
|
|
m_dirty.clear();
|
|
return;
|
|
}
|
|
|
|
const GSVector4i total_rect = m_dirty.GetTotalRect(m_TEX0, m_unscaled_size);
|
|
if (total_rect.rempty())
|
|
{
|
|
GL_INS("ERROR: Nothing to update?");
|
|
m_dirty.clear();
|
|
return;
|
|
}
|
|
|
|
const GSVector4i t_offset(total_rect.xyxy());
|
|
const GSVector4i t_size(total_rect - t_offset);
|
|
const GSVector4 t_sizef(t_size.zwzw());
|
|
|
|
// This'll leave undefined data in pixels that we're not reading from... shouldn't hurt anything.
|
|
GSTexture* const t = g_gs_device->CreateTexture(t_size.z, t_size.w, 1, GSTexture::Format::Color);
|
|
GSTexture::GSMap m;
|
|
const bool mapped = t->Map(m);
|
|
|
|
GIFRegTEXA TEXA = {};
|
|
TEXA.AEM = 1;
|
|
TEXA.TA0 = 0;
|
|
TEXA.TA1 = 0x80;
|
|
|
|
// Bilinear filtering this is probably not a good thing, at least in native, but upscaling Nearest can be gross and messy.
|
|
// It's needed for depth, though.. filtering depth doesn't make much sense, but SMT3 needs it..
|
|
const bool upscaled = (m_scale != 1.0f);
|
|
const bool override_linear = (upscaled && GSConfig.UserHacks_BilinearHack == GSBilinearDirtyMode::ForceBilinear);
|
|
const bool linear = (m_type == RenderTarget && upscaled && GSConfig.UserHacks_BilinearHack != GSBilinearDirtyMode::ForceNearest);
|
|
|
|
GSDevice::MultiStretchRect* drects = static_cast<GSDevice::MultiStretchRect*>(
|
|
alloca(sizeof(GSDevice::MultiStretchRect) * static_cast<u32>(m_dirty.size())));
|
|
u32 ndrects = 0;
|
|
|
|
const GSOffset off(g_gs_renderer->m_mem.GetOffset(m_TEX0.TBP0, m_TEX0.TBW, m_TEX0.PSM));
|
|
for (size_t i = 0; i < m_dirty.size(); i++)
|
|
{
|
|
// Don't align the area we write to the target to the block size. If the format matches, the writes don't need
|
|
// to be block aligned. We still read the whole thing in, because that's the granularity that ReadTexture
|
|
// operates at, but discard those pixels when updating the framebuffer. Onimusha 2 does this dance where it
|
|
// uploads the left 4 pixels to the middle of the image, then moves it to the left, and because we process
|
|
// the move in hardware, local memory never gets updated, and thus is stale.
|
|
const GSVector4i update_r = m_dirty.GetDirtyRect(i, m_TEX0, total_rect, false);
|
|
if (update_r.rempty())
|
|
continue;
|
|
|
|
const GSVector4i read_r = m_dirty.GetDirtyRect(i, m_TEX0, total_rect, true);
|
|
const GSVector4i t_r(read_r - t_offset);
|
|
if (mapped)
|
|
{
|
|
g_gs_renderer->m_mem.ReadTexture(
|
|
off, read_r, m.bits + t_r.y * static_cast<u32>(m.pitch) + (t_r.x * sizeof(u32)), m.pitch, TEXA);
|
|
}
|
|
else
|
|
{
|
|
const int pitch = VectorAlign(read_r.width() * sizeof(u32));
|
|
g_gs_renderer->m_mem.ReadTexture(off, read_r, s_unswizzle_buffer, pitch, TEXA);
|
|
|
|
t->Update(t_r, s_unswizzle_buffer, pitch);
|
|
}
|
|
|
|
GSDevice::MultiStretchRect& drect = drects[ndrects++];
|
|
drect.src = t;
|
|
drect.src_rect = GSVector4(update_r - t_offset) / t_sizef;
|
|
drect.dst_rect = GSVector4(update_r) * GSVector4(m_scale);
|
|
drect.linear = linear && (m_dirty[i].req_linear || override_linear);
|
|
|
|
// Copy the new GS memory content into the destination texture.
|
|
if (m_type == RenderTarget)
|
|
{
|
|
GL_INS("ERROR: Update RenderTarget 0x%x bw:%d (%d,%d => %d,%d)", m_TEX0.TBP0, m_TEX0.TBW,
|
|
update_r.x, update_r.y, update_r.z, update_r.w);
|
|
drect.wmask = static_cast<u8>(m_dirty[i].rgba._u32);
|
|
}
|
|
else if (m_type == DepthStencil)
|
|
{
|
|
GL_INS("ERROR: Update DepthStencil 0x%x", m_TEX0.TBP0);
|
|
drect.wmask = 0xF;
|
|
}
|
|
}
|
|
|
|
if (mapped)
|
|
t->Unmap();
|
|
|
|
if (ndrects > 0)
|
|
{
|
|
ShaderConvert depth_shader = upscaled ? ShaderConvert::RGBA8_TO_FLOAT32_BILN : ShaderConvert::RGBA8_TO_FLOAT32;
|
|
if (m_type == DepthStencil && GSLocalMemory::m_psm[m_TEX0.PSM].trbpp != 32)
|
|
{
|
|
switch (GSLocalMemory::m_psm[m_TEX0.PSM].trbpp)
|
|
{
|
|
case 24:
|
|
depth_shader = upscaled ? ShaderConvert::RGBA8_TO_FLOAT24_BILN : ShaderConvert::RGBA8_TO_FLOAT24;
|
|
break;
|
|
case 16:
|
|
depth_shader = upscaled ? ShaderConvert::RGB5A1_TO_FLOAT16_BILN : ShaderConvert::RGB5A1_TO_FLOAT16;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// No need to sort here, it's all the one texture.
|
|
const ShaderConvert shader = (m_type == RenderTarget) ? ShaderConvert::COPY : depth_shader;
|
|
|
|
g_gs_device->DrawMultiStretchRects(drects, ndrects, m_texture, shader);
|
|
}
|
|
|
|
if ((m_TEX0.PSM & 0xf) == PSMCT24)
|
|
{
|
|
m_alpha_min = 128;
|
|
m_alpha_max = 128;
|
|
}
|
|
else
|
|
{
|
|
m_alpha_min = 0;
|
|
m_alpha_max = m_32_bits_fmt ? 255 : 128;
|
|
}
|
|
g_gs_device->Recycle(t);
|
|
m_dirty.clear();
|
|
}
|
|
|
|
void GSTextureCache::Target::UpdateIfDirtyIntersects(const GSVector4i& rc)
|
|
{
|
|
m_age = 0;
|
|
|
|
for (auto& dirty : m_dirty)
|
|
{
|
|
const GSVector4i dirty_rc(dirty.GetDirtyRect(m_TEX0, false));
|
|
if (dirty_rc.rintersect(rc).rempty())
|
|
continue;
|
|
|
|
// strictly speaking, we only need to update the area outside of the move.
|
|
// but, to keep things simple, just update the whole thing
|
|
GL_CACHE("TC: Update dirty rectangle [%d,%d,%d,%d] due to intersection with [%d,%d,%d,%d]",
|
|
dirty_rc.x, dirty_rc.y, dirty_rc.z, dirty_rc.w, rc.x, rc.y, rc.z, rc.w);
|
|
Update();
|
|
break;
|
|
}
|
|
}
|
|
|
|
void GSTextureCache::Target::UpdateValidChannels(u32 psm, u32 fbmsk)
|
|
{
|
|
const GSLocalMemory::psm_t& psm_s = GSLocalMemory::m_psm[psm];
|
|
m_valid_alpha_low |= (psm_s.trbpp == 32 && (fbmsk & 0x0F000000) != 0x0F000000) || (psm_s.trbpp == 16);
|
|
m_valid_alpha_high |= (psm_s.trbpp == 32 && (fbmsk & 0xF0000000) != 0xF0000000) || (psm_s.trbpp == 16);
|
|
m_valid_rgb |= (psm_s.trbpp >= 24 && (fbmsk & 0x00FFFFFF) != 0x00FFFFFF) || (psm_s.trbpp == 16);
|
|
}
|
|
|
|
bool GSTextureCache::Target::HasValidBitsForFormat(u32 psm, bool req_color, bool req_alpha)
|
|
{
|
|
// Grab validities..
|
|
bool alpha_valid = false;
|
|
bool color_valid = false;
|
|
|
|
switch (psm)
|
|
{
|
|
case PSMT4:
|
|
return (m_valid_rgb && m_valid_alpha_low && m_valid_alpha_high);
|
|
case PSMT8H:
|
|
return m_valid_alpha_low || m_valid_alpha_high;
|
|
case PSMT4HL:
|
|
return m_valid_alpha_low;
|
|
case PSMT4HH:
|
|
return m_valid_alpha_high;
|
|
case PSMT8: // Down here because of channel shuffles.
|
|
default:
|
|
alpha_valid = ((m_TEX0.PSM & 0xF) == 0x1) ? true : (m_valid_alpha_low || m_valid_alpha_high);
|
|
color_valid = m_valid_rgb;
|
|
break;
|
|
}
|
|
|
|
return (color_valid && req_color) || (!req_color && ((alpha_valid && req_alpha) || !req_alpha));
|
|
}
|
|
|
|
void GSTextureCache::Target::ResizeDrawn(const GSVector4i& rect)
|
|
{
|
|
m_drawn_since_read = m_drawn_since_read.rintersect(rect);
|
|
}
|
|
|
|
|
|
void GSTextureCache::Target::UpdateDrawn(const GSVector4i& rect, bool can_update_size)
|
|
{
|
|
if (m_drawn_since_read.rempty())
|
|
{
|
|
m_drawn_since_read = rect.rintersect(m_valid);
|
|
}
|
|
else if (can_update_size)
|
|
{
|
|
m_drawn_since_read = m_drawn_since_read.runion(rect);
|
|
}
|
|
}
|
|
|
|
void GSTextureCache::Target::ResizeValidity(const GSVector4i& rect)
|
|
{
|
|
if (!m_valid.eq(GSVector4i::zero()))
|
|
{
|
|
m_valid = m_valid.rintersect(rect);
|
|
m_drawn_since_read = m_drawn_since_read.rintersect(rect);
|
|
m_end_block = GSLocalMemory::GetEndBlockAddress(m_TEX0.TBP0, m_TEX0.TBW, m_TEX0.PSM, m_valid);
|
|
}
|
|
// Else No valid size, so need to resize down.
|
|
|
|
// GL_CACHE("ResizeValidity (0x%x->0x%x) from R:%d,%d Valid: %d,%d", m_TEX0.TBP0, m_end_block, rect.z, rect.w, m_valid.z, m_valid.w);
|
|
}
|
|
|
|
void GSTextureCache::Target::UpdateValidity(const GSVector4i& rect, bool can_resize)
|
|
{
|
|
if (m_valid.eq(GSVector4i::zero()))
|
|
{
|
|
m_valid = rect;
|
|
|
|
m_end_block = GSLocalMemory::GetEndBlockAddress(m_TEX0.TBP0, m_TEX0.TBW, m_TEX0.PSM, m_valid);
|
|
}
|
|
else if (can_resize)
|
|
{
|
|
m_valid = m_valid.runion(rect);
|
|
|
|
m_end_block = GSLocalMemory::GetEndBlockAddress(m_TEX0.TBP0, m_TEX0.TBW, m_TEX0.PSM, m_valid);
|
|
}
|
|
// GL_CACHE("UpdateValidity (0x%x->0x%x) from R:%d,%d Valid: %d,%d", m_TEX0.TBP0, m_end_block, rect.z, rect.w, m_valid.z, m_valid.w);
|
|
}
|
|
|
|
bool GSTextureCache::Target::ResizeTexture(int new_unscaled_width, int new_unscaled_height, bool recycle_old)
|
|
{
|
|
if (m_unscaled_size.x == new_unscaled_width && m_unscaled_size.y == new_unscaled_height)
|
|
return true;
|
|
|
|
const GSVector2i size = m_texture->GetSize();
|
|
const GSVector2i new_unscaled_size = GSVector2i(new_unscaled_width, new_unscaled_height);
|
|
const GSVector2i new_size = ScaleRenderTargetSize(new_unscaled_size, m_scale);
|
|
const bool clear = (new_size.x > size.x || new_size.y > size.y);
|
|
|
|
GSTexture* tex = m_texture->IsDepthStencil() ?
|
|
g_gs_device->CreateDepthStencil(new_size.x, new_size.y, m_texture->GetFormat(), clear) :
|
|
g_gs_device->CreateRenderTarget(new_size.x, new_size.y, m_texture->GetFormat(), clear);
|
|
if (!tex)
|
|
{
|
|
Console.Error("(ResizeTexture) Failed to allocate %dx%d texture from %dx%d texture", size.x, size.y, new_size.x, new_size.y);
|
|
return false;
|
|
}
|
|
|
|
// Only need to copy if it's been written to.
|
|
if (m_texture->GetState() == GSTexture::State::Dirty)
|
|
{
|
|
const GSVector4i rc = GSVector4i::loadh(size.min(new_size));
|
|
if (tex->IsDepthStencil())
|
|
{
|
|
// Can't do partial copies in DirectX for depth textures, and it's probably not ideal in other
|
|
// APIs either. So use a fullscreen quad setting depth instead.
|
|
g_gs_device->StretchRect(m_texture, tex, GSVector4(rc), ShaderConvert::DEPTH_COPY, false);
|
|
}
|
|
else
|
|
{
|
|
// Fast memcpy()-like path for color targets.
|
|
g_gs_device->CopyRect(m_texture, tex, rc, 0, 0);
|
|
}
|
|
|
|
g_perfmon.Put(GSPerfMon::TextureCopies, 1);
|
|
}
|
|
else if (m_texture->GetState() == GSTexture::State::Cleared)
|
|
{
|
|
// Otherwise just pass the clear through.
|
|
if (tex->GetType() != GSTexture::Type::DepthStencil)
|
|
g_gs_device->ClearRenderTarget(tex, m_texture->GetClearColor());
|
|
else
|
|
g_gs_device->ClearDepth(tex, m_texture->GetClearDepth());
|
|
}
|
|
else
|
|
{
|
|
g_gs_device->InvalidateRenderTarget(tex);
|
|
}
|
|
|
|
g_texture_cache->m_target_memory_usage = (g_texture_cache->m_target_memory_usage - m_texture->GetMemUsage()) + tex->GetMemUsage();
|
|
|
|
if (recycle_old)
|
|
g_gs_device->Recycle(m_texture);
|
|
else
|
|
delete m_texture;
|
|
|
|
m_texture = tex;
|
|
m_unscaled_size = new_unscaled_size;
|
|
|
|
return true;
|
|
}
|
|
|
|
// GSTextureCache::SourceMap
|
|
|
|
void GSTextureCache::SourceMap::Add(Source* s, const GIFRegTEX0& TEX0)
|
|
{
|
|
m_surfaces.insert(s);
|
|
|
|
// The source pointer will be stored/duplicated in all m_map[array of pages]
|
|
s->m_pages.loopPages([this, s](u32 page)
|
|
{
|
|
s->m_erase_it[page] = m_map[page].InsertFront(s);
|
|
});
|
|
}
|
|
|
|
void GSTextureCache::SourceMap::RemoveAll()
|
|
{
|
|
for (auto s : m_surfaces)
|
|
{
|
|
if (s->m_from_hash_cache)
|
|
{
|
|
pxAssert(s->m_from_hash_cache->refcount > 0);
|
|
if ((--s->m_from_hash_cache->refcount) == 0)
|
|
s->m_from_hash_cache->age = 0;
|
|
}
|
|
|
|
delete s;
|
|
}
|
|
|
|
m_surfaces.clear();
|
|
|
|
for (FastList<Source*>& item : m_map)
|
|
{
|
|
item.clear();
|
|
}
|
|
}
|
|
|
|
void GSTextureCache::SourceMap::RemoveAt(Source* s)
|
|
{
|
|
m_surfaces.erase(s);
|
|
|
|
GL_CACHE("TC: Remove Src Texture: 0x%x TBW %u PSM %s",
|
|
s->m_TEX0.TBP0, s->m_TEX0.TBW, psm_str(s->m_TEX0.PSM));
|
|
|
|
s->m_pages.loopPages([this, s](u32 page)
|
|
{
|
|
m_map[page].EraseIndex(s->m_erase_it[page]);
|
|
});
|
|
|
|
if (s->m_from_hash_cache)
|
|
{
|
|
pxAssert(s->m_from_hash_cache->refcount > 0);
|
|
if ((--s->m_from_hash_cache->refcount) == 0)
|
|
s->m_from_hash_cache->age = 0;
|
|
}
|
|
|
|
delete s;
|
|
}
|
|
|
|
void GSTextureCache::AttachPaletteToSource(Source* s, u16 pal, bool need_gs_texture)
|
|
{
|
|
s->m_palette_obj = m_palette_map.LookupPalette(pal, need_gs_texture);
|
|
s->m_palette = need_gs_texture ? s->m_palette_obj->GetPaletteGSTexture() : nullptr;
|
|
s->m_alpha_minmax = s->m_palette_obj->GetAlphaMinMax();
|
|
}
|
|
|
|
void GSTextureCache::AttachPaletteToSource(Source* s, GSTexture* gpu_clut)
|
|
{
|
|
s->m_palette_obj = nullptr;
|
|
s->m_palette = gpu_clut;
|
|
|
|
// Unknown.
|
|
s->m_alpha_minmax.first = 0;
|
|
s->m_alpha_minmax.second = 255;
|
|
}
|
|
|
|
GSTextureCache::SurfaceOffset GSTextureCache::ComputeSurfaceOffset(const GSOffset& off, const GSVector4i& r, const Target* t)
|
|
{
|
|
// Computes offset from Target to offset+rectangle in Target coords.
|
|
if (!t)
|
|
return {false};
|
|
const SurfaceOffset so = ComputeSurfaceOffset(off.bp(), off.bw(), off.psm(), r, t);
|
|
return so;
|
|
}
|
|
|
|
GSTextureCache::SurfaceOffset GSTextureCache::ComputeSurfaceOffset(const uint32_t bp, const uint32_t bw, const uint32_t psm, const GSVector4i& r, const Target* t)
|
|
{
|
|
// Computes offset from Target to bp+bw+psm+r in Target coords.
|
|
if (!t)
|
|
return {false};
|
|
SurfaceOffsetKey sok;
|
|
sok.elems[0].bp = bp;
|
|
sok.elems[0].bw = bw;
|
|
sok.elems[0].psm = psm;
|
|
sok.elems[0].rect = r;
|
|
sok.elems[1].bp = t->m_TEX0.TBP0;
|
|
sok.elems[1].bw = t->m_TEX0.TBW;
|
|
sok.elems[1].psm = t->m_TEX0.PSM;
|
|
sok.elems[1].rect = t->m_valid;
|
|
const SurfaceOffset so = ComputeSurfaceOffset(sok);
|
|
// Check if any dirty rect in the target overlaps with the offset.
|
|
if (so.is_valid && !t->m_dirty.empty())
|
|
{
|
|
const SurfaceOffsetKeyElem& t_sok = sok.elems[1];
|
|
const GSLocalMemory::psm_t& t_psm_s = GSLocalMemory::m_psm[t_sok.psm];
|
|
const u32 so_bp = t_psm_s.info.bn(so.b2a_offset.x, so.b2a_offset.y, t_sok.bp, t_sok.bw);
|
|
const u32 so_bp_end = t_psm_s.info.bn(so.b2a_offset.z - 1, so.b2a_offset.w - 1, t_sok.bp, t_sok.bw);
|
|
for (const auto& dr : t->m_dirty)
|
|
{
|
|
const GSLocalMemory::psm_t& dr_psm_s = GSLocalMemory::m_psm[dr.psm];
|
|
const u32 dr_bp = dr_psm_s.info.bn(dr.r.x, dr.r.y, t_sok.bp, dr.bw);
|
|
const u32 dr_bp_end = dr_psm_s.info.bn(dr.r.z - 1, dr.r.w - 1, t_sok.bp, dr.bw);
|
|
const bool overlap = GSTextureCache::CheckOverlap(dr_bp, dr_bp_end, so_bp, so_bp_end);
|
|
if (overlap)
|
|
{
|
|
// Dirty rectangle in target overlaps with the found offset.
|
|
return {false};
|
|
}
|
|
}
|
|
}
|
|
return so;
|
|
}
|
|
|
|
GSTextureCache::SurfaceOffset GSTextureCache::ComputeSurfaceOffset(const SurfaceOffsetKey& sok)
|
|
{
|
|
const SurfaceOffsetKeyElem& a_el = sok.elems[0];
|
|
const SurfaceOffsetKeyElem& b_el = sok.elems[1];
|
|
const GSLocalMemory::psm_t& a_psm_s = GSLocalMemory::m_psm[a_el.psm];
|
|
const GSLocalMemory::psm_t& b_psm_s = GSLocalMemory::m_psm[b_el.psm];
|
|
const GSVector4i a_rect = a_el.rect.ralign<Align_Outside>(a_psm_s.bs);
|
|
const GSVector4i b_rect = b_el.rect.ralign<Align_Outside>(b_psm_s.bs);
|
|
if (a_rect.width() <= 0 || a_rect.height() <= 0 || a_rect.x < 0 || a_rect.y < 0)
|
|
return {false}; // Invalid A rectangle.
|
|
if (b_rect.width() <= 0 || b_rect.height() <= 0 || b_rect.x < 0 || b_rect.y < 0)
|
|
return {false}; // Invalid B rectangle.
|
|
const u32 a_bp_end = a_psm_s.info.bn(a_rect.z - 1, a_rect.w - 1, a_el.bp, a_el.bw);
|
|
const u32 b_bp_end = b_psm_s.info.bn(b_rect.z - 1, b_rect.w - 1, b_el.bp, b_el.bw);
|
|
const bool overlap = GSTextureCache::CheckOverlap(a_el.bp, a_bp_end, b_el.bp, b_bp_end);
|
|
if (!overlap)
|
|
return {false}; // A and B do not overlap.
|
|
|
|
// Key parameter is valid.
|
|
const auto it = m_surface_offset_cache.find(sok);
|
|
if (it != m_surface_offset_cache.end())
|
|
return it->second; // Cache HIT.
|
|
|
|
// Cache MISS.
|
|
// Search for a valid <x,y> offset from B to A in B coordinates.
|
|
SurfaceOffset so;
|
|
so.is_valid = false;
|
|
const int dx = b_psm_s.bs.x;
|
|
const int dy = b_psm_s.bs.y;
|
|
GSVector4i b2a_offset = GSVector4i::zero();
|
|
if (a_el.bp >= b_el.bp)
|
|
{
|
|
// A starts after B, search <x,y> offset from B to A in B coords.
|
|
for (b2a_offset.x = b_rect.x; b2a_offset.x < b_rect.z; b2a_offset.x += dx)
|
|
{
|
|
for (b2a_offset.y = b_rect.y; b2a_offset.y < b_rect.w; b2a_offset.y += dy)
|
|
{
|
|
const u32 a_candidate_bp = b_psm_s.info.bn(b2a_offset.x, b2a_offset.y, b_el.bp, b_el.bw);
|
|
if (a_el.bp == a_candidate_bp)
|
|
{
|
|
so.is_valid = true; // Sweep search HIT: <x,y> offset found.
|
|
break;
|
|
}
|
|
}
|
|
if (so.is_valid)
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// B starts after A, suppose <x,y> offset is <x,y> of the B validity rectangle.
|
|
so.is_valid = true;
|
|
b2a_offset.x = b_rect.x;
|
|
b2a_offset.y = b_rect.y;
|
|
}
|
|
|
|
assert(!so.is_valid || b2a_offset.x >= b_rect.x);
|
|
assert(!so.is_valid || b2a_offset.x < b_rect.z);
|
|
assert(!so.is_valid || b2a_offset.y >= b_rect.y);
|
|
assert(!so.is_valid || b2a_offset.y < b_rect.w);
|
|
|
|
if (so.is_valid)
|
|
{
|
|
// Search for a valid <z,w> offset from B to the end of A in B coordinates.
|
|
if (a_bp_end >= b_bp_end)
|
|
{
|
|
// A ends after B, suppose <z,w> offset is <z,w> of the B validity rectangle.
|
|
b2a_offset.z = b_rect.z;
|
|
b2a_offset.w = b_rect.w;
|
|
}
|
|
else
|
|
{
|
|
// B ends after A, sweep search <z,w> offset in B coordinates.
|
|
so.is_valid = false;
|
|
for (b2a_offset.z = b2a_offset.x; b2a_offset.z <= b_rect.z; b2a_offset.z += dx)
|
|
{
|
|
for (b2a_offset.w = b2a_offset.y; b2a_offset.w <= b_rect.w; b2a_offset.w += dy)
|
|
{
|
|
const u32 a_candidate_bp_end = b_psm_s.info.bn(b2a_offset.z - 1, b2a_offset.w - 1, b_el.bp, b_el.bw);
|
|
if (a_bp_end == a_candidate_bp_end)
|
|
{
|
|
// Align b2a_offset outside.
|
|
if (b2a_offset.z == b2a_offset.x)
|
|
++b2a_offset.z;
|
|
if (b2a_offset.w == b2a_offset.y)
|
|
++b2a_offset.w;
|
|
b2a_offset = b2a_offset.ralign<Align_Outside>(b_psm_s.bs);
|
|
so.is_valid = true; // Sweep search HIT: <z,w> offset found.
|
|
break;
|
|
}
|
|
}
|
|
if (so.is_valid)
|
|
break;
|
|
}
|
|
if (!so.is_valid)
|
|
{
|
|
// Sweep search <z,w> MISS.
|
|
GL_CACHE("TC: ComputeSurfaceOffset - Could not find <z,w> offset.");
|
|
b2a_offset.z = b_rect.z;
|
|
b2a_offset.w = b_rect.w;
|
|
}
|
|
}
|
|
}
|
|
|
|
assert(!so.is_valid || b2a_offset.z > b2a_offset.x);
|
|
assert(!so.is_valid || b2a_offset.z <= b_rect.z);
|
|
assert(!so.is_valid || b2a_offset.w > b_rect.y);
|
|
assert(!so.is_valid || b2a_offset.w <= b_rect.w);
|
|
|
|
so.b2a_offset = b2a_offset;
|
|
|
|
const GSVector4i& r1 = so.b2a_offset;
|
|
const GSVector4i& r2 = b_rect;
|
|
[[maybe_unused]] const GSVector4i ri = r1.rintersect(r2);
|
|
assert(!so.is_valid || (r1.eq(ri) && r1.x >= 0 && r1.y >= 0 && r1.z > 0 && r1.w > 0));
|
|
|
|
// Clear cache if size too big.
|
|
if (m_surface_offset_cache.size() + 1 > S_SURFACE_OFFSET_CACHE_MAX_SIZE)
|
|
{
|
|
GL_PERF("TC: ComputeSurfaceOffset - Size of cache %d too big, clearing it.", m_surface_offset_cache.size());
|
|
m_surface_offset_cache.clear();
|
|
}
|
|
m_surface_offset_cache.emplace(std::make_pair(sok, so));
|
|
if (so.is_valid)
|
|
{
|
|
GL_CACHE("TC: ComputeSurfaceOffset - Cached HIT element (size %d), [B] BW %d, PSM %s, BP 0x%x (END 0x%x) + OFF <%d,%d => %d,%d> ---> [A] BP 0x%x (END: 0x%x).",
|
|
m_surface_offset_cache.size(), b_el.bw, psm_str(b_el.psm), b_el.bp, b_bp_end,
|
|
so.b2a_offset.x, so.b2a_offset.y, so.b2a_offset.z, so.b2a_offset.w,
|
|
a_el.bp, a_bp_end);
|
|
}
|
|
else
|
|
{
|
|
GL_CACHE("TC: ComputeSurfaceOffset - Cached MISS element (size %d), [B] BW %d, PSM %s, BP 0x%x (END 0x%x) -/-> [A] BP 0x%x (END: 0x%x).",
|
|
m_surface_offset_cache.size(), b_el.bw, psm_str(b_el.psm), b_el.bp, b_bp_end,
|
|
a_el.bp, a_bp_end);
|
|
}
|
|
return so;
|
|
}
|
|
|
|
void GSTextureCache::InvalidateTemporarySource()
|
|
{
|
|
if (!m_temporary_source)
|
|
return;
|
|
|
|
delete m_temporary_source;
|
|
m_temporary_source = nullptr;
|
|
}
|
|
|
|
void GSTextureCache::InjectHashCacheTexture(const HashCacheKey& key, GSTexture* tex, const std::pair<u8, u8>& alpha_minmax)
|
|
{
|
|
// When we insert we update memory usage. Old texture gets removed below.
|
|
m_hash_cache_replacement_memory_usage += tex->GetMemUsage();
|
|
|
|
auto it = m_hash_cache.find(key);
|
|
if (it == m_hash_cache.end())
|
|
{
|
|
// We must've got evicted before we finished loading. No matter, add it in there anyway;
|
|
// if it's not used again, it'll get tossed out later.
|
|
const HashCacheEntry entry{tex, 1u, 0u, alpha_minmax, true};
|
|
m_hash_cache.emplace(key, entry);
|
|
return;
|
|
}
|
|
|
|
// Reset age so we don't get thrown out too early.
|
|
it->second.age = 0;
|
|
it->second.alpha_minmax = alpha_minmax;
|
|
|
|
// Update memory usage, swap the textures, and recycle the old one for reuse.
|
|
if (!it->second.is_replacement)
|
|
m_hash_cache_memory_usage -= it->second.texture->GetMemUsage();
|
|
else
|
|
m_hash_cache_replacement_memory_usage -= it->second.texture->GetMemUsage();
|
|
|
|
it->second.is_replacement = true;
|
|
it->second.texture->Swap(tex);
|
|
g_gs_device->Recycle(tex);
|
|
}
|
|
|
|
// GSTextureCache::Palette
|
|
|
|
GSTextureCache::Palette::Palette(const u32* clut, u16 pal, bool need_gs_texture)
|
|
: m_tex_palette(nullptr)
|
|
, m_pal(pal)
|
|
{
|
|
const u16 palette_size = pal * sizeof(u32);
|
|
m_clut = (u32*)_aligned_malloc(palette_size, 64);
|
|
memcpy(m_clut, clut, palette_size);
|
|
if (need_gs_texture)
|
|
{
|
|
InitializeTexture();
|
|
}
|
|
|
|
m_alpha_minmax = GSGetRGBA8AlphaMinMax(m_clut, pal, 1, 0);
|
|
}
|
|
|
|
GSTextureCache::Palette::~Palette()
|
|
{
|
|
if (m_tex_palette)
|
|
{
|
|
g_texture_cache->m_source_memory_usage -= m_tex_palette->GetMemUsage();
|
|
g_gs_device->Recycle(m_tex_palette);
|
|
}
|
|
|
|
_aligned_free(m_clut);
|
|
}
|
|
|
|
GSTexture* GSTextureCache::Palette::GetPaletteGSTexture()
|
|
{
|
|
return m_tex_palette;
|
|
}
|
|
|
|
GSTextureCache::PaletteKey GSTextureCache::Palette::GetPaletteKey()
|
|
{
|
|
return {m_clut, m_pal};
|
|
}
|
|
|
|
void GSTextureCache::Palette::InitializeTexture()
|
|
{
|
|
if (!m_tex_palette)
|
|
{
|
|
// A palette texture is always created with dimensions 256x1 (also in the case that m_pal is 16, thus a 16x1 texture
|
|
// would be enough to store the CLUT data) because the coordinates that the shader uses for
|
|
// sampling such texture are always normalized by 255.
|
|
// This is because indexes are stored as normalized values of an RGBA texture (e.g. index 15 will be read as (15/255),
|
|
// and therefore will read texel 15/255 * texture size).
|
|
m_tex_palette = g_gs_device->CreateTexture(m_pal, 1, 1, GSTexture::Format::Color);
|
|
m_tex_palette->Update(GSVector4i(0, 0, m_pal, 1), m_clut, m_pal * sizeof(m_clut[0]));
|
|
g_texture_cache->m_source_memory_usage += m_tex_palette->GetMemUsage();
|
|
}
|
|
}
|
|
|
|
// GSTextureCache::PaletteKeyHash
|
|
|
|
u64 GSTextureCache::PaletteKeyHash::operator()(const PaletteKey& key) const
|
|
{
|
|
ASSERT(key.pal == 16 || key.pal == 256);
|
|
return key.pal == 16 ?
|
|
GSXXH3_64bits(key.clut, sizeof(key.clut[0]) * 16) :
|
|
GSXXH3_64bits(key.clut, sizeof(key.clut[0]) * 256);
|
|
};
|
|
|
|
// GSTextureCache::PaletteKeyEqual
|
|
|
|
bool GSTextureCache::PaletteKeyEqual::operator()(const PaletteKey& lhs, const PaletteKey& rhs) const
|
|
{
|
|
if (lhs.pal != rhs.pal)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return GSVector4i::compare64(lhs.clut, rhs.clut, lhs.pal * sizeof(lhs.clut[0]));
|
|
};
|
|
|
|
// GSTextureCache::PaletteMap
|
|
|
|
GSTextureCache::PaletteMap::PaletteMap()
|
|
{
|
|
for (auto& map : m_maps)
|
|
{
|
|
map.reserve(MAX_SIZE);
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<GSTextureCache::Palette> GSTextureCache::PaletteMap::LookupPalette(u16 pal, bool need_gs_texture)
|
|
{
|
|
return LookupPalette(g_gs_renderer->m_mem.m_clut, pal, need_gs_texture);
|
|
}
|
|
|
|
std::shared_ptr<GSTextureCache::Palette> GSTextureCache::PaletteMap::LookupPalette(const u32* clut, u16 pal, bool need_gs_texture)
|
|
{
|
|
ASSERT(pal == 16 || pal == 256);
|
|
|
|
// Choose which hash map search into:
|
|
// pal == 16 : index 0
|
|
// pal == 256 : index 1
|
|
auto& map = m_maps[pal == 16 ? 0 : 1];
|
|
|
|
// Create PaletteKey for searching into map (clut is actually not copied, so do not store this key into the map)
|
|
const PaletteKey palette_key = {clut, pal};
|
|
|
|
const auto& it1 = map.find(palette_key);
|
|
|
|
if (it1 != map.end())
|
|
{
|
|
// Clut content match, HIT
|
|
if (need_gs_texture && !it1->second->GetPaletteGSTexture())
|
|
{
|
|
// Generate GSTexture and upload clut content if needed and not done yet
|
|
it1->second->InitializeTexture();
|
|
}
|
|
return it1->second;
|
|
}
|
|
|
|
// No palette with matching clut content, MISS
|
|
|
|
if (map.size() > MAX_SIZE)
|
|
{
|
|
// If the map is too big, try to clean it by disposing and removing unused palettes, before adding the new one
|
|
GL_INS("WARNING, %u-bit PaletteMap (Size %u): Max size %u exceeded, clearing unused palettes.", pal * sizeof(u32), map.size(), MAX_SIZE);
|
|
|
|
const u32 current_size = map.size();
|
|
|
|
for (auto it = map.begin(); it != map.end();)
|
|
{
|
|
// If the palette is unused, there is only one shared pointers holding a reference to the unused Palette object,
|
|
// and this shared pointer is the one stored in the map itself
|
|
if (it->second.use_count() <= 1)
|
|
{
|
|
// Palette is unused
|
|
it = map.erase(it); // Erase element from map
|
|
// The palette object should now be gone as the shared pointer to the object in the map is deleted
|
|
}
|
|
else
|
|
{
|
|
++it;
|
|
}
|
|
}
|
|
|
|
const u32 cleared_palette_count = current_size - static_cast<u32>(map.size());
|
|
|
|
if (cleared_palette_count == 0)
|
|
{
|
|
GL_INS("ERROR, %u-bit PaletteMap (Size %u): Max size %u exceeded, could not clear any palette, negative performance impact.", pal * sizeof(u32), map.size(), MAX_SIZE);
|
|
}
|
|
else
|
|
{
|
|
map.reserve(MAX_SIZE); // Ensure map capacity is not modified by the clearing
|
|
GL_INS("INFO, %u-bit PaletteMap (Size %u): Cleared %u palettes.", pal * sizeof(u32), map.size(), cleared_palette_count);
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<Palette> palette = std::make_shared<Palette>(clut, pal, need_gs_texture);
|
|
|
|
map.emplace(palette->GetPaletteKey(), palette);
|
|
|
|
GL_CACHE("TC, %u-bit PaletteMap (Size %u): Added new palette.", pal * sizeof(u32), map.size());
|
|
|
|
return palette;
|
|
}
|
|
|
|
void GSTextureCache::PaletteMap::Clear()
|
|
{
|
|
for (auto& map : m_maps)
|
|
{
|
|
map.clear(); // Clear all the nodes of the map, deleting Palette objects managed by shared pointers as they should be unused elsewhere
|
|
map.reserve(MAX_SIZE); // Ensure map capacity is not modified by the clearing
|
|
}
|
|
}
|
|
|
|
std::size_t GSTextureCache::SurfaceOffsetKeyHash::operator()(const GSTextureCache::SurfaceOffsetKey& key) const
|
|
{
|
|
std::hash<u32> hash_fn_u32;
|
|
std::hash<int> hash_fn_int;
|
|
std::hash<size_t> hash_fn_szt;
|
|
size_t hash = 0x9e3779b9;
|
|
for (const SurfaceOffsetKeyElem& elem : key.elems)
|
|
{
|
|
hash = hash ^ hash_fn_u32(elem.bp) << 1;
|
|
hash = hash ^ hash_fn_u32(elem.bw) << 1;
|
|
hash = hash ^ hash_fn_u32(elem.psm) << 1;
|
|
hash = hash ^ hash_fn_int(elem.rect.x) << 1;
|
|
hash = hash ^ hash_fn_int(elem.rect.y) << 1;
|
|
hash = hash ^ hash_fn_int(elem.rect.z) << 1;
|
|
hash = hash ^ hash_fn_int(elem.rect.w) << 1;
|
|
}
|
|
return hash_fn_szt(hash);
|
|
}
|
|
|
|
bool GSTextureCache::SurfaceOffsetKeyEqual::operator()(const GSTextureCache::SurfaceOffsetKey& lhs, const GSTextureCache::SurfaceOffsetKey& rhs) const
|
|
{
|
|
for (size_t i = 0; i < lhs.elems.size(); ++i)
|
|
{
|
|
const SurfaceOffsetKeyElem& lhs_elem = lhs.elems[i];
|
|
const SurfaceOffsetKeyElem& rhs_elem = rhs.elems[i];
|
|
if (lhs_elem.bp != rhs_elem.bp
|
|
|| lhs_elem.bw != rhs_elem.bw
|
|
|| lhs_elem.psm != rhs_elem.psm
|
|
|| !lhs_elem.rect.eq(rhs_elem.rect))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool GSTextureCache::SourceRegion::IsFixedTEX0(GIFRegTEX0 TEX0) const
|
|
{
|
|
return IsFixedTEX0(1 << TEX0.TW, 1 << TEX0.TH);
|
|
}
|
|
|
|
bool GSTextureCache::SourceRegion::IsFixedTEX0(int tw, int th) const
|
|
{
|
|
return IsFixedTEX0W(tw) || IsFixedTEX0H(th);
|
|
}
|
|
|
|
bool GSTextureCache::SourceRegion::IsFixedTEX0W(int tw) const
|
|
{
|
|
return (GetMaxX() > tw);
|
|
}
|
|
|
|
bool GSTextureCache::SourceRegion::IsFixedTEX0H(int th) const
|
|
{
|
|
return (GetMaxY() > th);
|
|
}
|
|
|
|
GSVector2i GSTextureCache::SourceRegion::GetSize(int tw, int th) const
|
|
{
|
|
return GSVector2i(HasX() ? GetWidth() : tw, HasY() ? GetHeight() : th);
|
|
}
|
|
|
|
GSVector4i GSTextureCache::SourceRegion::GetRect(int tw, int th) const
|
|
{
|
|
return GSVector4i(HasX() ? GetMinX() : 0, HasY() ? GetMinY() : 0, HasX() ? GetMaxX() : tw, HasY() ? GetMaxY() : th);
|
|
}
|
|
|
|
GSVector4i GSTextureCache::SourceRegion::GetOffset(int tw, int th) const
|
|
{
|
|
const int xoffs = (GetMaxX() > tw) ? GetMinX() : 0;
|
|
const int yoffs = (GetMaxY() > th) ? GetMinY() : 0;
|
|
return GSVector4i(xoffs, yoffs, xoffs, yoffs);
|
|
}
|
|
|
|
GSTextureCache::SourceRegion GSTextureCache::SourceRegion::AdjustForMipmap(u32 level) const
|
|
{
|
|
// Texture levels must be at least one pixel wide/high.
|
|
SourceRegion ret = {};
|
|
if (HasX())
|
|
{
|
|
const s32 new_minx = GetMinX() >> level;
|
|
const s32 new_maxx = new_minx + std::max(GetWidth() >> level, 1);
|
|
ret.SetX(new_minx, new_maxx);
|
|
}
|
|
if (HasY())
|
|
{
|
|
const s32 new_miny = GetMinY() >> level;
|
|
const s32 new_maxy = new_miny + std::max(GetHeight() >> level, 1);
|
|
ret.SetY(new_miny, new_maxy);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void GSTextureCache::SourceRegion::AdjustTEX0(GIFRegTEX0* TEX0) const
|
|
{
|
|
const GSOffset offset(GSLocalMemory::m_psm[TEX0->PSM].info, TEX0->TBP0, TEX0->TBW, TEX0->PSM);
|
|
TEX0->TBP0 += offset.bn(GetMinX(), GetMinY());
|
|
}
|
|
|
|
GSTextureCache::SourceRegion GSTextureCache::SourceRegion::Create(GIFRegTEX0 TEX0, GIFRegCLAMP CLAMP)
|
|
{
|
|
SourceRegion region = {};
|
|
|
|
if (CLAMP.WMS == CLAMP_REGION_CLAMP && CLAMP.MAXU >= CLAMP.MINU)
|
|
{
|
|
// Another Lupin case here, it uses region clamp with UV (not ST), puts a clamp region further
|
|
// into the texture, but a smaller TW/TH. Catch this by looking for a clamp range above TW.
|
|
const u32 rw = CLAMP.MAXU - CLAMP.MINU + 1;
|
|
if (rw < (1u << TEX0.TW) || CLAMP.MAXU >= (1u << TEX0.TW))
|
|
{
|
|
region.SetX(CLAMP.MINU, CLAMP.MAXU + 1);
|
|
GL_CACHE("TC: Region clamp optimization: %d width -> %d", 1 << TEX0.TW, region.GetWidth());
|
|
}
|
|
}
|
|
else if (CLAMP.WMS == CLAMP_REGION_REPEAT && CLAMP.MINU != 0)
|
|
{
|
|
// Lupin the 3rd is really evil, it sets TW/TH to the texture size, but then uses region repeat
|
|
// to offset the actual texture data to elsewhere. So, we'll just force any cases like this down
|
|
// the region texture path.
|
|
const u32 rw = ((CLAMP.MINU | CLAMP.MAXU) - CLAMP.MAXU) + 1;
|
|
if (rw < (1u << TEX0.TW) || (CLAMP.MAXU != 0 && (rw <= (1u << TEX0.TW))))
|
|
{
|
|
region.SetX(CLAMP.MAXU, (CLAMP.MINU | CLAMP.MAXU) + 1);
|
|
GL_CACHE("TC: Region repeat optimization: %d width -> %d", 1 << TEX0.TW, region.GetWidth());
|
|
}
|
|
}
|
|
if (CLAMP.WMT == CLAMP_REGION_CLAMP && CLAMP.MAXV >= CLAMP.MINV)
|
|
{
|
|
const u32 rh = CLAMP.MAXV - CLAMP.MINV + 1;
|
|
if (rh < (1u << TEX0.TH) || CLAMP.MAXV >= (1u << TEX0.TH))
|
|
{
|
|
region.SetY(CLAMP.MINV, CLAMP.MAXV + 1);
|
|
GL_CACHE("TC: Region clamp optimization: %d height -> %d", 1 << TEX0.TW, region.GetHeight());
|
|
}
|
|
}
|
|
else if (CLAMP.WMT == CLAMP_REGION_REPEAT && CLAMP.MINV != 0)
|
|
{
|
|
const u32 rh = ((CLAMP.MINV | CLAMP.MAXV) - CLAMP.MAXV) + 1;
|
|
if (rh < (1u << TEX0.TH) || (CLAMP.MAXV != 0 && (rh <= (1u << TEX0.TH))))
|
|
{
|
|
region.SetY(CLAMP.MAXV, (CLAMP.MINV | CLAMP.MAXV) + 1);
|
|
GL_CACHE("TC: Region repeat optimization: %d height -> %d", 1 << TEX0.TW, region.GetHeight());
|
|
}
|
|
}
|
|
|
|
return region;
|
|
}
|
|
|
|
using BlockHashState = XXH3_state_t;
|
|
|
|
__fi static void BlockHashReset(BlockHashState& st)
|
|
{
|
|
XXH3_64bits_reset(&st);
|
|
}
|
|
|
|
__fi static void BlockHashAccumulate(BlockHashState& st, const u8* bp)
|
|
{
|
|
GSXXH3_64bits_update(&st, bp, BLOCK_SIZE);
|
|
}
|
|
|
|
__fi static void BlockHashAccumulate(BlockHashState& st, const u8* bp, u32 size)
|
|
{
|
|
GSXXH3_64bits_update(&st, bp, size);
|
|
}
|
|
|
|
__fi static GSTextureCache::HashType FinishBlockHash(BlockHashState& st)
|
|
{
|
|
return GSXXH3_64bits_digest(&st);
|
|
}
|
|
|
|
static void HashTextureLevel(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, GSTextureCache::SourceRegion region, BlockHashState& hash_st, u8* temp)
|
|
{
|
|
const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[TEX0.PSM];
|
|
const GSVector2i& bs = psm.bs;
|
|
const int tw = region.HasX() ? region.GetWidth() : (1 << TEX0.TW);
|
|
const int th = region.HasY() ? region.GetHeight() : (1 << TEX0.TH);
|
|
|
|
// From GSLocalMemory foreachBlock(), used for reading textures.
|
|
// We want to hash the exact same blocks here.
|
|
const GSVector4i rect(region.GetRect(tw, th));
|
|
const GSVector4i block_rect(rect.ralign<Align_Outside>(bs));
|
|
GSLocalMemory& mem = g_gs_renderer->m_mem;
|
|
const GSOffset off = mem.GetOffset(TEX0.TBP0, TEX0.TBW, TEX0.PSM);
|
|
|
|
// For textures which are smaller than the block size, we expand and then hash.
|
|
// This is because otherwise we get the padding bytes, which can be random junk.
|
|
// We also expand formats where the bits contributing to the texture do not cover
|
|
// all the 32 bits, as otherwise we'll get differing hash values if game overlap
|
|
// the texture data with other textures/framebuffers/etc (which is common).
|
|
// Even though you might think this would be slower than just hashing for the hash
|
|
// cache, it actually ends up faster (unswizzling is faster than hashing).
|
|
if (tw < bs.x || th < bs.y || psm.fmsk != 0xFFFFFFFFu || region.GetMaxX() > 0 || region.GetMinY() > 0)
|
|
{
|
|
// Expand texture indices. Align to 32 bytes for AVX2.
|
|
const bool palette = (psm.pal > 0);
|
|
const u32 pitch = VectorAlign(static_cast<u32>(block_rect.z) << (palette ? 0 : 2));
|
|
const u32 row_size = static_cast<u32>(tw) << (palette ? 0 : 2);
|
|
const GSLocalMemory::readTexture rtx = palette ? psm.rtxP : psm.rtx;
|
|
|
|
// Use temp buffer for expanding, since we may not need to update.
|
|
rtx(mem, off, block_rect, temp, pitch, TEXA);
|
|
|
|
// Hash the expanded texture.
|
|
u8* ptr = temp + (pitch * static_cast<u32>(rect.top - block_rect.top)) +
|
|
static_cast<u32>(rect.left - block_rect.left);
|
|
if (pitch == row_size)
|
|
{
|
|
BlockHashAccumulate(hash_st, ptr, pitch * static_cast<u32>(th));
|
|
}
|
|
else
|
|
{
|
|
for (int y = 0; y < th; y++, ptr += pitch)
|
|
BlockHashAccumulate(hash_st, ptr, row_size);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
GSOffset::BNHelper bn = off.bnMulti(block_rect.left, block_rect.top);
|
|
const int right = block_rect.right >> off.blockShiftX();
|
|
const int bottom = block_rect.bottom >> off.blockShiftY();
|
|
const int xAdd = (1 << off.blockShiftX()) * (psm.bpp / 8);
|
|
|
|
for (; bn.blkY() < bottom; bn.nextBlockY())
|
|
{
|
|
for (int x = 0; bn.blkX() < right; bn.nextBlockX(), x += xAdd)
|
|
{
|
|
BlockHashAccumulate(hash_st, mem.BlockPtr(bn.value()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
GSTextureCache::HashType GSTextureCache::HashTexture(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, SourceRegion region)
|
|
{
|
|
BlockHashState hash_st;
|
|
BlockHashReset(hash_st);
|
|
HashTextureLevel(TEX0, TEXA, region, hash_st, s_unswizzle_buffer);
|
|
return FinishBlockHash(hash_st);
|
|
}
|
|
|
|
void GSTextureCache::PreloadTexture(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, SourceRegion region, GSLocalMemory& mem,
|
|
bool paltex, GSTexture* tex, u32 level, std::pair<u8, u8>* alpha_minmax)
|
|
{
|
|
// m_TEX0 is adjusted for mips (messy, should be changed).
|
|
const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[TEX0.PSM];
|
|
const GSVector2i& bs = psm.bs;
|
|
const int tw = region.HasX() ? region.GetWidth() : (1 << TEX0.TW);
|
|
const int th = region.HasY() ? region.GetHeight() : (1 << TEX0.TH);
|
|
|
|
// Expand texture/apply palette.
|
|
const GSVector4i rect(region.GetRect(tw, th));
|
|
const GSVector4i block_rect(rect.ralign<Align_Outside>(bs));
|
|
const GSOffset off(mem.GetOffset(TEX0.TBP0, TEX0.TBW, TEX0.PSM));
|
|
const int read_width = block_rect.width();
|
|
u32 pitch = static_cast<u32>(read_width) * sizeof(u32);
|
|
GSLocalMemory::readTexture rtx = psm.rtx;
|
|
if (paltex)
|
|
{
|
|
pitch >>= 2;
|
|
rtx = psm.rtxP;
|
|
}
|
|
|
|
// If we can stream it directly to GPU memory, do so, otherwise go through a temp buffer.
|
|
const GSVector4i unoffset_rect(0, 0, tw, th);
|
|
GSTexture::GSMap map;
|
|
if (rect.eq(block_rect) && !alpha_minmax && tex->Map(map, &unoffset_rect, level))
|
|
{
|
|
rtx(mem, off, block_rect, map.bits, map.pitch, TEXA);
|
|
tex->Unmap();
|
|
}
|
|
else
|
|
{
|
|
pitch = VectorAlign(pitch);
|
|
|
|
u8* buff = s_unswizzle_buffer;
|
|
rtx(mem, off, block_rect, buff, pitch, TEXA);
|
|
|
|
const u8* ptr = buff + (pitch * static_cast<u32>(rect.top - block_rect.top)) +
|
|
(static_cast<u32>(rect.left - block_rect.left) << (paltex ? 0 : 2));
|
|
if (alpha_minmax)
|
|
{
|
|
pxAssert(GSLocalMemory::m_psm[TEX0.PSM].pal == 0);
|
|
*alpha_minmax = GSGetRGBA8AlphaMinMax(buff, unoffset_rect.width(), unoffset_rect.height(), pitch);
|
|
}
|
|
tex->Update(unoffset_rect, ptr, pitch, level);
|
|
}
|
|
}
|
|
|
|
GSTextureCache::HashCacheKey::HashCacheKey()
|
|
: TEX0Hash(0)
|
|
, CLUTHash(0)
|
|
{
|
|
TEX0.U64 = 0;
|
|
TEXA.U64 = 0;
|
|
}
|
|
|
|
GSTextureCache::HashCacheKey GSTextureCache::HashCacheKey::Create(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, const u32* clut, const GSVector2i* lod, SourceRegion region)
|
|
{
|
|
const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[TEX0.PSM];
|
|
|
|
HashCacheKey ret;
|
|
ret.TEX0.U64 = TEX0.U64 & 0x00000007FFF00000ULL;
|
|
ret.TEXA.U64 = (psm.pal == 0 && psm.fmt > 0) ? (TEXA.U64 & 0x000000FF000080FFULL) : 0;
|
|
ret.CLUTHash = clut ? GSTextureCache::PaletteKeyHash{}({clut, psm.pal}) : 0;
|
|
ret.region = region;
|
|
|
|
BlockHashState hash_st;
|
|
BlockHashReset(hash_st);
|
|
|
|
// base level is always hashed
|
|
HashTextureLevel(TEX0, TEXA, region, hash_st, s_unswizzle_buffer);
|
|
|
|
if (lod)
|
|
{
|
|
// hash and combine full mipmaps when enabled
|
|
const int basemip = lod->x;
|
|
const int nmips = lod->y - lod->x + 1;
|
|
for (int i = 1; i < nmips; i++)
|
|
{
|
|
const GIFRegTEX0 MIP_TEX0{g_gs_renderer->GetTex0Layer(basemip + i)};
|
|
HashTextureLevel(MIP_TEX0, TEXA, region.AdjustForMipmap(i), hash_st, s_unswizzle_buffer);
|
|
}
|
|
}
|
|
|
|
ret.TEX0Hash = FinishBlockHash(hash_st);
|
|
|
|
return ret;
|
|
}
|
|
|
|
GSTextureCache::HashCacheKey GSTextureCache::HashCacheKey::WithRemovedCLUTHash() const
|
|
{
|
|
HashCacheKey ret{*this};
|
|
ret.CLUTHash = 0;
|
|
return ret;
|
|
}
|
|
|
|
void GSTextureCache::HashCacheKey::RemoveCLUTHash()
|
|
{
|
|
CLUTHash = 0;
|
|
}
|
|
|
|
u64 GSTextureCache::HashCacheKeyHash::operator()(const HashCacheKey& key) const
|
|
{
|
|
std::size_t h = 0;
|
|
HashCombine(h, key.TEX0Hash, key.CLUTHash, key.TEX0.U64, key.TEXA.U64, key.region.bits);
|
|
return h;
|
|
}
|