TextureCache::TCacheEntryBase* TextureCache::Load(const u32 stage) { const FourTexUnits &tex = bpmem.tex[stage >> 2]; const u32 id = stage & 3; const u32 address = (tex.texImage3[id].image_base/* & 0x1FFFFF*/) << 5; u32 width = tex.texImage0[id].width + 1; u32 height = tex.texImage0[id].height + 1; const int texformat = tex.texImage0[id].format; const u32 tlutaddr = tex.texTlut[id].tmem_offset << 9; const u32 tlutfmt = tex.texTlut[id].tlut_format; const bool use_mipmaps = (tex.texMode0[id].min_filter & 3) != 0; u32 tex_levels = use_mipmaps ? ((tex.texMode1[id].max_lod + 0xf) / 0x10 + 1) : 1; const bool from_tmem = tex.texImage1[id].image_type != 0; if (0 == address) return nullptr; // TexelSizeInNibbles(format) * width * height / 16; const unsigned int bsw = TexDecoder_GetBlockWidthInTexels(texformat); const unsigned int bsh = TexDecoder_GetBlockHeightInTexels(texformat); unsigned int expandedWidth = ROUND_UP(width, bsw); unsigned int expandedHeight = ROUND_UP(height, bsh); const unsigned int nativeW = width; const unsigned int nativeH = height; // Hash assigned to texcache entry (also used to generate filenames used for texture dumping and custom texture lookup) u64 base_hash = TEXHASH_INVALID; u64 full_hash = TEXHASH_INVALID; u32 full_format = texformat; const bool isPaletteTexture = (texformat == GX_TF_C4 || texformat == GX_TF_C8 || texformat == GX_TF_C14X2); // Reject invalid tlut format. if (isPaletteTexture && tlutfmt > GX_TL_RGB5A3) return nullptr; if (isPaletteTexture) full_format = texformat | (tlutfmt << 16); const u32 texture_size = TexDecoder_GetTextureSizeInBytes(expandedWidth, expandedHeight, texformat); u32 additional_mips_size = 0; // not including level 0, which is texture_size // GPUs don't like when the specified mipmap count would require more than one 1x1-sized LOD in the mipmap chain // e.g. 64x64 with 7 LODs would have the mipmap chain 64x64,32x32,16x16,8x8,4x4,2x2,1x1,0x0, so we limit the mipmap count to 6 there tex_levels = std::min<u32>(IntLog2(std::max(width, height)) + 1, tex_levels); for (u32 level = 1; level != tex_levels; ++level) { // We still need to calculate the original size of the mips const u32 expanded_mip_width = ROUND_UP(CalculateLevelSize(width, level), bsw); const u32 expanded_mip_height = ROUND_UP(CalculateLevelSize(height, level), bsh); additional_mips_size += TexDecoder_GetTextureSizeInBytes(expanded_mip_width, expanded_mip_height, texformat); } // If we are recording a FifoLog, keep track of what memory we read. // FifiRecorder does it's own memory modification tracking independant of the texture hashing below. if (g_bRecordFifoData && !from_tmem) FifoRecorder::GetInstance().UseMemory(address, texture_size + additional_mips_size, MemoryUpdate::TEXTURE_MAP); const u8* src_data; if (from_tmem) src_data = &texMem[bpmem.tex[stage / 4].texImage1[stage % 4].tmem_even * TMEM_LINE_SIZE]; else src_data = Memory::GetPointer(address); // TODO: This doesn't hash GB tiles for preloaded RGBA8 textures (instead, it's hashing more data from the low tmem bank than it should) base_hash = GetHash64(src_data, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples); u32 palette_size = 0; if (isPaletteTexture) { palette_size = TexDecoder_GetPaletteSize(texformat); full_hash = base_hash ^ GetHash64(&texMem[tlutaddr], palette_size, g_ActiveConfig.iSafeTextureCache_ColorSamples); } else { full_hash = base_hash; } // Search the texture cache for textures by address // // Find all texture cache entries for the current texture address, and decide whether to use one of // them, or to create a new one // // In most cases, the fastest way is to use only one texture cache entry for the same address. Usually, // when a texture changes, the old version of the texture is unlikely to be used again. If there were // new cache entries created for normal texture updates, there would be a slowdown due to a huge amount // of unused cache entries. Also thanks to texture pooling, overwriting an existing cache entry is // faster than creating a new one from scratch. // // Some games use the same address for different textures though. If the same cache entry was used in // this case, it would be constantly overwritten, and effectively there wouldn't be any caching for // those textures. Examples for this are Metroid Prime and Castlevania 3. Metroid Prime has multiple // sets of fonts on each other stored in a single texture and uses the palette to make different // characters visible or invisible. In Castlevania 3 some textures are used for 2 different things or // at least in 2 different ways(size 1024x1024 vs 1024x256). // // To determine whether to use multiple cache entries or a single entry, use the following heuristic: // If the same texture address is used several times during the same frame, assume the address is used // for different purposes and allow creating an additional cache entry. If there's at least one entry // that hasn't been used for the same frame, then overwrite it, in order to keep the cache as small as // possible. If the current texture is found in the cache, use that entry. // // For efb copies, the entry created in CopyRenderTargetToTexture always has to be used, or else it was // done in vain. std::pair<TexCache::iterator, TexCache::iterator> iter_range = textures_by_address.equal_range((u64)address); TexCache::iterator iter = iter_range.first; TexCache::iterator oldest_entry = iter; int temp_frameCount = 0x7fffffff; TexCache::iterator unconverted_copy = textures_by_address.end(); while (iter != iter_range.second) { TCacheEntryBase* entry = iter->second; // Do not load strided EFB copies, they are not meant to be used directly if (entry->IsEfbCopy() && entry->native_width == nativeW && entry->native_height == nativeH && entry->memory_stride == entry->CacheLinesPerRow() * 32) { // EFB copies have slightly different rules as EFB copy formats have different // meanings from texture formats. if ((base_hash == entry->hash && (!isPaletteTexture || g_Config.backend_info.bSupportsPaletteConversion)) || IsPlayingBackFifologWithBrokenEFBCopies) { // TODO: We should check format/width/height/levels for EFB copies. Checking // format is complicated because EFB copy formats don't exactly match // texture formats. I'm not sure what effect checking width/height/levels // would have. if (!isPaletteTexture || !g_Config.backend_info.bSupportsPaletteConversion) return ReturnEntry(stage, entry); // Note that we found an unconverted EFB copy, then continue. We'll // perform the conversion later. Currently, we only convert EFB copies to // palette textures; we could do other conversions if it proved to be // beneficial. unconverted_copy = iter; } else { // Aggressively prune EFB copies: if it isn't useful here, it will probably // never be useful again. It's theoretically possible for a game to do // something weird where the copy could become useful in the future, but in // practice it doesn't happen. iter = FreeTexture(iter); continue; } } else { // For normal textures, all texture parameters need to match if (entry->hash == full_hash && entry->format == full_format && entry->native_levels >= tex_levels && entry->native_width == nativeW && entry->native_height == nativeH) { entry = DoPartialTextureUpdates(iter); return ReturnEntry(stage, entry); } } // Find the texture which hasn't been used for the longest time. Count paletted // textures as the same texture here, when the texture itself is the same. This // improves the performance a lot in some games that use paletted textures. // Example: Sonic the Fighters (inside Sonic Gems Collection) // Skip EFB copies here, so they can be used for partial texture updates if (entry->frameCount != FRAMECOUNT_INVALID && entry->frameCount < temp_frameCount && !entry->IsEfbCopy() && !(isPaletteTexture && entry->base_hash == base_hash)) { temp_frameCount = entry->frameCount; oldest_entry = iter; } ++iter; } if (unconverted_copy != textures_by_address.end()) { // Perform palette decoding. TCacheEntryBase *entry = unconverted_copy->second; TCacheEntryConfig config; config.rendertarget = true; config.width = entry->config.width; config.height = entry->config.height; config.layers = FramebufferManagerBase::GetEFBLayers(); TCacheEntryBase *decoded_entry = AllocateTexture(config); decoded_entry->SetGeneralParameters(address, texture_size, full_format); decoded_entry->SetDimensions(entry->native_width, entry->native_height, 1); decoded_entry->SetHashes(base_hash, full_hash); decoded_entry->frameCount = FRAMECOUNT_INVALID; decoded_entry->is_efb_copy = false; g_texture_cache->ConvertTexture(decoded_entry, entry, &texMem[tlutaddr], (TlutFormat)tlutfmt); textures_by_address.emplace((u64)address, decoded_entry); return ReturnEntry(stage, decoded_entry); } // Search the texture cache for normal textures by hash // // If the texture was fully hashed, the address does not need to match. Identical duplicate textures cause unnecessary slowdowns // Example: Tales of Symphonia (GC) uses over 500 small textures in menus, but only around 70 different ones if (g_ActiveConfig.iSafeTextureCache_ColorSamples == 0 || std::max(texture_size, palette_size) <= (u32)g_ActiveConfig.iSafeTextureCache_ColorSamples * 8) { iter_range = textures_by_hash.equal_range(full_hash); iter = iter_range.first; while (iter != iter_range.second) { TCacheEntryBase* entry = iter->second; // All parameters, except the address, need to match here if (entry->format == full_format && entry->native_levels >= tex_levels && entry->native_width == nativeW && entry->native_height == nativeH) { entry = DoPartialTextureUpdates(iter); return ReturnEntry(stage, entry); } ++iter; } } // If at least one entry was not used for the same frame, overwrite the oldest one if (temp_frameCount != 0x7fffffff) { // pool this texture and make a new one later FreeTexture(oldest_entry); } std::shared_ptr<HiresTexture> hires_tex; if (g_ActiveConfig.bHiresTextures) { hires_tex = HiresTexture::Search( src_data, texture_size, &texMem[tlutaddr], palette_size, width, height, texformat, use_mipmaps ); if (hires_tex) { auto& l = hires_tex->m_levels[0]; if (l.width != width || l.height != height) { width = l.width; height = l.height; } expandedWidth = l.width; expandedHeight = l.height; CheckTempSize(l.data_size); memcpy(temp, l.data, l.data_size); } } if (!hires_tex) { if (!(texformat == GX_TF_RGBA8 && from_tmem)) { const u8* tlut = &texMem[tlutaddr]; TexDecoder_Decode(temp, src_data, expandedWidth, expandedHeight, texformat, tlut, (TlutFormat)tlutfmt); } else { u8* src_data_gb = &texMem[bpmem.tex[stage / 4].texImage2[stage % 4].tmem_odd * TMEM_LINE_SIZE]; TexDecoder_DecodeRGBA8FromTmem(temp, src_data, src_data_gb, expandedWidth, expandedHeight); } } // how many levels the allocated texture shall have const u32 texLevels = hires_tex ? (u32)hires_tex->m_levels.size() : tex_levels; // create the entry/texture TCacheEntryConfig config; config.width = width; config.height = height; config.levels = texLevels; TCacheEntryBase* entry = AllocateTexture(config); GFX_DEBUGGER_PAUSE_AT(NEXT_NEW_TEXTURE, true); iter = textures_by_address.emplace((u64)address, entry); if (g_ActiveConfig.iSafeTextureCache_ColorSamples == 0 || std::max(texture_size, palette_size) <= (u32)g_ActiveConfig.iSafeTextureCache_ColorSamples * 8) { entry->textures_by_hash_iter = textures_by_hash.emplace(full_hash, entry); } entry->SetGeneralParameters(address, texture_size, full_format); entry->SetDimensions(nativeW, nativeH, tex_levels); entry->SetHashes(base_hash, full_hash); entry->is_efb_copy = false; entry->is_custom_tex = hires_tex != nullptr; // load texture entry->Load(width, height, expandedWidth, 0); std::string basename = ""; if (g_ActiveConfig.bDumpTextures && !hires_tex) { basename = HiresTexture::GenBaseName( src_data, texture_size, &texMem[tlutaddr], palette_size, width, height, texformat, use_mipmaps, true ); DumpTexture(entry, basename, 0); } if (hires_tex) { for (u32 level = 1; level != texLevels; ++level) { auto& l = hires_tex->m_levels[level]; CheckTempSize(l.data_size); memcpy(temp, l.data, l.data_size); entry->Load(l.width, l.height, l.width, level); } } else { // load mips - TODO: Loading mipmaps from tmem is untested! src_data += texture_size; const u8* ptr_even = nullptr; const u8* ptr_odd = nullptr; if (from_tmem) { ptr_even = &texMem[bpmem.tex[stage / 4].texImage1[stage % 4].tmem_even * TMEM_LINE_SIZE + texture_size]; ptr_odd = &texMem[bpmem.tex[stage / 4].texImage2[stage % 4].tmem_odd * TMEM_LINE_SIZE]; } for (u32 level = 1; level != texLevels; ++level) { const u32 mip_width = CalculateLevelSize(width, level); const u32 mip_height = CalculateLevelSize(height, level); const u32 expanded_mip_width = ROUND_UP(mip_width, bsw); const u32 expanded_mip_height = ROUND_UP(mip_height, bsh); const u8*& mip_src_data = from_tmem ? ((level % 2) ? ptr_odd : ptr_even) : src_data; const u8* tlut = &texMem[tlutaddr]; TexDecoder_Decode(temp, mip_src_data, expanded_mip_width, expanded_mip_height, texformat, tlut, (TlutFormat)tlutfmt); mip_src_data += TexDecoder_GetTextureSizeInBytes(expanded_mip_width, expanded_mip_height, texformat); entry->Load(mip_width, mip_height, expanded_mip_width, level); if (g_ActiveConfig.bDumpTextures) DumpTexture(entry, basename, level); } } INCSTAT(stats.numTexturesUploaded); SETSTAT(stats.numTexturesAlive, textures_by_address.size()); entry = DoPartialTextureUpdates(iter); return ReturnEntry(stage, entry); }
TextureCache::TCacheEntryBase* TextureCache::Load(unsigned int const stage, u32 const address, unsigned int width, unsigned int height, int const texformat, unsigned int const tlutaddr, int const tlutfmt, bool const use_mipmaps, unsigned int maxlevel, bool const from_tmem) { if (0 == address) return nullptr; // TexelSizeInNibbles(format) * width * height / 16; const unsigned int bsw = TexDecoder_GetBlockWidthInTexels(texformat) - 1; const unsigned int bsh = TexDecoder_GetBlockHeightInTexels(texformat) - 1; unsigned int expandedWidth = (width + bsw) & (~bsw); unsigned int expandedHeight = (height + bsh) & (~bsh); const unsigned int nativeW = width; const unsigned int nativeH = height; u32 texID = address; // Hash assigned to texcache entry (also used to generate filenames used for texture dumping and custom texture lookup) u64 tex_hash = TEXHASH_INVALID; u64 tlut_hash = TEXHASH_INVALID; u32 full_format = texformat; PC_TexFormat pcfmt = PC_TEX_FMT_NONE; const bool isPaletteTexture = (texformat == GX_TF_C4 || texformat == GX_TF_C8 || texformat == GX_TF_C14X2); if (isPaletteTexture) full_format = texformat | (tlutfmt << 16); const u32 texture_size = TexDecoder_GetTextureSizeInBytes(expandedWidth, expandedHeight, texformat); const u8* src_data; if (from_tmem) src_data = &texMem[bpmem.tex[stage / 4].texImage1[stage % 4].tmem_even * TMEM_LINE_SIZE]; else src_data = Memory::GetPointer(address); // TODO: This doesn't hash GB tiles for preloaded RGBA8 textures (instead, it's hashing more data from the low tmem bank than it should) tex_hash = GetHash64(src_data, texture_size, g_ActiveConfig.iSafeTextureCache_ColorSamples); if (isPaletteTexture) { const u32 palette_size = TexDecoder_GetPaletteSize(texformat); tlut_hash = GetHash64(&texMem[tlutaddr], palette_size, g_ActiveConfig.iSafeTextureCache_ColorSamples); // NOTE: For non-paletted textures, texID is equal to the texture address. // A paletted texture, however, may have multiple texIDs assigned though depending on the currently used tlut. // This (changing texID depending on the tlut_hash) is a trick to get around // an issue with Metroid Prime's fonts (it has multiple sets of fonts on each other // stored in a single texture and uses the palette to make different characters // visible or invisible. Thus, unless we want to recreate the textures for every drawn character, // we must make sure that a paletted texture gets assigned multiple IDs for each tlut used. // // TODO: Because texID isn't always the same as the address now, CopyRenderTargetToTexture might be broken now texID ^= ((u32)tlut_hash) ^(u32)(tlut_hash >> 32); tex_hash ^= tlut_hash; } // D3D doesn't like when the specified mipmap count would require more than one 1x1-sized LOD in the mipmap chain // e.g. 64x64 with 7 LODs would have the mipmap chain 64x64,32x32,16x16,8x8,4x4,2x2,1x1,1x1, so we limit the mipmap count to 6 there while (g_ActiveConfig.backend_info.bUseMinimalMipCount && std::max(expandedWidth, expandedHeight) >> maxlevel == 0) --maxlevel; TCacheEntryBase *entry = textures[texID]; if (entry) { // 1. Calculate reference hash: // calculated from RAM texture data for normal textures. Hashes for paletted textures are modified by tlut_hash. 0 for virtual EFB copies. if (g_ActiveConfig.bCopyEFBToTexture && entry->IsEfbCopy()) tex_hash = TEXHASH_INVALID; // 2. a) For EFB copies, only the hash and the texture address need to match if (entry->IsEfbCopy() && tex_hash == entry->hash && address == entry->addr) { entry->type = TCET_EC_VRAM; // TODO: Print a warning if the format changes! In this case, // we could reinterpret the internal texture object data to the new pixel format // (similar to what is already being done in Renderer::ReinterpretPixelFormat()) return ReturnEntry(stage, entry); } // 2. b) For normal textures, all texture parameters need to match if (address == entry->addr && tex_hash == entry->hash && full_format == entry->format && entry->num_mipmaps > maxlevel && entry->native_width == nativeW && entry->native_height == nativeH) { return ReturnEntry(stage, entry); } // 3. If we reach this line, we'll have to upload the new texture data to VRAM. // If we're lucky, the texture parameters didn't change and we can reuse the internal texture object instead of destroying and recreating it. // // TODO: Don't we need to force texture decoding to RGBA8 for dynamic EFB copies? // TODO: Actually, it should be enough if the internal texture format matches... if ((entry->type == TCET_NORMAL && width == entry->virtual_width && height == entry->virtual_height && full_format == entry->format && entry->num_mipmaps > maxlevel) || (entry->type == TCET_EC_DYNAMIC && entry->native_width == width && entry->native_height == height)) { // reuse the texture } else { // delete the texture and make a new one delete entry; entry = nullptr; } } bool using_custom_texture = false; if (g_ActiveConfig.bHiresTextures) { // This function may modify width/height. pcfmt = LoadCustomTexture(tex_hash, texformat, 0, width, height); if (pcfmt != PC_TEX_FMT_NONE) { if (expandedWidth != width || expandedHeight != height) { expandedWidth = width; expandedHeight = height; // If we thought we could reuse the texture before, make sure to pool it now! if (entry) { delete entry; entry = nullptr; } } using_custom_texture = true; } } if (!using_custom_texture) { if (!(texformat == GX_TF_RGBA8 && from_tmem)) { pcfmt = TexDecoder_Decode(temp, src_data, expandedWidth, expandedHeight, texformat, tlutaddr, tlutfmt, g_ActiveConfig.backend_info.bUseRGBATextures); } else { u8* src_data_gb = &texMem[bpmem.tex[stage/4].texImage2[stage%4].tmem_odd * TMEM_LINE_SIZE]; pcfmt = TexDecoder_DecodeRGBA8FromTmem(temp, src_data, src_data_gb, expandedWidth, expandedHeight); } } u32 texLevels = use_mipmaps ? (maxlevel + 1) : 1; const bool using_custom_lods = using_custom_texture && CheckForCustomTextureLODs(tex_hash, texformat, texLevels); // Only load native mips if their dimensions fit to our virtual texture dimensions const bool use_native_mips = use_mipmaps && !using_custom_lods && (width == nativeW && height == nativeH); texLevels = (use_native_mips || using_custom_lods) ? texLevels : 1; // TODO: Should be forced to 1 for non-pow2 textures (e.g. efb copies with automatically adjusted IR) // create the entry/texture if (nullptr == entry) { textures[texID] = entry = g_texture_cache->CreateTexture(width, height, expandedWidth, texLevels, pcfmt); // Sometimes, we can get around recreating a texture if only the number of mip levels changes // e.g. if our texture cache entry got too many mipmap levels we can limit the number of used levels by setting the appropriate render states // Thus, we don't update this member for every Load, but just whenever the texture gets recreated // TODO: This is the wrong value. We should be storing the number of levels our actual texture has. // But that will currently make the above "existing entry" tests fail as "texLevels" is not calculated until after. // Currently, we might try to reuse a texture which appears to have more levels than actual, maybe.. entry->num_mipmaps = maxlevel + 1; entry->type = TCET_NORMAL; GFX_DEBUGGER_PAUSE_AT(NEXT_NEW_TEXTURE, true); } else { // load texture (CreateTexture also loads level 0) entry->Load(width, height, expandedWidth, 0); } entry->SetGeneralParameters(address, texture_size, full_format, entry->num_mipmaps); entry->SetDimensions(nativeW, nativeH, width, height); entry->hash = tex_hash; if (entry->IsEfbCopy() && !g_ActiveConfig.bCopyEFBToTexture) entry->type = TCET_EC_DYNAMIC; else entry->type = TCET_NORMAL; if (g_ActiveConfig.bDumpTextures && !using_custom_texture) DumpTexture(entry, 0); u32 level = 1; // load mips - TODO: Loading mipmaps from tmem is untested! if (pcfmt != PC_TEX_FMT_NONE) { if (use_native_mips) { src_data += texture_size; const u8* ptr_even = nullptr; const u8* ptr_odd = nullptr; if (from_tmem) { ptr_even = &texMem[bpmem.tex[stage/4].texImage1[stage%4].tmem_even * TMEM_LINE_SIZE + texture_size]; ptr_odd = &texMem[bpmem.tex[stage/4].texImage2[stage%4].tmem_odd * TMEM_LINE_SIZE]; } for (; level != texLevels; ++level) { const u32 mip_width = CalculateLevelSize(width, level); const u32 mip_height = CalculateLevelSize(height, level); const u32 expanded_mip_width = (mip_width + bsw) & (~bsw); const u32 expanded_mip_height = (mip_height + bsh) & (~bsh); const u8*& mip_src_data = from_tmem ? ((level % 2) ? ptr_odd : ptr_even) : src_data; TexDecoder_Decode(temp, mip_src_data, expanded_mip_width, expanded_mip_height, texformat, tlutaddr, tlutfmt, g_ActiveConfig.backend_info.bUseRGBATextures); mip_src_data += TexDecoder_GetTextureSizeInBytes(expanded_mip_width, expanded_mip_height, texformat); entry->Load(mip_width, mip_height, expanded_mip_width, level); if (g_ActiveConfig.bDumpTextures) DumpTexture(entry, level); } } else if (using_custom_lods) { for (; level != texLevels; ++level) { unsigned int mip_width = CalculateLevelSize(width, level); unsigned int mip_height = CalculateLevelSize(height, level); LoadCustomTexture(tex_hash, texformat, level, mip_width, mip_height); entry->Load(mip_width, mip_height, mip_width, level); } } } INCSTAT(stats.numTexturesCreated); SETSTAT(stats.numTexturesAlive, textures.size()); return ReturnEntry(stage, entry); }
namespace TextureConversionShader { u16 GetEncodedSampleCount(EFBCopyFormat format) { switch (format) { case EFBCopyFormat::R4: return 8; case EFBCopyFormat::RA4: return 4; case EFBCopyFormat::RA8: return 2; case EFBCopyFormat::RGB565: return 2; case EFBCopyFormat::RGB5A3: return 2; case EFBCopyFormat::RGBA8: return 1; case EFBCopyFormat::A8: case EFBCopyFormat::R8_0x1: case EFBCopyFormat::R8: case EFBCopyFormat::G8: case EFBCopyFormat::B8: return 4; case EFBCopyFormat::RG8: case EFBCopyFormat::GB8: return 2; default: PanicAlert("Invalid EFB Copy Format (0x%X)! (GetEncodedSampleCount)", static_cast<int>(format)); return 1; } } // block dimensions : widthStride, heightStride // texture dims : width, height, x offset, y offset static void WriteSwizzler(char*& p, EFBCopyFormat format, APIType ApiType) { // left, top, of source rectangle within source texture // width of the destination rectangle, scale_factor (1 or 2) if (ApiType == APIType::Vulkan) WRITE(p, "layout(std140, push_constant) uniform PCBlock { int4 position; } PC;\n"); else WRITE(p, "uniform int4 position;\n"); // Alpha channel in the copy is set to 1 the EFB format does not have an alpha channel. WRITE(p, "float4 RGBA8ToRGB8(float4 src)\n"); WRITE(p, "{\n"); WRITE(p, " return float4(src.xyz, 1.0);\n"); WRITE(p, "}\n"); WRITE(p, "float4 RGBA8ToRGBA6(float4 src)\n"); WRITE(p, "{\n"); WRITE(p, " int4 val = int4(src * 255.0) >> 2;\n"); WRITE(p, " return float4(val) / 63.0;\n"); WRITE(p, "}\n"); WRITE(p, "float4 RGBA8ToRGB565(float4 src)\n"); WRITE(p, "{\n"); WRITE(p, " int4 val = int4(src * 255.0);\n"); WRITE(p, " val = int4(val.r >> 3, val.g >> 2, val.b >> 3, 1);\n"); WRITE(p, " return float4(val) / float4(31.0, 63.0, 31.0, 1.0);\n"); WRITE(p, "}\n"); int blkW = TexDecoder_GetEFBCopyBlockWidthInTexels(format); int blkH = TexDecoder_GetEFBCopyBlockHeightInTexels(format); int samples = GetEncodedSampleCount(format); if (ApiType == APIType::OpenGL) { WRITE(p, "#define samp0 samp9\n"); WRITE(p, "SAMPLER_BINDING(9) uniform sampler2DArray samp0;\n"); WRITE(p, "FRAGMENT_OUTPUT_LOCATION(0) out vec4 ocol0;\n"); WRITE(p, "void main()\n"); WRITE(p, "{\n" " int2 sampleUv;\n" " int2 uv1 = int2(gl_FragCoord.xy);\n"); } else if (ApiType == APIType::Vulkan) { WRITE(p, "SAMPLER_BINDING(0) uniform sampler2DArray samp0;\n"); WRITE(p, "FRAGMENT_OUTPUT_LOCATION(0) out vec4 ocol0;\n"); WRITE(p, "void main()\n"); WRITE(p, "{\n" " int2 sampleUv;\n" " int2 uv1 = int2(gl_FragCoord.xy);\n" " int4 position = PC.position;\n"); } else // D3D { WRITE(p, "sampler samp0 : register(s0);\n"); WRITE(p, "Texture2DArray Tex0 : register(t0);\n"); WRITE(p, "void main(\n"); WRITE(p, " out float4 ocol0 : SV_Target, in float4 rawpos : SV_Position)\n"); WRITE(p, "{\n" " int2 sampleUv;\n" " int2 uv1 = int2(rawpos.xy);\n"); } WRITE(p, " int x_block_position = (uv1.x >> %d) << %d;\n", IntLog2(blkH * blkW / samples), IntLog2(blkW)); WRITE(p, " int y_block_position = uv1.y << %d;\n", IntLog2(blkH)); if (samples == 1) { // With samples == 1, we write out pairs of blocks; one A8R8, one G8B8. WRITE(p, " bool first = (uv1.x & %d) == 0;\n", blkH * blkW / 2); samples = 2; } WRITE(p, " int offset_in_block = uv1.x & %d;\n", (blkH * blkW / samples) - 1); WRITE(p, " int y_offset_in_block = offset_in_block >> %d;\n", IntLog2(blkW / samples)); WRITE(p, " int x_offset_in_block = (offset_in_block & %d) << %d;\n", (blkW / samples) - 1, IntLog2(samples)); WRITE(p, " sampleUv.x = x_block_position + x_offset_in_block;\n"); WRITE(p, " sampleUv.y = y_block_position + y_offset_in_block;\n"); WRITE(p, " float2 uv0 = float2(sampleUv);\n"); // sampleUv is the sample position in (int)gx_coords WRITE(p, " uv0 += float2(0.5, 0.5);\n"); // move to center of pixel WRITE(p, " uv0 *= float(position.w);\n"); // scale by two if needed (also move to pixel borders // so that linear filtering will average adjacent // pixel) WRITE(p, " uv0 += float2(position.xy);\n"); // move to copied rect WRITE(p, " uv0 /= float2(%d, %d);\n", EFB_WIDTH, EFB_HEIGHT); // normalize to [0:1] if (ApiType == APIType::OpenGL) // ogl has to flip up and down { WRITE(p, " uv0.y = 1.0-uv0.y;\n"); } WRITE(p, " float sample_offset = float(position.w) / float(%d);\n", EFB_WIDTH); } static void WriteSampleColor(char*& p, const char* colorComp, const char* dest, int xoffset, APIType ApiType, const EFBCopyParams& params) { WRITE(p, " %s = ", dest); if (!params.depth) { switch (params.efb_format) { case PEControl::RGB8_Z24: WRITE(p, "RGBA8ToRGB8("); break; case PEControl::RGBA6_Z24: WRITE(p, "RGBA8ToRGBA6("); break; case PEControl::RGB565_Z16: WRITE(p, "RGBA8ToRGB565("); break; default: WRITE(p, "("); break; } } else { // Handle D3D depth inversion. if (ApiType == APIType::D3D || ApiType == APIType::Vulkan) WRITE(p, "1.0 - ("); else WRITE(p, "("); } if (ApiType == APIType::OpenGL || ApiType == APIType::Vulkan) { WRITE(p, "texture(samp0, float3(uv0 + float2(%d, 0) * sample_offset, 0.0))).%s;\n", xoffset, colorComp); } else { WRITE(p, "Tex0.Sample(samp0, float3(uv0 + float2(%d, 0) * sample_offset, 0.0))).%s;\n", xoffset, colorComp); } } static void WriteColorToIntensity(char*& p, const char* src, const char* dest) { if (!IntensityConstantAdded) { WRITE(p, " float4 IntensityConst = float4(0.257f,0.504f,0.098f,0.0625f);\n"); IntensityConstantAdded = true; } WRITE(p, " %s = dot(IntensityConst.rgb, %s.rgb);\n", dest, src); // don't add IntensityConst.a yet, because doing it later is faster and uses less instructions, // due to vectorization } static void WriteToBitDepth(char*& p, u8 depth, const char* src, const char* dest) { WRITE(p, " %s = floor(%s * 255.0 / exp2(8.0 - %d.0));\n", dest, src, depth); } static void WriteEncoderEnd(char*& p) { WRITE(p, "}\n"); IntensityConstantAdded = false; } static void WriteI8Encoder(char*& p, APIType ApiType, const EFBCopyParams& params) { WriteSwizzler(p, EFBCopyFormat::R8, ApiType); WRITE(p, " float3 texSample;\n"); WriteSampleColor(p, "rgb", "texSample", 0, ApiType, params); WriteColorToIntensity(p, "texSample", "ocol0.b"); WriteSampleColor(p, "rgb", "texSample", 1, ApiType, params); WriteColorToIntensity(p, "texSample", "ocol0.g"); WriteSampleColor(p, "rgb", "texSample", 2, ApiType, params); WriteColorToIntensity(p, "texSample", "ocol0.r"); WriteSampleColor(p, "rgb", "texSample", 3, ApiType, params); WriteColorToIntensity(p, "texSample", "ocol0.a"); WRITE(p, " ocol0.rgba += IntensityConst.aaaa;\n"); // see WriteColorToIntensity WriteEncoderEnd(p); } static void WriteI4Encoder(char*& p, APIType ApiType, const EFBCopyParams& params) { WriteSwizzler(p, EFBCopyFormat::R4, ApiType); WRITE(p, " float3 texSample;\n"); WRITE(p, " float4 color0;\n"); WRITE(p, " float4 color1;\n"); WriteSampleColor(p, "rgb", "texSample", 0, ApiType, params); WriteColorToIntensity(p, "texSample", "color0.b"); WriteSampleColor(p, "rgb", "texSample", 1, ApiType, params); WriteColorToIntensity(p, "texSample", "color1.b"); WriteSampleColor(p, "rgb", "texSample", 2, ApiType, params); WriteColorToIntensity(p, "texSample", "color0.g"); WriteSampleColor(p, "rgb", "texSample", 3, ApiType, params); WriteColorToIntensity(p, "texSample", "color1.g"); WriteSampleColor(p, "rgb", "texSample", 4, ApiType, params); WriteColorToIntensity(p, "texSample", "color0.r"); WriteSampleColor(p, "rgb", "texSample", 5, ApiType, params); WriteColorToIntensity(p, "texSample", "color1.r"); WriteSampleColor(p, "rgb", "texSample", 6, ApiType, params); WriteColorToIntensity(p, "texSample", "color0.a"); WriteSampleColor(p, "rgb", "texSample", 7, ApiType, params); WriteColorToIntensity(p, "texSample", "color1.a"); WRITE(p, " color0.rgba += IntensityConst.aaaa;\n"); WRITE(p, " color1.rgba += IntensityConst.aaaa;\n"); WriteToBitDepth(p, 4, "color0", "color0"); WriteToBitDepth(p, 4, "color1", "color1"); WRITE(p, " ocol0 = (color0 * 16.0 + color1) / 255.0;\n"); WriteEncoderEnd(p); } static void WriteIA8Encoder(char*& p, APIType ApiType, const EFBCopyParams& params) { WriteSwizzler(p, EFBCopyFormat::RA8, ApiType); WRITE(p, " float4 texSample;\n"); WriteSampleColor(p, "rgba", "texSample", 0, ApiType, params); WRITE(p, " ocol0.b = texSample.a;\n"); WriteColorToIntensity(p, "texSample", "ocol0.g"); WriteSampleColor(p, "rgba", "texSample", 1, ApiType, params); WRITE(p, " ocol0.r = texSample.a;\n"); WriteColorToIntensity(p, "texSample", "ocol0.a"); WRITE(p, " ocol0.ga += IntensityConst.aa;\n"); WriteEncoderEnd(p); } static void WriteIA4Encoder(char*& p, APIType ApiType, const EFBCopyParams& params) { WriteSwizzler(p, EFBCopyFormat::RA4, ApiType); WRITE(p, " float4 texSample;\n"); WRITE(p, " float4 color0;\n"); WRITE(p, " float4 color1;\n"); WriteSampleColor(p, "rgba", "texSample", 0, ApiType, params); WRITE(p, " color0.b = texSample.a;\n"); WriteColorToIntensity(p, "texSample", "color1.b"); WriteSampleColor(p, "rgba", "texSample", 1, ApiType, params); WRITE(p, " color0.g = texSample.a;\n"); WriteColorToIntensity(p, "texSample", "color1.g"); WriteSampleColor(p, "rgba", "texSample", 2, ApiType, params); WRITE(p, " color0.r = texSample.a;\n"); WriteColorToIntensity(p, "texSample", "color1.r"); WriteSampleColor(p, "rgba", "texSample", 3, ApiType, params); WRITE(p, " color0.a = texSample.a;\n"); WriteColorToIntensity(p, "texSample", "color1.a"); WRITE(p, " color1.rgba += IntensityConst.aaaa;\n"); WriteToBitDepth(p, 4, "color0", "color0"); WriteToBitDepth(p, 4, "color1", "color1"); WRITE(p, " ocol0 = (color0 * 16.0 + color1) / 255.0;\n"); WriteEncoderEnd(p); } static void WriteRGB565Encoder(char*& p, APIType ApiType, const EFBCopyParams& params) { WriteSwizzler(p, EFBCopyFormat::RGB565, ApiType); WRITE(p, " float3 texSample0;\n"); WRITE(p, " float3 texSample1;\n"); WriteSampleColor(p, "rgb", "texSample0", 0, ApiType, params); WriteSampleColor(p, "rgb", "texSample1", 1, ApiType, params); WRITE(p, " float2 texRs = float2(texSample0.r, texSample1.r);\n"); WRITE(p, " float2 texGs = float2(texSample0.g, texSample1.g);\n"); WRITE(p, " float2 texBs = float2(texSample0.b, texSample1.b);\n"); WriteToBitDepth(p, 6, "texGs", "float2 gInt"); WRITE(p, " float2 gUpper = floor(gInt / 8.0);\n"); WRITE(p, " float2 gLower = gInt - gUpper * 8.0;\n"); WriteToBitDepth(p, 5, "texRs", "ocol0.br"); WRITE(p, " ocol0.br = ocol0.br * 8.0 + gUpper;\n"); WriteToBitDepth(p, 5, "texBs", "ocol0.ga"); WRITE(p, " ocol0.ga = ocol0.ga + gLower * 32.0;\n"); WRITE(p, " ocol0 = ocol0 / 255.0;\n"); WriteEncoderEnd(p); } static void WriteRGB5A3Encoder(char*& p, APIType ApiType, const EFBCopyParams& params) { WriteSwizzler(p, EFBCopyFormat::RGB5A3, ApiType); WRITE(p, " float4 texSample;\n"); WRITE(p, " float color0;\n"); WRITE(p, " float gUpper;\n"); WRITE(p, " float gLower;\n"); WriteSampleColor(p, "rgba", "texSample", 0, ApiType, params); // 0.8784 = 224 / 255 which is the maximum alpha value that can be represented in 3 bits WRITE(p, "if(texSample.a > 0.878f) {\n"); WriteToBitDepth(p, 5, "texSample.g", "color0"); WRITE(p, " gUpper = floor(color0 / 8.0);\n"); WRITE(p, " gLower = color0 - gUpper * 8.0;\n"); WriteToBitDepth(p, 5, "texSample.r", "ocol0.b"); WRITE(p, " ocol0.b = ocol0.b * 4.0 + gUpper + 128.0;\n"); WriteToBitDepth(p, 5, "texSample.b", "ocol0.g"); WRITE(p, " ocol0.g = ocol0.g + gLower * 32.0;\n"); WRITE(p, "} else {\n"); WriteToBitDepth(p, 4, "texSample.r", "ocol0.b"); WriteToBitDepth(p, 4, "texSample.b", "ocol0.g"); WriteToBitDepth(p, 3, "texSample.a", "color0"); WRITE(p, "ocol0.b = ocol0.b + color0 * 16.0;\n"); WriteToBitDepth(p, 4, "texSample.g", "color0"); WRITE(p, "ocol0.g = ocol0.g + color0 * 16.0;\n"); WRITE(p, "}\n"); WriteSampleColor(p, "rgba", "texSample", 1, ApiType, params); WRITE(p, "if(texSample.a > 0.878f) {\n"); WriteToBitDepth(p, 5, "texSample.g", "color0"); WRITE(p, " gUpper = floor(color0 / 8.0);\n"); WRITE(p, " gLower = color0 - gUpper * 8.0;\n"); WriteToBitDepth(p, 5, "texSample.r", "ocol0.r"); WRITE(p, " ocol0.r = ocol0.r * 4.0 + gUpper + 128.0;\n"); WriteToBitDepth(p, 5, "texSample.b", "ocol0.a"); WRITE(p, " ocol0.a = ocol0.a + gLower * 32.0;\n"); WRITE(p, "} else {\n"); WriteToBitDepth(p, 4, "texSample.r", "ocol0.r"); WriteToBitDepth(p, 4, "texSample.b", "ocol0.a"); WriteToBitDepth(p, 3, "texSample.a", "color0"); WRITE(p, "ocol0.r = ocol0.r + color0 * 16.0;\n"); WriteToBitDepth(p, 4, "texSample.g", "color0"); WRITE(p, "ocol0.a = ocol0.a + color0 * 16.0;\n"); WRITE(p, "}\n"); WRITE(p, " ocol0 = ocol0 / 255.0;\n"); WriteEncoderEnd(p); } static void WriteRGBA8Encoder(char*& p, APIType ApiType, const EFBCopyParams& params) { WriteSwizzler(p, EFBCopyFormat::RGBA8, ApiType); WRITE(p, " float4 texSample;\n"); WRITE(p, " float4 color0;\n"); WRITE(p, " float4 color1;\n"); WriteSampleColor(p, "rgba", "texSample", 0, ApiType, params); WRITE(p, " color0.b = texSample.a;\n"); WRITE(p, " color0.g = texSample.r;\n"); WRITE(p, " color1.b = texSample.g;\n"); WRITE(p, " color1.g = texSample.b;\n"); WriteSampleColor(p, "rgba", "texSample", 1, ApiType, params); WRITE(p, " color0.r = texSample.a;\n"); WRITE(p, " color0.a = texSample.r;\n"); WRITE(p, " color1.r = texSample.g;\n"); WRITE(p, " color1.a = texSample.b;\n"); WRITE(p, " ocol0 = first ? color0 : color1;\n"); WriteEncoderEnd(p); } static void WriteC4Encoder(char*& p, const char* comp, APIType ApiType, const EFBCopyParams& params) { WriteSwizzler(p, EFBCopyFormat::R4, ApiType); WRITE(p, " float4 color0;\n"); WRITE(p, " float4 color1;\n"); WriteSampleColor(p, comp, "color0.b", 0, ApiType, params); WriteSampleColor(p, comp, "color1.b", 1, ApiType, params); WriteSampleColor(p, comp, "color0.g", 2, ApiType, params); WriteSampleColor(p, comp, "color1.g", 3, ApiType, params); WriteSampleColor(p, comp, "color0.r", 4, ApiType, params); WriteSampleColor(p, comp, "color1.r", 5, ApiType, params); WriteSampleColor(p, comp, "color0.a", 6, ApiType, params); WriteSampleColor(p, comp, "color1.a", 7, ApiType, params); WriteToBitDepth(p, 4, "color0", "color0"); WriteToBitDepth(p, 4, "color1", "color1"); WRITE(p, " ocol0 = (color0 * 16.0 + color1) / 255.0;\n"); WriteEncoderEnd(p); } static void WriteC8Encoder(char*& p, const char* comp, APIType ApiType, const EFBCopyParams& params) { WriteSwizzler(p, EFBCopyFormat::R8, ApiType); WriteSampleColor(p, comp, "ocol0.b", 0, ApiType, params); WriteSampleColor(p, comp, "ocol0.g", 1, ApiType, params); WriteSampleColor(p, comp, "ocol0.r", 2, ApiType, params); WriteSampleColor(p, comp, "ocol0.a", 3, ApiType, params); WriteEncoderEnd(p); } static void WriteCC4Encoder(char*& p, const char* comp, APIType ApiType, const EFBCopyParams& params) { WriteSwizzler(p, EFBCopyFormat::RA4, ApiType); WRITE(p, " float2 texSample;\n"); WRITE(p, " float4 color0;\n"); WRITE(p, " float4 color1;\n"); WriteSampleColor(p, comp, "texSample", 0, ApiType, params); WRITE(p, " color0.b = texSample.x;\n"); WRITE(p, " color1.b = texSample.y;\n"); WriteSampleColor(p, comp, "texSample", 1, ApiType, params); WRITE(p, " color0.g = texSample.x;\n"); WRITE(p, " color1.g = texSample.y;\n"); WriteSampleColor(p, comp, "texSample", 2, ApiType, params); WRITE(p, " color0.r = texSample.x;\n"); WRITE(p, " color1.r = texSample.y;\n"); WriteSampleColor(p, comp, "texSample", 3, ApiType, params); WRITE(p, " color0.a = texSample.x;\n"); WRITE(p, " color1.a = texSample.y;\n"); WriteToBitDepth(p, 4, "color0", "color0"); WriteToBitDepth(p, 4, "color1", "color1"); WRITE(p, " ocol0 = (color0 * 16.0 + color1) / 255.0;\n"); WriteEncoderEnd(p); } static void WriteCC8Encoder(char*& p, const char* comp, APIType ApiType, const EFBCopyParams& params) { WriteSwizzler(p, EFBCopyFormat::RA8, ApiType); WriteSampleColor(p, comp, "ocol0.bg", 0, ApiType, params); WriteSampleColor(p, comp, "ocol0.ra", 1, ApiType, params); WriteEncoderEnd(p); } static void WriteZ8Encoder(char*& p, const char* multiplier, APIType ApiType, const EFBCopyParams& params) { WriteSwizzler(p, EFBCopyFormat::G8, ApiType); WRITE(p, " float depth;\n"); WriteSampleColor(p, "r", "depth", 0, ApiType, params); WRITE(p, "ocol0.b = frac(depth * %s);\n", multiplier); WriteSampleColor(p, "r", "depth", 1, ApiType, params); WRITE(p, "ocol0.g = frac(depth * %s);\n", multiplier); WriteSampleColor(p, "r", "depth", 2, ApiType, params); WRITE(p, "ocol0.r = frac(depth * %s);\n", multiplier); WriteSampleColor(p, "r", "depth", 3, ApiType, params); WRITE(p, "ocol0.a = frac(depth * %s);\n", multiplier); WriteEncoderEnd(p); } static void WriteZ16Encoder(char*& p, APIType ApiType, const EFBCopyParams& params) { WriteSwizzler(p, EFBCopyFormat::RA8, ApiType); WRITE(p, " float depth;\n"); WRITE(p, " float3 expanded;\n"); // byte order is reversed WriteSampleColor(p, "r", "depth", 0, ApiType, params); WRITE(p, " depth *= 16777216.0;\n"); WRITE(p, " expanded.r = floor(depth / (256.0 * 256.0));\n"); WRITE(p, " depth -= expanded.r * 256.0 * 256.0;\n"); WRITE(p, " expanded.g = floor(depth / 256.0);\n"); WRITE(p, " ocol0.b = expanded.g / 255.0;\n"); WRITE(p, " ocol0.g = expanded.r / 255.0;\n"); WriteSampleColor(p, "r", "depth", 1, ApiType, params); WRITE(p, " depth *= 16777216.0;\n"); WRITE(p, " expanded.r = floor(depth / (256.0 * 256.0));\n"); WRITE(p, " depth -= expanded.r * 256.0 * 256.0;\n"); WRITE(p, " expanded.g = floor(depth / 256.0);\n"); WRITE(p, " ocol0.r = expanded.g / 255.0;\n"); WRITE(p, " ocol0.a = expanded.r / 255.0;\n"); WriteEncoderEnd(p); } static void WriteZ16LEncoder(char*& p, APIType ApiType, const EFBCopyParams& params) { WriteSwizzler(p, EFBCopyFormat::GB8, ApiType); WRITE(p, " float depth;\n"); WRITE(p, " float3 expanded;\n"); // byte order is reversed WriteSampleColor(p, "r", "depth", 0, ApiType, params); WRITE(p, " depth *= 16777216.0;\n"); WRITE(p, " expanded.r = floor(depth / (256.0 * 256.0));\n"); WRITE(p, " depth -= expanded.r * 256.0 * 256.0;\n"); WRITE(p, " expanded.g = floor(depth / 256.0);\n"); WRITE(p, " depth -= expanded.g * 256.0;\n"); WRITE(p, " expanded.b = depth;\n"); WRITE(p, " ocol0.b = expanded.b / 255.0;\n"); WRITE(p, " ocol0.g = expanded.g / 255.0;\n"); WriteSampleColor(p, "r", "depth", 1, ApiType, params); WRITE(p, " depth *= 16777216.0;\n"); WRITE(p, " expanded.r = floor(depth / (256.0 * 256.0));\n"); WRITE(p, " depth -= expanded.r * 256.0 * 256.0;\n"); WRITE(p, " expanded.g = floor(depth / 256.0);\n"); WRITE(p, " depth -= expanded.g * 256.0;\n"); WRITE(p, " expanded.b = depth;\n"); WRITE(p, " ocol0.r = expanded.b / 255.0;\n"); WRITE(p, " ocol0.a = expanded.g / 255.0;\n"); WriteEncoderEnd(p); } static void WriteZ24Encoder(char*& p, APIType ApiType, const EFBCopyParams& params) { WriteSwizzler(p, EFBCopyFormat::RGBA8, ApiType); WRITE(p, " float depth0;\n"); WRITE(p, " float depth1;\n"); WRITE(p, " float3 expanded0;\n"); WRITE(p, " float3 expanded1;\n"); WriteSampleColor(p, "r", "depth0", 0, ApiType, params); WriteSampleColor(p, "r", "depth1", 1, ApiType, params); for (int i = 0; i < 2; i++) { WRITE(p, " depth%i *= 16777216.0;\n", i); WRITE(p, " expanded%i.r = floor(depth%i / (256.0 * 256.0));\n", i, i); WRITE(p, " depth%i -= expanded%i.r * 256.0 * 256.0;\n", i, i); WRITE(p, " expanded%i.g = floor(depth%i / 256.0);\n", i, i); WRITE(p, " depth%i -= expanded%i.g * 256.0;\n", i, i); WRITE(p, " expanded%i.b = depth%i;\n", i, i); } WRITE(p, " if (!first) {\n"); // upper 16 WRITE(p, " ocol0.b = expanded0.g / 255.0;\n"); WRITE(p, " ocol0.g = expanded0.b / 255.0;\n"); WRITE(p, " ocol0.r = expanded1.g / 255.0;\n"); WRITE(p, " ocol0.a = expanded1.b / 255.0;\n"); WRITE(p, " } else {\n"); // lower 8 WRITE(p, " ocol0.b = 1.0;\n"); WRITE(p, " ocol0.g = expanded0.r / 255.0;\n"); WRITE(p, " ocol0.r = 1.0;\n"); WRITE(p, " ocol0.a = expanded1.r / 255.0;\n"); WRITE(p, " }\n"); WriteEncoderEnd(p); } const char* GenerateEncodingShader(const EFBCopyParams& params, APIType api_type) { text[sizeof(text) - 1] = 0x7C; // canary char* p = text; switch (params.copy_format) { case EFBCopyFormat::R4: if (params.yuv) WriteI4Encoder(p, api_type, params); else WriteC4Encoder(p, "r", api_type, params); break; case EFBCopyFormat::RA4: if (params.yuv) WriteIA4Encoder(p, api_type, params); else WriteCC4Encoder(p, "ar", api_type, params); break; case EFBCopyFormat::RA8: if (params.yuv) WriteIA8Encoder(p, api_type, params); else WriteCC8Encoder(p, "ar", api_type, params); break; case EFBCopyFormat::RGB565: WriteRGB565Encoder(p, api_type, params); break; case EFBCopyFormat::RGB5A3: WriteRGB5A3Encoder(p, api_type, params); break; case EFBCopyFormat::RGBA8: if (params.depth) WriteZ24Encoder(p, api_type, params); else WriteRGBA8Encoder(p, api_type, params); break; case EFBCopyFormat::A8: WriteC8Encoder(p, "a", api_type, params); break; case EFBCopyFormat::R8_0x1: case EFBCopyFormat::R8: if (params.yuv) WriteI8Encoder(p, api_type, params); else WriteC8Encoder(p, "r", api_type, params); break; case EFBCopyFormat::G8: if (params.depth) WriteZ8Encoder(p, "256.0", api_type, params); // Z8M else WriteC8Encoder(p, "g", api_type, params); break; case EFBCopyFormat::B8: if (params.depth) WriteZ8Encoder(p, "65536.0", api_type, params); // Z8L else WriteC8Encoder(p, "b", api_type, params); break; case EFBCopyFormat::RG8: if (params.depth) WriteZ16Encoder(p, api_type, params); // Z16H else WriteCC8Encoder(p, "rg", api_type, params); break; case EFBCopyFormat::GB8: if (params.depth) WriteZ16LEncoder(p, api_type, params); // Z16L else WriteCC8Encoder(p, "gb", api_type, params); break; default: PanicAlert("Invalid EFB Copy Format (0x%X)! (GenerateEncodingShader)", static_cast<int>(params.copy_format)); break; } if (text[sizeof(text) - 1] != 0x7C) PanicAlert("TextureConversionShader generator - buffer too small, canary has been eaten!"); return text; } // NOTE: In these uniforms, a row refers to a row of blocks, not texels. static const char decoding_shader_header[] = R"( #ifdef VULKAN layout(std140, push_constant) uniform PushConstants { uvec2 dst_size; uvec2 src_size; uint src_offset; uint src_row_stride; uint palette_offset; } push_constants; #define u_dst_size (push_constants.dst_size) #define u_src_size (push_constants.src_size) #define u_src_offset (push_constants.src_offset) #define u_src_row_stride (push_constants.src_row_stride) #define u_palette_offset (push_constants.palette_offset) TEXEL_BUFFER_BINDING(0) uniform usamplerBuffer s_input_buffer; TEXEL_BUFFER_BINDING(1) uniform usamplerBuffer s_palette_buffer; IMAGE_BINDING(rgba8, 0) uniform writeonly image2DArray output_image; #else uniform uvec2 u_dst_size; uniform uvec2 u_src_size; uniform uint u_src_offset; uniform uint u_src_row_stride; uniform uint u_palette_offset; SAMPLER_BINDING(9) uniform usamplerBuffer s_input_buffer; SAMPLER_BINDING(10) uniform usamplerBuffer s_palette_buffer; layout(rgba8, binding = 0) uniform writeonly image2DArray output_image; #endif uint Swap16(uint v) { // Convert BE to LE. return ((v >> 8) | (v << 8)) & 0xFFFFu; } uint Convert3To8(uint v) { // Swizzle bits: 00000123 -> 12312312 return (v << 5) | (v << 2) | (v >> 1); } uint Convert4To8(uint v) { // Swizzle bits: 00001234 -> 12341234 return (v << 4) | v; } uint Convert5To8(uint v) { // Swizzle bits: 00012345 -> 12345123 return (v << 3) | (v >> 2); } uint Convert6To8(uint v) { // Swizzle bits: 00123456 -> 12345612 return (v << 2) | (v >> 4); } uint GetTiledTexelOffset(uvec2 block_size, uvec2 coords) { uvec2 block = coords / block_size; uvec2 offset = coords % block_size; uint buffer_pos = u_src_offset; buffer_pos += block.y * u_src_row_stride; buffer_pos += block.x * (block_size.x * block_size.y); buffer_pos += offset.y * block_size.x; buffer_pos += offset.x; return buffer_pos; } uvec4 GetPaletteColor(uint index) { // Fetch and swap BE to LE. uint val = Swap16(texelFetch(s_palette_buffer, int(u_palette_offset + index)).x); uvec4 color; #if defined(PALETTE_FORMAT_IA8) uint a = bitfieldExtract(val, 8, 8); uint i = bitfieldExtract(val, 0, 8); color = uvec4(i, i, i, a); #elif defined(PALETTE_FORMAT_RGB565) color.x = Convert5To8(bitfieldExtract(val, 11, 5)); color.y = Convert6To8(bitfieldExtract(val, 5, 6)); color.z = Convert5To8(bitfieldExtract(val, 0, 5)); color.a = 255u; #elif defined(PALETTE_FORMAT_RGB5A3) if ((val & 0x8000u) != 0u) { color.x = Convert5To8(bitfieldExtract(val, 10, 5)); color.y = Convert5To8(bitfieldExtract(val, 5, 5)); color.z = Convert5To8(bitfieldExtract(val, 0, 5)); color.a = 255u; } else { color.a = Convert3To8(bitfieldExtract(val, 12, 3)); color.r = Convert4To8(bitfieldExtract(val, 8, 4)); color.g = Convert4To8(bitfieldExtract(val, 4, 4)); color.b = Convert4To8(bitfieldExtract(val, 0, 4)); } #else // Not used. color = uvec4(0, 0, 0, 0); #endif return color; } vec4 GetPaletteColorNormalized(uint index) { uvec4 color = GetPaletteColor(index); return vec4(color) / 255.0; } )"; static const std::map<TextureFormat, DecodingShaderInfo> s_decoding_shader_info{ {TextureFormat::I4, {BUFFER_FORMAT_R8_UINT, 0, 8, 8, false, R"( layout(local_size_x = 8, local_size_y = 8) in; void main() { uvec2 coords = gl_GlobalInvocationID.xy; // Tiled in 8x8 blocks, 4 bits per pixel // We need to do the tiling manually here because the texel size is smaller than // the size of the buffer elements. uint2 block = coords.xy / 8u; uint2 offset = coords.xy % 8u; uint buffer_pos = u_src_offset; buffer_pos += block.y * u_src_row_stride; buffer_pos += block.x * 32u; buffer_pos += offset.y * 4u; buffer_pos += offset.x / 2u; // Select high nibble for odd texels, low for even. uint val = texelFetch(s_input_buffer, int(buffer_pos)).x; uint i; if ((coords.x & 1u) == 0u) i = Convert4To8((val >> 4)); else i = Convert4To8((val & 0x0Fu)); uvec4 color = uvec4(i, i, i, i); vec4 norm_color = vec4(color) / 255.0; imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); } )"}}, {TextureFormat::IA4, {BUFFER_FORMAT_R8_UINT, 0, 8, 8, false, R"( layout(local_size_x = 8, local_size_y = 8) in; void main() { uvec2 coords = gl_GlobalInvocationID.xy; // Tiled in 8x4 blocks, 8 bits per pixel uint buffer_pos = GetTiledTexelOffset(uvec2(8u, 4u), coords); uint val = texelFetch(s_input_buffer, int(buffer_pos)).x; uint i = Convert4To8((val & 0x0Fu)); uint a = Convert4To8((val >> 4)); uvec4 color = uvec4(i, i, i, a); vec4 norm_color = vec4(color) / 255.0; imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); } )"}}, {TextureFormat::I8, {BUFFER_FORMAT_R8_UINT, 0, 8, 8, false, R"( layout(local_size_x = 8, local_size_y = 8) in; void main() { uvec2 coords = gl_GlobalInvocationID.xy; // Tiled in 8x4 blocks, 8 bits per pixel uint buffer_pos = GetTiledTexelOffset(uvec2(8u, 4u), coords); uint i = texelFetch(s_input_buffer, int(buffer_pos)).x; uvec4 color = uvec4(i, i, i, i); vec4 norm_color = vec4(color) / 255.0; imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); } )"}}, {TextureFormat::IA8, {BUFFER_FORMAT_R16_UINT, 0, 8, 8, false, R"( layout(local_size_x = 8, local_size_y = 8) in; void main() { uvec2 coords = gl_GlobalInvocationID.xy; // Tiled in 4x4 blocks, 16 bits per pixel uint buffer_pos = GetTiledTexelOffset(uvec2(4u, 4u), coords); uint val = texelFetch(s_input_buffer, int(buffer_pos)).x; uint a = (val & 0xFFu); uint i = (val >> 8); uvec4 color = uvec4(i, i, i, a); vec4 norm_color = vec4(color) / 255.0; imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); } )"}}, {TextureFormat::RGB565, {BUFFER_FORMAT_R16_UINT, 0, 8, 8, false, R"( layout(local_size_x = 8, local_size_y = 8) in; void main() { uvec2 coords = gl_GlobalInvocationID.xy; // Tiled in 4x4 blocks uint buffer_pos = GetTiledTexelOffset(uvec2(4u, 4u), coords); uint val = Swap16(texelFetch(s_input_buffer, int(buffer_pos)).x); uvec4 color; color.x = Convert5To8(bitfieldExtract(val, 11, 5)); color.y = Convert6To8(bitfieldExtract(val, 5, 6)); color.z = Convert5To8(bitfieldExtract(val, 0, 5)); color.a = 255u; vec4 norm_color = vec4(color) / 255.0; imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); } )"}}, {TextureFormat::RGB5A3, {BUFFER_FORMAT_R16_UINT, 0, 8, 8, false, R"( layout(local_size_x = 8, local_size_y = 8) in; void main() { uvec2 coords = gl_GlobalInvocationID.xy; // Tiled in 4x4 blocks uint buffer_pos = GetTiledTexelOffset(uvec2(4u, 4u), coords); uint val = Swap16(texelFetch(s_input_buffer, int(buffer_pos)).x); uvec4 color; if ((val & 0x8000u) != 0u) { color.x = Convert5To8(bitfieldExtract(val, 10, 5)); color.y = Convert5To8(bitfieldExtract(val, 5, 5)); color.z = Convert5To8(bitfieldExtract(val, 0, 5)); color.a = 255u; } else { color.a = Convert3To8(bitfieldExtract(val, 12, 3)); color.r = Convert4To8(bitfieldExtract(val, 8, 4)); color.g = Convert4To8(bitfieldExtract(val, 4, 4)); color.b = Convert4To8(bitfieldExtract(val, 0, 4)); } vec4 norm_color = vec4(color) / 255.0; imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); } )"}}, {TextureFormat::RGBA8, {BUFFER_FORMAT_R16_UINT, 0, 8, 8, false, R"( layout(local_size_x = 8, local_size_y = 8) in; void main() { uvec2 coords = gl_GlobalInvocationID.xy; // Tiled in 4x4 blocks // We can't use the normal calculation function, as these are packed as the AR channels // for the entire block, then the GB channels afterwards. uint2 block = coords.xy / 4u; uint2 offset = coords.xy % 4u; uint buffer_pos = u_src_offset; // Our buffer has 16-bit elements, so the offsets here are half what they would be in bytes. buffer_pos += block.y * u_src_row_stride; buffer_pos += block.x * 32u; buffer_pos += offset.y * 4u; buffer_pos += offset.x; // The two GB channels follow after the block's AR channels. uint val1 = texelFetch(s_input_buffer, int(buffer_pos + 0u)).x; uint val2 = texelFetch(s_input_buffer, int(buffer_pos + 16u)).x; uvec4 color; color.a = (val1 & 0xFFu); color.r = (val1 >> 8); color.g = (val2 & 0xFFu); color.b = (val2 >> 8); vec4 norm_color = vec4(color) / 255.0; imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); } )"}}, {TextureFormat::CMPR, {BUFFER_FORMAT_R32G32_UINT, 0, 64, 1, true, R"( // In the compute version of this decoder, we flatten the blocks to a one-dimension array. // Each group is subdivided into 16, and the first thread in each group fetches the DXT data. // All threads then calculate the possible colors for the block and write to the output image. #define GROUP_SIZE 64u #define BLOCK_SIZE_X 4u #define BLOCK_SIZE_Y 4u #define BLOCK_SIZE (BLOCK_SIZE_X * BLOCK_SIZE_Y) #define BLOCKS_PER_GROUP (GROUP_SIZE / BLOCK_SIZE) layout(local_size_x = GROUP_SIZE, local_size_y = 1) in; shared uvec2 shared_temp[BLOCKS_PER_GROUP]; uint DXTBlend(uint v1, uint v2) { // 3/8 blend, which is close to 1/3 return ((v1 * 3u + v2 * 5u) >> 3); } void main() { uint local_thread_id = gl_LocalInvocationID.x; uint block_in_group = local_thread_id / BLOCK_SIZE; uint thread_in_block = local_thread_id % BLOCK_SIZE; uint block_index = gl_WorkGroupID.x * BLOCKS_PER_GROUP + block_in_group; // Annoyingly, we can't precalculate this as a uniform because the DXT block size differs // from the block size of the overall texture (4 vs 8). We can however use a multiply and // subtraction to avoid the modulo for calculating the block's X coordinate. uint blocks_wide = u_src_size.x / BLOCK_SIZE_X; uvec2 block_coords; block_coords.y = block_index / blocks_wide; block_coords.x = block_index - (block_coords.y * blocks_wide); // Only the first thread for each block reads from the texel buffer. if (thread_in_block == 0u) { // Calculate tiled block coordinates. uvec2 tile_block_coords = block_coords / 2u; uvec2 subtile_block_coords = block_coords % 2u; uint buffer_pos = u_src_offset; buffer_pos += tile_block_coords.y * u_src_row_stride; buffer_pos += tile_block_coords.x * 4u; buffer_pos += subtile_block_coords.y * 2u; buffer_pos += subtile_block_coords.x; // Read the entire DXT block to shared memory. uvec2 raw_data = texelFetch(s_input_buffer, int(buffer_pos)).xy; shared_temp[block_in_group] = raw_data; } // Ensure store is completed before the remaining threads in the block continue. memoryBarrierShared(); barrier(); // Unpack colors and swap BE to LE. uvec2 raw_data = shared_temp[block_in_group]; uint swapped = ((raw_data.x & 0xFF00FF00u) >> 8) | ((raw_data.x & 0x00FF00FFu) << 8); uint c1 = swapped & 0xFFFFu; uint c2 = swapped >> 16; // Expand 5/6 bit channels to 8-bits per channel. uint blue1 = Convert5To8(bitfieldExtract(c1, 0, 5)); uint blue2 = Convert5To8(bitfieldExtract(c2, 0, 5)); uint green1 = Convert6To8(bitfieldExtract(c1, 5, 6)); uint green2 = Convert6To8(bitfieldExtract(c2, 5, 6)); uint red1 = Convert5To8(bitfieldExtract(c1, 11, 5)); uint red2 = Convert5To8(bitfieldExtract(c2, 11, 5)); // Determine the four colors the block can use. // It's quicker to just precalculate all four colors rather than branching on the index. // NOTE: These must be masked with 0xFF. This is done at the normalization stage below. uvec4 color0, color1, color2, color3; color0 = uvec4(red1, green1, blue1, 255u); color1 = uvec4(red2, green2, blue2, 255u); if (c1 > c2) { color2 = uvec4(DXTBlend(red2, red1), DXTBlend(green2, green1), DXTBlend(blue2, blue1), 255u); color3 = uvec4(DXTBlend(red1, red2), DXTBlend(green1, green2), DXTBlend(blue1, blue2), 255u); } else { color2 = uvec4((red1 + red2) / 2u, (green1 + green2) / 2u, (blue1 + blue2) / 2u, 255u); color3 = uvec4((red1 + red2) / 2u, (green1 + green2) / 2u, (blue1 + blue2) / 2u, 0u); } // Calculate the texel coordinates that we will write to. // The divides/modulo here should be turned into a shift/binary AND. uint local_y = thread_in_block / BLOCK_SIZE_X; uint local_x = thread_in_block % BLOCK_SIZE_X; uint global_x = block_coords.x * BLOCK_SIZE_X + local_x; uint global_y = block_coords.y * BLOCK_SIZE_Y + local_y; // Use the coordinates within the block to shift the 32-bit value containing // all 16 indices to a single 2-bit index. uint index = bitfieldExtract(raw_data.y, int((local_y * 8u) + (6u - local_x * 2u)), 2); // Select the un-normalized color from the precalculated color array. // Using a switch statement here removes the need for dynamic indexing of an array. uvec4 color; switch (index) { case 0u: color = color0; break; case 1u: color = color1; break; case 2u: color = color2; break; case 3u: color = color3; break; default: color = color0; break; } // Normalize and write to the output image. vec4 norm_color = vec4(color & 0xFFu) / 255.0; imageStore(output_image, ivec3(ivec2(uvec2(global_x, global_y)), 0), norm_color); } )"}}, {TextureFormat::C4, {BUFFER_FORMAT_R8_UINT, static_cast<u32>(TexDecoder_GetPaletteSize(TextureFormat::C4)), 8, 8, false, R"( layout(local_size_x = 8, local_size_y = 8) in; void main() { uvec2 coords = gl_GlobalInvocationID.xy; // Tiled in 8x8 blocks, 4 bits per pixel // We need to do the tiling manually here because the texel size is smaller than // the size of the buffer elements. uint2 block = coords.xy / 8u; uint2 offset = coords.xy % 8u; uint buffer_pos = u_src_offset; buffer_pos += block.y * u_src_row_stride; buffer_pos += block.x * 32u; buffer_pos += offset.y * 4u; buffer_pos += offset.x / 2u; // Select high nibble for odd texels, low for even. uint val = texelFetch(s_input_buffer, int(buffer_pos)).x; uint index = ((coords.x & 1u) == 0u) ? (val >> 4) : (val & 0x0Fu); vec4 norm_color = GetPaletteColorNormalized(index); imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); } )"}}, {TextureFormat::C8, {BUFFER_FORMAT_R8_UINT, static_cast<u32>(TexDecoder_GetPaletteSize(TextureFormat::C8)), 8, 8, false, R"( layout(local_size_x = 8, local_size_y = 8) in; void main() { uvec2 coords = gl_GlobalInvocationID.xy; // Tiled in 8x4 blocks, 8 bits per pixel uint buffer_pos = GetTiledTexelOffset(uvec2(8u, 4u), coords); uint index = texelFetch(s_input_buffer, int(buffer_pos)).x; vec4 norm_color = GetPaletteColorNormalized(index); imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); } )"}}, {TextureFormat::C14X2, {BUFFER_FORMAT_R16_UINT, static_cast<u32>(TexDecoder_GetPaletteSize(TextureFormat::C14X2)), 8, 8, false, R"( layout(local_size_x = 8, local_size_y = 8) in; void main() { uvec2 coords = gl_GlobalInvocationID.xy; // Tiled in 4x4 blocks, 16 bits per pixel uint buffer_pos = GetTiledTexelOffset(uvec2(4u, 4u), coords); uint index = Swap16(texelFetch(s_input_buffer, int(buffer_pos)).x) & 0x3FFFu; vec4 norm_color = GetPaletteColorNormalized(index); imageStore(output_image, ivec3(ivec2(coords), 0), norm_color); } )"}}}; static const std::array<u32, BUFFER_FORMAT_COUNT> s_buffer_bytes_per_texel = {{ 1, // BUFFER_FORMAT_R8_UINT 2, // BUFFER_FORMAT_R16_UINT 8, // BUFFER_FORMAT_R32G32_UINT }}; const DecodingShaderInfo* GetDecodingShaderInfo(TextureFormat format) { auto iter = s_decoding_shader_info.find(format); return iter != s_decoding_shader_info.end() ? &iter->second : nullptr; } u32 GetBytesPerBufferElement(BufferFormat buffer_format) { return s_buffer_bytes_per_texel[buffer_format]; } std::pair<u32, u32> GetDispatchCount(const DecodingShaderInfo* info, u32 width, u32 height) { // Flatten to a single dimension? if (info->group_flatten) return {(width * height + (info->group_size_x - 1)) / info->group_size_x, 1}; return {(width + (info->group_size_x - 1)) / info->group_size_x, (height + (info->group_size_y - 1)) / info->group_size_y}; } std::string GenerateDecodingShader(TextureFormat format, TLUTFormat palette_format, APIType api_type) { const DecodingShaderInfo* info = GetDecodingShaderInfo(format); if (!info) return ""; std::stringstream ss; switch (palette_format) { case TLUTFormat::IA8: ss << "#define PALETTE_FORMAT_IA8 1\n"; break; case TLUTFormat::RGB565: ss << "#define PALETTE_FORMAT_RGB565 1\n"; break; case TLUTFormat::RGB5A3: ss << "#define PALETTE_FORMAT_RGB5A3 1\n"; break; } ss << decoding_shader_header; ss << info->shader_body; return ss.str(); } } // namespace