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();
}
}
)hlsl";
void GeometryShaderCache::Init()
{
s_compiler = &HLSLAsyncCompiler::getInstance();
s_geometry_shaders_lock.unlock();
bool use_partial_buffer_update = D3D::SupportPartialContantBufferUpdate();
u32 gbsize = static_cast<u32>(Common::AlignUpSizePow2(sizeof(GeometryShaderConstants), 16) * (use_partial_buffer_update ? 1024 : 1)); // must be a multiple of 16
gscbuf = new D3D::ConstantStreamBuffer(gbsize);
ID3D11Buffer* buf = gscbuf->GetBuffer();
CHECK(buf != nullptr, "Create geometry shader constant buffer (size=%u)", gbsize);
D3D::SetDebugObjectName(buf, "geometry shader constant buffer used to emulate the GX pipeline");
// used when drawing clear quads
ClearGeometryShader = D3D::CompileAndCreateGeometryShader(gs_clear_shader_code);
CHECK(ClearGeometryShader != nullptr, "Create clear geometry shader");
D3D::SetDebugObjectName(ClearGeometryShader.get(), "clear geometry shader");
// used for buffer copy
CopyGeometryShader = D3D::CompileAndCreateGeometryShader(gs_copy_shader_code);
CHECK(CopyGeometryShader != nullptr, "Create copy geometry shader");
D3D::SetDebugObjectName(CopyGeometryShader.get(), "copy geometry shader");
Clear();
if (!File::Exists(File::GetUserPath(D_SHADERCACHE_IDX)))
File::CreateDir(File::GetUserPath(D_SHADERCACHE_IDX));
pKey_t gameid = (pKey_t)GetMurmurHash3(reinterpret_cast<const u8*>(SConfig::GetInstance().m_strGameID.data()), (u32)SConfig::GetInstance().m_strGameID.size(), 0);
s_geometry_shaders = GSCache::Create(
gameid,
GEOMETRYSHADERGEN_UID_VERSION,
"Ishiiruka.gs",
StringFromFormat("%s.gs", SConfig::GetInstance().m_strGameID.c_str())
);
std::string cache_filename = StringFromFormat("%sIDX11-%s-gs.cache", File::GetUserPath(D_SHADERCACHE_IDX).c_str(),
SConfig::GetInstance().m_strGameID.c_str());
GeometryShaderCacheInserter inserter;
g_gs_disk_cache.OpenAndRead(cache_filename, inserter);
if (g_ActiveConfig.bCompileShaderOnStartup)
{
size_t shader_count = 0;
s_geometry_shaders->ForEachMostUsedByCategory(gameid,
[&](const GeometryShaderUid& it, size_t total)
{
GeometryShaderUid item = it;
item.ClearHASH();
item.CalculateUIDHash();
CompileGShader(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();
}
},
[](GSCacheEntry& entry)
{
return !entry.shader;
}
, true);
s_compiler->WaitForFinish();
}
s_last_entry = nullptr;
}