From f8167d442ff87cc3e0ed4afa24444055cd069929 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Sun, 6 Nov 2022 16:56:21 +0100 Subject: [PATCH] Second round of removals, and some minor refactoring in the Vulkan backend. --- GPU/Common/FragmentShaderGenerator.cpp | 11 +-- GPU/Common/ShaderCommon.h | 6 +- GPU/Common/ShaderId.cpp | 12 --- GPU/Common/ShaderId.h | 7 +- GPU/Common/ShaderUniforms.cpp | 8 -- GPU/Common/ShaderUniforms.h | 12 --- GPU/Common/VertexShaderGenerator.cpp | 101 +++---------------------- GPU/Common/VertexShaderGenerator.h | 15 +--- GPU/D3D11/ShaderManagerD3D11.cpp | 13 +--- GPU/D3D11/ShaderManagerD3D11.h | 2 - GPU/Directx9/ShaderManagerDX9.cpp | 34 +-------- GPU/GLES/ShaderManagerGLES.cpp | 20 ----- GPU/GLES/ShaderManagerGLES.h | 7 -- GPU/GPUCommon.cpp | 2 +- GPU/Vulkan/DrawEngineVulkan.cpp | 67 +++++----------- GPU/Vulkan/DrawEngineVulkan.h | 21 +++-- GPU/Vulkan/ShaderManagerVulkan.cpp | 4 - GPU/Vulkan/ShaderManagerVulkan.h | 5 -- unittest/TestShaderGenerators.cpp | 5 -- 19 files changed, 59 insertions(+), 293 deletions(-) diff --git a/GPU/Common/FragmentShaderGenerator.cpp b/GPU/Common/FragmentShaderGenerator.cpp index 1cfd750540..e02aa04a3d 100644 --- a/GPU/Common/FragmentShaderGenerator.cpp +++ b/GPU/Common/FragmentShaderGenerator.cpp @@ -31,6 +31,7 @@ #include "GPU/Common/ShaderId.h" #include "GPU/Common/ShaderUniforms.h" #include "GPU/Common/FragmentShaderGenerator.h" +#include "GPU/Vulkan/DrawEngineVulkan.h" #include "GPU/ge_constants.h" #include "GPU/GPUState.h" @@ -185,23 +186,23 @@ bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLangu WRITE(p, "layout (depth_unchanged) out float gl_FragDepth;\n"); } - WRITE(p, "layout (std140, set = 1, binding = 3) uniform baseUBO {\n%s};\n", ub_baseStr); + WRITE(p, "layout (std140, set = 1, binding = %d) uniform baseUBO {\n%s};\n", DRAW_BINDING_DYNUBO_BASE, ub_baseStr); if (doTexture) { - WRITE(p, "layout (set = 1, binding = 0) uniform %s%s tex;\n", texture3D ? "sampler3D" : "sampler2D", arrayTexture ? "Array" : ""); + WRITE(p, "layout (set = 1, binding = %d) uniform %s%s tex;\n", DRAW_BINDING_TEXTURE, texture3D ? "sampler3D" : "sampler2D", arrayTexture ? "Array" : ""); } if (readFramebufferTex) { // The framebuffer texture is always bound as an array. - p.C("layout (set = 1, binding = 1) uniform sampler2DArray fbotex;\n"); + p.F("layout (set = 1, binding = %d) uniform sampler2DArray fbotex;\n", DRAW_BINDING_2ND_TEXTURE); } else if (fetchFramebuffer) { - p.C("layout (input_attachment_index = 0, set = 1, binding = 9) uniform subpassInput inputColor;\n"); + p.F("layout (input_attachment_index = 0, set = 1, binding = %d) uniform subpassInput inputColor;\n", DRAW_BINDING_INPUT_ATTACHMENT); if (fragmentShaderFlags) { *fragmentShaderFlags |= FragmentShaderFlags::INPUT_ATTACHMENT; } } if (shaderDepalMode != ShaderDepalMode::OFF) { - WRITE(p, "layout (set = 1, binding = 2) uniform sampler2D pal;\n"); + WRITE(p, "layout (set = 1, binding = %d) uniform sampler2D pal;\n", DRAW_BINDING_DEPAL_TEXTURE); } // Note: the precision qualifiers must match the vertex shader! diff --git a/GPU/Common/ShaderCommon.h b/GPU/Common/ShaderCommon.h index 63e3116014..2307423927 100644 --- a/GPU/Common/ShaderCommon.h +++ b/GPU/Common/ShaderCommon.h @@ -90,11 +90,7 @@ enum : uint64_t { DIRTY_MIPBIAS = 1ULL << 37, DIRTY_LIGHT_CONTROL = 1ULL << 38, - // space for 1 more uniform dirty flags. Remember to update DIRTY_ALL_UNIFORMS. - - DIRTY_BONE_UNIFORMS = 0xFF000000ULL, - - DIRTY_ALL_UNIFORMS = 0x7FFFFFFFFFULL, + DIRTY_ALL_UNIFORMS = 0x7F00FFFFFFULL, // 00 is where bone uniforms used to be. DIRTY_ALL_LIGHTS = DIRTY_LIGHT0 | DIRTY_LIGHT1 | DIRTY_LIGHT2 | DIRTY_LIGHT3, // Other dirty elements that aren't uniforms! diff --git a/GPU/Common/ShaderId.cpp b/GPU/Common/ShaderId.cpp index 8ecced2853..6183a0a5db 100644 --- a/GPU/Common/ShaderId.cpp +++ b/GPU/Common/ShaderId.cpp @@ -35,7 +35,6 @@ std::string VertexShaderDesc(const VShaderID &id) { int ls1 = id.Bits(VS_BIT_LS1, 2); if (uvgMode) desc << uvgModes[uvgMode]; - if (id.Bit(VS_BIT_ENABLE_BONES)) desc << "Bones:" << (id.Bits(VS_BIT_BONES, 3) + 1) << " "; // Lights if (id.Bit(VS_BIT_LIGHTING_ENABLE)) { desc << "Light: "; @@ -51,7 +50,6 @@ std::string VertexShaderDesc(const VShaderID &id) { } } if (id.Bits(VS_BIT_MATERIAL_UPDATE, 3)) desc << "MatUp:" << id.Bits(VS_BIT_MATERIAL_UPDATE, 3) << " "; - if (id.Bits(VS_BIT_WEIGHT_FMTSCALE, 2)) desc << "WScale " << id.Bits(VS_BIT_WEIGHT_FMTSCALE, 2) << " "; if (id.Bit(VS_BIT_FLATSHADE)) desc << "Flat "; if (id.Bit(VS_BIT_BEZIER)) desc << "Bezier "; @@ -117,16 +115,6 @@ void ComputeVertexShaderID(VShaderID *id_out, u32 vertType, bool useHWTransform, id.SetBits(VS_BIT_LS1, 2, gstate.getUVLS1()); } - // Bones. - bool enableBones = false; - id.SetBit(VS_BIT_ENABLE_BONES, enableBones); - if (enableBones) { - id.SetBits(VS_BIT_BONES, 3, TranslateNumBones(vertTypeGetNumBoneWeights(vertType)) - 1); - // 2 bits. We should probably send in the weight scalefactor as a uniform instead, - // or simply preconvert all weights to floats. - id.SetBits(VS_BIT_WEIGHT_FMTSCALE, 2, weightsAsFloat ? 0 : (vertType & GE_VTYPE_WEIGHT_MASK) >> GE_VTYPE_WEIGHT_SHIFT); - } - if (gstate.isLightingEnabled()) { // doShadeMapping is stored as UVGenMode, and light type doesn't matter for shade mapping. id.SetBit(VS_BIT_LIGHTING_ENABLE); diff --git a/GPU/Common/ShaderId.h b/GPU/Common/ShaderId.h index 06b252d87d..910e0aa40d 100644 --- a/GPU/Common/ShaderId.h +++ b/GPU/Common/ShaderId.h @@ -29,9 +29,7 @@ enum VShaderBit : uint8_t { VS_BIT_UVPROJ_MODE = 18, // 2, can overlap with LS0 VS_BIT_LS0 = 18, // 2 VS_BIT_LS1 = 20, // 2 - VS_BIT_BONES = 22, // 3 should be enough, not 8 - // 25 - 29 are free. - VS_BIT_ENABLE_BONES = 30, + // 21 - 30 are free. // If this is set along with LIGHTING_ENABLE, all other lighting bits below // are passed to the shader directly instead. @@ -52,8 +50,7 @@ enum VShaderBit : uint8_t { VS_BIT_LIGHT2_ENABLE = 54, VS_BIT_LIGHT3_ENABLE = 55, VS_BIT_LIGHTING_ENABLE = 56, - VS_BIT_WEIGHT_FMTSCALE = 57, // only two bits - // 59 - 61 are free. + // 57 - 61 are free. VS_BIT_FLATSHADE = 62, // 1 bit VS_BIT_BEZIER = 63, // 1 bit // No more free diff --git a/GPU/Common/ShaderUniforms.cpp b/GPU/Common/ShaderUniforms.cpp index 724fd26080..4be865048c 100644 --- a/GPU/Common/ShaderUniforms.cpp +++ b/GPU/Common/ShaderUniforms.cpp @@ -337,11 +337,3 @@ void LightUpdateUniforms(UB_VS_Lights *ub, uint64_t dirtyUniforms) { } } } - -void BoneUpdateUniforms(UB_VS_Bones *ub, uint64_t dirtyUniforms) { - for (int i = 0; i < 8; i++) { - if (dirtyUniforms & (DIRTY_BONEMATRIX0 << i)) { - ConvertMatrix4x3To3x4Transposed(ub->bones[i], gstate.boneMatrix + 12 * i); - } - } -} diff --git a/GPU/Common/ShaderUniforms.h b/GPU/Common/ShaderUniforms.h index ecddc4b3ca..09e8a5e9b9 100644 --- a/GPU/Common/ShaderUniforms.h +++ b/GPU/Common/ShaderUniforms.h @@ -120,17 +120,6 @@ R"( vec4 u_ambient; vec3 u_lightspecular3; )"; -// With some cleverness, we could get away with uploading just half this when only the four or five first -// bones are being used. This is 384b. -struct alignas(16) UB_VS_Bones { - float bones[8][12]; -}; - -static const char * const ub_vs_bonesStr = -R"( mat3x4 u_bone0; mat3x4 u_bone1; mat3x4 u_bone2; mat3x4 u_bone3; mat3x4 u_bone4; mat3x4 u_bone5; mat3x4 u_bone6; mat3x4 u_bone7; mat3x4 u_bone8; -)"; - - static const char * const ub_frameStr = R"( float u_rotation; @@ -145,7 +134,6 @@ void CalcCullRange(float minValues[4], float maxValues[4], bool flipViewport, bo void BaseUpdateUniforms(UB_VS_FS_Base *ub, uint64_t dirtyUniforms, bool flipViewport, bool useBufferedRendering); void LightUpdateUniforms(UB_VS_Lights *ub, uint64_t dirtyUniforms); -void BoneUpdateUniforms(UB_VS_Bones *ub, uint64_t dirtyUniforms); void FrameUpdateUniforms(UB_Frame *ub, bool useBufferedRendering); uint32_t PackLightControlBits(); diff --git a/GPU/Common/VertexShaderGenerator.cpp b/GPU/Common/VertexShaderGenerator.cpp index fd99a52cd9..cb8336d12c 100644 --- a/GPU/Common/VertexShaderGenerator.cpp +++ b/GPU/Common/VertexShaderGenerator.cpp @@ -30,6 +30,7 @@ #include "GPU/Common/ShaderUniforms.h" #include "GPU/Common/VertexDecoderCommon.h" #include "GPU/Common/VertexShaderGenerator.h" +#include "GPU/Vulkan/DrawEngineVulkan.h" #undef WRITE @@ -190,7 +191,6 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag bool flipNormal = id.Bit(VS_BIT_NORM_REVERSE); int ls0 = id.Bits(VS_BIT_LS0, 2); int ls1 = id.Bits(VS_BIT_LS1, 2); - bool enableBones = id.Bit(VS_BIT_ENABLE_BONES) && useHWTransform; bool enableLighting = id.Bit(VS_BIT_LIGHTING_ENABLE); int matUpdate = id.Bits(VS_BIT_MATERIAL_UPDATE, 3); @@ -200,9 +200,8 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag return false; } - // Apparently we don't support bezier/spline together with bones. - bool doBezier = id.Bit(VS_BIT_BEZIER) && !enableBones && useHWTransform; - bool doSpline = id.Bit(VS_BIT_SPLINE) && !enableBones && useHWTransform; + bool doBezier = id.Bit(VS_BIT_BEZIER) && useHWTransform; + bool doSpline = id.Bit(VS_BIT_SPLINE) && useHWTransform; if (doBezier || doSpline) { if (!hasNormal) { // Bad usage. @@ -235,11 +234,6 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag } } - int numBoneWeights = 0; - int boneWeightScale = id.Bits(VS_BIT_WEIGHT_FMTSCALE, 2); - if (enableBones) { - numBoneWeights = 1 + id.Bits(VS_BIT_BONES, 3); - } bool texCoordInVec3 = false; bool vertexRangeCulling = id.Bit(VS_BIT_VERTEX_RANGE_CULLING) && !isModeThrough; @@ -254,15 +248,9 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag WRITE(p, "layout (std140, set = 0, binding = 0) uniform frameVars {\n%s};\n", ub_frameStr); } - WRITE(p, "layout (std140, set = 1, binding = 3) uniform baseVars {\n%s};\n", ub_baseStr); + WRITE(p, "layout (std140, set = 1, binding = %d) uniform baseVars {\n%s};\n", DRAW_BINDING_DYNUBO_BASE, ub_baseStr); if (enableLighting || doShadeMapping) - WRITE(p, "layout (std140, set = 1, binding = 4) uniform lightVars {\n%s};\n", ub_vs_lightsStr); - if (enableBones) - WRITE(p, "layout (std140, set = 1, binding = 5) uniform boneVars {\n%s};\n", ub_vs_bonesStr); - - if (enableBones) { - WRITE(p, "%s", boneWeightDecl[numBoneWeights]); - } + WRITE(p, "layout (std140, set = 1, binding = %d) uniform lightVars {\n%s};\n", DRAW_BINDING_DYNUBO_LIGHT, ub_vs_lightsStr); if (useHWTransform) WRITE(p, "layout (location = %d) in vec3 position;\n", (int)PspAttributeLocation::POSITION); @@ -304,7 +292,6 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag if (compat.shaderLanguage == HLSL_D3D11) { WRITE(p, "cbuffer base : register(b0) {\n%s};\n", ub_baseStr); WRITE(p, "cbuffer lights: register(b1) {\n%s};\n", ub_vs_lightsStr); - WRITE(p, "cbuffer bones : register(b2) {\n%s};\n", ub_vs_bonesStr); } else { WRITE(p, "#pragma warning( disable : 3571 )\n"); if (isModeThrough) { @@ -325,15 +312,6 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag WRITE(p, "mat3x4 u_view : register(c%i);\n", CONST_VS_VIEW); if (doTextureTransform) WRITE(p, "mat3x4 u_texmtx : register(c%i);\n", CONST_VS_TEXMTX); - if (enableBones) { -#ifdef USE_BONE_ARRAY - WRITE(p, "mat3x4 u_bone[%i] : register(c%i);\n", numBones, CONST_VS_BONE0); -#else - for (int i = 0; i < numBoneWeights; i++) { - WRITE(p, "mat3x4 u_bone%i : register(c%i);\n", i, CONST_VS_BONE0 + i * 3); - } -#endif - } if (doTexture) { WRITE(p, "vec4 u_uvscaleoffset : register(c%i);\n", CONST_VS_UVSCALEOFFSET); } @@ -385,9 +363,6 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag if ((doSpline || doBezier) && compat.shaderLanguage == HLSL_D3D11) { WRITE(p, " uint instanceId : SV_InstanceID;\n"); } - if (enableBones) { - WRITE(p, " %s", boneWeightAttrDeclHLSL[numBoneWeights]); - } if (doTexture && hasTexcoord) { WRITE(p, " vec2 texcoord : TEXCOORD0;\n"); } @@ -450,17 +425,6 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag } WRITE(p, "};\n"); } else { - if (enableBones) { - const char * const * boneWeightDecl = boneWeightAttrDecl; - if (!strcmp(compat.attribute, "in")) { - boneWeightDecl = boneWeightInDecl; - } - WRITE(p, "%s", boneWeightDecl[numBoneWeights]); - *attrMask |= 1 << ATTR_W1; - if (numBoneWeights >= 5) - *attrMask |= 1 << ATTR_W2; - } - if (useHWTransform) WRITE(p, "%s vec3 position;\n", compat.attribute); else @@ -523,12 +487,6 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag WRITE(p, "uniform mediump mat4 u_texmtx;\n"); *uniformMask |= DIRTY_TEXMATRIX; } - if (enableBones) { - for (int i = 0; i < numBoneWeights; i++) { - WRITE(p, "uniform mat4 u_bone%i;\n", i); - *uniformMask |= DIRTY_BONEMATRIX0 << i; - } - } if (doTexture) { WRITE(p, "uniform vec4 u_uvscaleoffset;\n"); *uniformMask |= DIRTY_UVSCALEOFFSET; @@ -636,7 +594,7 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag WRITE(p, " vec4 tex;\n"); WRITE(p, " vec4 col;\n"); WRITE(p, "};\n"); - WRITE(p, "layout (std430, set = 1, binding = 6) readonly buffer s_tess_data {\n"); + WRITE(p, "layout (std430, set = 1, binding = %d) readonly buffer s_tess_data {\n", DRAW_BINDING_TESS_STORAGE_BUF); WRITE(p, " TessData tess_data[];\n"); WRITE(p, "};\n"); @@ -644,10 +602,10 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag WRITE(p, " vec4 basis;\n"); WRITE(p, " vec4 deriv;\n"); WRITE(p, "};\n"); - WRITE(p, "layout (std430, set = 1, binding = 7) readonly buffer s_tess_weights_u {\n"); + WRITE(p, "layout (std430, set = 1, binding = %d) readonly buffer s_tess_weights_u {\n", DRAW_BINDING_TESS_STORAGE_BUF_WU); WRITE(p, " TessWeight tess_weights_u[];\n"); WRITE(p, "};\n"); - WRITE(p, "layout (std430, set = 1, binding = 8) readonly buffer s_tess_weights_v {\n"); + WRITE(p, "layout (std430, set = 1, binding = %d) readonly buffer s_tess_weights_v {\n", DRAW_BINDING_TESS_STORAGE_BUF_WV); WRITE(p, " TessWeight tess_weights_v[];\n"); WRITE(p, "};\n"); } else if (ShaderLanguageIsOpenGL(compat.shaderLanguage)) { @@ -823,9 +781,6 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag if (!useHWTransform) { WRITE(p, " float fog = In.fog;\n"); } - if (enableBones) { - WRITE(p, "%s", boneWeightAttrInitHLSL[numBoneWeights]); - } } if (!useHWTransform) { @@ -873,7 +828,7 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag } } else { // Step 1: World Transform / Skinning - if (!enableBones) { + if (true) { if (doBezier || doSpline) { // Hardware tessellation WRITE(p, " Tess tess;\n"); @@ -897,44 +852,6 @@ bool GenerateVertexShader(const VShaderID &id, char *buffer, const ShaderLanguag else WRITE(p, " mediump vec3 worldnormal = normalizeOr001(mul(vec4(0.0, 0.0, %s1.0, 0.0), u_world).xyz);\n", flipNormal ? "-" : ""); } - } else { - static const char *rescale[4] = {"", " * 1.9921875", " * 1.999969482421875", ""}; // 2*127.5f/128.f, 2*32767.5f/32768.f, 1.0f}; - const char *factor = rescale[boneWeightScale]; - - static const char * const boneWeightAttr[8] = { - "w1.x", "w1.y", "w1.z", "w1.w", - "w2.x", "w2.y", "w2.z", "w2.w", - }; - - const char *boneMatrix = compat.forceMatrix4x4 ? "mat4" : "mat3x4"; - - // Uncomment this to screw up bone shaders to check the vertex shader software fallback - // WRITE(p, "THIS SHOULD ERROR! #error"); - if (numBoneWeights == 1 && ShaderLanguageIsOpenGL(compat.shaderLanguage)) - WRITE(p, " %s skinMatrix = mul(w1, u_bone0)", boneMatrix); - else - WRITE(p, " %s skinMatrix = mul(w1.x, u_bone0)", boneMatrix); - for (int i = 1; i < numBoneWeights; i++) { - const char *weightAttr = boneWeightAttr[i]; - // workaround for "cant do .x of scalar" issue. - if (ShaderLanguageIsOpenGL(compat.shaderLanguage)) { - if (numBoneWeights == 1 && i == 0) weightAttr = "w1"; - if (numBoneWeights == 5 && i == 4) weightAttr = "w2"; - } - WRITE(p, " + mul(%s, u_bone%i)", weightAttr, i); - } - - WRITE(p, ";\n"); - - WRITE(p, " vec3 skinnedpos = mul(vec4(position, 1.0), skinMatrix).xyz%s;\n", factor); - WRITE(p, " vec3 worldpos = mul(vec4(skinnedpos, 1.0), u_world).xyz;\n"); - - if (hasNormal) { - WRITE(p, " mediump vec3 skinnednormal = mul(vec4(%snormal, 0.0), skinMatrix).xyz%s;\n", flipNormal ? "-" : "", factor); - } else { - WRITE(p, " mediump vec3 skinnednormal = mul(vec4(0.0, 0.0, %s1.0, 0.0), skinMatrix).xyz%s;\n", flipNormal ? "-" : "", factor); - } - WRITE(p, " mediump vec3 worldnormal = normalizeOr001(mul(vec4(skinnednormal, 0.0), u_world).xyz);\n"); } std::string matrixPostfix; diff --git a/GPU/Common/VertexShaderGenerator.h b/GPU/Common/VertexShaderGenerator.h index 9d3707411c..5e45452b46 100644 --- a/GPU/Common/VertexShaderGenerator.h +++ b/GPU/Common/VertexShaderGenerator.h @@ -55,16 +55,7 @@ enum { CONST_VS_LIGHTSPECULAR = 44, CONST_VS_LIGHTAMBIENT = 48, CONST_VS_DEPTHRANGE = 52, - CONST_VS_BONE0 = 53, - CONST_VS_BONE1 = 56, - CONST_VS_BONE2 = 59, - CONST_VS_BONE3 = 62, - CONST_VS_BONE4 = 65, - CONST_VS_BONE5 = 68, - CONST_VS_BONE6 = 71, - CONST_VS_BONE7 = 74, - CONST_VS_BONE8 = 77, - CONST_VS_CULLRANGEMIN = 80, - CONST_VS_CULLRANGEMAX = 81, - CONST_VS_ROTATION = 82, + CONST_VS_CULLRANGEMIN = 53, + CONST_VS_CULLRANGEMAX = 54, + CONST_VS_ROTATION = 55, }; diff --git a/GPU/D3D11/ShaderManagerD3D11.cpp b/GPU/D3D11/ShaderManagerD3D11.cpp index f8788f6df5..01753a6d49 100644 --- a/GPU/D3D11/ShaderManagerD3D11.cpp +++ b/GPU/D3D11/ShaderManagerD3D11.cpp @@ -95,24 +95,19 @@ ShaderManagerD3D11::ShaderManagerD3D11(Draw::DrawContext *draw, ID3D11Device *de codeBuffer_ = new char[CODE_BUFFER_SIZE]; memset(&ub_base, 0, sizeof(ub_base)); memset(&ub_lights, 0, sizeof(ub_lights)); - memset(&ub_bones, 0, sizeof(ub_bones)); static_assert(sizeof(ub_base) <= 512, "ub_base grew too big"); static_assert(sizeof(ub_lights) <= 512, "ub_lights grew too big"); - static_assert(sizeof(ub_bones) <= 384, "ub_bones grew too big"); D3D11_BUFFER_DESC desc{sizeof(ub_base), D3D11_USAGE_DYNAMIC, D3D11_BIND_CONSTANT_BUFFER, D3D11_CPU_ACCESS_WRITE }; ASSERT_SUCCESS(device_->CreateBuffer(&desc, nullptr, &push_base)); desc.ByteWidth = sizeof(ub_lights); ASSERT_SUCCESS(device_->CreateBuffer(&desc, nullptr, &push_lights)); - desc.ByteWidth = sizeof(ub_bones); - ASSERT_SUCCESS(device_->CreateBuffer(&desc, nullptr, &push_bones)); } ShaderManagerD3D11::~ShaderManagerD3D11() { push_base->Release(); push_lights->Release(); - push_bones->Release(); ClearShaders(); delete[] codeBuffer_; } @@ -161,19 +156,13 @@ uint64_t ShaderManagerD3D11::UpdateUniforms(bool useBufferedRendering) { memcpy(map.pData, &ub_lights, sizeof(ub_lights)); context_->Unmap(push_lights, 0); } - if (dirty & DIRTY_BONE_UNIFORMS) { - BoneUpdateUniforms(&ub_bones, dirty); - context_->Map(push_bones, 0, D3D11_MAP_WRITE_DISCARD, 0, &map); - memcpy(map.pData, &ub_bones, sizeof(ub_bones)); - context_->Unmap(push_bones, 0); - } } gstate_c.CleanUniforms(); return dirty; } void ShaderManagerD3D11::BindUniforms() { - ID3D11Buffer *vs_cbs[3] = { push_base, push_lights, push_bones }; + ID3D11Buffer *vs_cbs[3] = { push_base, push_lights }; ID3D11Buffer *ps_cbs[1] = { push_base }; context_->VSSetConstantBuffers(0, 3, vs_cbs); context_->PSSetConstantBuffers(0, 1, ps_cbs); diff --git a/GPU/D3D11/ShaderManagerD3D11.h b/GPU/D3D11/ShaderManagerD3D11.h index 37997b80a1..b7c70d48e4 100644 --- a/GPU/D3D11/ShaderManagerD3D11.h +++ b/GPU/D3D11/ShaderManagerD3D11.h @@ -121,12 +121,10 @@ private: // Uniform block scratchpad. These (the relevant ones) are copied to the current pushbuffer at draw time. UB_VS_FS_Base ub_base; UB_VS_Lights ub_lights; - UB_VS_Bones ub_bones; // Not actual pushbuffers, requires D3D11.1, let's try to live without that first. ID3D11Buffer *push_base; ID3D11Buffer *push_lights; - ID3D11Buffer *push_bones; D3D11FragmentShader *lastFShader_ = nullptr; D3D11VertexShader *lastVShader_ = nullptr; diff --git a/GPU/Directx9/ShaderManagerDX9.cpp b/GPU/Directx9/ShaderManagerDX9.cpp index 0b419cfe76..cc07db3d2f 100644 --- a/GPU/Directx9/ShaderManagerDX9.cpp +++ b/GPU/Directx9/ShaderManagerDX9.cpp @@ -324,7 +324,7 @@ void ShaderManagerDX9::PSUpdateUniforms(u64 dirtyUniforms) { } const uint64_t vsUniforms = DIRTY_PROJMATRIX | DIRTY_PROJTHROUGHMATRIX | DIRTY_WORLDMATRIX | DIRTY_VIEWMATRIX | DIRTY_TEXMATRIX | -DIRTY_FOGCOEF | DIRTY_BONE_UNIFORMS | DIRTY_UVSCALEOFFSET | DIRTY_DEPTHRANGE | DIRTY_CULLRANGE | +DIRTY_FOGCOEF | DIRTY_UVSCALEOFFSET | DIRTY_DEPTHRANGE | DIRTY_CULLRANGE | DIRTY_AMBIENT | DIRTY_MATAMBIENTALPHA | DIRTY_MATSPECULAR | DIRTY_MATDIFFUSE | DIRTY_MATEMISSIVE | DIRTY_LIGHT0 | DIRTY_LIGHT1 | DIRTY_LIGHT2 | DIRTY_LIGHT3; void ShaderManagerDX9::VSUpdateUniforms(u64 dirtyUniforms) { @@ -387,38 +387,6 @@ void ShaderManagerDX9::VSUpdateUniforms(u64 dirtyUniforms) { } VSSetFloatArray(CONST_VS_FOGCOEF, fogcoef, 2); } - // TODO: Could even set all bones in one go if they're all dirty. -#ifdef USE_BONE_ARRAY - if (u_bone != 0) { - float allBones[8 * 16]; - - bool allDirty = true; - for (int i = 0; i < numBones; i++) { - if (dirtyUniforms & (DIRTY_BONEMATRIX0 << i)) { - ConvertMatrix4x3To4x4(allBones + 16 * i, gstate.boneMatrix + 12 * i); - } else { - allDirty = false; - } - } - if (allDirty) { - // Set them all with one call - //glUniformMatrix4fv(u_bone, numBones, GL_FALSE, allBones); - } else { - // Set them one by one. Could try to coalesce two in a row etc but too lazy. - for (int i = 0; i < numBones; i++) { - if (dirtyUniforms & (DIRTY_BONEMATRIX0 << i)) { - //glUniformMatrix4fv(u_bone + i, 1, GL_FALSE, allBones + 16 * i); - } - } - } - } -#else - for (int i = 0; i < 8; i++) { - if (dirtyUniforms & (DIRTY_BONEMATRIX0 << i)) { - VSSetMatrix4x3_3(CONST_VS_BONE0 + 3 * i, gstate.boneMatrix + 12 * i); - } - } -#endif // Texturing if (dirtyUniforms & DIRTY_UVSCALEOFFSET) { diff --git a/GPU/GLES/ShaderManagerGLES.cpp b/GPU/GLES/ShaderManagerGLES.cpp index aa17822d8c..00bf4539e7 100644 --- a/GPU/GLES/ShaderManagerGLES.cpp +++ b/GPU/GLES/ShaderManagerGLES.cpp @@ -121,10 +121,6 @@ LinkedShader::LinkedShader(GLRenderManager *render, VShaderID VSID, Shader *vs, queries.push_back({ &u_world, "u_world" }); queries.push_back({ &u_texmtx, "u_texmtx" }); - if (VSID.Bit(VS_BIT_ENABLE_BONES)) - numBones = TranslateNumBones(VSID.Bits(VS_BIT_BONES, 3) + 1); - else - numBones = 0; queries.push_back({ &u_depthRange, "u_depthRange" }); queries.push_back({ &u_cullRangeMin, "u_cullRangeMin" }); queries.push_back({ &u_cullRangeMax, "u_cullRangeMax" }); @@ -134,15 +130,6 @@ LinkedShader::LinkedShader(GLRenderManager *render, VShaderID VSID, Shader *vs, queries.push_back({ &u_scaleX, "u_scaleX" }); queries.push_back({ &u_scaleY, "u_scaleY" }); -#ifdef USE_BONE_ARRAY - queries.push_back({ &u_bone, "u_bone" }); -#else - static const char * const boneNames[8] = { "u_bone0", "u_bone1", "u_bone2", "u_bone3", "u_bone4", "u_bone5", "u_bone6", "u_bone7", }; - for (int i = 0; i < 8; i++) { - queries.push_back({ &u_bone[i], boneNames[i] }); - } -#endif - // Lighting, texturing queries.push_back({ &u_ambient, "u_ambient" }); queries.push_back({ &u_matambientalpha, "u_matambientalpha" }); @@ -584,13 +571,6 @@ void LinkedShader::UpdateUniforms(u32 vertType, const ShaderID &vsid, bool useBu float f = (float)gstate.getStencilTestRef() * (1.0f / 255.0f); render_->SetUniformF(&u_stencilReplaceValue, 1, &f); } - float bonetemp[16]; - for (int i = 0; i < numBones; i++) { - if (dirty & (DIRTY_BONEMATRIX0 << i)) { - ConvertMatrix4x3To4x4Transposed(bonetemp, gstate.boneMatrix + 12 * i); - render_->SetUniformM4x4(&u_bone[i], bonetemp); - } - } if (dirty & DIRTY_SHADERBLEND) { if (u_blendFixA != -1) { diff --git a/GPU/GLES/ShaderManagerGLES.h b/GPU/GLES/ShaderManagerGLES.h index 97ffe6c010..946026661e 100644 --- a/GPU/GLES/ShaderManagerGLES.h +++ b/GPU/GLES/ShaderManagerGLES.h @@ -67,13 +67,6 @@ public: int u_scaleX; int u_scaleY; -#ifdef USE_BONE_ARRAY - int u_bone; // array, size is numBones -#else - int u_bone[8]; -#endif - int numBones; - // Shader blending. int u_fbotex; int u_blendFixA; diff --git a/GPU/GPUCommon.cpp b/GPU/GPUCommon.cpp index 930c3becab..21d90fa8af 100644 --- a/GPU/GPUCommon.cpp +++ b/GPU/GPUCommon.cpp @@ -777,7 +777,7 @@ void GPUCommon::ResetMatrices() { matrixVisible.tgen[i] = toFloat24(gstate.tgenMatrix[i]); // Assume all the matrices changed, so dirty things related to them. - gstate_c.Dirty(DIRTY_WORLDMATRIX | DIRTY_VIEWMATRIX | DIRTY_PROJMATRIX | DIRTY_TEXMATRIX | DIRTY_FRAGMENTSHADER_STATE | DIRTY_BONE_UNIFORMS); + gstate_c.Dirty(DIRTY_WORLDMATRIX | DIRTY_VIEWMATRIX | DIRTY_PROJMATRIX | DIRTY_TEXMATRIX | DIRTY_FRAGMENTSHADER_STATE); } u32 GPUCommon::EnqueueList(u32 listpc, u32 stall, int subIntrBase, PSPPointer args, bool head) { diff --git a/GPU/Vulkan/DrawEngineVulkan.cpp b/GPU/Vulkan/DrawEngineVulkan.cpp index 198930b75d..da347d7a82 100644 --- a/GPU/Vulkan/DrawEngineVulkan.cpp +++ b/GPU/Vulkan/DrawEngineVulkan.cpp @@ -62,19 +62,6 @@ enum { enum { VAI_KILL_AGE = 120, VAI_UNRELIABLE_KILL_AGE = 240, VAI_UNRELIABLE_KILL_MAX = 4 }; -enum { - DRAW_BINDING_TEXTURE = 0, - DRAW_BINDING_2ND_TEXTURE = 1, - DRAW_BINDING_DEPAL_TEXTURE = 2, - DRAW_BINDING_DYNUBO_BASE = 3, - DRAW_BINDING_DYNUBO_LIGHT = 4, - DRAW_BINDING_DYNUBO_BONE = 5, - DRAW_BINDING_TESS_STORAGE_BUF = 6, - DRAW_BINDING_TESS_STORAGE_BUF_WU = 7, - DRAW_BINDING_TESS_STORAGE_BUF_WV = 8, - DRAW_BINDING_INPUT_ATTACHMENT = 9, -}; - enum { TRANSFORMED_VERTEX_BUFFER_SIZE = VERTEX_BUFFER_MAX * sizeof(TransformedVertex) }; @@ -97,7 +84,7 @@ void DrawEngineVulkan::InitDeviceObjects() { // TODO: Make things more flexible, so we at least have specialized layouts for input attachments and tess. // Note that it becomes a support matrix.. - VkDescriptorSetLayoutBinding bindings[10]{}; + VkDescriptorSetLayoutBinding bindings[DRAW_BINDING_COUNT]{}; bindings[0].descriptorCount = 1; bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; bindings[0].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; @@ -120,27 +107,23 @@ void DrawEngineVulkan::InitDeviceObjects() { bindings[4].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC; bindings[4].stageFlags = VK_SHADER_STAGE_VERTEX_BIT; bindings[4].binding = DRAW_BINDING_DYNUBO_LIGHT; - bindings[5].descriptorCount = 1; - bindings[5].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC; - bindings[5].stageFlags = VK_SHADER_STAGE_VERTEX_BIT; - bindings[5].binding = DRAW_BINDING_DYNUBO_BONE; // Used only for hardware tessellation. + bindings[5].descriptorCount = 1; + bindings[5].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + bindings[5].stageFlags = VK_SHADER_STAGE_VERTEX_BIT; + bindings[5].binding = DRAW_BINDING_TESS_STORAGE_BUF; bindings[6].descriptorCount = 1; bindings[6].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; bindings[6].stageFlags = VK_SHADER_STAGE_VERTEX_BIT; - bindings[6].binding = DRAW_BINDING_TESS_STORAGE_BUF; + bindings[6].binding = DRAW_BINDING_TESS_STORAGE_BUF_WU; bindings[7].descriptorCount = 1; bindings[7].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; bindings[7].stageFlags = VK_SHADER_STAGE_VERTEX_BIT; - bindings[7].binding = DRAW_BINDING_TESS_STORAGE_BUF_WU; + bindings[7].binding = DRAW_BINDING_TESS_STORAGE_BUF_WV; bindings[8].descriptorCount = 1; - bindings[8].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - bindings[8].stageFlags = VK_SHADER_STAGE_VERTEX_BIT; - bindings[8].binding = DRAW_BINDING_TESS_STORAGE_BUF_WV; - bindings[9].descriptorCount = 1; - bindings[9].descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; - bindings[9].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; - bindings[9].binding = DRAW_BINDING_INPUT_ATTACHMENT; + bindings[8].descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; + bindings[8].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT; + bindings[8].binding = DRAW_BINDING_INPUT_ATTACHMENT; VulkanContext *vulkan = (VulkanContext *)draw_->GetNativeObject(Draw::NativeObject::CONTEXT); VkDevice device = vulkan->GetDevice(); @@ -155,7 +138,7 @@ void DrawEngineVulkan::InitDeviceObjects() { static constexpr int DEFAULT_DESC_POOL_SIZE = 512; std::vector dpTypes; dpTypes.resize(5); - dpTypes[0].descriptorCount = DEFAULT_DESC_POOL_SIZE * 3; + dpTypes[0].descriptorCount = DEFAULT_DESC_POOL_SIZE * 2; dpTypes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC; dpTypes[1].descriptorCount = DEFAULT_DESC_POOL_SIZE * 3; // Don't use these for tess anymore, need max three per set. dpTypes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; @@ -384,10 +367,9 @@ void DrawEngineVulkan::DecodeVertsToPushBuffer(VulkanPushBuffer *push, uint32_t DecodeVerts(dest); } -VkDescriptorSet DrawEngineVulkan::GetOrCreateDescriptorSet(VkImageView imageView, VkSampler sampler, VkBuffer base, VkBuffer light, VkBuffer bone, bool tess) { +VkDescriptorSet DrawEngineVulkan::GetOrCreateDescriptorSet(VkImageView imageView, VkSampler sampler, VkBuffer base, VkBuffer light, bool tess) { _dbg_assert_(base != VK_NULL_HANDLE); _dbg_assert_(light != VK_NULL_HANDLE); - _dbg_assert_(bone != VK_NULL_HANDLE); DescriptorSetKey key{}; key.imageView_ = imageView; @@ -396,7 +378,6 @@ VkDescriptorSet DrawEngineVulkan::GetOrCreateDescriptorSet(VkImageView imageView key.depalImageView_ = boundDepal_; key.base_ = base; key.light_ = light; - key.bone_ = bone; key.secondaryIsInputAttachment = boundSecondaryIsInputAttachment_; FrameData &frame = GetCurFrame(); @@ -506,10 +487,6 @@ VkDescriptorSet DrawEngineVulkan::GetOrCreateDescriptorSet(VkImageView imageView buf[count].offset = 0; buf[count].range = sizeof(UB_VS_Lights); count++; - buf[count].buffer = bone; - buf[count].offset = 0; - buf[count].range = sizeof(UB_VS_Bones); - count++; for (int i = 0; i < count; i++) { writes[n].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; writes[n].pNext = nullptr; @@ -533,11 +510,9 @@ VkDescriptorSet DrawEngineVulkan::GetOrCreateDescriptorSet(VkImageView imageView void DrawEngineVulkan::DirtyAllUBOs() { baseUBOOffset = 0; lightUBOOffset = 0; - boneUBOOffset = 0; baseBuf = VK_NULL_HANDLE; lightBuf = VK_NULL_HANDLE; - boneBuf = VK_NULL_HANDLE; - dirtyUniforms_ = DIRTY_BASE_UNIFORMS | DIRTY_LIGHT_UNIFORMS | DIRTY_BONE_UNIFORMS; + dirtyUniforms_ = DIRTY_BASE_UNIFORMS | DIRTY_LIGHT_UNIFORMS; imageView = VK_NULL_HANDLE; sampler = VK_NULL_HANDLE; gstate_c.Dirty(DIRTY_TEXTURE_IMAGE); @@ -826,10 +801,10 @@ void DrawEngineVulkan::DoFlush() { dirtyUniforms_ |= shaderManager_->UpdateUniforms(framebufferManager_->UseBufferedRendering()); UpdateUBOs(&frameData); - VkDescriptorSet ds = GetOrCreateDescriptorSet(imageView, sampler, baseBuf, lightBuf, boneBuf, tess); + VkDescriptorSet ds = GetOrCreateDescriptorSet(imageView, sampler, baseBuf, lightBuf, tess); - const uint32_t dynamicUBOOffsets[3] = { - baseUBOOffset, lightUBOOffset, boneUBOOffset, + const uint32_t dynamicUBOOffsets[] = { + baseUBOOffset, lightUBOOffset, }; if (useElements) { if (!ibuf) { @@ -962,9 +937,9 @@ void DrawEngineVulkan::DoFlush() { // Even if the first draw is through-mode, make sure we at least have one copy of these uniforms buffered UpdateUBOs(&frameData); - VkDescriptorSet ds = GetOrCreateDescriptorSet(imageView, sampler, baseBuf, lightBuf, boneBuf, tess); - const uint32_t dynamicUBOOffsets[3] = { - baseUBOOffset, lightUBOOffset, boneUBOOffset, + VkDescriptorSet ds = GetOrCreateDescriptorSet(imageView, sampler, baseBuf, lightBuf, tess); + const uint32_t dynamicUBOOffsets[] = { + baseUBOOffset, lightUBOOffset, }; PROFILE_THIS_SCOPE("renderman_q"); @@ -1053,10 +1028,6 @@ void DrawEngineVulkan::UpdateUBOs(FrameData *frame) { lightUBOOffset = shaderManager_->PushLightBuffer(frame->pushUBO, &lightBuf); dirtyUniforms_ &= ~DIRTY_LIGHT_UNIFORMS; } - if ((dirtyUniforms_ & DIRTY_BONE_UNIFORMS) || boneBuf == VK_NULL_HANDLE) { - boneUBOOffset = shaderManager_->PushBoneBuffer(frame->pushUBO, &boneBuf); - dirtyUniforms_ &= ~DIRTY_BONE_UNIFORMS; - } } DrawEngineVulkan::FrameData &DrawEngineVulkan::GetCurFrame() { diff --git a/GPU/Vulkan/DrawEngineVulkan.h b/GPU/Vulkan/DrawEngineVulkan.h index 035bc595df..c4a5b7bb0d 100644 --- a/GPU/Vulkan/DrawEngineVulkan.h +++ b/GPU/Vulkan/DrawEngineVulkan.h @@ -121,6 +121,19 @@ private: VkDescriptorBufferInfo bufInfo_[3]{}; }; +enum { + DRAW_BINDING_TEXTURE = 0, + DRAW_BINDING_2ND_TEXTURE = 1, + DRAW_BINDING_DEPAL_TEXTURE = 2, + DRAW_BINDING_DYNUBO_BASE = 3, + DRAW_BINDING_DYNUBO_LIGHT = 4, + DRAW_BINDING_TESS_STORAGE_BUF = 5, + DRAW_BINDING_TESS_STORAGE_BUF_WU = 6, + DRAW_BINDING_TESS_STORAGE_BUF_WV = 7, + DRAW_BINDING_INPUT_ATTACHMENT = 8, + DRAW_BINDING_COUNT = 9, +}; + // Handles transform, lighting and drawing. class DrawEngineVulkan : public DrawEngineCommon { public: @@ -207,7 +220,7 @@ private: void UpdateUBOs(FrameData *frame); FrameData &GetCurFrame(); - VkDescriptorSet GetOrCreateDescriptorSet(VkImageView imageView, VkSampler sampler, VkBuffer base, VkBuffer light, VkBuffer bone, bool tess); + VkDescriptorSet GetOrCreateDescriptorSet(VkImageView imageView, VkSampler sampler, VkBuffer base, VkBuffer light, bool tess); Draw::DrawContext *draw_; @@ -238,8 +251,7 @@ private: VkImageView secondaryImageView_; VkImageView depalImageView_; VkSampler sampler_; - VkBuffer base_, light_, bone_; // All three UBO slots will be set to this. This will usually be identical - // for all draws in a frame, except when the buffer has to grow. + VkBuffer base_, light_; bool secondaryIsInputAttachment; }; @@ -276,8 +288,7 @@ private: uint64_t dirtyUniforms_; uint32_t baseUBOOffset; uint32_t lightUBOOffset; - uint32_t boneUBOOffset; - VkBuffer baseBuf, lightBuf, boneBuf; + VkBuffer baseBuf, lightBuf; VkImageView imageView = VK_NULL_HANDLE; VkSampler sampler = VK_NULL_HANDLE; diff --git a/GPU/Vulkan/ShaderManagerVulkan.cpp b/GPU/Vulkan/ShaderManagerVulkan.cpp index 1d478325da..778ff1e665 100644 --- a/GPU/Vulkan/ShaderManagerVulkan.cpp +++ b/GPU/Vulkan/ShaderManagerVulkan.cpp @@ -204,11 +204,9 @@ ShaderManagerVulkan::ShaderManagerVulkan(Draw::DrawContext *draw) uboAlignment_ = vulkan->GetPhysicalDeviceProperties().properties.limits.minUniformBufferOffsetAlignment; memset(&ub_base, 0, sizeof(ub_base)); memset(&ub_lights, 0, sizeof(ub_lights)); - memset(&ub_bones, 0, sizeof(ub_bones)); static_assert(sizeof(ub_base) <= 512, "ub_base grew too big"); static_assert(sizeof(ub_lights) <= 512, "ub_lights grew too big"); - static_assert(sizeof(ub_bones) <= 384, "ub_bones grew too big"); } ShaderManagerVulkan::~ShaderManagerVulkan() { @@ -273,8 +271,6 @@ uint64_t ShaderManagerVulkan::UpdateUniforms(bool useBufferedRendering) { BaseUpdateUniforms(&ub_base, dirty, false, useBufferedRendering); if (dirty & DIRTY_LIGHT_UNIFORMS) LightUpdateUniforms(&ub_lights, dirty); - if (dirty & DIRTY_BONE_UNIFORMS) - BoneUpdateUniforms(&ub_bones, dirty); } gstate_c.CleanUniforms(); return dirty; diff --git a/GPU/Vulkan/ShaderManagerVulkan.h b/GPU/Vulkan/ShaderManagerVulkan.h index 8e6ce2636a..c930f6f522 100644 --- a/GPU/Vulkan/ShaderManagerVulkan.h +++ b/GPU/Vulkan/ShaderManagerVulkan.h @@ -149,10 +149,6 @@ public: uint32_t PushLightBuffer(VulkanPushBuffer *dest, VkBuffer *buf) { return dest->PushAligned(&ub_lights, sizeof(ub_lights), uboAlignment_, buf); } - // TODO: Only push half the bone buffer if we only have four bones. - uint32_t PushBoneBuffer(VulkanPushBuffer *dest, VkBuffer *buf) { - return dest->PushAligned(&ub_bones, sizeof(ub_bones), uboAlignment_, buf); - } bool LoadCache(FILE *f); void SaveCache(FILE *f); @@ -177,7 +173,6 @@ private: // Uniform block scratchpad. These (the relevant ones) are copied to the current pushbuffer at draw time. UB_VS_FS_Base ub_base; UB_VS_Lights ub_lights; - UB_VS_Bones ub_bones; VulkanFragmentShader *lastFShader_ = nullptr; VulkanVertexShader *lastVShader_ = nullptr; diff --git a/unittest/TestShaderGenerators.cpp b/unittest/TestShaderGenerators.cpp index 6701e162fd..c583431243 100644 --- a/unittest/TestShaderGenerators.cpp +++ b/unittest/TestShaderGenerators.cpp @@ -407,15 +407,10 @@ bool TestVertexShaders() { // The generated bits need some adjustment: - // We don't use these bits in the HLSL shader generator. - id.SetBits(VS_BIT_WEIGHT_FMTSCALE, 2, 0); // If mode is through, we won't do hardware transform. if (id.Bit(VS_BIT_IS_THROUGH)) { id.SetBit(VS_BIT_USE_HW_TRANSFORM, 0); } - if (!id.Bit(VS_BIT_USE_HW_TRANSFORM)) { - id.SetBit(VS_BIT_ENABLE_BONES, 0); - } if (id.Bit(VS_BIT_VERTEX_RANGE_CULLING)) { continue; }