void ShaderCache::HandlePSUIDChange(PixelShaderUid ps_uid, DSTALPHA_MODE ps_dst_alpha_mode)
{
s_last_pixel_shader_uid = ps_uid;
auto ps_iterator = s_ps_bytecode_cache.find(ps_uid);
if (ps_iterator != s_ps_bytecode_cache.end())
{
s_last_pixel_shader_bytecode = ps_iterator->second;
GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
}
else
{
ShaderCode ps_code = GeneratePixelShaderCode(APIType::D3D, ps_uid.GetUidData());
ID3DBlob* ps_bytecode = nullptr;
if (!D3D::CompilePixelShader(ps_code.GetBuffer(), &ps_bytecode))
{
GFX_DEBUGGER_PAUSE_AT(NEXT_ERROR, true);
return;
}
s_last_pixel_shader_bytecode = InsertByteCode(ps_uid, &s_ps_bytecode_cache, ps_bytecode);
s_ps_disk_cache.Append(ps_uid, reinterpret_cast<u8*>(ps_bytecode->GetBufferPointer()),
static_cast<u32>(ps_bytecode->GetBufferSize()));
SETSTAT(stats.numPixelShadersAlive, static_cast<int>(s_ps_bytecode_cache.size()));
INCSTAT(stats.numPixelShadersCreated);
}
}
bool PixelShaderCache::SetShader()
{
PixelShaderUid uid = GetPixelShaderUid();
// Check if the shader is already set
if (last_entry)
{
if (uid == last_uid)
{
GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
return (last_entry->shader != nullptr);
}
}
last_uid = uid;
// Check if the shader is already in the cache
PSCache::iterator iter;
iter = PixelShaders.find(uid);
if (iter != PixelShaders.end())
{
const PSCacheEntry& entry = iter->second;
last_entry = &entry;
GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
return (entry.shader != nullptr);
}
// Need to compile a new shader
ShaderCode code = GeneratePixelShaderCode(APIType::D3D, uid.GetUidData());
D3DBlob* pbytecode;
if (!D3D::CompilePixelShader(code.GetBuffer(), &pbytecode))
{
GFX_DEBUGGER_PAUSE_AT(NEXT_ERROR, true);
return false;
}
// Insert the bytecode into the caches
g_ps_disk_cache.Append(uid, pbytecode->Data(), pbytecode->Size());
bool success = InsertByteCode(uid, pbytecode->Data(), pbytecode->Size());
pbytecode->Release();
GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
return success;
}
void ShaderCache::HandlePSUIDChange(
const PixelShaderUid &ps_uid,
bool on_gpu_thread)
{
s_shaders_lock.lock();
ByteCodeCacheEntry* entry = &ps_bytecode_cache->GetOrAdd(ps_uid);
s_shaders_lock.unlock();
if (on_gpu_thread)
{
s_last_pixel_shader_bytecode = entry;
}
if (entry->m_initialized.test_and_set())
{
return;
}
// Need to compile a new shader
ShaderCompilerWorkUnit *wunit = s_compiler->NewUnit(PIXELSHADERGEN_BUFFERSIZE);
wunit->GenerateCodeHandler = [ps_uid](ShaderCompilerWorkUnit* wunit)
{
ShaderCode code;
code.SetBuffer(wunit->code.data());
GeneratePixelShaderCodeD3D11(code, ps_uid.GetUidData());
wunit->codesize = (u32)code.BufferSize();
};
wunit->entrypoint = "main";
wunit->flags = D3DCOMPILE_SKIP_VALIDATION | D3DCOMPILE_OPTIMIZATION_LEVEL3;
wunit->target = D3D::PixelShaderVersionString();
wunit->ResultHandler = [ps_uid, entry](ShaderCompilerWorkUnit* wunit)
{
if (SUCCEEDED(wunit->cresult))
{
D3DBlob* shaderBuffer = new D3DBlob(wunit->shaderbytecode);
s_ps_disk_cache.Append(ps_uid, shaderBuffer->Data(), shaderBuffer->Size());
PushByteCode(entry, shaderBuffer);
wunit->shaderbytecode->Release();
wunit->shaderbytecode = nullptr;
}
else
{
static int num_failures = 0;
std::string filename = StringFromFormat("%sbad_ps_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), num_failures++);
std::ofstream file;
OpenFStream(file, filename, std::ios_base::out);
file << ((const char *)wunit->code.data());
file << ((const char *)wunit->error->GetBufferPointer());
file.close();
PanicAlert("Failed to compile pixel shader!\nThis usually happens when trying to use Dolphin with an outdated GPU or integrated GPU like the Intel GMA series.\n\nIf you're sure this is Dolphin's error anyway, post the contents of %s along with this error message at the forums.\n\nDebug info (%s):\n%s",
filename,
D3D::PixelShaderVersionString(),
(char*)wunit->error->GetBufferPointer());
}
};
s_compiler->CompileShaderAsync(wunit);
}
void ShaderCache::Init()
{
s_compiler = &HLSLAsyncCompiler::getInstance();
s_shaders_lock.unlock();
s_pass_entry.m_compiled = true;
s_pass_entry.m_initialized.test_and_set();
// This class intentionally shares its shader cache files with DX11, as the shaders are (right now) identical.
// Reduces unnecessary compilation when switching between APIs.
s_last_domain_shader_bytecode = &s_pass_entry;
s_last_hull_shader_bytecode = &s_pass_entry;
s_last_geometry_shader_bytecode = &s_pass_entry;
s_last_pixel_shader_bytecode = nullptr;
s_last_vertex_shader_bytecode = nullptr;
s_last_geometry_shader_uid = {};
s_last_pixel_shader_uid = {};
s_last_vertex_shader_uid = {};
s_last_tessellation_shader_uid = {};
s_last_cpu_geometry_shader_uid = {};
s_last_cpu_pixel_shader_uid = {};
s_last_cpu_vertex_shader_uid = {};
s_last_cpu_tessellation_shader_uid = {};
// Ensure shader cache directory exists..
std::string shader_cache_path = File::GetUserPath(D_SHADERCACHE_IDX);
if (!File::Exists(shader_cache_path))
File::CreateDir(File::GetUserPath(D_SHADERCACHE_IDX));
std::string title_unique_id = SConfig::GetInstance().m_strGameID;
std::string ds_cache_filename = StringFromFormat("%sIDX11-%s-ds.cache", shader_cache_path.c_str(), title_unique_id.c_str());
std::string hs_cache_filename = StringFromFormat("%sIDX11-%s-hs.cache", shader_cache_path.c_str(), title_unique_id.c_str());
std::string gs_cache_filename = StringFromFormat("%sIDX11-%s-gs.cache", shader_cache_path.c_str(), title_unique_id.c_str());
std::string ps_cache_filename = StringFromFormat("%sIDX11-%s-ps.cache", shader_cache_path.c_str(), title_unique_id.c_str());
std::string vs_cache_filename = StringFromFormat("%sIDX11-%s-vs.cache", shader_cache_path.c_str(), title_unique_id.c_str());
pKey_t gameid = (pKey_t)GetMurmurHash3(reinterpret_cast<const u8*>(SConfig::GetInstance().m_strGameID.data()), (u32)SConfig::GetInstance().m_strGameID.size(), 0);
vs_bytecode_cache = VsBytecodeCache::Create(
gameid,
VERTEXSHADERGEN_UID_VERSION,
"Ishiiruka.vs",
StringFromFormat("%s.vs", title_unique_id.c_str())
);
ps_bytecode_cache = PsBytecodeCache::Create(
gameid,
PIXELSHADERGEN_UID_VERSION,
"Ishiiruka.ps",
StringFromFormat("%s.ps", title_unique_id.c_str())
);
gs_bytecode_cache = GsBytecodeCache::Create(
gameid,
GEOMETRYSHADERGEN_UID_VERSION,
"Ishiiruka.gs",
StringFromFormat("%s.gs", title_unique_id.c_str())
);
ts_bytecode_cache = TsBytecodeCache::Create(
gameid,
TESSELLATIONSHADERGEN_UID_VERSION,
"Ishiiruka.ts",
StringFromFormat("%s.ts", title_unique_id.c_str())
);
DShaderCacheInserter ds_inserter;
s_ds_disk_cache.OpenAndRead(ds_cache_filename, ds_inserter);
HShaderCacheInserter hs_inserter;
s_hs_disk_cache.OpenAndRead(hs_cache_filename, hs_inserter);
ShaderCacheInserter<GeometryShaderUid, GsBytecodeCache, &gs_bytecode_cache> gs_inserter;
s_gs_disk_cache.OpenAndRead(gs_cache_filename, gs_inserter);
ShaderCacheInserter<PixelShaderUid, PsBytecodeCache, &ps_bytecode_cache> ps_inserter;
s_ps_disk_cache.OpenAndRead(ps_cache_filename, ps_inserter);
ShaderCacheInserter<VertexShaderUid, VsBytecodeCache, &vs_bytecode_cache> vs_inserter;
s_vs_disk_cache.OpenAndRead(vs_cache_filename, vs_inserter);
// Clear out disk cache when debugging shaders to ensure stale ones don't stick around..
SETSTAT(stats.numGeometryShadersAlive, static_cast<int>(gs_bytecode_cache->size()));
SETSTAT(stats.numGeometryShadersCreated, 0);
SETSTAT(stats.numPixelShadersAlive, static_cast<int>(ps_bytecode_cache->size()));
SETSTAT(stats.numPixelShadersCreated, 0);
SETSTAT(stats.numVertexShadersAlive, static_cast<int>(vs_bytecode_cache->size()));
SETSTAT(stats.numVertexShadersCreated, 0);
if (g_ActiveConfig.bCompileShaderOnStartup)
{
size_t shader_count = 0;
ps_bytecode_cache->ForEachMostUsedByCategory(gameid,
[&](const PixelShaderUid& it, size_t total)
{
PixelShaderUid item = it;
item.ClearHASH();
item.CalculateUIDHash();
HandlePSUIDChange(item, true);
shader_count++;
if ((shader_count & 7) == 0)
{
Host_UpdateTitle(StringFromFormat("Compiling Pixel Shaders %i %% (%i/%i)", (shader_count * 100) / total, shader_count, total));
s_compiler->WaitForFinish();
}
},
[](ByteCodeCacheEntry& entry)
{
return !entry.m_shader_bytecode.pShaderBytecode;
}
, true);
shader_count = 0;
vs_bytecode_cache->ForEachMostUsedByCategory(gameid,
[&](const VertexShaderUid& it, size_t total)
{
VertexShaderUid item = it;
item.ClearHASH();
item.CalculateUIDHash();
HandleVSUIDChange(item, true);
shader_count++;
if ((shader_count & 31) == 0)
{
Host_UpdateTitle(StringFromFormat("Compiling Vertex Shaders %i %% (%i/%i)", (shader_count * 100) / total, shader_count, total));
s_compiler->WaitForFinish();
}
},
[](ByteCodeCacheEntry& entry)
{
return !entry.m_shader_bytecode.pShaderBytecode;
}
, true);
shader_count = 0;
gs_bytecode_cache->ForEachMostUsedByCategory(gameid,
[&](const GeometryShaderUid& it, size_t total)
{
GeometryShaderUid item = it;
item.ClearHASH();
item.CalculateUIDHash();
HandleGSUIDChange(item, true);
shader_count++;
if ((shader_count & 7) == 0)
{
Host_UpdateTitle(StringFromFormat("Compiling Geometry Shaders %i %% (%i/%i)", (shader_count * 100) / total, shader_count, total));
s_compiler->WaitForFinish();
}
},
[](ByteCodeCacheEntry& entry)
{
return !entry.m_shader_bytecode.pShaderBytecode;
}
, true);
shader_count = 0;
ts_bytecode_cache->ForEachMostUsedByCategory(gameid,
[&](const TessellationShaderUid& it, size_t total)
{
TessellationShaderUid item = it;
item.ClearHASH();
item.CalculateUIDHash();
HandleTSUIDChange(item, true);
shader_count++;
if ((shader_count & 31) == 0)
{
Host_UpdateTitle(StringFromFormat("Compiling Tessellation Shaders %i %% (%i/%i)", (shader_count * 100) / total, shader_count, total));
s_compiler->WaitForFinish();
}
},
[](std::pair<ByteCodeCacheEntry, ByteCodeCacheEntry>& entry)
{
return !entry.first.m_shader_bytecode.pShaderBytecode;
}
, true);
s_compiler->WaitForFinish();
}
}
void PixelShaderCache::PrepareShader(
PIXEL_SHADER_RENDER_MODE render_mode,
u32 components,
const XFMemory &xfr,
const BPMemory &bpm,
bool ongputhread)
{
const API_TYPE api = ((D3D::GetCaps().PixelShaderVersion >> 8) & 0xFF) < 3 ? API_D3D9_SM20 : API_D3D9_SM30;
PixelShaderUid uid;
GetPixelShaderUID(uid, render_mode, components, xfr, bpm);
if (ongputhread)
{
Compiler->ProcCompilationResults();
#if defined(_DEBUG) || defined(DEBUGFAST)
if (g_ActiveConfig.bEnableShaderDebugging)
{
ShaderCode code;
GeneratePixelShaderCodeD3D9(code, uid.GetUidData());
}
#endif
// Check if the shader is already set
if (last_entry[render_mode])
{
if (uid == last_uid[render_mode])
{
return;
}
}
last_uid[render_mode] = uid;
GFX_DEBUGGER_PAUSE_AT(NEXT_PIXEL_SHADER_CHANGE, true);
}
else
{
if (external_last_uid[render_mode] == uid)
{
return;
}
external_last_uid[render_mode] = uid;
}
PixelShadersLock.lock();
PSCacheEntry* entry = &PixelShaders[uid];
PixelShadersLock.unlock();
if (ongputhread)
{
last_entry[render_mode] = entry;
}
// Compile only when we have a new instance
if (entry->initialized.test_and_set())
{
return;
}
// Need to compile a new shader
ShaderCompilerWorkUnit *wunit = Compiler->NewUnit(PIXELSHADERGEN_BUFFERSIZE);
wunit->GenerateCodeHandler = [uid, api](ShaderCompilerWorkUnit* wunit)
{
ShaderCode code;
code.SetBuffer(wunit->code.data());
if (api == API_D3D9_SM20)
{
GeneratePixelShaderCodeD3D9SM2(code, uid.GetUidData());
}
else
{
GeneratePixelShaderCodeD3D9(code, uid.GetUidData());
}
wunit->codesize = (u32)code.BufferSize();
};
wunit->entrypoint = "main";
wunit->flags = D3DCOMPILE_SKIP_VALIDATION | D3DCOMPILE_OPTIMIZATION_LEVEL3;
wunit->target = D3D::PixelShaderVersionString();
wunit->ResultHandler = [uid, entry](ShaderCompilerWorkUnit* wunit)
{
if (SUCCEEDED(wunit->cresult))
{
ID3DBlob* shaderBuffer = wunit->shaderbytecode;
const u8* bytecode = (const u8*)shaderBuffer->GetBufferPointer();
u32 bytecodelen = (u32)shaderBuffer->GetBufferSize();
g_ps_disk_cache.Append(uid, bytecode, bytecodelen);
PushByteCode(uid, bytecode, bytecodelen, entry);
#if defined(_DEBUG) || defined(DEBUGFAST)
if (g_ActiveConfig.bEnableShaderDebugging)
{
u32 code_hash = HashAdler32((const u8 *)wunit->code.data(), wunit->codesize);
unique_shaders.insert(code_hash);
entry->code = wunit->code.data();
}
if (g_ActiveConfig.iLog & CONF_SAVESHADERS) {
static int counter = 0;
char szTemp[MAX_PATH];
sprintf(szTemp, "%sps_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), counter++);
SaveData(szTemp, wunit->code.data());
}
#endif
}
else
{
static int num_failures = 0;
std::string filename = StringFromFormat("%sbad_ps_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), num_failures++);
std::ofstream file;
OpenFStream(file, filename, std::ios_base::out);
file << ((const char *)wunit->code.data());
file << ((const char*)wunit->error->GetBufferPointer());
file.close();
PanicAlert("Failed to compile pixel shader!\nThis usually happens when trying to use Dolphin with an outdated GPU or integrated GPU like the Intel GMA series.\n\nIf you're sure this is Dolphin's error anyway, post the contents of %s along with this error message at the forums.\n\nDebug info (%s):\n%s",
filename,
D3D::VertexShaderVersionString(),
(const char*)wunit->error->GetBufferPointer());
}
};
Compiler->CompileShaderAsync(wunit);
}
void PixelShaderCache::CompilePShader(const PixelShaderUid& uid, PIXEL_SHADER_RENDER_MODE render_mode, bool ongputhread)
{
const API_TYPE api = ((D3D::GetCaps().PixelShaderVersion >> 8) & 0xFF) < 3 ? API_D3D9_SM20 : API_D3D9_SM30;
s_pixel_shaders_lock.lock();
PSCacheEntry* entry = &s_pshaders->GetOrAdd(uid);
s_pixel_shaders_lock.unlock();
if (ongputhread)
{
s_last_entry[render_mode] = entry;
}
// Compile only when we have a new instance
if (entry->initialized.test_and_set())
{
return;
}
// Need to compile a new shader
ShaderCompilerWorkUnit *wunit = s_compiler->NewUnit(PIXELSHADERGEN_BUFFERSIZE);
wunit->GenerateCodeHandler = [uid, api](ShaderCompilerWorkUnit* wunit)
{
ShaderCode code;
code.SetBuffer(wunit->code.data());
if (api == API_D3D9_SM20)
{
GeneratePixelShaderCodeD3D9SM2(code, uid.GetUidData());
}
else
{
GeneratePixelShaderCodeD3D9(code, uid.GetUidData());
}
wunit->codesize = (u32)code.BufferSize();
};
wunit->entrypoint = "main";
wunit->flags = D3DCOMPILE_SKIP_VALIDATION | D3DCOMPILE_OPTIMIZATION_LEVEL3;
wunit->target = D3D::PixelShaderVersionString();
wunit->ResultHandler = [uid, entry](ShaderCompilerWorkUnit* wunit)
{
if (SUCCEEDED(wunit->cresult))
{
ID3DBlob* shaderBuffer = wunit->shaderbytecode;
const u8* bytecode = (const u8*)shaderBuffer->GetBufferPointer();
u32 bytecodelen = (u32)shaderBuffer->GetBufferSize();
g_ps_disk_cache.Append(uid, bytecode, bytecodelen);
PushByteCode(uid, bytecode, bytecodelen, entry);
}
else
{
static int num_failures = 0;
std::string filename = StringFromFormat("%sbad_ps_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), num_failures++);
std::ofstream file;
OpenFStream(file, filename, std::ios_base::out);
file << ((const char *)wunit->code.data());
file << ((const char*)wunit->error->GetBufferPointer());
file.close();
PanicAlert("Failed to compile pixel shader!\nThis usually happens when trying to use Dolphin with an outdated GPU or integrated GPU like the Intel GMA series.\n\nIf you're sure this is Dolphin's error anyway, post the contents of %s along with this error message at the forums.\n\nDebug info (%s):\n%s",
filename,
D3D::VertexShaderVersionString(),
(const char*)wunit->error->GetBufferPointer());
}
};
s_compiler->CompileShaderAsync(wunit);
}
void PixelShaderCache::Init()
{
s_pixel_shaders_lock.unlock();
for (u32 i = 0; i < PSRM_DEPTH_ONLY + 1; i++)
{
s_last_entry[i] = nullptr;
}
s_compiler = &HLSLAsyncCompiler::getInstance();
//program used for clear screen
{
char pprog[3072];
sprintf(pprog, "void main(\n"
"out float4 ocol0 : COLOR0,\n"
" in float4 incol0 : COLOR0){\n"
"ocol0 = incol0;\n"
"}\n");
s_clear_program = D3D::CompileAndCreatePixelShader(pprog, (int)strlen(pprog));
}
int shaderModel = ((D3D::GetCaps().PixelShaderVersion >> 8) & 0xFF);
int maxConstants = (shaderModel < 3) ? 32 : ((shaderModel < 4) ? 224 : 65536);
// other screen copy/convert programs
for (int copyMatrixType = 0; copyMatrixType < NUM_COPY_TYPES; copyMatrixType++)
{
for (int depthType = 0; depthType < NUM_DEPTH_CONVERSION_TYPES; depthType++)
{
for (int ssaaMode = 0; ssaaMode < MAX_SSAA_SHADERS; ssaaMode++)
{
if (ssaaMode && !s_copy_program[copyMatrixType][depthType][ssaaMode - 1]
|| depthType && !s_copy_program[copyMatrixType][depthType - 1][ssaaMode]
|| copyMatrixType && !s_copy_program[copyMatrixType - 1][depthType][ssaaMode])
{
// if it failed at a lower setting, it's going to fail here for the same reason it did there,
// so skip this attempt to avoid duplicate error messages.
s_copy_program[copyMatrixType][depthType][ssaaMode] = NULL;
}
else
{
s_copy_program[copyMatrixType][depthType][ssaaMode] = CreateCopyShader(copyMatrixType, depthType, ssaaMode);
}
}
}
}
Clear();
if (!File::Exists(File::GetUserPath(D_SHADERCACHE_IDX)))
File::CreateDir(File::GetUserPath(D_SHADERCACHE_IDX).c_str());
SETSTAT(stats.numPixelShadersCreated, 0);
SETSTAT(stats.numPixelShadersAlive, 0);
pKey_t gameid = (pKey_t)GetMurmurHash3(reinterpret_cast<const u8*>(SConfig::GetInstance().m_strGameID.data()), (u32)SConfig::GetInstance().m_strGameID.size(), 0);
s_pshaders = ObjectUsageProfiler<PixelShaderUid, pKey_t, PSCacheEntry, PixelShaderUid::ShaderUidHasher>::Create(
gameid,
PIXELSHADERGEN_UID_VERSION,
"Ishiiruka.ps.dx9",
StringFromFormat("%s.ps.dx9", SConfig::GetInstance().m_strGameID.c_str())
);
std::string cache_filename = StringFromFormat("%sIDX9-%s-ps.cache", File::GetUserPath(D_SHADERCACHE_IDX).c_str(),
SConfig::GetInstance().m_strGameID.c_str());
PixelShaderCacheInserter inserter;
g_ps_disk_cache.OpenAndRead(cache_filename, inserter);
if (g_ActiveConfig.bCompileShaderOnStartup)
{
std::vector<PixelShaderUid> shaders;
size_t shader_count = 0;
s_pshaders->ForEachMostUsedByCategory(gameid,
[&](const PixelShaderUid& item, size_t total)
{
PixelShaderUid newitem = item;
pixel_shader_uid_data& uid_data = newitem.GetUidData<pixel_shader_uid_data>();
if (uid_data.render_mode == PSRM_DUAL_SOURCE_BLEND && !g_ActiveConfig.backend_info.bSupportsDualSourceBlend)
{
uid_data.render_mode = PSRM_DEFAULT;
newitem.ClearHASH();
newitem.CalculateUIDHash();
CompilePShader(newitem, PIXEL_SHADER_RENDER_MODE::PSRM_DEFAULT, true);
uid_data.render_mode = PSRM_ALPHA_PASS;
uid_data.fog_proj = 0;
uid_data.fog_RangeBaseEnabled = 0;
newitem.ClearHASH();
newitem.CalculateUIDHash();
CompilePShader(newitem, PIXEL_SHADER_RENDER_MODE::PSRM_ALPHA_PASS, true);
}
else
{
newitem.ClearHASH();
newitem.CalculateUIDHash();
CompilePShader(newitem, PIXEL_SHADER_RENDER_MODE::PSRM_DEFAULT, true);
}
shader_count++;
if ((shader_count & 7) == 0)
{
Host_UpdateTitle(StringFromFormat("Compiling Pixel Shaders %i %% (%i/%i)", (shader_count * 100) / total, shader_count, total));
s_compiler->WaitForFinish();
}
},
[](PSCacheEntry& entry)
{
return !entry.shader;
}, true);
s_compiler->WaitForFinish();
}
}
