preserve-emulation/ppsspp
1
0
Fork 0
mirror of https://github.com/hrydgard/ppsspp.git synced 2026-07-11 01:25:07 +02:00
Code Issues Packages Projects Releases Wiki Activity

Make Description a member function of VShaderID / FShaderID. Assorted cleanup

Browse Source
This commit is contained in:
Henrik Rydgård
2026-07-09 17:46:07 +02:00
parent e8bcceef62
commit 9e687c3282
9 changed files with 127 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Common/GPU/ShaderWriter.h
+4 -3
View File
@@ -57,10 +57,11 @@ public:
return *this;
}
// W: Writes a zero-terminated string to the stream.
ShaderWriter &W(const char *text) {
size_t len = strlen(text);
memcpy(p_, text, len + 1);
ShaderWriter &W(std::string_view text) {
size_t len = text.size();
memcpy(p_, text.data(), len);
p_ += len;
*p_ = '\0';
return *this;
}
GPU/Common/FragmentShaderGenerator.cpp
+1 -1
View File
@@ -101,7 +101,7 @@ bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLangu
}
ShaderWriter p(buffer, compat, ShaderStage::Fragment, extensions, flags);
p.F("// %s\n", FragmentShaderDesc(id).c_str());
p.C("// %").W(id.Description()).endl();
p.ApplySamplerMetadata(arrayTexture ? samplersStereo : samplersMono);
GPU/Common/ShaderId.cpp
+64 -64
View File
@@ -19,56 +19,56 @@ std::string ShaderID::ToDebugString() const {
return StringFromFormat("%08x:%08x", d >> 32, d & 0xFFFFFFFF);
}
std::string VertexShaderDesc(const VShaderID &id) {
std::string VShaderID::Description() const {
char buffer[512];
StringWriter desc(buffer, sizeof(buffer));
desc.W(id.ToDebugString()).C(" ");
if (id.Bit(VS_BIT_IS_THROUGH)) desc.C("THR ");
if (id.Bit(VS_BIT_USE_HW_TRANSFORM)) desc.C("HWX "); else desc.C("SWX ");
if (id.Bit(VS_BIT_HAS_NORMAL)) desc.C("N ");
if (id.Bit(VS_BIT_HAS_TEXCOORD)) desc.C("T ");
if (id.Bit(VS_BIT_HAS_COLOR)) desc.C("C ");
if (id.Bit(VS_BIT_LMODE)) desc.C("LM ");
if (id.Bit(VS_BIT_NORM_REVERSE)) desc.C("RevN ");
if (id.Bit(VS_BIT_FLATSHADE)) desc.C("Flat ");
if (id.Bits(VS_BIT_MATERIAL_UPDATE, 3)) desc.C("MatUp:").F("%d", id.Bits(VS_BIT_MATERIAL_UPDATE, 3)).C(" ");
desc.W(ToDebugString()).C(" ");
if (Bit(VS_BIT_IS_THROUGH)) desc.C("THR ");
if (Bit(VS_BIT_USE_HW_TRANSFORM)) desc.C("HWX "); else desc.C("SWX ");
if (Bit(VS_BIT_HAS_NORMAL)) desc.C("N ");
if (Bit(VS_BIT_HAS_TEXCOORD)) desc.C("T ");
if (Bit(VS_BIT_HAS_COLOR)) desc.C("C ");
if (Bit(VS_BIT_LMODE)) desc.C("LM ");
if (Bit(VS_BIT_NORM_REVERSE)) desc.C("RevN ");
if (Bit(VS_BIT_FLATSHADE)) desc.C("Flat ");
if (Bits(VS_BIT_MATERIAL_UPDATE, 3)) desc.C("MatUp:").F("%d", Bits(VS_BIT_MATERIAL_UPDATE, 3)).C(" ");
int uvgMode = id.Bits(VS_BIT_UVGEN_MODE, 2);
int uvgMode = Bits(VS_BIT_UVGEN_MODE, 2);
static constexpr std::string_view uvgModes[4] = {"UV ", "UVMtx ", "UVEnv ", "UVUnk "};
if (uvgMode) desc.W(uvgModes[uvgMode]);
if (uvgMode == GE_TEXMAP_TEXTURE_MATRIX) {
int uvprojMode = id.Bits(VS_BIT_UVPROJ_MODE, 2);
int uvprojMode = Bits(VS_BIT_UVPROJ_MODE, 2);
static constexpr std::string_view uvprojModes[4] = { "TexProjPos ", "TexProjUV ", "TexProjNNrm ", "TexProjNrm " };
desc.W(uvprojModes[uvprojMode]);
}
if (id.Bit(VS_BIT_ENABLE_BONES)) desc.F("Bones:%d ", id.Bits(VS_BIT_BONES, 3) + 1);
if (id.Bits(VS_BIT_WEIGHT_FMTSCALE, 2)) desc.F("WScale:%d ", id.Bits(VS_BIT_WEIGHT_FMTSCALE, 2));
if (Bit(VS_BIT_ENABLE_BONES)) desc.F("Bones:%d ", Bits(VS_BIT_BONES, 3) + 1);
if (Bits(VS_BIT_WEIGHT_FMTSCALE, 2)) desc.F("WScale:%d ", Bits(VS_BIT_WEIGHT_FMTSCALE, 2));
int ls0 = id.Bits(VS_BIT_LS0, 2);
int ls1 = id.Bits(VS_BIT_LS1, 2);
int ls0 = Bits(VS_BIT_LS0, 2);
int ls1 = Bits(VS_BIT_LS1, 2);
if (id.Bit(VS_BIT_FS_MINMAX_DISCARD)) desc.C("FSMinMax ");
if (id.Bit(VS_BIT_FS_DEPTH_CLAMP)) desc.C("FSDepthClamp ");
if (Bit(VS_BIT_FS_MINMAX_DISCARD)) desc.C("FSMinMax ");
if (Bit(VS_BIT_FS_DEPTH_CLAMP)) desc.C("FSDepthClamp ");
// Lights
if (id.Bit(VS_BIT_LIGHTING_ENABLE)) {
if (Bit(VS_BIT_LIGHTING_ENABLE)) {
desc.C("Light: ");
}
if (id.Bit(VS_BIT_LIGHT_UBERSHADER)) {
if (Bit(VS_BIT_LIGHT_UBERSHADER)) {
desc.C("LightUberShader ");
}
for (int i = 0; i < 4; i++) {
bool enabled = id.Bit(VS_BIT_LIGHT0_ENABLE + i) && id.Bit(VS_BIT_LIGHTING_ENABLE);
bool enabled = Bit(VS_BIT_LIGHT0_ENABLE + i) && Bit(VS_BIT_LIGHTING_ENABLE);
if (enabled || (uvgMode == GE_TEXMAP_ENVIRONMENT_MAP && (ls0 == i || ls1 == i))) {
desc.F("%d: ", i);
desc.F("c:%d t:%d ", id.Bits(VS_BIT_LIGHT0_COMP + 4 * i, 2), id.Bits(VS_BIT_LIGHT0_TYPE + 4 * i, 2));
desc.F("c:%d t:%d ", Bits(VS_BIT_LIGHT0_COMP + 4 * i, 2), Bits(VS_BIT_LIGHT0_TYPE + 4 * i, 2));
}
}
if (id.Bit(VS_BIT_SIMPLE_STEREO)) desc.C("SimpleStereo ");
if (id.Bit(VS_BIT_VERTEX_RANGE_CULLING)) desc.C("RangeCull ");
if (Bit(VS_BIT_SIMPLE_STEREO)) desc.C("SimpleStereo ");
if (Bit(VS_BIT_VERTEX_RANGE_CULLING)) desc.C("RangeCull ");
return desc.as_string();
}
@@ -176,15 +176,15 @@ static bool MatrixNeedsProjection(const float m[12], GETexProjMapMode mode) {
return m[2] != 0.0f || m[5] != 0.0f || (m[8] != 0.0f && mode != GE_PROJMAP_UV) || m[11] != 1.0f;
}
std::string FragmentShaderDesc(const FShaderID &id) {
std::string FShaderID::Description() const {
char buffer[512];
StringWriter desc(buffer, sizeof(buffer));
desc.W(id.ToDebugString()).C(" ");
if (id.Bit(FS_BIT_CLEARMODE)) desc.C("Clear ");
if (id.Bit(FS_BIT_DO_TEXTURE)) {
desc.W(id.Bit(FS_BIT_3D_TEXTURE) ? "Tex3D" : "Tex");
switch (id.Bits(FS_BIT_TEXFUNC, 3)) {
desc.W(ToDebugString()).C(" ");
if (Bit(FS_BIT_CLEARMODE)) desc.C("Clear ");
if (Bit(FS_BIT_DO_TEXTURE)) {
desc.W(Bit(FS_BIT_3D_TEXTURE) ? "Tex3D" : "Tex");
switch (Bits(FS_BIT_TEXFUNC, 3)) {
case GE_TEXFUNC_ADD: desc.C("(TFuncAdd) "); break;
case GE_TEXFUNC_BLEND: desc.C("(TFuncBlend) "); break;
case GE_TEXFUNC_DECAL: desc.C("(TFuncDecal) "); break;
@@ -193,41 +193,41 @@ std::string FragmentShaderDesc(const FShaderID &id) {
default: desc.C("(TFuncUnk) "); break;
}
}
if (id.Bit(FS_BIT_LMODE)) desc.C("LM ");
if (id.Bit(FS_BIT_ENABLE_FOG)) desc.C("Fog ");
if (id.Bit(FS_BIT_FLATSHADE)) desc.C("Flat ");
if (id.Bit(FS_BIT_DEPTH_TEST_NEVER)) desc.C("DepthNever ");
if (id.Bit(FS_BIT_COLOR_WRITEMASK)) desc.C("WriteMask ");
if (id.Bit(FS_BIT_SHADER_TEX_CLAMP)) {
if (Bit(FS_BIT_LMODE)) desc.C("LM ");
if (Bit(FS_BIT_ENABLE_FOG)) desc.C("Fog ");
if (Bit(FS_BIT_FLATSHADE)) desc.C("Flat ");
if (Bit(FS_BIT_DEPTH_TEST_NEVER)) desc.C("DepthNever ");
if (Bit(FS_BIT_COLOR_WRITEMASK)) desc.C("WriteMask ");
if (Bit(FS_BIT_SHADER_TEX_CLAMP)) {
desc.C("TClamp");
if (id.Bit(FS_BIT_CLAMP_S)) desc.C("S");
if (id.Bit(FS_BIT_CLAMP_T)) desc.C("T");
if (Bit(FS_BIT_CLAMP_S)) desc.C("S");
if (Bit(FS_BIT_CLAMP_T)) desc.C("T");
desc.C(" ");
}
int blendBits = id.Bits(FS_BIT_REPLACE_BLEND, 3);
int blendBits = Bits(FS_BIT_REPLACE_BLEND, 3);
if (blendBits) {
switch (blendBits) {
case ReplaceBlendType::REPLACE_BLEND_BLUE_TO_ALPHA:
desc.C("BlueToAlpha_" "A:").F("%d ", id.Bits(FS_BIT_BLENDFUNC_A, 4));
desc.C("BlueToAlpha_" "A:").F("%d ", Bits(FS_BIT_BLENDFUNC_A, 4));
break;
default:
desc.C("ReplaceBlend_").F("%d ", id.Bits(FS_BIT_REPLACE_BLEND, 3))
.C("A:").F("%d ", id.Bits(FS_BIT_BLENDFUNC_A, 4))
.C("_B:").F("%d ", id.Bits(FS_BIT_BLENDFUNC_B, 4))
.C("_Eq:").F("%d ", id.Bits(FS_BIT_BLENDEQ, 3));
desc.C("ReplaceBlend_").F("%d ", Bits(FS_BIT_REPLACE_BLEND, 3))
.C("A:").F("%d ", Bits(FS_BIT_BLENDFUNC_A, 4))
.C("_B:").F("%d ", Bits(FS_BIT_BLENDFUNC_B, 4))
.C("_Eq:").F("%d ", Bits(FS_BIT_BLENDEQ, 3));
break;
}
}
switch (id.Bits(FS_BIT_STENCIL_TO_ALPHA, 2)) {
switch (Bits(FS_BIT_STENCIL_TO_ALPHA, 2)) {
case REPLACE_ALPHA_NO: break;
case REPLACE_ALPHA_YES: desc.C("StenToAlpha "); break;
case REPLACE_ALPHA_DUALSOURCE: desc.C("StenToAlphaDual "); break;
default: desc.C("StenToAlphaUnknown "); break; // bad
}
if (id.Bits(FS_BIT_STENCIL_TO_ALPHA, 2) != REPLACE_ALPHA_NO) {
switch (id.Bits(FS_BIT_REPLACE_ALPHA_WITH_STENCIL_TYPE, 4)) {
if (Bits(FS_BIT_STENCIL_TO_ALPHA, 2) != REPLACE_ALPHA_NO) {
switch (Bits(FS_BIT_REPLACE_ALPHA_WITH_STENCIL_TYPE, 4)) {
case STENCIL_VALUE_UNIFORM: desc.C("StenUniform "); break;
case STENCIL_VALUE_ZERO: desc.C("Sten0 "); break;
case STENCIL_VALUE_ONE: desc.C("Sten1 "); break;
@@ -239,30 +239,30 @@ std::string FragmentShaderDesc(const FShaderID &id) {
case STENCIL_VALUE_DECR_8BIT: desc.C("StenDecr8 "); break;
default: desc.C("StenUnknown "); break;
}
} else if (id.Bit(FS_BIT_REPLACE_ALPHA_WITH_STENCIL_TYPE)) {
} else if (Bit(FS_BIT_REPLACE_ALPHA_WITH_STENCIL_TYPE)) {
desc.C("StenOff ");
}
if (id.Bit(FS_BIT_ALPHA_AGAINST_ZERO)) desc.C("AlphaTest0 ").W(alphaTestFuncs[id.Bits(FS_BIT_ALPHA_TEST_FUNC, 3)]).C(" ");
else if (id.Bit(FS_BIT_ALPHA_TEST)) desc.C("AlphaTest ").W(alphaTestFuncs[id.Bits(FS_BIT_ALPHA_TEST_FUNC, 3)]).C(" ");
if (id.Bit(FS_BIT_COLOR_AGAINST_ZERO)) desc.C("ColorTest0 ").W(alphaTestFuncs[id.Bits(FS_BIT_COLOR_TEST_FUNC, 2)]).C(" "); // first 4 match;
else if (id.Bit(FS_BIT_COLOR_TEST)) desc.C("ColorTest ").W(alphaTestFuncs[id.Bits(FS_BIT_COLOR_TEST_FUNC, 2)]).C(" "); // first 4 match
if (id.Bit(FS_BIT_TEST_DISCARD_TO_ZERO)) desc.C("TestDiscardToZero ");
if (id.Bit(FS_BIT_NO_DEPTH_CANNOT_DISCARD_STENCIL)) desc.C("StencilDiscardWorkaround ");
int logicMode = id.Bits(FS_BIT_REPLACE_LOGIC_OP, 4);
if ((logicMode != GE_LOGIC_COPY) && !id.Bit(FS_BIT_CLEARMODE)) desc.C("RLogic(").W(logicFuncs[logicMode]).C(")");
if (id.Bit(FS_BIT_SAMPLE_ARRAY_TEXTURE)) desc.C("TexArray ");
if (id.Bit(FS_BIT_STEREO)) desc.C("Stereo ");
if (id.Bit(FS_BIT_USE_FRAMEBUFFER_FETCH)) desc.C("(fetch)");
if (id.Bit(FS_BIT_MINMAX_DISCARD)) desc.C("FragMinMaxDiscard ");
if (id.Bit(FS_BIT_DEPTH_CLAMP)) desc.C("FragDepthClamp ");
if (Bit(FS_BIT_ALPHA_AGAINST_ZERO)) desc.C("AlphaTest0 ").W(alphaTestFuncs[Bits(FS_BIT_ALPHA_TEST_FUNC, 3)]).C(" ");
else if (Bit(FS_BIT_ALPHA_TEST)) desc.C("AlphaTest ").W(alphaTestFuncs[Bits(FS_BIT_ALPHA_TEST_FUNC, 3)]).C(" ");
if (Bit(FS_BIT_COLOR_AGAINST_ZERO)) desc.C("ColorTest0 ").W(alphaTestFuncs[Bits(FS_BIT_COLOR_TEST_FUNC, 2)]).C(" "); // first 4 match;
else if (Bit(FS_BIT_COLOR_TEST)) desc.C("ColorTest ").W(alphaTestFuncs[Bits(FS_BIT_COLOR_TEST_FUNC, 2)]).C(" "); // first 4 match
if (Bit(FS_BIT_TEST_DISCARD_TO_ZERO)) desc.C("TestDiscardToZero ");
if (Bit(FS_BIT_NO_DEPTH_CANNOT_DISCARD_STENCIL)) desc.C("StencilDiscardWorkaround ");
int logicMode = Bits(FS_BIT_REPLACE_LOGIC_OP, 4);
if ((logicMode != GE_LOGIC_COPY) && !Bit(FS_BIT_CLEARMODE)) desc.C("RLogic(").W(logicFuncs[logicMode]).C(")");
if (Bit(FS_BIT_SAMPLE_ARRAY_TEXTURE)) desc.C("TexArray ");
if (Bit(FS_BIT_STEREO)) desc.C("Stereo ");
if (Bit(FS_BIT_USE_FRAMEBUFFER_FETCH)) desc.C("(fetch)");
if (Bit(FS_BIT_MINMAX_DISCARD)) desc.C("FragMinMaxDiscard ");
if (Bit(FS_BIT_DEPTH_CLAMP)) desc.C("FragDepthClamp ");
const ShaderDepalMode depalMode = (ShaderDepalMode)id.Bits(FS_BIT_SHADER_DEPAL_MODE, 2);
const ShaderDepalMode depalMode = (ShaderDepalMode)Bits(FS_BIT_SHADER_DEPAL_MODE, 2);
switch (depalMode) {
case ShaderDepalMode::OFF: break;
case ShaderDepalMode::NORMAL: desc.C("Depal(");
{
const GEBufferFormat shaderDepalFormat = (GEBufferFormat)id.Bits(FS_BIT_SHADER_DEPAL_FORMAT, 3);
const GEBufferFormat shaderDepalFormat = (GEBufferFormat)Bits(FS_BIT_SHADER_DEPAL_FORMAT, 3);
desc.W(GeBufferFormatToString(shaderDepalFormat)).C(") ");
break;
}
GPU/Common/ShaderId.h
+9 -4
View File
@@ -205,6 +205,10 @@ struct VShaderID : public ShaderID {
void SetBits(VShaderBit bit, int count, int value) {
ShaderID::SetBits((int)bit, count, value);
}
// Generates a compact string that describes the shader. Useful in a list to get an overview
// of the current flora of shaders.
std::string Description() const;
};
struct FShaderID : public ShaderID {
@@ -230,20 +234,21 @@ struct FShaderID : public ShaderID {
void SetBits(FShaderBit bit, int count, int value) {
ShaderID::SetBits((int)bit, count, value);
}
std::string Description() const;
};
static_assert(sizeof(VShaderID) == sizeof(uint64_t), "VShaderID size mismatch");
static_assert(sizeof(FShaderID) == sizeof(uint64_t), "FShaderID size mismatch");
namespace Draw {
class Bugs;
}
void ComputeVertexShaderID(VShaderID *id, u32 vertType, bool useHWTransform, bool weightsAsFloat, bool useSkinInDecode, ClipInfoFlags clipInfoFlags);
// Generates a compact string that describes the shader. Useful in a list to get an overview
// of the current flora of shaders.
std::string VertexShaderDesc(const VShaderID &id);
struct ComputedPipelineState;
void ComputeFragmentShaderID(FShaderID *id, const ComputedPipelineState &pipelineState, const Draw::Bugs &bugs, ClipInfoFlags clipInfoFlags);
std::string FragmentShaderDesc(const FShaderID &id);
// For sanity checking.
bool FragmentIdNeedsFramebufferRead(const FShaderID &id);
GPU/Common/VertexShaderGenerator.cpp
+1 -1
View File
@@ -169,7 +169,7 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag
ShaderWriter p(buffer, compat, ShaderStage::Vertex, extensions);
p.F("// %s\n", VertexShaderDesc(id).c_str());
p.C("// %").W(id.Description()).endl();
bool lmode = id.Bit(VS_BIT_LMODE);
GPU/D3D11/ShaderManagerD3D11.cpp
+2 -2
View File
@@ -47,7 +47,7 @@ std::string D3D11FragmentShader::GetShaderString(DebugShaderStringType type) con
case SHADER_STRING_SOURCE_CODE:
return source_;
case SHADER_STRING_SHORT_DESC:
return FragmentShaderDesc(id_);
return id_.Description();
default:
return "N/A";
}
@@ -69,7 +69,7 @@ std::string D3D11VertexShader::GetShaderString(DebugShaderStringType type) const
case SHADER_STRING_SOURCE_CODE:
return source_;
case SHADER_STRING_SHORT_DESC:
return VertexShaderDesc(id_);
return id_.Description();
default:
return "N/A";
}
GPU/GLES/ShaderManagerGLES.cpp
+3 -3
View File
@@ -677,7 +677,7 @@ Shader *ShaderManagerGLES::CompileFragmentShader(FShaderID FSID) {
return nullptr;
}
_assert_msg_(strlen(codeBuffer_) < CODE_BUFFER_SIZE, "FS length error: %d", (int)strlen(codeBuffer_));
std::string desc = FragmentShaderDesc(FSID);
std::string desc = FSID.Description();
ShaderDescGLES params{ GL_FRAGMENT_SHADER, 0, uniformMask };
return new Shader(render_, codeBuffer_, desc, params);
}
@@ -695,7 +695,7 @@ Shader *ShaderManagerGLES::CompileVertexShader(VShaderID VSID) {
return nullptr;
}
_assert_msg_(strlen(codeBuffer_) < CODE_BUFFER_SIZE, "VS length error: %d", (int)strlen(codeBuffer_));
std::string desc = VertexShaderDesc(VSID);
std::string desc = VSID.Description();
ShaderDescGLES params{ GL_VERTEX_SHADER, attrMask, uniformMask };
params.useHWTransform = useHWTransform;
return new Shader(render_, codeBuffer_, desc, params);
@@ -826,7 +826,7 @@ std::string Shader::GetShaderString(DebugShaderStringType type, ShaderID id) con
case SHADER_STRING_SOURCE_CODE:
return source_;
case SHADER_STRING_SHORT_DESC:
return isFragment_ ? FragmentShaderDesc(FShaderID(id)) : VertexShaderDesc(VShaderID(id));
return isFragment_ ? FShaderID(id).Description() : VShaderID(id).Description();
default:
return "N/A";
}
GPU/Vulkan/PipelineManagerVulkan.cpp
+39 -41
View File
@@ -1,12 +1,11 @@
#include <cstring>
#include <memory>
#include <set>
#include <sstream>
#include "Common/Profiler/Profiler.h"
#include "Common/Log.h"
#include "Common/StringUtils.h"
#include "Common/Data/Text/StringWriter.h"
#include "Common/GPU/Vulkan/VulkanContext.h"
#include "GPU/Vulkan/PipelineManagerVulkan.h"
#include "GPU/Vulkan/ShaderManagerVulkan.h"
@@ -30,7 +29,7 @@ PipelineManagerVulkan::~PipelineManagerVulkan() {
// Block on all pipelines to make sure any background compiles are done.
// This is very important to do before we start trying to tear down the shaders - otherwise, we might
// be deleting shaders before queued pipeline creations that use them are performed.
pipelines_.Iterate([&](const VulkanPipelineKey &key, VulkanPipeline *value) {
pipelines_.Iterate([](const VulkanPipelineKey &key, VulkanPipeline *value) {
if (value->pipeline) {
value->pipeline->BlockUntilCompiled();
}
@@ -327,7 +326,7 @@ static VulkanPipeline *CreateVulkanPipeline(VulkanRenderManager *renderManager,
std::string tag = "game";
#ifdef _DEBUG
tag = FragmentShaderDesc(fs->GetID()) + " VS " + VertexShaderDesc(vs->GetID());
tag = fs->GetID().Description() + " VS " + vs->GetID().Description();
#endif
VKRGraphicsPipeline *pipeline = renderManager->CreateGraphicsPipeline(desc, pipelineFlags, variantBitmask, sampleCount, cacheLoad, tag.c_str());
@@ -509,64 +508,63 @@ std::string PipelineManagerVulkan::DebugGetObjectString(const std::string &id, D
}
std::string VulkanPipelineKey::GetRasterStateDesc(bool lineBreaks) const {
std::stringstream str;
str << topologies[raster.topology] << " ";
char temp[512];
StringWriter str(temp);
str.W(topologies[raster.topology]).C(" ");
if (useHWTransform) {
str << "HWX ";
str.C("HWX ");
}
if (vtxFmtId) {
str << "Vfmt(" << StringFromFormat("%08x", vtxFmtId) << ") "; // TODO: Format nicer.
str.F("Vfmt(%08x) ", vtxFmtId); // TODO: Format nicer.
} else {
str << "SWX ";
str.C("SWX ");
}
if (lineBreaks) str << std::endl;
if (lineBreaks) str.endl();
if (raster.blendEnable) {
str << "Blend(C:" << blendOps[raster.blendOpColor] << "/"
<< blendFactors[raster.srcColor] << ":" << blendFactors[raster.destColor] << " ";
str.W("Blend(C:").W(blendOps[raster.blendOpColor]).W("/").W(blendFactors[raster.srcColor]).W(":").W(blendFactors[raster.destColor]).W(" ");
if (raster.blendOpAlpha != VK_BLEND_OP_ADD ||
raster.srcAlpha != VK_BLEND_FACTOR_ONE ||
raster.destAlpha != VK_BLEND_FACTOR_ZERO) {
str << "A:" << blendOps[raster.blendOpAlpha] << "/"
<< blendFactors[raster.srcColor] << ":" << blendFactors[raster.destColor] << " ";
str.C("A:").W(blendOps[raster.blendOpAlpha]).C("/").W(blendFactors[raster.srcColor]).C(":").W(blendFactors[raster.destColor]).W(" ");
}
str << ") ";
if (lineBreaks) str << std::endl;
str.C(") ");
if (lineBreaks) str.endl();
}
if (raster.colorWriteMask != 0xF) {
str << "Mask(";
str.C("Mask(");
for (int i = 0; i < 4; i++) {
if (raster.colorWriteMask & (1 << i)) {
str << "RGBA"[i];
str.F("%c", "RGBA"[i]);
} else {
str << "_";
str.C("_");
}
}
str << ") ";
if (lineBreaks) str << std::endl;
str.C(") ");
if (lineBreaks) str.endl();
}
if (raster.depthTestEnable) {
str << "Z(";
str.C("Z(");
if (raster.depthWriteEnable)
str << "W, ";
str.C("W, ");
if (raster.depthCompareOp)
str << compareOps[raster.depthCompareOp & 7];
str << ") ";
if (lineBreaks) str << std::endl;
str.W(compareOps[raster.depthCompareOp & 7]);
str.C(") ");
if (lineBreaks) str.endl();
}
if (raster.stencilTestEnable) {
str << "Stenc(";
str << compareOps[raster.stencilCompareOp & 7] << " ";
str << stencilOps[raster.stencilPassOp & 7] << "/";
str << stencilOps[raster.stencilFailOp & 7] << "/";
str << stencilOps[raster.stencilDepthFailOp & 7];
str << ") ";
if (lineBreaks) str << std::endl;
str.C("Stenc(");
str.W(compareOps[raster.stencilCompareOp & 7]).C(" ");
str.W(stencilOps[raster.stencilPassOp & 7]).C("/");
str.W(stencilOps[raster.stencilFailOp & 7]).C("/");
str.W(stencilOps[raster.stencilDepthFailOp & 7]);
str.C(") ");
if (lineBreaks) str.endl();
}
if (raster.logicOpEnable) {
str << "Logic(" << logicOps[raster.logicOp & 15] << ") ";
if (lineBreaks) str << std::endl;
str.C("Logic(").W(logicOps[raster.logicOp & 15]).C(") ");
if (lineBreaks) str.endl();
}
return str.str();
return str.as_string();
}
std::string VulkanPipelineKey::GetDescription(DebugShaderStringType stringType, ShaderManagerVulkan *shaderManager) const {
@@ -581,11 +579,11 @@ std::string VulkanPipelineKey::GetDescription(DebugShaderStringType stringType,
VkShaderModule fsModule = this->fShader->BlockUntilReady();
VkShaderModule vsModule = this->vShader->BlockUntilReady();
std::stringstream str;
str << "VS: " << VertexShaderDesc(shaderManager->GetVertexShaderFromModule(vsModule)->GetID()) << std::endl;
str << "FS: " << FragmentShaderDesc(shaderManager->GetFragmentShaderFromModule(fsModule)->GetID()) << std::endl;
str << GetRasterStateDesc(true);
return str.str();
std::string str;
str += "VS: " + shaderManager->GetVertexShaderFromModule(vsModule)->GetID().Description() + "\n";
str += "FS: " + shaderManager->GetFragmentShaderFromModule(fsModule)->GetID().Description() + "\n";
str += GetRasterStateDesc(true);
return str;
}
default:
GPU/Vulkan/ShaderManagerVulkan.cpp
+4 -4
View File
@@ -106,7 +106,7 @@ VulkanFragmentShader::VulkanFragmentShader(VulkanContext *vulkan, FShaderID id,
: vulkan_(vulkan), id_(id), flags_(flags) {
_assert_(!id.is_invalid());
source_ = code;
module_ = CompileShaderModuleAsync(vulkan, VK_SHADER_STAGE_FRAGMENT_BIT, source_.c_str(), new std::string(FragmentShaderDesc(id)));
module_ = CompileShaderModuleAsync(vulkan, VK_SHADER_STAGE_FRAGMENT_BIT, source_.c_str(), new std::string(id.Description()));
VERBOSE_LOG(Log::G3D, "Compiled fragment shader:\n%s\n", (const char *)code);
}
@@ -127,7 +127,7 @@ std::string VulkanFragmentShader::GetShaderString(DebugShaderStringType type) co
case SHADER_STRING_SOURCE_CODE:
return source_;
case SHADER_STRING_SHORT_DESC:
return FragmentShaderDesc(id_);
return id_.Description();
default:
return "N/A";
}
@@ -137,7 +137,7 @@ VulkanVertexShader::VulkanVertexShader(VulkanContext *vulkan, VShaderID id, Vert
: vulkan_(vulkan), useHWTransform_(useHWTransform), flags_(flags), id_(id) {
_assert_(!id.is_invalid());
source_ = code;
module_ = CompileShaderModuleAsync(vulkan, VK_SHADER_STAGE_VERTEX_BIT, source_.c_str(), new std::string(VertexShaderDesc(id)));
module_ = CompileShaderModuleAsync(vulkan, VK_SHADER_STAGE_VERTEX_BIT, source_.c_str(), new std::string(id.Description()));
VERBOSE_LOG(Log::G3D, "Compiled vertex shader:\n%s\n", (const char *)code);
}
@@ -158,7 +158,7 @@ std::string VulkanVertexShader::GetShaderString(DebugShaderStringType type) cons
case SHADER_STRING_SOURCE_CODE:
return source_;
case SHADER_STRING_SHORT_DESC:
return VertexShaderDesc(id_);
return id_.Description();
default:
return "N/A";
}