izzy/dolphin
0
0
Fork 0
mirror of https://github.com/izzy2lost/dolphin.git synced 2026-06-19 01:16:48 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #11300 from iwubcode/custom-shaders

Browse Source 
VideoCommon: add a graphics mod action that allows you to modify the game's base rendering
This commit is contained in:
Admiral H. Curtiss
2023-08-22 02:18:40 +02:00
committed by GitHub
parent 3451cb1ca2 5506121685
commit dbe6a5f7e4
28 changed files with 2576 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/Core/DolphinLib.props
+6
View File
@@ -663,15 +663,18 @@
<ClInclude Include="VideoCommon\GeometryShaderGen.h" />
<ClInclude Include="VideoCommon\GeometryShaderManager.h" />
<ClInclude Include="VideoCommon\GraphicsModSystem\Config\GraphicsMod.h" />
<ClInclude Include="VideoCommon\GraphicsModSystem\Config\GraphicsModAsset.h" />
<ClInclude Include="VideoCommon\GraphicsModSystem\Config\GraphicsModFeature.h" />
<ClInclude Include="VideoCommon\GraphicsModSystem\Config\GraphicsModGroup.h" />
<ClInclude Include="VideoCommon\GraphicsModSystem\Config\GraphicsTarget.h" />
<ClInclude Include="VideoCommon\GraphicsModSystem\Config\GraphicsTargetGroup.h" />
<ClInclude Include="VideoCommon\GraphicsModSystem\Constants.h" />
<ClInclude Include="VideoCommon\GraphicsModSystem\Runtime\Actions\CustomPipelineAction.h" />
<ClInclude Include="VideoCommon\GraphicsModSystem\Runtime\Actions\MoveAction.h" />
<ClInclude Include="VideoCommon\GraphicsModSystem\Runtime\Actions\PrintAction.h" />
<ClInclude Include="VideoCommon\GraphicsModSystem\Runtime\Actions\ScaleAction.h" />
<ClInclude Include="VideoCommon\GraphicsModSystem\Runtime\Actions\SkipAction.h" />
<ClInclude Include="VideoCommon\GraphicsModSystem\Runtime\CustomShaderCache.h" />
<ClInclude Include="VideoCommon\GraphicsModSystem\Runtime\FBInfo.h" />
<ClInclude Include="VideoCommon\GraphicsModSystem\Runtime\GraphicsModAction.h" />
<ClInclude Include="VideoCommon\GraphicsModSystem\Runtime\GraphicsModActionData.h" />
@@ -1276,14 +1279,17 @@
<ClCompile Include="VideoCommon\GeometryShaderGen.cpp" />
<ClCompile Include="VideoCommon\GeometryShaderManager.cpp" />
<ClCompile Include="VideoCommon\GraphicsModSystem\Config\GraphicsMod.cpp" />
<ClCompile Include="VideoCommon\GraphicsModSystem\Config\GraphicsModAsset.cpp" />
<ClCompile Include="VideoCommon\GraphicsModSystem\Config\GraphicsModFeature.cpp" />
<ClCompile Include="VideoCommon\GraphicsModSystem\Config\GraphicsModGroup.cpp" />
<ClCompile Include="VideoCommon\GraphicsModSystem\Config\GraphicsTarget.cpp" />
<ClCompile Include="VideoCommon\GraphicsModSystem\Config\GraphicsTargetGroup.cpp" />
<ClCompile Include="VideoCommon\GraphicsModSystem\Runtime\Actions\CustomPipelineAction.cpp" />
<ClCompile Include="VideoCommon\GraphicsModSystem\Runtime\Actions\MoveAction.cpp" />
<ClCompile Include="VideoCommon\GraphicsModSystem\Runtime\Actions\PrintAction.cpp" />
<ClCompile Include="VideoCommon\GraphicsModSystem\Runtime\Actions\ScaleAction.cpp" />
<ClCompile Include="VideoCommon\GraphicsModSystem\Runtime\Actions\SkipAction.cpp" />
<ClCompile Include="VideoCommon\GraphicsModSystem\Runtime\CustomShaderCache.cpp" />
<ClCompile Include="VideoCommon\GraphicsModSystem\Runtime\FBInfo.cpp" />
<ClCompile Include="VideoCommon\GraphicsModSystem\Runtime\GraphicsModActionFactory.cpp" />
<ClCompile Include="VideoCommon\GraphicsModSystem\Runtime\GraphicsModManager.cpp" />
Source/Core/VideoCommon/CMakeLists.txt
+6
View File
@@ -64,6 +64,8 @@ add_library(videocommon
GeometryShaderManager.h
GraphicsModSystem/Config/GraphicsMod.cpp
GraphicsModSystem/Config/GraphicsMod.h
GraphicsModSystem/Config/GraphicsModAsset.cpp
GraphicsModSystem/Config/GraphicsModAsset.h
GraphicsModSystem/Config/GraphicsModFeature.cpp
GraphicsModSystem/Config/GraphicsModFeature.h
GraphicsModSystem/Config/GraphicsModGroup.cpp
@@ -73,6 +75,8 @@ add_library(videocommon
GraphicsModSystem/Config/GraphicsTargetGroup.cpp
GraphicsModSystem/Config/GraphicsTargetGroup.h
GraphicsModSystem/Constants.h
GraphicsModSystem/Runtime/Actions/CustomPipelineAction.cpp
GraphicsModSystem/Runtime/Actions/CustomPipelineAction.h
GraphicsModSystem/Runtime/Actions/MoveAction.cpp
GraphicsModSystem/Runtime/Actions/MoveAction.h
GraphicsModSystem/Runtime/Actions/PrintAction.cpp
@@ -81,6 +85,8 @@ add_library(videocommon
GraphicsModSystem/Runtime/Actions/ScaleAction.h
GraphicsModSystem/Runtime/Actions/SkipAction.cpp
GraphicsModSystem/Runtime/Actions/SkipAction.h
GraphicsModSystem/Runtime/CustomShaderCache.cpp
GraphicsModSystem/Runtime/CustomShaderCache.h
GraphicsModSystem/Runtime/FBInfo.cpp
GraphicsModSystem/Runtime/FBInfo.h
GraphicsModSystem/Runtime/GraphicsModAction.h
Source/Core/VideoCommon/ConstantManager.h
+2
View File
@@ -58,6 +58,8 @@ struct alignas(16) PixelShaderConstants
// For shader_framebuffer_fetch logic ops:
u32 logic_op_enable; // bool
LogicOp logic_op_mode;
// For custom shaders...
u32 time_ms;
};
struct alignas(16) VertexShaderConstants
Source/Core/VideoCommon/GraphicsModSystem/Config/GraphicsMod.cpp
+21
View File
@@ -178,6 +178,27 @@ bool GraphicsModConfig::DeserializeFromConfig(const picojson::value& value)
}
}
const auto& assets = value.get("assets");
if (assets.is<picojson::array>())
{
for (const auto& asset_val : assets.get<picojson::array>())
{
if (!asset_val.is<picojson::object>())
{
ERROR_LOG_FMT(
VIDEO, "Failed to load mod configuration file, specified asset is not a json object");
return false;
}
GraphicsModAssetConfig asset;
if (!asset.DeserializeFromConfig(asset_val.get<picojson::object>()))
{
return false;
}
m_assets.push_back(std::move(asset));
}
}
return true;
}
Source/Core/VideoCommon/GraphicsModSystem/Config/GraphicsMod.h
+2
View File
@@ -9,6 +9,7 @@
#include <picojson.h>
#include "VideoCommon/GraphicsModSystem/Config/GraphicsModAsset.h"
#include "VideoCommon/GraphicsModSystem/Config/GraphicsModFeature.h"
#include "VideoCommon/GraphicsModSystem/Config/GraphicsTargetGroup.h"
@@ -30,6 +31,7 @@ struct GraphicsModConfig
std::vector<GraphicsTargetGroupConfig> m_groups;
std::vector<GraphicsModFeatureConfig> m_features;
std::vector<GraphicsModAssetConfig> m_assets;
static std::optional<GraphicsModConfig> Create(const std::string& file, Source source);
static std::optional<GraphicsModConfig> Create(const picojson::object* obj);
Source/Core/VideoCommon/GraphicsModSystem/Config/GraphicsModAsset.cpp
+52
View File
@@ -0,0 +1,52 @@
// Copyright 2023 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include "VideoCommon/GraphicsModSystem/Config/GraphicsModAsset.h"
#include "Common/Logging/Log.h"
bool GraphicsModAssetConfig::DeserializeFromConfig(const picojson::object& obj)
{
auto name_iter = obj.find("name");
if (name_iter == obj.end())
{
ERROR_LOG_FMT(VIDEO, "Failed to load mod configuration file, specified asset has no name");
return false;
}
if (!name_iter->second.is<std::string>())
{
ERROR_LOG_FMT(VIDEO, "Failed to load mod configuration file, specified asset has a name "
"that is not a string");
return false;
}
m_name = name_iter->second.to_str();
auto data_iter = obj.find("data");
if (data_iter == obj.end())
{
ERROR_LOG_FMT(VIDEO, "Failed to load mod configuration file, specified asset '{}' has no data",
m_name);
return false;
}
if (!data_iter->second.is<picojson::object>())
{
ERROR_LOG_FMT(VIDEO,
"Failed to load mod configuration file, specified asset '{}' has data "
"that is not an object",
m_name);
return false;
}
for (const auto& [key, value] : data_iter->second.get<picojson::object>())
{
if (!value.is<std::string>())
{
ERROR_LOG_FMT(VIDEO,
"Failed to load mod configuration file, specified asset '{}' has data "
"with a value for key '{}' that is not a string",
m_name, key);
}
m_map[key] = value.to_str();
}
return true;
}
Source/Core/VideoCommon/GraphicsModSystem/Config/GraphicsModAsset.h
+18
View File
@@ -0,0 +1,18 @@
// Copyright 2023 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <string>
#include <picojson.h>
#include "VideoCommon/Assets/DirectFilesystemAssetLibrary.h"
struct GraphicsModAssetConfig
{
std::string m_name;
VideoCommon::DirectFilesystemAssetLibrary::AssetMap m_map;
bool DeserializeFromConfig(const picojson::object& obj);
};
Source/Core/VideoCommon/GraphicsModSystem/Runtime/Actions/CustomPipelineAction.cpp
+449
View File
@@ -0,0 +1,449 @@
// Copyright 2022 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include "VideoCommon/GraphicsModSystem/Runtime/Actions/CustomPipelineAction.h"
#include <algorithm>
#include <array>
#include <fmt/format.h>
#include "Common/FileUtil.h"
#include "Common/Logging/Log.h"
#include "Common/StringUtil.h"
#include "Core/System.h"
#include "VideoCommon/AbstractGfx.h"
#include "VideoCommon/Assets/CustomAssetLoader.h"
#include "VideoCommon/Assets/DirectFilesystemAssetLibrary.h"
#include "VideoCommon/ShaderGenCommon.h"
#include "VideoCommon/TextureCacheBase.h"
namespace
{
bool IsQualifier(std::string_view value)
{
static std::array<std::string_view, 7> qualifiers = {"attribute", "const", "highp", "lowp",
"mediump", "uniform", "varying"};
return std::find(qualifiers.begin(), qualifiers.end(), value) != qualifiers.end();
}
bool IsBuiltInMacro(std::string_view value)
{
static std::array<std::string_view, 5> built_in = {"__LINE__", "__FILE__", "__VERSION__",
"GL_core_profile", "GL_compatibility_profile"};
return std::find(built_in.begin(), built_in.end(), value) != built_in.end();
}
std::vector<std::string> GlobalConflicts(std::string_view source)
{
std::string_view last_identifier = "";
std::vector<std::string> global_result;
u32 scope = 0;
for (u32 i = 0; i < source.size(); i++)
{
// If we're out of global scope, we don't care
// about any of the details
if (scope > 0)
{
if (source[i] == '{')
{
scope++;
}
else if (source[i] == '}')
{
scope--;
}
continue;
}
const auto parse_identifier = [&]() {
const u32 start = i;
for (; i < source.size(); i++)
{
if (!Common::IsAlpha(source[i]) && source[i] != '_' && !std::isdigit(source[i]))
break;
}
u32 end = i;
i--; // unwind
return source.substr(start, end - start);
};
if (Common::IsAlpha(source[i]) || source[i] == '_')
{
const std::string_view identifier = parse_identifier();
if (IsQualifier(identifier))
continue;
if (IsBuiltInMacro(identifier))
continue;
last_identifier = identifier;
}
else if (source[i] == '#')
{
const auto parse_until_end_of_preprocessor = [&]() {
bool continue_until_next_newline = false;
for (; i < source.size(); i++)
{
if (source[i] == '\n')
{
if (continue_until_next_newline)
continue_until_next_newline = false;
else
break;
}
else if (source[i] == '\\')
{
continue_until_next_newline = true;
}
}
};
i++;
const std::string_view identifier = parse_identifier();
if (identifier == "define")
{
i++;
// skip whitespace
while (source[i] == ' ')
{
i++;
}
global_result.push_back(std::string{parse_identifier()});
parse_until_end_of_preprocessor();
}
else
{
parse_until_end_of_preprocessor();
}
}
else if (source[i] == '{')
{
scope++;
}
else if (source[i] == '(')
{
// Unlikely the user will be using layouts but...
if (last_identifier == "layout")
continue;
// Since we handle equality, we can assume the identifier
// before '(' is a function definition
global_result.push_back(std::string{last_identifier});
}
else if (source[i] == '=')
{
global_result.push_back(std::string{last_identifier});
i++;
for (; i < source.size(); i++)
{
if (source[i] == ';')
break;
}
}
else if (source[i] == '/')
{
if ((i + 1) >= source.size())
continue;
if (source[i + 1] == '/')
{
// Go to end of line...
for (; i < source.size(); i++)
{
if (source[i] == '\n')
break;
}
}
else if (source[i + 1] == '*')
{
// Multiline, look for first '*/'
for (; i < source.size(); i++)
{
if (source[i] == '/' && source[i - 1] == '*')
break;
}
}
}
}
// Sort the conflicts from largest to smallest string
// this way we can ensure smaller strings that are a substring
// of the larger string are able to be replaced appropriately
std::sort(global_result.begin(), global_result.end(),
[](const std::string& first, const std::string& second) {
return first.size() > second.size();
});
return global_result;
}
void WriteDefines(ShaderCode* out, const std::vector<std::string>& texture_code_names,
u32 texture_unit)
{
for (std::size_t i = 0; i < texture_code_names.size(); i++)
{
const auto& code_name = texture_code_names[i];
out->Write("#define {}_UNIT_{{0}} {}\n", code_name, texture_unit);
out->Write(
"#define {0}_COORD_{{0}} float3(data.texcoord[data.texmap_to_texcoord_index[{1}]].xy, "
"{2})\n",
code_name, texture_unit, i + 1);
}
}
} // namespace
std::unique_ptr<CustomPipelineAction>
CustomPipelineAction::Create(const picojson::value& json_data,
std::shared_ptr<VideoCommon::CustomAssetLibrary> library)
{
std::vector<CustomPipelineAction::PipelinePassPassDescription> pipeline_passes;
const auto& passes_json = json_data.get("passes");
if (passes_json.is<picojson::array>())
{
for (const auto& passes_json_val : passes_json.get<picojson::array>())
{
CustomPipelineAction::PipelinePassPassDescription pipeline_pass;
if (!passes_json_val.is<picojson::object>())
{
ERROR_LOG_FMT(VIDEO,
"Failed to load custom pipeline action, 'passes' has an array value that "
"is not an object!");
return nullptr;
}
auto pass = passes_json_val.get<picojson::object>();
if (!pass.contains("pixel_material_asset"))
{
ERROR_LOG_FMT(VIDEO,
"Failed to load custom pipeline action, 'passes' value missing required "
"field 'pixel_material_asset'");
return nullptr;
}
auto pixel_material_asset_json = pass["pixel_material_asset"];
if (!pixel_material_asset_json.is<std::string>())
{
ERROR_LOG_FMT(VIDEO, "Failed to load custom pipeline action, 'passes' field "
"'pixel_material_asset' is not a string!");
return nullptr;
}
pipeline_pass.m_pixel_material_asset = pixel_material_asset_json.to_str();
pipeline_passes.push_back(std::move(pipeline_pass));
}
}
if (pipeline_passes.empty())
{
ERROR_LOG_FMT(VIDEO, "Failed to load custom pipeline action, must specify at least one pass");
return nullptr;
}
if (pipeline_passes.size() > 1)
{
ERROR_LOG_FMT(
VIDEO,
"Failed to load custom pipeline action, multiple passes are not currently supported");
return nullptr;
}
return std::make_unique<CustomPipelineAction>(std::move(library), std::move(pipeline_passes));
}
CustomPipelineAction::CustomPipelineAction(
std::shared_ptr<VideoCommon::CustomAssetLibrary> library,
std::vector<PipelinePassPassDescription> pass_descriptions)
: m_library(std::move(library)), m_passes_config(std::move(pass_descriptions))
{
m_passes.resize(m_passes_config.size());
}
CustomPipelineAction::~CustomPipelineAction() = default;
void CustomPipelineAction::OnDrawStarted(GraphicsModActionData::DrawStarted* draw_started)
{
if (!draw_started) [[unlikely]]
return;
if (!draw_started->custom_pixel_shader) [[unlikely]]
return;
if (!m_valid)
return;
if (m_passes.empty()) [[unlikely]]
return;
// For now assume a single pass
auto& pass = m_passes[0];
if (!pass.m_pixel_shader.m_asset) [[unlikely]]
return;
const auto shader_data = pass.m_pixel_shader.m_asset->GetData();
if (shader_data)
{
if (pass.m_pixel_shader.m_asset->GetLastLoadedTime() > pass.m_pixel_shader.m_cached_write_time)
{
const auto material = pass.m_pixel_material.m_asset->GetData();
if (!material)
return;
pass.m_pixel_shader.m_cached_write_time = pass.m_pixel_shader.m_asset->GetLastLoadedTime();
for (const auto& prop : material->properties)
{
if (!shader_data->m_properties.contains(prop.m_code_name))
{
ERROR_LOG_FMT(VIDEO,
"Custom pipeline has material asset '{}' that has property '{}'"
"that is not on shader asset '{}'",
pass.m_pixel_material.m_asset->GetAssetId(), prop.m_code_name,
pass.m_pixel_shader.m_asset->GetAssetId());
return;
}
}
// Calculate shader details
std::string color_shader_data =
ReplaceAll(shader_data->m_shader_source, "custom_main", CUSTOM_PIXELSHADER_COLOR_FUNC);
const auto global_conflicts = GlobalConflicts(color_shader_data);
color_shader_data = ReplaceAll(color_shader_data, "\r\n", "\n");
color_shader_data = ReplaceAll(color_shader_data, "{", "{{");
color_shader_data = ReplaceAll(color_shader_data, "}", "}}");
// First replace global conflicts with dummy strings
// This avoids the problem where a shorter word
// is in a longer word, ex two functions: 'execute' and 'execute_fast'
for (std::size_t i = 0; i < global_conflicts.size(); i++)
{
const std::string& identifier = global_conflicts[i];
color_shader_data =
ReplaceAll(color_shader_data, identifier, fmt::format("_{0}_DOLPHIN_TEMP_{0}_", i));
}
// Now replace the temporaries with the actual value
for (std::size_t i = 0; i < global_conflicts.size(); i++)
{
const std::string& identifier = global_conflicts[i];
color_shader_data = ReplaceAll(color_shader_data, fmt::format("_{0}_DOLPHIN_TEMP_{0}_", i),
fmt::format("{}_{{0}}", identifier));
}
for (const auto& texture_code_name : m_texture_code_names)
{
color_shader_data =
ReplaceAll(color_shader_data, fmt::format("{}_COORD", texture_code_name),
fmt::format("{}_COORD_{{0}}", texture_code_name));
color_shader_data = ReplaceAll(color_shader_data, fmt::format("{}_UNIT", texture_code_name),
fmt::format("{}_UNIT_{{0}}", texture_code_name));
}
m_last_generated_shader_code = ShaderCode{};
WriteDefines(&m_last_generated_shader_code, m_texture_code_names, draw_started->texture_unit);
m_last_generated_shader_code.Write("{}", color_shader_data);
}
CustomPixelShader custom_pixel_shader;
custom_pixel_shader.custom_shader = m_last_generated_shader_code.GetBuffer();
*draw_started->custom_pixel_shader = custom_pixel_shader;
}
}
void CustomPipelineAction::OnTextureCreate(GraphicsModActionData::TextureCreate* create)
{
if (!create->custom_textures) [[unlikely]]
return;
if (!create->additional_dependencies) [[unlikely]]
return;
if (m_passes_config.empty()) [[unlikely]]
return;
if (m_passes.empty()) [[unlikely]]
return;
m_valid = true;
auto& loader = Core::System::GetInstance().GetCustomAssetLoader();
// For now assume a single pass
const auto& pass_config = m_passes_config[0];
auto& pass = m_passes[0];
if (!pass.m_pixel_material.m_asset)
{
pass.m_pixel_material.m_asset =
loader.LoadMaterial(pass_config.m_pixel_material_asset, m_library);
pass.m_pixel_material.m_cached_write_time = pass.m_pixel_material.m_asset->GetLastLoadedTime();
}
create->additional_dependencies->push_back(VideoCommon::CachedAsset<VideoCommon::CustomAsset>{
pass.m_pixel_material.m_asset, pass.m_pixel_material.m_asset->GetLastLoadedTime()});
const auto material_data = pass.m_pixel_material.m_asset->GetData();
if (!material_data)
return;
if (!pass.m_pixel_shader.m_asset || pass.m_pixel_material.m_asset->GetLastLoadedTime() >
pass.m_pixel_material.m_cached_write_time)
{
pass.m_pixel_shader.m_asset = loader.LoadPixelShader(material_data->shader_asset, m_library);
// Note: the asset timestamp will be updated in the draw command
}
create->additional_dependencies->push_back(VideoCommon::CachedAsset<VideoCommon::CustomAsset>{
pass.m_pixel_shader.m_asset, pass.m_pixel_shader.m_asset->GetLastLoadedTime()});
m_texture_code_names.clear();
std::vector<VideoCommon::CachedAsset<VideoCommon::GameTextureAsset>> game_assets;
for (const auto& property : material_data->properties)
{
if (property.m_type == VideoCommon::MaterialProperty::Type::Type_TextureAsset)
{
if (property.m_value)
{
if (auto* value = std::get_if<std::string>(&*property.m_value))
{
auto asset = loader.LoadGameTexture(*value, m_library);
if (asset)
{
const auto loaded_time = asset->GetLastLoadedTime();
game_assets.push_back(VideoCommon::CachedAsset<VideoCommon::GameTextureAsset>{
std::move(asset), loaded_time});
m_texture_code_names.push_back(property.m_code_name);
}
}
}
}
}
// Note: we swap here instead of doing a clear + append of the member
// variable so that any loaded assets from previous iterations
// won't be let go
std::swap(pass.m_game_textures, game_assets);
for (auto& game_texture : pass.m_game_textures)
{
if (game_texture.m_asset)
{
auto data = game_texture.m_asset->GetData();
if (data)
{
if (create->texture_width != data->m_levels[0].width ||
create->texture_height != data->m_levels[0].height)
{
ERROR_LOG_FMT(VIDEO,
"Custom pipeline for texture '{}' has asset '{}' that does not match "
"the width/height of the texture loaded. Texture {}x{} vs asset {}x{}",
create->texture_name, game_texture.m_asset->GetAssetId(),
create->texture_width, create->texture_height, data->m_levels[0].width,
data->m_levels[0].height);
m_valid = false;
}
}
else
{
m_valid = false;
}
}
}
// TODO: compare game textures and shader requirements
create->custom_textures->insert(create->custom_textures->end(), pass.m_game_textures.begin(),
pass.m_game_textures.end());
}
Source/Core/VideoCommon/GraphicsModSystem/Runtime/Actions/CustomPipelineAction.h
+54
View File
@@ -0,0 +1,54 @@
// Copyright 2022 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <memory>
#include <string>
#include <string_view>
#include <vector>
#include <picojson.h>
#include "VideoCommon/AbstractTexture.h"
#include "VideoCommon/Assets/CustomAssetLibrary.h"
#include "VideoCommon/Assets/MaterialAsset.h"
#include "VideoCommon/Assets/ShaderAsset.h"
#include "VideoCommon/Assets/TextureAsset.h"
#include "VideoCommon/GraphicsModSystem/Runtime/GraphicsModAction.h"
#include "VideoCommon/ShaderGenCommon.h"
class CustomPipelineAction final : public GraphicsModAction
{
public:
struct PipelinePassPassDescription
{
std::string m_pixel_material_asset;
};
static std::unique_ptr<CustomPipelineAction>
Create(const picojson::value& json_data,
std::shared_ptr<VideoCommon::CustomAssetLibrary> library);
CustomPipelineAction(std::shared_ptr<VideoCommon::CustomAssetLibrary> library,
std::vector<PipelinePassPassDescription> pass_descriptions);
~CustomPipelineAction();
void OnDrawStarted(GraphicsModActionData::DrawStarted*) override;
void OnTextureCreate(GraphicsModActionData::TextureCreate*) override;
private:
std::shared_ptr<VideoCommon::CustomAssetLibrary> m_library;
std::vector<PipelinePassPassDescription> m_passes_config;
struct PipelinePass
{
VideoCommon::CachedAsset<VideoCommon::MaterialAsset> m_pixel_material;
VideoCommon::CachedAsset<VideoCommon::PixelShaderAsset> m_pixel_shader;
std::vector<VideoCommon::CachedAsset<VideoCommon::GameTextureAsset>> m_game_textures;
};
std::vector<PipelinePass> m_passes;
ShaderCode m_last_generated_shader_code;
bool m_valid = true;
std::vector<std::string> m_texture_code_names;
};
Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.cpp
+376
View File
@@ -0,0 +1,376 @@
// Copyright 2022 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include "VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.h"
#include "VideoCommon/AbstractGfx.h"
#include "VideoCommon/VideoConfig.h"
CustomShaderCache::CustomShaderCache()
{
m_api_type = g_ActiveConfig.backend_info.api_type;
m_host_config.bits = ShaderHostConfig::GetCurrent().bits;
m_async_shader_compiler = g_gfx->CreateAsyncShaderCompiler();
m_async_shader_compiler->StartWorkerThreads(1); // TODO
m_async_uber_shader_compiler = g_gfx->CreateAsyncShaderCompiler();
m_async_uber_shader_compiler->StartWorkerThreads(1); // TODO
m_frame_end_handler =
AfterFrameEvent::Register([this] { RetrieveAsyncShaders(); }, "RetreiveAsyncShaders");
}
CustomShaderCache::~CustomShaderCache()
{
if (m_async_shader_compiler)
m_async_shader_compiler->StopWorkerThreads();
if (m_async_uber_shader_compiler)
m_async_uber_shader_compiler->StopWorkerThreads();
}
void CustomShaderCache::RetrieveAsyncShaders()
{
m_async_shader_compiler->RetrieveWorkItems();
m_async_uber_shader_compiler->RetrieveWorkItems();
}
void CustomShaderCache::Reload()
{
while (m_async_shader_compiler->HasPendingWork() || m_async_shader_compiler->HasCompletedWork())
{
m_async_shader_compiler->RetrieveWorkItems();
}
while (m_async_uber_shader_compiler->HasPendingWork() ||
m_async_uber_shader_compiler->HasCompletedWork())
{
m_async_uber_shader_compiler->RetrieveWorkItems();
}
m_ps_cache = {};
m_uber_ps_cache = {};
m_pipeline_cache = {};
m_uber_pipeline_cache = {};
}
std::optional<const AbstractPipeline*>
CustomShaderCache::GetPipelineAsync(const VideoCommon::GXPipelineUid& uid,
const CustomShaderInstance& custom_shaders,
const AbstractPipelineConfig& pipeline_config)
{
if (auto holder = m_pipeline_cache.GetHolder(uid, custom_shaders))
{
if (holder->pending)
return std::nullopt;
return holder->value.get();
}
AsyncCreatePipeline(uid, custom_shaders, pipeline_config);
return std::nullopt;
}
std::optional<const AbstractPipeline*>
CustomShaderCache::GetPipelineAsync(const VideoCommon::GXUberPipelineUid& uid,
const CustomShaderInstance& custom_shaders,
const AbstractPipelineConfig& pipeline_config)
{
if (auto holder = m_uber_pipeline_cache.GetHolder(uid, custom_shaders))
{
if (holder->pending)
return std::nullopt;
return holder->value.get();
}
AsyncCreatePipeline(uid, custom_shaders, pipeline_config);
return std::nullopt;
}
void CustomShaderCache::AsyncCreatePipeline(const VideoCommon::GXPipelineUid& uid,
const CustomShaderInstance& custom_shaders,
const AbstractPipelineConfig& pipeline_config)
{
class PipelineWorkItem final : public VideoCommon::AsyncShaderCompiler::WorkItem
{
public:
PipelineWorkItem(CustomShaderCache* shader_cache, const VideoCommon::GXPipelineUid& uid,
const CustomShaderInstance& custom_shaders, PipelineIterator iterator,
const AbstractPipelineConfig& pipeline_config)
: m_shader_cache(shader_cache), m_uid(uid), m_iterator(iterator),
m_custom_shaders(custom_shaders), m_config(pipeline_config)
{
SetStagesReady();
}
void SetStagesReady()
{
m_stages_ready = true;
PixelShaderUid ps_uid = m_uid.ps_uid;
ClearUnusedPixelShaderUidBits(m_shader_cache->m_api_type, m_shader_cache->m_host_config,
&ps_uid);
if (auto holder = m_shader_cache->m_ps_cache.GetHolder(ps_uid, m_custom_shaders))
{
// If the pixel shader is no longer pending compilation
// and the shader compilation succeeded, set
// the pipeline to use the new pixel shader.
// Otherwise, use the existing shader.
if (!holder->pending && holder->value.get())
{
m_config.pixel_shader = holder->value.get();
}
m_stages_ready &= !holder->pending;
}
else
{
m_stages_ready &= false;
m_shader_cache->QueuePixelShaderCompile(ps_uid, m_custom_shaders);
}
}
bool Compile() override
{
if (m_stages_ready)
{
m_pipeline = g_gfx->CreatePipeline(m_config);
}
return true;
}
void Retrieve() override
{
if (m_stages_ready)
{
m_shader_cache->NotifyPipelineFinished(m_iterator, std::move(m_pipeline));
}
else
{
// Re-queue for next frame.
auto wi = m_shader_cache->m_async_shader_compiler->CreateWorkItem<PipelineWorkItem>(
m_shader_cache, m_uid, m_custom_shaders, m_iterator, m_config);
m_shader_cache->m_async_shader_compiler->QueueWorkItem(std::move(wi), 0);
}
}
private:
CustomShaderCache* m_shader_cache;
std::unique_ptr<AbstractPipeline> m_pipeline;
VideoCommon::GXPipelineUid m_uid;
PipelineIterator m_iterator;
AbstractPipelineConfig m_config;
CustomShaderInstance m_custom_shaders;
bool m_stages_ready;
};
auto list_iter = m_pipeline_cache.InsertElement(uid, custom_shaders);
auto work_item = m_async_shader_compiler->CreateWorkItem<PipelineWorkItem>(
this, uid, custom_shaders, list_iter, pipeline_config);
m_async_shader_compiler->QueueWorkItem(std::move(work_item), 0);
}
void CustomShaderCache::AsyncCreatePipeline(const VideoCommon::GXUberPipelineUid& uid,
const CustomShaderInstance& custom_shaders,
const AbstractPipelineConfig& pipeline_config)
{
class PipelineWorkItem final : public VideoCommon::AsyncShaderCompiler::WorkItem
{
public:
PipelineWorkItem(CustomShaderCache* shader_cache, const VideoCommon::GXUberPipelineUid& uid,
const CustomShaderInstance& custom_shaders, UberPipelineIterator iterator,
const AbstractPipelineConfig& pipeline_config)
: m_shader_cache(shader_cache), m_uid(uid), m_iterator(iterator),
m_custom_shaders(custom_shaders), m_config(pipeline_config)
{
SetStagesReady();
}
void SetStagesReady()
{
m_stages_ready = true;
UberShader::PixelShaderUid ps_uid = m_uid.ps_uid;
ClearUnusedPixelShaderUidBits(m_shader_cache->m_api_type, m_shader_cache->m_host_config,
&ps_uid);
if (auto holder = m_shader_cache->m_uber_ps_cache.GetHolder(ps_uid, m_custom_shaders))
{
if (!holder->pending && holder->value.get())
{
m_config.pixel_shader = holder->value.get();
}
m_stages_ready &= !holder->pending;
}
else
{
m_stages_ready &= false;
m_shader_cache->QueuePixelShaderCompile(ps_uid, m_custom_shaders);
}
}
bool Compile() override
{
if (m_stages_ready)
{
if (m_config.pixel_shader == nullptr || m_config.vertex_shader == nullptr)
return false;
m_pipeline = g_gfx->CreatePipeline(m_config);
}
return true;
}
void Retrieve() override
{
if (m_stages_ready)
{
m_shader_cache->NotifyPipelineFinished(m_iterator, std::move(m_pipeline));
}
else
{
// Re-queue for next frame.
auto wi = m_shader_cache->m_async_uber_shader_compiler->CreateWorkItem<PipelineWorkItem>(
m_shader_cache, m_uid, m_custom_shaders, m_iterator, m_config);
m_shader_cache->m_async_uber_shader_compiler->QueueWorkItem(std::move(wi), 0);
}
}
private:
CustomShaderCache* m_shader_cache;
std::unique_ptr<AbstractPipeline> m_pipeline;
VideoCommon::GXUberPipelineUid m_uid;
UberPipelineIterator m_iterator;
AbstractPipelineConfig m_config;
CustomShaderInstance m_custom_shaders;
bool m_stages_ready;
};
auto list_iter = m_uber_pipeline_cache.InsertElement(uid, custom_shaders);
auto work_item = m_async_uber_shader_compiler->CreateWorkItem<PipelineWorkItem>(
this, uid, custom_shaders, list_iter, pipeline_config);
m_async_uber_shader_compiler->QueueWorkItem(std::move(work_item), 0);
}
void CustomShaderCache::NotifyPipelineFinished(PipelineIterator iterator,
std::unique_ptr<AbstractPipeline> pipeline)
{
iterator->second.pending = false;
iterator->second.value = std::move(pipeline);
}
void CustomShaderCache::NotifyPipelineFinished(UberPipelineIterator iterator,
std::unique_ptr<AbstractPipeline> pipeline)
{
iterator->second.pending = false;
iterator->second.value = std::move(pipeline);
}
void CustomShaderCache::QueuePixelShaderCompile(const PixelShaderUid& uid,
const CustomShaderInstance& custom_shaders)
{
class PixelShaderWorkItem final : public VideoCommon::AsyncShaderCompiler::WorkItem
{
public:
PixelShaderWorkItem(CustomShaderCache* shader_cache, const PixelShaderUid& uid,
const CustomShaderInstance& custom_shaders, PixelShaderIterator iter)
: m_shader_cache(shader_cache), m_uid(uid), m_custom_shaders(custom_shaders), m_iter(iter)
{
}
bool Compile() override
{
m_shader = m_shader_cache->CompilePixelShader(m_uid, m_custom_shaders);
return true;
}
void Retrieve() override
{
m_shader_cache->NotifyPixelShaderFinished(m_iter, std::move(m_shader));
}
private:
CustomShaderCache* m_shader_cache;
std::unique_ptr<AbstractShader> m_shader;
PixelShaderUid m_uid;
CustomShaderInstance m_custom_shaders;
PixelShaderIterator m_iter;
};
auto list_iter = m_ps_cache.InsertElement(uid, custom_shaders);
auto work_item = m_async_shader_compiler->CreateWorkItem<PixelShaderWorkItem>(
this, uid, custom_shaders, list_iter);
m_async_shader_compiler->QueueWorkItem(std::move(work_item), 0);
}
void CustomShaderCache::QueuePixelShaderCompile(const UberShader::PixelShaderUid& uid,
const CustomShaderInstance& custom_shaders)
{
class PixelShaderWorkItem final : public VideoCommon::AsyncShaderCompiler::WorkItem
{
public:
PixelShaderWorkItem(CustomShaderCache* shader_cache, const UberShader::PixelShaderUid& uid,
const CustomShaderInstance& custom_shaders, UberPixelShaderIterator iter)
: m_shader_cache(shader_cache), m_uid(uid), m_custom_shaders(custom_shaders), m_iter(iter)
{
}
bool Compile() override
{
m_shader = m_shader_cache->CompilePixelShader(m_uid, m_custom_shaders);
return true;
}
void Retrieve() override
{
m_shader_cache->NotifyPixelShaderFinished(m_iter, std::move(m_shader));
}
private:
CustomShaderCache* m_shader_cache;
std::unique_ptr<AbstractShader> m_shader;
UberShader::PixelShaderUid m_uid;
CustomShaderInstance m_custom_shaders;
UberPixelShaderIterator m_iter;
};
auto list_iter = m_uber_ps_cache.InsertElement(uid, custom_shaders);
auto work_item = m_async_uber_shader_compiler->CreateWorkItem<PixelShaderWorkItem>(
this, uid, custom_shaders, list_iter);
m_async_uber_shader_compiler->QueueWorkItem(std::move(work_item), 0);
}
std::unique_ptr<AbstractShader>
CustomShaderCache::CompilePixelShader(const PixelShaderUid& uid,
const CustomShaderInstance& custom_shaders) const
{
const ShaderCode source_code = GeneratePixelShaderCode(
m_api_type, m_host_config, uid.GetUidData(), custom_shaders.pixel_contents);
return g_gfx->CreateShaderFromSource(ShaderStage::Pixel, source_code.GetBuffer(),
"Custom Pixel Shader");
}
std::unique_ptr<AbstractShader>
CustomShaderCache::CompilePixelShader(const UberShader::PixelShaderUid& uid,
const CustomShaderInstance& custom_shaders) const
{
const ShaderCode source_code =
GenPixelShader(m_api_type, m_host_config, uid.GetUidData(), custom_shaders.pixel_contents);
return g_gfx->CreateShaderFromSource(ShaderStage::Pixel, source_code.GetBuffer(),
"Custom Uber Pixel Shader");
}
void CustomShaderCache::NotifyPixelShaderFinished(PixelShaderIterator iterator,
std::unique_ptr<AbstractShader> shader)
{
iterator->second.pending = false;
iterator->second.value = std::move(shader);
}
void CustomShaderCache::NotifyPixelShaderFinished(UberPixelShaderIterator iterator,
std::unique_ptr<AbstractShader> shader)
{
iterator->second.pending = false;
iterator->second.value = std::move(shader);
}
Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.h
+144
View File
@@ -0,0 +1,144 @@
// Copyright 2022 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <array>
#include <list>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include "VideoCommon/AbstractPipeline.h"
#include "VideoCommon/AbstractShader.h"
#include "VideoCommon/AsyncShaderCompiler.h"
#include "VideoCommon/GXPipelineTypes.h"
#include "VideoCommon/PixelShaderGen.h"
#include "VideoCommon/ShaderGenCommon.h"
#include "VideoCommon/UberShaderPixel.h"
#include "VideoCommon/VideoEvents.h"
struct CustomShaderInstance
{
CustomPixelShaderContents pixel_contents;
bool operator==(const CustomShaderInstance& other) const = default;
};
class CustomShaderCache
{
public:
CustomShaderCache();
~CustomShaderCache();
CustomShaderCache(const CustomShaderCache&) = delete;
CustomShaderCache(CustomShaderCache&&) = delete;
CustomShaderCache& operator=(const CustomShaderCache&) = delete;
CustomShaderCache& operator=(CustomShaderCache&&) = delete;
// Changes the shader host config. Shaders should be reloaded afterwards.
void SetHostConfig(const ShaderHostConfig& host_config) { m_host_config.bits = host_config.bits; }
// Retrieves all pending shaders/pipelines from the async compiler.
void RetrieveAsyncShaders();
// Reloads/recreates all shaders and pipelines.
void Reload();
// The optional will be empty if this pipeline is now background compiling.
std::optional<const AbstractPipeline*>
GetPipelineAsync(const VideoCommon::GXPipelineUid& uid,
const CustomShaderInstance& custom_shaders,
const AbstractPipelineConfig& pipeline_config);
std::optional<const AbstractPipeline*>
GetPipelineAsync(const VideoCommon::GXUberPipelineUid& uid,
const CustomShaderInstance& custom_shaders,
const AbstractPipelineConfig& pipeline_config);
private:
// Configuration bits.
APIType m_api_type = APIType::Nothing;
ShaderHostConfig m_host_config = {};
std::unique_ptr<VideoCommon::AsyncShaderCompiler> m_async_shader_compiler;
std::unique_ptr<VideoCommon::AsyncShaderCompiler> m_async_uber_shader_compiler;
void AsyncCreatePipeline(const VideoCommon::GXPipelineUid& uid,
const CustomShaderInstance& custom_shaders,
const AbstractPipelineConfig& pipeline_config);
void AsyncCreatePipeline(const VideoCommon::GXUberPipelineUid& uid,
const CustomShaderInstance& custom_shaders,
const AbstractPipelineConfig& pipeline_config);
// Shader/Pipeline cache helper
template <typename Uid, typename ValueType>
struct Cache
{
struct CacheHolder
{
std::unique_ptr<ValueType> value = nullptr;
bool pending = true;
};
using CacheElement = std::pair<CustomShaderInstance, CacheHolder>;
using CacheList = std::list<CacheElement>;
std::map<Uid, CacheList> uid_to_cachelist;
const CacheHolder* GetHolder(const Uid& uid, const CustomShaderInstance& custom_shaders) const
{
if (auto uuid_it = uid_to_cachelist.find(uid); uuid_it != uid_to_cachelist.end())
{
for (const auto& [custom_shader_val, holder] : uuid_it->second)
{
if (custom_shaders == custom_shader_val)
{
return &holder;
}
}
}
return nullptr;
}
typename CacheList::iterator InsertElement(const Uid& uid,
const CustomShaderInstance& custom_shaders)
{
CacheList& cachelist = uid_to_cachelist[uid];
CacheElement e{custom_shaders, CacheHolder{}};
return cachelist.emplace(cachelist.begin(), std::move(e));
}
};
Cache<PixelShaderUid, AbstractShader> m_ps_cache;
Cache<UberShader::PixelShaderUid, AbstractShader> m_uber_ps_cache;
Cache<VideoCommon::GXPipelineUid, AbstractPipeline> m_pipeline_cache;
Cache<VideoCommon::GXUberPipelineUid, AbstractPipeline> m_uber_pipeline_cache;
using PipelineIterator = Cache<VideoCommon::GXPipelineUid, AbstractPipeline>::CacheList::iterator;
using UberPipelineIterator =
Cache<VideoCommon::GXUberPipelineUid, AbstractPipeline>::CacheList::iterator;
using PixelShaderIterator = Cache<PixelShaderUid, AbstractShader>::CacheList::iterator;
using UberPixelShaderIterator =
Cache<UberShader::PixelShaderUid, AbstractShader>::CacheList::iterator;
void NotifyPipelineFinished(PipelineIterator iterator,
std::unique_ptr<AbstractPipeline> pipeline);
void NotifyPipelineFinished(UberPipelineIterator iterator,
std::unique_ptr<AbstractPipeline> pipeline);
std::unique_ptr<AbstractShader>
CompilePixelShader(const PixelShaderUid& uid, const CustomShaderInstance& custom_shaders) const;
void NotifyPixelShaderFinished(PixelShaderIterator iterator,
std::unique_ptr<AbstractShader> shader);
std::unique_ptr<AbstractShader>
CompilePixelShader(const UberShader::PixelShaderUid& uid,
const CustomShaderInstance& custom_shaders) const;
void NotifyPixelShaderFinished(UberPixelShaderIterator iterator,
std::unique_ptr<AbstractShader> shader);
void QueuePixelShaderCompile(const PixelShaderUid& uid,
const CustomShaderInstance& custom_shaders);
void QueuePixelShaderCompile(const UberShader::PixelShaderUid& uid,
const CustomShaderInstance& custom_shaders);
Common::EventHook m_frame_end_handler;
};
Source/Core/VideoCommon/GraphicsModSystem/Runtime/GraphicsModActionData.h
+5
View File
@@ -3,18 +3,23 @@
#pragma once
#include <array>
#include <optional>
#include <string_view>
#include <vector>
#include "Common/CommonTypes.h"
#include "Common/Matrix.h"
#include "VideoCommon/Assets/TextureAsset.h"
#include "VideoCommon/PixelShaderGen.h"
namespace GraphicsModActionData
{
struct DrawStarted
{
u32 texture_unit;
bool* skip;
std::optional<CustomPixelShader>* custom_pixel_shader;
};
struct EFB
Source/Core/VideoCommon/GraphicsModSystem/Runtime/GraphicsModActionFactory.cpp
+6 -1
View File
@@ -3,6 +3,7 @@
#include "VideoCommon/GraphicsModSystem/Runtime/GraphicsModActionFactory.h"
#include "VideoCommon/GraphicsModSystem/Runtime/Actions/CustomPipelineAction.h"
#include "VideoCommon/GraphicsModSystem/Runtime/Actions/MoveAction.h"
#include "VideoCommon/GraphicsModSystem/Runtime/Actions/PrintAction.h"
#include "VideoCommon/GraphicsModSystem/Runtime/Actions/ScaleAction.h"
@@ -11,7 +12,7 @@
namespace GraphicsModActionFactory
{
std::unique_ptr<GraphicsModAction> Create(std::string_view name, const picojson::value& json_data,
std::string_view path)
std::shared_ptr<VideoCommon::CustomAssetLibrary> library)
{
if (name == "print")
{
@@ -29,6 +30,10 @@ std::unique_ptr<GraphicsModAction> Create(std::string_view name, const picojson:
{
return ScaleAction::Create(json_data);
}
else if (name == "custom_pipeline")
{
return CustomPipelineAction::Create(json_data, std::move(library));
}
return nullptr;
}
Source/Core/VideoCommon/GraphicsModSystem/Runtime/GraphicsModActionFactory.h
+2 -1
View File
@@ -8,10 +8,11 @@
#include <picojson.h>
#include "VideoCommon/Assets/CustomAssetLibrary.h"
#include "VideoCommon/GraphicsModSystem/Runtime/GraphicsModAction.h"
namespace GraphicsModActionFactory
{
std::unique_ptr<GraphicsModAction> Create(std::string_view name, const picojson::value& json_data,
std::string_view path);
std::shared_ptr<VideoCommon::CustomAssetLibrary> library);
}
Source/Core/VideoCommon/GraphicsModSystem/Runtime/GraphicsModManager.cpp
+32 -6
View File
@@ -13,7 +13,9 @@
#include "Core/ConfigManager.h"
#include "VideoCommon/Assets/DirectFilesystemAssetLibrary.h"
#include "VideoCommon/GraphicsModSystem/Config/GraphicsMod.h"
#include "VideoCommon/GraphicsModSystem/Config/GraphicsModAsset.h"
#include "VideoCommon/GraphicsModSystem/Config/GraphicsModGroup.h"
#include "VideoCommon/GraphicsModSystem/Runtime/GraphicsModActionFactory.h"
#include "VideoCommon/TextureInfo.h"
@@ -187,6 +189,8 @@ void GraphicsModManager::Load(const GraphicsModGroupConfig& config)
const auto& mods = config.GetMods();
auto filesystem_library = std::make_shared<VideoCommon::DirectFilesystemAssetLibrary>();
std::map<std::string, std::vector<GraphicsTargetConfig>> group_to_targets;
for (const auto& mod : mods)
{
@@ -208,6 +212,29 @@ void GraphicsModManager::Load(const GraphicsModGroupConfig& config)
group_to_targets[internal_group].push_back(target);
}
}
std::string base_path;
SplitPath(mod.GetAbsolutePath(), &base_path, nullptr, nullptr);
for (const GraphicsModAssetConfig& asset : mod.m_assets)
{
auto asset_map = asset.m_map;
for (auto& [k, v] : asset_map)
{
if (v.is_absolute())
{
WARN_LOG_FMT(VIDEO,
"Specified graphics mod asset '{}' for mod '{}' has an absolute path, you "
"shouldn't release this to users.",
asset.m_name, mod.m_title);
}
else
{
v = std::filesystem::path{base_path} / v;
}
}
filesystem_library->SetAssetIDMapData(asset.m_name, std::move(asset_map));
}
}
for (const auto& mod : mods)
@@ -215,12 +242,11 @@ void GraphicsModManager::Load(const GraphicsModGroupConfig& config)
for (const GraphicsModFeatureConfig& feature : mod.m_features)
{
const auto create_action =
[](const std::string_view& action_name, const picojson::value& json_data,
GraphicsModConfig mod_config) -> std::unique_ptr<GraphicsModAction> {
std::string base_path;
SplitPath(mod_config.GetAbsolutePath(), &base_path, nullptr, nullptr);
auto action = GraphicsModActionFactory::Create(action_name, json_data, base_path);
[filesystem_library](const std::string_view& action_name,
const picojson::value& json_data,
GraphicsModConfig mod_config) -> std::unique_ptr<GraphicsModAction> {
auto action =
GraphicsModActionFactory::Create(action_name, json_data, std::move(filesystem_library));
if (action == nullptr)
{
return nullptr;
Source/Core/VideoCommon/LightingShaderGen.cpp
+177
View File
@@ -175,3 +175,180 @@ void GetLightingShaderUid(LightingUidData& uid_data)
}
}
}
void GenerateCustomLightingHeaderDetails(ShaderCode* out, u32 enablelighting, u32 light_mask)
{
u32 light_count = 0;
for (u32 j = 0; j < NUM_XF_COLOR_CHANNELS; j++)
{
if ((enablelighting & (1 << j)) != 0) // Color lights
{
for (int i = 0; i < 8; ++i)
{
if ((light_mask & (1 << (i + 8 * j))) != 0)
{
light_count++;
}
}
}
if ((enablelighting & (1 << (j + 2))) != 0) // Alpha lights
{
for (int i = 0; i < 8; ++i)
{
if ((light_mask & (1 << (i + 8 * (j + 2)))) != 0)
{
light_count++;
}
}
}
}
if (light_count > 0)
{
out->Write("\tCustomShaderLightData[{}] light;\n", light_count);
}
else
{
// Cheat so shaders compile
out->Write("\tCustomShaderLightData[1] light;\n", light_count);
}
out->Write("\tint light_count;\n");
}
void GenerateCustomLightingImplementation(ShaderCode* out, const LightingUidData& uid_data,
std::string_view in_color_name)
{
auto generate_lighting = [](ShaderCode* out, const LightingUidData& uid_data, int index,
int litchan_index, u32 channel_index, u32 custom_light_index,
bool alpha) {
const auto attnfunc =
static_cast<AttenuationFunc>((uid_data.attnfunc >> (2 * litchan_index)) & 0x3);
const std::string_view light_type = alpha ? "alpha" : "color";
const std::string name = fmt::format("lights_chan{}_{}", channel_index, light_type);
out->Write("\t{{\n");
out->Write("\t\tcustom_data.{}[{}].direction = " LIGHT_DIR ".xyz;\n", name, custom_light_index,
LIGHT_DIR_PARAMS(index));
out->Write("\t\tcustom_data.{}[{}].position = " LIGHT_POS ".xyz;\n", name, custom_light_index,
LIGHT_POS_PARAMS(index));
out->Write("\t\tcustom_data.{}[{}].cosatt = " LIGHT_COSATT ";\n", name, custom_light_index,
LIGHT_COSATT_PARAMS(index));
out->Write("\t\tcustom_data.{}[{}].distatt = " LIGHT_DISTATT ";\n", name, custom_light_index,
LIGHT_DISTATT_PARAMS(index));
out->Write("\t\tcustom_data.{}[{}].attenuation_type = {};\n", name, custom_light_index,
static_cast<u32>(attnfunc));
if (alpha)
{
out->Write("\t\tcustom_data.{}[{}].color = float3(" LIGHT_COL
") / float3(255.0, 255.0, 255.0);\n",
name, custom_light_index, LIGHT_COL_PARAMS(index, alpha ? "a" : "rgb"));
}
else
{
out->Write("\t\tcustom_data.{}[{}].color = " LIGHT_COL " / float3(255.0, 255.0, 255.0);\n",
name, custom_light_index, LIGHT_COL_PARAMS(index, alpha ? "a" : "rgb"));
}
out->Write("\t}}\n");
};
for (u32 i = 0; i < 8; i++)
{
for (u32 channel_index = 0; channel_index < NUM_XF_COLOR_CHANNELS; channel_index++)
{
out->Write("\tcustom_data.lights_chan{}_color[{}].direction = float3(0, 0, 0);\n",
channel_index, i);
out->Write("\tcustom_data.lights_chan{}_color[{}].position = float3(0, 0, 0);\n",
channel_index, i);
out->Write("\tcustom_data.lights_chan{}_color[{}].color = float3(0, 0, 0);\n", channel_index,
i);
out->Write("\tcustom_data.lights_chan{}_color[{}].cosatt = float4(0, 0, 0, 0);\n",
channel_index, i);
out->Write("\tcustom_data.lights_chan{}_color[{}].distatt = float4(0, 0, 0, 0);\n",
channel_index, i);
out->Write("\tcustom_data.lights_chan{}_color[{}].attenuation_type = 0;\n", channel_index, i);
out->Write("\tcustom_data.lights_chan{}_alpha[{}].direction = float3(0, 0, 0);\n",
channel_index, i);
out->Write("\tcustom_data.lights_chan{}_alpha[{}].position = float3(0, 0, 0);\n",
channel_index, i);
out->Write("\tcustom_data.lights_chan{}_alpha[{}].color = float3(0, 0, 0);\n", channel_index,
i);
out->Write("\tcustom_data.lights_chan{}_alpha[{}].cosatt = float4(0, 0, 0, 0);\n",
channel_index, i);
out->Write("\tcustom_data.lights_chan{}_alpha[{}].distatt = float4(0, 0, 0, 0);\n",
channel_index, i);
out->Write("\tcustom_data.lights_chan{}_alpha[{}].attenuation_type = 0;\n", channel_index, i);
}
}
for (u32 j = 0; j < NUM_XF_COLOR_CHANNELS; j++)
{
const bool colormatsource = !!(uid_data.matsource & (1 << j));
if (colormatsource) // from vertex
out->Write("custom_data.base_material[{}] = {}{};\n", j, in_color_name, j);
else // from color
out->Write("custom_data.base_material[{}] = {}[{}] / 255.0;\n", j, I_MATERIALS, j + 2);
if ((uid_data.enablelighting & (1 << j)) != 0)
{
if ((uid_data.ambsource & (1 << j)) != 0) // from vertex
out->Write("custom_data.ambient_lighting[{}] = {}{};\n", j, in_color_name, j);
else // from color
out->Write("custom_data.ambient_lighting[{}] = {}[{}] / 255.0;\n", j, I_MATERIALS, j);
}
else
{
out->Write("custom_data.ambient_lighting[{}] = float4(1, 1, 1, 1);\n", j);
}
// check if alpha is different
const bool alphamatsource = !!(uid_data.matsource & (1 << (j + 2)));
if (alphamatsource != colormatsource)
{
if (alphamatsource) // from vertex
out->Write("custom_data.base_material[{}].w = {}{}.w;\n", j, in_color_name, j);
else // from color
out->Write("custom_data.base_material[{}].w = {}[{}].w / 255.0;\n", j, I_MATERIALS, j + 2);
}
if ((uid_data.enablelighting & (1 << (j + 2))) != 0)
{
if ((uid_data.ambsource & (1 << (j + 2))) != 0) // from vertex
out->Write("custom_data.ambient_lighting[{}].w = {}{}.w;\n", j, in_color_name, j);
else // from color
out->Write("custom_data.ambient_lighting[{}].w = {}[{}].w / 255.0;\n", j, I_MATERIALS, j);
}
else
{
out->Write("custom_data.ambient_lighting[{}].w = 1;\n", j);
}
u32 light_count = 0;
if ((uid_data.enablelighting & (1 << j)) != 0) // Color lights
{
for (int i = 0; i < 8; ++i)
{
if ((uid_data.light_mask & (1 << (i + 8 * j))) != 0)
{
generate_lighting(out, uid_data, i, j, j, light_count, false);
light_count++;
}
}
}
out->Write("\tcustom_data.light_chan{}_color_count = {};\n", j, light_count);
light_count = 0;
if ((uid_data.enablelighting & (1 << (j + 2))) != 0) // Alpha lights
{
for (int i = 0; i < 8; ++i)
{
if ((uid_data.light_mask & (1 << (i + 8 * (j + 2)))) != 0)
{
generate_lighting(out, uid_data, i, j + 2, j, light_count, true);
light_count++;
}
}
}
out->Write("\tcustom_data.light_chan{}_alpha_count = {};\n", j, light_count);
}
}
Source/Core/VideoCommon/LightingShaderGen.h
+4
View File
@@ -47,3 +47,7 @@ constexpr char s_lighting_struct[] = "struct Light {\n"
void GenerateLightingShaderCode(ShaderCode& object, const LightingUidData& uid_data,
std::string_view in_color_name, std::string_view dest);
void GetLightingShaderUid(LightingUidData& uid_data);
void GenerateCustomLightingHeaderDetails(ShaderCode* out, u32 enablelighting, u32 light_mask);
void GenerateCustomLightingImplementation(ShaderCode* out, const LightingUidData& uid_data,
std::string_view in_color_name);
Source/Core/VideoCommon/PixelShaderGen.cpp
+232 -5
View File
@@ -3,6 +3,7 @@
#include "VideoCommon/PixelShaderGen.h"
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <fmt/format.h>
@@ -130,6 +131,17 @@ constexpr Common::EnumMap<const char*, TevColorArg::Zero> tev_c_input_table{
"int3(0,0,0)", // ZERO
};
constexpr Common::EnumMap<const char*, TevColorArg::Zero> tev_c_input_type{
"CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_PREV", "CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_PREV",
"CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR", "CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR",
"CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR", "CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR",
"CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR", "CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR",
"CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_TEX", "CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_TEX",
"CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_RAS", "CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_RAS",
"CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_NUMERIC", "CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_NUMERIC",
"CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_KONST", "CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_NUMERIC",
};
constexpr Common::EnumMap<const char*, TevAlphaArg::Zero> tev_a_input_table{
"prev.a", // APREV,
"c0.a", // A0,
@@ -141,6 +153,13 @@ constexpr Common::EnumMap<const char*, TevAlphaArg::Zero> tev_a_input_table{
"0", // ZERO
};
constexpr Common::EnumMap<const char*, TevAlphaArg::Zero> tev_a_input_type{
"CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_PREV", "CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR",
"CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR", "CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR",
"CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_TEX", "CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_RAS",
"CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_KONST", "CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_NUMERIC",
};
constexpr Common::EnumMap<const char*, RasColorChan::Zero> tev_ras_table{
"iround(col0 * 255.0)",
"iround(col1 * 255.0)",
@@ -387,6 +406,7 @@ void WritePixelShaderCommonHeader(ShaderCode& out, APIType api_type,
"\tbool blend_subtract_alpha;\n"
"\tbool logic_op_enable;\n"
"\tuint logic_op_mode;\n"
"\tuint time_ms;\n"
"}};\n\n");
out.Write("#define bpmem_combiners(i) (bpmem_pack1[(i)].xy)\n"
"#define bpmem_tevind(i) (bpmem_pack1[(i)].z)\n"
@@ -732,8 +752,131 @@ uint WrapCoord(int coord, uint wrap, int size) {{
}
}
void WriteCustomShaderStructImpl(ShaderCode* out, u32 num_stages, bool per_pixel_lighting,
const pixel_shader_uid_data* uid_data)
{
out->Write("\tCustomShaderData custom_data;\n");
if (per_pixel_lighting)
{
out->Write("\tcustom_data.position = WorldPos;\n");
out->Write("\tcustom_data.normal = Normal;\n");
}
else
{
out->Write("\tcustom_data.position = float3(0, 0, 0);\n");
out->Write("\tcustom_data.normal = float3(0, 0, 0);\n");
}
if (uid_data->genMode_numtexgens == 0) [[unlikely]]
{
out->Write("\tcustom_data.texcoord[0] = float3(0, 0, 0);\n");
}
else
{
for (u32 i = 0; i < uid_data->genMode_numtexgens; ++i)
{
out->Write("\tif (tex{0}.z == 0.0)\n", i);
out->Write("\t{{\n");
out->Write("\t\tcustom_data.texcoord[{0}] = tex{0};\n", i);
out->Write("\t}}\n");
out->Write("\telse {{\n");
out->Write("\t\tcustom_data.texcoord[{0}] = float3(tex{0}.xy / tex{0}.z, 0);\n", i);
out->Write("\t}}\n");
}
}
for (u32 i = 0; i < 8; i++)
{
// Shader compilation complains if every index isn't initialized
out->Write("\tcustom_data.texmap_to_texcoord_index[{0}] = 0;\n", i);
}
for (u32 i = 0; i < uid_data->genMode_numindstages; ++i)
{
if ((uid_data->nIndirectStagesUsed & (1U << i)) != 0)
{
u32 texcoord = uid_data->GetTevindirefCoord(i);
const u32 texmap = uid_data->GetTevindirefMap(i);
// Quirk: when the tex coord is not less than the number of tex gens (i.e. the tex coord does
// not exist), then tex coord 0 is used (though sometimes glitchy effects happen on console).
// This affects the Mario portrait in Luigi's Mansion, where the developers forgot to set
// the number of tex gens to 2 (bug 11462).
if (texcoord >= uid_data->genMode_numtexgens)
texcoord = 0;
out->Write("\tcustom_data.texmap_to_texcoord_index[{}] = {};\n", texmap, texcoord);
}
}
out->Write("\tcustom_data.texcoord_count = {};\n", uid_data->genMode_numtexgens);
// Try and do a best guess on what the texcoord index is
// Note: one issue with this would be textures that are used
// multiple times in the same draw but with different texture coordinates.
// In that scenario, only the last texture coordinate would be defined.
// This issue can be seen in how Rogue Squadron 2 does bump mapping
for (u32 i = 0; i < num_stages; i++)
{
auto& tevstage = uid_data->stagehash[i];
// Quirk: when the tex coord is not less than the number of tex gens (i.e. the tex coord does
// not exist), then tex coord 0 is used (though sometimes glitchy effects happen on console).
u32 texcoord = tevstage.tevorders_texcoord;
const bool has_tex_coord = texcoord < uid_data->genMode_numtexgens;
if (!has_tex_coord)
texcoord = 0;
out->Write("\tcustom_data.texmap_to_texcoord_index[{}] = {};\n", tevstage.tevorders_texmap,
texcoord);
}
GenerateCustomLightingImplementation(out, uid_data->lighting, "colors_");
for (u32 i = 0; i < 16; i++)
{
// Shader compilation complains if every struct isn't initialized
// Color Input
for (u32 j = 0; j < 4; j++)
{
out->Write("\tcustom_data.tev_stages[{}].input_color[{}].input_type = "
"CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_UNUSED;\n",
i, j);
out->Write("\tcustom_data.tev_stages[{}].input_color[{}].value = "
"float3(0, 0, 0);\n",
i, j);
}
// Alpha Input
for (u32 j = 0; j < 4; j++)
{
out->Write("\tcustom_data.tev_stages[{}].input_alpha[{}].input_type = "
"CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_UNUSED;\n",
i, j);
out->Write("\tcustom_data.tev_stages[{}].input_alpha[{}].value = "
"float(0);\n",
i, j);
}
// Texmap
out->Write("\tcustom_data.tev_stages[{}].texmap = 0u;\n", i);
// Output
out->Write("\tcustom_data.tev_stages[{}].output_color = "
"float4(0, 0, 0, 0);\n",
i);
}
// Actual data will be filled out in the tev stage code, just set the
// stage count for now
out->Write("\tcustom_data.tev_stage_count = {};\n", num_stages);
// Time
out->Write("\tcustom_data.time_ms = time_ms;\n");
}
static void WriteStage(ShaderCode& out, const pixel_shader_uid_data* uid_data, int n,
APIType api_type, bool stereo);
APIType api_type, bool stereo, bool has_custom_shaders);
static void WriteTevRegular(ShaderCode& out, std::string_view components, TevBias bias, TevOp op,
bool clamp, TevScale scale);
static void WriteAlphaTest(ShaderCode& out, const pixel_shader_uid_data* uid_data, APIType api_type,
@@ -746,7 +889,8 @@ static void WriteColor(ShaderCode& out, APIType api_type, const pixel_shader_uid
static void WriteBlend(ShaderCode& out, const pixel_shader_uid_data* uid_data);
ShaderCode GeneratePixelShaderCode(APIType api_type, const ShaderHostConfig& host_config,
const pixel_shader_uid_data* uid_data)
const pixel_shader_uid_data* uid_data,
const CustomPixelShaderContents& custom_details)
{
ShaderCode out;
@@ -762,8 +906,17 @@ ShaderCode GeneratePixelShaderCode(APIType api_type, const ShaderHostConfig& hos
// Stuff that is shared between ubershaders and pixelgen.
WriteBitfieldExtractHeader(out, api_type, host_config);
WritePixelShaderCommonHeader(out, api_type, host_config, uid_data->bounding_box);
// Custom shader details
WriteCustomShaderStructDef(&out, uid_data->genMode_numtexgens);
for (std::size_t i = 0; i < custom_details.shaders.size(); i++)
{
const auto& shader_details = custom_details.shaders[i];
out.Write(fmt::runtime(shader_details.custom_shader), i);
}
out.Write("\n#define sampleTextureWrapper(texmap, uv, layer) "
"sampleTexture(texmap, samp[texmap], uv, layer)\n");
@@ -892,6 +1045,14 @@ ShaderCode GeneratePixelShaderCode(APIType api_type, const ShaderHostConfig& hos
out.Write("void main()\n{{\n");
out.Write("\tfloat4 rawpos = gl_FragCoord;\n");
bool has_custom_shaders = false;
if (std::any_of(custom_details.shaders.begin(), custom_details.shaders.end(),
[](const std::optional<CustomPixelShader>& ps) { return ps.has_value(); }))
{
WriteCustomShaderStructImpl(&out, numStages, per_pixel_lighting, uid_data);
has_custom_shaders = true;
}
if (use_framebuffer_fetch)
{
// Store off a copy of the initial framebuffer value.
@@ -1013,7 +1174,7 @@ ShaderCode GeneratePixelShaderCode(APIType api_type, const ShaderHostConfig& hos
for (u32 i = 0; i < numStages; i++)
{
// Build the equation for this stage
WriteStage(out, uid_data, i, api_type, stereo);
WriteStage(out, uid_data, i, api_type, stereo, has_custom_shaders);
}
{
@@ -1146,7 +1307,21 @@ ShaderCode GeneratePixelShaderCode(APIType api_type, const ShaderHostConfig& hos
// Write the color and alpha values to the framebuffer
// If using shader blend, we still use the separate alpha
WriteColor(out, api_type, uid_data, !uid_data->no_dual_src || uid_data->blend_enable);
const bool use_dual_source = !uid_data->no_dual_src || uid_data->blend_enable;
WriteColor(out, api_type, uid_data, use_dual_source);
for (std::size_t i = 0; i < custom_details.shaders.size(); i++)
{
const auto& shader_details = custom_details.shaders[i];
if (!shader_details.custom_shader.empty())
{
out.Write("\t{{\n");
out.Write("\t\tcustom_data.final_color = ocol0;\n");
out.Write("\t\tocol0.xyz = {}_{}(custom_data).xyz;\n", CUSTOM_PIXELSHADER_COLOR_FUNC, i);
out.Write("\t}}\n\n");
}
}
if (uid_data->blend_enable)
WriteBlend(out, uid_data);
@@ -1162,7 +1337,7 @@ ShaderCode GeneratePixelShaderCode(APIType api_type, const ShaderHostConfig& hos
}
static void WriteStage(ShaderCode& out, const pixel_shader_uid_data* uid_data, int n,
APIType api_type, bool stereo)
APIType api_type, bool stereo, bool has_custom_shaders)
{
using Common::EnumMap;
@@ -1556,6 +1731,58 @@ static void WriteStage(ShaderCode& out, const pixel_shader_uid_data* uid_data, i
out.Write(", -1024, 1023)");
out.Write(";\n");
if (has_custom_shaders)
{
// Color input
out.Write(
"\tcustom_data.tev_stages[{}].input_color[0].value = {} / float3(255.0, 255.0, 255.0);\n",
n, tev_c_input_table[cc.a]);
out.Write("\tcustom_data.tev_stages[{}].input_color[0].input_type = {};\n", n,
tev_c_input_type[cc.a]);
out.Write(
"\tcustom_data.tev_stages[{}].input_color[1].value = {} / float3(255.0, 255.0, 255.0);\n",
n, tev_c_input_table[cc.b]);
out.Write("\tcustom_data.tev_stages[{}].input_color[1].input_type = {};\n", n,
tev_c_input_type[cc.b]);
out.Write(
"\tcustom_data.tev_stages[{}].input_color[2].value = {} / float3(255.0, 255.0, 255.0);\n",
n, tev_c_input_table[cc.c]);
out.Write("\tcustom_data.tev_stages[{}].input_color[2].input_type = {};\n", n,
tev_c_input_type[cc.c]);
out.Write(
"\tcustom_data.tev_stages[{}].input_color[3].value = {} / float3(255.0, 255.0, 255.0);\n",
n, tev_c_input_table[cc.d]);
out.Write("\tcustom_data.tev_stages[{}].input_color[3].input_type = {};\n", n,
tev_c_input_type[cc.d]);
// Alpha input
out.Write("\tcustom_data.tev_stages[{}].input_alpha[0].value = {} / float(255.0);\n", n,
tev_a_input_table[ac.a]);
out.Write("\tcustom_data.tev_stages[{}].input_alpha[0].input_type = {};\n", n,
tev_a_input_type[ac.a]);
out.Write("\tcustom_data.tev_stages[{}].input_alpha[1].value = {} / float(255.0);\n", n,
tev_a_input_table[ac.b]);
out.Write("\tcustom_data.tev_stages[{}].input_alpha[1].input_type = {};\n", n,
tev_a_input_type[ac.b]);
out.Write("\tcustom_data.tev_stages[{}].input_alpha[2].value = {} / float(255.0);\n", n,
tev_a_input_table[ac.c]);
out.Write("\tcustom_data.tev_stages[{}].input_alpha[2].input_type = {};\n", n,
tev_a_input_type[ac.c]);
out.Write("\tcustom_data.tev_stages[{}].input_alpha[3].value = {} / float(255.0);\n", n,
tev_a_input_table[ac.d]);
out.Write("\tcustom_data.tev_stages[{}].input_alpha[3].input_type = {};\n", n,
tev_a_input_type[ac.d]);
// Texmap
out.Write("\tcustom_data.tev_stages[{}].texmap = {}u;\n", n, stage.tevorders_texmap);
// Output
out.Write("\tcustom_data.tev_stages[{}].output_color.rgb = {} / float3(255.0, 255.0, 255.0);\n",
n, tev_c_output_table[cc.dest]);
out.Write("\tcustom_data.tev_stages[{}].output_color.a = {} / float(255.0);\n", n,
tev_a_output_table[ac.dest]);
}
}
static void WriteTevRegular(ShaderCode& out, std::string_view components, TevBias bias, TevOp op,
Source/Core/VideoCommon/PixelShaderGen.h
+5 -1
View File
@@ -158,8 +158,12 @@ struct pixel_shader_uid_data
using PixelShaderUid = ShaderUid<pixel_shader_uid_data>;
void WriteCustomShaderStructImpl(ShaderCode* out, u32 num_stages, bool per_pixel_lighting,
const pixel_shader_uid_data* uid_data);
ShaderCode GeneratePixelShaderCode(APIType api_type, const ShaderHostConfig& host_config,
const pixel_shader_uid_data* uid_data);
const pixel_shader_uid_data* uid_data,
const CustomPixelShaderContents& custom_details);
void WritePixelShaderCommonHeader(ShaderCode& out, APIType api_type,
const ShaderHostConfig& host_config, bool bounding_box);
void ClearUnusedPixelShaderUidBits(APIType api_type, const ShaderHostConfig& host_config,
Source/Core/VideoCommon/ShaderCache.cpp
+2 -2
View File
@@ -449,7 +449,7 @@ ShaderCache::CompileVertexUberShader(const UberShader::VertexShaderUid& uid) con
std::unique_ptr<AbstractShader> ShaderCache::CompilePixelShader(const PixelShaderUid& uid) const
{
const ShaderCode source_code =
GeneratePixelShaderCode(m_api_type, m_host_config, uid.GetUidData());
GeneratePixelShaderCode(m_api_type, m_host_config, uid.GetUidData(), {});
return g_gfx->CreateShaderFromSource(ShaderStage::Pixel, source_code.GetBuffer());
}
@@ -457,7 +457,7 @@ std::unique_ptr<AbstractShader>
ShaderCache::CompilePixelUberShader(const UberShader::PixelShaderUid& uid) const
{
const ShaderCode source_code =
UberShader::GenPixelShader(m_api_type, m_host_config, uid.GetUidData());
UberShader::GenPixelShader(m_api_type, m_host_config, uid.GetUidData(), {});
return g_gfx->CreateShaderFromSource(ShaderStage::Pixel, source_code.GetBuffer(),
fmt::to_string(*uid.GetUidData()));
}

Some files were not shown because too many files have changed in this diff Show More